From 8008a8a9545e2e4585776541d96a5af0a57d12d1 Mon Sep 17 00:00:00 2001 From: Adam Nemet Date: Mon, 5 Jun 2017 16:27:09 +0000 Subject: [PATCH] Handle non-unique edges in edge-dominance This removes a quadratic behavior in assert-enabled builds. GVN propagates the equivalence from a condition into the blocks guarded by the condition. E.g. for 'if (a == 7) { ... }', 'a' will be replaced in the block with 7. It does this by replacing all the uses of 'a' that are dominated by the true edge. For a switch with N cases and U uses of the value, this will mean N * U calls to 'dominates'. Asserting isSingleEdge in 'dominates' make this N^2 * U because this function checks for the uniqueness of the edge. I.e. traverses each edge between the SwitchInst's block and the cases. The change removes the assert and makes 'dominates' works correctly in the presence of non-unique edges. This brings build time down by an order of magnitude for an input that has ~10k cases in a switch statement. Differential Revision: https://reviews.llvm.org/D33584 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@304721 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/IR/Dominators.h | 6 ++++ lib/IR/Dominators.cpp | 20 ++++-------- unittests/IR/DominatorTreeTest.cpp | 52 ++++++++++++++++++++++++++++++ 3 files changed, 65 insertions(+), 13 deletions(-) diff --git a/include/llvm/IR/Dominators.h b/include/llvm/IR/Dominators.h index def91e73eb1..9be6acc3359 100644 --- a/include/llvm/IR/Dominators.h +++ b/include/llvm/IR/Dominators.h @@ -66,6 +66,7 @@ public: return End; } + /// Check if this is the only edge between Start and End. bool isSingleEdge() const; }; @@ -143,6 +144,11 @@ public: bool dominates(const Instruction *Def, const Use &U) const; bool dominates(const Instruction *Def, const Instruction *User) const; bool dominates(const Instruction *Def, const BasicBlock *BB) const; + + /// Return true if an edge dominates a use. + /// + /// If BBE is not a unique edge between start and end of the edge, it can + /// never dominate the use. bool dominates(const BasicBlockEdge &BBE, const Use &U) const; bool dominates(const BasicBlockEdge &BBE, const BasicBlock *BB) const; diff --git a/lib/IR/Dominators.cpp b/lib/IR/Dominators.cpp index 44948cc5831..37e735251fd 100644 --- a/lib/IR/Dominators.cpp +++ b/lib/IR/Dominators.cpp @@ -150,12 +150,6 @@ bool DominatorTree::dominates(const Instruction *Def, bool DominatorTree::dominates(const BasicBlockEdge &BBE, const BasicBlock *UseBB) const { - // Assert that we have a single edge. We could handle them by simply - // returning false, but since isSingleEdge is linear on the number of - // edges, the callers can normally handle them more efficiently. - assert(BBE.isSingleEdge() && - "This function is not efficient in handling multiple edges"); - // If the BB the edge ends in doesn't dominate the use BB, then the // edge also doesn't. const BasicBlock *Start = BBE.getStart(); @@ -188,11 +182,17 @@ bool DominatorTree::dominates(const BasicBlockEdge &BBE, // trivially dominates itself, so we only have to find if it dominates the // other predecessors. Since the only way out of X is via NormalDest, X can // only properly dominate a node if NormalDest dominates that node too. + int IsDuplicateEdge = 0; for (const_pred_iterator PI = pred_begin(End), E = pred_end(End); PI != E; ++PI) { const BasicBlock *BB = *PI; - if (BB == Start) + if (BB == Start) { + // If there are multiple edges between Start and End, by definition they + // can't dominate anything. + if (IsDuplicateEdge++) + return false; continue; + } if (!dominates(End, BB)) return false; @@ -201,12 +201,6 @@ bool DominatorTree::dominates(const BasicBlockEdge &BBE, } bool DominatorTree::dominates(const BasicBlockEdge &BBE, const Use &U) const { - // Assert that we have a single edge. We could handle them by simply - // returning false, but since isSingleEdge is linear on the number of - // edges, the callers can normally handle them more efficiently. - assert(BBE.isSingleEdge() && - "This function is not efficient in handling multiple edges"); - Instruction *UserInst = cast(U.getUser()); // A PHI in the end of the edge is dominated by it. PHINode *PN = dyn_cast(UserInst); diff --git a/unittests/IR/DominatorTreeTest.cpp b/unittests/IR/DominatorTreeTest.cpp index d2062839a73..232f0cbd4ed 100644 --- a/unittests/IR/DominatorTreeTest.cpp +++ b/unittests/IR/DominatorTreeTest.cpp @@ -257,3 +257,55 @@ TEST(DominatorTree, Unreachable) { DT->verifyDomTree(); }); } + +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, DominatorTreeBase *PDT) { + Function::iterator FI = F.begin(); + + BasicBlock *BB0 = &*FI++; + BasicBlock *BB1 = &*FI++; + BasicBlock *BB2 = &*FI++; + + const TerminatorInst *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)); + }); +} -- 2.40.0