X-Git-Url: https://git.saurik.com/apple/javascriptcore.git/blobdiff_plain/4e4e5a6f2694187498445a6ac6f1634ce8141119..4be4e30906bcb8ee30b4d189205cb70bad6707ce:/jit/JSInterfaceJIT.h diff --git a/jit/JSInterfaceJIT.h b/jit/JSInterfaceJIT.h index f34800a..294d09c 100644 --- a/jit/JSInterfaceJIT.h +++ b/jit/JSInterfaceJIT.h @@ -26,14 +26,17 @@ #ifndef JSInterfaceJIT_h #define JSInterfaceJIT_h +#include "BytecodeConventions.h" #include "JITCode.h" #include "JITStubs.h" -#include "JSImmediate.h" +#include "JSCJSValue.h" +#include "JSStack.h" +#include "JSString.h" #include "MacroAssembler.h" -#include "RegisterFile.h" -#include #include +#if ENABLE(JIT) + namespace JSC { class JSInterfaceJIT : public MacroAssembler { public: @@ -53,22 +56,31 @@ namespace JSC { #if CPU(X86_64) static const RegisterID returnValueRegister = X86Registers::eax; static const RegisterID cachedResultRegister = X86Registers::eax; +#if !OS(WINDOWS) static const RegisterID firstArgumentRegister = X86Registers::edi; - - static const RegisterID timeoutCheckRegister = X86Registers::r12; +#else + static const RegisterID firstArgumentRegister = X86Registers::ecx; +#endif + +#if ENABLE(VALUE_PROFILER) + static const RegisterID bucketCounterRegister = X86Registers::r10; +#endif + 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; static const FPRegisterID fpRegT3 = X86Registers::xmm3; + + static const RegisterID nonArgGPR1 = X86Registers::eax; // regT0 #elif CPU(X86) static const RegisterID returnValueRegister = X86Registers::eax; static const RegisterID cachedResultRegister = X86Registers::eax; @@ -76,7 +88,7 @@ namespace JSC { // 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 bucketCounterRegister = X86Registers::esi; static const RegisterID callFrameRegister = X86Registers::edi; static const RegisterID regT0 = X86Registers::eax; @@ -88,53 +100,61 @@ namespace JSC { static const FPRegisterID fpRegT1 = X86Registers::xmm1; static const FPRegisterID fpRegT2 = X86Registers::xmm2; static const FPRegisterID fpRegT3 = X86Registers::xmm3; -#elif CPU(ARM_THUMB2) +#elif CPU(ARM) static const RegisterID returnValueRegister = ARMRegisters::r0; static const RegisterID cachedResultRegister = ARMRegisters::r0; static const RegisterID firstArgumentRegister = ARMRegisters::r0; - + +#if ENABLE(VALUE_PROFILER) + static const RegisterID bucketCounterRegister = ARMRegisters::r7; +#endif + static const RegisterID regT0 = ARMRegisters::r0; static const RegisterID regT1 = ARMRegisters::r1; static const RegisterID regT2 = ARMRegisters::r2; static const RegisterID regT3 = ARMRegisters::r4; - + + // Update ctiTrampoline in JITStubs.cpp if these values are changed! 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; static const FPRegisterID fpRegT3 = ARMRegisters::d3; -#elif CPU(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 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; +#elif CPU(ARM64) + static const RegisterID returnValueRegister = ARM64Registers::x0; + static const RegisterID cachedResultRegister = ARM64Registers::x0; + static const RegisterID firstArgumentRegister = ARM64Registers::x0; + +#if ENABLE(VALUE_PROFILER) + static const RegisterID bucketCounterRegister = ARM64Registers::x7; +#endif + + static const RegisterID regT0 = ARM64Registers::x0; + static const RegisterID regT1 = ARM64Registers::x1; + static const RegisterID regT2 = ARM64Registers::x2; + static const RegisterID regT3 = ARM64Registers::x23; - static const RegisterID regStackPtr = ARMRegisters::sp; - static const RegisterID regLink = ARMRegisters::lr; + static const RegisterID callFrameRegister = ARM64Registers::x25; + static const RegisterID timeoutCheckRegister = ARM64Registers::x26; + static const RegisterID tagTypeNumberRegister = ARM64Registers::x27; + static const RegisterID tagMaskRegister = ARM64Registers::x28; - static const FPRegisterID fpRegT0 = ARMRegisters::d0; - static const FPRegisterID fpRegT1 = ARMRegisters::d1; - static const FPRegisterID fpRegT2 = ARMRegisters::d2; - static const FPRegisterID fpRegT3 = ARMRegisters::d3; + static const FPRegisterID fpRegT0 = ARM64Registers::q0; + static const FPRegisterID fpRegT1 = ARM64Registers::q1; + static const FPRegisterID fpRegT2 = ARM64Registers::q2; + static const FPRegisterID fpRegT3 = ARM64Registers::q3; + + static const RegisterID nonArgGPR1 = ARM64Registers::x9; #elif CPU(MIPS) static const RegisterID returnValueRegister = MIPSRegisters::v0; static const RegisterID cachedResultRegister = MIPSRegisters::v0; static const RegisterID firstArgumentRegister = MIPSRegisters::a0; +#if ENABLE(VALUE_PROFILER) + static const RegisterID bucketCounterRegister = MIPSRegisters::s3; +#endif + // regT0 must be v0 for returning a 32-bit value. static const RegisterID regT0 = MIPSRegisters::v0; @@ -147,37 +167,82 @@ namespace JSC { static const RegisterID regT3 = MIPSRegisters::s2; static const RegisterID callFrameRegister = MIPSRegisters::s0; - static const RegisterID timeoutCheckRegister = MIPSRegisters::s1; static const FPRegisterID fpRegT0 = MIPSRegisters::f4; static const FPRegisterID fpRegT1 = MIPSRegisters::f6; static const FPRegisterID fpRegT2 = MIPSRegisters::f8; - static const FPRegisterID fpRegT2 = MIPSRegisters::f10; + static const FPRegisterID fpRegT3 = MIPSRegisters::f10; +#elif CPU(SH4) + static const RegisterID callFrameRegister = SH4Registers::fp; + + static const RegisterID regT0 = SH4Registers::r0; + static const RegisterID regT1 = SH4Registers::r1; + static const RegisterID regT2 = SH4Registers::r2; + static const RegisterID regT3 = SH4Registers::r10; + static const RegisterID regT4 = SH4Registers::r4; + static const RegisterID regT5 = SH4Registers::r5; + static const RegisterID regT6 = SH4Registers::r6; + static const RegisterID regT7 = SH4Registers::r7; + static const RegisterID firstArgumentRegister =regT4; + + static const RegisterID returnValueRegister = SH4Registers::r0; + static const RegisterID cachedResultRegister = SH4Registers::r0; + + static const FPRegisterID fpRegT0 = SH4Registers::fr0; + static const FPRegisterID fpRegT1 = SH4Registers::fr2; + static const FPRegisterID fpRegT2 = SH4Registers::fr4; + static const FPRegisterID fpRegT3 = SH4Registers::fr6; + static const FPRegisterID fpRegT4 = SH4Registers::fr8; + static const FPRegisterID fpRegT5 = SH4Registers::fr10; + static const FPRegisterID fpRegT6 = SH4Registers::fr12; + static const FPRegisterID fpRegT7 = SH4Registers::fr14; #else #error "JIT not supported on this platform." #endif +#if USE(JSVALUE32_64) + // Can't just propogate JSValue::Int32Tag as visual studio doesn't like it + static const unsigned Int32Tag = 0xffffffff; + COMPILE_ASSERT(Int32Tag == JSValue::Int32Tag, Int32Tag_out_of_sync); +#else + static const unsigned Int32Tag = TagTypeNumber >> 32; +#endif inline Jump emitLoadJSCell(unsigned virtualRegisterIndex, RegisterID payload); inline Jump emitLoadInt32(unsigned virtualRegisterIndex, RegisterID dst); inline Jump emitLoadDouble(unsigned virtualRegisterIndex, FPRegisterID dst, RegisterID scratch); #if USE(JSVALUE32_64) inline Jump emitJumpIfNotJSCell(unsigned virtualRegisterIndex); - inline Address tagFor(unsigned index, RegisterID base = callFrameRegister); + inline Address tagFor(int index, RegisterID base = callFrameRegister); #endif -#if USE(JSVALUE32) || USE(JSVALUE64) +#if USE(JSVALUE64) + Jump emitJumpIfNotJSCell(RegisterID); Jump emitJumpIfImmediateNumber(RegisterID reg); Jump emitJumpIfNotImmediateNumber(RegisterID reg); void emitFastArithImmToInt(RegisterID reg); + void emitFastArithIntToImmNoCheck(RegisterID src, RegisterID dest); #endif - inline Address payloadFor(unsigned index, RegisterID base = callFrameRegister); - inline Address addressFor(unsigned index, RegisterID base = callFrameRegister); + Jump emitJumpIfNotType(RegisterID baseReg, RegisterID scratchReg, JSType); + + void emitGetFromCallFrameHeaderPtr(JSStack::CallFrameHeaderEntry, RegisterID to, RegisterID from = callFrameRegister); + void emitPutToCallFrameHeader(RegisterID from, JSStack::CallFrameHeaderEntry); + void emitPutImmediateToCallFrameHeader(void* value, JSStack::CallFrameHeaderEntry); + void emitPutCellToCallFrameHeader(RegisterID from, JSStack::CallFrameHeaderEntry); + + void preserveReturnAddressAfterCall(RegisterID); + void restoreReturnAddressBeforeReturn(RegisterID); + void restoreReturnAddressBeforeReturn(Address); + void restoreArgumentReference(); + + inline Address payloadFor(int index, RegisterID base = callFrameRegister); + inline Address intPayloadFor(int index, RegisterID base = callFrameRegister); + inline Address intTagFor(int index, RegisterID base = callFrameRegister); + inline Address addressFor(int index, RegisterID base = callFrameRegister); }; struct ThunkHelpers { - static unsigned stringImplDataOffset() { return WebCore::StringImpl::dataOffset(); } static unsigned jsStringLengthOffset() { return OBJECT_OFFSETOF(JSString, m_length); } static unsigned jsStringValueOffset() { return OBJECT_OFFSETOF(JSString, m_value); } }; @@ -192,34 +257,44 @@ namespace JSC { inline JSInterfaceJIT::Jump JSInterfaceJIT::emitJumpIfNotJSCell(unsigned virtualRegisterIndex) { ASSERT(static_cast(virtualRegisterIndex) < FirstConstantRegisterIndex); - return branch32(NotEqual, tagFor(virtualRegisterIndex), Imm32(JSValue::CellTag)); + return branch32(NotEqual, tagFor(virtualRegisterIndex), TrustedImm32(JSValue::CellTag)); } inline JSInterfaceJIT::Jump JSInterfaceJIT::emitLoadInt32(unsigned virtualRegisterIndex, RegisterID dst) { ASSERT(static_cast(virtualRegisterIndex) < FirstConstantRegisterIndex); loadPtr(payloadFor(virtualRegisterIndex), dst); - return branch32(NotEqual, tagFor(virtualRegisterIndex), Imm32(JSValue::Int32Tag)); + return branch32(NotEqual, tagFor(static_cast(virtualRegisterIndex)), TrustedImm32(JSValue::Int32Tag)); } - inline JSInterfaceJIT::Address JSInterfaceJIT::tagFor(unsigned virtualRegisterIndex, RegisterID base) + inline JSInterfaceJIT::Address JSInterfaceJIT::tagFor(int virtualRegisterIndex, RegisterID base) { - ASSERT(static_cast(virtualRegisterIndex) < FirstConstantRegisterIndex); - return Address(base, (virtualRegisterIndex * sizeof(Register)) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)); + ASSERT(virtualRegisterIndex < FirstConstantRegisterIndex); + return Address(base, (static_cast(virtualRegisterIndex) * sizeof(Register)) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)); } - inline JSInterfaceJIT::Address JSInterfaceJIT::payloadFor(unsigned virtualRegisterIndex, RegisterID base) + inline JSInterfaceJIT::Address JSInterfaceJIT::payloadFor(int virtualRegisterIndex, RegisterID base) { - ASSERT(static_cast(virtualRegisterIndex) < FirstConstantRegisterIndex); - return Address(base, (virtualRegisterIndex * sizeof(Register)) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)); + ASSERT(virtualRegisterIndex < FirstConstantRegisterIndex); + return Address(base, (static_cast(virtualRegisterIndex) * sizeof(Register)) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)); + } + + inline JSInterfaceJIT::Address JSInterfaceJIT::intPayloadFor(int virtualRegisterIndex, RegisterID base) + { + return payloadFor(virtualRegisterIndex, base); + } + + inline JSInterfaceJIT::Address JSInterfaceJIT::intTagFor(int virtualRegisterIndex, RegisterID base) + { + return tagFor(virtualRegisterIndex, base); } inline JSInterfaceJIT::Jump JSInterfaceJIT::emitLoadDouble(unsigned virtualRegisterIndex, FPRegisterID dst, RegisterID scratch) { ASSERT(static_cast(virtualRegisterIndex) < FirstConstantRegisterIndex); loadPtr(tagFor(virtualRegisterIndex), scratch); - Jump isDouble = branch32(Below, scratch, Imm32(JSValue::LowestTag)); - Jump notInt = branch32(NotEqual, scratch, Imm32(JSValue::Int32Tag)); + Jump isDouble = branch32(Below, scratch, TrustedImm32(JSValue::LowestTag)); + Jump notInt = branch32(NotEqual, scratch, TrustedImm32(JSValue::Int32Tag)); loadPtr(payloadFor(virtualRegisterIndex), scratch); convertInt32ToDouble(scratch, dst); Jump done = jump(); @@ -227,94 +302,202 @@ namespace JSC { loadDouble(addressFor(virtualRegisterIndex), dst); done.link(this); return notInt; - } + } + #endif #if USE(JSVALUE64) + ALWAYS_INLINE JSInterfaceJIT::Jump JSInterfaceJIT::emitJumpIfNotJSCell(RegisterID reg) + { + return branchTest64(NonZero, reg, tagMaskRegister); + } + ALWAYS_INLINE JSInterfaceJIT::Jump JSInterfaceJIT::emitJumpIfImmediateNumber(RegisterID reg) { - return branchTestPtr(NonZero, reg, tagTypeNumberRegister); + return branchTest64(NonZero, reg, tagTypeNumberRegister); } ALWAYS_INLINE JSInterfaceJIT::Jump JSInterfaceJIT::emitJumpIfNotImmediateNumber(RegisterID reg) { - return branchTestPtr(Zero, reg, tagTypeNumberRegister); + return branchTest64(Zero, reg, tagTypeNumberRegister); } inline JSInterfaceJIT::Jump JSInterfaceJIT::emitLoadJSCell(unsigned virtualRegisterIndex, RegisterID dst) { - loadPtr(addressFor(virtualRegisterIndex), dst); - return branchTestPtr(NonZero, dst, tagMaskRegister); + load64(addressFor(virtualRegisterIndex), dst); + return branchTest64(NonZero, dst, tagMaskRegister); } inline JSInterfaceJIT::Jump JSInterfaceJIT::emitLoadInt32(unsigned virtualRegisterIndex, RegisterID dst) { - loadPtr(addressFor(virtualRegisterIndex), dst); - Jump result = branchPtr(Below, dst, tagTypeNumberRegister); + load64(addressFor(virtualRegisterIndex), dst); + Jump result = branch64(Below, dst, tagTypeNumberRegister); zeroExtend32ToPtr(dst, dst); return result; } inline JSInterfaceJIT::Jump JSInterfaceJIT::emitLoadDouble(unsigned virtualRegisterIndex, FPRegisterID dst, RegisterID scratch) { - loadPtr(addressFor(virtualRegisterIndex), scratch); + load64(addressFor(virtualRegisterIndex), scratch); Jump notNumber = emitJumpIfNotImmediateNumber(scratch); - Jump notInt = branchPtr(Below, scratch, tagTypeNumberRegister); + Jump notInt = branch64(Below, scratch, tagTypeNumberRegister); convertInt32ToDouble(scratch, dst); Jump done = jump(); notInt.link(this); - addPtr(tagTypeNumberRegister, scratch); - movePtrToDouble(scratch, dst); + add64(tagTypeNumberRegister, scratch); + move64ToDouble(scratch, dst); done.link(this); return notNumber; } - + ALWAYS_INLINE void JSInterfaceJIT::emitFastArithImmToInt(RegisterID) { } + // operand is int32_t, must have been zero-extended if register is 64-bit. + ALWAYS_INLINE void JSInterfaceJIT::emitFastArithIntToImmNoCheck(RegisterID src, RegisterID dest) + { + if (src != dest) + move(src, dest); + or64(tagTypeNumberRegister, dest); + } #endif -#if USE(JSVALUE32) - inline JSInterfaceJIT::Jump JSInterfaceJIT::emitLoadJSCell(unsigned virtualRegisterIndex, RegisterID dst) +#if USE(JSVALUE64) + inline JSInterfaceJIT::Address JSInterfaceJIT::payloadFor(int virtualRegisterIndex, RegisterID base) { - loadPtr(addressFor(virtualRegisterIndex), dst); - return branchTest32(NonZero, dst, Imm32(JSImmediate::TagMask)); + ASSERT(virtualRegisterIndex < FirstConstantRegisterIndex); + return addressFor(virtualRegisterIndex, base); } - inline JSInterfaceJIT::Jump JSInterfaceJIT::emitLoadInt32(unsigned virtualRegisterIndex, RegisterID dst) + inline JSInterfaceJIT::Address JSInterfaceJIT::intPayloadFor(int virtualRegisterIndex, RegisterID base) { - loadPtr(addressFor(virtualRegisterIndex), dst); - Jump result = branchTest32(Zero, dst, Imm32(JSImmediate::TagTypeNumber)); - rshift32(Imm32(JSImmediate::IntegerPayloadShift), dst); - return result; + ASSERT(virtualRegisterIndex < FirstConstantRegisterIndex); + return Address(base, (static_cast(virtualRegisterIndex) * sizeof(Register)) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload)); + } + inline JSInterfaceJIT::Address JSInterfaceJIT::intTagFor(int virtualRegisterIndex, RegisterID base) + { + ASSERT(virtualRegisterIndex < FirstConstantRegisterIndex); + return Address(base, (static_cast(virtualRegisterIndex) * sizeof(Register)) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag)); + } +#endif + + ALWAYS_INLINE JSInterfaceJIT::Jump JSInterfaceJIT::emitJumpIfNotType(RegisterID baseReg, RegisterID scratchReg, JSType type) + { + loadPtr(Address(baseReg, JSCell::structureOffset()), scratchReg); + return branch8(NotEqual, Address(scratchReg, Structure::typeInfoTypeOffset()), TrustedImm32(type)); + } + + ALWAYS_INLINE void JSInterfaceJIT::emitGetFromCallFrameHeaderPtr(JSStack::CallFrameHeaderEntry entry, RegisterID to, RegisterID from) + { + loadPtr(Address(from, entry * sizeof(Register)), to); + } + + ALWAYS_INLINE void JSInterfaceJIT::emitPutToCallFrameHeader(RegisterID from, JSStack::CallFrameHeaderEntry entry) + { +#if USE(JSVALUE32_64) + storePtr(from, payloadFor(entry, callFrameRegister)); +#else + store64(from, addressFor(entry, callFrameRegister)); +#endif } - inline JSInterfaceJIT::Jump JSInterfaceJIT::emitLoadDouble(unsigned, FPRegisterID, RegisterID) + ALWAYS_INLINE void JSInterfaceJIT::emitPutImmediateToCallFrameHeader(void* value, JSStack::CallFrameHeaderEntry entry) { - ASSERT_NOT_REACHED(); - return jump(); + storePtr(TrustedImmPtr(value), Address(callFrameRegister, entry * sizeof(Register))); + } + + ALWAYS_INLINE void JSInterfaceJIT::emitPutCellToCallFrameHeader(RegisterID from, JSStack::CallFrameHeaderEntry entry) + { +#if USE(JSVALUE32_64) + store32(TrustedImm32(JSValue::CellTag), tagFor(entry, callFrameRegister)); + store32(from, payloadFor(entry, callFrameRegister)); +#else + store64(from, addressFor(entry, callFrameRegister)); +#endif + } + + inline JSInterfaceJIT::Address JSInterfaceJIT::addressFor(int virtualRegisterIndex, RegisterID base) + { + ASSERT(virtualRegisterIndex < FirstConstantRegisterIndex); + return Address(base, (static_cast(virtualRegisterIndex) * sizeof(Register))); + } + +#if CPU(ARM) || CPU(ARM64) + + ALWAYS_INLINE void JSInterfaceJIT::preserveReturnAddressAfterCall(RegisterID reg) + { + move(linkRegister, reg); } - ALWAYS_INLINE void JSInterfaceJIT::emitFastArithImmToInt(RegisterID reg) + ALWAYS_INLINE void JSInterfaceJIT::restoreReturnAddressBeforeReturn(RegisterID reg) { - rshift32(Imm32(JSImmediate::IntegerPayloadShift), reg); + move(reg, linkRegister); } -#endif + ALWAYS_INLINE void JSInterfaceJIT::restoreReturnAddressBeforeReturn(Address address) + { + loadPtr(address, linkRegister); + } +#elif CPU(SH4) -#if !USE(JSVALUE32_64) - inline JSInterfaceJIT::Address JSInterfaceJIT::payloadFor(unsigned virtualRegisterIndex, RegisterID base) + ALWAYS_INLINE void JSInterfaceJIT::preserveReturnAddressAfterCall(RegisterID reg) { - ASSERT(static_cast(virtualRegisterIndex) < FirstConstantRegisterIndex); - return addressFor(virtualRegisterIndex, base); + m_assembler.stspr(reg); + } + + ALWAYS_INLINE void JSInterfaceJIT::restoreReturnAddressBeforeReturn(RegisterID reg) + { + m_assembler.ldspr(reg); + } + + ALWAYS_INLINE void JSInterfaceJIT::restoreReturnAddressBeforeReturn(Address address) + { + loadPtrLinkReg(address); + } + +#elif CPU(MIPS) + + ALWAYS_INLINE void JSInterfaceJIT::preserveReturnAddressAfterCall(RegisterID reg) + { + move(returnAddressRegister, reg); + } + + ALWAYS_INLINE void JSInterfaceJIT::restoreReturnAddressBeforeReturn(RegisterID reg) + { + move(reg, returnAddressRegister); } + + ALWAYS_INLINE void JSInterfaceJIT::restoreReturnAddressBeforeReturn(Address address) + { + loadPtr(address, returnAddressRegister); + } + +#else // CPU(X86) || CPU(X86_64) + + ALWAYS_INLINE void JSInterfaceJIT::preserveReturnAddressAfterCall(RegisterID reg) + { + pop(reg); + } + + ALWAYS_INLINE void JSInterfaceJIT::restoreReturnAddressBeforeReturn(RegisterID reg) + { + push(reg); + } + + ALWAYS_INLINE void JSInterfaceJIT::restoreReturnAddressBeforeReturn(Address address) + { + push(address); + } + #endif - inline JSInterfaceJIT::Address JSInterfaceJIT::addressFor(unsigned virtualRegisterIndex, RegisterID base) + ALWAYS_INLINE void JSInterfaceJIT::restoreArgumentReference() { - ASSERT(static_cast(virtualRegisterIndex) < FirstConstantRegisterIndex); - return Address(base, (virtualRegisterIndex * sizeof(Register))); + move(stackPointerRegister, firstArgumentRegister); + poke(callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*)); } -} +} // namespace JSC + +#endif // ENABLE(JIT) #endif // JSInterfaceJIT_h