Make error messages more useful than jsut an abort

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

diff --git a/lib/Analysis/LoopInfo.cpp b/lib/Analysis/LoopInfo.cpp
index a361e629e1a41e0ff3b75849a39b71ea55b5c773..7a1daa089e28361ebe3cc7ada275b876f6a64d5a 100644 (file)
--- a/lib/Analysis/LoopInfo.cpp
+++ b/lib/Analysis/LoopInfo.cpp
@@ -68,6 +68,10 @@ void Loop::print(std::ostream &OS) const {
     getSubLoops()[i]->print(OS);
 }
 
+void Loop::dump() const {
+  print(std::cerr);
+}
+
 
 //===----------------------------------------------------------------------===//
 // LoopInfo implementation
@@ -124,12 +128,12 @@ Loop *LoopInfo::ConsiderForLoop(BasicBlock *BB, const DominatorSet &DS) {
   std::vector<BasicBlock *> TodoStack;
 
   // Scan the predecessors of BB, checking to see if BB dominates any of
-  // them.
+  // them.  This identifies backedges which target this node...
   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);
 
-  if (TodoStack.empty()) return 0;  // Doesn't dominate any predecessors...
+  if (TodoStack.empty()) return 0;  // No backedges to this block...
 
   // Create a new loop to represent this basic block...
   Loop *L = new Loop(BB);
@@ -140,8 +144,29 @@ Loop *LoopInfo::ConsiderForLoop(BasicBlock *BB, const DominatorSet &DS) {
     TodoStack.pop_back();
 
     if (!L->contains(X)) {         // As of yet unprocessed??
+      // Check to see if this block already belongs to a loop.  If this occurs
+      // then we have a case where a loop that is supposed to be a child of the
+      // current loop was processed before the current loop.  When this occurs,
+      // this child loop gets added to a part of the current loop, making it a
+      // sibling to the current loop.  We have to reparent this loop.
+      if (Loop *SubLoop = const_cast<Loop*>(getLoopFor(X)))
+        if (SubLoop->getHeader() == X && X != BB) {
+          // Remove the subloop from it's current parent...
+          assert(SubLoop->ParentLoop && SubLoop->ParentLoop != L);
+          Loop *SLP = SubLoop->ParentLoop;  // SubLoopParent
+          std::vector<Loop*>::iterator I =
+            std::find(SLP->SubLoops.begin(), SLP->SubLoops.end(), SubLoop);
+          assert(I != SLP->SubLoops.end() && "SubLoop not a child of parent?");
+          SLP->SubLoops.erase(I);   // Remove from parent...
+          
+          // Add the subloop to THIS loop...
+          SubLoop->ParentLoop = L;
+          L->SubLoops.push_back(SubLoop);
+        }
+
+      // Normal case, add the block to our loop...
       L->Blocks.push_back(X);
-      
+        
       // Add all of the predecessors of X to the end of the work stack...
       TodoStack.insert(TodoStack.end(), pred_begin(X), pred_end(X));
     }
@@ -200,6 +225,13 @@ BasicBlock *Loop::getLoopPreheader() const {
         return 0;             // Multiple predecessors outside the loop
       Out = *PI;
     }
+  
+  // Make sure there is only one exit out of the preheader...
+  succ_iterator SI = succ_begin(Out);
+  ++SI;
+  if (SI != succ_end(Out))
+    return 0;  // Multiple exits from the block, must not be a preheader.
+
 
   // If there is exactly one preheader, return it.  If there was zero, then Out
   // is still null.
@@ -228,15 +260,18 @@ void Loop::addBasicBlockToLoop(BasicBlock *NewBB, LoopInfo &LI) {
   }
 }
 
-/// changeExitBlock - This method is used to update loop information.  One
-/// instance of the specified Old basic block is removed from the exit list
+/// changeExitBlock - This method is used to update loop information.  All
+/// instances of the specified Old basic block are removed from the exit list
 /// and replaced with New.
 ///
 void Loop::changeExitBlock(BasicBlock *Old, BasicBlock *New) {
   assert(Old != New && "Cannot changeExitBlock to the same thing!");
   assert(Old && New && "Cannot changeExitBlock to or from a null node!");
-  std::vector<BasicBlock*>::iterator I = 
-    std::find(ExitBlocks.begin(), ExitBlocks.end(), Old);
-  assert(I != ExitBlocks.end() && "Old exit block not found!");
-  *I = New;
+  assert(hasExitBlock(Old) && "Old exit block not found!");
+  std::vector<BasicBlock*>::iterator
+    I = std::find(ExitBlocks.begin(), ExitBlocks.end(), Old);
+  while (I != ExitBlocks.end()) {
+    *I = New;
+    I = std::find(I+1, ExitBlocks.end(), Old);
+  }
 }