For PR780:

[oota-llvm.git] / include / llvm / Analysis / LoopInfo.h

diff --git a/include/llvm/Analysis/LoopInfo.h b/include/llvm/Analysis/LoopInfo.h
index 0be3ddb3a0e1b2cf9c18ffb721ad0fc54d38fb07..06b007cf3fcce6fd54e3762f04004a58aee9b579 100644 (file)
--- a/include/llvm/Analysis/LoopInfo.h
+++ b/include/llvm/Analysis/LoopInfo.h
@@ -1,10 +1,10 @@
 //===- llvm/Analysis/LoopInfo.h - Natural Loop Calculator -------*- C++ -*-===//
-// 
+//
 //                     The LLVM Compiler Infrastructure
 //
 // This file was developed by the LLVM research group and is distributed under
 // the University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
+//
 //===----------------------------------------------------------------------===//
 //
 // This file defines the LoopInfo class that is used to identify natural loops
@@ -35,14 +35,14 @@
 
 namespace llvm {
 
-struct DominatorSet;
+struct ETForest;
 class LoopInfo;
 class PHINode;
 class Instruction;
 
 //===----------------------------------------------------------------------===//
-/// 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;
@@ -74,6 +74,7 @@ public:
 
   /// iterator/begin/end - Return the loops contained entirely within this loop.
   ///
+  const std::vector<Loop*> &getSubLoops() const { return SubLoops; }
   typedef std::vector<Loop*>::const_iterator iterator;
   iterator begin() const { return SubLoops.begin(); }
   iterator end() const { return SubLoops.end(); }
@@ -120,6 +121,12 @@ public:
   ///
   BasicBlock *getLoopPreheader() const;
 
+  /// getLoopLatch - If there is a latch block for this loop, return it.  A
+  /// latch block is the canonical backedge for a loop.  A loop header in normal
+  /// form has two edges into it: one from a preheader and one from a latch
+  /// block.
+  BasicBlock *getLoopLatch() const;
+  
   /// getCanonicalInductionVariable - Check to see if the loop has a canonical
   /// induction variable: an integer recurrence that starts at 0 and increments
   /// by one each time through the loop.  If so, return the phi node that
@@ -175,6 +182,21 @@ public:
     Blocks.push_back(BB);
   }
 
+  /// moveToHeader - This method is used to move BB (which must be part of this
+  /// loop) to be the loop header of the loop (the block that dominates all
+  /// others).
+  void moveToHeader(BasicBlock *BB) {
+    if (Blocks[0] == BB) return;
+    for (unsigned i = 0; ; ++i) {
+      assert(i != Blocks.size() && "Loop does not contain BB!");
+      if (Blocks[i] == BB) {
+        Blocks[i] = Blocks[0];
+        Blocks[0] = BB;
+        return;
+      }
+    }
+  }
+
   /// removeBlockFromLoop - This removes the specified basic block from the
   /// current loop, updating the Blocks as appropriate.  This does not update
   /// the mapping in the LoopInfo class.
@@ -214,7 +236,8 @@ public:
   /// block is in no loop (for example the entry node), null is returned.
   ///
   Loop *getLoopFor(const BasicBlock *BB) const {
-    std::map<BasicBlock *, Loop*>::const_iterator I=BBMap.find((BasicBlock*)BB);
+    std::map<BasicBlock *, Loop*>::const_iterator I=
+      BBMap.find(const_cast<BasicBlock*>(BB));
     return I != BBMap.end() ? I->second : 0;
   }
 
@@ -233,7 +256,8 @@ public:
 
   // isLoopHeader - True if the block is a loop header node
   bool isLoopHeader(BasicBlock *BB) const {
-    return getLoopFor(BB)->getHeader() == BB;
+    const Loop *L = getLoopFor(BB);
+    return L && L->getHeader() == BB;
   }
 
   /// runOnFunction - Calculate the natural loop information.
@@ -243,8 +267,6 @@ public:
   virtual void releaseMemory();
   void print(std::ostream &O, const Module* = 0) const;
 
-  /// getAnalysisUsage - Requires dominator sets
-  ///
   virtual void getAnalysisUsage(AnalysisUsage &AU) const;
 
   /// removeLoop - This removes the specified top-level loop from this loop info
@@ -273,29 +295,24 @@ public:
   /// BasicBlocks to loops.
   void removeBlock(BasicBlock *BB);
 
-  static void stub();  // Noop
 private:
-  void Calculate(const DominatorSet &DS);
-  Loop *ConsiderForLoop(BasicBlock *BB, const DominatorSet &DS);
+  void Calculate(ETForest &EF);
+  Loop *ConsiderForLoop(BasicBlock *BB, ETForest &EF);
   void MoveSiblingLoopInto(Loop *NewChild, Loop *NewParent);
   void InsertLoopInto(Loop *L, Loop *Parent);
 };
 
 
-// Make sure that any clients of this file link in LoopInfo.cpp
-static IncludeFile
-LOOP_INFO_INCLUDE_FILE((void*)&LoopInfo::stub);
-
 // Allow clients to walk the list of nested loops...
 template <> struct GraphTraits<const Loop*> {
   typedef const Loop NodeType;
   typedef std::vector<Loop*>::const_iterator ChildIteratorType;
 
   static NodeType *getEntryNode(const Loop *L) { return L; }
-  static inline ChildIteratorType child_begin(NodeType *N) { 
+  static inline ChildIteratorType child_begin(NodeType *N) {
     return N->begin();
   }
-  static inline ChildIteratorType child_end(NodeType *N) { 
+  static inline ChildIteratorType child_end(NodeType *N) {
     return N->end();
   }
 };
@@ -305,14 +322,17 @@ template <> struct GraphTraits<Loop*> {
   typedef std::vector<Loop*>::const_iterator ChildIteratorType;
 
   static NodeType *getEntryNode(Loop *L) { return L; }
-  static inline ChildIteratorType child_begin(NodeType *N) { 
+  static inline ChildIteratorType child_begin(NodeType *N) {
     return N->begin();
   }
-  static inline ChildIteratorType child_end(NodeType *N) { 
+  static inline ChildIteratorType child_end(NodeType *N) {
     return N->end();
   }
 };
 
 } // End llvm namespace
 
+// Make sure that any clients of this file link in LoopInfo.cpp
+FORCE_DEFINING_FILE_TO_BE_LINKED(LoopInfo)
+
 #endif