// Check that 'BB' doesn't have any uses outside of the 'L' static bool isBlockInLCSSAForm(const Loop &L, const BasicBlock &BB, DominatorTree &DT) { for (const Instruction &I : BB) { // Tokens can't be used in PHI nodes and live-out tokens prevent loop // optimizations, so for the purposes of considered LCSSA form, we // can ignore them. if (I.getType()->isTokenTy()) continue; for (const Use &U : I.uses()) { const Instruction *UI = cast<Instruction>(U.getUser()); const BasicBlock *UserBB = UI->getParent(); if (const PHINode *P = dyn_cast<PHINode>(UI)) UserBB = P->getIncomingBlock(U); // Check the current block, as a fast-path, before checking whether // the use is anywhere in the loop. Most values are used in the same // block they are defined in. Also, blocks not reachable from the // entry are special; uses in them don't need to go through PHIs. if (UserBB != &BB && !L.contains(UserBB) && DT.isReachableFromEntry(UserBB)) return false; } } return true; }
/// isLCSSAForm - Return true if the Loop is in LCSSA form bool Loop::isLCSSAForm(DominatorTree &DT) const { // Sort the blocks vector so that we can use binary search to do quick // lookups. SmallPtrSet<BasicBlock*, 16> LoopBBs(block_begin(), block_end()); for (block_iterator BI = block_begin(), E = block_end(); BI != E; ++BI) { BasicBlock *BB = *BI; for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E;++I) for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E; ++UI) { User *U = *UI; BasicBlock *UserBB = cast<Instruction>(U)->getParent(); if (PHINode *P = dyn_cast<PHINode>(U)) UserBB = P->getIncomingBlock(UI); // Check the current block, as a fast-path, before checking whether // the use is anywhere in the loop. Most values are used in the same // block they are defined in. Also, blocks not reachable from the // entry are special; uses in them don't need to go through PHIs. if (UserBB != BB && !LoopBBs.count(UserBB) && DT.isReachableFromEntry(UserBB)) return false; } } return true; }
static bool ProcessBlock(BasicBlock &BB, DominatorTree &DT, LoopInfo &LI, AAResults &AA) { // Can't sink anything out of a block that has less than two successors. if (BB.getTerminator()->getNumSuccessors() <= 1) return false; // Don't bother sinking code out of unreachable blocks. In addition to being // unprofitable, it can also lead to infinite looping, because in an // unreachable loop there may be nowhere to stop. if (!DT.isReachableFromEntry(&BB)) return false; bool MadeChange = false; // Walk the basic block bottom-up. Remember if we saw a store. BasicBlock::iterator I = BB.end(); --I; bool ProcessedBegin = false; SmallPtrSet<Instruction *, 8> Stores; do { Instruction *Inst = &*I; // The instruction to sink. // Predecrement I (if it's not begin) so that it isn't invalidated by // sinking. ProcessedBegin = I == BB.begin(); if (!ProcessedBegin) --I; if (isa<DbgInfoIntrinsic>(Inst)) continue; if (SinkInstruction(Inst, Stores, DT, LI, AA)) { ++NumSunk; MadeChange = true; } // If we just processed the first instruction in the block, we're done. } while (!ProcessedBegin); return MadeChange; }
/// isLCSSAForm - Return true if the Loop is in LCSSA form bool Loop::isLCSSAForm(DominatorTree &DT) const { for (block_iterator BI = block_begin(), E = block_end(); BI != E; ++BI) { BasicBlock *BB = *BI; for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E;++I) for (Use &U : I->uses()) { Instruction *UI = cast<Instruction>(U.getUser()); BasicBlock *UserBB = UI->getParent(); if (PHINode *P = dyn_cast<PHINode>(UI)) UserBB = P->getIncomingBlock(U); // Check the current block, as a fast-path, before checking whether // the use is anywhere in the loop. Most values are used in the same // block they are defined in. Also, blocks not reachable from the // entry are special; uses in them don't need to go through PHIs. if (UserBB != BB && !contains(UserBB) && DT.isReachableFromEntry(UserBB)) return false; } } return true; }
/// Given \p BBs as input, find another set of BBs which collectively /// dominates \p BBs and have the minimal sum of frequencies. Return the BB /// set found in \p BBs. static void findBestInsertionSet(DominatorTree &DT, BlockFrequencyInfo &BFI, BasicBlock *Entry, SmallPtrSet<BasicBlock *, 8> &BBs) { assert(!BBs.count(Entry) && "Assume Entry is not in BBs"); // Nodes on the current path to the root. SmallPtrSet<BasicBlock *, 8> Path; // Candidates includes any block 'BB' in set 'BBs' that is not strictly // dominated by any other blocks in set 'BBs', and all nodes in the path // in the dominator tree from Entry to 'BB'. SmallPtrSet<BasicBlock *, 16> Candidates; for (auto BB : BBs) { // Ignore unreachable basic blocks. if (!DT.isReachableFromEntry(BB)) continue; Path.clear(); // Walk up the dominator tree until Entry or another BB in BBs // is reached. Insert the nodes on the way to the Path. BasicBlock *Node = BB; // The "Path" is a candidate path to be added into Candidates set. bool isCandidate = false; do { Path.insert(Node); if (Node == Entry || Candidates.count(Node)) { isCandidate = true; break; } assert(DT.getNode(Node)->getIDom() && "Entry doens't dominate current Node"); Node = DT.getNode(Node)->getIDom()->getBlock(); } while (!BBs.count(Node)); // If isCandidate is false, Node is another Block in BBs dominating // current 'BB'. Drop the nodes on the Path. if (!isCandidate) continue; // Add nodes on the Path into Candidates. Candidates.insert(Path.begin(), Path.end()); } // Sort the nodes in Candidates in top-down order and save the nodes // in Orders. unsigned Idx = 0; SmallVector<BasicBlock *, 16> Orders; Orders.push_back(Entry); while (Idx != Orders.size()) { BasicBlock *Node = Orders[Idx++]; for (auto ChildDomNode : DT.getNode(Node)->getChildren()) { if (Candidates.count(ChildDomNode->getBlock())) Orders.push_back(ChildDomNode->getBlock()); } } // Visit Orders in bottom-up order. using InsertPtsCostPair = std::pair<SmallPtrSet<BasicBlock *, 16>, BlockFrequency>; // InsertPtsMap is a map from a BB to the best insertion points for the // subtree of BB (subtree not including the BB itself). DenseMap<BasicBlock *, InsertPtsCostPair> InsertPtsMap; InsertPtsMap.reserve(Orders.size() + 1); for (auto RIt = Orders.rbegin(); RIt != Orders.rend(); RIt++) { BasicBlock *Node = *RIt; bool NodeInBBs = BBs.count(Node); SmallPtrSet<BasicBlock *, 16> &InsertPts = InsertPtsMap[Node].first; BlockFrequency &InsertPtsFreq = InsertPtsMap[Node].second; // Return the optimal insert points in BBs. if (Node == Entry) { BBs.clear(); if (InsertPtsFreq > BFI.getBlockFreq(Node) || (InsertPtsFreq == BFI.getBlockFreq(Node) && InsertPts.size() > 1)) BBs.insert(Entry); else BBs.insert(InsertPts.begin(), InsertPts.end()); break; } BasicBlock *Parent = DT.getNode(Node)->getIDom()->getBlock(); // Initially, ParentInsertPts is empty and ParentPtsFreq is 0. Every child // will update its parent's ParentInsertPts and ParentPtsFreq. SmallPtrSet<BasicBlock *, 16> &ParentInsertPts = InsertPtsMap[Parent].first; BlockFrequency &ParentPtsFreq = InsertPtsMap[Parent].second; // Choose to insert in Node or in subtree of Node. // Don't hoist to EHPad because we may not find a proper place to insert // in EHPad. // If the total frequency of InsertPts is the same as the frequency of the // target Node, and InsertPts contains more than one nodes, choose hoisting // to reduce code size. if (NodeInBBs || (!Node->isEHPad() && (InsertPtsFreq > BFI.getBlockFreq(Node) || (InsertPtsFreq == BFI.getBlockFreq(Node) && InsertPts.size() > 1)))) { ParentInsertPts.insert(Node); ParentPtsFreq += BFI.getBlockFreq(Node); } else { ParentInsertPts.insert(InsertPts.begin(), InsertPts.end()); ParentPtsFreq += InsertPtsFreq; } } }