/*

 * Copyright (C) 2008, 2009, 2010 Apple Inc. All rights reserved.

 * Copyright (C) 2008 Cameron Zwarich <cwzwarich@uwaterloo.ca>

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * 1.  Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 * 2.  Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in the

 *     documentation and/or other materials provided with the distribution.

 * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

 *     its contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#include "CodeBlock.h"

#include "JIT.h"

#include "JSValue.h"

#include "Interpreter.h"

#include "JSFunction.h"

#include "JSStaticScopeObject.h"

#include "Debugger.h"

#include "BytecodeGenerator.h"

#include <stdio.h>

#include <wtf/StringExtras.h>

#define DUMP_CODE_BLOCK_STATISTICS 0

namespace JSC {

#if !defined(NDEBUG) || ENABLE(OPCODE_SAMPLING)

static UString escapeQuotes(const UString& str)

{

    UString result = str;

    unsigned pos = 0;

    while ((pos = result.find('\"', pos)) != UString::NotFound) {

        result = makeString(result.substr(0, pos), "\"\\\"\"", result.substr(pos + 1));

        pos += 4;

    }

    return result;

}

static UString valueToSourceString(ExecState* exec, JSValue val)

{

    if (!val)

        return "0";

    if (val.isString())

        return makeString("\"", escapeQuotes(val.toString(exec)), "\"");

    return val.toString(exec);

}

static CString constantName(ExecState* exec, int k, JSValue value)

{

    return makeString(valueToSourceString(exec, value), "(@k", UString::from(k - FirstConstantRegisterIndex), ")").UTF8String();

}

static CString idName(int id0, const Identifier& ident)

{

    return makeString(ident.ustring(), "(@id", UString::from(id0), ")").UTF8String();

}

CString CodeBlock::registerName(ExecState* exec, int r) const

{

    if (r == missingThisObjectMarker())

        return "<null>";

    if (isConstantRegisterIndex(r))

        return constantName(exec, r, getConstant(r));

    return makeString("r", UString::from(r)).UTF8String();

}

static UString regexpToSourceString(RegExp* regExp)

{

    char postfix[5] = { '/', 0, 0, 0, 0 };

    int index = 1;

    if (regExp->global())

        postfix[index++] = 'g';

    if (regExp->ignoreCase())

        postfix[index++] = 'i';

    if (regExp->multiline())

        postfix[index] = 'm';

    return makeString("/", regExp->pattern(), postfix);

}

static CString regexpName(int re, RegExp* regexp)

{

    return makeString(regexpToSourceString(regexp), "(@re", UString::from(re), ")").UTF8String();

}

static UString pointerToSourceString(void* p)

{

    char buffer[2 + 2 * sizeof(void*) + 1]; // 0x [two characters per byte] \0

    snprintf(buffer, sizeof(buffer), "%p", p);

    return buffer;

}

NEVER_INLINE static const char* debugHookName(int debugHookID)

{

    switch (static_cast<DebugHookID>(debugHookID)) {

        case DidEnterCallFrame:

            return "didEnterCallFrame";

        case WillLeaveCallFrame:

            return "willLeaveCallFrame";

        case WillExecuteStatement:

            return "willExecuteStatement";

        case WillExecuteProgram:

            return "willExecuteProgram";

        case DidExecuteProgram:

            return "didExecuteProgram";

        case DidReachBreakpoint:

            return "didReachBreakpoint";

    }

    ASSERT_NOT_REACHED();

    return "";

}

void CodeBlock::printUnaryOp(ExecState* exec, int location, Vector<Instruction>::const_iterator& it, const char* op) const

{

    int r0 = (++it)->u.operand;

    int r1 = (++it)->u.operand;

    printf("[%4d] %s\t\t %s, %s\n", location, op, registerName(exec, r0).data(), registerName(exec, r1).data());

}

void CodeBlock::printBinaryOp(ExecState* exec, int location, Vector<Instruction>::const_iterator& it, const char* op) const

{

    int r0 = (++it)->u.operand;

    int r1 = (++it)->u.operand;

    int r2 = (++it)->u.operand;

    printf("[%4d] %s\t\t %s, %s, %s\n", location, op, registerName(exec, r0).data(), registerName(exec, r1).data(), registerName(exec, r2).data());

}

void CodeBlock::printConditionalJump(ExecState* exec, const Vector<Instruction>::const_iterator&, Vector<Instruction>::const_iterator& it, int location, const char* op) const

{

    int r0 = (++it)->u.operand;

    int offset = (++it)->u.operand;

    printf("[%4d] %s\t\t %s, %d(->%d)\n", location, op, registerName(exec, r0).data(), offset, location + offset);

}

void CodeBlock::printGetByIdOp(ExecState* exec, int location, Vector<Instruction>::const_iterator& it, const char* op) const

{

    int r0 = (++it)->u.operand;

    int r1 = (++it)->u.operand;

    int id0 = (++it)->u.operand;

    printf("[%4d] %s\t %s, %s, %s\n", location, op, registerName(exec, r0).data(), registerName(exec, r1).data(), idName(id0, m_identifiers[id0]).data());

    it += 4;

}

void CodeBlock::printPutByIdOp(ExecState* exec, int location, Vector<Instruction>::const_iterator& it, const char* op) const

{

    int r0 = (++it)->u.operand;

    int id0 = (++it)->u.operand;

    int r1 = (++it)->u.operand;

    printf("[%4d] %s\t %s, %s, %s\n", location, op, registerName(exec, r0).data(), idName(id0, m_identifiers[id0]).data(), registerName(exec, r1).data());

    it += 5;

}

#if ENABLE(JIT)

static bool isGlobalResolve(OpcodeID opcodeID)

{

    return opcodeID == op_resolve_global || opcodeID == op_resolve_global_dynamic;

}

static bool isPropertyAccess(OpcodeID opcodeID)

{

    switch (opcodeID) {

        case op_get_by_id_self:

        case op_get_by_id_proto:

        case op_get_by_id_chain:

        case op_get_by_id_self_list:

        case op_get_by_id_proto_list:

        case op_put_by_id_transition:

        case op_put_by_id_replace:

        case op_get_by_id:

        case op_put_by_id:

        case op_get_by_id_generic:

        case op_put_by_id_generic:

        case op_get_array_length:

        case op_get_string_length:

            return true;

        default:

            return false;

    }

}

static unsigned instructionOffsetForNth(ExecState* exec, const Vector<Instruction>& instructions, int nth, bool (*predicate)(OpcodeID))

{

    size_t i = 0;

    while (i < instructions.size()) {

        OpcodeID currentOpcode = exec->interpreter()->getOpcodeID(instructions[i].u.opcode);

        if (predicate(currentOpcode)) {

            if (!--nth)

                return i;

        }

        i += opcodeLengths[currentOpcode];

    }

    ASSERT_NOT_REACHED();

    return 0;

}

static void printGlobalResolveInfo(const GlobalResolveInfo& resolveInfo, unsigned instructionOffset)

{

    printf("  [%4d] %s: %s\n", instructionOffset, "resolve_global", pointerToSourceString(resolveInfo.structure).UTF8String().data());

}

static void printStructureStubInfo(const StructureStubInfo& stubInfo, unsigned instructionOffset)

{

    switch (stubInfo.accessType) {

    case access_get_by_id_self:

        printf("  [%4d] %s: %s\n", instructionOffset, "get_by_id_self", pointerToSourceString(stubInfo.u.getByIdSelf.baseObjectStructure).UTF8String().data());

        return;

    case access_get_by_id_proto:

        printf("  [%4d] %s: %s, %s\n", instructionOffset, "get_by_id_proto", pointerToSourceString(stubInfo.u.getByIdProto.baseObjectStructure).UTF8String().data(), pointerToSourceString(stubInfo.u.getByIdProto.prototypeStructure).UTF8String().data());

        return;

    case access_get_by_id_chain:

        printf("  [%4d] %s: %s, %s\n", instructionOffset, "get_by_id_chain", pointerToSourceString(stubInfo.u.getByIdChain.baseObjectStructure).UTF8String().data(), pointerToSourceString(stubInfo.u.getByIdChain.chain).UTF8String().data());

        return;

    case access_get_by_id_self_list:

        printf("  [%4d] %s: %s (%d)\n", instructionOffset, "op_get_by_id_self_list", pointerToSourceString(stubInfo.u.getByIdSelfList.structureList).UTF8String().data(), stubInfo.u.getByIdSelfList.listSize);

        return;

    case access_get_by_id_proto_list:

        printf("  [%4d] %s: %s (%d)\n", instructionOffset, "op_get_by_id_proto_list", pointerToSourceString(stubInfo.u.getByIdProtoList.structureList).UTF8String().data(), stubInfo.u.getByIdProtoList.listSize);

        return;

    case access_put_by_id_transition:

        printf("  [%4d] %s: %s, %s, %s\n", instructionOffset, "put_by_id_transition", pointerToSourceString(stubInfo.u.putByIdTransition.previousStructure).UTF8String().data(), pointerToSourceString(stubInfo.u.putByIdTransition.structure).UTF8String().data(), pointerToSourceString(stubInfo.u.putByIdTransition.chain).UTF8String().data());

        return;

    case access_put_by_id_replace:

        printf("  [%4d] %s: %s\n", instructionOffset, "put_by_id_replace", pointerToSourceString(stubInfo.u.putByIdReplace.baseObjectStructure).UTF8String().data());

        return;

    case access_get_by_id:

        printf("  [%4d] %s\n", instructionOffset, "get_by_id");

        return;

    case access_put_by_id:

        printf("  [%4d] %s\n", instructionOffset, "put_by_id");

        return;

    case access_get_by_id_generic:

        printf("  [%4d] %s\n", instructionOffset, "op_get_by_id_generic");

        return;

    case access_put_by_id_generic:

        printf("  [%4d] %s\n", instructionOffset, "op_put_by_id_generic");

        return;

    case access_get_array_length:

        printf("  [%4d] %s\n", instructionOffset, "op_get_array_length");

        return;

    case access_get_string_length:

        printf("  [%4d] %s\n", instructionOffset, "op_get_string_length");

        return;

    default:

        ASSERT_NOT_REACHED();

    }

}

#endif

void CodeBlock::printStructure(const char* name, const Instruction* vPC, int operand) const

{

    unsigned instructionOffset = vPC - m_instructions.begin();

    printf("  [%4d] %s: %s\n", instructionOffset, name, pointerToSourceString(vPC[operand].u.structure).UTF8String().data());

}

void CodeBlock::printStructures(const Instruction* vPC) const

{

    Interpreter* interpreter = m_globalData->interpreter;

    unsigned instructionOffset = vPC - m_instructions.begin();

    if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id)) {

        printStructure("get_by_id", vPC, 4);

        return;

    }

    if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_self)) {

        printStructure("get_by_id_self", vPC, 4);

        return;

    }

    if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_proto)) {

        printf("  [%4d] %s: %s, %s\n", instructionOffset, "get_by_id_proto", pointerToSourceString(vPC[4].u.structure).UTF8String().data(), pointerToSourceString(vPC[5].u.structure).UTF8String().data());

        return;

    }

    if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_transition)) {

        printf("  [%4d] %s: %s, %s, %s\n", instructionOffset, "put_by_id_transition", pointerToSourceString(vPC[4].u.structure).UTF8String().data(), pointerToSourceString(vPC[5].u.structure).UTF8String().data(), pointerToSourceString(vPC[6].u.structureChain).UTF8String().data());

        return;

    }

    if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_chain)) {

        printf("  [%4d] %s: %s, %s\n", instructionOffset, "get_by_id_chain", pointerToSourceString(vPC[4].u.structure).UTF8String().data(), pointerToSourceString(vPC[5].u.structureChain).UTF8String().data());

        return;

    }

    if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id)) {

        printStructure("put_by_id", vPC, 4);

        return;

    }

    if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_replace)) {

        printStructure("put_by_id_replace", vPC, 4);

        return;

    }

    if (vPC[0].u.opcode == interpreter->getOpcode(op_resolve_global)) {

        printStructure("resolve_global", vPC, 4);

        return;

    }

    if (vPC[0].u.opcode == interpreter->getOpcode(op_resolve_global_dynamic)) {

        printStructure("resolve_global_dynamic", vPC, 4);

        return;

    }

    // These m_instructions doesn't ref Structures.

    ASSERT(vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_generic) || vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_generic) || vPC[0].u.opcode == interpreter->getOpcode(op_call) || vPC[0].u.opcode == interpreter->getOpcode(op_call_eval) || vPC[0].u.opcode == interpreter->getOpcode(op_construct));

}

void CodeBlock::dump(ExecState* exec) const

{

    if (m_instructions.isEmpty()) {

        printf("No instructions available.\n");

        return;

    }

    size_t instructionCount = 0;

    for (size_t i = 0; i < m_instructions.size(); i += opcodeLengths[exec->interpreter()->getOpcodeID(m_instructions[i].u.opcode)])

        ++instructionCount;

    printf("%lu m_instructions; %lu bytes at %p; %d parameter(s); %d callee register(s)\n\n",

        static_cast<unsigned long>(instructionCount),

        static_cast<unsigned long>(m_instructions.size() * sizeof(Instruction)),

        this, m_numParameters, m_numCalleeRegisters);

    Vector<Instruction>::const_iterator begin = m_instructions.begin();

    Vector<Instruction>::const_iterator end = m_instructions.end();

    for (Vector<Instruction>::const_iterator it = begin; it != end; ++it)

        dump(exec, begin, it);

    if (!m_identifiers.isEmpty()) {

        printf("\nIdentifiers:\n");

        size_t i = 0;

        do {

            printf("  id%u = %s\n", static_cast<unsigned>(i), m_identifiers[i].ascii());

            ++i;

        } while (i != m_identifiers.size());

    }

    if (!m_constantRegisters.isEmpty()) {

        printf("\nConstants:\n");

        unsigned registerIndex = m_numVars;

        size_t i = 0;

        do {

            printf("   k%u = %s\n", registerIndex, valueToSourceString(exec, m_constantRegisters[i].jsValue()).ascii());

            ++i;

            ++registerIndex;

        } while (i < m_constantRegisters.size());

    }

    if (m_rareData && !m_rareData->m_regexps.isEmpty()) {

        printf("\nm_regexps:\n");

        size_t i = 0;

        do {

            printf("  re%u = %s\n", static_cast<unsigned>(i), regexpToSourceString(m_rareData->m_regexps[i].get()).ascii());

            ++i;

        } while (i < m_rareData->m_regexps.size());

    }

#if ENABLE(JIT)

    if (!m_globalResolveInfos.isEmpty() || !m_structureStubInfos.isEmpty())

        printf("\nStructures:\n");

    if (!m_globalResolveInfos.isEmpty()) {

        size_t i = 0;

        do {

             printGlobalResolveInfo(m_globalResolveInfos[i], instructionOffsetForNth(exec, m_instructions, i + 1, isGlobalResolve));

             ++i;

        } while (i < m_globalResolveInfos.size());

    }

    if (!m_structureStubInfos.isEmpty()) {

        size_t i = 0;

        do {

            printStructureStubInfo(m_structureStubInfos[i], instructionOffsetForNth(exec, m_instructions, i + 1, isPropertyAccess));

             ++i;

        } while (i < m_structureStubInfos.size());

    }

#else

    if (!m_globalResolveInstructions.isEmpty() || !m_propertyAccessInstructions.isEmpty())

        printf("\nStructures:\n");

    if (!m_globalResolveInstructions.isEmpty()) {

        size_t i = 0;

        do {

             printStructures(&m_instructions[m_globalResolveInstructions[i]]);

             ++i;

        } while (i < m_globalResolveInstructions.size());

    }

    if (!m_propertyAccessInstructions.isEmpty()) {

        size_t i = 0;

        do {

            printStructures(&m_instructions[m_propertyAccessInstructions[i]]);

             ++i;

        } while (i < m_propertyAccessInstructions.size());

    }

#endif

    if (m_rareData && !m_rareData->m_exceptionHandlers.isEmpty()) {

        printf("\nException Handlers:\n");

        unsigned i = 0;

        do {

            printf("\t %d: { start: [%4d] end: [%4d] target: [%4d] }\n", i + 1, m_rareData->m_exceptionHandlers[i].start, m_rareData->m_exceptionHandlers[i].end, m_rareData->m_exceptionHandlers[i].target);

            ++i;

        } while (i < m_rareData->m_exceptionHandlers.size());

    }

    if (m_rareData && !m_rareData->m_immediateSwitchJumpTables.isEmpty()) {

        printf("Immediate Switch Jump Tables:\n");

        unsigned i = 0;

        do {

            printf("  %1d = {\n", i);

            int entry = 0;

            Vector<int32_t>::const_iterator end = m_rareData->m_immediateSwitchJumpTables[i].branchOffsets.end();

            for (Vector<int32_t>::const_iterator iter = m_rareData->m_immediateSwitchJumpTables[i].branchOffsets.begin(); iter != end; ++iter, ++entry) {

                if (!*iter)

                    continue;

                printf("\t\t%4d => %04d\n", entry + m_rareData->m_immediateSwitchJumpTables[i].min, *iter);

            }

            printf("      }\n");

            ++i;

        } while (i < m_rareData->m_immediateSwitchJumpTables.size());

    }

    if (m_rareData && !m_rareData->m_characterSwitchJumpTables.isEmpty()) {

        printf("\nCharacter Switch Jump Tables:\n");

        unsigned i = 0;

        do {

            printf("  %1d = {\n", i);

            int entry = 0;

            Vector<int32_t>::const_iterator end = m_rareData->m_characterSwitchJumpTables[i].branchOffsets.end();

            for (Vector<int32_t>::const_iterator iter = m_rareData->m_characterSwitchJumpTables[i].branchOffsets.begin(); iter != end; ++iter, ++entry) {

                if (!*iter)

                    continue;

                ASSERT(!((i + m_rareData->m_characterSwitchJumpTables[i].min) & ~0xFFFF));

                UChar ch = static_cast<UChar>(entry + m_rareData->m_characterSwitchJumpTables[i].min);

                printf("\t\t\"%s\" => %04d\n", UString(&ch, 1).ascii(), *iter);

        }

            printf("      }\n");

            ++i;

        } while (i < m_rareData->m_characterSwitchJumpTables.size());

    }

    if (m_rareData && !m_rareData->m_stringSwitchJumpTables.isEmpty()) {

        printf("\nString Switch Jump Tables:\n");

        unsigned i = 0;

        do {

            printf("  %1d = {\n", i);

            StringJumpTable::StringOffsetTable::const_iterator end = m_rareData->m_stringSwitchJumpTables[i].offsetTable.end();

            for (StringJumpTable::StringOffsetTable::const_iterator iter = m_rareData->m_stringSwitchJumpTables[i].offsetTable.begin(); iter != end; ++iter)

                printf("\t\t\"%s\" => %04d\n", UString(iter->first).ascii(), iter->second.branchOffset);

            printf("      }\n");

            ++i;

        } while (i < m_rareData->m_stringSwitchJumpTables.size());

    }

    printf("\n");

}

void CodeBlock::dump(ExecState* exec, const Vector<Instruction>::const_iterator& begin, Vector<Instruction>::const_iterator& it) const

{

    int location = it - begin;

    switch (exec->interpreter()->getOpcodeID(it->u.opcode)) {

        case op_enter: {

            printf("[%4d] enter\n", location);

            break;

        }

        case op_enter_with_activation: {

            int r0 = (++it)->u.operand;

            printf("[%4d] enter_with_activation %s\n", location, registerName(exec, r0).data());

            break;

        }

        case op_create_arguments: {

            int r0 = (++it)->u.operand;

            printf("[%4d] create_arguments\t %s\n", location, registerName(exec, r0).data());

            break;

        }

        case op_init_arguments: {

            int r0 = (++it)->u.operand;

            printf("[%4d] init_arguments\t %s\n", location, registerName(exec, r0).data());

            break;

        }

        case op_get_callee: {

            int r0 = (++it)->u.operand;

            printf("[%4d] op_get_callee %s\n", location, registerName(exec, r0).data());

            break;

        }

        case op_create_this: {

            int r0 = (++it)->u.operand;

            int r1 = (++it)->u.operand;

            printf("[%4d] create_this %s %s\n", location, registerName(exec, r0).data(), registerName(exec, r1).data());

            break;

        }

        case op_convert_this: {

            int r0 = (++it)->u.operand;

            printf("[%4d] convert_this %s\n", location, registerName(exec, r0).data());

            break;

        }

        case op_new_object: {

            int r0 = (++it)->u.operand;

            printf("[%4d] new_object\t %s\n", location, registerName(exec, r0).data());

            break;

        }

        case op_new_array: {

            int dst = (++it)->u.operand;

            int argv = (++it)->u.operand;

            int argc = (++it)->u.operand;

            printf("[%4d] new_array\t %s, %s, %d\n", location, registerName(exec, dst).data(), registerName(exec, argv).data(), argc);

            break;