[turbofan] Run DeadCodeElimination together with the advanced reducers.

src/compiler/graph-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 <functional>
 #include <limits>
 
 #include "src/compiler/graph.h"
 #include "src/compiler/graph-reducer.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 enum class GraphReducer::State : uint8_t {
   kUnvisited,
   kRevisit,
   kOnStack,
   kVisited
 };
 
 
-GraphReducer::GraphReducer(Zone* zone, Graph* graph, Node* dead_value,
-                           Node* dead_control)
+GraphReducer::GraphReducer(Zone* zone, Graph* graph, Node* dead)
     : graph_(graph),
-      dead_value_(dead_value),
-      dead_control_(dead_control),
+      dead_(dead),
       state_(graph, 4),
       reducers_(zone),
       revisit_(zone),
       stack_(zone) {}
 
 
 GraphReducer::~GraphReducer() {}
 
 
 void GraphReducer::AddReducer(Reducer* reducer) {
@@ skipping 158 matching lines @@
                                     Node* control) {
   if (effect == nullptr && node->op()->EffectInputCount() > 0) {
     effect = NodeProperties::GetEffectInput(node);
   }
   if (control == nullptr && node->op()->ControlInputCount() > 0) {
     control = NodeProperties::GetControlInput(node);
   }
 
   // Requires distinguishing between value, effect and control edges.
   for (Edge edge : node->use_edges()) {
-    Node* user = edge.from();
+    Node* const user = edge.from();
+    DCHECK(!user->IsDead());
     if (NodeProperties::IsControlEdge(edge)) {
       if (user->opcode() == IrOpcode::kIfSuccess) {
         Replace(user, control);
       } else if (user->opcode() == IrOpcode::kIfException) {
-        for (Edge e : user->use_edges()) {
-          if (NodeProperties::IsValueEdge(e)) e.UpdateTo(dead_value_);
-          if (NodeProperties::IsEffectEdge(e)) e.UpdateTo(graph()->start());
-          if (NodeProperties::IsControlEdge(e)) e.UpdateTo(dead_control_);
-        }
-        edge.UpdateTo(user);
+        DCHECK_NOT_NULL(dead_);
+        edge.UpdateTo(dead_);
+        Revisit(user);
       } else {
         UNREACHABLE();
       }
     } else if (NodeProperties::IsEffectEdge(edge)) {
       DCHECK_NOT_NULL(effect);
       edge.UpdateTo(effect);
       Revisit(user);
     } else {
       DCHECK_NOT_NULL(value);
       edge.UpdateTo(value);
@@ skipping 27 matching lines @@
 void GraphReducer::Revisit(Node* node) {
   if (state_.Get(node) == State::kVisited) {
     state_.Set(node, State::kRevisit);
     revisit_.push(node);
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8