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