[turbofan] Connect non-terminating loops via Terminate.

src/compiler/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/compiler/common-operator.h"
 #include "src/compiler/control-reducer.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/graph-reducer.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/node-marker.h"
@@ skipping 132 matching lines @@
     }
 
     return done;
   }
 
   // Connect {loop}, the header of a non-terminating loop, to the end node.
   Node* ConnectNTL(Node* loop) {
     TRACE("ConnectNTL: #%d:%s\n", loop->id(), loop->op()->mnemonic());
     DCHECK_EQ(IrOpcode::kLoop, loop->opcode());
 
-    Node* always = graph()->NewNode(common()->Always());
-    Node* branch = graph()->NewNode(common()->Branch(), always, loop);
-    Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
-    Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
-
-    // Insert the branch into the loop and collect all loop effects.
+    // Collect all loop effects.
     NodeVector effects(zone_);
     for (auto edge : loop->use_edges()) {
       DCHECK_EQ(loop, edge.to());
       DCHECK(NodeProperties::IsControlEdge(edge));
-      if (edge.from() == branch) continue;
       switch (edge.from()->opcode()) {
         case IrOpcode::kPhi:
           break;
         case IrOpcode::kEffectPhi:
           effects.push_back(edge.from());
           break;
         default:
-          // Update all control edges (except {branch}) pointing to the {loop}.
-          edge.UpdateTo(if_true);
           break;
       }
     }
 
     // Compute effects for the Return.
     Node* effect = graph()->start();
     int const effects_count = static_cast<int>(effects.size());
     if (effects_count == 1) {
       effect = effects[0];
     } else if (effects_count > 1) {
       effect = graph()->NewNode(common()->EffectSet(effects_count),
                                 effects_count, &effects.front());
     }
 
-    // Add a return to connect the NTL to the end.
-    Node* ret = graph()->NewNode(
-        common()->Return(), jsgraph_->UndefinedConstant(), effect, if_false);
+    // Add a terminate to connect the NTL to the end.
+    Node* terminate = graph()->NewNode(common()->Terminate(), effect, loop);
 
     Node* end = graph()->end();
     if (end->opcode() == IrOpcode::kDead) {
       // End is actually the dead node. Make a new end.
-      end = graph()->NewNode(common()->End(), ret);
+      end = graph()->NewNode(common()->End(), terminate);
       graph()->SetEnd(end);
       return end;
     }
     // End is not dead.
     Node* merge = end->InputAt(0);
     if (merge == NULL || merge->opcode() == IrOpcode::kDead) {
-      // The end node died; just connect end to {ret}.
-      end->ReplaceInput(0, ret);
+      // The end node died; just connect end to {terminate}.
+      end->ReplaceInput(0, terminate);
     } else if (merge->opcode() != IrOpcode::kMerge) {
-      // Introduce a final merge node for {end->InputAt(0)} and {ret}.
-      merge = graph()->NewNode(common()->Merge(2), merge, ret);
+      // Introduce a final merge node for {end->InputAt(0)} and {terminate}.
+      merge = graph()->NewNode(common()->Merge(2), merge, terminate);
       end->ReplaceInput(0, merge);
-      ret = merge;
+      terminate = merge;
     } else {
       // Append a new input to the final merge at the end.
-      merge->AppendInput(graph()->zone(), ret);
+      merge->AppendInput(graph()->zone(), terminate);
       merge->set_op(common()->Merge(merge->InputCount()));
     }
-    return ret;
+    return terminate;
   }
 
   void AddNodesReachableFromRoots(ReachabilityMarker& marked,
                                   NodeVector& nodes) {
     jsgraph_->GetCachedNodes(&nodes);  // Consider cached nodes roots.
     Node* end = graph()->end();
     marked.SetReachableFromEnd(end);
     if (!end->IsDead()) nodes.push_back(end);  // Consider end to be a root.
     for (Node* node : nodes) marked.SetReachableFromEnd(node);
     AddBackwardsReachableNodes(marked, nodes, 0);
@@ skipping 377 matching lines @@
     case IrOpcode::kIfFalse:
       return impl.ReduceIfProjection(node, kFalse);
     default:
       return node;
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8