/*
 * Copyright (C) 2008, 2009, 2010, 2012 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 "BatchedTransitionOptimizer.h"
#include "CallFrameClosure.h"
#include "CallFrameInlines.h"
#include "CopiedSpaceInlineMethods.h"
#include "CodeBlock.h"
#include "Heap.h"
#include "Debugger.h"
#include "DebuggerCallFrame.h"
#include "DirectArguments.h"
#include "ErrorInstance.h"
#include "EvalCodeCache.h"
#include "Exception.h"
#include "ExceptionHelpers.h"
#include "GetterSetter.h"
#include "HostCallReturnValue.h"
#include "JSLexicalEnvironment.h"
#include "JSModuleEnvironment.h"
#include "JSArray.h"
#include "JSBoundFunction.h"
#include "JSStackInlines.h"
#include "JSString.h"
#include "JSWithScope.h"
#include "LiteralParser.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 "ScopedArguments.h"
#include "StackVisitor.h"
#include "SourceProvider.h"
#include "StrictEvalActivation.h"
#include "StrongInlines.h"
#include "Symbol.h"
#include <limits.h>
#include <wtf/StackStats.h>
#include <wtf/MemoryMonitor.h>
#include <wtf/StringPrintStream.h>
#include <wtf/Threading.h>
#include <wtf/WTFThreadData.h>
#include <wtf/text/StringBuilder.h>

#if ENABLE(JIT)
#include "JIT.h"
#endif

#define WTF_USE_GCC_COMPUTED_GOTO_WORKAROUND (ENABLE(LLINT) && !defined(__llvm__))

using namespace std;

namespace JSC {

String StackFrame::friendlySourceURL() const
{
    String traceLine;

    switch (codeType) {
    case StackFrameEvalCode:
    case StackFrameModuleCode:
    case StackFrameFunctionCode:
    case StackFrameGlobalCode:
        if (!sourceURL.isEmpty())
            traceLine = sourceURL.impl();
        break;
    case StackFrameNativeCode:
        traceLine = "[native code]";
        break;
    }
    return traceLine.isNull() ? emptyString() : traceLine;
}
String StackFrame::friendlyFunctionName(CallFrame* callFrame) const
{
    String traceLine;
    JSObject* stackFrameCallee = callee.get();

    switch (codeType) {
    case StackFrameEvalCode:
        traceLine = "eval code";
        break;
    case StackFrameModuleCode:
        traceLine = "module code";
        break;
    case StackFrameNativeCode:
        if (callee)
            traceLine = getCalculatedDisplayName(callFrame->vm(), stackFrameCallee).impl();
        break;
    case StackFrameFunctionCode:
        if (callee)
        	traceLine = getCalculatedDisplayName(callFrame->vm(), stackFrameCallee).impl();
        break;
    case StackFrameGlobalCode:
        traceLine = "global code";
        break;
    }
    return traceLine.isNull() ? emptyString() : traceLine;
}

Interpreter::ErrorHandlingMode::ErrorHandlingMode(ExecState *exec)
    : m_interpreter(*exec->vm().interpreter)
{
    if (!m_interpreter.m_errorHandlingModeReentry)
        m_interpreter.registerFile().enableErrorStackReserve();
    m_interpreter.m_errorHandlingModeReentry++;
}

Interpreter::ErrorHandlingMode::~ErrorHandlingMode()
{
    m_interpreter.m_errorHandlingModeReentry--;
    ASSERT(m_interpreter.m_errorHandlingModeReentry >= 0);
    if (!m_interpreter.m_errorHandlingModeReentry)
        m_interpreter.registerFile().disableErrorStackReserve();
}


// The Interpreter::StackPolicy class is used to compute a stack capacity
// requirement to ensure that we have enough room on the native stack for:
// 1. the max cumulative stack used by the interpreter and all code
//    paths sub of it up till leaf functions.
// 2. the max cumulative stack used by the interpreter before it reaches
//    the next checkpoint (execute...() function) in the interpreter.
//
// The interpreter can be run on different threads and hence, different
// native stacks (with different sizes) before exiting out of the first
// frame. Hence, the required capacity needs to be re-computed on every
// entry into the interpreter.
//
// Currently the requiredStack is computed based on a policy. See comments
// in StackPolicy::StackPolicy() for details.

Interpreter::StackPolicy::StackPolicy(Interpreter& interpreter, const StackBounds& stack)
    : m_interpreter(interpreter)
{
    const size_t size = stack.size();

    // We have two separate stack limits, one for regular JS execution, and one
    // for when we're handling errors. We need the error stack to be smaller
    // otherwise there would obviously not be any stack left to execute JS in when
    // there's a stack overflow.
    //
    // These sizes were derived from the stack usage of a number of sites when
    // layout occurs when we've already consumed most of the C stack.
    const size_t requiredStack = 256 * KB;
    const size_t errorModeRequiredStack = 64 * KB;

    size_t requiredCapacity = m_interpreter.m_errorHandlingModeReentry ? errorModeRequiredStack : requiredStack;

    RELEASE_ASSERT(size > requiredCapacity);

    m_requiredCapacity = requiredCapacity;
}

JSValue eval(CallFrame* callFrame)
{
    if (!callFrame->argumentCount())
        return jsUndefined();

    JSValue program = callFrame->argument(0);
    if (!program.isString())
        return program;
    
    JSGlobalData& vm = callFrame->vm();
    TopCallFrameSetter topCallFrame(vm, callFrame);
    String programSource = asString(program)->value(callFrame);
    RETURN_IF_EXCEPTION(vm, JSValue());
    
    CallFrame* callerFrame = callFrame->callerFrame();
    CallSiteIndex callerCallSiteIndex = callerFrame->callSiteIndex();
    CodeBlock* callerCodeBlock = callerFrame->codeBlock();
    JSScope* callerScopeChain = callerFrame->uncheckedR(callerCodeBlock->scopeRegister().offset()).Register::scope();

    bool isArrowFunctionContext = callerCodeBlock->isArrowFunction() || callerCodeBlock->isArrowFunctionContext();

    DerivedContextType derivedContextType = callerCodeBlock->derivedContextType();
    if (!isArrowFunctionContext && callerCodeBlock->isClassContext()) {
        derivedContextType = callerCodeBlock->isConstructor()
            ? DerivedContextType::DerivedConstructorContext
            : DerivedContextType::DerivedMethodContext;
    }

    EvalContextType evalContextType;
    if (isFunctionParseMode(callerCodeBlock->parseMode()))
        evalContextType = EvalContextType::FunctionEvalContext;
    else if (callerCodeBlock->codeType() == EvalCode)
        evalContextType = callerCodeBlock->evalContextType();
    else
        evalContextType = EvalContextType::None;

    EvalExecutable* eval = callerCodeBlock->evalCodeCache().tryGet(programSource, callerCallSiteIndex);;
	if (!eval) {
        if (!callerCodeBlock->isStrictMode()) {
            if (programSource.is8Bit()) {
                LiteralParser<LChar> preparser(callFrame, programSource.characters8(), programSource.length(), NonStrictJSON);
                if (JSValue parsedObject = preparser.tryLiteralParse())
                    return parsedObject;
            } else {
                LiteralParser<UChar> preparser(callFrame, programSource.characters16(), programSource.length(), NonStrictJSON);
                if (JSValue parsedObject = preparser.tryLiteralParse())
                    return parsedObject;                
            }
            RETURN_IF_EXCEPTION(vm, JSValue());
        }

        eval = callerCodeBlock->evalCodeCache().getSlow(vm, callerCodeBlock->ownerExecutable(), programSource, callerCallSiteIndex, callerCodeBlock->isStrictMode(), derivedContextType, evalContextType, isArrowFunctionContext, callerScopeChain);
        
        if (!eval)
            return jsUndefined();
    }

    JSValue thisValue = callerFrame->thisValue();
    Interpreter* interpreter = vm.interpreter;
    return interpreter->execute(eval, callFrame, thisValue, callerScopeChain);
}

unsigned sizeOfVarargs(CallFrame* callFrame, JSValue arguments, uint32_t firstVarArgOffset)
{
    VM& vm = callFrame->vm();

    unsigned length;
    if (!arguments)
        length = callFrame->argumentCount();
    else if (arguments.isUndefinedOrNull())
        length = 0;
    else if (!arguments.isObject()) {
        vm.throwException(callFrame, createInvalidFunctionApplyParameterError(callFrame, arguments));
        return 0;
    }
    else if (asObject(arguments)->structure()->typeInfo().type() == DirectArgumentsType)
        length = jsCast<DirectArguments*>(arguments)->length(callFrame);
    else if (asObject(arguments)->structure()->typeInfo().type() == ScopedArgumentsType)
        length = jsCast<ScopedArguments*>(arguments)->length(callFrame);
    else {
        ASSERT(arguments.isObject());
        length = toLength(callFrame, jsCast<JSObject*>(arguments));
    }
    RETURN_IF_EXCEPTION(vm, 0);

    if (length >= firstVarArgOffset)
    	length -= firstVarArgOffset;
	else
		length = 0;

    return length;
}

CallFrame* sizeAndAllocFrameForVarargs(CallFrame* callFrame, JSStack* registerFile, JSValue arguments, int firstFreeRegister, uint32_t firstVarArgOffset)
{
    VM& vm = callFrame->vm();

    unsigned length = sizeOfVarargs(callFrame, arguments, firstVarArgOffset);
    RETURN_IF_EXCEPTION(vm, 0);

    CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + firstFreeRegister - CallFrame::offsetFor(length + 1));
    if (length > maxArguments || !registerFile->grow(newCallFrame->registers())) {
        vm.throwException(callFrame, createStackOverflowError(callFrame));
        return 0;
    }
    return newCallFrame;
}

void loadVarargs(CallFrame* callFrame, CallFrame* newCallFrame, JSValue thisValue, JSValue arguments, uint32_t firstVarArgOffset)
{
    unsigned length = sizeOfVarargs(callFrame, arguments, firstVarArgOffset);

    newCallFrame->setArgumentCountIncludingThis(length + 1);
    newCallFrame->setThisValue(thisValue);

    if (!arguments || !length)
    	return;

    if (asObject(arguments)->structure()->typeInfo().type() == DirectArgumentsType)
        jsCast<DirectArguments*>(arguments)->copyToArguments(callFrame, newCallFrame, length, firstVarArgOffset);
    else if (asObject(arguments)->structure()->typeInfo().type() == ScopedArgumentsType)
        jsCast<ScopedArguments*>(arguments)->copyToArguments(callFrame, newCallFrame, length, firstVarArgOffset);
    else if (isJSArray(arguments))
        asArray(arguments)->copyToArguments(callFrame, newCallFrame, length, firstVarArgOffset);
    else {
		for (size_t i = 0; i < length; ++i) {
			newCallFrame->setArgument(i, asObject(arguments)->get(callFrame, i + firstVarArgOffset));
			if (UNLIKELY(callFrame->vm().exception()))
				return;
		}
    }
}

Interpreter::Interpreter(JSGlobalData& vm)
: m_sampleEntryDepth(0)
, m_vm(vm)
, m_errorHandlingModeReentry(0)
, m_registerFile(vm)
#if !ASSERT_DISABLED
, m_initialized(false)
#endif
{
}

Interpreter::~Interpreter()
{
}

void Interpreter::initialize(LLInt::Data* llintData, bool canUseJIT)
{
    UNUSED_PARAM(llintData);
    UNUSED_PARAM(canUseJIT);

#if ENABLE(COMPUTED_GOTO_OPCODES) && ENABLE(LLINT)
    m_opcodeTable = LLInt::opcodeMap();
    for (int i = 0; i < numOpcodeIDs; ++i)
        m_opcodeIDTable.add(m_opcodeTable[i], static_cast<OpcodeID>(i));
#endif

#if !ASSERT_DISABLED
    m_initialized = true;
#endif

#if ENABLE(OPCODE_SAMPLING)
    enableSampler();
#endif
}

#ifdef NDEBUG

void Interpreter::dumpCallFrame(CallFrame*)
{
}

#else

void Interpreter::dumpCallFrame(CallFrame* callFrame)
{
    callFrame->codeBlock()->dump(callFrame);
    dumpRegisters(callFrame);
}

class DumpRegisterFunctor {
public:
    DumpRegisterFunctor(const Register*& it)
        : m_hasSkippedFirstFrame(false)
        , m_it(it)
    {
    }

    StackVisitor::Status operator()(StackVisitor& visitor)
    {
        if (!m_hasSkippedFirstFrame) {
            m_hasSkippedFirstFrame = true;
            return StackVisitor::Continue;
        }

        unsigned line = 0;
        unsigned unusedColumn = 0;
        visitor->computeLineAndColumn(line, unusedColumn);
        dataLogF("[ReturnVPC]                | %10p | %d (line %d)\n", m_it, visitor->bytecodeOffset(), line);
        --m_it;
        return StackVisitor::Done;
    }

private:
    bool m_hasSkippedFirstFrame;
    const Register*& m_it;
};

void Interpreter::dumpRegisters(CallFrame* callFrame)
{
    dataLog("Register frame: \n\n");
    dataLog("-----------------------------------------------------------------------------\n");
    dataLog("            use            |   address  |                value               \n");
    dataLog("-----------------------------------------------------------------------------\n");

    CodeBlock* codeBlock = callFrame->codeBlock();
    const Register* it;
    const Register* end;

    it = callFrame->registers() + JSStack::ThisArgument + callFrame->argumentCount();
    end = callFrame->registers() + JSStack::ThisArgument - 1;
    while (it > end) {
        JSValue v = it->jsValue();
        int registerNumber = it - callFrame->registers();
        String name = codeBlock->nameForRegister(registerNumber);
        dataLogF("[r% 3d %14s]      | %10p | %-16s 0x%lld \n", registerNumber, name.ascii().data(), it, toCString(v).data(), (long long)JSValue::encode(v));
		--it;
    }
    
    dataLog("-----------------------------------------------------------------------------\n");
    dataLog("[ArgumentCount]            | %10p | %lu \n", it, (unsigned long) callFrame->argumentCount());
    --it;
    dataLog("[CallerFrame]              | %10p | %p \n", it, callFrame->callerFrame());
    --it;
    dataLog("[Callee]                   | %10p | %p \n", it, callFrame->callee());
    --it;
    // FIXME: Remove the next decrement when the ScopeChain slot is removed from the call header
    --it;
#if ENABLE(JIT)
    AbstractPC pc = callFrame->abstractReturnPC(callFrame->vm());
    if (pc.hasJITReturnAddress())
        dataLog("[ReturnJITPC]              | %10p | %p \n", it, pc.jitReturnAddress().value());
#endif

    DumpRegisterFunctor functor(it);
    callFrame->iterate(functor);

    dataLog("[CodeBlock]                | %10p | %p \n", it, callFrame->codeBlock());
    --it;
    dataLog("-----------------------------------------------------------------------------\n");

    end = it - codeBlock->m_numVars;
    if (it != end) {
        do {
            JSValue v = it->jsValue();
            int registerNumber = it - callFrame->registers();
            String name = codeBlock->nameForRegister(registerNumber);
            dataLogF("[r% 3d %14s]      | %10p | %-16s 0x%lld \n", registerNumber, name.ascii().data(), it, toCString(v).data(), (long long)JSValue::encode(v));
			--it;
        } while (it != end);
    }
    dataLog("-----------------------------------------------------------------------------\n");

    end = it - codeBlock->m_numCalleeLocals + codeBlock->m_numVars;
    if (it != end) {
        do {
            JSValue v = (*it).jsValue();
            int registerNumber = it - callFrame->registers();
            dataLogF("[r% 3d]                     | %10p | %-16s 0x%lld \n", registerNumber, it, toCString(v).data(), (long long)JSValue::encode(v));
            --it;
        } while (it != end);
    }
    dataLog("-----------------------------------------------------------------------------\n");
}

#endif

bool Interpreter::isOpcode(Opcode opcode)
{
#if ENABLE(COMPUTED_GOTO_OPCODES)
#if !ENABLE(LLINT)
    return opcode >= 0 && static_cast<OpcodeID>(bitwise_cast<uintptr_t>(opcode)) <= op_end;
#else
    return opcode != HashTraits<Opcode>::emptyValue()
        && !HashTraits<Opcode>::isDeletedValue(opcode)
        && m_opcodeIDTable.contains(opcode);
#endif
#else
    return opcode >= 0 && opcode <= op_end;
#endif
}

static bool unwindCallFrame(StackVisitor& visitor)
{
    CallFrame* callFrame = visitor->callFrame();

    if (Debugger* debugger = callFrame->dynamicGlobalObject()->debugger()) {
    	SuspendExceptionScope scope(&callFrame->vm());
        if (jsDynamicCast<JSFunction*>(callFrame->callee()))
            debugger->returnEvent(callFrame);
        else
            debugger->didExecuteProgram(callFrame);
        ASSERT(!callFrame->hadException());
    }

    CallFrame* callerFrame = callFrame->callerFrame();
    return !callerFrame->isVMEntrySentinel();
}

static StackFrameCodeType getStackFrameCodeType(StackVisitor& visitor)
{
    switch (visitor->codeType()) {
    case StackVisitor::Frame::Eval:
        return StackFrameEvalCode;
    case StackVisitor::Frame::Module:
        return StackFrameModuleCode;
    case StackVisitor::Frame::Function:
        return StackFrameFunctionCode;
    case StackVisitor::Frame::Global:
        return StackFrameGlobalCode;
    case StackVisitor::Frame::Native:
        ASSERT_NOT_REACHED();
        return StackFrameNativeCode;
    }
    RELEASE_ASSERT_NOT_REACHED();
    return StackFrameGlobalCode;
}

StackFrame::~StackFrame()
{
}

void StackFrame::computeLineAndColumn(unsigned& line, unsigned& column) const
{
    if (!codeBlock) {
        line = 0;
        column = 0;
        return;
    }

    int divot = 0;
    int unusedStartOffset = 0;
    int unusedEndOffset = 0;
    unsigned divotLine = 0;
    unsigned divotColumn = 0;
    expressionInfo(divot, unusedStartOffset, unusedEndOffset, divotLine, divotColumn);

    line = divotLine + lineOffset;
    column = divotColumn;
}

void StackFrame::expressionInfo(int& divot, int& startOffset, int& endOffset, unsigned& line, unsigned& column) const
{
    codeBlock->baselineVersion()->expressionRangeForBytecodeOffset(bytecodeOffset, divot, startOffset, endOffset, line, column);
    divot += characterOffset;
}

String StackFrame::toString(CallFrame* callFrame) const
{
    StringBuilder traceBuild;
    String functionName = friendlyFunctionName(callFrame);
    String sourceURL = friendlySourceURL();
    traceBuild.append(functionName);
    if (!sourceURL.isEmpty()) {
        if (!functionName.isEmpty())
            traceBuild.append('@');
        traceBuild.append(sourceURL);
        if (codeType != StackFrameNativeCode) {
            unsigned line;
            unsigned column;
            computeLineAndColumn(line, column);

            traceBuild.append(':');
            traceBuild.appendNumber(line);
            traceBuild.append(':');
            traceBuild.appendNumber(column);
        }
    }
    return traceBuild.toString().impl();
}

class GetStackTraceFunctor {
public:
    GetStackTraceFunctor(VM& vm, Vector<StackFrame>& results, size_t remainingCapacity)
        : m_vm(vm)
        , m_results(results)
        , m_remainingCapacityForFrameCapture(remainingCapacity)
    {
    }

    StackVisitor::Status operator()(StackVisitor& visitor)
    {
        VM& vm = m_vm;
        if (m_remainingCapacityForFrameCapture) {
			if (visitor->isJSFrame() && !visitor->codeBlock()->isBuiltinFunction()) {
				CodeBlock* codeBlock = visitor->codeBlock();
				StackFrame s = {
					Strong<JSObject>(vm, visitor->callee()),
					getStackFrameCodeType(visitor),
					Strong<ExecutableBase>(vm, codeBlock->ownerExecutable()),
					codeBlock,
					codeBlock->source(),
					0 /*see CodeBlock::expressionRangeForBytecodeOffset*/,
					0,
					0,
					visitor->bytecodeOffset(),
					visitor->sourceURL()
				};

				m_results.append(s);
			} else {
				StackFrame s = { Strong<JSObject>(vm, visitor->callee()), StackFrameNativeCode, Strong<ExecutableBase>(), nullptr, nullptr, 0, 0, 0, 0, String()};
				m_results.append(s);
			}

			m_remainingCapacityForFrameCapture--;
			return StackVisitor::Continue;
		}
		return StackVisitor::Done;
	}

private:
	VM& m_vm;
	Vector<StackFrame>& m_results;
	size_t m_remainingCapacityForFrameCapture;
};

void Interpreter::getStackTrace(Vector<StackFrame>& results, size_t maxStackSize)
{
	if(WTF::gLowMemory)
		return;

	VM& vm = m_vm;
	ASSERT(!vm.topCallFrame->isVMEntrySentinel());
	CallFrame* callFrame = vm.topCallFrame;
	if (!callFrame)
		return;

	GetStackTraceFunctor functor(vm, results, maxStackSize);
	callFrame->iterate(functor);
}


JSString* Interpreter:: stackTraceAsString(ExecState* exec, const Vector<StackFrame>& stackTrace)
{
    // FIXME: JSStringJoiner could be more efficient than StringBuilder here.
    StringBuilder builder;
    for (unsigned i = 0; i < stackTrace.size(); i++) {
        builder.append(String(stackTrace[i].toString(exec)));
        if (i != stackTrace.size() - 1)
            builder.append('\n');
    }
    return jsString(&exec->vm(), builder.toString());
}

class GetCatchHandlerFunctor {
public:
	GetCatchHandlerFunctor()
        : m_handler(0)
    {
    }

    HandlerInfo* handler() { return m_handler; }

    StackVisitor::Status operator()(StackVisitor& visitor)
    {
        visitor.unwindToMachineCodeBlockFrame();

        CodeBlock* codeBlock = visitor->codeBlock();
        if (!codeBlock)
            return StackVisitor::Continue;

        unsigned exceptionHandlerIndex;
        if (codeBlock->jitType() != JITCode::DFGJIT)
            exceptionHandlerIndex = visitor->callFrame()->bytecodeOffset();
        else
            exceptionHandlerIndex = visitor->callFrame()->callSiteIndex().bits();

        m_handler = codeBlock->handlerForIndex(exceptionHandlerIndex, CodeBlock::RequiredHandler::CatchHandler);
        if (m_handler)
            return StackVisitor::Done;

        return StackVisitor::Continue;
    }

private:
    HandlerInfo* m_handler;
};

class UnwindFunctor {
public:
    UnwindFunctor(CallFrame*& callFrame, bool isTermination, CodeBlock*& codeBlock, HandlerInfo*& handler)
        : m_callFrame(callFrame)
        , m_isTermination(isTermination)
        , m_codeBlock(codeBlock)
        , m_handler(handler)
    {
    }

    StackVisitor::Status operator()(StackVisitor& visitor)
    {
        visitor.unwindToMachineCodeBlockFrame();
        VM& vm = m_callFrame->vm();
        m_callFrame = visitor->callFrame();
        m_codeBlock = visitor->codeBlock();

        unsigned exceptionHandlerIndex;
        if (m_codeBlock->jitType() != JITCode::DFGJIT)
            exceptionHandlerIndex = m_callFrame->bytecodeOffset();
        else
            exceptionHandlerIndex = m_callFrame->callSiteIndex().bits();

        if (m_isTermination || !(m_handler = m_codeBlock ? m_codeBlock->handlerForIndex(exceptionHandlerIndex) : 0)) {
			if (!unwindCallFrame(visitor)) {
				if (LegacyProfiler* profiler = vm.enabledProfiler())
					profiler->exceptionUnwind(m_callFrame);
				return StackVisitor::Done;
			}
		} else
			return StackVisitor::Done;

		return StackVisitor::Continue;
	}

private:
	CallFrame*& m_callFrame;
	bool m_isTermination;
	CodeBlock*& m_codeBlock;
	HandlerInfo*& m_handler;
};

NEVER_INLINE HandlerInfo* Interpreter::unwind(CallFrame*& callFrame, Exception* exception)
{
    if (callFrame->isVMEntrySentinel()) {
        // This happens when we throw stack overflow in a function that is called
        // directly from callToJavaScript.  Stack overflow throws the exception in the
        // context of the caller.  In that case the caller is the sentinel frame.  The
        // right thing to do is to pretend that the exception is uncaught so that we
        // go to the uncaught exception handler, which returns through callToJavaScript.
        return 0;
    }

    CodeBlock* codeBlock = callFrame->codeBlock();
    bool isTermination = false;

    JSValue exceptionValue = exception->value();
    ASSERT(!exceptionValue.isEmpty());
    ASSERT(!exceptionValue.isCell() || exceptionValue.asCell());
    // This shouldn't be possible (hence the assertions), but we're already in the slowest of
    // slow cases, so let's harden against it anyway to be safe.
    if (exceptionValue.isEmpty() || (exceptionValue.isCell() && !exceptionValue.asCell()))
        exceptionValue = jsNull();

    if (exceptionValue.isObject())
        isTermination = isTerminatedExecutionException(exception);

    ASSERT(callFrame->vm().exception() && callFrame->vm().exception()->stack().size());

    Debugger* debugger = callFrame->dynamicGlobalObject()->debugger();
    if (debugger && !exception->didNotifyInspectorOfThrow()) {
		// We need to clear the exception here in order to see if a new exception happens.
		// Afterwards, the values are put back to continue processing this error.
		SuspendExceptionScope scope(&callFrame->vm());

        // This code assumes that if the debugger is enabled then there is no inlining.
        // If that assumption turns out to be false then we'll ignore the inlined call
        // frames.
        // https://bugs.webkit.org/show_bug.cgi?id=121754

		bool hasCatchHandler;
		if (isTermination)
			hasCatchHandler = false;
		else {
			GetCatchHandlerFunctor functor;
			callFrame->iterate(functor);
			HandlerInfo* handler = functor.handler();
			ASSERT(!handler || handler->isCatchHandler());
			hasCatchHandler = !!handler;
		}

        debugger->exception(callFrame, exceptionValue, hasCatchHandler);
        ASSERT(!callFrame->hadException());
    }
    exception->setDidNotifyInspectorOfThrow();

    // Calculate an exception handler vPC, unwinding call frames as necessary.
    HandlerInfo* handler = 0;
    JSGlobalData& vm = callFrame->vm();
    ASSERT(callFrame == vm.topCallFrame);
    UnwindFunctor functor(callFrame, isTermination, codeBlock, handler);
    callFrame->iterate(functor);
	if (!handler)
		return 0;

	if (LegacyProfiler* profiler = vm.enabledProfiler())
		profiler->exceptionUnwind(callFrame);

    return handler;
}

static inline JSValue checkedReturn(JSValue returnValue)
{
    ASSERT(returnValue);
    return returnValue;
}

static inline JSObject* checkedReturn(JSObject* returnValue)
{
    ASSERT(returnValue);
    return returnValue;
}

class SamplingScope {
public:
    SamplingScope(Interpreter* interpreter)
        : m_interpreter(interpreter)
    {
        interpreter->startSampling();
    }
    ~SamplingScope()
    {
        m_interpreter->stopSampling();
    }
private:
    Interpreter* m_interpreter;
};

static bool canGrowHeap(CallFrame* callFrame)
{
	if(UNLIKELY(WTF::gLowMemory))
		return false;

	if(LIKELY(WTF::MmapMonitor::instance().canGrow(0)))
		return true;

	VM& vm = callFrame->vm();

	if(vm.heap.shouldCollect())
		vm.heap.collect(false, true);

	return WTF::MmapMonitor::instance().canGrow(callFrame, callFrame->dynamicGlobalObject(), 0);
}

JSValue Interpreter::execute(ProgramExecutable* program, CallFrame* callFrame, JSObject* thisObj)
{
    SamplingScope samplingScope(this);

    JSScope* scope = thisObj->globalObject()->globalScope();
    JSGlobalData& vm = *scope->vm();

    ASSERT(!vm->exception());
    ASSERT(!vm.isCollectorBusy());

    if (vm.isCollectorBusy())
        return jsUndefined();

    StackStats::CheckPoint stackCheckPoint;
    const StackBounds& nativeStack = wtfThreadData().stack();
    StackPolicy policy(*this, nativeStack);
    if (!nativeStack.isSafeToRecurse(policy.requiredCapacity()))
        return throwStackOverflowError(callFrame);

    // First check if the "program" is actually just a JSON object. If so,
    // we'll handle the JSON object here. Else, we'll handle real JS code
    // below at failedJSONP.
    DynamicGlobalObjectScope globalObjectScope(vm, scope->globalObject());

    if(!canGrowHeap(callFrame))
    	return throwTerminatedExecutionException(callFrame);

    Vector<JSONPData> JSONPData;
    bool parseResult;
    const String programSource = program->source().toString();
    if (programSource.isNull())
        return jsUndefined();
    if (programSource.is8Bit()) {
        LiteralParser<LChar> literalParser(callFrame, programSource.characters8(), programSource.length(), JSONP);
        parseResult = literalParser.tryJSONPParse(JSONPData, scope->globalObject()->globalObjectMethodTable()->supportsRichSourceInfo(scope->globalObject()));
    } else {
        LiteralParser<UChar> literalParser(callFrame, programSource.characters16(), programSource.length(), JSONP);
        parseResult = literalParser.tryJSONPParse(JSONPData, scope->globalObject()->globalObjectMethodTable()->supportsRichSourceInfo(scope->globalObject()));
    }

    RETURN_IF_EXCEPTION(vm, JSValue());
    if (parseResult) {
        JSGlobalObject* globalObject = scope->globalObject();
        JSValue result;
        for (unsigned entry = 0; entry < JSONPData.size(); entry++) {
            Vector<JSONPPathEntry> JSONPPath;
            JSONPPath.swap(JSONPData[entry].m_path);
            JSValue JSONPValue = JSONPData[entry].m_value.get();
            if (JSONPPath.size() == 1 && JSONPPath[0].m_type == JSONPPathEntryTypeDeclareVar) {
				globalObject->addVar(callFrame, JSONPPath[0].m_pathEntryName);
				RETURN_IF_EXCEPTION(vm, JSValue());
				PutPropertySlot slot(globalObject);
				globalObject->methodTable()->put(globalObject, callFrame, JSONPPath[0].m_pathEntryName, JSONPValue, slot);
				RETURN_IF_EXCEPTION(vm, JSValue());
				result = jsUndefined();
				continue;
            }
            JSValue baseObject(globalObject);
            for (unsigned i = 0; i < JSONPPath.size() - 1; i++) {
                ASSERT(JSONPPath[i].m_type != JSONPPathEntryTypeDeclareVar);
                switch (JSONPPath[i].m_type) {
                case JSONPPathEntryTypeDot: {
                	if (i == 0) {
						RELEASE_ASSERT(baseObject == globalObject);

						class DoGet
						{
						public:
							DoGet(CallFrame* callFrame, Vector<JSONPPathEntry>& JSONPPath, unsigned i)
							: callFrame(callFrame)
							, JSONPPath(JSONPPath)
							, i(i)
							{
							}
							JSValue operator()(JSSegmentedVariableObject* scope) {
								PropertySlot slot(scope, PropertySlot::InternalMethodType::Get);
								if (scope->getPropertySlot(callFrame, JSONPPath[i].m_pathEntryName, slot))
									return slot.getValue(callFrame, JSONPPath[i].m_pathEntryName);
								return JSValue();
							};
						private:
							CallFrame* callFrame;
							Vector<JSONPPathEntry>& JSONPPath;
							const unsigned i;
						};

						DoGet doGet(callFrame, JSONPPath, i);

						JSValue result = doGet(globalObject->globalLexicalEnvironment());
						RETURN_IF_EXCEPTION(vm, JSValue());
						if (result) {
							baseObject = result;
							continue;
						}

						result = doGet(globalObject);
						RETURN_IF_EXCEPTION(vm, JSValue());
						if (result) {
							baseObject = result;
							continue;
						}

						if (entry)
							return vm.throwException(callFrame, createUndefinedVariableError(callFrame, JSONPPath[i].m_pathEntryName));
						goto failedJSONP;
					}

					baseObject = baseObject.get(callFrame, JSONPPath[i].m_pathEntryName);
					RETURN_IF_EXCEPTION(vm, JSValue());
                    continue;
                }
                case JSONPPathEntryTypeLookup: {
                    baseObject = baseObject.get(callFrame, static_cast<unsigned>(JSONPPath[i].m_pathIndex));
                    if (callFrame->hadException())
                        return jsUndefined();
                    continue;
                }
                default:
                    ASSERT_NOT_REACHED();
                    return jsUndefined();
                }
            }

            if (JSONPPath.size() == 1 && JSONPPath.last().m_type != JSONPPathEntryTypeLookup) {
                RELEASE_ASSERT(baseObject == globalObject);
                JSGlobalLexicalEnvironment* scope = globalObject->globalLexicalEnvironment();
                if (scope->hasProperty(callFrame, JSONPPath.last().m_pathEntryName))
                    baseObject = scope;
                RETURN_IF_EXCEPTION(vm, JSValue());
            }

            PutPropertySlot slot(baseObject);
            switch (JSONPPath.last().m_type) {
            case JSONPPathEntryTypeCall: {
                JSValue function = baseObject.get(callFrame, JSONPPath.last().m_pathEntryName);
                if (callFrame->hadException())
                    return jsUndefined();
                CallData callData;
                CallType callType = getCallData(function, callData);
                if (callType == CallType::None)
                    return callFrame->vm().throwException(callFrame, createNotAFunctionError(callFrame, function));
                MarkedArgumentBuffer jsonArg;
                jsonArg.append(JSONPValue);
                JSValue thisValue = JSONPPath.size() == 1 ? jsUndefined(): baseObject;
                JSONPValue = JSC::call(callFrame, function, callType, callData, thisValue, jsonArg);
                if (callFrame->hadException())
                    return jsUndefined();
                break;
            }
            case JSONPPathEntryTypeDot: {
                baseObject.put(callFrame, JSONPPath.last().m_pathEntryName, JSONPValue, slot);
                if (callFrame->hadException())
                    return jsUndefined();
                break;
            }
            case JSONPPathEntryTypeLookup: {
                baseObject.putByIndex(callFrame, JSONPPath.last().m_pathIndex, JSONPValue, slot.isStrictMode());
                if (callFrame->hadException())
                    return jsUndefined();
                break;
            }
            default:
                ASSERT_NOT_REACHED();
				return jsUndefined();
            }
            result = JSONPValue;
        }
        return result;
    }
failedJSONP:
	// If we get here, then we have already proven that the script is not a JSON
	// object.

	// Compile source to bytecode if necessary:

	ProgramCodeBlock* codeBlock;
	{
		CodeBlock* tempCodeBlock;
		JSObject* error = program->prepareForExecution<ProgramExecutable>(callFrame, 0, scope, CodeForCall, tempCodeBlock);
		if (UNLIKELY(error))
			return vm.throwException(callFrame, error);
		codeBlock = jsCast<ProgramCodeBlock*>(tempCodeBlock);
	}

#if ENABLE(JIT)
    if(!program->generatedJITCode())
        // Mixing Interpreter + JIT is not supported.
    	return throwOutOfMemoryError(callFrame);
#endif

    if (UNLIKELY(vm.watchdog && vm.watchdog->didFire(callFrame)))
    	return throwTerminatedExecutionException(callFrame);

    if (scope->structure()->isUncacheableDictionary())
        scope->flattenDictionaryObject(vm);

    // Push the call frame for this invocation:
    ASSERT(codeBlock->numParameters() == 1); // 1 parameter for 'this'.
    CallFrame* newCallFrame = m_registerFile.pushFrame(callFrame, codeBlock, 1, JSCallee::create(vm, scope->globalObject(), scope));
    if (UNLIKELY(!newCallFrame))
        return checkedReturn(throwStackOverflowError(callFrame));

    // Set the arguments for the callee:
    newCallFrame->setThisValue(thisObj);

    if (LegacyProfiler* profiler = vm.enabledProfiler())
        profiler->willExecute(callFrame, program->sourceURL(), program->lineNo());

    // Execute the code:
    JSValue result;
    {
        SamplingTool::CallRecord callRecord(m_sampler.get());
        Watchdog::Scope watchdogScope(vm.watchdog.get());

        result = program->generatedJITCode()->execute(&m_registerFile, newCallFrame, &vm);
    }

    if (LegacyProfiler* profiler = vm.enabledProfiler())
        profiler->didExecute(callFrame, program->sourceURL(), program->lineNo());

    m_registerFile.popFrame(newCallFrame);

    return checkedReturn(result);
}

JSValue Interpreter::executeCall(CallFrame* callFrame, JSObject* function, CallType callType, const CallData& callData, JSValue thisValue, const ArgList& args)
{
    JSGlobalData& vm = callFrame->vm();
    ASSERT(!callFrame->hadException());
    ASSERT(!vm.isCollectorBusy());
    if (vm.isCollectorBusy())
        return jsNull();

    StackStats::CheckPoint stackCheckPoint;
    const StackBounds& nativeStack = wtfThreadData().stack();
    StackPolicy policy(*this, nativeStack);
    if (!nativeStack.isSafeToRecurse(policy.requiredCapacity()))
        return throwStackOverflowError(callFrame);

    bool isJSCall = (callType == CallType::JS);
    JSScope* scope = 0;
    CodeBlock* newCodeBlock;
    size_t argsCount = 1 + args.size(); // implicit "this" parameter

    JSGlobalObject* globalObject;

    if (isJSCall) {
        scope = callData.js.scope;
        globalObject = scope->globalObject();
    } else {
        ASSERT(callType == CallType::Host);
        globalObject = function->globalObject();
    }

    DynamicGlobalObjectScope globalObjectScope(vm, globalObject);

    if(!canGrowHeap(callFrame))
    	return throwTerminatedExecutionException(callFrame);

    if (isJSCall) {
        // Compile the callee:
        JSObject* compileError = callData.js.functionExecutable->prepareForExecution<FunctionExecutable>(callFrame, jsCast<JSFunction*>(function), scope, CodeForCall, newCodeBlock);
        if (UNLIKELY(!!compileError))
            return checkedReturn(callFrame->vm().throwException(callFrame, compileError));
        if(!newCodeBlock)
        	return checkedReturn(createOutOfMemoryError(callFrame));
        newCodeBlock->m_shouldAlwaysBeInlined = false;
    } else
        newCodeBlock = 0;

    if (UNLIKELY(vm.watchdog && vm.watchdog->didFire(callFrame)))
    	return throwTerminatedExecutionException(callFrame);

    CallFrame* newCallFrame = m_registerFile.pushFrame(callFrame, newCodeBlock, argsCount, function);
    if (UNLIKELY(!newCallFrame))
        return checkedReturn(throwStackOverflowError(callFrame));

    // Set the arguments for the callee:
    newCallFrame->setThisValue(thisValue);
    for (size_t i = 0; i < args.size(); ++i)
        newCallFrame->setArgument(i, args.at(i));

    if (LegacyProfiler* profiler = vm.enabledProfiler())
        profiler->willExecute(callFrame, function);

    JSValue result;
    {
        SamplingTool::CallRecord callRecord(m_sampler.get(), !isJSCall);
        Watchdog::Scope watchdogScope(vm.watchdog.get());

        // Execute the code:
        if (isJSCall) {
#if ENABLE(LLINT_C_LOOP)
            result = LLInt::CLoop::execute(newCallFrame, llint_function_for_call_prologue);
#elif ENABLE(JIT)
            result = callData.js.functionExecutable->generatedJITCodeForCall()->execute(&m_registerFile, newCallFrame, &vm);
#endif // ENABLE(JIT)
        } else
            result = JSValue::decode(callData.native.function(newCallFrame));
    }

    if (LegacyProfiler* profiler = vm.enabledProfiler())
        profiler->didExecute(callFrame, function);

    m_registerFile.popFrame(newCallFrame);
    return checkedReturn(result);
}

JSObject* Interpreter::executeConstruct(CallFrame* callFrame, JSObject* constructor, ConstructType constructType, const ConstructData& constructData, const ArgList& args, JSValue newTarget)
{
    JSGlobalData& vm = callFrame->vm();
    ASSERT(!callFrame->hadException());
    ASSERT(!vm.isCollectorBusy());
    // We throw in this case because we have to return something "valid" but we're
    // already in an invalid state.
    if (vm.isCollectorBusy())
        return throwStackOverflowError(callFrame);

    StackStats::CheckPoint stackCheckPoint;
    const StackBounds& nativeStack = wtfThreadData().stack();
    StackPolicy policy(*this, nativeStack);
    if (!nativeStack.isSafeToRecurse(policy.requiredCapacity()))
        return throwStackOverflowError(callFrame);

    bool isJSConstruct = (constructType == ConstructType::JS);
    JSScope* scope = 0;
    CodeBlock* newCodeBlock;
    size_t argsCount = 1 + args.size(); // implicit "this" parameter

    JSGlobalObject* globalObject;

    if (isJSConstruct) {
        scope = constructData.js.scope;
        globalObject = scope->globalObject();
    } else {
        ASSERT(constructType == ConstructType::Host);
        globalObject = constructor->globalObject();
    }

    DynamicGlobalObjectScope globalObjectScope(vm, globalObject);

    if(!canGrowHeap(callFrame))
    	return throwTerminatedExecutionException(callFrame);

    if (isJSConstruct) {
        // Compile the callee:
        JSObject* compileError = constructData.js.functionExecutable->prepareForExecution<FunctionExecutable>(callFrame, jsCast<JSFunction*>(constructor), scope, CodeForConstruct, newCodeBlock);
        if (UNLIKELY(!!compileError))
            return checkedReturn(callFrame->vm().throwException(callFrame, compileError));
        if(!newCodeBlock)
        	return createOutOfMemoryError(callFrame);
        newCodeBlock->m_shouldAlwaysBeInlined = false;
    } else
        newCodeBlock = 0;

    if (UNLIKELY(vm.watchdog && vm.watchdog->didFire(callFrame)))
    	return throwTerminatedExecutionException(callFrame);

    CallFrame* newCallFrame = m_registerFile.pushFrame(callFrame, newCodeBlock, argsCount, constructor);
    if (UNLIKELY(!newCallFrame))
        return checkedReturn(throwStackOverflowError(callFrame));

    // Set the arguments for the callee:
    newCallFrame->setThisValue(newTarget);
    for (size_t i = 0; i < args.size(); ++i)
        newCallFrame->setArgument(i, args.at(i));

    if (LegacyProfiler* profiler = vm.enabledProfiler())
        profiler->willExecute(callFrame, constructor);

    JSValue result;
    {
        SamplingTool::CallRecord callRecord(m_sampler.get(), !isJSConstruct);
        Watchdog::Scope watchdogScope(vm.watchdog.get());

        // Execute the code.
        if (isJSConstruct) {
#if ENABLE(LLINT_C_LOOP)
            result = LLInt::CLoop::execute(newCallFrame, llint_function_for_construct_prologue);
#elif ENABLE(JIT)
            result = constructData.js.functionExecutable->generatedJITCodeForConstruct()->execute(&m_registerFile, newCallFrame, &vm);
#endif // ENABLE(JIT)
        } else {
            result = JSValue::decode(constructData.native.function(newCallFrame));
            if (!callFrame->hadException()) {
				ASSERT_WITH_MESSAGE(result.isObject(), "Host constructor returned non object.");
				if (!result.isObject())
					return throwTypeError(newCallFrame);
			}
        }
    }

    if (LegacyProfiler* profiler = vm.enabledProfiler())
        profiler->didExecute(callFrame, constructor);

    m_registerFile.popFrame(newCallFrame);

    if (callFrame->hadException())
        return 0;
    if(result.isObject())
    	return checkedReturn(asObject(result));
	return throwTypeError(callFrame);
}

CallFrameClosure Interpreter::prepareForRepeatCall(FunctionExecutable* functionExecutable, CallFrame* callFrame, JSFunction* function, int argumentCountIncludingThis, JSScope* scope)
{
    JSGlobalData& vm = *scope->vm();
    ASSERT(!vm->exception());
    
    if (vm.isCollectorBusy())
        return CallFrameClosure();

    StackStats::CheckPoint stackCheckPoint;
    const StackBounds& nativeStack = wtfThreadData().stack();
    StackPolicy policy(*this, nativeStack);
    if (!nativeStack.isSafeToRecurse(policy.requiredCapacity())) {
        throwStackOverflowError(callFrame);
        return CallFrameClosure();
    }

    if(!canGrowHeap(callFrame)){
    	throwTerminatedExecutionException(callFrame);
        return CallFrameClosure();
    }

    // Compile the callee:
    CodeBlock* newCodeBlock = 0;
    JSObject* error = functionExecutable->prepareForExecution<FunctionExecutable>(callFrame, function, scope, CodeForCall, newCodeBlock);
    if (error) {
    	callFrame->vm().throwException(callFrame, error);
        return CallFrameClosure();
    }
    if(!newCodeBlock){
        throwOutOfMemoryError(callFrame);
        return CallFrameClosure();
    }

    newCodeBlock->m_shouldAlwaysBeInlined = false;

    size_t argsCount = argumentCountIncludingThis;

    CallFrame* newCallFrame = m_registerFile.pushFrame(callFrame, newCodeBlock, argsCount, function);
    if (UNLIKELY(!newCallFrame)) {
        throwStackOverflowError(callFrame);
        return CallFrameClosure();
    }

    // Return the successful closure:
    CallFrameClosure result = { callFrame, newCallFrame, function, functionExecutable, &vm, scope, newCodeBlock->numParameters(), argumentCountIncludingThis };
    return result;
}

JSValue Interpreter::execute(CallFrameClosure& closure) 
{
    JSGlobalData& vm = *closure.globalData;
    SamplingScope samplingScope(this);

    ASSERT(!vm.isCollectorBusy());
    if (vm.isCollectorBusy())
        return jsNull();

    if(!canGrowHeap(closure.oldCallFrame))
    	return throwTerminatedExecutionException(closure.oldCallFrame);

    StackStats::CheckPoint stackCheckPoint;
    m_registerFile.validateFence(closure.newCallFrame, "BEFORE");
    m_registerFile.validateFence(closure.newCallFrame, "STEP 1");

    if (UNLIKELY(vm.watchdog && vm.watchdog->didFire(closure.oldCallFrame)))
    	return throwTerminatedExecutionException(closure.oldCallFrame);

    if (LegacyProfiler* profiler = vm.enabledProfiler())
        profiler->willExecute(closure.oldCallFrame, closure.function);

    // The code execution below may push more frames and point the topCallFrame
    // to those newer frames, or it may pop to the top frame to the caller of
    // the current repeat frame, or it may leave the top frame pointing to the
    // current repeat frame.
    //
    // Hence, we need to preserve the topCallFrame here ourselves before
    // repeating this call on a second callback function.

    TopCallFrameSetter topCallFrame(vm, closure.newCallFrame);

    // Execute the code:
    JSValue result;
    {
        SamplingTool::CallRecord callRecord(m_sampler.get());
        Watchdog::Scope watchdogScope(vm.watchdog.get());
        
#if ENABLE(LLINT_C_LOOP)
        result = LLInt::CLoop::execute(closure.newCallFrame, llint_function_for_call_prologue);
#elif ENABLE(JIT)
        result = closure.functionExecutable->generatedJITCodeForCall()->execute(&m_registerFile, closure.newCallFrame, &vm);
#endif // ENABLE(JIT)
    }

    if (LegacyProfiler* profiler = vm.enabledProfiler())
        profiler->didExecute(closure.oldCallFrame, closure.function);

    m_registerFile.validateFence(closure.newCallFrame, "AFTER");
    return checkedReturn(result);
}

void Interpreter::endRepeatCall(CallFrameClosure& closure)
{
    m_registerFile.popFrame(closure.newCallFrame);
}

JSValue Interpreter::execute(EvalExecutable* eval, CallFrame* callFrame, JSValue thisValue, JSScope* scope)
{
    JSGlobalData& vm = *scope->vm();
    SamplingScope samplingScope(this);

    ASSERT(scope->vm() == &callFrame->vm());
    ASSERT(!vm->exception());
    ASSERT(!vm.isCollectorBusy());
    if (vm.isCollectorBusy())
        return jsNull();

    DynamicGlobalObjectScope globalObjectScope(vm, scope->globalObject());

    if(!canGrowHeap(callFrame))
    	return throwTerminatedExecutionException(callFrame);

    StackStats::CheckPoint stackCheckPoint;
    const StackBounds& nativeStack = wtfThreadData().stack();
    StackPolicy policy(*this, nativeStack);
    if (!nativeStack.isSafeToRecurse(policy.requiredCapacity()))
        return throwStackOverflowError(callFrame);

    JSScope* variableObject;
    if ((!eval->codeBlock() || eval->codeBlock()->numVariables() || eval->codeBlock()->numberOfFunctionDecls()) && eval->isStrictMode()) {
        scope = StrictEvalActivation::create(callFrame, scope);
        variableObject = scope;
    } else {
		for (JSScope* node = scope; ; node = node->next()) {
			ASSERT(node);
            if (node->isGlobalObject()) {
				variableObject = node;
				break;
			}
            if (node->isJSLexicalEnvironment()) {
                JSLexicalEnvironment* lexicalEnvironment = jsCast<JSLexicalEnvironment*>(node);
                if (lexicalEnvironment->symbolTable()->scopeType() == SymbolTable::ScopeType::VarScope) {
					variableObject = node;
					break;
				}
            }
        }
    }

    // Compile the callee:
    EvalCodeBlock* codeBlock;
    {
        CodeBlock* tempCodeBlock;
		JSObject* compileError = eval->prepareForExecution<EvalExecutable>(callFrame, 0, scope, CodeForCall, tempCodeBlock);
		if (UNLIKELY(!!compileError))
			return vm.throwException(callFrame, compileError);
		codeBlock = jsCast<EvalCodeBlock*>(tempCodeBlock);
	}

#if ENABLE(JIT)
    if (!eval->generatedJITCode())
        // Mixing Interpreter + JIT is not supported.
    	return throwOutOfMemoryError(callFrame);
#endif

    unsigned numVariables = codeBlock->numVariables();
    int numFunctions = codeBlock->numberOfFunctionDecls();

    if (variableObject->structure()->isUncacheableDictionary())
        variableObject->flattenDictionaryObject(vm);

    // We can't declare a "var"/"function" that overwrites a global "let"/"const"/"class" in a sloppy-mode eval.
    if (variableObject->isGlobalObject() && !eval->isStrictMode() && (numVariables || numFunctions)) {
        JSGlobalLexicalEnvironment* globalLexicalEnvironment = jsCast<JSGlobalObject*>(variableObject)->globalLexicalEnvironment();
        for (unsigned i = 0; i < numVariables; ++i) {
            const Identifier& ident = codeBlock->variable(i);
            PropertySlot slot(globalLexicalEnvironment, PropertySlot::InternalMethodType::VMInquiry);
            if (JSGlobalLexicalEnvironment::getOwnPropertySlot(globalLexicalEnvironment, callFrame, ident, slot)) {
                return checkedReturn(callFrame->vm().throwException(callFrame,
                    createTypeError(callFrame, makeString("Can't create duplicate global variable in eval: '", String(ident.impl()), "'"))));
            }
        }

        for (int i = 0; i < numFunctions; ++i) {
            FunctionExecutable* function = codeBlock->functionDecl(i);
            PropertySlot slot(globalLexicalEnvironment, PropertySlot::InternalMethodType::VMInquiry);
            if (JSGlobalLexicalEnvironment::getOwnPropertySlot(globalLexicalEnvironment, callFrame, function->name(), slot)) {
                return checkedReturn(callFrame->vm().throwException(callFrame,
                    createTypeError(callFrame, makeString("Can't create duplicate global variable in eval: '", String(function->name().impl()), "'"))));
            }
        }
    }

    if (numVariables || numFunctions) {
        // Scope for BatchedTransitionOptimizer
        BatchedTransitionOptimizer optimizer(vm, variableObject);
        if (variableObject->next() && !eval->isStrictMode())
        	variableObject->globalObject()->varInjectionWatchpoint()->fireAll(vm);

        for (unsigned i = 0; i < numVariables; ++i) {
            const Identifier& ident = codeBlock->variable(i);
            bool hasProperty = variableObject->hasProperty(callFrame, ident);
            if(UNLIKELY(vm.exception()))
            	return jsUndefined();
            if (!hasProperty) {
                PutPropertySlot slot(variableObject);
                variableObject->methodTable()->put(variableObject, callFrame, ident, jsUndefined(), slot);
                if(UNLIKELY(vm.exception()))
                	return jsUndefined();
            }
        }

        for (int i = 0; i < numFunctions; ++i) {
            FunctionExecutable* function = codeBlock->functionDecl(i);
            PutPropertySlot slot(variableObject);
            variableObject->methodTable()->put(variableObject, callFrame, function->name(), JSFunction::create(vm, function, scope), slot);
            if(UNLIKELY(vm.exception()))
            	return jsUndefined();
        }
    }

    if (UNLIKELY(vm.watchdog && vm.watchdog->didFire(callFrame)))
    	return throwTerminatedExecutionException(callFrame);

    // Push the frame:
    ASSERT(codeBlock->numParameters() == 1); // 1 parameter for 'this'.
    CallFrame* newCallFrame = m_registerFile.pushFrame(callFrame, codeBlock, 1, JSCallee::create(vm, scope->globalObject(), scope));
    if (UNLIKELY(!newCallFrame))
        return checkedReturn(throwStackOverflowError(callFrame));

    // Set the arguments for the callee:
    newCallFrame->setThisValue(thisValue);

    if (LegacyProfiler* profiler = vm.enabledProfiler())
        profiler->willExecute(callFrame, eval->sourceURL(), eval->lineNo());

    // Execute the code:
    JSValue result;
    {
        SamplingTool::CallRecord callRecord(m_sampler.get());
        Watchdog::Scope watchdogScope(vm.watchdog.get());

#if ENABLE(LLINT_C_LOOP)
        result = LLInt::CLoop::execute(newCallFrame, llint_eval_prologue);
#elif ENABLE(JIT)
        result = eval->generatedJITCode()->execute(&m_registerFile, newCallFrame, &vm);
#endif // ENABLE(JIT)
    }

    if (LegacyProfiler* profiler = vm.enabledProfiler())
        profiler->didExecute(callFrame, eval->sourceURL(), eval->lineNo());

    m_registerFile.popFrame(newCallFrame);
    return checkedReturn(result);
}

JSValue Interpreter::execute(ModuleProgramExecutable* executable, CallFrame* callFrame, JSModuleEnvironment* scope)
{
    VM& vm = *scope->vm();
    SamplingScope samplingScope(this);

    ASSERT(scope->vm() == &callFrame->vm());
    ASSERT(!vm.exception());
    ASSERT(!vm.isCollectorBusy());
    RELEASE_ASSERT(vm.currentThreadIsHoldingAPILock());
    if (vm.isCollectorBusy())
        return jsNull();

    StackStats::CheckPoint stackCheckPoint;
    const StackBounds& nativeStack = wtfThreadData().stack();
    StackPolicy policy(*this, nativeStack);
    if (!nativeStack.isSafeToRecurse(policy.requiredCapacity()))
        return throwStackOverflowError(callFrame);

    DynamicGlobalObjectScope globalObjectScope(vm, scope->globalObject());

    if(!canGrowHeap(callFrame))
    	return throwTerminatedExecutionException(callFrame);

    ModuleProgramCodeBlock* codeBlock;
    {
		CodeBlock* tempCodeBlock;
		JSObject* compileError = executable->prepareForExecution<ModuleProgramExecutable>(callFrame, 0, scope, CodeForCall, tempCodeBlock);
		if (UNLIKELY(!!compileError))
			return checkedReturn(callFrame->vm().throwException(callFrame, compileError));
		codeBlock = jsCast<ModuleProgramCodeBlock*>(tempCodeBlock);
    }

#if ENABLE(JIT)
    if(!executable->generatedJITCode())
        // Mixing Interpreter + JIT is not supported.
    	return throwOutOfMemoryError(callFrame);
#endif

    if (UNLIKELY(vm.watchdog && vm.watchdog->didFire(callFrame)))
        return throwTerminatedExecutionException(callFrame);

    // Push the frame:
    ASSERT(codeBlock->numParameters() == 1); // 1 parameter for 'this'.
    CallFrame* newCallFrame = m_registerFile.pushFrame(callFrame, codeBlock, 1, JSCallee::create(vm, scope->globalObject(), scope));
    if (UNLIKELY(!newCallFrame))
        return checkedReturn(throwStackOverflowError(callFrame));

    // The |this| of the module is always `undefined`.
    // http://www.ecma-international.org/ecma-262/6.0/#sec-module-environment-records-hasthisbinding
    // http://www.ecma-international.org/ecma-262/6.0/#sec-module-environment-records-getthisbinding
    newCallFrame->setThisValue(jsUndefined());

    if (LegacyProfiler* profiler = vm.enabledProfiler())
        profiler->willExecute(callFrame, executable->sourceURL(), executable->lineNo());

    // Execute the code:
    JSValue result;
    {
        SamplingTool::CallRecord callRecord(m_sampler.get());
        result = executable->generatedJITCode()->execute(&m_registerFile, newCallFrame, &vm);
    }

    if (LegacyProfiler* profiler = vm.enabledProfiler())
        profiler->didExecute(callFrame, executable->sourceURL(), executable->lineNo());

    return checkedReturn(result);
}

NEVER_INLINE void Interpreter::debug(CallFrame* callFrame, DebugHookID debugHookID)
{
    Debugger* debugger = callFrame->dynamicGlobalObject()->debugger();
    if (!debugger)
        return;

    ASSERT(callFrame->codeBlock()->hasDebuggerRequests());
    ASSERT(!callFrame->hadException());

    switch (debugHookID) {
        case DidEnterCallFrame:
            debugger->callEvent(callFrame);
            break;
        case WillLeaveCallFrame:
            debugger->returnEvent(callFrame);
            break;
        case WillExecuteStatement:
            debugger->atStatement(callFrame);
            break;
        case WillExecuteProgram:
            debugger->willExecuteProgram(callFrame);
            break;
        case DidExecuteProgram:
            debugger->didExecuteProgram(callFrame);
            break;
        case DidReachBreakpoint:
            debugger->didReachBreakpoint(callFrame);
            break;
    }
    ASSERT(!callFrame->hadException());
}

void Interpreter::enableSampler()
{
#if ENABLE(OPCODE_SAMPLING)
    if (!m_sampler) {
        m_sampler = adoptPtr(new SamplingTool(this));
        m_sampler->setup();
    }
#endif
}
void Interpreter::dumpSampleData(ExecState* exec)
{
#if ENABLE(OPCODE_SAMPLING)
    if (m_sampler)
        m_sampler->dump(exec);
#else
    UNUSED_PARAM(exec);
#endif
}
void Interpreter::startSampling()
{
#if ENABLE(SAMPLING_THREAD)
    if (!m_sampleEntryDepth)
        SamplingThread::start();

    m_sampleEntryDepth++;
#endif
}
void Interpreter::stopSampling()
{
#if ENABLE(SAMPLING_THREAD)
    m_sampleEntryDepth--;
    if (!m_sampleEntryDepth)
        SamplingThread::stop();
#endif
}

} // namespace JSC
