6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-13 20:32:21 +00:00
Code Issues Projects Releases Wiki Activity

- Add new methods to LoopInfo: getLoopPreheader, addBasicBlockToLoop.

Browse Source 
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
This commit is contained in:
Chris Lattner 2002-09-26 05:32:43 +00:00
parent 0a1a874d1f
commit 2b7bb7a986
1 changed files with 46 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
include/llvm/Analysis/LoopInfo.h
View File

@ -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);