//===- llvm/unittests/IR/DominatorTreeTest.cpp - Constants unit tests -----===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #include #include "llvm/Analysis/PostDominators.h" #include "llvm/Analysis/IteratedDominanceFrontier.h" #include "llvm/AsmParser/Parser.h" #include "llvm/IR/Constants.h" #include "llvm/IR/Dominators.h" #include "llvm/IR/Instructions.h" #include "llvm/IR/LLVMContext.h" #include "llvm/IR/Module.h" #include "llvm/Support/SourceMgr.h" #include "CFGBuilder.h" #include "gtest/gtest.h" using namespace llvm; /// Build the dominator tree for the function and run the Test. static void runWithDomTree( Module &M, StringRef FuncName, function_ref Test) { auto *F = M.getFunction(FuncName); ASSERT_NE(F, nullptr) << "Could not find " << FuncName; // Compute the dominator tree for the function. DominatorTree DT(*F); PostDominatorTree PDT(*F); Test(*F, &DT, &PDT); } static std::unique_ptr makeLLVMModule(LLVMContext &Context, StringRef ModuleStr) { SMDiagnostic Err; std::unique_ptr M = parseAssemblyString(ModuleStr, Err, Context); assert(M && "Bad assembly?"); return M; } TEST(DominatorTree, PHIs) { StringRef ModuleString = R"( define void @f() { bb1: br label %bb1 bb2: %a = phi i32 [0, %bb1], [1, %bb2] %b = phi i32 [2, %bb1], [%a, %bb2] br label %bb2 }; )"; // Parse the module. LLVMContext Context; std::unique_ptr M = makeLLVMModule(Context, ModuleString); runWithDomTree(*M, "f", [&](Function &F, DominatorTree *DT, PostDominatorTree *PDT) { auto FI = F.begin(); ++FI; BasicBlock *BB2 = &*FI; auto BI = BB2->begin(); Instruction *PhiA = &*BI++; Instruction *PhiB = &*BI; // Phis are thought to execute "instantly, together". EXPECT_TRUE(DT->dominates(PhiA, PhiB)); EXPECT_TRUE(DT->dominates(PhiB, PhiA)); }); } TEST(DominatorTree, Unreachable) { StringRef ModuleString = "declare i32 @g()\n" "define void @f(i32 %x) personality i32 ()* @g {\n" "bb0:\n" " %y1 = add i32 %x, 1\n" " %y2 = add i32 %x, 1\n" " %y3 = invoke i32 @g() to label %bb1 unwind label %bb2\n" "bb1:\n" " %y4 = add i32 %x, 1\n" " br label %bb4\n" "bb2:\n" " %y5 = landingpad i32\n" " cleanup\n" " br label %bb4\n" "bb3:\n" " %y6 = add i32 %x, 1\n" " %y7 = add i32 %x, 1\n" " ret void\n" "bb4:\n" " %y8 = phi i32 [0, %bb2], [%y4, %bb1]\n" " %y9 = phi i32 [0, %bb2], [%y4, %bb1]\n" " ret void\n" "}\n"; // Parse the module. LLVMContext Context; std::unique_ptr M = makeLLVMModule(Context, ModuleString); runWithDomTree( *M, "f", [&](Function &F, DominatorTree *DT, PostDominatorTree *PDT) { Function::iterator FI = F.begin(); BasicBlock *BB0 = &*FI++; BasicBlock::iterator BBI = BB0->begin(); Instruction *Y1 = &*BBI++; Instruction *Y2 = &*BBI++; Instruction *Y3 = &*BBI++; BasicBlock *BB1 = &*FI++; BBI = BB1->begin(); Instruction *Y4 = &*BBI++; BasicBlock *BB2 = &*FI++; BBI = BB2->begin(); Instruction *Y5 = &*BBI++; BasicBlock *BB3 = &*FI++; BBI = BB3->begin(); Instruction *Y6 = &*BBI++; Instruction *Y7 = &*BBI++; BasicBlock *BB4 = &*FI++; BBI = BB4->begin(); Instruction *Y8 = &*BBI++; Instruction *Y9 = &*BBI++; // Reachability EXPECT_TRUE(DT->isReachableFromEntry(BB0)); EXPECT_TRUE(DT->isReachableFromEntry(BB1)); EXPECT_TRUE(DT->isReachableFromEntry(BB2)); EXPECT_FALSE(DT->isReachableFromEntry(BB3)); EXPECT_TRUE(DT->isReachableFromEntry(BB4)); // BB dominance EXPECT_TRUE(DT->dominates(BB0, BB0)); EXPECT_TRUE(DT->dominates(BB0, BB1)); EXPECT_TRUE(DT->dominates(BB0, BB2)); EXPECT_TRUE(DT->dominates(BB0, BB3)); EXPECT_TRUE(DT->dominates(BB0, BB4)); EXPECT_FALSE(DT->dominates(BB1, BB0)); EXPECT_TRUE(DT->dominates(BB1, BB1)); EXPECT_FALSE(DT->dominates(BB1, BB2)); EXPECT_TRUE(DT->dominates(BB1, BB3)); EXPECT_FALSE(DT->dominates(BB1, BB4)); EXPECT_FALSE(DT->dominates(BB2, BB0)); EXPECT_FALSE(DT->dominates(BB2, BB1)); EXPECT_TRUE(DT->dominates(BB2, BB2)); EXPECT_TRUE(DT->dominates(BB2, BB3)); EXPECT_FALSE(DT->dominates(BB2, BB4)); EXPECT_FALSE(DT->dominates(BB3, BB0)); EXPECT_FALSE(DT->dominates(BB3, BB1)); EXPECT_FALSE(DT->dominates(BB3, BB2)); EXPECT_TRUE(DT->dominates(BB3, BB3)); EXPECT_FALSE(DT->dominates(BB3, BB4)); // BB proper dominance EXPECT_FALSE(DT->properlyDominates(BB0, BB0)); EXPECT_TRUE(DT->properlyDominates(BB0, BB1)); EXPECT_TRUE(DT->properlyDominates(BB0, BB2)); EXPECT_TRUE(DT->properlyDominates(BB0, BB3)); EXPECT_FALSE(DT->properlyDominates(BB1, BB0)); EXPECT_FALSE(DT->properlyDominates(BB1, BB1)); EXPECT_FALSE(DT->properlyDominates(BB1, BB2)); EXPECT_TRUE(DT->properlyDominates(BB1, BB3)); EXPECT_FALSE(DT->properlyDominates(BB2, BB0)); EXPECT_FALSE(DT->properlyDominates(BB2, BB1)); EXPECT_FALSE(DT->properlyDominates(BB2, BB2)); EXPECT_TRUE(DT->properlyDominates(BB2, BB3)); EXPECT_FALSE(DT->properlyDominates(BB3, BB0)); EXPECT_FALSE(DT->properlyDominates(BB3, BB1)); EXPECT_FALSE(DT->properlyDominates(BB3, BB2)); EXPECT_FALSE(DT->properlyDominates(BB3, BB3)); // Instruction dominance in the same reachable BB EXPECT_FALSE(DT->dominates(Y1, Y1)); EXPECT_TRUE(DT->dominates(Y1, Y2)); EXPECT_FALSE(DT->dominates(Y2, Y1)); EXPECT_FALSE(DT->dominates(Y2, Y2)); // Instruction dominance in the same unreachable BB EXPECT_TRUE(DT->dominates(Y6, Y6)); EXPECT_TRUE(DT->dominates(Y6, Y7)); EXPECT_TRUE(DT->dominates(Y7, Y6)); EXPECT_TRUE(DT->dominates(Y7, Y7)); // Invoke EXPECT_TRUE(DT->dominates(Y3, Y4)); EXPECT_FALSE(DT->dominates(Y3, Y5)); // Phi EXPECT_TRUE(DT->dominates(Y2, Y9)); EXPECT_FALSE(DT->dominates(Y3, Y9)); EXPECT_FALSE(DT->dominates(Y8, Y9)); // Anything dominates unreachable EXPECT_TRUE(DT->dominates(Y1, Y6)); EXPECT_TRUE(DT->dominates(Y3, Y6)); // Unreachable doesn't dominate reachable EXPECT_FALSE(DT->dominates(Y6, Y1)); // Instruction, BB dominance EXPECT_FALSE(DT->dominates(Y1, BB0)); EXPECT_TRUE(DT->dominates(Y1, BB1)); EXPECT_TRUE(DT->dominates(Y1, BB2)); EXPECT_TRUE(DT->dominates(Y1, BB3)); EXPECT_TRUE(DT->dominates(Y1, BB4)); EXPECT_FALSE(DT->dominates(Y3, BB0)); EXPECT_TRUE(DT->dominates(Y3, BB1)); EXPECT_FALSE(DT->dominates(Y3, BB2)); EXPECT_TRUE(DT->dominates(Y3, BB3)); EXPECT_FALSE(DT->dominates(Y3, BB4)); EXPECT_TRUE(DT->dominates(Y6, BB3)); // Post dominance. EXPECT_TRUE(PDT->dominates(BB0, BB0)); EXPECT_FALSE(PDT->dominates(BB1, BB0)); EXPECT_FALSE(PDT->dominates(BB2, BB0)); EXPECT_FALSE(PDT->dominates(BB3, BB0)); EXPECT_TRUE(PDT->dominates(BB4, BB1)); // Dominance descendants. SmallVector DominatedBBs, PostDominatedBBs; DT->getDescendants(BB0, DominatedBBs); PDT->getDescendants(BB0, PostDominatedBBs); EXPECT_EQ(DominatedBBs.size(), 4UL); EXPECT_EQ(PostDominatedBBs.size(), 1UL); // BB3 is unreachable. It should have no dominators nor postdominators. DominatedBBs.clear(); PostDominatedBBs.clear(); DT->getDescendants(BB3, DominatedBBs); DT->getDescendants(BB3, PostDominatedBBs); EXPECT_EQ(DominatedBBs.size(), 0UL); EXPECT_EQ(PostDominatedBBs.size(), 0UL); // Check DFS Numbers before DT->updateDFSNumbers(); EXPECT_EQ(DT->getNode(BB0)->getDFSNumIn(), 0UL); EXPECT_EQ(DT->getNode(BB0)->getDFSNumOut(), 7UL); EXPECT_EQ(DT->getNode(BB1)->getDFSNumIn(), 1UL); EXPECT_EQ(DT->getNode(BB1)->getDFSNumOut(), 2UL); EXPECT_EQ(DT->getNode(BB2)->getDFSNumIn(), 5UL); EXPECT_EQ(DT->getNode(BB2)->getDFSNumOut(), 6UL); EXPECT_EQ(DT->getNode(BB4)->getDFSNumIn(), 3UL); EXPECT_EQ(DT->getNode(BB4)->getDFSNumOut(), 4UL); // Check levels before EXPECT_EQ(DT->getNode(BB0)->getLevel(), 0U); EXPECT_EQ(DT->getNode(BB1)->getLevel(), 1U); EXPECT_EQ(DT->getNode(BB2)->getLevel(), 1U); EXPECT_EQ(DT->getNode(BB4)->getLevel(), 1U); // Reattach block 3 to block 1 and recalculate BB1->getTerminator()->eraseFromParent(); BranchInst::Create(BB4, BB3, ConstantInt::getTrue(F.getContext()), BB1); DT->recalculate(F); // Check DFS Numbers after DT->updateDFSNumbers(); EXPECT_EQ(DT->getNode(BB0)->getDFSNumIn(), 0UL); EXPECT_EQ(DT->getNode(BB0)->getDFSNumOut(), 9UL); EXPECT_EQ(DT->getNode(BB1)->getDFSNumIn(), 1UL); EXPECT_EQ(DT->getNode(BB1)->getDFSNumOut(), 4UL); EXPECT_EQ(DT->getNode(BB2)->getDFSNumIn(), 7UL); EXPECT_EQ(DT->getNode(BB2)->getDFSNumOut(), 8UL); EXPECT_EQ(DT->getNode(BB3)->getDFSNumIn(), 2UL); EXPECT_EQ(DT->getNode(BB3)->getDFSNumOut(), 3UL); EXPECT_EQ(DT->getNode(BB4)->getDFSNumIn(), 5UL); EXPECT_EQ(DT->getNode(BB4)->getDFSNumOut(), 6UL); // Check levels after EXPECT_EQ(DT->getNode(BB0)->getLevel(), 0U); EXPECT_EQ(DT->getNode(BB1)->getLevel(), 1U); EXPECT_EQ(DT->getNode(BB2)->getLevel(), 1U); EXPECT_EQ(DT->getNode(BB3)->getLevel(), 2U); EXPECT_EQ(DT->getNode(BB4)->getLevel(), 1U); // Change root node EXPECT_TRUE(DT->verify()); BasicBlock *NewEntry = BasicBlock::Create(F.getContext(), "new_entry", &F, BB0); BranchInst::Create(BB0, NewEntry); EXPECT_EQ(F.begin()->getName(), NewEntry->getName()); EXPECT_TRUE(&F.getEntryBlock() == NewEntry); DT->setNewRoot(NewEntry); EXPECT_TRUE(DT->verify()); }); } TEST(DominatorTree, NonUniqueEdges) { StringRef ModuleString = "define i32 @f(i32 %i, i32 *%p) {\n" "bb0:\n" " store i32 %i, i32 *%p\n" " switch i32 %i, label %bb2 [\n" " i32 0, label %bb1\n" " i32 1, label %bb1\n" " ]\n" " bb1:\n" " ret i32 1\n" " bb2:\n" " ret i32 4\n" "}\n"; // Parse the module. LLVMContext Context; std::unique_ptr M = makeLLVMModule(Context, ModuleString); runWithDomTree( *M, "f", [&](Function &F, DominatorTree *DT, PostDominatorTree *PDT) { Function::iterator FI = F.begin(); BasicBlock *BB0 = &*FI++; BasicBlock *BB1 = &*FI++; BasicBlock *BB2 = &*FI++; const Instruction *TI = BB0->getTerminator(); assert(TI->getNumSuccessors() == 3 && "Switch has three successors"); BasicBlockEdge Edge_BB0_BB2(BB0, TI->getSuccessor(0)); assert(Edge_BB0_BB2.getEnd() == BB2 && "Default label is the 1st successor"); BasicBlockEdge Edge_BB0_BB1_a(BB0, TI->getSuccessor(1)); assert(Edge_BB0_BB1_a.getEnd() == BB1 && "BB1 is the 2nd successor"); BasicBlockEdge Edge_BB0_BB1_b(BB0, TI->getSuccessor(2)); assert(Edge_BB0_BB1_b.getEnd() == BB1 && "BB1 is the 3rd successor"); EXPECT_TRUE(DT->dominates(Edge_BB0_BB2, BB2)); EXPECT_FALSE(DT->dominates(Edge_BB0_BB2, BB1)); EXPECT_FALSE(DT->dominates(Edge_BB0_BB1_a, BB1)); EXPECT_FALSE(DT->dominates(Edge_BB0_BB1_b, BB1)); EXPECT_FALSE(DT->dominates(Edge_BB0_BB1_a, BB2)); EXPECT_FALSE(DT->dominates(Edge_BB0_BB1_b, BB2)); }); } // Verify that the PDT is correctly updated in case an edge removal results // in a new unreachable CFG node. Also make sure that the updated PDT is the // same as a freshly recalculated one. // // For the following input code and initial PDT: // // CFG PDT // // A Exit // | | // _B D // / | \ | // ^ v \ B // \ / D / \ // C \ C A // v // Exit // // we verify that CFG' and PDT-updated is obtained after removal of edge C -> B. // // CFG' PDT-updated // // A Exit // | / | \ // B C B D // | \ | // v \ A // / D // C \ // | \ // unreachable Exit // // Both the blocks that end with ret and with unreachable become trivial // PostDominatorTree roots, as they have no successors. // TEST(DominatorTree, DeletingEdgesIntroducesUnreachables) { StringRef ModuleString = "define void @f() {\n" "A:\n" " br label %B\n" "B:\n" " br i1 undef, label %D, label %C\n" "C:\n" " br label %B\n" "D:\n" " ret void\n" "}\n"; // Parse the module. LLVMContext Context; std::unique_ptr M = makeLLVMModule(Context, ModuleString); runWithDomTree( *M, "f", [&](Function &F, DominatorTree *DT, PostDominatorTree *PDT) { Function::iterator FI = F.begin(); FI++; BasicBlock *B = &*FI++; BasicBlock *C = &*FI++; BasicBlock *D = &*FI++; ASSERT_TRUE(PDT->dominates(PDT->getNode(D), PDT->getNode(B))); EXPECT_TRUE(DT->verify()); EXPECT_TRUE(PDT->verify()); C->getTerminator()->eraseFromParent(); new UnreachableInst(C->getContext(), C); DT->deleteEdge(C, B); PDT->deleteEdge(C, B); EXPECT_TRUE(DT->verify()); EXPECT_TRUE(PDT->verify()); EXPECT_FALSE(PDT->dominates(PDT->getNode(D), PDT->getNode(B))); EXPECT_NE(PDT->getNode(C), nullptr); DominatorTree NDT(F); EXPECT_EQ(DT->compare(NDT), 0); PostDominatorTree NPDT(F); EXPECT_EQ(PDT->compare(NPDT), 0); }); } // Verify that the PDT is correctly updated in case an edge removal results // in an infinite loop. Also make sure that the updated PDT is the // same as a freshly recalculated one. // // Test case: // // CFG PDT // // A Exit // | | // _B D // / | \ | // ^ v \ B // \ / D / \ // C \ C A // / \ v // ^ v Exit // \_/ // // After deleting the edge C->B, C is part of an infinite reverse-unreachable // loop: // // CFG' PDT' // // A Exit // | / | \ // B C B D // | \ | // v \ A // / D // C \ // / \ v // ^ v Exit // \_/ // // As C now becomes reverse-unreachable, it forms a new non-trivial root and // gets connected to the virtual exit. // D does not postdominate B anymore, because there are two forward paths from // B to the virtual exit: // - B -> C -> VirtualExit // - B -> D -> VirtualExit. // TEST(DominatorTree, DeletingEdgesIntroducesInfiniteLoop) { StringRef ModuleString = "define void @f() {\n" "A:\n" " br label %B\n" "B:\n" " br i1 undef, label %D, label %C\n" "C:\n" " switch i32 undef, label %C [\n" " i32 0, label %B\n" " ]\n" "D:\n" " ret void\n" "}\n"; // Parse the module. LLVMContext Context; std::unique_ptr M = makeLLVMModule(Context, ModuleString); runWithDomTree( *M, "f", [&](Function &F, DominatorTree *DT, PostDominatorTree *PDT) { Function::iterator FI = F.begin(); FI++; BasicBlock *B = &*FI++; BasicBlock *C = &*FI++; BasicBlock *D = &*FI++; ASSERT_TRUE(PDT->dominates(PDT->getNode(D), PDT->getNode(B))); EXPECT_TRUE(DT->verify()); EXPECT_TRUE(PDT->verify()); auto SwitchC = cast(C->getTerminator()); SwitchC->removeCase(SwitchC->case_begin()); DT->deleteEdge(C, B); EXPECT_TRUE(DT->verify()); PDT->deleteEdge(C, B); EXPECT_TRUE(PDT->verify()); EXPECT_FALSE(PDT->dominates(PDT->getNode(D), PDT->getNode(B))); EXPECT_NE(PDT->getNode(C), nullptr); DominatorTree NDT(F); EXPECT_EQ(DT->compare(NDT), 0); PostDominatorTree NPDT(F); EXPECT_EQ(PDT->compare(NPDT), 0); }); } // Verify that the PDT is correctly updated in case an edge removal results // in an infinite loop. // // Test case: // // CFG PDT // // A Exit // | / | \ // B-- C2 B D // | \ / | // v \ C A // / D // C--C2 \ // / \ \ v // ^ v --Exit // \_/ // // After deleting the edge C->E, C is part of an infinite reverse-unreachable // loop: // // CFG' PDT' // // A Exit // | / | \ // B C B D // | \ | // v \ A // / D // C \ // / \ v // ^ v Exit // \_/ // // In PDT, D does not post-dominate B. After the edge C -> C2 is removed, // C becomes a new nontrivial PDT root. // TEST(DominatorTree, DeletingEdgesIntroducesInfiniteLoop2) { StringRef ModuleString = "define void @f() {\n" "A:\n" " br label %B\n" "B:\n" " br i1 undef, label %D, label %C\n" "C:\n" " switch i32 undef, label %C [\n" " i32 0, label %C2\n" " ]\n" "C2:\n" " ret void\n" "D:\n" " ret void\n" "}\n"; // Parse the module. LLVMContext Context; std::unique_ptr M = makeLLVMModule(Context, ModuleString); runWithDomTree( *M, "f", [&](Function &F, DominatorTree *DT, PostDominatorTree *PDT) { Function::iterator FI = F.begin(); FI++; BasicBlock *B = &*FI++; BasicBlock *C = &*FI++; BasicBlock *C2 = &*FI++; BasicBlock *D = &*FI++; EXPECT_TRUE(DT->verify()); EXPECT_TRUE(PDT->verify()); auto SwitchC = cast(C->getTerminator()); SwitchC->removeCase(SwitchC->case_begin()); DT->deleteEdge(C, C2); PDT->deleteEdge(C, C2); C2->removeFromParent(); EXPECT_EQ(DT->getNode(C2), nullptr); PDT->eraseNode(C2); delete C2; EXPECT_TRUE(DT->verify()); EXPECT_TRUE(PDT->verify()); EXPECT_FALSE(PDT->dominates(PDT->getNode(D), PDT->getNode(B))); EXPECT_NE(PDT->getNode(C), nullptr); DominatorTree NDT(F); EXPECT_EQ(DT->compare(NDT), 0); PostDominatorTree NPDT(F); EXPECT_EQ(PDT->compare(NPDT), 0); }); } // Verify that the IDF returns blocks in a deterministic way. // // Test case: // // CFG // // (A) // / \ // / \ // (B) (C) // |\ /| // | X | // |/ \| // (D) (E) // // IDF for block B is {D, E}, and the order of blocks in this list is defined by // their 1) level in dom-tree and 2) DFSIn number if the level is the same. // TEST(DominatorTree, IDFDeterminismTest) { StringRef ModuleString = "define void @f() {\n" "A:\n" " br i1 undef, label %B, label %C\n" "B:\n" " br i1 undef, label %D, label %E\n" "C:\n" " br i1 undef, label %D, label %E\n" "D:\n" " ret void\n" "E:\n" " ret void\n" "}\n"; // Parse the module. LLVMContext Context; std::unique_ptr M = makeLLVMModule(Context, ModuleString); runWithDomTree( *M, "f", [&](Function &F, DominatorTree *DT, PostDominatorTree *PDT) { Function::iterator FI = F.begin(); BasicBlock *A = &*FI++; BasicBlock *B = &*FI++; BasicBlock *C = &*FI++; BasicBlock *D = &*FI++; BasicBlock *E = &*FI++; (void)C; DT->updateDFSNumbers(); ForwardIDFCalculator IDF(*DT); SmallPtrSet DefBlocks; DefBlocks.insert(B); IDF.setDefiningBlocks(DefBlocks); SmallVector IDFBlocks; SmallPtrSet LiveInBlocks; IDF.resetLiveInBlocks(); IDF.calculate(IDFBlocks); EXPECT_EQ(IDFBlocks.size(), 2UL); EXPECT_EQ(DT->getNode(A)->getDFSNumIn(), 0UL); EXPECT_EQ(IDFBlocks[0], D); EXPECT_EQ(IDFBlocks[1], E); EXPECT_TRUE(DT->getNode(IDFBlocks[0])->getDFSNumIn() < DT->getNode(IDFBlocks[1])->getDFSNumIn()); }); } namespace { const auto Insert = CFGBuilder::ActionKind::Insert; const auto Delete = CFGBuilder::ActionKind::Delete; bool CompUpdates(const CFGBuilder::Update &A, const CFGBuilder::Update &B) { return std::tie(A.Action, A.Edge.From, A.Edge.To) < std::tie(B.Action, B.Edge.From, B.Edge.To); } } // namespace TEST(DominatorTree, InsertReachable) { CFGHolder Holder; std::vector Arcs = { {"1", "2"}, {"2", "3"}, {"3", "4"}, {"4", "5"}, {"5", "6"}, {"5", "7"}, {"3", "8"}, {"8", "9"}, {"9", "10"}, {"8", "11"}, {"11", "12"}}; std::vector Updates = {{Insert, {"12", "10"}}, {Insert, {"10", "9"}}, {Insert, {"7", "6"}}, {Insert, {"7", "5"}}}; CFGBuilder B(Holder.F, Arcs, Updates); DominatorTree DT(*Holder.F); EXPECT_TRUE(DT.verify()); PostDominatorTree PDT(*Holder.F); EXPECT_TRUE(PDT.verify()); Optional LastUpdate; while ((LastUpdate = B.applyUpdate())) { EXPECT_EQ(LastUpdate->Action, Insert); BasicBlock *From = B.getOrAddBlock(LastUpdate->Edge.From); BasicBlock *To = B.getOrAddBlock(LastUpdate->Edge.To); DT.insertEdge(From, To); EXPECT_TRUE(DT.verify()); PDT.insertEdge(From, To); EXPECT_TRUE(PDT.verify()); } } TEST(DominatorTree, InsertReachable2) { CFGHolder Holder; std::vector Arcs = { {"1", "2"}, {"2", "3"}, {"3", "4"}, {"4", "5"}, {"5", "6"}, {"5", "7"}, {"7", "5"}, {"2", "8"}, {"8", "11"}, {"11", "12"}, {"12", "10"}, {"10", "9"}, {"9", "10"}}; std::vector Updates = {{Insert, {"10", "7"}}}; CFGBuilder B(Holder.F, Arcs, Updates); DominatorTree DT(*Holder.F); EXPECT_TRUE(DT.verify()); PostDominatorTree PDT(*Holder.F); EXPECT_TRUE(PDT.verify()); Optional LastUpdate = B.applyUpdate(); EXPECT_TRUE(LastUpdate); EXPECT_EQ(LastUpdate->Action, Insert); BasicBlock *From = B.getOrAddBlock(LastUpdate->Edge.From); BasicBlock *To = B.getOrAddBlock(LastUpdate->Edge.To); DT.insertEdge(From, To); EXPECT_TRUE(DT.verify()); PDT.insertEdge(From, To); EXPECT_TRUE(PDT.verify()); } TEST(DominatorTree, InsertUnreachable) { CFGHolder Holder; std::vector Arcs = {{"1", "2"}, {"2", "3"}, {"3", "4"}, {"5", "6"}, {"5", "7"}, {"3", "8"}, {"9", "10"}, {"11", "12"}}; std::vector Updates = {{Insert, {"4", "5"}}, {Insert, {"8", "9"}}, {Insert, {"10", "12"}}, {Insert, {"10", "11"}}}; CFGBuilder B(Holder.F, Arcs, Updates); DominatorTree DT(*Holder.F); EXPECT_TRUE(DT.verify()); PostDominatorTree PDT(*Holder.F); EXPECT_TRUE(PDT.verify()); Optional LastUpdate; while ((LastUpdate = B.applyUpdate())) { EXPECT_EQ(LastUpdate->Action, Insert); BasicBlock *From = B.getOrAddBlock(LastUpdate->Edge.From); BasicBlock *To = B.getOrAddBlock(LastUpdate->Edge.To); DT.insertEdge(From, To); EXPECT_TRUE(DT.verify()); PDT.insertEdge(From, To); EXPECT_TRUE(PDT.verify()); } } TEST(DominatorTree, InsertFromUnreachable) { CFGHolder Holder; std::vector Arcs = {{"1", "2"}, {"2", "3"}, {"3", "4"}}; std::vector Updates = {{Insert, {"3", "5"}}}; CFGBuilder B(Holder.F, Arcs, Updates); PostDominatorTree PDT(*Holder.F); EXPECT_TRUE(PDT.verify()); Optional LastUpdate = B.applyUpdate(); EXPECT_TRUE(LastUpdate); EXPECT_EQ(LastUpdate->Action, Insert); BasicBlock *From = B.getOrAddBlock(LastUpdate->Edge.From); BasicBlock *To = B.getOrAddBlock(LastUpdate->Edge.To); PDT.insertEdge(From, To); EXPECT_TRUE(PDT.verify()); EXPECT_EQ(PDT.root_size(), 2UL); // Make sure we can use a const pointer with getNode. const BasicBlock *BB5 = B.getOrAddBlock("5"); EXPECT_NE(PDT.getNode(BB5), nullptr); } TEST(DominatorTree, InsertMixed) { CFGHolder Holder; std::vector Arcs = { {"1", "2"}, {"2", "3"}, {"3", "4"}, {"5", "6"}, {"5", "7"}, {"8", "9"}, {"9", "10"}, {"8", "11"}, {"11", "12"}, {"7", "3"}}; std::vector Updates = { {Insert, {"4", "5"}}, {Insert, {"2", "5"}}, {Insert, {"10", "9"}}, {Insert, {"12", "10"}}, {Insert, {"12", "10"}}, {Insert, {"7", "8"}}, {Insert, {"7", "5"}}}; CFGBuilder B(Holder.F, Arcs, Updates); DominatorTree DT(*Holder.F); EXPECT_TRUE(DT.verify()); PostDominatorTree PDT(*Holder.F); EXPECT_TRUE(PDT.verify()); Optional LastUpdate; while ((LastUpdate = B.applyUpdate())) { EXPECT_EQ(LastUpdate->Action, Insert); BasicBlock *From = B.getOrAddBlock(LastUpdate->Edge.From); BasicBlock *To = B.getOrAddBlock(LastUpdate->Edge.To); DT.insertEdge(From, To); EXPECT_TRUE(DT.verify()); PDT.insertEdge(From, To); EXPECT_TRUE(PDT.verify()); } } TEST(DominatorTree, InsertPermut) { std::vector Arcs = { {"1", "2"}, {"2", "3"}, {"3", "4"}, {"5", "6"}, {"5", "7"}, {"8", "9"}, {"9", "10"}, {"8", "11"}, {"11", "12"}, {"7", "3"}}; std::vector Updates = {{Insert, {"4", "5"}}, {Insert, {"2", "5"}}, {Insert, {"10", "9"}}, {Insert, {"12", "10"}}}; while (std::next_permutation(Updates.begin(), Updates.end(), CompUpdates)) { CFGHolder Holder; CFGBuilder B(Holder.F, Arcs, Updates); DominatorTree DT(*Holder.F); EXPECT_TRUE(DT.verify()); PostDominatorTree PDT(*Holder.F); EXPECT_TRUE(PDT.verify()); Optional LastUpdate; while ((LastUpdate = B.applyUpdate())) { EXPECT_EQ(LastUpdate->Action, Insert); BasicBlock *From = B.getOrAddBlock(LastUpdate->Edge.From); BasicBlock *To = B.getOrAddBlock(LastUpdate->Edge.To); DT.insertEdge(From, To); EXPECT_TRUE(DT.verify()); PDT.insertEdge(From, To); EXPECT_TRUE(PDT.verify()); } } } TEST(DominatorTree, DeleteReachable) { CFGHolder Holder; std::vector Arcs = { {"1", "2"}, {"2", "3"}, {"2", "4"}, {"3", "4"}, {"4", "5"}, {"5", "6"}, {"5", "7"}, {"7", "8"}, {"3", "8"}, {"8", "9"}, {"9", "10"}, {"10", "2"}}; std::vector Updates = { {Delete, {"2", "4"}}, {Delete, {"7", "8"}}, {Delete, {"10", "2"}}}; CFGBuilder B(Holder.F, Arcs, Updates); DominatorTree DT(*Holder.F); EXPECT_TRUE(DT.verify()); PostDominatorTree PDT(*Holder.F); EXPECT_TRUE(PDT.verify()); Optional LastUpdate; while ((LastUpdate = B.applyUpdate())) { EXPECT_EQ(LastUpdate->Action, Delete); BasicBlock *From = B.getOrAddBlock(LastUpdate->Edge.From); BasicBlock *To = B.getOrAddBlock(LastUpdate->Edge.To); DT.deleteEdge(From, To); EXPECT_TRUE(DT.verify()); PDT.deleteEdge(From, To); EXPECT_TRUE(PDT.verify()); } } TEST(DominatorTree, DeleteUnreachable) { CFGHolder Holder; std::vector Arcs = { {"1", "2"}, {"2", "3"}, {"3", "4"}, {"4", "5"}, {"5", "6"}, {"5", "7"}, {"7", "8"}, {"3", "8"}, {"8", "9"}, {"9", "10"}, {"10", "2"}}; std::vector Updates = { {Delete, {"8", "9"}}, {Delete, {"7", "8"}}, {Delete, {"3", "4"}}}; CFGBuilder B(Holder.F, Arcs, Updates); DominatorTree DT(*Holder.F); EXPECT_TRUE(DT.verify()); PostDominatorTree PDT(*Holder.F); EXPECT_TRUE(PDT.verify()); Optional LastUpdate; while ((LastUpdate = B.applyUpdate())) { EXPECT_EQ(LastUpdate->Action, Delete); BasicBlock *From = B.getOrAddBlock(LastUpdate->Edge.From); BasicBlock *To = B.getOrAddBlock(LastUpdate->Edge.To); DT.deleteEdge(From, To); EXPECT_TRUE(DT.verify()); PDT.deleteEdge(From, To); EXPECT_TRUE(PDT.verify()); } } TEST(DominatorTree, InsertDelete) { std::vector Arcs = { {"1", "2"}, {"2", "3"}, {"3", "4"}, {"4", "5"}, {"5", "6"}, {"5", "7"}, {"3", "8"}, {"8", "9"}, {"9", "10"}, {"8", "11"}, {"11", "12"}}; std::vector Updates = { {Insert, {"2", "4"}}, {Insert, {"12", "10"}}, {Insert, {"10", "9"}}, {Insert, {"7", "6"}}, {Insert, {"7", "5"}}, {Delete, {"3", "8"}}, {Insert, {"10", "7"}}, {Insert, {"2", "8"}}, {Delete, {"3", "4"}}, {Delete, {"8", "9"}}, {Delete, {"11", "12"}}}; CFGHolder Holder; CFGBuilder B(Holder.F, Arcs, Updates); DominatorTree DT(*Holder.F); EXPECT_TRUE(DT.verify()); PostDominatorTree PDT(*Holder.F); EXPECT_TRUE(PDT.verify()); Optional LastUpdate; while ((LastUpdate = B.applyUpdate())) { BasicBlock *From = B.getOrAddBlock(LastUpdate->Edge.From); BasicBlock *To = B.getOrAddBlock(LastUpdate->Edge.To); if (LastUpdate->Action == Insert) { DT.insertEdge(From, To); PDT.insertEdge(From, To); } else { DT.deleteEdge(From, To); PDT.deleteEdge(From, To); } EXPECT_TRUE(DT.verify()); EXPECT_TRUE(PDT.verify()); } } TEST(DominatorTree, InsertDeleteExhaustive) { std::vector Arcs = { {"1", "2"}, {"2", "3"}, {"3", "4"}, {"4", "5"}, {"5", "6"}, {"5", "7"}, {"3", "8"}, {"8", "9"}, {"9", "10"}, {"8", "11"}, {"11", "12"}}; std::vector Updates = { {Insert, {"2", "4"}}, {Insert, {"12", "10"}}, {Insert, {"10", "9"}}, {Insert, {"7", "6"}}, {Insert, {"7", "5"}}, {Delete, {"3", "8"}}, {Insert, {"10", "7"}}, {Insert, {"2", "8"}}, {Delete, {"3", "4"}}, {Delete, {"8", "9"}}, {Delete, {"11", "12"}}}; std::mt19937 Generator(0); for (unsigned i = 0; i < 16; ++i) { std::shuffle(Updates.begin(), Updates.end(), Generator); CFGHolder Holder; CFGBuilder B(Holder.F, Arcs, Updates); DominatorTree DT(*Holder.F); EXPECT_TRUE(DT.verify()); PostDominatorTree PDT(*Holder.F); EXPECT_TRUE(PDT.verify()); Optional LastUpdate; while ((LastUpdate = B.applyUpdate())) { BasicBlock *From = B.getOrAddBlock(LastUpdate->Edge.From); BasicBlock *To = B.getOrAddBlock(LastUpdate->Edge.To); if (LastUpdate->Action == Insert) { DT.insertEdge(From, To); PDT.insertEdge(From, To); } else { DT.deleteEdge(From, To); PDT.deleteEdge(From, To); } EXPECT_TRUE(DT.verify()); EXPECT_TRUE(PDT.verify()); } } } TEST(DominatorTree, InsertIntoIrreducible) { std::vector Arcs = { {"0", "1"}, {"1", "27"}, {"1", "7"}, {"10", "18"}, {"13", "10"}, {"18", "13"}, {"18", "23"}, {"23", "13"}, {"23", "24"}, {"24", "1"}, {"24", "18"}, {"27", "24"}}; CFGHolder Holder; CFGBuilder B(Holder.F, Arcs, {{Insert, {"7", "23"}}}); DominatorTree DT(*Holder.F); EXPECT_TRUE(DT.verify()); B.applyUpdate(); BasicBlock *From = B.getOrAddBlock("7"); BasicBlock *To = B.getOrAddBlock("23"); DT.insertEdge(From, To); EXPECT_TRUE(DT.verify()); } TEST(DominatorTree, EdgeDomination) { StringRef ModuleString = "define i32 @f(i1 %cond) {\n" " bb0:\n" " br i1 %cond, label %bb1, label %bb2\n" " bb1:\n" " br label %bb3\n" " bb2:\n" " br label %bb3\n" " bb3:\n" " ret i32 4" "}\n"; // Parse the module. LLVMContext Context; std::unique_ptr M = makeLLVMModule(Context, ModuleString); runWithDomTree(*M, "f", [&](Function &F, DominatorTree *DT, PostDominatorTree *PDT) { Function::iterator FI = F.begin(); BasicBlock *BB0 = &*FI++; BasicBlock *BB1 = &*FI++; BasicBlock *BB2 = &*FI++; BasicBlock *BB3 = &*FI++; BasicBlockEdge E01(BB0, BB1); BasicBlockEdge E02(BB0, BB2); BasicBlockEdge E13(BB1, BB3); BasicBlockEdge E23(BB2, BB3); EXPECT_TRUE(DT->dominates(E01, E01)); EXPECT_FALSE(DT->dominates(E01, E02)); EXPECT_TRUE(DT->dominates(E01, E13)); EXPECT_FALSE(DT->dominates(E01, E23)); EXPECT_FALSE(DT->dominates(E02, E01)); EXPECT_TRUE(DT->dominates(E02, E02)); EXPECT_FALSE(DT->dominates(E02, E13)); EXPECT_TRUE(DT->dominates(E02, E23)); EXPECT_FALSE(DT->dominates(E13, E01)); EXPECT_FALSE(DT->dominates(E13, E02)); EXPECT_TRUE(DT->dominates(E13, E13)); EXPECT_FALSE(DT->dominates(E13, E23)); EXPECT_FALSE(DT->dominates(E23, E01)); EXPECT_FALSE(DT->dominates(E23, E02)); EXPECT_FALSE(DT->dominates(E23, E13)); EXPECT_TRUE(DT->dominates(E23, E23)); }); } TEST(DominatorTree, ValueDomination) { StringRef ModuleString = R"( @foo = global i8 0 define i8 @f(i8 %arg) { ret i8 %arg } )"; LLVMContext Context; std::unique_ptr M = makeLLVMModule(Context, ModuleString); runWithDomTree(*M, "f", [&](Function &F, DominatorTree *DT, PostDominatorTree *PDT) { Argument *A = F.getArg(0); GlobalValue *G = M->getNamedValue("foo"); Constant *C = ConstantInt::getNullValue(Type::getInt8Ty(Context)); Instruction *I = F.getEntryBlock().getTerminator(); EXPECT_TRUE(DT->dominates(A, I)); EXPECT_TRUE(DT->dominates(G, I)); EXPECT_TRUE(DT->dominates(C, I)); const Use &U = I->getOperandUse(0); EXPECT_TRUE(DT->dominates(A, U)); EXPECT_TRUE(DT->dominates(G, U)); EXPECT_TRUE(DT->dominates(C, U)); }); }