[turbofan] Preserve Bounds when cloning nodes in the scheduler.

src/compiler/node.cc

 // 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.
 
 #include "src/compiler/node.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
@@ skipping 32 matching lines @@
     old_input_ptr++;
     new_input_ptr++;
     old_use_ptr--;
     new_use_ptr--;
   }
   this->count_ = count;
 }
 
 
 Node* Node::New(Zone* zone, NodeId id, const Operator* op, int input_count,
-                Node** inputs, bool has_extensible_inputs) {
+                Node* const* inputs, bool has_extensible_inputs) {
   Node** input_ptr;
   Use* use_ptr;
   Node* node;
   bool is_inline;
 
   if (input_count > kMaxInlineCapacity) {
     // Allocate out-of-line inputs.
     int capacity =
         has_extensible_inputs ? input_count + kMaxInlineCapacity : input_count;
     OutOfLineInputs* outline = OutOfLineInputs::New(zone, capacity);
@@ skipping 35 matching lines @@
     Use* use = use_ptr - 1 - current;
     use->bit_field_ = Use::InputIndexField::encode(current) |
                       Use::InlineField::encode(is_inline);
     to->AppendUse(use);
   }
   node->Verify();
   return node;
 }
 
 
+Node* Node::Clone(Zone* zone, NodeId id, const Node* node) {
+  int const input_count = node->InputCount();
+  Node* const* const inputs = node->has_inline_inputs()
+                                  ? node->inputs_.inline_
+                                  : node->inputs_.outline_->inputs_;
+  Node* const clone = New(zone, id, node->op(), input_count, inputs, false);
+  clone->set_bounds(node->bounds());
+  return clone;
+}
+
+
 void Node::Kill() {
   DCHECK_NOT_NULL(op());
   NullAllInputs();
   DCHECK(uses().empty());
 }
 
 
 void Node::AppendInput(Zone* zone, Node* new_to) {
   DCHECK_NOT_NULL(zone);
   DCHECK_NOT_NULL(new_to);
@@ skipping 265 matching lines @@
   ++(*this);
   return result;
 }
 
 
 bool Node::Uses::empty() const { return begin() == end(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8