[turbofan] Check node input/use consistency for changed operators and new nodes.

test/cctest/compiler/test-loop-analysis.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 "src/compiler/access-builder.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/graph-visualizer.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/loop-analysis.h"
 #include "src/compiler/node.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/compiler/schedule.h"
 #include "src/compiler/scheduler.h"
 #include "src/compiler/simplified-operator.h"
 #include "src/compiler/verifier.h"
 #include "test/cctest/cctest.h"
 
 using namespace v8::internal;
 using namespace v8::internal::compiler;
 
 static Operator kIntAdd(IrOpcode::kInt32Add, Operator::kPure, "Int32Add", 2, 0,
                         0, 1, 0, 0);
 static Operator kIntLt(IrOpcode::kInt32LessThan, Operator::kPure,
                        "Int32LessThan", 2, 0, 0, 1, 0, 0);
-static Operator kStore(IrOpcode::kStore, Operator::kNoProperties, "Store", 0, 2,
+static Operator kStore(IrOpcode::kStore, Operator::kNoProperties, "Store", 1, 1,
                        1, 0, 1, 0);
 
 static const int kNumLeafs = 4;
 
 // A helper for all tests dealing with LoopFinder.
 class LoopFinderTester : HandleAndZoneScope {
  public:
   LoopFinderTester()
       : isolate(main_isolate()),
         common(main_zone()),
@@ skipping 186 matching lines @@
 };
 
 
 struct StoreLoop {
   Node* base;
   Node* val;
   Node* phi;
   Node* store;
 
   explicit StoreLoop(While& w)
-      : base(w.t.jsgraph.Int32Constant(12)),
-        val(w.t.jsgraph.Int32Constant(13)) {
+      : base(w.t.graph.start()), val(w.t.jsgraph.Int32Constant(13)) {
     Build(w);
   }
 
   StoreLoop(While& w, Node* b, Node* v) : base(b), val(v) { Build(w); }
 
   void Build(While& w) {
     phi = w.t.graph.NewNode(w.t.op(2, true), base, base, w.loop);
-    store = w.t.graph.NewNode(&kStore, phi, val, w.loop);
+    store = w.t.graph.NewNode(&kStore, val, phi, w.loop);
     phi->ReplaceInput(1, store);
   }
 };
 
 
 TEST(LaLoop1) {
   // One loop.
   LoopFinderTester t;
   While w(t, t.p0);
   t.Return(t.p0, t.start, w.exit);
@@ skipping 225 matching lines @@
   Node* p1b = t.graph.NewNode(op, t.p0, t.p0, w1.loop);
   Node* p2a = t.graph.NewNode(op, p1a, t.p0, w2.loop);
   Node* p2b = t.graph.NewNode(op, p1b, t.p0, w2.loop);
 
   p1a->ReplaceInput(1, p2b);
   p1b->ReplaceInput(1, p2a);
 
   p2a->ReplaceInput(1, p2b);
   p2b->ReplaceInput(1, p2a);
 
-  t.Return(t.p0, p1a, w1.exit);
+  t.Return(t.p0, t.start, w1.exit);
 
   Node* chain[] = {w1.loop, w2.loop};
   t.CheckNestedLoops(chain, 2);
 
   Node* h1[] = {w1.loop, p1a, p1b};
   Node* b1[] = {w1.branch, w1.if_true, w2.loop,    p2a,
                 p2b,       w2.branch,  w2.if_true, w2.exit};
   t.CheckLoop(h1, 3, b1, 8);
 
   Node* h2[] = {w2.loop, p2a, p2b};
@@ skipping 503 matching lines @@
 TEST(LaManyNested_31) { RunManyNestedLoops_i(31); }
 TEST(LaManyNested_32) { RunManyNestedLoops_i(32); }
 TEST(LaManyNested_33) { RunManyNestedLoops_i(33); }
 TEST(LaManyNested_34) { RunManyNestedLoops_i(34); }
 TEST(LaManyNested_62) { RunManyNestedLoops_i(62); }
 TEST(LaManyNested_63) { RunManyNestedLoops_i(63); }
 TEST(LaManyNested_64) { RunManyNestedLoops_i(64); }
 
 
 TEST(LaPhiTangle) { LoopFinderTester t; }