[turbofan] Clean up cached nodes in JSGraph.

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/js-graph.h"
 #include "src/compiler/node-marker.h"
 #include "src/compiler/node-matchers.h"
@@ skipping 82 matching lines @@
 
   // Repair the graph after the possible creation of non-terminating or dead
   // loops. Removing dead loops can produce more opportunities for reduction.
   bool RepairAndRemoveLoops() {
     // TODO(turbofan): we can skip this if the graph has no loops, but
     // we have to be careful about proper loop detection during reduction.
 
     // Gather all nodes backwards-reachable from end (through inputs).
     ReachabilityMarker marked(graph());
     NodeVector nodes(zone_);
-    AddNodesReachableFromEnd(marked, nodes);
+    AddNodesReachableFromRoots(marked, nodes);
 
     // Walk forward through control nodes, looking for back edges to nodes
     // that are not connected to end. Those are non-terminating loops (NTLs).
     Node* start = graph()->start();
     marked.Push(start);
     marked.SetReachableFromStart(start);
 
     // We use a stack of (Node, Node::UseEdges::iterator) pairs to avoid
     // O(n^2) traversal.
     typedef std::pair<Node*, Node::UseEdges::iterator> FwIter;
@@ skipping 37 matching lines @@
         }
         ++fw_stack.back().second;
       }
       if (pop) {
         marked.Pop(node);
         fw_stack.pop_back();
       }
     }
 
     // Trim references from dead nodes to live nodes first.
-    jsgraph_->GetCachedNodes(&nodes);
     TrimNodes(marked, nodes);
 
     // Any control nodes not reachable from start are dead, even loops.
     for (size_t i = 0; i < nodes.size(); i++) {
       Node* node = nodes[i];
       if (node->op()->ControlOutputCount() > 0 &&
           !marked.IsReachableFromStart(node)) {
         ReplaceNode(node, dead());  // uses will be added to revisit queue.
       }
     }
@@ skipping 72 matching lines @@
       // Mark the node as visited so that we can revisit later.
       MarkAsVisited(merge);
     } else {
       // Append a new input to the final merge at the end.
       merge->AppendInput(graph()->zone(), ret);
       merge->set_op(common_->Merge(merge->InputCount()));
     }
     return ret;
   }
 
-  void AddNodesReachableFromEnd(ReachabilityMarker& marked, NodeVector& nodes) {
+  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);
-      AddBackwardsReachableNodes(marked, nodes, nodes.size() - 1);
-    }
+    if (!end->IsDead()) nodes.push_back(end);  // Consider end to be a root.
+    for (Node* node : nodes) marked.SetReachableFromEnd(node);
+    AddBackwardsReachableNodes(marked, nodes, 0);
   }
 
   void AddBackwardsReachableNodes(ReachabilityMarker& marked, NodeVector& nodes,
                                   size_t cursor) {
     while (cursor < nodes.size()) {
       Node* node = nodes[cursor++];
       for (Node* const input : node->inputs()) {
         if (!marked.SetReachableFromEnd(input)) {
           nodes.push_back(input);
         }
       }
     }
   }
 
   void Trim() {
     // Gather all nodes backwards-reachable from end through inputs.
     ReachabilityMarker marked(graph());
     NodeVector nodes(zone_);
-    AddNodesReachableFromEnd(marked, nodes);
-
-    // Process cached nodes in the JSGraph too.
     jsgraph_->GetCachedNodes(&nodes);
+    AddNodesReachableFromRoots(marked, nodes);
     TrimNodes(marked, nodes);
   }
 
   void TrimNodes(ReachabilityMarker& marked, NodeVector& nodes) {
     // Remove dead->live edges.
     for (size_t j = 0; j < nodes.size(); j++) {
       Node* node = nodes[j];
       for (Edge edge : node->use_edges()) {
         Node* use = edge.from();
         if (!marked.IsReachableFromEnd(use)) {
@@ skipping 414 matching lines @@
       return impl.ReduceIfProjection(node, kTrue);
     case IrOpcode::kIfFalse:
       return impl.ReduceIfProjection(node, kFalse);
     default:
       return node;
   }
 }
 }
 }
 }  // namespace v8::internal::compiler