- Add new methods to LoopInfo: getLoopPreheader, addBasicBlockToLoop.

    These allow extra information to be easily gathered, and loopinfo to be
    updated.

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

diff --git a/include/llvm/Analysis/LoopInfo.h b/include/llvm/Analysis/LoopInfo.h
index 65e11a5636c2a54b039f7d6e81871b143fd5fc50..4e572c7e77879a0cfdb6ba84356970824ba03f3b 100644 (file)
--- a/include/llvm/Analysis/LoopInfo.h
+++ b/include/llvm/Analysis/LoopInfo.h
@@ -17,9 +17,9 @@ class DominatorSet;
 class LoopInfo;
 
 //===----------------------------------------------------------------------===//
-// Loop class - Instances of this class are used to represent loops that are 
-// detected in the flow graph 
-//
+/// Loop class - Instances of this class are used to represent loops that are 
+/// detected in the flow graph 
+///
 class Loop {
   Loop *ParentLoop;
   std::vector<BasicBlock *> Blocks;  // First entry is the header node
@@ -32,18 +32,40 @@ public:
 
   inline unsigned getLoopDepth() const { return LoopDepth; }
   inline BasicBlock *getHeader() const { return Blocks.front(); }
+  inline Loop *getParentLoop() const { return ParentLoop; }
 
-  // contains - Return true of the specified basic block is in this loop
+  /// contains - Return true of the specified basic block is in this loop
   bool contains(const BasicBlock *BB) const;
 
-  // getSubLoops - Return the loops contained entirely within this loop
+  /// getSubLoops - Return the loops contained entirely within this loop
+  ///
   inline const std::vector<Loop*> &getSubLoops() const { return SubLoops; }
   inline const std::vector<BasicBlock*> &getBlocks() const { return Blocks; }
 
-  // isLoopExit - True if terminator in the block can branch to another block
-  // that is outside of the current loop.
+  /// isLoopExit - True if terminator in the block can branch to another block
+  /// that is outside of the current loop.
   bool isLoopExit(BasicBlock *BB) const;
 
+  /// getLoopPreheader - If there is a preheader for this loop, return it.  A
+  /// loop has a preheader if there is only one edge to the header of the loop
+  /// from outside of the loop.  If this is the case, the block branching to the
+  /// header of the loop is the preheader node.  The "preheaders" pass can be
+  /// "Required" to ensure that there is always a preheader node for every loop.
+  ///
+  /// This method returns null if there is no preheader for the loop (either
+  /// because the loop is dead or because multiple blocks branch to the header
+  /// node of this loop).
+  ///
+  BasicBlock *getLoopPreheader() const;
+
+  /// addBasicBlockToLoop - This function is used by other analyses to update
+  /// loop information.  NewBB is set to be a new member of the current loop.
+  /// Because of this, it is added as a member of all parent loops, and is added
+  /// to the specified LoopInfo object as being in the current basic block.  It
+  /// is not valid to replace the loop header with this method.
+  ///
+  void addBasicBlockToLoop(BasicBlock *NewBB, LoopInfo &LI);
+
   void print(std::ostream &O) const;
 private:
   friend class LoopInfo;
@@ -63,31 +85,35 @@ private:
 
 
 //===----------------------------------------------------------------------===//
-// LoopInfo - This class builds and contains all of the top level loop
-// structures in the specified function.
-//
+/// LoopInfo - This class builds and contains all of the top level loop
+/// structures in the specified function.
+///
 class LoopInfo : public FunctionPass {
   // BBMap - Mapping of basic blocks to the inner most loop they occur in
   std::map<BasicBlock*, Loop*> BBMap;
   std::vector<Loop*> TopLevelLoops;
+  friend class Loop;
 public:
-  // LoopInfo ctor - Calculate the natural loop information for a CFG
   ~LoopInfo() { releaseMemory(); }
 
   const std::vector<Loop*> &getTopLevelLoops() const { return TopLevelLoops; }
 
-  // getLoopFor - Return the inner most loop that BB lives in.  If a basic block
-  // is in no loop (for example the entry node), null is returned.
-  //
+  /// getLoopFor - Return the inner most loop that BB lives in.  If a basic
+  /// block is in no loop (for example the entry node), null is returned.
+  ///
   const Loop *getLoopFor(const BasicBlock *BB) const {
     std::map<BasicBlock *, Loop*>::const_iterator I=BBMap.find((BasicBlock*)BB);
     return I != BBMap.end() ? I->second : 0;
   }
+
+  /// operator[] - same as getLoopFor...
+  ///
   inline const Loop *operator[](const BasicBlock *BB) const {
     return getLoopFor(BB);
   }
 
-  // getLoopDepth - Return the loop nesting level of the specified block...
+  /// getLoopDepth - Return the loop nesting level of the specified block...
+  ///
   unsigned getLoopDepth(const BasicBlock *BB) const {
     const Loop *L = getLoopFor(BB);
     return L ? L->getLoopDepth() : 0;
@@ -102,14 +128,15 @@ public:
   bool isLoopEnd(BasicBlock *BB) const;
 #endif
 
-  // runOnFunction - Pass framework implementation
+  /// runOnFunction - Calculate the natural loop information.
+  ///
   virtual bool runOnFunction(Function &F);
 
   virtual void releaseMemory();
   void print(std::ostream &O) const;
 
-  // getAnalysisUsage - Provide loop info, require dominator set
-  //
+  /// getAnalysisUsage - Requires dominator sets
+  ///
   virtual void getAnalysisUsage(AnalysisUsage &AU) const;
 
   static void stub();  // Noop
@@ -119,7 +146,7 @@ private:
 };
 
 
-// Make sure that any clients of this file link in PostDominators.cpp
+// Make sure that any clients of this file link in LoopInfo.cpp
 static IncludeFile
 LOOP_INFO_INCLUDE_FILE((void*)&LoopInfo::stub);