[turbofan] Change End to take a variable number of inputs.

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 51 matching lines @@
 
 // A helper for all tests dealing with ControlTester.
 class ControlReducerTester : HandleAndZoneScope {
  public:
   ControlReducerTester()
       : isolate(main_isolate()),
         common(main_zone()),
         graph(main_zone()),
         jsgraph(main_isolate(), &graph, &common, NULL, NULL),
         start(graph.NewNode(common.Start(1))),
-        end(graph.NewNode(common.End(), start)),
+        end(graph.NewNode(common.End(1), start)),
         p0(graph.NewNode(common.Parameter(0), start)),
         zero(jsgraph.Int32Constant(0)),
         one(jsgraph.OneConstant()),
         half(jsgraph.Constant(0.5)),
         self(graph.NewNode(common.Int32Constant(0xaabbccdd))),
         dead(graph.NewNode(common.Dead())) {
     graph.SetEnd(end);
     graph.SetStart(start);
     leaf[0] = zero;
     leaf[1] = one;
@@ skipping 71 matching lines @@
 
   // Checks one-step reduction of a phi.
   void ReducePhiNonIterative(Node* expect, Node* phi) {
     Node* result = ControlReducer::ReducePhiForTesting(&jsgraph, phi);
     CHECK_EQ(expect, result);
   }
 
   void ReducePhiIterative(Node* expect, Node* phi) {
     p0->ReplaceInput(0, start);  // hack: parameters may be trimmed.
     Node* ret = graph.NewNode(common.Return(), phi, start, start);
-    Node* end = graph.NewNode(common.End(), ret);
+    Node* end = graph.NewNode(common.End(1), ret);
     graph.SetEnd(end);
     ControlReducer::ReduceGraph(main_zone(), &jsgraph);
     CheckInputs(end, ret);
     CheckInputs(ret, expect, start, start);
   }
 
   void ReduceMerge(Node* expect, Node* merge) {
     Node* result = ControlReducer::ReduceMerge(&jsgraph, merge);
     CHECK_EQ(expect, result);
   }
 
   void ReduceMergeIterative(Node* expect, Node* merge) {
     p0->ReplaceInput(0, start);  // hack: parameters may be trimmed.
-    Node* end = graph.NewNode(common.End(), merge);
+    Node* end = graph.NewNode(common.End(1), merge);
     graph.SetEnd(end);
     ReduceGraph();
     CheckInputs(end, expect);
   }
 
   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, use);
@@ skipping 216 matching lines @@
     CHECK_EQ(i == 0 ? NULL : dead[i - 1], dead[i]->InputAt(0));
     CHECK_EQ(i == 0 ? T.start : live[i - 1], live[i]->InputAt(0));
   }
 }
 
 
 TEST(Trim_cycle1) {
   ControlReducerTester T;
   Node* loop = T.graph.NewNode(T.common.Loop(1), T.start, T.start);
   loop->ReplaceInput(1, loop);
-  Node* end = T.graph.NewNode(T.common.End(), loop);
+  Node* end = T.graph.NewNode(T.common.End(1), loop);
   T.graph.SetEnd(end);
 
   CHECK(IsUsedBy(T.start, loop));
   CHECK(IsUsedBy(loop, end));
   CHECK(IsUsedBy(loop, loop));
 
   T.Trim();
 
   // nothing should have happened to the loop itself.
   CHECK(IsUsedBy(T.start, loop));
   CHECK(IsUsedBy(loop, end));
   CHECK(IsUsedBy(loop, loop));
   CheckInputs(loop, T.start, loop);
   CheckInputs(end, loop);
 }
 
 
 TEST(Trim_cycle2) {
   ControlReducerTester T;
   Node* loop = T.graph.NewNode(T.common.Loop(2), T.start, T.start);
   loop->ReplaceInput(1, loop);
-  Node* end = T.graph.NewNode(T.common.End(), loop);
+  Node* end = T.graph.NewNode(T.common.End(1), loop);
   Node* phi =
       T.graph.NewNode(T.common.Phi(kMachAnyTagged, 2), T.one, T.half, loop);
   T.graph.SetEnd(end);
 
   CHECK(IsUsedBy(T.start, loop));
   CHECK(IsUsedBy(loop, end));
   CHECK(IsUsedBy(loop, loop));
   CHECK(IsUsedBy(loop, phi));
   CHECK(IsUsedBy(T.one, phi));
   CHECK(IsUsedBy(T.half, phi));
@@ skipping 617 matching lines @@
 }
 
 
 TEST(CMergeReduce_dead_chain1) {
   ControlReducerTester R;
   for (int i = 0; i < 5; i++) {
     Node* merge = R.graph.NewNode(R.common.Merge(1), R.dead);
     for (int j = 0; j < i; j++) {
       merge = R.graph.NewNode(R.common.Merge(1), merge);
     }
-    Node* end = R.graph.NewNode(R.common.End(), merge);
+    Node* end = R.graph.NewNode(R.common.End(1), merge);
     R.graph.SetEnd(end);
     R.ReduceGraph();
     CHECK(merge->IsDead());
     CHECK(!end->InputAt(0));  // end dies.
   }
 }
 
 
 TEST(CMergeReduce_dead_chain2) {
   ControlReducerTester R;
@@ skipping 546 matching lines @@
 
   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);
 }