Enable the new LoopInfo algorithm by default.

The primary advantage is that loop optimizations will be applied in a
stable order. This helps debugging and unit test creation. It is also
a better overall implementation without pathologically bad performance
on deep functions.

On large functions (llvm-stress --size=200000 | opt -loops)
Before: 0.1263s
After:  0.0225s

On deep functions (after tweaking llvm-stress, thanks Nadav):
Before: 0.2281s
After:  0.0227s

See r158790 for more comments.

The loop tree is now consistently generated in forward order, but loop
passes are applied in reverse order over the program. If we have a
loop optimization that prefers forward order, that can easily be
achieved by adding a different type of LoopPassManager.

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

2 files changed, 11 insertions, 192 deletions

diff --git a/include/llvm/Analysis/LoopInfo.h b/include/llvm/Analysis/LoopInfo.h
index 14d87e0..eeb482d 100644
--- a/include/llvm/Analysis/LoopInfo.h
+++ b/include/llvm/Analysis/LoopInfo.h
@@ -127,8 +127,12 @@ public:
   const std::vector<LoopT *> &getSubLoops() const { return SubLoops; }
   std::vector<LoopT *> &getSubLoopsVector() { return SubLoops; }
   typedef typename std::vector<LoopT *>::const_iterator iterator;
+  typedef typename std::vector<LoopT *>::const_reverse_iterator
+    reverse_iterator;
   iterator begin() const { return SubLoops.begin(); }
   iterator end() const { return SubLoops.end(); }
+  reverse_iterator rbegin() const { return SubLoops.rbegin(); }
+  reverse_iterator rend() const { return SubLoops.rend(); }
   bool empty() const { return SubLoops.empty(); }
 
   /// getBlocks - Get a list of the basic blocks which make up this loop.
@@ -431,8 +435,12 @@ public:
   /// function.
   ///
   typedef typename std::vector<LoopT *>::const_iterator iterator;
+  typedef typename std::vector<LoopT *>::const_reverse_iterator
+    reverse_iterator;
   iterator begin() const { return TopLevelLoops.begin(); }
   iterator end() const { return TopLevelLoops.end(); }
+  reverse_iterator rbegin() const { return TopLevelLoops.rbegin(); }
+  reverse_iterator rend() const { return TopLevelLoops.rend(); }
   bool empty() const { return TopLevelLoops.empty(); }
 
   /// getLoopFor - Return the inner most loop that BB lives in.  If a basic
@@ -525,19 +533,6 @@ public:
     return isNotAlreadyContainedIn(SubLoop->getParentLoop(), ParentLoop);
   }
 
-  void Calculate(DominatorTreeBase<BlockT> &DT);
-
-  LoopT *ConsiderForLoop(BlockT *BB, DominatorTreeBase<BlockT> &DT);
-
-  /// MoveSiblingLoopInto - This method moves the NewChild loop to live inside
-  /// of the NewParent Loop, instead of being a sibling of it.
-  void MoveSiblingLoopInto(LoopT *NewChild, LoopT *NewParent);
-
-  /// InsertLoopInto - This inserts loop L into the specified parent loop.  If
-  /// the parent loop contains a loop which should contain L, the loop gets
-  /// inserted into L instead.
-  void InsertLoopInto(LoopT *L, LoopT *Parent);
-
   /// Create the loop forest using a stable algorithm.
   void Analyze(DominatorTreeBase<BlockT> &DomTree);
 
@@ -570,8 +565,11 @@ public:
   /// function.
   ///
   typedef LoopInfoBase<BasicBlock, Loop>::iterator iterator;
+  typedef LoopInfoBase<BasicBlock, Loop>::reverse_iterator reverse_iterator;
   inline iterator begin() const { return LI.begin(); }
   inline iterator end() const { return LI.end(); }
+  inline reverse_iterator rbegin() const { return LI.rbegin(); }
+  inline reverse_iterator rend() const { return LI.rend(); }
   bool empty() const { return LI.empty(); }
 
   /// getLoopFor - Return the inner most loop that BB lives in.  If a basic
diff --git a/include/llvm/Analysis/LoopInfoImpl.h b/include/llvm/Analysis/LoopInfoImpl.h
index 1be717c..c07fbf7 100644
--- a/include/llvm/Analysis/LoopInfoImpl.h
+++ b/include/llvm/Analysis/LoopInfoImpl.h
@@ -354,185 +354,6 @@ void LoopBase<BlockT, LoopT>::print(raw_ostream &OS, unsigned Depth) const {
 }
 
 //===----------------------------------------------------------------------===//
-/// LoopInfo - This class builds and contains all of the top level loop
-/// structures in the specified function.
-///
-
-template<class BlockT, class LoopT>
-void LoopInfoBase<BlockT, LoopT>::Calculate(DominatorTreeBase<BlockT> &DT) {
-  BlockT *RootNode = DT.getRootNode()->getBlock();
-
-  for (df_iterator<BlockT*> NI = df_begin(RootNode),
-         NE = df_end(RootNode); NI != NE; ++NI)
-    if (LoopT *L = ConsiderForLoop(*NI, DT))
-      TopLevelLoops.push_back(L);
-}
-
-template<class BlockT, class LoopT>
-LoopT *LoopInfoBase<BlockT, LoopT>::
-ConsiderForLoop(BlockT *BB, DominatorTreeBase<BlockT> &DT) {
-  if (BBMap.count(BB)) return 0; // Haven't processed this node?
-
-  std::vector<BlockT *> TodoStack;
-
-  // Scan the predecessors of BB, checking to see if BB dominates any of
-  // them.  This identifies backedges which target this node...
-  typedef GraphTraits<Inverse<BlockT*> > InvBlockTraits;
-  for (typename InvBlockTraits::ChildIteratorType I =
-         InvBlockTraits::child_begin(BB), E = InvBlockTraits::child_end(BB);
-       I != E; ++I) {
-    typename InvBlockTraits::NodeType *N = *I;
-    // If BB dominates its predecessor...
-    if (DT.dominates(BB, N) && DT.isReachableFromEntry(N))
-      TodoStack.push_back(N);
-  }
-
-  if (TodoStack.empty()) return 0;  // No backedges to this block...
-
-  // Create a new loop to represent this basic block...
-  LoopT *L = new LoopT(BB);
-  BBMap[BB] = L;
-
-  while (!TodoStack.empty()) {  // Process all the nodes in the loop
-    BlockT *X = TodoStack.back();
-    TodoStack.pop_back();
-
-    if (!L->contains(X) &&         // As of yet unprocessed??
-        DT.isReachableFromEntry(X)) {
-      // 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 (LoopT *SubLoop =
-          const_cast<LoopT *>(getLoopFor(X)))
-        if (SubLoop->getHeader() == X && isNotAlreadyContainedIn(SubLoop, L)){
-          // Remove the subloop from its current parent...
-          assert(SubLoop->ParentLoop && SubLoop->ParentLoop != L);
-          LoopT *SLP = SubLoop->ParentLoop;  // SubLoopParent
-          typename std::vector<LoopT *>::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);
-
-      typedef GraphTraits<Inverse<BlockT*> > InvBlockTraits;
-
-      // Add all of the predecessors of X to the end of the work stack...
-      TodoStack.insert(TodoStack.end(), InvBlockTraits::child_begin(X),
-                       InvBlockTraits::child_end(X));
-    }
-  }
-
-  // If there are any loops nested within this loop, create them now!
-  for (typename std::vector<BlockT*>::iterator I = L->Blocks.begin(),
-         E = L->Blocks.end(); I != E; ++I)
-    if (LoopT *NewLoop = ConsiderForLoop(*I, DT)) {
-      L->SubLoops.push_back(NewLoop);
-      NewLoop->ParentLoop = L;
-    }
-
-  // Add the basic blocks that comprise this loop to the BBMap so that this
-  // loop can be found for them.
-  //
-  for (typename std::vector<BlockT*>::iterator I = L->Blocks.begin(),
-         E = L->Blocks.end(); I != E; ++I)
-    BBMap.insert(std::make_pair(*I, L));
-
-  // Now that we have a list of all of the child loops of this loop, check to
-  // see if any of them should actually be nested inside of each other.  We
-  // can accidentally pull loops our of their parents, so we must make sure to
-  // organize the loop nests correctly now.
-  {
-    std::map<BlockT *, LoopT *> ContainingLoops;
-    for (unsigned i = 0; i != L->SubLoops.size(); ++i) {
-      LoopT *Child = L->SubLoops[i];
-      assert(Child->getParentLoop() == L && "Not proper child loop?");
-
-      if (LoopT *ContainingLoop = ContainingLoops[Child->getHeader()]) {
-        // If there is already a loop which contains this loop, move this loop
-        // into the containing loop.
-        MoveSiblingLoopInto(Child, ContainingLoop);
-        --i;  // The loop got removed from the SubLoops list.
-      } else {
-        // This is currently considered to be a top-level loop.  Check to see
-        // if any of the contained blocks are loop headers for subloops we
-        // have already processed.
-        for (unsigned b = 0, e = Child->Blocks.size(); b != e; ++b) {
-          LoopT *&BlockLoop = ContainingLoops[Child->Blocks[b]];
-          if (BlockLoop == 0) {   // Child block not processed yet...
-            BlockLoop = Child;
-          } else if (BlockLoop != Child) {
-            LoopT *SubLoop = BlockLoop;
-            // Reparent all of the blocks which used to belong to BlockLoops
-            for (unsigned j = 0, f = SubLoop->Blocks.size(); j != f; ++j)
-              ContainingLoops[SubLoop->Blocks[j]] = Child;
-
-            // There is already a loop which contains this block, that means
-            // that we should reparent the loop which the block is currently
-            // considered to belong to to be a child of this loop.
-            MoveSiblingLoopInto(SubLoop, Child);
-            --i;  // We just shrunk the SubLoops list.
-          }
-        }
-      }
-    }
-  }
-
-  return L;
-}
-
-/// MoveSiblingLoopInto - This method moves the NewChild loop to live inside
-/// of the NewParent Loop, instead of being a sibling of it.
-template<class BlockT, class LoopT>
-void LoopInfoBase<BlockT, LoopT>::
-MoveSiblingLoopInto(LoopT *NewChild, LoopT *NewParent) {
-  LoopT *OldParent = NewChild->getParentLoop();
-  assert(OldParent && OldParent == NewParent->getParentLoop() &&
-         NewChild != NewParent && "Not sibling loops!");
-
-  // Remove NewChild from being a child of OldParent
-  typename std::vector<LoopT *>::iterator I =
-    std::find(OldParent->SubLoops.begin(), OldParent->SubLoops.end(),
-              NewChild);
-  assert(I != OldParent->SubLoops.end() && "Parent fields incorrect??");
-  OldParent->SubLoops.erase(I);   // Remove from parent's subloops list
-  NewChild->ParentLoop = 0;
-
-  InsertLoopInto(NewChild, NewParent);
-}
-
-/// InsertLoopInto - This inserts loop L into the specified parent loop.  If
-/// the parent loop contains a loop which should contain L, the loop gets
-/// inserted into L instead.
-template<class BlockT, class LoopT>
-void LoopInfoBase<BlockT, LoopT>::InsertLoopInto(LoopT *L, LoopT *Parent) {
-  BlockT *LHeader = L->getHeader();
-  assert(Parent->contains(LHeader) &&
-         "This loop should not be inserted here!");
-
-  // Check to see if it belongs in a child loop...
-  for (unsigned i = 0, e = static_cast<unsigned>(Parent->SubLoops.size());
-       i != e; ++i)
-    if (Parent->SubLoops[i]->contains(LHeader)) {
-      InsertLoopInto(L, Parent->SubLoops[i]);
-      return;
-    }
-
-  // If not, insert it here!
-  Parent->SubLoops.push_back(L);
-  L->ParentLoop = Parent;
-}
-
-//===----------------------------------------------------------------------===//
 /// Stable LoopInfo Analysis - Build a loop tree using stable iterators so the
 /// result does / not depend on use list (block predecessor) order.
 ///