* Eliminate the Provided set. All Passes now finally just automatically

[oota-llvm.git] / lib / Analysis / LoopInfo.cpp

diff --git a/lib/Analysis/LoopInfo.cpp b/lib/Analysis/LoopInfo.cpp
index 9b34095e4f2477c07d07e0d68905d8f8175896c5..8b3a43482288972ccca88fc2462b171707c2abed 100644 (file)
--- a/lib/Analysis/LoopInfo.cpp
+++ b/lib/Analysis/LoopInfo.cpp
@@ -9,34 +9,59 @@
 
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/Dominators.h"
-#include "llvm/BasicBlock.h"
+#include "llvm/Support/CFG.h"
+#include "llvm/Assembly/Writer.h"
 #include "Support/DepthFirstIterator.h"
 #include <algorithm>
 
-AnalysisID cfg::LoopInfo::ID(AnalysisID::create<cfg::LoopInfo>());
+static RegisterAnalysis<LoopInfo>
+X("loops", "Natural Loop Construction");
+AnalysisID LoopInfo::ID = X;
 
 //===----------------------------------------------------------------------===//
-// cfg::Loop implementation
+// Loop implementation
 //
-bool cfg::Loop::contains(const BasicBlock *BB) const {
+bool Loop::contains(const BasicBlock *BB) const {
   return find(Blocks.begin(), Blocks.end(), BB) != Blocks.end();
 }
 
+void Loop::print(std::ostream &OS) const {
+  OS << std::string(getLoopDepth()*2, ' ') << "Loop Containing: ";
+
+  for (unsigned i = 0; i < getBlocks().size(); ++i) {
+    if (i) OS << ",";
+    WriteAsOperand(OS, (const Value*)getBlocks()[i]);
+  }
+  OS << "\n";
+
+  std::copy(getSubLoops().begin(), getSubLoops().end(),
+            std::ostream_iterator<const Loop*>(OS, "\n"));
+}
 
 //===----------------------------------------------------------------------===//
-// cfg::LoopInfo implementation
+// LoopInfo implementation
 //
-bool cfg::LoopInfo::runOnMethod(Method *M) {
-  BBMap.clear();                             // Reset internal state of analysis
-  TopLevelLoops.clear();
+
+bool LoopInfo::runOnFunction(Function &) {
+  releaseMemory();
   Calculate(getAnalysis<DominatorSet>());    // Update
   return false;
 }
 
-void cfg::LoopInfo::Calculate(const DominatorSet &DS) {
-  const BasicBlock *RootNode = DS.getRoot();
+void LoopInfo::releaseMemory() {
+  for (std::vector<Loop*>::iterator I = TopLevelLoops.begin(),
+         E = TopLevelLoops.end(); I != E; ++I)
+    delete *I;   // Delete all of the loops...
 
-  for (df_iterator<const BasicBlock*> NI = df_begin(RootNode),
+  BBMap.clear();                             // Reset internal state of analysis
+  TopLevelLoops.clear();
+}
+
+
+void LoopInfo::Calculate(const DominatorSet &DS) {
+  BasicBlock *RootNode = DS.getRoot();
+
+  for (df_iterator<BasicBlock*> NI = df_begin(RootNode),
         NE = df_end(RootNode); NI != NE; ++NI)
     if (Loop *L = ConsiderForLoop(*NI, DS))
       TopLevelLoops.push_back(L);
@@ -45,24 +70,24 @@ void cfg::LoopInfo::Calculate(const DominatorSet &DS) {
     TopLevelLoops[i]->setLoopDepth(1);
 }
 
-void cfg::LoopInfo::getAnalysisUsageInfo(Pass::AnalysisSet &Required,
-                                         Pass::AnalysisSet &Destroyed,
-                                         Pass::AnalysisSet &Provided) {
-  Required.push_back(DominatorSet::ID);
-  Provided.push_back(ID);
+void LoopInfo::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.setPreservesAll();
+  AU.addRequired(DominatorSet::ID);
 }
 
+void LoopInfo::print(std::ostream &OS) const {
+  std::copy(getTopLevelLoops().begin(), getTopLevelLoops().end(),
+            std::ostream_iterator<const Loop*>(OS, "\n"));
+}
 
-cfg::Loop *cfg::LoopInfo::ConsiderForLoop(const BasicBlock *BB,
-                                         const DominatorSet &DS) {
+Loop *LoopInfo::ConsiderForLoop(BasicBlock *BB, const DominatorSet &DS) {
   if (BBMap.find(BB) != BBMap.end()) return 0;   // Havn't processed this node?
 
-  std::vector<const BasicBlock *> TodoStack;
+  std::vector<BasicBlock *> TodoStack;
 
   // Scan the predecessors of BB, checking to see if BB dominates any of
   // them.
-  for (BasicBlock::pred_const_iterator I = BB->pred_begin(),
-        E = BB->pred_end(); I != E; ++I)
+  for (pred_iterator I = pred_begin(BB), E = pred_end(BB); I != E; ++I)
     if (DS.dominates(BB, *I))   // If BB dominates it's predecessor...
       TodoStack.push_back(*I);
 
@@ -73,14 +98,14 @@ cfg::Loop *cfg::LoopInfo::ConsiderForLoop(const BasicBlock *BB,
   BBMap[BB] = L;
 
   while (!TodoStack.empty()) {  // Process all the nodes in the loop
-    const BasicBlock *X = TodoStack.back();
+    BasicBlock *X = TodoStack.back();
     TodoStack.pop_back();
 
     if (!L->contains(X)) {                  // As of yet unprocessed??
       L->Blocks.push_back(X);
 
       // Add all of the predecessors of X to the end of the work stack...
-      TodoStack.insert(TodoStack.end(), X->pred_begin(), X->pred_end());
+      TodoStack.insert(TodoStack.end(), pred_begin(X), pred_end(X));
     }
   }
 
@@ -88,7 +113,7 @@ cfg::Loop *cfg::LoopInfo::ConsiderForLoop(const BasicBlock *BB,
   // loop can be found for them.  Also check subsidary basic blocks to see if
   // they start subloops of their own.
   //
-  for (std::vector<const BasicBlock*>::reverse_iterator I = L->Blocks.rbegin(),
+  for (std::vector<BasicBlock*>::reverse_iterator I = L->Blocks.rbegin(),
         E = L->Blocks.rend(); I != E; ++I) {
 
     // Check to see if this block starts a new loop