[turbofan] Cleanup Graph and related classes.

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/types-inl.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;
+typedef int32_t 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:
-  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);
 
   const Operator* op() const { return op_; }
   void set_op(const Operator* op) { op_ = op; }
 
   IrOpcode::Value opcode() const {
@@ skipping 72 matching lines @@
 
    private:
     Node* node_;
   };
 
   Uses uses() { return Uses(this); }
   UseEdges use_edges() { return UseEdges(this); }
 
   bool OwnedBy(Node* owner) const;
 
-  static Node* New(Graph* graph, int input_count, Node** inputs,
-                   bool has_extensible_inputs);
+  static Node* New(Zone* zone, NodeId id, const Operator* op, int input_count,
+                   Node** inputs, bool has_extensible_inputs);
 
  protected:
   friend class Graph;
   friend class Edge;
 
   class Use : public ZoneObject {
    public:
     Node* from;
     Use* next;
     Use* prev;
@@ skipping 17 matching lines @@
       return &inputs_.static_[index];
     }
   }
 
   inline void AppendUse(Use* use);
   inline void RemoveUse(Use* use);
 
   void* operator new(size_t, void* location) { return location; }
 
  private:
-  inline Node(NodeId id, int input_count, int reserve_input_count);
+  inline Node(NodeId id, const Operator* op, int input_count,
+              int reserve_input_count);
 
   typedef ZoneDeque<Input> InputDeque;
 
+  friend class NodeMarkerBase;
   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; }
 
   int input_count() const { return InputCountField::decode(bit_field_); }
@@ skipping 231 matching lines @@
   Input* CurrentInput() const {
     return current_->from->GetInputRecordPtr(current_->input_index);
   }
 
   Node::Use* current_;
 };
 
 
 std::ostream& operator<<(std::ostream& os, const Node& n);
 
-typedef std::set<Node*, std::less<Node*>, zone_allocator<Node*> > NodeSet;
-typedef NodeSet::iterator NodeSetIter;
-typedef NodeSet::reverse_iterator NodeSetRIter;
-
 typedef ZoneDeque<Node*> NodeDeque;
 
 typedef ZoneVector<Node*> NodeVector;
 typedef NodeVector::iterator NodeVectorIter;
 typedef NodeVector::const_iterator NodeVectorConstIter;
 typedef NodeVector::reverse_iterator NodeVectorRIter;
 
 typedef ZoneVector<NodeVector> NodeVectorVector;
 typedef NodeVectorVector::iterator NodeVectorVectorIter;
 typedef NodeVectorVector::reverse_iterator NodeVectorVectorRIter;
@@ skipping 194 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_