maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[MBP] Use range based for-loops throughout this code. Several had 

already been added and the inconsistency made choosing names and
changing code more annoying. Plus, wow are they better for this code!

llvm-svn: 231347
This commit is contained in:
Chandler Carruth 2015-03-05 03:19:05 +00:00
parent d2d3597ea2
commit 7a715dae05
1 changed files with 108 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

246
llvm/lib/CodeGen/MachineBlockPlacement.cpp
View File

@ -151,19 +151,18 @@ public:
// Update the incoming blocks to point to this chain, and add them to the // Update the incoming blocks to point to this chain, and add them to the
// chain structure. // chain structure.
for (BlockChain::iterator BI = Chain->begin(), BE = Chain->end(); BI != BE; for (MachineBasicBlock *ChainBB : *Chain) {
++BI) { Blocks.push_back(ChainBB);
Blocks.push_back(*BI); assert(BlockToChain[ChainBB] == Chain && "Incoming blocks not in chain");
assert(BlockToChain[*BI] == Chain && "Incoming blocks not in chain"); BlockToChain[ChainBB] = this;
BlockToChain[*BI] = this;
} }
} }
#ifndef NDEBUG #ifndef NDEBUG
/// \brief Dump the blocks in this chain. /// \brief Dump the blocks in this chain.
LLVM_DUMP_METHOD void dump() { LLVM_DUMP_METHOD void dump() {
for (iterator I = begin(), E = end(); I != E; ++I) for (MachineBasicBlock *MBB : *this)
(*I)->dump(); MBB->dump();
} }
#endif // NDEBUG #endif // NDEBUG
@ -311,20 +310,17 @@ void MachineBlockPlacement::markChainSuccessors(
const BlockFilterSet *BlockFilter) { const BlockFilterSet *BlockFilter) {
// Walk all the blocks in this chain, marking their successors as having // Walk all the blocks in this chain, marking their successors as having
// a predecessor placed. // a predecessor placed.
for (BlockChain::iterator CBI = Chain.begin(), CBE = Chain.end(); CBI != CBE; for (MachineBasicBlock *MBB : Chain) {
++CBI) {
// Add any successors for which this is the only un-placed in-loop // Add any successors for which this is the only un-placed in-loop
// predecessor to the worklist as a viable candidate for CFG-neutral // predecessor to the worklist as a viable candidate for CFG-neutral
// placement. No subsequent placement of this block will violate the CFG // placement. No subsequent placement of this block will violate the CFG
// shape, so we get to use heuristics to choose a favorable placement. // shape, so we get to use heuristics to choose a favorable placement.
for (MachineBasicBlock::succ_iterator SI = (*CBI)->succ_begin(), for (MachineBasicBlock *Succ : MBB->successors()) {
SE = (*CBI)->succ_end(); if (BlockFilter && !BlockFilter->count(Succ))
SI != SE; ++SI) {
if (BlockFilter && !BlockFilter->count(*SI))
continue; continue;
BlockChain &SuccChain = *BlockToChain[*SI]; BlockChain &SuccChain = *BlockToChain[Succ];
// Disregard edges within a fixed chain, or edges to the loop header. // Disregard edges within a fixed chain, or edges to the loop header.
if (&Chain == &SuccChain || *SI == LoopHeaderBB) if (&Chain == &SuccChain || Succ == LoopHeaderBB)
continue; continue;
// This is a cross-chain edge that is within the loop, so decrement the // This is a cross-chain edge that is within the loop, so decrement the
@ -453,22 +449,20 @@ MachineBasicBlock *MachineBlockPlacement::selectBestCandidateBlock(
MachineBasicBlock *BestBlock = nullptr; MachineBasicBlock *BestBlock = nullptr;
BlockFrequency BestFreq; BlockFrequency BestFreq;
for (SmallVectorImpl<MachineBasicBlock *>::iterator WBI = WorkList.begin(), for (MachineBasicBlock *MBB : WorkList) {
WBE = WorkList.end(); BlockChain &SuccChain = *BlockToChain[MBB];
WBI != WBE; ++WBI) {
BlockChain &SuccChain = *BlockToChain[*WBI];
if (&SuccChain == &Chain) { if (&SuccChain == &Chain) {
DEBUG(dbgs() << " " << getBlockName(*WBI) << " -> Already merged!\n"); DEBUG(dbgs() << " " << getBlockName(MBB) << " -> Already merged!\n");
continue; continue;
} }
assert(SuccChain.LoopPredecessors == 0 && "Found CFG-violating block"); assert(SuccChain.LoopPredecessors == 0 && "Found CFG-violating block");
BlockFrequency CandidateFreq = MBFI->getBlockFreq(*WBI); BlockFrequency CandidateFreq = MBFI->getBlockFreq(MBB);
DEBUG(dbgs() << " " << getBlockName(*WBI) << " -> "; DEBUG(dbgs() << " " << getBlockName(MBB) << " -> ";
MBFI->printBlockFreq(dbgs(), CandidateFreq) << " (freq)\n"); MBFI->printBlockFreq(dbgs(), CandidateFreq) << " (freq)\n");
if (BestBlock && BestFreq >= CandidateFreq) if (BestBlock && BestFreq >= CandidateFreq)
continue; continue;
BestBlock = *WBI; BestBlock = MBB;
BestFreq = CandidateFreq; BestFreq = CandidateFreq;
} }
return BestBlock; return BestBlock;
@ -578,10 +572,7 @@ MachineBlockPlacement::findBestLoopTop(MachineLoop &L,
BlockFrequency BestPredFreq; BlockFrequency BestPredFreq;
MachineBasicBlock *BestPred = nullptr; MachineBasicBlock *BestPred = nullptr;
for (MachineBasicBlock::pred_iterator PI = L.getHeader()->pred_begin(), for (MachineBasicBlock *Pred : L.getHeader()->predecessors()) {
PE = L.getHeader()->pred_end();
PI != PE; ++PI) {
MachineBasicBlock *Pred = *PI;
if (!LoopBlockSet.count(Pred)) if (!LoopBlockSet.count(Pred))
continue; continue;
DEBUG(dbgs() << " header pred: " << getBlockName(Pred) << ", " DEBUG(dbgs() << " header pred: " << getBlockName(Pred) << ", "
@ -643,12 +634,11 @@ MachineBlockPlacement::findBestLoopExit(MachineFunction &F, MachineLoop &L,
DEBUG(dbgs() << "Finding best loop exit for: " << getBlockName(L.getHeader()) DEBUG(dbgs() << "Finding best loop exit for: " << getBlockName(L.getHeader())
<< "\n"); << "\n");
for (MachineLoop::block_iterator I = L.block_begin(), E = L.block_end(); for (MachineBasicBlock *MBB : L.getBlocks()) {
I != E; ++I) { BlockChain &Chain = *BlockToChain[MBB];
BlockChain &Chain = *BlockToChain[*I];
// Ensure that this block is at the end of a chain; otherwise it could be // Ensure that this block is at the end of a chain; otherwise it could be
// mid-way through an inner loop or a successor of an analyzable branch. // mid-way through an inner loop or a successor of an analyzable branch.
if (*I != *std::prev(Chain.end())) if (MBB != *std::prev(Chain.end()))
continue; continue;
// Now walk the successors. We need to establish whether this has a viable // Now walk the successors. We need to establish whether this has a viable
@ -662,41 +652,39 @@ MachineBlockPlacement::findBestLoopExit(MachineFunction &F, MachineLoop &L,
// the MBPI analysis, we use the internal weights and manually compute the // the MBPI analysis, we use the internal weights and manually compute the
// probabilities to avoid quadratic behavior. // probabilities to avoid quadratic behavior.
uint32_t WeightScale = 0; uint32_t WeightScale = 0;
uint32_t SumWeight = MBPI->getSumForBlock(*I, WeightScale); uint32_t SumWeight = MBPI->getSumForBlock(MBB, WeightScale);
for (MachineBasicBlock::succ_iterator SI = (*I)->succ_begin(), for (MachineBasicBlock *Succ : MBB->successors()) {
SE = (*I)->succ_end(); if (Succ->isLandingPad())
SI != SE; ++SI) {
if ((*SI)->isLandingPad())
continue; continue;
if (*SI == *I) if (Succ == MBB)
continue; continue;
BlockChain &SuccChain = *BlockToChain[*SI]; BlockChain &SuccChain = *BlockToChain[Succ];
// Don't split chains, either this chain or the successor's chain. // Don't split chains, either this chain or the successor's chain.
if (&Chain == &SuccChain) { if (&Chain == &SuccChain) {
DEBUG(dbgs() << " exiting: " << getBlockName(*I) << " -> " DEBUG(dbgs() << " exiting: " << getBlockName(MBB) << " -> "
<< getBlockName(*SI) << " (chain conflict)\n"); << getBlockName(Succ) << " (chain conflict)\n");
continue; continue;
} }
uint32_t SuccWeight = MBPI->getEdgeWeight(*I, *SI); uint32_t SuccWeight = MBPI->getEdgeWeight(MBB, Succ);
if (LoopBlockSet.count(*SI)) { if (LoopBlockSet.count(Succ)) {
DEBUG(dbgs() << " looping: " << getBlockName(*I) << " -> " DEBUG(dbgs() << " looping: " << getBlockName(MBB) << " -> "
<< getBlockName(*SI) << " (" << SuccWeight << ")\n"); << getBlockName(Succ) << " (" << SuccWeight << ")\n");
HasLoopingSucc = true; HasLoopingSucc = true;
continue; continue;
} }
unsigned SuccLoopDepth = 0; unsigned SuccLoopDepth = 0;
if (MachineLoop *ExitLoop = MLI->getLoopFor(*SI)) { if (MachineLoop *ExitLoop = MLI->getLoopFor(Succ)) {
SuccLoopDepth = ExitLoop->getLoopDepth(); SuccLoopDepth = ExitLoop->getLoopDepth();
if (ExitLoop->contains(&L)) if (ExitLoop->contains(&L))
BlocksExitingToOuterLoop.insert(*I); BlocksExitingToOuterLoop.insert(MBB);
} }
BranchProbability SuccProb(SuccWeight / WeightScale, SumWeight); BranchProbability SuccProb(SuccWeight / WeightScale, SumWeight);
BlockFrequency ExitEdgeFreq = MBFI->getBlockFreq(*I) * SuccProb; BlockFrequency ExitEdgeFreq = MBFI->getBlockFreq(MBB) * SuccProb;
DEBUG(dbgs() << " exiting: " << getBlockName(*I) << " -> " DEBUG(dbgs() << " exiting: " << getBlockName(MBB) << " -> "
<< getBlockName(*SI) << " [L:" << SuccLoopDepth << "] ("; << getBlockName(Succ) << " [L:" << SuccLoopDepth << "] (";
MBFI->printBlockFreq(dbgs(), ExitEdgeFreq) << ")\n"); MBFI->printBlockFreq(dbgs(), ExitEdgeFreq) << ")\n");
// Note that we bias this toward an existing layout successor to retain // Note that we bias this toward an existing layout successor to retain
// incoming order in the absence of better information. The exit must have // incoming order in the absence of better information. The exit must have
@ -705,10 +693,10 @@ MachineBlockPlacement::findBestLoopExit(MachineFunction &F, MachineLoop &L,
BranchProbability Bias(100 - ExitBlockBias, 100); BranchProbability Bias(100 - ExitBlockBias, 100);
if (!ExitingBB || BestExitLoopDepth < SuccLoopDepth || if (!ExitingBB || BestExitLoopDepth < SuccLoopDepth ||
ExitEdgeFreq > BestExitEdgeFreq || ExitEdgeFreq > BestExitEdgeFreq ||
((*I)->isLayoutSuccessor(*SI) && (MBB->isLayoutSuccessor(Succ) &&
!(ExitEdgeFreq < BestExitEdgeFreq * Bias))) { !(ExitEdgeFreq < BestExitEdgeFreq * Bias))) {
BestExitEdgeFreq = ExitEdgeFreq; BestExitEdgeFreq = ExitEdgeFreq;
ExitingBB = *I; ExitingBB = MBB;
} }
} }
@ -749,12 +737,10 @@ void MachineBlockPlacement::rotateLoop(BlockChain &LoopChain,
MachineBasicBlock *Top = *LoopChain.begin(); MachineBasicBlock *Top = *LoopChain.begin();
bool ViableTopFallthrough = false; bool ViableTopFallthrough = false;
for (MachineBasicBlock::pred_iterator PI = Top->pred_begin(), for (MachineBasicBlock *Pred : Top->predecessors()) {
PE = Top->pred_end(); BlockChain *PredChain = BlockToChain[Pred];
PI != PE; ++PI) { if (!LoopBlockSet.count(Pred) &&
BlockChain *PredChain = BlockToChain[*PI]; (!PredChain || Pred == *std::prev(PredChain->end()))) {
if (!LoopBlockSet.count(*PI) &&
(!PredChain || *PI == *std::prev(PredChain->end()))) {
ViableTopFallthrough = true; ViableTopFallthrough = true;
break; break;
} }
@ -765,12 +751,10 @@ void MachineBlockPlacement::rotateLoop(BlockChain &LoopChain,
// introduce an unnecessary branch. // introduce an unnecessary branch.
if (ViableTopFallthrough) { if (ViableTopFallthrough) {
MachineBasicBlock *Bottom = *std::prev(LoopChain.end()); MachineBasicBlock *Bottom = *std::prev(LoopChain.end());
for (MachineBasicBlock::succ_iterator SI = Bottom->succ_begin(), for (MachineBasicBlock *Succ : Bottom->successors()) {
SE = Bottom->succ_end(); BlockChain *SuccChain = BlockToChain[Succ];
SI != SE; ++SI) { if (!LoopBlockSet.count(Succ) &&
BlockChain *SuccChain = BlockToChain[*SI]; (!SuccChain || Succ == *SuccChain->begin()))
if (!LoopBlockSet.count(*SI) &&
(!SuccChain || *SI == *SuccChain->begin()))
return; return;
} }
} }
@ -793,8 +777,8 @@ void MachineBlockPlacement::buildLoopChains(MachineFunction &F,
MachineLoop &L) { MachineLoop &L) {
// First recurse through any nested loops, building chains for those inner // First recurse through any nested loops, building chains for those inner
// loops. // loops.
for (MachineLoop::iterator LI = L.begin(), LE = L.end(); LI != LE; ++LI) for (MachineLoop *InnerLoop : L)
buildLoopChains(F, **LI); buildLoopChains(F, *InnerLoop);
SmallVector<MachineBasicBlock *, 16> BlockWorkList; SmallVector<MachineBasicBlock *, 16> BlockWorkList;
BlockFilterSet LoopBlockSet(L.block_begin(), L.block_end()); BlockFilterSet LoopBlockSet(L.block_begin(), L.block_end());
@ -820,20 +804,16 @@ void MachineBlockPlacement::buildLoopChains(MachineFunction &F,
SmallPtrSet<BlockChain *, 4> UpdatedPreds; SmallPtrSet<BlockChain *, 4> UpdatedPreds;
assert(LoopChain.LoopPredecessors == 0); assert(LoopChain.LoopPredecessors == 0);
UpdatedPreds.insert(&LoopChain); UpdatedPreds.insert(&LoopChain);
for (MachineLoop::block_iterator BI = L.block_begin(), BE = L.block_end(); for (MachineBasicBlock *LoopBB : L.getBlocks()) {
BI != BE; ++BI) { BlockChain &Chain = *BlockToChain[LoopBB];
BlockChain &Chain = *BlockToChain[*BI];
if (!UpdatedPreds.insert(&Chain).second) if (!UpdatedPreds.insert(&Chain).second)
continue; continue;
assert(Chain.LoopPredecessors == 0); assert(Chain.LoopPredecessors == 0);
for (BlockChain::iterator BCI = Chain.begin(), BCE = Chain.end(); for (MachineBasicBlock *ChainBB : Chain) {
BCI != BCE; ++BCI) { assert(BlockToChain[ChainBB] == &Chain);
assert(BlockToChain[*BCI] == &Chain); for (MachineBasicBlock *Pred : ChainBB->predecessors()) {
for (MachineBasicBlock::pred_iterator PI = (*BCI)->pred_begin(), if (BlockToChain[Pred] == &Chain || !LoopBlockSet.count(Pred))
PE = (*BCI)->pred_end();
PI != PE; ++PI) {
if (BlockToChain[*PI] == &Chain || !LoopBlockSet.count(*PI))
continue; continue;
++Chain.LoopPredecessors; ++Chain.LoopPredecessors;
} }
@ -855,29 +835,26 @@ void MachineBlockPlacement::buildLoopChains(MachineFunction &F,
<< " Loop header: " << getBlockName(*L.block_begin()) << "\n" << " Loop header: " << getBlockName(*L.block_begin()) << "\n"
<< " Chain header: " << getBlockName(*LoopChain.begin()) << "\n"; << " Chain header: " << getBlockName(*LoopChain.begin()) << "\n";
} }
for (BlockChain::iterator BCI = LoopChain.begin(), BCE = LoopChain.end(); for (MachineBasicBlock *ChainBB : LoopChain) {
BCI != BCE; ++BCI) { dbgs() << " ... " << getBlockName(ChainBB) << "\n";
dbgs() << " ... " << getBlockName(*BCI) << "\n"; if (!LoopBlockSet.erase(ChainBB)) {
if (!LoopBlockSet.erase(*BCI)) {
// We don't mark the loop as bad here because there are real situations // We don't mark the loop as bad here because there are real situations
// where this can occur. For example, with an unanalyzable fallthrough // where this can occur. For example, with an unanalyzable fallthrough
// from a loop block to a non-loop block or vice versa. // from a loop block to a non-loop block or vice versa.
dbgs() << "Loop chain contains a block not contained by the loop!\n" dbgs() << "Loop chain contains a block not contained by the loop!\n"
<< " Loop header: " << getBlockName(*L.block_begin()) << "\n" << " Loop header: " << getBlockName(*L.block_begin()) << "\n"
<< " Chain header: " << getBlockName(*LoopChain.begin()) << "\n" << " Chain header: " << getBlockName(*LoopChain.begin()) << "\n"
<< " Bad block: " << getBlockName(*BCI) << "\n"; << " Bad block: " << getBlockName(ChainBB) << "\n";
} }
} }
if (!LoopBlockSet.empty()) { if (!LoopBlockSet.empty()) {
BadLoop = true; BadLoop = true;
for (BlockFilterSet::iterator LBI = LoopBlockSet.begin(), for (MachineBasicBlock *LoopBB : LoopBlockSet)
LBE = LoopBlockSet.end();
LBI != LBE; ++LBI)
dbgs() << "Loop contains blocks never placed into a chain!\n" dbgs() << "Loop contains blocks never placed into a chain!\n"
<< " Loop header: " << getBlockName(*L.block_begin()) << "\n" << " Loop header: " << getBlockName(*L.block_begin()) << "\n"
<< " Chain header: " << getBlockName(*LoopChain.begin()) << "\n" << " Chain header: " << getBlockName(*LoopChain.begin()) << "\n"
<< " Bad block: " << getBlockName(*LBI) << "\n"; << " Bad block: " << getBlockName(LoopBB) << "\n";
} }
assert(!BadLoop && "Detected problems with the placement of this loop."); assert(!BadLoop && "Detected problems with the placement of this loop.");
}); });
@ -935,27 +912,22 @@ void MachineBlockPlacement::buildCFGChains(MachineFunction &F) {
} }
// Build any loop-based chains. // Build any loop-based chains.
for (MachineLoopInfo::iterator LI = MLI->begin(), LE = MLI->end(); LI != LE; for (MachineLoop *L : *MLI)
++LI) buildLoopChains(F, *L);
buildLoopChains(F, **LI);
SmallVector<MachineBasicBlock *, 16> BlockWorkList; SmallVector<MachineBasicBlock *, 16> BlockWorkList;
SmallPtrSet<BlockChain *, 4> UpdatedPreds; SmallPtrSet<BlockChain *, 4> UpdatedPreds;
for (MachineFunction::iterator FI = F.begin(), FE = F.end(); FI != FE; ++FI) { for (MachineBasicBlock &MBB : F) {
MachineBasicBlock *BB = &*FI; BlockChain &Chain = *BlockToChain[&MBB];
BlockChain &Chain = *BlockToChain[BB];
if (!UpdatedPreds.insert(&Chain).second) if (!UpdatedPreds.insert(&Chain).second)
continue; continue;
assert(Chain.LoopPredecessors == 0); assert(Chain.LoopPredecessors == 0);
for (BlockChain::iterator BCI = Chain.begin(), BCE = Chain.end(); for (MachineBasicBlock *ChainBB : Chain) {
BCI != BCE; ++BCI) { assert(BlockToChain[ChainBB] == &Chain);
assert(BlockToChain[*BCI] == &Chain); for (MachineBasicBlock *Pred : ChainBB->predecessors()) {
for (MachineBasicBlock::pred_iterator PI = (*BCI)->pred_begin(), if (BlockToChain[Pred] == &Chain)
PE = (*BCI)->pred_end();
PI != PE; ++PI) {
if (BlockToChain[*PI] == &Chain)
continue; continue;
++Chain.LoopPredecessors; ++Chain.LoopPredecessors;
} }
@ -975,46 +947,40 @@ void MachineBlockPlacement::buildCFGChains(MachineFunction &F) {
// Crash at the end so we get all of the debugging output first. // Crash at the end so we get all of the debugging output first.
bool BadFunc = false; bool BadFunc = false;
FunctionBlockSetType FunctionBlockSet; FunctionBlockSetType FunctionBlockSet;
for (MachineFunction::iterator FI = F.begin(), FE = F.end(); FI != FE; ++FI) for (MachineBasicBlock &MBB : F)
FunctionBlockSet.insert(FI); FunctionBlockSet.insert(&MBB);
for (BlockChain::iterator BCI = FunctionChain.begin(), for (MachineBasicBlock *ChainBB : FunctionChain)
BCE = FunctionChain.end(); if (!FunctionBlockSet.erase(ChainBB)) {
BCI != BCE; ++BCI)
if (!FunctionBlockSet.erase(*BCI)) {
BadFunc = true; BadFunc = true;
dbgs() << "Function chain contains a block not in the function!\n" dbgs() << "Function chain contains a block not in the function!\n"
<< " Bad block: " << getBlockName(*BCI) << "\n"; << " Bad block: " << getBlockName(ChainBB) << "\n";
} }
if (!FunctionBlockSet.empty()) { if (!FunctionBlockSet.empty()) {
BadFunc = true; BadFunc = true;
for (FunctionBlockSetType::iterator FBI = FunctionBlockSet.begin(), for (MachineBasicBlock *RemainingBB : FunctionBlockSet)
FBE = FunctionBlockSet.end();
FBI != FBE; ++FBI)
dbgs() << "Function contains blocks never placed into a chain!\n" dbgs() << "Function contains blocks never placed into a chain!\n"
<< " Bad block: " << getBlockName(*FBI) << "\n"; << " Bad block: " << getBlockName(RemainingBB) << "\n";
} }
assert(!BadFunc && "Detected problems with the block placement."); assert(!BadFunc && "Detected problems with the block placement.");
}); });
// Splice the blocks into place. // Splice the blocks into place.
MachineFunction::iterator InsertPos = F.begin(); MachineFunction::iterator InsertPos = F.begin();
for (BlockChain::iterator BI = FunctionChain.begin(), for (MachineBasicBlock *ChainBB : FunctionChain) {
BE = FunctionChain.end(); DEBUG(dbgs() << (ChainBB == *FunctionChain.begin() ? "Placing chain "
BI != BE; ++BI) {
DEBUG(dbgs() << (BI == FunctionChain.begin() ? "Placing chain "
: " ... ") : " ... ")
<< getBlockName(*BI) << "\n"); << getBlockName(ChainBB) << "\n");
if (InsertPos != MachineFunction::iterator(*BI)) if (InsertPos != MachineFunction::iterator(ChainBB))
F.splice(InsertPos, *BI); F.splice(InsertPos, ChainBB);
else else
++InsertPos; ++InsertPos;
// Update the terminator of the previous block. // Update the terminator of the previous block.
if (BI == FunctionChain.begin()) if (ChainBB == *FunctionChain.begin())
continue; continue;
MachineBasicBlock *PrevBB = std::prev(MachineFunction::iterator(*BI)); MachineBasicBlock *PrevBB = std::prev(MachineFunction::iterator(ChainBB));
// FIXME: It would be awesome of updateTerminator would just return rather // FIXME: It would be awesome of updateTerminator would just return rather
// than assert when the branch cannot be analyzed in order to remove this // than assert when the branch cannot be analyzed in order to remove this
@ -1033,7 +999,7 @@ void MachineBlockPlacement::buildCFGChains(MachineFunction &F) {
// is mistakenly pointing to "*BI". // is mistakenly pointing to "*BI".
// //
bool needUpdateBr = true; bool needUpdateBr = true;
if (!Cond.empty() && (!FBB || FBB == *BI)) { if (!Cond.empty() && (!FBB || FBB == ChainBB)) {
PrevBB->updateTerminator(); PrevBB->updateTerminator();
needUpdateBr = false; needUpdateBr = false;
Cond.clear(); Cond.clear();
@ -1082,14 +1048,15 @@ void MachineBlockPlacement::buildCFGChains(MachineFunction &F) {
const BranchProbability ColdProb(1, 5); // 20% const BranchProbability ColdProb(1, 5); // 20%
BlockFrequency EntryFreq = MBFI->getBlockFreq(F.begin()); BlockFrequency EntryFreq = MBFI->getBlockFreq(F.begin());
BlockFrequency WeightedEntryFreq = EntryFreq * ColdProb; BlockFrequency WeightedEntryFreq = EntryFreq * ColdProb;
for (BlockChain::iterator BI = std::next(FunctionChain.begin()), for (MachineBasicBlock *ChainBB : FunctionChain) {
BE = FunctionChain.end(); if (ChainBB == *FunctionChain.begin())
BI != BE; ++BI) { continue;
// Don't align non-looping basic blocks. These are unlikely to execute // Don't align non-looping basic blocks. These are unlikely to execute
// enough times to matter in practice. Note that we'll still handle // enough times to matter in practice. Note that we'll still handle
// unnatural CFGs inside of a natural outer loop (the common case) and // unnatural CFGs inside of a natural outer loop (the common case) and
// rotated loops. // rotated loops.
MachineLoop *L = MLI->getLoopFor(*BI); MachineLoop *L = MLI->getLoopFor(ChainBB);
if (!L) if (!L)
continue; continue;
@ -1099,7 +1066,7 @@ void MachineBlockPlacement::buildCFGChains(MachineFunction &F) {
// If the block is cold relative to the function entry don't waste space // If the block is cold relative to the function entry don't waste space
// aligning it. // aligning it.
BlockFrequency Freq = MBFI->getBlockFreq(*BI); BlockFrequency Freq = MBFI->getBlockFreq(ChainBB);
if (Freq < WeightedEntryFreq) if (Freq < WeightedEntryFreq)
continue; continue;
@ -1112,12 +1079,13 @@ void MachineBlockPlacement::buildCFGChains(MachineFunction &F) {
// Check for the existence of a non-layout predecessor which would benefit // Check for the existence of a non-layout predecessor which would benefit
// from aligning this block. // from aligning this block.
MachineBasicBlock *LayoutPred = *std::prev(BI); MachineBasicBlock *LayoutPred =
&*std::prev(MachineFunction::iterator(ChainBB));
// Force alignment if all the predecessors are jumps. We already checked // Force alignment if all the predecessors are jumps. We already checked
// that the block isn't cold above. // that the block isn't cold above.
if (!LayoutPred->isSuccessor(*BI)) { if (!LayoutPred->isSuccessor(ChainBB)) {
(*BI)->setAlignment(Align); ChainBB->setAlignment(Align);
continue; continue;
} }
@ -1125,10 +1093,11 @@ void MachineBlockPlacement::buildCFGChains(MachineFunction &F) {
// cold relative to the block. When this is true, other predecessors make up // cold relative to the block. When this is true, other predecessors make up
// all of the hot entries into the block and thus alignment is likely to be // all of the hot entries into the block and thus alignment is likely to be
// important. // important.
BranchProbability LayoutProb = MBPI->getEdgeProbability(LayoutPred, *BI); BranchProbability LayoutProb =
MBPI->getEdgeProbability(LayoutPred, ChainBB);
BlockFrequency LayoutEdgeFreq = MBFI->getBlockFreq(LayoutPred) * LayoutProb; BlockFrequency LayoutEdgeFreq = MBFI->getBlockFreq(LayoutPred) * LayoutProb;
if (LayoutEdgeFreq <= (Freq * ColdProb)) if (LayoutEdgeFreq <= (Freq * ColdProb))
(*BI)->setAlignment(Align); ChainBB->setAlignment(Align);
} }
} }
@ -1155,8 +1124,8 @@ bool MachineBlockPlacement::runOnMachineFunction(MachineFunction &F) {
if (AlignAllBlock) if (AlignAllBlock)
// Align all of the blocks in the function to a specific alignment. // Align all of the blocks in the function to a specific alignment.
for (MachineFunction::iterator FI = F.begin(), FE = F.end(); FI != FE; ++FI) for (MachineBasicBlock &MBB : F)
FI->setAlignment(AlignAllBlock); MBB.setAlignment(AlignAllBlock);
// We always return true as we have no way to track whether the final order // We always return true as we have no way to track whether the final order
// differs from the original order. // differs from the original order.
@ -1211,20 +1180,19 @@ bool MachineBlockPlacementStats::runOnMachineFunction(MachineFunction &F) {
MBPI = &getAnalysis<MachineBranchProbabilityInfo>(); MBPI = &getAnalysis<MachineBranchProbabilityInfo>();
MBFI = &getAnalysis<MachineBlockFrequencyInfo>(); MBFI = &getAnalysis<MachineBlockFrequencyInfo>();
for (MachineFunction::iterator I = F.begin(), E = F.end(); I != E; ++I) { for (MachineBasicBlock &MBB : F) {
BlockFrequency BlockFreq = MBFI->getBlockFreq(I); BlockFrequency BlockFreq = MBFI->getBlockFreq(&MBB);
Statistic &NumBranches = Statistic &NumBranches =
(I->succ_size() > 1) ? NumCondBranches : NumUncondBranches; (MBB.succ_size() > 1) ? NumCondBranches : NumUncondBranches;
Statistic &BranchTakenFreq = Statistic &BranchTakenFreq =
(I->succ_size() > 1) ? CondBranchTakenFreq : UncondBranchTakenFreq; (MBB.succ_size() > 1) ? CondBranchTakenFreq : UncondBranchTakenFreq;
for (MachineBasicBlock::succ_iterator SI = I->succ_begin(), for (MachineBasicBlock *Succ : MBB.successors()) {
SE = I->succ_end();
SI != SE; ++SI) {
// Skip if this successor is a fallthrough. // Skip if this successor is a fallthrough.
if (I->isLayoutSuccessor(*SI)) if (MBB.isLayoutSuccessor(Succ))
continue; continue;
BlockFrequency EdgeFreq = BlockFreq * MBPI->getEdgeProbability(I, *SI); BlockFrequency EdgeFreq =
BlockFreq * MBPI->getEdgeProbability(&MBB, Succ);
++NumBranches; ++NumBranches;
BranchTakenFreq += EdgeFreq.getFrequency(); BranchTakenFreq += EdgeFreq.getFrequency();
} }