Changeset 155497 in webkit for trunk/Source/JavaScriptCore/dfg/DFGNodeFlags.h

Timestamp:

Sep 10, 2013, 8:24:09 PM (12 years ago)

Author:

[email protected]

Message:

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):

File:

• trunk/Source/JavaScriptCore/dfg/DFGNodeFlags.h (modified) (2 diffs)

trunk/Source/JavaScriptCore/dfg/DFGNodeFlags.h

@@ -38 +38 @@
 // 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);
 }
 
@@ -92 +92 @@
 }
 
+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;