LLVM  4.0.0
Dominators.cpp
Go to the documentation of this file.
1 //===- Dominators.cpp - Dominator Calculation -----------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements simple dominator construction algorithms for finding
11 // forward dominators. Postdominators are available in libanalysis, but are not
12 // included in libvmcore, because it's not needed. Forward dominators are
13 // needed to support the Verifier pass.
14 //
15 //===----------------------------------------------------------------------===//
16 
17 #include "llvm/IR/Dominators.h"
19 #include "llvm/ADT/SmallPtrSet.h"
20 #include "llvm/IR/CFG.h"
21 #include "llvm/IR/Instructions.h"
22 #include "llvm/IR/PassManager.h"
24 #include "llvm/Support/Debug.h"
27 #include <algorithm>
28 using namespace llvm;
29 
30 // Always verify dominfo if expensive checking is enabled.
31 #ifdef EXPENSIVE_CHECKS
32 static bool VerifyDomInfo = true;
33 #else
34 static bool VerifyDomInfo = false;
35 #endif
36 static cl::opt<bool,true>
37 VerifyDomInfoX("verify-dom-info", cl::location(VerifyDomInfo),
38  cl::desc("Verify dominator info (time consuming)"));
39 
41  const TerminatorInst *TI = Start->getTerminator();
42  unsigned NumEdgesToEnd = 0;
43  for (unsigned int i = 0, n = TI->getNumSuccessors(); i < n; ++i) {
44  if (TI->getSuccessor(i) == End)
45  ++NumEdgesToEnd;
46  if (NumEdgesToEnd >= 2)
47  return false;
48  }
49  assert(NumEdgesToEnd == 1);
50  return true;
51 }
52 
53 //===----------------------------------------------------------------------===//
54 // DominatorTree Implementation
55 //===----------------------------------------------------------------------===//
56 //
57 // Provide public access to DominatorTree information. Implementation details
58 // can be found in Dominators.h, GenericDomTree.h, and
59 // GenericDomTreeConstruction.h.
60 //
61 //===----------------------------------------------------------------------===//
62 
65 
68  typename std::remove_pointer<GraphTraits<BasicBlock *>::NodeRef>::type>
69  &DT,
70  Function &F);
71 template void llvm::Calculate<Function, Inverse<BasicBlock *>>(
72  DominatorTreeBase<typename std::remove_pointer<
73  GraphTraits<Inverse<BasicBlock *>>::NodeRef>::type> &DT,
74  Function &F);
75 
76 // dominates - Return true if Def dominates a use in User. This performs
77 // the special checks necessary if Def and User are in the same basic block.
78 // Note that Def doesn't dominate a use in Def itself!
80  const Instruction *User) const {
81  const BasicBlock *UseBB = User->getParent();
82  const BasicBlock *DefBB = Def->getParent();
83 
84  // Any unreachable use is dominated, even if Def == User.
85  if (!isReachableFromEntry(UseBB))
86  return true;
87 
88  // Unreachable definitions don't dominate anything.
89  if (!isReachableFromEntry(DefBB))
90  return false;
91 
92  // An instruction doesn't dominate a use in itself.
93  if (Def == User)
94  return false;
95 
96  // The value defined by an invoke dominates an instruction only if it
97  // dominates every instruction in UseBB.
98  // A PHI is dominated only if the instruction dominates every possible use in
99  // the UseBB.
100  if (isa<InvokeInst>(Def) || isa<PHINode>(User))
101  return dominates(Def, UseBB);
102 
103  if (DefBB != UseBB)
104  return dominates(DefBB, UseBB);
105 
106  // Loop through the basic block until we find Def or User.
108  for (; &*I != Def && &*I != User; ++I)
109  /*empty*/;
110 
111  return &*I == Def;
112 }
113 
114 // true if Def would dominate a use in any instruction in UseBB.
115 // note that dominates(Def, Def->getParent()) is false.
117  const BasicBlock *UseBB) const {
118  const BasicBlock *DefBB = Def->getParent();
119 
120  // Any unreachable use is dominated, even if DefBB == UseBB.
121  if (!isReachableFromEntry(UseBB))
122  return true;
123 
124  // Unreachable definitions don't dominate anything.
125  if (!isReachableFromEntry(DefBB))
126  return false;
127 
128  if (DefBB == UseBB)
129  return false;
130 
131  // Invoke results are only usable in the normal destination, not in the
132  // exceptional destination.
133  if (const auto *II = dyn_cast<InvokeInst>(Def)) {
134  BasicBlock *NormalDest = II->getNormalDest();
135  BasicBlockEdge E(DefBB, NormalDest);
136  return dominates(E, UseBB);
137  }
138 
139  return dominates(DefBB, UseBB);
140 }
141 
143  const BasicBlock *UseBB) const {
144  // Assert that we have a single edge. We could handle them by simply
145  // returning false, but since isSingleEdge is linear on the number of
146  // edges, the callers can normally handle them more efficiently.
147  assert(BBE.isSingleEdge() &&
148  "This function is not efficient in handling multiple edges");
149 
150  // If the BB the edge ends in doesn't dominate the use BB, then the
151  // edge also doesn't.
152  const BasicBlock *Start = BBE.getStart();
153  const BasicBlock *End = BBE.getEnd();
154  if (!dominates(End, UseBB))
155  return false;
156 
157  // Simple case: if the end BB has a single predecessor, the fact that it
158  // dominates the use block implies that the edge also does.
159  if (End->getSinglePredecessor())
160  return true;
161 
162  // The normal edge from the invoke is critical. Conceptually, what we would
163  // like to do is split it and check if the new block dominates the use.
164  // With X being the new block, the graph would look like:
165  //
166  // DefBB
167  // /\ . .
168  // / \ . .
169  // / \ . .
170  // / \ | |
171  // A X B C
172  // | \ | /
173  // . \|/
174  // . NormalDest
175  // .
176  //
177  // Given the definition of dominance, NormalDest is dominated by X iff X
178  // dominates all of NormalDest's predecessors (X, B, C in the example). X
179  // trivially dominates itself, so we only have to find if it dominates the
180  // other predecessors. Since the only way out of X is via NormalDest, X can
181  // only properly dominate a node if NormalDest dominates that node too.
182  for (const_pred_iterator PI = pred_begin(End), E = pred_end(End);
183  PI != E; ++PI) {
184  const BasicBlock *BB = *PI;
185  if (BB == Start)
186  continue;
187 
188  if (!dominates(End, BB))
189  return false;
190  }
191  return true;
192 }
193 
194 bool DominatorTree::dominates(const BasicBlockEdge &BBE, const Use &U) const {
195  // Assert that we have a single edge. We could handle them by simply
196  // returning false, but since isSingleEdge is linear on the number of
197  // edges, the callers can normally handle them more efficiently.
198  assert(BBE.isSingleEdge() &&
199  "This function is not efficient in handling multiple edges");
200 
201  Instruction *UserInst = cast<Instruction>(U.getUser());
202  // A PHI in the end of the edge is dominated by it.
203  PHINode *PN = dyn_cast<PHINode>(UserInst);
204  if (PN && PN->getParent() == BBE.getEnd() &&
205  PN->getIncomingBlock(U) == BBE.getStart())
206  return true;
207 
208  // Otherwise use the edge-dominates-block query, which
209  // handles the crazy critical edge cases properly.
210  const BasicBlock *UseBB;
211  if (PN)
212  UseBB = PN->getIncomingBlock(U);
213  else
214  UseBB = UserInst->getParent();
215  return dominates(BBE, UseBB);
216 }
217 
218 bool DominatorTree::dominates(const Instruction *Def, const Use &U) const {
219  Instruction *UserInst = cast<Instruction>(U.getUser());
220  const BasicBlock *DefBB = Def->getParent();
221 
222  // Determine the block in which the use happens. PHI nodes use
223  // their operands on edges; simulate this by thinking of the use
224  // happening at the end of the predecessor block.
225  const BasicBlock *UseBB;
226  if (PHINode *PN = dyn_cast<PHINode>(UserInst))
227  UseBB = PN->getIncomingBlock(U);
228  else
229  UseBB = UserInst->getParent();
230 
231  // Any unreachable use is dominated, even if Def == User.
232  if (!isReachableFromEntry(UseBB))
233  return true;
234 
235  // Unreachable definitions don't dominate anything.
236  if (!isReachableFromEntry(DefBB))
237  return false;
238 
239  // Invoke instructions define their return values on the edges to their normal
240  // successors, so we have to handle them specially.
241  // Among other things, this means they don't dominate anything in
242  // their own block, except possibly a phi, so we don't need to
243  // walk the block in any case.
244  if (const InvokeInst *II = dyn_cast<InvokeInst>(Def)) {
245  BasicBlock *NormalDest = II->getNormalDest();
246  BasicBlockEdge E(DefBB, NormalDest);
247  return dominates(E, U);
248  }
249 
250  // If the def and use are in different blocks, do a simple CFG dominator
251  // tree query.
252  if (DefBB != UseBB)
253  return dominates(DefBB, UseBB);
254 
255  // Ok, def and use are in the same block. If the def is an invoke, it
256  // doesn't dominate anything in the block. If it's a PHI, it dominates
257  // everything in the block.
258  if (isa<PHINode>(UserInst))
259  return true;
260 
261  // Otherwise, just loop through the basic block until we find Def or User.
262  BasicBlock::const_iterator I = DefBB->begin();
263  for (; &*I != Def && &*I != UserInst; ++I)
264  /*empty*/;
265 
266  return &*I != UserInst;
267 }
268 
271 
272  // ConstantExprs aren't really reachable from the entry block, but they
273  // don't need to be treated like unreachable code either.
274  if (!I) return true;
275 
276  // PHI nodes use their operands on their incoming edges.
277  if (PHINode *PN = dyn_cast<PHINode>(I))
278  return isReachableFromEntry(PN->getIncomingBlock(U));
279 
280  // Everything else uses their operands in their own block.
281  return isReachableFromEntry(I->getParent());
282 }
283 
285  Function &F = *getRoot()->getParent();
286 
287  DominatorTree OtherDT;
288  OtherDT.recalculate(F);
289  if (compare(OtherDT)) {
290  errs() << "DominatorTree is not up to date!\nComputed:\n";
291  print(errs());
292  errs() << "\nActual:\n";
293  OtherDT.print(errs());
294  abort();
295  }
296 }
297 
298 //===----------------------------------------------------------------------===//
299 // DominatorTreeAnalysis and related pass implementations
300 //===----------------------------------------------------------------------===//
301 //
302 // This implements the DominatorTreeAnalysis which is used with the new pass
303 // manager. It also implements some methods from utility passes.
304 //
305 //===----------------------------------------------------------------------===//
306 
309  DominatorTree DT;
310  DT.recalculate(F);
311  return DT;
312 }
313 
314 AnalysisKey DominatorTreeAnalysis::Key;
315 
317 
320  OS << "DominatorTree for function: " << F.getName() << "\n";
321  AM.getResult<DominatorTreeAnalysis>(F).print(OS);
322 
323  return PreservedAnalyses::all();
324 }
325 
328  AM.getResult<DominatorTreeAnalysis>(F).verifyDomTree();
329 
330  return PreservedAnalyses::all();
331 }
332 
333 //===----------------------------------------------------------------------===//
334 // DominatorTreeWrapperPass Implementation
335 //===----------------------------------------------------------------------===//
336 //
337 // The implementation details of the wrapper pass that holds a DominatorTree
338 // suitable for use with the legacy pass manager.
339 //
340 //===----------------------------------------------------------------------===//
341 
344  "Dominator Tree Construction", true, true)
345 
346 bool DominatorTreeWrapperPass::runOnFunction(Function &F) {
347  DT.recalculate(F);
348  return false;
349 }
350 
352  if (VerifyDomInfo)
353  DT.verifyDomTree();
354 }
355 
357  DT.print(OS);
358 }
359 
bool compare(const DominatorTree &Other) const
Returns false if the other dominator tree matches this dominator tree.
Definition: Dominators.h:107
static bool VerifyDomInfo
Definition: Dominators.cpp:34
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
size_t i
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
template void Calculate< Function, BasicBlock * >(DominatorTreeBaseByGraphTraits< GraphTraits< BasicBlock * >> &DT, Function &F)
const BasicBlock * getStart() const
Definition: Dominators.h:49
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:100
Analysis pass which computes a DominatorTree.
Definition: Dominators.h:189
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:191
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:228
void verifyAnalysis() const override
verifyAnalysis() - This member can be implemented by a analysis pass to check state of analysis infor...
Definition: Dominators.cpp:351
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
#define F(x, y, z)
Definition: MD5.cpp:51
bool isReachableFromEntry(const Use &U) const
Provide an overload for a Use.
Definition: Dominators.cpp:269
Base class for the actual dominator tree node.
DominatorTreePrinterPass(raw_ostream &OS)
Definition: Dominators.cpp:316
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:96
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
unsigned getNumSuccessors() const
Return the number of successors that this terminator has.
Definition: InstrTypes.h:74
Subclasses of this class are all able to terminate a basic block.
Definition: InstrTypes.h:52
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:107
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs...ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:653
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
BasicBlock * getSuccessor(unsigned idx) const
Return the specified successor.
Definition: InstrTypes.h:79
DominatorTree run(Function &F, FunctionAnalysisManager &)
Run the analysis pass over a function and produce a dominator tree.
Definition: Dominators.cpp:307
Interval::pred_iterator pred_begin(Interval *I)
pred_begin/pred_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:116
static const unsigned End
User * getUser() const
Returns the User that contains this Use.
Definition: Use.cpp:41
Interval::pred_iterator pred_end(Interval *I)
Definition: Interval.h:119
void verifyDomTree() const
Verify the correctness of the domtree by re-computing it.
Definition: Dominators.cpp:284
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:113
static cl::opt< bool, true > VerifyDomInfoX("verify-dom-info", cl::location(VerifyDomInfo), cl::desc("Verify dominator info (time consuming)"))
const BasicBlock * getEnd() const
Definition: Dominators.h:52
bool dominates(const Instruction *Def, const Use &U) const
Return true if Def dominates a use in User.
Definition: Dominators.cpp:218
Iterator for intrusive lists based on ilist_node.
Generic dominator tree construction - This file provides routines to construct immediate dominator in...
void print(raw_ostream &OS, const Module *M=nullptr) const override
print - Print out the internal state of the pass.
Definition: Dominators.cpp:356
BasicBlock * getSinglePredecessor()
Return the predecessor of this block if it has a single predecessor block.
Definition: BasicBlock.cpp:226
INITIALIZE_PASS(DominatorTreeWrapperPass,"domtree","Dominator Tree Construction", true, true) bool DominatorTreeWrapperPass
Definition: Dominators.cpp:343
void print(raw_ostream &o) const
print - Convert to human readable form
#define I(x, y, z)
Definition: MD5.cpp:54
TerminatorInst * getTerminator()
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:124
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:287
bool isSingleEdge() const
Definition: Dominators.cpp:40
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
Definition: Dominators.cpp:318
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
Invoke instruction.
void recalculate(FT &F)
recalculate - compute a dominator tree for the given function
A container for analyses that lazily runs them and caches their results.
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:217
This header defines various interfaces for pass management in LLVM.
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:64
LocationClass< Ty > location(Ty &L)
Definition: CommandLine.h:411
const BasicBlock * getParent() const
Definition: Instruction.h:62
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
Definition: Dominators.cpp:326