[turbofan] Remove last_use_ field from Node.

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"
 
 #include <algorithm>
 
 namespace v8 {
 namespace internal {
@@ skipping 100 matching lines @@
 
 int Node::UseCount() const {
   int use_count = 0;
   for (const Use* use = first_use_; use; use = use->next) {
     ++use_count;
   }
   return use_count;
 }
 
 
-Node* Node::UseAt(int index) const {
-  DCHECK_LE(0, index);
-  DCHECK_LT(index, UseCount());
-  const Use* use = first_use_;
-  while (index-- != 0) {
-    use = use->next;
+void Node::ReplaceUses(Node* that) {
+  DCHECK(this->first_use_ == nullptr || this->first_use_->prev == nullptr);
+  DCHECK(that->first_use_ == nullptr || that->first_use_->prev == nullptr);
+
+  // Update the pointers to {this} to point to {that}.
+  Use* last_use = nullptr;
+  for (Use* use = this->first_use_; use; use = use->next) {
+    use->from->GetInputRecordPtr(use->input_index)->to = that;
+    last_use = use;
   }
-  return use->from;
+  if (last_use) {
+    // Concat the use list of {this} and {that}.
+    last_use->next = that->first_use_;
+    if (that->first_use_) that->first_use_->prev = last_use;
+    that->first_use_ = this->first_use_;
+  }
+  first_use_ = nullptr;
 }
 
 
-void Node::ReplaceUses(Node* replace_to) {
-  for (Use* use = first_use_; use; use = use->next) {
-    use->from->GetInputRecordPtr(use->input_index)->to = replace_to;
-  }
-  if (!replace_to->last_use_) {
-    DCHECK(!replace_to->first_use_);
-    replace_to->first_use_ = first_use_;
-    replace_to->last_use_ = last_use_;
-  } else if (first_use_) {
-    DCHECK_NOT_NULL(replace_to->first_use_);
-    replace_to->last_use_->next = first_use_;
-    first_use_->prev = replace_to->last_use_;
-    replace_to->last_use_ = last_use_;
-  }
-  first_use_ = nullptr;
-  last_use_ = nullptr;
-}
-
-
 void Node::Input::Update(Node* new_to) {
   Node* old_to = this->to;
   if (new_to == old_to) return;  // Nothing to do.
   // Snip out the use from where it used to be
   if (old_to) {
     old_to->RemoveUse(use);
   }
   to = new_to;
   // And put it into the new node's use list.
   if (new_to) {
     new_to->AppendUse(use);
   } else {
     use->next = nullptr;
     use->prev = nullptr;
   }
 }
 
 
 Node::Node(NodeId id, const Operator* op, int input_count,
            int reserved_input_count)
     : op_(op),
       mark_(0),
       id_(id),
       bit_field_(InputCountField::encode(input_count) |
                  ReservedInputCountField::encode(reserved_input_count) |
                  HasAppendableInputsField::encode(false)),
-      first_use_(nullptr),
-      last_use_(nullptr) {}
+      first_use_(nullptr) {}
 
 
 void Node::EnsureAppendableInputs(Zone* zone) {
   if (!has_appendable_inputs()) {
     void* deque_buffer = zone->New(sizeof(InputDeque));
     InputDeque* deque = new (deque_buffer) InputDeque(zone);
     for (int i = 0; i < input_count(); ++i) {
       deque->push_back(inputs_.static_[i]);
     }
     inputs_.appendable_ = deque;
     set_has_appendable_inputs(true);
   }
 }
 
 
 void Node::AppendUse(Use* const use) {
-  use->next = nullptr;
-  use->prev = last_use_;
-  if (last_use_) {
-    last_use_->next = use;
-  } else {
-    first_use_ = use;
-  }
-  last_use_ = use;
+  DCHECK(first_use_ == nullptr || first_use_->prev == nullptr);
+  use->next = first_use_;
+  use->prev = nullptr;
+  if (first_use_) first_use_->prev = use;
+  first_use_ = use;
 }
 
 
 void Node::RemoveUse(Use* const use) {
-  if (use == last_use_) {
-    last_use_ = use->prev;
-  }
+  DCHECK(first_use_ == nullptr || first_use_->prev == nullptr);
   if (use->prev) {
+    DCHECK_NE(first_use_, use);
     use->prev->next = use->next;
   } else {
+    DCHECK_EQ(first_use_, use);
     first_use_ = use->next;
   }
   if (use->next) {
     use->next->prev = use->prev;
   }
 }
 
 
 std::ostream& operator<<(std::ostream& os, const Node& n) {
   os << n.id() << ": " << *n.op();
@@ skipping 44 matching lines @@
   ++(*this);
   return result;
 }
 
 
 bool Node::Uses::empty() const { return begin() == end(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8