Index: llvm/trunk/include/llvm/Analysis/DomTreeUpdater.h =================================================================== --- llvm/trunk/include/llvm/Analysis/DomTreeUpdater.h +++ llvm/trunk/include/llvm/Analysis/DomTreeUpdater.h @@ -136,7 +136,8 @@ /// DEBUG mode. CAUTION! This function has to be called *after* making the /// update on the actual CFG. It is illegal to submit any update that has /// already been applied. } - void insertEdge(BasicBlock *From, BasicBlock *To); + LLVM_ATTRIBUTE_DEPRECATED(void insertEdge(BasicBlock *From, BasicBlock *To), + "Use applyUpdates() instead."); /// \deprecated {Submit an edge insertion to all available trees. /// Under either Strategy, an invalid update will be discard silently. @@ -146,7 +147,9 @@ /// want to discard an invalid update. /// CAUTION! It is illegal to submit any update that has already been /// submitted. } - void insertEdgeRelaxed(BasicBlock *From, BasicBlock *To); + LLVM_ATTRIBUTE_DEPRECATED(void insertEdgeRelaxed(BasicBlock *From, + BasicBlock *To), + "Use applyUpdates() instead."); /// \deprecated { Submit an edge deletion to all available trees. The Eager /// Strategy flushes this update immediately while the Lazy Strategy queues @@ -155,7 +158,8 @@ /// CAUTION! This function has to be called *after* making the update on the /// actual CFG. It is illegal to submit any update that has already been /// submitted. } - void deleteEdge(BasicBlock *From, BasicBlock *To); + LLVM_ATTRIBUTE_DEPRECATED(void deleteEdge(BasicBlock *From, BasicBlock *To), + "Use applyUpdates() instead."); /// \deprecated { Submit an edge deletion to all available trees. /// Under either Strategy, an invalid update will be discard silently. @@ -165,7 +169,9 @@ /// want to discard an invalid update. /// CAUTION! It is illegal to submit any update that has already been /// submitted. } - void deleteEdgeRelaxed(BasicBlock *From, BasicBlock *To); + LLVM_ATTRIBUTE_DEPRECATED(void deleteEdgeRelaxed(BasicBlock *From, + BasicBlock *To), + "Use applyUpdates() instead."); /// Delete DelBB. DelBB will be removed from its Parent and /// erased from available trees if it exists and finally get deleted. Index: llvm/trunk/lib/Transforms/Scalar/CallSiteSplitting.cpp =================================================================== --- llvm/trunk/lib/Transforms/Scalar/CallSiteSplitting.cpp +++ llvm/trunk/lib/Transforms/Scalar/CallSiteSplitting.cpp @@ -366,7 +366,7 @@ assert(Splits.size() == 2 && "Expected exactly 2 splits!"); for (unsigned i = 0; i < Splits.size(); i++) { Splits[i]->getTerminator()->eraseFromParent(); - DTU.deleteEdge(Splits[i], TailBB); + DTU.applyUpdates({{DominatorTree::Delete, Splits[i], TailBB}}); } // Erase the tail block once done with musttail patching Index: llvm/trunk/lib/Transforms/Scalar/CorrelatedValuePropagation.cpp =================================================================== --- llvm/trunk/lib/Transforms/Scalar/CorrelatedValuePropagation.cpp +++ llvm/trunk/lib/Transforms/Scalar/CorrelatedValuePropagation.cpp @@ -373,7 +373,7 @@ ++NumDeadCases; Changed = true; if (--SuccessorsCount[Succ] == 0) - DTU.deleteEdge(BB, Succ); + DTU.applyUpdates({{DominatorTree::Delete, BB, Succ}}); continue; } if (State == LazyValueInfo::True) { Index: llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp =================================================================== --- llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp +++ llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp @@ -1159,7 +1159,7 @@ ConstantInt::getFalse(CondCmp->getType()); ReplaceFoldableUses(CondCmp, CI); } - DTU->deleteEdgeRelaxed(BB, ToRemoveSucc); + DTU->applyUpdates({{DominatorTree::Delete, BB, ToRemoveSucc}}); return true; } @@ -1246,7 +1246,7 @@ RemoveSucc->removePredecessor(BB); BranchInst::Create(KeepSucc, BI); BI->eraseFromParent(); - DTU->deleteEdgeRelaxed(BB, RemoveSucc); + DTU->applyUpdates({{DominatorTree::Delete, BB, RemoveSucc}}); return true; } CurrentBB = CurrentPred; Index: llvm/trunk/lib/Transforms/Scalar/TailRecursionElimination.cpp =================================================================== --- llvm/trunk/lib/Transforms/Scalar/TailRecursionElimination.cpp +++ llvm/trunk/lib/Transforms/Scalar/TailRecursionElimination.cpp @@ -678,7 +678,7 @@ BB->getInstList().erase(Ret); // Remove return. BB->getInstList().erase(CI); // Remove call. - DTU.insertEdge(BB, OldEntry); + DTU.applyUpdates({{DominatorTree::Insert, BB, OldEntry}}); ++NumEliminated; return true; } Index: llvm/trunk/lib/Transforms/Utils/BasicBlockUtils.cpp =================================================================== --- llvm/trunk/lib/Transforms/Utils/BasicBlockUtils.cpp +++ llvm/trunk/lib/Transforms/Utils/BasicBlockUtils.cpp @@ -721,7 +721,7 @@ UncondBranch->eraseFromParent(); if (DTU) - DTU->deleteEdge(Pred, BB); + DTU->applyUpdates({{DominatorTree::Delete, Pred, BB}}); return cast(NewRet); } Index: llvm/trunk/lib/Transforms/Utils/Local.cpp =================================================================== --- llvm/trunk/lib/Transforms/Utils/Local.cpp +++ llvm/trunk/lib/Transforms/Utils/Local.cpp @@ -128,7 +128,8 @@ Builder.CreateBr(Destination); BI->eraseFromParent(); if (DTU) - DTU->deleteEdgeRelaxed(BB, OldDest); + DTU->applyUpdates({{DominatorTree::Delete, BB, OldDest}}, + /*ForceRemoveDuplicates*/ true); return true; } @@ -204,7 +205,8 @@ i = SI->removeCase(i); e = SI->case_end(); if (DTU) - DTU->deleteEdgeRelaxed(ParentBB, DefaultDest); + DTU->applyUpdates({{DominatorTree::Delete, ParentBB, DefaultDest}}, + /*ForceRemoveDuplicates*/ true); continue; } @@ -664,7 +666,8 @@ if (PhiIt != OldPhiIt) PhiIt = &BB->front(); } if (DTU) - DTU->deleteEdgeRelaxed(Pred, BB); + DTU->applyUpdates({{DominatorTree::Delete, Pred, BB}}, + /*ForceRemoveDuplicates*/ true); } /// MergeBasicBlockIntoOnlyPred - DestBB is a block with one predecessor and its @@ -1967,7 +1970,8 @@ UnwindDestBB->removePredecessor(BB); II->eraseFromParent(); if (DTU) - DTU->deleteEdgeRelaxed(BB, UnwindDestBB); + DTU->applyUpdates({{DominatorTree::Delete, BB, UnwindDestBB}}, + /*ForceRemoveDuplicates*/ true); } BasicBlock *llvm::changeToInvokeAndSplitBasicBlock(CallInst *CI, @@ -2114,7 +2118,8 @@ UnwindDestBB->removePredecessor(II->getParent()); II->eraseFromParent(); if (DTU) - DTU->deleteEdgeRelaxed(BB, UnwindDestBB); + DTU->applyUpdates({{DominatorTree::Delete, BB, UnwindDestBB}}, + /*ForceRemoveDuplicates*/ true); } else changeToCall(II, DTU); Changed = true; @@ -2203,7 +2208,8 @@ TI->replaceAllUsesWith(NewTI); TI->eraseFromParent(); if (DTU) - DTU->deleteEdgeRelaxed(BB, UnwindDest); + DTU->applyUpdates({{DominatorTree::Delete, BB, UnwindDest}}, + /*ForceRemoveDuplicates*/ true); } /// removeUnreachableBlocks - Remove blocks that are not reachable, even Index: llvm/trunk/lib/Transforms/Utils/LoopUtils.cpp =================================================================== --- llvm/trunk/lib/Transforms/Utils/LoopUtils.cpp +++ llvm/trunk/lib/Transforms/Utils/LoopUtils.cpp @@ -535,10 +535,9 @@ DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Eager); if (DT) { // Update the dominator tree by informing it about the new edge from the - // preheader to the exit. - DTU.insertEdge(Preheader, ExitBlock); - // Inform the dominator tree about the removed edge. - DTU.deleteEdge(Preheader, L->getHeader()); + // preheader to the exit and the removed edge. + DTU.applyUpdates({{DominatorTree::Insert, Preheader, ExitBlock}, + {DominatorTree::Delete, Preheader, L->getHeader()}}); } // Use a map to unique and a vector to guarantee deterministic ordering. Index: llvm/trunk/unittests/Analysis/DomTreeUpdaterTest.cpp =================================================================== --- llvm/trunk/unittests/Analysis/DomTreeUpdaterTest.cpp +++ llvm/trunk/unittests/Analysis/DomTreeUpdaterTest.cpp @@ -71,8 +71,9 @@ SwitchInst *SI = dyn_cast(BB0->getTerminator()); ASSERT_NE(SI, nullptr) << "Couldn't get SwitchInst."; - DTU.insertEdgeRelaxed(BB0, BB0); - DTU.deleteEdgeRelaxed(BB0, BB0); + DTU.applyUpdates( + {{DominatorTree::Insert, BB0, BB0}, {DominatorTree::Delete, BB0, BB0}}, + /*ForceRemoveDuplicates*/ true); // Delete edge bb0 -> bb3 and push the update twice to verify duplicate // entries are discarded. @@ -105,9 +106,10 @@ ASSERT_FALSE(DTU.hasPendingUpdates()); // Invalid Insert: no edge bb1 -> bb2 after change to bb0. - DTU.insertEdgeRelaxed(BB1, BB2); // Invalid Delete: edge exists bb0 -> bb1 after change to bb0. - DTU.deleteEdgeRelaxed(BB0, BB1); + DTU.applyUpdates( + {{DominatorTree::Insert, BB1, BB2}, {DominatorTree::Delete, BB0, BB1}}, + /*ForceRemoveDuplicates*/ true); // DTU working with Eager UpdateStrategy does not need to flush. ASSERT_TRUE(DT.verify()); @@ -182,7 +184,8 @@ EXPECT_EQ(F->begin()->getName(), NewEntry->getName()); EXPECT_TRUE(&F->getEntryBlock() == NewEntry); - DTU.insertEdgeRelaxed(NewEntry, BB0); + DTU.applyUpdates({{DominatorTree::Insert, NewEntry, BB0}}, + /*ForceRemoveDuplicates*/ true); // Changing the Entry BB requires a full recalculation of DomTree. DTU.recalculate(*F); @@ -251,7 +254,7 @@ BasicBlock *BB3 = &*FI++; // Test discards of self-domination update. - DTU.deleteEdge(BB0, BB0); + DTU.applyUpdates({{DominatorTree::Delete, BB0, BB0}}); ASSERT_FALSE(DTU.hasPendingDomTreeUpdates()); // Delete edge bb0 -> bb3 and push the update twice to verify duplicate @@ -358,8 +361,10 @@ // +-> succ // // While the final CFG form is functionally identical the updates to - // DTU are not. In the first case we must have DTU.insertEdge(Pred1, Succ) - // while in the latter case we must *NOT* have DTU.insertEdge(Pred1, Succ). + // DTU are not. In the first case we must have + // DTU.applyUpdates({{DominatorTree::Insert, Pred1, Succ}}) while in the + // latter case we must *NOT* have DTU.applyUpdates({{DominatorTree::Insert, + // Pred1, Succ}}). // CFG Change: bb0 now only has bb0 -> bb1 and bb0 -> bb3. We are preparing to // remove bb2. @@ -412,9 +417,9 @@ ASSERT_TRUE(isa(BB1->getTerminator())); EXPECT_EQ(BB1->getParent(), F); - // Update the DTU. In this case we don't call DTU.insertEdge(BB0, BB3) because - // the edge previously existed at the start of this test when DT was first - // created. + // Update the DTU. In this case we don't submit {DominatorTree::Insert, BB0, + // BB3} because the edge previously existed at the start of this test when DT + // was first created. Updates.push_back({DominatorTree::Delete, BB0, BB1}); Updates.push_back({DominatorTree::Delete, BB1, BB3}); @@ -467,7 +472,7 @@ BasicBlock *BB2 = &*FI++; BasicBlock *BB3 = &*FI++; // Test discards of self-domination update. - DTU.deleteEdge(BB0, BB0); + DTU.applyUpdates({{DominatorTree::Delete, BB0, BB0}}); // Delete edge bb0 -> bb3 and push the update twice to verify duplicate // entries are discarded. @@ -558,7 +563,7 @@ // Insert the new edge between new_entry -> bb0. Without this the // recalculate() call below will not actually recalculate the DT as there // are no changes pending and no blocks deleted. - DTU.insertEdge(NewEntry, BB0); + DTU.applyUpdates({{DominatorTree::Insert, NewEntry, BB0}}); // Changing the Entry BB requires a full recalculation. DTU.recalculate(*F);