-//===- llvm/Analysis/Interval.h - Interval Class Declaration -----*- C++ -*--=//
+//===- llvm/Analysis/Interval.h - Interval Class Declaration ----*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
//
-// This file contains the declaration of the cfg::Interval class, which
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the declaration of the Interval class, which
// represents a set of CFG nodes and is a portion of an interval partition.
//
// Intervals have some interesting and useful properties, including the
#ifndef LLVM_INTERVAL_H
#define LLVM_INTERVAL_H
+#include "Support/GraphTraits.h"
#include <vector>
+#include <iosfwd>
-class BasicBlock;
+namespace llvm {
-namespace cfg {
+class BasicBlock;
//===----------------------------------------------------------------------===//
//
// Successors - List of BasicBlocks that are reachable directly from nodes in
// this interval, but are not in the interval themselves.
- // These nodes neccesarily must be header nodes for other intervals.
+ // These nodes necessarily must be header nodes for other intervals.
//
std::vector<BasicBlock*> Successors;
// isLoop - Find out if there is a back edge in this interval...
bool isLoop() const;
+ // print - Show contents in human readable format...
+ void print(std::ostream &O) const;
+};
- // succ_begin/succ_end - define methods so that Intervals may be used
- // just like BasicBlocks can with the succ_* functions, and *::succ_iterator.
- //
- inline succ_iterator succ_begin() { return Successors.begin(); }
- inline succ_iterator succ_end() { return Successors.end(); }
+// succ_begin/succ_end - define methods so that Intervals may be used
+// just like BasicBlocks can with the succ_* functions, and *::succ_iterator.
+//
+inline Interval::succ_iterator succ_begin(Interval *I) {
+ return I->Successors.begin();
+}
+inline Interval::succ_iterator succ_end(Interval *I) {
+ return I->Successors.end();
+}
- // pred_begin/pred_end - define methods so that Intervals may be used
- // just like BasicBlocks can with the pred_* functions, and *::pred_iterator.
- //
- inline Interval::pred_iterator pred_begin() { return Predecessors.begin(); }
- inline Interval::pred_iterator pred_end() { return Predecessors.end(); }
+// pred_begin/pred_end - define methods so that Intervals may be used
+// just like BasicBlocks can with the pred_* functions, and *::pred_iterator.
+//
+inline Interval::pred_iterator pred_begin(Interval *I) {
+ return I->Predecessors.begin();
+}
+inline Interval::pred_iterator pred_end(Interval *I) {
+ return I->Predecessors.end();
+}
+
+template <> struct GraphTraits<Interval*> {
+ typedef Interval NodeType;
+ typedef Interval::succ_iterator ChildIteratorType;
+
+ static NodeType *getEntryNode(Interval *I) { return I; }
+
+ // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
+ static inline ChildIteratorType child_begin(NodeType *N) {
+ return succ_begin(N);
+ }
+ static inline ChildIteratorType child_end(NodeType *N) {
+ return succ_end(N);
+ }
+};
+
+template <> struct GraphTraits<Inverse<Interval*> > {
+ typedef Interval NodeType;
+ typedef Interval::pred_iterator ChildIteratorType;
+ static NodeType *getEntryNode(Inverse<Interval *> G) { return G.Graph; }
+ static inline ChildIteratorType child_begin(NodeType *N) {
+ return pred_begin(N);
+ }
+ static inline ChildIteratorType child_end(NodeType *N) {
+ return pred_end(N);
+ }
};
-} // End namespace cfg
+} // End llvm namespace
#endif