#include "llvm/Analysis/Dominators.h"
#include "llvm/Assembly/Writer.h"
#include "llvm/Support/CFG.h"
+#include "llvm/Support/Streams.h"
#include "llvm/ADT/DepthFirstIterator.h"
+#include "llvm/ADT/SmallPtrSet.h"
#include <algorithm>
-#include <iostream>
+#include <ostream>
using namespace llvm;
-static RegisterAnalysis<LoopInfo>
+char LoopInfo::ID = 0;
+static RegisterPass<LoopInfo>
X("loops", "Natural Loop Construction", true);
//===----------------------------------------------------------------------===//
(*I)->print(OS, Depth+2);
}
+/// verifyLoop - Verify loop structure
+void Loop::verifyLoop() const {
+#ifndef NDEBUG
+ assert (getHeader() && "Loop header is missing");
+ assert (getLoopPreheader() && "Loop preheader is missing");
+ assert (getLoopLatch() && "Loop latch is missing");
+ for (std::vector<Loop*>::const_iterator I = SubLoops.begin(), E = SubLoops.end();
+ I != E; ++I)
+ (*I)->verifyLoop();
+#endif
+}
+
void Loop::dump() const {
- print(std::cerr);
+ print(cerr);
}
//
bool LoopInfo::runOnFunction(Function &) {
releaseMemory();
- Calculate(getAnalysis<ETForest>()); // Update
+ Calculate(getAnalysis<DominatorTree>()); // Update
return false;
}
TopLevelLoops.clear();
}
-
-void LoopInfo::Calculate(ETForest &EF) {
- BasicBlock *RootNode = EF.getRoot();
+void LoopInfo::Calculate(DominatorTree &DT) {
+ BasicBlock *RootNode = DT.getRootNode()->getBlock();
for (df_iterator<BasicBlock*> NI = df_begin(RootNode),
NE = df_end(RootNode); NI != NE; ++NI)
- if (Loop *L = ConsiderForLoop(*NI, EF))
+ if (Loop *L = ConsiderForLoop(*NI, DT))
TopLevelLoops.push_back(L);
}
void LoopInfo::getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
- AU.addRequired<ETForest>();
+ AU.addRequired<DominatorTree>();
}
void LoopInfo::print(std::ostream &OS, const Module* ) const {
return isNotAlreadyContainedIn(SubLoop->getParentLoop(), ParentLoop);
}
-Loop *LoopInfo::ConsiderForLoop(BasicBlock *BB, ETForest &EF) {
+Loop *LoopInfo::ConsiderForLoop(BasicBlock *BB, DominatorTree &DT) {
if (BBMap.find(BB) != BBMap.end()) return 0; // Haven't processed this node?
std::vector<BasicBlock *> TodoStack;
// Scan the predecessors of BB, checking to see if BB dominates any of
// them. This identifies backedges which target this node...
for (pred_iterator I = pred_begin(BB), E = pred_end(BB); I != E; ++I)
- if (EF.dominates(BB, *I)) // If BB dominates it's predecessor...
+ if (DT.dominates(BB, *I)) // If BB dominates it's predecessor...
TodoStack.push_back(*I);
if (TodoStack.empty()) return 0; // No backedges to this block...
TodoStack.pop_back();
if (!L->contains(X) && // As of yet unprocessed??
- EF.dominates(EntryBlock, X)) { // X is reachable from entry block?
+ DT.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,
// If there are any loops nested within this loop, create them now!
for (std::vector<BasicBlock*>::iterator I = L->Blocks.begin(),
E = L->Blocks.end(); I != E; ++I)
- if (Loop *NewLoop = ConsiderForLoop(*I, EF)) {
+ if (Loop *NewLoop = ConsiderForLoop(*I, DT)) {
L->SubLoops.push_back(NewLoop);
NewLoop->ParentLoop = L;
}
// APIs for simple analysis of the loop.
//
+/// 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 Loop::getExitingBlocks(SmallVector<BasicBlock*, 8> &ExitingBlocks) const {
+ // Sort the blocks vector so that we can use binary search to do quick
+ // lookups.
+ std::vector<BasicBlock*> LoopBBs(block_begin(), block_end());
+ std::sort(LoopBBs.begin(), LoopBBs.end());
+
+ 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 (!std::binary_search(LoopBBs.begin(), LoopBBs.end(), *I)) {
+ // Not in current loop? It must be an exit block.
+ ExitingBlocks.push_back(*BI);
+ break;
+ }
+}
+
/// 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*> &ExitBlocks) const {
+void Loop::getExitBlocks(SmallVector<BasicBlock*, 8> &ExitBlocks) const {
+ // Sort the blocks vector so that we can use binary search to do quick
+ // lookups.
+ std::vector<BasicBlock*> LoopBBs(block_begin(), block_end());
+ std::sort(LoopBBs.begin(), LoopBBs.end());
+
for (std::vector<BasicBlock*>::const_iterator BI = Blocks.begin(),
- BE = Blocks.end(); BI != BE; ++BI)
+ 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?
- ExitBlocks.push_back(*I); // It must be an exit block...
+ if (!std::binary_search(LoopBBs.begin(), LoopBBs.end(), *I))
+ // Not in current loop? It must be an exit block.
+ ExitBlocks.push_back(*I);
+}
+
+/// 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 Loop::getUniqueExitBlocks(SmallVector<BasicBlock*, 8> &ExitBlocks) const {
+ // Sort the blocks vector so that we can use binary search to do quick
+ // lookups.
+ std::vector<BasicBlock*> LoopBBs(block_begin(), block_end());
+ std::sort(LoopBBs.begin(), LoopBBs.end());
+
+ std::vector<BasicBlock*> switchExitBlocks;
+
+ for (std::vector<BasicBlock*>::const_iterator BI = Blocks.begin(),
+ BE = Blocks.end(); BI != BE; ++BI) {
+
+ BasicBlock *current = *BI;
+ switchExitBlocks.clear();
+
+ for (succ_iterator I = succ_begin(*BI), E = succ_end(*BI); I != E; ++I) {
+ if (std::binary_search(LoopBBs.begin(), LoopBBs.end(), *I))
+ // If block is inside the loop then it is not a exit block.
+ continue;
+
+ pred_iterator PI = pred_begin(*I);
+ BasicBlock *firstPred = *PI;
+
+ // If current basic block is this exit block's first predecessor
+ // then only insert exit block in to the output ExitBlocks vector.
+ // This ensures that same exit block is not inserted twice into
+ // ExitBlocks vector.
+ if (current != firstPred)
+ continue;
+
+ // If a terminator has more then two successors, for example SwitchInst,
+ // then it is possible that there are multiple edges from current block
+ // to one exit block.
+ if (current->getTerminator()->getNumSuccessors() <= 2) {
+ ExitBlocks.push_back(*I);
+ continue;
+ }
+
+ // In case of multiple edges from current block to exit block, collect
+ // only one edge in ExitBlocks. Use switchExitBlocks to keep track of
+ // duplicate edges.
+ if (std::find(switchExitBlocks.begin(), switchExitBlocks.end(), *I)
+ == switchExitBlocks.end()) {
+ switchExitBlocks.push_back(*I);
+ ExitBlocks.push_back(*I);
+ }
+ }
+ }
}
/// returns null.
///
Value *Loop::getTripCount() const {
- // Canonical loops will end with a 'setne I, V', where I is the incremented
+ // Canonical loops will end with a 'cmp ne I, V', where I is the incremented
// canonical induction variable and V is the trip count of the loop.
Instruction *Inc = getCanonicalInductionVariableIncrement();
if (Inc == 0) return 0;
IV->getIncomingBlock(contains(IV->getIncomingBlock(1)));
if (BranchInst *BI = dyn_cast<BranchInst>(BackedgeBlock->getTerminator()))
- if (BI->isConditional())
- if (SetCondInst *SCI = dyn_cast<SetCondInst>(BI->getCondition()))
- if (SCI->getOperand(0) == Inc)
+ if (BI->isConditional()) {
+ if (ICmpInst *ICI = dyn_cast<ICmpInst>(BI->getCondition())) {
+ if (ICI->getOperand(0) == Inc)
if (BI->getSuccessor(0) == getHeader()) {
- if (SCI->getOpcode() == Instruction::SetNE)
- return SCI->getOperand(1);
- } else if (SCI->getOpcode() == Instruction::SetEQ) {
- return SCI->getOperand(1);
+ if (ICI->getPredicate() == ICmpInst::ICMP_NE)
+ return ICI->getOperand(1);
+ } else if (ICI->getPredicate() == ICmpInst::ICMP_EQ) {
+ return ICI->getOperand(1);
}
+ }
+ }
return 0;
}
+/// isLCSSAForm - Return true if the Loop is in LCSSA form
+bool Loop::isLCSSAForm() const {
+ // Sort the blocks vector so that we can use binary search to do quick
+ // lookups.
+ SmallPtrSet<BasicBlock*, 16> LoopBBs(block_begin(), block_end());
+
+ for (block_iterator BI = block_begin(), E = block_end(); BI != E; ++BI) {
+ BasicBlock *BB = *BI;
+ for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I)
+ for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E;
+ ++UI) {
+ BasicBlock *UserBB = cast<Instruction>(*UI)->getParent();
+ if (PHINode *P = dyn_cast<PHINode>(*UI)) {
+ unsigned OperandNo = UI.getOperandNo();
+ UserBB = P->getIncomingBlock(OperandNo/2);
+ }
+
+ // Check the current block, as a fast-path. Most values are used in the
+ // same block they are defined in.
+ if (UserBB != BB && !LoopBBs.count(UserBB))
+ return false;
+ }
+ }
+
+ return true;
+}
//===-------------------------------------------------------------------===//
// APIs for updating loop information after changing the CFG