[llvm] r304721 - Handle non-unique edges in edge-dominance
Adam Nemet via llvm-commits
llvm-commits at lists.llvm.org
Mon Jun 5 09:27:10 PDT 2017
Author: anemet
Date: Mon Jun 5 11:27:09 2017
New Revision: 304721
URL: http://llvm.org/viewvc/llvm-project?rev=304721&view=rev
Log:
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
Modified:
llvm/trunk/include/llvm/IR/Dominators.h
llvm/trunk/lib/IR/Dominators.cpp
llvm/trunk/unittests/IR/DominatorTreeTest.cpp
Modified: llvm/trunk/include/llvm/IR/Dominators.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/IR/Dominators.h?rev=304721&r1=304720&r2=304721&view=diff
==============================================================================
--- llvm/trunk/include/llvm/IR/Dominators.h (original)
+++ llvm/trunk/include/llvm/IR/Dominators.h Mon Jun 5 11:27:09 2017
@@ -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;
Modified: llvm/trunk/lib/IR/Dominators.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/IR/Dominators.cpp?rev=304721&r1=304720&r2=304721&view=diff
==============================================================================
--- llvm/trunk/lib/IR/Dominators.cpp (original)
+++ llvm/trunk/lib/IR/Dominators.cpp Mon Jun 5 11:27:09 2017
@@ -150,12 +150,6 @@ bool DominatorTree::dominates(const Inst
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 Basi
// 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 Basi
}
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<Instruction>(U.getUser());
// A PHI in the end of the edge is dominated by it.
PHINode *PN = dyn_cast<PHINode>(UserInst);
Modified: llvm/trunk/unittests/IR/DominatorTreeTest.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/IR/DominatorTreeTest.cpp?rev=304721&r1=304720&r2=304721&view=diff
==============================================================================
--- llvm/trunk/unittests/IR/DominatorTreeTest.cpp (original)
+++ llvm/trunk/unittests/IR/DominatorTreeTest.cpp Mon Jun 5 11:27:09 2017
@@ -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<Module> M = makeLLVMModule(Context, ModuleString);
+
+ runWithDomTree(
+ *M, "f",
+ [&](Function &F, DominatorTree *DT, DominatorTreeBase<BasicBlock> *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));
+ });
+}
More information about the llvm-commits
mailing list