[turbofan] Introduce DeadValue and DeadEffect operators.

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 29 matching lines @@
   Node* dead() { return jsgraph_->DeadControl(); }
 
   //===========================================================================
   // Reducer implementation: perform reductions on a node.
   //===========================================================================
   Reduction Reduce(Node* node) override {
     if (node->op()->ControlInputCount() == 1 ||
         node->opcode() == IrOpcode::kLoop) {
       // If a node has only one control input and it is dead, replace with dead.
       Node* control = NodeProperties::GetControlInput(node);
-      if (control->opcode() == IrOpcode::kDead) {
+      if (control->opcode() == IrOpcode::kDeadControl) {
         TRACE("ControlDead: #%d:%s\n", node->id(), node->op()->mnemonic());
         return Replace(control);
       }
     }
 
     Node* result = node;
     // Reduce branches, phis, and merges.
     switch (node->opcode()) {
       case IrOpcode::kBranch:
         result = ReduceBranch(node);
@@ skipping 70 matching lines @@
   // Reduce redundant phis.
   Node* ReducePhi(Node* node) {
     int n = node->InputCount();
     if (n <= 1) return dead();            // No non-control inputs.
     if (n == 2) return node->InputAt(0);  // Only one non-control input.
 
     Node* replacement = NULL;
     auto const inputs = node->inputs();
     for (auto it = inputs.begin(); n > 1; --n, ++it) {
       Node* input = *it;
-      if (input->opcode() == IrOpcode::kDead) continue;  // ignore dead inputs.
-      if (input != node && input != replacement) {       // non-redundant input.
+      // Ignore dead inputs.
+      if (input->opcode() == IrOpcode::kDeadControl) continue;
+      // Non-redundant input.
+      if (input != node && input != replacement) {
         if (replacement != NULL) return node;
         replacement = input;
       }
     }
     return replacement == NULL ? dead() : replacement;
   }
 
   // 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;
+      if (node->InputAt(index)->opcode() == IrOpcode::kDeadControl) 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) {
+      if (input->opcode() != IrOpcode::kDeadControl) {
         live++;
         live_index = index;
       }
       index++;
     }
 
     TRACE("ReduceMerge: #%d:%s (%d of %d live)\n", node->id(),
           node->op()->mnemonic(), live, index);
 
     if (live == 0) return dead();  // no remaining inputs.
@@ skipping 93 matching lines @@
     }
     return result == kUnknown ? node : dead();
   }
 
   // Remove inputs to {node} corresponding to the dead inputs to {merge}
   // and compact the remaining inputs, updating the operator.
   void RemoveDeadInputs(Node* merge, Node* node) {
     int live = 0;
     for (int i = 0; i < merge->InputCount(); i++) {
       // skip dead inputs.
-      if (merge->InputAt(i)->opcode() == IrOpcode::kDead) continue;
+      if (merge->InputAt(i)->opcode() == IrOpcode::kDeadControl) continue;
       // compact live inputs.
       if (live != i) node->ReplaceInput(live, node->InputAt(i));
       live++;
     }
     // compact remaining inputs.
     int total = live;
     for (int i = merge->InputCount(); i < node->InputCount(); i++) {
       if (total != i) node->ReplaceInput(total, node->InputAt(i));
       total++;
     }
@@ skipping 58 matching lines @@
     case IrOpcode::kIfFalse:
       return impl.ReduceIfProjection(node, kFalse);
     default:
       return node;
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8