#define DEBUG_TYPE "licm"
#include "llvm/Transforms/Scalar.h"
+#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Instructions.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Analysis/LoopPass.h"
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/Analysis/AliasSetTracker.h"
#include "llvm/Analysis/Dominators.h"
-#include "llvm/Support/CFG.h"
+#include "llvm/Analysis/ScalarEvolution.h"
#include "llvm/Transforms/Utils/PromoteMemToReg.h"
-#include "llvm/Transforms/Utils/Local.h"
+#include "llvm/Support/CFG.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/ADT/Statistic.h"
DisablePromotion("disable-licm-promotion", cl::Hidden,
cl::desc("Disable memory promotion in LICM pass"));
- struct LICM : public FunctionPass {
- virtual bool runOnFunction(Function &F);
+ struct VISIBILITY_HIDDEN LICM : public LoopPass {
+ static char ID; // Pass identification, replacement for typeid
+ LICM() : LoopPass((intptr_t)&ID) {}
+
+ virtual bool runOnLoop(Loop *L, LPPassManager &LPM);
/// This transformation requires natural loop information & requires that
/// loop preheaders be inserted into the CFG...
AU.addRequired<DominatorTree>();
AU.addRequired<DominanceFrontier>(); // For scalar promotion (mem2reg)
AU.addRequired<AliasAnalysis>();
+ AU.addPreserved<ScalarEvolution>();
+ AU.addPreserved<DominanceFrontier>();
+ }
+
+ bool doFinalization() {
+ LoopToAliasMap.clear();
+ return false;
}
private:
BasicBlock *Preheader; // The preheader block of the current loop...
Loop *CurLoop; // The current loop we are working on...
AliasSetTracker *CurAST; // AliasSet information for the current loop...
+ std::map<Loop *, AliasSetTracker *> LoopToAliasMap;
- /// visitLoop - Hoist expressions out of the specified loop...
- ///
- void visitLoop(Loop *L, AliasSetTracker &AST);
+ /// cloneBasicBlockAnalysis - Simple Analysis hook. Clone alias set info.
+ void cloneBasicBlockAnalysis(BasicBlock *From, BasicBlock *To, Loop *L);
+
+ /// deleteAnalysisValue - Simple Analysis hook. Delete value V from alias
+ /// set.
+ void deleteAnalysisValue(Value *V, Loop *L);
/// SinkRegion - Walk the specified region of the CFG (defined by all blocks
/// dominated by the specified block, and that are in the current loop) in
/// visit uses before definitions, allowing us to sink a loop body in one
/// pass without iteration.
///
- void SinkRegion(DominatorTree::Node *N);
+ void SinkRegion(DomTreeNode *N);
/// HoistRegion - Walk the specified region of the CFG (defined by all
/// blocks dominated by the specified block, and that are in the current
/// visit definitions before uses, allowing us to hoist a loop body in one
/// pass without iteration.
///
- void HoistRegion(DominatorTree::Node *N);
+ void HoistRegion(DomTreeNode *N);
/// inSubLoop - Little predicate that returns true if the specified basic
/// block is in a subloop of the current one, not the current one itself.
if (BlockInLoop == LoopHeader)
return true;
- DominatorTree::Node *BlockInLoopNode = DT->getNode(BlockInLoop);
- DominatorTree::Node *IDom = DT->getNode(ExitBlock);
+ DomTreeNode *BlockInLoopNode = DT->getNode(BlockInLoop);
+ DomTreeNode *IDom = DT->getNode(ExitBlock);
// Because the exit block is not in the loop, we know we have to get _at
// least_ its immediate dominator.
std::map<Value*, AllocaInst*> &Val2AlMap);
};
+ char LICM::ID = 0;
RegisterPass<LICM> X("licm", "Loop Invariant Code Motion");
}
-FunctionPass *llvm::createLICMPass() { return new LICM(); }
+LoopPass *llvm::createLICMPass() { return new LICM(); }
-/// runOnFunction - For LICM, this simply traverses the loop structure of the
-/// function, hoisting expressions out of loops if possible.
+/// Hoist expressions out of the specified loop. Note, alias info for inner
+/// loop is not preserved so it is not a good idea to run LICM multiple
+/// times on one loop.
///
-bool LICM::runOnFunction(Function &) {
+bool LICM::runOnLoop(Loop *L, LPPassManager &LPM) {
Changed = false;
// Get our Loop and Alias Analysis information...
DF = &getAnalysis<DominanceFrontier>();
DT = &getAnalysis<DominatorTree>();
- // Hoist expressions out of all of the top-level loops.
- for (LoopInfo::iterator I = LI->begin(), E = LI->end(); I != E; ++I) {
- AliasSetTracker AST(*AA);
- visitLoop(*I, AST);
- }
- return Changed;
-}
+ CurAST = new AliasSetTracker(*AA);
+ // Collect Alias info from subloops
+ for (Loop::iterator LoopItr = L->begin(), LoopItrE = L->end();
+ LoopItr != LoopItrE; ++LoopItr) {
+ Loop *InnerL = *LoopItr;
+ AliasSetTracker *InnerAST = LoopToAliasMap[InnerL];
+ assert (InnerAST && "Where is my AST?");
-
-/// visitLoop - Hoist expressions out of the specified loop...
-///
-void LICM::visitLoop(Loop *L, AliasSetTracker &AST) {
- // Recurse through all subloops before we process this loop...
- for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I) {
- AliasSetTracker SubAST(*AA);
- visitLoop(*I, SubAST);
-
- // Incorporate information about the subloops into this loop...
- AST.add(SubAST);
+ // What if InnerLoop was modified by other passes ?
+ CurAST->add(*InnerAST);
}
+
CurLoop = L;
- CurAST = &AST;
// Get the preheader block to move instructions into...
Preheader = L->getLoopPreheader();
for (std::vector<BasicBlock*>::const_iterator I = L->getBlocks().begin(),
E = L->getBlocks().end(); I != E; ++I)
if (LI->getLoopFor(*I) == L) // Ignore blocks in subloops...
- AST.add(**I); // Incorporate the specified basic block
+ CurAST->add(**I); // Incorporate the specified basic block
// We want to visit all of the instructions in this loop... that are not parts
// of our subloops (they have already had their invariants hoisted out of
//
// Traverse the body of the loop in depth first order on the dominator tree so
// that we are guaranteed to see definitions before we see uses. This allows
- // us to sink instructions in one pass, without iteration. AFter sinking
+ // us to sink instructions in one pass, without iteration. After sinking
// instructions, we perform another pass to hoist them out of the loop.
//
SinkRegion(DT->getNode(L->getHeader()));
// Clear out loops state information for the next iteration
CurLoop = 0;
Preheader = 0;
+
+ LoopToAliasMap[L] = CurAST;
+ return Changed;
}
/// SinkRegion - Walk the specified region of the CFG (defined by all blocks
/// uses before definitions, allowing us to sink a loop body in one pass without
/// iteration.
///
-void LICM::SinkRegion(DominatorTree::Node *N) {
+void LICM::SinkRegion(DomTreeNode *N) {
assert(N != 0 && "Null dominator tree node?");
BasicBlock *BB = N->getBlock();
if (!CurLoop->contains(BB)) return;
// We are processing blocks in reverse dfo, so process children first...
- const std::vector<DominatorTree::Node*> &Children = N->getChildren();
+ const std::vector<DomTreeNode*> &Children = N->getChildren();
for (unsigned i = 0, e = Children.size(); i != e; ++i)
SinkRegion(Children[i]);
/// first order w.r.t the DominatorTree. This allows us to visit definitions
/// before uses, allowing us to hoist a loop body in one pass without iteration.
///
-void LICM::HoistRegion(DominatorTree::Node *N) {
+void LICM::HoistRegion(DomTreeNode *N) {
assert(N != 0 && "Null dominator tree node?");
BasicBlock *BB = N->getBlock();
hoist(I);
}
- const std::vector<DominatorTree::Node*> &Children = N->getChildren();
+ const std::vector<DomTreeNode*> &Children = N->getChildren();
for (unsigned i = 0, e = Children.size(); i != e; ++i)
HoistRegion(Children[i]);
}
}
// Otherwise these instructions are hoistable/sinkable
- return isa<BinaryOperator>(I) || isa<ShiftInst>(I) || isa<CastInst>(I) ||
- isa<SelectInst>(I) || isa<GetElementPtrInst>(I);
+ return isa<BinaryOperator>(I) || isa<CastInst>(I) ||
+ isa<SelectInst>(I) || isa<GetElementPtrInst>(I) || isa<CmpInst>(I) ||
+ isa<InsertElementInst>(I) || isa<ExtractElementInst>(I) ||
+ isa<ShuffleVectorInst>(I);
}
/// isNotUsedInLoop - Return true if the only users of this instruction are
void LICM::sink(Instruction &I) {
DOUT << "LICM sinking instruction: " << I;
- std::vector<BasicBlock*> ExitBlocks;
+ SmallVector<BasicBlock*, 8> ExitBlocks;
CurLoop->getExitBlocks(ExitBlocks);
if (isa<LoadInst>(I)) ++NumMovedLoads;
// Firstly, we create a stack object to hold the value...
AllocaInst *AI = 0;
- if (I.getType() != Type::VoidTy)
+ if (I.getType() != Type::VoidTy) {
AI = new AllocaInst(I.getType(), 0, I.getName(),
- I.getParent()->getParent()->front().begin());
+ I.getParent()->getParent()->getEntryBlock().begin());
+ CurAST->add(AI);
+ }
// Secondly, insert load instructions for each use of the instruction
// outside of the loop.
// Insert a new load instruction right before the terminator in
// the predecessor block.
PredVal = new LoadInst(AI, "", Pred->getTerminator());
+ CurAST->add(cast<LoadInst>(PredVal));
}
UPN->setIncomingValue(i, PredVal);
} else {
LoadInst *L = new LoadInst(AI, "", U);
U->replaceUsesOfWith(&I, L);
+ CurAST->add(L);
}
}
if (AI) {
std::vector<AllocaInst*> Allocas;
Allocas.push_back(AI);
- PromoteMemToReg(Allocas, *DT, *DF, AA->getTargetData(), CurAST);
+ PromoteMemToReg(Allocas, *DT, *DF, CurAST);
}
}
}
return true;
// Get the exit blocks for the current loop.
- std::vector<BasicBlock*> ExitBlocks;
+ SmallVector<BasicBlock*, 8> ExitBlocks;
CurLoop->getExitBlocks(ExitBlocks);
// For each exit block, get the DT node and walk up the DT until the
//
std::set<BasicBlock*> ProcessedBlocks;
- std::vector<BasicBlock*> ExitBlocks;
+ SmallVector<BasicBlock*, 8> ExitBlocks;
CurLoop->getExitBlocks(ExitBlocks);
for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i)
if (ProcessedBlocks.insert(ExitBlocks[i]).second) {
PromotedAllocas.reserve(PromotedValues.size());
for (unsigned i = 0, e = PromotedValues.size(); i != e; ++i)
PromotedAllocas.push_back(PromotedValues[i].first);
- PromoteMemToReg(PromotedAllocas, *DT, *DF, AA->getTargetData(), CurAST);
+ PromoteMemToReg(PromotedAllocas, *DT, *DF, CurAST);
}
/// FindPromotableValuesInLoop - Check the current loop for stores to definite
-/// pointers, which are not loaded and stored through may aliases. If these are
-/// found, create an alloca for the value, add it to the PromotedValues list,
-/// and keep track of the mapping from value to alloca.
-///
+/// pointers, which are not loaded and stored through may aliases and are safe
+/// for promotion. If these are found, create an alloca for the value, add it
+/// to the PromotedValues list, and keep track of the mapping from value to
+/// alloca.
void LICM::FindPromotableValuesInLoop(
std::vector<std::pair<AllocaInst*, Value*> > &PromotedValues,
std::map<Value*, AllocaInst*> &ValueToAllocaMap) {
Instruction *FnStart = CurLoop->getHeader()->getParent()->begin()->begin();
+ SmallVector<Instruction *, 4> LoopExits;
+ SmallVector<BasicBlock *, 4> Blocks;
+ CurLoop->getExitingBlocks(Blocks);
+ for (SmallVector<BasicBlock *, 4>::iterator BI = Blocks.begin(),
+ BE = Blocks.end(); BI != BE; ++BI) {
+ BasicBlock *BB = *BI;
+ LoopExits.push_back(BB->getTerminator());
+ }
+
// Loop over all of the alias sets in the tracker object.
for (AliasSetTracker::iterator I = CurAST->begin(), E = CurAST->end();
I != E; ++I) {
// volatile loads or stores.
if (!AS.isForwardingAliasSet() && AS.isMod() && AS.isMustAlias() &&
!AS.isVolatile() && CurLoop->isLoopInvariant(AS.begin()->first)) {
- assert(AS.begin() != AS.end() &&
+ assert(!AS.empty() &&
"Must alias set should have at least one pointer element in it!");
Value *V = AS.begin()->first;
break;
}
+ // If one use of value V inside the loop is safe then it is OK to promote
+ // this value. On the otherside if there is not any unsafe use inside the
+ // looop then also it is OK to promote this value. Otherwise it is
+ // unsafe to promote this value.
+ if (PointerOk) {
+ bool oneSafeUse = false;
+ bool oneUnsafeUse = false;
+ for(Value::use_iterator UI = V->use_begin(), UE = V->use_end();
+ UI != UE; ++UI) {
+ Instruction *Use = dyn_cast<Instruction>(*UI);
+ if (!Use || !CurLoop->contains(Use->getParent()))
+ continue;
+ for (SmallVector<Instruction *, 4>::iterator
+ ExitI = LoopExits.begin(), ExitE = LoopExits.end();
+ ExitI != ExitE; ++ExitI) {
+ Instruction *Ex = *ExitI;
+ if (!isa<PHINode>(Use) && DT->dominates(Use, Ex)) {
+ oneSafeUse = true;
+ break;
+ }
+ else
+ oneUnsafeUse = true;
+ }
+
+ if (oneSafeUse)
+ break;
+ }
+
+ if (oneSafeUse)
+ PointerOk = true;
+ else if (!oneUnsafeUse)
+ PointerOk = true;
+ else
+ PointerOk = false;
+ }
+
if (PointerOk) {
const Type *Ty = cast<PointerType>(V->getType())->getElementType();
AllocaInst *AI = new AllocaInst(Ty, 0, V->getName()+".tmp", FnStart);
}
}
}
+
+/// cloneBasicBlockAnalysis - Simple Analysis hook. Clone alias set info.
+void LICM::cloneBasicBlockAnalysis(BasicBlock *From, BasicBlock *To, Loop *L) {
+ AliasSetTracker *AST = LoopToAliasMap[L];
+ if (!AST)
+ return;
+
+ AST->copyValue(From, To);
+}
+
+/// deleteAnalysisValue - Simple Analysis hook. Delete value V from alias
+/// set.
+void LICM::deleteAnalysisValue(Value *V, Loop *L) {
+ AliasSetTracker *AST = LoopToAliasMap[L];
+ if (!AST)
+ return;
+
+ AST->deleteValue(V);
+}