Changeset 189967 in webkit


Ignore:
Timestamp:
Sep 18, 2015, 9:21:08 AM (10 years ago)
Author:
msaboff@apple.com
Message:

Remove register preservation and restoration stub code
​https://bugs.webkit.org/show_bug.cgi?id=149335

Reviewed by Mark Lam.

Delete the register preservation and restoration thunks and related plumbing.

Much of this change is removing the unneeded RegisterPreservationMode parameter
from various functions.

(JSC::CallLinkInfo::isVarargsCallType):
(JSC::CallLinkInfo::CallLinkInfo):
(JSC::CallLinkInfo::isVarargs):
(JSC::CallLinkInfo::isLinked):
(JSC::CallLinkInfo::setUpCallFromFTL):
(JSC::CallLinkInfo::registerPreservationMode): Deleted.

  • ftl/FTLJITCode.cpp:

(JSC::FTL::JITCode::initializeAddressForCall):
(JSC::FTL::JITCode::addressForCall):

  • ftl/FTLJITCode.h:
  • ftl/FTLOSREntry.cpp:

(JSC::FTL::prepareOSREntry):

  • ftl/FTLOSRExitCompiler.cpp:

(JSC::FTL::compileStub):

  • jit/JITCode.cpp:

(JSC::JITCode::execute):
(JSC::DirectJITCode::initializeCodeRef):
(JSC::DirectJITCode::addressForCall):
(JSC::NativeJITCode::initializeCodeRef):
(JSC::NativeJITCode::addressForCall):
(JSC::DirectJITCode::ensureWrappers): Deleted.

  • jit/JITCode.h:

(JSC::JITCode::jitTypeFor):
(JSC::JITCode::executableAddress):

  • jit/JITOperations.cpp:
  • jit/RegisterPreservationWrapperGenerator.cpp: Removed.
  • jit/RegisterPreservationWrapperGenerator.h: Removed.
  • jit/Repatch.cpp:

(JSC::linkPolymorphicCall):

  • jit/ThunkGenerators.cpp:

(JSC::virtualThunkFor):

  • jit/ThunkGenerators.h:
  • llint/LLIntSlowPaths.cpp:

(JSC::LLInt::entryOSR):
(JSC::LLInt::setUpCall):

  • runtime/Executable.cpp:

(JSC::ExecutableBase::clearCode):
(JSC::ScriptExecutable::installCode):
(JSC::WebAssemblyExecutable::prepareForExecution):

  • runtime/Executable.h:

(JSC::ExecutableBase::generatedJITCodeFor):
(JSC::ExecutableBase::entrypointFor):
(JSC::ExecutableBase::offsetOfJITCodeWithArityCheckFor):

  • runtime/RegisterPreservationMode.h: Removed.
Location:
trunk/Source/JavaScriptCore
Files:
3 deleted
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/CMakeLists.txt

    r189961 r189967  
    388388    jit/RegisterAtOffset.cpp
    389389    jit/RegisterAtOffsetList.cpp
    390     jit/RegisterPreservationWrapperGenerator.cpp
    391390    jit/RegisterSet.cpp
    392391    jit/Repatch.cpp

  • trunk/Source/JavaScriptCore/ChangeLog

    r189964 r189967  
     12015-09-18  Michael Saboff  <msaboff@apple.com>
     2
     3        Remove register preservation and restoration stub code
     4        https://bugs.webkit.org/show_bug.cgi?id=149335
     5
     6        Reviewed by Mark Lam.
     7
     8        Delete the register preservation and restoration thunks and related plumbing.
     9
     10        Much of this change is removing the unneeded RegisterPreservationMode parameter
     11        from various functions.
     12
     13        * CMakeLists.txt:
     14        * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
     15        * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
     16        * JavaScriptCore.xcodeproj/project.pbxproj:
     17        * bytecode/CallLinkInfo.h:
     18        (JSC::CallLinkInfo::isVarargsCallType):
     19        (JSC::CallLinkInfo::CallLinkInfo):
     20        (JSC::CallLinkInfo::isVarargs):
     21        (JSC::CallLinkInfo::isLinked):
     22        (JSC::CallLinkInfo::setUpCallFromFTL):
     23        (JSC::CallLinkInfo::registerPreservationMode): Deleted.
     24        * ftl/FTLJITCode.cpp:
     25        (JSC::FTL::JITCode::initializeAddressForCall):
     26        (JSC::FTL::JITCode::addressForCall):
     27        * ftl/FTLJITCode.h:
     28        * ftl/FTLOSREntry.cpp:
     29        (JSC::FTL::prepareOSREntry):
     30        * ftl/FTLOSRExitCompiler.cpp:
     31        (JSC::FTL::compileStub):
     32        * jit/JITCode.cpp:
     33        (JSC::JITCode::execute):
     34        (JSC::DirectJITCode::initializeCodeRef):
     35        (JSC::DirectJITCode::addressForCall):
     36        (JSC::NativeJITCode::initializeCodeRef):
     37        (JSC::NativeJITCode::addressForCall):
     38        (JSC::DirectJITCode::ensureWrappers): Deleted.
     39        * jit/JITCode.h:
     40        (JSC::JITCode::jitTypeFor):
     41        (JSC::JITCode::executableAddress):
     42        * jit/JITOperations.cpp:
     43        * jit/RegisterPreservationWrapperGenerator.cpp: Removed.
     44        * jit/RegisterPreservationWrapperGenerator.h: Removed.
     45        * jit/Repatch.cpp:
     46        (JSC::linkPolymorphicCall):
     47        * jit/ThunkGenerators.cpp:
     48        (JSC::virtualThunkFor):
     49        * jit/ThunkGenerators.h:
     50        * llint/LLIntSlowPaths.cpp:
     51        (JSC::LLInt::entryOSR):
     52        (JSC::LLInt::setUpCall):
     53        * runtime/Executable.cpp:
     54        (JSC::ExecutableBase::clearCode):
     55        (JSC::ScriptExecutable::installCode):
     56        (JSC::WebAssemblyExecutable::prepareForExecution):
     57        * runtime/Executable.h:
     58        (JSC::ExecutableBase::generatedJITCodeFor):
     59        (JSC::ExecutableBase::entrypointFor):
     60        (JSC::ExecutableBase::offsetOfJITCodeWithArityCheckFor):
     61        * runtime/RegisterPreservationMode.h: Removed.
     62
    1632015-09-17  Joseph Pecoraro  <pecoraro@apple.com>
    264

  • trunk/Source/JavaScriptCore/JavaScriptCore.vcxproj/JavaScriptCore.vcxproj

    r189961 r189967  
    650650    <ClCompile Include="..\jit\RegisterAtOffset.cpp" />
    651651    <ClCompile Include="..\jit\RegisterAtOffsetList.cpp" />
    652     <ClCompile Include="..\jit\RegisterPreservationWrapperGenerator.cpp" />
    653652    <ClCompile Include="..\jit\RegisterSet.cpp" />
    654653    <ClCompile Include="..\jit\Repatch.cpp" />
    … …  
    14521451    <ClInclude Include="..\jit\RegisterAtOffsetList.h" />
    14531452    <ClInclude Include="..\jit\RegisterMap.h" />
    1454     <ClInclude Include="..\jit\RegisterPreservationWrapperGenerator.h" />
    14551453    <ClInclude Include="..\jit\RegisterSet.h" />
    14561454    <ClInclude Include="..\jit\Repatch.h" />

  • trunk/Source/JavaScriptCore/JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters

    r189961 r189967  
    14981498      <Filter>Derived Sources</Filter>
    14991499    </ClCompile>
    1500     <ClCompile Include="..\jit\RegisterPreservationWrapperGenerator.cpp">
    1501       <Filter>jit</Filter>
    1502     </ClCompile>
    15031500    <ClCompile Include="$(ConfigurationBuildDir)\obj$(PlatformArchitecture)\$(ProjectName)\DerivedSources\JSCBuiltins.cpp">
    15041501      <Filter>Derived Sources</Filter>
    … …  
    40414038    </ClInclude>
    40424039    <ClInclude Include="$(ConfigurationBuildDir)\obj$(PlatformArchitecture)\$(ProjectName)\DerivedSources\JSDataViewPrototype.lut.h" />
    4043     <ClInclude Include="..\jit\RegisterPreservationWrapperGenerator.h">
    4044       <Filter>jit</Filter>
    4045     </ClInclude>
    40464040    <ClInclude Include="..\ftl\FTLAbbreviatedTypes.h">
    40474041      <Filter>ftl</Filter>

  • trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

    r189961 r189967  
    379379                0F6B1CB6185FC9E900845D97 /* FTLJSCall.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F6B1CB4185FC9E900845D97 /* FTLJSCall.h */; settings = {ATTRIBUTES = (Private, ); }; };
    380380                0F6B1CB91861244C00845D97 /* ArityCheckMode.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F6B1CB71861244C00845D97 /* ArityCheckMode.h */; settings = {ATTRIBUTES = (Private, ); }; };
    381                 0F6B1CBA1861244C00845D97 /* RegisterPreservationMode.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F6B1CB81861244C00845D97 /* RegisterPreservationMode.h */; settings = {ATTRIBUTES = (Private, ); }; };
    382                 0F6B1CBD1861246A00845D97 /* RegisterPreservationWrapperGenerator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F6B1CBB1861246A00845D97 /* RegisterPreservationWrapperGenerator.cpp */; };
    383                 0F6B1CBE1861246A00845D97 /* RegisterPreservationWrapperGenerator.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F6B1CBC1861246A00845D97 /* RegisterPreservationWrapperGenerator.h */; settings = {ATTRIBUTES = (Private, ); }; };
    384381                0F6B1CC51862C47800845D97 /* FTLUnwindInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F6B1CC11862C47800845D97 /* FTLUnwindInfo.cpp */; };
    385382                0F6B1CC61862C47800845D97 /* FTLUnwindInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F6B1CC21862C47800845D97 /* FTLUnwindInfo.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    22102207                0F6B1CB4185FC9E900845D97 /* FTLJSCall.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FTLJSCall.h; path = ftl/FTLJSCall.h; sourceTree = "<group>"; };
    22112208                0F6B1CB71861244C00845D97 /* ArityCheckMode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ArityCheckMode.h; sourceTree = "<group>"; };
    2212                 0F6B1CB81861244C00845D97 /* RegisterPreservationMode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RegisterPreservationMode.h; sourceTree = "<group>"; };
    2213                 0F6B1CBB1861246A00845D97 /* RegisterPreservationWrapperGenerator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RegisterPreservationWrapperGenerator.cpp; sourceTree = "<group>"; };
    2214                 0F6B1CBC1861246A00845D97 /* RegisterPreservationWrapperGenerator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RegisterPreservationWrapperGenerator.h; sourceTree = "<group>"; };
    22152209                0F6B1CC11862C47800845D97 /* FTLUnwindInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = FTLUnwindInfo.cpp; path = ftl/FTLUnwindInfo.cpp; sourceTree = "<group>"; };
    22162210                0F6B1CC21862C47800845D97 /* FTLUnwindInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FTLUnwindInfo.h; path = ftl/FTLUnwindInfo.h; sourceTree = "<group>"; };
    … …  
    41584152                                6540C79D1B82D99D000F6B79 /* RegisterAtOffsetList.h */,
    41594153                                623A37EB1B87A7BD00754209 /* RegisterMap.h */,
    4160                                 0F6B1CBB1861246A00845D97 /* RegisterPreservationWrapperGenerator.cpp */,
    4161                                 0F6B1CBC1861246A00845D97 /* RegisterPreservationWrapperGenerator.h */,
    41624154                                0FC3141418146D7000033232 /* RegisterSet.cpp */,
    41634155                                0FC314101814559100033232 /* RegisterSet.h */,
    … …  
    49504942                                BCD202BF0E1706A7002C7E82 /* RegExpPrototype.cpp */,
    49514943                                BCD202C00E1706A7002C7E82 /* RegExpPrototype.h */,
    4952                                 0F6B1CB81861244C00845D97 /* RegisterPreservationMode.h */,
    49534944                                0FB7F39115ED8E3800F167B2 /* Reject.h */,
    49544945                                70B0A9D01A9B66200001306A /* RuntimeFlags.h */,
    … …  
    67466737                                BC18C45D0E16F5CD00B34460 /* Register.h in Headers */,
    67476738                                969A072B0ED1CE6900F1F681 /* RegisterID.h in Headers */,
    6748                                 0F6B1CBA1861244C00845D97 /* RegisterPreservationMode.h in Headers */,
    6749                                 0F6B1CBE1861246A00845D97 /* RegisterPreservationWrapperGenerator.h in Headers */,
    67506739                                0FC314121814559100033232 /* RegisterSet.h in Headers */,
    67516740                                0F50AF3C193E8B3900674EE8 /* DFGStructureClobberState.h in Headers */,
    … …  
    79277916                                14280843107EC0930013E7B2 /* RegExpObject.cpp in Sources */,
    79287917                                14280844107EC0930013E7B2 /* RegExpPrototype.cpp in Sources */,
    7929                                 0F6B1CBD1861246A00845D97 /* RegisterPreservationWrapperGenerator.cpp in Sources */,
    79307918                                0FC3141518146D7000033232 /* RegisterSet.cpp in Sources */,
    79317919                                A57D23ED1891B5540031C7FA /* RegularExpression.cpp in Sources */,

  • trunk/Source/JavaScriptCore/bytecode/CallLinkInfo.h

    r189884 r189967  
    7474
    7575    CallLinkInfo()
    76         : m_registerPreservationMode(static_cast<unsigned>(RegisterPreservationNotRequired))
    77         , m_hasSeenShouldRepatch(false)
     76        : m_hasSeenShouldRepatch(false)
    7877        , m_hasSeenClosure(false)
    7978        , m_clearedByGC(false)
    … …  
    136135    }
    137136
    138     RegisterPreservationMode registerPreservationMode() const
    139     {
    140         return static_cast<RegisterPreservationMode>(m_registerPreservationMode);
    141     }
    142 
    143137    bool isLinked() { return m_stub || m_callee; }
    144138    void unlink(VM&);
    … …  
    170164        CodeLocationNearCall hotPathOther, unsigned calleeGPR)
    171165    {
    172         m_registerPreservationMode = static_cast<unsigned>(RegisterPreservationNotRequired);
    173166        m_callType = callType;
    174167        m_codeOrigin = codeOrigin;
    … …  
    347340    RefPtr<PolymorphicCallStubRoutine> m_stub;
    348341    RefPtr<JITStubRoutine> m_slowStub;
    349     unsigned m_registerPreservationMode : 1; // Real type is RegisterPreservationMode
    350342    bool m_hasSeenShouldRepatch : 1;
    351343    bool m_hasSeenClosure : 1;

  • trunk/Source/JavaScriptCore/ftl/FTLJITCode.cpp

    r187488 r189967  
    7676}
    7777
    78 JITCode::CodePtr JITCode::addressForCall(VM&, ExecutableBase*, ArityCheckMode arityCheck, RegisterPreservationMode)
     78JITCode::CodePtr JITCode::addressForCall(ArityCheckMode arityCheck)
    7979{
    8080    switch (arityCheck) {

  • trunk/Source/JavaScriptCore/ftl/FTLJITCode.h

    r189575 r189967  
    5959    ~JITCode();
    6060   
    61     CodePtr addressForCall(VM&, ExecutableBase*, ArityCheckMode, RegisterPreservationMode) override;
     61    CodePtr addressForCall(ArityCheckMode) override;
    6262    void* executableAddressAtOffset(size_t offset) override;
    6363    void* dataAddressAtOffset(size_t offset) override;

  • trunk/Source/JavaScriptCore/ftl/FTLOSREntry.cpp

    r188311 r189967  
    101101    exec->setCodeBlock(entryCodeBlock);
    102102   
    103     void* result = entryCode->addressForCall(
    104         vm, executable, ArityCheckNotRequired,
    105         RegisterPreservationNotRequired).executableAddress();
     103    void* result = entryCode->addressForCall(ArityCheckNotRequired).executableAddress();
    106104    if (Options::verboseOSR())
    107105        dataLog("    Entry will succeed, going to address", RawPointer(result), "\n");

  • trunk/Source/JavaScriptCore/ftl/FTLOSRExitCompiler.cpp

    r189961 r189967  
    4141#include "OperandsInlines.h"
    4242#include "JSCInlines.h"
    43 #include "RegisterPreservationWrapperGenerator.h"
    4443
    4544namespace JSC { namespace FTL {
    … …  
    380379    // restoration thunk would restore them from.
    381380   
    382     ptrdiff_t offset = registerPreservationOffset();
    383     RegisterSet toSave = registersToPreserve();
    384    
    385381    // Before we start messing with the frame, we need to set aside any registers that the
    386382    // FTL code was preserving.
    … …  
    398394    // contain some extra stuff.
    399395    //
    400     // First we compute the padded stack space:
     396    // We compute the padded stack space:
    401397    //
    402398    //     paddedStackSpace = roundUp(codeBlock->numParameters - regT2 + 1)
    403399    //
    404     // The stack will have regT2 + CallFrameHeaderSize stuff, but above it there will be
    405     // paddedStackSpace gunk used by the arity check fail restoration thunk. When that happens
    406     // we want to make the stack look like this, from higher addresses down:
     400    // The stack will have regT2 + CallFrameHeaderSize stuff.
     401    // We want to make the stack look like this, from higher addresses down:
    407402    //
    408     //     - register preservation return PC
    409     //     - preserved registers
    410     //     - arity check fail return PC
    411403    //     - argument padding
    412404    //     - actual arguments
    413405    //     - call frame header
    414     //
    415     // So that the actual call frame header appears to return to the arity check fail return
    416     // PC, and that then returns to the register preservation thunk. The arity check thunk that
    417     // we return to will have the padding size encoded into it. It will then know to return
    418     // into the register preservation thunk, which uses the argument count to figure out where
    419     // registers are preserved.
    420406
    421407    // This code assumes that we're dealing with FunctionCode.
    … …  
    437423    // First set up SP so that our data doesn't get clobbered by signals.
    438424    unsigned conservativeStackDelta =
    439         registerPreservationOffset() +
    440425        (exit.m_values.numberOfLocals() + baselineCodeBlock->calleeSaveSpaceAsVirtualRegisters()) * sizeof(Register) +
    441426        maxFrameExtentForSlowPathCall;
    … …  
    446431        MacroAssembler::framePointerRegister, MacroAssembler::stackPointerRegister);
    447432    jit.checkStackPointerAlignment();
    448    
    449     jit.subPtr(
    450         MacroAssembler::TrustedImm32(registerPreservationOffset()),
    451         MacroAssembler::framePointerRegister);
    452    
    453     // Copy the old frame data into its new location.
    454     jit.add32(MacroAssembler::TrustedImm32(JSStack::CallFrameHeaderSize), GPRInfo::regT2);
    455     jit.move(MacroAssembler::framePointerRegister, GPRInfo::regT1);
    456     MacroAssembler::Label loop = jit.label();
    457     jit.sub32(MacroAssembler::TrustedImm32(1), GPRInfo::regT2);
    458     jit.load64(MacroAssembler::Address(GPRInfo::regT1, offset), GPRInfo::regT0);
    459     jit.store64(GPRInfo::regT0, GPRInfo::regT1);
    460     jit.addPtr(MacroAssembler::TrustedImm32(sizeof(Register)), GPRInfo::regT1);
    461     jit.branchTest32(MacroAssembler::NonZero, GPRInfo::regT2).linkTo(loop, &jit);
    462 
     433
     434    RegisterSet allFTLCalleeSaves = RegisterSet::ftlCalleeSaveRegisters();
    463435    RegisterAtOffsetList* baselineCalleeSaves = baselineCodeBlock->calleeSaveRegisters();
    464436
    465437    for (Reg reg = Reg::first(); reg <= Reg::last(); reg = reg.next()) {
    466         if (!toSave.get(reg) || !reg.isGPR())
     438        if (!allFTLCalleeSaves.get(reg) || !reg.isGPR())
    467439            continue;
    468440        unsigned unwindIndex = codeBlock->calleeSaveRegisters()->indexOf(reg);

  • trunk/Source/JavaScriptCore/jit/JITCode.cpp

    r187488 r189967  
    3030#include "JSCInlines.h"
    3131#include "ProtoCallFrame.h"
    32 #include "RegisterPreservationWrapperGenerator.h"
    3332#include <wtf/PrintStream.h>
    3433
    … …  
    7877        entryAddress = executableAddress();
    7978    } else
    80         entryAddress = addressForCall(*vm, function->executable(), MustCheckArity, RegisterPreservationNotRequired).executableAddress();
     79        entryAddress = addressForCall(MustCheckArity).executableAddress();
    8180    JSValue result = JSValue::decode(vmEntryToJavaScript(entryAddress, vm, protoCallFrame));
    8281    return vm->exception() ? jsNull() : result;
    … …  
    180179}
    181180
    182 DirectJITCode::RegisterPreservationWrappers* DirectJITCode::ensureWrappers()
    183 {
    184     if (!m_wrappers)
    185         m_wrappers = std::make_unique<RegisterPreservationWrappers>();
    186     return m_wrappers.get();
    187 }
    188 
    189 JITCode::CodePtr DirectJITCode::addressForCall(
    190     VM& vm, ExecutableBase* executable, ArityCheckMode arity,
    191     RegisterPreservationMode registers)
     181JITCode::CodePtr DirectJITCode::addressForCall(ArityCheckMode arity)
    192182{
    193183    switch (arity) {
    194184    case ArityCheckNotRequired:
    195         switch (registers) {
    196         case RegisterPreservationNotRequired:
    197             RELEASE_ASSERT(m_ref);
    198             return m_ref.code();
    199         case MustPreserveRegisters: {
    200 #if ENABLE(JIT)
    201             RegisterPreservationWrappers* wrappers = ensureWrappers();
    202             if (!wrappers->withoutArityCheck)
    203                 wrappers->withoutArityCheck = generateRegisterPreservationWrapper(vm, executable, m_ref.code());
    204             return wrappers->withoutArityCheck.code();
    205 #else
    206             UNUSED_PARAM(vm);
    207             UNUSED_PARAM(executable);
    208             RELEASE_ASSERT_NOT_REACHED();
    209 #endif
    210         } }
     185        RELEASE_ASSERT(m_ref);
     186        return m_ref.code();
    211187    case MustCheckArity:
    212         switch (registers) {
    213         case RegisterPreservationNotRequired:
    214             RELEASE_ASSERT(m_withArityCheck);
    215             return m_withArityCheck;
    216         case MustPreserveRegisters: {
    217 #if ENABLE(JIT)
    218             RegisterPreservationWrappers* wrappers = ensureWrappers();
    219             if (!wrappers->withArityCheck)
    220                 wrappers->withArityCheck = generateRegisterPreservationWrapper(vm, executable, m_withArityCheck);
    221             return wrappers->withArityCheck.code();
    222 #else
    223             RELEASE_ASSERT_NOT_REACHED();
    224 #endif
    225         } }
     188        RELEASE_ASSERT(m_withArityCheck);
     189        return m_withArityCheck;
    226190    }
    227191    RELEASE_ASSERT_NOT_REACHED();
    … …  
    249213}
    250214
    251 JITCode::CodePtr NativeJITCode::addressForCall(
    252     VM&, ExecutableBase*, ArityCheckMode, RegisterPreservationMode)
     215JITCode::CodePtr NativeJITCode::addressForCall(ArityCheckMode)
    253216{
    254217    RELEASE_ASSERT(!!m_ref);

  • trunk/Source/JavaScriptCore/jit/JITCode.h

    r189889 r189967  
    3333#include "JSCJSValue.h"
    3434#include "MacroAssemblerCodeRef.h"
    35 #include "RegisterPreservationMode.h"
    3635
    3736namespace JSC {
    … …  
    196195    }
    197196   
    198     virtual CodePtr addressForCall(VM&, ExecutableBase*, ArityCheckMode, RegisterPreservationMode) = 0;
     197    virtual CodePtr addressForCall(ArityCheckMode) = 0;
    199198    virtual void* executableAddressAtOffset(size_t offset) = 0;
    200199    void* executableAddress() { return executableAddressAtOffset(0); }
    … …  
    247246    void initializeCodeRef(CodeRef, CodePtr withArityCheck);
    248247
    249     virtual CodePtr addressForCall(VM&, ExecutableBase*, ArityCheckMode, RegisterPreservationMode) override;
     248    virtual CodePtr addressForCall(ArityCheckMode) override;
    250249
    251250private:
    252     struct RegisterPreservationWrappers {
    253         CodeRef withoutArityCheck;
    254         CodeRef withArityCheck;
    255     };
    256 
    257     RegisterPreservationWrappers* ensureWrappers();
    258    
    259251    CodePtr m_withArityCheck;
    260    
    261     std::unique_ptr<RegisterPreservationWrappers> m_wrappers;
    262252};
    263253
    … …  
    270260    void initializeCodeRef(CodeRef);
    271261
    272     virtual CodePtr addressForCall(VM&, ExecutableBase*, ArityCheckMode, RegisterPreservationMode) override;
     262    virtual CodePtr addressForCall(ArityCheckMode) override;
    273263};
    274264

  • trunk/Source/JavaScriptCore/jit/JITOperations.cpp

    r189920 r189967  
    768768    CodeBlock* codeBlock = 0;
    769769    if (executable->isHostFunction()) {
    770         codePtr = executable->entrypointFor(*vm, kind, MustCheckArity, callLinkInfo->registerPreservationMode());
     770        codePtr = executable->entrypointFor(kind, MustCheckArity);
    771771#if ENABLE(WEBASSEMBLY)
    772772    } else if (executable->isWebAssemblyExecutable()) {
    … …  
    780780        else
    781781            arity = ArityCheckNotRequired;
    782         codePtr = webAssemblyExecutable->entrypointFor(*vm, kind, arity, callLinkInfo->registerPreservationMode());
     782        codePtr = webAssemblyExecutable->entrypointFor(kind, arity);
    783783#endif
    784784    } else {
    … …  
    805805        else
    806806            arity = ArityCheckNotRequired;
    807         codePtr = functionExecutable->entrypointFor(*vm, kind, arity, callLinkInfo->registerPreservationMode());
     807        codePtr = functionExecutable->entrypointFor(kind, arity);
    808808    }
    809809    if (!callLinkInfo->seenOnce())
    … …  
    868868    }
    869869    return encodeResult(executable->entrypointFor(
    870         *vm, kind, MustCheckArity, callLinkInfo->registerPreservationMode()).executableAddress(),
     870        kind, MustCheckArity).executableAddress(),
    871871        reinterpret_cast<void*>(callLinkInfo->callMode() == CallMode::Tail ? ReuseTheFrame : KeepTheFrame));
    872872}

  • trunk/Source/JavaScriptCore/jit/Repatch.cpp

    r189884 r189967  
    796796        ASSERT(variant.executable()->hasJITCodeForCall());
    797797        MacroAssemblerCodePtr codePtr =
    798             variant.executable()->generatedJITCodeForCall()->addressForCall(
    799                 *vm, variant.executable(), ArityCheckNotRequired, callLinkInfo.registerPreservationMode());
     798            variant.executable()->generatedJITCodeForCall()->addressForCall(ArityCheckNotRequired);
    800799       
    801800        if (fastCounts) {

  • trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp

    r189884 r189967  
    203203        CCallHelpers::Address(
    204204            GPRInfo::regT4, ExecutableBase::offsetOfJITCodeWithArityCheckFor(
    205                 callLinkInfo.specializationKind(), callLinkInfo.registerPreservationMode())),
     205                callLinkInfo.specializationKind())),
    206206        GPRInfo::regT4);
    207207    slowCase.append(jit.branchTestPtr(CCallHelpers::Zero, GPRInfo::regT4));

  • trunk/Source/JavaScriptCore/jit/ThunkGenerators.h

    r189884 r189967  
    2828
    2929#include "CodeSpecializationKind.h"
    30 #include "RegisterPreservationMode.h"
    3130#include "ThunkGenerator.h"
    3231
    … …  
    3938MacroAssemblerCodeRef throwExceptionFromCallSlowPathGenerator(VM*);
    4039
    41 MacroAssemblerCodeRef linkCallThunk(VM*, CallLinkInfo&, CodeSpecializationKind, RegisterPreservationMode);
     40MacroAssemblerCodeRef linkCallThunk(VM*, CallLinkInfo&, CodeSpecializationKind);
    4241MacroAssemblerCodeRef linkCallThunkGenerator(VM*);
    4342MacroAssemblerCodeRef linkPolymorphicCallThunkGenerator(VM*);

  • trunk/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp

    r189920 r189967  
    358358        LLINT_RETURN_TWO(codeBlock->jitCode()->executableAddress(), 0);
    359359    ASSERT(kind == ArityCheck);
    360     LLINT_RETURN_TWO(codeBlock->jitCode()->addressForCall(
    361         *codeBlock->vm(), codeBlock->ownerExecutable(), MustCheckArity,
    362         RegisterPreservationNotRequired).executableAddress(), 0);
     360    LLINT_RETURN_TWO(codeBlock->jitCode()->addressForCall(MustCheckArity).executableAddress(), 0);
    363361}
    364362#else // ENABLE(JIT)
    … …  
    11431141
    11441142    if (executable->isHostFunction()) {
    1145         codePtr = executable->entrypointFor(vm, kind, MustCheckArity, RegisterPreservationNotRequired);
     1143        codePtr = executable->entrypointFor(kind, MustCheckArity);
    11461144    } else if (!isWebAssemblyExecutable) {
    11471145        FunctionExecutable* functionExecutable = static_cast<FunctionExecutable*>(executable);
    … …  
    11601158        else
    11611159            arity = ArityCheckNotRequired;
    1162         codePtr = functionExecutable->entrypointFor(vm, kind, arity, RegisterPreservationNotRequired);
     1160        codePtr = functionExecutable->entrypointFor(kind, arity);
    11631161    } else {
    11641162#if ENABLE(WEBASSEMBLY)
    … …  
    11721170        else
    11731171            arity = ArityCheckNotRequired;
    1174         codePtr = webAssemblyExecutable->entrypointFor(vm, kind, arity, RegisterPreservationNotRequired);
     1172        codePtr = webAssemblyExecutable->entrypointFor(kind, arity);
    11751173#endif
    11761174    }

  • trunk/Source/JavaScriptCore/runtime/Executable.cpp

    r189889 r189967  
    5858    m_jitCodeForCallWithArityCheck = MacroAssemblerCodePtr();
    5959    m_jitCodeForConstructWithArityCheck = MacroAssemblerCodePtr();
    60     m_jitCodeForCallWithArityCheckAndPreserveRegs = MacroAssemblerCodePtr();
    61     m_jitCodeForConstructWithArityCheckAndPreserveRegs = MacroAssemblerCodePtr();
    6260#endif
    6361    m_numParametersForCall = NUM_PARAMETERS_NOT_COMPILED;
    … …  
    184182        m_jitCodeForCall = genericCodeBlock ? genericCodeBlock->jitCode() : nullptr;
    185183        m_jitCodeForCallWithArityCheck = MacroAssemblerCodePtr();
    186         m_jitCodeForCallWithArityCheckAndPreserveRegs = MacroAssemblerCodePtr();
    187184        m_numParametersForCall = genericCodeBlock ? genericCodeBlock->numParameters() : NUM_PARAMETERS_NOT_COMPILED;
    188185        break;
    … …  
    190187        m_jitCodeForConstruct = genericCodeBlock ? genericCodeBlock->jitCode() : nullptr;
    191188        m_jitCodeForConstructWithArityCheck = MacroAssemblerCodePtr();
    192         m_jitCodeForConstructWithArityCheckAndPreserveRegs = MacroAssemblerCodePtr();
    193189        m_numParametersForConstruct = genericCodeBlock ? genericCodeBlock->numParameters() : NUM_PARAMETERS_NOT_COMPILED;
    194190        break;
    … …  
    746742    m_jitCodeForCall = codeBlock->jitCode();
    747743    m_jitCodeForCallWithArityCheck = MacroAssemblerCodePtr();
    748     m_jitCodeForCallWithArityCheckAndPreserveRegs = MacroAssemblerCodePtr();
    749744    m_numParametersForCall = codeBlock->numParameters();
    750745

  • trunk/Source/JavaScriptCore/runtime/Executable.h

    r189889 r189967  
    3838#include "JITCode.h"
    3939#include "JSGlobalObject.h"
    40 #include "RegisterPreservationMode.h"
    4140#include "SamplingTool.h"
    4241#include "SourceCode.h"
    … …  
    164163    }
    165164   
    166     MacroAssemblerCodePtr entrypointFor(
    167         VM& vm, CodeSpecializationKind kind, ArityCheckMode arity, RegisterPreservationMode registers)
     165    MacroAssemblerCodePtr entrypointFor(CodeSpecializationKind kind, ArityCheckMode arity)
    168166    {
    169167        // Check if we have a cached result. We only have it for arity check because we use the
    … …  
    173171            switch (kind) {
    174172            case CodeForCall:
    175                 switch (registers) {
    176                 case RegisterPreservationNotRequired:
    177                     if (MacroAssemblerCodePtr result = m_jitCodeForCallWithArityCheck)
    178                         return result;
    179                     break;
    180                 case MustPreserveRegisters:
    181                     if (MacroAssemblerCodePtr result = m_jitCodeForCallWithArityCheckAndPreserveRegs)
    182                         return result;
    183                     break;
    184                 }
     173                if (MacroAssemblerCodePtr result = m_jitCodeForCallWithArityCheck)
     174                    return result;
    185175                break;
    186176            case CodeForConstruct:
    187                 switch (registers) {
    188                 case RegisterPreservationNotRequired:
    189                     if (MacroAssemblerCodePtr result = m_jitCodeForConstructWithArityCheck)
    190                         return result;
    191                     break;
    192                 case MustPreserveRegisters:
    193                     if (MacroAssemblerCodePtr result = m_jitCodeForConstructWithArityCheckAndPreserveRegs)
    194                         return result;
    195                     break;
    196                 }
     177                if (MacroAssemblerCodePtr result = m_jitCodeForConstructWithArityCheck)
     178                    return result;
    197179                break;
    198180            }
    199181        }
    200182        MacroAssemblerCodePtr result =
    201             generatedJITCodeFor(kind)->addressForCall(vm, this, arity, registers);
     183            generatedJITCodeFor(kind)->addressForCall(arity);
    202184        if (arity == MustCheckArity) {
    203185            // Cache the result; this is necessary for the JIT's virtual call optimizations.
    204186            switch (kind) {
    205187            case CodeForCall:
    206                 switch (registers) {
    207                 case RegisterPreservationNotRequired:
    208                     m_jitCodeForCallWithArityCheck = result;
    209                     break;
    210                 case MustPreserveRegisters:
    211                     m_jitCodeForCallWithArityCheckAndPreserveRegs = result;
    212                     break;
    213                 }
     188                m_jitCodeForCallWithArityCheck = result;
    214189                break;
    215190            case CodeForConstruct:
    216                 switch (registers) {
    217                 case RegisterPreservationNotRequired:
    218                     m_jitCodeForConstructWithArityCheck = result;
    219                     break;
    220                 case MustPreserveRegisters:
    221                     m_jitCodeForConstructWithArityCheckAndPreserveRegs = result;
    222                     break;
    223                 }
     191                m_jitCodeForConstructWithArityCheck = result;
    224192                break;
    225193            }
    … …  
    229197
    230198    static ptrdiff_t offsetOfJITCodeWithArityCheckFor(
    231         CodeSpecializationKind kind, RegisterPreservationMode registers)
     199        CodeSpecializationKind kind)
    232200    {
    233201        switch (kind) {
    234202        case CodeForCall:
    235             switch (registers) {
    236             case RegisterPreservationNotRequired:
    237                 return OBJECT_OFFSETOF(ExecutableBase, m_jitCodeForCallWithArityCheck);
    238             case MustPreserveRegisters:
    239                 return OBJECT_OFFSETOF(ExecutableBase, m_jitCodeForCallWithArityCheckAndPreserveRegs);
    240             }
     203            return OBJECT_OFFSETOF(ExecutableBase, m_jitCodeForCallWithArityCheck);
    241204        case CodeForConstruct:
    242             switch (registers) {
    243             case RegisterPreservationNotRequired:
    244                 return OBJECT_OFFSETOF(ExecutableBase, m_jitCodeForConstructWithArityCheck);
    245             case MustPreserveRegisters:
    246                 return OBJECT_OFFSETOF(ExecutableBase, m_jitCodeForConstructWithArityCheckAndPreserveRegs);
    247             }
     205            return OBJECT_OFFSETOF(ExecutableBase, m_jitCodeForConstructWithArityCheck);
    248206        }
    249207        RELEASE_ASSERT_NOT_REACHED();
    … …  
    294252    MacroAssemblerCodePtr m_jitCodeForCallWithArityCheck;
    295253    MacroAssemblerCodePtr m_jitCodeForConstructWithArityCheck;
    296     MacroAssemblerCodePtr m_jitCodeForCallWithArityCheckAndPreserveRegs;
    297     MacroAssemblerCodePtr m_jitCodeForConstructWithArityCheckAndPreserveRegs;
    298254};
    299255
Note: See TracChangeset for help on using the changeset viewer.