-//===- LoopInfo.cpp - Natural Loop Calculator -------------------------------=//
+//===- LoopInfo.cpp - Natural Loop Calculator -----------------------------===//
+//
+// 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
// and determine the loop depth of various nodes of the CFG. Note that the
#include "Support/DepthFirstIterator.h"
#include <algorithm>
+namespace llvm {
+
static RegisterAnalysis<LoopInfo>
X("loops", "Natural Loop Construction", true);
}
bool Loop::isLoopExit(const BasicBlock *BB) const {
- for (BasicBlock::succ_const_iterator SI = succ_begin(BB), SE = succ_end(BB);
+ for (succ_const_iterator SI = succ_begin(BB), SE = succ_end(BB);
SI != SE; ++SI) {
if (!contains(*SI))
return true;
return false;
}
+/// getNumBackEdges - Calculate the number of back edges to the loop header.
+///
unsigned Loop::getNumBackEdges() const {
unsigned NumBackEdges = 0;
BasicBlock *H = getHeader();
- for (std::vector<BasicBlock*>::const_iterator I = Blocks.begin(),
- E = Blocks.end(); I != E; ++I)
- for (BasicBlock::succ_iterator SI = succ_begin(*I), SE = succ_end(*I);
- SI != SE; ++SI)
- if (*SI == H)
- ++NumBackEdges;
-
+ for (pred_iterator I = pred_begin(H), E = pred_end(H); I != E; ++I)
+ if (contains(*I))
+ ++NumBackEdges;
+
return NumBackEdges;
}
-void Loop::print(std::ostream &OS) const {
- OS << std::string(getLoopDepth()*2, ' ') << "Loop Containing: ";
+void Loop::print(std::ostream &OS, unsigned Depth) const {
+ OS << std::string(Depth*2, ' ') << "Loop Containing: ";
for (unsigned i = 0; i < getBlocks().size(); ++i) {
if (i) OS << ",";
OS << "\n";
- for (unsigned i = 0, e = getSubLoops().size(); i != e; ++i)
- getSubLoops()[i]->print(OS);
+ for (iterator I = begin(), E = end(); I != E; ++I)
+ (*I)->print(OS, Depth+2);
}
void Loop::dump() const {
Loop *L = new Loop(BB);
BBMap[BB] = L;
+ BasicBlock *EntryBlock = &BB->getParent()->getEntryBlock();
+
while (!TodoStack.empty()) { // Process all the nodes in the loop
BasicBlock *X = TodoStack.back();
TodoStack.pop_back();
- if (!L->contains(X)) { // As of yet unprocessed??
+ if (!L->contains(X) && // As of yet unprocessed??
+ DS.dominates(EntryBlock, X)) { // X is reachable from entry block?
// Check to see if this block already belongs to a loop. If this occurs
// then we have a case where a loop that is supposed to be a child of the
// current loop was processed before the current loop. When this occurs,
NewLoop->ParentLoop = L;
}
-
// Add the basic blocks that comprise this loop to the BBMap so that this
// loop can be found for them.
//
BBMap.insert(BBMI, std::make_pair(*I, L)); // Must be at this level
}
+ // Now that we have a list of all of the child loops of this loop, check to
+ // see if any of them should actually be nested inside of each other. We can
+ // accidentally pull loops our of their parents, so we must make sure to
+ // organize the loop nests correctly now.
+ {
+ std::map<BasicBlock*, Loop*> ContainingLoops;
+ for (unsigned i = 0; i != L->SubLoops.size(); ++i) {
+ Loop *Child = L->SubLoops[i];
+ assert(Child->getParentLoop() == L && "Not proper child loop?");
+
+ if (Loop *ContainingLoop = ContainingLoops[Child->getHeader()]) {
+ // If there is already a loop which contains this loop, move this loop
+ // into the containing loop.
+ MoveSiblingLoopInto(Child, ContainingLoop);
+ --i; // The loop got removed from the SubLoops list.
+ } else {
+ // This is currently considered to be a top-level loop. Check to see if
+ // any of the contained blocks are loop headers for subloops we have
+ // already processed.
+ for (unsigned b = 0, e = Child->Blocks.size(); b != e; ++b) {
+ Loop *&BlockLoop = ContainingLoops[Child->Blocks[b]];
+ if (BlockLoop == 0) { // Child block not processed yet...
+ BlockLoop = Child;
+ } else if (BlockLoop != Child) {
+ Loop *SubLoop = BlockLoop;
+ // Reparent all of the blocks which used to belong to BlockLoops
+ for (unsigned j = 0, e = SubLoop->Blocks.size(); j != e; ++j)
+ ContainingLoops[SubLoop->Blocks[j]] = Child;
+
+ // There is already a loop which contains this block, that means
+ // that we should reparent the loop which the block is currently
+ // considered to belong to to be a child of this loop.
+ MoveSiblingLoopInto(SubLoop, Child);
+ --i; // We just shrunk the SubLoops list.
+ }
+ }
+ }
+ }
+ }
+
// 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(),
return L;
}
+/// MoveSiblingLoopInto - This method moves the NewChild loop to live inside of
+/// the NewParent Loop, instead of being a sibling of it.
+void LoopInfo::MoveSiblingLoopInto(Loop *NewChild, Loop *NewParent) {
+ Loop *OldParent = NewChild->getParentLoop();
+ assert(OldParent && OldParent == NewParent->getParentLoop() &&
+ NewChild != NewParent && "Not sibling loops!");
+
+ // Remove NewChild from being a child of OldParent
+ std::vector<Loop*>::iterator I =
+ std::find(OldParent->SubLoops.begin(), OldParent->SubLoops.end(), NewChild);
+ assert(I != OldParent->SubLoops.end() && "Parent fields incorrect??");
+ OldParent->SubLoops.erase(I); // Remove from parent's subloops list
+ NewChild->ParentLoop = 0;
+
+ InsertLoopInto(NewChild, NewParent);
+}
+
+/// InsertLoopInto - This inserts loop L into the specified parent loop. If the
+/// parent loop contains a loop which should contain L, the loop gets inserted
+/// into L instead.
+void LoopInfo::InsertLoopInto(Loop *L, Loop *Parent) {
+ BasicBlock *LHeader = L->getHeader();
+ assert(Parent->contains(LHeader) && "This loop should not be inserted here!");
+
+ // Check to see if it belongs in a child loop...
+ for (unsigned i = 0, e = Parent->SubLoops.size(); i != e; ++i)
+ if (Parent->SubLoops[i]->contains(LHeader)) {
+ InsertLoopInto(L, Parent->SubLoops[i]);
+ return;
+ }
+
+ // If not, insert it here!
+ Parent->SubLoops.push_back(L);
+ L->ParentLoop = Parent;
+}
+
+
+
/// 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
I = std::find(I+1, ExitBlocks.end(), Old);
}
}
+
+} // End llvm namespace