namespace llvm {
-struct DominatorSet;
+class ETForest;
class LoopInfo;
class PHINode;
class Instruction;
// induction variable canonicalization pass should be used to normalize loops
// for easy analysis. These methods assume canonical loops.
+ /// getExitingBlocks - Return all blocks inside the loop that have successors
+ /// outside of the loop. These are the blocks _inside of the current loop_
+ /// which branch out. The returned list is always unique.
+ ///
+ void getExitingBlocks(std::vector<BasicBlock*> &Blocks) const;
+
/// getExitBlocks - Return all of the successor blocks of this loop. These
/// are the blocks _outside of the current loop_ which are branched to.
///
void getExitBlocks(std::vector<BasicBlock*> &Blocks) const;
+ /// getUniqueExitBlocks - Return all unique successor blocks of this loop.
+ /// These are the blocks _outside of the current loop_ which are branched to.
+ /// This assumes that loop is in canonical form.
+ ///
+ void getUniqueExitBlocks(std::vector<BasicBlock*> &ExitBlocks) 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
///
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
/// this returns null.
///
Value *getTripCount() const;
+
+ /// isLCSSAForm - Return true if the Loop is in LCSSA form
+ bool isLCSSAForm() const;
//===--------------------------------------------------------------------===//
// APIs for updating loop information after changing the CFG
void removeBlockFromLoop(BasicBlock *BB);
void print(std::ostream &O, unsigned Depth = 0) const;
+ void print(std::ostream *O, unsigned Depth = 0) const {
+ if (O) print(*O, Depth);
+ }
void dump() const;
private:
friend class LoopInfo;
// 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.
virtual bool runOnFunction(Function &F);
virtual void releaseMemory();
+
void print(std::ostream &O, const Module* = 0) const;
+ void print(std::ostream *O, const Module* M = 0) const {
+ if (O) print(*O, M);
+ }
- /// getAnalysisUsage - Requires dominator sets
- ///
virtual void getAnalysisUsage(AnalysisUsage &AU) const;
/// removeLoop - This removes the specified top-level loop from this loop info
/// 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(reinterpret_cast<void*>(&LoopInfo::stub));
-
// Allow clients to walk the list of nested loops...
template <> struct GraphTraits<const Loop*> {
typedef const Loop NodeType;
} // End llvm namespace
+// Make sure that any clients of this file link in LoopInfo.cpp
+FORCE_DEFINING_FILE_TO_BE_LINKED(LoopInfo)
+
#endif