[turbofan] Avoid repeatedly revisiting inputs in GraphReducer.

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 "src/compiler/graph-reducer.h"
 
 #include <functional>
 
 #include "src/compiler/graph-inl.h"
 
@@ skipping 81 matching lines @@
   if (skip == reducers_.end()) {
     // No change from any reducer.
     return Reducer::NoChange();
   }
   // At least one reducer did some in-place reduction.
   return Reducer::Changed(node);
 }
 
 
 void GraphReducer::ReduceTop() {
-  Node* const node = Top();
+  NodeState& entry = stack_.top();
+  Node* node = entry.node;
+  DCHECK(state_[node->id()] == State::kOnStack);
+
   if (node->IsDead()) return Pop();  // Node was killed while on stack.
 
   // Recurse on an input if necessary.
-  for (auto const input : node->inputs()) {
+  int start = entry.input_index < node->InputCount() ? entry.input_index : 0;
+  for (int i = start; i < node->InputCount(); i++) {
+    Node* input = node->InputAt(i);
+    entry.input_index = i + 1;
+    if (input != node && Recurse(input)) return;
+  }
+  for (int i = 0; i < start; i++) {
+    Node* input = node->InputAt(i);
+    entry.input_index = i + 1;
     if (input != node && Recurse(input)) return;
   }
 
   // Remember the node count before reduction.
   const int node_count = graph()->NodeCount();
 
   // All inputs should be visited or on stack. Apply reductions to node.
   Reduction reduction = Reduce(node);
 
   // After reducing the node, pop it off the stack.
@@ skipping 29 matching lines @@
 
         // If there was a replacement, reduce it after popping {node}.
         Recurse(replacement);
       }
     }
   }
 }
 
 
 void GraphReducer::Pop() {
-  Node* const node = Top();
+  Node* const node = stack_.top().node;
   state_[node->id()] = State::kVisited;
   stack_.pop();
 }
 
 
 void GraphReducer::Push(Node* const node) {
   size_t const id = static_cast<size_t>(node->id());
   if (id >= state_.size()) state_.resize(id + 1);
   DCHECK(id < state_.size());
   DCHECK(state_[id] != State::kOnStack);
   state_[id] = State::kOnStack;
-  stack_.push(node);
+  stack_.push({node, 0});
 }
 
 
-Node* GraphReducer::Top() const {
-  DCHECK(!stack_.empty());
-  Node* const node = stack_.top();
-  size_t const id = static_cast<size_t>(node->id());
-  DCHECK(id < state_.size());
-  DCHECK(state_[id] == State::kOnStack);
-  USE(id);
-  return node;
-}
-
-
 bool GraphReducer::Recurse(Node* const node) {
   size_t const id = static_cast<size_t>(node->id());
   if (id < state_.size() && state_[id] > State::kRevisit) return false;
   Push(node);
   return true;
 }
 
 
 void GraphReducer::Revisit(Node* const node) {
   size_t const id = static_cast<size_t>(node->id());
   if (id < state_.size() && state_[id] == State::kVisited) {
     state_[id] = State::kRevisit;
     revisit_.push(node);
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8