Make start node a value input to parameter nodes.

test/cctest/compiler/test-phi-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/compiler/common-operator.h"
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/phi-reducer.h"
 
 using namespace v8::internal;
 using namespace v8::internal::compiler;
 
 class PhiReducerTester : HandleAndZoneScope {
  public:
-  PhiReducerTester()
+  explicit PhiReducerTester(int num_parameters = 0)
       : isolate(main_isolate()),
         common(main_zone()),
         graph(main_zone()),
-        self(graph.NewNode(common.Start())),
-        dead(graph.NewNode(common.Dead())) {}
+        self(graph.NewNode(common.Start(num_parameters))),
+        dead(graph.NewNode(common.Dead())) {
+    graph.SetStart(self);
+  }
 
   Isolate* isolate;
   CommonOperatorBuilder common;
   Graph graph;
   Node* self;
   Node* dead;
 
   void CheckReduce(Node* expect, Node* phi) {
     PhiReducer reducer;
     Reduction reduction = reducer.Reduce(phi);
     if (expect == phi) {
       CHECK(!reduction.Changed());
     } else {
       CHECK(reduction.Changed());
       CHECK_EQ(expect, reduction.replacement());
     }
   }
 
   Node* Int32Constant(int32_t val) {
     return graph.NewNode(common.Int32Constant(val));
   }
 
   Node* Float64Constant(double val) {
     return graph.NewNode(common.Float64Constant(val));
   }
 
   Node* Parameter(int32_t index = 0) {
-    return graph.NewNode(common.Parameter(index));
+    return graph.NewNode(common.Parameter(index), graph.start());
   }
 
   Node* Phi(Node* a) {
     return SetSelfReferences(graph.NewNode(common.Phi(1), a));
   }
 
   Node* Phi(Node* a, Node* b) {
     return SetSelfReferences(graph.NewNode(common.Phi(2), a, b));
   }
 
@@ skipping 153 matching lines @@
   Node* oneish = R.Float64Constant(1.1);
   Node* param = R.Parameter();
 
   Node* singles[] = {zero, one, oneish, param};
   for (size_t i = 0; i < ARRAY_SIZE(singles); ++i) {
     R.CheckReduce(singles[i], R.PhiWithControl(singles[i], R.dead));
     R.CheckReduce(singles[i], R.PhiWithControl(R.self, singles[i], R.dead));
     R.CheckReduce(singles[i], R.PhiWithControl(singles[i], R.self, R.dead));
   }
 }