1 //===-- llvm/User.h - User class definition ---------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This class defines the interface that one who uses a Value must implement.
11 // Each instance of the Value class keeps track of what User's have handles
14 // * Instructions are the largest class of Users.
15 // * Constants may be users of other constants (think arrays and stuff)
17 //===----------------------------------------------------------------------===//
19 #ifndef LLVM_IR_USER_H
20 #define LLVM_IR_USER_H
22 #include "llvm/ADT/iterator.h"
23 #include "llvm/ADT/iterator_range.h"
24 #include "llvm/IR/Value.h"
25 #include "llvm/Support/ErrorHandling.h"
29 /// \brief Compile-time customization of User operands.
31 /// Customizes operand-related allocators and accessors.
35 class User
: public Value
{
36 User(const User
&) LLVM_DELETED_FUNCTION
;
37 void *operator new(size_t) LLVM_DELETED_FUNCTION
;
39 friend struct HungoffOperandTraits
;
40 virtual void anchor();
42 /// \brief This is a pointer to the array of Uses for this User.
44 /// For nodes of fixed arity (e.g. a binary operator) this array will live
45 /// prefixed to some derived class instance. For nodes of resizable variable
46 /// arity (e.g. PHINodes, SwitchInst etc.), this memory will be dynamically
47 /// allocated and should be destroyed by the classes' virtual dtor.
50 void *operator new(size_t s
, unsigned Us
);
51 User(Type
*ty
, unsigned vty
, Use
*OpList
, unsigned NumOps
)
52 : Value(ty
, vty
), OperandList(OpList
) {
55 Use
*allocHungoffUses(unsigned) const;
56 void dropHungoffUses() {
57 Use::zap(OperandList
, OperandList
+ NumOperands
, true);
58 OperandList
= nullptr;
59 // Reset NumOperands so User::operator delete() does the right thing.
64 Use::zap(OperandList
, OperandList
+ NumOperands
);
66 /// \brief Free memory allocated for User and Use objects.
67 void operator delete(void *Usr
);
68 /// \brief Placement delete - required by std, but never called.
69 void operator delete(void*, unsigned) {
70 llvm_unreachable("Constructor throws?");
72 /// \brief Placement delete - required by std, but never called.
73 void operator delete(void*, unsigned, bool) {
74 llvm_unreachable("Constructor throws?");
77 template <int Idx
, typename U
> static Use
&OpFrom(const U
*that
) {
79 ? OperandTraits
<U
>::op_end(const_cast<U
*>(that
))[Idx
]
80 : OperandTraits
<U
>::op_begin(const_cast<U
*>(that
))[Idx
];
82 template <int Idx
> Use
&Op() {
83 return OpFrom
<Idx
>(this);
85 template <int Idx
> const Use
&Op() const {
86 return OpFrom
<Idx
>(this);
89 Value
*getOperand(unsigned i
) const {
90 assert(i
< NumOperands
&& "getOperand() out of range!");
91 return OperandList
[i
];
93 void setOperand(unsigned i
, Value
*Val
) {
94 assert(i
< NumOperands
&& "setOperand() out of range!");
95 assert((!isa
<Constant
>((const Value
*)this) ||
96 isa
<GlobalValue
>((const Value
*)this)) &&
97 "Cannot mutate a constant with setOperand!");
100 const Use
&getOperandUse(unsigned i
) const {
101 assert(i
< NumOperands
&& "getOperandUse() out of range!");
102 return OperandList
[i
];
104 Use
&getOperandUse(unsigned i
) {
105 assert(i
< NumOperands
&& "getOperandUse() out of range!");
106 return OperandList
[i
];
109 unsigned getNumOperands() const { return NumOperands
; }
111 // ---------------------------------------------------------------------------
112 // Operand Iterator interface...
114 typedef Use
* op_iterator
;
115 typedef const Use
* const_op_iterator
;
116 typedef iterator_range
<op_iterator
> op_range
;
117 typedef iterator_range
<const_op_iterator
> const_op_range
;
119 inline op_iterator
op_begin() { return OperandList
; }
120 inline const_op_iterator
op_begin() const { return OperandList
; }
121 inline op_iterator
op_end() { return OperandList
+NumOperands
; }
122 inline const_op_iterator
op_end() const { return OperandList
+NumOperands
; }
123 inline op_range
operands() {
124 return op_range(op_begin(), op_end());
126 inline const_op_range
operands() const {
127 return const_op_range(op_begin(), op_end());
130 /// \brief Iterator for directly iterating over the operand Values.
131 struct value_op_iterator
132 : iterator_adaptor_base
<value_op_iterator
, op_iterator
,
133 std::random_access_iterator_tag
, Value
*,
134 ptrdiff_t, Value
*, Value
*> {
135 explicit value_op_iterator(Use
*U
= nullptr) : iterator_adaptor_base(U
) {}
137 Value
*operator*() const { return *I
; }
138 Value
*operator->() const { return operator*(); }
141 inline value_op_iterator
value_op_begin() {
142 return value_op_iterator(op_begin());
144 inline value_op_iterator
value_op_end() {
145 return value_op_iterator(op_end());
147 inline iterator_range
<value_op_iterator
> operand_values() {
148 return iterator_range
<value_op_iterator
>(value_op_begin(), value_op_end());
151 /// \brief Drop all references to operands.
153 /// This function is in charge of "letting go" of all objects that this User
154 /// refers to. This allows one to 'delete' a whole class at a time, even
155 /// though there may be circular references... First all references are
156 /// dropped, and all use counts go to zero. Then everything is deleted for
157 /// real. Note that no operations are valid on an object that has "dropped
158 /// all references", except operator delete.
159 void dropAllReferences() {
160 for (Use
&U
: operands())
164 /// \brief Replace uses of one Value with another.
166 /// Replaces all references to the "From" definition with references to the
168 void replaceUsesOfWith(Value
*From
, Value
*To
);
170 // Methods for support type inquiry through isa, cast, and dyn_cast:
171 static inline bool classof(const Value
*V
) {
172 return isa
<Instruction
>(V
) || isa
<Constant
>(V
);
176 template<> struct simplify_type
<User::op_iterator
> {
177 typedef Value
* SimpleType
;
178 static SimpleType
getSimplifiedValue(User::op_iterator
&Val
) {
182 template<> struct simplify_type
<User::const_op_iterator
> {
183 typedef /*const*/ Value
* SimpleType
;
184 static SimpleType
getSimplifiedValue(User::const_op_iterator
&Val
) {
189 } // End llvm namespace