[turbofan] Remove the JSGraph dependency from the ControlFlowOptimizer.

The control flow optimization should work independent of the JSGraph. We
used the JSGraph there because it was convinient, not because it was
necessary.

R=jarin@chromium.org

Review URL: https://codereview.chromium.org/1160863003

Cr-Commit-Position: refs/heads/master@{#28674}

src/compiler/control-flow-optimizer.cc

@@ -4,7 +4,8 @@
 
 #include "src/compiler/control-flow-optimizer.h"
 
-#include "src/compiler/js-graph.h"
+#include "src/compiler/common-operator.h"
+#include "src/compiler/graph.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
 
@@ -12,10 +13,15 @@ namespace v8 {
 namespace internal {
 namespace compiler {
 
-ControlFlowOptimizer::ControlFlowOptimizer(JSGraph* jsgraph, Zone* zone)
-    : jsgraph_(jsgraph),
+ControlFlowOptimizer::ControlFlowOptimizer(Graph* graph,
+                                           CommonOperatorBuilder* common,
+                                           MachineOperatorBuilder* machine,
+                                           Zone* zone)
+    : graph_(graph),
+      common_(common),
+      machine_(machine),
       queue_(zone),
-      queued_(jsgraph->graph(), 2),
+      queued_(graph, 2),
       zone_(zone) {}
 
 
@@ -267,19 +273,6 @@ bool ControlFlowOptimizer::TryBuildSwitch(Node* node) {
   return true;
 }
 
-
-CommonOperatorBuilder* ControlFlowOptimizer::common() const {
-  return jsgraph()->common();
-}
-
-
-Graph* ControlFlowOptimizer::graph() const { return jsgraph()->graph(); }
-
-
-MachineOperatorBuilder* ControlFlowOptimizer::machine() const {
-  return jsgraph()->machine();
-}
-
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8

src/compiler/control-flow-optimizer.h

@@ -15,14 +15,14 @@ namespace compiler {
 // Forward declarations.
 class CommonOperatorBuilder;
 class Graph;
-class JSGraph;
 class MachineOperatorBuilder;
 class Node;
 
 
 class ControlFlowOptimizer final {
  public:
-  ControlFlowOptimizer(JSGraph* jsgraph, Zone* zone);
+  ControlFlowOptimizer(Graph* graph, CommonOperatorBuilder* common,
+                       MachineOperatorBuilder* machine, Zone* zone);
 
   void Optimize();
 
@@ -34,13 +34,14 @@ class ControlFlowOptimizer final {
   bool TryBuildSwitch(Node* node);
   bool TryCloneBranch(Node* node);
 
-  CommonOperatorBuilder* common() const;
-  Graph* graph() const;
-  JSGraph* jsgraph() const { return jsgraph_; }
-  MachineOperatorBuilder* machine() const;
+  Graph* graph() const { return graph_; }
+  CommonOperatorBuilder* common() const { return common_; }
+  MachineOperatorBuilder* machine() const { return machine_; }
   Zone* zone() const { return zone_; }
 
-  JSGraph* const jsgraph_;
+  Graph* const graph_;
+  CommonOperatorBuilder* const common_;
+  MachineOperatorBuilder* const machine_;
   ZoneQueue<Node*> queue_;
   NodeMarker<bool> queued_;
   Zone* const zone_;

src/compiler/pipeline.cc

@@ -602,7 +602,8 @@ struct ControlFlowOptimizationPhase {
   static const char* phase_name() { return "control flow optimization"; }
 
   void Run(PipelineData* data, Zone* temp_zone) {
-    ControlFlowOptimizer optimizer(data->jsgraph(), temp_zone);
+    ControlFlowOptimizer optimizer(data->graph(), data->common(),
+                                   data->machine(), temp_zone);
     optimizer.Optimize();
   }
 };

test/unittests/compiler/control-flow-optimizer-unittest.cc

@@ -3,7 +3,6 @@
 // found in the LICENSE file.
 
 #include "src/compiler/control-flow-optimizer.h"
-#include "src/compiler/js-graph.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/machine-operator.h"
 #include "test/unittests/compiler/graph-unittest.h"
@@ -21,28 +20,21 @@ namespace compiler {
 class ControlFlowOptimizerTest : public GraphTest {
  public:
   explicit ControlFlowOptimizerTest(int num_parameters = 3)
-      : GraphTest(num_parameters),
-        machine_(zone()),
-        javascript_(zone()),
-        jsgraph_(isolate(), graph(), common(), javascript(), machine()) {}
+      : GraphTest(num_parameters), machine_(zone()), javascript_(zone()) {}
   ~ControlFlowOptimizerTest() override {}
 
  protected:
   void Optimize() {
-    ControlFlowOptimizer optimizer(jsgraph(), zone());
+    ControlFlowOptimizer optimizer(graph(), common(), machine(), zone());
     optimizer.Optimize();
   }
 
-  Node* EmptyFrameState() { return jsgraph()->EmptyFrameState(); }
-
-  JSGraph* jsgraph() { return &jsgraph_; }
   JSOperatorBuilder* javascript() { return &javascript_; }
   MachineOperatorBuilder* machine() { return &machine_; }
 
  private:
   MachineOperatorBuilder machine_;
   JSOperatorBuilder javascript_;
-  JSGraph jsgraph_;
 };
 
 
@@ -77,7 +69,7 @@ TEST_F(ControlFlowOptimizerTest, BuildSwitch2) {
   Node* input = Parameter(0);
   Node* context = Parameter(1);
   Node* index = graph()->NewNode(javascript()->ToNumber(), input, context,
-                                 EmptyFrameState(), start(), start());
+                                 start(), start(), start());
   Node* if_success = graph()->NewNode(common()->IfSuccess(), index);
   Node* branch0 = graph()->NewNode(
       common()->Branch(),

test/unittests/compiler/graph-unittest.cc

@@ -81,6 +81,16 @@ Node* GraphTest::UndefinedConstant() {
 }
 
 
+Node* GraphTest::EmptyFrameState() {
+  Node* state_values = graph()->NewNode(common()->StateValues(0));
+  return graph()->NewNode(
+      common()->FrameState(JS_FRAME, BailoutId::None(),
+                           OutputFrameStateCombine::Ignore()),
+      state_values, state_values, state_values, NumberConstant(0),
+      UndefinedConstant(), graph()->start());
+}
+
+
 Matcher<Node*> GraphTest::IsFalseConstant() {
   return IsHeapConstant(
       Unique<HeapObject>::CreateImmovable(factory()->false_value()));

test/unittests/compiler/graph-unittest.h

@@ -50,6 +50,8 @@ class GraphTest : public TestWithContext, public TestWithIsolateAndZone {
   Node* TrueConstant();
   Node* UndefinedConstant();
 
+  Node* EmptyFrameState();
+
   Matcher<Node*> IsFalseConstant();
   Matcher<Node*> IsTrueConstant();
   Matcher<Node*> IsUndefinedConstant();