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

test/cctest/compiler/test-osr.cc

 // Copyright 2015 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/codegen.h"
 #include "src/compiler/all-nodes.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/diamond.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/js-graph.h"
@@ skipping 75 matching lines @@
     Node* inputs[6];
     inputs[0] = incoming;
     inputs[1] = osr_values[osr_value];
     if (count > 2) inputs[2] = back1;
     if (count > 3) inputs[3] = back2;
     if (count > 4) inputs[4] = back3;
     inputs[count] = loop;
     return graph.NewNode(common.Phi(kMachAnyTagged, count), count + 1, inputs);
   }
 
-  Node* NewLoop(bool is_osr, int num_backedges, Node* entry = NULL) {
-    CHECK_LT(num_backedges, 4);
-    CHECK_GE(num_backedges, 0);
-    int count = 1 + num_backedges;
-    if (entry == NULL) entry = osr_normal_entry;
-    Node* inputs[5] = {entry, self, self, self, self};
+  Node* NewLoop(bool is_osr, int num_backedges, Node* entry = nullptr) {
+    if (entry == nullptr) entry = osr_normal_entry;
+    Node* loop = graph.NewNode(common.Loop(1), entry);
     if (is_osr) {
-      count = 2 + num_backedges;
-      inputs[1] = osr_loop_entry;
+      loop->AppendInput(graph.zone(), osr_loop_entry);
     }
-
-    Node* loop = graph.NewNode(common.Loop(count), count, inputs);
-    for (int i = 0; i < loop->InputCount(); i++) {
-      if (loop->InputAt(i) == self) loop->ReplaceInput(i, loop);
+    for (int i = 0; i < num_backedges; i++) {
+      loop->AppendInput(graph.zone(), loop);
     }
-
+    NodeProperties::ChangeOp(loop, common.Loop(loop->InputCount()));
     return loop;
   }
 
   Node* NewOsrLoop(int num_backedges, Node* entry = NULL) {
     return NewLoop(true, num_backedges, entry);
   }
 
   void DeconstructOsr() {
     OsrHelper helper(0, 0);
     helper.Deconstruct(&jsgraph, &common, main_zone());
@@ skipping 368 matching lines @@
 
 TEST(Deconstruct_osr_nested3) {
   OsrDeconstructorTester T(1);
 
   // outermost loop.
   While loop0(T, T.p0, false, 1);
   Node* loop0_cntr = MakeCounter(&T.jsgraph, T.p0, loop0.loop);
   loop0.branch->ReplaceInput(0, loop0_cntr);
 
   // middle loop.
-  Node* loop1 = T.graph.NewNode(T.common.Loop(2), loop0.if_true, T.self);
-  loop1->ReplaceInput(0, loop0.if_true);
+  Node* loop1 = T.graph.NewNode(T.common.Loop(1), loop0.if_true);
   Node* loop1_phi = T.graph.NewNode(T.common.Phi(kMachAnyTagged, 2), loop0_cntr,
                                     loop0_cntr, loop1);
 
   // innermost (OSR) loop.
   While loop2(T, T.p0, true, 1);
   loop2.loop->ReplaceInput(0, loop1);
 
   Node* loop2_cntr = MakeCounter(&T.jsgraph, loop1_phi, loop2.loop);
   loop2_cntr->ReplaceInput(1, T.osr_values[0]);
   Node* osr_phi = loop2_cntr;
   Node* loop2_inc = loop2_cntr->InputAt(2);
   loop2.branch->ReplaceInput(0, loop2_cntr);
 
   loop1_phi->ReplaceInput(1, loop2_cntr);
   loop0_cntr->ReplaceInput(1, loop2_cntr);
 
   // Branch to either the outer or middle loop.
   Node* branch = T.graph.NewNode(T.common.Branch(), loop2_cntr, loop2.exit);
   Node* if_true = T.graph.NewNode(T.common.IfTrue(), branch);
   Node* if_false = T.graph.NewNode(T.common.IfFalse(), branch);
 
   loop0.loop->ReplaceInput(1, if_true);
-  loop1->ReplaceInput(1, if_false);
+  loop1->AppendInput(T.graph.zone(), if_false);
+  NodeProperties::ChangeOp(loop1, T.common.Loop(2));
 
   Node* ret =
       T.graph.NewNode(T.common.Return(), loop0_cntr, T.start, loop0.exit);
   Node* end = T.graph.NewNode(T.common.End(1), ret);
   T.graph.SetEnd(end);
 
   T.DeconstructOsr();
 
   // Check structure of deconstructed graph.
   // Check loop2 (OSR loop) is directly connected to start.
@@ skipping 27 matching lines @@
 
   Node* new_loop0_phi = new_ret->InputAt(0);
   CHECK_EQ(IrOpcode::kPhi, new_loop0_phi->opcode());
   CHECK_EQ(new_loop0_loop, NodeProperties::GetControlInput(new_loop0_phi));
   CHECK_EQ(new_loop0_phi, FindSuccessor(new_loop0_loop, IrOpcode::kPhi));
 
   // Check that the return returns the phi from the OSR loop and control
   // depends on the copy of the outer loop0.
   CheckInputs(new_ret, new_loop0_phi, T.graph.start(), new_loop0_exit);
 }