[turbofan] Use Node input iterators where possible

src/compiler/node.h

 // Copyright 2013 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.
 
 #ifndef V8_COMPILER_NODE_H_
 #define V8_COMPILER_NODE_H_
 
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/compiler/types.h"
@@ skipping 392 matching lines @@
   bool operator==(const iterator& other) const {
     return input_ptr_ == other.input_ptr_;
   }
   bool operator!=(const iterator& other) const { return !(*this == other); }
   iterator& operator++() {
     input_ptr_++;
     use_--;
     return *this;
   }
   iterator operator++(int);
+  iterator& operator+=(difference_type offset) {
+    input_ptr_ += offset;
+    use_ -= offset;
+    return *this;
+  }
+  iterator operator+(difference_type offset) const {
+    return iterator(use_ - offset, input_ptr_ + offset);
+  }
+  difference_type operator-(const iterator& other) const {
+    return static_cast<difference_type>(input_ptr_ - other.input_ptr_);
+  }
 
  private:
   friend class Node;
 
   explicit iterator(Node* from, int index = 0)
       : use_(from->GetUsePtr(index)), input_ptr_(from->GetInputPtr(index)) {}
 
+  explicit iterator(Use* use, Node** input_ptr)
+      : use_(use), input_ptr_(input_ptr) {}
+
   Use* use_;
   Node** input_ptr_;
 };
 
 
 Node::InputEdges::iterator Node::InputEdges::begin() const {
   return Node::InputEdges::iterator(this->node_, 0);
 }
 
 
@@ skipping 18 matching lines @@
     return iter_ == other.iter_;
   }
   bool operator!=(const const_iterator& other) const {
     return !(*this == other);
   }
   const_iterator& operator++() {
     ++iter_;
     return *this;
   }
   const_iterator operator++(int);
+  const_iterator& operator+=(difference_type offset) {
+    iter_ += offset;
+    return *this;
+  }
+  const_iterator operator+(difference_type offset) const {
+    return const_iterator(iter_ + offset);
+  }
+  difference_type operator-(const const_iterator& other) const {
+    return iter_ - other.iter_;
+  }
 
  private:
   friend class Node::Inputs;
 
   const_iterator(Node* node, int index) : iter_(node, index) {}
 
+  explicit const_iterator(Node::InputEdges::iterator iter) : iter_(iter) {}
+
   Node::InputEdges::iterator iter_;
 };
 
 
 Node::Inputs::const_iterator Node::Inputs::begin() const {
   return const_iterator(this->node_, 0);
 }
 
 
 Node::Inputs::const_iterator Node::Inputs::end() const {
@@ skipping 83 matching lines @@
 }
 
 
 Node::Uses::const_iterator Node::Uses::end() const { return const_iterator(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_NODE_H_