X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FSupport%2FCFG.h;h=b0b857bf028004aa3418ff903bd1221be8222ef1;hb=6f2c64d70aad5328a843a6f6a6547ada69ead33b;hp=48918e0609976b61d2426e86c96aad5fda996159;hpb=f77b57097d00b301c164e10a034860fdbbcbe932;p=oota-llvm.git

diff --git a/include/llvm/Support/CFG.h b/include/llvm/Support/CFG.h
index 48918e06099..b0b857bf028 100644
--- a/include/llvm/Support/CFG.h
+++ b/include/llvm/Support/CFG.h
@@ -1,70 +1,72 @@
-//===-- llvm/Support/CFG.h - Process LLVM structures as graphs ---*- C++ -*--=//
+//===-- llvm/Support/CFG.h - Process LLVM structures as graphs --*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
 //
 // This file defines specializations of GraphTraits that allow Function and
 // BasicBlock graphs to be treated as proper graphs for generic algorithms.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CFG_H
-#define LLVM_CFG_H
+#ifndef LLVM_SUPPORT_CFG_H
+#define LLVM_SUPPORT_CFG_H
 
-#include "Support/GraphTraits.h"
+#include "llvm/ADT/GraphTraits.h"
 #include "llvm/Function.h"
 #include "llvm/InstrTypes.h"
-#include "Support/iterator"
+#include "llvm/ADT/iterator.h"
+
+namespace llvm {
 
 //===--------------------------------------------------------------------===//
 // BasicBlock pred_iterator definition
 //===--------------------------------------------------------------------===//
 
 template <class _Ptr,  class _USE_iterator> // Predecessor Iterator
-class PredIterator : public bidirectional_iterator<_Ptr, ptrdiff_t> {
-  typedef bidirectional_iterator<_Ptr, ptrdiff_t> super;
-  _Ptr *BB;
+class PredIterator : public forward_iterator<_Ptr, ptrdiff_t> {
+  typedef forward_iterator<_Ptr, ptrdiff_t> super;
   _USE_iterator It;
 public:
   typedef PredIterator<_Ptr,_USE_iterator> _Self;
   typedef typename super::pointer pointer;
-  
-  inline void advancePastConstants() {
-    // TODO: This is bad
-    // Loop to ignore constant pool references
-    while (It != BB->use_end() && !isa<TerminatorInst>(*It))
+
+  inline void advancePastNonTerminators() {
+    // Loop to ignore non terminator uses (for example PHI nodes)...
+    while (!It.atEnd() && !isa<TerminatorInst>(*It))
       ++It;
   }
-  
-  inline PredIterator(_Ptr *bb) : BB(bb), It(bb->use_begin()) {
-    advancePastConstants();
+
+  inline PredIterator(_Ptr *bb) : It(bb->use_begin()) {
+    advancePastNonTerminators();
   }
-  inline PredIterator(_Ptr *bb, bool) : BB(bb), It(bb->use_end()) {}
-    
+  inline PredIterator(_Ptr *bb, bool) : It(bb->use_end()) {}
+
   inline bool operator==(const _Self& x) const { return It == x.It; }
   inline bool operator!=(const _Self& x) const { return !operator==(x); }
-  
-  inline pointer operator*() const { 
-    assert(It != BB->use_end() && "pred_iterator out of range!");
-    return cast<Instruction>(*It)->getParent(); 
+
+  inline pointer operator*() const {
+    assert(!It.atEnd() && "pred_iterator out of range!");
+    return cast<TerminatorInst>(*It)->getParent();
   }
   inline pointer *operator->() const { return &(operator*()); }
-  
+
   inline _Self& operator++() {   // Preincrement
-    assert(It != BB->use_end() && "pred_iterator out of range!");
-    ++It; advancePastConstants();
-    return *this; 
+    assert(!It.atEnd() && "pred_iterator out of range!");
+    ++It; advancePastNonTerminators();
+    return *this;
   }
-  
+
   inline _Self operator++(int) { // Postincrement
-    _Self tmp = *this; ++*this; return tmp; 
-  }
-  
-  inline _Self& operator--() { --It; return *this; }  // Predecrement
-  inline _Self operator--(int) { // Postdecrement
-    _Self tmp = *this; --*this; return tmp;
+    _Self tmp = *this; ++*this; return tmp;
   }
 };
 
 typedef PredIterator<BasicBlock, Value::use_iterator> pred_iterator;
-typedef PredIterator<const BasicBlock, 
+typedef PredIterator<const BasicBlock,
                      Value::use_const_iterator> pred_const_iterator;
 
 inline pred_iterator pred_begin(BasicBlock *BB) { return pred_iterator(BB); }
@@ -82,20 +84,20 @@ inline pred_const_iterator pred_end(const BasicBlock *BB) {
 // BasicBlock succ_iterator definition
 //===--------------------------------------------------------------------===//
 
-template <class _Term, class _BB>           // Successor Iterator
-class SuccIterator : public bidirectional_iterator<_BB, ptrdiff_t> {
-  const _Term Term;
+template <class Term_, class BB_>           // Successor Iterator
+class SuccIterator : public bidirectional_iterator<BB_, ptrdiff_t> {
+  const Term_ Term;
   unsigned idx;
-  typedef bidirectional_iterator<_BB, ptrdiff_t> super;
+  typedef bidirectional_iterator<BB_, ptrdiff_t> super;
 public:
-  typedef SuccIterator<_Term, _BB> _Self;
+  typedef SuccIterator<Term_, BB_> _Self;
   typedef typename super::pointer pointer;
   // TODO: This can be random access iterator, need operator+ and stuff tho
-    
-  inline SuccIterator(_Term T) : Term(T), idx(0) {         // begin iterator
+
+  inline SuccIterator(Term_ T) : Term(T), idx(0) {         // begin iterator
     assert(T && "getTerminator returned null!");
   }
-  inline SuccIterator(_Term T, bool)                       // end iterator
+  inline SuccIterator(Term_ T, bool)                       // end iterator
     : Term(T), idx(Term->getNumSuccessors()) {
     assert(T && "getTerminator returned null!");
   }
@@ -105,18 +107,22 @@ public:
     idx = I.idx;
     return *this;
   }
-    
+
+  /// getSuccessorIndex - This is used to interface between code that wants to
+  /// operate on terminator instructions directly.
+  unsigned getSuccessorIndex() const { return idx; }
+
   inline bool operator==(const _Self& x) const { return idx == x.idx; }
   inline bool operator!=(const _Self& x) const { return !operator==(x); }
-  
+
   inline pointer operator*() const { return Term->getSuccessor(idx); }
   inline pointer operator->() const { return operator*(); }
-  
+
   inline _Self& operator++() { ++idx; return *this; } // Preincrement
   inline _Self operator++(int) { // Postincrement
-    _Self tmp = *this; ++*this; return tmp; 
+    _Self tmp = *this; ++*this; return tmp;
   }
-    
+
   inline _Self& operator--() { --idx; return *this; }  // Predecrement
   inline _Self operator--(int) { // Postdecrement
     _Self tmp = *this; --*this; return tmp;
@@ -146,7 +152,7 @@ inline succ_const_iterator succ_end(const BasicBlock *BB) {
 // GraphTraits specializations for basic block graphs (CFGs)
 //===--------------------------------------------------------------------===//
 
-// Provide specializations of GraphTraits to be able to treat a function as a 
+// Provide specializations of GraphTraits to be able to treat a function as a
 // graph of basic blocks...
 
 template <> struct GraphTraits<BasicBlock*> {
@@ -154,10 +160,10 @@ template <> struct GraphTraits<BasicBlock*> {
   typedef succ_iterator ChildIteratorType;
 
   static NodeType *getEntryNode(BasicBlock *BB) { return BB; }
-  static inline ChildIteratorType child_begin(NodeType *N) { 
+  static inline ChildIteratorType child_begin(NodeType *N) {
     return succ_begin(N);
   }
-  static inline ChildIteratorType child_end(NodeType *N) { 
+  static inline ChildIteratorType child_end(NodeType *N) {
     return succ_end(N);
   }
 };
@@ -168,15 +174,15 @@ template <> struct GraphTraits<const BasicBlock*> {
 
   static NodeType *getEntryNode(const BasicBlock *BB) { return BB; }
 
-  static inline ChildIteratorType child_begin(NodeType *N) { 
+  static inline ChildIteratorType child_begin(NodeType *N) {
     return succ_begin(N);
   }
-  static inline ChildIteratorType child_end(NodeType *N) { 
+  static inline ChildIteratorType child_end(NodeType *N) {
     return succ_end(N);
   }
 };
 
-// Provide specializations of GraphTraits to be able to treat a function as a 
+// Provide specializations of GraphTraits to be able to treat a function as a
 // graph of basic blocks... and to walk it in inverse order.  Inverse order for
 // a function is considered to be when traversing the predecessor edges of a BB
 // instead of the successor edges.
@@ -185,10 +191,10 @@ template <> struct GraphTraits<Inverse<BasicBlock*> > {
   typedef BasicBlock NodeType;
   typedef pred_iterator ChildIteratorType;
   static NodeType *getEntryNode(Inverse<BasicBlock *> G) { return G.Graph; }
-  static inline ChildIteratorType child_begin(NodeType *N) { 
+  static inline ChildIteratorType child_begin(NodeType *N) {
     return pred_begin(N);
   }
-  static inline ChildIteratorType child_end(NodeType *N) { 
+  static inline ChildIteratorType child_end(NodeType *N) {
     return pred_end(N);
   }
 };
@@ -197,12 +203,12 @@ template <> struct GraphTraits<Inverse<const BasicBlock*> > {
   typedef const BasicBlock NodeType;
   typedef pred_const_iterator ChildIteratorType;
   static NodeType *getEntryNode(Inverse<const BasicBlock*> G) {
-    return G.Graph; 
+    return G.Graph;
   }
-  static inline ChildIteratorType child_begin(NodeType *N) { 
+  static inline ChildIteratorType child_begin(NodeType *N) {
     return pred_begin(N);
   }
-  static inline ChildIteratorType child_end(NodeType *N) { 
+  static inline ChildIteratorType child_end(NodeType *N) {
     return pred_end(N);
   }
 };
@@ -213,12 +219,12 @@ template <> struct GraphTraits<Inverse<const BasicBlock*> > {
 // GraphTraits specializations for function basic block graphs (CFGs)
 //===--------------------------------------------------------------------===//
 
-// Provide specializations of GraphTraits to be able to treat a function as a 
+// Provide specializations of GraphTraits to be able to treat a function as a
 // graph of basic blocks... these are the same as the basic block iterators,
 // except that the root node is implicitly the first node of the function.
 //
 template <> struct GraphTraits<Function*> : public GraphTraits<BasicBlock*> {
-  static NodeType *getEntryNode(Function *F) { return &F->getEntryNode(); }
+  static NodeType *getEntryNode(Function *F) { return &F->getEntryBlock(); }
 
   // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
   typedef Function::iterator nodes_iterator;
@@ -227,7 +233,7 @@ template <> struct GraphTraits<Function*> : public GraphTraits<BasicBlock*> {
 };
 template <> struct GraphTraits<const Function*> :
   public GraphTraits<const BasicBlock*> {
-  static NodeType *getEntryNode(const Function *F) { return &F->getEntryNode();}
+  static NodeType *getEntryNode(const Function *F) {return &F->getEntryBlock();}
 
   // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
   typedef Function::const_iterator nodes_iterator;
@@ -236,7 +242,7 @@ template <> struct GraphTraits<const Function*> :
 };
 
 
-// Provide specializations of GraphTraits to be able to treat a function as a 
+// Provide specializations of GraphTraits to be able to treat a function as a
 // graph of basic blocks... and to walk it in inverse order.  Inverse order for
 // a function is considered to be when traversing the predecessor edges of a BB
 // instead of the successor edges.
@@ -244,14 +250,16 @@ template <> struct GraphTraits<const Function*> :
 template <> struct GraphTraits<Inverse<Function*> > :
   public GraphTraits<Inverse<BasicBlock*> > {
   static NodeType *getEntryNode(Inverse<Function*> G) {
-    return &G.Graph->getEntryNode();
+    return &G.Graph->getEntryBlock();
   }
 };
 template <> struct GraphTraits<Inverse<const Function*> > :
   public GraphTraits<Inverse<const BasicBlock*> > {
   static NodeType *getEntryNode(Inverse<const Function *> G) {
-    return &G.Graph->getEntryNode();
+    return &G.Graph->getEntryBlock();
   }
 };
 
+} // End llvm namespace
+
 #endif