Changeset 153215 in webkit for trunk/Source/JavaScriptCore/dfg/DFGAbstractState.h

Timestamp:

Jul 24, 2013, 9:02:17 PM (12 years ago)

Author:

[email protected]

Message:

fourthTier: don't insert ForceOSRExits except for inadequate coverage
​https://bugs.webkit.org/show_bug.cgi?id=117363

Source/JavaScriptCore:

Reviewed by Mark Hahnenberg.

Previously (in ​http://trac.webkit.org/changeset/151303) I made it so that we
inserted ForceOSRExits more eagerly. I now think it's better to have
contradictions execute normally and exit with full OSR exit profiling. It's
better at catching the few cases where the DFG will end up with different
types than the baseline engines.

This simplifies a bunch of code. For example it gets rid of
ConstantFoldingPhase::paintUnreachableCode().

You can think of this as a partial roll-out of r151303, except that it uses
the facilities introduced by that patch to give us run-time assertions that
check the CFA's correctness: if the CFA thought that something was a
contradiction but the code didn't exit, we'll now trap.

• dfg/DFGAbstractState.cpp:

(JSC::DFG::AbstractState::AbstractState):
(JSC::DFG::AbstractState::startExecuting):
(JSC::DFG::AbstractState::executeEffects):
(JSC::DFG::AbstractState::execute):
(JSC::DFG::AbstractState::filter):
(JSC::DFG::AbstractState::filterArrayModes):
(JSC::DFG::AbstractState::filterByValue):
(DFG):

• dfg/DFGAbstractState.h:

(AbstractState):
(JSC::DFG::AbstractState::filter):
(JSC::DFG::AbstractState::filterArrayModes):
(JSC::DFG::AbstractState::filterByValue):

• dfg/DFGCFAPhase.cpp:

(JSC::DFG::CFAPhase::performBlockCFA):

• dfg/DFGConstantFoldingPhase.cpp:

(JSC::DFG::ConstantFoldingPhase::run):
(JSC::DFG::ConstantFoldingPhase::foldConstants):
(ConstantFoldingPhase):

• dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::compile):

• ftl/FTLLowerDFGToLLVM.cpp:

(JSC::FTL::LowerDFGToLLVM::compileNode):

LayoutTests:

Reviewed by Mark Hahnenberg.

Convert this test, since this was the test originally added for
ConstantFoldingPhase::paintUnreachableCode(). I wanted to make sure that I had good coverage
for this since I am removing that method.

• fast/js/dfg-force-exit-then-sparse-conditional-constant-prop-in-loop-expected.txt:
• fast/js/script-tests/dfg-force-exit-then-sparse-conditional-constant-prop-in-loop.js:

File:

• trunk/Source/JavaScriptCore/dfg/DFGAbstractState.h (modified) (5 diffs)

trunk/Source/JavaScriptCore/dfg/DFGAbstractState.h

@@ -94 +94 @@
     };
     
-    enum ExecutionMode {
-        // If we encounter a contradiction, assume that this might just
-        // be because we haven't converged yet.
-        StillConverging,
-        
-        // If we encounter a contradition, assume that this contradiction
-        // is real and report it to the profiling infrastructure as if it
-        // happened at run time.
-        AfterConvergence,
-        
-        // Assume that there cannot be any contradictions other than
-        // ForceOSRExit because we have already cleaned the graph.
-        CleanFiltration
-    };
-    
     AbstractState(Graph&);
     
@@ -192 +177 @@
     // This is guaranteed to be equivalent to doing:
     //
-    // if (state.startExecuting(index, executionMode)) {
+    // if (state.startExecuting(index)) {
     //     state.executeEdges(index);
     //     result = state.executeEffects(index);
     // } else
     //     result = true;
-    bool execute(unsigned indexInBlock, ExecutionMode);
+    bool execute(unsigned indexInBlock);
     
     // Indicate the start of execution of the node. It resets any state in the node,
@@ -205 +190 @@
     // analysis concluded that the node can exit, you should probably set that
     // information aside prior to calling startExecuting().
-    bool startExecuting(Node*, ExecutionMode);
-    bool startExecuting(unsigned indexInBlock, ExecutionMode);
+    bool startExecuting(Node*);
+    bool startExecuting(unsigned indexInBlock);
     
     // Abstractly execute the edges of the given node. This runs filterEdgeByUse()
@@ -248 +233 @@
     
     template<typename T>
-    FiltrationResult filter(T node, const StructureSet& set, ExitKind exitKind)
-    {
-        return filter(forNode(node), set, exitKind);
+    FiltrationResult filter(T node, const StructureSet& set)
+    {
+        return filter(forNode(node), set);
     }
     
     template<typename T>
-    FiltrationResult filterArrayModes(
-        T node, ArrayModes arrayModes, ExitKind exitKind = BadIndexingType)
-    {
-        return filterArrayModes(forNode(node), arrayModes, exitKind);
+    FiltrationResult filterArrayModes(T node, ArrayModes arrayModes)
+    {
+        return filterArrayModes(forNode(node), arrayModes);
     }
     
     template<typename T>
-    FiltrationResult filter(T node, SpeculatedType type, ExitKind exitKind = BadType)
-    {
-        return filter(forNode(node), type, exitKind);
+    FiltrationResult filter(T node, SpeculatedType type)
+    {
+        return filter(forNode(node), type);
     }
     
     template<typename T>
-    FiltrationResult filterByValue(T node, JSValue value, ExitKind exitKind)
-    {
-        return filterByValue(forNode(node), value, exitKind);
-    }
-    
-    FiltrationResult filter(AbstractValue&, const StructureSet&, ExitKind);
-    FiltrationResult filterArrayModes(AbstractValue&, ArrayModes, ExitKind = BadIndexingType);
-    FiltrationResult filter(AbstractValue&, SpeculatedType, ExitKind = BadType);
-    FiltrationResult filterByValue(AbstractValue&, JSValue, ExitKind);
-    
-    void bail(ExitKind);
+    FiltrationResult filterByValue(T node, JSValue value)
+    {
+        return filterByValue(forNode(node), value);
+    }
+    
+    FiltrationResult filter(AbstractValue&, const StructureSet&);
+    FiltrationResult filterArrayModes(AbstractValue&, ArrayModes);
+    FiltrationResult filter(AbstractValue&, SpeculatedType);
+    FiltrationResult filterByValue(AbstractValue&, JSValue);
     
 private:
@@ -333 +315 @@
     BasicBlock* m_block;
     Node* m_currentNode;
-    ExecutionMode m_executionMode;
     
     bool m_haveStructures;