Pull predecessor and successor iterators out of the CFG*.h files, and plop them into

the BasicBlock class where they should be.  pred_begin/pred_end become methods on BasicBlock,
and the cfg namespace isn't used anymore.

Also pull Interval stuff into the Interval class out of the global namespace

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@690 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Analysis/Interval.h b/include/llvm/Analysis/Interval.h
index 1d708b691cdb809324fc3ca250ecd4d3dbea7e9e..db9d67c15ab475f993c68acf117a22a295edb089 100644 (file)
--- a/include/llvm/Analysis/Interval.h
+++ b/include/llvm/Analysis/Interval.h
@@ -87,28 +87,20 @@ public:
 
   // isLoop - Find out if there is a back edge in this interval...
   bool isLoop() const;
-};
 
 
-// succ_begin/succ_end - define global functions 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 global functions 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();
-}
+  // 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(); }
+  
+  // 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(); }
+};
 
 }    // End namespace cfg
 

diff --git a/include/llvm/Analysis/IntervalIterator.h b/include/llvm/Analysis/IntervalIterator.h
index e3c2d08de89ad7cd2ae7d079efbc19d323c6cf68..454c0ca07e3367178fe809796dafdc209838b2db 100644 (file)
--- a/include/llvm/Analysis/IntervalIterator.h
+++ b/include/llvm/Analysis/IntervalIterator.h
@@ -28,7 +28,6 @@
 
 #include "llvm/Analysis/IntervalPartition.h"
 #include "llvm/Method.h"
-#include "llvm/CFG.h"
 #include <stack>
 #include <set>
 #include <algorithm>
@@ -127,8 +126,8 @@ public:
     do {
       // All of the intervals on the stack have been visited.  Try visiting
       // their successors now.
-      Interval::succ_iterator &SuccIt =  IntStack.top().second,
-                               EndIt =  succ_end(IntStack.top().first);
+      Interval::succ_iterator &SuccIt = IntStack.top().second,
+                               EndIt = IntStack.top().first->succ_end();
       while (SuccIt != EndIt) {                 // Loop over all interval succs
        bool Done = ProcessInterval(getSourceGraphNode(OrigContainer, *SuccIt));
        ++SuccIt;                               // Increment iterator
@@ -165,11 +164,11 @@ private:
     Visited.insert(Header);   // The header has now been visited!
 
     // Check all of our successors to see if they are in the interval...
-    for (typename NodeTy::succ_iterator I = succ_begin(Node),E = succ_end(Node);
-        I != E; ++I)
+    for (typename NodeTy::succ_iterator I = Node->succ_begin(),
+                                        E = Node->succ_end(); I != E; ++I)
       ProcessNode(Int, getSourceGraphNode(OrigContainer, *I));
 
-    IntStack.push(make_pair(Int, succ_begin(Int)));
+    IntStack.push(make_pair(Int, Int->succ_begin()));
     return true;
   }
   
@@ -196,8 +195,8 @@ private:
          Int->Successors.push_back(NodeHeader);
       }
     } else {                             // Otherwise, not in interval yet
-      for (typename NodeTy::pred_iterator I = pred_begin(Node), 
-                                         E = pred_end(Node); I != E; ++I) {
+      for (typename NodeTy::pred_iterator I = Node->pred_begin(), 
+                                         E = Node->pred_end(); I != E; ++I) {
        if (!Int->contains(*I)) {        // If pred not in interval, we can't be
          if (!Int->isSuccessor(NodeHeader)) // Add only if not already in set
            Int->Successors.push_back(NodeHeader);
@@ -219,8 +218,8 @@ private:
     
       // Now that we have discovered that Node is in the interval, perhaps some
       // of its successors are as well?
-      for (typename NodeTy::succ_iterator It = succ_begin(Node), 
-            End = succ_end(Node); It != End; ++It)
+      for (typename NodeTy::succ_iterator It = Node->succ_begin(), 
+            End = Node->succ_end(); It != End; ++It)
        ProcessNode(Int, getSourceGraphNode(OrigContainer, *It));
     }
   }