[turbofan] Simplify reduction if IfTrue and IfFalse and fix bugs.

test/cctest/compiler/test-control-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 "test/cctest/cctest.h"
 
 #include "src/base/bits.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/control-reducer.h"
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/node-properties-inl.h"
 
 using namespace v8::internal;
 using namespace v8::internal::compiler;
 
 static const size_t kNumLeafs = 4;
 
+enum Decision { kFalse, kUnknown, kTrue };
+
 // TODO(titzer): convert this whole file into unit tests.
 
 static int CheckInputs(Node* node, Node* i0 = NULL, Node* i1 = NULL,
                        Node* i2 = NULL) {
   int count = 3;
   if (i2 == NULL) count = 2;
   if (i1 == NULL) count = 1;
   if (i0 == NULL) count = 0;
   CHECK_EQ(count, node->InputCount());
   if (i0 != NULL) CHECK_EQ(i0, node->InputAt(0));
@@ skipping 138 matching lines @@
   }
 
   void ReduceMergeIterative(Node* expect, Node* merge) {
     p0->ReplaceInput(0, start);  // hack: parameters may be trimmed.
     Node* end = graph.NewNode(common.End(), merge);
     graph.SetEnd(end);
     ReduceGraph();
     CheckInputs(end, expect);
   }
 
-  void ReduceBranch(Node* expect, Node* branch) {
-    Node* result =
-        ControlReducer::ReduceBranchForTesting(&jsgraph, &common, branch);
-    CHECK_EQ(expect, result);
+  void ReduceBranch(Decision expected, Node* branch) {
+    Node* control = branch->InputAt(1);
+    for (Node* use : branch->uses()) {
+      if (use->opcode() == IrOpcode::kIfTrue) {
+        Node* result =
+            ControlReducer::ReduceIfNodeForTesting(&jsgraph, &common, use);
+        if (expected == kTrue) CHECK_EQ(control, result);
+        if (expected == kFalse) CHECK_EQ(IrOpcode::kDead, result->opcode());
+        if (expected == kUnknown) CHECK_EQ(use, result);
+      } else if (use->opcode() == IrOpcode::kIfFalse) {
+        Node* result =
+            ControlReducer::ReduceIfNodeForTesting(&jsgraph, &common, use);
+        if (expected == kFalse) CHECK_EQ(control, result);
+        if (expected == kTrue) CHECK_EQ(IrOpcode::kDead, result->opcode());
+        if (expected == kUnknown) CHECK_EQ(use, result);
+      } else {
+        UNREACHABLE();
+      }
+    }
   }
 
   Node* Return(Node* val, Node* effect, Node* control) {
     Node* ret = graph.NewNode(common.Return(), val, effect, control);
     end->ReplaceInput(0, ret);
     return ret;
   }
 };
 
 
@@ skipping 829 matching lines @@
     loop->ReplaceInput(1, if_true);
   }
 
   void chain(Node* control) { loop->ReplaceInput(0, control); }
 };
 
 
 TEST(CBranchReduce_none1) {
   ControlReducerTester R;
   Diamond d(R, R.p0);
-  R.ReduceBranch(d.branch, d.branch);
+  R.ReduceBranch(kUnknown, d.branch);
 }
 
 
 TEST(CBranchReduce_none2) {
   ControlReducerTester R;
   Diamond d1(R, R.p0);
   Diamond d2(R, R.p0);
   d2.chain(d1);
-  R.ReduceBranch(d2.branch, d2.branch);
+  R.ReduceBranch(kUnknown, d2.branch);
 }
 
 
 TEST(CBranchReduce_true) {
   ControlReducerTester R;
   Node* true_values[] = {
       R.one,                               R.jsgraph.Int32Constant(2),
       R.jsgraph.Int32Constant(0x7fffffff), R.jsgraph.Constant(1.0),
       R.jsgraph.Constant(22.1),            R.jsgraph.TrueConstant()};
 
   for (size_t i = 0; i < arraysize(true_values); i++) {
     Diamond d(R, true_values[i]);
-    Node* true_use = R.graph.NewNode(R.common.Merge(1), d.if_true);
-    Node* false_use = R.graph.NewNode(R.common.Merge(1), d.if_false);
-    R.ReduceBranch(R.start, d.branch);
-    CHECK_EQ(R.start, true_use->InputAt(0));
-    CHECK_EQ(IrOpcode::kDead, false_use->InputAt(0)->opcode());
-    CHECK(d.if_true->IsDead());   // replaced
-    CHECK(d.if_false->IsDead());  // replaced
+    R.ReduceBranch(kTrue, d.branch);
   }
 }
 
 
 TEST(CBranchReduce_false) {
   ControlReducerTester R;
   Node* false_values[] = {R.zero, R.jsgraph.Constant(0.0),
                           R.jsgraph.Constant(-0.0), R.jsgraph.FalseConstant()};
 
   for (size_t i = 0; i < arraysize(false_values); i++) {
     Diamond d(R, false_values[i]);
-    Node* true_use = R.graph.NewNode(R.common.Merge(1), d.if_true);
-    Node* false_use = R.graph.NewNode(R.common.Merge(1), d.if_false);
-    R.ReduceBranch(R.start, d.branch);
-    CHECK_EQ(R.start, false_use->InputAt(0));
-    CHECK_EQ(IrOpcode::kDead, true_use->InputAt(0)->opcode());
-    CHECK(d.if_true->IsDead());   // replaced
-    CHECK(d.if_false->IsDead());  // replaced
+    R.ReduceBranch(kFalse, d.branch);
   }
 }
 
 
 TEST(CDiamondReduce_true) {
   ControlReducerTester R;
   Diamond d1(R, R.one);
   R.ReduceMergeIterative(R.start, d1.merge);
 }
 
@@ skipping 261 matching lines @@
   CheckInputs(merge, rt, rf, loop);
   CheckInputs(loop, b2.if_false, loop);
 }
 
 
 TEST(CNonTermLoop_big2) {
   ControlReducerTester R;
   Branch b1(R, R.p0);
   Node* rt = R.graph.NewNode(R.common.Return(), R.one, R.start, b1.if_true);
 
-  Branch b2(R, R.zero, b1.if_false);
+  Node* loop = R.graph.NewNode(R.common.Loop(2), b1.if_false, R.start);
+  Branch b2(R, R.zero, loop);
+  loop->ReplaceInput(1, b2.if_false);
   Node* rf = R.graph.NewNode(R.common.Return(), R.zero, R.start, b2.if_true);
-  Node* loop = R.SetSelfReferences(
-      R.graph.NewNode(R.common.Loop(2), b2.if_false, R.self));
   Node* merge = R.graph.NewNode(R.common.Merge(2), rt, rf);
   R.end->ReplaceInput(0, merge);
 
   R.ReduceGraph();
 
   Node* new_merge = R.end->InputAt(0);  // old merge was reduced.
   CHECK_NE(merge, new_merge);
   CheckInputs(new_merge, rt, loop);
   CheckInputs(loop, b1.if_false, loop);
   CHECK(merge->IsDead());
@@ skipping 294 matching lines @@
 
   Node* ret = R.Return(d1.phi, R.start, d1.merge);
 
   R.ReduceGraph();  // d1 gets folded true.
 
   CheckInputs(ret, y2, R.start, R.start);
   CheckDeadDiamond(d1);
   CheckDeadDiamond(d2);
   CheckDeadDiamond(d3);
 }