[turbofan] Initial work on cleaning up the Node class.

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 <deque>
 #include <set>
 #include <vector>
 
 #include "src/v8.h"
 
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/types.h"
 #include "src/zone.h"
 #include "src/zone-allocator.h"
 #include "src/zone-containers.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
+// Forward declarations.
 class Edge;
 class Graph;
 
+
 // Marks are used during traversal of the graph to distinguish states of nodes.
 // Each node has a mark which is a monotonically increasing integer, and a
 // {NodeMarker} has a range of values that indicate states of a node.
 typedef uint32_t Mark;
 
 // NodeIds are identifying numbers for nodes that can be used to index auxiliary
 // out-of-line data associated with each node.
 typedef int NodeId;
 
 // A Node is the basic primitive of graphs. Nodes are chained together by
@@ skipping 21 matching lines @@
   const Operator* op() const { return op_; }
   void set_op(const Operator* op) { op_ = op; }
 
   IrOpcode::Value opcode() const {
     DCHECK(op_->opcode() <= IrOpcode::kLast);
     return static_cast<IrOpcode::Value>(op_->opcode());
   }
 
   NodeId id() const { return id_; }
 
-  int InputCount() const { return input_count_; }
+  int InputCount() const { return input_count(); }
   Node* InputAt(int index) const { return GetInputRecordPtr(index)->to; }
   inline void ReplaceInput(int index, Node* new_input);
   inline void AppendInput(Zone* zone, Node* new_input);
   inline void InsertInput(Zone* zone, int index, Node* new_input);
   inline void RemoveInput(int index);
 
-  int UseCount() { return use_count_; }
-  Node* UseAt(int index) {
-    DCHECK(index < use_count_);
-    Use* current = first_use_;
-    while (index-- != 0) {
-      current = current->next;
-    }
-    return current->from;
-  }
+  int UseCount() const;
+  Node* UseAt(int index) const;
   inline void ReplaceUses(Node* replace_to);
   template <class UnaryPredicate>
   inline void ReplaceUsesIf(UnaryPredicate pred, Node* replace_to);
   inline void RemoveAllInputs();
 
   inline void TrimInputCount(int input_count);
 
   class InputEdges {
    public:
     class iterator;
@@ skipping 73 matching lines @@
    public:
     Node* to;
     Use* use;
 
     void Update(Node* new_to);
   };
 
   void EnsureAppendableInputs(Zone* zone);
 
   Input* GetInputRecordPtr(int index) const {
-    if (has_appendable_inputs_) {
+    if (has_appendable_inputs()) {
       return &((*inputs_.appendable_)[index]);
     } else {
-      return inputs_.static_ + index;
+      return &inputs_.static_[index];
     }
   }
 
   inline void AppendUse(Use* use);
   inline void RemoveUse(Use* use);
 
   void* operator new(size_t, void* location) { return location; }
 
  private:
-  Node(Graph* graph, int input_count, int reserve_input_count);
+  inline Node(NodeId id, int input_count, int reserve_input_count);
 
   typedef ZoneDeque<Input> InputDeque;
 
   friend class NodeProperties;
   template <typename State>
   friend class NodeMarker;
 
   // Only NodeProperties should manipulate the bounds.
   Bounds bounds() { return bounds_; }
   void set_bounds(Bounds b) { bounds_ = b; }
 
   // Only NodeMarkers should manipulate the marks on nodes.
   Mark mark() { return mark_; }
   void set_mark(Mark mark) { mark_ = mark; }
 
-  static const int kReservedInputCountBits = 2;
-  static const int kMaxReservedInputs = (1 << kReservedInputCountBits) - 1;
-  static const int kDefaultReservedInputs = kMaxReservedInputs;
+  int input_count() const { return InputCountField::decode(bit_field_); }
+  void set_input_count(int input_count) {
+    DCHECK_LE(0, input_count);
+    bit_field_ = InputCountField::update(bit_field_, input_count);
+  }
+
+  int reserved_input_count() const {
+    return ReservedInputCountField::decode(bit_field_);
+  }
+  void set_reserved_input_count(int reserved_input_count) {
+    DCHECK_LE(0, reserved_input_count);
+    bit_field_ =
+        ReservedInputCountField::update(bit_field_, reserved_input_count);
+  }
+
+  bool has_appendable_inputs() const {
+    return HasAppendableInputsField::decode(bit_field_);
+  }
+  void set_has_appendable_inputs(bool has_appendable_inputs) {
+    bit_field_ =
+        HasAppendableInputsField::update(bit_field_, has_appendable_inputs);
+  }
+
+  typedef BitField<unsigned, 0, 29> InputCountField;
+  typedef BitField<unsigned, 29, 2> ReservedInputCountField;
+  typedef BitField<unsigned, 31, 1> HasAppendableInputsField;
+  static const int kDefaultReservedInputs = ReservedInputCountField::kMax;
 
   const Operator* op_;
   Bounds bounds_;
   Mark mark_;
   NodeId id_;
-  int input_count_ : 29;
-  unsigned int reserve_input_count_ : kReservedInputCountBits;
-  bool has_appendable_inputs_ : 1;
+  unsigned bit_field_;
   union {
     // When a node is initially allocated, it uses a static buffer to hold its
     // inputs under the assumption that the number of outputs will not increase.
     // When the first input is appended, the static buffer is converted into a
     // deque to allow for space-efficient growing.
     Input* static_;
     InputDeque* appendable_;
   } inputs_;
-  int use_count_;
   Use* first_use_;
   Use* last_use_;
 
   DISALLOW_COPY_AND_ASSIGN(Node);
 };
 
 
 // An encapsulation for information associated with a single use of node as a
 // input from another node, allowing access to both the defining node and
 // the node having the input.
 class Edge {
  public:
   Node* from() const { return input_->use->from; }
   Node* to() const { return input_->to; }
   int index() const {
     int index = input_->use->input_index;
-    DCHECK(index < input_->use->from->input_count_);
+    DCHECK(index < input_->use->from->input_count());
     return index;
   }
 
   bool operator==(const Edge& other) { return input_ == other.input_; }
   bool operator!=(const Edge& other) { return !(*this == other); }
 
   void UpdateTo(Node* new_to) { input_->Update(new_to); }
 
  private:
   friend class Node::Uses::iterator;
@@ skipping 239 matching lines @@
   if (replace_to->last_use_ == NULL) {
     DCHECK_EQ(NULL, replace_to->first_use_);
     replace_to->first_use_ = first_use_;
     replace_to->last_use_ = last_use_;
   } else if (first_use_ != NULL) {
     DCHECK_NE(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_;
   }
-  replace_to->use_count_ += use_count_;
-  use_count_ = 0;
   first_use_ = NULL;
   last_use_ = NULL;
 }
 
 template <class UnaryPredicate>
 inline void Node::ReplaceUsesIf(UnaryPredicate pred, Node* replace_to) {
   for (Use* use = first_use_; use != NULL;) {
     Use* next = use->next;
     if (pred(use->from)) {
       RemoveUse(use);
       replace_to->AppendUse(use);
       use->from->GetInputRecordPtr(use->input_index)->to = replace_to;
     }
     use = next;
   }
 }
 
 inline void Node::RemoveAllInputs() {
   for (Edge edge : input_edges()) {
     edge.UpdateTo(NULL);
   }
 }
 
 inline void Node::TrimInputCount(int new_input_count) {
-  if (new_input_count == input_count_) return;  // Nothing to do.
+  if (new_input_count == input_count()) return;  // Nothing to do.
 
-  DCHECK(new_input_count < input_count_);
+  DCHECK(new_input_count < input_count());
 
   // Update inline inputs.
-  for (int i = new_input_count; i < input_count_; i++) {
+  for (int i = new_input_count; i < input_count(); i++) {
     Node::Input* input = GetInputRecordPtr(i);
     input->Update(NULL);
   }
-  input_count_ = new_input_count;
+  set_input_count(new_input_count);
 }
 
 inline void Node::ReplaceInput(int index, Node* new_to) {
   Input* input = GetInputRecordPtr(index);
   input->Update(new_to);
 }
 
 inline 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 != NULL) {
     old_to->RemoveUse(use);
   }
   to = new_to;
   // And put it into the new node's use list.
   if (new_to != NULL) {
     new_to->AppendUse(use);
   } else {
     use->next = NULL;
     use->prev = NULL;
   }
 }
 
 inline void Node::EnsureAppendableInputs(Zone* zone) {
-  if (!has_appendable_inputs_) {
+  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) {
+    for (int i = 0; i < input_count(); ++i) {
       deque->push_back(inputs_.static_[i]);
     }
     inputs_.appendable_ = deque;
-    has_appendable_inputs_ = true;
+    set_has_appendable_inputs(true);
   }
 }
 
 inline void Node::AppendInput(Zone* zone, Node* to_append) {
   Use* new_use = new (zone) Use;
   Input new_input;
   new_input.to = to_append;
   new_input.use = new_use;
-  if (reserve_input_count_ > 0) {
-    DCHECK(!has_appendable_inputs_);
-    reserve_input_count_--;
-    inputs_.static_[input_count_] = new_input;
+  if (reserved_input_count() > 0) {
+    DCHECK(!has_appendable_inputs());
+    set_reserved_input_count(reserved_input_count() - 1);
+    inputs_.static_[input_count()] = new_input;
   } else {
     EnsureAppendableInputs(zone);
     inputs_.appendable_->push_back(new_input);
   }
-  new_use->input_index = input_count_;
+  new_use->input_index = input_count();
   new_use->from = this;
   to_append->AppendUse(new_use);
-  input_count_++;
+  set_input_count(input_count() + 1);
 }
 
 inline void Node::InsertInput(Zone* zone, int index, Node* to_insert) {
   DCHECK(index >= 0 && index < InputCount());
   // TODO(turbofan): Optimize this implementation!
   AppendInput(zone, InputAt(InputCount() - 1));
   for (int i = InputCount() - 1; i > index; --i) {
     ReplaceInput(i, InputAt(i - 1));
   }
   ReplaceInput(index, to_insert);
@@ skipping 10 matching lines @@
 
 inline void Node::AppendUse(Use* use) {
   use->next = NULL;
   use->prev = last_use_;
   if (last_use_ == NULL) {
     first_use_ = use;
   } else {
     last_use_->next = use;
   }
   last_use_ = use;
-  ++use_count_;
 }
 
 inline void Node::RemoveUse(Use* use) {
   if (last_use_ == use) {
     last_use_ = use->prev;
   }
   if (use->prev != NULL) {
     use->prev->next = use->next;
   } else {
     first_use_ = use->next;
   }
   if (use->next != NULL) {
     use->next->prev = use->prev;
   }
-  --use_count_;
 }
 
 inline bool Node::OwnedBy(Node* owner) const {
   return first_use_ != NULL && first_use_->from == owner &&
          first_use_->next == NULL;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_NODE_H_