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/compiler/generic-algorithm.h"
#include "src/compiler/generic-node.h"
#include "src/compiler/opcodes.h"
#include "src/compiler/operator.h"
#include "src/types.h"
#include "src/zone.h"
#include "src/zone-allocator.h"

namespace v8 {
namespace internal {
namespace compiler {

class NodeData {
 public:
  Operator* op() const { return op_; }
  void set_op(Operator* op) { op_ = op; }

  IrOpcode::Value opcode() const {
    DCHECK(op_->opcode() <= IrOpcode::kLast);
    return static_cast<IrOpcode::Value>(op_->opcode());
  }

  Bounds bounds() { return bounds_; }

 protected:
  Operator* op_;
  Bounds bounds_;
  explicit NodeData(Zone* zone) : bounds_(Bounds(Type::None(zone))) {}

  friend class NodeProperties;
  void set_bounds(Bounds b) { bounds_ = b; }
};

// A Node is the basic primitive of an IR graph. In addition to the members
// inherited from Vector, 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 : public GenericNode<NodeData, Node> {
 public:
  Node(GenericGraphBase* graph, int input_count)
      : GenericNode<NodeData, Node>(graph, input_count) {}

  void Initialize(Operator* op) { set_op(op); }

  void CollectProjections(int projection_count, Node** projections);
  Node* FindProjection(int32_t projection_index);
};

OStream& operator<<(OStream& os, const Node& n);

typedef GenericGraphVisit::NullNodeVisitor<NodeData, Node> NullNodeVisitor;

typedef zone_allocator<Node*> NodePtrZoneAllocator;

typedef std::set<Node*, std::less<Node*>, NodePtrZoneAllocator> NodeSet;
typedef NodeSet::iterator NodeSetIter;
typedef NodeSet::reverse_iterator NodeSetRIter;

typedef std::deque<Node*, NodePtrZoneAllocator> NodeDeque;
typedef NodeDeque::iterator NodeDequeIter;

typedef std::vector<Node*, NodePtrZoneAllocator> NodeVector;
typedef NodeVector::iterator NodeVectorIter;
typedef NodeVector::reverse_iterator NodeVectorRIter;

typedef zone_allocator<NodeVector> ZoneNodeVectorAllocator;
typedef std::vector<NodeVector, ZoneNodeVectorAllocator> NodeVectorVector;
typedef NodeVectorVector::iterator NodeVectorVectorIter;
typedef NodeVectorVector::reverse_iterator NodeVectorVectorRIter;

typedef Node::Uses::iterator UseIter;
typedef Node::Inputs::iterator InputIter;

// Helper to extract parameters from Operator1<*> nodes.
template <typename T>
static inline T OpParameter(Node* node) {
  return reinterpret_cast<Operator1<T>*>(node->op())->parameter();
}
}
}
}  // namespace v8::internal::compiler

#endif  // V8_COMPILER_NODE_H_