Remove deprecated NodeData 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>
@@ skipping 12 matching lines @@
 namespace internal {
 namespace compiler {
 
 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;
 
-class NodeData {
- public:
-  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());
-  }
-
- protected:
-  const Operator* op_;
-  Bounds bounds_;
-  Mark mark_;
-  explicit NodeData(Zone* zone) {}
-
-  friend class NodeProperties;
-  template <typename State>
-  friend class NodeMarker;
-
-  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; }
-};
-
+// 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
 // input/use chains but by default otherwise contain only an identifying number
 // which specific applications of graphs and nodes can use to index auxiliary
 // out-of-line data, especially transient data.
 //
 // In addition Nodes only contain a mutable Operator that may change during
 // compilation, e.g. during lowering passes. Other information that needs to be
 // associated with Nodes during compilation must be stored out-of-line indexed
 // by the Node's id.
-class Node FINAL : public NodeData {
+class Node FINAL {
  public:
   void Initialize(const Operator* op) {
     set_op(op);
     set_mark(0);
   }
 
   bool IsDead() const { return InputCount() > 0 && InputAt(0) == NULL; }
   void Kill();
 
   void CollectProjections(ZoneVector<Node*>* projections);
   Node* FindProjection(size_t projection_index);
 
-  inline NodeId id() const { return id_; }
+  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_; }
   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) {
@@ skipping 79 matching lines @@
   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);
 
   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;
 
+  const Operator* op_;
+  Bounds bounds_;
+  Mark mark_;
   NodeId id_;
   int input_count_ : 29;
   unsigned int reserve_input_count_ : kReservedInputCountBits;
   bool has_appendable_inputs_ : 1;
   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 ndoe having the input.
 class Node::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_);
     return index;
   }
 
  private:
   friend class Node::Uses::iterator;
   friend class Node::Inputs::iterator;
 
   explicit Edge(Node::Input* input) : input_(input) {}
 
   Node::Input* input_;
 };
 
+
 // A forward iterator to visit the nodes which are depended upon by a node
 // in the order of input.
 class Node::Inputs::iterator {
  public:
   iterator(const Node::Inputs::iterator& other)  // NOLINT
       : node_(other.node_),
         index_(other.index_) {}
 
   Node* operator*() { return GetInput()->to; }
   Node::Edge edge() { return Node::Edge(GetInput()); }
@@ skipping 19 matching lines @@
   friend class Node;
 
   explicit iterator(Node* node, int index) : node_(node), index_(index) {}
 
   Input* GetInput() const { return node_->GetInputRecordPtr(index_); }
 
   Node* node_;
   int index_;
 };
 
+
 // A forward iterator to visit the uses of a node. The uses are returned in
 // the order in which they were added as inputs.
 class Node::Uses::iterator {
  public:
   iterator(const Node::Uses::iterator& other)  // NOLINT
       : current_(other.current_),
         index_(other.index_) {}
 
   Node* operator*() { return current_->from; }
   Node::Edge edge() { return Node::Edge(CurrentInput()); }
@@ skipping 23 matching lines @@
   explicit iterator(Node* node) : current_(node->first_use_), index_(0) {}
 
   Input* CurrentInput() const {
     return current_->from->GetInputRecordPtr(current_->input_index);
   }
 
   Node::Use* current_;
   int index_;
 };
 
+
 std::ostream& operator<<(std::ostream& os, const Node& n);
 
 typedef GenericGraphVisit::NullNodeVisitor NullNodeVisitor;
 
 typedef std::set<Node*, std::less<Node*>, zone_allocator<Node*> > NodeSet;
 typedef NodeSet::iterator NodeSetIter;
 typedef NodeSet::reverse_iterator NodeSetRIter;
 
 typedef ZoneDeque<Node*> NodeDeque;
 
@@ skipping 186 matching lines @@
 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_