Changeset 155482 in webkit for trunk/Source/JavaScriptCore/dfg/DFGGraph.h

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:

• trunk/Source/JavaScriptCore/dfg/DFGGraph.h (modified) (9 diffs)

trunk/Source/JavaScriptCore/dfg/DFGGraph.h

@@ -62 +62 @@
 
 enum AddSpeculationMode {
-    DontSpeculateInteger,
-    SpeculateIntegerAndTruncateConstants,
-    SpeculateInteger
+    DontSpeculateInt32,
+    SpeculateInt32AndTruncateConstants,
+    SpeculateInt32
 };
 
@@ -191 +191 @@
     }
     
-    AddSpeculationMode addSpeculationMode(Node* add, bool leftShouldSpeculateInteger, bool rightShouldSpeculateInteger)
+    AddSpeculationMode addSpeculationMode(Node* add, bool leftShouldSpeculateInt32, bool rightShouldSpeculateInt32)
     {
         ASSERT(add->op() == ValueAdd || add->op() == ArithAdd || add->op() == ArithSub);
@@ -199 +199 @@
         
         if (left->hasConstant())
-            return addImmediateShouldSpeculateInteger(add, rightShouldSpeculateInteger, left);
+            return addImmediateShouldSpeculateInt32(add, rightShouldSpeculateInt32, left);
         if (right->hasConstant())
-            return addImmediateShouldSpeculateInteger(add, leftShouldSpeculateInteger, right);
-        
-        return (leftShouldSpeculateInteger && rightShouldSpeculateInteger && add->canSpeculateInteger()) ? SpeculateInteger : DontSpeculateInteger;
+            return addImmediateShouldSpeculateInt32(add, leftShouldSpeculateInt32, right);
+        
+        return (leftShouldSpeculateInt32 && rightShouldSpeculateInt32 && add->canSpeculateInt32()) ? SpeculateInt32 : DontSpeculateInt32;
     }
     
     AddSpeculationMode valueAddSpeculationMode(Node* add)
     {
-        return addSpeculationMode(add, add->child1()->shouldSpeculateIntegerExpectingDefined(), add->child2()->shouldSpeculateIntegerExpectingDefined());
+        return addSpeculationMode(add, add->child1()->shouldSpeculateInt32ExpectingDefined(), add->child2()->shouldSpeculateInt32ExpectingDefined());
     }
     
     AddSpeculationMode arithAddSpeculationMode(Node* add)
     {
-        return addSpeculationMode(add, add->child1()->shouldSpeculateIntegerForArithmetic(), add->child2()->shouldSpeculateIntegerForArithmetic());
+        return addSpeculationMode(add, add->child1()->shouldSpeculateInt32ForArithmetic(), add->child2()->shouldSpeculateInt32ForArithmetic());
     }
     
@@ -224 +224 @@
     }
     
-    bool addShouldSpeculateInteger(Node* add)
-    {
-        return addSpeculationMode(add) != DontSpeculateInteger;
-    }
-    
-    bool mulShouldSpeculateInteger(Node* mul)
+    bool addShouldSpeculateInt32(Node* add)
+    {
+        return addSpeculationMode(add) != DontSpeculateInt32;
+    }
+    
+    bool mulShouldSpeculateInt32(Node* mul)
     {
         ASSERT(mul->op() == ArithMul);
@@ -236 +236 @@
         Node* right = mul->child2().node();
         
-        return Node::shouldSpeculateIntegerForArithmetic(left, right) && mul->canSpeculateInteger();
-    }
-    
-    bool negateShouldSpeculateInteger(Node* negate)
+        return Node::shouldSpeculateInt32ForArithmetic(left, right) && mul->canSpeculateInt32();
+    }
+    
+    bool negateShouldSpeculateInt32(Node* negate)
     {
         ASSERT(negate->op() == ArithNegate);
-        return negate->child1()->shouldSpeculateIntegerForArithmetic() && negate->canSpeculateInteger();
+        return negate->child1()->shouldSpeculateInt32ForArithmetic() && negate->canSpeculateInt32();
     }
     
@@ -718 +718 @@
     void addForDepthFirstSort(Vector<BasicBlock*>& result, Vector<BasicBlock*, 16>& worklist, HashSet<BasicBlock*>& seen, BasicBlock*);
     
-    AddSpeculationMode addImmediateShouldSpeculateInteger(Node* add, bool variableShouldSpeculateInteger, Node* immediate)
+    AddSpeculationMode addImmediateShouldSpeculateInt32(Node* add, bool variableShouldSpeculateInt32, Node* immediate)
     {
         ASSERT(immediate->hasConstant());
@@ -724 +724 @@
         JSValue immediateValue = immediate->valueOfJSConstant(m_codeBlock);
         if (!immediateValue.isNumber())
-            return DontSpeculateInteger;
-        
-        if (!variableShouldSpeculateInteger)
-            return DontSpeculateInteger;
+            return DontSpeculateInt32;
+        
+        if (!variableShouldSpeculateInt32)
+            return DontSpeculateInt32;
         
         if (immediateValue.isInt32())
-            return add->canSpeculateInteger() ? SpeculateInteger : DontSpeculateInteger;
+            return add->canSpeculateInt32() ? SpeculateInt32 : DontSpeculateInt32;
         
         double doubleImmediate = immediateValue.asDouble();
         const double twoToThe48 = 281474976710656.0;
         if (doubleImmediate < -twoToThe48 || doubleImmediate > twoToThe48)
-            return DontSpeculateInteger;
-        
-        return nodeCanTruncateInteger(add->arithNodeFlags()) ? SpeculateIntegerAndTruncateConstants : DontSpeculateInteger;
-    }
-    
-    bool mulImmediateShouldSpeculateInteger(Node* mul, Node* variable, Node* immediate)
+            return DontSpeculateInt32;
+        
+        return nodeCanTruncateInteger(add->arithNodeFlags()) ? SpeculateInt32AndTruncateConstants : DontSpeculateInt32;
+    }
+    
+    bool mulImmediateShouldSpeculateInt32(Node* mul, Node* variable, Node* immediate)
     {
         ASSERT(immediate->hasConstant());
@@ -748 +748 @@
             return false;
         
-        if (!variable->shouldSpeculateIntegerForArithmetic())
+        if (!variable->shouldSpeculateInt32ForArithmetic())
             return false;
         
@@ -756 +756 @@
         // rounding in a double multiplication - hence it will be equivalent to an integer
         // multiplication, if we are doing int32 truncation afterwards (which is what
-        // canSpeculateInteger() implies).
+        // canSpeculateInt32() implies).
         const int32_t twoToThe22 = 1 << 22;
         if (intImmediate <= -twoToThe22 || intImmediate >= twoToThe22)
-            return mul->canSpeculateInteger() && !nodeMayOverflow(mul->arithNodeFlags());
-
-        return mul->canSpeculateInteger();
+            return mul->canSpeculateInt32() && !nodeMayOverflow(mul->arithNodeFlags());
+
+        return mul->canSpeculateInt32();
     }
 };