[turbofan] Add support for advanced reducers.

test/unittests/compiler/graph-reducer-unittest.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/compiler/graph.h"
-#include "src/compiler/graph-reducer.h"
 #include "src/compiler/node.h"
 #include "src/compiler/operator.h"
+#include "test/unittests/compiler/graph-reducer-unittest.h"
 #include "test/unittests/test-utils.h"
-#include "testing/gmock/include/gmock/gmock.h"
 
 using testing::_;
 using testing::DefaultValue;
 using testing::Return;
 using testing::Sequence;
 using testing::StrictMock;
 
 namespace v8 {
 namespace internal {
 namespace compiler {
@@ skipping 27 matching lines @@
 static TestOperator kOpC0(kOpcodeC0, Operator::kNoWrite, "opc0", 0, 0);
 static TestOperator kOpC1(kOpcodeC1, Operator::kNoWrite, "opc1", 1, 0);
 static TestOperator kOpC2(kOpcodeC2, Operator::kNoWrite, "opc2", 2, 0);
 
 struct MockReducer : public Reducer {
   MOCK_METHOD1(Reduce, Reduction(Node*));
 };
 
 
 // Replaces all "A" operators with "B" operators without creating new nodes.
-class InPlaceABReducer : public Reducer {
+class InPlaceABReducer final : public Reducer {
  public:
-  virtual Reduction Reduce(Node* node) {
+  Reduction Reduce(Node* node) final {
     switch (node->op()->opcode()) {
       case kOpcodeA0:
         EXPECT_EQ(0, node->InputCount());
         node->set_op(&kOpB0);
         return Replace(node);
       case kOpcodeA1:
         EXPECT_EQ(1, node->InputCount());
         node->set_op(&kOpB1);
         return Replace(node);
       case kOpcodeA2:
         EXPECT_EQ(2, node->InputCount());
         node->set_op(&kOpB2);
         return Replace(node);
     }
     return NoChange();
   }
 };
 
 
 // Replaces all "A" operators with "B" operators by allocating new nodes.
-class NewABReducer : public Reducer {
+class NewABReducer final : public Reducer {
  public:
   explicit NewABReducer(Graph* graph) : graph_(graph) {}
-  virtual Reduction Reduce(Node* node) {
+
+  Reduction Reduce(Node* node) final {
     switch (node->op()->opcode()) {
       case kOpcodeA0:
         EXPECT_EQ(0, node->InputCount());
         return Replace(graph_->NewNode(&kOpB0));
       case kOpcodeA1:
         EXPECT_EQ(1, node->InputCount());
         return Replace(graph_->NewNode(&kOpB1, node->InputAt(0)));
       case kOpcodeA2:
         EXPECT_EQ(2, node->InputCount());
         return Replace(
             graph_->NewNode(&kOpB2, node->InputAt(0), node->InputAt(1)));
     }
     return NoChange();
   }
-  Graph* graph_;
+
+ private:
+  Graph* const graph_;
 };
 
 
 // Wraps all "kOpA0" nodes in "kOpB1" operators by allocating new nodes.
 class A0Wrapper final : public Reducer {
  public:
   explicit A0Wrapper(Graph* graph) : graph_(graph) {}
-  virtual Reduction Reduce(Node* node) override {
+
+  Reduction Reduce(Node* node) final {
     switch (node->op()->opcode()) {
       case kOpcodeA0:
         EXPECT_EQ(0, node->InputCount());
         return Replace(graph_->NewNode(&kOpB1, node));
     }
     return NoChange();
   }
-  Graph* graph_;
+
+ private:
+  Graph* const graph_;
 };
 
 
 // Wraps all "kOpB0" nodes in two "kOpC1" operators by allocating new nodes.
 class B0Wrapper final : public Reducer {
  public:
   explicit B0Wrapper(Graph* graph) : graph_(graph) {}
-  virtual Reduction Reduce(Node* node) override {
+
+  Reduction Reduce(Node* node) final {
     switch (node->op()->opcode()) {
       case kOpcodeB0:
         EXPECT_EQ(0, node->InputCount());
         return Replace(graph_->NewNode(&kOpC1, graph_->NewNode(&kOpC1, node)));
     }
     return NoChange();
   }
-  Graph* graph_;
+
+ private:
+  Graph* const graph_;
 };
 
 
 // Replaces all "kOpA1" nodes with the first input.
-class A1Forwarder : public Reducer {
-  virtual Reduction Reduce(Node* node) {
+class A1Forwarder final : public Reducer {
+ public:
+  Reduction Reduce(Node* node) final {
     switch (node->op()->opcode()) {
       case kOpcodeA1:
         EXPECT_EQ(1, node->InputCount());
         return Replace(node->InputAt(0));
     }
     return NoChange();
   }
 };
 
 
 // Replaces all "kOpB1" nodes with the first input.
-class B1Forwarder : public Reducer {
-  virtual Reduction Reduce(Node* node) {
+class B1Forwarder final : public Reducer {
+ public:
+  Reduction Reduce(Node* node) final {
     switch (node->op()->opcode()) {
       case kOpcodeB1:
         EXPECT_EQ(1, node->InputCount());
         return Replace(node->InputAt(0));
     }
     return NoChange();
   }
 };
 
 
 // Replaces all "B" operators with "C" operators without creating new nodes.
-class InPlaceBCReducer : public Reducer {
+class InPlaceBCReducer final : public Reducer {
  public:
-  virtual Reduction Reduce(Node* node) {
+  Reduction Reduce(Node* node) final {
     switch (node->op()->opcode()) {
       case kOpcodeB0:
         EXPECT_EQ(0, node->InputCount());
         node->set_op(&kOpC0);
         return Replace(node);
       case kOpcodeB1:
         EXPECT_EQ(1, node->InputCount());
         node->set_op(&kOpC1);
         return Replace(node);
       case kOpcodeB2:
         EXPECT_EQ(2, node->InputCount());
         node->set_op(&kOpC2);
         return Replace(node);
     }
     return NoChange();
   }
 };
 
 
 // Swaps the inputs to "kOp2A" and "kOp2B" nodes based on ids.
-class AB2Sorter : public Reducer {
-  virtual Reduction Reduce(Node* node) {
+class AB2Sorter final : public Reducer {
+ public:
+  Reduction Reduce(Node* node) final {
     switch (node->op()->opcode()) {
       case kOpcodeA2:
       case kOpcodeB2:
         EXPECT_EQ(2, node->InputCount());
         Node* x = node->InputAt(0);
         Node* y = node->InputAt(1);
         if (x->id() > y->id()) {
           node->ReplaceInput(0, y);
           node->ReplaceInput(1, x);
           return Replace(node);
         }
     }
     return NoChange();
   }
 };
 
+}  // namespace
 
-}  // namespace
+
+class AdvancedReducerTest : public TestWithZone {
+ public:
+  AdvancedReducerTest() : graph_(zone()) {}
+
+ protected:
+  Graph* graph() { return &graph_; }
+
+ private:
+  Graph graph_;
+};
+
+
+TEST_F(AdvancedReducerTest, Replace) {
+  struct DummyReducer final : public AdvancedReducer {
+    explicit DummyReducer(Editor* editor) : AdvancedReducer(editor) {}
+    Reduction Reduce(Node* node) final {
+      Replace(node, node);
+      return NoChange();
+    }
+  };
+  StrictMock<MockAdvancedReducerEditor> e;
+  DummyReducer r(&e);
+  Node* node0 = graph()->NewNode(&kOpA0);
+  Node* node1 = graph()->NewNode(&kOpA1, node0);
+  EXPECT_CALL(e, Replace(node0, node0));
+  EXPECT_CALL(e, Replace(node1, node1));
+  EXPECT_FALSE(r.Reduce(node0).Changed());
+  EXPECT_FALSE(r.Reduce(node1).Changed());
+}
+
+
+TEST_F(AdvancedReducerTest, Revisit) {
+  struct DummyReducer final : public AdvancedReducer {
+    explicit DummyReducer(Editor* editor) : AdvancedReducer(editor) {}
+    Reduction Reduce(Node* node) final {
+      Revisit(node);
+      return NoChange();
+    }
+  };
+  StrictMock<MockAdvancedReducerEditor> e;
+  DummyReducer r(&e);
+  Node* node0 = graph()->NewNode(&kOpA0);
+  Node* node1 = graph()->NewNode(&kOpA1, node0);
+  EXPECT_CALL(e, Revisit(node0));
+  EXPECT_CALL(e, Revisit(node1));
+  EXPECT_FALSE(r.Reduce(node0).Changed());
+  EXPECT_FALSE(r.Reduce(node1).Changed());
+}
 
 
 class GraphReducerTest : public TestWithZone {
  public:
   GraphReducerTest() : graph_(zone()) {}
 
   static void SetUpTestCase() {
     TestWithZone::SetUpTestCase();
     DefaultValue<Reduction>::Set(Reducer::NoChange());
   }
@@ skipping 351 matching lines @@
     EXPECT_EQ(&kOpA0, n1->op());
     EXPECT_EQ(&kOpA1, n2->op());
     EXPECT_EQ(&kOpA1, n3->op());
     EXPECT_EQ(&kOpA2, end->op());
     EXPECT_EQ(end, graph()->end());
     EXPECT_LE(end->InputAt(0)->id(), end->InputAt(1)->id());
   }
 }
 
 
+namespace {
+
 // Generate a node graph with the given permutations.
 void GenDAG(Graph* graph, int* p3, int* p2, int* p1) {
   Node* level4 = graph->NewNode(&kOpA0);
   Node* level3[] = {graph->NewNode(&kOpA1, level4),
                     graph->NewNode(&kOpA1, level4)};
 
   Node* level2[] = {graph->NewNode(&kOpA1, level3[p3[0]]),
                     graph->NewNode(&kOpA1, level3[p3[1]]),
                     graph->NewNode(&kOpA1, level3[p3[0]]),
                     graph->NewNode(&kOpA1, level3[p3[1]])};
 
   Node* level1[] = {graph->NewNode(&kOpA2, level2[p2[0]], level2[p2[1]]),
                     graph->NewNode(&kOpA2, level2[p2[2]], level2[p2[3]])};
 
   Node* end = graph->NewNode(&kOpA2, level1[p1[0]], level1[p1[1]]);
   graph->SetEnd(end);
 }
 
+}  // namespace
+
 
 TEST_F(GraphReducerTest, SortForwardReduce) {
   // Tests combined reductions on a series of DAGs.
   for (int j = 0; j < 2; j++) {
     int p3[] = {j, 1 - j};
     for (int m = 0; m < 2; m++) {
       int p1[] = {m, 1 - m};
       for (int k = 0; k < 24; k++) {  // All permutations of 0, 1, 2, 3
         int p2[] = {-1, -1, -1, -1};
         int n = k;
@@ skipping 56 matching lines @@
       }
 
       EXPECT_EQ(before, graph()->NodeCount());
       EXPECT_EQ(&kOpC0, n1->op());
       EXPECT_EQ(&kOpC1, end->op());
       EXPECT_EQ(n1, end->InputAt(0));
     }
   }
 }
 
-
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8