/*

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

 *

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

 */

#ifndef JIT_h

#define JIT_h

#if ENABLE(JIT)

// We've run into some problems where changing the size of the class JIT leads to

// performance fluctuations.  Try forcing alignment in an attempt to stabalize this.

#if COMPILER(GCC)

#define JIT_CLASS_ALIGNMENT __attribute__ ((aligned (32)))

#else

#define JIT_CLASS_ALIGNMENT

#endif

#define ASSERT_JIT_OFFSET(actual, expected) ASSERT_WITH_MESSAGE(actual == expected, "JIT Offset \"%s\" should be %d, not %d.\n", #expected, static_cast<int>(actual), static_cast<int>(expected));

#include "CodeBlock.h"

#include "Interpreter.h"

#include "JSInterfaceJIT.h"

#include "Opcode.h"

#include "Profiler.h"

#include <bytecode/SamplingTool.h>

namespace JSC {

    class CodeBlock;

    class JIT;

    class JSPropertyNameIterator;

    class Interpreter;

    class Register;

    class RegisterFile;

    class ScopeChainNode;

    class StructureChain;

    struct CallLinkInfo;

    struct Instruction;

    struct OperandTypes;

    struct PolymorphicAccessStructureList;

    struct SimpleJumpTable;

    struct StringJumpTable;

    struct StructureStubInfo;

    struct CallRecord {

        MacroAssembler::Call from;

        unsigned bytecodeOffset;

        void* to;

        CallRecord()

        {

        }

        CallRecord(MacroAssembler::Call from, unsigned bytecodeOffset, void* to = 0)

            : from(from)

            , bytecodeOffset(bytecodeOffset)

            , to(to)

        {

        }

    };

    struct JumpTable {

        MacroAssembler::Jump from;

        unsigned toBytecodeOffset;

        JumpTable(MacroAssembler::Jump f, unsigned t)

            : from(f)

            , toBytecodeOffset(t)

        {

        }

    };

    struct SlowCaseEntry {

        MacroAssembler::Jump from;

        unsigned to;

        unsigned hint;

        SlowCaseEntry(MacroAssembler::Jump f, unsigned t, unsigned h = 0)

            : from(f)

            , to(t)

            , hint(h)

        {

        }

    };

    struct SwitchRecord {

        enum Type {

            Immediate,

            Character,

            String

        };

        Type type;

        union {

            SimpleJumpTable* simpleJumpTable;

            StringJumpTable* stringJumpTable;

        } jumpTable;

        unsigned bytecodeOffset;

        unsigned defaultOffset;

        SwitchRecord(SimpleJumpTable* jumpTable, unsigned bytecodeOffset, unsigned defaultOffset, Type type)

            : type(type)

            , bytecodeOffset(bytecodeOffset)

            , defaultOffset(defaultOffset)

        {

            this->jumpTable.simpleJumpTable = jumpTable;

        }

        SwitchRecord(StringJumpTable* jumpTable, unsigned bytecodeOffset, unsigned defaultOffset)

            : type(String)

            , bytecodeOffset(bytecodeOffset)

            , defaultOffset(defaultOffset)

        {

            this->jumpTable.stringJumpTable = jumpTable;

        }

    };

    struct PropertyStubCompilationInfo {

        MacroAssembler::Call callReturnLocation;

        MacroAssembler::Label hotPathBegin;

    };

    struct StructureStubCompilationInfo {

        MacroAssembler::DataLabelPtr hotPathBegin;

        MacroAssembler::Call hotPathOther;

        MacroAssembler::Call callReturnLocation;

    };

    struct MethodCallCompilationInfo {

        MethodCallCompilationInfo(unsigned propertyAccessIndex)

            : propertyAccessIndex(propertyAccessIndex)

        {

        }

        MacroAssembler::DataLabelPtr structureToCompare;

        unsigned propertyAccessIndex;

    };

    // Near calls can only be patched to other JIT code, regular calls can be patched to JIT code or relinked to stub functions.

    void ctiPatchNearCallByReturnAddress(CodeBlock* codeblock, ReturnAddressPtr returnAddress, MacroAssemblerCodePtr newCalleeFunction);

    void ctiPatchCallByReturnAddress(CodeBlock* codeblock, ReturnAddressPtr returnAddress, MacroAssemblerCodePtr newCalleeFunction);

    void ctiPatchCallByReturnAddress(CodeBlock* codeblock, ReturnAddressPtr returnAddress, FunctionPtr newCalleeFunction);

    class JIT : private JSInterfaceJIT {

        friend class JITStubCall;

        using MacroAssembler::Jump;

        using MacroAssembler::JumpList;

        using MacroAssembler::Label;

        static const int patchGetByIdDefaultStructure = -1;

        // Magic number - initial offset cannot be representable as a signed 8bit value, or the X86Assembler

        // will compress the displacement, and we may not be able to fit a patched offset.

        static const int patchGetByIdDefaultOffset = 256;

    public:

        static JITCode compile(JSGlobalData* globalData, CodeBlock* codeBlock, CodePtr* functionEntryArityCheck = 0)

        {

            return JIT(globalData, codeBlock).privateCompile(functionEntryArityCheck);

        }

        static void compileGetByIdProto(JSGlobalData* globalData, CallFrame* callFrame, CodeBlock* codeBlock, StructureStubInfo* stubInfo, Structure* structure, Structure* prototypeStructure, const Identifier& ident, const PropertySlot& slot, size_t cachedOffset, ReturnAddressPtr returnAddress)

        {

            JIT jit(globalData, codeBlock);

            jit.privateCompileGetByIdProto(stubInfo, structure, prototypeStructure, ident, slot, cachedOffset, returnAddress, callFrame);

        }

        static void compileGetByIdSelfList(JSGlobalData* globalData, CodeBlock* codeBlock, StructureStubInfo* stubInfo, PolymorphicAccessStructureList* polymorphicStructures, int currentIndex, Structure* structure, const Identifier& ident, const PropertySlot& slot, size_t cachedOffset)

        {

            JIT jit(globalData, codeBlock);

            jit.privateCompileGetByIdSelfList(stubInfo, polymorphicStructures, currentIndex, structure, ident, slot, cachedOffset);

        }

        static void compileGetByIdProtoList(JSGlobalData* globalData, CallFrame* callFrame, CodeBlock* codeBlock, StructureStubInfo* stubInfo, PolymorphicAccessStructureList* prototypeStructureList, int currentIndex, Structure* structure, Structure* prototypeStructure, const Identifier& ident, const PropertySlot& slot, size_t cachedOffset)

        {

            JIT jit(globalData, codeBlock);

            jit.privateCompileGetByIdProtoList(stubInfo, prototypeStructureList, currentIndex, structure, prototypeStructure, ident, slot, cachedOffset, callFrame);

        }

        static void compileGetByIdChainList(JSGlobalData* globalData, CallFrame* callFrame, CodeBlock* codeBlock, StructureStubInfo* stubInfo, PolymorphicAccessStructureList* prototypeStructureList, int currentIndex, Structure* structure, StructureChain* chain, size_t count, const Identifier& ident, const PropertySlot& slot, size_t cachedOffset)

        {

            JIT jit(globalData, codeBlock);

            jit.privateCompileGetByIdChainList(stubInfo, prototypeStructureList, currentIndex, structure, chain, count, ident, slot, cachedOffset, callFrame);

        }

        static void compileGetByIdChain(JSGlobalData* globalData, CallFrame* callFrame, CodeBlock* codeBlock, StructureStubInfo* stubInfo, Structure* structure, StructureChain* chain, size_t count, const Identifier& ident, const PropertySlot& slot, size_t cachedOffset, ReturnAddressPtr returnAddress)

        {

            JIT jit(globalData, codeBlock);

            jit.privateCompileGetByIdChain(stubInfo, structure, chain, count, ident, slot, cachedOffset, returnAddress, callFrame);

        }

        static void compilePutByIdTransition(JSGlobalData* globalData, CodeBlock* codeBlock, StructureStubInfo* stubInfo, Structure* oldStructure, Structure* newStructure, size_t cachedOffset, StructureChain* chain, ReturnAddressPtr returnAddress, bool direct)

        {

            JIT jit(globalData, codeBlock);

            jit.privateCompilePutByIdTransition(stubInfo, oldStructure, newStructure, cachedOffset, chain, returnAddress, direct);

        }

        static void compileCTIMachineTrampolines(JSGlobalData* globalData, RefPtr<ExecutablePool>* executablePool, TrampolineStructure *trampolines)

        {

            if (!globalData->canUseJIT())

                return;

            JIT jit(globalData);

            jit.privateCompileCTIMachineTrampolines(executablePool, globalData, trampolines);

        }

        static CodePtr compileCTINativeCall(JSGlobalData* globalData, PassRefPtr<ExecutablePool> executablePool, NativeFunction func)

        {

            if (!globalData->canUseJIT())

                return CodePtr();

            JIT jit(globalData);

            return jit.privateCompileCTINativeCall(executablePool, globalData, func);

        }

        static void patchGetByIdSelf(CodeBlock* codeblock, StructureStubInfo*, Structure*, size_t cachedOffset, ReturnAddressPtr returnAddress);

        static void patchPutByIdReplace(CodeBlock* codeblock, StructureStubInfo*, Structure*, size_t cachedOffset, ReturnAddressPtr returnAddress, bool direct);

        static void patchMethodCallProto(CodeBlock* codeblock, MethodCallLinkInfo&, JSFunction*, Structure*, JSObject*, ReturnAddressPtr);

        static void compilePatchGetArrayLength(JSGlobalData* globalData, CodeBlock* codeBlock, ReturnAddressPtr returnAddress)

        {

            JIT jit(globalData, codeBlock);

            return jit.privateCompilePatchGetArrayLength(returnAddress);

        }

        static void linkCall(JSFunction* callee, CodeBlock* callerCodeBlock, CodeBlock* calleeCodeBlock, CodePtr, CallLinkInfo*, int callerArgCount, JSGlobalData*);

        static void linkConstruct(JSFunction* callee, CodeBlock* callerCodeBlock, CodeBlock* calleeCodeBlock, CodePtr, CallLinkInfo*, int callerArgCount, JSGlobalData*);

        static void unlinkCallOrConstruct(CallLinkInfo*);

    private:

        struct JSRInfo {

            DataLabelPtr storeLocation;

            Label target;

            JSRInfo(DataLabelPtr storeLocation, Label targetLocation)

                : storeLocation(storeLocation)

                , target(targetLocation)

            {

            }

        };

        JIT(JSGlobalData*, CodeBlock* = 0);

        void privateCompileMainPass();

        void privateCompileLinkPass();

        void privateCompileSlowCases();

        JITCode privateCompile(CodePtr* functionEntryArityCheck);

        void privateCompileGetByIdProto(StructureStubInfo*, Structure*, Structure* prototypeStructure, const Identifier&, const PropertySlot&, size_t cachedOffset, ReturnAddressPtr returnAddress, CallFrame* callFrame);

        void privateCompileGetByIdSelfList(StructureStubInfo*, PolymorphicAccessStructureList*, int, Structure*, const Identifier&, const PropertySlot&, size_t cachedOffset);

        void privateCompileGetByIdProtoList(StructureStubInfo*, PolymorphicAccessStructureList*, int, Structure*, Structure* prototypeStructure, const Identifier&, const PropertySlot&, size_t cachedOffset, CallFrame* callFrame);

        void privateCompileGetByIdChainList(StructureStubInfo*, PolymorphicAccessStructureList*, int, Structure*, StructureChain* chain, size_t count, const Identifier&, const PropertySlot&, size_t cachedOffset, CallFrame* callFrame);

        void privateCompileGetByIdChain(StructureStubInfo*, Structure*, StructureChain*, size_t count, const Identifier&, const PropertySlot&, size_t cachedOffset, ReturnAddressPtr returnAddress, CallFrame* callFrame);

        void privateCompilePutByIdTransition(StructureStubInfo*, Structure*, Structure*, size_t cachedOffset, StructureChain*, ReturnAddressPtr returnAddress, bool direct);

        void privateCompileCTIMachineTrampolines(RefPtr<ExecutablePool>* executablePool, JSGlobalData* data, TrampolineStructure *trampolines);

        Label privateCompileCTINativeCall(JSGlobalData*, bool isConstruct = false);

        CodePtr privateCompileCTINativeCall(PassRefPtr<ExecutablePool> executablePool, JSGlobalData* data, NativeFunction func);

        void privateCompilePatchGetArrayLength(ReturnAddressPtr returnAddress);

        void addSlowCase(Jump);

        void addSlowCase(JumpList);

        void addJump(Jump, int);

        void emitJumpSlowToHot(Jump, int);

        void compileOpCall(OpcodeID, Instruction* instruction, unsigned callLinkInfoIndex);

        void compileOpCallVarargs(Instruction* instruction);

        void compileOpCallInitializeCallFrame();

        void compileOpCallSlowCase(Instruction* instruction, Vector<SlowCaseEntry>::iterator& iter, unsigned callLinkInfoIndex, OpcodeID opcodeID);

        void compileOpCallVarargsSlowCase(Instruction* instruction, Vector<SlowCaseEntry>::iterator& iter);

        enum CompileOpStrictEqType { OpStrictEq, OpNStrictEq };

        void compileOpStrictEq(Instruction* instruction, CompileOpStrictEqType type);

        bool isOperandConstantImmediateDouble(unsigned src);

        void emitLoadDouble(unsigned index, FPRegisterID value);

        void emitLoadInt32ToDouble(unsigned index, FPRegisterID value);

        void testPrototype(Structure*, JumpList& failureCases);

#if USE(JSVALUE32_64)

        bool getOperandConstantImmediateInt(unsigned op1, unsigned op2, unsigned& op, int32_t& constant);

        void emitLoadTag(unsigned index, RegisterID tag);

        void emitLoadPayload(unsigned index, RegisterID payload);

        void emitLoad(const JSValue& v, RegisterID tag, RegisterID payload);

        void emitLoad(unsigned index, RegisterID tag, RegisterID payload, RegisterID base = callFrameRegister);

        void emitLoad2(unsigned index1, RegisterID tag1, RegisterID payload1, unsigned index2, RegisterID tag2, RegisterID payload2);

        void emitStore(unsigned index, RegisterID tag, RegisterID payload, RegisterID base = callFrameRegister);

        void emitStore(unsigned index, const JSValue constant, RegisterID base = callFrameRegister);

        void emitStoreInt32(unsigned index, RegisterID payload, bool indexIsInt32 = false);

        void emitStoreInt32(unsigned index, Imm32 payload, bool indexIsInt32 = false);

        void emitStoreCell(unsigned index, RegisterID payload, bool indexIsCell = false);

        void emitStoreBool(unsigned index, RegisterID tag, bool indexIsBool = false);

        void emitStoreDouble(unsigned index, FPRegisterID value);

        bool isLabeled(unsigned bytecodeOffset);

        void map(unsigned bytecodeOffset, unsigned virtualRegisterIndex, RegisterID tag, RegisterID payload);

        void unmap(RegisterID);

        void unmap();

        bool isMapped(unsigned virtualRegisterIndex);

        bool getMappedPayload(unsigned virtualRegisterIndex, RegisterID& payload);

        bool getMappedTag(unsigned virtualRegisterIndex, RegisterID& tag);

        void emitJumpSlowCaseIfNotJSCell(unsigned virtualRegisterIndex);

        void emitJumpSlowCaseIfNotJSCell(unsigned virtualRegisterIndex, RegisterID tag);

        void linkSlowCaseIfNotJSCell(Vector<SlowCaseEntry>::iterator&, unsigned virtualRegisterIndex);

#if ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS)

        void compileGetByIdHotPath();

        void compileGetByIdSlowCase(int resultVReg, int baseVReg, Identifier* ident, Vector<SlowCaseEntry>::iterator& iter, bool isMethodCheck = false);

#endif

        void compileGetDirectOffset(RegisterID base, RegisterID resultTag, RegisterID resultPayload, Structure* structure, size_t cachedOffset);

        void compileGetDirectOffset(JSObject* base, RegisterID temp, RegisterID resultTag, RegisterID resultPayload, size_t cachedOffset);

        void compileGetDirectOffset(RegisterID base, RegisterID resultTag, RegisterID resultPayload, RegisterID structure, RegisterID offset);

        void compilePutDirectOffset(RegisterID base, RegisterID valueTag, RegisterID valuePayload, Structure* structure, size_t cachedOffset);

        // Arithmetic opcode helpers

        void emitAdd32Constant(unsigned dst, unsigned op, int32_t constant, ResultType opType);

        void emitSub32Constant(unsigned dst, unsigned op, int32_t constant, ResultType opType);

        void emitBinaryDoubleOp(OpcodeID, unsigned dst, unsigned op1, unsigned op2, OperandTypes, JumpList& notInt32Op1, JumpList& notInt32Op2, bool op1IsInRegisters = true, bool op2IsInRegisters = true);

#if CPU(X86)

        // These architecture specific value are used to enable patching - see comment on op_put_by_id.

        static const int patchOffsetPutByIdStructure = 7;

        static const int patchOffsetPutByIdExternalLoad = 13;

        static const int patchLengthPutByIdExternalLoad = 3;

        static const int patchOffsetPutByIdPropertyMapOffset1 = 22;

        static const int patchOffsetPutByIdPropertyMapOffset2 = 28;

        // These architecture specific value are used to enable patching - see comment on op_get_by_id.

        static const int patchOffsetGetByIdStructure = 7;

        static const int patchOffsetGetByIdBranchToSlowCase = 13;

        static const int patchOffsetGetByIdExternalLoad = 13;

        static const int patchLengthGetByIdExternalLoad = 3;

        static const int patchOffsetGetByIdPropertyMapOffset1 = 22;

        static const int patchOffsetGetByIdPropertyMapOffset2 = 28;

        static const int patchOffsetGetByIdPutResult = 28;

#if ENABLE(OPCODE_SAMPLING)

        static const int patchOffsetGetByIdSlowCaseCall = 37;

#else

        static const int patchOffsetGetByIdSlowCaseCall = 27;

#endif

        static const int patchOffsetOpCallCompareToJump = 6;

        static const int patchOffsetMethodCheckProtoObj = 11;

        static const int patchOffsetMethodCheckProtoStruct = 18;

        static const int patchOffsetMethodCheckPutFunction = 29;

#elif CPU(ARM_TRADITIONAL)

        // These architecture specific value are used to enable patching - see comment on op_put_by_id.

        static const int patchOffsetPutByIdStructure = 4;

        static const int patchOffsetPutByIdExternalLoad = 16;

        static const int patchLengthPutByIdExternalLoad = 4;

        static const int patchOffsetPutByIdPropertyMapOffset1 = 20;

        static const int patchOffsetPutByIdPropertyMapOffset2 = 28;

        // These architecture specific value are used to enable patching - see comment on op_get_by_id.

        static const int patchOffsetGetByIdStructure = 4;

        static const int patchOffsetGetByIdBranchToSlowCase = 16;

        static const int patchOffsetGetByIdExternalLoad = 16;

        static const int patchLengthGetByIdExternalLoad = 4;

        static const int patchOffsetGetByIdPropertyMapOffset1 = 20;

        static const int patchOffsetGetByIdPropertyMapOffset2 = 28;

        static const int patchOffsetGetByIdPutResult = 36;

#if ENABLE(OPCODE_SAMPLING)

        #error "OPCODE_SAMPLING is not yet supported"

#else

        static const int patchOffsetGetByIdSlowCaseCall = 32;

#endif

        static const int patchOffsetOpCallCompareToJump = 12;

        static const int patchOffsetMethodCheckProtoObj = 12;

        static const int patchOffsetMethodCheckProtoStruct = 20;

        static const int patchOffsetMethodCheckPutFunction = 32;

        // sequenceOpCall

        static const int sequenceOpCallInstructionSpace = 12;

        static const int sequenceOpCallConstantSpace = 2;

        // sequenceMethodCheck

        static const int sequenceMethodCheckInstructionSpace = 40;

        static const int sequenceMethodCheckConstantSpace = 6;

        // sequenceGetByIdHotPath

        static const int sequenceGetByIdHotPathInstructionSpace = 36;

        static const int sequenceGetByIdHotPathConstantSpace = 4;

        // sequenceGetByIdSlowCase

        static const int sequenceGetByIdSlowCaseInstructionSpace = 40;

        static const int sequenceGetByIdSlowCaseConstantSpace = 2;

        // sequencePutById

        static const int sequencePutByIdInstructionSpace = 36;

        static const int sequencePutByIdConstantSpace = 4;

#elif CPU(ARM_THUMB2)

        // These architecture specific value are used to enable patching - see comment on op_put_by_id.

        static const int patchOffsetPutByIdStructure = 10;

        static const int patchOffsetPutByIdExternalLoad = 26;

        static const int patchLengthPutByIdExternalLoad = 12;

        static const int patchOffsetPutByIdPropertyMapOffset1 = 46;

        static const int patchOffsetPutByIdPropertyMapOffset2 = 58;

        // These architecture specific value are used to enable patching - see comment on op_get_by_id.

        static const int patchOffsetGetByIdStructure = 10;

        static const int patchOffsetGetByIdBranchToSlowCase = 26;

        static const int patchOffsetGetByIdExternalLoad = 26;

        static const int patchLengthGetByIdExternalLoad = 12;

        static const int patchOffsetGetByIdPropertyMapOffset1 = 46;

        static const int patchOffsetGetByIdPropertyMapOffset2 = 58;

        static const int patchOffsetGetByIdPutResult = 62;

#if ENABLE(OPCODE_SAMPLING)

        #error "OPCODE_SAMPLING is not yet supported"

#else

        static const int patchOffsetGetByIdSlowCaseCall = 30;

#endif

        static const int patchOffsetOpCallCompareToJump = 16;

        static const int patchOffsetMethodCheckProtoObj = 24;

        static const int patchOffsetMethodCheckProtoStruct = 34;

        static const int patchOffsetMethodCheckPutFunction = 58;

        // sequenceOpCall

        static const int sequenceOpCallInstructionSpace = 12;

        static const int sequenceOpCallConstantSpace = 2;

        // sequenceMethodCheck

        static const int sequenceMethodCheckInstructionSpace = 40;

        static const int sequenceMethodCheckConstantSpace = 6;

        // sequenceGetByIdHotPath

        static const int sequenceGetByIdHotPathInstructionSpace = 36;

        static const int sequenceGetByIdHotPathConstantSpace = 4;

        // sequenceGetByIdSlowCase

        static const int sequenceGetByIdSlowCaseInstructionSpace = 40;

        static const int sequenceGetByIdSlowCaseConstantSpace = 2;

        // sequencePutById

        static const int sequencePutByIdInstructionSpace = 36;

        static const int sequencePutByIdConstantSpace = 4;

#else

#error "JSVALUE32_64 not supported on this platform."

#endif

#else // USE(JSVALUE32_64)

        void emitGetVirtualRegister(int src, RegisterID dst);

        void emitGetVirtualRegisters(int src1, RegisterID dst1, int src2, RegisterID dst2);

        void emitPutVirtualRegister(unsigned dst, RegisterID from = regT0);

        int32_t getConstantOperandImmediateInt(unsigned src);

        void emitGetVariableObjectRegister(RegisterID variableObject, int index, RegisterID dst);

        void emitPutVariableObjectRegister(RegisterID src, RegisterID variableObject, int index);

        void killLastResultRegister();

        Jump emitJumpIfJSCell(RegisterID);

        Jump emitJumpIfBothJSCells(RegisterID, RegisterID, RegisterID);

        void emitJumpSlowCaseIfJSCell(RegisterID);

        Jump emitJumpIfNotJSCell(RegisterID);

        void emitJumpSlowCaseIfNotJSCell(RegisterID);

        void emitJumpSlowCaseIfNotJSCell(RegisterID, int VReg);

#if USE(JSVALUE64)

#else

        JIT::Jump emitJumpIfImmediateNumber(RegisterID reg)

        {

            return emitJumpIfImmediateInteger(reg);

        }

        JIT::Jump emitJumpIfNotImmediateNumber(RegisterID reg)

        {

            return emitJumpIfNotImmediateInteger(reg);

        }

#endif

        JIT::Jump emitJumpIfImmediateInteger(RegisterID);

        JIT::Jump emitJumpIfNotImmediateInteger(RegisterID);

        JIT::Jump emitJumpIfNotImmediateIntegers(RegisterID, RegisterID, RegisterID);

        void emitJumpSlowCaseIfNotImmediateInteger(RegisterID);

        void emitJumpSlowCaseIfNotImmediateNumber(RegisterID);

        void emitJumpSlowCaseIfNotImmediateIntegers(RegisterID, RegisterID, RegisterID);

#if !USE(JSVALUE64)

        void emitFastArithDeTagImmediate(RegisterID);

        Jump emitFastArithDeTagImmediateJumpIfZero(RegisterID);

#endif

        void emitFastArithReTagImmediate(RegisterID src, RegisterID dest);

        void emitFastArithIntToImmNoCheck(RegisterID src, RegisterID dest);

        void emitTagAsBoolImmediate(RegisterID reg);

        void compileBinaryArithOp(OpcodeID, unsigned dst, unsigned src1, unsigned src2, OperandTypes opi);

#if USE(JSVALUE64)

        void compileBinaryArithOpSlowCase(OpcodeID, Vector<SlowCaseEntry>::iterator&, unsigned dst, unsigned src1, unsigned src2, OperandTypes, bool op1HasImmediateIntFastCase, bool op2HasImmediateIntFastCase);

#else

        void compileBinaryArithOpSlowCase(OpcodeID, Vector<SlowCaseEntry>::iterator&, unsigned dst, unsigned src1, unsigned src2, OperandTypes);

#endif

#if ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS)

        void compileGetByIdHotPath(int resultVReg, int baseVReg, Identifier* ident, unsigned propertyAccessInstructionIndex);

        void compileGetByIdSlowCase(int resultVReg, int baseVReg, Identifier* ident, Vector<SlowCaseEntry>::iterator& iter, bool isMethodCheck = false);

#endif

        void compileGetDirectOffset(RegisterID base, RegisterID result, Structure* structure, size_t cachedOffset);

        void compileGetDirectOffset(JSObject* base, RegisterID temp, RegisterID result, size_t cachedOffset);

        void compileGetDirectOffset(RegisterID base, RegisterID result, RegisterID structure, RegisterID offset, RegisterID scratch);

        void compilePutDirectOffset(RegisterID base, RegisterID value, Structure* structure, size_t cachedOffset);

#if CPU(X86_64)

        // These architecture specific value are used to enable patching - see comment on op_put_by_id.

        static const int patchOffsetPutByIdStructure = 10;

        static const int patchOffsetPutByIdExternalLoad = 20;

        static const int patchLengthPutByIdExternalLoad = 4;

        static const int patchOffsetPutByIdPropertyMapOffset = 31;

        // These architecture specific value are used to enable patching - see comment on op_get_by_id.

        static const int patchOffsetGetByIdStructure = 10;

        static const int patchOffsetGetByIdBranchToSlowCase = 20;

        static const int patchOffsetGetByIdExternalLoad = 20;

        static const int patchLengthGetByIdExternalLoad = 4;

        static const int patchOffsetGetByIdPropertyMapOffset = 31;

        static const int patchOffsetGetByIdPutResult = 31;