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

Changeset 284851 in webkit


Ignore:
Timestamp:
Oct 25, 2021, 5:17:53 PM (5 years ago)
Author:
ysuzuki@apple.com
Message:

[JSC] Don't branch around register allocation in DFG enumerator get by val
​https://bugs.webkit.org/show_bug.cgi?id=232260
rdar://84544469

Reviewed by Robin Morisset.

JSTests:

  • stress/dont-branch-around-regalloc-enumerator-get-by-val-float.js: Added.

(foo):

Source/JavaScriptCore:

  • dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::compileGetByValOnString):
(JSC::DFG::SpeculativeJIT::compileGetByValOnIntTypedArray):
(JSC::DFG::SpeculativeJIT::compileGetByValOnFloatTypedArray):
(JSC::DFG::SpeculativeJIT::compileGetByValForObjectWithString):
(JSC::DFG::SpeculativeJIT::compileGetByValForObjectWithSymbol):
(JSC::DFG::SpeculativeJIT::compileGetByValOnDirectArguments):
(JSC::DFG::SpeculativeJIT::compileGetByValOnScopedArguments):
(JSC::DFG::SpeculativeJIT::compileEnumeratorGetByVal):

  • dfg/DFGSpeculativeJIT.h:
  • dfg/DFGSpeculativeJIT32_64.cpp:

(JSC::DFG::SpeculativeJIT::compileGetByVal):
(JSC::DFG::SpeculativeJIT::compile):

  • dfg/DFGSpeculativeJIT64.cpp:

(JSC::DFG::SpeculativeJIT::compileGetByVal):
(JSC::DFG::SpeculativeJIT::compile):

Location:
trunk
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/JSTests/ChangeLog

    r284757 r284851  
     12021-10-25  Yusuke Suzuki  <ysuzuki@apple.com>
     2
     3        [JSC] Don't branch around register allocation in DFG enumerator get by val
     4        https://bugs.webkit.org/show_bug.cgi?id=232260
     5        rdar://84544469
     6
     7        Reviewed by Robin Morisset.
     8
     9        * stress/dont-branch-around-regalloc-enumerator-get-by-val-float.js: Added.
     10        (foo):
     11
    1122021-10-24  Alexey Shvayka  <ashvayka@apple.com>
    213

  • trunk/Source/JavaScriptCore/ChangeLog

    r284788 r284851  
     12021-10-25  Yusuke Suzuki  <ysuzuki@apple.com>
     2
     3        [JSC] Don't branch around register allocation in DFG enumerator get by val
     4        https://bugs.webkit.org/show_bug.cgi?id=232260
     5        rdar://84544469
     6
     7        Reviewed by Robin Morisset.
     8
     9        * dfg/DFGSpeculativeJIT.cpp:
     10        (JSC::DFG::SpeculativeJIT::compileGetByValOnString):
     11        (JSC::DFG::SpeculativeJIT::compileGetByValOnIntTypedArray):
     12        (JSC::DFG::SpeculativeJIT::compileGetByValOnFloatTypedArray):
     13        (JSC::DFG::SpeculativeJIT::compileGetByValForObjectWithString):
     14        (JSC::DFG::SpeculativeJIT::compileGetByValForObjectWithSymbol):
     15        (JSC::DFG::SpeculativeJIT::compileGetByValOnDirectArguments):
     16        (JSC::DFG::SpeculativeJIT::compileGetByValOnScopedArguments):
     17        (JSC::DFG::SpeculativeJIT::compileEnumeratorGetByVal):
     18        * dfg/DFGSpeculativeJIT.h:
     19        * dfg/DFGSpeculativeJIT32_64.cpp:
     20        (JSC::DFG::SpeculativeJIT::compileGetByVal):
     21        (JSC::DFG::SpeculativeJIT::compile):
     22        * dfg/DFGSpeculativeJIT64.cpp:
     23        (JSC::DFG::SpeculativeJIT::compileGetByVal):
     24        (JSC::DFG::SpeculativeJIT::compile):
     25
    1262021-10-25  Mikhail R. Gadelha  <mikhail@igalia.com>
    227

  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp

    r284700 r284851  
    25942594}
    25952595
    2596 void SpeculativeJIT::compileGetByValOnString(Node* node, const ScopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>& prefix)
     2596void SpeculativeJIT::compileGetByValOnString(Node* node, const ScopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>& prefix)
    25972597{
    25982598    SpeculateCellOperand base(this, m_graph.child(node, 0));
    … …  
    26052605    JSValueRegs resultRegs;
    26062606    DataFormat format;
    2607     std::tie(resultRegs, format) = prefix(node->arrayMode().isOutOfBounds() ? DataFormatJS : DataFormatCell);
     2607    std::tie(resultRegs, format, std::ignore) = prefix(node->arrayMode().isOutOfBounds() ? DataFormatJS : DataFormatCell);
    26082608    GPRReg scratchReg = resultRegs.payloadGPR();
    26092609
    … …  
    33893389}
    33903390
    3391 void SpeculativeJIT::compileGetByValOnIntTypedArray(Node* node, TypedArrayType type, const ScopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>& prefix)
     3391void SpeculativeJIT::compileGetByValOnIntTypedArray(Node* node, TypedArrayType type, const ScopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>& prefix)
    33923392{
    33933393    ASSERT(isInt(type));
    … …  
    34123412    JSValueRegs resultRegs;
    34133413    DataFormat format;
    3414     std::tie(resultRegs, format) = prefix(DataFormatInt32);
     3414    std::tie(resultRegs, format, std::ignore) = prefix(DataFormatInt32);
    34153415    bool shouldBox = format == DataFormatJS;
    34163416
    … …  
    36573657}
    36583658
    3659 void SpeculativeJIT::compileGetByValOnFloatTypedArray(Node* node, TypedArrayType type, const ScopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>& prefix)
     3659void SpeculativeJIT::compileGetByValOnFloatTypedArray(Node* node, TypedArrayType type, const ScopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>& prefix)
    36603660{
    36613661    ASSERT(isFloat(type));
    … …  
    36653665    StorageOperand storage(this, m_graph.varArgChild(node, 2));
    36663666    GPRTemporary scratch(this);
     3667    FPRTemporary result(this);
    36673668
    36683669    GPRReg baseReg = base.gpr();
    … …  
    36703671    GPRReg storageReg = storage.gpr();
    36713672    GPRReg scratchGPR = scratch.gpr();
     3673    FPRReg resultReg = result.fpr();
    36723674
    36733675    JSValueRegs resultRegs;
    36743676    DataFormat format;
    3675     std::tie(resultRegs, format) = prefix(DataFormatDouble);
    3676 
    3677     FPRTemporary result(this);
    3678     FPRReg resultReg = result.fpr();
     3677    std::tie(resultRegs, format, std::ignore) = prefix(DataFormatDouble);
     3678
    36793679    emitTypedArrayBoundsCheck(node, baseReg, propertyReg, scratchGPR);
    36803680    switch (elementSize(type)) {
    … …  
    37383738}
    37393739
    3740 void SpeculativeJIT::compileGetByValForObjectWithString(Node* node, const ScopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>& prefix)
     3740void SpeculativeJIT::compileGetByValForObjectWithString(Node* node, const ScopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>& prefix)
    37413741{
    37423742    SpeculateCellOperand arg1(this, m_graph.varArgChild(node, 0));
    … …  
    37473747
    37483748    JSValueRegs resultRegs;
    3749     std::tie(resultRegs, std::ignore) = prefix(DataFormatJS);
     3749    CanUseFlush canUseFlush = CanUseFlush::Yes;
     3750    std::tie(resultRegs, std::ignore, canUseFlush) = prefix(DataFormatJS);
    37503751
    37513752    speculateObject(m_graph.varArgChild(node, 0), arg1GPR);
    37523753    speculateString(m_graph.varArgChild(node, 1), arg2GPR);
    37533754
    3754     flushRegisters();
     3755    if (canUseFlush == CanUseFlush::No)
     3756        silentSpillAllRegisters(resultRegs);
     3757    else
     3758        flushRegisters();
    37553759    callOperation(operationGetByValObjectString, resultRegs, TrustedImmPtr::weakPointer(m_graph, m_graph.globalObjectFor(node->origin.semantic)), arg1GPR, arg2GPR);
     3760    if (canUseFlush == CanUseFlush::No)
     3761        silentFillAllRegisters();
    37563762    m_jit.exceptionCheck();
    37573763
    … …  
    37593765}
    37603766
    3761 void SpeculativeJIT::compileGetByValForObjectWithSymbol(Node* node, const ScopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>& prefix)
     3767void SpeculativeJIT::compileGetByValForObjectWithSymbol(Node* node, const ScopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>& prefix)
    37623768{
    37633769    SpeculateCellOperand arg1(this, m_graph.varArgChild(node, 0));
    … …  
    37683774
    37693775    JSValueRegs resultRegs;
    3770     std::tie(resultRegs, std::ignore) = prefix(DataFormatJS);
     3776    CanUseFlush canUseFlush = CanUseFlush::Yes;
     3777    std::tie(resultRegs, std::ignore, canUseFlush) = prefix(DataFormatJS);
    37713778
    37723779    speculateObject(m_graph.varArgChild(node, 0), arg1GPR);
    37733780    speculateSymbol(m_graph.varArgChild(node, 1), arg2GPR);
    37743781
    3775     flushRegisters();
     3782    if (canUseFlush == CanUseFlush::No)
     3783        silentSpillAllRegisters(resultRegs);
     3784    else
     3785        flushRegisters();
    37763786    callOperation(operationGetByValObjectSymbol, resultRegs, TrustedImmPtr::weakPointer(m_graph, m_graph.globalObjectFor(node->origin.semantic)), arg1GPR, arg2GPR);
     3787    if (canUseFlush == CanUseFlush::No)
     3788        silentFillAllRegisters();
    37773789    m_jit.exceptionCheck();
    37783790
    … …  
    81118123}
    81128124
    8113 void SpeculativeJIT::compileGetByValOnDirectArguments(Node* node, const ScopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>& prefix)
     8125void SpeculativeJIT::compileGetByValOnDirectArguments(Node* node, const ScopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>& prefix)
    81148126{
    81158127    SpeculateCellOperand base(this, m_graph.varArgChild(node, 0));
    … …  
    81208132
    81218133    JSValueRegs resultRegs;
    8122     std::tie(resultRegs, std::ignore) = prefix(DataFormatJS);
     8134    std::tie(resultRegs, std::ignore, std::ignore) = prefix(DataFormatJS);
    81238135    GPRReg scratchReg = resultRegs.payloadGPR();
    81248136   
    … …  
    81528164}
    81538165
    8154 void SpeculativeJIT::compileGetByValOnScopedArguments(Node* node, const ScopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>& prefix)
     8166void SpeculativeJIT::compileGetByValOnScopedArguments(Node* node, const ScopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>& prefix)
    81558167{
    81568168    SpeculateCellOperand base(this, m_graph.varArgChild(node, 0));
    … …  
    81688180
    81698181    JSValueRegs resultRegs;
    8170     std::tie(resultRegs, std::ignore) = prefix(DataFormatJS);
     8182    std::tie(resultRegs, std::ignore, std::ignore) = prefix(DataFormatJS);
    81718183   
    81728184    m_jit.loadPtr(
    … …  
    1586615878        MacroAssembler::Jump badStructureSlowPath;
    1586715879
    15868         compileGetByVal(node, scopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat)>([&] (DataFormat) {
     15880        compileGetByVal(node, scopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat)>([&] (DataFormat) {
    1586915881            Edge storageEdge = m_graph.varArgChild(node, 2);
    1587015882            StorageOperand storage;
    … …  
    1593915951
    1594015952            notFastNamedCases.link(&m_jit);
    15941             return std::make_pair(resultRegs, DataFormatJS);
     15953            return std::tuple { resultRegs, DataFormatJS, CanUseFlush::No };
    1594215954        }));
    1594315955

  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h

    r284330 r284851  
    13591359   
    13601360    // We use a scopedLambda to placate register allocation validation.
    1361     void compileGetByVal(Node*, const ScopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>& prefix);
     1361    enum class CanUseFlush { Yes, No };
     1362    void compileGetByVal(Node*, const ScopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>& prefix);
    13621363
    13631364    void compileGetCharCodeAt(Node*);
    1364     void compileGetByValOnString(Node*, const ScopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>& prefix);
     1365    void compileGetByValOnString(Node*, const ScopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>& prefix);
    13651366    void compileFromCharCode(Node*);
    13661367
    1367     void compileGetByValOnDirectArguments(Node*, const ScopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>& prefix);
    1368     void compileGetByValOnScopedArguments(Node*, const ScopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>& prefix);
     1368    void compileGetByValOnDirectArguments(Node*, const ScopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>& prefix);
     1369    void compileGetByValOnScopedArguments(Node*, const ScopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>& prefix);
    13691370
    13701371    void compileGetPrivateName(Node*);
    … …  
    14461447    void compileGetTypedArrayByteOffsetAsInt52(Node*);
    14471448#endif
    1448     void compileGetByValOnIntTypedArray(Node*, TypedArrayType, const ScopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>& prefix);
     1449    void compileGetByValOnIntTypedArray(Node*, TypedArrayType, const ScopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>& prefix);
    14491450    void compilePutByValForIntTypedArray(GPRReg base, GPRReg property, Node*, TypedArrayType);
    1450     void compileGetByValOnFloatTypedArray(Node*, TypedArrayType, const ScopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>& prefix);
     1451    void compileGetByValOnFloatTypedArray(Node*, TypedArrayType, const ScopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>& prefix);
    14511452    void compilePutByValForFloatTypedArray(GPRReg base, GPRReg property, Node*, TypedArrayType);
    1452     void compileGetByValForObjectWithString(Node*, const ScopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>& prefix);
    1453     void compileGetByValForObjectWithSymbol(Node*, const ScopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>& prefix);
     1453    void compileGetByValForObjectWithString(Node*, const ScopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>& prefix);
     1454    void compileGetByValForObjectWithSymbol(Node*, const ScopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>& prefix);
    14541455    void compilePutByValForCellWithString(Node*, Edge& child1, Edge& child2, Edge& child3);
    14551456    void compilePutByValForCellWithSymbol(Node*, Edge& child1, Edge& child2, Edge& child3);

  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp

    r284788 r284851  
    18161816}
    18171817
    1818 void SpeculativeJIT::compileGetByVal(Node* node, const ScopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>& prefix)
     1818void SpeculativeJIT::compileGetByVal(Node* node, const ScopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>& prefix)
    18191819{
    18201820    switch (node->arrayMode().type()) {
    … …  
    18341834
    18351835        JSValueRegs resultRegs;
    1836         std::tie(resultRegs, std::ignore) = prefix(DataFormatJS);
     1836        std::tie(resultRegs, std::ignore, std::ignore) = prefix(DataFormatJS);
    18371837
    18381838        speculationCheck(OutOfBounds, JSValueRegs(), node,
    … …  
    18641864
    18651865            JSValueRegs resultRegs;
    1866             std::tie(resultRegs, std::ignore) = prefix(DataFormatJS);
    1867 
    1868             flushRegisters();
     1866            CanUseFlush canUseFlush = CanUseFlush::Yes;
     1867            std::tie(resultRegs, std::ignore, canUseFlush) = prefix(DataFormatJS);
     1868
     1869            if (canUseFlush == CanUseFlush::No)
     1870                silentSpillAllRegisters(resultRegs);
     1871            else
     1872                flushRegisters();
    18691873            callOperation(operationGetByVal, resultRegs, TrustedImmPtr::weakPointer(m_graph, m_graph.globalObjectFor(node->origin.semantic)), baseGPR, propertyRegs);
     1874            if (canUseFlush == CanUseFlush::No)
     1875                silentFillAllRegisters();
    18701876            m_jit.exceptionCheck();
    18711877
    … …  
    18801886        auto generate = [&] (JSValueRegs baseRegs) {
    18811887            JSValueRegs resultRegs;
    1882             std::tie(resultRegs, std::ignore) = prefix(DataFormatJS);
     1888            std::tie(resultRegs, std::ignore, std::ignore) = prefix(DataFormatJS);
    18831889
    18841890            CodeOrigin codeOrigin = node->origin.semantic;
    … …  
    19471953            JSValueRegs resultRegs;
    19481954            DataFormat format;
    1949             std::tie(resultRegs, format) = prefix(node->arrayMode().type() == Array::Int32 ? DataFormatInt32 : DataFormatJS);
     1955            std::tie(resultRegs, format, std::ignore) = prefix(node->arrayMode().type() == Array::Int32 ? DataFormatInt32 : DataFormatJS);
    19501956
    19511957            speculationCheck(OutOfBounds, JSValueRegs(), nullptr, m_jit.branch32(MacroAssembler::AboveOrEqual, propertyReg, MacroAssembler::Address(storageReg, Butterfly::offsetOfPublicLength())));
    … …  
    20042010
    20052011        JSValueRegs resultRegs;
    2006         std::tie(resultRegs, std::ignore) = prefix(DataFormatJS);
     2012        std::tie(resultRegs, std::ignore, std::ignore) = prefix(DataFormatJS);
    20072013
    20082014        MacroAssembler::JumpList slowCases;
    … …  
    20372043            JSValueRegs resultRegs;
    20382044            DataFormat format;
    2039             std::tie(resultRegs, format) = prefix(DataFormatDouble);
     2045            std::tie(resultRegs, format, std::ignore) = prefix(DataFormatDouble);
    20402046
    20412047            speculationCheck(OutOfBounds, JSValueRegs(), nullptr, m_jit.branch32(MacroAssembler::AboveOrEqual, propertyReg, MacroAssembler::Address(storageReg, Butterfly::offsetOfPublicLength())));
    … …  
    20692075
    20702076        JSValueRegs resultRegs;
    2071         std::tie(resultRegs, std::ignore) = prefix(DataFormatJS);
     2077        std::tie(resultRegs, std::ignore, std::ignore) = prefix(DataFormatJS);
    20722078
    20732079        MacroAssembler::JumpList slowCases;
    … …  
    20992105
    21002106            JSValueRegs resultRegs;
    2101             std::tie(resultRegs, std::ignore) = prefix(DataFormatJS);
     2107            std::tie(resultRegs, std::ignore, std::ignore) = prefix(DataFormatJS);
    21022108
    21032109            speculationCheck(OutOfBounds, JSValueRegs(), nullptr, m_jit.branch32(MacroAssembler::AboveOrEqual, propertyReg, MacroAssembler::Address(storageReg, ArrayStorage::vectorLengthOffset())));
    … …  
    21232129
    21242130        JSValueRegs resultRegs;
    2125         std::tie(resultRegs, std::ignore) = prefix(DataFormatJS);
     2131        std::tie(resultRegs, std::ignore, std::ignore) = prefix(DataFormatJS);
    21262132
    21272133        JITCompiler::Jump outOfBounds = m_jit.branch32(
    … …  
    25952601        // Relies on StringCharAt node having same basic layout as GetByVal
    25962602        JSValueRegsTemporary result;
    2597         compileGetByValOnString(node, scopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>([&] (DataFormat preferredFormat) {
     2603        compileGetByValOnString(node, scopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>([&] (DataFormat preferredFormat) {
    25982604            result = JSValueRegsTemporary(this);
    25992605            ASSERT(preferredFormat == DataFormatJS || preferredFormat == DataFormatCell);
    2600             return std::make_pair(result.regs(), preferredFormat);
     2606            return std::tuple { result.regs(), preferredFormat, CanUseFlush::Yes };
    26012607        }));
    26022608        break;
    … …  
    26372643        JSValueRegsTemporary jsValueResult;
    26382644        GPRTemporary oneRegResult;
    2639         compileGetByVal(node, scopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>([&] (DataFormat preferredFormat) {
     2645        compileGetByVal(node, scopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>([&] (DataFormat preferredFormat) {
    26402646            JSValueRegs resultRegs;
    26412647            switch (preferredFormat) {
    … …  
    26542660            }
    26552661            };
    2656             return std::make_pair(resultRegs, preferredFormat);
     2662            return std::tuple { resultRegs, preferredFormat, CanUseFlush::Yes };
    26572663        }));
    26582664        break;

  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp

    r284700 r284851  
    23312331}
    23322332
    2333 void SpeculativeJIT::compileGetByVal(Node* node, const ScopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>& prefix)
     2333void SpeculativeJIT::compileGetByVal(Node* node, const ScopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>& prefix)
    23342334{
    23352335    switch (node->arrayMode().type()) {
    … …  
    23462346
    23472347        JSValueRegs resultRegs;
    2348         std::tie(resultRegs, std::ignore) = prefix(DataFormatJS);
     2348        std::tie(resultRegs, std::ignore, std::ignore) = prefix(DataFormatJS);
    23492349
    23502350        speculationCheck(OutOfBounds, JSValueRegs(), node,
    … …  
    23782378
    23792379            JSValueRegs resultRegs;
    2380             std::tie(resultRegs, std::ignore) = prefix(DataFormatJS);
    2381 
    2382             flushRegisters();
     2380            CanUseFlush canUseFlush = CanUseFlush::Yes;
     2381            std::tie(resultRegs, std::ignore, canUseFlush) = prefix(DataFormatJS);
     2382
     2383            if (canUseFlush == CanUseFlush::No)
     2384                silentSpillAllRegisters(resultRegs);
     2385            else
     2386                flushRegisters();
    23832387            callOperation(operationGetByVal, resultRegs, TrustedImmPtr::weakPointer(m_graph, m_graph.globalObjectFor(node->origin.semantic)), baseGPR, propertyGPR);
     2388            if (canUseFlush == CanUseFlush::No)
     2389                silentFillAllRegisters();
    23842390            m_jit.exceptionCheck();
    23852391
    … …  
    24042410
    24052411        JSValueRegs resultRegs;
    2406         std::tie(resultRegs, std::ignore) = prefix(DataFormatJS);
     2412        std::tie(resultRegs, std::ignore, std::ignore) = prefix(DataFormatJS);
    24072413        GPRReg resultGPR = resultRegs.gpr();
    24082414
    … …  
    24622468            JSValueRegs resultRegs;
    24632469            DataFormat format;
    2464             std::tie(resultRegs, format) = prefix(node->arrayMode().type() == Array::Int32 ? DataFormatJSInt32 : DataFormatJS);
     2470            std::tie(resultRegs, format, std::ignore) = prefix(node->arrayMode().type() == Array::Int32 ? DataFormatJSInt32 : DataFormatJS);
    24652471            GPRReg result = resultRegs.gpr();
    24662472
    … …  
    24942500
    24952501        JSValueRegs resultRegs;
    2496         std::tie(resultRegs, std::ignore) = prefix(DataFormatJS);
     2502        std::tie(resultRegs, std::ignore, std::ignore) = prefix(DataFormatJS);
    24972503        GPRReg resultReg = resultRegs.gpr();
    24982504
    … …  
    25382544            JSValueRegs resultRegs;
    25392545            DataFormat format;
    2540             std::tie(resultRegs, format) = prefix(DataFormatDouble);
     2546            std::tie(resultRegs, format, std::ignore) = prefix(DataFormatDouble);
    25412547
    25422548            speculationCheck(OutOfBounds, JSValueRegs(), nullptr, m_jit.branch32(MacroAssembler::AboveOrEqual, propertyReg, MacroAssembler::Address(storageReg, Butterfly::offsetOfPublicLength())));
    … …  
    25732579        JSValueRegs resultRegs;
    25742580        DataFormat format;
    2575         std::tie(resultRegs, format) = prefix(resultIsUnboxed ? DataFormatDouble : DataFormatJS);
     2581        std::tie(resultRegs, format, std::ignore) = prefix(resultIsUnboxed ? DataFormatDouble : DataFormatJS);
    25762582
    25772583        MacroAssembler::JumpList slowCases;
    … …  
    26262632
    26272633            JSValueRegs resultRegs;
    2628             std::tie(resultRegs, std::ignore) = prefix(DataFormatJS);
     2634            std::tie(resultRegs, std::ignore, std::ignore) = prefix(DataFormatJS);
    26292635            GPRReg resultGPR = resultRegs.gpr();
    26302636
    … …  
    26512657
    26522658        JSValueRegs resultRegs;
    2653         std::tie(resultRegs, std::ignore) = prefix(DataFormatJS);
     2659        std::tie(resultRegs, std::ignore, std::ignore) = prefix(DataFormatJS);
    26542660        GPRReg resultReg = resultRegs.gpr();
    26552661
    … …  
    32433249        // Relies on StringCharAt node having same basic layout as GetByVal
    32443250        JSValueRegsTemporary result;
    3245         compileGetByValOnString(node, scopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>([&] (DataFormat preferredFormat) {
     3251        compileGetByValOnString(node, scopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>([&] (DataFormat preferredFormat) {
    32463252            result = JSValueRegsTemporary(this);
    32473253            ASSERT(preferredFormat == DataFormatJS || preferredFormat == DataFormatCell);
    3248             return std::make_pair(result.regs(), preferredFormat);
     3254            return std::tuple { result.regs(), preferredFormat, CanUseFlush::Yes };
    32493255        }));
    32503256        break;
    … …  
    32853291    case GetByVal: {
    32863292        JSValueRegsTemporary result;
    3287         compileGetByVal(node, scopedLambda<std::tuple<JSValueRegs, DataFormat>(DataFormat preferredFormat)>([&] (DataFormat preferredFormat) {
     3293        compileGetByVal(node, scopedLambda<std::tuple<JSValueRegs, DataFormat, CanUseFlush>(DataFormat preferredFormat)>([&] (DataFormat preferredFormat) {
    32883294            JSValueRegs resultRegs;
    32893295            switch (preferredFormat) {
    … …  
    32963302            }
    32973303            };
    3298             return std::make_pair(resultRegs, preferredFormat);
     3304            return std::tuple { resultRegs, preferredFormat, CanUseFlush::Yes };
    32993305        }));
    33003306        break;
Note: See TracChangeset for help on using the changeset viewer.