/*

 * 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

#include <wtf/Platform.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

#include "CodeBlock.h"

#include "Interpreter.h"

#include "JITCode.h"

#include "JITStubs.h"

#include "Opcode.h"

#include "RegisterFile.h"

#include "MacroAssembler.h"

#include "Profiler.h"

#include <bytecode/SamplingTool.h>

#include <wtf/AlwaysInline.h>

#include <wtf/Vector.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 bytecodeIndex;

        void* to;

        CallRecord()

        {

        }

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

            : from(from)

            , bytecodeIndex(bytecodeIndex)

            , to(to)

        {

        }

    };

    struct JumpTable {

        MacroAssembler::Jump from;

        unsigned toBytecodeIndex;

        JumpTable(MacroAssembler::Jump f, unsigned t)

            : from(f)

            , toBytecodeIndex(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 bytecodeIndex;

        unsigned defaultOffset;

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

            : type(type)

            , bytecodeIndex(bytecodeIndex)

            , defaultOffset(defaultOffset)

        {

            this->jumpTable.simpleJumpTable = jumpTable;

        }

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

            : type(String)

            , bytecodeIndex(bytecodeIndex)

            , 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 MacroAssembler {

        friend class JITStubCall;

        using MacroAssembler::Jump;

        using MacroAssembler::JumpList;

        using MacroAssembler::Label;

        // NOTES:

        //

        // regT0 has two special meanings.  The return value from a stub

        // call will always be in regT0, and by default (unless

        // a register is specified) emitPutVirtualRegister() will store

        // the value from regT0.

        //

        // regT3 is required to be callee-preserved.

        //

        // tempRegister2 is has no such dependencies.  It is important that

        // on x86/x86-64 it is ecx for performance reasons, since the

        // MacroAssembler will need to plant register swaps if it is not -

        // however the code will still function correctly.

#if PLATFORM(X86_64)

        static const RegisterID returnValueRegister = X86Registers::eax;

        static const RegisterID cachedResultRegister = X86Registers::eax;

        static const RegisterID firstArgumentRegister = X86Registers::edi;

        static const RegisterID timeoutCheckRegister = X86Registers::r12;

        static const RegisterID callFrameRegister = X86Registers::r13;

        static const RegisterID tagTypeNumberRegister = X86Registers::r14;

        static const RegisterID tagMaskRegister = X86Registers::r15;

        static const RegisterID regT0 = X86Registers::eax;

        static const RegisterID regT1 = X86Registers::edx;

        static const RegisterID regT2 = X86Registers::ecx;

        static const RegisterID regT3 = X86Registers::ebx;

        static const FPRegisterID fpRegT0 = X86Registers::xmm0;

        static const FPRegisterID fpRegT1 = X86Registers::xmm1;

        static const FPRegisterID fpRegT2 = X86Registers::xmm2;

#elif PLATFORM(X86)

        static const RegisterID returnValueRegister = X86Registers::eax;

        static const RegisterID cachedResultRegister = X86Registers::eax;

        // On x86 we always use fastcall conventions = but on

        // OS X if might make more sense to just use regparm.

        static const RegisterID firstArgumentRegister = X86Registers::ecx;

        static const RegisterID timeoutCheckRegister = X86Registers::esi;

        static const RegisterID callFrameRegister = X86Registers::edi;

        static const RegisterID regT0 = X86Registers::eax;

        static const RegisterID regT1 = X86Registers::edx;

        static const RegisterID regT2 = X86Registers::ecx;

        static const RegisterID regT3 = X86Registers::ebx;

        static const FPRegisterID fpRegT0 = X86Registers::xmm0;

        static const FPRegisterID fpRegT1 = X86Registers::xmm1;

        static const FPRegisterID fpRegT2 = X86Registers::xmm2;

#elif PLATFORM(ARM_THUMB2)

        static const RegisterID returnValueRegister = ARMRegisters::r0;

        static const RegisterID cachedResultRegister = ARMRegisters::r0;

        static const RegisterID firstArgumentRegister = ARMRegisters::r0;

        static const RegisterID regT0 = ARMRegisters::r0;

        static const RegisterID regT1 = ARMRegisters::r1;

        static const RegisterID regT2 = ARMRegisters::r2;

        static const RegisterID regT3 = ARMRegisters::r4;

        static const RegisterID callFrameRegister = ARMRegisters::r5;

        static const RegisterID timeoutCheckRegister = ARMRegisters::r6;

        static const FPRegisterID fpRegT0 = ARMRegisters::d0;

        static const FPRegisterID fpRegT1 = ARMRegisters::d1;

        static const FPRegisterID fpRegT2 = ARMRegisters::d2;

#elif PLATFORM(ARM_TRADITIONAL)

        static const RegisterID returnValueRegister = ARMRegisters::r0;

        static const RegisterID cachedResultRegister = ARMRegisters::r0;

        static const RegisterID firstArgumentRegister = ARMRegisters::r0;

        static const RegisterID timeoutCheckRegister = ARMRegisters::r5;

        static const RegisterID callFrameRegister = ARMRegisters::r4;

        static const RegisterID ctiReturnRegister = ARMRegisters::r6;

        static const RegisterID regT0 = ARMRegisters::r0;

        static const RegisterID regT1 = ARMRegisters::r1;

        static const RegisterID regT2 = ARMRegisters::r2;

        // Callee preserved

        static const RegisterID regT3 = ARMRegisters::r7;

        static const RegisterID regS0 = ARMRegisters::S0;

        // Callee preserved

        static const RegisterID regS1 = ARMRegisters::S1;

        static const RegisterID regStackPtr = ARMRegisters::sp;

        static const RegisterID regLink = ARMRegisters::lr;

        static const FPRegisterID fpRegT0 = ARMRegisters::d0;

        static const FPRegisterID fpRegT1 = ARMRegisters::d1;

        static const FPRegisterID fpRegT2 = ARMRegisters::d2;

#else

    #error "JIT not supported on this platform."

#endif

        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)

        {

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

        }

        static void compileGetByIdProto(JSGlobalData* globalData, CallFrame* callFrame, CodeBlock* codeBlock, StructureStubInfo* stubInfo, Structure* structure, Structure* prototypeStructure, size_t cachedOffset, ReturnAddressPtr returnAddress)

        {

            JIT jit(globalData, codeBlock);

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

        }

        static void compileGetByIdSelfList(JSGlobalData* globalData, CodeBlock* codeBlock, StructureStubInfo* stubInfo, PolymorphicAccessStructureList* polymorphicStructures, int currentIndex, Structure* structure, size_t cachedOffset)

        {

            JIT jit(globalData, codeBlock);

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

        }

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

        {

            JIT jit(globalData, codeBlock);

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

        }

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

        {

            JIT jit(globalData, codeBlock);

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

        }

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

        {

            JIT jit(globalData, codeBlock);

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

        }

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

        {

            JIT jit(globalData, codeBlock);

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

        }

        static void compileCTIMachineTrampolines(JSGlobalData* globalData, RefPtr<ExecutablePool>* executablePool, CodePtr* ctiStringLengthTrampoline, CodePtr* ctiVirtualCallLink, CodePtr* ctiVirtualCall, CodePtr* ctiNativeCallThunk)

        {

            JIT jit(globalData);

            jit.privateCompileCTIMachineTrampolines(executablePool, globalData, ctiStringLengthTrampoline, ctiVirtualCallLink, ctiVirtualCall, ctiNativeCallThunk);

        }

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

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

        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, JITCode&, CallLinkInfo*, int callerArgCount, JSGlobalData*);

        static void unlinkCall(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();

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

        void privateCompileGetByIdSelfList(StructureStubInfo*, PolymorphicAccessStructureList*, int, Structure*, size_t cachedOffset);

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

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

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

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

        void privateCompileCTIMachineTrampolines(RefPtr<ExecutablePool>* executablePool, JSGlobalData* data, CodePtr* ctiStringLengthTrampoline, CodePtr* ctiVirtualCallLink, CodePtr* ctiVirtualCall, CodePtr* ctiNativeCallThunk);

        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 compileOpCallSetupArgs(Instruction*);

        void compileOpCallVarargsSetupArgs(Instruction*);

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

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

        void compileOpConstructSetupArgs(Instruction*);

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

        Address addressFor(unsigned index, RegisterID base = callFrameRegister);

        void testPrototype(Structure*, JumpList& failureCases);

#if USE(JSVALUE32_64)

        Address tagFor(unsigned index, RegisterID base = callFrameRegister);

        Address payloadFor(unsigned index, RegisterID base = callFrameRegister);

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

        void map(unsigned bytecodeIndex, 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 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 PLATFORM(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) && USE(JIT_STUB_ARGUMENT_VA_LIST)

        static const int patchOffsetGetByIdSlowCaseCall = 35;

#elif ENABLE(OPCODE_SAMPLING)

        static const int patchOffsetGetByIdSlowCaseCall = 37;

#elif USE(JIT_STUB_ARGUMENT_VA_LIST)

        static const int patchOffsetGetByIdSlowCaseCall = 25;

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

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

        JIT::Jump emitJumpIfImmediateNumber(RegisterID);

        JIT::Jump emitJumpIfNotImmediateNumber(RegisterID);

#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 emitFastArithImmToInt(RegisterID);

        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