Changeset 158315 in webkit
- Timestamp:
- Oct 30, 2013 2:26:46 PM (10 years ago)
- Location:
- trunk/Source/JavaScriptCore
- Files:
-
- 23 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Source/JavaScriptCore/ChangeLog
r158313 r158315 1 2013-10-30 Mark Lam <mark.lam@apple.com> 2 3 Adjust CallFrameHeader's ReturnPC and CallFrame locations to match the native ABI . 4 https://bugs.webkit.org/show_bug.cgi?id=123444. 5 6 Reviewed by Geoffrey Garen. 7 8 - Introduced an explicit CallerFrameAndPC struct. 9 - A CallFrame is expected to start with a CallerFrameAndPC struct. 10 - The Register class no longer supports CallFrame* and Instruction*. 11 12 These hides the differences between JSVALUE32_64 and JSVALUE64 in 13 terms of managing the callerFrame() and returnPC() values. 14 15 - Convert all uses of JSStack::CallerFrame and JSStack::ReturnPC to 16 go through CallFrame to access the appropriate values and offsets. 17 CallFrame, in turn, will access the callerFrame and returnPC via 18 the CallerFrameAndPC struct. 19 20 - InlineCallFrame will provide offsets for its callerFrame and 21 returnPC. It will make use of CallFrame::callerFrameOffset() and 22 CallerFrame::returnPCOffset() to compute these. 23 24 * bytecode/CodeOrigin.h: 25 (JSC::InlineCallFrame::callerFrameOffset): 26 (JSC::InlineCallFrame::returnPCOffset): 27 * dfg/DFGJITCompiler.cpp: 28 (JSC::DFG::JITCompiler::compileEntry): 29 (JSC::DFG::JITCompiler::compileExceptionHandlers): 30 * dfg/DFGOSRExitCompilerCommon.cpp: 31 (JSC::DFG::reifyInlinedCallFrames): 32 * dfg/DFGSpeculativeJIT.h: 33 (JSC::DFG::SpeculativeJIT::calleeFrameSlot): 34 (JSC::DFG::SpeculativeJIT::calleeArgumentSlot): 35 (JSC::DFG::SpeculativeJIT::calleeFrameTagSlot): 36 (JSC::DFG::SpeculativeJIT::calleeFramePayloadSlot): 37 (JSC::DFG::SpeculativeJIT::calleeArgumentTagSlot): 38 (JSC::DFG::SpeculativeJIT::calleeArgumentPayloadSlot): 39 - Prefixed all the above with callee since they apply to the callee frame. 40 (JSC::DFG::SpeculativeJIT::calleeFrameCallerFrame): 41 - Added to set the callerFrame pointer in the callee frame. 42 43 * dfg/DFGSpeculativeJIT32_64.cpp: 44 (JSC::DFG::SpeculativeJIT::emitCall): 45 (JSC::DFG::SpeculativeJIT::compile): 46 * dfg/DFGSpeculativeJIT64.cpp: 47 (JSC::DFG::SpeculativeJIT::emitCall): 48 (JSC::DFG::SpeculativeJIT::compile): 49 * ftl/FTLLink.cpp: 50 (JSC::FTL::compileEntry): 51 (JSC::FTL::link): 52 * interpreter/CallFrame.h: 53 (JSC::ExecState::callerFrame): 54 (JSC::ExecState::callerFrameOffset): 55 (JSC::ExecState::returnPC): 56 (JSC::ExecState::hasReturnPC): 57 (JSC::ExecState::clearReturnPC): 58 (JSC::ExecState::returnPCOffset): 59 (JSC::ExecState::setCallerFrame): 60 (JSC::ExecState::setReturnPC): 61 (JSC::ExecState::callerFrameAndPC): 62 * interpreter/JSStack.h: 63 * interpreter/Register.h: 64 * jit/AssemblyHelpers.h: 65 (JSC::AssemblyHelpers::emitPutToCallFrameHeader): 66 - Convert to using storePtr() here and simplify the code. 67 (JSC::AssemblyHelpers::emitGetCallerFrameFromCallFrameHeaderPtr): 68 (JSC::AssemblyHelpers::emitPutCallerFrameToCallFrameHeader): 69 (JSC::AssemblyHelpers::emitGetReturnPCFromCallFrameHeaderPtr): 70 (JSC::AssemblyHelpers::emitPutReturnPCToCallFrameHeader): 71 - Helpers to emit gets/puts of the callerFrame and returnPC. 72 (JSC::AssemblyHelpers::addressForByteOffset): 73 * jit/JIT.cpp: 74 (JSC::JIT::JIT): 75 (JSC::JIT::privateCompile): 76 (JSC::JIT::privateCompileExceptionHandlers): 77 * jit/JITCall.cpp: 78 (JSC::JIT::compileCallEval): 79 (JSC::JIT::compileOpCall): 80 * jit/JITCall32_64.cpp: 81 (JSC::JIT::emit_op_ret): 82 (JSC::JIT::emit_op_ret_object_or_this): 83 (JSC::JIT::compileCallEval): 84 (JSC::JIT::compileOpCall): 85 * jit/JITInlines.h: 86 (JSC::JIT::unmap): 87 * jit/JITOpcodes.cpp: 88 (JSC::JIT::emit_op_end): 89 (JSC::JIT::emit_op_ret): 90 (JSC::JIT::emit_op_ret_object_or_this): 91 * jit/JITOpcodes32_64.cpp: 92 (JSC::JIT::privateCompileCTINativeCall): 93 (JSC::JIT::emit_op_end): 94 * jit/JITOperations.cpp: 95 * jit/SpecializedThunkJIT.h: 96 (JSC::SpecializedThunkJIT::returnJSValue): 97 (JSC::SpecializedThunkJIT::returnDouble): 98 (JSC::SpecializedThunkJIT::returnInt32): 99 (JSC::SpecializedThunkJIT::returnJSCell): 100 * jit/ThunkGenerators.cpp: 101 (JSC::throwExceptionFromCallSlowPathGenerator): 102 (JSC::slowPathFor): 103 (JSC::nativeForGenerator): 104 105 * llint/LLIntData.cpp: 106 (JSC::LLInt::Data::performAssertions): 107 * llint/LowLevelInterpreter.asm: 108 - Updated offsets and asserts to match the new CallFrame layout. 109 1 110 2013-10-30 Filip Pizlo <fpizlo@apple.com> 2 111 -
trunk/Source/JavaScriptCore/bytecode/CodeOrigin.h
r157660 r158315 143 143 CodeBlock* baselineCodeBlock() const; 144 144 145 ptrdiff_t callerFrameOffset() const { return stackOffset * sizeof(Register) + CallFrame::callerFrameOffset(); } 146 ptrdiff_t returnPCOffset() const { return stackOffset * sizeof(Register) + CallFrame::returnPCOffset(); } 147 145 148 void dumpBriefFunctionInformation(PrintStream&) const; 146 149 void dump(PrintStream&) const; -
trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp
r158304 r158315 100 100 // both normal return code and when jumping to an exception handler). 101 101 preserveReturnAddressAfterCall(GPRInfo::regT2); 102 emitPut ToCallFrameHeader(GPRInfo::regT2, JSStack::ReturnPC);102 emitPutReturnPCToCallFrameHeader(GPRInfo::regT2); 103 103 emitPutImmediateToCallFrameHeader(m_codeBlock, JSStack::CodeBlock); 104 104 } … … 128 128 // Remove hostCallFrameFlag from caller. 129 129 m_exceptionChecksWithCallFrameRollback.link(this); 130 emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,GPRInfo::argumentGPR0);130 emitGetCallerFrameFromCallFrameHeaderPtr(GPRInfo::argumentGPR0); 131 131 andPtr(TrustedImm32(safeCast<int32_t>(~CallFrame::hostCallFrameFlag())), GPRInfo::argumentGPR0); 132 132 doLookup = jump(); -
trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.cpp
r157035 r158315 112 112 if (!inlineCallFrame->isClosureCall) 113 113 jit.store64(AssemblyHelpers::TrustedImm64(JSValue::encode(JSValue(inlineCallFrame->calleeConstant()->scope()))), AssemblyHelpers::addressFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::ScopeChain))); 114 jit.store64(callerFrameGPR, AssemblyHelpers::addressFor ((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::CallerFrame)));115 jit.storePtr(AssemblyHelpers::TrustedImmPtr(jumpTarget), AssemblyHelpers::addressFor ((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::ReturnPC)));114 jit.store64(callerFrameGPR, AssemblyHelpers::addressForByteOffset(inlineCallFrame->callerFrameOffset())); 115 jit.storePtr(AssemblyHelpers::TrustedImmPtr(jumpTarget), AssemblyHelpers::addressForByteOffset(inlineCallFrame->returnPCOffset())); 116 116 uint32_t locationBits = CallFrame::Location::encodeAsBytecodeOffset(codeOrigin.bytecodeIndex); 117 117 jit.store32(AssemblyHelpers::TrustedImm32(locationBits), AssemblyHelpers::tagFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::ArgumentCount))); … … 128 128 if (!inlineCallFrame->isClosureCall) 129 129 jit.storePtr(AssemblyHelpers::TrustedImmPtr(inlineCallFrame->calleeConstant()->scope()), AssemblyHelpers::payloadFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::ScopeChain))); 130 jit.store32(AssemblyHelpers::TrustedImm32(JSValue::CellTag), AssemblyHelpers::tagFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::CallerFrame))); 131 jit.storePtr(callerFrameGPR, AssemblyHelpers::payloadFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::CallerFrame))); 132 jit.storePtr(AssemblyHelpers::TrustedImmPtr(jumpTarget), AssemblyHelpers::payloadFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::ReturnPC))); 130 jit.storePtr(callerFrameGPR, AssemblyHelpers::addressForByteOffset(inlineCallFrame->callerFrameOffset())); 131 jit.storePtr(AssemblyHelpers::TrustedImmPtr(jumpTarget), AssemblyHelpers::addressForByteOffset(inlineCallFrame->returnPCOffset())); 133 132 Instruction* instruction = baselineCodeBlock->instructions().begin() + codeOrigin.bytecodeIndex; 134 133 uint32_t locationBits = CallFrame::Location::encodeAsBytecodeInstruction(instruction); -
trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h
r158304 r158315 732 732 733 733 // Access to our fixed callee CallFrame. 734 MacroAssembler::Address call FrameSlot(int numArgs, int slot)734 MacroAssembler::Address calleeFrameSlot(int numArgs, int slot) 735 735 { 736 736 return MacroAssembler::Address(GPRInfo::callFrameRegister, calleeFrameOffset(numArgs) + sizeof(Register) * slot); … … 738 738 739 739 // Access to our fixed callee CallFrame. 740 MacroAssembler::Address argumentSlot(int numArgs, int argument) 741 { 742 return callFrameSlot(numArgs, virtualRegisterForArgument(argument).offset()); 743 } 744 745 MacroAssembler::Address callFrameTagSlot(int numArgs, int slot) 746 { 747 return callFrameSlot(numArgs, slot).withOffset(OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag)); 748 } 749 750 MacroAssembler::Address callFramePayloadSlot(int numArgs, int slot) 751 { 752 return callFrameSlot(numArgs, slot).withOffset(OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload)); 753 } 754 755 MacroAssembler::Address argumentTagSlot(int numArgs, int argument) 756 { 757 return argumentSlot(numArgs, argument).withOffset(OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag)); 758 } 759 760 MacroAssembler::Address argumentPayloadSlot(int numArgs, int argument) 761 { 762 return argumentSlot(numArgs, argument).withOffset(OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload)); 740 MacroAssembler::Address calleeArgumentSlot(int numArgs, int argument) 741 { 742 return calleeFrameSlot(numArgs, virtualRegisterForArgument(argument).offset()); 743 } 744 745 MacroAssembler::Address calleeFrameTagSlot(int numArgs, int slot) 746 { 747 return calleeFrameSlot(numArgs, slot).withOffset(OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag)); 748 } 749 750 MacroAssembler::Address calleeFramePayloadSlot(int numArgs, int slot) 751 { 752 return calleeFrameSlot(numArgs, slot).withOffset(OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload)); 753 } 754 755 MacroAssembler::Address calleeArgumentTagSlot(int numArgs, int argument) 756 { 757 return calleeArgumentSlot(numArgs, argument).withOffset(OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag)); 758 } 759 760 MacroAssembler::Address calleeArgumentPayloadSlot(int numArgs, int argument) 761 { 762 return calleeArgumentSlot(numArgs, argument).withOffset(OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload)); 763 } 764 765 MacroAssembler::Address calleeFrameCallerFrame(int numArgs) 766 { 767 return calleeFrameSlot(numArgs, 0).withOffset(CallFrame::callerFrameOffset()); 763 768 } 764 769 -
trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp
r158304 r158315 660 660 int numArgs = numPassedArgs + dummyThisArgument; 661 661 662 m_jit.store32(MacroAssembler::TrustedImm32(numArgs), call FramePayloadSlot(numArgs, JSStack::ArgumentCount));663 m_jit.storePtr(GPRInfo::callFrameRegister, call FramePayloadSlot(numArgs, JSStack::CallerFrame));664 m_jit.store32(calleePayloadGPR, call FramePayloadSlot(numArgs, JSStack::Callee));665 m_jit.store32(calleeTagGPR, call FrameTagSlot(numArgs, JSStack::Callee));662 m_jit.store32(MacroAssembler::TrustedImm32(numArgs), calleeFramePayloadSlot(numArgs, JSStack::ArgumentCount)); 663 m_jit.storePtr(GPRInfo::callFrameRegister, calleeFrameCallerFrame(numArgs)); 664 m_jit.store32(calleePayloadGPR, calleeFramePayloadSlot(numArgs, JSStack::Callee)); 665 m_jit.store32(calleeTagGPR, calleeFrameTagSlot(numArgs, JSStack::Callee)); 666 666 667 667 for (int i = 0; i < numPassedArgs; i++) { … … 672 672 use(argEdge); 673 673 674 m_jit.store32(argTagGPR, argumentTagSlot(numArgs, i + dummyThisArgument));675 m_jit.store32(argPayloadGPR, argumentPayloadSlot(numArgs, i + dummyThisArgument));674 m_jit.store32(argTagGPR, calleeArgumentTagSlot(numArgs, i + dummyThisArgument)); 675 m_jit.store32(argPayloadGPR, calleeArgumentPayloadSlot(numArgs, i + dummyThisArgument)); 676 676 } 677 677 … … 3094 3094 3095 3095 // Grab the return address. 3096 m_jit.emitGet FromCallFrameHeaderPtr(JSStack::ReturnPC,GPRInfo::regT2);3096 m_jit.emitGetReturnPCFromCallFrameHeaderPtr(GPRInfo::regT2); 3097 3097 // Restore our caller's "r". 3098 m_jit.emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,GPRInfo::callFrameRegister);3098 m_jit.emitGetCallerFrameFromCallFrameHeaderPtr(GPRInfo::callFrameRegister); 3099 3099 // Return. 3100 3100 m_jit.restoreReturnAddressBeforeReturn(GPRInfo::regT2); -
trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp
r158304 r158315 684 684 int numArgs = numPassedArgs + dummyThisArgument; 685 685 686 m_jit.store32(MacroAssembler::TrustedImm32(numArgs), call FramePayloadSlot(numArgs, JSStack::ArgumentCount));687 m_jit.store64(GPRInfo::callFrameRegister, call FrameSlot(numArgs, JSStack::CallerFrame));688 m_jit.store64(calleeGPR, call FrameSlot(numArgs, JSStack::Callee));686 m_jit.store32(MacroAssembler::TrustedImm32(numArgs), calleeFramePayloadSlot(numArgs, JSStack::ArgumentCount)); 687 m_jit.store64(GPRInfo::callFrameRegister, calleeFrameCallerFrame(numArgs)); 688 m_jit.store64(calleeGPR, calleeFrameSlot(numArgs, JSStack::Callee)); 689 689 690 690 for (int i = 0; i < numPassedArgs; i++) { … … 694 694 use(argEdge); 695 695 696 m_jit.store64(argGPR, argumentSlot(numArgs, i + dummyThisArgument));696 m_jit.store64(argGPR, calleeArgumentSlot(numArgs, i + dummyThisArgument)); 697 697 } 698 698 … … 3414 3414 3415 3415 // Grab the return address. 3416 m_jit.emitGet FromCallFrameHeaderPtr(JSStack::ReturnPC,GPRInfo::regT1);3416 m_jit.emitGetReturnPCFromCallFrameHeaderPtr(GPRInfo::regT1); 3417 3417 // Restore our caller's "r". 3418 m_jit.emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,GPRInfo::callFrameRegister);3418 m_jit.emitGetCallerFrameFromCallFrameHeaderPtr(GPRInfo::callFrameRegister); 3419 3419 // Return. 3420 3420 m_jit.restoreReturnAddressBeforeReturn(GPRInfo::regT1); -
trunk/Source/JavaScriptCore/ftl/FTLLink.cpp
r158116 r158315 47 47 { 48 48 jit.preserveReturnAddressAfterCall(GPRInfo::regT2); 49 jit.emitPut ToCallFrameHeader(GPRInfo::regT2, JSStack::ReturnPC);49 jit.emitPutReturnPCToCallFrameHeader(GPRInfo::regT2); 50 50 jit.emitPutImmediateToCallFrameHeader(jit.codeBlock(), JSStack::CodeBlock); 51 51 } … … 94 94 GPRInfo::nonArgGPR0); 95 95 jit.call(GPRInfo::nonArgGPR0); 96 jit.emitGet FromCallFrameHeaderPtr(JSStack::ReturnPC,GPRInfo::regT1);97 jit.emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,GPRInfo::callFrameRegister);96 jit.emitGetReturnPCFromCallFrameHeaderPtr(GPRInfo::regT1); 97 jit.emitGetCallerFrameFromCallFrameHeaderPtr(GPRInfo::callFrameRegister); 98 98 jit.restoreReturnAddressBeforeReturn(GPRInfo::regT1); 99 99 jit.ret(); … … 163 163 GPRInfo::nonArgGPR0); 164 164 jit.call(GPRInfo::nonArgGPR0); 165 jit.emitGet FromCallFrameHeaderPtr(JSStack::ReturnPC,GPRInfo::regT1);166 jit.emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,GPRInfo::callFrameRegister);165 jit.emitGetReturnPCFromCallFrameHeaderPtr(GPRInfo::regT1); 166 jit.emitGetCallerFrameFromCallFrameHeaderPtr(GPRInfo::callFrameRegister); 167 167 jit.restoreReturnAddressBeforeReturn(GPRInfo::regT1); 168 168 jit.ret(); -
trunk/Source/JavaScriptCore/interpreter/CallFrame.h
r158237 r158315 113 113 CallFrame& operator=(const Register& r) { *static_cast<Register*>(this) = r; return *this; } 114 114 115 CallFrame* callerFrame() const { return this[JSStack::CallerFrame].callFrame(); } 116 #if ENABLE(JIT) || ENABLE(LLINT) 117 ReturnAddressPtr returnPC() const { return ReturnAddressPtr(this[JSStack::ReturnPC].vPC()); } 118 bool hasReturnPC() const { return !!this[JSStack::ReturnPC].vPC(); } 119 void clearReturnPC() { registers()[JSStack::ReturnPC] = static_cast<Instruction*>(0); } 120 #endif 115 CallFrame* callerFrame() const { return callerFrameAndPC().callerFrame; } 116 static ptrdiff_t callerFrameOffset() { return OBJECT_OFFSETOF(CallerFrameAndPC, callerFrame); } 117 118 ReturnAddressPtr returnPC() const { return ReturnAddressPtr(callerFrameAndPC().pc); } 119 bool hasReturnPC() const { return !!callerFrameAndPC().pc; } 120 void clearReturnPC() { callerFrameAndPC().pc = 0; } 121 static ptrdiff_t returnPCOffset() { return OBJECT_OFFSETOF(CallerFrameAndPC, pc); } 121 122 AbstractPC abstractReturnPC(VM& vm) { return AbstractPC(vm, this); } 122 123 … … 200 201 #endif 201 202 202 void setCallerFrame(CallFrame* callerFrame) { static_cast<Register*>(this)[JSStack::CallerFrame] = callerFrame; }203 void setCallerFrame(CallFrame* frame) { callerFrameAndPC().callerFrame = frame; } 203 204 void setScope(JSScope* scope) { static_cast<Register*>(this)[JSStack::ScopeChain] = scope; } 204 205 … … 275 276 void setCallee(JSObject* callee) { static_cast<Register*>(this)[JSStack::Callee] = Register::withCallee(callee); } 276 277 void setCodeBlock(CodeBlock* codeBlock) { static_cast<Register*>(this)[JSStack::CodeBlock] = codeBlock; } 277 void setReturnPC(void* value) { static_cast<Register*>(this)[JSStack::ReturnPC] = (Instruction*)value; }278 278 void setReturnPC(void* value) { callerFrameAndPC().pc = reinterpret_cast<Instruction*>(value); } 279 279 280 CallFrame* callerFrameNoFlags() { return callerFrame()->removeHostCallFrameFlag(); } 280 281 … … 325 326 } 326 327 328 CallerFrameAndPC& callerFrameAndPC() { return *reinterpret_cast<CallerFrameAndPC*>(this); } 329 const CallerFrameAndPC& callerFrameAndPC() const { return *reinterpret_cast<const CallerFrameAndPC*>(this); } 330 327 331 friend class JSStack; 328 332 friend class VMInspector; -
trunk/Source/JavaScriptCore/interpreter/JSStack.h
r158237 r158315 49 49 class LLIntOffsetsExtractor; 50 50 51 struct Instruction; 52 typedef ExecState CallFrame; 53 54 struct CallerFrameAndPC { 55 CallFrame* callerFrame; 56 Instruction* pc; 57 }; 58 51 59 class JSStack { 52 60 WTF_MAKE_NONCOPYABLE(JSStack); 53 61 public: 54 62 enum CallFrameHeaderEntry { 55 C allFrameHeaderSize = 6,56 FirstArgument = 7,57 ThisArgument = 6,58 ArgumentCount = 5,59 Call erFrame = 4,60 Callee = 3, 61 ScopeChain = 2,62 ReturnPC = 1, // This is either an Instruction* or a pointer into JIT generated code stored as an Instruction*.63 CodeBlock = 0,63 CodeBlock = sizeof(CallerFrameAndPC) / sizeof(Register), 64 ScopeChain, 65 Callee, 66 ArgumentCount, 67 CallFrameHeaderSize, 68 69 // The following entries are not part of the CallFrameHeader but are provided here as a convenience: 70 ThisArgument = CallFrameHeaderSize, 71 FirstArgument, 64 72 }; 65 73 -
trunk/Source/JavaScriptCore/interpreter/Register.h
r156677 r158315 43 43 class JSScope; 44 44 45 struct Instruction;46 47 45 typedef ExecState CallFrame; 48 46 … … 57 55 EncodedJSValue encodedJSValue() const; 58 56 59 Register& operator=(CallFrame*);60 57 Register& operator=(CodeBlock*); 61 58 Register& operator=(JSScope*); 62 Register& operator=(Instruction*);63 59 64 60 int32_t i() const; 65 61 JSActivation* activation() const; 66 CallFrame* callFrame() const;67 62 CodeBlock* codeBlock() const; 68 63 JSObject* function() const; 69 64 JSPropertyNameIterator* propertyNameIterator() const; 70 65 JSScope* scope() const; 71 Instruction* vPC() const;72 66 int32_t unboxedInt32() const; 73 67 int64_t unboxedInt52() const; … … 92 86 union { 93 87 EncodedJSValue value; 94 CallFrame* callFrame;95 88 CodeBlock* codeBlock; 96 Instruction* vPC;97 89 EncodedValueDescriptor encodedValue; 98 90 double number; … … 131 123 // Interpreter functions 132 124 133 ALWAYS_INLINE Register& Register::operator=(CallFrame* callFrame)134 {135 u.callFrame = callFrame;136 return *this;137 }138 139 125 ALWAYS_INLINE Register& Register::operator=(CodeBlock* codeBlock) 140 126 { … … 143 129 } 144 130 145 ALWAYS_INLINE Register& Register::operator=(Instruction* vPC)146 {147 u.vPC = vPC;148 return *this;149 }150 151 131 ALWAYS_INLINE int32_t Register::i() const 152 132 { … … 154 134 } 155 135 156 ALWAYS_INLINE CallFrame* Register::callFrame() const157 {158 return u.callFrame;159 }160 161 136 ALWAYS_INLINE CodeBlock* Register::codeBlock() const 162 137 { 163 138 return u.codeBlock; 164 }165 166 ALWAYS_INLINE Instruction* Register::vPC() const167 {168 return u.vPC;169 139 } 170 140 -
trunk/Source/JavaScriptCore/jit/AssemblyHelpers.h
r157685 r158315 134 134 void emitPutToCallFrameHeader(GPRReg from, JSStack::CallFrameHeaderEntry entry) 135 135 { 136 #if USE(JSVALUE64) 137 store64(from, Address(GPRInfo::callFrameRegister, entry * sizeof(Register))); 138 #else 139 store32(from, Address(GPRInfo::callFrameRegister, entry * sizeof(Register))); 140 #endif 136 storePtr(from, Address(GPRInfo::callFrameRegister, entry * sizeof(Register))); 141 137 } 142 138 … … 144 140 { 145 141 storePtr(TrustedImmPtr(value), Address(GPRInfo::callFrameRegister, entry * sizeof(Register))); 142 } 143 144 void emitGetCallerFrameFromCallFrameHeaderPtr(RegisterID to) 145 { 146 loadPtr(Address(GPRInfo::callFrameRegister, CallFrame::callerFrameOffset()), to); 147 } 148 void emitPutCallerFrameToCallFrameHeader(RegisterID from) 149 { 150 storePtr(from, Address(GPRInfo::callFrameRegister, CallFrame::callerFrameOffset())); 151 } 152 153 void emitGetReturnPCFromCallFrameHeaderPtr(RegisterID to) 154 { 155 loadPtr(Address(GPRInfo::callFrameRegister, CallFrame::returnPCOffset()), to); 156 } 157 void emitPutReturnPCToCallFrameHeader(RegisterID from) 158 { 159 storePtr(from, Address(GPRInfo::callFrameRegister, CallFrame::returnPCOffset())); 160 } 161 void emitPutReturnPCToCallFrameHeader(TrustedImmPtr from) 162 { 163 storePtr(from, Address(GPRInfo::callFrameRegister, CallFrame::returnPCOffset())); 146 164 } 147 165 … … 155 173 } 156 174 175 static Address addressForByteOffset(ptrdiff_t byteOffset) 176 { 177 return Address(GPRInfo::callFrameRegister, byteOffset); 178 } 157 179 static Address addressFor(VirtualRegister virtualRegister) 158 180 { -
trunk/Source/JavaScriptCore/jit/JIT.cpp
r158237 r158315 84 84 , m_jumpTargetIndex(0) 85 85 , m_mappedBytecodeOffset((unsigned)-1) 86 , m_mappedVirtualRegisterIndex( JSStack::ReturnPC)86 , m_mappedVirtualRegisterIndex(UINT_MAX) 87 87 , m_mappedTag((RegisterID)-1) 88 88 , m_mappedPayload((RegisterID)-1) … … 548 548 549 549 preserveReturnAddressAfterCall(regT2); 550 emitPut ToCallFrameHeader(regT2, JSStack::ReturnPC);550 emitPutReturnPCToCallFrameHeader(regT2); 551 551 emitPutImmediateToCallFrameHeader(m_codeBlock, JSStack::CodeBlock); 552 552 … … 613 613 store8(TrustedImm32(0), &m_codeBlock->m_shouldAlwaysBeInlined); 614 614 preserveReturnAddressAfterCall(regT2); 615 emitPut ToCallFrameHeader(regT2, JSStack::ReturnPC);615 emitPutReturnPCToCallFrameHeader(regT2); 616 616 emitPutImmediateToCallFrameHeader(m_codeBlock, JSStack::CodeBlock); 617 617 … … 803 803 // Remove hostCallFlag from caller 804 804 m_exceptionChecksWithCallFrameRollback.link(this); 805 emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,GPRInfo::argumentGPR0);805 emitGetCallerFrameFromCallFrameHeaderPtr(GPRInfo::argumentGPR0); 806 806 andPtr(TrustedImm32(safeCast<int32_t>(~CallFrame::hostCallFrameFlag())), GPRInfo::argumentGPR0); 807 807 doLookup = jump(); -
trunk/Source/JavaScriptCore/jit/JITCall.cpp
r157603 r158315 132 132 callOperationWithCallFrameRollbackOnException(operationCallEval); 133 133 addSlowCase(branch64(Equal, regT0, TrustedImm64(JSValue::encode(JSValue())))); 134 emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,callFrameRegister);134 emitGetCallerFrameFromCallFrameHeaderPtr(callFrameRegister); 135 135 136 136 sampleCodeBlock(m_codeBlock); … … 192 192 emitGetVirtualRegister(callee, regT0); // regT0 holds callee. 193 193 194 store64(callFrameRegister, Address(regT1, JSStack::CallerFrame * static_cast<int>(sizeof(Register))));194 store64(callFrameRegister, Address(regT1, CallFrame::callerFrameOffset())); 195 195 store64(regT0, Address(regT1, JSStack::Callee * static_cast<int>(sizeof(Register)))); 196 196 move(regT1, callFrameRegister); -
trunk/Source/JavaScriptCore/jit/JITCall32_64.cpp
r157603 r158315 62 62 63 63 emitLoad(dst, regT1, regT0); 64 emitGet FromCallFrameHeaderPtr(JSStack::ReturnPC,regT2);65 emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,callFrameRegister);64 emitGetReturnPCFromCallFrameHeaderPtr(regT2); 65 emitGetCallerFrameFromCallFrameHeaderPtr(callFrameRegister); 66 66 67 67 restoreReturnAddressBeforeReturn(regT2); … … 79 79 Jump notObject = emitJumpIfNotObject(regT2); 80 80 81 emitGet FromCallFrameHeaderPtr(JSStack::ReturnPC,regT2);82 emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,callFrameRegister);81 emitGetReturnPCFromCallFrameHeaderPtr(regT2); 82 emitGetCallerFrameFromCallFrameHeaderPtr(callFrameRegister); 83 83 84 84 restoreReturnAddressBeforeReturn(regT2); … … 89 89 emitLoad(thisReg, regT1, regT0); 90 90 91 emitGet FromCallFrameHeaderPtr(JSStack::ReturnPC,regT2);92 emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,callFrameRegister);91 emitGetReturnPCFromCallFrameHeaderPtr(regT2); 92 emitGetCallerFrameFromCallFrameHeaderPtr(callFrameRegister); 93 93 94 94 restoreReturnAddressBeforeReturn(regT2); … … 203 203 callOperationWithCallFrameRollbackOnException(operationCallEval); 204 204 addSlowCase(branch32(Equal, regT1, TrustedImm32(JSValue::EmptyValueTag))); 205 emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,callFrameRegister);205 emitGetCallerFrameFromCallFrameHeaderPtr(callFrameRegister); 206 206 207 207 sampleCodeBlock(m_codeBlock); … … 263 263 emitLoad(callee, regT1, regT0); // regT1, regT0 holds callee. 264 264 265 storePtr(callFrameRegister, Address( regT3, JSStack::CallerFrame * static_cast<int>(sizeof(Register))));265 storePtr(callFrameRegister, Address(GPRInfo::regT3, CallFrame::callerFrameOffset())); 266 266 emitStore(JSStack::Callee, regT1, regT0, regT3); 267 267 move(regT3, callFrameRegister); -
trunk/Source/JavaScriptCore/jit/JITInlines.h
r157797 r158315 993 993 { 994 994 m_mappedBytecodeOffset = (unsigned)-1; 995 m_mappedVirtualRegisterIndex = JSStack::ReturnPC;995 m_mappedVirtualRegisterIndex = UINT_MAX; 996 996 m_mappedTag = (RegisterID)-1; 997 997 m_mappedPayload = (RegisterID)-1; -
trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp
r157746 r158315 86 86 RELEASE_ASSERT(returnValueRegister != callFrameRegister); 87 87 emitGetVirtualRegister(currentInstruction[1].u.operand, returnValueRegister); 88 restoreReturnAddressBeforeReturn(Address(callFrameRegister, JSStack::ReturnPC * static_cast<int>(sizeof(Register))));88 restoreReturnAddressBeforeReturn(Address(callFrameRegister, CallFrame::returnPCOffset())); 89 89 ret(); 90 90 } … … 276 276 277 277 // Grab the return address. 278 emitGet FromCallFrameHeaderPtr(JSStack::ReturnPC,regT1);278 emitGetReturnPCFromCallFrameHeaderPtr(regT1); 279 279 280 280 // Restore our caller's "r". 281 emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,callFrameRegister);281 emitGetCallerFrameFromCallFrameHeaderPtr(callFrameRegister); 282 282 283 283 // Return. … … 299 299 300 300 // Grab the return address. 301 emitGet FromCallFrameHeaderPtr(JSStack::ReturnPC,regT1);301 emitGetReturnPCFromCallFrameHeaderPtr(regT1); 302 302 303 303 // Restore our caller's "r". 304 emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,callFrameRegister);304 emitGetCallerFrameFromCallFrameHeaderPtr(callFrameRegister); 305 305 306 306 // Return. … … 314 314 315 315 // Grab the return address. 316 emitGet FromCallFrameHeaderPtr(JSStack::ReturnPC,regT1);316 emitGetReturnPCFromCallFrameHeaderPtr(regT1); 317 317 318 318 // Restore our caller's "r". 319 emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,callFrameRegister);319 emitGetCallerFrameFromCallFrameHeaderPtr(callFrameRegister); 320 320 321 321 // Return. -
trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp
r157746 r158315 55 55 // Load caller frame's scope chain into this callframe so that whatever we call can 56 56 // get to its global data. 57 emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,regT0);57 emitGetCallerFrameFromCallFrameHeaderPtr(regT0); 58 58 emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT0); 59 59 emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain); 60 60 61 61 peek(regT1); 62 emitPut ToCallFrameHeader(regT1, JSStack::ReturnPC);62 emitPutReturnPCToCallFrameHeader(regT1); 63 63 64 64 // Calling convention: f(ecx, edx, ...); … … 78 78 // Load caller frame's scope chain into this callframe so that whatever we call can 79 79 // get to its global data. 80 emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,regT2);80 emitGetCallerFrameFromCallFrameHeaderPtr(regT2); 81 81 emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT2); 82 82 emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain); 83 83 84 84 preserveReturnAddressAfterCall(regT3); // Callee preserved 85 emitPut ToCallFrameHeader(regT3, JSStack::ReturnPC);85 emitPutReturnPCToCallFrameHeader(regT3); 86 86 87 87 // Calling convention: f(r0 == regT0, r1 == regT1, ...); … … 101 101 // Load caller frame's scope chain into this callframe so that whatever we call can 102 102 // get to its global data. 103 emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,regT0);103 emitGetCallerFrameFromCallFrameHeaderPtr(regT0); 104 104 emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT0); 105 105 emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain); 106 106 107 107 preserveReturnAddressAfterCall(regT3); // Callee preserved 108 emitPut ToCallFrameHeader(regT3, JSStack::ReturnPC);108 emitPutReturnPCToCallFrameHeader(regT3); 109 109 110 110 // Calling convention: f(a0, a1, a2, a3); … … 133 133 // Load caller frame's scope chain into this callframe so that whatever we call can 134 134 // get to its global data. 135 emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,regT2);135 emitGetCallerFrameFromCallFrameHeaderPtr(regT2); 136 136 emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT2); 137 137 emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain); 138 138 139 139 preserveReturnAddressAfterCall(regT3); // Callee preserved 140 emitPut ToCallFrameHeader(regT3, JSStack::ReturnPC);140 emitPutReturnPCToCallFrameHeader(regT3); 141 141 142 142 // Calling convention: f(r0 == regT4, r1 == regT5, ...); … … 213 213 ASSERT(returnValueRegister != callFrameRegister); 214 214 emitLoad(currentInstruction[1].u.operand, regT1, regT0); 215 restoreReturnAddressBeforeReturn(Address(callFrameRegister, JSStack::ReturnPC * static_cast<int>(sizeof(Register))));215 restoreReturnAddressBeforeReturn(Address(callFrameRegister, CallFrame::returnPCOffset())); 216 216 ret(); 217 217 } -
trunk/Source/JavaScriptCore/jit/JITOperations.cpp
r158304 r158315 1718 1718 HIDE_SYMBOL(getHostCallReturnValue) "\n" 1719 1719 SYMBOL_STRING(getHostCallReturnValue) ":" "\n" 1720 "mov 32(%r13), %r13\n"1720 "mov 0(%r13), %r13\n" // CallerFrameAndPC::callerFrame 1721 1721 "mov %r13, %rdi\n" 1722 1722 "jmp " LOCAL_REFERENCE(getHostCallReturnValueWithExecState) "\n" … … 1729 1729 HIDE_SYMBOL(getHostCallReturnValue) "\n" 1730 1730 SYMBOL_STRING(getHostCallReturnValue) ":" "\n" 1731 "mov 32(%edi), %edi\n"1731 "mov 0(%edi), %edi\n" // CallerFrameAndPC::callerFrame 1732 1732 "mov %edi, 4(%esp)\n" 1733 1733 "jmp " LOCAL_REFERENCE(getHostCallReturnValueWithExecState) "\n" … … 1743 1743 ".thumb_func " THUMB_FUNC_PARAM(getHostCallReturnValue) "\n" 1744 1744 SYMBOL_STRING(getHostCallReturnValue) ":" "\n" 1745 "ldr r5, [r5, # 32]" "\n"1745 "ldr r5, [r5, #0]" "\n" // CallerFrameAndPC::callerFrame 1746 1746 "mov r0, r5" "\n" 1747 1747 "b " LOCAL_REFERENCE(getHostCallReturnValueWithExecState) "\n" … … 1755 1755 INLINE_ARM_FUNCTION(getHostCallReturnValue) 1756 1756 SYMBOL_STRING(getHostCallReturnValue) ":" "\n" 1757 "ldr r5, [r5, # 32]" "\n"1757 "ldr r5, [r5, #0]" "\n" // CallerFrameAndPC::callerFrame 1758 1758 "mov r0, r5" "\n" 1759 1759 "b " LOCAL_REFERENCE(getHostCallReturnValueWithExecState) "\n" … … 1779 1779 SYMBOL_STRING(getHostCallReturnValue) ":" "\n" 1780 1780 LOAD_FUNCTION_TO_T9(getHostCallReturnValueWithExecState) 1781 "lw $s0, 32($s0)" "\n"1781 "lw $s0, 0($s0)" "\n" // CallerFrameAndPC::callerFrame 1782 1782 "move $a0, $s0" "\n" 1783 1783 "b " LOCAL_REFERENCE(getHostCallReturnValueWithExecState) "\n" … … 1790 1790 HIDE_SYMBOL(getHostCallReturnValue) "\n" 1791 1791 SYMBOL_STRING(getHostCallReturnValue) ":" "\n" 1792 "add #32, r14" "\n" 1793 "mov.l @r14, r14" "\n" 1792 "mov.l @r14, r14" "\n" // CallerFrameAndPC::callerFrame 1794 1793 "mov r14, r4" "\n" 1795 1794 "mov.l 2f, " SH4_SCRATCH_REGISTER "\n" … … 1805 1804 { 1806 1805 __asm { 1807 mov edi, [edi + 32];1806 mov edi, [edi + 0]; // CallerFrameAndPC::callerFrame 1808 1807 mov [esp + 4], edi; 1809 1808 jmp getHostCallReturnValueWithExecState -
trunk/Source/JavaScriptCore/jit/SpecializedThunkJIT.h
r157653 r158315 98 98 if (src != regT0) 99 99 move(src, regT0); 100 loadPtr( payloadFor(JSStack::CallerFrame, callFrameRegister), callFrameRegister);100 loadPtr(Address(callFrameRegister, CallFrame::callerFrameOffset()), callFrameRegister); 101 101 ret(); 102 102 } … … 106 106 ASSERT_UNUSED(payload, payload == regT0); 107 107 ASSERT_UNUSED(tag, tag == regT1); 108 loadPtr( payloadFor(JSStack::CallerFrame, callFrameRegister), callFrameRegister);108 loadPtr(Address(callFrameRegister, CallFrame::callerFrameOffset()), callFrameRegister); 109 109 ret(); 110 110 } … … 132 132 highNonZero.link(this); 133 133 #endif 134 loadPtr( payloadFor(JSStack::CallerFrame, callFrameRegister), callFrameRegister);134 loadPtr(Address(callFrameRegister, CallFrame::callerFrameOffset()), callFrameRegister); 135 135 ret(); 136 136 } … … 141 141 move(src, regT0); 142 142 tagReturnAsInt32(); 143 loadPtr( payloadFor(JSStack::CallerFrame, callFrameRegister), callFrameRegister);143 loadPtr(Address(callFrameRegister, CallFrame::callerFrameOffset()), callFrameRegister); 144 144 ret(); 145 145 } … … 150 150 move(src, regT0); 151 151 tagReturnAsJSCell(); 152 loadPtr( payloadFor(JSStack::CallerFrame, callFrameRegister), callFrameRegister);152 loadPtr(Address(callFrameRegister, CallFrame::callerFrameOffset()), callFrameRegister); 153 153 ret(); 154 154 } -
trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp
r158237 r158315 68 68 69 69 // The CallFrame register points to the (failed) callee frame, so we need to pop back one frame. 70 jit.loadPtr( 71 CCallHelpers::Address( 72 GPRInfo::callFrameRegister, 73 static_cast<ptrdiff_t>(sizeof(Register)) * JSStack::CallerFrame), 74 GPRInfo::callFrameRegister); 70 jit.emitGetCallerFrameFromCallFrameHeaderPtr(GPRInfo::callFrameRegister); 75 71 76 72 jit.setupArgumentsExecState(); … … 89 85 jit.preserveReturnAddressAfterCall(GPRInfo::nonArgGPR2); 90 86 emitPointerValidation(jit, GPRInfo::nonArgGPR2); 91 jit.storePtr( 92 GPRInfo::nonArgGPR2, 93 CCallHelpers::Address( 94 GPRInfo::callFrameRegister, 95 static_cast<ptrdiff_t>(sizeof(Register)) * JSStack::ReturnPC)); 87 jit.emitPutReturnPCToCallFrameHeader(GPRInfo::nonArgGPR2); 96 88 jit.storePtr(GPRInfo::callFrameRegister, &vm->topCallFrame); 97 89 jit.setupArgumentsExecState(); … … 104 96 // 2) Host call return value returner thingy. 105 97 // 3) The function to call. 106 jit.loadPtr( 107 CCallHelpers::Address( 108 GPRInfo::callFrameRegister, 109 static_cast<ptrdiff_t>(sizeof(Register)) * JSStack::ReturnPC), 110 GPRInfo::nonPreservedNonReturnGPR); 111 jit.storePtr( 112 CCallHelpers::TrustedImmPtr(0), 113 CCallHelpers::Address( 114 GPRInfo::callFrameRegister, 115 static_cast<ptrdiff_t>(sizeof(Register)) * JSStack::ReturnPC)); 98 jit.emitGetReturnPCFromCallFrameHeaderPtr(GPRInfo::nonPreservedNonReturnGPR); 99 jit.emitPutReturnPCToCallFrameHeader(CCallHelpers::TrustedImmPtr(0)); 116 100 emitPointerValidation(jit, GPRInfo::nonPreservedNonReturnGPR); 117 101 jit.restoreReturnAddressBeforeReturn(GPRInfo::nonPreservedNonReturnGPR); … … 273 257 // Load caller frame's scope chain into this callframe so that whatever we call can 274 258 // get to its global data. 275 jit.emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,JSInterfaceJIT::regT0);259 jit.emitGetCallerFrameFromCallFrameHeaderPtr(JSInterfaceJIT::regT0); 276 260 jit.emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, JSInterfaceJIT::regT1, JSInterfaceJIT::regT0); 277 261 jit.emitPutCellToCallFrameHeader(JSInterfaceJIT::regT1, JSStack::ScopeChain); 278 262 279 263 jit.peek(JSInterfaceJIT::regT1); 280 jit.emitPut ToCallFrameHeader(JSInterfaceJIT::regT1, JSStack::ReturnPC);264 jit.emitPutReturnPCToCallFrameHeader(JSInterfaceJIT::regT1); 281 265 282 266 // Calling convention: f(ecx, edx, ...); … … 297 281 // Load caller frame's scope chain into this callframe so that whatever we call can 298 282 // get to its global data. 299 jit.emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,JSInterfaceJIT::regT0);283 jit.emitGetCallerFrameFromCallFrameHeaderPtr(JSInterfaceJIT::regT0); 300 284 jit.emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, JSInterfaceJIT::regT1, JSInterfaceJIT::regT0); 301 285 jit.emitPutCellToCallFrameHeader(JSInterfaceJIT::regT1, JSStack::ScopeChain); 302 286 303 287 jit.peek(JSInterfaceJIT::regT1); 304 jit.emitPut ToCallFrameHeader(JSInterfaceJIT::regT1, JSStack::ReturnPC);288 jit.emitPutReturnPCToCallFrameHeader(JSInterfaceJIT::regT1); 305 289 306 290 #if !OS(WINDOWS) … … 342 326 // Load caller frame's scope chain into this callframe so that whatever we call can 343 327 // get to its global data. 344 jit.emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,ARM64Registers::x3);328 jit.emitGetCallerFrameFromCallFrameHeaderPtr(ARM64Registers::x3); 345 329 jit.emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, JSInterfaceJIT::regT1, ARM64Registers::x3); 346 330 jit.emitPutCellToCallFrameHeader(JSInterfaceJIT::regT1, JSStack::ScopeChain); 347 331 348 332 jit.preserveReturnAddressAfterCall(JSInterfaceJIT::regT3); // Callee preserved 349 jit.emitPut ToCallFrameHeader(ARM64Registers::lr, JSStack::ReturnPC);333 jit.emitPutReturnPCToCallFrameHeader(ARM64Registers::lr); 350 334 351 335 // Host function signature: f(ExecState*); … … 362 346 // Load caller frame's scope chain into this callframe so that whatever we call can 363 347 // get to its global data. 364 jit.emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,JSInterfaceJIT::regT2);348 jit.emitGetCallerFrameFromCallFrameHeaderPtr(JSInterfaceJIT::regT2); 365 349 jit.emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, JSInterfaceJIT::regT1, JSInterfaceJIT::regT2); 366 350 jit.emitPutCellToCallFrameHeader(JSInterfaceJIT::regT1, JSStack::ScopeChain); 367 351 368 352 jit.preserveReturnAddressAfterCall(JSInterfaceJIT::regT3); // Callee preserved 369 jit.emitPut ToCallFrameHeader(JSInterfaceJIT::regT3, JSStack::ReturnPC);353 jit.emitPutReturnPCToCallFrameHeader(JSInterfaceJIT::regT3); 370 354 371 355 // Calling convention: f(r0 == regT0, r1 == regT1, ...); … … 383 367 // Load caller frame's scope chain into this callframe so that whatever we call can 384 368 // get to its global data. 385 jit.emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,JSInterfaceJIT::regT2);369 jit.emitGetCallerFrameFromCallFrameHeaderPtr(JSInterfaceJIT::regT2); 386 370 jit.emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, JSInterfaceJIT::regT1, JSInterfaceJIT::regT2); 387 371 jit.emitPutCellToCallFrameHeader(JSInterfaceJIT::regT1, JSStack::ScopeChain); 388 372 389 373 jit.preserveReturnAddressAfterCall(JSInterfaceJIT::regT3); // Callee preserved 390 jit.emitPut ToCallFrameHeader(JSInterfaceJIT::regT3, JSStack::ReturnPC);374 jit.emitPutReturnPCToCallFrameHeader(JSInterfaceJIT::regT3); 391 375 392 376 // Calling convention: f(r0 == regT4, r1 == regT5, ...); … … 404 388 // Load caller frame's scope chain into this callframe so that whatever we call can 405 389 // get to its global data. 406 jit.emitGet FromCallFrameHeaderPtr(JSStack::CallerFrame,JSInterfaceJIT::regT0);390 jit.emitGetCallerFrameFromCallFrameHeaderPtr(JSInterfaceJIT::regT0); 407 391 jit.emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, JSInterfaceJIT::regT1, JSInterfaceJIT::regT0); 408 392 jit.emitPutCellToCallFrameHeader(JSInterfaceJIT::regT1, JSStack::ScopeChain); 409 393 410 394 jit.preserveReturnAddressAfterCall(JSInterfaceJIT::regT3); // Callee preserved 411 jit.emitPut ToCallFrameHeader(JSInterfaceJIT::regT3, JSStack::ReturnPC);395 jit.emitPutReturnPCToCallFrameHeader(JSInterfaceJIT::regT3); 412 396 413 397 // Calling convention: f(a0, a1, a2, a3); -
trunk/Source/JavaScriptCore/llint/LLIntData.cpp
r158237 r158315 71 71 // Assertions to match LowLevelInterpreter.asm. If you change any of this code, be 72 72 // prepared to change LowLevelInterpreter.asm as well!! 73 ASSERT(JSStack::CallFrameHeaderSize * 8 == 48); 74 ASSERT(JSStack::ArgumentCount * 8 == 40); 75 ASSERT(JSStack::CallerFrame * 8 == 32); 76 ASSERT(JSStack::Callee * 8 == 24); 77 ASSERT(JSStack::ScopeChain * 8 == 16); 78 ASSERT(JSStack::ReturnPC * 8 == 8); 79 ASSERT(JSStack::CodeBlock * 8 == 0); 73 74 #ifndef NDEBUG 75 #if USE(JSVALUE64) 76 const ptrdiff_t PtrSize = 8; 77 const ptrdiff_t CallFrameHeaderSlots = 6; 78 #else // USE(JSVALUE64) // i.e. 32-bit version 79 const ptrdiff_t PtrSize = 4; 80 const ptrdiff_t CallFrameHeaderSlots = 5; 81 #endif 82 const ptrdiff_t SlotSize = 8; 83 #endif 84 85 ASSERT(sizeof(void*) == PtrSize); 86 ASSERT(sizeof(Register) == SlotSize); 87 ASSERT(JSStack::CallFrameHeaderSize == CallFrameHeaderSlots); 88 89 ASSERT(!CallFrame::callerFrameOffset()); 90 ASSERT(CallFrame::returnPCOffset() == CallFrame::callerFrameOffset() + PtrSize); 91 ASSERT(JSStack::CodeBlock * sizeof(Register) == CallFrame::returnPCOffset() + PtrSize); 92 ASSERT(JSStack::ScopeChain * sizeof(Register) == JSStack::CodeBlock * sizeof(Register) + SlotSize); 93 ASSERT(JSStack::Callee * sizeof(Register) == JSStack::ScopeChain * sizeof(Register) + SlotSize); 94 ASSERT(JSStack::ArgumentCount * sizeof(Register) == JSStack::Callee * sizeof(Register) + SlotSize); 95 ASSERT(JSStack::ThisArgument * sizeof(Register) == JSStack::ArgumentCount * sizeof(Register) + SlotSize); 96 ASSERT(JSStack::CallFrameHeaderSize == JSStack::ThisArgument); 97 80 98 ASSERT(CallFrame::argumentOffsetIncludingThis(0) == JSStack::ThisArgument); 99 81 100 #if CPU(BIG_ENDIAN) 82 101 ASSERT(OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag) == 0); -
trunk/Source/JavaScriptCore/llint/LowLevelInterpreter.asm
r158237 r158315 32 32 33 33 # These declarations must match interpreter/JSStack.h. 34 const CallFrameHeaderSize = 48 34 35 if JSVALUE64 36 const PtrSize = 8 35 37 const CallFrameHeaderSlots = 6 36 const ArgumentCount = 40 37 const CallerFrame = 32 38 const Callee = 24 39 const ScopeChain = 16 40 const ReturnPC = 8 41 const CodeBlock = 0 42 43 const ThisArgumentOffset = ArgumentCount + 8 38 else 39 const PtrSize = 4 40 const CallFrameHeaderSlots = 5 41 end 42 const SlotSize = 8 43 44 const CallerFrame = 0 45 const ReturnPC = CallerFrame + PtrSize 46 const CodeBlock = ReturnPC + PtrSize 47 const ScopeChain = CodeBlock + SlotSize 48 const Callee = ScopeChain + SlotSize 49 const ArgumentCount = Callee + SlotSize 50 const ThisArgumentOffset = ArgumentCount + SlotSize 51 const CallFrameHeaderSize = ThisArgumentOffset 44 52 45 53 # Some value representation constants.
Note: See TracChangeset
for help on using the changeset viewer.