/*

 * 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 "Interpreter.h"

#include "Arguments.h"

#include "BatchedTransitionOptimizer.h"

#include "CallFrame.h"

#include "CallFrameClosure.h"

#include "CodeBlock.h"

#include "Collector.h"

#include "Debugger.h"

#include "DebuggerCallFrame.h"

#include "EvalCodeCache.h"

#include "ExceptionHelpers.h"

#include "GetterSetter.h"

#include "GlobalEvalFunction.h"

#include "JSActivation.h"

#include "JSArray.h"

#include "JSByteArray.h"

#include "JSFunction.h"

#include "JSNotAnObject.h"

#include "JSPropertyNameIterator.h"

#include "LiteralParser.h"

#include "JSStaticScopeObject.h"

#include "JSString.h"

#include "ObjectPrototype.h"

#include "Operations.h"

#include "Parser.h"

#include "Profiler.h"

#include "RegExpObject.h"

#include "RegExpPrototype.h"

#include "Register.h"

#include "SamplingTool.h"

#include <limits.h>

#include <stdio.h>

#include <wtf/Threading.h>

#if ENABLE(JIT)

#include "JIT.h"

#endif

using namespace std;

namespace JSC {

// Returns the depth of the scope chain within a given call frame.

static int depth(CodeBlock* codeBlock, ScopeChain& sc)

{

    if (!codeBlock->needsFullScopeChain())

        return 0;

    return sc.localDepth();

}

#if ENABLE(INTERPRETER) 

NEVER_INLINE bool Interpreter::resolve(CallFrame* callFrame, Instruction* vPC, JSValue& exceptionValue)

{

    int dst = vPC[1].u.operand;

    int property = vPC[2].u.operand;

    ScopeChainNode* scopeChain = callFrame->scopeChain();

    ScopeChainIterator iter = scopeChain->begin();

    ScopeChainIterator end = scopeChain->end();

    ASSERT(iter != end);

    CodeBlock* codeBlock = callFrame->codeBlock();

    Identifier& ident = codeBlock->identifier(property);

    do {

        JSObject* o = *iter;

        PropertySlot slot(o);

        if (o->getPropertySlot(callFrame, ident, slot)) {

            JSValue result = slot.getValue(callFrame, ident);

            exceptionValue = callFrame->globalData().exception;

            if (exceptionValue)

                return false;

            callFrame->r(dst) = JSValue(result);

            return true;

        }

    } while (++iter != end);

    exceptionValue = createUndefinedVariableError(callFrame, ident, vPC - codeBlock->instructions().begin(), codeBlock);

    return false;

}

NEVER_INLINE bool Interpreter::resolveSkip(CallFrame* callFrame, Instruction* vPC, JSValue& exceptionValue)

{

    CodeBlock* codeBlock = callFrame->codeBlock();

    int dst = vPC[1].u.operand;

    int property = vPC[2].u.operand;

    int skip = vPC[3].u.operand;

    ScopeChainNode* scopeChain = callFrame->scopeChain();

    ScopeChainIterator iter = scopeChain->begin();

    ScopeChainIterator end = scopeChain->end();

    ASSERT(iter != end);

    while (skip--) {

        ++iter;

        ASSERT(iter != end);

    }

    Identifier& ident = codeBlock->identifier(property);

    do {

        JSObject* o = *iter;

        PropertySlot slot(o);

        if (o->getPropertySlot(callFrame, ident, slot)) {

            JSValue result = slot.getValue(callFrame, ident);

            exceptionValue = callFrame->globalData().exception;

            if (exceptionValue)

                return false;

            callFrame->r(dst) = JSValue(result);

            return true;

        }

    } while (++iter != end);

    exceptionValue = createUndefinedVariableError(callFrame, ident, vPC - codeBlock->instructions().begin(), codeBlock);

    return false;

}

NEVER_INLINE bool Interpreter::resolveGlobal(CallFrame* callFrame, Instruction* vPC, JSValue& exceptionValue)

{

    int dst = vPC[1].u.operand;

    JSGlobalObject* globalObject = static_cast<JSGlobalObject*>(vPC[2].u.jsCell);

    ASSERT(globalObject->isGlobalObject());

    int property = vPC[3].u.operand;

    Structure* structure = vPC[4].u.structure;

    int offset = vPC[5].u.operand;

    if (structure == globalObject->structure()) {

        callFrame->r(dst) = JSValue(globalObject->getDirectOffset(offset));

        return true;

    }

    CodeBlock* codeBlock = callFrame->codeBlock();

    Identifier& ident = codeBlock->identifier(property);

    PropertySlot slot(globalObject);

    if (globalObject->getPropertySlot(callFrame, ident, slot)) {

        JSValue result = slot.getValue(callFrame, ident);

        if (slot.isCacheableValue() && !globalObject->structure()->isUncacheableDictionary() && slot.slotBase() == globalObject) {

            if (vPC[4].u.structure)

                vPC[4].u.structure->deref();

            globalObject->structure()->ref();

            vPC[4] = globalObject->structure();

            vPC[5] = slot.cachedOffset();

            callFrame->r(dst) = JSValue(result);

            return true;

        }

        exceptionValue = callFrame->globalData().exception;

        if (exceptionValue)

            return false;

        callFrame->r(dst) = JSValue(result);

        return true;

    }

    exceptionValue = createUndefinedVariableError(callFrame, ident, vPC - codeBlock->instructions().begin(), codeBlock);

    return false;

}

NEVER_INLINE bool Interpreter::resolveGlobalDynamic(CallFrame* callFrame, Instruction* vPC, JSValue& exceptionValue)

{

    int dst = vPC[1].u.operand;

    JSGlobalObject* globalObject = static_cast<JSGlobalObject*>(vPC[2].u.jsCell);

    ASSERT(globalObject->isGlobalObject());

    int property = vPC[3].u.operand;

    Structure* structure = vPC[4].u.structure;

    int offset = vPC[5].u.operand;

    CodeBlock* codeBlock = callFrame->codeBlock();

    int skip = vPC[6].u.operand;

    ScopeChainNode* scopeChain = callFrame->scopeChain();

    ScopeChainIterator iter = scopeChain->begin();

    ScopeChainIterator end = scopeChain->end();

    ASSERT(iter != end);

    while (skip--) {

        JSObject* o = *iter;

        if (o->hasCustomProperties()) {

            Identifier& ident = codeBlock->identifier(property);

            do {

                PropertySlot slot(o);

                if (o->getPropertySlot(callFrame, ident, slot)) {

                    JSValue result = slot.getValue(callFrame, ident);

                    exceptionValue = callFrame->globalData().exception;

                    if (exceptionValue)

                        return false;

                    callFrame->r(dst) = JSValue(result);

                    return true;

                }

                if (iter == end)

                    break;

                o = *iter;

                ++iter;

            } while (true);

            exceptionValue = createUndefinedVariableError(callFrame, ident, vPC - codeBlock->instructions().begin(), codeBlock);

            return false;

        }

        ++iter;

    }

    if (structure == globalObject->structure()) {

        callFrame->r(dst) = JSValue(globalObject->getDirectOffset(offset));

        return true;

    }

    Identifier& ident = codeBlock->identifier(property);

    PropertySlot slot(globalObject);

    if (globalObject->getPropertySlot(callFrame, ident, slot)) {

        JSValue result = slot.getValue(callFrame, ident);

        if (slot.isCacheableValue() && !globalObject->structure()->isUncacheableDictionary() && slot.slotBase() == globalObject) {

            if (vPC[4].u.structure)

                vPC[4].u.structure->deref();

            globalObject->structure()->ref();

            vPC[4] = globalObject->structure();

            vPC[5] = slot.cachedOffset();

            callFrame->r(dst) = JSValue(result);

            return true;

        }

        exceptionValue = callFrame->globalData().exception;

        if (exceptionValue)

            return false;

        callFrame->r(dst) = JSValue(result);

        return true;

    }

    exceptionValue = createUndefinedVariableError(callFrame, ident, vPC - codeBlock->instructions().begin(), codeBlock);

    return false;

}

NEVER_INLINE void Interpreter::resolveBase(CallFrame* callFrame, Instruction* vPC)

{

    int dst = vPC[1].u.operand;

    int property = vPC[2].u.operand;

    callFrame->r(dst) = JSValue(JSC::resolveBase(callFrame, callFrame->codeBlock()->identifier(property), callFrame->scopeChain()));

}

NEVER_INLINE bool Interpreter::resolveBaseAndProperty(CallFrame* callFrame, Instruction* vPC, JSValue& exceptionValue)

{

    int baseDst = vPC[1].u.operand;

    int propDst = vPC[2].u.operand;

    int property = vPC[3].u.operand;

    ScopeChainNode* scopeChain = callFrame->scopeChain();

    ScopeChainIterator iter = scopeChain->begin();

    ScopeChainIterator end = scopeChain->end();

    // FIXME: add scopeDepthIsZero optimization

    ASSERT(iter != end);

    CodeBlock* codeBlock = callFrame->codeBlock();

    Identifier& ident = codeBlock->identifier(property);

    JSObject* base;

    do {

        base = *iter;

        PropertySlot slot(base);

        if (base->getPropertySlot(callFrame, ident, slot)) {

            JSValue result = slot.getValue(callFrame, ident);

            exceptionValue = callFrame->globalData().exception;

            if (exceptionValue)

                return false;

            callFrame->r(propDst) = JSValue(result);

            callFrame->r(baseDst) = JSValue(base);

            return true;

        }

        ++iter;

    } while (iter != end);

    exceptionValue = createUndefinedVariableError(callFrame, ident, vPC - codeBlock->instructions().begin(), codeBlock);

    return false;

}

#endif // ENABLE(INTERPRETER)

ALWAYS_INLINE CallFrame* Interpreter::slideRegisterWindowForCall(CodeBlock* newCodeBlock, RegisterFile* registerFile, CallFrame* callFrame, size_t registerOffset, int argc)

{

    Register* r = callFrame->registers();

    Register* newEnd = r + registerOffset + newCodeBlock->m_numCalleeRegisters;

    if (LIKELY(argc == newCodeBlock->m_numParameters)) { // correct number of arguments

        if (UNLIKELY(!registerFile->grow(newEnd)))

            return 0;

        r += registerOffset;

    } else if (argc < newCodeBlock->m_numParameters) { // too few arguments -- fill in the blanks

        size_t omittedArgCount = newCodeBlock->m_numParameters - argc;

        registerOffset += omittedArgCount;

        newEnd += omittedArgCount;

        if (!registerFile->grow(newEnd))

            return 0;

        r += registerOffset;

        Register* argv = r - RegisterFile::CallFrameHeaderSize - omittedArgCount;

        for (size_t i = 0; i < omittedArgCount; ++i)

            argv[i] = jsUndefined();

    } else { // too many arguments -- copy expected arguments, leaving the extra arguments behind

        size_t numParameters = newCodeBlock->m_numParameters;

        registerOffset += numParameters;

        newEnd += numParameters;

        if (!registerFile->grow(newEnd))

            return 0;

        r += registerOffset;

        Register* argv = r - RegisterFile::CallFrameHeaderSize - numParameters - argc;

        for (size_t i = 0; i < numParameters; ++i)

            argv[i + argc] = argv[i];

    }

    return CallFrame::create(r);

}

#if ENABLE(INTERPRETER)

static NEVER_INLINE bool isInvalidParamForIn(CallFrame* callFrame, CodeBlock* codeBlock, const Instruction* vPC, JSValue value, JSValue& exceptionData)

{

    if (value.isObject())

        return false;

    exceptionData = createInvalidParamError(callFrame, "in" , value, vPC - codeBlock->instructions().begin(), codeBlock);

    return true;

}

static NEVER_INLINE bool isInvalidParamForInstanceOf(CallFrame* callFrame, CodeBlock* codeBlock, const Instruction* vPC, JSValue value, JSValue& exceptionData)

{

    if (value.isObject() && asObject(value)->structure()->typeInfo().implementsHasInstance())

        return false;

    exceptionData = createInvalidParamError(callFrame, "instanceof" , value, vPC - codeBlock->instructions().begin(), codeBlock);

    return true;

}

#endif

NEVER_INLINE JSValue Interpreter::callEval(CallFrame* callFrame, RegisterFile* registerFile, Register* argv, int argc, int registerOffset, JSValue& exceptionValue)

{

    if (argc < 2)

        return jsUndefined();

    JSValue program = argv[1].jsValue();

    if (!program.isString())

        return program;

    UString programSource = asString(program)->value(callFrame);

    if (callFrame->hadException())

        return JSValue();

    LiteralParser preparser(callFrame, programSource, LiteralParser::NonStrictJSON);

    if (JSValue parsedObject = preparser.tryLiteralParse())

        return parsedObject;

    ScopeChainNode* scopeChain = callFrame->scopeChain();

    CodeBlock* codeBlock = callFrame->codeBlock();

    RefPtr<EvalExecutable> eval = codeBlock->evalCodeCache().get(callFrame, programSource, scopeChain, exceptionValue);

    JSValue result = jsUndefined();

    if (eval)

        result = callFrame->globalData().interpreter->execute(eval.get(), callFrame, callFrame->r(codeBlock->thisRegister()).jsValue().toThisObject(callFrame), callFrame->registers() - registerFile->start() + registerOffset, scopeChain, &exceptionValue);

    return result;

}

Interpreter::Interpreter()

    : m_sampleEntryDepth(0)

    , m_reentryDepth(0)

{

#if ENABLE(COMPUTED_GOTO_INTERPRETER)

    privateExecute(InitializeAndReturn, 0, 0, 0);

    for (int i = 0; i < numOpcodeIDs; ++i)

        m_opcodeIDTable.add(m_opcodeTable[i], static_cast<OpcodeID>(i));

#endif // ENABLE(COMPUTED_GOTO_INTERPRETER)

#if ENABLE(OPCODE_SAMPLING)

    enableSampler();

#endif

}

#ifndef NDEBUG

void Interpreter::dumpCallFrame(CallFrame* callFrame)

{

    callFrame->codeBlock()->dump(callFrame);

    dumpRegisters(callFrame);

}

void Interpreter::dumpRegisters(CallFrame* callFrame)

{

    printf("Register frame: \n\n");

    printf("-----------------------------------------------------------------------------\n");

    printf("            use            |   address  |                value               \n");

    printf("-----------------------------------------------------------------------------\n");

    CodeBlock* codeBlock = callFrame->codeBlock();

    RegisterFile* registerFile = &callFrame->scopeChain()->globalObject->globalData()->interpreter->registerFile();

    const Register* it;

    const Register* end;

    JSValue v;

    if (codeBlock->codeType() == GlobalCode) {

        it = registerFile->lastGlobal();

        end = it + registerFile->numGlobals();

        while (it != end) {

            v = (*it).jsValue();

#if USE(JSVALUE32_64)

            printf("[global var]               | %10p | %-16s 0x%llx \n", it, v.description(), JSValue::encode(v));

#else

            printf("[global var]               | %10p | %-16s %p \n", it, v.description(), JSValue::encode(v));

#endif

            ++it;

        }

        printf("-----------------------------------------------------------------------------\n");

    }

    it = callFrame->registers() - RegisterFile::CallFrameHeaderSize - codeBlock->m_numParameters;

    v = (*it).jsValue();

#if USE(JSVALUE32_64)

    printf("[this]                     | %10p | %-16s 0x%llx \n", it, v.description(), JSValue::encode(v)); ++it;

#else

    printf("[this]                     | %10p | %-16s %p \n", it, v.description(), JSValue::encode(v)); ++it;

#endif

    end = it + max(codeBlock->m_numParameters - 1, 0); // - 1 to skip "this"

    if (it != end) {

        do {

            v = (*it).jsValue();

#if USE(JSVALUE32_64)

            printf("[param]                    | %10p | %-16s 0x%llx \n", it, v.description(), JSValue::encode(v));

#else

            printf("[param]                    | %10p | %-16s %p \n", it, v.description(), JSValue::encode(v));

#endif

            ++it;

        } while (it != end);

    }

    printf("-----------------------------------------------------------------------------\n");

    printf("[CodeBlock]                | %10p | %p \n", it, (*it).codeBlock()); ++it;

    printf("[ScopeChain]               | %10p | %p \n", it, (*it).scopeChain()); ++it;

    printf("[CallerRegisters]          | %10p | %d \n", it, (*it).i()); ++it;

    printf("[ReturnPC]                 | %10p | %p \n", it, (*it).vPC()); ++it;

    printf("[ArgumentCount]            | %10p | %d \n", it, (*it).i()); ++it;

    printf("[Callee]                   | %10p | %p \n", it, (*it).function()); ++it;

    printf("-----------------------------------------------------------------------------\n");

    int registerCount = 0;

    end = it + codeBlock->m_numVars;

    if (it != end) {

        do {

            v = (*it).jsValue();

#if USE(JSVALUE32_64)

            printf("[r%2d]                      | %10p | %-16s 0x%llx \n", registerCount, it, v.description(), JSValue::encode(v));

#else

            printf("[r%2d]                      | %10p | %-16s %p \n", registerCount, it, v.description(), JSValue::encode(v));

#endif

            ++it;

            ++registerCount;

        } while (it != end);

    }

    printf("-----------------------------------------------------------------------------\n");

    end = it + codeBlock->m_numCalleeRegisters - codeBlock->m_numVars;

    if (it != end) {

        do {

            v = (*it).jsValue();

#if USE(JSVALUE32_64)

            printf("[r%2d]                      | %10p | %-16s 0x%llx \n", registerCount, it, v.description(), JSValue::encode(v));

#else

            printf("[r%2d]                      | %10p | %-16s %p \n", registerCount, it, v.description(), JSValue::encode(v));

#endif

            ++it;

            ++registerCount;

        } while (it != end);

    }

    printf("-----------------------------------------------------------------------------\n");

}

#endif

bool Interpreter::isOpcode(Opcode opcode)

{

#if ENABLE(COMPUTED_GOTO_INTERPRETER)

    return opcode != HashTraits<Opcode>::emptyValue()

        && !HashTraits<Opcode>::isDeletedValue(opcode)

        && m_opcodeIDTable.contains(opcode);

#else

    return opcode >= 0 && opcode <= op_end;

#endif

}

NEVER_INLINE bool Interpreter::unwindCallFrame(CallFrame*& callFrame, JSValue exceptionValue, unsigned& bytecodeOffset, CodeBlock*& codeBlock)

{

    CodeBlock* oldCodeBlock = codeBlock;

    ScopeChainNode* scopeChain = callFrame->scopeChain();

    if (Debugger* debugger = callFrame->dynamicGlobalObject()->debugger()) {

        DebuggerCallFrame debuggerCallFrame(callFrame, exceptionValue);

        if (callFrame->callee())

            debugger->returnEvent(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->ownerExecutable()->lastLine());

        else

            debugger->didExecuteProgram(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->ownerExecutable()->lastLine());

    }

    if (Profiler* profiler = *Profiler::enabledProfilerReference()) {

        if (callFrame->callee())

            profiler->didExecute(callFrame, callFrame->callee());

        else

            profiler->didExecute(callFrame, codeBlock->ownerExecutable()->sourceURL(), codeBlock->ownerExecutable()->lineNo());

    }