/*

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

#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 {

#if !USE(JSVALUE32_64)

#define RECORD_JUMP_TARGET(targetOffset) \

   do { m_labels[m_bytecodeOffset + (targetOffset)].used(); } while (false)

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)

    // (2) The second function provides fast property access for string length

    Label stringLengthBegin = align();

    // Check eax is a string

    Jump string_failureCases1 = emitJumpIfNotJSCell(regT0);

    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)), regT0);

    Jump string_failureCases3 = branch32(Above, regT0, Imm32(JSImmediate::maxImmediateInt));

    // regT0 contains a 64 bit value (is positive, is zero extended) so we don't need sign extend here.

    emitFastArithIntToImmNoCheck(regT0, regT0);

    ret();

#endif

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

    COMPILE_ASSERT(sizeof(CodeType) == 4, CodeTypeEnumMustBe32Bit);

    // VirtualCallLink Trampoline

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

    JumpList callLinkFailures;

    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();

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

    restoreReturnAddressBeforeReturn(regT3);

    emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT1);

    jump(regT0);

    // 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 callCompileConstruct = 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(callCompileConstruct, FunctionPtr(cti_op_construct_jitCompile));

    CodeRef finalCode = patchBuffer.finalizeCode();

    *executablePool = finalCode.m_executablePool;

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

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

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

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

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

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

#if ENABLE(JIT_OPTIMIZE_MOD)

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

#endif

#if ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS)

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

#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_64)

    // 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(edi, esi, edx, ecx, ...);

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

    move(callFrameRegister, X86Registers::edi);

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

    emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, X86Registers::esi);

    loadPtr(Address(X86Registers::esi, OBJECT_OFFSETOF(JSFunction, m_executable)), X86Registers::r9);

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

    call(Address(X86Registers::r9, 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);

    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 CPU(MIPS)

    // 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);

    preserveReturnAddressAfterCall(regT3); // Callee preserved

    emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);

    // Calling convention:      f(a0, a1, a2, a3);

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

    // Allocate stack space for 16 bytes (8-byte aligned)

    // 16 bytes (unused) for 4 arguments

    subPtr(Imm32(16), stackPointerRegister);

    // Setup arg0

    move(callFrameRegister, MIPSRegisters::a0);

    // Call

    emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, MIPSRegisters::a2);

    loadPtr(Address(MIPSRegisters::a2, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);

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

    call(Address(regT2, executableOffsetToFunction));

    // Restore stack space

    addPtr(Imm32(16), stackPointerRegister);

    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

    // Check for an exception

    loadPtr(&(globalData->exception), regT2);

    Jump exceptionHandler = branchTestPtr(NonZero, regT2);

    // Return.

    ret();

    // Handle an exception

    exceptionHandler.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>, JSGlobalData* globalData, NativeFunction)

{

    return globalData->jitStubs->ctiNativeCall();

}

void JIT::emit_op_mov(Instruction* currentInstruction)

{

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

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

    if (m_codeBlock->isConstantRegisterIndex(src)) {

        storePtr(ImmPtr(JSValue::encode(getConstantOperand(src))), Address(callFrameRegister, dst * sizeof(Register)));

        if (dst == m_lastResultBytecodeRegister)

            killLastResultRegister();

    } else if ((src == m_lastResultBytecodeRegister) || (dst == m_lastResultBytecodeRegister)) {

        // If either the src or dst is the cached register go though

        // get/put registers to make sure we track this correctly.

        emitGetVirtualRegister(src, regT0);

        emitPutVirtualRegister(dst);

    } else {

        // Perform the copy via regT1; do not disturb any mapping in regT0.

        loadPtr(Address(callFrameRegister, src * sizeof(Register)), regT1);

        storePtr(regT1, Address(callFrameRegister, dst * sizeof(Register)));

    }

}

void JIT::emit_op_end(Instruction* currentInstruction)

{

    if (m_codeBlock->needsFullScopeChain())

        JITStubCall(this, cti_op_end).call();

    ASSERT(returnValueRegister != callFrameRegister);

    emitGetVirtualRegister(currentInstruction[1].u.operand, returnValueRegister);

    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);

    RECORD_JUMP_TARGET(target);

}

void JIT::emit_op_loop_if_lesseq(Instruction* currentInstruction)

{

    emitTimeoutCheck();

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

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

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

    if (isOperandConstantImmediateInt(op2)) {

        emitGetVirtualRegister(op1, regT0);

        emitJumpSlowCaseIfNotImmediateInteger(regT0);

#if USE(JSVALUE64)

        int32_t op2imm = getConstantOperandImmediateInt(op2);

#else

        int32_t op2imm = static_cast<int32_t>(JSImmediate::rawValue(getConstantOperand(op2)));

#endif

        addJump(branch32(LessThanOrEqual, regT0, Imm32(op2imm)), target);

    } else {

        emitGetVirtualRegisters(op1, regT0, op2, regT1);

        emitJumpSlowCaseIfNotImmediateInteger(regT0);

        emitJumpSlowCaseIfNotImmediateInteger(regT1);

        addJump(branch32(LessThanOrEqual, regT0, regT1), 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 (baseVal, proto, and value respectively) into registers.

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

    emitGetVirtualRegister(value, regT2);

    emitGetVirtualRegister(baseVal, regT0);

    emitGetVirtualRegister(proto, regT1);

    // Check that baseVal & proto are cells.

    emitJumpSlowCaseIfNotJSCell(regT2, value);

    emitJumpSlowCaseIfNotJSCell(regT0, baseVal);

    emitJumpSlowCaseIfNotJSCell(regT1, 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(ImmPtr(JSValue::encode(jsBoolean(true))), regT0);

    Label loop(this);

    // Load the prototype of the object 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);

    loadPtr(Address(regT2, OBJECT_OFFSETOF(Structure, m_prototype)), regT2);

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

    emitJumpIfJSCell(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(ImmPtr(JSValue::encode(jsBoolean(false))), regT0);

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

    isInstance.link(this);

    emitPutVirtualRegister(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_call(Instruction* currentInstruction)

{

    compileOpCall(op_call, currentInstruction, m_callLinkInfoIndex++);

}

void JIT::emit_op_call_eval(Instruction* currentInstruction)

{

    compileOpCall(op_call_eval, currentInstruction, m_callLinkInfoIndex++);

}

void JIT::emit_op_load_varargs(Instruction* currentInstruction)

{

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

    int argsOffset = currentInstruction[2].u.operand;

    JITStubCall stubCall(this, cti_op_load_varargs);

    stubCall.addArgument(Imm32(argsOffset));

    stubCall.call();

    // Stores a naked int32 in the register file.

    store32(returnValueRegister, Address(callFrameRegister, argCountDst * sizeof(Register)));

}

void JIT::emit_op_call_varargs(Instruction* currentInstruction)

{

    compileOpCallVarargs(currentInstruction);

}

void JIT::emit_op_construct(Instruction* currentInstruction)

{

    compileOpCall(op_construct, currentInstruction, m_callLinkInfoIndex++);

}

void JIT::emit_op_get_global_var(Instruction* currentInstruction)

{

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

    move(ImmPtr(globalObject), regT0);

    emitGetVariableObjectRegister(regT0, currentInstruction[3].u.operand, regT0);

    emitPutVirtualRegister(currentInstruction[1].u.operand);

}

void JIT::emit_op_put_global_var(Instruction* currentInstruction)

{

    emitGetVirtualRegister(currentInstruction[3].u.operand, regT1);

    JSVariableObject* globalObject = static_cast<JSVariableObject*>(currentInstruction[1].u.jsCell);

    move(ImmPtr(globalObject), regT0);

    emitPutVariableObjectRegister(regT1, regT0, currentInstruction[2].u.operand);

}

void JIT::emit_op_get_scoped_var(Instruction* currentInstruction)

{

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

    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT0);

    while (skip--)

        loadPtr(Address(regT0, OBJECT_OFFSETOF(ScopeChainNode, next)), regT0);

    loadPtr(Address(regT0, OBJECT_OFFSETOF(ScopeChainNode, object)), regT0);

    emitGetVariableObjectRegister(regT0, currentInstruction[2].u.operand, regT0);

    emitPutVirtualRegister(currentInstruction[1].u.operand);

}

void JIT::emit_op_put_scoped_var(Instruction* currentInstruction)

{

    int skip = currentInstruction[2].u.operand;

    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1);

    emitGetVirtualRegister(currentInstruction[3].u.operand, regT0);

    while (skip--)

        loadPtr(Address(regT1, OBJECT_OFFSETOF(ScopeChainNode, next)), regT1);

    loadPtr(Address(regT1, OBJECT_OFFSETOF(ScopeChainNode, object)), regT1);

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

}

void JIT::emit_op_tear_off_activation(Instruction* currentInstruction)

{

    JITStubCall stubCall(this, cti_op_tear_off_activation);

    stubCall.addArgument(currentInstruction[1].u.operand, regT2);

    stubCall.addArgument(unmodifiedArgumentsRegister(currentInstruction[2].u.operand), regT2);

    stubCall.call();

}

void JIT::emit_op_tear_off_arguments(Instruction* currentInstruction)

{

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

    Jump argsNotCreated = branchTestPtr(Zero, Address(callFrameRegister, sizeof(Register) * (unmodifiedArgumentsRegister(dst))));

    JITStubCall stubCall(this, cti_op_tear_off_arguments);

    stubCall.addArgument(unmodifiedArgumentsRegister(dst), regT2);

    stubCall.call();

    argsNotCreated.link(this);

}

void JIT::emit_op_ret(Instruction* currentInstruction)

{

    // We could JIT generate the deref, only calling out to C when the refcount hits zero.

    if (m_codeBlock->needsFullScopeChain())

        JITStubCall(this, cti_op_ret_scopeChain).call();