Changeset 292083 in webkit


Ignore:
Timestamp:
Mar 29, 2022, 5:08:22 PM (3 years ago)
Author:
[email protected]
Message:

[JSC] Use constants buffer to load JSGlobalObject in BaselineJIT thunks
https://bugs.webkit.org/show_bug.cgi?id=238414

Reviewed by Saam Barati.

Since these thunks are only called from BaselineJIT, we can assume constants
buffer register. And since we are always using 0 index for JSGlobalObject,
we can encode this into these shared thunks directly instead of loading
CodeBlock pointer from the stack.

We also fix using OBJECT_OFFSETOF for JSGlobalObject directly. We should use
it as JSGlobalObject::offsetOfXXX to make it clean and make it annotated that
these fields are accessed by JIT.

This patch also removes UnusedPointer.h since it is no longer used.

  • CMakeLists.txt:
  • JavaScriptCore.xcodeproj/project.pbxproj:
  • jit/JIT.cpp:

(JSC::JIT::JIT):
(JSC::JIT::emitVarReadOnlyCheck):

  • jit/JIT.h:
  • jit/JITInlines.h:

(JSC::JIT::loadConstant):
(JSC::JIT::loadGlobalObject):

  • jit/JITOpcodes.cpp:

(JSC::JIT::emit_op_overrides_has_instance):
(JSC::JIT::valueIsFalseyGenerator):
(JSC::JIT::valueIsTruthyGenerator):
(JSC::JIT::op_throw_handlerGenerator):
(JSC::JIT::op_check_traps_handlerGenerator):

  • jit/JITPropertyAccess.cpp:

(JSC::JIT::slow_op_get_by_val_callSlowOperationThenCheckExceptionGenerator):
(JSC::JIT::slow_op_get_private_name_callSlowOperationThenCheckExceptionGenerator):
(JSC::JIT::slow_op_put_by_val_callSlowOperationThenCheckExceptionGenerator):
(JSC::JIT::slow_op_put_private_name_callSlowOperationThenCheckExceptionGenerator):
(JSC::JIT::slow_op_del_by_id_callSlowOperationThenCheckExceptionGenerator):
(JSC::JIT::slow_op_del_by_val_callSlowOperationThenCheckExceptionGenerator):
(JSC::JIT::slow_op_get_by_id_callSlowOperationThenCheckExceptionGenerator):
(JSC::JIT::slow_op_get_by_id_with_this_callSlowOperationThenCheckExceptionGenerator):
(JSC::JIT::slow_op_put_by_id_callSlowOperationThenCheckExceptionGenerator):
(JSC::JIT::generateOpResolveScopeThunk):
(JSC::JIT::generateOpGetFromScopeThunk):
(JSC::JIT::emitVarInjectionCheck):

  • jit/UnusedPointer.h: Removed.
  • runtime/JSGlobalObject.h:

(JSC::JSGlobalObject::offsetOfVarInjectionWatchpoint):
(JSC::JSGlobalObject::offsetOfVarReadOnlyWatchpoint):
(JSC::JSGlobalObject::offsetOfFunctionProtoHasInstanceSymbolFunction):

Location:
trunk/Source/JavaScriptCore
Files:
1 deleted
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/JavaScriptCore/CMakeLists.txt

    r290647 r292083  
    877877    jit/TempRegisterSet.h
    878878    jit/ThunkGenerator.h
    879     jit/UnusedPointer.h
    880879
    881880    llint/LLIntOpcode.h
  • trunk/Source/JavaScriptCore/ChangeLog

    r292080 r292083  
     12022-03-29  Yusuke Suzuki  <[email protected]>
     2
     3        [JSC] Use constants buffer to load JSGlobalObject in BaselineJIT thunks
     4        https://bugs.webkit.org/show_bug.cgi?id=238414
     5
     6        Reviewed by Saam Barati.
     7
     8        Since these thunks are only called from BaselineJIT, we can assume constants
     9        buffer register. And since we are always using 0 index for JSGlobalObject,
     10        we can encode this into these shared thunks directly instead of loading
     11        CodeBlock pointer from the stack.
     12
     13        We also fix using OBJECT_OFFSETOF for JSGlobalObject directly. We should use
     14        it as JSGlobalObject::offsetOfXXX to make it clean and make it annotated that
     15        these fields are accessed by JIT.
     16
     17        This patch also removes UnusedPointer.h since it is no longer used.
     18
     19        * CMakeLists.txt:
     20        * JavaScriptCore.xcodeproj/project.pbxproj:
     21        * jit/JIT.cpp:
     22        (JSC::JIT::JIT):
     23        (JSC::JIT::emitVarReadOnlyCheck):
     24        * jit/JIT.h:
     25        * jit/JITInlines.h:
     26        (JSC::JIT::loadConstant):
     27        (JSC::JIT::loadGlobalObject):
     28        * jit/JITOpcodes.cpp:
     29        (JSC::JIT::emit_op_overrides_has_instance):
     30        (JSC::JIT::valueIsFalseyGenerator):
     31        (JSC::JIT::valueIsTruthyGenerator):
     32        (JSC::JIT::op_throw_handlerGenerator):
     33        (JSC::JIT::op_check_traps_handlerGenerator):
     34        * jit/JITPropertyAccess.cpp:
     35        (JSC::JIT::slow_op_get_by_val_callSlowOperationThenCheckExceptionGenerator):
     36        (JSC::JIT::slow_op_get_private_name_callSlowOperationThenCheckExceptionGenerator):
     37        (JSC::JIT::slow_op_put_by_val_callSlowOperationThenCheckExceptionGenerator):
     38        (JSC::JIT::slow_op_put_private_name_callSlowOperationThenCheckExceptionGenerator):
     39        (JSC::JIT::slow_op_del_by_id_callSlowOperationThenCheckExceptionGenerator):
     40        (JSC::JIT::slow_op_del_by_val_callSlowOperationThenCheckExceptionGenerator):
     41        (JSC::JIT::slow_op_get_by_id_callSlowOperationThenCheckExceptionGenerator):
     42        (JSC::JIT::slow_op_get_by_id_with_this_callSlowOperationThenCheckExceptionGenerator):
     43        (JSC::JIT::slow_op_put_by_id_callSlowOperationThenCheckExceptionGenerator):
     44        (JSC::JIT::generateOpResolveScopeThunk):
     45        (JSC::JIT::generateOpGetFromScopeThunk):
     46        (JSC::JIT::emitVarInjectionCheck):
     47        * jit/UnusedPointer.h: Removed.
     48        * runtime/JSGlobalObject.h:
     49        (JSC::JSGlobalObject::offsetOfVarInjectionWatchpoint):
     50        (JSC::JSGlobalObject::offsetOfVarReadOnlyWatchpoint):
     51        (JSC::JSGlobalObject::offsetOfFunctionProtoHasInstanceSymbolFunction):
     52
    1532022-03-29  Geza Lore  <[email protected]>
    254
  • trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

    r291935 r292083  
    270270                0F2DD8141AB3D8BE00BBB8E8 /* DFGArgumentsUtilities.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F2DD80F1AB3D8BE00BBB8E8 /* DFGArgumentsUtilities.h */; };
    271271                0F2DD8151AB3D8BE00BBB8E8 /* DFGForAllKills.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F2DD8101AB3D8BE00BBB8E8 /* DFGForAllKills.h */; };
    272                 0F2E892C16D028AD009E4FD2 /* UnusedPointer.h in Headers */ = {isa = PBXBuildFile; fileRef = 65987F2F16828A7E003C2F8D /* UnusedPointer.h */; settings = {ATTRIBUTES = (Private, ); }; };
    273272                0F2E892D16D02BAF009E4FD2 /* DFGMinifiedID.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FB4B51016B3A964003F696B /* DFGMinifiedID.h */; settings = {ATTRIBUTES = (Private, ); }; };
    274273                0F2FC77316E12F740038D976 /* DFGDCEPhase.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F2FC77116E12F6F0038D976 /* DFGDCEPhase.h */; };
     
    42144213                658D3A5519638268003C45D6 /* VMEntryRecord.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = VMEntryRecord.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
    42154214                65987F2C167FE84B003C2F8D /* DFGOSRExitCompilationInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DFGOSRExitCompilationInfo.h; path = dfg/DFGOSRExitCompilationInfo.h; sourceTree = "<group>"; };
    4216                 65987F2F16828A7E003C2F8D /* UnusedPointer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UnusedPointer.h; sourceTree = "<group>"; };
    42174215                659CDA591F67509800D3E53F /* YarrUnicodeProperties.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = YarrUnicodeProperties.cpp; path = yarr/YarrUnicodeProperties.cpp; sourceTree = "<group>"; };
    42184216                659CDA5A1F67509800D3E53F /* YarrUnicodeProperties.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = YarrUnicodeProperties.h; path = yarr/YarrUnicodeProperties.h; sourceTree = "<group>"; };
     
    66816679                                A7386552118697B400540279 /* ThunkGenerators.cpp */,
    66826680                                A7386553118697B400540279 /* ThunkGenerators.h */,
    6683                                 65987F2F16828A7E003C2F8D /* UnusedPointer.h */,
    66846681                        );
    66856682                        path = jit;
     
    1120611203                                14AD91261DCA9FA40014F9FE /* UnlinkedProgramCodeBlock.h in Headers */,
    1120711204                                14AB66761DECF40900A56C26 /* UnlinkedSourceCode.h in Headers */,
    11208                                 0F2E892C16D028AD009E4FD2 /* UnusedPointer.h in Headers */,
    1120911205                                99DA00B11BD5994E00F4575C /* UpdateContents.py in Headers */,
    1121011206                                0F963B3813FC6FE90002D9B2 /* ValueProfile.h in Headers */,
  • trunk/Source/JavaScriptCore/jit/JIT.cpp

    r290768 r292083  
    7878    , m_loopOSREntryBytecodeIndex(loopOSREntryBytecodeIndex)
    7979{
    80     m_globalObjectConstant = addToConstantPool(JITConstantPool::Type::GlobalObject);
     80    auto globalObjectConstant = addToConstantPool(JITConstantPool::Type::GlobalObject);
     81    ASSERT_UNUSED(globalObjectConstant, globalObjectConstant == s_globalObjectConstant);
    8182    m_profiledCodeBlock = codeBlock;
    8283    m_unlinkedCodeBlock = codeBlock->unlinkedCodeBlock();
     
    138139    if (resolveType == GlobalVar || resolveType == GlobalVarWithVarInjectionChecks) {
    139140        loadGlobalObject(scratchGPR);
    140         loadPtr(Address(scratchGPR, OBJECT_OFFSETOF(JSGlobalObject, m_varReadOnlyWatchpoint)), scratchGPR);
     141        loadPtr(Address(scratchGPR, JSGlobalObject::offsetOfVarReadOnlyWatchpoint()), scratchGPR);
    141142        addSlowCase(branch8(Equal, Address(scratchGPR, WatchpointSet::offsetOfState()), TrustedImm32(IsInvalidated)));
    142143    }
  • trunk/Source/JavaScriptCore/jit/JIT.h

    r290768 r292083  
    4848#include "LLIntData.h"
    4949#include "PCToCodeOriginMap.h"
    50 #include "UnusedPointer.h"
    5150#include <wtf/UniqueRef.h>
    5251
     
    170169        using MacroAssembler::Label;
    171170
    172         static constexpr uintptr_t patchGetByIdDefaultStructure = unusedPointer;
    173         static constexpr int patchGetByIdDefaultOffset = 0;
    174         // Magic number - initial offset cannot be representable as a signed 8bit value, or the X86Assembler
    175         // will compress the displacement, and we may not be able to fit a patched offset.
    176         static constexpr int patchPutByIdDefaultOffset = 256;
    177 
    178171        using Base = JSInterfaceJIT;
    179172
    180173    public:
    181         JIT(VM&, CodeBlock* = nullptr, BytecodeIndex loopOSREntryBytecodeOffset = BytecodeIndex(0));
     174        JIT(VM&, CodeBlock*, BytecodeIndex loopOSREntryBytecodeOffset);
    182175        ~JIT();
    183176
     
    190183        void doMainThreadPreparationBeforeCompile();
    191184       
    192         static CompilationResult compile(VM& vm, CodeBlock* codeBlock, JITCompilationEffort effort, BytecodeIndex bytecodeOffset = BytecodeIndex(0))
    193         {
    194             return JIT(vm, codeBlock, bytecodeOffset).privateCompile(codeBlock, effort);
     185        static CompilationResult compile(VM& vm, CodeBlock* codeBlock, JITCompilationEffort effort)
     186        {
     187            return JIT(vm, codeBlock, BytecodeIndex(0)).privateCompile(codeBlock, effort);
    195188        }
    196189
     
    205198        static constexpr GPRReg s_metadataGPR = LLInt::Registers::metadataTableGPR;
    206199        static constexpr GPRReg s_constantsGPR = LLInt::Registers::pbGPR;
     200        static constexpr JITConstantPool::Constant s_globalObjectConstant { 0 };
    207201
    208202    private:
     
    257251    private:
    258252        void loadGlobalObject(GPRReg);
     253
     254        // Assuming s_constantsGPR is available.
     255        static void loadGlobalObject(CCallHelpers&, GPRReg);
     256        static void loadConstant(CCallHelpers&, unsigned constantIndex, GPRReg);
     257
    259258        void loadCodeBlockConstant(VirtualRegister, JSValueRegs);
    260259        void loadCodeBlockConstantPayload(VirtualRegister, RegisterID);
     
    963962
    964963        Vector<JITConstantPool::Value> m_constantPool;
    965         JITConstantPool::Constant m_globalObjectConstant { std::numeric_limits<unsigned>::max() };
    966964        SegmentedVector<UnlinkedCallLinkInfo> m_unlinkedCalls;
    967965        SegmentedVector<UnlinkedStructureStubInfo> m_unlinkedStubInfos;
  • trunk/Source/JavaScriptCore/jit/JITInlines.h

    r290768 r292083  
    494494}
    495495
     496ALWAYS_INLINE void JIT::loadConstant(CCallHelpers& jit, JITConstantPool::Constant constantIndex, GPRReg result)
     497{
     498    jit.loadPtr(Address(s_constantsGPR, BaselineJITData::offsetOfData() + static_cast<uintptr_t>(constantIndex) * sizeof(void*)), result);
     499}
     500
     501ALWAYS_INLINE void JIT::loadGlobalObject(CCallHelpers& jit, GPRReg result)
     502{
     503    loadConstant(jit, s_globalObjectConstant, result);
     504}
     505
    496506ALWAYS_INLINE void JIT::loadConstant(JITConstantPool::Constant constantIndex, GPRReg result)
    497507{
    498     loadPtr(Address(s_constantsGPR, BaselineJITData::offsetOfData() + static_cast<uintptr_t>(constantIndex) * sizeof(void*)), result);
     508    loadConstant(*this, constantIndex, result);
    499509}
    500510
    501511ALWAYS_INLINE void JIT::loadGlobalObject(GPRReg result)
    502512{
    503     loadConstant(m_globalObjectConstant, result);
     513    loadGlobalObject(*this, result);
    504514}
    505515
  • trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp

    r292080 r292083  
    135135    move(TrustedImm32(1), regT0);
    136136    loadGlobalObject(regT1);
    137     Jump customHasInstanceValue = branchPtr(NotEqual, regT2, Address(regT1, OBJECT_OFFSETOF(JSGlobalObject, m_functionProtoHasInstanceSymbolFunction)));
     137    Jump customHasInstanceValue = branchPtr(NotEqual, regT2, Address(regT1, JSGlobalObject::offsetOfFunctionProtoHasInstanceSymbolFunction()));
    138138    // We know that constructor is an object from the way bytecode is emitted for instanceof expressions.
    139139    emitGetVirtualRegisterPayload(constructor, regT2);
     
    471471    jit.tagReturnAddress();
    472472
    473     jit.loadPtr(addressFor(CallFrameSlot::codeBlock), globalObjectGPR);
    474     jit.loadPtr(Address(globalObjectGPR, CodeBlock::offsetOfGlobalObject()), globalObjectGPR);
     473    loadGlobalObject(jit, globalObjectGPR);
    475474    jit.move(TrustedImm32(1), regT0);
    476475    auto isFalsey = jit.branchIfFalsey(vm, valueJSR, scratch1GPR, scratch2GPR, fpRegT0, fpRegT1, shouldCheckMasqueradesAsUndefined, globalObjectGPR);
     
    658657    jit.tagReturnAddress();
    659658
    660     jit.loadPtr(addressFor(CallFrameSlot::codeBlock), globalObjectGPR);
    661     jit.loadPtr(Address(globalObjectGPR, CodeBlock::offsetOfGlobalObject()), globalObjectGPR);
     659    loadGlobalObject(jit, globalObjectGPR);
    662660    jit.move(TrustedImm32(1), regT0);
    663661    auto isTruthy = jit.branchIfTruthy(vm, valueJSR, scratch1GPR, scratch2GPR, fpRegT0, fpRegT1, shouldCheckMasqueradesAsUndefined, globalObjectGPR);
     
    729727    jit.store32(bytecodeOffsetGPR, tagFor(CallFrameSlot::argumentCountIncludingThis));
    730728    jit.prepareCallOperation(vm);
    731     jit.loadPtr(addressFor(CallFrameSlot::codeBlock), globalObjectGPR);
    732     jit.loadPtr(Address(globalObjectGPR, CodeBlock::offsetOfGlobalObject()), globalObjectGPR);
     729    loadGlobalObject(jit, globalObjectGPR);
    733730    jit.setupArguments<decltype(operationThrow)>(globalObjectGPR, thrownValueJSR);
    734731    Call operation = jit.call(OperationPtrTag);
     
    15591556    jit.store32(bytecodeOffsetGPR, tagFor(CallFrameSlot::argumentCountIncludingThis));
    15601557    jit.prepareCallOperation(vm);
    1561     jit.loadPtr(addressFor(CallFrameSlot::codeBlock), globalObjectGPR);
    1562     jit.loadPtr(Address(globalObjectGPR, CodeBlock::offsetOfGlobalObject()), globalObjectGPR);
     1558    loadGlobalObject(jit, globalObjectGPR);
    15631559    jit.setupArguments<decltype(operationHandleTraps)>(globalObjectGPR);
    15641560    CCallHelpers::Call operation = jit.call(OperationPtrTag);
  • trunk/Source/JavaScriptCore/jit/JITPropertyAccess.cpp

    r292080 r292083  
    150150    jit.store32(bytecodeOffsetGPR, tagFor(CallFrameSlot::argumentCountIncludingThis));
    151151    jit.prepareCallOperation(vm);
    152     jit.loadPtr(addressFor(CallFrameSlot::codeBlock), globalObjectGPR);
    153     jit.loadPtr(Address(globalObjectGPR, CodeBlock::offsetOfGlobalObject()), globalObjectGPR);
     152    loadGlobalObject(jit, globalObjectGPR);
    154153    jit.setupArguments<SlowOperation>(globalObjectGPR, stubInfoGPR, profileGPR, baseJSR, propertyJSR);
    155154    static_assert(preferredArgumentGPR<SlowOperation, 1>() == argumentGPR1, "Needed for branch to slow operation via StubInfo");
     
    245244    jit.store32(bytecodeOffsetGPR, tagFor(CallFrameSlot::argumentCountIncludingThis));
    246245    jit.prepareCallOperation(vm);
    247     jit.loadPtr(addressFor(CallFrameSlot::codeBlock), globalObjectGPR);
    248     jit.loadPtr(Address(globalObjectGPR, CodeBlock::offsetOfGlobalObject()), globalObjectGPR);
     246    loadGlobalObject(jit, globalObjectGPR);
    249247    jit.setupArguments<SlowOperation>(globalObjectGPR, stubInfoGPR, baseJSR, propertyJSR);
    250248    static_assert(preferredArgumentGPR<SlowOperation, 1>() == argumentGPR1, "Needed for branch to slow operation via StubInfo");
     
    468466    jit.store32(bytecodeOffsetGPR, tagFor(CallFrameSlot::argumentCountIncludingThis));
    469467    jit.prepareCallOperation(vm);
    470     jit.loadPtr(addressFor(CallFrameSlot::codeBlock), globalObjectGPR);
    471     jit.loadPtr(Address(globalObjectGPR, CodeBlock::offsetOfGlobalObject()), globalObjectGPR);
     468    loadGlobalObject(jit, globalObjectGPR);
    472469    jit.setupArgumentsForIndirectCall<SlowOperatoin>(stubInfoGPR,
    473470        globalObjectGPR, baseJSR, propertyJSR, valueJSR, stubInfoGPR, profileGPR);
     
    566563    jit.store32(bytecodeOffsetGPR, tagFor(CallFrameSlot::argumentCountIncludingThis));
    567564    jit.prepareCallOperation(vm);
    568     jit.loadPtr(addressFor(CallFrameSlot::codeBlock), globalObjectGPR);
    569     jit.loadPtr(Address(globalObjectGPR, CodeBlock::offsetOfGlobalObject()), globalObjectGPR);
     565    loadGlobalObject(jit, globalObjectGPR);
    570566    // Loading nullptr to this register is necessary for setupArgumentsForIndirectCall
    571567    // to not clobber globalObjectGPR on ARM_THUMB2, and is otherwise harmless.
     
    746742    jit.store32(bytecodeOffsetGPR, tagFor(CallFrameSlot::argumentCountIncludingThis));
    747743    jit.prepareCallOperation(vm);
    748     jit.loadPtr(addressFor(CallFrameSlot::codeBlock), globalObjectGPR);
    749     jit.loadPtr(Address(globalObjectGPR, CodeBlock::offsetOfGlobalObject()), globalObjectGPR);
     744    loadGlobalObject(jit, globalObjectGPR);
    750745    jit.setupArguments<SlowOperation>(globalObjectGPR, stubInfoGPR, baseJSR, propertyGPR, ecmaModeGPR);
    751746    static_assert(preferredArgumentGPR<SlowOperation, 1>() == argumentGPR1, "Needed for branch to slow operation via StubInfo");
     
    858853    jit.store32(bytecodeOffsetGPR, tagFor(CallFrameSlot::argumentCountIncludingThis));
    859854    jit.prepareCallOperation(vm);
    860     jit.loadPtr(addressFor(CallFrameSlot::codeBlock), globalObjectGPR);
    861     jit.loadPtr(Address(globalObjectGPR, CodeBlock::offsetOfGlobalObject()), globalObjectGPR);
     855    loadGlobalObject(jit, globalObjectGPR);
    862856    jit.setupArguments<SlowOperation>(globalObjectGPR, stubInfoGPR, baseJSR, propertyJSR, ecmaModeGPR);
    863857    static_assert(preferredArgumentGPR<SlowOperation, 1>() == argumentGPR1, "Needed for branch to slow operation via StubInfo");
     
    10851079    jit.store32(bytecodeOffsetGPR, tagFor(CallFrameSlot::argumentCountIncludingThis));
    10861080    jit.prepareCallOperation(vm);
    1087     jit.loadPtr(addressFor(CallFrameSlot::codeBlock), globalObjectGPR);
    1088     jit.loadPtr(Address(globalObjectGPR, CodeBlock::offsetOfGlobalObject()), globalObjectGPR);
     1081    loadGlobalObject(jit, globalObjectGPR);
    10891082    jit.setupArguments<SlowOperation>(globalObjectGPR, stubInfoGPR, baseJSR, propertyGPR);
    10901083    static_assert(preferredArgumentGPR<SlowOperation, 1>() == argumentGPR1, "Needed for branch to slow operation via StubInfo");
     
    11861179    jit.store32(bytecodeOffsetGPR, tagFor(CallFrameSlot::argumentCountIncludingThis));
    11871180    jit.prepareCallOperation(vm);
    1188     jit.loadPtr(addressFor(CallFrameSlot::codeBlock), globalObjectGPR);
    1189     jit.loadPtr(Address(globalObjectGPR, CodeBlock::offsetOfGlobalObject()), globalObjectGPR);
     1181    loadGlobalObject(jit, globalObjectGPR);
    11901182    jit.setupArguments<SlowOperation>(globalObjectGPR, stubInfoGPR, baseJSR, thisJSR, propertyGPR);
    11911183    static_assert(preferredArgumentGPR<SlowOperation, 1>() == argumentGPR1, "Needed for branch to slow operation via StubInfo");
     
    12951287    jit.store32(bytecodeOffsetGPR, tagFor(CallFrameSlot::argumentCountIncludingThis));
    12961288    jit.prepareCallOperation(vm);
    1297     jit.loadPtr(addressFor(CallFrameSlot::codeBlock), globalObjectGPR);
    1298     jit.loadPtr(Address(globalObjectGPR, CodeBlock::offsetOfGlobalObject()), globalObjectGPR);
     1289    loadGlobalObject(jit, globalObjectGPR);
    12991290    jit.setupArguments<SlowOperation>(globalObjectGPR, stubInfoGPR, valueJSR, baseJSR, propertyGPR);
    13001291    static_assert(preferredArgumentGPR<SlowOperation, 1>() == argumentGPR1, "Needed for branch to slow operation via StubInfo");
     
    15931584        if (globalObjectGPR == InvalidGPRReg) {
    15941585            globalObjectGPR = scratchGPR;
    1595             jit.loadPtr(addressFor(CallFrameSlot::codeBlock), scratchGPR);
    1596             jit.loadPtr(Address(scratchGPR, CodeBlock::offsetOfGlobalObject()), globalObjectGPR);
     1586            loadGlobalObject(jit, globalObjectGPR);
    15971587        }
    1598         jit.loadPtr(Address(globalObjectGPR, OBJECT_OFFSETOF(JSGlobalObject, m_varInjectionWatchpoint)), scratchGPR);
     1588        jit.loadPtr(Address(globalObjectGPR, JSGlobalObject::offsetOfVarInjectionWatchpoint()), scratchGPR);
    15991589        slowCase.append(jit.branch8(Equal, Address(scratchGPR, WatchpointSet::offsetOfState()), TrustedImm32(IsInvalidated)));
    16001590    };
     
    16181608        case GlobalPropertyWithVarInjectionChecks: {
    16191609            // JSScope::constantScopeForCodeBlock() loads codeBlock->globalObject().
    1620             jit.loadPtr(addressFor(CallFrameSlot::codeBlock), scratchGPR);
    1621             jit.loadPtr(Address(scratchGPR, CodeBlock::offsetOfGlobalObject()), returnValueGPR);
     1610            loadGlobalObject(jit, returnValueGPR);
    16221611            doVarInjectionCheck(needsVarInjectionChecks(resolveType), returnValueGPR);
    16231612            jit.load32(Address(metadataGPR, Metadata::offsetOfGlobalLexicalBindingEpoch()), scratchGPR);
     
    16321621            // JSScope::constantScopeForCodeBlock() loads codeBlock->globalObject() for GlobalVar*,
    16331622            // and codeBlock->globalObject()->globalLexicalEnvironment() for GlobalLexicalVar*.
    1634             jit.loadPtr(addressFor(CallFrameSlot::codeBlock), scratchGPR);
    1635             jit.loadPtr(Address(scratchGPR, CodeBlock::offsetOfGlobalObject()), returnValueGPR);
     1623            loadGlobalObject(jit, returnValueGPR);
    16361624            doVarInjectionCheck(needsVarInjectionChecks(resolveType), returnValueGPR);
    16371625            if (resolveType == GlobalLexicalVar || resolveType == GlobalLexicalVarWithVarInjectionChecks)
     
    18101798        if (!needsVarInjectionChecks)
    18111799            return;
    1812         jit.loadPtr(addressFor(CallFrameSlot::codeBlock), scratchGPR);
    1813         jit.loadPtr(Address(scratchGPR, CodeBlock::offsetOfGlobalObject()), scratchGPR);
    1814         jit.loadPtr(Address(scratchGPR, OBJECT_OFFSETOF(JSGlobalObject, m_varInjectionWatchpoint)), scratchGPR);
     1800        loadGlobalObject(jit, scratchGPR);
     1801        jit.loadPtr(Address(scratchGPR, JSGlobalObject::offsetOfVarInjectionWatchpoint()), scratchGPR);
    18151802        slowCase.append(jit.branch8(Equal, Address(scratchGPR, WatchpointSet::offsetOfState()), TrustedImm32(IsInvalidated)));
    18161803    };
     
    18271814
    18281815            jit.jitAssert(scopedLambda<Jump(void)>([&] () -> Jump {
    1829                 jit.loadPtr(addressFor(CallFrameSlot::codeBlock), scratchGPR);
    1830                 jit.loadPtr(Address(scratchGPR, CodeBlock::offsetOfGlobalObject()), scratchGPR);
     1816                loadGlobalObject(jit, scratchGPR);
    18311817                return jit.branchPtr(Equal, scopeGPR, scratchGPR);
    18321818            }));
     
    25702556
    25712557    loadGlobalObject(scratchGPR);
    2572     loadPtr(Address(scratchGPR, OBJECT_OFFSETOF(JSGlobalObject, m_varInjectionWatchpoint)), scratchGPR);
     2558    loadPtr(Address(scratchGPR, JSGlobalObject::offsetOfVarInjectionWatchpoint()), scratchGPR);
    25732559    addSlowCase(branch8(Equal, Address(scratchGPR, WatchpointSet::offsetOfState()), TrustedImm32(IsInvalidated)));
    25742560}
  • trunk/Source/JavaScriptCore/runtime/JSGlobalObject.h

    r291756 r292083  
    925925    static ptrdiff_t offsetOfGlobalLexicalEnvironment() { return OBJECT_OFFSETOF(JSGlobalObject, m_globalLexicalEnvironment); }
    926926    static ptrdiff_t offsetOfGlobalLexicalBindingEpoch() { return OBJECT_OFFSETOF(JSGlobalObject, m_globalLexicalBindingEpoch); }
     927    static ptrdiff_t offsetOfVarInjectionWatchpoint() { return OBJECT_OFFSETOF(JSGlobalObject, m_varInjectionWatchpoint); }
     928    static ptrdiff_t offsetOfVarReadOnlyWatchpoint() { return OBJECT_OFFSETOF(JSGlobalObject, m_varReadOnlyWatchpoint); }
     929    static ptrdiff_t offsetOfFunctionProtoHasInstanceSymbolFunction() { return OBJECT_OFFSETOF(JSGlobalObject, m_functionProtoHasInstanceSymbolFunction); }
    927930
    928931#if ENABLE(REMOTE_INSPECTOR)
Note: See TracChangeset for help on using the changeset viewer.