Loop *ParentLoop;
std::vector<Loop*> SubLoops; // Loops contained entirely within this one
std::vector<BasicBlock*> Blocks; // First entry is the header node
- std::vector<BasicBlock*> ExitBlocks; // Reachable blocks outside the loop
unsigned LoopDepth; // Nesting depth of this loop
Loop(const Loop &); // DO NOT IMPLEMENT
///
const std::vector<BasicBlock*> &getBlocks() const { return Blocks; }
- /// getExitBlocks - Return all of the successor blocks of this loop. These
- /// are the blocks _outside of the current loop_ which are branched to.
- ///
- const std::vector<BasicBlock*> &getExitBlocks() const { return ExitBlocks; }
-
/// isLoopExit - True if terminator in the block can branch to another block
- /// that is outside of the current loop. The reached block should be in the
- /// ExitBlocks list.
+ /// that is outside of the current loop.
///
bool isLoopExit(const BasicBlock *BB) const;
///
unsigned getNumBackEdges() const;
- /// hasExitBlock - Return true if the current loop has the specified block as
- /// an exit block...
- bool hasExitBlock(BasicBlock *BB) const {
- for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i)
- if (ExitBlocks[i] == BB)
- return true;
- return false;
- }
-
//===--------------------------------------------------------------------===//
// APIs for simple analysis of the loop.
//
// induction variable canonicalization pass should be used to normalize loops
// for easy analysis. These methods assume canonical loops.
+ /// 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;
+
/// 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
///
void addBasicBlockToLoop(BasicBlock *NewBB, LoopInfo &LI);
- /// changeExitBlock - This method is used to update loop information. All
- /// instances of the specified Old basic block are removed from the exit list
- /// and replaced with New.
- ///
- void changeExitBlock(BasicBlock *Old, BasicBlock *New);
-
/// replaceChildLoopWith - This is used when splitting loops up. It replaces
/// the OldChild entry in our children list with NewChild, and updates the
/// parent pointer of OldChild to be null and the NewChild to be this loop.
/// into another loop.
Loop *removeChildLoop(iterator OldChild);
- /// addExitBlock - Add the specified exit block to the loop.
- ///
- void addExitBlock(BasicBlock *BB) {
- ExitBlocks.push_back(BB);
- }
-
/// addBlockEntry - This adds a basic block directly to the basic block list.
/// This should only be used by transformations that create new loops. Other
/// transformations should use addBasicBlockToLoop.
}
/// removeBlockFromLoop - This removes the specified basic block from the
- /// current loop, updating the Blocks and ExitBlocks lists as appropriate.
- /// This does not update the mapping in the LoopInfo class.
+ /// current loop, updating the Blocks as appropriate. This does not update
+ /// the mapping in the LoopInfo class.
void removeBlockFromLoop(BasicBlock *BB);
void print(std::ostream &O, unsigned Depth = 0) const;
if (i) OS << ",";
WriteAsOperand(OS, getBlocks()[i], false);
}
- if (!ExitBlocks.empty()) {
- OS << "\tExitBlocks: ";
- for (unsigned i = 0; i < getExitBlocks().size(); ++i) {
- if (i) OS << ",";
- WriteAsOperand(OS, getExitBlocks()[i], false);
- }
- }
-
OS << "\n";
for (iterator I = begin(), E = end(); I != E; ++I)
}
}
- // Now that we know all of the blocks that make up this loop, see if there are
- // any branches to outside of the loop... building the ExitBlocks list.
- for (std::vector<BasicBlock*>::iterator BI = L->Blocks.begin(),
- BE = L->Blocks.end(); BI != BE; ++BI)
- for (succ_iterator I = succ_begin(*BI), E = succ_end(*BI); I != E; ++I)
- if (!L->contains(*I)) // Not in current loop?
- L->ExitBlocks.push_back(*I); // It must be an exit block...
-
return L;
}
// APIs for simple analysis of the loop.
//
+/// getExitBlocks - Return all of the successor blocks of this loop. These
+/// are the blocks _outside of the current loop_ which are branched to.
+///
+void Loop::getExitBlocks(std::vector<BasicBlock*> &Blocks) const {
+ for (std::vector<BasicBlock*>::const_iterator BI = Blocks.begin(),
+ BE = Blocks.end(); BI != BE; ++BI)
+ for (succ_iterator I = succ_begin(*BI), E = succ_end(*BI); I != E; ++I)
+ if (!contains(*I)) // Not in current loop?
+ Blocks.push_back(*I); // It must be an exit block...
+}
+
+
/// 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
}
}
-/// changeExitBlock - This method is used to update loop information. All
-/// instances of the specified Old basic block are removed from the exit list
-/// and replaced with New.
-///
-void Loop::changeExitBlock(BasicBlock *Old, BasicBlock *New) {
- assert(Old != New && "Cannot changeExitBlock to the same thing!");
- assert(Old && New && "Cannot changeExitBlock to or from a null node!");
- assert(hasExitBlock(Old) && "Old exit block not found!");
- std::vector<BasicBlock*>::iterator
- I = std::find(ExitBlocks.begin(), ExitBlocks.end(), Old);
- while (I != ExitBlocks.end()) {
- *I = New;
- I = std::find(I+1, ExitBlocks.end(), Old);
- }
-}
-
/// replaceChildLoopWith - This is used when splitting loops up. It replaces
/// the OldChild entry in our children list with NewChild, and updates the
/// parent pointers of the two loops as appropriate.
/// does not update the mapping in the LoopInfo class.
void Loop::removeBlockFromLoop(BasicBlock *BB) {
RemoveFromVector(Blocks, BB);
-
- // If this block branched out of this loop, remove any exit blocks entries due
- // to it.
- for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); SI != E; ++SI)
- if (!contains(*SI) && *SI != BB)
- RemoveFromVector(ExitBlocks, *SI);
-
- // If any blocks in this loop branch to BB, add it to the exit blocks set.
- for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
- if (contains(*PI))
- ExitBlocks.push_back(BB);
}
/// will iterate.
SCEVHandle ScalarEvolutionsImpl::ComputeIterationCount(const Loop *L) {
// If the loop has a non-one exit block count, we can't analyze it.
- if (L->getExitBlocks().size() != 1) return UnknownValue;
+ std::vector<BasicBlock*> ExitBlocks;
+ L->getExitBlocks(ExitBlocks);
+ if (ExitBlocks.size() != 1) return UnknownValue;
// Okay, there is one exit block. Try to find the condition that causes the
// loop to be exited.
- BasicBlock *ExitBlock = L->getExitBlocks()[0];
+ BasicBlock *ExitBlock = ExitBlocks[0];
BasicBlock *ExitingBlock = 0;
for (pred_iterator PI = pred_begin(ExitBlock), E = pred_end(ExitBlock);
PrintLoopInfo(OS, SE, *I);
std::cerr << "Loop " << L->getHeader()->getName() << ": ";
- if (L->getExitBlocks().size() != 1)
+
+ std::vector<BasicBlock*> ExitBlocks;
+ L->getExitBlocks(ExitBlocks);
+ if (ExitBlocks.size() != 1)
std::cerr << "<multiple exits> ";
if (SE->hasLoopInvariantIterationCount(L)) {
else {
// Check to see if any exits from the loop are more than just return
// blocks.
- for (unsigned i = 0, e = TLL->getExitBlocks().size(); i != e; ++i)
- if (!isa<ReturnInst>(TLL->getExitBlocks()[i]->getTerminator())) {
+ std::vector<BasicBlock*> ExitBlocks;
+ TLL->getExitBlocks(ExitBlocks);
+ for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i)
+ if (!isa<ReturnInst>(ExitBlocks[i]->getTerminator())) {
ShouldExtractLoop = true;
break;
}
ScalarEvolutionRewriter &RW) {
// Find the exit block for the loop. We can currently only handle loops with
// a single exit.
- if (L->getExitBlocks().size() != 1) return;
- BasicBlock *ExitBlock = L->getExitBlocks()[0];
+ std::vector<BasicBlock*> ExitBlocks;
+ L->getExitBlocks(ExitBlocks);
+ if (ExitBlocks.size() != 1) return;
+ BasicBlock *ExitBlock = ExitBlocks[0];
// Make sure there is only one predecessor block in the loop.
BasicBlock *ExitingBlock = 0;
// We insert the code into the preheader of the loop if the loop contains
// multiple exit blocks, or in the exit block if there is exactly one.
BasicBlock *BlockToInsertInto;
- if (L->getExitBlocks().size() == 1)
- BlockToInsertInto = L->getExitBlocks()[0];
+ std::vector<BasicBlock*> ExitBlocks;
+ L->getExitBlocks(ExitBlocks);
+ if (ExitBlocks.size() == 1)
+ BlockToInsertInto = ExitBlocks[0];
else
BlockToInsertInto = Preheader;
BasicBlock::iterator InsertPt = BlockToInsertInto->begin();
}
}
-static void ChangeExitBlocksFromTo(Loop::iterator I, Loop::iterator E,
- BasicBlock *Old, BasicBlock *New) {
- for (; I != E; ++I) {
- Loop *L = *I;
- if (L->hasExitBlock(Old)) {
- L->changeExitBlock(Old, New);
- ChangeExitBlocksFromTo(L->begin(), L->end(), Old, New);
- }
- }
-}
-
-
bool LoopUnroll::visitLoop(Loop *L) {
bool Changed = false;
}
DEBUG(std::cerr << "UNROLLING!\n");
- assert(L->getExitBlocks().size() == 1 && "Must have exactly one exit block!");
- BasicBlock *LoopExit = L->getExitBlocks()[0];
+ BasicBlock *LoopExit = BI->getSuccessor(L->contains(BI->getSuccessor(0)));
// Create a new basic block to temporarily hold all of the cloned code.
BasicBlock *NewBlock = new BasicBlock();
LI->removeBlock(Preheader);
LI->removeBlock(BB);
- // If any loops used Preheader as an exit block, update them to use LoopExit.
- if (Parent)
- ChangeExitBlocksFromTo(Parent->begin(), Parent->end(),
- Preheader, LoopExit);
- else
- ChangeExitBlocksFromTo(LI->begin(), LI->end(),
- Preheader, LoopExit);
-
// If the preheader was the entry block of this function, move the exit block
// to be the new entry of the loop.
Function *F = LoopExit->getParent();
// predecessors that are inside of the loop. This check guarantees that the
// loop preheader/header will dominate the exit blocks. If the exit block has
// predecessors from outside of the loop, split the edge now.
- for (unsigned i = 0, e = L->getExitBlocks().size(); i != e; ++i) {
- BasicBlock *ExitBlock = L->getExitBlocks()[i];
+ std::vector<BasicBlock*> ExitBlocks;
+ L->getExitBlocks(ExitBlocks);
+ for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i) {
+ BasicBlock *ExitBlock = ExitBlocks[i];
for (pred_iterator PI = pred_begin(ExitBlock), PE = pred_end(ExitBlock);
PI != PE; ++PI)
if (!L->contains(*PI)) {
return NewBB;
}
-// ChangeExitBlock - This recursive function is used to change any exit blocks
-// that use OldExit to use NewExit instead. This is recursive because children
-// may need to be processed as well.
-//
-static void ChangeExitBlock(Loop *L, BasicBlock *OldExit, BasicBlock *NewExit) {
- if (L->hasExitBlock(OldExit)) {
- L->changeExitBlock(OldExit, NewExit);
- for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I)
- ChangeExitBlock(*I, OldExit, NewExit);
- }
-}
-
-
/// InsertPreheaderForLoop - Once we discover that a loop doesn't have a
/// preheader, this method is called to insert one. This method has two phases:
/// preheader insertion and analysis updating.
ParentLoopsE = getAnalysis<LoopInfo>().end();
}
- // Loop over all sibling loops, performing the substitution (recursively to
- // include child loops)...
- for (; ParentLoops != ParentLoopsE; ++ParentLoops)
- ChangeExitBlock(*ParentLoops, Header, NewBB);
-
DominatorSet &DS = getAnalysis<DominatorSet>(); // Update dominator info
DominatorTree &DT = getAnalysis<DominatorTree>();
/// outside of the loop.
void LoopSimplify::RewriteLoopExitBlock(Loop *L, BasicBlock *Exit) {
DominatorSet &DS = getAnalysis<DominatorSet>();
- assert(std::find(L->getExitBlocks().begin(), L->getExitBlocks().end(), Exit)
- != L->getExitBlocks().end() && "Not a current exit block!");
std::vector<BasicBlock*> LoopBlocks;
for (pred_iterator I = pred_begin(Exit), E = pred_end(Exit); I != E; ++I)
if (Loop *Parent = L->getParentLoop())
Parent->addBasicBlockToLoop(NewBB, getAnalysis<LoopInfo>());
- // Replace any instances of Exit with NewBB in this and any nested loops...
- for (df_iterator<Loop*> I = df_begin(L), E = df_end(L); I != E; ++I)
- if (I->hasExitBlock(Exit))
- I->changeExitBlock(Exit, NewBB); // Update exit block information
-
// Update dominator information (set, immdom, domtree, and domfrontier)
UpdateDomInfoForRevectoredPreds(NewBB, LoopBlocks);
}
AddBlockAndPredsToSet(*I, StopBlock, Blocks);
}
-static void ReplaceExitBlocksOfLoopAndParents(Loop *L, BasicBlock *Old,
- BasicBlock *New) {
- if (!L->hasExitBlock(Old)) return;
- L->changeExitBlock(Old, New);
- ReplaceExitBlocksOfLoopAndParents(L->getParentLoop(), Old, New);
-}
-
-/// VerifyExitBlocks - This is a function which can be useful for hacking on the
-/// LoopSimplify Code.
-static void VerifyExitBlocks(Loop *L) {
- std::vector<BasicBlock*> ExitBlocks;
- for (unsigned i = 0, e = L->getBlocks().size(); i != e; ++i) {
- BasicBlock *BB = L->getBlocks()[i];
- for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); SI != E; ++SI)
- if (!L->contains(*SI))
- ExitBlocks.push_back(*SI);
- }
-
- std::vector<BasicBlock*> EB = L->getExitBlocks();
- std::sort(EB.begin(), EB.end());
- std::sort(ExitBlocks.begin(), ExitBlocks.end());
- assert(EB == ExitBlocks && "Exit blocks were incorrectly updated!");
-
- for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I)
- VerifyExitBlocks(*I);
-}
-
/// FindPHIToPartitionLoops - The first part of loop-nestification is to find a
/// PHI node that tells us how to partition the loops.
static PHINode *FindPHIToPartitionLoops(Loop *L) {
// L is now a subloop of our outer loop.
NewOuter->addChildLoop(L);
- // Add all of L's exit blocks to the outer loop.
- for (unsigned i = 0, e = L->getExitBlocks().size(); i != e; ++i)
- NewOuter->addExitBlock(L->getExitBlocks()[i]);
-
- // Add temporary exit block entries for NewBB. Add one for each edge in L
- // that goes to NewBB.
- for (pred_iterator PI = pred_begin(NewBB), E = pred_end(NewBB); PI != E; ++PI)
- if (L->contains(*PI))
- L->addExitBlock(NewBB);
-
for (unsigned i = 0, e = L->getBlocks().size(); i != e; ++i)
NewOuter->addBlockEntry(L->getBlocks()[i]);
}
}
- // Check all subloops of this loop, replacing any exit blocks that got
- // revectored with the new basic block.
- for (pred_iterator I = pred_begin(NewBB), E = pred_end(NewBB); I != E; ++I)
- if (NewOuter->contains(*I)) {
- // Change any exit blocks that used to go to Header to go to NewBB
- // instead.
- ReplaceExitBlocksOfLoopAndParents((Loop*)LI[*I], Header, NewBB);
- }
-
- //VerifyExitBlocks(NewOuter);
return NewOuter;
}
// loop and all parent loops.
L->addBasicBlockToLoop(BEBlock, getAnalysis<LoopInfo>());
- // Replace any instances of Exit with NewBB in this and any nested loops...
- for (df_iterator<Loop*> I = df_begin(L), E = df_end(L); I != E; ++I)
- if (I->hasExitBlock(Header))
- I->changeExitBlock(Header, BEBlock); // Update exit block information
-
// Update dominator information (set, immdom, domtree, and domfrontier)
UpdateDomInfoForRevectoredPreds(BEBlock, BackedgeBlocks);
}
projects / oota-llvm.git / commitdiff