[turbofan] Allow indexed access to node inputs/input_edges

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.
 
+  Node::Inputs node_inputs = node->inputs();
+
   // Recurse on an input if necessary.
-  int start = entry.input_index < node->InputCount() ? entry.input_index : 0;
-
-  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;
+  int start = entry.input_index < node_inputs.count() ? entry.input_index : 0;
+  for (int i = start; i < node_inputs.count(); ++i) {
+    Node* input = node_inputs[i];

[Jarin, 2017/01/10 10:53:39]

Nice, I like this more than the iterator-heavy stuff.

     if (input != node && Recurse(input)) {
-      entry.input_index = (it - node_inputs_begin) + 1;
+      entry.input_index = i + 1;
       return;
     }
   }
-  for (auto it = node_inputs_begin; it != node_inputs_begin + start; ++it) {
-    Node* input = *it;
+  for (int i = 0; i < start; ++i) {
+    Node* input = node_inputs[i];
     if (input != node && Recurse(input)) {
-      entry.input_index = (it - node_inputs_begin) + 1;
+      entry.input_index = i + 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.
     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;
+    for (int i = 0; i < node_inputs.count(); ++i) {
+      Node* input = node_inputs[i];
       if (input != node && Recurse(input)) {
-        entry.input_index = (it - node_inputs_begin) + 1;
+        entry.input_index = i + 1;
         return;
       }
     }
   }
 
   // After reducing the node, pop it off the stack.
   Pop();
 
   // Check if we have a new replacement.
   if (replacement != node) {
@@ skipping 115 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