LLVM  16.0.0git
CFG.h
Go to the documentation of this file.
1 //===- CFG.h ----------------------------------------------------*- 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 /// \file
9 ///
10 /// This file provides various utilities for inspecting and working with the
11 /// control flow graph in LLVM IR. This includes generic facilities for
12 /// iterating successors and predecessors of basic blocks, the successors of
13 /// specific terminator instructions, etc. It also defines specializations of
14 /// GraphTraits that allow Function and BasicBlock graphs to be treated as
15 /// proper graphs for generic algorithms.
16 ///
17 //===----------------------------------------------------------------------===//
18 
19 #ifndef LLVM_IR_CFG_H
20 #define LLVM_IR_CFG_H
21 
22 #include "llvm/ADT/GraphTraits.h"
23 #include "llvm/ADT/iterator.h"
25 #include "llvm/IR/BasicBlock.h"
26 #include "llvm/IR/Function.h"
27 #include "llvm/IR/Value.h"
28 #include <cassert>
29 #include <cstddef>
30 #include <iterator>
31 
32 namespace llvm {
33 
34 class Instruction;
35 class Use;
36 
37 //===----------------------------------------------------------------------===//
38 // BasicBlock pred_iterator definition
39 //===----------------------------------------------------------------------===//
40 
41 template <class Ptr, class USE_iterator> // Predecessor Iterator
42 class PredIterator {
43 public:
44  using iterator_category = std::forward_iterator_tag;
45  using value_type = Ptr;
46  using difference_type = std::ptrdiff_t;
47  using pointer = Ptr *;
48  using reference = Ptr *;
49 
50 protected:
52  USE_iterator It;
53 
54  inline void advancePastNonTerminators() {
55  // Loop to ignore non-terminator uses (for example BlockAddresses).
56  while (!It.atEnd()) {
57  if (auto *Inst = dyn_cast<Instruction>(*It))
58  if (Inst->isTerminator())
59  break;
60 
61  ++It;
62  }
63  }
64 
65 public:
66  PredIterator() = default;
67  explicit inline PredIterator(Ptr *bb) : It(bb->user_begin()) {
69  }
70  inline PredIterator(Ptr *bb, bool) : It(bb->user_end()) {}
71 
72  inline bool operator==(const Self& x) const { return It == x.It; }
73  inline bool operator!=(const Self& x) const { return !operator==(x); }
74 
75  inline reference operator*() const {
76  assert(!It.atEnd() && "pred_iterator out of range!");
77  return cast<Instruction>(*It)->getParent();
78  }
79  inline pointer *operator->() const { return &operator*(); }
80 
81  inline Self& operator++() { // Preincrement
82  assert(!It.atEnd() && "pred_iterator out of range!");
84  return *this;
85  }
86 
87  inline Self operator++(int) { // Postincrement
88  Self tmp = *this; ++*this; return tmp;
89  }
90 
91  /// getOperandNo - Return the operand number in the predecessor's
92  /// terminator of the successor.
93  unsigned getOperandNo() const {
94  return It.getOperandNo();
95  }
96 
97  /// getUse - Return the operand Use in the predecessor's terminator
98  /// of the successor.
99  Use &getUse() const {
100  return It.getUse();
101  }
102 };
103 
105 using const_pred_iterator =
109 
112  return const_pred_iterator(BB);
113 }
116  return const_pred_iterator(BB, true);
117 }
118 inline bool pred_empty(const BasicBlock *BB) {
119  return pred_begin(BB) == pred_end(BB);
120 }
121 /// Get the number of predecessors of \p BB. This is a linear time operation.
122 /// Use \ref BasicBlock::hasNPredecessors() or hasNPredecessorsOrMore if able.
123 inline unsigned pred_size(const BasicBlock *BB) {
124  return std::distance(pred_begin(BB), pred_end(BB));
125 }
127  return pred_range(pred_begin(BB), pred_end(BB));
128 }
131 }
132 
133 //===----------------------------------------------------------------------===//
134 // Instruction and BasicBlock succ_iterator helpers
135 //===----------------------------------------------------------------------===//
136 
137 template <class InstructionT, class BlockT>
139  : public iterator_facade_base<SuccIterator<InstructionT, BlockT>,
140  std::random_access_iterator_tag, BlockT, int,
141  BlockT *, BlockT *> {
142 public:
144  using pointer = BlockT *;
145  using reference = BlockT *;
146 
147 private:
148  InstructionT *Inst;
149  int Idx;
151 
152  inline bool index_is_valid(int Idx) {
153  // Note that we specially support the index of zero being valid even in the
154  // face of a null instruction.
155  return Idx >= 0 && (Idx == 0 || Idx <= (int)Inst->getNumSuccessors());
156  }
157 
158  /// Proxy object to allow write access in operator[]
159  class SuccessorProxy {
160  Self It;
161 
162  public:
163  explicit SuccessorProxy(const Self &It) : It(It) {}
164 
165  SuccessorProxy(const SuccessorProxy &) = default;
166 
167  SuccessorProxy &operator=(SuccessorProxy RHS) {
168  *this = reference(RHS);
169  return *this;
170  }
171 
172  SuccessorProxy &operator=(reference RHS) {
173  It.Inst->setSuccessor(It.Idx, RHS);
174  return *this;
175  }
176 
177  operator reference() const { return *It; }
178  };
179 
180 public:
181  // begin iterator
182  explicit inline SuccIterator(InstructionT *Inst) : Inst(Inst), Idx(0) {}
183  // end iterator
184  inline SuccIterator(InstructionT *Inst, bool) : Inst(Inst) {
185  if (Inst)
186  Idx = Inst->getNumSuccessors();
187  else
188  // Inst == NULL happens, if a basic block is not fully constructed and
189  // consequently getTerminator() returns NULL. In this case we construct
190  // a SuccIterator which describes a basic block that has zero
191  // successors.
192  // Defining SuccIterator for incomplete and malformed CFGs is especially
193  // useful for debugging.
194  Idx = 0;
195  }
196 
197  /// This is used to interface between code that wants to
198  /// operate on terminator instructions directly.
199  int getSuccessorIndex() const { return Idx; }
200 
201  inline bool operator==(const Self &x) const { return Idx == x.Idx; }
202 
203  inline BlockT *operator*() const { return Inst->getSuccessor(Idx); }
204 
205  // We use the basic block pointer directly for operator->.
206  inline BlockT *operator->() const { return operator*(); }
207 
208  inline bool operator<(const Self &RHS) const {
209  assert(Inst == RHS.Inst && "Cannot compare iterators of different blocks!");
210  return Idx < RHS.Idx;
211  }
212 
213  int operator-(const Self &RHS) const {
214  assert(Inst == RHS.Inst && "Cannot compare iterators of different blocks!");
215  return Idx - RHS.Idx;
216  }
217 
218  inline Self &operator+=(int RHS) {
219  int NewIdx = Idx + RHS;
220  assert(index_is_valid(NewIdx) && "Iterator index out of bound");
221  Idx = NewIdx;
222  return *this;
223  }
224 
225  inline Self &operator-=(int RHS) { return operator+=(-RHS); }
226 
227  // Specially implement the [] operation using a proxy object to support
228  // assignment.
229  inline SuccessorProxy operator[](int Offset) {
230  Self TmpIt = *this;
231  TmpIt += Offset;
232  return SuccessorProxy(TmpIt);
233  }
234 
235  /// Get the source BlockT of this iterator.
236  inline BlockT *getSource() {
237  assert(Inst && "Source not available, if basic block was malformed");
238  return Inst->getParent();
239  }
240 };
241 
246 
249  return const_succ_iterator(I);
250 }
251 inline succ_iterator succ_end(Instruction *I) { return succ_iterator(I, true); }
253  return const_succ_iterator(I, true);
254 }
255 inline bool succ_empty(const Instruction *I) {
256  return succ_begin(I) == succ_end(I);
257 }
258 inline unsigned succ_size(const Instruction *I) {
259  return std::distance(succ_begin(I), succ_end(I));
260 }
262  return succ_range(succ_begin(I), succ_end(I));
263 }
266 }
267 
269  return succ_iterator(BB->getTerminator());
270 }
272  return const_succ_iterator(BB->getTerminator());
273 }
275  return succ_iterator(BB->getTerminator(), true);
276 }
278  return const_succ_iterator(BB->getTerminator(), true);
279 }
280 inline bool succ_empty(const BasicBlock *BB) {
281  return succ_begin(BB) == succ_end(BB);
282 }
283 inline unsigned succ_size(const BasicBlock *BB) {
284  return std::distance(succ_begin(BB), succ_end(BB));
285 }
287  return succ_range(succ_begin(BB), succ_end(BB));
288 }
291 }
292 
293 //===--------------------------------------------------------------------===//
294 // GraphTraits specializations for basic block graphs (CFGs)
295 //===--------------------------------------------------------------------===//
296 
297 // Provide specializations of GraphTraits to be able to treat a function as a
298 // graph of basic blocks...
299 
300 template <> struct GraphTraits<BasicBlock*> {
301  using NodeRef = BasicBlock *;
303 
304  static NodeRef getEntryNode(BasicBlock *BB) { return BB; }
307 };
308 
309 template <> struct GraphTraits<const BasicBlock*> {
310  using NodeRef = const BasicBlock *;
312 
313  static NodeRef getEntryNode(const BasicBlock *BB) { return BB; }
314 
317 };
318 
319 // Provide specializations of GraphTraits to be able to treat a function as a
320 // graph of basic blocks... and to walk it in inverse order. Inverse order for
321 // a function is considered to be when traversing the predecessor edges of a BB
322 // instead of the successor edges.
323 //
324 template <> struct GraphTraits<Inverse<BasicBlock*>> {
325  using NodeRef = BasicBlock *;
327 
328  static NodeRef getEntryNode(Inverse<BasicBlock *> G) { return G.Graph; }
331 };
332 
333 template <> struct GraphTraits<Inverse<const BasicBlock*>> {
334  using NodeRef = const BasicBlock *;
336 
340 };
341 
342 //===--------------------------------------------------------------------===//
343 // GraphTraits specializations for function basic block graphs (CFGs)
344 //===--------------------------------------------------------------------===//
345 
346 // Provide specializations of GraphTraits to be able to treat a function as a
347 // graph of basic blocks... these are the same as the basic block iterators,
348 // except that the root node is implicitly the first node of the function.
349 //
350 template <> struct GraphTraits<Function*> : public GraphTraits<BasicBlock*> {
351  static NodeRef getEntryNode(Function *F) { return &F->getEntryBlock(); }
352 
353  // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
355 
357  return nodes_iterator(F->begin());
358  }
359 
361  return nodes_iterator(F->end());
362  }
363 
364  static size_t size(Function *F) { return F->size(); }
365 };
366 template <> struct GraphTraits<const Function*> :
368  static NodeRef getEntryNode(const Function *F) { return &F->getEntryBlock(); }
369 
370  // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
372 
374  return nodes_iterator(F->begin());
375  }
376 
378  return nodes_iterator(F->end());
379  }
380 
381  static size_t size(const Function *F) { return F->size(); }
382 };
383 
384 // Provide specializations of GraphTraits to be able to treat a function as a
385 // graph of basic blocks... and to walk it in inverse order. Inverse order for
386 // a function is considered to be when traversing the predecessor edges of a BB
387 // instead of the successor edges.
388 //
389 template <> struct GraphTraits<Inverse<Function*>> :
392  return &G.Graph->getEntryBlock();
393  }
394 };
395 template <> struct GraphTraits<Inverse<const Function*>> :
398  return &G.Graph->getEntryBlock();
399  }
400 };
401 
402 } // end namespace llvm
403 
404 #endif // LLVM_IR_CFG_H
llvm::SuccIterator::operator-
int operator-(const Self &RHS) const
Definition: CFG.h:213
llvm::SuccIterator
Definition: CFG.h:138
llvm::GraphTraits< BasicBlock * >::getEntryNode
static NodeRef getEntryNode(BasicBlock *BB)
Definition: CFG.h:304
llvm::SuccIterator::operator==
bool operator==(const Self &x) const
Definition: CFG.h:201
llvm::GraphTraits< Inverse< BasicBlock * > >::child_end
static ChildIteratorType child_end(NodeRef N)
Definition: CFG.h:330
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::GraphTraits< Inverse< const Function * > >::getEntryNode
static NodeRef getEntryNode(Inverse< const Function * > G)
Definition: CFG.h:397
llvm::succ_end
Interval::succ_iterator succ_end(Interval *I)
Definition: Interval.h:102
llvm::Function
Definition: Function.h:60
llvm::SuccIterator::SuccIterator
SuccIterator(InstructionT *Inst, bool)
Definition: CFG.h:184
llvm::pred_size
unsigned pred_size(MachineBasicBlock *BB)
Definition: MachineSSAContext.h:32
llvm::SuccIterator::pointer
BlockT * pointer
Definition: CFG.h:144
llvm::GraphTraits< Inverse< BasicBlock * > >::child_begin
static ChildIteratorType child_begin(NodeRef N)
Definition: CFG.h:329
llvm::GraphTraits< const BasicBlock * >::child_begin
static ChildIteratorType child_begin(NodeRef N)
Definition: CFG.h:315
llvm::GraphTraits< BasicBlock * >::child_end
static ChildIteratorType child_end(NodeRef N)
Definition: CFG.h:306
llvm::successors
auto successors(MachineBasicBlock *BB)
Definition: MachineSSAContext.h:29
RHS
Value * RHS
Definition: X86PartialReduction.cpp:76
tmp
alloca< 16 x float >, align 16 %tmp2=alloca< 16 x float >, align 16 store< 16 x float > %A,< 16 x float > *%tmp %s=bitcast< 16 x float > *%tmp to i8 *%s2=bitcast< 16 x float > *%tmp2 to i8 *call void @llvm.memcpy.i64(i8 *%s, i8 *%s2, i64 64, i32 16) %R=load< 16 x float > *%tmp2 ret< 16 x float > %R } declare void @llvm.memcpy.i64(i8 *nocapture, i8 *nocapture, i64, i32) nounwind which compiles to:_foo:subl $140, %esp movaps %xmm3, 112(%esp) movaps %xmm2, 96(%esp) movaps %xmm1, 80(%esp) movaps %xmm0, 64(%esp) movl 60(%esp), %eax movl %eax, 124(%esp) movl 56(%esp), %eax movl %eax, 120(%esp) movl 52(%esp), %eax< many many more 32-bit copies > movaps(%esp), %xmm0 movaps 16(%esp), %xmm1 movaps 32(%esp), %xmm2 movaps 48(%esp), %xmm3 addl $140, %esp ret On Nehalem, it may even be cheaper to just use movups when unaligned than to fall back to lower-granularity chunks. Implement processor-specific optimizations for parity with GCC on these processors. GCC does two optimizations:1. ix86_pad_returns inserts a noop before ret instructions if immediately preceded by a conditional branch or is the target of a jump. 2. ix86_avoid_jump_misspredicts inserts noops in cases where a 16-byte block of code contains more than 3 branches. The first one is done for all AMDs, Core2, and "Generic" The second one is done for:Atom, Pentium Pro, all AMDs, Pentium 4, Nocona, Core 2, and "Generic" Testcase:int x(int a) { return(a &0xf0)> >4 tmp
Definition: README.txt:1347
llvm::const_pred_iterator
PredIterator< const BasicBlock, Value::const_user_iterator > const_pred_iterator
Definition: CFG.h:106
llvm::succ_empty
bool succ_empty(const Instruction *I)
Definition: CFG.h:255
llvm::PredIterator::getOperandNo
unsigned getOperandNo() const
getOperandNo - Return the operand number in the predecessor's terminator of the successor.
Definition: CFG.h:93
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:55
llvm::PredIterator::operator*
reference operator*() const
Definition: CFG.h:75
GraphTraits.h
llvm::GraphTraits< const Function * >::nodes_begin
static nodes_iterator nodes_begin(const Function *F)
Definition: CFG.h:373
bb
< i1 > br i1 label label bb bb
Definition: README.txt:978
llvm::PredIterator::operator!=
bool operator!=(const Self &x) const
Definition: CFG.h:73
llvm::GraphTraits< Inverse< const BasicBlock * > >::getEntryNode
static NodeRef getEntryNode(Inverse< const BasicBlock * > G)
Definition: CFG.h:337
llvm::GraphTraits< Function * >::nodes_end
static nodes_iterator nodes_end(Function *F)
Definition: CFG.h:360
llvm::PredIterator::advancePastNonTerminators
void advancePastNonTerminators()
Definition: CFG.h:54
int
Clang compiles this i1 i64 store i64 i64 store i64 i64 store i64 i64 store i64 align Which gets codegen d xmm0 movaps rbp movaps rbp movaps rbp movaps rbp rbp rbp rbp rbp It would be better to have movq s of instead of the movaps s LLVM produces ret int
Definition: README.txt:536
llvm::GraphTraits< Inverse< Function * > >::getEntryNode
static NodeRef getEntryNode(Inverse< Function * > G)
Definition: CFG.h:391
llvm::succ_size
unsigned succ_size(MachineBasicBlock *BB)
Definition: MachineSSAContext.h:31
llvm::Instruction
Definition: Instruction.h:42
llvm::predecessors
auto predecessors(MachineBasicBlock *BB)
Definition: MachineSSAContext.h:30
llvm::SuccIterator::operator-=
Self & operator-=(int RHS)
Definition: CFG.h:225
llvm::GraphTraits< Inverse< const BasicBlock * > >::child_begin
static ChildIteratorType child_begin(NodeRef N)
Definition: CFG.h:338
llvm::GraphTraits< Function * >::nodes_begin
static nodes_iterator nodes_begin(Function *F)
Definition: CFG.h:356
llvm::SuccIterator::getSource
BlockT * getSource()
Get the source BlockT of this iterator.
Definition: CFG.h:236
llvm::SuccIterator::operator*
BlockT * operator*() const
Definition: CFG.h:203
llvm::GraphTraits< const BasicBlock * >::child_end
static ChildIteratorType child_end(NodeRef N)
Definition: CFG.h:316
G
const DataFlowGraph & G
Definition: RDFGraph.cpp:200
llvm::pointer_iterator
Definition: iterator.h:344
llvm::PredIterator::value_type
Ptr value_type
Definition: CFG.h:45
BasicBlock.h
llvm::PredIterator::difference_type
std::ptrdiff_t difference_type
Definition: CFG.h:46
llvm::GraphTraits< Inverse< BasicBlock * > >::getEntryNode
static NodeRef getEntryNode(Inverse< BasicBlock * > G)
Definition: CFG.h:328
llvm::succ_range
iterator_range< succ_iterator > succ_range
Definition: CFG.h:244
llvm::SuccIterator::SuccIterator
SuccIterator(InstructionT *Inst)
Definition: CFG.h:182
const
aarch64 promote const
Definition: AArch64PromoteConstant.cpp:232
llvm::PredIterator::operator++
Self & operator++()
Definition: CFG.h:81
llvm::GraphTraits< const Function * >::nodes_end
static nodes_iterator nodes_end(const Function *F)
Definition: CFG.h:377
iterator.h
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::succ_begin
Interval::succ_iterator succ_begin(Interval *I)
succ_begin/succ_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:99
llvm::iterator_facade_base
CRTP base class which implements the entire standard iterator facade in terms of a minimal subset of ...
Definition: iterator.h:80
llvm::const_succ_range
iterator_range< const_succ_iterator > const_succ_range
Definition: CFG.h:245
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::PredIterator::It
USE_iterator It
Definition: CFG.h:52
llvm::SuccIterator::reference
BlockT * reference
Definition: CFG.h:145
llvm::GraphTraits< BasicBlock * >::child_begin
static ChildIteratorType child_begin(NodeRef N)
Definition: CFG.h:305
llvm::SuccIterator::difference_type
int difference_type
Definition: CFG.h:143
Ptr
@ Ptr
Definition: TargetLibraryInfo.cpp:60
iterator_range.h
llvm::GraphTraits< const BasicBlock * >
Definition: CFG.h:309
llvm::PredIterator::operator->
pointer * operator->() const
Definition: CFG.h:79
llvm::pred_empty
bool pred_empty(const BasicBlock *BB)
Definition: CFG.h:118
llvm::PredIterator
Definition: CFG.h:42
llvm::GraphTraits< Function * >::size
static size_t size(Function *F)
Definition: CFG.h:364
llvm::const_pred_range
iterator_range< const_pred_iterator > const_pred_range
Definition: CFG.h:108
llvm::pred_iterator
PredIterator< BasicBlock, Value::user_iterator > pred_iterator
Definition: CFG.h:104
llvm::PredIterator::getUse
Use & getUse() const
getUse - Return the operand Use in the predecessor's terminator of the successor.
Definition: CFG.h:99
llvm::pred_end
Interval::pred_iterator pred_end(Interval *I)
Definition: Interval.h:112
Function.h
x
TODO unsigned x
Definition: README.txt:10
llvm::SuccIterator::getSuccessorIndex
int getSuccessorIndex() const
This is used to interface between code that wants to operate on terminator instructions directly.
Definition: CFG.h:199
llvm::Inverse
Definition: GraphTraits.h:97
llvm::PredIterator::operator==
bool operator==(const Self &x) const
Definition: CFG.h:72
llvm::PredIterator::operator++
Self operator++(int)
Definition: CFG.h:87
llvm::pred_begin
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:109
llvm::GraphTraits< const Function * >::size
static size_t size(const Function *F)
Definition: CFG.h:381
llvm::GraphTraits< const Function * >::getEntryNode
static NodeRef getEntryNode(const Function *F)
Definition: CFG.h:368
llvm::PredIterator::PredIterator
PredIterator(Ptr *bb, bool)
Definition: CFG.h:70
llvm::GraphTraits< Function * >::getEntryNode
static NodeRef getEntryNode(Function *F)
Definition: CFG.h:351
llvm::pred_range
iterator_range< pred_iterator > pred_range
Definition: CFG.h:107
llvm::GraphTraits< BasicBlock * >
Definition: CFG.h:300
llvm::PredIterator::pointer
Ptr * pointer
Definition: CFG.h:47
N
#define N
llvm::SuccIterator::operator[]
SuccessorProxy operator[](int Offset)
Definition: CFG.h:229
llvm::iterator_range
A range adaptor for a pair of iterators.
Definition: iterator_range.h:30
llvm::PredIterator::PredIterator
PredIterator(Ptr *bb)
Definition: CFG.h:67
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::succ_iterator
SuccIterator< Instruction, BasicBlock > succ_iterator
Definition: CFG.h:242
llvm::PredIterator::PredIterator
PredIterator()=default
llvm::GraphTraits
Definition: GraphTraits.h:37
llvm::const_succ_iterator
SuccIterator< const Instruction, const BasicBlock > const_succ_iterator
Definition: CFG.h:243
llvm::PredIterator::reference
Ptr * reference
Definition: CFG.h:48
llvm::PredIterator::iterator_category
std::forward_iterator_tag iterator_category
Definition: CFG.h:44
llvm::SuccIterator::operator+=
Self & operator+=(int RHS)
Definition: CFG.h:218
Value.h
llvm::SuccIterator::operator<
bool operator<(const Self &RHS) const
Definition: CFG.h:208
llvm::GraphTraits< const BasicBlock * >::getEntryNode
static NodeRef getEntryNode(const BasicBlock *BB)
Definition: CFG.h:313
llvm::GraphTraits< Inverse< const BasicBlock * > >::child_end
static ChildIteratorType child_end(NodeRef N)
Definition: CFG.h:339
llvm::SuccIterator::operator->
BlockT * operator->() const
Definition: CFG.h:206
llvm::Use
A Use represents the edge between a Value definition and its users.
Definition: Use.h:43