Make start node a value input to parameter nodes.

test/cctest/compiler/test-scheduler.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/compiler/common-operator.h"
 #include "src/compiler/generic-node-inl.h"
 #include "src/compiler/generic-node.h"
@@ skipping 587 matching lines @@
 
   BasicBlock* loop1[] = {B, C, D, E};
   CheckLoopContains(loop1, 4);
 }
 
 
 TEST(BuildScheduleEmpty) {
   HandleAndZoneScope scope;
   Graph graph(scope.main_zone());
   CommonOperatorBuilder builder(scope.main_zone());
-  graph.SetStart(graph.NewNode(builder.Start()));
+  graph.SetStart(graph.NewNode(builder.Start(0)));
   graph.SetEnd(graph.NewNode(builder.End(), graph.start()));
 
   Scheduler scheduler(scope.main_zone());
   USE(scheduler.NewSchedule(&graph));
 }
 
 
 TEST(BuildScheduleOneParameter) {
   HandleAndZoneScope scope;
   Graph graph(scope.main_zone());
   CommonOperatorBuilder builder(scope.main_zone());
-  graph.SetStart(graph.NewNode(builder.Start()));
+  graph.SetStart(graph.NewNode(builder.Start(0)));
 
-  Node* p1 = graph.NewNode(builder.Parameter(0));
+  Node* p1 = graph.NewNode(builder.Parameter(0), graph.start());
   Node* ret = graph.NewNode(builder.Return(), p1, graph.start(), graph.start());
 
   graph.SetEnd(graph.NewNode(builder.End(), ret));
 
   Scheduler scheduler(scope.main_zone());
   USE(scheduler.NewSchedule(&graph));
 }
 
 
 static int GetScheduledNodeCount(Schedule* schedule) {
@@ skipping 24 matching lines @@
   OFStream os(stdout);
   os << *schedule << endl;
 }
 
 
 TEST(BuildScheduleIfSplit) {
   HandleAndZoneScope scope;
   Graph graph(scope.main_zone());
   CommonOperatorBuilder builder(scope.main_zone());
   JSOperatorBuilder js_builder(scope.main_zone());
-  graph.SetStart(graph.NewNode(builder.Start()));
+  graph.SetStart(graph.NewNode(builder.Start(3)));
 
-  Node* p1 = graph.NewNode(builder.Parameter(0));
-  Node* p2 = graph.NewNode(builder.Parameter(1));
-  Node* p3 = graph.NewNode(builder.Parameter(2));
-  Node* p4 = graph.NewNode(builder.Parameter(3));
-  Node* p5 = graph.NewNode(builder.Parameter(4));
+  Node* p1 = graph.NewNode(builder.Parameter(0), graph.start());
+  Node* p2 = graph.NewNode(builder.Parameter(1), graph.start());
+  Node* p3 = graph.NewNode(builder.Parameter(2), graph.start());
+  Node* p4 = graph.NewNode(builder.Parameter(3), graph.start());
+  Node* p5 = graph.NewNode(builder.Parameter(4), graph.start());
   Node* cmp = graph.NewNode(js_builder.LessThanOrEqual(), p1, p2, p3,
                             graph.start(), graph.start());
   Node* branch = graph.NewNode(builder.Branch(), cmp, graph.start());
   Node* true_branch = graph.NewNode(builder.IfTrue(), branch);
   Node* false_branch = graph.NewNode(builder.IfFalse(), branch);
 
   Node* ret1 = graph.NewNode(builder.Return(), p4, graph.start(), true_branch);
   Node* ret2 = graph.NewNode(builder.Return(), p5, graph.start(), false_branch);
   Node* merge = graph.NewNode(builder.Merge(2), ret1, ret2);
   graph.SetEnd(graph.NewNode(builder.End(), merge));
@@ skipping 24 matching lines @@
       PrintableUnique<Object>::CreateUninitialized(scope.main_zone(), object);
 
   // Manually transcripted code for:
   // function turbo_fan_test(a, b, c, y) {
   //   if (a < b) {
   //     return a + b - c * c - a + y;
   //   } else {
   //     return c * c - a;
   //   }
   // }
+  op = common_builder.Start(0);
+  Node* n0 = graph.NewNode(op);
+  USE(n0);
   Node* nil = graph.NewNode(common_builder.Dead());
   op = common_builder.End();
   Node* n23 = graph.NewNode(op, nil);
   USE(n23);
   op = common_builder.Merge(2);
   Node* n22 = graph.NewNode(op, nil, nil);
   USE(n22);
   op = common_builder.Return();
   Node* n16 = graph.NewNode(op, nil, nil, nil);
   USE(n16);
   op = js_builder.Add();
   Node* n15 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n15);
   op = js_builder.Subtract();
   Node* n14 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n14);
   op = js_builder.Subtract();
   Node* n13 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n13);
   op = js_builder.Add();
   Node* n11 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n11);
   op = common_builder.Parameter(0);
-  Node* n2 = graph.NewNode(op);
+  Node* n2 = graph.NewNode(op, n0);
   USE(n2);
   n11->ReplaceInput(0, n2);
   op = common_builder.Parameter(0);
-  Node* n3 = graph.NewNode(op);
+  Node* n3 = graph.NewNode(op, n0);
   USE(n3);
   n11->ReplaceInput(1, n3);
   op = common_builder.HeapConstant(unique_constant);
   Node* n7 = graph.NewNode(op);
   USE(n7);
   n11->ReplaceInput(2, n7);
   op = js_builder.LessThan();
   Node* n8 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n8);
   n8->ReplaceInput(0, n2);
   n8->ReplaceInput(1, n3);
   n8->ReplaceInput(2, n7);
-  op = common_builder.Start();
-  Node* n0 = graph.NewNode(op);
-  USE(n0);
   n8->ReplaceInput(3, n0);
   n8->ReplaceInput(4, n0);
   n11->ReplaceInput(3, n8);
   op = common_builder.IfTrue();
   Node* n10 = graph.NewNode(op, nil);
   USE(n10);
   op = common_builder.Branch();
   Node* n9 = graph.NewNode(op, nil, nil);
   USE(n9);
   n9->ReplaceInput(0, n8);
   n9->ReplaceInput(1, n0);
   n10->ReplaceInput(0, n9);
   n11->ReplaceInput(4, n10);
   n13->ReplaceInput(0, n11);
   op = js_builder.Multiply();
   Node* n12 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n12);
   op = common_builder.Parameter(0);
-  Node* n4 = graph.NewNode(op);
+  Node* n4 = graph.NewNode(op, n0);
   USE(n4);
   n12->ReplaceInput(0, n4);
   n12->ReplaceInput(1, n4);
   n12->ReplaceInput(2, n7);
   n12->ReplaceInput(3, n11);
   n12->ReplaceInput(4, n10);
   n13->ReplaceInput(1, n12);
   n13->ReplaceInput(2, n7);
   n13->ReplaceInput(3, n12);
   n13->ReplaceInput(4, n10);
   n14->ReplaceInput(0, n13);
   n14->ReplaceInput(1, n2);
   n14->ReplaceInput(2, n7);
   n14->ReplaceInput(3, n13);
   n14->ReplaceInput(4, n10);
   n15->ReplaceInput(0, n14);
   op = common_builder.Parameter(0);
-  Node* n5 = graph.NewNode(op);
+  Node* n5 = graph.NewNode(op, n0);
   USE(n5);
   n15->ReplaceInput(1, n5);
   n15->ReplaceInput(2, n7);
   n15->ReplaceInput(3, n14);
   n15->ReplaceInput(4, n10);
   n16->ReplaceInput(0, n15);
   n16->ReplaceInput(1, n15);
   n16->ReplaceInput(2, n10);
   n22->ReplaceInput(0, n16);
   op = common_builder.Return();
@@ skipping 52 matching lines @@
   PrintableUnique<Object> unique_constant =
       PrintableUnique<Object>::CreateUninitialized(scope.main_zone(), object);
 
   // Manually transcripted code for:
   // function turbo_fan_test(a, b) {
   //   while (a < b) {
   //     a++;
   //   }
   //   return a;
   // }
+  op = common_builder.Start(0);
+  Node* n0 = graph.NewNode(op);
+  USE(n0);
   Node* nil = graph.NewNode(common_builder.Dead());
   op = common_builder.End();
   Node* n20 = graph.NewNode(op, nil);
   USE(n20);
   op = common_builder.Return();
   Node* n19 = graph.NewNode(op, nil, nil, nil);
   USE(n19);
   op = common_builder.Phi(2);
   Node* n8 = graph.NewNode(op, nil, nil, nil);
   USE(n8);
   op = common_builder.Parameter(0);
-  Node* n2 = graph.NewNode(op);
+  Node* n2 = graph.NewNode(op, n0);
   USE(n2);
   n8->ReplaceInput(0, n2);
   op = js_builder.Add();
   Node* n18 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n18);
   op = js_builder.ToNumber();
   Node* n16 = graph.NewNode(op, nil, nil, nil, nil);
   USE(n16);
   n16->ReplaceInput(0, n8);
   op = common_builder.HeapConstant(unique_constant);
   Node* n5 = graph.NewNode(op);
   USE(n5);
   n16->ReplaceInput(1, n5);
   op = js_builder.LessThan();
   Node* n12 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n12);
   n12->ReplaceInput(0, n8);
   op = common_builder.Phi(2);
   Node* n9 = graph.NewNode(op, nil, nil, nil);
   USE(n9);
   op = common_builder.Parameter(0);
-  Node* n3 = graph.NewNode(op);
+  Node* n3 = graph.NewNode(op, n0);
   USE(n3);
   n9->ReplaceInput(0, n3);
   n9->ReplaceInput(1, n9);
   op = common_builder.Loop(2);
   Node* n6 = graph.NewNode(op, nil, nil);
   USE(n6);
-  op = common_builder.Start();
-  Node* n0 = graph.NewNode(op);
-  USE(n0);
   n6->ReplaceInput(0, n0);
   op = common_builder.IfTrue();
   Node* n14 = graph.NewNode(op, nil);
   USE(n14);
   op = common_builder.Branch();
   Node* n13 = graph.NewNode(op, nil, nil);
   USE(n13);
   n13->ReplaceInput(0, n12);
   n13->ReplaceInput(1, n6);
   n14->ReplaceInput(0, n13);
@@ skipping 63 matching lines @@
   //     a++;
   //     while (c < b) {
   //       c++;
   //     }
   //   }
   //   while (a < b) {
   //     a += 2;
   //   }
   //   return a;
   // }
+  op = common_builder.Start(0);
+  Node* n0 = graph.NewNode(op);
+  USE(n0);
   Node* nil = graph.NewNode(common_builder.Dead());
   op = common_builder.End();
   Node* n46 = graph.NewNode(op, nil);
   USE(n46);
   op = common_builder.Return();
   Node* n45 = graph.NewNode(op, nil, nil, nil);
   USE(n45);
   op = common_builder.Phi(2);
   Node* n35 = graph.NewNode(op, nil, nil, nil);
   USE(n35);
   op = common_builder.Phi(2);
   Node* n9 = graph.NewNode(op, nil, nil, nil);
   USE(n9);
   op = common_builder.Parameter(0);
-  Node* n2 = graph.NewNode(op);
+  Node* n2 = graph.NewNode(op, n0);
   USE(n2);
   n9->ReplaceInput(0, n2);
   op = common_builder.Phi(2);
   Node* n23 = graph.NewNode(op, nil, nil, nil);
   USE(n23);
   op = js_builder.Add();
   Node* n20 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n20);
   op = js_builder.ToNumber();
   Node* n18 = graph.NewNode(op, nil, nil, nil, nil);
   USE(n18);
   n18->ReplaceInput(0, n9);
   op = common_builder.HeapConstant(unique_constant);
   Node* n6 = graph.NewNode(op);
   USE(n6);
   n18->ReplaceInput(1, n6);
   op = js_builder.LessThan();
   Node* n14 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n14);
   n14->ReplaceInput(0, n9);
   op = common_builder.Phi(2);
   Node* n10 = graph.NewNode(op, nil, nil, nil);
   USE(n10);
   op = common_builder.Parameter(0);
-  Node* n3 = graph.NewNode(op);
+  Node* n3 = graph.NewNode(op, n0);
   USE(n3);
   n10->ReplaceInput(0, n3);
   op = common_builder.Phi(2);
   Node* n24 = graph.NewNode(op, nil, nil, nil);
   USE(n24);
   n24->ReplaceInput(0, n10);
   n24->ReplaceInput(1, n24);
   op = common_builder.Loop(2);
   Node* n21 = graph.NewNode(op, nil, nil);
   USE(n21);
   op = common_builder.IfTrue();
   Node* n16 = graph.NewNode(op, nil);
   USE(n16);
   op = common_builder.Branch();
   Node* n15 = graph.NewNode(op, nil, nil);
   USE(n15);
   n15->ReplaceInput(0, n14);
   op = common_builder.Loop(2);
   Node* n7 = graph.NewNode(op, nil, nil);
   USE(n7);
-  op = common_builder.Start();
-  Node* n0 = graph.NewNode(op);
-  USE(n0);
   n7->ReplaceInput(0, n0);
   op = common_builder.IfFalse();
   Node* n30 = graph.NewNode(op, nil);
   USE(n30);
   op = common_builder.Branch();
   Node* n28 = graph.NewNode(op, nil, nil);
   USE(n28);
   op = js_builder.LessThan();
   Node* n27 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n27);
   op = common_builder.Phi(2);
   Node* n25 = graph.NewNode(op, nil, nil, nil);
   USE(n25);
   op = common_builder.Phi(2);
   Node* n11 = graph.NewNode(op, nil, nil, nil);
   USE(n11);
   op = common_builder.Parameter(0);
-  Node* n4 = graph.NewNode(op);
+  Node* n4 = graph.NewNode(op, n0);
   USE(n4);
   n11->ReplaceInput(0, n4);
   n11->ReplaceInput(1, n25);
   n11->ReplaceInput(2, n7);
   n25->ReplaceInput(0, n11);
   op = js_builder.Add();
   Node* n32 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n32);
   op = js_builder.ToNumber();
   Node* n31 = graph.NewNode(op, nil, nil, nil, nil);
@@ skipping 156 matching lines @@
   //     while (c < b) {
   //       c++;
   //       if (d == 0) break;
   //       a++;
   //     }
   //     if (a == 1) continue;
   //     d++;
   //   }
   //   return a + d;
   // }
+  op = common_builder.Start(0);
+  Node* n0 = graph.NewNode(op);
+  USE(n0);
   Node* nil = graph.NewNode(common_builder.Dead());
   op = common_builder.End();
   Node* n58 = graph.NewNode(op, nil);
   USE(n58);
   op = common_builder.Return();
   Node* n57 = graph.NewNode(op, nil, nil, nil);
   USE(n57);
   op = js_builder.Add();
   Node* n56 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n56);
   op = common_builder.Phi(2);
   Node* n10 = graph.NewNode(op, nil, nil, nil);
   USE(n10);
   op = common_builder.Parameter(0);
-  Node* n2 = graph.NewNode(op);
+  Node* n2 = graph.NewNode(op, n0);
   USE(n2);
   n10->ReplaceInput(0, n2);
   op = common_builder.Phi(2);
   Node* n25 = graph.NewNode(op, nil, nil, nil);
   USE(n25);
   op = js_builder.Add();
   Node* n22 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n22);
   op = js_builder.ToNumber();
   Node* n20 = graph.NewNode(op, nil, nil, nil, nil);
   USE(n20);
   n20->ReplaceInput(0, n10);
   op = common_builder.HeapConstant(unique_constant);
   Node* n6 = graph.NewNode(op);
   USE(n6);
   n20->ReplaceInput(1, n6);
   op = js_builder.LessThan();
   Node* n16 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n16);
   n16->ReplaceInput(0, n10);
   op = common_builder.Phi(2);
   Node* n11 = graph.NewNode(op, nil, nil, nil);
   USE(n11);
   op = common_builder.Parameter(0);
-  Node* n3 = graph.NewNode(op);
+  Node* n3 = graph.NewNode(op, n0);
   USE(n3);
   n11->ReplaceInput(0, n3);
   op = common_builder.Phi(2);
   Node* n26 = graph.NewNode(op, nil, nil, nil);
   USE(n26);
   n26->ReplaceInput(0, n11);
   n26->ReplaceInput(1, n26);
   op = common_builder.Loop(2);
   Node* n23 = graph.NewNode(op, nil, nil);
   USE(n23);
   op = common_builder.IfTrue();
   Node* n18 = graph.NewNode(op, nil);
   USE(n18);
   op = common_builder.Branch();
   Node* n17 = graph.NewNode(op, nil, nil);
   USE(n17);
   n17->ReplaceInput(0, n16);
   op = common_builder.Loop(2);
   Node* n8 = graph.NewNode(op, nil, nil);
   USE(n8);
-  op = common_builder.Start();
-  Node* n0 = graph.NewNode(op);
-  USE(n0);
   n8->ReplaceInput(0, n0);
   op = common_builder.Merge(2);
   Node* n53 = graph.NewNode(op, nil, nil);
   USE(n53);
   op = common_builder.IfTrue();
   Node* n49 = graph.NewNode(op, nil);
   USE(n49);
   op = common_builder.Branch();
   Node* n48 = graph.NewNode(op, nil, nil);
   USE(n48);
@@ skipping 12 matching lines @@
   op = js_builder.LessThan();
   Node* n30 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n30);
   op = common_builder.Phi(2);
   Node* n27 = graph.NewNode(op, nil, nil, nil);
   USE(n27);
   op = common_builder.Phi(2);
   Node* n12 = graph.NewNode(op, nil, nil, nil);
   USE(n12);
   op = common_builder.Parameter(0);
-  Node* n4 = graph.NewNode(op);
+  Node* n4 = graph.NewNode(op, n0);
   USE(n4);
   n12->ReplaceInput(0, n4);
   op = common_builder.Phi(2);
   Node* n41 = graph.NewNode(op, nil, nil, nil);
   USE(n41);
   n41->ReplaceInput(0, n27);
   op = js_builder.Add();
   Node* n35 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n35);
   op = js_builder.ToNumber();
@@ skipping 214 matching lines @@
   PrintableUnique<Object> unique_constant =
       PrintableUnique<Object>::CreateUninitialized(scope.main_zone(), object);
 
   // Manually transcripted code for:
   // function turbo_fan_test(a, b, c) {
   //   while (a < b) {
   //     a += b + c;
   //   }
   //   return a;
   // }
+  op = common_builder.Start(0);
+  Node* n0 = graph.NewNode(op);
+  USE(n0);
   Node* nil = graph.NewNode(common_builder.Dead());
   op = common_builder.End();
   Node* n22 = graph.NewNode(op, nil);
   USE(n22);
   op = common_builder.Return();
   Node* n21 = graph.NewNode(op, nil, nil, nil);
   USE(n21);
   op = common_builder.Phi(2);
   Node* n9 = graph.NewNode(op, nil, nil, nil);
   USE(n9);
   op = common_builder.Parameter(0);
-  Node* n2 = graph.NewNode(op);
+  Node* n2 = graph.NewNode(op, n0);
   USE(n2);
   n9->ReplaceInput(0, n2);
   op = js_builder.Add();
   Node* n20 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n20);
   n20->ReplaceInput(0, n9);
   op = machine_builder.Int32Add();
   Node* n19 = graph.NewNode(op, nil, nil);
   USE(n19);
   op = common_builder.Phi(2);
   Node* n10 = graph.NewNode(op, nil, nil, nil);
   USE(n10);
   op = common_builder.Parameter(0);
-  Node* n3 = graph.NewNode(op);
+  Node* n3 = graph.NewNode(op, n0);
   USE(n3);
   n10->ReplaceInput(0, n3);
   n10->ReplaceInput(1, n10);
   op = common_builder.Loop(2);
   Node* n7 = graph.NewNode(op, nil, nil);
   USE(n7);
-  op = common_builder.Start();
-  Node* n0 = graph.NewNode(op);
-  USE(n0);
   n7->ReplaceInput(0, n0);
   op = common_builder.IfTrue();
   Node* n17 = graph.NewNode(op, nil);
   USE(n17);
   op = common_builder.Branch();
   Node* n16 = graph.NewNode(op, nil, nil);
   USE(n16);
   op = js_builder.ToBoolean();
   Node* n15 = graph.NewNode(op, nil, nil, nil, nil);
   USE(n15);
@@ skipping 21 matching lines @@
   n16->ReplaceInput(0, n15);
   n16->ReplaceInput(1, n7);
   n17->ReplaceInput(0, n16);
   n7->ReplaceInput(1, n17);
   n10->ReplaceInput(2, n7);
   n19->ReplaceInput(0, n2);
   op = common_builder.Phi(2);
   Node* n11 = graph.NewNode(op, nil, nil, nil);
   USE(n11);
   op = common_builder.Parameter(0);
-  Node* n4 = graph.NewNode(op);
+  Node* n4 = graph.NewNode(op, n0);
   USE(n4);
   n11->ReplaceInput(0, n4);
   n11->ReplaceInput(1, n11);
   n11->ReplaceInput(2, n7);
   n19->ReplaceInput(1, n3);
   n20->ReplaceInput(1, n19);
   n20->ReplaceInput(2, n6);
   n20->ReplaceInput(3, n19);
   n20->ReplaceInput(4, n17);
   n9->ReplaceInput(1, n20);
@@ skipping 153 matching lines @@
   CHECK(!call_block->deferred_);
   CHECK(!cont_block->deferred_);
   // The lazy deopt block contains framestate + bailout (and nothing else).
   CHECK_EQ(deoptimization_node, deopt_block->control_input_);
   CHECK_EQ(2, static_cast<int>(deopt_block->nodes_.size()));
   CHECK_EQ(lazy_deopt_node, deopt_block->nodes_[0]);
   CHECK_EQ(state_node, deopt_block->nodes_[1]);
 }
 
 #endif