/// Assign pass manager to manage this pass.
void LoopPass::assignPassManager(PMStack &PMS,
PassManagerType PreferredType) {
// Find LPPassManager
while (!PMS.empty() &&
PMS.top()->getPassManagerType() > PMT_LoopPassManager)
PMS.pop();
LPPassManager *LPPM;
if (PMS.top()->getPassManagerType() == PMT_LoopPassManager)
LPPM = (LPPassManager*)PMS.top();
else {
// Create new Loop Pass Manager if it does not exist.
assert (!PMS.empty() && "Unable to create Loop Pass Manager");
PMDataManager *PMD = PMS.top();
// [1] Create new Loop Pass Manager
LPPM = new LPPassManager();
LPPM->populateInheritedAnalysis(PMS);
// [2] Set up new manager's top level manager
PMTopLevelManager *TPM = PMD->getTopLevelManager();
TPM->addIndirectPassManager(LPPM);
// [3] Assign manager to manage this new manager. This may create
// and push new managers into PMS
Pass *P = LPPM->getAsPass();
TPM->schedulePass(P);
// [4] Push new manager into PMS
PMS.push(LPPM);
}
LPPM->add(this);
}
// Check if this pass is suitable for the current LPPassManager, if
// available. This pass P is not suitable for a LPPassManager if P
// is not preserving higher level analysis info used by other
// LPPassManager passes. In such case, pop LPPassManager from the
// stack. This will force assignPassManager() to create new
// LPPassManger as expected.
void LoopPass::preparePassManager(PMStack &PMS) {
// Find LPPassManager
while (!PMS.empty() &&
PMS.top()->getPassManagerType() > PMT_LoopPassManager)
PMS.pop();
LPPassManager *LPPM = dynamic_cast<LPPassManager *>(PMS.top());
// If this pass is destroying high level information that is used
// by other passes that are managed by LPM then do not insert
// this pass in current LPM. Use new LPPassManager.
if (LPPM && !LPPM->preserveHigherLevelAnalysis(this))
PMS.pop();
}
bool LoopExtractor::runOnLoop(Loop *L, LPPassManager &LPM) {
// Only visit top-level loops.
if (L->getParentLoop())
return false;
// If LoopSimplify form is not available, stay out of trouble.
if (!L->isLoopSimplifyForm())
return false;
DominatorTree &DT = getAnalysis<DominatorTree>();
bool Changed = false;
// If there is more than one top-level loop in this function, extract all of
// the loops. Otherwise there is exactly one top-level loop; in this case if
// this function is more than a minimal wrapper around the loop, extract
// the loop.
bool ShouldExtractLoop = false;
// Extract the loop if the entry block doesn't branch to the loop header.
TerminatorInst *EntryTI =
L->getHeader()->getParent()->getEntryBlock().getTerminator();
if (!isa<BranchInst>(EntryTI) ||
!cast<BranchInst>(EntryTI)->isUnconditional() ||
EntryTI->getSuccessor(0) != L->getHeader())
ShouldExtractLoop = true;
else {
// Check to see if any exits from the loop are more than just return
// blocks.
SmallVector<BasicBlock*, 8> ExitBlocks;
L->getExitBlocks(ExitBlocks);
for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i)
if (!isa<ReturnInst>(ExitBlocks[i]->getTerminator())) {
ShouldExtractLoop = true;
break;
}
}
if (ShouldExtractLoop) {
if (NumLoops == 0) return Changed;
--NumLoops;
if (ExtractLoop(DT, L) != 0) {
Changed = true;
// After extraction, the loop is replaced by a function call, so
// we shouldn't try to run any more loop passes on it.
LPM.deleteLoopFromQueue(L);
}
++NumExtracted;
}
return Changed;
}
bool LoopDeletionLegacyPass::runOnLoop(Loop *L, LPPassManager &LPM) {
if (skipLoop(L))
return false;
DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
ScalarEvolution &SE = getAnalysis<ScalarEvolutionWrapperPass>().getSE();
LoopInfo &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
DEBUG(dbgs() << "Analyzing Loop for deletion: ");
DEBUG(L->dump());
LoopDeletionResult Result = deleteLoopIfDead(L, DT, SE, LI);
if (Result == LoopDeletionResult::Deleted)
LPM.markLoopAsDeleted(*L);
return Result != LoopDeletionResult::Unmodified;
}
bool LoopRegionOutliner::runOnLoop(Loop *L, LPPassManager &LPM) {
// Only visit top-level loops.
if (L->getParentLoop())
return false;
// If LoopSimplify form is not available, stay out of trouble.
if (!L->isLoopSimplifyForm())
return false;
#if LLVM_VERSION_MINOR == 5
DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
#else
DominatorTree &DT = getAnalysis<DominatorTree>();
#endif
bool Changed = false;
// Extract the loop if it was not previously extracted:
// If this loop is inside a function prefixed with __cere__
// it means we are looking at an already outlined loop
bool ShouldExtractLoop = true;
Function *function = L->getHeader()->getParent();
std::string name = function->getName();
std::size_t found = name.find("__cere__");
if (found != std::string::npos) {
ShouldExtractLoop = false;
}
if (ShouldExtractLoop) {
if (NumLoops == 0)
return Changed;
--NumLoops;
RegionExtractor Extractor(DT, *L, RegionName, ProfileApp, false);
if (Extractor.extractCodeRegion() != 0) {
Changed = true;
// After extraction, the loop is replaced by a function call, so
// we shouldn't try to run any more loop passes on it.
LPM.deleteLoopFromQueue(L);
}
++NumExtracted;
}
return Changed;
}
// If one loop has very large self trip count
// we don't want to unroll it.
// self trip count means trip count divide by the parent's trip count. for example
// for (int i = 0; i < 16; i++) {
// for (int j = 0; j < 4; j++) {
// for (int k = 0; k < 2; k++) {
// ...
// }
// ...
// }
// The inner loops j and k could be unrolled, but the loop i will not be unrolled.
// The return value true means the L could be unrolled, otherwise, it could not
// be unrolled.
bool handleParentLoops(Loop *L, LPPassManager &LPM) {
Loop *currL = L;
ScalarEvolution *SE = &getAnalysis<ScalarEvolution>();
BasicBlock *ExitBlock = currL->getLoopLatch();
if (!ExitBlock || !L->isLoopExiting(ExitBlock))
ExitBlock = currL->getExitingBlock();
unsigned currTripCount = 0;
bool shouldUnroll = true;
if (ExitBlock)
currTripCount = SE->getSmallConstantTripCount(L, ExitBlock);
while(currL) {
Loop *parentL = currL->getParentLoop();
unsigned parentTripCount = 0;
if (parentL) {
BasicBlock *parentExitBlock = parentL->getLoopLatch();
if (!parentExitBlock || !parentL->isLoopExiting(parentExitBlock))
parentExitBlock = parentL->getExitingBlock();
if (parentExitBlock)
parentTripCount = SE->getSmallConstantTripCount(parentL, parentExitBlock);
}
if ((parentTripCount != 0 && currTripCount / parentTripCount > 16) ||
(currTripCount > 32)) {
if (currL == L)
shouldUnroll = false;
setUnrollID(currL, false);
if (currL != L)
LPM.deleteLoopFromQueue(currL);
}
currL = parentL;
currTripCount = parentTripCount;
}
return shouldUnroll;
}
// Inserts an unwinding annotation (assume or assert, depending on the function
// given in the constructor) and removes the loop.
bool RmLoopPass::runOnLoop(Loop *L, LPPassManager &LPM){
BasicBlock *latch = L -> getLoopLatch();
BasicBlock *header = L -> getHeader();
SmallVector<BasicBlock *, 1> exitBBs;
L -> getExitBlocks(exitBBs);
BasicBlock *exitBB = NULL;
SmallVector<BasicBlock *, 1>::iterator it = exitBBs.begin();
for(; it != exitBBs.end() && !exitBB; ++it){
if(std::find(createdBB.begin(), createdBB.end(), *it) == createdBB.end())
exitBB = *it;
}
assert(exitBB && "exitBB is null");
// std::cout << "\n\n LOOP REMOVAL:\n";
// std::cout << "Latch: " << latch -> getName().str() << "\n";
// std::cout << "Header: " << header -> getName().str() << "\n";
// std::cout << "ExitBB: " << exitBB -> getName().str() << "\n";
//assert(exitBBs.size() == 1 && "RmLoopPass - more than one exit BB");
// At this point we have an header, a latch and an exit BasicBlock
// and they all are different
assert(latch && header
&& "Not able to obtain some loop basic block; try to run doInitialization before");
// Get loop last branch instruction
BranchInst *br = cast<BranchInst>(latch -> getTerminator());
// assert(br -> isConditional() && "loop terminator with unconditional branch");
// Get loop's last iteration condition
Value *cond = NULL; // Loop last iteration branch condition
if(br -> isConditional())
cond = br -> getCondition();
else{
std::cout << "\n************************************************************\n";
std::cout << "*BE CAREFUL!!!! There is a latch with unconditional branch!*\n";
std::cout << "************************************************************\n";
}
// In order to remove the back edge, we need to remove the loop from the LPPAssManager
LPM.deleteLoopFromQueue(L);
// Create a new BasicBlock with the unwinding annotation.
// Unreachable instruction is used as a terminator instruction in this BasicBlock
BasicBlock *newBB = BasicBlock::Create(header -> getContext()
, "unwinding_annotation"
, header -> getParent());
createdBB.push_back(newBB);
Type *t = Type::getInt32Ty(header -> getContext());
Constant *c = llvm::ConstantInt::get(t,uint32_t(0));
ArrayRef<Value *> *param = new ArrayRef<Value *>(c);
CallInst::Create(function, *param, "", newBB);
if(unreachable){
new UnreachableInst(header -> getContext(), newBB);
}else{
BranchInst::Create(exitBB,newBB);
for(BasicBlock::iterator it = exitBB->begin(); it != exitBB->end();++it){
PHINode *phi = dyn_cast<PHINode>(it);
if(!phi)
break;
//Value *latchValue = phi->getIncomingValueForBlock(latch);
phi->addIncoming(UndefValue::get(phi -> getType()),newBB);
}
}
BranchInst *newBr = NULL;
if(cond){
if(br -> getSuccessor(0) == header){
newBr = BranchInst::Create(newBB,br -> getSuccessor(1),cond);
}else{
newBr = BranchInst::Create(br -> getSuccessor(1),newBB,cond);
}
}else{
newBr = BranchInst::Create(newBB);
}
ReplaceInstWithInst(br,newBr);
// The latch BasicBlock must be removed from the PHI nodes in
// the header BasicBlock
for(BasicBlock::iterator it = header->begin(); it != header->end();++it){
PHINode *phi = dyn_cast<PHINode>(it);
if(!phi)
break;
int latchIndex = phi->getBasicBlockIndex(latch);
phi->removeIncomingValue(latchIndex);
}
//std::cout << "\n---- NewBB ------\n";
//newBB -> print(outs());
//std::cout << "\n---- ExitBB\n";
//exitBB -> print(outs());
return true;
}
/// runOnLoop - Remove dead loops, by which we mean loops that do not impact the
/// observable behavior of the program other than finite running time. Note
/// we do ensure that this never remove a loop that might be infinite, as doing
/// so could change the halting/non-halting nature of a program.
/// NOTE: This entire process relies pretty heavily on LoopSimplify and LCSSA
/// in order to make various safety checks work.
bool LoopDeletion::runOnLoop(Loop *L, LPPassManager &LPM) {
// We can only remove the loop if there is a preheader that we can
// branch from after removing it.
BasicBlock *preheader = L->getLoopPreheader();
if (!preheader)
return false;
// If LoopSimplify form is not available, stay out of trouble.
if (!L->hasDedicatedExits())
return false;
// We can't remove loops that contain subloops. If the subloops were dead,
// they would already have been removed in earlier executions of this pass.
if (L->begin() != L->end())
return false;
SmallVector<BasicBlock*, 4> exitingBlocks;
L->getExitingBlocks(exitingBlocks);
SmallVector<BasicBlock*, 4> exitBlocks;
L->getUniqueExitBlocks(exitBlocks);
// We require that the loop only have a single exit block. Otherwise, we'd
// be in the situation of needing to be able to solve statically which exit
// block will be branched to, or trying to preserve the branching logic in
// a loop invariant manner.
if (exitBlocks.size() != 1)
return false;
// Finally, we have to check that the loop really is dead.
bool Changed = false;
if (!isLoopDead(L, exitingBlocks, exitBlocks, Changed, preheader))
return Changed;
// Don't remove loops for which we can't solve the trip count.
// They could be infinite, in which case we'd be changing program behavior.
ScalarEvolution &SE = getAnalysis<ScalarEvolution>();
const SCEV *S = SE.getMaxBackedgeTakenCount(L);
if (isa<SCEVCouldNotCompute>(S))
return Changed;
// Now that we know the removal is safe, remove the loop by changing the
// branch from the preheader to go to the single exit block.
BasicBlock *exitBlock = exitBlocks[0];
// Because we're deleting a large chunk of code at once, the sequence in which
// we remove things is very important to avoid invalidation issues. Don't
// mess with this unless you have good reason and know what you're doing.
// Tell ScalarEvolution that the loop is deleted. Do this before
// deleting the loop so that ScalarEvolution can look at the loop
// to determine what it needs to clean up.
SE.forgetLoop(L);
// Connect the preheader directly to the exit block.
TerminatorInst *TI = preheader->getTerminator();
TI->replaceUsesOfWith(L->getHeader(), exitBlock);
// Rewrite phis in the exit block to get their inputs from
// the preheader instead of the exiting block.
BasicBlock *exitingBlock = exitingBlocks[0];
BasicBlock::iterator BI = exitBlock->begin();
while (PHINode *P = dyn_cast<PHINode>(BI)) {
int j = P->getBasicBlockIndex(exitingBlock);
assert(j >= 0 && "Can't find exiting block in exit block's phi node!");
P->setIncomingBlock(j, preheader);
for (unsigned i = 1; i < exitingBlocks.size(); ++i)
P->removeIncomingValue(exitingBlocks[i]);
++BI;
}
// Update the dominator tree and remove the instructions and blocks that will
// be deleted from the reference counting scheme.
DominatorTree &DT = getAnalysis<DominatorTree>();
SmallVector<DomTreeNode*, 8> ChildNodes;
for (Loop::block_iterator LI = L->block_begin(), LE = L->block_end();
LI != LE; ++LI) {
// Move all of the block's children to be children of the preheader, which
// allows us to remove the domtree entry for the block.
ChildNodes.insert(ChildNodes.begin(), DT[*LI]->begin(), DT[*LI]->end());
for (SmallVectorImpl<DomTreeNode *>::iterator DI = ChildNodes.begin(),
DE = ChildNodes.end(); DI != DE; ++DI) {
DT.changeImmediateDominator(*DI, DT[preheader]);
}
ChildNodes.clear();
DT.eraseNode(*LI);
// Remove the block from the reference counting scheme, so that we can
// delete it freely later.
(*LI)->dropAllReferences();
}
// Erase the instructions and the blocks without having to worry
// about ordering because we already dropped the references.
// NOTE: This iteration is safe because erasing the block does not remove its
// entry from the loop's block list. We do that in the next section.
for (Loop::block_iterator LI = L->block_begin(), LE = L->block_end();
LI != LE; ++LI)
(*LI)->eraseFromParent();
// Finally, the blocks from loopinfo. This has to happen late because
// otherwise our loop iterators won't work.
LoopInfo &loopInfo = getAnalysis<LoopInfo>();
SmallPtrSet<BasicBlock*, 8> blocks;
blocks.insert(L->block_begin(), L->block_end());
for (SmallPtrSet<BasicBlock*,8>::iterator I = blocks.begin(),
E = blocks.end(); I != E; ++I)
loopInfo.removeBlock(*I);
// The last step is to inform the loop pass manager that we've
// eliminated this loop.
LPM.deleteLoopFromQueue(L);
Changed = true;
++NumDeleted;
return Changed;
}
void DSWP::cleanup(Loop *L, LPPassManager &LPM) {
// Move some instructions that may not have been inserted in the right
// place, delete the old loop, and clean up our aux data structures for this
// loop.
/*
* move the produce instructions, which have been inserted after the branch,
* in front of it
*/
for (int i = 0; i < MAX_THREAD; i++) {
for (Function::iterator bi = allFunc[i]->begin(), be = allFunc[i]->end(); bi != be; ++bi) {
BasicBlock *bb = bi;
TerminatorInst *term = NULL;
for (BasicBlock::iterator ii = bb->begin(), ie = bb->end(); ii != ie; ++ii) {
Instruction *inst = ii;
if (isa<TerminatorInst>(inst)) {
term = dyn_cast<TerminatorInst>(inst);
break;
}
}
if (term == NULL) {
error("term cannot be null");
}
while (true) {
Instruction *last = &bb->getInstList().back();
if (isa<TerminatorInst>(last))
break;
last->moveBefore(term);
}
}
}
/*
* move the phi nodes to the top of the block
*/
for (int i = 0; i < MAX_THREAD; i++) {
for (Function::iterator bi = allFunc[i]->begin(), be = allFunc[i]->end(); bi != be; ++bi) {
BasicBlock *bb = bi;
Instruction *first_nonphi = bb->getFirstNonPHI();
BasicBlock::iterator ii = bb->begin(), ie = bb->end();
// advance the iterator up to one past first_nonphi
while (&(*ii) != first_nonphi) {
++ii;
}
++ii;
// move any phi nodes after the first nonphi to before it
for (BasicBlock::iterator i_next; ii != ie; ii = i_next) {
i_next = ii;
++i_next;
Instruction *inst = ii;
if (isa<PHINode>(inst)) {
inst->moveBefore(first_nonphi);
}
}
}
}
cout << "begin to delete loop" << endl;
for (Loop::block_iterator bi = L->block_begin(), be = L->block_end(); bi != be; ++bi) {
BasicBlock *BB = *bi;
for (BasicBlock::iterator ii = BB->begin(), i_next, ie = BB->end(); ii != ie; ii = i_next) {
i_next = ii;
++i_next;
Instruction &inst = *ii;
inst.replaceAllUsesWith(UndefValue::get(inst.getType()));
inst.eraseFromParent();
}
}
// Delete the basic blocks only afterwards
// so that backwards branch instructions don't break
for (Loop::block_iterator bi = L->block_begin(), be = L->block_end(); bi != be; ++bi) {
BasicBlock *BB = *bi;
BB->eraseFromParent();
}
LPM.deleteLoopFromQueue(L);
}
bool LoopExtractor::runOnLoop(Loop *L, LPPassManager &LPM) {
if (skipOptnoneFunction(L))
return false;
// Only visit top-level loops.
if (L->getParentLoop())
return false;
// If LoopSimplify form is not available, stay out of trouble.
if (!L->isLoopSimplifyForm())
return false;
DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
bool Changed = false;
// If there is more than one top-level loop in this function, extract all of
// the loops. Otherwise there is exactly one top-level loop; in this case if
// this function is more than a minimal wrapper around the loop, extract
// the loop.
bool ShouldExtractLoop = false;
// Extract the loop if the entry block doesn't branch to the loop header.
TerminatorInst *EntryTI =
L->getHeader()->getParent()->getEntryBlock().getTerminator();
if (!isa<BranchInst>(EntryTI) ||
!cast<BranchInst>(EntryTI)->isUnconditional() ||
EntryTI->getSuccessor(0) != L->getHeader()) {
ShouldExtractLoop = true;
} else {
// Check to see if any exits from the loop are more than just return
// blocks.
SmallVector<BasicBlock*, 8> ExitBlocks;
L->getExitBlocks(ExitBlocks);
for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i)
if (!isa<ReturnInst>(ExitBlocks[i]->getTerminator())) {
ShouldExtractLoop = true;
break;
}
}
if (ShouldExtractLoop) {
// We must omit landing pads. Landing pads must accompany the invoke
// instruction. But this would result in a loop in the extracted
// function. An infinite cycle occurs when it tries to extract that loop as
// well.
SmallVector<BasicBlock*, 8> ExitBlocks;
L->getExitBlocks(ExitBlocks);
for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i)
if (ExitBlocks[i]->isLandingPad()) {
ShouldExtractLoop = false;
break;
}
}
if (ShouldExtractLoop) {
if (NumLoops == 0) return Changed;
--NumLoops;
CodeExtractor Extractor(DT, *L);
if (Extractor.extractCodeRegion() != nullptr) {
Changed = true;
// After extraction, the loop is replaced by a function call, so
// we shouldn't try to run any more loop passes on it.
LPM.deleteLoopFromQueue(L);
}
++NumExtracted;
}
return Changed;
}
