1 | //===-- llvm/Constant.h - Constant class definition -------------*- 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 contains the declaration of the Constant class. |
10 | // |
11 | //===----------------------------------------------------------------------===// |
12 | |
13 | #ifndef LLVM_IR_CONSTANT_H |
14 | #define LLVM_IR_CONSTANT_H |
15 | |
16 | #include "llvm/IR/User.h" |
17 | #include "llvm/IR/Value.h" |
18 | #include "llvm/Support/Casting.h" |
19 | |
20 | namespace llvm { |
21 | |
22 | class APInt; |
23 | |
24 | /// This is an important base class in LLVM. It provides the common facilities |
25 | /// of all constant values in an LLVM program. A constant is a value that is |
26 | /// immutable at runtime. Functions are constants because their address is |
27 | /// immutable. Same with global variables. |
28 | /// |
29 | /// All constants share the capabilities provided in this class. All constants |
30 | /// can have a null value. They can have an operand list. Constants can be |
31 | /// simple (integer and floating point values), complex (arrays and structures), |
32 | /// or expression based (computations yielding a constant value composed of |
33 | /// only certain operators and other constant values). |
34 | /// |
35 | /// Note that Constants are immutable (once created they never change) |
36 | /// and are fully shared by structural equivalence. This means that two |
37 | /// structurally equivalent constants will always have the same address. |
38 | /// Constants are created on demand as needed and never deleted: thus clients |
39 | /// don't have to worry about the lifetime of the objects. |
40 | /// LLVM Constant Representation |
41 | class Constant : public User { |
42 | protected: |
43 | Constant(Type *ty, ValueTy vty, Use *Ops, unsigned NumOps) |
44 | : User(ty, vty, Ops, NumOps) {} |
45 | |
46 | ~Constant() = default; |
47 | |
48 | public: |
49 | void operator=(const Constant &) = delete; |
50 | Constant(const Constant &) = delete; |
51 | |
52 | /// Return true if this is the value that would be returned by getNullValue. |
53 | bool isNullValue() const; |
54 | |
55 | /// Returns true if the value is one. |
56 | bool isOneValue() const; |
57 | |
58 | /// Return true if the value is not the one value, or, |
59 | /// for vectors, does not contain one value elements. |
60 | bool isNotOneValue() const; |
61 | |
62 | /// Return true if this is the value that would be returned by |
63 | /// getAllOnesValue. |
64 | bool isAllOnesValue() const; |
65 | |
66 | /// Return true if the value is what would be returned by |
67 | /// getZeroValueForNegation. |
68 | bool isNegativeZeroValue() const; |
69 | |
70 | /// Return true if the value is negative zero or null value. |
71 | bool isZeroValue() const; |
72 | |
73 | /// Return true if the value is not the smallest signed value, or, |
74 | /// for vectors, does not contain smallest signed value elements. |
75 | bool isNotMinSignedValue() const; |
76 | |
77 | /// Return true if the value is the smallest signed value. |
78 | bool isMinSignedValue() const; |
79 | |
80 | /// Return true if this is a finite and non-zero floating-point scalar |
81 | /// constant or a fixed width vector constant with all finite and non-zero |
82 | /// elements. |
83 | bool isFiniteNonZeroFP() const; |
84 | |
85 | /// Return true if this is a normal (as opposed to denormal, infinity, nan, |
86 | /// or zero) floating-point scalar constant or a vector constant with all |
87 | /// normal elements. See APFloat::isNormal. |
88 | bool isNormalFP() const; |
89 | |
90 | /// Return true if this scalar has an exact multiplicative inverse or this |
91 | /// vector has an exact multiplicative inverse for each element in the vector. |
92 | bool hasExactInverseFP() const; |
93 | |
94 | /// Return true if this is a floating-point NaN constant or a vector |
95 | /// floating-point constant with all NaN elements. |
96 | bool isNaN() const; |
97 | |
98 | /// Return true if this constant and a constant 'Y' are element-wise equal. |
99 | /// This is identical to just comparing the pointers, with the exception that |
100 | /// for vectors, if only one of the constants has an `undef` element in some |
101 | /// lane, the constants still match. |
102 | bool isElementWiseEqual(Value *Y) const; |
103 | |
104 | /// Return true if this is a vector constant that includes any undef or |
105 | /// poison elements. Since it is impossible to inspect a scalable vector |
106 | /// element- wise at compile time, this function returns true only if the |
107 | /// entire vector is undef or poison. |
108 | bool containsUndefOrPoisonElement() const; |
109 | |
110 | /// Return true if this is a vector constant that includes any poison |
111 | /// elements. |
112 | bool containsPoisonElement() const; |
113 | |
114 | /// Return true if this is a vector constant that includes any strictly undef |
115 | /// (not poison) elements. |
116 | bool containsUndefElement() const; |
117 | |
118 | /// Return true if this is a fixed width vector constant that includes |
119 | /// any constant expressions. |
120 | bool containsConstantExpression() const; |
121 | |
122 | /// Return true if the value can vary between threads. |
123 | bool isThreadDependent() const; |
124 | |
125 | /// Return true if the value is dependent on a dllimport variable. |
126 | bool isDLLImportDependent() const; |
127 | |
128 | /// Return true if the constant has users other than constant expressions and |
129 | /// other dangling things. |
130 | bool isConstantUsed() const; |
131 | |
132 | /// This method classifies the entry according to whether or not it may |
133 | /// generate a relocation entry (either static or dynamic). This must be |
134 | /// conservative, so if it might codegen to a relocatable entry, it should say |
135 | /// so. |
136 | /// |
137 | /// FIXME: This really should not be in IR. |
138 | bool needsRelocation() const; |
139 | bool needsDynamicRelocation() const; |
140 | |
141 | /// For aggregates (struct/array/vector) return the constant that corresponds |
142 | /// to the specified element if possible, or null if not. This can return null |
143 | /// if the element index is a ConstantExpr, if 'this' is a constant expr or |
144 | /// if the constant does not fit into an uint64_t. |
145 | Constant *getAggregateElement(unsigned Elt) const; |
146 | Constant *getAggregateElement(Constant *Elt) const; |
147 | |
148 | /// If all elements of the vector constant have the same value, return that |
149 | /// value. Otherwise, return nullptr. Ignore undefined elements by setting |
150 | /// AllowUndefs to true. |
151 | Constant *getSplatValue(bool AllowUndefs = false) const; |
152 | |
153 | /// If C is a constant integer then return its value, otherwise C must be a |
154 | /// vector of constant integers, all equal, and the common value is returned. |
155 | const APInt &getUniqueInteger() const; |
156 | |
157 | /// Called if some element of this constant is no longer valid. |
158 | /// At this point only other constants may be on the use_list for this |
159 | /// constant. Any constants on our Use list must also be destroy'd. The |
160 | /// implementation must be sure to remove the constant from the list of |
161 | /// available cached constants. Implementations should implement |
162 | /// destroyConstantImpl to remove constants from any pools/maps they are |
163 | /// contained it. |
164 | void destroyConstant(); |
165 | |
166 | //// Methods for support type inquiry through isa, cast, and dyn_cast: |
167 | static bool classof(const Value *V) { |
168 | static_assert(ConstantFirstVal == 0, "V->getValueID() >= ConstantFirstVal always succeeds" ); |
169 | return V->getValueID() <= ConstantLastVal; |
170 | } |
171 | |
172 | /// This method is a special form of User::replaceUsesOfWith |
173 | /// (which does not work on constants) that does work |
174 | /// on constants. Basically this method goes through the trouble of building |
175 | /// a new constant that is equivalent to the current one, with all uses of |
176 | /// From replaced with uses of To. After this construction is completed, all |
177 | /// of the users of 'this' are replaced to use the new constant, and then |
178 | /// 'this' is deleted. In general, you should not call this method, instead, |
179 | /// use Value::replaceAllUsesWith, which automatically dispatches to this |
180 | /// method as needed. |
181 | /// |
182 | void handleOperandChange(Value *, Value *); |
183 | |
184 | static Constant *getNullValue(Type* Ty); |
185 | |
186 | /// @returns the value for an integer or vector of integer constant of the |
187 | /// given type that has all its bits set to true. |
188 | /// Get the all ones value |
189 | static Constant *getAllOnesValue(Type* Ty); |
190 | |
191 | /// Return the value for an integer or pointer constant, or a vector thereof, |
192 | /// with the given scalar value. |
193 | static Constant *getIntegerValue(Type *Ty, const APInt &V); |
194 | |
195 | /// If there are any dead constant users dangling off of this constant, remove |
196 | /// them. This method is useful for clients that want to check to see if a |
197 | /// global is unused, but don't want to deal with potentially dead constants |
198 | /// hanging off of the globals. |
199 | void removeDeadConstantUsers() const; |
200 | |
201 | /// Return true if the constant has exactly one live use. |
202 | /// |
203 | /// This returns the same result as calling Value::hasOneUse after |
204 | /// Constant::removeDeadConstantUsers, but doesn't remove dead constants. |
205 | bool hasOneLiveUse() const; |
206 | |
207 | /// Return true if the constant has no live uses. |
208 | /// |
209 | /// This returns the same result as calling Value::use_empty after |
210 | /// Constant::removeDeadConstantUsers, but doesn't remove dead constants. |
211 | bool hasZeroLiveUses() const; |
212 | |
213 | const Constant *stripPointerCasts() const { |
214 | return cast<Constant>(Val: Value::stripPointerCasts()); |
215 | } |
216 | |
217 | Constant *stripPointerCasts() { |
218 | return const_cast<Constant*>( |
219 | static_cast<const Constant *>(this)->stripPointerCasts()); |
220 | } |
221 | |
222 | /// Try to replace undefined constant C or undefined elements in C with |
223 | /// Replacement. If no changes are made, the constant C is returned. |
224 | static Constant *replaceUndefsWith(Constant *C, Constant *Replacement); |
225 | |
226 | /// Merges undefs of a Constant with another Constant, along with the |
227 | /// undefs already present. Other doesn't have to be the same type as C, but |
228 | /// both must either be scalars or vectors with the same element count. If no |
229 | /// changes are made, the constant C is returned. |
230 | static Constant *mergeUndefsWith(Constant *C, Constant *Other); |
231 | |
232 | /// Return true if a constant is ConstantData or a ConstantAggregate or |
233 | /// ConstantExpr that contain only ConstantData. |
234 | bool isManifestConstant() const; |
235 | |
236 | private: |
237 | enum PossibleRelocationsTy { |
238 | /// This constant requires no relocations. That is, it holds simple |
239 | /// constants (like integrals). |
240 | NoRelocation = 0, |
241 | |
242 | /// This constant holds static relocations that can be resolved by the |
243 | /// static linker. |
244 | LocalRelocation = 1, |
245 | |
246 | /// This constant holds dynamic relocations that the dynamic linker will |
247 | /// need to resolve. |
248 | GlobalRelocation = 2, |
249 | }; |
250 | |
251 | /// Determine what potential relocations may be needed by this constant. |
252 | PossibleRelocationsTy getRelocationInfo() const; |
253 | |
254 | bool hasNLiveUses(unsigned N) const; |
255 | }; |
256 | |
257 | } // end namespace llvm |
258 | |
259 | #endif // LLVM_IR_CONSTANT_H |
260 | |