RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 03:02:36 +01:00
Code Issues Projects Releases Wiki Activity

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

Browse Source 
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 57083c3412
commit 5fb5d9fc63
1 changed files with 108 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

248
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(ChainBB) << "\n");
: " ... ") if (InsertPos != MachineFunction::iterator(ChainBB))
<< getBlockName(*BI) << "\n"); F.splice(InsertPos, ChainBB);
if (InsertPos != MachineFunction::iterator(*BI))
F.splice(InsertPos, *BI);
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();
} }