Members/tobaru/cbc/CbC_llvm: lib/CodeGen/MachineBlockPlacement.cpp comparison

comparison lib/CodeGen/MachineBlockPlacement.cpp @ 77:54457678186b

LLVM 3.6

author	Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
date	Mon, 08 Sep 2014 22:06:00 +0900
parents	e4204d083e25
children	60c9769439b8

comparison

equal deleted inserted replaced

-:e874dbf0ad9d
+:54457678186b
 // first time it reaches a chain of basic blocks, it schedules them in the
 // function in-order.
 //
 //===----------------------------------------------------------------------===//
-#define DEBUG_TYPE "block-placement2"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetLowering.h"
+#include "llvm/Target/TargetSubtargetInfo.h"
 #include <algorithm>
 using namespace llvm;
+#define DEBUG_TYPE "block-placement2"
 STATISTIC(NumCondBranches, "Number of conditional branches");
 STATISTIC(NumUncondBranches, "Number of uncondittional branches");
 STATISTIC(CondBranchTakenFreq,
 "Potential frequency of taking conditional branches");
 }
 }
 #ifndef NDEBUG
 /// \brief Dump the blocks in this chain.
-void dump() LLVM_ATTRIBUTE_USED {
+LLVM_DUMP_METHOD void dump() {
 for (iterator I = begin(), E = end(); I != E; ++I)
 (*I)->dump();
 }
 #endif // NDEBUG
 DenseMap<MachineBasicBlock *, BlockChain *> BlockToChain;
 void markChainSuccessors(BlockChain &Chain,
 MachineBasicBlock *LoopHeaderBB,
 SmallVectorImpl<MachineBasicBlock *> &BlockWorkList,
-const BlockFilterSet *BlockFilter = 0);
+const BlockFilterSet *BlockFilter = nullptr);
 MachineBasicBlock *selectBestSuccessor(MachineBasicBlock *BB,
 BlockChain &Chain,
 const BlockFilterSet *BlockFilter);
 MachineBasicBlock *selectBestCandidateBlock(
 BlockChain &Chain, SmallVectorImpl<MachineBasicBlock *> &WorkList,
 const BlockChain &PlacedChain,
 MachineFunction::iterator &PrevUnplacedBlockIt,
 const BlockFilterSet *BlockFilter);
 void buildChain(MachineBasicBlock *BB, BlockChain &Chain,
 SmallVectorImpl<MachineBasicBlock *> &BlockWorkList,
-const BlockFilterSet *BlockFilter = 0);
+const BlockFilterSet *BlockFilter = nullptr);
 MachineBasicBlock *findBestLoopTop(MachineLoop &L,
 const BlockFilterSet &LoopBlockSet);
 MachineBasicBlock *findBestLoopExit(MachineFunction &F,
 MachineLoop &L,
 const BlockFilterSet &LoopBlockSet);
 static char ID; // Pass identification, replacement for typeid
 MachineBlockPlacement() : MachineFunctionPass(ID) {
 initializeMachineBlockPlacementPass(*PassRegistry::getPassRegistry());
 }
-bool runOnMachineFunction(MachineFunction &F);
+bool runOnMachineFunction(MachineFunction &F) override;
-void getAnalysisUsage(AnalysisUsage &AU) const {
+void getAnalysisUsage(AnalysisUsage &AU) const override {
 AU.addRequired<MachineBranchProbabilityInfo>();
 AU.addRequired<MachineBlockFrequencyInfo>();
 AU.addRequired<MachineLoopInfo>();
 MachineFunctionPass::getAnalysisUsage(AU);
 }
 MachineBasicBlock *MachineBlockPlacement::selectBestSuccessor(
 MachineBasicBlock *BB, BlockChain &Chain,
 const BlockFilterSet *BlockFilter) {
 const BranchProbability HotProb(4, 5); // 80%
-MachineBasicBlock *BestSucc = 0;
+MachineBasicBlock *BestSucc = nullptr;
 // FIXME: Due to the performance of the probability and weight routines in
 // the MBPI analysis, we manually compute probabilities using the edge
 // weights. This is suboptimal as it means that the somewhat subtle
 // definition of edge weight semantics is encoded here as well. We should
 // improve the MBPI interface to efficiently support query patterns such as
 BestWeight = SuccWeight;
 }
 return BestSucc;
 }
-namespace {
-/// \brief Predicate struct to detect blocks already placed.
-class IsBlockPlaced {
-const BlockChain &PlacedChain;
-const BlockToChainMapType &BlockToChain;
-public:
-IsBlockPlaced(const BlockChain &PlacedChain,
-const BlockToChainMapType &BlockToChain)
-: PlacedChain(PlacedChain), BlockToChain(BlockToChain) {}
-bool operator()(MachineBasicBlock *BB) const {
-return BlockToChain.lookup(BB) == &PlacedChain;
-}
-};
-}
 /// \brief Select the best block from a worklist.
 ///
 /// This looks through the provided worklist as a list of candidate basic
 /// blocks and select the most profitable one to place. The definition of
 /// profitable only really makes sense in the context of a loop. This returns
 // Once we need to walk the worklist looking for a candidate, cleanup the
 // worklist of already placed entries.
 // FIXME: If this shows up on profiles, it could be folded (at the cost of
 // some code complexity) into the loop below.
 WorkList.erase(std::remove_if(WorkList.begin(), WorkList.end(),
-IsBlockPlaced(Chain, BlockToChain)),
+[&](MachineBasicBlock *BB) {
+return BlockToChain.lookup(BB) == &Chain;
+}),
 WorkList.end());
-MachineBasicBlock *BestBlock = 0;
+MachineBasicBlock *BestBlock = nullptr;
 BlockFrequency BestFreq;
 for (SmallVectorImpl<MachineBasicBlock *>::iterator WBI = WorkList.begin(),
 WBE = WorkList.end();
 WBI != WBE; ++WBI) {
 BlockChain &SuccChain = *BlockToChain[*WBI];
 continue;
 }
 assert(SuccChain.LoopPredecessors == 0 && "Found CFG-violating block");
 BlockFrequency CandidateFreq = MBFI->getBlockFreq(*WBI);
-DEBUG(dbgs() << "    " << getBlockName(*WBI) << " -> " << CandidateFreq
+DEBUG(dbgs() << "    " << getBlockName(*WBI) << " -> ";
-<< " (freq)\n");
+MBFI->printBlockFreq(dbgs(), CandidateFreq) << " (freq)\n");
 if (BestBlock && BestFreq >= CandidateFreq)
 continue;
 BestBlock = *WBI;
 BestFreq = CandidateFreq;
 }
 // as the block to place. This will force the entire chain to be placed,
 // and satisfies the requirements of merging chains.
 return *BlockToChain[I]->begin();
 }
 }
-return 0;
+return nullptr;
 }
 void MachineBlockPlacement::buildChain(
 MachineBasicBlock *BB,
 BlockChain &Chain,
 MachineFunction &F = *BB->getParent();
 MachineFunction::iterator PrevUnplacedBlockIt = F.begin();
 MachineBasicBlock *LoopHeaderBB = BB;
 markChainSuccessors(Chain, LoopHeaderBB, BlockWorkList, BlockFilter);
-BB = *llvm::prior(Chain.end());
+BB = *std::prev(Chain.end());
 for (;;) {
 assert(BB);
 assert(BlockToChain[BB] == &Chain);
-assert(*llvm::prior(Chain.end()) == BB);
+assert(*std::prev(Chain.end()) == BB);
 // Look for the best viable successor if there is one to place immediately
 // after this block.
 MachineBasicBlock *BestSucc = selectBestSuccessor(BB, Chain, BlockFilter);
 SuccChain.LoopPredecessors = 0;
 DEBUG(dbgs() << "Merging from " << getBlockNum(BB)
 << " to " << getBlockNum(BestSucc) << "\n");
 markChainSuccessors(SuccChain, LoopHeaderBB, BlockWorkList, BlockFilter);
 Chain.merge(BestSucc, &SuccChain);
-BB = *llvm::prior(Chain.end());
+BB = *std::prev(Chain.end());
 }
 DEBUG(dbgs() << "Finished forming chain for header block "
 << getBlockNum(*Chain.begin()) << "\n");
 }
 DEBUG(dbgs() << "Finding best loop top for: "
 << getBlockName(L.getHeader()) << "\n");
 BlockFrequency BestPredFreq;
-MachineBasicBlock *BestPred = 0;
+MachineBasicBlock *BestPred = nullptr;
 for (MachineBasicBlock::pred_iterator PI = L.getHeader()->pred_begin(),
 PE = L.getHeader()->pred_end();
 PI != PE; ++PI) {
 MachineBasicBlock *Pred = *PI;
 if (!LoopBlockSet.count(Pred))
 continue;
 DEBUG(dbgs() << "    header pred: " << getBlockName(Pred) << ", "
-<< Pred->succ_size() << " successors, "
+<< Pred->succ_size() << " successors, ";
-<< MBFI->getBlockFreq(Pred) << " freq\n");
+MBFI->printBlockFreq(dbgs(), Pred) << " freq\n");
 if (Pred->succ_size() > 1)
 continue;
 BlockFrequency PredFreq = MBFI->getBlockFreq(Pred);
 if (!BestPred || PredFreq > BestPredFreq ||
 // of the loop, rotating the header into the middle of the loop will create
 // a non-contiguous range of blocks which is Very Bad. So start with the
 // header and only rotate if safe.
 BlockChain &HeaderChain = *BlockToChain[L.getHeader()];
 if (!LoopBlockSet.count(*HeaderChain.begin()))
-return 0;
+return nullptr;
 BlockFrequency BestExitEdgeFreq;
 unsigned BestExitLoopDepth = 0;
-MachineBasicBlock *ExitingBB = 0;
+MachineBasicBlock *ExitingBB = nullptr;
 // If there are exits to outer loops, loop rotation can severely limit
 // fallthrough opportunites unless it selects such an exit. Keep a set of
 // blocks where rotating to exit with that block will reach an outer loop.
 SmallPtrSet<MachineBasicBlock *, 4> BlocksExitingToOuterLoop;
 E = L.block_end();
 I != E; ++I) {
 BlockChain &Chain = *BlockToChain[*I];
 // 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.
-if (*I != *llvm::prior(Chain.end()))
+if (*I != *std::prev(Chain.end()))
 continue;
 // Now walk the successors. We need to establish whether this has a viable
 // exiting successor and whether it has a viable non-exiting successor.
 // We store the old exiting state and restore it if a viable looping
 BranchProbability SuccProb(SuccWeight / WeightScale, SumWeight);
 BlockFrequency ExitEdgeFreq = MBFI->getBlockFreq(*I) * SuccProb;
 DEBUG(dbgs() << "    exiting: " << getBlockName(*I) << " -> "
 << getBlockName(*SI) << " [L:" << SuccLoopDepth
-<< "] (" << ExitEdgeFreq << ")\n");
+<< "] (";
+MBFI->printBlockFreq(dbgs(), ExitEdgeFreq) << ")\n");
 // Note that we bias this toward an existing layout successor to retain
 // incoming order in the absence of better information. The exit must have
 // a frequency higher than the current exit before we consider breaking
 // the layout.
 BranchProbability Bias(100 - ExitBlockBias, 100);
 }
 }
 // Without a candidate exiting block or with only a single block in the
 // loop, just use the loop header to layout the loop.
 if (!ExitingBB || L.getNumBlocks() == 1)
-return 0;
+return nullptr;
 // Also, if we have exit blocks which lead to outer loops but didn't select
 // one of them as the exiting block we are rotating toward, disable loop
 // rotation altogether.
 if (!BlocksExitingToOuterLoop.empty() &&
 !BlocksExitingToOuterLoop.count(ExitingBB))
-return 0;
+return nullptr;
 DEBUG(dbgs() << "  Best exiting block: " << getBlockName(ExitingBB) << "\n");
 return ExitingBB;
 }
 for (MachineBasicBlock::pred_iterator PI = Top->pred_begin(),
 PE = Top->pred_end();
 PI != PE; ++PI) {
 BlockChain *PredChain = BlockToChain[*PI];
 if (!LoopBlockSet.count(*PI) &&
-(!PredChain || *PI == *llvm::prior(PredChain->end()))) {
+(!PredChain || *PI == *std::prev(PredChain->end()))) {
 ViableTopFallthrough = true;
 break;
 }
 }
 // If the header has viable fallthrough, check whether the current loop
 // bottom is a viable exiting block. If so, bail out as rotating will
 // introduce an unnecessary branch.
 if (ViableTopFallthrough) {
-MachineBasicBlock *Bottom = *llvm::prior(LoopChain.end());
+MachineBasicBlock *Bottom = *std::prev(LoopChain.end());
 for (MachineBasicBlock::succ_iterator SI = Bottom->succ_begin(),
 SE = Bottom->succ_end();
 SI != SE; ++SI) {
 BlockChain *SuccChain = BlockToChain[*SI];
 if (!LoopBlockSet.count(*SI) &&
 BlockChain::iterator ExitIt = std::find(LoopChain.begin(), LoopChain.end(),
 ExitingBB);
 if (ExitIt == LoopChain.end())
 return;
-std::rotate(LoopChain.begin(), llvm::next(ExitIt), LoopChain.end());
+std::rotate(LoopChain.begin(), std::next(ExitIt), LoopChain.end());
 }
 /// \brief Forms basic block chains from the natural loop structures.
 ///
 /// These chains are designed to preserve the existing *structure* of the code
 MachineBasicBlock *LoopTop = findBestLoopTop(L, LoopBlockSet);
 // If we selected just the header for the loop top, look for a potentially
 // profitable exit block in the event that rotating the loop can eliminate
 // branches by placing an exit edge at the bottom.
-MachineBasicBlock *ExitingBB = 0;
+MachineBasicBlock *ExitingBB = nullptr;
 if (LoopTop == L.getHeader())
 ExitingBB = findBestLoopExit(F, L, LoopBlockSet);
 BlockChain &LoopChain = *BlockToChain[LoopTop];
 = new (ChainAllocator.Allocate()) BlockChain(BlockToChain, BB);
 // Also, merge any blocks which we cannot reason about and must preserve
 // the exact fallthrough behavior for.
 for (;;) {
 Cond.clear();
-MachineBasicBlock *TBB = 0, *FBB = 0; // For AnalyzeBranch.
+MachineBasicBlock *TBB = nullptr, *FBB = nullptr; // For AnalyzeBranch.
 if (!TII->AnalyzeBranch(*BB, TBB, FBB, Cond) || !FI->canFallThrough())
 break;
-MachineFunction::iterator NextFI(llvm::next(FI));
+MachineFunction::iterator NextFI(std::next(FI));
 MachineBasicBlock *NextBB = NextFI;
 // Ensure that the layout successor is a viable block, as we know that
 // fallthrough is a possibility.
 assert(NextFI != FE && "Can't fallthrough past the last block.");
 DEBUG(dbgs() << "Pre-merging due to unanalyzable fallthrough: "
 << getBlockName(BB) << " -> " << getBlockName(NextBB)
 << "\n");
-Chain->merge(NextBB, 0);
+Chain->merge(NextBB, nullptr);
 FI = NextFI;
 BB = NextBB;
 }
 }
 ++InsertPos;
 // Update the terminator of the previous block.
 if (BI == FunctionChain.begin())
 continue;
-MachineBasicBlock *PrevBB = llvm::prior(MachineFunction::iterator(*BI));
+MachineBasicBlock *PrevBB = std::prev(MachineFunction::iterator(*BI));
 // FIXME: It would be awesome of updateTerminator would just return rather
 // than assert when the branch cannot be analyzed in order to remove this
 // boiler plate.
 Cond.clear();
-MachineBasicBlock *TBB = 0, *FBB = 0; // For AnalyzeBranch.
+MachineBasicBlock *TBB = nullptr, *FBB = nullptr; // For AnalyzeBranch.
 if (!TII->AnalyzeBranch(*PrevBB, TBB, FBB, Cond)) {
 // The "PrevBB" is not yet updated to reflect current code layout, so,
 //   o. it may fall-through to a block without explict "goto" instruction
 //      before layout, and no longer fall-through it after layout; or
 //   o. just opposite.
 bool needUpdateBr = true;
 if (!Cond.empty() && (!FBB || FBB == *BI)) {
 PrevBB->updateTerminator();
 needUpdateBr = false;
 Cond.clear();
-TBB = FBB = 0;
+TBB = FBB = nullptr;
 if (TII->AnalyzeBranch(*PrevBB, TBB, FBB, Cond)) {
 // FIXME: This should never take place.
-TBB = FBB = 0;
+TBB = FBB = nullptr;
 }
 }
 // If PrevBB has a two-way branch, try to re-order the branches
 // such that we branch to the successor with higher weight first.
 }
 }
 // Fixup the last block.
 Cond.clear();
-MachineBasicBlock *TBB = 0, *FBB = 0; // For AnalyzeBranch.
+MachineBasicBlock *TBB = nullptr, *FBB = nullptr; // For AnalyzeBranch.
 if (!TII->AnalyzeBranch(F.back(), TBB, FBB, Cond))
 F.back().updateTerminator();
 // Walk through the backedges of the function now that we have fully laid out
 // the basic blocks and align the destination of each backedge. We don't rely
 return;  // Empty chain.
 const BranchProbability ColdProb(1, 5); // 20%
 BlockFrequency EntryFreq = MBFI->getBlockFreq(F.begin());
 BlockFrequency WeightedEntryFreq = EntryFreq * ColdProb;
-for (BlockChain::iterator BI = llvm::next(FunctionChain.begin()),
+for (BlockChain::iterator BI = std::next(FunctionChain.begin()),
 BE = FunctionChain.end();
 BI != BE; ++BI) {
 // Don't align non-looping basic blocks. These are unlikely to execute
 // enough times to matter in practice. Note that we'll still handle
 // unnatural CFGs inside of a natural outer loop (the common case) and
 if (Freq < (LoopHeaderFreq * ColdProb))
 continue;
 // Check for the existence of a non-layout predecessor which would benefit
 // from aligning this block.
-MachineBasicBlock *LayoutPred = *llvm::prior(BI);
+MachineBasicBlock *LayoutPred = *std::prev(BI);
 // Force alignment if all the predecessors are jumps. We already checked
 // that the block isn't cold above.
 if (!LayoutPred->isSuccessor(*BI)) {
 (*BI)->setAlignment(Align);
 }
 }
 bool MachineBlockPlacement::runOnMachineFunction(MachineFunction &F) {
 // Check for single-block functions and skip them.
-if (llvm::next(F.begin()) == F.end())
+if (std::next(F.begin()) == F.end())
+return false;
+if (skipOptnoneFunction(*F.getFunction()))
 return false;
 MBPI = &getAnalysis<MachineBranchProbabilityInfo>();
 MBFI = &getAnalysis<MachineBlockFrequencyInfo>();
 MLI = &getAnalysis<MachineLoopInfo>();
-TII = F.getTarget().getInstrInfo();
+TII = F.getSubtarget().getInstrInfo();
-TLI = F.getTarget().getTargetLowering();
+TLI = F.getSubtarget().getTargetLowering();
 assert(BlockToChain.empty());
 buildCFGChains(F);
 BlockToChain.clear();
 static char ID; // Pass identification, replacement for typeid
 MachineBlockPlacementStats() : MachineFunctionPass(ID) {
 initializeMachineBlockPlacementStatsPass(*PassRegistry::getPassRegistry());
 }
-bool runOnMachineFunction(MachineFunction &F);
+bool runOnMachineFunction(MachineFunction &F) override;
-void getAnalysisUsage(AnalysisUsage &AU) const {
+void getAnalysisUsage(AnalysisUsage &AU) const override {
 AU.addRequired<MachineBranchProbabilityInfo>();
 AU.addRequired<MachineBlockFrequencyInfo>();
 AU.setPreservesAll();
 MachineFunctionPass::getAnalysisUsage(AU);
 }
 INITIALIZE_PASS_END(MachineBlockPlacementStats, "block-placement-stats",
 "Basic Block Placement Stats", false, false)
 bool MachineBlockPlacementStats::runOnMachineFunction(MachineFunction &F) {
 // Check for single-block functions and skip them.
-if (llvm::next(F.begin()) == F.end())
+if (std::next(F.begin()) == F.end())
 return false;
 MBPI = &getAnalysis<MachineBranchProbabilityInfo>();
 MBFI = &getAnalysis<MachineBlockFrequencyInfo>();

Mercurial > hg > Members > tobaru > cbc > CbC_llvm

comparison lib/CodeGen/MachineBlockPlacement.cpp @ 77:54457678186b