/*

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

 * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>

 *

 * 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.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``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 INC. OR

 * 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"

#if ENABLE(JIT)

#if USE(JSVALUE32_64)

#include "JIT.h"

#include "JITInlineMethods.h"

#include "JITStubCall.h"

#include "JSArray.h"

#include "JSCell.h"

#include "JSFunction.h"

#include "JSPropertyNameIterator.h"

#include "LinkBuffer.h"

namespace JSC {

void JIT::privateCompileCTIMachineTrampolines(RefPtr<ExecutablePool>* executablePool, JSGlobalData* globalData, TrampolineStructure *trampolines)

{

#if ENABLE(JIT_OPTIMIZE_MOD)

    Label softModBegin = align();

    softModulo();

#endif

#if ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS)

    // (1) This function provides fast property access for string length

    Label stringLengthBegin = align();

    // regT0 holds payload, regT1 holds tag

    Jump string_failureCases1 = branch32(NotEqual, regT1, Imm32(JSValue::CellTag));

    Jump string_failureCases2 = branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsStringVPtr));

    // Checks out okay! - get the length from the Ustring.

    load32(Address(regT0, OBJECT_OFFSETOF(JSString, m_length)), regT2);

    Jump string_failureCases3 = branch32(Above, regT2, Imm32(INT_MAX));

    move(regT2, regT0);

    move(Imm32(JSValue::Int32Tag), regT1);

    ret();

#endif

    JumpList callLinkFailures;

    // (2) Trampolines for the slow cases of op_call / op_call_eval / op_construct.

#if ENABLE(JIT_OPTIMIZE_CALL)

    // VirtualCallLink Trampoline

    // regT0 holds callee, regT1 holds argCount.  regT2 will hold the FunctionExecutable.

    Label virtualCallLinkBegin = align();

    compileOpCallInitializeCallFrame();

    preserveReturnAddressAfterCall(regT3);

    emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);

    restoreArgumentReference();

    Call callLazyLinkCall = call();

    callLinkFailures.append(branchTestPtr(Zero, regT0));

    restoreReturnAddressBeforeReturn(regT3);

    emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT1);

    jump(regT0);

    // VirtualConstructLink Trampoline

    // regT0 holds callee, regT1 holds argCount.  regT2 will hold the FunctionExecutable.

    Label virtualConstructLinkBegin = align();

    compileOpCallInitializeCallFrame();

    preserveReturnAddressAfterCall(regT3);

    emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);

    restoreArgumentReference();

    Call callLazyLinkConstruct = call();

    restoreReturnAddressBeforeReturn(regT3);

    callLinkFailures.append(branchTestPtr(Zero, regT0));

    emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT1);

    jump(regT0);

#endif // ENABLE(JIT_OPTIMIZE_CALL)

    // VirtualCall Trampoline

    // regT0 holds callee, regT1 holds argCount.  regT2 will hold the FunctionExecutable.

    Label virtualCallBegin = align();

    compileOpCallInitializeCallFrame();

    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);

    Jump hasCodeBlock3 = branch32(GreaterThanOrEqual, Address(regT2, OBJECT_OFFSETOF(FunctionExecutable, m_numParametersForCall)), Imm32(0));

    preserveReturnAddressAfterCall(regT3);

    restoreArgumentReference();

    Call callCompileCall = call();

    callLinkFailures.append(branchTestPtr(Zero, regT0));

    emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT1);

    restoreReturnAddressBeforeReturn(regT3);

    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);

    hasCodeBlock3.link(this);

    loadPtr(Address(regT2, OBJECT_OFFSETOF(FunctionExecutable, m_jitCodeForCallWithArityCheck)), regT0);

    jump(regT0);

    // VirtualConstruct Trampoline

    // regT0 holds callee, regT1 holds argCount.  regT2 will hold the FunctionExecutable.

    Label virtualConstructBegin = align();

    compileOpCallInitializeCallFrame();

    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);

    Jump hasCodeBlock4 = branch32(GreaterThanOrEqual, Address(regT2, OBJECT_OFFSETOF(FunctionExecutable, m_numParametersForConstruct)), Imm32(0));

    preserveReturnAddressAfterCall(regT3);

    restoreArgumentReference();

    Call callCompileCconstruct = call();

    callLinkFailures.append(branchTestPtr(Zero, regT0));

    emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT1);

    restoreReturnAddressBeforeReturn(regT3);

    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);

    hasCodeBlock4.link(this);

    loadPtr(Address(regT2, OBJECT_OFFSETOF(FunctionExecutable, m_jitCodeForConstructWithArityCheck)), regT0);

    jump(regT0);

    // If the parser fails we want to be able to be able to keep going,

    // So we handle this as a parse failure.

    callLinkFailures.link(this);

    emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT1);

    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);

    restoreReturnAddressBeforeReturn(regT1);

    move(ImmPtr(&globalData->exceptionLocation), regT2);

    storePtr(regT1, regT2);

    poke(callFrameRegister, 1 + OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));

    poke(ImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()));

    ret();

    // NativeCall Trampoline

    Label nativeCallThunk = privateCompileCTINativeCall(globalData);    

    Label nativeConstructThunk = privateCompileCTINativeCall(globalData, true);    

#if ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS)

    Call string_failureCases1Call = makeTailRecursiveCall(string_failureCases1);

    Call string_failureCases2Call = makeTailRecursiveCall(string_failureCases2);

    Call string_failureCases3Call = makeTailRecursiveCall(string_failureCases3);

#endif

    // All trampolines constructed! copy the code, link up calls, and set the pointers on the Machine object.

    LinkBuffer patchBuffer(this, m_globalData->executableAllocator.poolForSize(m_assembler.size()));

#if ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS)

    patchBuffer.link(string_failureCases1Call, FunctionPtr(cti_op_get_by_id_string_fail));

    patchBuffer.link(string_failureCases2Call, FunctionPtr(cti_op_get_by_id_string_fail));

    patchBuffer.link(string_failureCases3Call, FunctionPtr(cti_op_get_by_id_string_fail));

#endif

#if ENABLE(JIT_OPTIMIZE_CALL)

    patchBuffer.link(callLazyLinkCall, FunctionPtr(cti_vm_lazyLinkCall));

    patchBuffer.link(callLazyLinkConstruct, FunctionPtr(cti_vm_lazyLinkConstruct));

#endif

    patchBuffer.link(callCompileCall, FunctionPtr(cti_op_call_jitCompile));

    patchBuffer.link(callCompileCconstruct, FunctionPtr(cti_op_construct_jitCompile));

    CodeRef finalCode = patchBuffer.finalizeCode();

    *executablePool = finalCode.m_executablePool;

    trampolines->ctiVirtualCall = trampolineAt(finalCode, virtualCallBegin);

    trampolines->ctiVirtualConstruct = trampolineAt(finalCode, virtualConstructBegin);

    trampolines->ctiNativeCall = trampolineAt(finalCode, nativeCallThunk);

    trampolines->ctiNativeConstruct = trampolineAt(finalCode, nativeConstructThunk);

#if ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS)

    trampolines->ctiStringLengthTrampoline = trampolineAt(finalCode, stringLengthBegin);

#endif

#if ENABLE(JIT_OPTIMIZE_CALL)

    trampolines->ctiVirtualCallLink = trampolineAt(finalCode, virtualCallLinkBegin);

    trampolines->ctiVirtualConstructLink = trampolineAt(finalCode, virtualConstructLinkBegin);

#endif

#if ENABLE(JIT_OPTIMIZE_MOD)

    trampolines->ctiSoftModulo = trampolineAt(finalCode, softModBegin);

#endif

}

JIT::Label JIT::privateCompileCTINativeCall(JSGlobalData* globalData, bool isConstruct)

{

    int executableOffsetToFunction = isConstruct ? OBJECT_OFFSETOF(NativeExecutable, m_constructor) : OBJECT_OFFSETOF(NativeExecutable, m_function);

    Label nativeCallThunk = align();

#if CPU(X86)

    // Load caller frame's scope chain into this callframe so that whatever we call can

    // get to its global data.

    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT0);

    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT0);

    emitPutToCallFrameHeader(regT1, RegisterFile::ScopeChain);

    peek(regT1);

    emitPutToCallFrameHeader(regT1, RegisterFile::ReturnPC);

    // Calling convention:      f(ecx, edx, ...);

    // Host function signature: f(ExecState*);

    move(callFrameRegister, X86Registers::ecx);

    subPtr(Imm32(16 - sizeof(void*)), stackPointerRegister); // Align stack after call.

    // call the function

    emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, regT1);

    loadPtr(Address(regT1, OBJECT_OFFSETOF(JSFunction, m_executable)), regT1);

    move(regT0, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.

    call(Address(regT1, executableOffsetToFunction));

    addPtr(Imm32(16 - sizeof(void*)), stackPointerRegister);

#elif CPU(ARM)

    // Load caller frame's scope chain into this callframe so that whatever we call can

    // get to its global data.

    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT2);

    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT2);

    emitPutToCallFrameHeader(regT1, RegisterFile::ScopeChain);

    preserveReturnAddressAfterCall(regT3); // Callee preserved

    emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);

    // Calling convention:      f(r0 == regT0, r1 == regT1, ...);

    // Host function signature: f(ExecState*);

    move(callFrameRegister, ARMRegisters::r0);

    // call the function

    emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, ARMRegisters::r1);

    move(regT2, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.

    loadPtr(Address(ARMRegisters::r1, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);

    call(Address(regT2, executableOffsetToFunction));

    restoreReturnAddressBeforeReturn(regT3);

#elif ENABLE(JIT_OPTIMIZE_NATIVE_CALL)

#error "JIT_OPTIMIZE_NATIVE_CALL not yet supported on this platform."

#else

    UNUSED_PARAM(executableOffsetToFunction);

    breakpoint();

#endif // CPU(X86)

    // Check for an exception

    Jump sawException = branch32(NotEqual, AbsoluteAddress(reinterpret_cast<char*>(&globalData->exception) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), Imm32(JSValue::EmptyValueTag));

    // Return.

    ret();

    // Handle an exception

    sawException.link(this);

    // Grab the return address.

    preserveReturnAddressAfterCall(regT1);

    move(ImmPtr(&globalData->exceptionLocation), regT2);

    storePtr(regT1, regT2);

    poke(callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));

    // Set the return address.

    move(ImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()), regT1);

    restoreReturnAddressBeforeReturn(regT1);

    ret();

    return nativeCallThunk;

}

JIT::CodePtr JIT::privateCompileCTINativeCall(PassRefPtr<ExecutablePool> executablePool, JSGlobalData* globalData, NativeFunction func)

{

    Call nativeCall;

    Label nativeCallThunk = align();

#if CPU(X86)

    // Load caller frame's scope chain into this callframe so that whatever we call can

    // get to its global data.

    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT0);

    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT0);

    emitPutToCallFrameHeader(regT1, RegisterFile::ScopeChain);

    peek(regT1);

    emitPutToCallFrameHeader(regT1, RegisterFile::ReturnPC);

    // Calling convention:      f(ecx, edx, ...);

    // Host function signature: f(ExecState*);

    move(callFrameRegister, X86Registers::ecx);

    subPtr(Imm32(16 - sizeof(void*)), stackPointerRegister); // Align stack after call.

    move(regT0, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.

    // call the function

    nativeCall = call();

    addPtr(Imm32(16 - sizeof(void*)), stackPointerRegister);

#elif CPU(ARM)

    // Load caller frame's scope chain into this callframe so that whatever we call can

    // get to its global data.

    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT2);

    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT2);

    emitPutToCallFrameHeader(regT1, RegisterFile::ScopeChain);

    preserveReturnAddressAfterCall(regT3); // Callee preserved

    emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);

    // Calling convention:      f(r0 == regT0, r1 == regT1, ...);

    // Host function signature: f(ExecState*);

    move(callFrameRegister, ARMRegisters::r0);

    emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, ARMRegisters::r1);

    move(regT2, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.

    loadPtr(Address(ARMRegisters::r1, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);

    // call the function

    nativeCall = call();

    restoreReturnAddressBeforeReturn(regT3);

#elif ENABLE(JIT_OPTIMIZE_NATIVE_CALL)

#error "JIT_OPTIMIZE_NATIVE_CALL not yet supported on this platform."

#else

    breakpoint();

#endif // CPU(X86)

    // Check for an exception

    Jump sawException = branch32(NotEqual, AbsoluteAddress(reinterpret_cast<char*>(&globalData->exception) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), Imm32(JSValue::EmptyValueTag));

    // Return.

    ret();

    // Handle an exception

    sawException.link(this);

    // Grab the return address.

    preserveReturnAddressAfterCall(regT1);

    move(ImmPtr(&globalData->exceptionLocation), regT2);

    storePtr(regT1, regT2);

    poke(callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));

    // Set the return address.

    move(ImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()), regT1);

    restoreReturnAddressBeforeReturn(regT1);

    ret();

    // All trampolines constructed! copy the code, link up calls, and set the pointers on the Machine object.

    LinkBuffer patchBuffer(this, executablePool);

    patchBuffer.link(nativeCall, FunctionPtr(func));

    CodeRef finalCode = patchBuffer.finalizeCode();

    return trampolineAt(finalCode, nativeCallThunk);

}

void JIT::emit_op_mov(Instruction* currentInstruction)

{

    unsigned dst = currentInstruction[1].u.operand;

    unsigned src = currentInstruction[2].u.operand;

    if (m_codeBlock->isConstantRegisterIndex(src))

        emitStore(dst, getConstantOperand(src));

    else {

        emitLoad(src, regT1, regT0);

        emitStore(dst, regT1, regT0);

        map(m_bytecodeOffset + OPCODE_LENGTH(op_mov), dst, regT1, regT0);

    }

}

void JIT::emit_op_end(Instruction* currentInstruction)

{

    if (m_codeBlock->needsFullScopeChain())

        JITStubCall(this, cti_op_end).call();

    ASSERT(returnValueRegister != callFrameRegister);

    emitLoad(currentInstruction[1].u.operand, regT1, regT0);

    restoreReturnAddressBeforeReturn(Address(callFrameRegister, RegisterFile::ReturnPC * static_cast<int>(sizeof(Register))));

    ret();

}

void JIT::emit_op_jmp(Instruction* currentInstruction)

{

    unsigned target = currentInstruction[1].u.operand;

    addJump(jump(), target);

}

void JIT::emit_op_loop_if_lesseq(Instruction* currentInstruction)

{

    unsigned op1 = currentInstruction[1].u.operand;

    unsigned op2 = currentInstruction[2].u.operand;

    unsigned target = currentInstruction[3].u.operand;

    emitTimeoutCheck();

    if (isOperandConstantImmediateInt(op1)) {

        emitLoad(op2, regT1, regT0);

        addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));

        addJump(branch32(GreaterThanOrEqual, regT0, Imm32(getConstantOperand(op1).asInt32())), target);

        return;

    }

    if (isOperandConstantImmediateInt(op2)) {

        emitLoad(op1, regT1, regT0);

        addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));

        addJump(branch32(LessThanOrEqual, regT0, Imm32(getConstantOperand(op2).asInt32())), target);

        return;

    }

    emitLoad2(op1, regT1, regT0, op2, regT3, regT2);

    addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));

    addSlowCase(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));

    addJump(branch32(LessThanOrEqual, regT0, regT2), target);

}

void JIT::emitSlow_op_loop_if_lesseq(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)

{

    unsigned op1 = currentInstruction[1].u.operand;

    unsigned op2 = currentInstruction[2].u.operand;

    unsigned target = currentInstruction[3].u.operand;

    if (!isOperandConstantImmediateInt(op1) && !isOperandConstantImmediateInt(op2))

        linkSlowCase(iter); // int32 check

    linkSlowCase(iter); // int32 check

    JITStubCall stubCall(this, cti_op_loop_if_lesseq);

    stubCall.addArgument(op1);

    stubCall.addArgument(op2);

    stubCall.call();

    emitJumpSlowToHot(branchTest32(NonZero, regT0), target);

}

void JIT::emit_op_new_object(Instruction* currentInstruction)

{

    JITStubCall(this, cti_op_new_object).call(currentInstruction[1].u.operand);

}

void JIT::emit_op_instanceof(Instruction* currentInstruction)

{

    unsigned dst = currentInstruction[1].u.operand;

    unsigned value = currentInstruction[2].u.operand;

    unsigned baseVal = currentInstruction[3].u.operand;

    unsigned proto = currentInstruction[4].u.operand;

    // Load the operands into registers.

    // We use regT0 for baseVal since we will be done with this first, and we can then use it for the result.

    emitLoadPayload(value, regT2);

    emitLoadPayload(baseVal, regT0);

    emitLoadPayload(proto, regT1);

    // Check that value, baseVal, and proto are cells.

    emitJumpSlowCaseIfNotJSCell(value);

    emitJumpSlowCaseIfNotJSCell(baseVal);

    emitJumpSlowCaseIfNotJSCell(proto);

    // Check that baseVal 'ImplementsDefaultHasInstance'.

    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSCell, m_structure)), regT0);

    addSlowCase(branchTest8(Zero, Address(regT0, OBJECT_OFFSETOF(Structure, m_typeInfo.m_flags)), Imm32(ImplementsDefaultHasInstance)));

    // Optimistically load the result true, and start looping.

    // Initially, regT1 still contains proto and regT2 still contains value.

    // As we loop regT2 will be updated with its prototype, recursively walking the prototype chain.

    move(Imm32(JSValue::TrueTag), regT0);

    Label loop(this);

    // Load the prototype of the cell in regT2.  If this is equal to regT1 - WIN!

    // Otherwise, check if we've hit null - if we have then drop out of the loop, if not go again.

    loadPtr(Address(regT2, OBJECT_OFFSETOF(JSCell, m_structure)), regT2);

    load32(Address(regT2, OBJECT_OFFSETOF(Structure, m_prototype) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), regT2);

    Jump isInstance = branchPtr(Equal, regT2, regT1);

    branchTest32(NonZero, regT2).linkTo(loop, this);

    // We get here either by dropping out of the loop, or if value was not an Object.  Result is false.

    move(Imm32(JSValue::FalseTag), regT0);

    // isInstance jumps right down to here, to skip setting the result to false (it has already set true).

    isInstance.link(this);

    emitStoreBool(dst, regT0);

}

void JIT::emitSlow_op_instanceof(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)

{

    unsigned dst = currentInstruction[1].u.operand;

    unsigned value = currentInstruction[2].u.operand;

    unsigned baseVal = currentInstruction[3].u.operand;

    unsigned proto = currentInstruction[4].u.operand;

    linkSlowCaseIfNotJSCell(iter, value);

    linkSlowCaseIfNotJSCell(iter, baseVal);

    linkSlowCaseIfNotJSCell(iter, proto);

    linkSlowCase(iter);

    JITStubCall stubCall(this, cti_op_instanceof);

    stubCall.addArgument(value);

    stubCall.addArgument(baseVal);

    stubCall.addArgument(proto);

    stubCall.call(dst);

}

void JIT::emit_op_new_func(Instruction* currentInstruction)

{

    JITStubCall stubCall(this, cti_op_new_func);

    stubCall.addArgument(ImmPtr(m_codeBlock->functionDecl(currentInstruction[2].u.operand)));

    stubCall.call(currentInstruction[1].u.operand);

}

void JIT::emit_op_get_global_var(Instruction* currentInstruction)

{

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

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

    ASSERT(globalObject->isGlobalObject());

    int index = currentInstruction[3].u.operand;

    loadPtr(&globalObject->d()->registers, regT2);

    emitLoad(index, regT1, regT0, regT2);

    emitStore(dst, regT1, regT0);

    map(m_bytecodeOffset + OPCODE_LENGTH(op_get_global_var), dst, regT1, regT0);

}