⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 283389 in webkit


Ignore:
Timestamp:
Oct 1, 2021, 12:06:05 PM (5 years ago)
Author:
commit-queue@webkit.org
Message:

[JSC][32bit] Fix build after unlinked baseline JIT
​https://bugs.webkit.org/show_bug.cgi?id=230803

Patch by Xan López <Xan Lopez> on 2021-10-01
Reviewed by Saam Barati.

This is enough to make things build, but pretty much nothing works
yet. Will fix in a follow-up, this way we at least give people a
chance at not introducing more build regressions.

(With some code by Mikhail R. Gadelha and Geza Lore)

  • CMakeLists.txt:
  • assembler/MacroAssemblerARMv7.h:

(JSC::MacroAssemblerARMv7::branch32):
(JSC::MacroAssemblerARMv7::branchAdd32):

  • assembler/MacroAssemblerMIPS.h:

(JSC::MacroAssemblerMIPS::branchAdd32):

  • bytecode/CallLinkInfo.h:

(JSC::CallLinkInfo::addressOfMaxArgumentCountIncludingThis):

  • jit/JIT.h:
  • jit/JITCall32_64.cpp:

(JSC::JIT::compileOpCall):

  • jit/JITInlines.h:

(JSC::JIT::emitValueProfilingSite):
(JSC::JIT::emitValueProfilingSiteIfProfiledOpcode):
(JSC::JIT::emitArrayProfilingSiteWithCell):

  • jit/JITOpcodes.cpp:

(JSC::JIT::emit_op_loop_hint):

  • jit/JITPropertyAccess.cpp:

(JSC::JIT::emitVarInjectionCheck):

  • jit/JITPropertyAccess32_64.cpp:

(JSC::JIT::emitHasPrivateSlow):
(JSC::JIT::emitSlow_op_has_private_name):
(JSC::JIT::emitSlow_op_has_private_brand):
(JSC::JIT::emitResolveClosure):
(JSC::JIT::emit_op_resolve_scope):
(JSC::JIT::emit_op_get_from_scope):
(JSC::JIT::emitPutGlobalVariableIndirect):
(JSC::JIT::emit_op_put_to_scope):
(JSC::JIT::emitSlow_op_put_to_scope):
(JSC::JIT::emitVarInjectionCheck): Deleted.

  • llint/LowLevelInterpreter.asm:
  • llint/LowLevelInterpreter32_64.asm:
Location:
trunk/Source/JavaScriptCore
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/CMakeLists.txt

    r283139 r283389  
    840840    jit/AssemblyHelpersSpoolers.h
    841841    jit/BaselineJITCode.h
     842    jit/CallFrameShuffleData.h
    842843    jit/CCallHelpers.h
    843844    jit/ExecutableAllocator.h
    … …  
    860861    jit/RegisterAtOffset.h
    861862    jit/RegisterAtOffsetList.h
     863    jit/RegisterMap.h
    862864    jit/RegisterSet.h
    863865    jit/Snippet.h

  • trunk/Source/JavaScriptCore/ChangeLog

    r283387 r283389  
     12021-10-01  Xan López  <xan@igalia.com>
     2
     3        [JSC][32bit] Fix build after unlinked baseline JIT
     4        https://bugs.webkit.org/show_bug.cgi?id=230803
     5
     6        Reviewed by Saam Barati.
     7
     8        This is enough to make things build, but pretty much nothing works
     9        yet. Will fix in a follow-up, this way we at least give people a
     10        chance at not introducing more build regressions.
     11
     12        (With some code by Mikhail R. Gadelha and Geza Lore)
     13
     14        * CMakeLists.txt:
     15        * assembler/MacroAssemblerARMv7.h:
     16        (JSC::MacroAssemblerARMv7::branch32):
     17        (JSC::MacroAssemblerARMv7::branchAdd32):
     18        * assembler/MacroAssemblerMIPS.h:
     19        (JSC::MacroAssemblerMIPS::branchAdd32):
     20        * bytecode/CallLinkInfo.h:
     21        (JSC::CallLinkInfo::addressOfMaxArgumentCountIncludingThis):
     22        * jit/JIT.h:
     23        * jit/JITCall32_64.cpp:
     24        (JSC::JIT::compileOpCall):
     25        * jit/JITInlines.h:
     26        (JSC::JIT::emitValueProfilingSite):
     27        (JSC::JIT::emitValueProfilingSiteIfProfiledOpcode):
     28        (JSC::JIT::emitArrayProfilingSiteWithCell):
     29        * jit/JITOpcodes.cpp:
     30        (JSC::JIT::emit_op_loop_hint):
     31        * jit/JITPropertyAccess.cpp:
     32        (JSC::JIT::emitVarInjectionCheck):
     33        * jit/JITPropertyAccess32_64.cpp:
     34        (JSC::JIT::emitHasPrivateSlow):
     35        (JSC::JIT::emitSlow_op_has_private_name):
     36        (JSC::JIT::emitSlow_op_has_private_brand):
     37        (JSC::JIT::emitResolveClosure):
     38        (JSC::JIT::emit_op_resolve_scope):
     39        (JSC::JIT::emit_op_get_from_scope):
     40        (JSC::JIT::emitPutGlobalVariableIndirect):
     41        (JSC::JIT::emit_op_put_to_scope):
     42        (JSC::JIT::emitSlow_op_put_to_scope):
     43        (JSC::JIT::emitVarInjectionCheck): Deleted.
     44        * llint/LowLevelInterpreter.asm:
     45        * llint/LowLevelInterpreter32_64.asm:
     46
    1472021-10-01  Yusuke Suzuki  <ysuzuki@apple.com>
    248

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h

    r281355 r283389  
    16111611    Jump branch32(RelationalCondition cond, RegisterID left, RegisterID right)
    16121612    {
    1613         m_assembler.cmp(left, right);
     1613        if (left == ARMRegisters::sp) {
     1614            move(left, dataTempRegister);
     1615            m_assembler.cmp(dataTempRegister, right);
     1616        } else if (right == ARMRegisters::sp) {
     1617            move(right, dataTempRegister);
     1618            m_assembler.cmp(left, dataTempRegister);
     1619        } else
     1620            m_assembler.cmp(left, right);
    16141621        return Jump(makeBranch(cond));
    16151622    }
    … …  
    18411848    Jump branchAdd32(ResultCondition cond, TrustedImm32 imm, AbsoluteAddress dest)
    18421849    {
    1843         // Move the high bits of the address into addressTempRegister,
    1844         // and load the value into dataTempRegister.
    1845         move(TrustedImmPtr(dest.m_ptr), addressTempRegister);
    1846         m_assembler.ldr(dataTempRegister, addressTempRegister, ARMThumbImmediate::makeUInt16(0));
    1847 
    1848         // Do the add.
    1849         ARMThumbImmediate armImm = ARMThumbImmediate::makeEncodedImm(imm.m_value);
    1850         if (armImm.isValid())
    1851             m_assembler.add_S(dataTempRegister, dataTempRegister, armImm);
    1852         else {
    1853             // If the operand does not fit into an immediate then load it temporarily
    1854             // into addressTempRegister; since we're overwriting addressTempRegister
    1855             // we'll need to reload it with the high bits of the address afterwards.
    1856             move(imm, addressTempRegister);
    1857             m_assembler.add_S(dataTempRegister, dataTempRegister, addressTempRegister);
    1858             move(TrustedImmPtr(dest.m_ptr), addressTempRegister);
    1859         }
    1860 
    1861         // Store the result.
    1862         m_assembler.str(dataTempRegister, addressTempRegister, ARMThumbImmediate::makeUInt16(0));
    1863 
     1850        add32(imm, dest);
     1851        return Jump(makeBranch(cond));
     1852    }
     1853
     1854    Jump branchAdd32(ResultCondition cond, TrustedImm32 imm, Address dest)
     1855    {
     1856        add32(imm, dest);
    18641857        return Jump(makeBranch(cond));
    18651858    }

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h

    r281618 r283389  
    23552355    }
    23562356
     2357    Jump branchAdd32(ResultCondition cond, TrustedImm32 imm, Address dest)
     2358    {
     2359        ASSERT((cond == Overflow) || (cond == Signed) || (cond == PositiveOrZero) || (cond == Zero) || (cond == NonZero));
     2360        if (cond == Overflow) {
     2361            if (m_fixedWidth) {
     2362                /*
     2363                  load    dest, dataTemp
     2364                  move    imm, immTemp
     2365                  xor     cmpTemp, dataTemp, immTemp
     2366                  addu    dataTemp, dataTemp, immTemp
     2367                  store   dataTemp, dest
     2368                  bltz    cmpTemp, No_overflow    # diff sign bit -> no overflow
     2369                  xor     cmpTemp, dataTemp, immTemp
     2370                  bgez    cmpTemp, No_overflow    # same sign big -> no overflow
     2371                  nop
     2372                  b       Overflow
     2373                  nop
     2374                  b       No_overflow
     2375                  nop
     2376                  nop
     2377                  nop
     2378                  No_overflow:
     2379                */
     2380                load32(dest, dataTempRegister);
     2381                move(imm, immTempRegister);
     2382                m_assembler.xorInsn(cmpTempRegister, dataTempRegister, immTempRegister);
     2383                m_assembler.addu(dataTempRegister, dataTempRegister, immTempRegister);
     2384                store32(dataTempRegister, dest);
     2385                m_assembler.bltz(cmpTempRegister, 9);
     2386                m_assembler.xorInsn(cmpTempRegister, dataTempRegister, immTempRegister);
     2387                m_assembler.bgez(cmpTempRegister, 7);
     2388                m_assembler.nop();
     2389            } else {
     2390                m_assembler.lw(dataTempRegister, dest.base, dest.offset);
     2391                if (imm.m_value >= 0 && imm.m_value  <= 32767) {
     2392                    move(dataTempRegister, cmpTempRegister);
     2393                    m_assembler.addiu(dataTempRegister, dataTempRegister, imm.m_value);
     2394                    m_assembler.bltz(cmpTempRegister, 9);
     2395                    m_assembler.sw(dataTempRegister, dest.base, dest.offset);
     2396                    m_assembler.bgez(dataTempRegister, 7);
     2397                    m_assembler.nop();
     2398                } else if (imm.m_value >= -32768 && imm.m_value < 0) {
     2399                    move(dataTempRegister, cmpTempRegister);
     2400                    m_assembler.addiu(dataTempRegister, dataTempRegister, imm.m_value);
     2401                    m_assembler.bgez(cmpTempRegister, 9);
     2402                    m_assembler.sw(dataTempRegister, dest.base, dest.offset);
     2403                    m_assembler.bltz(cmpTempRegister, 7);
     2404                    m_assembler.nop();
     2405                } else {
     2406                    move(imm, immTempRegister);
     2407                    m_assembler.xorInsn(cmpTempRegister, dataTempRegister, immTempRegister);
     2408                    m_assembler.addu(dataTempRegister, dataTempRegister, immTempRegister);
     2409                    m_assembler.bltz(cmpTempRegister, 10);
     2410                    m_assembler.sw(dataTempRegister, dest.base, dest.offset);
     2411                    m_assembler.xorInsn(cmpTempRegister, dataTempRegister, immTempRegister);
     2412                    m_assembler.bgez(cmpTempRegister, 7);
     2413                    m_assembler.nop();
     2414                }
     2415            }
     2416            return jump();
     2417        }
     2418        if (m_fixedWidth) {
     2419            move(imm, immTempRegister);
     2420            load32(dest, dataTempRegister);
     2421            add32(immTempRegister, dataTempRegister);
     2422            store32(dataTempRegister, dest);
     2423        } else {
     2424            m_assembler.lw(dataTempRegister, dest.base, dest.offset);
     2425            add32(imm, dataTempRegister);
     2426            m_assembler.sw(dataTempRegister, dest.base, dest.offset);
     2427        }
     2428        if (cond == Signed) {
     2429            // Check if dest is negative.
     2430            m_assembler.slt(cmpTempRegister, dataTempRegister, MIPSRegisters::zero);
     2431            return branchNotEqual(cmpTempRegister, MIPSRegisters::zero);
     2432        }
     2433        if (cond == PositiveOrZero) {
     2434            // Check if dest is not negative.
     2435            m_assembler.slt(cmpTempRegister, dataTempRegister, MIPSRegisters::zero);
     2436            return branchEqual(cmpTempRegister, MIPSRegisters::zero);
     2437        }
     2438        if (cond == Zero)
     2439            return branchEqual(dataTempRegister, MIPSRegisters::zero);
     2440        if (cond == NonZero)
     2441            return branchNotEqual(dataTempRegister, MIPSRegisters::zero);
     2442        ASSERT(0);
     2443        return Jump();
     2444    }
     2445
    23572446    Jump branchMul32(ResultCondition cond, RegisterID src1, RegisterID src2, RegisterID dest)
    23582447    {

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

    r283139 r283389  
    2626#pragma once
    2727
     28#include "CallFrameShuffleData.h"
    2829#include "CallMode.h"
    2930#include "CodeLocation.h"
    … …  
    4243class JSFunction;
    4344enum OpcodeID : unsigned;
    44 struct CallFrameShuffleData;
    4545
    4646struct UnlinkedCallLinkInfo;
    … …  
    314314        return OBJECT_OFFSETOF(CallLinkInfo, m_maxArgumentCountIncludingThis);
    315315    }
     316
     317#if USE(JSVALUE32_64)
     318    uint32_t* addressOfMaxArgumentCountIncludingThis()
     319    {
     320        return &m_maxArgumentCountIncludingThis;
     321    }
     322#endif
    316323
    317324    uint32_t maxArgumentCountIncludingThis()

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

    r283229 r283389  
    346346        // This assumes that the value to profile is in regT0 and that regT3 is available for
    347347        // scratch.
    348 #if USE(JSVALUE64)
    349348        template<typename Bytecode> void emitValueProfilingSite(const Bytecode&, GPRReg);
    350349        template<typename Bytecode> void emitValueProfilingSite(const Bytecode&, JSValueRegs);
    351 #else
     350#if USE(JSVALUE32_64)
    352351        void emitValueProfilingSite(ValueProfile&, JSValueRegs);
    353         template<typename Metadata> void emitValueProfilingSite(Metadata&, JSValueRegs);
     352        template<typename Metadata>
     353        std::enable_if_t<std::is_same<decltype(Metadata::m_profile), ValueProfile>::value, void>
     354        emitValueProfilingSite(Metadata&, JSValueRegs);
    354355#endif
    355356
    … …  
    363364        template <typename Bytecode>
    364365        void emitArrayProfilingSiteWithCell(const Bytecode&, ptrdiff_t, RegisterID cellGPR, RegisterID scratchGPR);
     366
     367#if USE(JSVALUE32_64)
     368        void emitArrayProfilingSiteWithCell(RegisterID, ArrayProfile* , RegisterID);
     369        void emitArrayProfilingSiteWithCell(RegisterID, RegisterID , RegisterID);
     370#endif
    365371
    366372        template<typename Op>

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

    r283139 r283389  
    311311    checkStackPointerAlignment();
    312312    if (opcodeID == op_tail_call || opcodeID == op_tail_call_varargs || opcodeID == op_tail_call_forward_arguments) {
    313         auto slowPaths = info->emitTailCallFastPath(*this, regT0, regT2, CallLinkInfo::UseDataIC::Yes, [&] {
     313        auto slowPaths = info->emitTailCallDataICFastPath(*this, regT0, regT2, [&] {
    314314            emitRestoreCalleeSaves();
    315315            prepareForTailCallSlow(regT2);

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

    r283139 r283389  
    335335    store32(value.tagGPR(), &descriptor->asBits.tag);
    336336}
     337
     338template<typename Metadata>
     339std::enable_if_t<std::is_same<decltype(Metadata::m_profile), ValueProfile>::value, void> JIT::emitValueProfilingSite(Metadata& metadata, JSValueRegs value)
     340{
     341    emitValueProfilingSite(valueProfileFor(metadata, m_bytecodeIndex.checkpoint()), value);
     342}
    337343#endif
    338344
    … …  
    343349    emitValueProfilingSite(bytecode, regT0);
    344350#else
    345     emitValueProfilingSite(bytecode.metadata(m_codeBlock), JSValueRegs(regT1, regT0));
     351    emitValueProfilingSite(bytecode, JSValueRegs(regT1, regT0));
    346352#endif
    347353}
    … …  
    349355inline void JIT::emitValueProfilingSiteIfProfiledOpcode(...) { }
    350356
    351 #if USE(JSVALUE64)
    352357template<typename Bytecode>
    353358inline void JIT::emitValueProfilingSite(const Bytecode& bytecode, JSValueRegs value)
    … …  
    356361        return;
    357362
     363#if USE(JSVALUE64)
    358364    ptrdiff_t offset = m_unlinkedCodeBlock->metadata().offsetInMetadataTable(bytecode) + valueProfileOffsetFor<Bytecode>(m_bytecodeIndex.checkpoint()) + ValueProfile::offsetOfFirstBucket();
    359365    store64(value.gpr(), Address(s_metadataGPR, offset));
     366#else
     367    UNUSED_PARAM(value);
     368    UNUSED_PARAM(bytecode);
     369    // FIXME.
     370#endif
    360371}
    361372
    … …  
    365376    emitValueProfilingSite(bytecode, JSValueRegs(resultReg));
    366377}
    367 #endif
    368378
    369379template <typename Bytecode>
    … …  
    381391    emitArrayProfilingSiteWithCell(bytecode, Bytecode::Metadata::offsetOfArrayProfile() + ArrayProfile::offsetOfLastSeenStructureID(), cellGPR, scratchGPR);
    382392}
     393
     394#if USE(JSVALUE32_64)
     395inline void JIT::emitArrayProfilingSiteWithCell(RegisterID cellGPR, ArrayProfile* arrayProfile, RegisterID scratchGPR)
     396{
     397    if (shouldEmitProfiling()) {
     398        load32(MacroAssembler::Address(cellGPR, JSCell::structureIDOffset()), scratchGPR);
     399        store32(scratchGPR, arrayProfile->addressOfLastSeenStructureID());
     400    }
     401}
     402
     403inline void JIT::emitArrayProfilingSiteWithCell(RegisterID cellGPR, RegisterID arrayProfileGPR, RegisterID scratchGPR)
     404{
     405    if (shouldEmitProfiling()) {
     406        load32(MacroAssembler::Address(cellGPR, JSCell::structureIDOffset()), scratchGPR);
     407        store32(scratchGPR, Address(arrayProfileGPR, ArrayProfile::offsetOfLastSeenStructureID()));
     408    }
     409}
     410#endif
    383411
    384412ALWAYS_INLINE int32_t JIT::getOperandConstantInt(VirtualRegister src)

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

    r283229 r283389  
    14671467#if USE(JSVALUE64)
    14681468        JSValueRegs resultRegs(GPRInfo::returnValueGPR);
     1469        loadGlobalObject(resultRegs.gpr());
    14691470#else
    14701471        JSValueRegs resultRegs(GPRInfo::returnValueGPR2, GPRInfo::returnValueGPR);
    1471 #endif
    1472         loadGlobalObject(resultRegs.gpr());
     1472        loadGlobalObject(resultRegs.payloadGPR());
     1473        move(TrustedImm32(JSValue::CellTag), resultRegs.tagGPR());
     1474#endif
    14731475        checkStackPointerAlignment();
    14741476        emitRestoreCalleeSaves();

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

    r283229 r283389  
    18201820    auto bytecode = currentInstruction->as<OpHasPrivateBrand>();
    18211821    emitHasPrivateSlow(bytecode.m_dst, bytecode.m_base, bytecode.m_brand, AccessType::HasPrivateBrand);
    1822 }
    1823 
    1824 void JIT::emitVarInjectionCheck(bool needsVarInjectionChecks, GPRReg scratchGPR)
    1825 {
    1826     if (!needsVarInjectionChecks)
    1827         return;
    1828 
    1829     loadGlobalObject(scratchGPR);
    1830     loadPtr(Address(scratchGPR, OBJECT_OFFSETOF(JSGlobalObject, m_varInjectionWatchpoint)), scratchGPR);
    1831     addSlowCase(branch8(Equal, Address(scratchGPR, WatchpointSet::offsetOfState()), TrustedImm32(IsInvalidated)));
    18321822}
    18331823
    … …  
    31923182}
    31933183
     3184void JIT::emitVarInjectionCheck(bool needsVarInjectionChecks, GPRReg scratchGPR)
     3185{
     3186    if (!needsVarInjectionChecks)
     3187        return;
     3188
     3189    loadGlobalObject(scratchGPR);
     3190    loadPtr(Address(scratchGPR, OBJECT_OFFSETOF(JSGlobalObject, m_varInjectionWatchpoint)), scratchGPR);
     3191    addSlowCase(branch8(Equal, Address(scratchGPR, WatchpointSet::offsetOfState()), TrustedImm32(IsInvalidated)));
     3192}
     3193
    31943194} // namespace JSC
    31953195

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

    r283139 r283389  
    847847}
    848848
    849 void JIT::emitHasPrivateSlow(VirtualRegister dst, AccessType type)
    850 {
     849void JIT::emitHasPrivateSlow(VirtualRegister dst, VirtualRegister base, VirtualRegister property, AccessType type)
     850{
     851    // FIXME: 64-bit seems to also ignore base/property.
    851852    ASSERT(type == AccessType::HasPrivateName || type == AccessType::HasPrivateBrand);
     853    UNUSED_PARAM(base);
     854    UNUSED_PARAM(property);
    852855
    853856    JITInByValGenerator& gen = m_inByVals[m_inByValIndex++];
    … …  
    870873
    871874    auto bytecode = currentInstruction->as<OpHasPrivateName>();
    872     emitHasPrivateSlow(bytecode.m_dst, AccessType::HasPrivateName);
     875    emitHasPrivateSlow(bytecode.m_dst, bytecode.m_base, bytecode.m_property, AccessType::HasPrivateName);
    873876}
    874877
    … …  
    884887
    885888    auto bytecode = currentInstruction->as<OpHasPrivateBrand>();
    886     emitHasPrivateSlow(bytecode.m_dst, AccessType::HasPrivateBrand);
    887 }
    888 
    889 void JIT::emitVarInjectionCheck(bool needsVarInjectionChecks)
    890 {
    891     if (!needsVarInjectionChecks)
    892         return;
    893     addSlowCase(branch8(Equal, AbsoluteAddress(m_profiledCodeBlock->globalObject()->varInjectionWatchpoint()->addressOfState()), TrustedImm32(IsInvalidated)));
     889    emitHasPrivateSlow(bytecode.m_dst, bytecode.m_base, bytecode.m_brand, AccessType::HasPrivateBrand);
    894890}
    895891
    896892void JIT::emitResolveClosure(VirtualRegister dst, VirtualRegister scope, bool needsVarInjectionChecks, unsigned depth)
    897893{
    898     emitVarInjectionCheck(needsVarInjectionChecks);
     894    emitVarInjectionCheck(needsVarInjectionChecks, regT0);
    899895    move(TrustedImm32(JSValue::CellTag), regT1);
    900896    emitLoadPayload(scope, regT0);
    … …  
    919915            JSScope* constantScope = JSScope::constantScopeForCodeBlock(resolveType, m_profiledCodeBlock);
    920916            RELEASE_ASSERT(constantScope);
    921             emitVarInjectionCheck(needsVarInjectionChecks(resolveType));
     917            emitVarInjectionCheck(needsVarInjectionChecks(resolveType), regT0);
    922918            load32(&metadata.m_globalLexicalBindingEpoch, regT1);
    923919            addSlowCase(branch32(NotEqual, AbsoluteAddress(m_profiledCodeBlock->globalObject()->addressOfGlobalLexicalBindingEpoch()), regT1));
    … …  
    934930            JSScope* constantScope = JSScope::constantScopeForCodeBlock(resolveType, m_profiledCodeBlock);
    935931            RELEASE_ASSERT(constantScope);
    936             emitVarInjectionCheck(needsVarInjectionChecks(resolveType));
     932            emitVarInjectionCheck(needsVarInjectionChecks(resolveType), regT0);
    937933            move(TrustedImm32(JSValue::CellTag), regT1);
    938934            move(TrustedImmPtr(constantScope), regT0);
    … …  
    10741070        case GlobalLexicalVar:
    10751071        case GlobalLexicalVarWithVarInjectionChecks:
    1076             emitVarInjectionCheck(needsVarInjectionChecks(resolveType));
     1072            emitVarInjectionCheck(needsVarInjectionChecks(resolveType), regT0);
    10771073            if (indirectLoadForOperand)
    10781074                emitGetVarFromIndirectPointer(bitwise_cast<JSValue**>(operandSlot), regT1, regT0);
    … …  
    10841080        case ClosureVar:
    10851081        case ClosureVarWithVarInjectionChecks:
    1086             emitVarInjectionCheck(needsVarInjectionChecks(resolveType));
     1082            emitVarInjectionCheck(needsVarInjectionChecks(resolveType), regT0);
    10871083            emitGetClosureVar(scope, *operandSlot);
    10881084            break;
    … …  
    11731169    emitLoad(value, regT1, regT0);
    11741170    loadPtr(indirectWatchpointSet, regT2);
    1175     emitNotifyWrite(regT2);
     1171    emitNotifyWrite(*indirectWatchpointSet); // FIXME: ??
    11761172    loadPtr(addressOfOperand, regT2);
    11771173    store32(regT1, Address(regT2, TagOffset));
    … …  
    11941190    VirtualRegister scope = bytecode.m_scope;
    11951191    VirtualRegister value = bytecode.m_value;
    1196     GetPutInfo getPutInfo = copiedGetPutInfo(bytecode);
     1192    GetPutInfo getPutInfo = bytecode.metadata(m_profiledCodeBlock).m_getPutInfo;
    11971193    ResolveType resolveType = getPutInfo.resolveType();
    11981194    Structure** structureSlot = metadata.m_structure.slot();
    … …  
    12211217            RELEASE_ASSERT(constantScope);
    12221218            emitWriteBarrier(constantScope, value, ShouldFilterValue);
    1223             emitVarInjectionCheck(needsVarInjectionChecks(resolveType));
    1224             emitVarReadOnlyCheck(resolveType);
     1219            emitVarInjectionCheck(needsVarInjectionChecks(resolveType), regT0);
     1220            emitVarReadOnlyCheck(resolveType, regT0);
    12251221            if (!isInitialization(getPutInfo.initializationMode()) && (resolveType == GlobalLexicalVar || resolveType == GlobalLexicalVarWithVarInjectionChecks)) {
    12261222                // We need to do a TDZ check here because we can't always prove we need to emit TDZ checks statically.
    … …  
    12411237        case ClosureVarWithVarInjectionChecks:
    12421238            emitWriteBarrier(scope, value, ShouldFilterValue);
    1243             emitVarInjectionCheck(needsVarInjectionChecks(resolveType));
     1239            emitVarInjectionCheck(needsVarInjectionChecks(resolveType), regT0);
    12441240            emitPutClosureVar(scope, *operandSlot, value, metadata.m_watchpointSet);
    12451241            break;
    … …  
    13141310
    13151311    auto bytecode = currentInstruction->as<OpPutToScope>();
    1316     ResolveType resolveType = copiedGetPutInfo(bytecode).resolveType();
     1312    ResolveType resolveType = bytecode.metadata(m_profiledCodeBlock).m_getPutInfo.resolveType();
    13171313    if (resolveType == ModuleVar) {
    13181314        JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_throw_strict_mode_readonly_property_write_error);

  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter.asm

    r283288 r283389  
    25052505    end
    25062506else
     2507    macro loadBaselineJITConstantPool()
     2508    end
     2509
    25072510    macro setupReturnToBaselineAfterCheckpointExitIfNeeded()
    25082511    end

  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm

    r283168 r283389  
    500500            btpz r0, .recover
    501501            move r1, sp
     502
     503            loadBaselineJITConstantPool()
     504
    502505            jmp r0
    503506        .recover:
Note: See TracChangeset for help on using the changeset viewer.