LLVM  14.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/Function.h"
26 #include "llvm/IR/Value.h"
27 #include "llvm/Support/Casting.h"
28 #include <cassert>
29 #include <cstddef>
30 #include <iterator>
31 
32 namespace llvm {
33 
34 class BasicBlock;
35 class Instruction;
36 class Use;
37 
38 //===----------------------------------------------------------------------===//
39 // BasicBlock pred_iterator definition
40 //===----------------------------------------------------------------------===//
41 
42 template <class Ptr, class USE_iterator> // Predecessor Iterator
43 class PredIterator {
44 public:
45  using iterator_category = std::forward_iterator_tag;
46  using value_type = Ptr;
47  using difference_type = std::ptrdiff_t;
48  using pointer = Ptr *;
49  using reference = Ptr *;
50 
51 private:
53  USE_iterator It;
54 
55  inline void advancePastNonTerminators() {
56  // Loop to ignore non-terminator uses (for example BlockAddresses).
57  while (!It.atEnd()) {
58  if (auto *Inst = dyn_cast<Instruction>(*It))
59  if (Inst->isTerminator())
60  break;
61 
62  ++It;
63  }
64  }
65 
66 public:
67  PredIterator() = default;
68  explicit inline PredIterator(Ptr *bb) : It(bb->user_begin()) {
69  advancePastNonTerminators();
70  }
71  inline PredIterator(Ptr *bb, bool) : It(bb->user_end()) {}
72 
73  inline bool operator==(const Self& x) const { return It == x.It; }
74  inline bool operator!=(const Self& x) const { return !operator==(x); }
75 
76  inline reference operator*() const {
77  assert(!It.atEnd() && "pred_iterator out of range!");
78  return cast<Instruction>(*It)->getParent();
79  }
80  inline pointer *operator->() const { return &operator*(); }
81 
82  inline Self& operator++() { // Preincrement
83  assert(!It.atEnd() && "pred_iterator out of range!");
84  ++It; advancePastNonTerminators();
85  return *this;
86  }
87 
88  inline Self operator++(int) { // Postincrement
89  Self tmp = *this; ++*this; return tmp;
90  }
91 
92  /// getOperandNo - Return the operand number in the predecessor's
93  /// terminator of the successor.
94  unsigned getOperandNo() const {
95  return It.getOperandNo();
96  }
97 
98  /// getUse - Return the operand Use in the predecessor's terminator
99  /// of the successor.
100  Use &getUse() const {
101  return It.getUse();
102  }
103 };
104 
106 using const_pred_iterator =
110 
113  return const_pred_iterator(BB);
114 }
117  return const_pred_iterator(BB, true);
118 }
119 inline bool pred_empty(const BasicBlock *BB) {
120  return pred_begin(BB) == pred_end(BB);
121 }
122 /// Get the number of predecessors of \p BB. This is a linear time operation.
123 /// Use \ref BasicBlock::hasNPredecessors() or hasNPredecessorsOrMore if able.
124 inline unsigned pred_size(const BasicBlock *BB) {
125  return std::distance(pred_begin(BB), pred_end(BB));
126 }
128  return pred_range(pred_begin(BB), pred_end(BB));
129 }
132 }
133 
134 //===----------------------------------------------------------------------===//
135 // Instruction and BasicBlock succ_iterator helpers
136 //===----------------------------------------------------------------------===//
137 
138 template <class InstructionT, class BlockT>
140  : public iterator_facade_base<SuccIterator<InstructionT, BlockT>,
141  std::random_access_iterator_tag, BlockT, int,
142  BlockT *, BlockT *> {
143 public:
145  using pointer = BlockT *;
146  using reference = BlockT *;
147 
148 private:
149  InstructionT *Inst;
150  int Idx;
152 
153  inline bool index_is_valid(int Idx) {
154  // Note that we specially support the index of zero being valid even in the
155  // face of a null instruction.
156  return Idx >= 0 && (Idx == 0 || Idx <= (int)Inst->getNumSuccessors());
157  }
158 
159  /// Proxy object to allow write access in operator[]
160  class SuccessorProxy {
161  Self It;
162 
163  public:
164  explicit SuccessorProxy(const Self &It) : It(It) {}
165 
166  SuccessorProxy(const SuccessorProxy &) = default;
167 
168  SuccessorProxy &operator=(SuccessorProxy RHS) {
169  *this = reference(RHS);
170  return *this;
171  }
172 
173  SuccessorProxy &operator=(reference RHS) {
174  It.Inst->setSuccessor(It.Idx, RHS);
175  return *this;
176  }
177 
178  operator reference() const { return *It; }
179  };
180 
181 public:
182  // begin iterator
183  explicit inline SuccIterator(InstructionT *Inst) : Inst(Inst), Idx(0) {}
184  // end iterator
185  inline SuccIterator(InstructionT *Inst, bool) : Inst(Inst) {
186  if (Inst)
187  Idx = Inst->getNumSuccessors();
188  else
189  // Inst == NULL happens, if a basic block is not fully constructed and
190  // consequently getTerminator() returns NULL. In this case we construct
191  // a SuccIterator which describes a basic block that has zero
192  // successors.
193  // Defining SuccIterator for incomplete and malformed CFGs is especially
194  // useful for debugging.
195  Idx = 0;
196  }
197 
198  /// This is used to interface between code that wants to
199  /// operate on terminator instructions directly.
200  int getSuccessorIndex() const { return Idx; }
201 
202  inline bool operator==(const Self &x) const { return Idx == x.Idx; }
203 
204  inline BlockT *operator*() const { return Inst->getSuccessor(Idx); }
205 
206  // We use the basic block pointer directly for operator->.
207  inline BlockT *operator->() const { return operator*(); }
208 
209  inline bool operator<(const Self &RHS) const {
210  assert(Inst == RHS.Inst && "Cannot compare iterators of different blocks!");
211  return Idx < RHS.Idx;
212  }
213 
214  int operator-(const Self &RHS) const {
215  assert(Inst == RHS.Inst && "Cannot compare iterators of different blocks!");
216  return Idx - RHS.Idx;
217  }
218 
219  inline Self &operator+=(int RHS) {
220  int NewIdx = Idx + RHS;
221  assert(index_is_valid(NewIdx) && "Iterator index out of bound");
222  Idx = NewIdx;
223  return *this;
224  }
225 
226  inline Self &operator-=(int RHS) { return operator+=(-RHS); }
227 
228  // Specially implement the [] operation using a proxy object to support
229  // assignment.
230  inline SuccessorProxy operator[](int Offset) {
231  Self TmpIt = *this;
232  TmpIt += Offset;
233  return SuccessorProxy(TmpIt);
234  }
235 
236  /// Get the source BlockT of this iterator.
237  inline BlockT *getSource() {
238  assert(Inst && "Source not available, if basic block was malformed");
239  return Inst->getParent();
240  }
241 };
242 
247 
250  return const_succ_iterator(I);
251 }
252 inline succ_iterator succ_end(Instruction *I) { return succ_iterator(I, true); }
254  return const_succ_iterator(I, true);
255 }
256 inline bool succ_empty(const Instruction *I) {
257  return succ_begin(I) == succ_end(I);
258 }
259 inline unsigned succ_size(const Instruction *I) {
260  return std::distance(succ_begin(I), succ_end(I));
261 }
263  return succ_range(succ_begin(I), succ_end(I));
264 }
267 }
268 
270  return succ_iterator(BB->getTerminator());
271 }
273  return const_succ_iterator(BB->getTerminator());
274 }
276  return succ_iterator(BB->getTerminator(), true);
277 }
279  return const_succ_iterator(BB->getTerminator(), true);
280 }
281 inline bool succ_empty(const BasicBlock *BB) {
282  return succ_begin(BB) == succ_end(BB);
283 }
284 inline unsigned succ_size(const BasicBlock *BB) {
285  return std::distance(succ_begin(BB), succ_end(BB));
286 }
288  return succ_range(succ_begin(BB), succ_end(BB));
289 }
292 }
293 
294 //===--------------------------------------------------------------------===//
295 // GraphTraits specializations for basic block graphs (CFGs)
296 //===--------------------------------------------------------------------===//
297 
298 // Provide specializations of GraphTraits to be able to treat a function as a
299 // graph of basic blocks...
300 
301 template <> struct GraphTraits<BasicBlock*> {
302  using NodeRef = BasicBlock *;
304 
305  static NodeRef getEntryNode(BasicBlock *BB) { return BB; }
308 };
309 
310 template <> struct GraphTraits<const BasicBlock*> {
311  using NodeRef = const BasicBlock *;
313 
314  static NodeRef getEntryNode(const BasicBlock *BB) { return BB; }
315 
318 };
319 
320 // Provide specializations of GraphTraits to be able to treat a function as a
321 // graph of basic blocks... and to walk it in inverse order. Inverse order for
322 // a function is considered to be when traversing the predecessor edges of a BB
323 // instead of the successor edges.
324 //
325 template <> struct GraphTraits<Inverse<BasicBlock*>> {
326  using NodeRef = BasicBlock *;
328 
329  static NodeRef getEntryNode(Inverse<BasicBlock *> G) { return G.Graph; }
332 };
333 
334 template <> struct GraphTraits<Inverse<const BasicBlock*>> {
335  using NodeRef = const BasicBlock *;
337 
341 };
342 
343 //===--------------------------------------------------------------------===//
344 // GraphTraits specializations for function basic block graphs (CFGs)
345 //===--------------------------------------------------------------------===//
346 
347 // Provide specializations of GraphTraits to be able to treat a function as a
348 // graph of basic blocks... these are the same as the basic block iterators,
349 // except that the root node is implicitly the first node of the function.
350 //
351 template <> struct GraphTraits<Function*> : public GraphTraits<BasicBlock*> {
352  static NodeRef getEntryNode(Function *F) { return &F->getEntryBlock(); }
353 
354  // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
356 
358  return nodes_iterator(F->begin());
359  }
360 
362  return nodes_iterator(F->end());
363  }
364 
365  static size_t size(Function *F) { return F->size(); }
366 };
367 template <> struct GraphTraits<const Function*> :
369  static NodeRef getEntryNode(const Function *F) { return &F->getEntryBlock(); }
370 
371  // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
373 
375  return nodes_iterator(F->begin());
376  }
377 
379  return nodes_iterator(F->end());
380  }
381 
382  static size_t size(const Function *F) { return F->size(); }
383 };
384 
385 // Provide specializations of GraphTraits to be able to treat a function as a
386 // graph of basic blocks... and to walk it in inverse order. Inverse order for
387 // a function is considered to be when traversing the predecessor edges of a BB
388 // instead of the successor edges.
389 //
390 template <> struct GraphTraits<Inverse<Function*>> :
393  return &G.Graph->getEntryBlock();
394  }
395 };
396 template <> struct GraphTraits<Inverse<const Function*>> :
399  return &G.Graph->getEntryBlock();
400  }
401 };
402 
403 } // end namespace llvm
404 
405 #endif // LLVM_IR_CFG_H
llvm::SuccIterator::operator-
int operator-(const Self &RHS) const
Definition: CFG.h:214
llvm::SuccIterator
Definition: CFG.h:139
llvm::GraphTraits< BasicBlock * >::getEntryNode
static NodeRef getEntryNode(BasicBlock *BB)
Definition: CFG.h:305
llvm::SuccIterator::operator==
bool operator==(const Self &x) const
Definition: CFG.h:202
llvm::GraphTraits< Inverse< BasicBlock * > >::child_end
static ChildIteratorType child_end(NodeRef N)
Definition: CFG.h:331
llvm::predecessors
pred_range predecessors(BasicBlock *BB)
Definition: CFG.h:127
llvm
This file implements support for optimizing divisions by a constant.
Definition: AllocatorList.h:23
llvm::GraphTraits< Inverse< const Function * > >::getEntryNode
static NodeRef getEntryNode(Inverse< const Function * > G)
Definition: CFG.h:398
llvm::succ_end
Interval::succ_iterator succ_end(Interval *I)
Definition: Interval.h:102
llvm::Function
Definition: Function.h:62
llvm::SuccIterator::SuccIterator
SuccIterator(InstructionT *Inst, bool)
Definition: CFG.h:185
llvm::SuccIterator::pointer
BlockT * pointer
Definition: CFG.h:145
llvm::GraphTraits< Inverse< BasicBlock * > >::child_begin
static ChildIteratorType child_begin(NodeRef N)
Definition: CFG.h:330
llvm::GraphTraits< const BasicBlock * >::child_begin
static ChildIteratorType child_begin(NodeRef N)
Definition: CFG.h:316
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::GraphTraits< BasicBlock * >::child_end
static ChildIteratorType child_end(NodeRef N)
Definition: CFG.h:307
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::successors
succ_range successors(Instruction *I)
Definition: CFG.h:262
llvm::const_pred_iterator
PredIterator< const BasicBlock, Value::const_user_iterator > const_pred_iterator
Definition: CFG.h:107
llvm::succ_empty
bool succ_empty(const Instruction *I)
Definition: CFG.h:256
llvm::PredIterator::getOperandNo
unsigned getOperandNo() const
getOperandNo - Return the operand number in the predecessor's terminator of the successor.
Definition: CFG.h:94
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::PredIterator::operator*
reference operator*() const
Definition: CFG.h:76
GraphTraits.h
llvm::GraphTraits< const Function * >::nodes_begin
static nodes_iterator nodes_begin(const Function *F)
Definition: CFG.h:374
bb
< i1 > br i1 label label bb bb
Definition: README.txt:978
llvm::PredIterator::operator!=
bool operator!=(const Self &x) const
Definition: CFG.h:74
llvm::GraphTraits< Inverse< const BasicBlock * > >::getEntryNode
static NodeRef getEntryNode(Inverse< const BasicBlock * > G)
Definition: CFG.h:338
llvm::GraphTraits< Function * >::nodes_end
static nodes_iterator nodes_end(Function *F)
Definition: CFG.h:361
llvm::succ_size
unsigned succ_size(const Instruction *I)
Definition: CFG.h:259
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:392
llvm::Instruction
Definition: Instruction.h:45
llvm::SuccIterator::operator-=
Self & operator-=(int RHS)
Definition: CFG.h:226
llvm::GraphTraits< Inverse< const BasicBlock * > >::child_begin
static ChildIteratorType child_begin(NodeRef N)
Definition: CFG.h:339
llvm::GraphTraits< Function * >::nodes_begin
static nodes_iterator nodes_begin(Function *F)
Definition: CFG.h:357
llvm::SuccIterator::getSource
BlockT * getSource()
Get the source BlockT of this iterator.
Definition: CFG.h:237
llvm::SuccIterator::operator*
BlockT * operator*() const
Definition: CFG.h:204
llvm::GraphTraits< const BasicBlock * >::child_end
static ChildIteratorType child_end(NodeRef N)
Definition: CFG.h:317
G
const DataFlowGraph & G
Definition: RDFGraph.cpp:202
llvm::pointer_iterator
Definition: iterator.h:338
llvm::PredIterator::value_type
Ptr value_type
Definition: CFG.h:46
llvm::PredIterator::difference_type
std::ptrdiff_t difference_type
Definition: CFG.h:47
llvm::GraphTraits< Inverse< BasicBlock * > >::getEntryNode
static NodeRef getEntryNode(Inverse< BasicBlock * > G)
Definition: CFG.h:329
llvm::succ_range
iterator_range< succ_iterator > succ_range
Definition: CFG.h:245
llvm::SuccIterator::SuccIterator
SuccIterator(InstructionT *Inst)
Definition: CFG.h:183
const
aarch64 promote const
Definition: AArch64PromoteConstant.cpp:232
llvm::PredIterator::operator++
Self & operator++()
Definition: CFG.h:82
llvm::GraphTraits< const Function * >::nodes_end
static nodes_iterator nodes_end(const Function *F)
Definition: CFG.h:378
iterator.h
I
#define I(x, y, z)
Definition: MD5.cpp:59
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:66
llvm::const_succ_range
iterator_range< const_succ_iterator > const_succ_range
Definition: CFG.h:246
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::SuccIterator::reference
BlockT * reference
Definition: CFG.h:146
llvm::GraphTraits< BasicBlock * >::child_begin
static ChildIteratorType child_begin(NodeRef N)
Definition: CFG.h:306
llvm::SuccIterator::difference_type
int difference_type
Definition: CFG.h:144
iterator_range.h
llvm::ISD::BasicBlock
@ BasicBlock
Various leaf nodes.
Definition: ISDOpcodes.h:71
llvm::GraphTraits< const BasicBlock * >
Definition: CFG.h:310
llvm::PredIterator::operator->
pointer * operator->() const
Definition: CFG.h:80
llvm::pred_size
unsigned pred_size(const BasicBlock *BB)
Get the number of predecessors of BB.
Definition: CFG.h:124
llvm::pred_empty
bool pred_empty(const BasicBlock *BB)
Definition: CFG.h:119
llvm::PredIterator
Definition: CFG.h:43
llvm::GraphTraits< Function * >::size
static size_t size(Function *F)
Definition: CFG.h:365
llvm::const_pred_range
iterator_range< const_pred_iterator > const_pred_range
Definition: CFG.h:109
llvm::pred_iterator
PredIterator< BasicBlock, Value::user_iterator > pred_iterator
Definition: CFG.h:105
llvm::PredIterator::getUse
Use & getUse() const
getUse - Return the operand Use in the predecessor's terminator of the successor.
Definition: CFG.h:100
llvm::pred_end
Interval::pred_iterator pred_end(Interval *I)
Definition: Interval.h:112
Casting.h
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:200
llvm::Inverse
Definition: GraphTraits.h:95
llvm::PredIterator::operator==
bool operator==(const Self &x) const
Definition: CFG.h:73
llvm::PredIterator::operator++
Self operator++(int)
Definition: CFG.h:88
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:382
llvm::GraphTraits< const Function * >::getEntryNode
static NodeRef getEntryNode(const Function *F)
Definition: CFG.h:369
llvm::PredIterator::PredIterator
PredIterator(Ptr *bb, bool)
Definition: CFG.h:71
llvm::GraphTraits< Function * >::getEntryNode
static NodeRef getEntryNode(Function *F)
Definition: CFG.h:352
llvm::pred_range
iterator_range< pred_iterator > pred_range
Definition: CFG.h:108
llvm::GraphTraits< BasicBlock * >
Definition: CFG.h:301
llvm::PredIterator::pointer
Ptr * pointer
Definition: CFG.h:48
N
#define N
llvm::SuccIterator::operator[]
SuccessorProxy operator[](int Offset)
Definition: CFG.h:230
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:68
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:243
llvm::PredIterator::PredIterator
PredIterator()=default
llvm::GraphTraits
Definition: GraphTraits.h:35
llvm::const_succ_iterator
SuccIterator< const Instruction, const BasicBlock > const_succ_iterator
Definition: CFG.h:244
llvm::PredIterator::reference
Ptr * reference
Definition: CFG.h:49
llvm::PredIterator::iterator_category
std::forward_iterator_tag iterator_category
Definition: CFG.h:45
llvm::SuccIterator::operator+=
Self & operator+=(int RHS)
Definition: CFG.h:219
Value.h
llvm::SuccIterator::operator<
bool operator<(const Self &RHS) const
Definition: CFG.h:209
llvm::GraphTraits< const BasicBlock * >::getEntryNode
static NodeRef getEntryNode(const BasicBlock *BB)
Definition: CFG.h:314
llvm::GraphTraits< Inverse< const BasicBlock * > >::child_end
static ChildIteratorType child_end(NodeRef N)
Definition: CFG.h:340
llvm::SuccIterator::operator->
BlockT * operator->() const
Definition: CFG.h:207
llvm::Use
A Use represents the edge between a Value definition and its users.
Definition: Use.h:44