Changeset 158315 in webkit


Ignore:
Timestamp:
Oct 30, 2013 2:26:46 PM (10 years ago)
Author:
mark.lam@apple.com
Message:

Adjust CallFrameHeader's ReturnPC and CallFrame locations to match the native ABI .
https://bugs.webkit.org/show_bug.cgi?id=123444.

Reviewed by Geoffrey Garen.

  • Introduced an explicit CallerFrameAndPC struct.
  • A CallFrame is expected to start with a CallerFrameAndPC struct.
  • The Register class no longer supports CallFrame* and Instruction*.

These hides the differences between JSVALUE32_64 and JSVALUE64 in
terms of managing the callerFrame() and returnPC() values.

  • Convert all uses of JSStack::CallerFrame and JSStack::ReturnPC to go through CallFrame to access the appropriate values and offsets. CallFrame, in turn, will access the callerFrame and returnPC via the CallerFrameAndPC struct.
  • InlineCallFrame will provide offsets for its callerFrame and returnPC. It will make use of CallFrame::callerFrameOffset() and CallerFrame::returnPCOffset() to compute these.
  • bytecode/CodeOrigin.h:

(JSC::InlineCallFrame::callerFrameOffset):
(JSC::InlineCallFrame::returnPCOffset):

  • dfg/DFGJITCompiler.cpp:

(JSC::DFG::JITCompiler::compileEntry):
(JSC::DFG::JITCompiler::compileExceptionHandlers):

  • dfg/DFGOSRExitCompilerCommon.cpp:

(JSC::DFG::reifyInlinedCallFrames):

  • dfg/DFGSpeculativeJIT.h:

(JSC::DFG::SpeculativeJIT::calleeFrameSlot):
(JSC::DFG::SpeculativeJIT::calleeArgumentSlot):
(JSC::DFG::SpeculativeJIT::calleeFrameTagSlot):
(JSC::DFG::SpeculativeJIT::calleeFramePayloadSlot):
(JSC::DFG::SpeculativeJIT::calleeArgumentTagSlot):
(JSC::DFG::SpeculativeJIT::calleeArgumentPayloadSlot):

  • Prefixed all the above with callee since they apply to the callee frame.

(JSC::DFG::SpeculativeJIT::calleeFrameCallerFrame):

  • Added to set the callerFrame pointer in the callee frame.
  • dfg/DFGSpeculativeJIT32_64.cpp:

(JSC::DFG::SpeculativeJIT::emitCall):
(JSC::DFG::SpeculativeJIT::compile):

  • dfg/DFGSpeculativeJIT64.cpp:

(JSC::DFG::SpeculativeJIT::emitCall):
(JSC::DFG::SpeculativeJIT::compile):

  • ftl/FTLLink.cpp:

(JSC::FTL::compileEntry):
(JSC::FTL::link):

  • interpreter/CallFrame.h:

(JSC::ExecState::callerFrame):
(JSC::ExecState::callerFrameOffset):
(JSC::ExecState::returnPC):
(JSC::ExecState::hasReturnPC):
(JSC::ExecState::clearReturnPC):
(JSC::ExecState::returnPCOffset):
(JSC::ExecState::setCallerFrame):
(JSC::ExecState::setReturnPC):
(JSC::ExecState::callerFrameAndPC):

  • interpreter/JSStack.h:
  • interpreter/Register.h:
  • jit/AssemblyHelpers.h:

(JSC::AssemblyHelpers::emitPutToCallFrameHeader):

  • Convert to using storePtr() here and simplify the code.

(JSC::AssemblyHelpers::emitGetCallerFrameFromCallFrameHeaderPtr):
(JSC::AssemblyHelpers::emitPutCallerFrameToCallFrameHeader):
(JSC::AssemblyHelpers::emitGetReturnPCFromCallFrameHeaderPtr):
(JSC::AssemblyHelpers::emitPutReturnPCToCallFrameHeader):

  • Helpers to emit gets/puts of the callerFrame and returnPC.

(JSC::AssemblyHelpers::addressForByteOffset):

  • jit/JIT.cpp:

(JSC::JIT::JIT):
(JSC::JIT::privateCompile):
(JSC::JIT::privateCompileExceptionHandlers):

  • jit/JITCall.cpp:

(JSC::JIT::compileCallEval):
(JSC::JIT::compileOpCall):

  • jit/JITCall32_64.cpp:

(JSC::JIT::emit_op_ret):
(JSC::JIT::emit_op_ret_object_or_this):
(JSC::JIT::compileCallEval):
(JSC::JIT::compileOpCall):

  • jit/JITInlines.h:

(JSC::JIT::unmap):

  • jit/JITOpcodes.cpp:

(JSC::JIT::emit_op_end):
(JSC::JIT::emit_op_ret):
(JSC::JIT::emit_op_ret_object_or_this):

  • jit/JITOpcodes32_64.cpp:

(JSC::JIT::privateCompileCTINativeCall):
(JSC::JIT::emit_op_end):

  • jit/JITOperations.cpp:
  • jit/SpecializedThunkJIT.h:

(JSC::SpecializedThunkJIT::returnJSValue):
(JSC::SpecializedThunkJIT::returnDouble):
(JSC::SpecializedThunkJIT::returnInt32):
(JSC::SpecializedThunkJIT::returnJSCell):

  • jit/ThunkGenerators.cpp:

(JSC::throwExceptionFromCallSlowPathGenerator):
(JSC::slowPathFor):
(JSC::nativeForGenerator):

  • llint/LLIntData.cpp:

(JSC::LLInt::Data::performAssertions):

  • llint/LowLevelInterpreter.asm:
  • Updated offsets and asserts to match the new CallFrame layout.
Location:
trunk/Source/JavaScriptCore
Files:
23 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/JavaScriptCore/ChangeLog

    r158313 r158315  
     12013-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
    11102013-10-30  Filip Pizlo  <fpizlo@apple.com>
    2111
  • trunk/Source/JavaScriptCore/bytecode/CodeOrigin.h

    r157660 r158315  
    143143    CodeBlock* baselineCodeBlock() const;
    144144   
     145    ptrdiff_t callerFrameOffset() const { return stackOffset * sizeof(Register) + CallFrame::callerFrameOffset(); }
     146    ptrdiff_t returnPCOffset() const { return stackOffset * sizeof(Register) + CallFrame::returnPCOffset(); }
     147
    145148    void dumpBriefFunctionInformation(PrintStream&) const;
    146149    void dump(PrintStream&) const;
  • trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp

    r158304 r158315  
    100100    // both normal return code and when jumping to an exception handler).
    101101    preserveReturnAddressAfterCall(GPRInfo::regT2);
    102     emitPutToCallFrameHeader(GPRInfo::regT2, JSStack::ReturnPC);
     102    emitPutReturnPCToCallFrameHeader(GPRInfo::regT2);
    103103    emitPutImmediateToCallFrameHeader(m_codeBlock, JSStack::CodeBlock);
    104104}
     
    128128        // Remove hostCallFrameFlag from caller.
    129129        m_exceptionChecksWithCallFrameRollback.link(this);
    130         emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, GPRInfo::argumentGPR0);
     130        emitGetCallerFrameFromCallFrameHeaderPtr(GPRInfo::argumentGPR0);
    131131        andPtr(TrustedImm32(safeCast<int32_t>(~CallFrame::hostCallFrameFlag())), GPRInfo::argumentGPR0);
    132132        doLookup = jump();
  • trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.cpp

    r157035 r158315  
    112112        if (!inlineCallFrame->isClosureCall)
    113113            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()));
    116116        uint32_t locationBits = CallFrame::Location::encodeAsBytecodeOffset(codeOrigin.bytecodeIndex);
    117117        jit.store32(AssemblyHelpers::TrustedImm32(locationBits), AssemblyHelpers::tagFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::ArgumentCount)));
     
    128128        if (!inlineCallFrame->isClosureCall)
    129129            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()));
    133132        Instruction* instruction = baselineCodeBlock->instructions().begin() + codeOrigin.bytecodeIndex;
    134133        uint32_t locationBits = CallFrame::Location::encodeAsBytecodeInstruction(instruction);
  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h

    r158304 r158315  
    732732   
    733733    // Access to our fixed callee CallFrame.
    734     MacroAssembler::Address callFrameSlot(int numArgs, int slot)
     734    MacroAssembler::Address calleeFrameSlot(int numArgs, int slot)
    735735    {
    736736        return MacroAssembler::Address(GPRInfo::callFrameRegister, calleeFrameOffset(numArgs) + sizeof(Register) * slot);
     
    738738
    739739    // 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());
    763768    }
    764769
  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp

    r158304 r158315  
    660660    int numArgs = numPassedArgs + dummyThisArgument;
    661661
    662     m_jit.store32(MacroAssembler::TrustedImm32(numArgs), callFramePayloadSlot(numArgs, JSStack::ArgumentCount));
    663     m_jit.storePtr(GPRInfo::callFrameRegister, callFramePayloadSlot(numArgs, JSStack::CallerFrame));
    664     m_jit.store32(calleePayloadGPR, callFramePayloadSlot(numArgs, JSStack::Callee));
    665     m_jit.store32(calleeTagGPR, callFrameTagSlot(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));
    666666
    667667    for (int i = 0; i < numPassedArgs; i++) {
     
    672672        use(argEdge);
    673673
    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));
    676676    }
    677677
     
    30943094
    30953095        // Grab the return address.
    3096         m_jit.emitGetFromCallFrameHeaderPtr(JSStack::ReturnPC, GPRInfo::regT2);
     3096        m_jit.emitGetReturnPCFromCallFrameHeaderPtr(GPRInfo::regT2);
    30973097        // Restore our caller's "r".
    3098         m_jit.emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, GPRInfo::callFrameRegister);
     3098        m_jit.emitGetCallerFrameFromCallFrameHeaderPtr(GPRInfo::callFrameRegister);
    30993099        // Return.
    31003100        m_jit.restoreReturnAddressBeforeReturn(GPRInfo::regT2);
  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp

    r158304 r158315  
    684684    int numArgs = numPassedArgs + dummyThisArgument;
    685685   
    686     m_jit.store32(MacroAssembler::TrustedImm32(numArgs), callFramePayloadSlot(numArgs, JSStack::ArgumentCount));
    687     m_jit.store64(GPRInfo::callFrameRegister, callFrameSlot(numArgs, JSStack::CallerFrame));
    688     m_jit.store64(calleeGPR, callFrameSlot(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));
    689689   
    690690    for (int i = 0; i < numPassedArgs; i++) {
     
    694694        use(argEdge);
    695695       
    696         m_jit.store64(argGPR, argumentSlot(numArgs, i + dummyThisArgument));
     696        m_jit.store64(argGPR, calleeArgumentSlot(numArgs, i + dummyThisArgument));
    697697    }
    698698
     
    34143414
    34153415        // Grab the return address.
    3416         m_jit.emitGetFromCallFrameHeaderPtr(JSStack::ReturnPC, GPRInfo::regT1);
     3416        m_jit.emitGetReturnPCFromCallFrameHeaderPtr(GPRInfo::regT1);
    34173417        // Restore our caller's "r".
    3418         m_jit.emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, GPRInfo::callFrameRegister);
     3418        m_jit.emitGetCallerFrameFromCallFrameHeaderPtr(GPRInfo::callFrameRegister);
    34193419        // Return.
    34203420        m_jit.restoreReturnAddressBeforeReturn(GPRInfo::regT1);
  • trunk/Source/JavaScriptCore/ftl/FTLLink.cpp

    r158116 r158315  
    4747{
    4848    jit.preserveReturnAddressAfterCall(GPRInfo::regT2);
    49     jit.emitPutToCallFrameHeader(GPRInfo::regT2, JSStack::ReturnPC);
     49    jit.emitPutReturnPCToCallFrameHeader(GPRInfo::regT2);
    5050    jit.emitPutImmediateToCallFrameHeader(jit.codeBlock(), JSStack::CodeBlock);
    5151}
     
    9494            GPRInfo::nonArgGPR0);
    9595        jit.call(GPRInfo::nonArgGPR0);
    96         jit.emitGetFromCallFrameHeaderPtr(JSStack::ReturnPC, GPRInfo::regT1);
    97         jit.emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, GPRInfo::callFrameRegister);
     96        jit.emitGetReturnPCFromCallFrameHeaderPtr(GPRInfo::regT1);
     97        jit.emitGetCallerFrameFromCallFrameHeaderPtr(GPRInfo::callFrameRegister);
    9898        jit.restoreReturnAddressBeforeReturn(GPRInfo::regT1);
    9999        jit.ret();
     
    163163            GPRInfo::nonArgGPR0);
    164164        jit.call(GPRInfo::nonArgGPR0);
    165         jit.emitGetFromCallFrameHeaderPtr(JSStack::ReturnPC, GPRInfo::regT1);
    166         jit.emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, GPRInfo::callFrameRegister);
     165        jit.emitGetReturnPCFromCallFrameHeaderPtr(GPRInfo::regT1);
     166        jit.emitGetCallerFrameFromCallFrameHeaderPtr(GPRInfo::callFrameRegister);
    167167        jit.restoreReturnAddressBeforeReturn(GPRInfo::regT1);
    168168        jit.ret();
  • trunk/Source/JavaScriptCore/interpreter/CallFrame.h

    r158237 r158315  
    113113        CallFrame& operator=(const Register& r) { *static_cast<Register*>(this) = r; return *this; }
    114114
    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); }
    121122        AbstractPC abstractReturnPC(VM& vm) { return AbstractPC(vm, this); }
    122123
     
    200201#endif
    201202
    202         void setCallerFrame(CallFrame* callerFrame) { static_cast<Register*>(this)[JSStack::CallerFrame] = callerFrame; }
     203        void setCallerFrame(CallFrame* frame) { callerFrameAndPC().callerFrame = frame; }
    203204        void setScope(JSScope* scope) { static_cast<Register*>(this)[JSStack::ScopeChain] = scope; }
    204205
     
    275276        void setCallee(JSObject* callee) { static_cast<Register*>(this)[JSStack::Callee] = Register::withCallee(callee); }
    276277        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
    279280        CallFrame* callerFrameNoFlags() { return callerFrame()->removeHostCallFrameFlag(); }
    280281
     
    325326        }
    326327
     328        CallerFrameAndPC& callerFrameAndPC() { return *reinterpret_cast<CallerFrameAndPC*>(this); }
     329        const CallerFrameAndPC& callerFrameAndPC() const { return *reinterpret_cast<const CallerFrameAndPC*>(this); }
     330
    327331        friend class JSStack;
    328332        friend class VMInspector;
  • trunk/Source/JavaScriptCore/interpreter/JSStack.h

    r158237 r158315  
    4949    class LLIntOffsetsExtractor;
    5050
     51    struct Instruction;
     52    typedef ExecState CallFrame;
     53
     54    struct CallerFrameAndPC {
     55        CallFrame* callerFrame;
     56        Instruction* pc;
     57    };
     58
    5159    class JSStack {
    5260        WTF_MAKE_NONCOPYABLE(JSStack);
    5361    public:
    5462        enum CallFrameHeaderEntry {
    55             CallFrameHeaderSize = 6,
    56             FirstArgument = 7,
    57             ThisArgument = 6,
    58             ArgumentCount = 5,
    59             CallerFrame = 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,
    6472        };
    6573
  • trunk/Source/JavaScriptCore/interpreter/Register.h

    r156677 r158315  
    4343    class JSScope;
    4444
    45     struct Instruction;
    46 
    4745    typedef ExecState CallFrame;
    4846
     
    5755        EncodedJSValue encodedJSValue() const;
    5856       
    59         Register& operator=(CallFrame*);
    6057        Register& operator=(CodeBlock*);
    6158        Register& operator=(JSScope*);
    62         Register& operator=(Instruction*);
    6359
    6460        int32_t i() const;
    6561        JSActivation* activation() const;
    66         CallFrame* callFrame() const;
    6762        CodeBlock* codeBlock() const;
    6863        JSObject* function() const;
    6964        JSPropertyNameIterator* propertyNameIterator() const;
    7065        JSScope* scope() const;
    71         Instruction* vPC() const;
    7266        int32_t unboxedInt32() const;
    7367        int64_t unboxedInt52() const;
     
    9286        union {
    9387            EncodedJSValue value;
    94             CallFrame* callFrame;
    9588            CodeBlock* codeBlock;
    96             Instruction* vPC;
    9789            EncodedValueDescriptor encodedValue;
    9890            double number;
     
    131123    // Interpreter functions
    132124
    133     ALWAYS_INLINE Register& Register::operator=(CallFrame* callFrame)
    134     {
    135         u.callFrame = callFrame;
    136         return *this;
    137     }
    138 
    139125    ALWAYS_INLINE Register& Register::operator=(CodeBlock* codeBlock)
    140126    {
     
    143129    }
    144130
    145     ALWAYS_INLINE Register& Register::operator=(Instruction* vPC)
    146     {
    147         u.vPC = vPC;
    148         return *this;
    149     }
    150 
    151131    ALWAYS_INLINE int32_t Register::i() const
    152132    {
     
    154134    }
    155135
    156     ALWAYS_INLINE CallFrame* Register::callFrame() const
    157     {
    158         return u.callFrame;
    159     }
    160    
    161136    ALWAYS_INLINE CodeBlock* Register::codeBlock() const
    162137    {
    163138        return u.codeBlock;
    164     }
    165 
    166     ALWAYS_INLINE Instruction* Register::vPC() const
    167     {
    168         return u.vPC;
    169139    }
    170140
  • trunk/Source/JavaScriptCore/jit/AssemblyHelpers.h

    r157685 r158315  
    134134    void emitPutToCallFrameHeader(GPRReg from, JSStack::CallFrameHeaderEntry entry)
    135135    {
    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)));
    141137    }
    142138
     
    144140    {
    145141        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()));
    146164    }
    147165
     
    155173    }
    156174   
     175    static Address addressForByteOffset(ptrdiff_t byteOffset)
     176    {
     177        return Address(GPRInfo::callFrameRegister, byteOffset);
     178    }
    157179    static Address addressFor(VirtualRegister virtualRegister)
    158180    {
  • trunk/Source/JavaScriptCore/jit/JIT.cpp

    r158237 r158315  
    8484    , m_jumpTargetIndex(0)
    8585    , m_mappedBytecodeOffset((unsigned)-1)
    86     , m_mappedVirtualRegisterIndex(JSStack::ReturnPC)
     86    , m_mappedVirtualRegisterIndex(UINT_MAX)
    8787    , m_mappedTag((RegisterID)-1)
    8888    , m_mappedPayload((RegisterID)-1)
     
    548548
    549549    preserveReturnAddressAfterCall(regT2);
    550     emitPutToCallFrameHeader(regT2, JSStack::ReturnPC);
     550    emitPutReturnPCToCallFrameHeader(regT2);
    551551    emitPutImmediateToCallFrameHeader(m_codeBlock, JSStack::CodeBlock);
    552552
     
    613613        store8(TrustedImm32(0), &m_codeBlock->m_shouldAlwaysBeInlined);
    614614        preserveReturnAddressAfterCall(regT2);
    615         emitPutToCallFrameHeader(regT2, JSStack::ReturnPC);
     615        emitPutReturnPCToCallFrameHeader(regT2);
    616616        emitPutImmediateToCallFrameHeader(m_codeBlock, JSStack::CodeBlock);
    617617
     
    803803        // Remove hostCallFlag from caller
    804804        m_exceptionChecksWithCallFrameRollback.link(this);
    805         emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, GPRInfo::argumentGPR0);
     805        emitGetCallerFrameFromCallFrameHeaderPtr(GPRInfo::argumentGPR0);
    806806        andPtr(TrustedImm32(safeCast<int32_t>(~CallFrame::hostCallFrameFlag())), GPRInfo::argumentGPR0);
    807807        doLookup = jump();
  • trunk/Source/JavaScriptCore/jit/JITCall.cpp

    r157603 r158315  
    132132    callOperationWithCallFrameRollbackOnException(operationCallEval);
    133133    addSlowCase(branch64(Equal, regT0, TrustedImm64(JSValue::encode(JSValue()))));
    134     emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, callFrameRegister);
     134    emitGetCallerFrameFromCallFrameHeaderPtr(callFrameRegister);
    135135
    136136    sampleCodeBlock(m_codeBlock);
     
    192192    emitGetVirtualRegister(callee, regT0); // regT0 holds callee.
    193193
    194     store64(callFrameRegister, Address(regT1, JSStack::CallerFrame * static_cast<int>(sizeof(Register))));
     194    store64(callFrameRegister, Address(regT1, CallFrame::callerFrameOffset()));
    195195    store64(regT0, Address(regT1, JSStack::Callee * static_cast<int>(sizeof(Register))));
    196196    move(regT1, callFrameRegister);
  • trunk/Source/JavaScriptCore/jit/JITCall32_64.cpp

    r157603 r158315  
    6262
    6363    emitLoad(dst, regT1, regT0);
    64     emitGetFromCallFrameHeaderPtr(JSStack::ReturnPC, regT2);
    65     emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, callFrameRegister);
     64    emitGetReturnPCFromCallFrameHeaderPtr(regT2);
     65    emitGetCallerFrameFromCallFrameHeaderPtr(callFrameRegister);
    6666
    6767    restoreReturnAddressBeforeReturn(regT2);
     
    7979    Jump notObject = emitJumpIfNotObject(regT2);
    8080
    81     emitGetFromCallFrameHeaderPtr(JSStack::ReturnPC, regT2);
    82     emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, callFrameRegister);
     81    emitGetReturnPCFromCallFrameHeaderPtr(regT2);
     82    emitGetCallerFrameFromCallFrameHeaderPtr(callFrameRegister);
    8383
    8484    restoreReturnAddressBeforeReturn(regT2);
     
    8989    emitLoad(thisReg, regT1, regT0);
    9090
    91     emitGetFromCallFrameHeaderPtr(JSStack::ReturnPC, regT2);
    92     emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, callFrameRegister);
     91    emitGetReturnPCFromCallFrameHeaderPtr(regT2);
     92    emitGetCallerFrameFromCallFrameHeaderPtr(callFrameRegister);
    9393
    9494    restoreReturnAddressBeforeReturn(regT2);
     
    203203    callOperationWithCallFrameRollbackOnException(operationCallEval);
    204204    addSlowCase(branch32(Equal, regT1, TrustedImm32(JSValue::EmptyValueTag)));
    205     emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, callFrameRegister);
     205    emitGetCallerFrameFromCallFrameHeaderPtr(callFrameRegister);
    206206
    207207    sampleCodeBlock(m_codeBlock);
     
    263263    emitLoad(callee, regT1, regT0); // regT1, regT0 holds callee.
    264264
    265     storePtr(callFrameRegister, Address(regT3, JSStack::CallerFrame * static_cast<int>(sizeof(Register))));
     265    storePtr(callFrameRegister, Address(GPRInfo::regT3, CallFrame::callerFrameOffset()));
    266266    emitStore(JSStack::Callee, regT1, regT0, regT3);
    267267    move(regT3, callFrameRegister);
  • trunk/Source/JavaScriptCore/jit/JITInlines.h

    r157797 r158315  
    993993{
    994994    m_mappedBytecodeOffset = (unsigned)-1;
    995     m_mappedVirtualRegisterIndex = JSStack::ReturnPC;
     995    m_mappedVirtualRegisterIndex = UINT_MAX;
    996996    m_mappedTag = (RegisterID)-1;
    997997    m_mappedPayload = (RegisterID)-1;
  • trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp

    r157746 r158315  
    8686    RELEASE_ASSERT(returnValueRegister != callFrameRegister);
    8787    emitGetVirtualRegister(currentInstruction[1].u.operand, returnValueRegister);
    88     restoreReturnAddressBeforeReturn(Address(callFrameRegister, JSStack::ReturnPC * static_cast<int>(sizeof(Register))));
     88    restoreReturnAddressBeforeReturn(Address(callFrameRegister, CallFrame::returnPCOffset()));
    8989    ret();
    9090}
     
    276276
    277277    // Grab the return address.
    278     emitGetFromCallFrameHeaderPtr(JSStack::ReturnPC, regT1);
     278    emitGetReturnPCFromCallFrameHeaderPtr(regT1);
    279279
    280280    // Restore our caller's "r".
    281     emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, callFrameRegister);
     281    emitGetCallerFrameFromCallFrameHeaderPtr(callFrameRegister);
    282282
    283283    // Return.
     
    299299
    300300    // Grab the return address.
    301     emitGetFromCallFrameHeaderPtr(JSStack::ReturnPC, regT1);
     301    emitGetReturnPCFromCallFrameHeaderPtr(regT1);
    302302
    303303    // Restore our caller's "r".
    304     emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, callFrameRegister);
     304    emitGetCallerFrameFromCallFrameHeaderPtr(callFrameRegister);
    305305
    306306    // Return.
     
    314314
    315315    // Grab the return address.
    316     emitGetFromCallFrameHeaderPtr(JSStack::ReturnPC, regT1);
     316    emitGetReturnPCFromCallFrameHeaderPtr(regT1);
    317317
    318318    // Restore our caller's "r".
    319     emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, callFrameRegister);
     319    emitGetCallerFrameFromCallFrameHeaderPtr(callFrameRegister);
    320320
    321321    // Return.
  • trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp

    r157746 r158315  
    5555    // Load caller frame's scope chain into this callframe so that whatever we call can
    5656    // get to its global data.
    57     emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, regT0);
     57    emitGetCallerFrameFromCallFrameHeaderPtr(regT0);
    5858    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT0);
    5959    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    6060
    6161    peek(regT1);
    62     emitPutToCallFrameHeader(regT1, JSStack::ReturnPC);
     62    emitPutReturnPCToCallFrameHeader(regT1);
    6363
    6464    // Calling convention:      f(ecx, edx, ...);
     
    7878    // Load caller frame's scope chain into this callframe so that whatever we call can
    7979    // get to its global data.
    80     emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, regT2);
     80    emitGetCallerFrameFromCallFrameHeaderPtr(regT2);
    8181    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT2);
    8282    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    8383
    8484    preserveReturnAddressAfterCall(regT3); // Callee preserved
    85     emitPutToCallFrameHeader(regT3, JSStack::ReturnPC);
     85    emitPutReturnPCToCallFrameHeader(regT3);
    8686
    8787    // Calling convention:      f(r0 == regT0, r1 == regT1, ...);
     
    101101    // Load caller frame's scope chain into this callframe so that whatever we call can
    102102    // get to its global data.
    103     emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, regT0);
     103    emitGetCallerFrameFromCallFrameHeaderPtr(regT0);
    104104    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT0);
    105105    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    106106
    107107    preserveReturnAddressAfterCall(regT3); // Callee preserved
    108     emitPutToCallFrameHeader(regT3, JSStack::ReturnPC);
     108    emitPutReturnPCToCallFrameHeader(regT3);
    109109
    110110    // Calling convention:      f(a0, a1, a2, a3);
     
    133133    // Load caller frame's scope chain into this callframe so that whatever we call can
    134134    // get to its global data.
    135     emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, regT2);
     135    emitGetCallerFrameFromCallFrameHeaderPtr(regT2);
    136136    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT2);
    137137    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    138138
    139139    preserveReturnAddressAfterCall(regT3); // Callee preserved
    140     emitPutToCallFrameHeader(regT3, JSStack::ReturnPC);
     140    emitPutReturnPCToCallFrameHeader(regT3);
    141141
    142142    // Calling convention: f(r0 == regT4, r1 == regT5, ...);
     
    213213    ASSERT(returnValueRegister != callFrameRegister);
    214214    emitLoad(currentInstruction[1].u.operand, regT1, regT0);
    215     restoreReturnAddressBeforeReturn(Address(callFrameRegister, JSStack::ReturnPC * static_cast<int>(sizeof(Register))));
     215    restoreReturnAddressBeforeReturn(Address(callFrameRegister, CallFrame::returnPCOffset()));
    216216    ret();
    217217}
  • trunk/Source/JavaScriptCore/jit/JITOperations.cpp

    r158304 r158315  
    17181718HIDE_SYMBOL(getHostCallReturnValue) "\n"
    17191719SYMBOL_STRING(getHostCallReturnValue) ":" "\n"
    1720     "mov 32(%r13), %r13\n"
     1720    "mov 0(%r13), %r13\n" // CallerFrameAndPC::callerFrame
    17211721    "mov %r13, %rdi\n"
    17221722    "jmp " LOCAL_REFERENCE(getHostCallReturnValueWithExecState) "\n"
     
    17291729HIDE_SYMBOL(getHostCallReturnValue) "\n"
    17301730SYMBOL_STRING(getHostCallReturnValue) ":" "\n"
    1731     "mov 32(%edi), %edi\n"
     1731    "mov 0(%edi), %edi\n" // CallerFrameAndPC::callerFrame
    17321732    "mov %edi, 4(%esp)\n"
    17331733    "jmp " LOCAL_REFERENCE(getHostCallReturnValueWithExecState) "\n"
     
    17431743".thumb_func " THUMB_FUNC_PARAM(getHostCallReturnValue) "\n"
    17441744SYMBOL_STRING(getHostCallReturnValue) ":" "\n"
    1745     "ldr r5, [r5, #32]" "\n"
     1745    "ldr r5, [r5, #0]" "\n" // CallerFrameAndPC::callerFrame
    17461746    "mov r0, r5" "\n"
    17471747    "b " LOCAL_REFERENCE(getHostCallReturnValueWithExecState) "\n"
     
    17551755INLINE_ARM_FUNCTION(getHostCallReturnValue)
    17561756SYMBOL_STRING(getHostCallReturnValue) ":" "\n"
    1757     "ldr r5, [r5, #32]" "\n"
     1757    "ldr r5, [r5, #0]" "\n" // CallerFrameAndPC::callerFrame
    17581758    "mov r0, r5" "\n"
    17591759    "b " LOCAL_REFERENCE(getHostCallReturnValueWithExecState) "\n"
     
    17791779SYMBOL_STRING(getHostCallReturnValue) ":" "\n"
    17801780    LOAD_FUNCTION_TO_T9(getHostCallReturnValueWithExecState)
    1781     "lw $s0, 32($s0)" "\n"
     1781    "lw $s0, 0($s0)" "\n" // CallerFrameAndPC::callerFrame
    17821782    "move $a0, $s0" "\n"
    17831783    "b " LOCAL_REFERENCE(getHostCallReturnValueWithExecState) "\n"
     
    17901790HIDE_SYMBOL(getHostCallReturnValue) "\n"
    17911791SYMBOL_STRING(getHostCallReturnValue) ":" "\n"
    1792     "add #32, r14" "\n"
    1793     "mov.l @r14, r14" "\n"
     1792    "mov.l @r14, r14" "\n" // CallerFrameAndPC::callerFrame
    17941793    "mov r14, r4" "\n"
    17951794    "mov.l 2f, " SH4_SCRATCH_REGISTER "\n"
     
    18051804    {
    18061805        __asm {
    1807             mov edi, [edi + 32];
     1806            mov edi, [edi + 0]; // CallerFrameAndPC::callerFrame
    18081807            mov [esp + 4], edi;
    18091808            jmp getHostCallReturnValueWithExecState
  • trunk/Source/JavaScriptCore/jit/SpecializedThunkJIT.h

    r157653 r158315  
    9898            if (src != regT0)
    9999                move(src, regT0);
    100             loadPtr(payloadFor(JSStack::CallerFrame, callFrameRegister), callFrameRegister);
     100            loadPtr(Address(callFrameRegister, CallFrame::callerFrameOffset()), callFrameRegister);
    101101            ret();
    102102        }
     
    106106            ASSERT_UNUSED(payload, payload == regT0);
    107107            ASSERT_UNUSED(tag, tag == regT1);
    108             loadPtr(payloadFor(JSStack::CallerFrame, callFrameRegister), callFrameRegister);
     108            loadPtr(Address(callFrameRegister, CallFrame::callerFrameOffset()), callFrameRegister);
    109109            ret();
    110110        }
     
    132132            highNonZero.link(this);
    133133#endif
    134             loadPtr(payloadFor(JSStack::CallerFrame, callFrameRegister), callFrameRegister);
     134            loadPtr(Address(callFrameRegister, CallFrame::callerFrameOffset()), callFrameRegister);
    135135            ret();
    136136        }
     
    141141                move(src, regT0);
    142142            tagReturnAsInt32();
    143             loadPtr(payloadFor(JSStack::CallerFrame, callFrameRegister), callFrameRegister);
     143            loadPtr(Address(callFrameRegister, CallFrame::callerFrameOffset()), callFrameRegister);
    144144            ret();
    145145        }
     
    150150                move(src, regT0);
    151151            tagReturnAsJSCell();
    152             loadPtr(payloadFor(JSStack::CallerFrame, callFrameRegister), callFrameRegister);
     152            loadPtr(Address(callFrameRegister, CallFrame::callerFrameOffset()), callFrameRegister);
    153153            ret();
    154154        }
  • trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp

    r158237 r158315  
    6868
    6969    // 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);
    7571
    7672    jit.setupArgumentsExecState();
     
    8985    jit.preserveReturnAddressAfterCall(GPRInfo::nonArgGPR2);
    9086    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);
    9688    jit.storePtr(GPRInfo::callFrameRegister, &vm->topCallFrame);
    9789    jit.setupArgumentsExecState();
     
    10496    // 2) Host call return value returner thingy.
    10597    // 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));
    116100    emitPointerValidation(jit, GPRInfo::nonPreservedNonReturnGPR);
    117101    jit.restoreReturnAddressBeforeReturn(GPRInfo::nonPreservedNonReturnGPR);
     
    273257    // Load caller frame's scope chain into this callframe so that whatever we call can
    274258    // get to its global data.
    275     jit.emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, JSInterfaceJIT::regT0);
     259    jit.emitGetCallerFrameFromCallFrameHeaderPtr(JSInterfaceJIT::regT0);
    276260    jit.emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, JSInterfaceJIT::regT1, JSInterfaceJIT::regT0);
    277261    jit.emitPutCellToCallFrameHeader(JSInterfaceJIT::regT1, JSStack::ScopeChain);
    278262
    279263    jit.peek(JSInterfaceJIT::regT1);
    280     jit.emitPutToCallFrameHeader(JSInterfaceJIT::regT1, JSStack::ReturnPC);
     264    jit.emitPutReturnPCToCallFrameHeader(JSInterfaceJIT::regT1);
    281265
    282266    // Calling convention:      f(ecx, edx, ...);
     
    297281    // Load caller frame's scope chain into this callframe so that whatever we call can
    298282    // get to its global data.
    299     jit.emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, JSInterfaceJIT::regT0);
     283    jit.emitGetCallerFrameFromCallFrameHeaderPtr(JSInterfaceJIT::regT0);
    300284    jit.emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, JSInterfaceJIT::regT1, JSInterfaceJIT::regT0);
    301285    jit.emitPutCellToCallFrameHeader(JSInterfaceJIT::regT1, JSStack::ScopeChain);
    302286
    303287    jit.peek(JSInterfaceJIT::regT1);
    304     jit.emitPutToCallFrameHeader(JSInterfaceJIT::regT1, JSStack::ReturnPC);
     288    jit.emitPutReturnPCToCallFrameHeader(JSInterfaceJIT::regT1);
    305289
    306290#if !OS(WINDOWS)
     
    342326    // Load caller frame's scope chain into this callframe so that whatever we call can
    343327    // get to its global data.
    344     jit.emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, ARM64Registers::x3);
     328    jit.emitGetCallerFrameFromCallFrameHeaderPtr(ARM64Registers::x3);
    345329    jit.emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, JSInterfaceJIT::regT1, ARM64Registers::x3);
    346330    jit.emitPutCellToCallFrameHeader(JSInterfaceJIT::regT1, JSStack::ScopeChain);
    347331
    348332    jit.preserveReturnAddressAfterCall(JSInterfaceJIT::regT3); // Callee preserved
    349     jit.emitPutToCallFrameHeader(ARM64Registers::lr, JSStack::ReturnPC);
     333    jit.emitPutReturnPCToCallFrameHeader(ARM64Registers::lr);
    350334
    351335    // Host function signature: f(ExecState*);
     
    362346    // Load caller frame's scope chain into this callframe so that whatever we call can
    363347    // get to its global data.
    364     jit.emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, JSInterfaceJIT::regT2);
     348    jit.emitGetCallerFrameFromCallFrameHeaderPtr(JSInterfaceJIT::regT2);
    365349    jit.emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, JSInterfaceJIT::regT1, JSInterfaceJIT::regT2);
    366350    jit.emitPutCellToCallFrameHeader(JSInterfaceJIT::regT1, JSStack::ScopeChain);
    367351
    368352    jit.preserveReturnAddressAfterCall(JSInterfaceJIT::regT3); // Callee preserved
    369     jit.emitPutToCallFrameHeader(JSInterfaceJIT::regT3, JSStack::ReturnPC);
     353    jit.emitPutReturnPCToCallFrameHeader(JSInterfaceJIT::regT3);
    370354
    371355    // Calling convention:      f(r0 == regT0, r1 == regT1, ...);
     
    383367    // Load caller frame's scope chain into this callframe so that whatever we call can
    384368    // get to its global data.
    385     jit.emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, JSInterfaceJIT::regT2);
     369    jit.emitGetCallerFrameFromCallFrameHeaderPtr(JSInterfaceJIT::regT2);
    386370    jit.emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, JSInterfaceJIT::regT1, JSInterfaceJIT::regT2);
    387371    jit.emitPutCellToCallFrameHeader(JSInterfaceJIT::regT1, JSStack::ScopeChain);
    388372
    389373    jit.preserveReturnAddressAfterCall(JSInterfaceJIT::regT3); // Callee preserved
    390     jit.emitPutToCallFrameHeader(JSInterfaceJIT::regT3, JSStack::ReturnPC);
     374    jit.emitPutReturnPCToCallFrameHeader(JSInterfaceJIT::regT3);
    391375
    392376    // Calling convention: f(r0 == regT4, r1 == regT5, ...);
     
    404388    // Load caller frame's scope chain into this callframe so that whatever we call can
    405389    // get to its global data.
    406     jit.emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, JSInterfaceJIT::regT0);
     390    jit.emitGetCallerFrameFromCallFrameHeaderPtr(JSInterfaceJIT::regT0);
    407391    jit.emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, JSInterfaceJIT::regT1, JSInterfaceJIT::regT0);
    408392    jit.emitPutCellToCallFrameHeader(JSInterfaceJIT::regT1, JSStack::ScopeChain);
    409393
    410394    jit.preserveReturnAddressAfterCall(JSInterfaceJIT::regT3); // Callee preserved
    411     jit.emitPutToCallFrameHeader(JSInterfaceJIT::regT3, JSStack::ReturnPC);
     395    jit.emitPutReturnPCToCallFrameHeader(JSInterfaceJIT::regT3);
    412396
    413397    // Calling convention:      f(a0, a1, a2, a3);
  • trunk/Source/JavaScriptCore/llint/LLIntData.cpp

    r158237 r158315  
    7171    // Assertions to match LowLevelInterpreter.asm.  If you change any of this code, be
    7272    // 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
    8098    ASSERT(CallFrame::argumentOffsetIncludingThis(0) == JSStack::ThisArgument);
     99
    81100#if CPU(BIG_ENDIAN)
    82101    ASSERT(OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag) == 0);
  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter.asm

    r158237 r158315  
    3232
    3333# These declarations must match interpreter/JSStack.h.
    34 const CallFrameHeaderSize = 48
     34
     35if JSVALUE64
     36const PtrSize = 8
    3537const 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
     38else
     39const PtrSize = 4
     40const CallFrameHeaderSlots = 5
     41end
     42const SlotSize = 8
     43
     44const CallerFrame = 0
     45const ReturnPC = CallerFrame + PtrSize
     46const CodeBlock = ReturnPC + PtrSize
     47const ScopeChain = CodeBlock + SlotSize
     48const Callee = ScopeChain + SlotSize
     49const ArgumentCount = Callee + SlotSize
     50const ThisArgumentOffset = ArgumentCount + SlotSize
     51const CallFrameHeaderSize = ThisArgumentOffset
    4452
    4553# Some value representation constants.
Note: See TracChangeset for help on using the changeset viewer.