[turbofan] Use Node input iterators where possible

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"
@@ skipping 97 matching lines @@
 
 void GraphReducer::ReduceTop() {
   NodeState& entry = stack_.top();
   Node* node = entry.node;
   DCHECK(state_.Get(node) == State::kOnStack);
 
   if (node->IsDead()) return Pop();  // Node was killed while on stack.
 
   // Recurse on an input if necessary.
   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;
+
+  Node::Inputs node_inputs = node->inputs();
+  auto node_inputs_begin = node_inputs.begin();
+  auto node_inputs_end = node_inputs.end();
+  DCHECK(node_inputs_end == node_inputs_begin + node->InputCount());
+
+  for (auto it = node_inputs_begin + start; it != node_inputs_end; ++it) {
+    Node* input = *it;
+    if (input != node && Recurse(input)) {
+      entry.input_index = (it - node_inputs_begin) + 1;
+      return;
+    }
   }
-  for (int i = 0; i < start; i++) {
-    Node* input = node->InputAt(i);
-    entry.input_index = i + 1;
-    if (input != node && Recurse(input)) return;
+  for (auto it = node_inputs_begin; it != node_inputs_begin + start; ++it) {
+    Node* input = *it;
+    if (input != node && Recurse(input)) {
+      entry.input_index = (it - node_inputs_begin) + 1;
+      return;
+    }
   }
 
   // Remember the max node id before reduction.
   NodeId const max_id = static_cast<NodeId>(graph()->NodeCount() - 1);
 
   // All inputs should be visited or on stack. Apply reductions to node.
   Reduction reduction = Reduce(node);
 
   // If there was no reduction, pop {node} and continue.
   if (!reduction.Changed()) return Pop();
 
   // Check if the reduction is an in-place update of the {node}.
   Node* const replacement = reduction.replacement();
   if (replacement == node) {
     // In-place update of {node}, may need to recurse on an input.
-    for (int i = 0; i < node->InputCount(); ++i) {
-      Node* input = node->InputAt(i);
-      entry.input_index = i + 1;
-      if (input != node && Recurse(input)) return;
+    Node::Inputs node_inputs = node->inputs();
+    auto node_inputs_begin = node_inputs.begin();
+    auto node_inputs_end = node_inputs.end();
+    for (auto it = node_inputs_begin; it != node_inputs_end; ++it) {
+      Node* input = *it;
+      if (input != node && Recurse(input)) {
+        entry.input_index = (it - node_inputs_begin) + 1;
+        return;
+      }
     }
   }
 
   // After reducing the node, pop it off the stack.
   Pop();
 
   // Check if we have a new replacement.
   if (replacement != node) {
     Replace(node, replacement, max_id);
   } else {
@@ skipping 113 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