[turbofan] Remove another ineffective optimization from the ControlReducer.

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/all-nodes.h"
 #include "src/compiler/common-operator.h"
@@ skipping 884 matching lines @@
   ControlReducerTester R;
   Diamond d1(R, R.p0);
   Diamond d2(R, R.p0);
   d2.chain(d1);
   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()};
-
+  Node* true_values[] = {R.jsgraph.Int32Constant(2),
+                         R.jsgraph.Int64Constant(0x7fffffff),
+                         R.jsgraph.TrueConstant()};
   for (size_t i = 0; i < arraysize(true_values); i++) {
     Diamond d(R, true_values[i]);
     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()};
-
+  Node* false_values[] = {R.jsgraph.Int32Constant(0),
+                          R.jsgraph.Int64Constant(0),
+                          R.jsgraph.FalseConstant()};
   for (size_t i = 0; i < arraysize(false_values); i++) {
     Diamond d(R, false_values[i]);
     R.ReduceBranch(kFalse, d.branch);
   }
 }
 
 
 TEST(CDiamondReduce_true) {
   ControlReducerTester R;
-  Diamond d1(R, R.one);
+  Diamond d1(R, R.jsgraph.TrueConstant());
   R.ReduceMergeIterative(R.start, d1.merge);
 }
 
 
 TEST(CDiamondReduce_false) {
   ControlReducerTester R;
-  Diamond d2(R, R.zero);
+  Diamond d2(R, R.jsgraph.FalseConstant());
   R.ReduceMergeIterative(R.start, d2.merge);
 }
 
 
 TEST(CChainedDiamondsReduce_true_false) {
   ControlReducerTester R;
-  Diamond d1(R, R.one);
-  Diamond d2(R, R.zero);
+  Diamond d1(R, R.jsgraph.TrueConstant());
+  Diamond d2(R, R.jsgraph.FalseConstant());
   d2.chain(d1);
 
   R.ReduceMergeIterative(R.start, d2.merge);
 }
 
 
 TEST(CChainedDiamondsReduce_x_false) {
   ControlReducerTester R;
   Diamond d1(R, R.p0);
-  Diamond d2(R, R.zero);
+  Diamond d2(R, R.jsgraph.FalseConstant());
   d2.chain(d1);
 
   R.ReduceMergeIterative(R.start, d2.merge);
 }
 
 
 TEST(CChainedDiamondsReduce_false_x) {
   ControlReducerTester R;
   Diamond d1(R, R.zero);
   Diamond d2(R, R.p0);
   d2.chain(d1);
 
   R.ReduceMergeIterative(R.start, d2.merge);
 }
 
 
 TEST(CChainedDiamondsReduce_phi1) {
   ControlReducerTester R;
   Diamond d1(R, R.zero, R.one, R.zero);  // foldable branch, phi.
   Diamond d2(R, d1.phi);
   d2.chain(d1);
 
   R.ReduceMergeIterative(R.start, d2.merge);
 }
 
 
 TEST(CChainedDiamondsReduce_phi2) {
   ControlReducerTester R;
-  Diamond d1(R, R.p0, R.one, R.one);  // redundant phi.
+  Diamond d1(R, R.p0, R.jsgraph.TrueConstant(),
+             R.jsgraph.TrueConstant());  // redundant phi.
   Diamond d2(R, d1.phi);
   d2.chain(d1);
 
   R.ReduceMergeIterative(d1.merge, d2.merge);
 }
 
 
 TEST(CNestedDiamondsReduce_true_true_false) {
   ControlReducerTester R;
-  Diamond d1(R, R.one);
-  Diamond d2(R, R.zero);
+  Diamond d1(R, R.jsgraph.TrueConstant());
+  Diamond d2(R, R.jsgraph.FalseConstant());
   d2.nest(d1, true);
 
   R.ReduceMergeIterative(R.start, d1.merge);
 }
 
 
 TEST(CNestedDiamondsReduce_false_true_false) {
   ControlReducerTester R;
-  Diamond d1(R, R.one);
-  Diamond d2(R, R.zero);
+  Diamond d1(R, R.jsgraph.TrueConstant());
+  Diamond d2(R, R.jsgraph.FalseConstant());
   d2.nest(d1, false);
 
   R.ReduceMergeIterative(R.start, d1.merge);
 }
 
 
 TEST(CNestedDiamonds_xyz) {
   ControlReducerTester R;
 
   for (int a = 0; a < 2; a++) {
@@ skipping 53 matching lines @@
   ControlReducerTester R;
   Node* ret = R.Return(R.one, R.start, R.start);
   R.ReduceGraph();
   CheckInputs(R.graph.end(), ret);
   CheckInputs(ret, R.one, R.start, R.start);
 }
 
 
 TEST(Return2) {
   ControlReducerTester R;
-  Diamond d(R, R.one);
+  Diamond d(R, R.jsgraph.TrueConstant());
   Node* ret = R.Return(R.half, R.start, d.merge);
   R.ReduceGraph();
 
   DeadChecker dead(&R.graph);
   dead.Check(d.branch);
   dead.Check(d.if_true);
   dead.Check(d.if_false);
   dead.Check(d.merge);
 
   CheckInputs(R.graph.end(), ret);
   CheckInputs(ret, R.half, R.start, R.start);
 }
 
 
 TEST(Return_true1) {
   ControlReducerTester R;
-  Diamond d(R, R.one, R.half, R.zero);
+  Diamond d(R, R.jsgraph.TrueConstant(), R.half, R.zero);
   Node* ret = R.Return(d.phi, R.start, d.merge);
   R.ReduceGraph();
 
   DeadChecker dead(&R.graph);
   dead.Check(d.branch);
   dead.Check(d.if_true);
   dead.Check(d.if_false);
   dead.Check(d.merge);
   dead.Check(d.phi);
 
   CheckInputs(R.graph.end(), ret);
   CheckInputs(ret, R.half, R.start, R.start);
 }
 
 
 TEST(Return_false1) {
   ControlReducerTester R;
-  Diamond d(R, R.zero, R.one, R.half);
+  Diamond d(R, R.jsgraph.FalseConstant(), R.one, R.half);
   Node* ret = R.Return(d.phi, R.start, d.merge);
   R.ReduceGraph();
 
   DeadChecker dead(&R.graph);
   dead.Check(d.branch);
   dead.Check(d.if_true);
   dead.Check(d.if_false);
   dead.Check(d.merge);
   dead.Check(d.phi);
 
   CheckInputs(R.graph.end(), ret);
   CheckInputs(ret, R.half, R.start, R.start);
 }
 
 
 TEST(Return_effect1) {
   ControlReducerTester R;
-  Diamond d(R, R.one);
+  Diamond d(R, R.jsgraph.TrueConstant());
   Node* e1 = R.jsgraph.Float64Constant(-100.1);
   Node* e2 = R.jsgraph.Float64Constant(+100.1);
   Node* effect = R.graph.NewNode(R.common.EffectPhi(2), e1, e2, d.merge);
   Node* ret = R.Return(R.p0, effect, d.merge);
   R.ReduceGraph();
 
   DeadChecker dead(&R.graph);
   dead.Check(d);
   dead.Check(effect);
 
@@ skipping 67 matching lines @@
 
   DeadChecker dead(&R.graph);
   dead.Check(d2);
   dead.Check(d3);
 }
 
 
 TEST(Return_nested_diamonds_true1) {
   ControlReducerTester R;
   Diamond d2(R, R.p0, R.one, R.zero);
-  Diamond d1(R, R.one, d2.phi, R.zero);
+  Diamond d1(R, R.jsgraph.TrueConstant(), d2.phi, R.zero);
   Diamond d3(R, R.p0);
 
   d2.nest(d1, true);
   d3.nest(d1, false);
 
   Node* ret = R.Return(d1.phi, R.start, d1.merge);
 
   R.ReduceGraph();  // d1 gets folded true.
 
   CheckInputs(ret, d2.phi, R.start, d2.merge);
@@ skipping 24 matching lines @@
 
   DeadChecker dead(&R.graph);
   dead.Check(d1);
   dead.Check(d2);
   dead.CheckLive(d3);
 }
 
 
 TEST(Return_nested_diamonds_true_true1) {
   ControlReducerTester R;
-  Diamond d1(R, R.one, R.one, R.zero);
-  Diamond d2(R, R.one);
+  Diamond d1(R, R.jsgraph.TrueConstant(), R.one, R.zero);
+  Diamond d2(R, R.jsgraph.TrueConstant());
   Diamond d3(R, R.p0);
 
   d2.nest(d1, true);
   d3.nest(d1, false);
 
   Node* ret = R.Return(d1.phi, R.start, d1.merge);
 
   R.ReduceGraph();  // d1 and d2 both get folded true.
 
   CheckInputs(ret, R.one, R.start, R.start);
 
   DeadChecker dead(&R.graph);
   dead.Check(d1);
   dead.Check(d2);
   dead.Check(d3);
 }
 
 
 TEST(Return_nested_diamonds_true_false1) {
   ControlReducerTester R;
-  Diamond d1(R, R.one, R.one, R.zero);
-  Diamond d2(R, R.zero);
+  Diamond d1(R, R.jsgraph.TrueConstant(), R.one, R.zero);
+  Diamond d2(R, R.jsgraph.FalseConstant());
   Diamond d3(R, R.p0);
 
   d2.nest(d1, true);
   d3.nest(d1, false);
 
   Node* ret = R.Return(d1.phi, R.start, d1.merge);
 
   R.ReduceGraph();  // d1 gets folded true and d2 gets folded false.
 
   CheckInputs(ret, R.one, R.start, R.start);
@@ skipping 35 matching lines @@
 
 TEST(Return_nested_diamonds_true2) {
   ControlReducerTester R;
   Node* x2 = R.jsgraph.Float64Constant(11.1);
   Node* y2 = R.jsgraph.Float64Constant(22.2);
   Node* x3 = R.jsgraph.Float64Constant(33.3);
   Node* y3 = R.jsgraph.Float64Constant(44.4);
 
   Diamond d2(R, R.p0, x2, y2);
   Diamond d3(R, R.p0, x3, y3);
-  Diamond d1(R, R.one, d2.phi, d3.phi);
+  Diamond d1(R, R.jsgraph.TrueConstant(), d2.phi, d3.phi);
 
   d2.nest(d1, true);
   d3.nest(d1, false);
 
   Node* ret = R.Return(d1.phi, R.start, d1.merge);
 
   R.ReduceGraph();  // d1 gets folded true.
 
   CheckInputs(ret, d2.phi, R.start, d2.merge);
   CheckInputs(d2.branch, R.p0, R.start);
 
   DeadChecker dead(&R.graph);
   dead.Check(d1);
   dead.CheckLive(d2);
   dead.Check(d3);
 }
 
 
 TEST(Return_nested_diamonds_true_true2) {
   ControlReducerTester R;
   Node* x2 = R.jsgraph.Float64Constant(11.1);
   Node* y2 = R.jsgraph.Float64Constant(22.2);
   Node* x3 = R.jsgraph.Float64Constant(33.3);
   Node* y3 = R.jsgraph.Float64Constant(44.4);
 
-  Diamond d2(R, R.one, x2, y2);
+  Diamond d2(R, R.jsgraph.TrueConstant(), x2, y2);
   Diamond d3(R, R.p0, x3, y3);
-  Diamond d1(R, R.one, d2.phi, d3.phi);
+  Diamond d1(R, R.jsgraph.TrueConstant(), d2.phi, d3.phi);
 
   d2.nest(d1, true);
   d3.nest(d1, false);
 
   Node* ret = R.Return(d1.phi, R.start, d1.merge);
 
   R.ReduceGraph();  // d1 gets folded true.
 
   CheckInputs(ret, x2, R.start, R.start);
 
   DeadChecker dead(&R.graph);
   dead.Check(d1);
   dead.Check(d2);
   dead.Check(d3);
 }
 
 
 TEST(Return_nested_diamonds_true_false2) {
   ControlReducerTester R;
   Node* x2 = R.jsgraph.Float64Constant(11.1);
   Node* y2 = R.jsgraph.Float64Constant(22.2);
   Node* x3 = R.jsgraph.Float64Constant(33.3);
   Node* y3 = R.jsgraph.Float64Constant(44.4);
 
-  Diamond d2(R, R.zero, x2, y2);
+  Diamond d2(R, R.jsgraph.FalseConstant(), x2, y2);
   Diamond d3(R, R.p0, x3, y3);
-  Diamond d1(R, R.one, d2.phi, d3.phi);
+  Diamond d1(R, R.jsgraph.TrueConstant(), d2.phi, d3.phi);
 
   d2.nest(d1, true);
   d3.nest(d1, false);
 
   Node* ret = R.Return(d1.phi, R.start, d1.merge);
 
   R.ReduceGraph();  // d1 gets folded true.
 
   CheckInputs(ret, y2, R.start, R.start);
 
   DeadChecker dead(&R.graph);
   dead.Check(d1);
   dead.Check(d2);
   dead.Check(d3);
 }