/// simplifyUsersOfIV - Simplify instructions that use this induction variable
/// by using ScalarEvolution to analyze the IV's recurrence.
bool simplifyUsersOfIV(PHINode *CurrIV, ScalarEvolution *SE, LPPassManager *LPM,
SmallVectorImpl<WeakVH> &Dead, IVVisitor *V)
{
LoopInfo *LI = &LPM->getAnalysis<LoopInfo>();
SimplifyIndvar SIV(LI->getLoopFor(CurrIV->getParent()), SE, LPM, Dead);
SIV.simplifyUsers(CurrIV, V);
return SIV.hasChanged();
}
LoopInfo LoopAnalysis::run(Function &F, AnalysisManager<Function> *AM) {
// FIXME: Currently we create a LoopInfo from scratch for every function.
// This may prove to be too wasteful due to deallocating and re-allocating
// memory each time for the underlying map and vector datastructures. At some
// point it may prove worthwhile to use a freelist and recycle LoopInfo
// objects. I don't want to add that kind of complexity until the scope of
// the problem is better understood.
LoopInfo LI;
LI.Analyze(AM->getResult<DominatorTreeAnalysis>(F));
return std::move(LI);
}
bool JITOptimizations::runOnFunction(Function& F) {
this->LI = &getAnalysis<LoopInfo>();
bool changed = false;
FPM = new FunctionPassManager(F.getParent());
// if the user input something we use those passes
std::vector<const PassInfo *> &customPasses = JPD->getPassList();
if (customPasses.size() > 0) {
for (int i=0; i<customPasses.size();i++) {
const PassInfo *pass = customPasses[i];
FPM->add(pass->createPass());
}
} else {
// Optimization ordering:
// - ADCE
// - inline
// - DSE <---- THIS causes seg faults when running on sqlite3
// test in llvm test-suite
// - Instruction Combining
// ---- IF LOOPS ----
// - LICM
// - Loop Simplify
// - Loop Strength Reduction
// ------------------
// - SCCP
// - Simplify CFG
// - SROA
FPM->add(createAggressiveDCEPass());
if (JPD->getThresholdT2() != 0)
FPM->add(createDynamicInlinerPass(JPD));
FPM->add(createInstructionCombiningPass());
// --- Loop optimizations --- //
if (LI->begin() != LI->end()) {
FPM->add(createLICMPass());
FPM->add(createLoopSimplifyPass());
FPM->add(createLoopStrengthReducePass());
}
// -------------------------- //
FPM->add(createSCCPPass());
FPM->add(createCFGSimplificationPass());
FPM->add(createSROAPass(false));
}
changed = changed | FPM->doInitialization();
changed = changed | FPM->run(F);
changed = changed | FPM->doFinalization();
delete FPM;
return changed;
}
bool WorklessInstrument::runOnModule(Module& M)
{
Function * pFunction = SearchFunctionByName(M, strFileName, strFuncName, uSrcLine);
if(pFunction == NULL)
{
errs() << "Cannot find the input function\n";
return false;
}
LoopInfo *pLoopInfo = &(getAnalysis<LoopInfo>(*pFunction));
Loop * pLoop = SearchLoopByLineNo(pFunction, pLoopInfo, uSrcLine);
if(pLoop == NULL)
{
errs() << "Cannot find the input loop\n";
return false;
}
SetupTypes(&M);
SetupConstants(&M);
SetupHooks(&M);
SetupGlobals(&M);
BasicBlock * pHeader = pLoop->getHeader();
LoopSimplify(pLoop, this);
pLoop = pLoopInfo->getLoopFor(pHeader);
if(uType == 0)
{
}
else if(uType == 1)
{
InstrumentWorkless0Star1(&M, pLoop);
}
else if(uType == 2)
{
set<string> setWorkingBlocks;
ParseWorkingBlocks(setWorkingBlocks);
InstrumentWorkless0Or1Star(&M, pLoop, setWorkingBlocks);
}
else
{
errs() << "Wrong Workless Instrument Type\n";
}
return true;
}
bool polly::isHoistableLoad(LoadInst *LInst, Region &R, LoopInfo &LI,
ScalarEvolution &SE, const DominatorTree &DT) {
Loop *L = LI.getLoopFor(LInst->getParent());
auto *Ptr = LInst->getPointerOperand();
const SCEV *PtrSCEV = SE.getSCEVAtScope(Ptr, L);
while (L && R.contains(L)) {
if (!SE.isLoopInvariant(PtrSCEV, L))
return false;
L = L->getParentLoop();
}
for (auto *User : Ptr->users()) {
auto *UserI = dyn_cast<Instruction>(User);
if (!UserI || !R.contains(UserI))
continue;
if (!UserI->mayWriteToMemory())
continue;
auto &BB = *UserI->getParent();
bool DominatesAllPredecessors = true;
for (auto Pred : predecessors(R.getExit()))
if (R.contains(Pred) && !DT.dominates(&BB, Pred))
DominatesAllPredecessors = false;
if (!DominatesAllPredecessors)
continue;
return false;
}
return true;
}
static bool simplifyLoopCFG(Loop &L, DominatorTree &DT, LoopInfo &LI,
ScalarEvolution &SE) {
bool Changed = false;
// Copy blocks into a temporary array to avoid iterator invalidation issues
// as we remove them.
SmallVector<WeakTrackingVH, 16> Blocks(L.blocks());
for (auto &Block : Blocks) {
// Attempt to merge blocks in the trivial case. Don't modify blocks which
// belong to other loops.
BasicBlock *Succ = cast_or_null<BasicBlock>(Block);
if (!Succ)
continue;
BasicBlock *Pred = Succ->getSinglePredecessor();
if (!Pred || !Pred->getSingleSuccessor() || LI.getLoopFor(Pred) != &L)
continue;
// Merge Succ into Pred and delete it.
MergeBlockIntoPredecessor(Succ, &DT, &LI);
SE.forgetLoop(&L);
Changed = true;
}
return Changed;
}
static bool mergeBlocksIntoPredecessors(Loop &L, DominatorTree &DT,
LoopInfo &LI, MemorySSAUpdater *MSSAU) {
bool Changed = false;
DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Eager);
// Copy blocks into a temporary array to avoid iterator invalidation issues
// as we remove them.
SmallVector<WeakTrackingVH, 16> Blocks(L.blocks());
for (auto &Block : Blocks) {
// Attempt to merge blocks in the trivial case. Don't modify blocks which
// belong to other loops.
BasicBlock *Succ = cast_or_null<BasicBlock>(Block);
if (!Succ)
continue;
BasicBlock *Pred = Succ->getSinglePredecessor();
if (!Pred || !Pred->getSingleSuccessor() || LI.getLoopFor(Pred) != &L)
continue;
// Merge Succ into Pred and delete it.
MergeBlockIntoPredecessor(Succ, &DTU, &LI, MSSAU);
Changed = true;
}
return Changed;
}
bool Loop::isRecursivelyLCSSAForm(DominatorTree &DT, const LoopInfo &LI) const {
// For each block we check that it doesn't have any uses outside of it's
// innermost loop. This process will transitivelly guarntee that current loop
// and all of the nested loops are in the LCSSA form.
return all_of(this->blocks(), [&](const BasicBlock *BB) {
return isBlockInLCSSAForm(*LI.getLoopFor(BB), *BB, DT);
});
}
// Calculate Edge Weights using "Loop Branch Heuristics". Predict backedges
// as taken, exiting edges as not-taken.
bool BranchProbabilityInfo::calcLoopBranchHeuristics(const BasicBlock *BB,
const LoopInfo &LI) {
Loop *L = LI.getLoopFor(BB);
if (!L)
return false;
SmallVector<unsigned, 8> BackEdges;
SmallVector<unsigned, 8> ExitingEdges;
SmallVector<unsigned, 8> InEdges; // Edges from header to the loop.
for (succ_const_iterator I = succ_begin(BB), E = succ_end(BB); I != E; ++I) {
if (!L->contains(*I))
ExitingEdges.push_back(I.getSuccessorIndex());
else if (L->getHeader() == *I)
BackEdges.push_back(I.getSuccessorIndex());
else
InEdges.push_back(I.getSuccessorIndex());
}
if (BackEdges.empty() && ExitingEdges.empty())
return false;
// Collect the sum of probabilities of back-edges/in-edges/exiting-edges, and
// normalize them so that they sum up to one.
BranchProbability Probs[] = {BranchProbability::getZero(),
BranchProbability::getZero(),
BranchProbability::getZero()};
unsigned Denom = (BackEdges.empty() ? 0 : LBH_TAKEN_WEIGHT) +
(InEdges.empty() ? 0 : LBH_TAKEN_WEIGHT) +
(ExitingEdges.empty() ? 0 : LBH_NONTAKEN_WEIGHT);
if (!BackEdges.empty())
Probs[0] = BranchProbability(LBH_TAKEN_WEIGHT, Denom);
if (!InEdges.empty())
Probs[1] = BranchProbability(LBH_TAKEN_WEIGHT, Denom);
if (!ExitingEdges.empty())
Probs[2] = BranchProbability(LBH_NONTAKEN_WEIGHT, Denom);
if (uint32_t numBackEdges = BackEdges.size()) {
auto Prob = Probs[0] / numBackEdges;
for (unsigned SuccIdx : BackEdges)
setEdgeProbability(BB, SuccIdx, Prob);
}
if (uint32_t numInEdges = InEdges.size()) {
auto Prob = Probs[1] / numInEdges;
for (unsigned SuccIdx : InEdges)
setEdgeProbability(BB, SuccIdx, Prob);
}
if (uint32_t numExitingEdges = ExitingEdges.size()) {
auto Prob = Probs[2] / numExitingEdges;
for (unsigned SuccIdx : ExitingEdges)
setEdgeProbability(BB, SuccIdx, Prob);
}
return true;
}
// Calculate Edge Weights using "Loop Branch Heuristics". Predict backedges
// as taken, exiting edges as not-taken.
bool BranchProbabilityInfo::calcLoopBranchHeuristics(BasicBlock *BB,
const LoopInfo &LI) {
Loop *L = LI.getLoopFor(BB);
if (!L)
return false;
SmallVector<unsigned, 8> BackEdges;
SmallVector<unsigned, 8> ExitingEdges;
SmallVector<unsigned, 8> InEdges; // Edges from header to the loop.
for (succ_iterator I = succ_begin(BB), E = succ_end(BB); I != E; ++I) {
if (!L->contains(*I))
ExitingEdges.push_back(I.getSuccessorIndex());
else if (L->getHeader() == *I)
BackEdges.push_back(I.getSuccessorIndex());
else
InEdges.push_back(I.getSuccessorIndex());
}
if (BackEdges.empty() && ExitingEdges.empty())
return false;
if (uint32_t numBackEdges = BackEdges.size()) {
uint32_t backWeight = LBH_TAKEN_WEIGHT / numBackEdges;
if (backWeight < NORMAL_WEIGHT)
backWeight = NORMAL_WEIGHT;
for (SmallVectorImpl<unsigned>::iterator EI = BackEdges.begin(),
EE = BackEdges.end(); EI != EE; ++EI) {
setEdgeWeight(BB, *EI, backWeight);
}
}
if (uint32_t numInEdges = InEdges.size()) {
uint32_t inWeight = LBH_TAKEN_WEIGHT / numInEdges;
if (inWeight < NORMAL_WEIGHT)
inWeight = NORMAL_WEIGHT;
for (SmallVectorImpl<unsigned>::iterator EI = InEdges.begin(),
EE = InEdges.end(); EI != EE; ++EI) {
setEdgeWeight(BB, *EI, inWeight);
}
}
if (uint32_t numExitingEdges = ExitingEdges.size()) {
uint32_t exitWeight = LBH_NONTAKEN_WEIGHT / numExitingEdges;
if (exitWeight < MIN_WEIGHT)
exitWeight = MIN_WEIGHT;
for (SmallVectorImpl<unsigned>::iterator EI = ExitingEdges.begin(),
EE = ExitingEdges.end(); EI != EE; ++EI) {
setEdgeWeight(BB, *EI, exitWeight);
}
}
return true;
}
void StatsComputer::handleBB(FunInfo &funInfo, const LoopInfo &LI,
const BasicBlock &BB) {
for (BasicBlock::const_iterator I = BB.begin(), E = BB.end(); I != E; ++I) {
funInfo.incIns();
if (LI.getLoopFor(&BB))
funInfo.setHasLoop();
handleIns(funInfo, *I);
}
}
/// IsAcceptableTarget - Return true if it is possible to sink the instruction
/// in the specified basic block.
static bool IsAcceptableTarget(Instruction *Inst, BasicBlock *SuccToSinkTo,
DominatorTree &DT, LoopInfo &LI) {
assert(Inst && "Instruction to be sunk is null");
assert(SuccToSinkTo && "Candidate sink target is null");
// It is not possible to sink an instruction into its own block. This can
// happen with loops.
if (Inst->getParent() == SuccToSinkTo)
return false;
// It's never legal to sink an instruction into a block which terminates in an
// EH-pad.
if (SuccToSinkTo->getTerminator()->isExceptionalTerminator())
return false;
// If the block has multiple predecessors, this would introduce computation
// on different code paths. We could split the critical edge, but for now we
// just punt.
// FIXME: Split critical edges if not backedges.
if (SuccToSinkTo->getUniquePredecessor() != Inst->getParent()) {
// We cannot sink a load across a critical edge - there may be stores in
// other code paths.
if (Inst->mayReadFromMemory())
return false;
// We don't want to sink across a critical edge if we don't dominate the
// successor. We could be introducing calculations to new code paths.
if (!DT.dominates(Inst->getParent(), SuccToSinkTo))
return false;
// Don't sink instructions into a loop.
Loop *succ = LI.getLoopFor(SuccToSinkTo);
Loop *cur = LI.getLoopFor(Inst->getParent());
if (succ != nullptr && succ != cur)
return false;
}
// Finally, check that all the uses of the instruction are actually
// dominated by the candidate
return AllUsesDominatedByBlock(Inst, SuccToSinkTo, DT);
}
OptimizationRemarkEmitter::OptimizationRemarkEmitter(const Function *F)
: F(F), BFI(nullptr) {
if (!F->getContext().getDiagnosticHotnessRequested())
return;
// First create a dominator tree.
DominatorTree DT;
DT.recalculate(*const_cast<Function *>(F));
// Generate LoopInfo from it.
LoopInfo LI;
LI.analyze(DT);
// Then compute BranchProbabilityInfo.
BranchProbabilityInfo BPI;
BPI.calculate(*F, LI);
// Finally compute BFI.
OwnedBFI = llvm::make_unique<BlockFrequencyInfo>(*F, BPI, LI);
BFI = OwnedBFI.get();
}
std::pair<polly::BBPair, BranchInst *>
polly::executeScopConditionally(Scop &S, Value *RTC, DominatorTree &DT,
RegionInfo &RI, LoopInfo &LI) {
Region &R = S.getRegion();
PollyIRBuilder Builder(S.getEntry());
// Before:
//
// \ / //
// EnteringBB //
// _____|_____ //
// / EntryBB \ //
// | (region) | //
// \_ExitingBB_/ //
// | //
// ExitBB //
// / \ //
// Create a fork block.
BasicBlock *EnteringBB = S.getEnteringBlock();
BasicBlock *EntryBB = S.getEntry();
assert(EnteringBB && "Must be a simple region");
BasicBlock *SplitBlock =
splitEdge(EnteringBB, EntryBB, ".split_new_and_old", &DT, &LI, &RI);
SplitBlock->setName("polly.split_new_and_old");
// If EntryBB is the exit block of the region that includes Prev, exclude
// SplitBlock from that region by making it itself the exit block. This is
// trivially possible because there is just one edge to EnteringBB.
// This is necessary because we will add an outgoing edge from SplitBlock,
// which would violate the single exit block requirement of PrevRegion.
Region *PrevRegion = RI.getRegionFor(EnteringBB);
while (PrevRegion->getExit() == EntryBB) {
PrevRegion->replaceExit(SplitBlock);
PrevRegion = PrevRegion->getParent();
}
RI.setRegionFor(SplitBlock, PrevRegion);
// Create a join block
BasicBlock *ExitingBB = S.getExitingBlock();
BasicBlock *ExitBB = S.getExit();
assert(ExitingBB && "Must be a simple region");
BasicBlock *MergeBlock =
splitEdge(ExitingBB, ExitBB, ".merge_new_and_old", &DT, &LI, &RI);
MergeBlock->setName("polly.merge_new_and_old");
// Exclude the join block from the region.
R.replaceExitRecursive(MergeBlock);
RI.setRegionFor(MergeBlock, R.getParent());
// \ / //
// EnteringBB //
// | //
// SplitBlock //
// _____|_____ //
// / EntryBB \ //
// | (region) | //
// \_ExitingBB_/ //
// | //
// MergeBlock //
// | //
// ExitBB //
// / \ //
// Create the start and exiting block.
Function *F = SplitBlock->getParent();
BasicBlock *StartBlock =
BasicBlock::Create(F->getContext(), "polly.start", F);
BasicBlock *ExitingBlock =
BasicBlock::Create(F->getContext(), "polly.exiting", F);
SplitBlock->getTerminator()->eraseFromParent();
Builder.SetInsertPoint(SplitBlock);
BranchInst *CondBr = Builder.CreateCondBr(RTC, StartBlock, S.getEntry());
if (Loop *L = LI.getLoopFor(SplitBlock)) {
L->addBasicBlockToLoop(StartBlock, LI);
L->addBasicBlockToLoop(ExitingBlock, LI);
}
DT.addNewBlock(StartBlock, SplitBlock);
DT.addNewBlock(ExitingBlock, StartBlock);
RI.setRegionFor(StartBlock, RI.getRegionFor(SplitBlock));
RI.setRegionFor(ExitingBlock, RI.getRegionFor(SplitBlock));
// \ / //
// EnteringBB //
// | //
// SplitBlock---------\ //
// _____|_____ | //
// / EntryBB \ StartBlock //
// | (region) | | //
// \_ExitingBB_/ ExitingBlock //
// | //
// MergeBlock //
// | //
// ExitBB //
// / \ //
// Connect start block to exiting block.
Builder.SetInsertPoint(StartBlock);
Builder.CreateBr(ExitingBlock);
DT.changeImmediateDominator(ExitingBlock, StartBlock);
// Connect exiting block to join block.
Builder.SetInsertPoint(ExitingBlock);
Builder.CreateBr(MergeBlock);
DT.changeImmediateDominator(MergeBlock, SplitBlock);
// \ / //
// EnteringBB //
// | //
// SplitBlock---------\ //
// _____|_____ | //
// / EntryBB \ StartBlock //
// | (region) | | //
// \_ExitingBB_/ ExitingBlock //
// | | //
// MergeBlock---------/ //
// | //
// ExitBB //
// / \ //
//
// Split the edge between SplitBlock and EntryBB, to avoid a critical edge.
splitEdge(SplitBlock, EntryBB, ".pre_entry_bb", &DT, &LI, &RI);
// \ / //
// EnteringBB //
// | //
// SplitBlock---------\ //
// | | //
// PreEntryBB | //
// _____|_____ | //
// / EntryBB \ StartBlock //
// | (region) | | //
// \_ExitingBB_/ ExitingBlock //
// | | //
// MergeBlock---------/ //
// | //
// ExitBB //
// / \ //
return std::make_pair(std::make_pair(StartBlock, ExitingBlock), CondBr);
}
void JSEdgeRemovalPass::padExitBlocks(LoopInfo& li) {
for(LoopInfo::iterator b = li.begin(), e = li.end(); b != e; ++b) {
Loop* l = *b;
padExitBlocks(li, l);
}
}
/// SplitCriticalEdge - If this edge is a critical edge, insert a new node to
/// split the critical edge. This will update DominatorTree and
/// DominatorFrontier information if it is available, thus calling this pass
/// will not invalidate either of them. This returns the new block if the edge
/// was split, null otherwise.
///
/// If MergeIdenticalEdges is true (not the default), *all* edges from TI to the
/// specified successor will be merged into the same critical edge block.
/// This is most commonly interesting with switch instructions, which may
/// have many edges to any one destination. This ensures that all edges to that
/// dest go to one block instead of each going to a different block, but isn't
/// the standard definition of a "critical edge".
///
/// It is invalid to call this function on a critical edge that starts at an
/// IndirectBrInst. Splitting these edges will almost always create an invalid
/// program because the address of the new block won't be the one that is jumped
/// to.
///
BasicBlock *llvm::SplitCriticalEdge(TerminatorInst *TI, unsigned SuccNum,
Pass *P, bool MergeIdenticalEdges) {
if (!isCriticalEdge(TI, SuccNum, MergeIdenticalEdges)) return 0;
assert(!isa<IndirectBrInst>(TI) &&
"Cannot split critical edge from IndirectBrInst");
BasicBlock *TIBB = TI->getParent();
BasicBlock *DestBB = TI->getSuccessor(SuccNum);
// Create a new basic block, linking it into the CFG.
BasicBlock *NewBB = BasicBlock::Create(TI->getContext(),
TIBB->getName() + "." + DestBB->getName() + "_crit_edge");
// Create our unconditional branch.
BranchInst::Create(DestBB, NewBB);
// Branch to the new block, breaking the edge.
TI->setSuccessor(SuccNum, NewBB);
// Insert the block into the function... right after the block TI lives in.
Function &F = *TIBB->getParent();
Function::iterator FBBI = TIBB;
F.getBasicBlockList().insert(++FBBI, NewBB);
// If there are any PHI nodes in DestBB, we need to update them so that they
// merge incoming values from NewBB instead of from TIBB.
if (PHINode *APHI = dyn_cast<PHINode>(DestBB->begin())) {
// This conceptually does:
// foreach (PHINode *PN in DestBB)
// PN->setIncomingBlock(PN->getIncomingBlock(TIBB), NewBB);
// but is optimized for two cases.
if (APHI->getNumIncomingValues() <= 8) { // Small # preds case.
unsigned BBIdx = 0;
for (BasicBlock::iterator I = DestBB->begin(); isa<PHINode>(I); ++I) {
// We no longer enter through TIBB, now we come in through NewBB.
// Revector exactly one entry in the PHI node that used to come from
// TIBB to come from NewBB.
PHINode *PN = cast<PHINode>(I);
// Reuse the previous value of BBIdx if it lines up. In cases where we
// have multiple phi nodes with *lots* of predecessors, this is a speed
// win because we don't have to scan the PHI looking for TIBB. This
// happens because the BB list of PHI nodes are usually in the same
// order.
if (PN->getIncomingBlock(BBIdx) != TIBB)
BBIdx = PN->getBasicBlockIndex(TIBB);
PN->setIncomingBlock(BBIdx, NewBB);
}
} else {
// However, the foreach loop is slow for blocks with lots of predecessors
// because PHINode::getIncomingBlock is O(n) in # preds. Instead, walk
// the user list of TIBB to find the PHI nodes.
SmallPtrSet<PHINode*, 16> UpdatedPHIs;
for (Value::use_iterator UI = TIBB->use_begin(), E = TIBB->use_end();
UI != E; ) {
Value::use_iterator Use = UI++;
if (PHINode *PN = dyn_cast<PHINode>(Use)) {
// Remove one entry from each PHI.
if (PN->getParent() == DestBB && UpdatedPHIs.insert(PN))
PN->setOperand(Use.getOperandNo(), NewBB);
}
}
}
}
// If there are any other edges from TIBB to DestBB, update those to go
// through the split block, making those edges non-critical as well (and
// reducing the number of phi entries in the DestBB if relevant).
if (MergeIdenticalEdges) {
for (unsigned i = SuccNum+1, e = TI->getNumSuccessors(); i != e; ++i) {
if (TI->getSuccessor(i) != DestBB) continue;
// Remove an entry for TIBB from DestBB phi nodes.
DestBB->removePredecessor(TIBB);
// We found another edge to DestBB, go to NewBB instead.
TI->setSuccessor(i, NewBB);
}
}
// If we don't have a pass object, we can't update anything...
if (P == 0) return NewBB;
DominatorTree *DT = P->getAnalysisIfAvailable<DominatorTree>();
DominanceFrontier *DF = P->getAnalysisIfAvailable<DominanceFrontier>();
LoopInfo *LI = P->getAnalysisIfAvailable<LoopInfo>();
ProfileInfo *PI = P->getAnalysisIfAvailable<ProfileInfo>();
// If we have nothing to update, just return.
if (DT == 0 && DF == 0 && LI == 0 && PI == 0)
return NewBB;
// Now update analysis information. Since the only predecessor of NewBB is
// the TIBB, TIBB clearly dominates NewBB. TIBB usually doesn't dominate
// anything, as there are other successors of DestBB. However, if all other
// predecessors of DestBB are already dominated by DestBB (e.g. DestBB is a
// loop header) then NewBB dominates DestBB.
SmallVector<BasicBlock*, 8> OtherPreds;
// If there is a PHI in the block, loop over predecessors with it, which is
// faster than iterating pred_begin/end.
if (PHINode *PN = dyn_cast<PHINode>(DestBB->begin())) {
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
if (PN->getIncomingBlock(i) != NewBB)
OtherPreds.push_back(PN->getIncomingBlock(i));
} else {
for (pred_iterator I = pred_begin(DestBB), E = pred_end(DestBB);
I != E; ++I)
if (*I != NewBB)
OtherPreds.push_back(*I);
}
bool NewBBDominatesDestBB = true;
// Should we update DominatorTree information?
if (DT) {
DomTreeNode *TINode = DT->getNode(TIBB);
// The new block is not the immediate dominator for any other nodes, but
// TINode is the immediate dominator for the new node.
//
if (TINode) { // Don't break unreachable code!
DomTreeNode *NewBBNode = DT->addNewBlock(NewBB, TIBB);
DomTreeNode *DestBBNode = 0;
// If NewBBDominatesDestBB hasn't been computed yet, do so with DT.
if (!OtherPreds.empty()) {
DestBBNode = DT->getNode(DestBB);
while (!OtherPreds.empty() && NewBBDominatesDestBB) {
if (DomTreeNode *OPNode = DT->getNode(OtherPreds.back()))
NewBBDominatesDestBB = DT->dominates(DestBBNode, OPNode);
OtherPreds.pop_back();
}
OtherPreds.clear();
}
// If NewBBDominatesDestBB, then NewBB dominates DestBB, otherwise it
// doesn't dominate anything.
if (NewBBDominatesDestBB) {
if (!DestBBNode) DestBBNode = DT->getNode(DestBB);
DT->changeImmediateDominator(DestBBNode, NewBBNode);
}
}
}
// Should we update DominanceFrontier information?
if (DF) {
// If NewBBDominatesDestBB hasn't been computed yet, do so with DF.
if (!OtherPreds.empty()) {
// FIXME: IMPLEMENT THIS!
llvm_unreachable("Requiring domfrontiers but not idom/domtree/domset."
" not implemented yet!");
}
// Since the new block is dominated by its only predecessor TIBB,
// it cannot be in any block's dominance frontier. If NewBB dominates
// DestBB, its dominance frontier is the same as DestBB's, otherwise it is
// just {DestBB}.
DominanceFrontier::DomSetType NewDFSet;
if (NewBBDominatesDestBB) {
DominanceFrontier::iterator I = DF->find(DestBB);
if (I != DF->end()) {
DF->addBasicBlock(NewBB, I->second);
if (I->second.count(DestBB)) {
// However NewBB's frontier does not include DestBB.
DominanceFrontier::iterator NF = DF->find(NewBB);
DF->removeFromFrontier(NF, DestBB);
}
}
else
DF->addBasicBlock(NewBB, DominanceFrontier::DomSetType());
} else {
DominanceFrontier::DomSetType NewDFSet;
NewDFSet.insert(DestBB);
DF->addBasicBlock(NewBB, NewDFSet);
}
}
// Update LoopInfo if it is around.
if (LI) {
if (Loop *TIL = LI->getLoopFor(TIBB)) {
// If one or the other blocks were not in a loop, the new block is not
// either, and thus LI doesn't need to be updated.
if (Loop *DestLoop = LI->getLoopFor(DestBB)) {
if (TIL == DestLoop) {
// Both in the same loop, the NewBB joins loop.
DestLoop->addBasicBlockToLoop(NewBB, LI->getBase());
} else if (TIL->contains(DestLoop)) {
// Edge from an outer loop to an inner loop. Add to the outer loop.
TIL->addBasicBlockToLoop(NewBB, LI->getBase());
} else if (DestLoop->contains(TIL)) {
// Edge from an inner loop to an outer loop. Add to the outer loop.
DestLoop->addBasicBlockToLoop(NewBB, LI->getBase());
} else {
// Edge from two loops with no containment relation. Because these
// are natural loops, we know that the destination block must be the
// header of its loop (adding a branch into a loop elsewhere would
// create an irreducible loop).
assert(DestLoop->getHeader() == DestBB &&
"Should not create irreducible loops!");
if (Loop *P = DestLoop->getParentLoop())
P->addBasicBlockToLoop(NewBB, LI->getBase());
}
}
// If TIBB is in a loop and DestBB is outside of that loop, split the
// other exit blocks of the loop that also have predecessors outside
// the loop, to maintain a LoopSimplify guarantee.
if (!TIL->contains(DestBB) &&
P->mustPreserveAnalysisID(LoopSimplifyID)) {
assert(!TIL->contains(NewBB) &&
"Split point for loop exit is contained in loop!");
// Update LCSSA form in the newly created exit block.
if (P->mustPreserveAnalysisID(LCSSAID)) {
SmallVector<BasicBlock *, 1> OrigPred;
OrigPred.push_back(TIBB);
CreatePHIsForSplitLoopExit(OrigPred, NewBB, DestBB);
}
// For each unique exit block...
SmallVector<BasicBlock *, 4> ExitBlocks;
TIL->getExitBlocks(ExitBlocks);
for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i) {
// Collect all the preds that are inside the loop, and note
// whether there are any preds outside the loop.
SmallVector<BasicBlock *, 4> Preds;
bool HasPredOutsideOfLoop = false;
BasicBlock *Exit = ExitBlocks[i];
for (pred_iterator I = pred_begin(Exit), E = pred_end(Exit);
I != E; ++I)
if (TIL->contains(*I))
Preds.push_back(*I);
else
HasPredOutsideOfLoop = true;
// If there are any preds not in the loop, we'll need to split
// the edges. The Preds.empty() check is needed because a block
// may appear multiple times in the list. We can't use
// getUniqueExitBlocks above because that depends on LoopSimplify
// form, which we're in the process of restoring!
if (!Preds.empty() && HasPredOutsideOfLoop) {
BasicBlock *NewExitBB =
SplitBlockPredecessors(Exit, Preds.data(), Preds.size(),
"split", P);
if (P->mustPreserveAnalysisID(LCSSAID))
CreatePHIsForSplitLoopExit(Preds, NewExitBB, Exit);
}
}
}
// LCSSA form was updated above for the case where LoopSimplify is
// available, which means that all predecessors of loop exit blocks
// are within the loop. Without LoopSimplify form, it would be
// necessary to insert a new phi.
assert((!P->mustPreserveAnalysisID(LCSSAID) ||
P->mustPreserveAnalysisID(LoopSimplifyID)) &&
"SplitCriticalEdge doesn't know how to update LCCSA form "
"without LoopSimplify!");
}
}
// Update ProfileInfo if it is around.
if (PI)
PI->splitEdge(TIBB, DestBB, NewBB, MergeIdenticalEdges);
return NewBB;
}
TEST(LoopInfoTest, PreorderTraversals) {
const char *ModuleStr = "define void @f() {\n"
"entry:\n"
" br label %loop.0\n"
"loop.0:\n"
" br i1 undef, label %loop.0.0, label %loop.1\n"
"loop.0.0:\n"
" br i1 undef, label %loop.0.0, label %loop.0.1\n"
"loop.0.1:\n"
" br i1 undef, label %loop.0.1, label %loop.0.2\n"
"loop.0.2:\n"
" br i1 undef, label %loop.0.2, label %loop.0\n"
"loop.1:\n"
" br i1 undef, label %loop.1.0, label %end\n"
"loop.1.0:\n"
" br i1 undef, label %loop.1.0, label %loop.1.1\n"
"loop.1.1:\n"
" br i1 undef, label %loop.1.1, label %loop.1.2\n"
"loop.1.2:\n"
" br i1 undef, label %loop.1.2, label %loop.1\n"
"end:\n"
" ret void\n"
"}\n";
// Parse the module.
LLVMContext Context;
std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
Function &F = *M->begin();
DominatorTree DT(F);
LoopInfo LI;
LI.analyze(DT);
Function::iterator I = F.begin();
ASSERT_EQ("entry", I->getName());
++I;
Loop &L_0 = *LI.getLoopFor(&*I++);
ASSERT_EQ("loop.0", L_0.getHeader()->getName());
Loop &L_0_0 = *LI.getLoopFor(&*I++);
ASSERT_EQ("loop.0.0", L_0_0.getHeader()->getName());
Loop &L_0_1 = *LI.getLoopFor(&*I++);
ASSERT_EQ("loop.0.1", L_0_1.getHeader()->getName());
Loop &L_0_2 = *LI.getLoopFor(&*I++);
ASSERT_EQ("loop.0.2", L_0_2.getHeader()->getName());
Loop &L_1 = *LI.getLoopFor(&*I++);
ASSERT_EQ("loop.1", L_1.getHeader()->getName());
Loop &L_1_0 = *LI.getLoopFor(&*I++);
ASSERT_EQ("loop.1.0", L_1_0.getHeader()->getName());
Loop &L_1_1 = *LI.getLoopFor(&*I++);
ASSERT_EQ("loop.1.1", L_1_1.getHeader()->getName());
Loop &L_1_2 = *LI.getLoopFor(&*I++);
ASSERT_EQ("loop.1.2", L_1_2.getHeader()->getName());
auto Preorder = LI.getLoopsInPreorder();
ASSERT_EQ(8u, Preorder.size());
EXPECT_EQ(&L_0, Preorder[0]);
EXPECT_EQ(&L_0_0, Preorder[1]);
EXPECT_EQ(&L_0_1, Preorder[2]);
EXPECT_EQ(&L_0_2, Preorder[3]);
EXPECT_EQ(&L_1, Preorder[4]);
EXPECT_EQ(&L_1_0, Preorder[5]);
EXPECT_EQ(&L_1_1, Preorder[6]);
EXPECT_EQ(&L_1_2, Preorder[7]);
auto ReverseSiblingPreorder = LI.getLoopsInReverseSiblingPreorder();
ASSERT_EQ(8u, ReverseSiblingPreorder.size());
EXPECT_EQ(&L_1, ReverseSiblingPreorder[0]);
EXPECT_EQ(&L_1_2, ReverseSiblingPreorder[1]);
EXPECT_EQ(&L_1_1, ReverseSiblingPreorder[2]);
EXPECT_EQ(&L_1_0, ReverseSiblingPreorder[3]);
EXPECT_EQ(&L_0, ReverseSiblingPreorder[4]);
EXPECT_EQ(&L_0_2, ReverseSiblingPreorder[5]);
EXPECT_EQ(&L_0_1, ReverseSiblingPreorder[6]);
EXPECT_EQ(&L_0_0, ReverseSiblingPreorder[7]);
}
/// SplitCriticalEdge - If this edge is a critical edge, insert a new node to
/// split the critical edge. This will update DominatorTree information if it
/// is available, thus calling this pass will not invalidate either of them.
/// This returns the new block if the edge was split, null otherwise.
///
/// If MergeIdenticalEdges is true (not the default), *all* edges from TI to the
/// specified successor will be merged into the same critical edge block.
/// This is most commonly interesting with switch instructions, which may
/// have many edges to any one destination. This ensures that all edges to that
/// dest go to one block instead of each going to a different block, but isn't
/// the standard definition of a "critical edge".
///
/// It is invalid to call this function on a critical edge that starts at an
/// IndirectBrInst. Splitting these edges will almost always create an invalid
/// program because the address of the new block won't be the one that is jumped
/// to.
///
BasicBlock *llvm::SplitCriticalEdge(TerminatorInst *TI, unsigned SuccNum,
Pass *P, bool MergeIdenticalEdges,
bool DontDeleteUselessPhis,
bool SplitLandingPads) {
if (!isCriticalEdge(TI, SuccNum, MergeIdenticalEdges)) return 0;
assert(!isa<IndirectBrInst>(TI) &&
"Cannot split critical edge from IndirectBrInst");
BasicBlock *TIBB = TI->getParent();
BasicBlock *DestBB = TI->getSuccessor(SuccNum);
// Splitting the critical edge to a landing pad block is non-trivial. Don't do
// it in this generic function.
if (DestBB->isLandingPad()) return 0;
// Create a new basic block, linking it into the CFG.
BasicBlock *NewBB = BasicBlock::Create(TI->getContext(),
TIBB->getName() + "." + DestBB->getName() + "_crit_edge");
// Create our unconditional branch.
BranchInst *NewBI = BranchInst::Create(DestBB, NewBB);
NewBI->setDebugLoc(TI->getDebugLoc());
// Branch to the new block, breaking the edge.
TI->setSuccessor(SuccNum, NewBB);
// Insert the block into the function... right after the block TI lives in.
Function &F = *TIBB->getParent();
Function::iterator FBBI = TIBB;
F.getBasicBlockList().insert(++FBBI, NewBB);
// If there are any PHI nodes in DestBB, we need to update them so that they
// merge incoming values from NewBB instead of from TIBB.
{
unsigned BBIdx = 0;
for (BasicBlock::iterator I = DestBB->begin(); isa<PHINode>(I); ++I) {
// We no longer enter through TIBB, now we come in through NewBB.
// Revector exactly one entry in the PHI node that used to come from
// TIBB to come from NewBB.
PHINode *PN = cast<PHINode>(I);
// Reuse the previous value of BBIdx if it lines up. In cases where we
// have multiple phi nodes with *lots* of predecessors, this is a speed
// win because we don't have to scan the PHI looking for TIBB. This
// happens because the BB list of PHI nodes are usually in the same
// order.
if (PN->getIncomingBlock(BBIdx) != TIBB)
BBIdx = PN->getBasicBlockIndex(TIBB);
PN->setIncomingBlock(BBIdx, NewBB);
}
}
// If there are any other edges from TIBB to DestBB, update those to go
// through the split block, making those edges non-critical as well (and
// reducing the number of phi entries in the DestBB if relevant).
if (MergeIdenticalEdges) {
for (unsigned i = SuccNum+1, e = TI->getNumSuccessors(); i != e; ++i) {
if (TI->getSuccessor(i) != DestBB) continue;
// Remove an entry for TIBB from DestBB phi nodes.
DestBB->removePredecessor(TIBB, DontDeleteUselessPhis);
// We found another edge to DestBB, go to NewBB instead.
TI->setSuccessor(i, NewBB);
}
}
// If we don't have a pass object, we can't update anything...
if (P == 0) return NewBB;
DominatorTree *DT = P->getAnalysisIfAvailable<DominatorTree>();
LoopInfo *LI = P->getAnalysisIfAvailable<LoopInfo>();
// If we have nothing to update, just return.
if (DT == 0 && LI == 0)
return NewBB;
// Now update analysis information. Since the only predecessor of NewBB is
// the TIBB, TIBB clearly dominates NewBB. TIBB usually doesn't dominate
// anything, as there are other successors of DestBB. However, if all other
// predecessors of DestBB are already dominated by DestBB (e.g. DestBB is a
// loop header) then NewBB dominates DestBB.
SmallVector<BasicBlock*, 8> OtherPreds;
// If there is a PHI in the block, loop over predecessors with it, which is
// faster than iterating pred_begin/end.
if (PHINode *PN = dyn_cast<PHINode>(DestBB->begin())) {
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
if (PN->getIncomingBlock(i) != NewBB)
OtherPreds.push_back(PN->getIncomingBlock(i));
} else {
for (pred_iterator I = pred_begin(DestBB), E = pred_end(DestBB);
I != E; ++I) {
BasicBlock *P = *I;
if (P != NewBB)
OtherPreds.push_back(P);
}
}
bool NewBBDominatesDestBB = true;
// Should we update DominatorTree information?
if (DT) {
DomTreeNode *TINode = DT->getNode(TIBB);
// The new block is not the immediate dominator for any other nodes, but
// TINode is the immediate dominator for the new node.
//
if (TINode) { // Don't break unreachable code!
DomTreeNode *NewBBNode = DT->addNewBlock(NewBB, TIBB);
DomTreeNode *DestBBNode = 0;
// If NewBBDominatesDestBB hasn't been computed yet, do so with DT.
if (!OtherPreds.empty()) {
DestBBNode = DT->getNode(DestBB);
while (!OtherPreds.empty() && NewBBDominatesDestBB) {
if (DomTreeNode *OPNode = DT->getNode(OtherPreds.back()))
NewBBDominatesDestBB = DT->dominates(DestBBNode, OPNode);
OtherPreds.pop_back();
}
OtherPreds.clear();
}
// If NewBBDominatesDestBB, then NewBB dominates DestBB, otherwise it
// doesn't dominate anything.
if (NewBBDominatesDestBB) {
if (!DestBBNode) DestBBNode = DT->getNode(DestBB);
DT->changeImmediateDominator(DestBBNode, NewBBNode);
}
}
}
// Update LoopInfo if it is around.
if (LI) {
if (Loop *TIL = LI->getLoopFor(TIBB)) {
// If one or the other blocks were not in a loop, the new block is not
// either, and thus LI doesn't need to be updated.
if (Loop *DestLoop = LI->getLoopFor(DestBB)) {
if (TIL == DestLoop) {
// Both in the same loop, the NewBB joins loop.
DestLoop->addBasicBlockToLoop(NewBB, LI->getBase());
} else if (TIL->contains(DestLoop)) {
// Edge from an outer loop to an inner loop. Add to the outer loop.
TIL->addBasicBlockToLoop(NewBB, LI->getBase());
} else if (DestLoop->contains(TIL)) {
// Edge from an inner loop to an outer loop. Add to the outer loop.
DestLoop->addBasicBlockToLoop(NewBB, LI->getBase());
} else {
// Edge from two loops with no containment relation. Because these
// are natural loops, we know that the destination block must be the
// header of its loop (adding a branch into a loop elsewhere would
// create an irreducible loop).
assert(DestLoop->getHeader() == DestBB &&
"Should not create irreducible loops!");
if (Loop *P = DestLoop->getParentLoop())
P->addBasicBlockToLoop(NewBB, LI->getBase());
}
}
// If TIBB is in a loop and DestBB is outside of that loop, split the
// other exit blocks of the loop that also have predecessors outside
// the loop, to maintain a LoopSimplify guarantee.
if (!TIL->contains(DestBB) &&
P->mustPreserveAnalysisID(LoopSimplifyID)) {
assert(!TIL->contains(NewBB) &&
"Split point for loop exit is contained in loop!");
// Update LCSSA form in the newly created exit block.
if (P->mustPreserveAnalysisID(LCSSAID))
createPHIsForSplitLoopExit(TIBB, NewBB, DestBB);
// For each unique exit block...
// FIXME: This code is functionally equivalent to the corresponding
// loop in LoopSimplify.
SmallVector<BasicBlock *, 4> ExitBlocks;
TIL->getExitBlocks(ExitBlocks);
for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i) {
// Collect all the preds that are inside the loop, and note
// whether there are any preds outside the loop.
SmallVector<BasicBlock *, 4> Preds;
bool HasPredOutsideOfLoop = false;
BasicBlock *Exit = ExitBlocks[i];
for (pred_iterator I = pred_begin(Exit), E = pred_end(Exit);
I != E; ++I) {
BasicBlock *P = *I;
if (TIL->contains(P)) {
if (isa<IndirectBrInst>(P->getTerminator())) {
Preds.clear();
break;
}
Preds.push_back(P);
} else {
HasPredOutsideOfLoop = true;
}
}
// If there are any preds not in the loop, we'll need to split
// the edges. The Preds.empty() check is needed because a block
// may appear multiple times in the list. We can't use
// getUniqueExitBlocks above because that depends on LoopSimplify
// form, which we're in the process of restoring!
if (!Preds.empty() && HasPredOutsideOfLoop) {
if (!Exit->isLandingPad()) {
BasicBlock *NewExitBB =
SplitBlockPredecessors(Exit, Preds, "split", P);
if (P->mustPreserveAnalysisID(LCSSAID))
createPHIsForSplitLoopExit(Preds, NewExitBB, Exit);
} else if (SplitLandingPads) {
SmallVector<BasicBlock*, 8> NewBBs;
SplitLandingPadPredecessors(Exit, Preds,
".split1", ".split2",
P, NewBBs);
if (P->mustPreserveAnalysisID(LCSSAID))
createPHIsForSplitLoopExit(Preds, NewBBs[0], Exit);
}
}
}
}
// LCSSA form was updated above for the case where LoopSimplify is
// available, which means that all predecessors of loop exit blocks
// are within the loop. Without LoopSimplify form, it would be
// necessary to insert a new phi.
assert((!P->mustPreserveAnalysisID(LCSSAID) ||
P->mustPreserveAnalysisID(LoopSimplifyID)) &&
"SplitCriticalEdge doesn't know how to update LCCSA form "
"without LoopSimplify!");
}
}
return NewBB;
}
static bool simplifyLoopInst(Loop &L, DominatorTree &DT, LoopInfo &LI,
AssumptionCache &AC, const TargetLibraryInfo &TLI,
MemorySSAUpdater *MSSAU) {
const DataLayout &DL = L.getHeader()->getModule()->getDataLayout();
SimplifyQuery SQ(DL, &TLI, &DT, &AC);
// On the first pass over the loop body we try to simplify every instruction.
// On subsequent passes, we can restrict this to only simplifying instructions
// where the inputs have been updated. We end up needing two sets: one
// containing the instructions we are simplifying in *this* pass, and one for
// the instructions we will want to simplify in the *next* pass. We use
// pointers so we can swap between two stably allocated sets.
SmallPtrSet<const Instruction *, 8> S1, S2, *ToSimplify = &S1, *Next = &S2;
// Track the PHI nodes that have already been visited during each iteration so
// that we can identify when it is necessary to iterate.
SmallPtrSet<PHINode *, 4> VisitedPHIs;
// While simplifying we may discover dead code or cause code to become dead.
// Keep track of all such instructions and we will delete them at the end.
SmallVector<Instruction *, 8> DeadInsts;
// First we want to create an RPO traversal of the loop body. By processing in
// RPO we can ensure that definitions are processed prior to uses (for non PHI
// uses) in all cases. This ensures we maximize the simplifications in each
// iteration over the loop and minimizes the possible causes for continuing to
// iterate.
LoopBlocksRPO RPOT(&L);
RPOT.perform(&LI);
MemorySSA *MSSA = MSSAU ? MSSAU->getMemorySSA() : nullptr;
bool Changed = false;
for (;;) {
if (MSSAU && VerifyMemorySSA)
MSSA->verifyMemorySSA();
for (BasicBlock *BB : RPOT) {
for (Instruction &I : *BB) {
if (auto *PI = dyn_cast<PHINode>(&I))
VisitedPHIs.insert(PI);
if (I.use_empty()) {
if (isInstructionTriviallyDead(&I, &TLI))
DeadInsts.push_back(&I);
continue;
}
// We special case the first iteration which we can detect due to the
// empty `ToSimplify` set.
bool IsFirstIteration = ToSimplify->empty();
if (!IsFirstIteration && !ToSimplify->count(&I))
continue;
Value *V = SimplifyInstruction(&I, SQ.getWithInstruction(&I));
if (!V || !LI.replacementPreservesLCSSAForm(&I, V))
continue;
for (Value::use_iterator UI = I.use_begin(), UE = I.use_end();
UI != UE;) {
Use &U = *UI++;
auto *UserI = cast<Instruction>(U.getUser());
U.set(V);
// If the instruction is used by a PHI node we have already processed
// we'll need to iterate on the loop body to converge, so add it to
// the next set.
if (auto *UserPI = dyn_cast<PHINode>(UserI))
if (VisitedPHIs.count(UserPI)) {
Next->insert(UserPI);
continue;
}
// If we are only simplifying targeted instructions and the user is an
// instruction in the loop body, add it to our set of targeted
// instructions. Because we process defs before uses (outside of PHIs)
// we won't have visited it yet.
//
// We also skip any uses outside of the loop being simplified. Those
// should always be PHI nodes due to LCSSA form, and we don't want to
// try to simplify those away.
assert((L.contains(UserI) || isa<PHINode>(UserI)) &&
"Uses outside the loop should be PHI nodes due to LCSSA!");
if (!IsFirstIteration && L.contains(UserI))
ToSimplify->insert(UserI);
}
if (MSSAU)
if (Instruction *SimpleI = dyn_cast_or_null<Instruction>(V))
if (MemoryAccess *MA = MSSA->getMemoryAccess(&I))
if (MemoryAccess *ReplacementMA = MSSA->getMemoryAccess(SimpleI))
MA->replaceAllUsesWith(ReplacementMA);
assert(I.use_empty() && "Should always have replaced all uses!");
if (isInstructionTriviallyDead(&I, &TLI))
DeadInsts.push_back(&I);
++NumSimplified;
Changed = true;
}
}
// Delete any dead instructions found thus far now that we've finished an
// iteration over all instructions in all the loop blocks.
if (!DeadInsts.empty()) {
Changed = true;
RecursivelyDeleteTriviallyDeadInstructions(DeadInsts, &TLI, MSSAU);
}
if (MSSAU && VerifyMemorySSA)
MSSA->verifyMemorySSA();
// If we never found a PHI that needs to be simplified in the next
// iteration, we're done.
if (Next->empty())
break;
// Otherwise, put the next set in place for the next iteration and reset it
// and the visited PHIs for that iteration.
std::swap(Next, ToSimplify);
Next->clear();
VisitedPHIs.clear();
DeadInsts.clear();
}
return Changed;
}
/// SplitBlockPredecessors - This method transforms BB by introducing a new
/// basic block into the function, and moving some of the predecessors of BB to
/// be predecessors of the new block. The new predecessors are indicated by the
/// Preds array, which has NumPreds elements in it. The new block is given a
/// suffix of 'Suffix'.
///
/// This currently updates the LLVM IR, AliasAnalysis, DominatorTree,
/// DominanceFrontier, LoopInfo, and LCCSA but no other analyses.
/// In particular, it does not preserve LoopSimplify (because it's
/// complicated to handle the case where one of the edges being split
/// is an exit of a loop with other exits).
///
BasicBlock *llvm::SplitBlockPredecessors(BasicBlock *BB,
BasicBlock *const *Preds,
unsigned NumPreds, const char *Suffix,
Pass *P) {
// Create new basic block, insert right before the original block.
BasicBlock *NewBB = BasicBlock::Create(BB->getContext(), BB->getName()+Suffix,
BB->getParent(), BB);
// The new block unconditionally branches to the old block.
BranchInst *BI = BranchInst::Create(BB, NewBB);
LoopInfo *LI = P ? P->getAnalysisIfAvailable<LoopInfo>() : 0;
Loop *L = LI ? LI->getLoopFor(BB) : 0;
bool PreserveLCSSA = P->mustPreserveAnalysisID(LCSSAID);
// Move the edges from Preds to point to NewBB instead of BB.
// While here, if we need to preserve loop analyses, collect
// some information about how this split will affect loops.
bool HasLoopExit = false;
bool IsLoopEntry = !!L;
bool SplitMakesNewLoopHeader = false;
for (unsigned i = 0; i != NumPreds; ++i) {
// This is slightly more strict than necessary; the minimum requirement
// is that there be no more than one indirectbr branching to BB. And
// all BlockAddress uses would need to be updated.
assert(!isa<IndirectBrInst>(Preds[i]->getTerminator()) &&
"Cannot split an edge from an IndirectBrInst");
Preds[i]->getTerminator()->replaceUsesOfWith(BB, NewBB);
if (LI) {
// If we need to preserve LCSSA, determine if any of
// the preds is a loop exit.
if (PreserveLCSSA)
if (Loop *PL = LI->getLoopFor(Preds[i]))
if (!PL->contains(BB))
HasLoopExit = true;
// If we need to preserve LoopInfo, note whether any of the
// preds crosses an interesting loop boundary.
if (L) {
if (L->contains(Preds[i]))
IsLoopEntry = false;
else
SplitMakesNewLoopHeader = true;
}
}
}
// Update dominator tree and dominator frontier if available.
DominatorTree *DT = P ? P->getAnalysisIfAvailable<DominatorTree>() : 0;
if (DT)
DT->splitBlock(NewBB);
if (DominanceFrontier *DF = P ? P->getAnalysisIfAvailable<DominanceFrontier>():0)
DF->splitBlock(NewBB);
// Insert a new PHI node into NewBB for every PHI node in BB and that new PHI
// node becomes an incoming value for BB's phi node. However, if the Preds
// list is empty, we need to insert dummy entries into the PHI nodes in BB to
// account for the newly created predecessor.
if (NumPreds == 0) {
// Insert dummy values as the incoming value.
for (BasicBlock::iterator I = BB->begin(); isa<PHINode>(I); ++I)
cast<PHINode>(I)->addIncoming(UndefValue::get(I->getType()), NewBB);
return NewBB;
}
AliasAnalysis *AA = P ? P->getAnalysisIfAvailable<AliasAnalysis>() : 0;
if (L) {
if (IsLoopEntry) {
// Add the new block to the nearest enclosing loop (and not an
// adjacent loop). To find this, examine each of the predecessors and
// determine which loops enclose them, and select the most-nested loop
// which contains the loop containing the block being split.
Loop *InnermostPredLoop = 0;
for (unsigned i = 0; i != NumPreds; ++i)
if (Loop *PredLoop = LI->getLoopFor(Preds[i])) {
// Seek a loop which actually contains the block being split (to
// avoid adjacent loops).
while (PredLoop && !PredLoop->contains(BB))
PredLoop = PredLoop->getParentLoop();
// Select the most-nested of these loops which contains the block.
if (PredLoop &&
PredLoop->contains(BB) &&
(!InnermostPredLoop ||
InnermostPredLoop->getLoopDepth() < PredLoop->getLoopDepth()))
InnermostPredLoop = PredLoop;
}
if (InnermostPredLoop)
InnermostPredLoop->addBasicBlockToLoop(NewBB, LI->getBase());
} else {
L->addBasicBlockToLoop(NewBB, LI->getBase());
if (SplitMakesNewLoopHeader)
L->moveToHeader(NewBB);
}
}
// Otherwise, create a new PHI node in NewBB for each PHI node in BB.
for (BasicBlock::iterator I = BB->begin(); isa<PHINode>(I); ) {
PHINode *PN = cast<PHINode>(I++);
// Check to see if all of the values coming in are the same. If so, we
// don't need to create a new PHI node, unless it's needed for LCSSA.
Value *InVal = 0;
if (!HasLoopExit) {
InVal = PN->getIncomingValueForBlock(Preds[0]);
for (unsigned i = 1; i != NumPreds; ++i)
if (InVal != PN->getIncomingValueForBlock(Preds[i])) {
InVal = 0;
break;
}
}
if (InVal) {
// If all incoming values for the new PHI would be the same, just don't
// make a new PHI. Instead, just remove the incoming values from the old
// PHI.
for (unsigned i = 0; i != NumPreds; ++i)
PN->removeIncomingValue(Preds[i], false);
} else {
// If the values coming into the block are not the same, we need a PHI.
// Create the new PHI node, insert it into NewBB at the end of the block
PHINode *NewPHI =
PHINode::Create(PN->getType(), PN->getName()+".ph", BI);
if (AA) AA->copyValue(PN, NewPHI);
// Move all of the PHI values for 'Preds' to the new PHI.
for (unsigned i = 0; i != NumPreds; ++i) {
Value *V = PN->removeIncomingValue(Preds[i], false);
NewPHI->addIncoming(V, Preds[i]);
}
InVal = NewPHI;
}
// Add an incoming value to the PHI node in the loop for the preheader
// edge.
PN->addIncoming(InVal, NewBB);
}
return NewBB;
}
// Sinks \p I from the loop \p L's preheader to its uses. Returns true if
// sinking is successful.
// \p LoopBlockNumber is used to sort the insertion blocks to ensure
// determinism.
static bool sinkInstruction(Loop &L, Instruction &I,
const SmallVectorImpl<BasicBlock *> &ColdLoopBBs,
const SmallDenseMap<BasicBlock *, int, 16> &LoopBlockNumber,
LoopInfo &LI, DominatorTree &DT,
BlockFrequencyInfo &BFI) {
// Compute the set of blocks in loop L which contain a use of I.
SmallPtrSet<BasicBlock *, 2> BBs;
for (auto &U : I.uses()) {
Instruction *UI = cast<Instruction>(U.getUser());
// We cannot sink I to PHI-uses.
if (dyn_cast<PHINode>(UI))
return false;
// We cannot sink I if it has uses outside of the loop.
if (!L.contains(LI.getLoopFor(UI->getParent())))
return false;
BBs.insert(UI->getParent());
}
// findBBsToSinkInto is O(BBs.size() * ColdLoopBBs.size()). We cap the max
// BBs.size() to avoid expensive computation.
// FIXME: Handle code size growth for min_size and opt_size.
if (BBs.size() > MaxNumberOfUseBBsForSinking)
return false;
// Find the set of BBs that we should insert a copy of I.
SmallPtrSet<BasicBlock *, 2> BBsToSinkInto =
findBBsToSinkInto(L, BBs, ColdLoopBBs, DT, BFI);
if (BBsToSinkInto.empty())
return false;
// Copy the final BBs into a vector and sort them using the total ordering
// of the loop block numbers as iterating the set doesn't give a useful
// order. No need to stable sort as the block numbers are a total ordering.
SmallVector<BasicBlock *, 2> SortedBBsToSinkInto;
SortedBBsToSinkInto.insert(SortedBBsToSinkInto.begin(), BBsToSinkInto.begin(),
BBsToSinkInto.end());
std::sort(SortedBBsToSinkInto.begin(), SortedBBsToSinkInto.end(),
[&](BasicBlock *A, BasicBlock *B) {
return *LoopBlockNumber.find(A) < *LoopBlockNumber.find(B);
});
BasicBlock *MoveBB = *SortedBBsToSinkInto.begin();
// FIXME: Optimize the efficiency for cloned value replacement. The current
// implementation is O(SortedBBsToSinkInto.size() * I.num_uses()).
for (BasicBlock *N : SortedBBsToSinkInto) {
if (N == MoveBB)
continue;
// Clone I and replace its uses.
Instruction *IC = I.clone();
IC->setName(I.getName());
IC->insertBefore(&*N->getFirstInsertionPt());
// Replaces uses of I with IC in N
for (Value::use_iterator UI = I.use_begin(), UE = I.use_end(); UI != UE;) {
Use &U = *UI++;
auto *I = cast<Instruction>(U.getUser());
if (I->getParent() == N)
U.set(IC);
}
// Replaces uses of I with IC in blocks dominated by N
replaceDominatedUsesWith(&I, IC, DT, N);
DEBUG(dbgs() << "Sinking a clone of " << I << " To: " << N->getName()
<< '\n');
NumLoopSunkCloned++;
}
DEBUG(dbgs() << "Sinking " << I << " To: " << MoveBB->getName() << '\n');
NumLoopSunk++;
I.moveBefore(&*MoveBB->getFirstInsertionPt());
return true;
}
void TR_ExpressionsSimplification::simplifyInvariantLoopExpressions(ListIterator<TR::Block> &blocks)
{
// Need to locate the induction variable of the loop
//
LoopInfo *loopInfo = findLoopInfo(_currentRegion);
if (trace())
{
if (!loopInfo)
{
traceMsg(comp(), "Accurate loop info is not found, cannot carry out summation reduction\n");
}
else
{
traceMsg(comp(), "Accurate loop info has been found, will try to carry out summation reduction\n");
if (loopInfo->getBoundaryNode())
{
traceMsg(comp(), "Variable iterations from node %p has not been handled\n",loopInfo->getBoundaryNode());
}
else
{
traceMsg(comp(), "Natural Loop %p will run %d times\n", _currentRegion, loopInfo->getNumIterations());
}
}
}
// Initialize the list of candidates
//
_candidateTTs = new (trStackMemory()) TR_ScratchList<TR::TreeTop>(trMemory());
for (TR::Block *currentBlock = blocks.getFirst(); currentBlock; currentBlock = blocks.getNext())
{
if (trace())
traceMsg(comp(), "Analyzing block #%d, which must be executed once per iteration\n", currentBlock->getNumber());
// Scan through each node in the block
//
TR::TreeTop *tt = currentBlock->getEntry();
TR::TreeTop *exitTreeTop = currentBlock->getExit();
while (tt != exitTreeTop)
{
TR::Node *currentNode = tt->getNode();
if (trace())
traceMsg(comp(), "Analyzing tree top node %p\n", currentNode);
if (loopInfo)
{
// requires loop info for the number of iterations
setSummationReductionCandidates(currentNode, tt);
}
setStoreMotionCandidates(currentNode, tt);
tt = tt->getNextTreeTop();
}
}
// New code: without using any UDI
// walk through the trees in the loop
// to invalidate the candidates
//
if (!_supportedExpressions)
{
_supportedExpressions = new (trStackMemory()) TR_BitVector(comp()->getNodeCount(), trMemory(), stackAlloc, growable);
}
invalidateCandidates();
ListIterator<TR::TreeTop> treeTops(_candidateTTs);
for (TR::TreeTop *treeTop = treeTops.getFirst(); treeTop; treeTop = treeTops.getNext())
{
if (trace())
traceMsg(comp(), "Candidate TreeTop: %p, Node:%p\n", treeTop, treeTop->getNode());
bool usedCandidate = false;
bool isPreheaderBlockInvalid = false;
if (loopInfo)
{
usedCandidate = tranformSummationReductionCandidate(treeTop, loopInfo, &isPreheaderBlockInvalid);
}
if (isPreheaderBlockInvalid)
{
break;
}
if (!usedCandidate)
{
tranformStoreMotionCandidate(treeTop, &isPreheaderBlockInvalid);
}
if (isPreheaderBlockInvalid)
{
break;
}
}
}
LoopInfoSet EquivalenceChecking::determineLoopInfoSet(SgNode* root, VariableIdMapping* variableIdMapping, Labeler* labeler) {
cout<<"INFO: loop info set and determine iteration vars."<<endl;
ForStmtToOmpPragmaMap forStmtToPragmaMap=createOmpPragmaForStmtMap(root);
cout<<"INFO: found "<<forStmtToPragmaMap.size()<<" omp/simd loops."<<endl;
LoopInfoSet loopInfoSet;
RoseAst ast(root);
AstMatching m;
// (i) match all for-stmts and (ii) filter canonical ones
string matchexpression="$FORSTMT=SgForStatement(_,_,..)";
MatchResult r=m.performMatching(matchexpression,root);
cout << "DEBUG: Matched for loops: "<<r.size()<<endl;
for(MatchResult::iterator i=r.begin(); i!=r.end(); ++i) {
LoopInfo loopInfo;
SgNode* forNode=(*i)["$FORSTMT"];
cout << "DEBUG: Detected for loops: "<<forNode->unparseToString()<<endl;
cout<<"DEBUG: MATCH: "<<forNode->unparseToString()<<AstTerm::astTermWithNullValuesToString(forNode)<<endl;
ROSE_ASSERT(isSgForStatement(forNode));
SgInitializedName* ivar=0;
SgExpression* lb=0;
SgExpression* ub=0;
SgExpression* step=0;
SgStatement* body=0;
bool hasIncrementalIterationSpace=false;
bool isInclusiveUpperBound=false;
bool isCanonicalOmpForLoop=SageInterface::isCanonicalForLoop(forNode, &ivar, &lb, &ub, &step, &body, &hasIncrementalIterationSpace, &isInclusiveUpperBound);
if(isCanonicalOmpForLoop) {
ROSE_ASSERT(ivar);
SgInitializedName* node=0;
if(isCanonicalOmpForLoop) {
node=ivar;
}
ROSE_ASSERT(node);
#if 0
// WORKAROUND 1
// TODO: investigate why the for pointer is not stored in the same match-result
if(forNode==0) {
forNode=node; // init
while(!isSgForStatement(forNode)||isSgProject(forNode))
forNode=forNode->get_parent();
}
ROSE_ASSERT(!isSgProject(forNode));
#endif
loopInfo.iterationVarId=variableIdMapping->variableId(node);
loopInfo.forStmt=isSgForStatement(forNode);
loopInfo.iterationVarType=isOmpParallelFor(loopInfo.forStmt,forStmtToPragmaMap)?ITERVAR_PAR:ITERVAR_SEQ;
if(loopInfo.forStmt) {
const SgStatementPtrList& stmtList=loopInfo.forStmt->get_init_stmt();
ROSE_ASSERT(stmtList.size()==1);
loopInfo.initStmt=stmtList[0];
loopInfo.condExpr=loopInfo.forStmt->get_test_expr();
loopInfo.computeLoopLabelSet(labeler);
loopInfo.computeOuterLoopsVarIds(variableIdMapping);
loopInfo.isOmpCanonical=true;
} else {
cerr<<"WARNING: no for statement found."<<endl;
if(forNode) {
cerr<<"for-loop:"<<forNode->unparseToString()<<endl;
} else {
cerr<<"for-loop: 0"<<endl;
}
}
} else {
loopInfo.forStmt=isSgForStatement(forNode);
loopInfo.isOmpCanonical=false;
}
loopInfoSet.push_back(loopInfo);
}
cout<<"INFO: found "<<forStmtToPragmaMap.size()<<" omp/simd loops."<<endl;
cout<<"INFO: found "<<Specialization::numParLoops(loopInfoSet,variableIdMapping)<<" parallel loops."<<endl;
return loopInfoSet;
}
// Calculate Edge Weights using "Loop Branch Heuristics". Predict backedges
// as taken, exiting edges as not-taken.
bool BranchProbabilityInfo::calcLoopBranchHeuristics(const BasicBlock *BB,
const LoopInfo &LI,
SccInfo &SccI) {
int SccNum;
Loop *L = LI.getLoopFor(BB);
if (!L) {
SccNum = getSCCNum(BB, SccI);
if (SccNum < 0)
return false;
}
SmallPtrSet<const BasicBlock*, 8> UnlikelyBlocks;
if (L)
computeUnlikelySuccessors(BB, L, UnlikelyBlocks);
SmallVector<unsigned, 8> BackEdges;
SmallVector<unsigned, 8> ExitingEdges;
SmallVector<unsigned, 8> InEdges; // Edges from header to the loop.
SmallVector<unsigned, 8> UnlikelyEdges;
for (succ_const_iterator I = succ_begin(BB), E = succ_end(BB); I != E; ++I) {
// Use LoopInfo if we have it, otherwise fall-back to SCC info to catch
// irreducible loops.
if (L) {
if (UnlikelyBlocks.count(*I) != 0)
UnlikelyEdges.push_back(I.getSuccessorIndex());
else if (!L->contains(*I))
ExitingEdges.push_back(I.getSuccessorIndex());
else if (L->getHeader() == *I)
BackEdges.push_back(I.getSuccessorIndex());
else
InEdges.push_back(I.getSuccessorIndex());
} else {
if (getSCCNum(*I, SccI) != SccNum)
ExitingEdges.push_back(I.getSuccessorIndex());
else if (isSCCHeader(*I, SccNum, SccI))
BackEdges.push_back(I.getSuccessorIndex());
else
InEdges.push_back(I.getSuccessorIndex());
}
}
if (BackEdges.empty() && ExitingEdges.empty() && UnlikelyEdges.empty())
return false;
// Collect the sum of probabilities of back-edges/in-edges/exiting-edges, and
// normalize them so that they sum up to one.
unsigned Denom = (BackEdges.empty() ? 0 : LBH_TAKEN_WEIGHT) +
(InEdges.empty() ? 0 : LBH_TAKEN_WEIGHT) +
(UnlikelyEdges.empty() ? 0 : LBH_UNLIKELY_WEIGHT) +
(ExitingEdges.empty() ? 0 : LBH_NONTAKEN_WEIGHT);
if (uint32_t numBackEdges = BackEdges.size()) {
BranchProbability TakenProb = BranchProbability(LBH_TAKEN_WEIGHT, Denom);
auto Prob = TakenProb / numBackEdges;
for (unsigned SuccIdx : BackEdges)
setEdgeProbability(BB, SuccIdx, Prob);
}
if (uint32_t numInEdges = InEdges.size()) {
BranchProbability TakenProb = BranchProbability(LBH_TAKEN_WEIGHT, Denom);
auto Prob = TakenProb / numInEdges;
for (unsigned SuccIdx : InEdges)
setEdgeProbability(BB, SuccIdx, Prob);
}
if (uint32_t numExitingEdges = ExitingEdges.size()) {
BranchProbability NotTakenProb = BranchProbability(LBH_NONTAKEN_WEIGHT,
Denom);
auto Prob = NotTakenProb / numExitingEdges;
for (unsigned SuccIdx : ExitingEdges)
setEdgeProbability(BB, SuccIdx, Prob);
}
if (uint32_t numUnlikelyEdges = UnlikelyEdges.size()) {
BranchProbability UnlikelyProb = BranchProbability(LBH_UNLIKELY_WEIGHT,
Denom);
auto Prob = UnlikelyProb / numUnlikelyEdges;
for (unsigned SuccIdx : UnlikelyEdges)
setEdgeProbability(BB, SuccIdx, Prob);
}
return true;
}
// Create shadow information for function F, including top-sorting its blocks to give them indices and thus
// a sensible order for specialisation.
ShadowFunctionInvar* LLPEAnalysisPass::getFunctionInvarInfo(Function& F) {
// Already described?
DenseMap<Function*, ShadowFunctionInvar*>::iterator findit = functionInfo.find(&F);
if(findit != functionInfo.end())
return findit->second;
// Beware! This LoopInfo instance and whatever Loop objects come from it are only alive until
// the next call to getAnalysis. Therefore the ShadowLoopInvar objects we make here
// must mirror all information we're interested in from the Loops.
LoopInfo* LI = &getAnalysis<LoopInfo>(F);
ShadowFunctionInvar* RetInfoP = new ShadowFunctionInvar();
functionInfo[&F] = RetInfoP;
ShadowFunctionInvar& RetInfo = *RetInfoP;
// Top-sort all blocks, including child loop. Thanks to trickery in createTopOrderingFrom,
// instead of giving all loop blocks an equal topsort value due to the latch edge cycle,
// we order the header first, then the loop body in topological order ignoring the latch, then its exit blocks.
std::vector<BasicBlock*> TopOrderedBlocks;
SmallSet<BasicBlock*, 8> VisitedBlocks;
createTopOrderingFrom(&F.getEntryBlock(), TopOrderedBlocks, VisitedBlocks, LI, /* loop = */ 0);
// Since topsort gives a bottom-up ordering.
std::reverse(TopOrderedBlocks.begin(), TopOrderedBlocks.end());
// Assign indices to each BB and instruction (IIndices is useful since otherwise we have to walk
// the instruction list to get from an instruction to its index)
DenseMap<BasicBlock*, uint32_t> BBIndices;
DenseMap<Instruction*, uint32_t> IIndices;
for(uint32_t i = 0; i < TopOrderedBlocks.size(); ++i) {
BasicBlock* BB = TopOrderedBlocks[i];
BBIndices[BB] = i;
uint32_t j;
BasicBlock::iterator it, endit;
for(j = 0, it = BB->begin(), endit = BB->end(); it != endit; ++it, ++j) {
IIndices[it] = j;
}
}
// Create shadow block objects:
ShadowBBInvar* FShadowBlocks = new ShadowBBInvar[TopOrderedBlocks.size()];
for(uint32_t i = 0; i < TopOrderedBlocks.size(); ++i) {
BasicBlock* BB = TopOrderedBlocks[i];
ShadowBBInvar& SBB = FShadowBlocks[i];
SBB.F = &RetInfo;
SBB.idx = i;
SBB.BB = BB;
// True loop scope will be computed later, but by default...
SBB.outerScope = 0;
SBB.naturalScope = 0;
const Loop* BBScope = LI->getLoopFor(BB);
// Find successor block indices:
succ_iterator SI = succ_begin(BB), SE = succ_end(BB);
uint32_t succSize = std::distance(SI, SE);
SBB.succIdxs = ImmutableArray<uint32_t>(new uint32_t[succSize], succSize);
for(uint32_t j = 0; SI != SE; ++SI, ++j) {
SBB.succIdxs[j] = BBIndices[*SI];
}
// Find predecessor block indices:
pred_iterator PI = pred_begin(BB), PE = pred_end(BB);
uint32_t predSize = std::distance(PI, PE);
SBB.predIdxs = ImmutableArray<uint32_t>(new uint32_t[predSize], predSize);
for(uint32_t j = 0; PI != PE; ++PI, ++j) {
SBB.predIdxs[j] = BBIndices[*PI];
if(SBB.predIdxs[j] > i) {
if((!BBScope) || SBB.BB != BBScope->getHeader()) {
errs() << "Warning: block " << SBB.BB->getName() << " in " << F.getName() << " has predecessor " << (*PI)->getName() << " that comes after it topologically, but this is not a loop header. The program is not in well-nested natural loop form.\n";
}
}
}
// Find instruction def/use indices:
ShadowInstructionInvar* insts = new ShadowInstructionInvar[BB->size()];
BasicBlock::iterator BI = BB->begin(), BE = BB->end();
for(uint32_t j = 0; BI != BE; ++BI, ++j) {
Instruction* I = BI;
ShadowInstructionInvar& SI = insts[j];
SI.idx = j;
SI.parent = &SBB;
SI.I = I;
// Get operands indices:
uint32_t NumOperands;
ShadowInstIdx* operandIdxs;
if(PHINode* PN = dyn_cast<PHINode>(I)) {
NumOperands = PN->getNumIncomingValues();
operandIdxs = new ShadowInstIdx[NumOperands];
uint32_t* incomingBBs = new uint32_t[NumOperands];
for(unsigned k = 0, kend = PN->getNumIncomingValues(); k != kend; ++k) {
if(Instruction* OpI = dyn_cast<Instruction>(PN->getIncomingValue(k)))
operandIdxs[k] = ShadowInstIdx(BBIndices[OpI->getParent()], IIndices[OpI]);
else if(GlobalVariable* OpGV = const_cast<GlobalVariable*>(getGlobalVar(PN->getIncomingValue(k))))
operandIdxs[k] = ShadowInstIdx(INVALID_BLOCK_IDX, getShadowGlobalIndex(OpGV));
else
operandIdxs[k] = ShadowInstIdx();
incomingBBs[k] = BBIndices[PN->getIncomingBlock(k)];
}
SI.operandBBs = ImmutableArray<uint32_t>(incomingBBs, NumOperands);
}
else {
NumOperands = I->getNumOperands();
operandIdxs = new ShadowInstIdx[NumOperands];
for(unsigned k = 0, kend = I->getNumOperands(); k != kend; ++k) {
if(Instruction* OpI = dyn_cast<Instruction>(I->getOperand(k)))
operandIdxs[k] = ShadowInstIdx(BBIndices[OpI->getParent()], IIndices[OpI]);
else if(GlobalVariable* OpGV = const_cast<GlobalVariable*>(getGlobalVar(I->getOperand(k))))
operandIdxs[k] = ShadowInstIdx(INVALID_BLOCK_IDX, getShadowGlobalIndex(OpGV));
else if(BasicBlock* OpBB = dyn_cast<BasicBlock>(I->getOperand(k)))
operandIdxs[k] = ShadowInstIdx(BBIndices[OpBB], INVALID_INSTRUCTION_IDX);
else
operandIdxs[k] = ShadowInstIdx();
}
}
SI.operandIdxs = ImmutableArray<ShadowInstIdx>(operandIdxs, NumOperands);
// Get user indices:
unsigned nUsers = std::distance(I->use_begin(), I->use_end());
ShadowInstIdx* userIdxs = new ShadowInstIdx[nUsers];
Instruction::use_iterator UI;
unsigned k;
for(k = 0, UI = I->use_begin(); k != nUsers; ++k, ++UI) {
if(Instruction* UserI = dyn_cast<Instruction>(UI->getUser())) {
userIdxs[k] = ShadowInstIdx(BBIndices[UserI->getParent()], IIndices[UserI]);
}
else {
userIdxs[k] = ShadowInstIdx();
}
}
SI.userIdxs = ImmutableArray<ShadowInstIdx>(userIdxs, nUsers);
}
SBB.insts = ImmutableArray<ShadowInstructionInvar>(insts, BB->size());
}
RetInfo.BBs = ImmutableArray<ShadowBBInvar>(FShadowBlocks, TopOrderedBlocks.size());
// Get user info for arguments:
ShadowArgInvar* Args = new ShadowArgInvar[F.arg_size()];
Function::arg_iterator AI = F.arg_begin();
uint32_t i = 0;
for(; i != F.arg_size(); ++i, ++AI) {
Argument* A = AI;
ShadowArgInvar& SArg = Args[i];
SArg.A = A;
unsigned j = 0;
Argument::use_iterator UI = A->use_begin(), UE = A->use_end();
uint32_t nUsers = std::distance(UI, UE);
ShadowInstIdx* Users = new ShadowInstIdx[nUsers];
for(; UI != UE; ++UI, ++j) {
Value* UsedV = UI->getUser();
if(Instruction* UsedI = dyn_cast<Instruction>(UsedV)) {
Users[j] = ShadowInstIdx(BBIndices[UsedI->getParent()], IIndices[UsedI]);
}
else {
Users[j] = ShadowInstIdx();
}
}
SArg.userIdxs = ImmutableArray<ShadowInstIdx>(Users, nUsers);
}
RetInfo.Args = ImmutableArray<ShadowArgInvar>(Args, F.arg_size());
// Populate map from loop headers to header index. Due to the topological sort,
// all loops consist of that block + L->getBlocks().size() further, contiguous blocks,
// making is-in-loop easy to compute.
DominatorTree* thisDT = DTs[&F];
for(LoopInfo::iterator it = LI->begin(), it2 = LI->end(); it != it2; ++it) {
ShadowLoopInvar* newL = getLoopInfo(&RetInfo, BBIndices, *it, thisDT, 0);
RetInfo.TopLevelLoops.push_back(newL);
}
// Count alloca instructions at the start of the function; this will control how
// large the std::vector that represents the frame will be initialised.
RetInfo.frameSize = 0;
for(BasicBlock::iterator it = F.getEntryBlock().begin(), itend = F.getEntryBlock().end(); it != itend && isa<AllocaInst>(it); ++it)
++RetInfo.frameSize;
// "&& RootIA" checks whether we're inside the initial context creation, in which case we should
// allocate a frame whether or not main can ever allocate to avoid the frame index underflowing
// in some circumstances.
if((!RetInfo.frameSize) && RootIA) {
// Magic value indicating the function will never alloca anything and we can skip all frame processing.
RetInfo.frameSize = -1;
for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E && RetInfo.frameSize == -1; ++I) {
if(isa<AllocaInst>(*I))
RetInfo.frameSize = 0;
}
}
return RetInfoP;
}
/// 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 LoopDeletionPass::runImpl(Loop *L, DominatorTree &DT, ScalarEvolution &SE,
LoopInfo &loopInfo) {
assert(L->isLCSSAForm(DT) && "Expected LCSSA!");
// 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, SE, 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.
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.
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 (DomTreeNode *ChildNode : ChildNodes) {
DT.changeImmediateDominator(ChildNode, 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.
SmallPtrSet<BasicBlock *, 8> blocks;
blocks.insert(L->block_begin(), L->block_end());
for (BasicBlock *BB : blocks)
loopInfo.removeBlock(BB);
// The last step is to update LoopInfo now that we've eliminated this loop.
loopInfo.markAsRemoved(L);
Changed = true;
++NumDeleted;
return Changed;
}
void DSWP::buildPDG(Loop *L) {
//Initialize PDG
for (Loop::block_iterator bi = L->getBlocks().begin(); bi != L->getBlocks().end(); bi++) {
BasicBlock *BB = *bi;
for (BasicBlock::iterator ui = BB->begin(); ui != BB->end(); ui++) {
Instruction *inst = &(*ui);
//standardlize the name for all expr
if (util.hasNewDef(inst)) {
inst->setName(util.genId());
dname[inst] = inst->getNameStr();
} else {
dname[inst] = util.genId();
}
pdg[inst] = new vector<Edge>();
rev[inst] = new vector<Edge>();
}
}
//LoopInfo &li = getAnalysis<LoopInfo>();
/*
* Memory dependency analysis
*/
MemoryDependenceAnalysis &mda = getAnalysis<MemoryDependenceAnalysis>();
for (Loop::block_iterator bi = L->getBlocks().begin(); bi != L->getBlocks().end(); bi++) {
BasicBlock *BB = *bi;
for (BasicBlock::iterator ii = BB->begin(); ii != BB->end(); ii++) {
Instruction *inst = &(*ii);
//data dependence = register dependence + memory dependence
//begin register dependence
for (Value::use_iterator ui = ii->use_begin(); ui != ii->use_end(); ui++) {
if (Instruction *user = dyn_cast<Instruction>(*ui)) {
addEdge(inst, user, REG);
}
}
//finish register dependence
//begin memory dependence
MemDepResult mdr = mda.getDependency(inst);
//TODO not sure clobbers mean!!
if (mdr.isDef()) {
Instruction *dep = mdr.getInst();
if (isa<LoadInst>(inst)) {
if (isa<StoreInst>(dep)) {
addEdge(dep, inst, DTRUE); //READ AFTER WRITE
}
}
if (isa<StoreInst>(inst)) {
if (isa<LoadInst>(dep)) {
addEdge(dep, inst, DANTI); //WRITE AFTER READ
}
if (isa<StoreInst>(dep)) {
addEdge(dep, inst, DOUT); //WRITE AFTER WRITE
}
}
//READ AFTER READ IS INSERT AFTER PDG BUILD
}
//end memory dependence
}//for ii
}//for bi
/*
* begin control dependence
*/
PostDominatorTree &pdt = getAnalysis<PostDominatorTree>();
//cout << pdt.getRootNode()->getBlock()->getNameStr() << endl;
/*
* alien code part 1
*/
LoopInfo *LI = &getAnalysis<LoopInfo>();
std::set<BranchInst*> backedgeParents;
for (Loop::block_iterator bi = L->getBlocks().begin(); bi
!= L->getBlocks().end(); bi++) {
BasicBlock *BB = *bi;
for (BasicBlock::iterator ii = BB->begin(); ii != BB->end(); ii++) {
Instruction *inst = ii;
if (BranchInst *brInst = dyn_cast<BranchInst>(inst)) {
// get the loop this instruction (and therefore basic block) belongs to
Loop *instLoop = LI->getLoopFor(BB);
bool branchesToHeader = false;
for (int i = brInst->getNumSuccessors() - 1; i >= 0
&& !branchesToHeader; i--) {
// if the branch could exit, store it
if (LI->getLoopFor(brInst->getSuccessor(i)) != instLoop) {
branchesToHeader = true;
}
}
if (branchesToHeader) {
backedgeParents.insert(brInst);
}
}
}
}
//build information for predecessor of blocks in post dominator tree
for (Function::iterator bi = func->begin(); bi != func->end(); bi++) {
BasicBlock *BB = bi;
DomTreeNode *dn = pdt.getNode(BB);
for (DomTreeNode::iterator di = dn->begin(); di != dn->end(); di++) {
BasicBlock *CB = (*di)->getBlock();
pre[CB] = BB;
}
}
//
// //add dependency within a basicblock
// for (Loop::block_iterator bi = L->getBlocks().begin(); bi != L->getBlocks().end(); bi++) {
// BasicBlock *BB = *bi;
// Instruction *pre = NULL;
// for (BasicBlock::iterator ui = BB->begin(); ui != BB->end(); ui++) {
// Instruction *inst = &(*ui);
// if (pre != NULL) {
// addEdge(pre, inst, CONTROL);
// }
// pre = inst;
// }
// }
// //the special kind of dependence need loop peeling ? I don't know whether this is needed
// for (Loop::block_iterator bi = L->getBlocks().begin(); bi != L->getBlocks().end(); bi++) {
// BasicBlock *BB = *bi;
// for (succ_iterator PI = succ_begin(BB); PI != succ_end(BB); ++PI) {
// BasicBlock *succ = *PI;
//
// checkControlDependence(BB, succ, pdt);
// }
// }
/*
* alien code part 2
*/
// add normal control dependencies
// loop through each instruction
for (Loop::block_iterator bbIter = L->block_begin(); bbIter
!= L->block_end(); ++bbIter) {
BasicBlock *bb = *bbIter;
// check the successors of this basic block
if (BranchInst *branchInst = dyn_cast<BranchInst>(bb->getTerminator())) {
if (branchInst->getNumSuccessors() > 1) {
BasicBlock * succ = branchInst->getSuccessor(0);
// if the successor is nested shallower than the current basic block, continue
if (LI->getLoopDepth(bb) < LI->getLoopDepth(succ)) {
continue;
}
// otherwise, add all instructions to graph as control dependence
while (succ != NULL && succ != bb && LI->getLoopDepth(succ)
>= LI->getLoopDepth(bb)) {
Instruction *terminator = bb->getTerminator();
for (BasicBlock::iterator succInstIter = succ->begin(); &(*succInstIter)
!= succ->getTerminator(); ++succInstIter) {
addEdge(terminator, &(*succInstIter), CONTROL);
}
if (BranchInst *succBrInst = dyn_cast<BranchInst>(succ->getTerminator())) {
if (succBrInst->getNumSuccessors() > 1) {
addEdge(terminator, succ->getTerminator(),
CONTROL);
}
}
if (BranchInst *br = dyn_cast<BranchInst>(succ->getTerminator())) {
if (br->getNumSuccessors() == 1) {
succ = br->getSuccessor(0);
} else {
succ = NULL;
}
} else {
succ = NULL;
}
}
}
}
}
/*
* alien code part 3
*/
for (std::set<BranchInst*>::iterator exitIter = backedgeParents.begin(); exitIter != backedgeParents.end(); ++exitIter) {
BranchInst *exitBranch = *exitIter;
if (exitBranch->isConditional()) {
BasicBlock *header = LI->getLoopFor(exitBranch->getParent())->getHeader();
for (BasicBlock::iterator ctrlIter = header->begin(); ctrlIter != header->end(); ++ctrlIter) {
addEdge(exitBranch, &(*ctrlIter), CONTROL);
}
}
}
//end control dependence
}
/// For every instruction from the worklist, check to see if it has any uses
/// that are outside the current loop. If so, insert LCSSA PHI nodes and
/// rewrite the uses.
bool llvm::formLCSSAForInstructions(SmallVectorImpl<Instruction *> &Worklist,
DominatorTree &DT, LoopInfo &LI) {
SmallVector<Use *, 16> UsesToRewrite;
SmallSetVector<PHINode *, 16> PHIsToRemove;
PredIteratorCache PredCache;
bool Changed = false;
// Cache the Loop ExitBlocks across this loop. We expect to get a lot of
// instructions within the same loops, computing the exit blocks is
// expensive, and we're not mutating the loop structure.
SmallDenseMap<Loop*, SmallVector<BasicBlock *,1>> LoopExitBlocks;
while (!Worklist.empty()) {
UsesToRewrite.clear();
Instruction *I = Worklist.pop_back_val();
BasicBlock *InstBB = I->getParent();
Loop *L = LI.getLoopFor(InstBB);
if (!LoopExitBlocks.count(L))
L->getExitBlocks(LoopExitBlocks[L]);
assert(LoopExitBlocks.count(L));
const SmallVectorImpl<BasicBlock *> &ExitBlocks = LoopExitBlocks[L];
if (ExitBlocks.empty())
continue;
// Tokens cannot be used in PHI nodes, so we skip over them.
// We can run into tokens which are live out of a loop with catchswitch
// instructions in Windows EH if the catchswitch has one catchpad which
// is inside the loop and another which is not.
if (I->getType()->isTokenTy())
continue;
for (Use &U : I->uses()) {
Instruction *User = cast<Instruction>(U.getUser());
BasicBlock *UserBB = User->getParent();
if (PHINode *PN = dyn_cast<PHINode>(User))
UserBB = PN->getIncomingBlock(U);
if (InstBB != UserBB && !L->contains(UserBB))
UsesToRewrite.push_back(&U);
}
// If there are no uses outside the loop, exit with no change.
if (UsesToRewrite.empty())
continue;
++NumLCSSA; // We are applying the transformation
// Invoke instructions are special in that their result value is not
// available along their unwind edge. The code below tests to see whether
// DomBB dominates the value, so adjust DomBB to the normal destination
// block, which is effectively where the value is first usable.
BasicBlock *DomBB = InstBB;
if (InvokeInst *Inv = dyn_cast<InvokeInst>(I))
DomBB = Inv->getNormalDest();
DomTreeNode *DomNode = DT.getNode(DomBB);
SmallVector<PHINode *, 16> AddedPHIs;
SmallVector<PHINode *, 8> PostProcessPHIs;
SmallVector<PHINode *, 4> InsertedPHIs;
SSAUpdater SSAUpdate(&InsertedPHIs);
SSAUpdate.Initialize(I->getType(), I->getName());
// Insert the LCSSA phi's into all of the exit blocks dominated by the
// value, and add them to the Phi's map.
for (BasicBlock *ExitBB : ExitBlocks) {
if (!DT.dominates(DomNode, DT.getNode(ExitBB)))
continue;
// If we already inserted something for this BB, don't reprocess it.
if (SSAUpdate.HasValueForBlock(ExitBB))
continue;
PHINode *PN = PHINode::Create(I->getType(), PredCache.size(ExitBB),
I->getName() + ".lcssa", &ExitBB->front());
// Add inputs from inside the loop for this PHI.
for (BasicBlock *Pred : PredCache.get(ExitBB)) {
PN->addIncoming(I, Pred);
// If the exit block has a predecessor not within the loop, arrange for
// the incoming value use corresponding to that predecessor to be
// rewritten in terms of a different LCSSA PHI.
if (!L->contains(Pred))
UsesToRewrite.push_back(
&PN->getOperandUse(PN->getOperandNumForIncomingValue(
PN->getNumIncomingValues() - 1)));
}
AddedPHIs.push_back(PN);
// Remember that this phi makes the value alive in this block.
SSAUpdate.AddAvailableValue(ExitBB, PN);
// LoopSimplify might fail to simplify some loops (e.g. when indirect
// branches are involved). In such situations, it might happen that an
// exit for Loop L1 is the header of a disjoint Loop L2. Thus, when we
// create PHIs in such an exit block, we are also inserting PHIs into L2's
// header. This could break LCSSA form for L2 because these inserted PHIs
// can also have uses outside of L2. Remember all PHIs in such situation
// as to revisit than later on. FIXME: Remove this if indirectbr support
// into LoopSimplify gets improved.
if (auto *OtherLoop = LI.getLoopFor(ExitBB))
if (!L->contains(OtherLoop))
PostProcessPHIs.push_back(PN);
}
// Rewrite all uses outside the loop in terms of the new PHIs we just
// inserted.
for (Use *UseToRewrite : UsesToRewrite) {
// If this use is in an exit block, rewrite to use the newly inserted PHI.
// This is required for correctness because SSAUpdate doesn't handle uses
// in the same block. It assumes the PHI we inserted is at the end of the
// block.
Instruction *User = cast<Instruction>(UseToRewrite->getUser());
BasicBlock *UserBB = User->getParent();
if (PHINode *PN = dyn_cast<PHINode>(User))
UserBB = PN->getIncomingBlock(*UseToRewrite);
if (isa<PHINode>(UserBB->begin()) && isExitBlock(UserBB, ExitBlocks)) {
// Tell the VHs that the uses changed. This updates SCEV's caches.
if (UseToRewrite->get()->hasValueHandle())
ValueHandleBase::ValueIsRAUWd(*UseToRewrite, &UserBB->front());
UseToRewrite->set(&UserBB->front());
continue;
}
// Otherwise, do full PHI insertion.
SSAUpdate.RewriteUse(*UseToRewrite);
}
// SSAUpdater might have inserted phi-nodes inside other loops. We'll need
// to post-process them to keep LCSSA form.
for (PHINode *InsertedPN : InsertedPHIs) {
if (auto *OtherLoop = LI.getLoopFor(InsertedPN->getParent()))
if (!L->contains(OtherLoop))
PostProcessPHIs.push_back(InsertedPN);
}
// Post process PHI instructions that were inserted into another disjoint
// loop and update their exits properly.
for (auto *PostProcessPN : PostProcessPHIs) {
if (PostProcessPN->use_empty())
continue;
// Reprocess each PHI instruction.
Worklist.push_back(PostProcessPN);
}
// Keep track of PHI nodes that we want to remove because they did not have
// any uses rewritten.
for (PHINode *PN : AddedPHIs)
if (PN->use_empty())
PHIsToRemove.insert(PN);
Changed = true;
}
// Remove PHI nodes that did not have any uses rewritten.
for (PHINode *PN : PHIsToRemove) {
assert (PN->use_empty() && "Trying to remove a phi with uses.");
PN->eraseFromParent();
}
return Changed;
}
/// UpdateAnalysisInformation - Update DominatorTree, LoopInfo, and LCCSA
/// analysis information.
static void UpdateAnalysisInformation(BasicBlock *OldBB, BasicBlock *NewBB,
ArrayRef<BasicBlock *> Preds,
Pass *P, bool &HasLoopExit) {
if (!P) return;
LoopInfo *LI = P->getAnalysisIfAvailable<LoopInfo>();
Loop *L = LI ? LI->getLoopFor(OldBB) : 0;
// If we need to preserve loop analyses, collect some information about how
// this split will affect loops.
bool IsLoopEntry = !!L;
bool SplitMakesNewLoopHeader = false;
if (LI) {
bool PreserveLCSSA = P->mustPreserveAnalysisID(LCSSAID);
for (ArrayRef<BasicBlock*>::iterator
i = Preds.begin(), e = Preds.end(); i != e; ++i) {
BasicBlock *Pred = *i;
// If we need to preserve LCSSA, determine if any of the preds is a loop
// exit.
if (PreserveLCSSA)
if (Loop *PL = LI->getLoopFor(Pred))
if (!PL->contains(OldBB))
HasLoopExit = true;
// If we need to preserve LoopInfo, note whether any of the preds crosses
// an interesting loop boundary.
if (!L) continue;
if (L->contains(Pred))
IsLoopEntry = false;
else
SplitMakesNewLoopHeader = true;
}
}
// Update dominator tree if available.
DominatorTree *DT = P->getAnalysisIfAvailable<DominatorTree>();
if (DT)
DT->splitBlock(NewBB);
if (!L) return;
if (IsLoopEntry) {
// Add the new block to the nearest enclosing loop (and not an adjacent
// loop). To find this, examine each of the predecessors and determine which
// loops enclose them, and select the most-nested loop which contains the
// loop containing the block being split.
Loop *InnermostPredLoop = 0;
for (ArrayRef<BasicBlock*>::iterator
i = Preds.begin(), e = Preds.end(); i != e; ++i) {
BasicBlock *Pred = *i;
if (Loop *PredLoop = LI->getLoopFor(Pred)) {
// Seek a loop which actually contains the block being split (to avoid
// adjacent loops).
while (PredLoop && !PredLoop->contains(OldBB))
PredLoop = PredLoop->getParentLoop();
// Select the most-nested of these loops which contains the block.
if (PredLoop && PredLoop->contains(OldBB) &&
(!InnermostPredLoop ||
InnermostPredLoop->getLoopDepth() < PredLoop->getLoopDepth()))
InnermostPredLoop = PredLoop;
}
}
if (InnermostPredLoop)
InnermostPredLoop->addBasicBlockToLoop(NewBB, LI->getBase());
} else {
L->addBasicBlockToLoop(NewBB, LI->getBase());
if (SplitMakesNewLoopHeader)
L->moveToHeader(NewBB);
}
}
bool LoopInstSimplify::runOnLoop(Loop *L, LPPassManager &LPM) {
if (skipOptnoneFunction(L))
return false;
DominatorTreeWrapperPass *DTWP =
getAnalysisIfAvailable<DominatorTreeWrapperPass>();
DominatorTree *DT = DTWP ? &DTWP->getDomTree() : nullptr;
LoopInfo *LI = &getAnalysis<LoopInfo>();
DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
const DataLayout *DL = DLP ? &DLP->getDataLayout() : nullptr;
const TargetLibraryInfo *TLI = &getAnalysis<TargetLibraryInfo>();
AssumptionTracker *AT = &getAnalysis<AssumptionTracker>();
SmallVector<BasicBlock*, 8> ExitBlocks;
L->getUniqueExitBlocks(ExitBlocks);
array_pod_sort(ExitBlocks.begin(), ExitBlocks.end());
SmallPtrSet<const Instruction*, 8> S1, S2, *ToSimplify = &S1, *Next = &S2;
// The bit we are stealing from the pointer represents whether this basic
// block is the header of a subloop, in which case we only process its phis.
typedef PointerIntPair<BasicBlock*, 1> WorklistItem;
SmallVector<WorklistItem, 16> VisitStack;
SmallPtrSet<BasicBlock*, 32> Visited;
bool Changed = false;
bool LocalChanged;
do {
LocalChanged = false;
VisitStack.clear();
Visited.clear();
VisitStack.push_back(WorklistItem(L->getHeader(), false));
while (!VisitStack.empty()) {
WorklistItem Item = VisitStack.pop_back_val();
BasicBlock *BB = Item.getPointer();
bool IsSubloopHeader = Item.getInt();
// Simplify instructions in the current basic block.
for (BasicBlock::iterator BI = BB->begin(), BE = BB->end(); BI != BE;) {
Instruction *I = BI++;
// The first time through the loop ToSimplify is empty and we try to
// simplify all instructions. On later iterations ToSimplify is not
// empty and we only bother simplifying instructions that are in it.
if (!ToSimplify->empty() && !ToSimplify->count(I))
continue;
// Don't bother simplifying unused instructions.
if (!I->use_empty()) {
Value *V = SimplifyInstruction(I, DL, TLI, DT, AT);
if (V && LI->replacementPreservesLCSSAForm(I, V)) {
// Mark all uses for resimplification next time round the loop.
for (User *U : I->users())
Next->insert(cast<Instruction>(U));
I->replaceAllUsesWith(V);
LocalChanged = true;
++NumSimplified;
}
}
bool res = RecursivelyDeleteTriviallyDeadInstructions(I, TLI);
if (res) {
// RecursivelyDeleteTriviallyDeadInstruction can remove
// more than one instruction, so simply incrementing the
// iterator does not work. When instructions get deleted
// re-iterate instead.
BI = BB->begin(); BE = BB->end();
LocalChanged |= res;
}
if (IsSubloopHeader && !isa<PHINode>(I))
break;
}
// Add all successors to the worklist, except for loop exit blocks and the
// bodies of subloops. We visit the headers of loops so that we can process
// their phis, but we contract the rest of the subloop body and only follow
// edges leading back to the original loop.
for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE;
++SI) {
BasicBlock *SuccBB = *SI;
if (!Visited.insert(SuccBB).second)
continue;
const Loop *SuccLoop = LI->getLoopFor(SuccBB);
if (SuccLoop && SuccLoop->getHeader() == SuccBB
&& L->contains(SuccLoop)) {
VisitStack.push_back(WorklistItem(SuccBB, true));
SmallVector<BasicBlock*, 8> SubLoopExitBlocks;
SuccLoop->getExitBlocks(SubLoopExitBlocks);
for (unsigned i = 0; i < SubLoopExitBlocks.size(); ++i) {
BasicBlock *ExitBB = SubLoopExitBlocks[i];
if (LI->getLoopFor(ExitBB) == L && Visited.insert(ExitBB).second)
VisitStack.push_back(WorklistItem(ExitBB, false));
}
continue;
}
bool IsExitBlock = std::binary_search(ExitBlocks.begin(),
ExitBlocks.end(), SuccBB);
if (IsExitBlock)
continue;
VisitStack.push_back(WorklistItem(SuccBB, false));
}
}
// Place the list of instructions to simplify on the next loop iteration
// into ToSimplify.
std::swap(ToSimplify, Next);
Next->clear();
Changed |= LocalChanged;
} while (LocalChanged);
return Changed;
}
