[turbofan] Change End to take a variable number of inputs.

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 166 matching lines @@
       effect = graph()->NewNode(common()->EffectSet(effects_count),
                                 effects_count, &effects.front());
     }
 
     // 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(), terminate);
+      end = graph()->NewNode(common()->End(1), 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 {terminate}.
-      end->ReplaceInput(0, terminate);
-    } else if (merge->opcode() != IrOpcode::kMerge) {
-      // Introduce a final merge node for {end->InputAt(0)} and {terminate}.
-      merge = graph()->NewNode(common()->Merge(2), merge, terminate);
-      end->ReplaceInput(0, merge);
-      terminate = merge;
-    } else {
-      // Append a new input to the final merge at the end.
-      merge->AppendInput(graph()->zone(), terminate);
-      merge->set_op(common()->Merge(merge->InputCount()));
-    }
+    // Append a new input to the end.
+    end->AppendInput(graph()->zone(), terminate);
+    end->set_op(common()->End(end->InputCount()));
     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);
@@ skipping 90 matching lines @@
       case IrOpcode::kMerge:
         result = ReduceMerge(node);
         break;
       case IrOpcode::kSelect:
         result = ReduceSelect(node);
         break;
       case IrOpcode::kPhi:
       case IrOpcode::kEffectPhi:
         result = ReducePhi(node);
         break;
+      case IrOpcode::kEnd:
+        result = ReduceEnd(node);
+        break;
       default:
         break;
     }
 
     return result == node ? NoChange() : Replace(result);
   }
 
   // Try to statically fold a condition.
   Decision DecideCondition(Node* cond, bool recurse = true) {
     switch (cond->opcode()) {
@@ skipping 71 matching lines @@
   }
 
   // Reduce branches.
   Node* ReduceBranch(Node* branch) {
     if (DecideCondition(branch->InputAt(0)) != kUnknown) {
       for (Node* use : branch->uses()) Revisit(use);
     }
     return branch;
   }
 
+  // Reduce end by trimming away dead inputs.
+  Node* ReduceEnd(Node* node) {
+    // Count the number of live inputs.
+    int live = 0;
+    for (int index = 0; index < node->InputCount(); ++index) {
+      // Skip dead inputs.
+      if (node->InputAt(index)->opcode() == IrOpcode::kDead) continue;
+      // Compact live inputs.
+      if (index != live) node->ReplaceInput(live, node->InputAt(index));
+      ++live;
+    }
+
+    TRACE("ReduceEnd: #%d:%s (%d of %d live)\n", node->id(),
+          node->op()->mnemonic(), live, node->InputCount());
+
+    if (live == 0) return dead();  // No remaining inputs.
+
+    if (live < node->InputCount()) {
+      node->set_op(common()->End(live));
+      node->TrimInputCount(live);
+    }
+
+    return node;
+  }
+
   // Reduce merges by trimming away dead inputs from the merge and phis.
   Node* ReduceMerge(Node* node) {
     // Count the number of live inputs.
     int live = 0;
     int index = 0;
     int live_index = 0;
     for (Node* const input : node->inputs()) {
       if (input->opcode() != IrOpcode::kDead) {
         live++;
         live_index = index;
@@ skipping 179 matching lines @@
     case IrOpcode::kIfFalse:
       return impl.ReduceIfProjection(node, kFalse);
     default:
       return node;
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8