Revert "[turbofan] Smartify the GraphReducer."

test/cctest/compiler/test-graph-reducer.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "graph-tester.h"
 #include "src/compiler/generic-node-inl.h"
 #include "src/compiler/graph-reducer.h"
 
@@ skipping 184 matching lines @@
 };
 
 
 TEST(ReduceGraphFromEnd1) {
   GraphTester graph;
 
   Node* n1 = graph.NewNode(&OPA0);
   Node* end = graph.NewNode(&OPA1, n1);
   graph.SetEnd(end);
 
-  GraphReducer reducer(&graph, graph.zone());
+  GraphReducer reducer(&graph);
   ReducerRecorder recorder(graph.zone());
   reducer.AddReducer(&recorder);
   reducer.ReduceGraph();
   recorder.CheckContains(n1);
   recorder.CheckContains(end);
 }
 
 
 TEST(ReduceGraphFromEnd2) {
   GraphTester graph;
 
   Node* n1 = graph.NewNode(&OPA0);
   Node* n2 = graph.NewNode(&OPA1, n1);
   Node* n3 = graph.NewNode(&OPA1, n1);
   Node* end = graph.NewNode(&OPA2, n2, n3);
   graph.SetEnd(end);
 
-  GraphReducer reducer(&graph, graph.zone());
+  GraphReducer reducer(&graph);
   ReducerRecorder recorder(graph.zone());
   reducer.AddReducer(&recorder);
   reducer.ReduceGraph();
   recorder.CheckContains(n1);
   recorder.CheckContains(n2);
   recorder.CheckContains(n3);
   recorder.CheckContains(end);
 }
 
 
 TEST(ReduceInPlace1) {
   GraphTester graph;
 
   Node* n1 = graph.NewNode(&OPA0);
   Node* end = graph.NewNode(&OPA1, n1);
   graph.SetEnd(end);
 
-  GraphReducer reducer(&graph, graph.zone());
+  GraphReducer reducer(&graph);
   InPlaceABReducer r;
   reducer.AddReducer(&r);
 
   // Tests A* => B* with in-place updates.
   for (int i = 0; i < 3; i++) {
     int before = graph.NodeCount();
     reducer.ReduceGraph();
     CHECK_EQ(before, graph.NodeCount());
     CHECK_EQ(&OPB0, n1->op());
     CHECK_EQ(&OPB1, end->op());
     CHECK_EQ(n1, end->InputAt(0));
   }
 }
 
 
 TEST(ReduceInPlace2) {
   GraphTester graph;
 
   Node* n1 = graph.NewNode(&OPA0);
   Node* n2 = graph.NewNode(&OPA1, n1);
   Node* n3 = graph.NewNode(&OPA1, n1);
   Node* end = graph.NewNode(&OPA2, n2, n3);
   graph.SetEnd(end);
 
-  GraphReducer reducer(&graph, graph.zone());
+  GraphReducer reducer(&graph);
   InPlaceABReducer r;
   reducer.AddReducer(&r);
 
   // Tests A* => B* with in-place updates.
   for (int i = 0; i < 3; i++) {
     int before = graph.NodeCount();
     reducer.ReduceGraph();
     CHECK_EQ(before, graph.NodeCount());
     CHECK_EQ(&OPB0, n1->op());
     CHECK_EQ(&OPB1, n2->op());
     CHECK_EQ(n1, n2->InputAt(0));
     CHECK_EQ(&OPB1, n3->op());
     CHECK_EQ(n1, n3->InputAt(0));
     CHECK_EQ(&OPB2, end->op());
     CHECK_EQ(n2, end->InputAt(0));
     CHECK_EQ(n3, end->InputAt(1));
   }
 }
 
 
 TEST(ReduceNew1) {
   GraphTester graph;
 
   Node* n1 = graph.NewNode(&OPA0);
   Node* n2 = graph.NewNode(&OPA1, n1);
   Node* n3 = graph.NewNode(&OPA1, n1);
   Node* end = graph.NewNode(&OPA2, n2, n3);
   graph.SetEnd(end);
 
-  GraphReducer reducer(&graph, graph.zone());
+  GraphReducer reducer(&graph);
   NewABReducer r(&graph);
   reducer.AddReducer(&r);
 
   // Tests A* => B* while creating new nodes.
   for (int i = 0; i < 3; i++) {
     int before = graph.NodeCount();
     reducer.ReduceGraph();
     if (i == 0) {
       CHECK_NE(before, graph.NodeCount());
     } else {
@@ skipping 16 matching lines @@
 }
 
 
 TEST(Wrapping1) {
   GraphTester graph;
 
   Node* end = graph.NewNode(&OPA0);
   graph.SetEnd(end);
   CHECK_EQ(1, graph.NodeCount());
 
-  GraphReducer reducer(&graph, graph.zone());
+  GraphReducer reducer(&graph);
   A0Wrapper r(&graph);
   reducer.AddReducer(&r);
 
   reducer.ReduceGraph();
   CHECK_EQ(2, graph.NodeCount());
 
   Node* nend = graph.end();
   CHECK_NE(end, nend);
   CHECK_EQ(&OPB1, nend->op());
   CHECK_EQ(1, nend->InputCount());
   CHECK_EQ(end, nend->InputAt(0));
 }
 
 
 TEST(Wrapping2) {
   GraphTester graph;
 
   Node* end = graph.NewNode(&OPB0);
   graph.SetEnd(end);
   CHECK_EQ(1, graph.NodeCount());
 
-  GraphReducer reducer(&graph, graph.zone());
+  GraphReducer reducer(&graph);
   B0Wrapper r(&graph);
   reducer.AddReducer(&r);
 
   reducer.ReduceGraph();
   CHECK_EQ(3, graph.NodeCount());
 
   Node* nend = graph.end();
   CHECK_NE(end, nend);
   CHECK_EQ(&OPC1, nend->op());
   CHECK_EQ(1, nend->InputCount());
 
   Node* n1 = nend->InputAt(0);
   CHECK_NE(end, n1);
   CHECK_EQ(&OPC1, n1->op());
   CHECK_EQ(1, n1->InputCount());
   CHECK_EQ(end, n1->InputAt(0));
 }
 
 
 TEST(Forwarding1) {
   GraphTester graph;
 
   Node* n1 = graph.NewNode(&OPA0);
   Node* end = graph.NewNode(&OPA1, n1);
   graph.SetEnd(end);
 
-  GraphReducer reducer(&graph, graph.zone());
+  GraphReducer reducer(&graph);
   A1Forwarder r;
   reducer.AddReducer(&r);
 
   // Tests A1(x) => x
   for (int i = 0; i < 3; i++) {
     int before = graph.NodeCount();
     reducer.ReduceGraph();
     CHECK_EQ(before, graph.NodeCount());
     CHECK_EQ(&OPA0, n1->op());
     CHECK_EQ(n1, graph.end());
   }
 }
 
 
 TEST(Forwarding2) {
   GraphTester graph;
 
   Node* n1 = graph.NewNode(&OPA0);
   Node* n2 = graph.NewNode(&OPA1, n1);
   Node* n3 = graph.NewNode(&OPA1, n1);
   Node* end = graph.NewNode(&OPA2, n2, n3);
   graph.SetEnd(end);
 
-  GraphReducer reducer(&graph, graph.zone());
+  GraphReducer reducer(&graph);
   A1Forwarder r;
   reducer.AddReducer(&r);
 
   // Tests reducing A2(A1(x), A1(y)) => A2(x, y).
   for (int i = 0; i < 3; i++) {
     int before = graph.NodeCount();
     reducer.ReduceGraph();
     CHECK_EQ(before, graph.NodeCount());
     CHECK_EQ(&OPA0, n1->op());
     CHECK_EQ(n1, end->InputAt(0));
@@ skipping 10 matching lines @@
   for (int i = 0; i < 8; i++) {
     GraphTester graph;
 
     Node* n1 = graph.NewNode(&OPA0);
     Node* end = n1;
     for (int j = 0; j < i; j++) {
       end = graph.NewNode(&OPA1, end);
     }
     graph.SetEnd(end);
 
-    GraphReducer reducer(&graph, graph.zone());
+    GraphReducer reducer(&graph);
     A1Forwarder r;
     reducer.AddReducer(&r);
 
     for (int i = 0; i < 3; i++) {
       int before = graph.NodeCount();
       reducer.ReduceGraph();
       CHECK_EQ(before, graph.NodeCount());
       CHECK_EQ(&OPA0, n1->op());
       CHECK_EQ(n1, graph.end());
     }
   }
 }
 
 
 TEST(ReduceForward1) {
   GraphTester graph;
 
   Node* n1 = graph.NewNode(&OPA0);
   Node* n2 = graph.NewNode(&OPA1, n1);
   Node* n3 = graph.NewNode(&OPA1, n1);
   Node* end = graph.NewNode(&OPA2, n2, n3);
   graph.SetEnd(end);
 
-  GraphReducer reducer(&graph, graph.zone());
+  GraphReducer reducer(&graph);
   InPlaceABReducer r;
   B1Forwarder f;
   reducer.AddReducer(&r);
   reducer.AddReducer(&f);
 
   // Tests first reducing A => B, then B1(x) => x.
   for (int i = 0; i < 3; i++) {
     int before = graph.NodeCount();
     reducer.ReduceGraph();
     CHECK_EQ(before, graph.NodeCount());
@@ skipping 22 matching lines @@
 
     if (i == 0) end = graph.NewNode(&OPA2, n2, n3);
     if (i == 1) end = graph.NewNode(&OPA2, n3, n2);
     if (i == 2) end = graph.NewNode(&OPA2, n2, n1);
     if (i == 3) end = graph.NewNode(&OPA2, n1, n2);
     if (i == 4) end = graph.NewNode(&OPA2, n3, n1);
     if (i == 5) end = graph.NewNode(&OPA2, n1, n3);
 
     graph.SetEnd(end);
 
-    GraphReducer reducer(&graph, graph.zone());
+    GraphReducer reducer(&graph);
     reducer.AddReducer(&r);
 
     int before = graph.NodeCount();
     reducer.ReduceGraph();
     CHECK_EQ(before, graph.NodeCount());
     CHECK_EQ(&OPA0, n1->op());
     CHECK_EQ(&OPA1, n2->op());
     CHECK_EQ(&OPA1, n3->op());
     CHECK_EQ(&OPA2, end->op());
     CHECK_EQ(end, graph.end());
@@ skipping 38 matching lines @@
             if (p2[z] == -1) {
               if (p == 0) p2[z] = d - 1;
               p--;
             }
           }
           n = n / d;
         }
 
         GenDAG(&graph, p3, p2, p1);
 
-        GraphReducer reducer(&graph, graph.zone());
+        GraphReducer reducer(&graph);
         AB2Sorter r1;
         A1Forwarder r2;
         InPlaceABReducer r3;
         reducer.AddReducer(&r1);
         reducer.AddReducer(&r2);
         reducer.AddReducer(&r3);
 
         reducer.ReduceGraph();
 
         Node* end = graph.end();
@@ skipping 18 matching lines @@
 TEST(Order) {
   // Test that the order of reducers doesn't matter, as they should be
   // rerun for changed nodes.
   for (int i = 0; i < 2; i++) {
     GraphTester graph;
 
     Node* n1 = graph.NewNode(&OPA0);
     Node* end = graph.NewNode(&OPA1, n1);
     graph.SetEnd(end);
 
-    GraphReducer reducer(&graph, graph.zone());
+    GraphReducer reducer(&graph);
     InPlaceABReducer abr;
     InPlaceBCReducer bcr;
     if (i == 0) {
       reducer.AddReducer(&abr);
       reducer.AddReducer(&bcr);
     } else {
       reducer.AddReducer(&bcr);
       reducer.AddReducer(&abr);
     }
 
     // Tests A* => C* with in-place updates.
     for (int i = 0; i < 3; i++) {
       int before = graph.NodeCount();
       reducer.ReduceGraph();
       CHECK_EQ(before, graph.NodeCount());
       CHECK_EQ(&OPC0, n1->op());
       CHECK_EQ(&OPC1, end->op());
       CHECK_EQ(n1, end->InputAt(0));
     }
   }
 }