Changeset 192842 in webkit


Ignore:
Timestamp:
Nov 30, 2015, 4:07:39 PM (10 years ago)
Author:
mark.lam@apple.com
Message:

Refactor the op_add, op_sub, and op_mul snippets to use the SnippetOperand class.
​https://bugs.webkit.org/show_bug.cgi?id=151678

Reviewed by Geoffrey Garen.

  • dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::compileValueAdd):
(JSC::DFG::SpeculativeJIT::compileArithSub):

  • ftl/FTLCompile.cpp:
  • jit/JITAddGenerator.cpp:

(JSC::JITAddGenerator::generateFastPath):

  • jit/JITAddGenerator.h:

(JSC::JITAddGenerator::JITAddGenerator):

  • jit/JITArithmetic.cpp:

(JSC::JIT::emit_op_add):
(JSC::JIT::emit_op_mul):
(JSC::JIT::emit_op_sub):

  • jit/JITMulGenerator.cpp:

(JSC::JITMulGenerator::generateFastPath):

  • jit/JITMulGenerator.h:

(JSC::JITMulGenerator::JITMulGenerator):

  • jit/JITSubGenerator.cpp:

(JSC::JITSubGenerator::generateFastPath):

  • jit/JITSubGenerator.h:

(JSC::JITSubGenerator::JITSubGenerator):

  • jit/SnippetOperand.h:

(JSC::SnippetOperand::isPositiveConstInt32):

Location:
trunk/Source/JavaScriptCore
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r192841 r192842  
     12015-11-30  Mark Lam  <mark.lam@apple.com>
     2
     3        Refactor the op_add, op_sub, and op_mul snippets to use the SnippetOperand class.
     4        https://bugs.webkit.org/show_bug.cgi?id=151678
     5
     6        Reviewed by Geoffrey Garen.
     7
     8        * dfg/DFGSpeculativeJIT.cpp:
     9        (JSC::DFG::SpeculativeJIT::compileValueAdd):
     10        (JSC::DFG::SpeculativeJIT::compileArithSub):
     11        * ftl/FTLCompile.cpp:
     12        * jit/JITAddGenerator.cpp:
     13        (JSC::JITAddGenerator::generateFastPath):
     14        * jit/JITAddGenerator.h:
     15        (JSC::JITAddGenerator::JITAddGenerator):
     16        * jit/JITArithmetic.cpp:
     17        (JSC::JIT::emit_op_add):
     18        (JSC::JIT::emit_op_mul):
     19        (JSC::JIT::emit_op_sub):
     20        * jit/JITMulGenerator.cpp:
     21        (JSC::JITMulGenerator::generateFastPath):
     22        * jit/JITMulGenerator.h:
     23        (JSC::JITMulGenerator::JITMulGenerator):
     24        * jit/JITSubGenerator.cpp:
     25        (JSC::JITSubGenerator::generateFastPath):
     26        * jit/JITSubGenerator.h:
     27        (JSC::JITSubGenerator::JITSubGenerator):
     28        * jit/SnippetOperand.h:
     29        (JSC::SnippetOperand::isPositiveConstInt32):
     30
    1312015-11-30  Filip Pizlo  <fpizlo@apple.com>
    232

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

    r192814 r192842  
    28542854#endif
    28552855
    2856     ResultType leftType = m_state.forNode(node->child1()).resultType();
    2857     ResultType rightType = m_state.forNode(node->child2()).resultType();
    2858     int32_t leftConstInt32 = 0;
    2859     int32_t rightConstInt32 = 0;
    2860 
    2861     ASSERT(!leftIsConstInt32 || !rightIsConstInt32);
    2862 
    2863     if (leftIsConstInt32) {
    2864         leftConstInt32 = node->child1()->asInt32();
     2856    SnippetOperand leftOperand(m_state.forNode(node->child1()).resultType());
     2857    SnippetOperand rightOperand(m_state.forNode(node->child2()).resultType());
     2858
     2859    if (leftIsConstInt32)
     2860        leftOperand.setConstInt32(node->child1()->asInt32());
     2861    if (rightIsConstInt32)
     2862        rightOperand.setConstInt32(node->child2()->asInt32());
     2863
     2864    ASSERT(!leftOperand.isConst() || !rightOperand.isConst());
     2865
     2866    if (!leftOperand.isConst()) {
     2867        left = JSValueOperand(this, node->child1());
     2868        leftRegs = left->jsValueRegs();
     2869    }
     2870    if (!rightOperand.isConst()) {
    28652871        right = JSValueOperand(this, node->child2());
    28662872        rightRegs = right->jsValueRegs();
    2867     } else if (rightIsConstInt32) {
    2868         left = JSValueOperand(this, node->child1());
    2869         leftRegs = left->jsValueRegs();
    2870         rightConstInt32 = node->child2()->asInt32();
    2871     } else {
    2872         left = JSValueOperand(this, node->child1());
    2873         leftRegs = left->jsValueRegs();
    2874         right = JSValueOperand(this, node->child2());
    2875         rightRegs = right->jsValueRegs();
    2876     }
    2877 
    2878     JITAddGenerator gen(resultRegs, leftRegs, rightRegs, leftType, rightType,
    2879         leftIsConstInt32, rightIsConstInt32, leftConstInt32, rightConstInt32,
     2873    }
     2874
     2875    JITAddGenerator gen(leftOperand, rightOperand, resultRegs, leftRegs, rightRegs,
    28802876        leftFPR, rightFPR, scratchGPR, scratchFPR);
    28812877    gen.generateFastPath(m_jit);
    … …  
    32173213        JSValueRegs rightRegs = right.jsValueRegs();
    32183214
    3219         ResultType leftType = m_state.forNode(node->child1()).resultType();
    3220         ResultType rightType = m_state.forNode(node->child2()).resultType();
    3221 
    32223215        FPRTemporary leftNumber(this);
    32233216        FPRTemporary rightNumber(this);
    … …  
    32403233#endif
    32413234
    3242         JITSubGenerator gen(resultRegs, leftRegs, rightRegs, leftType, rightType,
     3235        SnippetOperand leftOperand(m_state.forNode(node->child1()).resultType());
     3236        SnippetOperand rightOperand(m_state.forNode(node->child2()).resultType());
     3237
     3238        JITSubGenerator gen(leftOperand, rightOperand, resultRegs, leftRegs, rightRegs,
    32433239            leftFPR, rightFPR, scratchGPR, scratchFPR);
    32443240        gen.generateFastPath(m_jit);

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

    r192599 r192842  
    441441        CCallHelpers fastPathJIT(&vm, codeBlock);
    442442
     443        SnippetOperand leftOperand(ic.leftType());
     444        SnippetOperand rightOperand(ic.rightType());
     445
    443446        GPRReg result = record.locations[0].directGPR();
    444447        GPRReg left = record.locations[1].directGPR();
    … …  
    455458        FPRReg scratchFPR = InvalidFPRReg;
    456459
    457         JITSubGenerator gen(JSValueRegs(result), JSValueRegs(left), JSValueRegs(right), ic.leftType(), ic.rightType(), leftFPR, rightFPR, scratchGPR, scratchFPR);
     460        JITSubGenerator gen(leftOperand, rightOperand, JSValueRegs(result), JSValueRegs(left), JSValueRegs(right), leftFPR, rightFPR, scratchGPR, scratchFPR);
    458461
    459462        auto numberOfBytesUsedToPreserveReusedRegisters =

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

    r192599 r192842  
    2525
    2626#include "config.h"
     27#include "JITAddGenerator.h"
    2728
    2829#if ENABLE(JIT)
    29 #include "JITAddGenerator.h"
    3030
    3131namespace JSC {
    … …  
    4242#endif
    4343
    44     ASSERT(!m_leftIsConstInt32 || !m_rightIsConstInt32);
     44    ASSERT(!m_leftOperand.isConstInt32() || !m_rightOperand.isConstInt32());
    4545   
    46     if (!m_leftType.mightBeNumber() || !m_rightType.mightBeNumber()) {
     46    if (!m_leftOperand.mightBeNumber() || !m_rightOperand.mightBeNumber()) {
    4747        ASSERT(!m_didEmitFastPath);
    4848        return;
    … …  
    5151    m_didEmitFastPath = true;
    5252
    53     if (m_leftIsConstInt32 || m_rightIsConstInt32) {
    54         JSValueRegs var;
    55         ResultType varType = ResultType::unknownType();
    56         int32_t constInt32;
    57 
    58         if (m_leftIsConstInt32) {
    59             var = m_right;
    60             varType = m_rightType;
    61             constInt32 = m_leftConstInt32;
    62         } else {
    63             var = m_left;
    64             varType = m_leftType;
    65             constInt32 = m_rightConstInt32;
    66         }
     53    if (m_leftOperand.isConstInt32() || m_rightOperand.isConstInt32()) {
     54        JSValueRegs var = m_leftOperand.isConstInt32() ? m_right : m_left;
     55        SnippetOperand& varOpr = m_leftOperand.isConstInt32() ? m_rightOperand : m_leftOperand;
     56        SnippetOperand& constOpr = m_leftOperand.isConstInt32() ? m_leftOperand : m_rightOperand;
    6757
    6858        // Try to do intVar + intConstant.
    6959        CCallHelpers::Jump notInt32 = jit.branchIfNotInt32(var);
    7060
    71         m_slowPathJumpList.append(jit.branchAdd32(CCallHelpers::Overflow, var.payloadGPR(), CCallHelpers::Imm32(constInt32), m_scratchGPR));
     61        m_slowPathJumpList.append(jit.branchAdd32(CCallHelpers::Overflow, var.payloadGPR(), CCallHelpers::Imm32(constOpr.asConstInt32()), m_scratchGPR));
    7262
    7363        jit.boxInt32(m_scratchGPR, m_result);
    … …  
    8171        // Try to do doubleVar + double(intConstant).
    8272        notInt32.link(&jit);
    83         if (!varType.definitelyIsNumber())
     73        if (!varOpr.definitelyIsNumber())
    8474            m_slowPathJumpList.append(jit.branchIfNotNumber(var, m_scratchGPR));
    8575
    8676        jit.unboxDoubleNonDestructive(var, m_leftFPR, m_scratchGPR, m_scratchFPR);
    8777
    88         jit.move(CCallHelpers::Imm32(constInt32), m_scratchGPR);
     78        jit.move(CCallHelpers::Imm32(constOpr.asConstInt32()), m_scratchGPR);
    8979        jit.convertInt32ToDouble(m_scratchGPR, m_rightFPR);
    9080
    … …  
    9282
    9383    } else {
    94         ASSERT(!m_leftIsConstInt32 && !m_rightIsConstInt32);
     84        ASSERT(!m_leftOperand.isConstInt32() && !m_rightOperand.isConstInt32());
    9585        CCallHelpers::Jump leftNotInt;
    9686        CCallHelpers::Jump rightNotInt;
    … …  
    112102
    113103        leftNotInt.link(&jit);
    114         if (!m_leftType.definitelyIsNumber())
     104        if (!m_leftOperand.definitelyIsNumber())
    115105            m_slowPathJumpList.append(jit.branchIfNotNumber(m_left, m_scratchGPR));
    116         if (!m_rightType.definitelyIsNumber())
     106        if (!m_rightOperand.definitelyIsNumber())
    117107            m_slowPathJumpList.append(jit.branchIfNotNumber(m_right, m_scratchGPR));
    118108
    … …  
    124114
    125115        rightNotInt.link(&jit);
    126         if (!m_rightType.definitelyIsNumber())
     116        if (!m_rightOperand.definitelyIsNumber())
    127117            m_slowPathJumpList.append(jit.branchIfNotNumber(m_right, m_scratchGPR));
    128118

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

    r192632 r192842  
    3030
    3131#include "CCallHelpers.h"
    32 #include "ResultType.h"
     32#include "SnippetOperand.h"
    3333
    3434namespace JSC {
    … …  
    3636class JITAddGenerator {
    3737public:
    38     JITAddGenerator(JSValueRegs result, JSValueRegs left, JSValueRegs right,
    39         ResultType leftType, ResultType rightType, bool leftIsConstInt32, bool rightIsConstInt32,
    40         int32_t leftConstInt32, int32_t rightConstInt32, FPRReg leftFPR, FPRReg rightFPR,
    41         GPRReg scratchGPR, FPRReg scratchFPR)
    42         : m_result(result)
     38    JITAddGenerator(SnippetOperand leftOperand, SnippetOperand rightOperand,
     39        JSValueRegs result, JSValueRegs left, JSValueRegs right,
     40        FPRReg leftFPR, FPRReg rightFPR, GPRReg scratchGPR, FPRReg scratchFPR)
     41        : m_leftOperand(leftOperand)
     42        , m_rightOperand(rightOperand)
     43        , m_result(result)
    4344        , m_left(left)
    4445        , m_right(right)
    45         , m_leftType(leftType)
    46         , m_rightType(rightType)
    47         , m_leftIsConstInt32(leftIsConstInt32)
    48         , m_rightIsConstInt32(rightIsConstInt32)
    49         , m_leftConstInt32(leftConstInt32)
    50         , m_rightConstInt32(rightConstInt32)
    5146        , m_leftFPR(leftFPR)
    5247        , m_rightFPR(rightFPR)
    … …  
    5449        , m_scratchFPR(scratchFPR)
    5550    {
    56         ASSERT(!leftIsConstInt32 || !rightIsConstInt32);
     51        ASSERT(!m_leftOperand.isConstInt32() || !m_rightOperand.isConstInt32());
    5752    }
    5853
    … …  
    6459
    6560private:
     61    SnippetOperand m_leftOperand;
     62    SnippetOperand m_rightOperand;
    6663    JSValueRegs m_result;
    6764    JSValueRegs m_left;
    6865    JSValueRegs m_right;
    69     ResultType m_leftType;
    70     ResultType m_rightType;
    71     bool m_leftIsConstInt32;
    72     bool m_rightIsConstInt32;
    73     int32_t m_leftConstInt32;
    74     int32_t m_rightConstInt32;
    7566    FPRReg m_leftFPR;
    7667    FPRReg m_rightFPR;

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

    r192836 r192842  
    686686#endif
    687687
    688     bool leftIsConstInt32 = isOperandConstantInt(op1);
    689     bool rightIsConstInt32 = isOperandConstantInt(op2);
    690     ResultType leftType = types.first();
    691     ResultType rightType = types.second();
    692     int32_t leftConstInt32 = 0;
    693     int32_t rightConstInt32 = 0;
    694 
    695     ASSERT(!leftIsConstInt32 || !rightIsConstInt32);
    696 
    697     if (leftIsConstInt32) {
    698         leftConstInt32 = getOperandConstantInt(op1);
     688    SnippetOperand leftOperand(types.first());
     689    SnippetOperand rightOperand(types.second());
     690
     691    if (isOperandConstantInt(op1))
     692        leftOperand.setConstInt32(getOperandConstantInt(op1));
     693    if (isOperandConstantInt(op2))
     694        rightOperand.setConstInt32(getOperandConstantInt(op2));
     695
     696    ASSERT(!leftOperand.isConst() || !rightOperand.isConst());
     697
     698    if (!leftOperand.isConst())
     699        emitGetVirtualRegister(op1, leftRegs);
     700    if (!rightOperand.isConst())
    699701        emitGetVirtualRegister(op2, rightRegs);
    700     } else if (rightIsConstInt32) {
    701         emitGetVirtualRegister(op1, leftRegs);
    702         rightConstInt32 = getOperandConstantInt(op2);
    703     } else {
    704         emitGetVirtualRegister(op1, leftRegs);
    705         emitGetVirtualRegister(op2, rightRegs);
    706     }
    707 
    708     JITAddGenerator gen(resultRegs, leftRegs, rightRegs, leftType, rightType,
    709         leftIsConstInt32, rightIsConstInt32, leftConstInt32, rightConstInt32,
     702
     703    JITAddGenerator gen(leftOperand, rightOperand, resultRegs, leftRegs, rightRegs,
    710704        fpRegT0, fpRegT1, scratchGPR, scratchFPR);
    711705
    … …  
    827821#endif
    828822
    829     bool leftIsConstInt32 = isOperandConstantInt(op1);
    830     bool rightIsConstInt32 = isOperandConstantInt(op2);
    831     ResultType leftType = types.first();
    832     ResultType rightType = types.second();
    833     int32_t leftConstInt32 = 0;
    834     int32_t rightConstInt32 = 0;
    835 
    836823    uint32_t* profilingCounter = nullptr;
    837824    if (shouldEmitProfiling())
    838825        profilingCounter = &m_codeBlock->addSpecialFastCaseProfile(m_bytecodeOffset)->m_counter;
    839826
    840     ASSERT(!leftIsConstInt32 || !rightIsConstInt32);
    841 
    842     if (leftIsConstInt32)
    843         leftConstInt32 = getOperandConstantInt(op1);
    844     if (rightIsConstInt32)
    845         rightConstInt32 = getOperandConstantInt(op2);
    846 
    847     bool leftIsPositiveConstInt32 = leftIsConstInt32 && (leftConstInt32 > 0);
    848     bool rightIsPositiveConstInt32 = rightIsConstInt32 && (rightConstInt32 > 0);
    849 
    850     if (leftIsPositiveConstInt32)
     827    SnippetOperand leftOperand(types.first());
     828    SnippetOperand rightOperand(types.second());
     829
     830    if (isOperandConstantInt(op1))
     831        leftOperand.setConstInt32(getOperandConstantInt(op1));
     832    if (isOperandConstantInt(op2))
     833        rightOperand.setConstInt32(getOperandConstantInt(op2));
     834
     835    ASSERT(!leftOperand.isConst() || !rightOperand.isConst());
     836
     837    if (!leftOperand.isPositiveConstInt32())
     838        emitGetVirtualRegister(op1, leftRegs);
     839    if (!rightOperand.isPositiveConstInt32())
    851840        emitGetVirtualRegister(op2, rightRegs);
    852     else if (rightIsPositiveConstInt32)
    853         emitGetVirtualRegister(op1, leftRegs);
    854     else {
    855         emitGetVirtualRegister(op1, leftRegs);
    856         emitGetVirtualRegister(op2, rightRegs);
    857     }
    858 
    859     JITMulGenerator gen(resultRegs, leftRegs, rightRegs, leftType, rightType,
    860         leftIsPositiveConstInt32, rightIsPositiveConstInt32, leftConstInt32, rightConstInt32,
     841
     842    JITMulGenerator gen(leftOperand, rightOperand, resultRegs, leftRegs, rightRegs,
    861843        fpRegT0, fpRegT1, scratchGPR, scratchFPR, profilingCounter);
    862844
    … …  
    905887#endif
    906888
     889    SnippetOperand leftOperand(types.first());
     890    SnippetOperand rightOperand(types.second());
     891   
    907892    emitGetVirtualRegister(op1, leftRegs);
    908893    emitGetVirtualRegister(op2, rightRegs);
    909894
    910     JITSubGenerator gen(resultRegs, leftRegs, rightRegs, types.first(), types.second(),
     895    JITSubGenerator gen(leftOperand, rightOperand, resultRegs, leftRegs, rightRegs,
    911896        fpRegT0, fpRegT1, scratchGPR, scratchFPR);
    912897

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

    r192600 r192842  
    2525
    2626#include "config.h"
     27#include "JITMulGenerator.h"
    2728
    2829#if ENABLE(JIT)
    29 #include "JITMulGenerator.h"
    3030
    3131namespace JSC {
    … …  
    4242#endif
    4343
    44     ASSERT(!m_leftIsPositiveConstInt32 || !m_rightIsPositiveConstInt32);
    45    
    46     if (!m_leftType.mightBeNumber() || !m_rightType.mightBeNumber()) {
     44    ASSERT(!m_leftOperand.isPositiveConstInt32() || !m_rightOperand.isPositiveConstInt32());
     45
     46    if (!m_leftOperand.mightBeNumber() || !m_rightOperand.mightBeNumber()) {
    4747        ASSERT(!m_didEmitFastPath);
    4848        return;
    … …  
    5151    m_didEmitFastPath = true;
    5252
    53     if (m_leftIsPositiveConstInt32 || m_rightIsPositiveConstInt32) {
    54         JSValueRegs var;
    55         ResultType varType = ResultType::unknownType();
    56         int32_t constInt32;
    57 
    58         if (m_leftIsPositiveConstInt32) {
    59             var = m_right;
    60             varType = m_rightType;
    61             constInt32 = m_leftConstInt32;
    62         } else {
    63             var = m_left;
    64             varType = m_leftType;
    65             constInt32 = m_rightConstInt32;
    66         }
     53    if (m_leftOperand.isPositiveConstInt32() || m_rightOperand.isPositiveConstInt32()) {
     54        JSValueRegs var = m_leftOperand.isPositiveConstInt32() ? m_right : m_left;
     55        SnippetOperand& varOpr = m_leftOperand.isPositiveConstInt32() ? m_rightOperand : m_leftOperand;
     56        SnippetOperand& constOpr = m_leftOperand.isPositiveConstInt32() ? m_leftOperand : m_rightOperand;
    6757
    6858        // Try to do intVar * intConstant.
    6959        CCallHelpers::Jump notInt32 = jit.branchIfNotInt32(var);
    7060
    71         m_slowPathJumpList.append(jit.branchMul32(CCallHelpers::Overflow, var.payloadGPR(), CCallHelpers::Imm32(constInt32), m_scratchGPR));
     61        m_slowPathJumpList.append(jit.branchMul32(CCallHelpers::Overflow, var.payloadGPR(), CCallHelpers::Imm32(constOpr.asConstInt32()), m_scratchGPR));
    7262
    7363        jit.boxInt32(m_scratchGPR, m_result);
    … …  
    8171        // Try to do doubleVar * double(intConstant).
    8272        notInt32.link(&jit);
    83         if (!varType.definitelyIsNumber())
     73        if (!varOpr.definitelyIsNumber())
    8474            m_slowPathJumpList.append(jit.branchIfNotNumber(var, m_scratchGPR));
    8575
    8676        jit.unboxDoubleNonDestructive(var, m_leftFPR, m_scratchGPR, m_scratchFPR);
    8777
    88         jit.move(CCallHelpers::Imm32(constInt32), m_scratchGPR);
     78        jit.move(CCallHelpers::Imm32(constOpr.asConstInt32()), m_scratchGPR);
    8979        jit.convertInt32ToDouble(m_scratchGPR, m_rightFPR);
    9080
    … …  
    9282
    9383    } else {
    94         ASSERT(!m_leftIsPositiveConstInt32 && !m_rightIsPositiveConstInt32);
     84        ASSERT(!m_leftOperand.isPositiveConstInt32() && !m_rightOperand.isPositiveConstInt32());
    9585
    9686        CCallHelpers::Jump leftNotInt;
    … …  
    131121
    132122        leftNotInt.link(&jit);
    133         if (!m_leftType.definitelyIsNumber())
     123        if (!m_leftOperand.definitelyIsNumber())
    134124            m_slowPathJumpList.append(jit.branchIfNotNumber(m_left, m_scratchGPR));
    135         if (!m_rightType.definitelyIsNumber())
     125        if (!m_rightOperand.definitelyIsNumber())
    136126            m_slowPathJumpList.append(jit.branchIfNotNumber(m_right, m_scratchGPR));
    137127
    … …  
    143133
    144134        rightNotInt.link(&jit);
    145         if (!m_rightType.definitelyIsNumber())
     135        if (!m_rightOperand.definitelyIsNumber())
    146136            m_slowPathJumpList.append(jit.branchIfNotNumber(m_right, m_scratchGPR));
    147137

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

    r192632 r192842  
    3030
    3131#include "CCallHelpers.h"
    32 #include "ResultType.h"
     32#include "SnippetOperand.h"
    3333
    3434namespace JSC {
    … …  
    3636class JITMulGenerator {
    3737public:
    38     JITMulGenerator(JSValueRegs result, JSValueRegs left, JSValueRegs right,
    39         ResultType leftType, ResultType rightType, bool leftIsPositiveConstInt32, bool rightIsPositiveConstInt32,
    40         int32_t leftConstInt32, int32_t rightConstInt32, FPRReg leftFPR, FPRReg rightFPR,
    41         GPRReg scratchGPR, FPRReg scratchFPR, uint32_t* profilingCounter)
    42         : m_result(result)
     38    JITMulGenerator(SnippetOperand leftOperand, SnippetOperand rightOperand,
     39        JSValueRegs result, JSValueRegs left, JSValueRegs right,
     40        FPRReg leftFPR, FPRReg rightFPR, GPRReg scratchGPR, FPRReg scratchFPR, uint32_t* profilingCounter)
     41        : m_leftOperand(leftOperand)
     42        , m_rightOperand(rightOperand)
     43        , m_result(result)
    4344        , m_left(left)
    4445        , m_right(right)
    45         , m_leftType(leftType)
    46         , m_rightType(rightType)
    47         , m_leftIsPositiveConstInt32(leftIsPositiveConstInt32)
    48         , m_rightIsPositiveConstInt32(rightIsPositiveConstInt32)
    49         , m_leftConstInt32(leftConstInt32)
    50         , m_rightConstInt32(rightConstInt32)
    5146        , m_leftFPR(leftFPR)
    5247        , m_rightFPR(rightFPR)
    … …  
    5550        , m_profilingCounter(profilingCounter)
    5651    {
    57         ASSERT(!leftIsPositiveConstInt32 || !rightIsPositiveConstInt32);
     52        ASSERT(!m_leftOperand.isPositiveConstInt32() || !m_rightOperand.isPositiveConstInt32());
    5853    }
    5954
    … …  
    6560
    6661private:
     62    SnippetOperand m_leftOperand;
     63    SnippetOperand m_rightOperand;
    6764    JSValueRegs m_result;
    6865    JSValueRegs m_left;
    6966    JSValueRegs m_right;
    70     ResultType m_leftType;
    71     ResultType m_rightType;
    72     bool m_leftIsPositiveConstInt32;
    73     bool m_rightIsPositiveConstInt32;
    74     int32_t m_leftConstInt32;
    75     int32_t m_rightConstInt32;
    7667    FPRReg m_leftFPR;
    7768    FPRReg m_rightFPR;

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

    r192599 r192842  
    2525
    2626#include "config.h"
     27#include "JITSubGenerator.h"
    2728
    2829#if ENABLE(JIT)
    29 #include "JITSubGenerator.h"
    3030
    3131namespace JSC {
    … …  
    6161
    6262    leftNotInt.link(&jit);
    63     if (!m_leftType.definitelyIsNumber())
     63    if (!m_leftOperand.definitelyIsNumber())
    6464        m_slowPathJumpList.append(jit.branchIfNotNumber(m_left, m_scratchGPR));
    65     if (!m_rightType.definitelyIsNumber())
     65    if (!m_rightOperand.definitelyIsNumber())
    6666        m_slowPathJumpList.append(jit.branchIfNotNumber(m_right, m_scratchGPR));
    6767
    … …  
    7373
    7474    rightNotInt.link(&jit);
    75     if (!m_rightType.definitelyIsNumber())
     75    if (!m_rightOperand.definitelyIsNumber())
    7676        m_slowPathJumpList.append(jit.branchIfNotNumber(m_right, m_scratchGPR));
    7777

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

    r192632 r192842  
    3030
    3131#include "CCallHelpers.h"
    32 #include "ResultType.h"
     32#include "SnippetOperand.h"
    3333
    3434namespace JSC {
    … …  
    3636class JITSubGenerator {
    3737public:
    38     JITSubGenerator(JSValueRegs result, JSValueRegs left, JSValueRegs right,
    39         ResultType leftType, ResultType rightType, FPRReg leftFPR, FPRReg rightFPR,
    40         GPRReg scratchGPR, FPRReg scratchFPR)
    41         : m_result(result)
     38    JITSubGenerator(SnippetOperand leftOperand, SnippetOperand rightOperand,
     39        JSValueRegs result, JSValueRegs left, JSValueRegs right,
     40        FPRReg leftFPR, FPRReg rightFPR, GPRReg scratchGPR, FPRReg scratchFPR)
     41        : m_leftOperand(leftOperand)
     42        , m_rightOperand(rightOperand)
     43        , m_result(result)
    4244        , m_left(left)
    4345        , m_right(right)
    44         , m_leftType(leftType)
    45         , m_rightType(rightType)
    4646        , m_leftFPR(leftFPR)
    4747        , m_rightFPR(rightFPR)
    … …  
    5757
    5858private:
     59    SnippetOperand m_leftOperand;
     60    SnippetOperand m_rightOperand;
    5961    JSValueRegs m_result;
    6062    JSValueRegs m_left;
    6163    JSValueRegs m_right;
    62     ResultType m_leftType;
    63     ResultType m_rightType;
    6464    FPRReg m_leftFPR;
    6565    FPRReg m_rightFPR;

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

    r192836 r192842  
    5151    bool isConstInt32() const { return m_type == ConstInt32; }
    5252    bool isConstDouble() const { return m_type == ConstDouble; }
     53    bool isPositiveConstInt32() const { return isConstInt32() && asConstInt32() > 0; }
    5354
    5455    int64_t asRawBits() const { return m_val.rawBits; }
Note: See TracChangeset for help on using the changeset viewer.