/// CloneDominatorInfo - Clone basicblock's dominator tree and, if available, /// dominance info. It is expected that basic block is already cloned. static void CloneDominatorInfo(BasicBlock *BB, DenseMap<const Value *, Value *> &ValueMap, DominatorTree *DT, DominanceFrontier *DF) { assert (DT && "DominatorTree is not available"); DenseMap<const Value *, Value*>::iterator BI = ValueMap.find(BB); assert (BI != ValueMap.end() && "BasicBlock clone is missing"); BasicBlock *NewBB = cast<BasicBlock>(BI->second); // NewBB already got dominator info. if (DT->getNode(NewBB)) return; assert (DT->getNode(BB) && "BasicBlock does not have dominator info"); // Entry block is not expected here. Infinite loops are not to cloned. assert (DT->getNode(BB)->getIDom() && "BasicBlock does not have immediate dominator"); BasicBlock *BBDom = DT->getNode(BB)->getIDom()->getBlock(); // NewBB's dominator is either BB's dominator or BB's dominator's clone. BasicBlock *NewBBDom = BBDom; DenseMap<const Value *, Value*>::iterator BBDomI = ValueMap.find(BBDom); if (BBDomI != ValueMap.end()) { NewBBDom = cast<BasicBlock>(BBDomI->second); if (!DT->getNode(NewBBDom)) CloneDominatorInfo(BBDom, ValueMap, DT, DF); } DT->addNewBlock(NewBB, NewBBDom); // Copy cloned dominance frontiner set if (DF) { DominanceFrontier::DomSetType NewDFSet; DominanceFrontier::iterator DFI = DF->find(BB); if ( DFI != DF->end()) { DominanceFrontier::DomSetType S = DFI->second; for (DominanceFrontier::DomSetType::iterator I = S.begin(), E = S.end(); I != E; ++I) { BasicBlock *DB = *I; DenseMap<const Value*, Value*>::iterator IDM = ValueMap.find(DB); if (IDM != ValueMap.end()) NewDFSet.insert(cast<BasicBlock>(IDM->second)); else NewDFSet.insert(DB); } } DF->addBasicBlock(NewBB, NewDFSet); } }
// NewBB is split and now it has one successor. Update dominace frontier to // reflect this change. void DominanceFrontier::splitBlock(BasicBlock *NewBB) { assert(NewBB->getTerminator()->getNumSuccessors() == 1 && "NewBB should have a single successor!"); BasicBlock *NewBBSucc = NewBB->getTerminator()->getSuccessor(0); SmallVector<BasicBlock*, 8> PredBlocks; for (pred_iterator PI = pred_begin(NewBB), PE = pred_end(NewBB); PI != PE; ++PI) PredBlocks.push_back(*PI); if (PredBlocks.empty()) // If NewBB does not have any predecessors then it is a entry block. // In this case, NewBB and its successor NewBBSucc dominates all // other blocks. return; // NewBBSucc inherits original NewBB frontier. DominanceFrontier::iterator NewBBI = find(NewBB); if (NewBBI != end()) { DominanceFrontier::DomSetType NewBBSet = NewBBI->second; DominanceFrontier::DomSetType NewBBSuccSet; NewBBSuccSet.insert(NewBBSet.begin(), NewBBSet.end()); addBasicBlock(NewBBSucc, NewBBSuccSet); } // If NewBB dominates NewBBSucc, then DF(NewBB) is now going to be the // DF(PredBlocks[0]) without the stuff that the new block does not dominate // a predecessor of. DominatorTree &DT = getAnalysis<DominatorTree>(); if (DT.dominates(NewBB, NewBBSucc)) { DominanceFrontier::iterator DFI = find(PredBlocks[0]); if (DFI != end()) { DominanceFrontier::DomSetType Set = DFI->second; // Filter out stuff in Set that we do not dominate a predecessor of. for (DominanceFrontier::DomSetType::iterator SetI = Set.begin(), E = Set.end(); SetI != E;) { bool DominatesPred = false; for (pred_iterator PI = pred_begin(*SetI), E = pred_end(*SetI); PI != E; ++PI) if (DT.dominates(NewBB, *PI)) DominatesPred = true; if (!DominatesPred) Set.erase(SetI++); else ++SetI; } if (NewBBI != end()) { for (DominanceFrontier::DomSetType::iterator SetI = Set.begin(), E = Set.end(); SetI != E; ++SetI) { BasicBlock *SB = *SetI; addToFrontier(NewBBI, SB); } } else addBasicBlock(NewBB, Set); } } else { // DF(NewBB) is {NewBBSucc} because NewBB does not strictly dominate // NewBBSucc, but it does dominate itself (and there is an edge (NewBB -> // NewBBSucc)). NewBBSucc is the single successor of NewBB. DominanceFrontier::DomSetType NewDFSet; NewDFSet.insert(NewBBSucc); addBasicBlock(NewBB, NewDFSet); } // Now we must loop over all of the dominance frontiers in the function, // replacing occurrences of NewBBSucc with NewBB in some cases. All // blocks that dominate a block in PredBlocks and contained NewBBSucc in // their dominance frontier must be updated to contain NewBB instead. // for (Function::iterator FI = NewBB->getParent()->begin(), FE = NewBB->getParent()->end(); FI != FE; ++FI) { DominanceFrontier::iterator DFI = find(FI); if (DFI == end()) continue; // unreachable block. // Only consider nodes that have NewBBSucc in their dominator frontier. if (!DFI->second.count(NewBBSucc)) continue; // Verify whether this block dominates a block in predblocks. If not, do // not update it. bool BlockDominatesAny = false; for (SmallVectorImpl<BasicBlock*>::const_iterator BI = PredBlocks.begin(), BE = PredBlocks.end(); BI != BE; ++BI) { if (DT.dominates(FI, *BI)) { BlockDominatesAny = true; break; } } // If NewBBSucc should not stay in our dominator frontier, remove it. // We remove it unless there is a predecessor of NewBBSucc that we // dominate, but we don't strictly dominate NewBBSucc. bool ShouldRemove = true; if ((BasicBlock*)FI == NewBBSucc || !DT.dominates(FI, NewBBSucc)) { // Okay, we know that PredDom does not strictly dominate NewBBSucc. // Check to see if it dominates any predecessors of NewBBSucc. for (pred_iterator PI = pred_begin(NewBBSucc), E = pred_end(NewBBSucc); PI != E; ++PI) if (DT.dominates(FI, *PI)) { ShouldRemove = false; break; } } if (ShouldRemove) removeFromFrontier(DFI, NewBBSucc); if (BlockDominatesAny && (&*FI == NewBB || !DT.dominates(FI, NewBB))) addToFrontier(DFI, NewBB); } }
/// 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; }
/// removeBlocks - Remove basic block DeadBB and all blocks dominated by DeadBB. /// This routine is used to remove split condition's dead branch, dominated by /// DeadBB. LiveBB dominates split conidition's other branch. void LoopIndexSplit::removeBlocks(BasicBlock *DeadBB, Loop *LP, BasicBlock *LiveBB) { // First update DeadBB's dominance frontier. SmallVector<BasicBlock *, 8> FrontierBBs; DominanceFrontier::iterator DeadBBDF = DF->find(DeadBB); if (DeadBBDF != DF->end()) { SmallVector<BasicBlock *, 8> PredBlocks; DominanceFrontier::DomSetType DeadBBSet = DeadBBDF->second; for (DominanceFrontier::DomSetType::iterator DeadBBSetI = DeadBBSet.begin(), DeadBBSetE = DeadBBSet.end(); DeadBBSetI != DeadBBSetE; ++DeadBBSetI) { BasicBlock *FrontierBB = *DeadBBSetI; FrontierBBs.push_back(FrontierBB); // Rremove any PHI incoming edge from blocks dominated by DeadBB. PredBlocks.clear(); for(pred_iterator PI = pred_begin(FrontierBB), PE = pred_end(FrontierBB); PI != PE; ++PI) { BasicBlock *P = *PI; if (P == DeadBB || DT->dominates(DeadBB, P)) PredBlocks.push_back(P); } for(BasicBlock::iterator FBI = FrontierBB->begin(), FBE = FrontierBB->end(); FBI != FBE; ++FBI) { if (PHINode *PN = dyn_cast<PHINode>(FBI)) { for(SmallVector<BasicBlock *, 8>::iterator PI = PredBlocks.begin(), PE = PredBlocks.end(); PI != PE; ++PI) { BasicBlock *P = *PI; PN->removeIncomingValue(P); } } else break; } } } // Now remove DeadBB and all nodes dominated by DeadBB in df order. SmallVector<BasicBlock *, 32> WorkList; DomTreeNode *DN = DT->getNode(DeadBB); for (df_iterator<DomTreeNode*> DI = df_begin(DN), E = df_end(DN); DI != E; ++DI) { BasicBlock *BB = DI->getBlock(); WorkList.push_back(BB); BB->replaceAllUsesWith(UndefValue::get( Type::getLabelTy(DeadBB->getContext()))); } while (!WorkList.empty()) { BasicBlock *BB = WorkList.back(); WorkList.pop_back(); LPM->deleteSimpleAnalysisValue(BB, LP); for(BasicBlock::iterator BBI = BB->begin(), BBE = BB->end(); BBI != BBE; ) { Instruction *I = BBI; ++BBI; I->replaceAllUsesWith(UndefValue::get(I->getType())); LPM->deleteSimpleAnalysisValue(I, LP); I->eraseFromParent(); } DT->eraseNode(BB); DF->removeBlock(BB); LI->removeBlock(BB); BB->eraseFromParent(); } // Update Frontier BBs' dominator info. while (!FrontierBBs.empty()) { BasicBlock *FBB = FrontierBBs.back(); FrontierBBs.pop_back(); BasicBlock *NewDominator = FBB->getSinglePredecessor(); if (!NewDominator) { pred_iterator PI = pred_begin(FBB), PE = pred_end(FBB); NewDominator = *PI; ++PI; if (NewDominator != LiveBB) { for(; PI != PE; ++PI) { BasicBlock *P = *PI; if (P == LiveBB) { NewDominator = LiveBB; break; } NewDominator = DT->findNearestCommonDominator(NewDominator, P); } } } assert (NewDominator && "Unable to fix dominator info."); DT->changeImmediateDominator(FBB, NewDominator); DF->changeImmediateDominator(FBB, NewDominator, DT); } }
// NewBB is split and now it has one successor. Update dominance frontier to // reflect this change. void DominanceFrontier::splitBlock(BasicBlock *NewBB) { assert(NewBB->getTerminator()->getNumSuccessors() == 1 && "NewBB should have a single successor!"); BasicBlock *NewBBSucc = NewBB->getTerminator()->getSuccessor(0); // NewBBSucc inherits original NewBB frontier. DominanceFrontier::iterator NewBBI = find(NewBB); if (NewBBI != end()) addBasicBlock(NewBBSucc, NewBBI->second); // If NewBB dominates NewBBSucc, then DF(NewBB) is now going to be the // DF(NewBBSucc) without the stuff that the new block does not dominate // a predecessor of. DominatorTree &DT = getAnalysis<DominatorTree>(); DomTreeNode *NewBBNode = DT.getNode(NewBB); DomTreeNode *NewBBSuccNode = DT.getNode(NewBBSucc); if (DT.dominates(NewBBNode, NewBBSuccNode)) { DominanceFrontier::iterator DFI = find(NewBBSucc); if (DFI != end()) { DominanceFrontier::DomSetType Set = DFI->second; // Filter out stuff in Set that we do not dominate a predecessor of. for (DominanceFrontier::DomSetType::iterator SetI = Set.begin(), E = Set.end(); SetI != E;) { bool DominatesPred = false; for (pred_iterator PI = pred_begin(*SetI), E = pred_end(*SetI); PI != E; ++PI) if (DT.dominates(NewBBNode, DT.getNode(*PI))) { DominatesPred = true; break; } if (!DominatesPred) Set.erase(SetI++); else ++SetI; } if (NewBBI != end()) { for (DominanceFrontier::DomSetType::iterator SetI = Set.begin(), E = Set.end(); SetI != E; ++SetI) { BasicBlock *SB = *SetI; addToFrontier(NewBBI, SB); } } else addBasicBlock(NewBB, Set); } } else { // DF(NewBB) is {NewBBSucc} because NewBB does not strictly dominate // NewBBSucc, but it does dominate itself (and there is an edge (NewBB -> // NewBBSucc)). NewBBSucc is the single successor of NewBB. DominanceFrontier::DomSetType NewDFSet; NewDFSet.insert(NewBBSucc); addBasicBlock(NewBB, NewDFSet); } // Now update dominance frontiers which either used to contain NewBBSucc // or which now need to include NewBB. // Collect the set of blocks which dominate a predecessor of NewBB or // NewSuccBB and which don't dominate both. This is an initial // approximation of the blocks whose dominance frontiers will need updates. SmallVector<DomTreeNode *, 16> AllPredDoms; // Compute the block which dominates both NewBBSucc and NewBB. This is // the immediate dominator of NewBBSucc unless NewBB dominates NewBBSucc. // The code below which climbs dominator trees will stop at this point, // because from this point up, dominance frontiers are unaffected. DomTreeNode *DominatesBoth = 0; if (NewBBSuccNode) { DominatesBoth = NewBBSuccNode->getIDom(); if (DominatesBoth == NewBBNode) DominatesBoth = NewBBNode->getIDom(); } // Collect the set of all blocks which dominate a predecessor of NewBB. SmallPtrSet<DomTreeNode *, 8> NewBBPredDoms; for (pred_iterator PI = pred_begin(NewBB), E = pred_end(NewBB); PI != E; ++PI) for (DomTreeNode *DTN = DT.getNode(*PI); DTN; DTN = DTN->getIDom()) { if (DTN == DominatesBoth) break; if (!NewBBPredDoms.insert(DTN)) break; AllPredDoms.push_back(DTN); } // Collect the set of all blocks which dominate a predecessor of NewSuccBB. SmallPtrSet<DomTreeNode *, 8> NewBBSuccPredDoms; for (pred_iterator PI = pred_begin(NewBBSucc), E = pred_end(NewBBSucc); PI != E; ++PI) for (DomTreeNode *DTN = DT.getNode(*PI); DTN; DTN = DTN->getIDom()) { if (DTN == DominatesBoth) break; if (!NewBBSuccPredDoms.insert(DTN)) break; if (!NewBBPredDoms.count(DTN)) AllPredDoms.push_back(DTN); } // Visit all relevant dominance frontiers and make any needed updates. for (SmallVectorImpl<DomTreeNode *>::const_iterator I = AllPredDoms.begin(), E = AllPredDoms.end(); I != E; ++I) { DomTreeNode *DTN = *I; iterator DFI = find((*I)->getBlock()); // Only consider nodes that have NewBBSucc in their dominator frontier. if (DFI == end() || !DFI->second.count(NewBBSucc)) continue; // If the block dominates a predecessor of NewBB but does not properly // dominate NewBB itself, add NewBB to its dominance frontier. if (NewBBPredDoms.count(DTN) && !DT.properlyDominates(DTN, NewBBNode)) addToFrontier(DFI, NewBB); // If the block does not dominate a predecessor of NewBBSucc or // properly dominates NewBBSucc itself, remove NewBBSucc from its // dominance frontier. if (!NewBBSuccPredDoms.count(DTN) || DT.properlyDominates(DTN, NewBBSuccNode)) removeFromFrontier(DFI, NewBBSucc); } }