Be explicit about backwards propagation properties that care about escaping to byteco...
authorfpizlo@apple.com <fpizlo@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 11 Sep 2013 03:24:09 +0000 (03:24 +0000)
committerfpizlo@apple.com <fpizlo@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 11 Sep 2013 03:24:09 +0000 (03:24 +0000)
Rubber stamped by Mark Hahnenberg.

We need to care about escaping to bytecode if we're doing a lossy optimization,
i.e. the optimization means we produce less information and so we can't rescue
ourselves during OSR exit.

We only need to care about escaping within the DFG code (and can ignore what
might happen in bytecode) if we're doing an optimization that is lossless, i.e.
we can always still reconstruct the values that bytecode wants.

Example #1:

    Large int32 + int32 which overflows. We want to optimize away the overflow
    check and just do a 32-bit add.

    This is lossy; the result should have one extra bit but we simply throw
    that bit away by doing a check-less 32-bit add. Hence we need to know that
    even the bytecode wouldn't have cared about that bit. This is true in cases
    like (a + b) | 0.

Example #2:

    Larbe int32 + int32 which overflows. We want to optimize away the overflow
    check by doing a 64-bit add.

    This is lossless. We can always convert the resulting 64-bit int back to a
    double if that's what bytecode wants. Hence we only need to know that the
    DFG code won't want to do something to this value that would make 64-bit
    ints either unprofitable or unsound.

The backwards propagator's notions of flags (NodeUsedAsValue, etc) are for lossy
optimizations and so should be named in a way that reflects this. This patch
calls then NodeBytecodeUsesAsValue, etc.

* dfg/DFGAbstractInterpreterInlines.h:
(JSC::DFG::::executeEffects):
* dfg/DFGArrayMode.cpp:
(JSC::DFG::ArrayMode::refine):
* dfg/DFGBackwardsPropagationPhase.cpp:
(JSC::DFG::BackwardsPropagationPhase::mergeDefaultFlags):
(JSC::DFG::BackwardsPropagationPhase::propagate):
* dfg/DFGFixupPhase.cpp:
(JSC::DFG::FixupPhase::fixupNode):
* dfg/DFGGraph.h:
(JSC::DFG::Graph::addImmediateShouldSpeculateInt32):
* dfg/DFGNode.h:
(JSC::DFG::Node::arithNodeFlags):
* dfg/DFGNodeFlags.cpp:
(JSC::DFG::dumpNodeFlags):
* dfg/DFGNodeFlags.h:
(JSC::DFG::bytecodeUsesAsNumber):
(JSC::DFG::bytecodeCanTruncateInteger):
(JSC::DFG::bytecodeCanIgnoreNegativeZero):
(JSC::DFG::nodeMayNegZero):
(JSC::DFG::nodeCanSpeculateInt32):
* dfg/DFGPredictionPropagationPhase.cpp:
(JSC::DFG::PredictionPropagationPhase::propagate):
* dfg/DFGSpeculativeJIT.cpp:
(JSC::DFG::SpeculativeJIT::compileDoubleAsInt32):
(JSC::DFG::SpeculativeJIT::compileAdd):
(JSC::DFG::SpeculativeJIT::compileArithSub):
(JSC::DFG::SpeculativeJIT::compileArithNegate):
(JSC::DFG::SpeculativeJIT::compileArithMul):
(JSC::DFG::SpeculativeJIT::compileArithDiv):
(JSC::DFG::SpeculativeJIT::compileArithMod):
* dfg/DFGVariableAccessData.h:
(JSC::DFG::VariableAccessData::shouldUseDoubleFormatAccordingToVote):
* ftl/FTLLowerDFGToLLVM.cpp:
(JSC::FTL::LowerDFGToLLVM::compileAdd):
(JSC::FTL::LowerDFGToLLVM::compileArithSub):
(JSC::FTL::LowerDFGToLLVM::compileArithMul):
(JSC::FTL::LowerDFGToLLVM::compileArithDiv):
(JSC::FTL::LowerDFGToLLVM::compileArithMod):
(JSC::FTL::LowerDFGToLLVM::compileArithNegate):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@155497 268f45cc-cd09-0410-ab3c-d52691b4dbfc

13 files changed:
Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h
Source/JavaScriptCore/dfg/DFGArrayMode.cpp
Source/JavaScriptCore/dfg/DFGBackwardsPropagationPhase.cpp
Source/JavaScriptCore/dfg/DFGFixupPhase.cpp
Source/JavaScriptCore/dfg/DFGGraph.h
Source/JavaScriptCore/dfg/DFGNode.h
Source/JavaScriptCore/dfg/DFGNodeFlags.cpp
Source/JavaScriptCore/dfg/DFGNodeFlags.h
Source/JavaScriptCore/dfg/DFGPredictionPropagationPhase.cpp
Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
Source/JavaScriptCore/dfg/DFGVariableAccessData.h
Source/JavaScriptCore/ftl/FTLLowerDFGToLLVM.cpp

index 6f85e8a..e4b5725 100644 (file)
@@ -1,3 +1,82 @@
+2013-09-10  Filip Pizlo  <fpizlo@apple.com>
+
+        Be explicit about backwards propagation properties that care about escaping to bytecode, as opposed to just escaping within DFG code.
+
+        Rubber stamped by Mark Hahnenberg.
+        
+        We need to care about escaping to bytecode if we're doing a lossy optimization,
+        i.e. the optimization means we produce less information and so we can't rescue
+        ourselves during OSR exit.
+        
+        We only need to care about escaping within the DFG code (and can ignore what
+        might happen in bytecode) if we're doing an optimization that is lossless, i.e.
+        we can always still reconstruct the values that bytecode wants.
+        
+        Example #1:
+        
+            Large int32 + int32 which overflows. We want to optimize away the overflow
+            check and just do a 32-bit add.
+            
+            This is lossy; the result should have one extra bit but we simply throw
+            that bit away by doing a check-less 32-bit add. Hence we need to know that 
+            even the bytecode wouldn't have cared about that bit. This is true in cases
+            like (a + b) | 0.
+        
+        Example #2:
+        
+            Larbe int32 + int32 which overflows. We want to optimize away the overflow
+            check by doing a 64-bit add.
+            
+            This is lossless. We can always convert the resulting 64-bit int back to a
+            double if that's what bytecode wants. Hence we only need to know that the
+            DFG code won't want to do something to this value that would make 64-bit
+            ints either unprofitable or unsound.
+        
+        The backwards propagator's notions of flags (NodeUsedAsValue, etc) are for lossy
+        optimizations and so should be named in a way that reflects this. This patch
+        calls then NodeBytecodeUsesAsValue, etc.
+        
+        * dfg/DFGAbstractInterpreterInlines.h:
+        (JSC::DFG::::executeEffects):
+        * dfg/DFGArrayMode.cpp:
+        (JSC::DFG::ArrayMode::refine):
+        * dfg/DFGBackwardsPropagationPhase.cpp:
+        (JSC::DFG::BackwardsPropagationPhase::mergeDefaultFlags):
+        (JSC::DFG::BackwardsPropagationPhase::propagate):
+        * dfg/DFGFixupPhase.cpp:
+        (JSC::DFG::FixupPhase::fixupNode):
+        * dfg/DFGGraph.h:
+        (JSC::DFG::Graph::addImmediateShouldSpeculateInt32):
+        * dfg/DFGNode.h:
+        (JSC::DFG::Node::arithNodeFlags):
+        * dfg/DFGNodeFlags.cpp:
+        (JSC::DFG::dumpNodeFlags):
+        * dfg/DFGNodeFlags.h:
+        (JSC::DFG::bytecodeUsesAsNumber):
+        (JSC::DFG::bytecodeCanTruncateInteger):
+        (JSC::DFG::bytecodeCanIgnoreNegativeZero):
+        (JSC::DFG::nodeMayNegZero):
+        (JSC::DFG::nodeCanSpeculateInt32):
+        * dfg/DFGPredictionPropagationPhase.cpp:
+        (JSC::DFG::PredictionPropagationPhase::propagate):
+        * dfg/DFGSpeculativeJIT.cpp:
+        (JSC::DFG::SpeculativeJIT::compileDoubleAsInt32):
+        (JSC::DFG::SpeculativeJIT::compileAdd):
+        (JSC::DFG::SpeculativeJIT::compileArithSub):
+        (JSC::DFG::SpeculativeJIT::compileArithNegate):
+        (JSC::DFG::SpeculativeJIT::compileArithMul):
+        (JSC::DFG::SpeculativeJIT::compileArithDiv):
+        (JSC::DFG::SpeculativeJIT::compileArithMod):
+        * dfg/DFGVariableAccessData.h:
+        (JSC::DFG::VariableAccessData::shouldUseDoubleFormatAccordingToVote):
+        * ftl/FTLLowerDFGToLLVM.cpp:
+        (JSC::FTL::LowerDFGToLLVM::compileAdd):
+        (JSC::FTL::LowerDFGToLLVM::compileArithSub):
+        (JSC::FTL::LowerDFGToLLVM::compileArithMul):
+        (JSC::FTL::LowerDFGToLLVM::compileArithDiv):
+        (JSC::FTL::LowerDFGToLLVM::compileArithMod):
+        (JSC::FTL::LowerDFGToLLVM::compileArithNegate):
+
 2013-09-10  Chris Curtis  <chris_curtis@apple.com>
 
         WebKit crashes when trying to send a msg via 'today's birthdays' dialogue box on Facebook
index 879ca10..f0a4241 100644 (file)
@@ -334,7 +334,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
         switch (node->binaryUseKind()) {
         case Int32Use:
             forNode(node).setType(SpecInt32);
-            if (!nodeCanTruncateInteger(node->arithNodeFlags()))
+            if (!bytecodeCanTruncateInteger(node->arithNodeFlags()))
                 node->setCanExit(true);
             break;
         case NumberUse:
@@ -369,7 +369,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
         switch (node->binaryUseKind()) {
         case Int32Use:
             forNode(node).setType(SpecInt32);
-            if (!nodeCanTruncateInteger(node->arithNodeFlags()))
+            if (!bytecodeCanTruncateInteger(node->arithNodeFlags()))
                 node->setCanExit(true);
             break;
         case NumberUse:
@@ -392,7 +392,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
         switch (node->child1().useKind()) {
         case Int32Use:
             forNode(node).setType(SpecInt32);
-            if (!nodeCanTruncateInteger(node->arithNodeFlags()))
+            if (!bytecodeCanTruncateInteger(node->arithNodeFlags()))
                 node->setCanExit(true);
             break;
         case NumberUse:
@@ -416,8 +416,8 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
         switch (node->binaryUseKind()) {
         case Int32Use:
             forNode(node).setType(SpecInt32);
-            if (!nodeCanTruncateInteger(node->arithNodeFlags())
-                || !nodeCanIgnoreNegativeZero(node->arithNodeFlags()))
+            if (!bytecodeCanTruncateInteger(node->arithNodeFlags())
+                || !bytecodeCanIgnoreNegativeZero(node->arithNodeFlags()))
                 node->setCanExit(true);
             break;
         case NumberUse:
index 9ae80cd..a894a95 100644 (file)
@@ -169,14 +169,14 @@ ArrayMode ArrayMode::refine(SpeculatedType base, SpeculatedType index, Speculate
         return withTypeAndConversion(Array::Contiguous, Array::Convert);
         
     case Array::Double:
-        if (flags & NodeUsedAsInt)
+        if (flags & NodeBytecodeUsesAsInt)
             return withTypeAndConversion(Array::Contiguous, Array::RageConvert);
         if (!value || isNumberSpeculation(value))
             return *this;
         return withTypeAndConversion(Array::Contiguous, Array::Convert);
         
     case Array::Contiguous:
-        if (doesConversion() && (flags & NodeUsedAsInt))
+        if (doesConversion() && (flags & NodeBytecodeUsesAsInt))
             return withConversion(Array::RageConvert);
         return *this;
         
index effc320..a894498 100644 (file)
@@ -152,25 +152,25 @@ private:
                 childIdx < node->firstChild() + node->numChildren();
                 childIdx++) {
                 if (!!m_graph.m_varArgChildren[childIdx])
-                    changed |= m_graph.m_varArgChildren[childIdx]->mergeFlags(NodeUsedAsValue);
+                    changed |= m_graph.m_varArgChildren[childIdx]->mergeFlags(NodeBytecodeUsesAsValue);
             }
         } else {
             if (!node->child1())
                 return changed;
-            changed |= node->child1()->mergeFlags(NodeUsedAsValue);
+            changed |= node->child1()->mergeFlags(NodeBytecodeUsesAsValue);
             if (!node->child2())
                 return changed;
-            changed |= node->child2()->mergeFlags(NodeUsedAsValue);
+            changed |= node->child2()->mergeFlags(NodeBytecodeUsesAsValue);
             if (!node->child3())
                 return changed;
-            changed |= node->child3()->mergeFlags(NodeUsedAsValue);
+            changed |= node->child3()->mergeFlags(NodeBytecodeUsesAsValue);
         }
         return changed;
     }
     
     void propagate(Node* node)
     {
-        NodeFlags flags = node->flags() & NodeBackPropMask;
+        NodeFlags flags = node->flags() & NodeBytecodeBackPropMask;
         
         switch (node->op()) {
         case GetLocal: {
@@ -183,7 +183,7 @@ private:
             VariableAccessData* variableAccessData = node->variableAccessData();
             if (!variableAccessData->isLoadedFrom())
                 break;
-            node->child1()->mergeFlags(NodeUsedAsValue);
+            node->child1()->mergeFlags(NodeBytecodeUsesAsValue);
             break;
         }
             
@@ -194,23 +194,23 @@ private:
         case BitLShift:
         case BitURShift:
         case ArithIMul: {
-            flags |= NodeUsedAsInt;
-            flags &= ~(NodeUsedAsNumber | NodeNeedsNegZero | NodeUsedAsOther);
+            flags |= NodeBytecodeUsesAsInt;
+            flags &= ~(NodeBytecodeUsesAsNumber | NodeBytecodeNeedsNegZero | NodeBytecodeUsesAsOther);
             node->child1()->mergeFlags(flags);
             node->child2()->mergeFlags(flags);
             break;
         }
             
         case ValueToInt32: {
-            flags |= NodeUsedAsInt;
-            flags &= ~(NodeUsedAsNumber | NodeNeedsNegZero | NodeUsedAsOther);
+            flags |= NodeBytecodeUsesAsInt;
+            flags &= ~(NodeBytecodeUsesAsNumber | NodeBytecodeNeedsNegZero | NodeBytecodeUsesAsOther);
             node->child1()->mergeFlags(flags);
             break;
         }
             
         case StringCharCodeAt: {
-            node->child1()->mergeFlags(NodeUsedAsValue);
-            node->child2()->mergeFlags(NodeUsedAsValue | NodeUsedAsInt);
+            node->child1()->mergeFlags(NodeBytecodeUsesAsValue);
+            node->child2()->mergeFlags(NodeBytecodeUsesAsValue | NodeBytecodeUsesAsInt);
             break;
         }
             
@@ -222,13 +222,13 @@ private:
 
         case ValueAdd: {
             if (isNotNegZero(node->child1().node()) || isNotNegZero(node->child2().node()))
-                flags &= ~NodeNeedsNegZero;
+                flags &= ~NodeBytecodeNeedsNegZero;
             if (node->child1()->hasNumberResult() || node->child2()->hasNumberResult())
-                flags &= ~NodeUsedAsOther;
+                flags &= ~NodeBytecodeUsesAsOther;
             if (!isWithinPowerOfTwo<32>(node->child1()) && !isWithinPowerOfTwo<32>(node->child2()))
-                flags |= NodeUsedAsNumber;
+                flags |= NodeBytecodeUsesAsNumber;
             if (!m_allowNestedOverflowingAdditions)
-                flags |= NodeUsedAsNumber;
+                flags |= NodeBytecodeUsesAsNumber;
             
             node->child1()->mergeFlags(flags);
             node->child2()->mergeFlags(flags);
@@ -237,11 +237,11 @@ private:
             
         case ArithAdd: {
             if (isNotNegZero(node->child1().node()) || isNotNegZero(node->child2().node()))
-                flags &= ~NodeNeedsNegZero;
+                flags &= ~NodeBytecodeNeedsNegZero;
             if (!isWithinPowerOfTwo<32>(node->child1()) && !isWithinPowerOfTwo<32>(node->child2()))
-                flags |= NodeUsedAsNumber;
+                flags |= NodeBytecodeUsesAsNumber;
             if (!m_allowNestedOverflowingAdditions)
-                flags |= NodeUsedAsNumber;
+                flags |= NodeBytecodeUsesAsNumber;
             
             node->child1()->mergeFlags(flags);
             node->child2()->mergeFlags(flags);
@@ -250,11 +250,11 @@ private:
             
         case ArithSub: {
             if (isNotNegZero(node->child1().node()) || isNotPosZero(node->child2().node()))
-                flags &= ~NodeNeedsNegZero;
+                flags &= ~NodeBytecodeNeedsNegZero;
             if (!isWithinPowerOfTwo<32>(node->child1()) && !isWithinPowerOfTwo<32>(node->child2()))
-                flags |= NodeUsedAsNumber;
+                flags |= NodeBytecodeUsesAsNumber;
             if (!m_allowNestedOverflowingAdditions)
-                flags |= NodeUsedAsNumber;
+                flags |= NodeBytecodeUsesAsNumber;
             
             node->child1()->mergeFlags(flags);
             node->child2()->mergeFlags(flags);
@@ -262,7 +262,7 @@ private:
         }
             
         case ArithNegate: {
-            flags &= ~NodeUsedAsOther;
+            flags &= ~NodeBytecodeUsesAsOther;
 
             node->child1()->mergeFlags(flags);
             break;
@@ -278,12 +278,12 @@ private:
             
             if (!isWithinPowerOfTwo<22>(node->child1().node())
                 && !isWithinPowerOfTwo<22>(node->child2().node()))
-                flags |= NodeUsedAsNumber;
+                flags |= NodeBytecodeUsesAsNumber;
             
             node->mergeFlags(flags);
             
-            flags |= NodeUsedAsNumber | NodeNeedsNegZero;
-            flags &= ~NodeUsedAsOther;
+            flags |= NodeBytecodeUsesAsNumber | NodeBytecodeNeedsNegZero;
+            flags &= ~NodeBytecodeUsesAsOther;
 
             node->child1()->mergeFlags(flags);
             node->child2()->mergeFlags(flags);
@@ -291,8 +291,8 @@ private:
         }
             
         case ArithDiv: {
-            flags |= NodeUsedAsNumber | NodeNeedsNegZero;
-            flags &= ~NodeUsedAsOther;
+            flags |= NodeBytecodeUsesAsNumber | NodeBytecodeNeedsNegZero;
+            flags &= ~NodeBytecodeUsesAsOther;
 
             node->child1()->mergeFlags(flags);
             node->child2()->mergeFlags(flags);
@@ -300,8 +300,8 @@ private:
         }
             
         case ArithMod: {
-            flags |= NodeUsedAsNumber | NodeNeedsNegZero;
-            flags &= ~NodeUsedAsOther;
+            flags |= NodeBytecodeUsesAsNumber | NodeBytecodeNeedsNegZero;
+            flags &= ~NodeBytecodeUsesAsOther;
 
             node->child1()->mergeFlags(flags);
             node->child2()->mergeFlags(flags);
@@ -309,18 +309,18 @@ private:
         }
             
         case GetByVal: {
-            node->child1()->mergeFlags(NodeUsedAsValue);
-            node->child2()->mergeFlags(NodeUsedAsNumber | NodeUsedAsOther | NodeUsedAsInt);
+            node->child1()->mergeFlags(NodeBytecodeUsesAsValue);
+            node->child2()->mergeFlags(NodeBytecodeUsesAsNumber | NodeBytecodeUsesAsOther | NodeBytecodeUsesAsInt);
             break;
         }
             
         case GetMyArgumentByValSafe: {
-            node->child1()->mergeFlags(NodeUsedAsNumber | NodeUsedAsOther | NodeUsedAsInt);
+            node->child1()->mergeFlags(NodeBytecodeUsesAsNumber | NodeBytecodeUsesAsOther | NodeBytecodeUsesAsInt);
             break;
         }
             
         case NewArrayWithSize: {
-            node->child1()->mergeFlags(NodeUsedAsValue | NodeUsedAsInt);
+            node->child1()->mergeFlags(NodeBytecodeUsesAsValue | NodeBytecodeUsesAsInt);
             break;
         }
             
@@ -328,18 +328,18 @@ private:
             // Negative zero is not observable. NaN versus undefined are only observable
             // in that you would get a different exception message. So, like, whatever: we
             // claim here that NaN v. undefined is observable.
-            node->child1()->mergeFlags(NodeUsedAsInt | NodeUsedAsNumber | NodeUsedAsOther);
+            node->child1()->mergeFlags(NodeBytecodeUsesAsInt | NodeBytecodeUsesAsNumber | NodeBytecodeUsesAsOther);
             break;
         }
             
         case StringCharAt: {
-            node->child1()->mergeFlags(NodeUsedAsValue);
-            node->child2()->mergeFlags(NodeUsedAsValue | NodeUsedAsInt);
+            node->child1()->mergeFlags(NodeBytecodeUsesAsValue);
+            node->child2()->mergeFlags(NodeBytecodeUsesAsValue | NodeBytecodeUsesAsInt);
             break;
         }
             
         case ToString: {
-            node->child1()->mergeFlags(NodeUsedAsNumber | NodeUsedAsOther);
+            node->child1()->mergeFlags(NodeBytecodeUsesAsNumber | NodeBytecodeUsesAsOther);
             break;
         }
             
@@ -349,9 +349,9 @@ private:
         }
             
         case PutByVal: {
-            m_graph.varArgChild(node, 0)->mergeFlags(NodeUsedAsValue);
-            m_graph.varArgChild(node, 1)->mergeFlags(NodeUsedAsNumber | NodeUsedAsOther | NodeUsedAsInt);
-            m_graph.varArgChild(node, 2)->mergeFlags(NodeUsedAsValue);
+            m_graph.varArgChild(node, 0)->mergeFlags(NodeBytecodeUsesAsValue);
+            m_graph.varArgChild(node, 1)->mergeFlags(NodeBytecodeUsesAsNumber | NodeBytecodeUsesAsOther | NodeBytecodeUsesAsInt);
+            m_graph.varArgChild(node, 2)->mergeFlags(NodeBytecodeUsesAsValue);
             break;
         }
             
@@ -359,24 +359,24 @@ private:
             SwitchData* data = node->switchData();
             switch (data->kind) {
             case SwitchImm:
-                // We don't need NodeNeedsNegZero because if the cases are all integers
-                // then -0 and 0 are treated the same.  We don't need NodeUsedAsOther
+                // We don't need NodeBytecodeNeedsNegZero because if the cases are all integers
+                // then -0 and 0 are treated the same.  We don't need NodeBytecodeUsesAsOther
                 // because if all of the cases are integers then NaN and undefined are
                 // treated the same (i.e. they will take default).
-                node->child1()->mergeFlags(NodeUsedAsNumber | NodeUsedAsInt);
+                node->child1()->mergeFlags(NodeBytecodeUsesAsNumber | NodeBytecodeUsesAsInt);
                 break;
             case SwitchChar: {
-                // We don't need NodeNeedsNegZero because if the cases are all strings
-                // then -0 and 0 are treated the same.  We don't need NodeUsedAsOther
+                // We don't need NodeBytecodeNeedsNegZero because if the cases are all strings
+                // then -0 and 0 are treated the same.  We don't need NodeBytecodeUsesAsOther
                 // because if all of the cases are single-character strings then NaN
                 // and undefined are treated the same (i.e. they will take default).
-                node->child1()->mergeFlags(NodeUsedAsNumber);
+                node->child1()->mergeFlags(NodeBytecodeUsesAsNumber);
                 break;
             }
             case SwitchString:
-                // We don't need NodeNeedsNegZero because if the cases are all strings
+                // We don't need NodeBytecodeNeedsNegZero because if the cases are all strings
                 // then -0 and 0 are treated the same.
-                node->child1()->mergeFlags(NodeUsedAsNumber | NodeUsedAsOther);
+                node->child1()->mergeFlags(NodeBytecodeUsesAsNumber | NodeBytecodeUsesAsOther);
                 break;
             }
             break;
index e8061ed..7331848 100644 (file)
@@ -407,7 +407,7 @@ private:
                 if (arrayMode.arrayClass() == Array::OriginalArray
                     && arrayMode.speculation() == Array::InBounds
                     && m_graph.globalObjectFor(node->codeOrigin)->arrayPrototypeChainIsSane()
-                    && !(node->flags() & NodeUsedAsOther))
+                    && !(node->flags() & NodeBytecodeUsesAsOther))
                     node->setArrayMode(arrayMode.withSpeculation(Array::SaneChain));
                 break;
                 
index 4d32879..73f5dd6 100644 (file)
@@ -736,7 +736,7 @@ private:
         if (doubleImmediate < -twoToThe48 || doubleImmediate > twoToThe48)
             return DontSpeculateInt32;
         
-        return nodeCanTruncateInteger(add->arithNodeFlags()) ? SpeculateInt32AndTruncateConstants : DontSpeculateInt32;
+        return bytecodeCanTruncateInteger(add->arithNodeFlags()) ? SpeculateInt32AndTruncateConstants : DontSpeculateInt32;
     }
     
     bool mulImmediateShouldSpeculateInt32(Node* mul, Node* variable, Node* immediate)
index f863c1d..a8cde28 100644 (file)
@@ -602,7 +602,7 @@ struct Node {
         NodeFlags result = m_flags & NodeArithFlagsMask;
         if (op() == ArithMul || op() == ArithDiv || op() == ArithMod || op() == ArithNegate || op() == DoubleAsInt32)
             return result;
-        return result & ~NodeNeedsNegZero;
+        return result & ~NodeBytecodeNeedsNegZero;
     }
     
     bool hasConstantBuffer()
index 714675e..657a8df 100644 (file)
@@ -77,13 +77,13 @@ void dumpNodeFlags(PrintStream& out, NodeFlags flags)
         out.print(comma, "MightClobber");
     
     if (flags & NodeResultMask) {
-        if (!(flags & NodeUsedAsNumber) && !(flags & NodeNeedsNegZero))
+        if (!(flags & NodeBytecodeUsesAsNumber) && !(flags & NodeBytecodeNeedsNegZero))
             out.print(comma, "PureInt");
-        else if (!(flags & NodeUsedAsNumber))
+        else if (!(flags & NodeBytecodeUsesAsNumber))
             out.print(comma, "PureInt(w/ neg zero)");
-        else if (!(flags & NodeNeedsNegZero))
+        else if (!(flags & NodeBytecodeNeedsNegZero))
             out.print(comma, "PureNum");
-        if (flags & NodeUsedAsOther)
+        if (flags & NodeBytecodeUsesAsOther)
             out.print(comma, "UseAsOther");
     }
     
@@ -93,7 +93,7 @@ void dumpNodeFlags(PrintStream& out, NodeFlags flags)
     if (flags & NodeMayNegZero)
         out.print(comma, "MayNegZero");
     
-    if (flags & NodeUsedAsInt)
+    if (flags & NodeBytecodeUsesAsInt)
         out.print(comma, "UseAsInt");
     
     if (!(flags & NodeDoesNotExit))
index 0dd1da9..97a7a01 100644 (file)
@@ -37,53 +37,53 @@ namespace JSC { namespace DFG {
 
 // Entries in the NodeType enum (below) are composed of an id, a result type (possibly none)
 // and some additional informative flags (must generate, is constant, etc).
-#define NodeResultMask              0x7
-#define NodeResultJS                0x1
-#define NodeResultNumber            0x2
-#define NodeResultInt32             0x3
-#define NodeResultBoolean           0x4
-#define NodeResultStorage           0x5
+#define NodeResultMask                   0x0007
+#define NodeResultJS                     0x0001
+#define NodeResultNumber                 0x0002
+#define NodeResultInt32                  0x0003
+#define NodeResultBoolean                0x0004
+#define NodeResultStorage                0x0005
                                 
-#define NodeMustGenerate           0x08 // set on nodes that have side effects, and may not trivially be removed by DCE.
-#define NodeHasVarArgs             0x10
-#define NodeClobbersWorld          0x20
-#define NodeMightClobber           0x40
+#define NodeMustGenerate                 0x0008 // set on nodes that have side effects, and may not trivially be removed by DCE.
+#define NodeHasVarArgs                   0x0010
+#define NodeClobbersWorld                0x0020
+#define NodeMightClobber                 0x0040
                                 
-#define NodeBehaviorMask          0x180
-#define NodeMayOverflow           0x080
-#define NodeMayNegZero            0x100
+#define NodeBehaviorMask                 0x0180
+#define NodeMayOverflow                  0x0080
+#define NodeMayNegZero                   0x0100
                                 
-#define NodeBackPropMask         0x1E00
-#define NodeUseBottom            0x0000
-#define NodeUsedAsNumber         0x0200 // The result of this computation may be used in a context that observes fractional, or bigger-than-int32, results.
-#define NodeNeedsNegZero         0x0400 // The result of this computation may be used in a context that observes -0.
-#define NodeUsedAsOther          0x0800 // The result of this computation may be used in a context that distinguishes between NaN and other things (like undefined).
-#define NodeUsedAsValue          (NodeUsedAsNumber | NodeNeedsNegZero | NodeUsedAsOther)
-#define NodeUsedAsInt            0x1000 // The result of this computation is known to be used in a context that prefers, but does not require, integer values.
+#define NodeBytecodeBackPropMask         0x1E00
+#define NodeBytecodeUseBottom            0x0000
+#define NodeBytecodeUsesAsNumber         0x0200 // The result of this computation may be used in a context that observes fractional, or bigger-than-int32, results.
+#define NodeBytecodeNeedsNegZero         0x0400 // The result of this computation may be used in a context that observes -0.
+#define NodeBytecodeUsesAsOther          0x0800 // The result of this computation may be used in a context that distinguishes between NaN and other things (like undefined).
+#define NodeBytecodeUsesAsValue          (NodeBytecodeUsesAsNumber | NodeBytecodeNeedsNegZero | NodeBytecodeUsesAsOther)
+#define NodeBytecodeUsesAsInt            0x1000 // The result of this computation is known to be used in a context that prefers, but does not require, integer values.
 
-#define NodeArithFlagsMask       (NodeBehaviorMask | NodeBackPropMask)
+#define NodeArithFlagsMask               (NodeBehaviorMask | NodeBytecodeBackPropMask)
 
-#define NodeDoesNotExit          0x2000 // This flag is negated to make it natural for the default to be that a node does exit.
+#define NodeDoesNotExit                  0x2000 // This flag is negated to make it natural for the default to be that a node does exit.
 
-#define NodeRelevantToOSR        0x4000
+#define NodeRelevantToOSR                0x4000
 
-#define NodeExitsForward         0x8000
+#define NodeExitsForward                 0x8000
 
 typedef uint32_t NodeFlags;
 
-static inline bool nodeUsedAsNumber(NodeFlags flags)
+static inline bool bytecodeUsesAsNumber(NodeFlags flags)
 {
-    return !!(flags & NodeUsedAsNumber);
+    return !!(flags & NodeBytecodeUsesAsNumber);
 }
 
-static inline bool nodeCanTruncateInteger(NodeFlags flags)
+static inline bool bytecodeCanTruncateInteger(NodeFlags flags)
 {
-    return !nodeUsedAsNumber(flags);
+    return !bytecodeUsesAsNumber(flags);
 }
 
-static inline bool nodeCanIgnoreNegativeZero(NodeFlags flags)
+static inline bool bytecodeCanIgnoreNegativeZero(NodeFlags flags)
 {
-    return !(flags & NodeNeedsNegZero);
+    return !(flags & NodeBytecodeNeedsNegZero);
 }
 
 static inline bool nodeMayOverflow(NodeFlags flags)
@@ -91,13 +91,18 @@ static inline bool nodeMayOverflow(NodeFlags flags)
     return !!(flags & NodeMayOverflow);
 }
 
+static inline bool nodeMayNegZero(NodeFlags flags)
+{
+    return !!(flags & NodeMayNegZero);
+}
+
 static inline bool nodeCanSpeculateInt32(NodeFlags flags)
 {
-    if (flags & NodeMayOverflow)
-        return !nodeUsedAsNumber(flags);
+    if (nodeMayOverflow(flags))
+        return !bytecodeUsesAsNumber(flags);
     
-    if (flags & NodeMayNegZero)
-        return nodeCanIgnoreNegativeZero(flags);
+    if (nodeMayNegZero(flags))
+        return bytecodeCanIgnoreNegativeZero(flags);
     
     return true;
 }
index 49871a3..226b947 100644 (file)
@@ -427,7 +427,7 @@ private:
         
         case StringFromCharCode: {
             changed |= setPrediction(SpecString);
-            changed |= node->child1()->mergeFlags(NodeUsedAsNumber | NodeUsedAsInt);            
+            changed |= node->child1()->mergeFlags(NodeBytecodeUsesAsNumber | NodeBytecodeUsesAsInt);            
             break;
         }
         case StringCharAt:
index 828edc1..7087d76 100644 (file)
@@ -2425,7 +2425,7 @@ void SpeculativeJIT::compileDoubleAsInt32(Node* node)
     GPRReg resultGPR = result.gpr();
 
     JITCompiler::JumpList failureCases;
-    bool negZeroCheck = !nodeCanIgnoreNegativeZero(node->arithNodeFlags());
+    bool negZeroCheck = !bytecodeCanIgnoreNegativeZero(node->arithNodeFlags());
     m_jit.branchConvertDoubleToInt32(valueFPR, resultGPR, failureCases, scratchFPR, negZeroCheck);
     forwardSpeculationCheck(Overflow, JSValueRegs(), 0, failureCases, ValueRecovery::inFPR(valueFPR));
 
@@ -2929,7 +2929,7 @@ void SpeculativeJIT::compileAdd(Node* node)
             SpeculateInt32Operand op2(this, node->child2());
             GPRTemporary result(this);
 
-            if (nodeCanTruncateInteger(node->arithNodeFlags())) {
+            if (bytecodeCanTruncateInteger(node->arithNodeFlags())) {
                 m_jit.move(op2.gpr(), result.gpr());
                 m_jit.add32(Imm32(imm1), result.gpr());
             } else
@@ -2944,7 +2944,7 @@ void SpeculativeJIT::compileAdd(Node* node)
             int32_t imm2 = valueOfInt32Constant(node->child2().node());
             GPRTemporary result(this);
                 
-            if (nodeCanTruncateInteger(node->arithNodeFlags())) {
+            if (bytecodeCanTruncateInteger(node->arithNodeFlags())) {
                 m_jit.move(op1.gpr(), result.gpr());
                 m_jit.add32(Imm32(imm2), result.gpr());
             } else
@@ -2962,7 +2962,7 @@ void SpeculativeJIT::compileAdd(Node* node)
         GPRReg gpr2 = op2.gpr();
         GPRReg gprResult = result.gpr();
 
-        if (nodeCanTruncateInteger(node->arithNodeFlags())) {
+        if (bytecodeCanTruncateInteger(node->arithNodeFlags())) {
             if (gpr1 == gprResult)
                 m_jit.add32(gpr2, gprResult);
             else {
@@ -3083,7 +3083,7 @@ void SpeculativeJIT::compileArithSub(Node* node)
             int32_t imm2 = valueOfInt32Constant(node->child2().node());
             GPRTemporary result(this);
 
-            if (nodeCanTruncateInteger(node->arithNodeFlags())) {
+            if (bytecodeCanTruncateInteger(node->arithNodeFlags())) {
                 m_jit.move(op1.gpr(), result.gpr());
                 m_jit.sub32(Imm32(imm2), result.gpr());
             } else {
@@ -3105,7 +3105,7 @@ void SpeculativeJIT::compileArithSub(Node* node)
             GPRTemporary result(this);
                 
             m_jit.move(Imm32(imm1), result.gpr());
-            if (nodeCanTruncateInteger(node->arithNodeFlags()))
+            if (bytecodeCanTruncateInteger(node->arithNodeFlags()))
                 m_jit.sub32(op2.gpr(), result.gpr());
             else
                 speculationCheck(Overflow, JSValueRegs(), 0, m_jit.branchSub32(MacroAssembler::Overflow, op2.gpr(), result.gpr()));
@@ -3118,7 +3118,7 @@ void SpeculativeJIT::compileArithSub(Node* node)
         SpeculateInt32Operand op2(this, node->child2());
         GPRTemporary result(this);
 
-        if (nodeCanTruncateInteger(node->arithNodeFlags())) {
+        if (bytecodeCanTruncateInteger(node->arithNodeFlags())) {
             m_jit.move(op1.gpr(), result.gpr());
             m_jit.sub32(op2.gpr(), result.gpr());
         } else
@@ -3156,11 +3156,11 @@ void SpeculativeJIT::compileArithNegate(Node* node)
 
         m_jit.move(op1.gpr(), result.gpr());
 
-        if (nodeCanTruncateInteger(node->arithNodeFlags()))
+        if (bytecodeCanTruncateInteger(node->arithNodeFlags()))
             m_jit.neg32(result.gpr());
         else {
             speculationCheck(Overflow, JSValueRegs(), 0, m_jit.branchNeg32(MacroAssembler::Overflow, result.gpr()));
-            if (!nodeCanIgnoreNegativeZero(node->arithNodeFlags()))
+            if (!bytecodeCanIgnoreNegativeZero(node->arithNodeFlags()))
                 speculationCheck(NegativeZero, JSValueRegs(), 0, m_jit.branchTest32(MacroAssembler::Zero, result.gpr()));
         }
 
@@ -3212,7 +3212,7 @@ void SpeculativeJIT::compileArithMul(Node* node)
         // We can perform truncated multiplications if we get to this point, because if the
         // fixup phase could not prove that it would be safe, it would have turned us into
         // a double multiplication.
-        if (nodeCanTruncateInteger(node->arithNodeFlags())) {
+        if (bytecodeCanTruncateInteger(node->arithNodeFlags())) {
             m_jit.move(reg1, result.gpr());
             m_jit.mul32(reg2, result.gpr());
         } else {
@@ -3222,7 +3222,7 @@ void SpeculativeJIT::compileArithMul(Node* node)
         }
             
         // Check for negative zero, if the users of this node care about such things.
-        if (!nodeCanIgnoreNegativeZero(node->arithNodeFlags())) {
+        if (!bytecodeCanIgnoreNegativeZero(node->arithNodeFlags())) {
             MacroAssembler::Jump resultNonZero = m_jit.branchTest32(MacroAssembler::NonZero, result.gpr());
             speculationCheck(NegativeZero, JSValueRegs(), 0, m_jit.branch32(MacroAssembler::LessThan, reg1, TrustedImm32(0)));
             speculationCheck(NegativeZero, JSValueRegs(), 0, m_jit.branch32(MacroAssembler::LessThan, reg2, TrustedImm32(0)));
@@ -3286,7 +3286,7 @@ void SpeculativeJIT::compileArithDiv(Node* node)
         JITCompiler::Jump safeDenominator = m_jit.branch32(JITCompiler::Above, temp, JITCompiler::TrustedImm32(1));
     
         JITCompiler::JumpList done;
-        if (nodeUsedAsNumber(node->arithNodeFlags())) {
+        if (bytecodeUsesAsNumber(node->arithNodeFlags())) {
             speculationCheck(Overflow, JSValueRegs(), 0, m_jit.branchTest32(JITCompiler::Zero, op2GPR));
             speculationCheck(Overflow, JSValueRegs(), 0, m_jit.branch32(JITCompiler::Equal, op1GPR, TrustedImm32(-2147483647-1)));
         } else {
@@ -3314,7 +3314,7 @@ void SpeculativeJIT::compileArithDiv(Node* node)
     
         // If the user cares about negative zero, then speculate that we're not about
         // to produce negative zero.
-        if (!nodeCanIgnoreNegativeZero(node->arithNodeFlags())) {
+        if (!bytecodeCanIgnoreNegativeZero(node->arithNodeFlags())) {
             MacroAssembler::Jump numeratorNonZero = m_jit.branchTest32(MacroAssembler::NonZero, op1GPR);
             speculationCheck(NegativeZero, JSValueRegs(), 0, m_jit.branch32(MacroAssembler::LessThan, op2GPR, TrustedImm32(0)));
             numeratorNonZero.link(&m_jit);
@@ -3334,7 +3334,7 @@ void SpeculativeJIT::compileArithDiv(Node* node)
 
         // Check that there was no remainder. If there had been, then we'd be obligated to
         // produce a double result instead.
-        if (nodeUsedAsNumber(node->arithNodeFlags()))
+        if (bytecodeUsesAsNumber(node->arithNodeFlags()))
             speculationCheck(Overflow, JSValueRegs(), 0, m_jit.branchTest32(JITCompiler::NonZero, edx.gpr()));
         
         done.link(&m_jit);
@@ -3349,7 +3349,7 @@ void SpeculativeJIT::compileArithDiv(Node* node)
 
         // If the user cares about negative zero, then speculate that we're not about
         // to produce negative zero.
-        if (!nodeCanIgnoreNegativeZero(node->arithNodeFlags())) {
+        if (!bytecodeCanIgnoreNegativeZero(node->arithNodeFlags())) {
             MacroAssembler::Jump numeratorNonZero = m_jit.branchTest32(MacroAssembler::NonZero, op1GPR);
             speculationCheck(NegativeZero, JSValueRegs(), 0, m_jit.branch32(MacroAssembler::LessThan, op2GPR, TrustedImm32(0)));
             numeratorNonZero.link(&m_jit);
@@ -3359,7 +3359,7 @@ void SpeculativeJIT::compileArithDiv(Node* node)
 
         // Check that there was no remainder. If there had been, then we'd be obligated to
         // produce a double result instead.
-        if (nodeUsedAsNumber(node->arithNodeFlags())) {
+        if (bytecodeUsesAsNumber(node->arithNodeFlags())) {
             speculationCheck(Overflow, JSValueRegs(), 0, m_jit.branchMul32(JITCompiler::Overflow, quotient.gpr(), op2GPR, multiplyAnswer.gpr()));
             speculationCheck(Overflow, JSValueRegs(), 0, m_jit.branch32(JITCompiler::NotEqual, multiplyAnswer.gpr(), op1GPR));
         }
@@ -3448,7 +3448,7 @@ void SpeculativeJIT::compileArithMod(Node* node)
                 m_jit.neg32(resultGPR);
                 m_jit.add32(dividendGPR, resultGPR);
                 
-                if (!nodeCanIgnoreNegativeZero(node->arithNodeFlags())) {
+                if (!bytecodeCanIgnoreNegativeZero(node->arithNodeFlags())) {
                     // Check that we're not about to create negative zero.
                     JITCompiler::Jump numeratorPositive = m_jit.branch32(JITCompiler::GreaterThanOrEqual, dividendGPR, TrustedImm32(0));
                     speculationCheck(NegativeZero, JSValueRegs(), 0, m_jit.branchTest32(JITCompiler::Zero, resultGPR));
@@ -3485,7 +3485,7 @@ void SpeculativeJIT::compileArithMod(Node* node)
                 m_jit.move(TrustedImm32(divisor), scratchGPR);
                 m_jit.assembler().cdq();
                 m_jit.assembler().idivl_r(scratchGPR);
-                if (!nodeCanIgnoreNegativeZero(node->arithNodeFlags())) {
+                if (!bytecodeCanIgnoreNegativeZero(node->arithNodeFlags())) {
                     JITCompiler::Jump numeratorPositive = m_jit.branch32(JITCompiler::GreaterThanOrEqual, op1SaveGPR, TrustedImm32(0));
                     speculationCheck(Overflow, JSValueRegs(), 0, m_jit.branchTest32(JITCompiler::Zero, edx.gpr()));
                     numeratorPositive.link(&m_jit);
@@ -3542,7 +3542,7 @@ void SpeculativeJIT::compileArithMod(Node* node)
         
         // FIXME: -2^31 / -1 will actually yield negative zero, so we could have a
         // separate case for that. But it probably doesn't matter so much.
-        if (nodeUsedAsNumber(node->arithNodeFlags())) {
+        if (bytecodeUsesAsNumber(node->arithNodeFlags())) {
             speculationCheck(Overflow, JSValueRegs(), 0, m_jit.branchTest32(JITCompiler::Zero, op2GPR));
             speculationCheck(Overflow, JSValueRegs(), 0, m_jit.branch32(JITCompiler::Equal, op1GPR, TrustedImm32(-2147483647-1)));
         } else {
@@ -3581,7 +3581,7 @@ void SpeculativeJIT::compileArithMod(Node* node)
             unlock(op2TempGPR);
 
         // Check that we're not about to create negative zero.
-        if (!nodeCanIgnoreNegativeZero(node->arithNodeFlags())) {
+        if (!bytecodeCanIgnoreNegativeZero(node->arithNodeFlags())) {
             JITCompiler::Jump numeratorPositive = m_jit.branch32(JITCompiler::GreaterThanOrEqual, op1SaveGPR, TrustedImm32(0));
             speculationCheck(Overflow, JSValueRegs(), 0, m_jit.branchTest32(JITCompiler::Zero, edx.gpr()));
             numeratorPositive.link(&m_jit);
@@ -3608,7 +3608,7 @@ void SpeculativeJIT::compileArithMod(Node* node)
 
         // If the user cares about negative zero, then speculate that we're not about
         // to produce negative zero.
-        if (!nodeCanIgnoreNegativeZero(node->arithNodeFlags())) {
+        if (!bytecodeCanIgnoreNegativeZero(node->arithNodeFlags())) {
             // Check that we're not about to create negative zero.
             JITCompiler::Jump numeratorPositive = m_jit.branch32(JITCompiler::GreaterThanOrEqual, dividendGPR, TrustedImm32(0));
             speculationCheck(Overflow, JSValueRegs(), 0, m_jit.branchTest32(JITCompiler::Zero, quotientThenRemainderGPR));
index 5900804..a13838a 100644 (file)
@@ -249,7 +249,7 @@ public:
         
         // If the variable is known to be used as an integer, then be safe -
         // don't force it to be a double.
-        if (flags() & NodeUsedAsInt)
+        if (flags() & NodeBytecodeUsesAsInt)
             return false;
         
         // If the variable has been voted to become a double, then make it a
index ab6e37e..11c43ec 100644 (file)
@@ -636,7 +636,7 @@ private:
             LValue left = lowInt32(m_node->child1());
             LValue right = lowInt32(m_node->child2());
             
-            if (nodeCanTruncateInteger(m_node->arithNodeFlags())) {
+            if (bytecodeCanTruncateInteger(m_node->arithNodeFlags())) {
                 setInt32(m_out.add(left, right));
                 break;
             }
@@ -666,7 +666,7 @@ private:
             LValue left = lowInt32(m_node->child1());
             LValue right = lowInt32(m_node->child2());
             
-            if (nodeCanTruncateInteger(m_node->arithNodeFlags())) {
+            if (bytecodeCanTruncateInteger(m_node->arithNodeFlags())) {
                 setInt32(m_out.sub(left, right));
                 break;
             }
@@ -697,7 +697,7 @@ private:
             LValue right = lowInt32(m_node->child2());
             
             LValue result;
-            if (nodeCanTruncateInteger(m_node->arithNodeFlags()))
+            if (bytecodeCanTruncateInteger(m_node->arithNodeFlags()))
                 result = m_out.mul(left, right);
             else {
                 LValue overflowResult = m_out.mulWithOverflow32(left, right);
@@ -705,7 +705,7 @@ private:
                 result = m_out.extractValue(overflowResult, 0);
             }
             
-            if (!nodeCanIgnoreNegativeZero(m_node->arithNodeFlags())) {
+            if (!bytecodeCanIgnoreNegativeZero(m_node->arithNodeFlags())) {
                 LBasicBlock slowCase = FTL_NEW_BLOCK(m_out, ("ArithMul slow case"));
                 LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ArithMul continuation"));
                 
@@ -755,7 +755,7 @@ private:
             
             LValue neg2ToThe31 = m_out.constInt32(-2147483647-1);
             
-            if (nodeUsedAsNumber(m_node->arithNodeFlags())) {
+            if (bytecodeUsesAsNumber(m_node->arithNodeFlags())) {
                 speculate(Overflow, noValue(), 0, m_out.isZero32(denominator));
                 speculate(Overflow, noValue(), 0, m_out.equal(numerator, neg2ToThe31));
                 m_out.jump(continuation);
@@ -785,7 +785,7 @@ private:
             
             m_out.appendTo(continuation, done);
             
-            if (!nodeCanIgnoreNegativeZero(m_node->arithNodeFlags())) {
+            if (!bytecodeCanIgnoreNegativeZero(m_node->arithNodeFlags())) {
                 LBasicBlock zeroNumerator = FTL_NEW_BLOCK(m_out, ("ArithDiv zero numerator"));
                 LBasicBlock numeratorContinuation = FTL_NEW_BLOCK(m_out, ("ArithDiv numerator continuation"));
                 
@@ -803,7 +803,7 @@ private:
             
             LValue divisionResult = m_out.div(numerator, denominator);
             
-            if (nodeUsedAsNumber(m_node->arithNodeFlags())) {
+            if (bytecodeUsesAsNumber(m_node->arithNodeFlags())) {
                 speculate(
                     Overflow, noValue(), 0,
                     m_out.notEqual(m_out.mul(divisionResult, denominator), numerator));
@@ -853,7 +853,7 @@ private:
             
             // FIXME: -2^31 / -1 will actually yield negative zero, so we could have a
             // separate case for that. But it probably doesn't matter so much.
-            if (nodeUsedAsNumber(m_node->arithNodeFlags())) {
+            if (bytecodeUsesAsNumber(m_node->arithNodeFlags())) {
                 speculate(Overflow, noValue(), 0, m_out.isZero32(denominator));
                 speculate(Overflow, noValue(), 0, m_out.equal(numerator, neg2ToThe31));
                 m_out.jump(continuation);
@@ -885,7 +885,7 @@ private:
             
             LValue remainder = m_out.rem(numerator, denominator);
             
-            if (!nodeCanIgnoreNegativeZero(m_node->arithNodeFlags())) {
+            if (!bytecodeCanIgnoreNegativeZero(m_node->arithNodeFlags())) {
                 LBasicBlock negativeNumerator = FTL_NEW_BLOCK(m_out, ("ArithMod negative numerator"));
                 LBasicBlock numeratorContinuation = FTL_NEW_BLOCK(m_out, ("ArithMod numerator continuation"));
                 
@@ -1007,7 +1007,7 @@ private:
             LValue value = lowInt32(m_node->child1());
             
             LValue result;
-            if (nodeCanTruncateInteger(m_node->arithNodeFlags()))
+            if (bytecodeCanTruncateInteger(m_node->arithNodeFlags()))
                 result = m_out.neg(value);
             else {
                 // We don't have a negate-with-overflow intrinsic. Hopefully this