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

Timestamp:

Sep 10, 2013, 9:35:16 PM (12 years ago)

Author:

[email protected]

Message:

Propagate the Int48 stuff into the prediction propagator.
​https://bugs.webkit.org/show_bug.cgi?id=121132

Reviewed by Mark Hahnenberg.

This still has no effect on codegen since Int48 still looks like a Double right now.

• bytecode/ExitKind.cpp:

(JSC::exitKindToString):

• bytecode/ExitKind.h:
• bytecode/SpeculatedType.cpp:

(JSC::speculationFromValue):

• bytecode/SpeculatedType.h:

(JSC::isMachineIntSpeculation):
(JSC::isMachineIntSpeculationExpectingDefined):
(JSC::isMachineIntSpeculationForArithmetic):

• dfg/DFGGraph.cpp:

(JSC::DFG::Graph::dump):

• dfg/DFGGraph.h:

(JSC::DFG::Graph::addShouldSpeculateMachineInt):
(JSC::DFG::Graph::mulShouldSpeculateInt32):
(JSC::DFG::Graph::mulShouldSpeculateMachineInt):
(JSC::DFG::Graph::negateShouldSpeculateMachineInt):
(JSC::DFG::Graph::hasExitSite):

• dfg/DFGNode.h:

(JSC::DFG::Node::shouldSpeculateMachineInt):
(JSC::DFG::Node::shouldSpeculateMachineIntForArithmetic):
(JSC::DFG::Node::shouldSpeculateMachineIntExpectingDefined):
(JSC::DFG::Node::canSpeculateInt48):

• dfg/DFGNodeFlags.h:

(JSC::DFG::nodeCanSpeculateInt48):

• dfg/DFGPredictionPropagationPhase.cpp:

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

File:

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

trunk/Source/JavaScriptCore/dfg/DFGGraph.h

@@ -229 +229 @@
     }
     
+    bool addShouldSpeculateMachineInt(Node* add)
+    {
+        Node* left = add->child1().node();
+        Node* right = add->child2().node();
+
+        bool speculation;
+        if (add->op() == ValueAdd)
+            speculation = Node::shouldSpeculateMachineIntExpectingDefined(left, right);
+        else
+            speculation = Node::shouldSpeculateMachineIntForArithmetic(left, right);
+
+        return speculation && !hasExitSite(add, Int48Overflow);
+    }
+    
     bool mulShouldSpeculateInt32(Node* mul)
     {
@@ -236 +250 @@
         Node* right = mul->child2().node();
         
-        return Node::shouldSpeculateInt32ForArithmetic(left, right) && mul->canSpeculateInt32();
+        return Node::shouldSpeculateInt32ForArithmetic(left, right)
+            && mul->canSpeculateInt32();
+    }
+    
+    bool mulShouldSpeculateMachineInt(Node* mul)
+    {
+        ASSERT(mul->op() == ArithMul);
+        
+        Node* left = mul->child1().node();
+        Node* right = mul->child2().node();
+
+        return Node::shouldSpeculateMachineIntForArithmetic(left, right)
+            && mul->canSpeculateInt48()
+            && !hasExitSite(mul, Int48Overflow);
     }
     
@@ -243 +270 @@
         ASSERT(negate->op() == ArithNegate);
         return negate->child1()->shouldSpeculateInt32ForArithmetic() && negate->canSpeculateInt32();
+    }
+    
+    bool negateShouldSpeculateMachineInt(Node* negate)
+    {
+        ASSERT(negate->op() == ArithNegate);
+        return negate->child1()->shouldSpeculateMachineIntForArithmetic()
+            && !hasExitSite(negate, Int48Overflow)
+            && negate->canSpeculateInt48();
     }
     
@@ -379 +414 @@
     {
         return baselineCodeBlockFor(codeOrigin)->hasExitSite(FrequentExitSite(codeOrigin.bytecodeIndex, exitKind));
+    }
+    
+    bool hasExitSite(Node* node, ExitKind exitKind)
+    {
+        return hasExitSite(node->codeOrigin, exitKind);
     }