Ignore:
Timestamp:
Sep 10, 2013, 3:16:00 PM (12 years ago)
Author:
[email protected]
Message:

We should say Int32 when we mean Int32. Saying Integer is just weird.

Rubber stamped by Mark Hahnenberg.

  • dfg/DFGAbstractInterpreterInlines.h:

(JSC::DFG::::executeEffects):

  • dfg/DFGFixupPhase.cpp:

(JSC::DFG::FixupPhase::fixupNode):
(JSC::DFG::FixupPhase::fixupToPrimitive):
(JSC::DFG::FixupPhase::fixIntEdge):
(JSC::DFG::FixupPhase::truncateConstantsIfNecessary):
(JSC::DFG::FixupPhase::attemptToMakeIntegerAdd):

  • dfg/DFGGraph.h:

(JSC::DFG::Graph::addSpeculationMode):
(JSC::DFG::Graph::valueAddSpeculationMode):
(JSC::DFG::Graph::arithAddSpeculationMode):
(JSC::DFG::Graph::addShouldSpeculateInt32):
(JSC::DFG::Graph::mulShouldSpeculateInt32):
(JSC::DFG::Graph::negateShouldSpeculateInt32):
(JSC::DFG::Graph::addImmediateShouldSpeculateInt32):
(JSC::DFG::Graph::mulImmediateShouldSpeculateInt32):

  • dfg/DFGNode.h:

(JSC::DFG::Node::shouldSpeculateInt32):
(JSC::DFG::Node::shouldSpeculateInt32ForArithmetic):
(JSC::DFG::Node::shouldSpeculateInt32ExpectingDefined):
(JSC::DFG::Node::canSpeculateInt32):

  • dfg/DFGNodeFlags.h:

(JSC::DFG::nodeCanSpeculateInt32):

  • dfg/DFGPredictionPropagationPhase.cpp:

(JSC::DFG::PredictionPropagationPhase::propagate):
(JSC::DFG::PredictionPropagationPhase::doDoubleVoting):

  • dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::arrayify):
(JSC::DFG::GPRTemporary::GPRTemporary):
(JSC::DFG::SpeculativeJIT::compilePeepHoleIntegerBranch):
(JSC::DFG::SpeculativeJIT::compileValueToInt32):
(JSC::DFG::SpeculativeJIT::compileUInt32ToNumber):
(JSC::DFG::SpeculativeJIT::compileInt32ToDouble):
(JSC::DFG::SpeculativeJIT::compileGetByValOnIntTypedArray):
(JSC::DFG::SpeculativeJIT::compilePutByValForIntTypedArray):
(JSC::DFG::SpeculativeJIT::compileAdd):
(JSC::DFG::SpeculativeJIT::compileArithSub):
(JSC::DFG::SpeculativeJIT::compileArithNegate):
(JSC::DFG::SpeculativeJIT::compileArithIMul):
(JSC::DFG::SpeculativeJIT::compileArithMul):
(JSC::DFG::SpeculativeJIT::compileArithDiv):
(JSC::DFG::SpeculativeJIT::compileArithMod):
(JSC::DFG::SpeculativeJIT::compileNewTypedArray):
(JSC::DFG::SpeculativeJIT::speculateInt32):
(JSC::DFG::SpeculativeJIT::emitSwitchImm):

  • dfg/DFGSpeculativeJIT.h:

(JSC::DFG::SpeculateInt32Operand::SpeculateInt32Operand):
(JSC::DFG::SpeculateInt32Operand::~SpeculateInt32Operand):

  • dfg/DFGSpeculativeJIT32_64.cpp:

(JSC::DFG::SpeculativeJIT::compileIntegerCompare):
(JSC::DFG::SpeculativeJIT::compileLogicalNot):
(JSC::DFG::SpeculativeJIT::emitBranch):
(JSC::DFG::SpeculativeJIT::compile):

  • dfg/DFGSpeculativeJIT64.cpp:

(JSC::DFG::SpeculativeJIT::compileIntegerCompare):
(JSC::DFG::SpeculativeJIT::compileLogicalNot):
(JSC::DFG::SpeculativeJIT::emitBranch):
(JSC::DFG::SpeculativeJIT::compile):

  • ftl/FTLLowerDFGToLLVM.cpp:

(JSC::FTL::LowerDFGToLLVM::compileUInt32ToNumber):
(JSC::FTL::LowerDFGToLLVM::compileGetByVal):

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r155415 r155482  
    770770    }
    771771   
    772     SpeculateIntegerOperand property(this, node->child2());
     772    SpeculateInt32Operand property(this, node->child2());
    773773   
    774774    arrayify(node, base.gpr(), property.gpr());
    … …  
    11851185}
    11861186
    1187 GPRTemporary::GPRTemporary(SpeculativeJIT* jit, SpeculateIntegerOperand& op1)
     1187GPRTemporary::GPRTemporary(SpeculativeJIT* jit, SpeculateInt32Operand& op1)
    11881188    : m_jit(jit)
    11891189    , m_gpr(InvalidGPRReg)
    … …  
    11951195}
    11961196
    1197 GPRTemporary::GPRTemporary(SpeculativeJIT* jit, SpeculateIntegerOperand& op1, SpeculateIntegerOperand& op2)
     1197GPRTemporary::GPRTemporary(SpeculativeJIT* jit, SpeculateInt32Operand& op1, SpeculateInt32Operand& op2)
    11981198    : m_jit(jit)
    11991199    , m_gpr(InvalidGPRReg)
    … …  
    14811481    if (isInt32Constant(node->child1().node())) {
    14821482        int32_t imm = valueOfInt32Constant(node->child1().node());
    1483         SpeculateIntegerOperand op2(this, node->child2());
     1483        SpeculateInt32Operand op2(this, node->child2());
    14841484        branch32(condition, JITCompiler::Imm32(imm), op2.gpr(), taken);
    14851485    } else if (isInt32Constant(node->child2().node())) {
    1486         SpeculateIntegerOperand op1(this, node->child1());
     1486        SpeculateInt32Operand op1(this, node->child1());
    14871487        int32_t imm = valueOfInt32Constant(node->child2().node());
    14881488        branch32(condition, op1.gpr(), JITCompiler::Imm32(imm), taken);
    14891489    } else {
    1490         SpeculateIntegerOperand op1(this, node->child1());
    1491         SpeculateIntegerOperand op2(this, node->child2());
     1490        SpeculateInt32Operand op1(this, node->child1());
     1491        SpeculateInt32Operand op2(this, node->child2());
    14921492        branch32(condition, op1.gpr(), op2.gpr(), taken);
    14931493    }
    … …  
    22122212    switch (node->child1().useKind()) {
    22132213    case Int32Use: {
    2214         SpeculateIntegerOperand op1(this, node->child1());
     2214        SpeculateInt32Operand op1(this, node->child1());
    22152215        GPRTemporary result(this, op1);
    22162216        m_jit.move(op1.gpr(), result.gpr());
    … …  
    22232223        switch (checkGeneratedTypeForToInt32(node->child1().node())) {
    22242224        case GeneratedOperandInteger: {
    2225             SpeculateIntegerOperand op1(this, node->child1(), ManualOperandSpeculation);
     2225            SpeculateInt32Operand op1(this, node->child1(), ManualOperandSpeculation);
    22262226            GPRTemporary result(this, op1);
    22272227            m_jit.move(op1.gpr(), result.gpr());
    … …  
    23802380void SpeculativeJIT::compileUInt32ToNumber(Node* node)
    23812381{
    2382     if (!nodeCanSpeculateInteger(node->arithNodeFlags())) {
     2382    if (!nodeCanSpeculateInt32(node->arithNodeFlags())) {
    23832383        // We know that this sometimes produces doubles. So produce a double every
    23842384        // time. This at least allows subsequent code to not have weird conditionals.
    … …  
    24382438   
    24392439    if (isInt32Speculation(m_state.forNode(node->child1()).m_type)) {
    2440         SpeculateIntegerOperand op1(this, node->child1(), ManualOperandSpeculation);
     2440        SpeculateInt32Operand op1(this, node->child1(), ManualOperandSpeculation);
    24412441        FPRTemporary result(this);
    24422442        m_jit.convertInt32ToDouble(op1.gpr(), result.fpr());
    … …  
    26122612   
    26132613    ASSERT(elementSize(type) == 4 && !isSigned(type));
    2614     if (node->shouldSpeculateInteger()) {
     2614    if (node->shouldSpeculateInt32()) {
    26152615        forwardSpeculationCheck(Overflow, JSValueRegs(), 0, m_jit.branch32(MacroAssembler::LessThan, resultReg, TrustedImm32(0)), ValueRecovery::uint32InGPR(resultReg));
    26162616        integerResult(resultReg, node);
    … …  
    26582658        switch (valueUse.useKind()) {
    26592659        case Int32Use: {
    2660             SpeculateIntegerOperand valueOp(this, valueUse);
     2660            SpeculateInt32Operand valueOp(this, valueUse);
    26612661            GPRTemporary scratch(this);
    26622662            GPRReg scratchReg = scratch.gpr();
    … …  
    29272927        if (isNumberConstant(node->child1().node())) {
    29282928            int32_t imm1 = valueOfInt32Constant(node->child1().node());
    2929             SpeculateIntegerOperand op2(this, node->child2());
     2929            SpeculateInt32Operand op2(this, node->child2());
    29302930            GPRTemporary result(this);
    29312931
    … …  
    29412941               
    29422942        if (isNumberConstant(node->child2().node())) {
    2943             SpeculateIntegerOperand op1(this, node->child1());
     2943            SpeculateInt32Operand op1(this, node->child1());
    29442944            int32_t imm2 = valueOfInt32Constant(node->child2().node());
    29452945            GPRTemporary result(this);
    … …  
    29552955        }
    29562956               
    2957         SpeculateIntegerOperand op1(this, node->child1());
    2958         SpeculateIntegerOperand op2(this, node->child2());
     2957        SpeculateInt32Operand op1(this, node->child1());
     2958        SpeculateInt32Operand op2(this, node->child2());
    29592959        GPRTemporary result(this, op1, op2);
    29602960
    … …  
    30803080    case Int32Use: {
    30813081        if (isNumberConstant(node->child2().node())) {
    3082             SpeculateIntegerOperand op1(this, node->child1());
     3082            SpeculateInt32Operand op1(this, node->child1());
    30833083            int32_t imm2 = valueOfInt32Constant(node->child2().node());
    30843084            GPRTemporary result(this);
    … …  
    31023102        if (isNumberConstant(node->child1().node())) {
    31033103            int32_t imm1 = valueOfInt32Constant(node->child1().node());
    3104             SpeculateIntegerOperand op2(this, node->child2());
     3104            SpeculateInt32Operand op2(this, node->child2());
    31053105            GPRTemporary result(this);
    31063106               
    … …  
    31153115        }
    31163116           
    3117         SpeculateIntegerOperand op1(this, node->child1());
    3118         SpeculateIntegerOperand op2(this, node->child2());
     3117        SpeculateInt32Operand op1(this, node->child1());
     3118        SpeculateInt32Operand op2(this, node->child2());
    31193119        GPRTemporary result(this);
    31203120
    … …  
    31523152    switch (node->child1().useKind()) {
    31533153    case Int32Use: {
    3154         SpeculateIntegerOperand op1(this, node->child1());
     3154        SpeculateInt32Operand op1(this, node->child1());
    31553155        GPRTemporary result(this);
    31563156
    … …  
    31863186void SpeculativeJIT::compileArithIMul(Node* node)
    31873187{
    3188     SpeculateIntegerOperand op1(this, node->child1());
    3189     SpeculateIntegerOperand op2(this, node->child2());
     3188    SpeculateInt32Operand op1(this, node->child1());
     3189    SpeculateInt32Operand op2(this, node->child2());
    31903190    GPRTemporary result(this);
    31913191
    … …  
    32033203    switch (node->binaryUseKind()) {
    32043204    case Int32Use: {
    3205         SpeculateIntegerOperand op1(this, node->child1());
    3206         SpeculateIntegerOperand op2(this, node->child2());
     3205        SpeculateInt32Operand op1(this, node->child1());
     3206        SpeculateInt32Operand op2(this, node->child2());
    32073207        GPRTemporary result(this);
    32083208
    … …  
    32593259    case Int32Use: {
    32603260#if CPU(X86) || CPU(X86_64)
    3261         SpeculateIntegerOperand op1(this, node->child1());
    3262         SpeculateIntegerOperand op2(this, node->child2());
     3261        SpeculateInt32Operand op1(this, node->child1());
     3262        SpeculateInt32Operand op2(this, node->child2());
    32633263        GPRTemporary eax(this, X86Registers::eax);
    32643264        GPRTemporary edx(this, X86Registers::edx);
    … …  
    33413341        integerResult(eax.gpr(), node);
    33423342#elif CPU(APPLE_ARMV7S)
    3343         SpeculateIntegerOperand op1(this, node->child1());
    3344         SpeculateIntegerOperand op2(this, node->child2());
     3343        SpeculateInt32Operand op1(this, node->child1());
     3344        SpeculateInt32Operand op2(this, node->child2());
    33453345        GPRReg op1GPR = op1.gpr();
    33463346        GPRReg op2GPR = op2.gpr();
    … …  
    35013501#endif
    35023502
    3503         SpeculateIntegerOperand op2(this, node->child2());
     3503        SpeculateInt32Operand op2(this, node->child2());
    35043504#if CPU(X86) || CPU(X86_64)
    35053505        GPRTemporary eax(this, X86Registers::eax);
    … …  
    44834483    Structure* structure = globalObject->typedArrayStructure(type);
    44844484   
    4485     SpeculateIntegerOperand size(this, node->child1());
     4485    SpeculateInt32Operand size(this, node->child1());
    44864486    GPRReg sizeGPR = size.gpr();
    44874487   
    … …  
    45594559        return;
    45604560   
    4561     (SpeculateIntegerOperand(this, edge)).gpr();
     4561    (SpeculateInt32Operand(this, edge)).gpr();
    45624562}
    45634563
    … …  
    49144914    switch (node->child1().useKind()) {
    49154915    case Int32Use: {
    4916         SpeculateIntegerOperand value(this, node->child1());
     4916        SpeculateInt32Operand value(this, node->child1());
    49174917        GPRTemporary temp(this);
    49184918        emitSwitchIntJump(data, value.gpr(), temp.gpr());
Note: See TracChangeset for help on using the changeset viewer.