Changeset 87364 in webkit


Ignore:
Timestamp:
May 25, 2011 11:58:55 PM (13 years ago)
Author:
barraclough@apple.com
Message:

​https://bugs.webkit.org/show_bug.cgi?id=61506

Reviewed by Sam Weinig.

Move the silent spill/fill methods in the DFG JIT to the JITCodeGenerator
so that they are available to the SpeculativeJIT.

  • dfg/DFGJITCodeGenerator.h:

(JSC::DFG::JITCodeGenerator::silentSpillGPR):
(JSC::DFG::JITCodeGenerator::silentSpillFPR):
(JSC::DFG::JITCodeGenerator::silentFillGPR):
(JSC::DFG::JITCodeGenerator::silentFillFPR):
(JSC::DFG::JITCodeGenerator::silentSpillAllRegisters):
(JSC::DFG::JITCodeGenerator::silentFillAllRegisters):

  • dfg/DFGNonSpeculativeJIT.h:
Location:
trunk/Source/JavaScriptCore
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r87359 r87364  
     12011-05-25  Gavin Barraclough  <barraclough@apple.com>
     2
     3        Reviewed by Sam Weinig.
     4
     5        https://bugs.webkit.org/show_bug.cgi?id=61506
     6
     7        Move the silent spill/fill methods in the DFG JIT to the JITCodeGenerator
     8        so that they are available to the SpeculativeJIT.
     9
     10        * dfg/DFGJITCodeGenerator.h:
     11        (JSC::DFG::JITCodeGenerator::silentSpillGPR):
     12        (JSC::DFG::JITCodeGenerator::silentSpillFPR):
     13        (JSC::DFG::JITCodeGenerator::silentFillGPR):
     14        (JSC::DFG::JITCodeGenerator::silentFillFPR):
     15        (JSC::DFG::JITCodeGenerator::silentSpillAllRegisters):
     16        (JSC::DFG::JITCodeGenerator::silentFillAllRegisters):
     17        * dfg/DFGNonSpeculativeJIT.h:
     18
    1192011-05-25  Ryosuke Niwa  <rniwa@webkit.org>
    220

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

    r85271 r87364  
    154154    }
    155155
     156    // These methods are used when generating 'unexpected'
     157    // calls out from JIT code to C++ helper routines -
     158    // they spill all live values to the appropriate
     159    // slots in the RegisterFile without changing any state
     160    // in the GenerationInfo.
     161    void silentSpillGPR(VirtualRegister spillMe, GPRReg exclude = InvalidGPRReg)
     162    {
     163        GenerationInfo& info = m_generationInfo[spillMe];
     164        ASSERT(info.registerFormat() != DataFormatNone && info.registerFormat() != DataFormatDouble);
     165
     166        if (!info.needsSpill() || (info.gpr() == exclude))
     167            return;
     168
     169        DataFormat registerFormat = info.registerFormat();
     170
     171        if (registerFormat == DataFormatInteger) {
     172            m_jit.orPtr(GPRInfo::tagTypeNumberRegister, info.gpr());
     173            m_jit.storePtr(info.gpr(), JITCompiler::addressFor(spillMe));
     174        } else {
     175            ASSERT(registerFormat & DataFormatJS || registerFormat == DataFormatCell);
     176            m_jit.storePtr(info.gpr(), JITCompiler::addressFor(spillMe));
     177        }
     178    }
     179    void silentSpillFPR(VirtualRegister spillMe, GPRReg canTrample, FPRReg exclude = InvalidFPRReg)
     180    {
     181        GenerationInfo& info = m_generationInfo[spillMe];
     182        ASSERT(info.registerFormat() == DataFormatDouble);
     183
     184        if (!info.needsSpill() || (info.fpr() == exclude))
     185            return;
     186
     187        boxDouble(info.fpr(), canTrample);
     188        m_jit.storePtr(canTrample, JITCompiler::addressFor(spillMe));
     189    }
     190
     191    void silentFillGPR(VirtualRegister spillMe, GPRReg exclude = InvalidGPRReg)
     192    {
     193        GenerationInfo& info = m_generationInfo[spillMe];
     194        if (info.gpr() == exclude)
     195            return;
     196
     197        NodeIndex nodeIndex = info.nodeIndex();
     198        Node& node = m_jit.graph()[nodeIndex];
     199        ASSERT(info.registerFormat() != DataFormatNone && info.registerFormat() != DataFormatDouble);
     200        DataFormat registerFormat = info.registerFormat();
     201
     202        if (registerFormat == DataFormatInteger) {
     203            if (node.isConstant()) {
     204                ASSERT(isInt32Constant(nodeIndex));
     205                m_jit.move(Imm32(valueOfInt32Constant(nodeIndex)), info.gpr());
     206            } else
     207                m_jit.load32(JITCompiler::addressFor(spillMe), info.gpr());
     208            return;
     209        }
     210
     211        if (node.isConstant())
     212            m_jit.move(constantAsJSValueAsImmPtr(nodeIndex), info.gpr());
     213        else {
     214            ASSERT(registerFormat & DataFormatJS || registerFormat == DataFormatCell);
     215            m_jit.loadPtr(JITCompiler::addressFor(spillMe), info.gpr());
     216        }
     217    }
     218    void silentFillFPR(VirtualRegister spillMe, GPRReg canTrample, FPRReg exclude = InvalidFPRReg)
     219    {
     220        GenerationInfo& info = m_generationInfo[spillMe];
     221        if (info.fpr() == exclude)
     222            return;
     223
     224        NodeIndex nodeIndex = info.nodeIndex();
     225        Node& node = m_jit.graph()[nodeIndex];
     226        ASSERT(info.registerFormat() == DataFormatDouble);
     227
     228        if (node.isConstant())
     229            m_jit.move(constantAsJSValueAsImmPtr(nodeIndex), info.gpr());
     230        else {
     231            m_jit.loadPtr(JITCompiler::addressFor(spillMe), canTrample);
     232            unboxDouble(canTrample, info.fpr());
     233        }
     234    }
     235
     236    void silentSpillAllRegisters(GPRReg exclude, GPRReg preserve = InvalidGPRReg)
     237    {
     238        GPRReg canTrample = GPRInfo::regT0;
     239        if (preserve == GPRInfo::regT0)
     240            canTrample = GPRInfo::regT1;
     241       
     242        for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) {
     243            if (iter.name() != InvalidVirtualRegister)
     244                silentSpillGPR(iter.name(), exclude);
     245        }
     246        for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
     247            if (iter.name() != InvalidVirtualRegister)
     248                silentSpillFPR(iter.name(), canTrample);
     249        }
     250    }
     251    void silentSpillAllRegisters(FPRReg exclude, GPRReg preserve = InvalidGPRReg)
     252    {
     253        GPRReg canTrample = GPRInfo::regT0;
     254        if (preserve == GPRInfo::regT0)
     255            canTrample = GPRInfo::regT1;
     256       
     257        for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) {
     258            if (iter.name() != InvalidVirtualRegister)
     259                silentSpillGPR(iter.name());
     260        }
     261        for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
     262            if (iter.name() != InvalidVirtualRegister)
     263                silentSpillFPR(iter.name(), canTrample, exclude);
     264        }
     265    }
     266    void silentFillAllRegisters(GPRReg exclude)
     267    {
     268        GPRReg canTrample = GPRInfo::regT0;
     269        if (exclude == GPRInfo::regT0)
     270            canTrample = GPRInfo::regT1;
     271       
     272        for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
     273            if (iter.name() != InvalidVirtualRegister)
     274                silentFillFPR(iter.name(), canTrample);
     275        }
     276        for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) {
     277            if (iter.name() != InvalidVirtualRegister)
     278                silentFillGPR(iter.name(), exclude);
     279        }
     280    }
     281    void silentFillAllRegisters(FPRReg exclude)
     282    {
     283        GPRReg canTrample = GPRInfo::regT0;
     284       
     285        for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
     286            if (iter.name() != InvalidVirtualRegister) {
     287                ASSERT_UNUSED(exclude, iter.regID() != exclude);
     288                silentFillFPR(iter.name(), canTrample, exclude);
     289            }
     290        }
     291        for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) {
     292            if (iter.name() != InvalidVirtualRegister)
     293                silentFillGPR(iter.name());
     294        }
     295    }
     296
    156297    // These methods convert between doubles, and doubles boxed and JSValues.
    157298    GPRReg boxDouble(FPRReg fpr, GPRReg gpr)

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

    r85271 r87364  
    8686    bool isKnownNumeric(NodeIndex);
    8787
    88     // These methods are used when generating 'unexpected'
    89     // calls out from JIT code to C++ helper routines -
    90     // they spill all live values to the appropriate
    91     // slots in the RegisterFile without changing any state
    92     // in the GenerationInfo.
    93     void silentSpillGPR(VirtualRegister spillMe, GPRReg exclude = InvalidGPRReg)
    94     {
    95         GenerationInfo& info = m_generationInfo[spillMe];
    96         ASSERT(info.registerFormat() != DataFormatNone && info.registerFormat() != DataFormatDouble);
    97 
    98         if (!info.needsSpill() || (info.gpr() == exclude))
    99             return;
    100 
    101         DataFormat registerFormat = info.registerFormat();
    102 
    103         if (registerFormat == DataFormatInteger) {
    104             m_jit.orPtr(GPRInfo::tagTypeNumberRegister, info.gpr());
    105             m_jit.storePtr(info.gpr(), JITCompiler::addressFor(spillMe));
    106         } else {
    107             ASSERT(registerFormat & DataFormatJS || registerFormat == DataFormatCell);
    108             m_jit.storePtr(info.gpr(), JITCompiler::addressFor(spillMe));
    109         }
    110     }
    111     void silentSpillFPR(VirtualRegister spillMe, GPRReg canTrample, FPRReg exclude = InvalidFPRReg)
    112     {
    113         GenerationInfo& info = m_generationInfo[spillMe];
    114         ASSERT(info.registerFormat() == DataFormatDouble);
    115 
    116         if (!info.needsSpill() || (info.fpr() == exclude))
    117             return;
    118 
    119         boxDouble(info.fpr(), canTrample);
    120         m_jit.storePtr(canTrample, JITCompiler::addressFor(spillMe));
    121     }
    122 
    123     void silentFillGPR(VirtualRegister spillMe, GPRReg exclude = InvalidGPRReg)
    124     {
    125         GenerationInfo& info = m_generationInfo[spillMe];
    126         if (info.gpr() == exclude)
    127             return;
    128 
    129         NodeIndex nodeIndex = info.nodeIndex();
    130         Node& node = m_jit.graph()[nodeIndex];
    131         ASSERT(info.registerFormat() != DataFormatNone && info.registerFormat() != DataFormatDouble);
    132         DataFormat registerFormat = info.registerFormat();
    133 
    134         if (registerFormat == DataFormatInteger) {
    135             if (node.isConstant()) {
    136                 ASSERT(isInt32Constant(nodeIndex));
    137                 m_jit.move(Imm32(valueOfInt32Constant(nodeIndex)), info.gpr());
    138             } else
    139                 m_jit.load32(JITCompiler::addressFor(spillMe), info.gpr());
    140             return;
    141         }
    142 
    143         if (node.isConstant())
    144             m_jit.move(constantAsJSValueAsImmPtr(nodeIndex), info.gpr());
    145         else {
    146             ASSERT(registerFormat & DataFormatJS || registerFormat == DataFormatCell);
    147             m_jit.loadPtr(JITCompiler::addressFor(spillMe), info.gpr());
    148         }
    149     }
    150     void silentFillFPR(VirtualRegister spillMe, GPRReg canTrample, FPRReg exclude = InvalidFPRReg)
    151     {
    152         GenerationInfo& info = m_generationInfo[spillMe];
    153         if (info.fpr() == exclude)
    154             return;
    155 
    156         NodeIndex nodeIndex = info.nodeIndex();
    157         Node& node = m_jit.graph()[nodeIndex];
    158         ASSERT(info.registerFormat() == DataFormatDouble);
    159 
    160         if (node.isConstant())
    161             m_jit.move(constantAsJSValueAsImmPtr(nodeIndex), info.gpr());
    162         else {
    163             m_jit.loadPtr(JITCompiler::addressFor(spillMe), canTrample);
    164             unboxDouble(canTrample, info.fpr());
    165         }
    166     }
    167 
    168     void silentSpillAllRegisters(GPRReg exclude, GPRReg preserve = InvalidGPRReg)
    169     {
    170         GPRReg canTrample = GPRInfo::regT0;
    171         if (preserve == GPRInfo::regT0)
    172             canTrample = GPRInfo::regT1;
    173        
    174         for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) {
    175             if (iter.name() != InvalidVirtualRegister)
    176                 silentSpillGPR(iter.name(), exclude);
    177         }
    178         for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
    179             if (iter.name() != InvalidVirtualRegister)
    180                 silentSpillFPR(iter.name(), canTrample);
    181         }
    182     }
    183     void silentSpillAllRegisters(FPRReg exclude, GPRReg preserve = InvalidGPRReg)
    184     {
    185         GPRReg canTrample = GPRInfo::regT0;
    186         if (preserve == GPRInfo::regT0)
    187             canTrample = GPRInfo::regT1;
    188        
    189         for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) {
    190             if (iter.name() != InvalidVirtualRegister)
    191                 silentSpillGPR(iter.name());
    192         }
    193         for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
    194             if (iter.name() != InvalidVirtualRegister)
    195                 silentSpillFPR(iter.name(), canTrample, exclude);
    196         }
    197     }
    198     void silentFillAllRegisters(GPRReg exclude)
    199     {
    200         GPRReg canTrample = GPRInfo::regT0;
    201         if (exclude == GPRInfo::regT0)
    202             canTrample = GPRInfo::regT1;
    203        
    204         for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
    205             if (iter.name() != InvalidVirtualRegister)
    206                 silentFillFPR(iter.name(), canTrample);
    207         }
    208         for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) {
    209             if (iter.name() != InvalidVirtualRegister)
    210                 silentFillGPR(iter.name(), exclude);
    211         }
    212     }
    213     void silentFillAllRegisters(FPRReg exclude)
    214     {
    215         GPRReg canTrample = GPRInfo::regT0;
    216        
    217         for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
    218             if (iter.name() != InvalidVirtualRegister) {
    219                 ASSERT_UNUSED(exclude, iter.regID() != exclude);
    220                 silentFillFPR(iter.name(), canTrample, exclude);
    221             }
    222         }
    223         for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) {
    224             if (iter.name() != InvalidVirtualRegister)
    225                 silentFillGPR(iter.name());
    226         }
    227     }
    228 
    22988    // These methods are used to plant calls out to C++
    23089    // helper routines to convert between types.
Note: See TracChangeset for help on using the changeset viewer.