LLVM  16.0.0git
Dominators.h
Go to the documentation of this file.
1 //===- Dominators.h - Dominator Info Calculation ----------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines the DominatorTree class, which provides fast and efficient
10 // dominance queries.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_IR_DOMINATORS_H
15 #define LLVM_IR_DOMINATORS_H
16 
17 #include "llvm/ADT/APInt.h"
18 #include "llvm/ADT/ArrayRef.h"
19 #include "llvm/ADT/DenseMap.h"
20 #include "llvm/ADT/DenseMapInfo.h"
22 #include "llvm/ADT/Hashing.h"
24 #include "llvm/ADT/SmallVector.h"
25 #include "llvm/ADT/Twine.h"
28 #include "llvm/IR/BasicBlock.h"
29 #include "llvm/IR/CFG.h"
30 #include "llvm/IR/PassManager.h"
31 #include "llvm/IR/Use.h"
32 #include "llvm/Pass.h"
33 #include "llvm/Support/CFGDiff.h"
34 #include "llvm/Support/CFGUpdate.h"
37 #include <algorithm>
38 #include <utility>
39 #include <vector>
40 
41 namespace llvm {
42 
43 class Function;
44 class Instruction;
45 class Module;
46 class Value;
47 class raw_ostream;
48 template <class GraphType> struct GraphTraits;
49 
50 extern template class DomTreeNodeBase<BasicBlock>;
51 extern template class DominatorTreeBase<BasicBlock, false>; // DomTree
52 extern template class DominatorTreeBase<BasicBlock, true>; // PostDomTree
53 
54 extern template class cfg::Update<BasicBlock *>;
55 
56 namespace DomTreeBuilder {
59 
61 
64 
65 extern template void Calculate<BBDomTree>(BBDomTree &DT);
66 extern template void CalculateWithUpdates<BBDomTree>(BBDomTree &DT,
67  BBUpdates U);
68 
69 extern template void Calculate<BBPostDomTree>(BBPostDomTree &DT);
70 
71 extern template void InsertEdge<BBDomTree>(BBDomTree &DT, BasicBlock *From,
72  BasicBlock *To);
73 extern template void InsertEdge<BBPostDomTree>(BBPostDomTree &DT,
75  BasicBlock *To);
76 
77 extern template void DeleteEdge<BBDomTree>(BBDomTree &DT, BasicBlock *From,
78  BasicBlock *To);
79 extern template void DeleteEdge<BBPostDomTree>(BBPostDomTree &DT,
81  BasicBlock *To);
82 
83 extern template void ApplyUpdates<BBDomTree>(BBDomTree &DT,
86 extern template void ApplyUpdates<BBPostDomTree>(BBPostDomTree &DT,
89 
90 extern template bool Verify<BBDomTree>(const BBDomTree &DT,
92 extern template bool Verify<BBPostDomTree>(const BBPostDomTree &DT,
94 } // namespace DomTreeBuilder
95 
97 
99  const BasicBlock *Start;
100  const BasicBlock *End;
101 
102 public:
103  BasicBlockEdge(const BasicBlock *Start_, const BasicBlock *End_) :
104  Start(Start_), End(End_) {}
105 
106  BasicBlockEdge(const std::pair<BasicBlock *, BasicBlock *> &Pair)
107  : Start(Pair.first), End(Pair.second) {}
108 
109  BasicBlockEdge(const std::pair<const BasicBlock *, const BasicBlock *> &Pair)
110  : Start(Pair.first), End(Pair.second) {}
111 
112  const BasicBlock *getStart() const {
113  return Start;
114  }
115 
116  const BasicBlock *getEnd() const {
117  return End;
118  }
119 
120  /// Check if this is the only edge between Start and End.
121  bool isSingleEdge() const;
122 };
123 
124 template <> struct DenseMapInfo<BasicBlockEdge> {
126 
127  static unsigned getHashValue(const BasicBlockEdge *V);
128 
129  static inline BasicBlockEdge getEmptyKey() {
130  return BasicBlockEdge(BBInfo::getEmptyKey(), BBInfo::getEmptyKey());
131  }
132 
133  static inline BasicBlockEdge getTombstoneKey() {
134  return BasicBlockEdge(BBInfo::getTombstoneKey(), BBInfo::getTombstoneKey());
135  }
136 
137  static unsigned getHashValue(const BasicBlockEdge &Edge) {
138  return hash_combine(BBInfo::getHashValue(Edge.getStart()),
139  BBInfo::getHashValue(Edge.getEnd()));
140  }
141 
142  static bool isEqual(const BasicBlockEdge &LHS, const BasicBlockEdge &RHS) {
143  return BBInfo::isEqual(LHS.getStart(), RHS.getStart()) &&
144  BBInfo::isEqual(LHS.getEnd(), RHS.getEnd());
145  }
146 };
147 
148 /// Concrete subclass of DominatorTreeBase that is used to compute a
149 /// normal dominator tree.
150 ///
151 /// Definition: A block is said to be forward statically reachable if there is
152 /// a path from the entry of the function to the block. A statically reachable
153 /// block may become statically unreachable during optimization.
154 ///
155 /// A forward unreachable block may appear in the dominator tree, or it may
156 /// not. If it does, dominance queries will return results as if all reachable
157 /// blocks dominate it. When asking for a Node corresponding to a potentially
158 /// unreachable block, calling code must handle the case where the block was
159 /// unreachable and the result of getNode() is nullptr.
160 ///
161 /// Generally, a block known to be unreachable when the dominator tree is
162 /// constructed will not be in the tree. One which becomes unreachable after
163 /// the dominator tree is initially constructed may still exist in the tree,
164 /// even if the tree is properly updated. Calling code should not rely on the
165 /// preceding statements; this is stated only to assist human understanding.
167  public:
169 
170  DominatorTree() = default;
171  explicit DominatorTree(Function &F) { recalculate(F); }
173  recalculate(*DT.Parent, U);
174  }
175 
176  /// Handle invalidation explicitly.
177  bool invalidate(Function &F, const PreservedAnalyses &PA,
179 
180  // Ensure base-class overloads are visible.
181  using Base::dominates;
182 
183  /// Return true if the (end of the) basic block BB dominates the use U.
184  bool dominates(const BasicBlock *BB, const Use &U) const;
185 
186  /// Return true if value Def dominates use U, in the sense that Def is
187  /// available at U, and could be substituted as the used value without
188  /// violating the SSA dominance requirement.
189  ///
190  /// In particular, it is worth noting that:
191  /// * Non-instruction Defs dominate everything.
192  /// * Def does not dominate a use in Def itself (outside of degenerate cases
193  /// like unreachable code or trivial phi cycles).
194  /// * Invoke/callbr Defs only dominate uses in their default destination.
195  bool dominates(const Value *Def, const Use &U) const;
196  /// Return true if value Def dominates all possible uses inside instruction
197  /// User. Same comments as for the Use-based API apply.
198  bool dominates(const Value *Def, const Instruction *User) const;
199  // Does not accept Value to avoid ambiguity with dominance checks between
200  // two basic blocks.
201  bool dominates(const Instruction *Def, const BasicBlock *BB) const;
202 
203  /// Return true if an edge dominates a use.
204  ///
205  /// If BBE is not a unique edge between start and end of the edge, it can
206  /// never dominate the use.
207  bool dominates(const BasicBlockEdge &BBE, const Use &U) const;
208  bool dominates(const BasicBlockEdge &BBE, const BasicBlock *BB) const;
209  /// Returns true if edge \p BBE1 dominates edge \p BBE2.
210  bool dominates(const BasicBlockEdge &BBE1, const BasicBlockEdge &BBE2) const;
211 
212  // Ensure base class overloads are visible.
213  using Base::isReachableFromEntry;
214 
215  /// Provide an overload for a Use.
216  bool isReachableFromEntry(const Use &U) const;
217 
218  // Pop up a GraphViz/gv window with the Dominator Tree rendered using `dot`.
219  void viewGraph(const Twine &Name, const Twine &Title);
220  void viewGraph();
221 };
222 
223 //===-------------------------------------
224 // DominatorTree GraphTraits specializations so the DominatorTree can be
225 // iterable by generic graph iterators.
226 
227 template <class Node, class ChildIterator> struct DomTreeGraphTraitsBase {
228  using NodeRef = Node *;
229  using ChildIteratorType = ChildIterator;
231 
232  static NodeRef getEntryNode(NodeRef N) { return N; }
233  static ChildIteratorType child_begin(NodeRef N) { return N->begin(); }
234  static ChildIteratorType child_end(NodeRef N) { return N->end(); }
235 
237  return df_begin(getEntryNode(N));
238  }
239 
240  static nodes_iterator nodes_end(NodeRef N) { return df_end(getEntryNode(N)); }
241 };
242 
243 template <>
246 };
247 
248 template <>
250  : public DomTreeGraphTraitsBase<const DomTreeNode,
252 
253 template <> struct GraphTraits<DominatorTree*>
254  : public GraphTraits<DomTreeNode*> {
255  static NodeRef getEntryNode(DominatorTree *DT) { return DT->getRootNode(); }
256 
258  return df_begin(getEntryNode(N));
259  }
260 
262  return df_end(getEntryNode(N));
263  }
264 };
265 
266 /// Analysis pass which computes a \c DominatorTree.
267 class DominatorTreeAnalysis : public AnalysisInfoMixin<DominatorTreeAnalysis> {
269  static AnalysisKey Key;
270 
271 public:
272  /// Provide the result typedef for this analysis pass.
274 
275  /// Run the analysis pass over a function and produce a dominator tree.
277 };
278 
279 /// Printer pass for the \c DominatorTree.
281  : public PassInfoMixin<DominatorTreePrinterPass> {
282  raw_ostream &OS;
283 
284 public:
286 
288 };
289 
290 /// Verifier pass for the \c DominatorTree.
291 struct DominatorTreeVerifierPass : PassInfoMixin<DominatorTreeVerifierPass> {
293 };
294 
295 /// Enables verification of dominator trees.
296 ///
297 /// This check is expensive and is disabled by default. `-verify-dom-info`
298 /// allows selectively enabling the check without needing to recompile.
299 extern bool VerifyDomInfo;
300 
301 /// Legacy analysis pass which computes a \c DominatorTree.
303  DominatorTree DT;
304 
305 public:
306  static char ID;
307 
309 
310  DominatorTree &getDomTree() { return DT; }
311  const DominatorTree &getDomTree() const { return DT; }
312 
313  bool runOnFunction(Function &F) override;
314 
315  void verifyAnalysis() const override;
316 
317  void getAnalysisUsage(AnalysisUsage &AU) const override {
318  AU.setPreservesAll();
319  }
320 
321  void releaseMemory() override { DT.reset(); }
322 
323  void print(raw_ostream &OS, const Module *M = nullptr) const override;
324 };
325 } // end namespace llvm
326 
327 #endif // LLVM_IR_DOMINATORS_H
llvm::PreservedAnalyses
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:152
llvm::DominatorTreeWrapperPass::ID
static char ID
Definition: Dominators.h:306
llvm::DomTreeBuilder::Verify< BBPostDomTree >
template bool Verify< BBPostDomTree >(const BBPostDomTree &DT, BBPostDomTree::VerificationLevel VL)
CFGUpdate.h
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::tgtok::Def
@ Def
Definition: TGLexer.h:50
llvm::DenseMapInfo< BasicBlockEdge >::isEqual
static bool isEqual(const BasicBlockEdge &LHS, const BasicBlockEdge &RHS)
Definition: Dominators.h:142
llvm::DominatorTreeWrapperPass::releaseMemory
void releaseMemory() override
releaseMemory() - This member can be implemented by a pass if it wants to be able to release its memo...
Definition: Dominators.h:321
llvm::GraphTraits< DomTreeNode * >
Definition: Dominators.h:244
llvm::PassInfoMixin
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:371
llvm::DomTreeBuilder::CalculateWithUpdates< BBDomTree >
template void CalculateWithUpdates< BBDomTree >(BBDomTree &DT, BBUpdates U)
llvm::DominatorTreeWrapperPass::getDomTree
const DominatorTree & getDomTree() const
Definition: Dominators.h:311
llvm::Function
Definition: Function.h:60
Pass.h
llvm::DomTreeNode
DomTreeNodeBase< BasicBlock > DomTreeNode
Definition: Dominators.h:96
llvm::DomTreeBuilder::ApplyUpdates< BBPostDomTree >
template void ApplyUpdates< BBPostDomTree >(BBPostDomTree &DT, BBPostDomTreeGraphDiff &, BBPostDomTreeGraphDiff *)
llvm::df_end
df_iterator< T > df_end(const T &G)
Definition: DepthFirstIterator.h:224
llvm::DominatorTree
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:166
APInt.h
DenseMap.h
llvm::DomTreeGraphTraitsBase< const VPDomTreeNode, VPDomTreeNode::const_iterator >::ChildIteratorType
VPDomTreeNode::const_iterator ChildIteratorType
Definition: Dominators.h:229
llvm::BasicBlockEdge
Definition: Dominators.h:98
llvm::DominatorTreeWrapperPass::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: Dominators.h:317
Hashing.h
RHS
Value * RHS
Definition: X86PartialReduction.cpp:76
llvm::DominatorTreePrinterPass
Printer pass for the DominatorTree.
Definition: Dominators.h:280
Use.h
DepthFirstIterator.h
llvm::DominatorTreeWrapperPass::print
void print(raw_ostream &OS, const Module *M=nullptr) const override
print - Print out the internal state of the pass.
Definition: Dominators.cpp:424
llvm::DomTreeGraphTraitsBase::nodes_end
static nodes_iterator nodes_end(NodeRef N)
Definition: Dominators.h:240
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::GraphDiff
Definition: CFGDiff.h:57
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:55
PointerIntPair.h
CFGDiff.h
llvm::GraphTraits< DominatorTree * >::getEntryNode
static NodeRef getEntryNode(DominatorTree *DT)
Definition: Dominators.h:255
llvm::DominatorTree::DominatorTree
DominatorTree(Function &F)
Definition: Dominators.h:171
LHS
Value * LHS
Definition: X86PartialReduction.cpp:75
llvm::DenseMapInfo
An information struct used to provide DenseMap with the various necessary components for a given valu...
Definition: APInt.h:34
llvm::DenseMapInfo< BasicBlockEdge >::getEmptyKey
static BasicBlockEdge getEmptyKey()
Definition: Dominators.h:129
llvm::DomTreeBuilder::InsertEdge< BBDomTree >
template void InsertEdge< BBDomTree >(BBDomTree &DT, BasicBlock *From, BasicBlock *To)
llvm::DominatorTreeBase::getRootNode
DomTreeNodeBase< NodeT > * getRootNode()
getRootNode - This returns the entry node for the CFG of the function.
Definition: GenericDomTree.h:370
llvm::User
Definition: User.h:44
Twine.h
llvm::DomTreeGraphTraitsBase
Definition: Dominators.h:227
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
llvm::BasicBlockEdge::BasicBlockEdge
BasicBlockEdge(const BasicBlock *Start_, const BasicBlock *End_)
Definition: Dominators.h:103
llvm::DomTreeBuilder::DeleteEdge< BBPostDomTree >
template void DeleteEdge< BBPostDomTree >(BBPostDomTree &DT, BasicBlock *From, BasicBlock *To)
llvm::Instruction
Definition: Instruction.h:42
llvm::DominatorTreeWrapperPass
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:302
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
dominates
static bool dominates(MachineBasicBlock &MBB, MachineBasicBlock::const_iterator A, MachineBasicBlock::const_iterator B)
Definition: RegAllocFast.cpp:343
llvm::BasicBlockEdge::getStart
const BasicBlock * getStart() const
Definition: Dominators.h:112
llvm::DomTreeBuilder::Verify< BBDomTree >
template bool Verify< BBDomTree >(const BBDomTree &DT, BBDomTree::VerificationLevel VL)
llvm::AnalysisManager::Invalidator
API to communicate dependencies between analyses during invalidation.
Definition: PassManager.h:661
llvm::DominatorTreePrinterPass::run
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
Definition: Dominators.cpp:378
llvm::DomTreeBuilder::DeleteEdge< BBDomTree >
template void DeleteEdge< BBDomTree >(BBDomTree &DT, BasicBlock *From, BasicBlock *To)
CFG.h
BasicBlock.h
const
aarch64 promote const
Definition: AArch64PromoteConstant.cpp:232
llvm::DominatorTree::DominatorTree
DominatorTree(DominatorTree &DT, DomTreeBuilder::BBUpdates U)
Definition: Dominators.h:172
llvm::AnalysisKey
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:69
ArrayRef.h
llvm::df_begin
df_iterator< T > df_begin(const T &G)
Definition: DepthFirstIterator.h:219
llvm::BasicBlockEdge::BasicBlockEdge
BasicBlockEdge(const std::pair< BasicBlock *, BasicBlock * > &Pair)
Definition: Dominators.h:106
iterator_range.h
llvm::DenseMapInfo< BasicBlockEdge >::getHashValue
static unsigned getHashValue(const BasicBlockEdge &Edge)
Definition: Dominators.h:137
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::AnalysisInfoMixin
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition: PassManager.h:394
llvm::df_iterator
Definition: DepthFirstIterator.h:86
llvm::DominatorTreeAnalysis::run
DominatorTree run(Function &F, FunctionAnalysisManager &)
Run the analysis pass over a function and produce a dominator tree.
Definition: Dominators.cpp:367
llvm::DominatorTreeBase::reset
void reset()
Definition: GenericDomTree.h:806
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::BasicBlockEdge::BasicBlockEdge
BasicBlockEdge(const std::pair< const BasicBlock *, const BasicBlock * > &Pair)
Definition: Dominators.h:109
llvm::BasicBlockEdge::getEnd
const BasicBlock * getEnd() const
Definition: Dominators.h:116
llvm::DomTreeGraphTraitsBase::getEntryNode
static NodeRef getEntryNode(NodeRef N)
Definition: Dominators.h:232
llvm::DominatorTreeWrapperPass::verifyAnalysis
void verifyAnalysis() const override
verifyAnalysis() - This member can be implemented by a analysis pass to check state of analysis infor...
Definition: Dominators.cpp:417
Module
Machine Check Debug Module
Definition: MachineCheckDebugify.cpp:122
llvm::DominatorTreeBase::Parent
ParentPtr Parent
Definition: GenericDomTree.h:255
llvm::DominatorTreeBase
Core dominator tree base class.
Definition: LoopInfo.h:65
Node
Definition: ItaniumDemangle.h:155
llvm::GraphTraits< DominatorTree * >::nodes_begin
static nodes_iterator nodes_begin(DominatorTree *N)
Definition: Dominators.h:257
llvm::DomTreeNodeBase< BasicBlock >
llvm::DomTreeGraphTraitsBase::nodes_begin
static nodes_iterator nodes_begin(NodeRef N)
Definition: Dominators.h:236
llvm::DominatorTreeWrapperPass::runOnFunction
bool runOnFunction(Function &F) override
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass.
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
llvm::AnalysisUsage::setPreservesAll
void setPreservesAll()
Set by analyses that do not transform their input at all.
Definition: PassAnalysisSupport.h:130
GenericDomTree.h
llvm::DenseMapInfo< BasicBlockEdge >::getTombstoneKey
static BasicBlockEdge getTombstoneKey()
Definition: Dominators.h:133
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
PassManager.h
GenericDomTreeConstruction.h
isEqual
static bool isEqual(const Function &Caller, const Function &Callee)
Definition: Attributes.cpp:1869
llvm::DominatorTreeWrapperPass::getDomTree
DominatorTree & getDomTree()
Definition: Dominators.h:310
llvm::DominatorTreeBase::VerificationLevel
VerificationLevel
Definition: GenericDomTree.h:245
llvm::DenseMapInfo< BasicBlockEdge >
Definition: Dominators.h:124
llvm::DominatorTreeAnalysis
Analysis pass which computes a DominatorTree.
Definition: Dominators.h:267
llvm::DomTreeBuilder::Calculate< BBPostDomTree >
template void Calculate< BBPostDomTree >(BBPostDomTree &DT)
llvm::DomTreeNodeBase< BasicBlock >::const_iterator
typename SmallVector< DomTreeNodeBase *, 4 >::const_iterator const_iterator
Definition: GenericDomTree.h:73
llvm::DominatorTreePrinterPass::DominatorTreePrinterPass
DominatorTreePrinterPass(raw_ostream &OS)
Definition: Dominators.cpp:376
SmallVector.h
llvm::hash_combine
hash_code hash_combine(const Ts &...args)
Combine values into a single hash_code.
Definition: Hashing.h:605
llvm::DomTreeBuilder::ApplyUpdates< BBDomTree >
template void ApplyUpdates< BBDomTree >(BBDomTree &DT, BBDomTreeGraphDiff &, BBDomTreeGraphDiff *)
llvm::DomTreeGraphTraitsBase::child_end
static ChildIteratorType child_end(NodeRef N)
Definition: Dominators.h:234
N
#define N
llvm::GraphTraits< DominatorTree * >::nodes_end
static nodes_iterator nodes_end(DominatorTree *N)
Definition: Dominators.h:261
DenseMapInfo.h
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:42
llvm::FunctionPass
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:308
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::GraphTraits
Definition: GraphTraits.h:37
From
BlockVerifier::State From
Definition: BlockVerifier.cpp:55
llvm::DomTreeBuilder::Calculate< BBDomTree >
template void Calculate< BBDomTree >(BBDomTree &DT)
llvm::DominatorTreeVerifierPass::run
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
Definition: Dominators.cpp:386
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::DomTreeGraphTraitsBase::child_begin
static ChildIteratorType child_begin(NodeRef N)
Definition: Dominators.h:233
ilist_iterator.h
llvm::DominatorTreeVerifierPass
Verifier pass for the DominatorTree.
Definition: Dominators.h:291
llvm::codeview::PublicSymFlags::Function
@ Function
llvm::VerifyDomInfo
bool VerifyDomInfo
Enables verification of dominator trees.
Definition: Dominators.cpp:39
llvm::DomTreeBuilder::InsertEdge< BBPostDomTree >
template void InsertEdge< BBPostDomTree >(BBPostDomTree &DT, BasicBlock *From, BasicBlock *To)
llvm::Use
A Use represents the edge between a Value definition and its users.
Definition: Use.h:43
llvm::DominatorTreeWrapperPass::DominatorTreeWrapperPass
DominatorTreeWrapperPass()
Definition: Dominators.cpp:405