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