Tweak argument

[oota-llvm.git] / include / llvm / Analysis / Interval.h

diff --git a/include/llvm/Analysis/Interval.h b/include/llvm/Analysis/Interval.h
index 1d708b691cdb809324fc3ca250ecd4d3dbea7e9e..0d5912305bc57ee8296ea6e8f9d0b424c2b3ada9 100644 (file)
--- a/include/llvm/Analysis/Interval.h
+++ b/include/llvm/Analysis/Interval.h
@@ -1,6 +1,13 @@
-//===- 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
@@ -13,11 +20,13 @@
 #ifndef LLVM_INTERVAL_H
 #define LLVM_INTERVAL_H
 
+#include "Support/GraphTraits.h"
 #include <vector>
+#include <iosfwd>
 
-class BasicBlock;
+namespace llvm {
 
-namespace cfg {
+class BasicBlock;
 
 //===----------------------------------------------------------------------===//
 //
@@ -31,9 +40,9 @@ class Interval {
   //
   BasicBlock *HeaderNode;
 public:
-  typedef vector<BasicBlock*>::iterator succ_iterator;
-  typedef vector<BasicBlock*>::iterator pred_iterator;
-  typedef vector<BasicBlock*>::iterator node_iterator;
+  typedef std::vector<BasicBlock*>::iterator succ_iterator;
+  typedef std::vector<BasicBlock*>::iterator pred_iterator;
+  typedef std::vector<BasicBlock*>::iterator node_iterator;
 
   inline Interval(BasicBlock *Header) : HeaderNode(Header) {
     Nodes.push_back(Header);
@@ -46,18 +55,18 @@ public:
 
   // Nodes - The basic blocks in this interval.
   //
-  vector<BasicBlock*> Nodes;
+  std::vector<BasicBlock*> Nodes;
 
   // 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.
   //
-  vector<BasicBlock*> Successors;
+  std::vector<BasicBlock*> Successors;
 
   // Predecessors - List of BasicBlocks that have this Interval's header block
   // as one of their successors.
   //
-  vector<BasicBlock*> Predecessors;
+  std::vector<BasicBlock*> Predecessors;
 
   // contains - Find out if a basic block is in this interval
   inline bool contains(BasicBlock *BB) const {
@@ -87,29 +96,58 @@ public:
 
   // 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 global functions so that Intervals may be used
+// 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) { 
+inline Interval::succ_iterator succ_begin(Interval *I) {
   return I->Successors.begin();
 }
-inline Interval::succ_iterator succ_end(Interval *I) { 
+inline Interval::succ_iterator succ_end(Interval *I)   {
   return I->Successors.end();
 }
-
-// pred_begin/pred_end - define global functions so that Intervals may be used
+  
+// 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) { 
+inline Interval::pred_iterator pred_begin(Interval *I) {
   return I->Predecessors.begin();
 }
-inline Interval::pred_iterator pred_end(Interval *I) { 
+inline Interval::pred_iterator pred_end(Interval *I)   {
   return I->Predecessors.end();
 }
 
-}    // End namespace cfg
+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 llvm namespace
 
 #endif