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 The number of values used by this User.
45 /// \brief This is a pointer to the array of Uses for this User.
47 /// For nodes of fixed arity (e.g. a binary operator) this array will live
48 /// prefixed to some derived class instance. For nodes of resizable variable
49 /// arity (e.g. PHINodes, SwitchInst etc.), this memory will be dynamically
50 /// allocated and should be destroyed by the classes' virtual dtor.
53 void *operator new(size_t s, unsigned Us);
54 User(Type *ty, unsigned vty, Use *OpList, unsigned NumOps)
55 : Value(ty, vty), NumOperands(NumOps), OperandList(OpList) {}
56 Use *allocHungoffUses(unsigned) const;
57 void dropHungoffUses() {
58 Use::zap(OperandList, OperandList + NumOperands, true);
59 OperandList = nullptr;
60 // Reset NumOperands so User::operator delete() does the right thing.
65 Use::zap(OperandList, OperandList + NumOperands);
67 /// \brief Free memory allocated for User and Use objects.
68 void operator delete(void *Usr);
69 /// \brief Placement delete - required by std, but never called.
70 void operator delete(void*, unsigned) {
71 llvm_unreachable("Constructor throws?");
73 /// \brief Placement delete - required by std, but never called.
74 void operator delete(void*, unsigned, bool) {
75 llvm_unreachable("Constructor throws?");
78 template <int Idx, typename U> static Use &OpFrom(const U *that) {
80 ? OperandTraits<U>::op_end(const_cast<U*>(that))[Idx]
81 : OperandTraits<U>::op_begin(const_cast<U*>(that))[Idx];
83 template <int Idx> Use &Op() {
84 return OpFrom<Idx>(this);
86 template <int Idx> const Use &Op() const {
87 return OpFrom<Idx>(this);
90 Value *getOperand(unsigned i) const {
91 assert(i < NumOperands && "getOperand() out of range!");
92 return OperandList[i];
94 void setOperand(unsigned i, Value *Val) {
95 assert(i < NumOperands && "setOperand() out of range!");
96 assert((!isa<Constant>((const Value*)this) ||
97 isa<GlobalValue>((const Value*)this)) &&
98 "Cannot mutate a constant with setOperand!");
101 const Use &getOperandUse(unsigned i) const {
102 assert(i < NumOperands && "getOperandUse() out of range!");
103 return OperandList[i];
105 Use &getOperandUse(unsigned i) {
106 assert(i < NumOperands && "getOperandUse() out of range!");
107 return OperandList[i];
110 unsigned getNumOperands() const { return NumOperands; }
112 // ---------------------------------------------------------------------------
113 // Operand Iterator interface...
115 typedef Use* op_iterator;
116 typedef const Use* const_op_iterator;
117 typedef iterator_range<op_iterator> op_range;
118 typedef iterator_range<const_op_iterator> const_op_range;
120 inline op_iterator op_begin() { return OperandList; }
121 inline const_op_iterator op_begin() const { return OperandList; }
122 inline op_iterator op_end() { return OperandList+NumOperands; }
123 inline const_op_iterator op_end() const { return OperandList+NumOperands; }
124 inline op_range operands() {
125 return op_range(op_begin(), op_end());
127 inline const_op_range operands() const {
128 return const_op_range(op_begin(), op_end());
131 /// \brief Iterator for directly iterating over the operand Values.
132 struct value_op_iterator
133 : iterator_adaptor_base<value_op_iterator, op_iterator,
134 std::random_access_iterator_tag, Value *,
135 ptrdiff_t, Value *, Value *> {
136 explicit value_op_iterator(Use *U = nullptr) : iterator_adaptor_base(U) {}
138 Value *operator*() const { return *I; }
139 Value *operator->() const { return operator*(); }
142 inline value_op_iterator value_op_begin() {
143 return value_op_iterator(op_begin());
145 inline value_op_iterator value_op_end() {
146 return value_op_iterator(op_end());
148 inline iterator_range<value_op_iterator> operand_values() {
149 return iterator_range<value_op_iterator>(value_op_begin(), value_op_end());
152 /// \brief Drop all references to operands.
154 /// This function is in charge of "letting go" of all objects that this User
155 /// refers to. This allows one to 'delete' a whole class at a time, even
156 /// though there may be circular references... First all references are
157 /// dropped, and all use counts go to zero. Then everything is deleted for
158 /// real. Note that no operations are valid on an object that has "dropped
159 /// all references", except operator delete.
160 void dropAllReferences() {
161 for (Use &U : operands())
165 /// \brief Replace uses of one Value with another.
167 /// Replaces all references to the "From" definition with references to the
169 void replaceUsesOfWith(Value *From, Value *To);
171 // Methods for support type inquiry through isa, cast, and dyn_cast:
172 static inline bool classof(const Value *V) {
173 return isa<Instruction>(V) || isa<Constant>(V);
177 template<> struct simplify_type<User::op_iterator> {
178 typedef Value* SimpleType;
179 static SimpleType getSimplifiedValue(User::op_iterator &Val) {
183 template<> struct simplify_type<User::const_op_iterator> {
184 typedef /*const*/ Value* SimpleType;
185 static SimpleType getSimplifiedValue(User::const_op_iterator &Val) {
190 } // End llvm namespace