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 fixed width vector constant that includes |

115 | /// any constant expressions. |

116 | bool containsConstantExpression() const; |

117 | |

118 | /// Return true if evaluation of this constant could trap. This is true for |

119 | /// things like constant expressions that could divide by zero. |

120 | bool canTrap() 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 | const Constant *stripPointerCasts() const { |

202 | return cast<Constant>(Value::stripPointerCasts()); |

203 | } |

204 | |

205 | Constant *stripPointerCasts() { |

206 | return const_cast<Constant*>( |

207 | static_cast<const Constant *>(this)->stripPointerCasts()); |

208 | } |

209 | |

210 | /// Try to replace undefined constant C or undefined elements in C with |

211 | /// Replacement. If no changes are made, the constant C is returned. |

212 | static Constant *replaceUndefsWith(Constant *C, Constant *Replacement); |

213 | |

214 | /// Merges undefs of a Constant with another Constant, along with the |

215 | /// undefs already present. Other doesn't have to be the same type as C, but |

216 | /// both must either be scalars or vectors with the same element count. If no |

217 | /// changes are made, the constant C is returned. |

218 | static Constant *mergeUndefsWith(Constant *C, Constant *Other); |

219 | |

220 | private: |

221 | enum PossibleRelocationsTy { |

222 | /// This constant requires no relocations. That is, it holds simple |

223 | /// constants (like integrals). |

224 | NoRelocation = 0, |

225 | |

226 | /// This constant holds static relocations that can be resolved by the |

227 | /// static linker. |

228 | LocalRelocation = 1, |

229 | |

230 | /// This constant holds dynamic relocations that the dynamic linker will |

231 | /// need to resolve. |

232 | GlobalRelocation = 2, |

233 | }; |

234 | |

235 | /// Determine what potential relocations may be needed by this constant. |

236 | PossibleRelocationsTy getRelocationInfo() const; |

237 | }; |

238 | |

239 | } // end namespace llvm |

240 | |

241 | #endif // LLVM_IR_CONSTANT_H |

242 |