1//===-- llvm/Constants.h - Constant class subclass definitions --*- 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/// @file
10/// This file contains the declarations for the subclasses of Constant,
11/// which represent the different flavors of constant values that live in LLVM.
12/// Note that Constants are immutable (once created they never change) and are
13/// fully shared by structural equivalence. This means that two structurally
14/// equivalent constants will always have the same address. Constants are
15/// created on demand as needed and never deleted: thus clients don't have to
16/// worry about the lifetime of the objects.
17//
18//===----------------------------------------------------------------------===//
19
20#ifndef LLVM_IR_CONSTANTS_H
21#define LLVM_IR_CONSTANTS_H
22
23#include "llvm/ADT/APFloat.h"
24#include "llvm/ADT/APInt.h"
25#include "llvm/ADT/ArrayRef.h"
26#include "llvm/ADT/STLExtras.h"
27#include "llvm/ADT/StringRef.h"
28#include "llvm/IR/Constant.h"
29#include "llvm/IR/DerivedTypes.h"
30#include "llvm/IR/Intrinsics.h"
31#include "llvm/IR/OperandTraits.h"
32#include "llvm/IR/User.h"
33#include "llvm/IR/Value.h"
34#include "llvm/Support/Casting.h"
35#include "llvm/Support/Compiler.h"
36#include "llvm/Support/ErrorHandling.h"
37#include <cassert>
38#include <cstddef>
39#include <cstdint>
40#include <optional>
41
42namespace llvm {
43
44template <class ConstantClass> struct ConstantAggrKeyType;
45
46/// Base class for constants with no operands.
47///
48/// These constants have no operands; they represent their data directly.
49/// Since they can be in use by unrelated modules (and are never based on
50/// GlobalValues), it never makes sense to RAUW them.
51class ConstantData : public Constant {
52 friend class Constant;
53
54 Value *handleOperandChangeImpl(Value *From, Value *To) {
55 llvm_unreachable("Constant data does not have operands!");
56 }
57
58protected:
59 explicit ConstantData(Type *Ty, ValueTy VT) : Constant(Ty, VT, nullptr, 0) {}
60
61 void *operator new(size_t S) { return User::operator new(Size: S, Us: 0); }
62
63public:
64 void operator delete(void *Ptr) { User::operator delete(Usr: Ptr); }
65
66 ConstantData(const ConstantData &) = delete;
67
68 /// Methods to support type inquiry through isa, cast, and dyn_cast.
69 static bool classof(const Value *V) {
70 return V->getValueID() >= ConstantDataFirstVal &&
71 V->getValueID() <= ConstantDataLastVal;
72 }
73};
74
75//===----------------------------------------------------------------------===//
76/// This is the shared class of boolean and integer constants. This class
77/// represents both boolean and integral constants.
78/// Class for constant integers.
79class ConstantInt final : public ConstantData {
80 friend class Constant;
81
82 APInt Val;
83
84 ConstantInt(IntegerType *Ty, const APInt &V);
85
86 void destroyConstantImpl();
87
88public:
89 ConstantInt(const ConstantInt &) = delete;
90
91 static ConstantInt *getTrue(LLVMContext &Context);
92 static ConstantInt *getFalse(LLVMContext &Context);
93 static ConstantInt *getBool(LLVMContext &Context, bool V);
94 static Constant *getTrue(Type *Ty);
95 static Constant *getFalse(Type *Ty);
96 static Constant *getBool(Type *Ty, bool V);
97
98 /// If Ty is a vector type, return a Constant with a splat of the given
99 /// value. Otherwise return a ConstantInt for the given value.
100 static Constant *get(Type *Ty, uint64_t V, bool IsSigned = false);
101
102 /// Return a ConstantInt with the specified integer value for the specified
103 /// type. If the type is wider than 64 bits, the value will be zero-extended
104 /// to fit the type, unless IsSigned is true, in which case the value will
105 /// be interpreted as a 64-bit signed integer and sign-extended to fit
106 /// the type.
107 /// Get a ConstantInt for a specific value.
108 static ConstantInt *get(IntegerType *Ty, uint64_t V, bool IsSigned = false);
109
110 /// Return a ConstantInt with the specified value for the specified type. The
111 /// value V will be canonicalized to a an unsigned APInt. Accessing it with
112 /// either getSExtValue() or getZExtValue() will yield a correctly sized and
113 /// signed value for the type Ty.
114 /// Get a ConstantInt for a specific signed value.
115 static ConstantInt *getSigned(IntegerType *Ty, int64_t V) {
116 return get(Ty, V, IsSigned: true);
117 }
118 static Constant *getSigned(Type *Ty, int64_t V) {
119 return get(Ty, V, IsSigned: true);
120 }
121
122 /// Return a ConstantInt with the specified value and an implied Type. The
123 /// type is the integer type that corresponds to the bit width of the value.
124 static ConstantInt *get(LLVMContext &Context, const APInt &V);
125
126 /// Return a ConstantInt constructed from the string strStart with the given
127 /// radix.
128 static ConstantInt *get(IntegerType *Ty, StringRef Str, uint8_t Radix);
129
130 /// If Ty is a vector type, return a Constant with a splat of the given
131 /// value. Otherwise return a ConstantInt for the given value.
132 static Constant *get(Type *Ty, const APInt &V);
133
134 /// Return the constant as an APInt value reference. This allows clients to
135 /// obtain a full-precision copy of the value.
136 /// Return the constant's value.
137 inline const APInt &getValue() const { return Val; }
138
139 /// getBitWidth - Return the bitwidth of this constant.
140 unsigned getBitWidth() const { return Val.getBitWidth(); }
141
142 /// Return the constant as a 64-bit unsigned integer value after it
143 /// has been zero extended as appropriate for the type of this constant. Note
144 /// that this method can assert if the value does not fit in 64 bits.
145 /// Return the zero extended value.
146 inline uint64_t getZExtValue() const { return Val.getZExtValue(); }
147
148 /// Return the constant as a 64-bit integer value after it has been sign
149 /// extended as appropriate for the type of this constant. Note that
150 /// this method can assert if the value does not fit in 64 bits.
151 /// Return the sign extended value.
152 inline int64_t getSExtValue() const { return Val.getSExtValue(); }
153
154 /// Return the constant as an llvm::MaybeAlign.
155 /// Note that this method can assert if the value does not fit in 64 bits or
156 /// is not a power of two.
157 inline MaybeAlign getMaybeAlignValue() const {
158 return MaybeAlign(getZExtValue());
159 }
160
161 /// Return the constant as an llvm::Align, interpreting `0` as `Align(1)`.
162 /// Note that this method can assert if the value does not fit in 64 bits or
163 /// is not a power of two.
164 inline Align getAlignValue() const {
165 return getMaybeAlignValue().valueOrOne();
166 }
167
168 /// A helper method that can be used to determine if the constant contained
169 /// within is equal to a constant. This only works for very small values,
170 /// because this is all that can be represented with all types.
171 /// Determine if this constant's value is same as an unsigned char.
172 bool equalsInt(uint64_t V) const { return Val == V; }
173
174 /// Variant of the getType() method to always return an IntegerType, which
175 /// reduces the amount of casting needed in parts of the compiler.
176 inline IntegerType *getIntegerType() const {
177 return cast<IntegerType>(Val: Value::getType());
178 }
179
180 /// This static method returns true if the type Ty is big enough to
181 /// represent the value V. This can be used to avoid having the get method
182 /// assert when V is larger than Ty can represent. Note that there are two
183 /// versions of this method, one for unsigned and one for signed integers.
184 /// Although ConstantInt canonicalizes everything to an unsigned integer,
185 /// the signed version avoids callers having to convert a signed quantity
186 /// to the appropriate unsigned type before calling the method.
187 /// @returns true if V is a valid value for type Ty
188 /// Determine if the value is in range for the given type.
189 static bool isValueValidForType(Type *Ty, uint64_t V);
190 static bool isValueValidForType(Type *Ty, int64_t V);
191
192 bool isNegative() const { return Val.isNegative(); }
193
194 /// This is just a convenience method to make client code smaller for a
195 /// common code. It also correctly performs the comparison without the
196 /// potential for an assertion from getZExtValue().
197 bool isZero() const { return Val.isZero(); }
198
199 /// This is just a convenience method to make client code smaller for a
200 /// common case. It also correctly performs the comparison without the
201 /// potential for an assertion from getZExtValue().
202 /// Determine if the value is one.
203 bool isOne() const { return Val.isOne(); }
204
205 /// This function will return true iff every bit in this constant is set
206 /// to true.
207 /// @returns true iff this constant's bits are all set to true.
208 /// Determine if the value is all ones.
209 bool isMinusOne() const { return Val.isAllOnes(); }
210
211 /// This function will return true iff this constant represents the largest
212 /// value that may be represented by the constant's type.
213 /// @returns true iff this is the largest value that may be represented
214 /// by this type.
215 /// Determine if the value is maximal.
216 bool isMaxValue(bool IsSigned) const {
217 if (IsSigned)
218 return Val.isMaxSignedValue();
219 else
220 return Val.isMaxValue();
221 }
222
223 /// This function will return true iff this constant represents the smallest
224 /// value that may be represented by this constant's type.
225 /// @returns true if this is the smallest value that may be represented by
226 /// this type.
227 /// Determine if the value is minimal.
228 bool isMinValue(bool IsSigned) const {
229 if (IsSigned)
230 return Val.isMinSignedValue();
231 else
232 return Val.isMinValue();
233 }
234
235 /// This function will return true iff this constant represents a value with
236 /// active bits bigger than 64 bits or a value greater than the given uint64_t
237 /// value.
238 /// @returns true iff this constant is greater or equal to the given number.
239 /// Determine if the value is greater or equal to the given number.
240 bool uge(uint64_t Num) const { return Val.uge(RHS: Num); }
241
242 /// getLimitedValue - If the value is smaller than the specified limit,
243 /// return it, otherwise return the limit value. This causes the value
244 /// to saturate to the limit.
245 /// @returns the min of the value of the constant and the specified value
246 /// Get the constant's value with a saturation limit
247 uint64_t getLimitedValue(uint64_t Limit = ~0ULL) const {
248 return Val.getLimitedValue(Limit);
249 }
250
251 /// Methods to support type inquiry through isa, cast, and dyn_cast.
252 static bool classof(const Value *V) {
253 return V->getValueID() == ConstantIntVal;
254 }
255};
256
257//===----------------------------------------------------------------------===//
258/// ConstantFP - Floating Point Values [float, double]
259///
260class ConstantFP final : public ConstantData {
261 friend class Constant;
262
263 APFloat Val;
264
265 ConstantFP(Type *Ty, const APFloat &V);
266
267 void destroyConstantImpl();
268
269public:
270 ConstantFP(const ConstantFP &) = delete;
271
272 /// This returns a ConstantFP, or a vector containing a splat of a ConstantFP,
273 /// for the specified value in the specified type. This should only be used
274 /// for simple constant values like 2.0/1.0 etc, that are known-valid both as
275 /// host double and as the target format.
276 static Constant *get(Type *Ty, double V);
277
278 /// If Ty is a vector type, return a Constant with a splat of the given
279 /// value. Otherwise return a ConstantFP for the given value.
280 static Constant *get(Type *Ty, const APFloat &V);
281
282 static Constant *get(Type *Ty, StringRef Str);
283 static ConstantFP *get(LLVMContext &Context, const APFloat &V);
284 static Constant *getNaN(Type *Ty, bool Negative = false,
285 uint64_t Payload = 0);
286 static Constant *getQNaN(Type *Ty, bool Negative = false,
287 APInt *Payload = nullptr);
288 static Constant *getSNaN(Type *Ty, bool Negative = false,
289 APInt *Payload = nullptr);
290 static Constant *getZero(Type *Ty, bool Negative = false);
291 static Constant *getNegativeZero(Type *Ty) { return getZero(Ty, Negative: true); }
292 static Constant *getInfinity(Type *Ty, bool Negative = false);
293
294 /// Return true if Ty is big enough to represent V.
295 static bool isValueValidForType(Type *Ty, const APFloat &V);
296 inline const APFloat &getValueAPF() const { return Val; }
297 inline const APFloat &getValue() const { return Val; }
298
299 /// Return true if the value is positive or negative zero.
300 bool isZero() const { return Val.isZero(); }
301
302 /// Return true if the sign bit is set.
303 bool isNegative() const { return Val.isNegative(); }
304
305 /// Return true if the value is infinity
306 bool isInfinity() const { return Val.isInfinity(); }
307
308 /// Return true if the value is a NaN.
309 bool isNaN() const { return Val.isNaN(); }
310
311 /// We don't rely on operator== working on double values, as it returns true
312 /// for things that are clearly not equal, like -0.0 and 0.0.
313 /// As such, this method can be used to do an exact bit-for-bit comparison of
314 /// two floating point values. The version with a double operand is retained
315 /// because it's so convenient to write isExactlyValue(2.0), but please use
316 /// it only for simple constants.
317 bool isExactlyValue(const APFloat &V) const;
318
319 bool isExactlyValue(double V) const {
320 bool ignored;
321 APFloat FV(V);
322 FV.convert(ToSemantics: Val.getSemantics(), RM: APFloat::rmNearestTiesToEven, losesInfo: &ignored);
323 return isExactlyValue(V: FV);
324 }
325
326 /// Methods for support type inquiry through isa, cast, and dyn_cast:
327 static bool classof(const Value *V) {
328 return V->getValueID() == ConstantFPVal;
329 }
330};
331
332//===----------------------------------------------------------------------===//
333/// All zero aggregate value
334///
335class ConstantAggregateZero final : public ConstantData {
336 friend class Constant;
337
338 explicit ConstantAggregateZero(Type *Ty)
339 : ConstantData(Ty, ConstantAggregateZeroVal) {}
340
341 void destroyConstantImpl();
342
343public:
344 ConstantAggregateZero(const ConstantAggregateZero &) = delete;
345
346 static ConstantAggregateZero *get(Type *Ty);
347
348 /// If this CAZ has array or vector type, return a zero with the right element
349 /// type.
350 Constant *getSequentialElement() const;
351
352 /// If this CAZ has struct type, return a zero with the right element type for
353 /// the specified element.
354 Constant *getStructElement(unsigned Elt) const;
355
356 /// Return a zero of the right value for the specified GEP index if we can,
357 /// otherwise return null (e.g. if C is a ConstantExpr).
358 Constant *getElementValue(Constant *C) const;
359
360 /// Return a zero of the right value for the specified GEP index.
361 Constant *getElementValue(unsigned Idx) const;
362
363 /// Return the number of elements in the array, vector, or struct.
364 ElementCount getElementCount() const;
365
366 /// Methods for support type inquiry through isa, cast, and dyn_cast:
367 ///
368 static bool classof(const Value *V) {
369 return V->getValueID() == ConstantAggregateZeroVal;
370 }
371};
372
373/// Base class for aggregate constants (with operands).
374///
375/// These constants are aggregates of other constants, which are stored as
376/// operands.
377///
378/// Subclasses are \a ConstantStruct, \a ConstantArray, and \a
379/// ConstantVector.
380///
381/// \note Some subclasses of \a ConstantData are semantically aggregates --
382/// such as \a ConstantDataArray -- but are not subclasses of this because they
383/// use operands.
384class ConstantAggregate : public Constant {
385protected:
386 ConstantAggregate(Type *T, ValueTy VT, ArrayRef<Constant *> V);
387
388public:
389 /// Transparently provide more efficient getOperand methods.
390 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
391
392 /// Methods for support type inquiry through isa, cast, and dyn_cast:
393 static bool classof(const Value *V) {
394 return V->getValueID() >= ConstantAggregateFirstVal &&
395 V->getValueID() <= ConstantAggregateLastVal;
396 }
397};
398
399template <>
400struct OperandTraits<ConstantAggregate>
401 : public VariadicOperandTraits<ConstantAggregate> {};
402
403DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantAggregate, Constant)
404
405//===----------------------------------------------------------------------===//
406/// ConstantArray - Constant Array Declarations
407///
408class ConstantArray final : public ConstantAggregate {
409 friend struct ConstantAggrKeyType<ConstantArray>;
410 friend class Constant;
411
412 ConstantArray(ArrayType *T, ArrayRef<Constant *> Val);
413
414 void destroyConstantImpl();
415 Value *handleOperandChangeImpl(Value *From, Value *To);
416
417public:
418 // ConstantArray accessors
419 static Constant *get(ArrayType *T, ArrayRef<Constant *> V);
420
421private:
422 static Constant *getImpl(ArrayType *T, ArrayRef<Constant *> V);
423
424public:
425 /// Specialize the getType() method to always return an ArrayType,
426 /// which reduces the amount of casting needed in parts of the compiler.
427 inline ArrayType *getType() const {
428 return cast<ArrayType>(Val: Value::getType());
429 }
430
431 /// Methods for support type inquiry through isa, cast, and dyn_cast:
432 static bool classof(const Value *V) {
433 return V->getValueID() == ConstantArrayVal;
434 }
435};
436
437//===----------------------------------------------------------------------===//
438// Constant Struct Declarations
439//
440class ConstantStruct final : public ConstantAggregate {
441 friend struct ConstantAggrKeyType<ConstantStruct>;
442 friend class Constant;
443
444 ConstantStruct(StructType *T, ArrayRef<Constant *> Val);
445
446 void destroyConstantImpl();
447 Value *handleOperandChangeImpl(Value *From, Value *To);
448
449public:
450 // ConstantStruct accessors
451 static Constant *get(StructType *T, ArrayRef<Constant *> V);
452
453 template <typename... Csts>
454 static std::enable_if_t<are_base_of<Constant, Csts...>::value, Constant *>
455 get(StructType *T, Csts *...Vs) {
456 return get(T, V: ArrayRef<Constant *>({Vs...}));
457 }
458
459 /// Return an anonymous struct that has the specified elements.
460 /// If the struct is possibly empty, then you must specify a context.
461 static Constant *getAnon(ArrayRef<Constant *> V, bool Packed = false) {
462 return get(T: getTypeForElements(V, Packed), V);
463 }
464 static Constant *getAnon(LLVMContext &Ctx, ArrayRef<Constant *> V,
465 bool Packed = false) {
466 return get(T: getTypeForElements(Ctx, V, Packed), V);
467 }
468
469 /// Return an anonymous struct type to use for a constant with the specified
470 /// set of elements. The list must not be empty.
471 static StructType *getTypeForElements(ArrayRef<Constant *> V,
472 bool Packed = false);
473 /// This version of the method allows an empty list.
474 static StructType *getTypeForElements(LLVMContext &Ctx,
475 ArrayRef<Constant *> V,
476 bool Packed = false);
477
478 /// Specialization - reduce amount of casting.
479 inline StructType *getType() const {
480 return cast<StructType>(Val: Value::getType());
481 }
482
483 /// Methods for support type inquiry through isa, cast, and dyn_cast:
484 static bool classof(const Value *V) {
485 return V->getValueID() == ConstantStructVal;
486 }
487};
488
489//===----------------------------------------------------------------------===//
490/// Constant Vector Declarations
491///
492class ConstantVector final : public ConstantAggregate {
493 friend struct ConstantAggrKeyType<ConstantVector>;
494 friend class Constant;
495
496 ConstantVector(VectorType *T, ArrayRef<Constant *> Val);
497
498 void destroyConstantImpl();
499 Value *handleOperandChangeImpl(Value *From, Value *To);
500
501public:
502 // ConstantVector accessors
503 static Constant *get(ArrayRef<Constant *> V);
504
505private:
506 static Constant *getImpl(ArrayRef<Constant *> V);
507
508public:
509 /// Return a ConstantVector with the specified constant in each element.
510 /// Note that this might not return an instance of ConstantVector
511 static Constant *getSplat(ElementCount EC, Constant *Elt);
512
513 /// Specialize the getType() method to always return a FixedVectorType,
514 /// which reduces the amount of casting needed in parts of the compiler.
515 inline FixedVectorType *getType() const {
516 return cast<FixedVectorType>(Val: Value::getType());
517 }
518
519 /// If all elements of the vector constant have the same value, return that
520 /// value. Otherwise, return nullptr. Ignore undefined elements by setting
521 /// AllowUndefs to true.
522 Constant *getSplatValue(bool AllowUndefs = false) const;
523
524 /// Methods for support type inquiry through isa, cast, and dyn_cast:
525 static bool classof(const Value *V) {
526 return V->getValueID() == ConstantVectorVal;
527 }
528};
529
530//===----------------------------------------------------------------------===//
531/// A constant pointer value that points to null
532///
533class ConstantPointerNull final : public ConstantData {
534 friend class Constant;
535
536 explicit ConstantPointerNull(PointerType *T)
537 : ConstantData(T, Value::ConstantPointerNullVal) {}
538
539 void destroyConstantImpl();
540
541public:
542 ConstantPointerNull(const ConstantPointerNull &) = delete;
543
544 /// Static factory methods - Return objects of the specified value
545 static ConstantPointerNull *get(PointerType *T);
546
547 /// Specialize the getType() method to always return an PointerType,
548 /// which reduces the amount of casting needed in parts of the compiler.
549 inline PointerType *getType() const {
550 return cast<PointerType>(Val: Value::getType());
551 }
552
553 /// Methods for support type inquiry through isa, cast, and dyn_cast:
554 static bool classof(const Value *V) {
555 return V->getValueID() == ConstantPointerNullVal;
556 }
557};
558
559//===----------------------------------------------------------------------===//
560/// ConstantDataSequential - A vector or array constant whose element type is a
561/// simple 1/2/4/8-byte integer or half/bfloat/float/double, and whose elements
562/// are just simple data values (i.e. ConstantInt/ConstantFP). This Constant
563/// node has no operands because it stores all of the elements of the constant
564/// as densely packed data, instead of as Value*'s.
565///
566/// This is the common base class of ConstantDataArray and ConstantDataVector.
567///
568class ConstantDataSequential : public ConstantData {
569 friend class LLVMContextImpl;
570 friend class Constant;
571
572 /// A pointer to the bytes underlying this constant (which is owned by the
573 /// uniquing StringMap).
574 const char *DataElements;
575
576 /// This forms a link list of ConstantDataSequential nodes that have
577 /// the same value but different type. For example, 0,0,0,1 could be a 4
578 /// element array of i8, or a 1-element array of i32. They'll both end up in
579 /// the same StringMap bucket, linked up.
580 std::unique_ptr<ConstantDataSequential> Next;
581
582 void destroyConstantImpl();
583
584protected:
585 explicit ConstantDataSequential(Type *ty, ValueTy VT, const char *Data)
586 : ConstantData(ty, VT), DataElements(Data) {}
587
588 static Constant *getImpl(StringRef Bytes, Type *Ty);
589
590public:
591 ConstantDataSequential(const ConstantDataSequential &) = delete;
592
593 /// Return true if a ConstantDataSequential can be formed with a vector or
594 /// array of the specified element type.
595 /// ConstantDataArray only works with normal float and int types that are
596 /// stored densely in memory, not with things like i42 or x86_f80.
597 static bool isElementTypeCompatible(Type *Ty);
598
599 /// If this is a sequential container of integers (of any size), return the
600 /// specified element in the low bits of a uint64_t.
601 uint64_t getElementAsInteger(unsigned i) const;
602
603 /// If this is a sequential container of integers (of any size), return the
604 /// specified element as an APInt.
605 APInt getElementAsAPInt(unsigned i) const;
606
607 /// If this is a sequential container of floating point type, return the
608 /// specified element as an APFloat.
609 APFloat getElementAsAPFloat(unsigned i) const;
610
611 /// If this is an sequential container of floats, return the specified element
612 /// as a float.
613 float getElementAsFloat(unsigned i) const;
614
615 /// If this is an sequential container of doubles, return the specified
616 /// element as a double.
617 double getElementAsDouble(unsigned i) const;
618
619 /// Return a Constant for a specified index's element.
620 /// Note that this has to compute a new constant to return, so it isn't as
621 /// efficient as getElementAsInteger/Float/Double.
622 Constant *getElementAsConstant(unsigned i) const;
623
624 /// Return the element type of the array/vector.
625 Type *getElementType() const;
626
627 /// Return the number of elements in the array or vector.
628 unsigned getNumElements() const;
629
630 /// Return the size (in bytes) of each element in the array/vector.
631 /// The size of the elements is known to be a multiple of one byte.
632 uint64_t getElementByteSize() const;
633
634 /// This method returns true if this is an array of \p CharSize integers.
635 bool isString(unsigned CharSize = 8) const;
636
637 /// This method returns true if the array "isString", ends with a null byte,
638 /// and does not contains any other null bytes.
639 bool isCString() const;
640
641 /// If this array is isString(), then this method returns the array as a
642 /// StringRef. Otherwise, it asserts out.
643 StringRef getAsString() const {
644 assert(isString() && "Not a string");
645 return getRawDataValues();
646 }
647
648 /// If this array is isCString(), then this method returns the array (without
649 /// the trailing null byte) as a StringRef. Otherwise, it asserts out.
650 StringRef getAsCString() const {
651 assert(isCString() && "Isn't a C string");
652 StringRef Str = getAsString();
653 return Str.substr(Start: 0, N: Str.size() - 1);
654 }
655
656 /// Return the raw, underlying, bytes of this data. Note that this is an
657 /// extremely tricky thing to work with, as it exposes the host endianness of
658 /// the data elements.
659 StringRef getRawDataValues() const;
660
661 /// Methods for support type inquiry through isa, cast, and dyn_cast:
662 static bool classof(const Value *V) {
663 return V->getValueID() == ConstantDataArrayVal ||
664 V->getValueID() == ConstantDataVectorVal;
665 }
666
667private:
668 const char *getElementPointer(unsigned Elt) const;
669};
670
671//===----------------------------------------------------------------------===//
672/// An array constant whose element type is a simple 1/2/4/8-byte integer or
673/// float/double, and whose elements are just simple data values
674/// (i.e. ConstantInt/ConstantFP). This Constant node has no operands because it
675/// stores all of the elements of the constant as densely packed data, instead
676/// of as Value*'s.
677class ConstantDataArray final : public ConstantDataSequential {
678 friend class ConstantDataSequential;
679
680 explicit ConstantDataArray(Type *ty, const char *Data)
681 : ConstantDataSequential(ty, ConstantDataArrayVal, Data) {}
682
683public:
684 ConstantDataArray(const ConstantDataArray &) = delete;
685
686 /// get() constructor - Return a constant with array type with an element
687 /// count and element type matching the ArrayRef passed in. Note that this
688 /// can return a ConstantAggregateZero object.
689 template <typename ElementTy>
690 static Constant *get(LLVMContext &Context, ArrayRef<ElementTy> Elts) {
691 const char *Data = reinterpret_cast<const char *>(Elts.data());
692 return getRaw(Data: StringRef(Data, Elts.size() * sizeof(ElementTy)), NumElements: Elts.size(),
693 ElementTy: Type::getScalarTy<ElementTy>(Context));
694 }
695
696 /// get() constructor - ArrayTy needs to be compatible with
697 /// ArrayRef<ElementTy>. Calls get(LLVMContext, ArrayRef<ElementTy>).
698 template <typename ArrayTy>
699 static Constant *get(LLVMContext &Context, ArrayTy &Elts) {
700 return ConstantDataArray::get(Context, ArrayRef(Elts));
701 }
702
703 /// getRaw() constructor - Return a constant with array type with an element
704 /// count and element type matching the NumElements and ElementTy parameters
705 /// passed in. Note that this can return a ConstantAggregateZero object.
706 /// ElementTy must be one of i8/i16/i32/i64/half/bfloat/float/double. Data is
707 /// the buffer containing the elements. Be careful to make sure Data uses the
708 /// right endianness, the buffer will be used as-is.
709 static Constant *getRaw(StringRef Data, uint64_t NumElements,
710 Type *ElementTy) {
711 Type *Ty = ArrayType::get(ElementType: ElementTy, NumElements);
712 return getImpl(Bytes: Data, Ty);
713 }
714
715 /// getFP() constructors - Return a constant of array type with a float
716 /// element type taken from argument `ElementType', and count taken from
717 /// argument `Elts'. The amount of bits of the contained type must match the
718 /// number of bits of the type contained in the passed in ArrayRef.
719 /// (i.e. half or bfloat for 16bits, float for 32bits, double for 64bits) Note
720 /// that this can return a ConstantAggregateZero object.
721 static Constant *getFP(Type *ElementType, ArrayRef<uint16_t> Elts);
722 static Constant *getFP(Type *ElementType, ArrayRef<uint32_t> Elts);
723 static Constant *getFP(Type *ElementType, ArrayRef<uint64_t> Elts);
724
725 /// This method constructs a CDS and initializes it with a text string.
726 /// The default behavior (AddNull==true) causes a null terminator to
727 /// be placed at the end of the array (increasing the length of the string by
728 /// one more than the StringRef would normally indicate. Pass AddNull=false
729 /// to disable this behavior.
730 static Constant *getString(LLVMContext &Context, StringRef Initializer,
731 bool AddNull = true);
732
733 /// Specialize the getType() method to always return an ArrayType,
734 /// which reduces the amount of casting needed in parts of the compiler.
735 inline ArrayType *getType() const {
736 return cast<ArrayType>(Val: Value::getType());
737 }
738
739 /// Methods for support type inquiry through isa, cast, and dyn_cast:
740 static bool classof(const Value *V) {
741 return V->getValueID() == ConstantDataArrayVal;
742 }
743};
744
745//===----------------------------------------------------------------------===//
746/// A vector constant whose element type is a simple 1/2/4/8-byte integer or
747/// float/double, and whose elements are just simple data values
748/// (i.e. ConstantInt/ConstantFP). This Constant node has no operands because it
749/// stores all of the elements of the constant as densely packed data, instead
750/// of as Value*'s.
751class ConstantDataVector final : public ConstantDataSequential {
752 friend class ConstantDataSequential;
753
754 explicit ConstantDataVector(Type *ty, const char *Data)
755 : ConstantDataSequential(ty, ConstantDataVectorVal, Data),
756 IsSplatSet(false) {}
757 // Cache whether or not the constant is a splat.
758 mutable bool IsSplatSet : 1;
759 mutable bool IsSplat : 1;
760 bool isSplatData() const;
761
762public:
763 ConstantDataVector(const ConstantDataVector &) = delete;
764
765 /// get() constructors - Return a constant with vector type with an element
766 /// count and element type matching the ArrayRef passed in. Note that this
767 /// can return a ConstantAggregateZero object.
768 static Constant *get(LLVMContext &Context, ArrayRef<uint8_t> Elts);
769 static Constant *get(LLVMContext &Context, ArrayRef<uint16_t> Elts);
770 static Constant *get(LLVMContext &Context, ArrayRef<uint32_t> Elts);
771 static Constant *get(LLVMContext &Context, ArrayRef<uint64_t> Elts);
772 static Constant *get(LLVMContext &Context, ArrayRef<float> Elts);
773 static Constant *get(LLVMContext &Context, ArrayRef<double> Elts);
774
775 /// getRaw() constructor - Return a constant with vector type with an element
776 /// count and element type matching the NumElements and ElementTy parameters
777 /// passed in. Note that this can return a ConstantAggregateZero object.
778 /// ElementTy must be one of i8/i16/i32/i64/half/bfloat/float/double. Data is
779 /// the buffer containing the elements. Be careful to make sure Data uses the
780 /// right endianness, the buffer will be used as-is.
781 static Constant *getRaw(StringRef Data, uint64_t NumElements,
782 Type *ElementTy) {
783 Type *Ty = VectorType::get(ElementType: ElementTy, EC: ElementCount::getFixed(MinVal: NumElements));
784 return getImpl(Bytes: Data, Ty);
785 }
786
787 /// getFP() constructors - Return a constant of vector type with a float
788 /// element type taken from argument `ElementType', and count taken from
789 /// argument `Elts'. The amount of bits of the contained type must match the
790 /// number of bits of the type contained in the passed in ArrayRef.
791 /// (i.e. half or bfloat for 16bits, float for 32bits, double for 64bits) Note
792 /// that this can return a ConstantAggregateZero object.
793 static Constant *getFP(Type *ElementType, ArrayRef<uint16_t> Elts);
794 static Constant *getFP(Type *ElementType, ArrayRef<uint32_t> Elts);
795 static Constant *getFP(Type *ElementType, ArrayRef<uint64_t> Elts);
796
797 /// Return a ConstantVector with the specified constant in each element.
798 /// The specified constant has to be a of a compatible type (i8/i16/
799 /// i32/i64/half/bfloat/float/double) and must be a ConstantFP or ConstantInt.
800 static Constant *getSplat(unsigned NumElts, Constant *Elt);
801
802 /// Returns true if this is a splat constant, meaning that all elements have
803 /// the same value.
804 bool isSplat() const;
805
806 /// If this is a splat constant, meaning that all of the elements have the
807 /// same value, return that value. Otherwise return NULL.
808 Constant *getSplatValue() const;
809
810 /// Specialize the getType() method to always return a FixedVectorType,
811 /// which reduces the amount of casting needed in parts of the compiler.
812 inline FixedVectorType *getType() const {
813 return cast<FixedVectorType>(Val: Value::getType());
814 }
815
816 /// Methods for support type inquiry through isa, cast, and dyn_cast:
817 static bool classof(const Value *V) {
818 return V->getValueID() == ConstantDataVectorVal;
819 }
820};
821
822//===----------------------------------------------------------------------===//
823/// A constant token which is empty
824///
825class ConstantTokenNone final : public ConstantData {
826 friend class Constant;
827
828 explicit ConstantTokenNone(LLVMContext &Context)
829 : ConstantData(Type::getTokenTy(C&: Context), ConstantTokenNoneVal) {}
830
831 void destroyConstantImpl();
832
833public:
834 ConstantTokenNone(const ConstantTokenNone &) = delete;
835
836 /// Return the ConstantTokenNone.
837 static ConstantTokenNone *get(LLVMContext &Context);
838
839 /// Methods to support type inquiry through isa, cast, and dyn_cast.
840 static bool classof(const Value *V) {
841 return V->getValueID() == ConstantTokenNoneVal;
842 }
843};
844
845/// A constant target extension type default initializer
846class ConstantTargetNone final : public ConstantData {
847 friend class Constant;
848
849 explicit ConstantTargetNone(TargetExtType *T)
850 : ConstantData(T, Value::ConstantTargetNoneVal) {}
851
852 void destroyConstantImpl();
853
854public:
855 ConstantTargetNone(const ConstantTargetNone &) = delete;
856
857 /// Static factory methods - Return objects of the specified value.
858 static ConstantTargetNone *get(TargetExtType *T);
859
860 /// Specialize the getType() method to always return an TargetExtType,
861 /// which reduces the amount of casting needed in parts of the compiler.
862 inline TargetExtType *getType() const {
863 return cast<TargetExtType>(Val: Value::getType());
864 }
865
866 /// Methods for support type inquiry through isa, cast, and dyn_cast.
867 static bool classof(const Value *V) {
868 return V->getValueID() == ConstantTargetNoneVal;
869 }
870};
871
872/// The address of a basic block.
873///
874class BlockAddress final : public Constant {
875 friend class Constant;
876
877 BlockAddress(Function *F, BasicBlock *BB);
878
879 void *operator new(size_t S) { return User::operator new(Size: S, Us: 2); }
880
881 void destroyConstantImpl();
882 Value *handleOperandChangeImpl(Value *From, Value *To);
883
884public:
885 void operator delete(void *Ptr) { User::operator delete(Usr: Ptr); }
886
887 /// Return a BlockAddress for the specified function and basic block.
888 static BlockAddress *get(Function *F, BasicBlock *BB);
889
890 /// Return a BlockAddress for the specified basic block. The basic
891 /// block must be embedded into a function.
892 static BlockAddress *get(BasicBlock *BB);
893
894 /// Lookup an existing \c BlockAddress constant for the given BasicBlock.
895 ///
896 /// \returns 0 if \c !BB->hasAddressTaken(), otherwise the \c BlockAddress.
897 static BlockAddress *lookup(const BasicBlock *BB);
898
899 /// Transparently provide more efficient getOperand methods.
900 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
901
902 Function *getFunction() const { return (Function *)Op<0>().get(); }
903 BasicBlock *getBasicBlock() const { return (BasicBlock *)Op<1>().get(); }
904
905 /// Methods for support type inquiry through isa, cast, and dyn_cast:
906 static bool classof(const Value *V) {
907 return V->getValueID() == BlockAddressVal;
908 }
909};
910
911template <>
912struct OperandTraits<BlockAddress>
913 : public FixedNumOperandTraits<BlockAddress, 2> {};
914
915DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BlockAddress, Value)
916
917/// Wrapper for a function that represents a value that
918/// functionally represents the original function. This can be a function,
919/// global alias to a function, or an ifunc.
920class DSOLocalEquivalent final : public Constant {
921 friend class Constant;
922
923 DSOLocalEquivalent(GlobalValue *GV);
924
925 void *operator new(size_t S) { return User::operator new(Size: S, Us: 1); }
926
927 void destroyConstantImpl();
928 Value *handleOperandChangeImpl(Value *From, Value *To);
929
930public:
931 void operator delete(void *Ptr) { User::operator delete(Usr: Ptr); }
932
933 /// Return a DSOLocalEquivalent for the specified global value.
934 static DSOLocalEquivalent *get(GlobalValue *GV);
935
936 /// Transparently provide more efficient getOperand methods.
937 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
938
939 GlobalValue *getGlobalValue() const {
940 return cast<GlobalValue>(Val: Op<0>().get());
941 }
942
943 /// Methods for support type inquiry through isa, cast, and dyn_cast:
944 static bool classof(const Value *V) {
945 return V->getValueID() == DSOLocalEquivalentVal;
946 }
947};
948
949template <>
950struct OperandTraits<DSOLocalEquivalent>
951 : public FixedNumOperandTraits<DSOLocalEquivalent, 1> {};
952
953DEFINE_TRANSPARENT_OPERAND_ACCESSORS(DSOLocalEquivalent, Value)
954
955/// Wrapper for a value that won't be replaced with a CFI jump table
956/// pointer in LowerTypeTestsModule.
957class NoCFIValue final : public Constant {
958 friend class Constant;
959
960 NoCFIValue(GlobalValue *GV);
961
962 void *operator new(size_t S) { return User::operator new(Size: S, Us: 1); }
963
964 void destroyConstantImpl();
965 Value *handleOperandChangeImpl(Value *From, Value *To);
966
967public:
968 /// Return a NoCFIValue for the specified function.
969 static NoCFIValue *get(GlobalValue *GV);
970
971 /// Transparently provide more efficient getOperand methods.
972 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
973
974 GlobalValue *getGlobalValue() const {
975 return cast<GlobalValue>(Val: Op<0>().get());
976 }
977
978 /// NoCFIValue is always a pointer.
979 PointerType *getType() const {
980 return cast<PointerType>(Val: Value::getType());
981 }
982
983 /// Methods for support type inquiry through isa, cast, and dyn_cast:
984 static bool classof(const Value *V) {
985 return V->getValueID() == NoCFIValueVal;
986 }
987};
988
989template <>
990struct OperandTraits<NoCFIValue> : public FixedNumOperandTraits<NoCFIValue, 1> {
991};
992
993DEFINE_TRANSPARENT_OPERAND_ACCESSORS(NoCFIValue, Value)
994
995//===----------------------------------------------------------------------===//
996/// A constant value that is initialized with an expression using
997/// other constant values.
998///
999/// This class uses the standard Instruction opcodes to define the various
1000/// constant expressions. The Opcode field for the ConstantExpr class is
1001/// maintained in the Value::SubclassData field.
1002class ConstantExpr : public Constant {
1003 friend struct ConstantExprKeyType;
1004 friend class Constant;
1005
1006 void destroyConstantImpl();
1007 Value *handleOperandChangeImpl(Value *From, Value *To);
1008
1009protected:
1010 ConstantExpr(Type *ty, unsigned Opcode, Use *Ops, unsigned NumOps)
1011 : Constant(ty, ConstantExprVal, Ops, NumOps) {
1012 // Operation type (an Instruction opcode) is stored as the SubclassData.
1013 setValueSubclassData(Opcode);
1014 }
1015
1016 ~ConstantExpr() = default;
1017
1018public:
1019 // Static methods to construct a ConstantExpr of different kinds. Note that
1020 // these methods may return a object that is not an instance of the
1021 // ConstantExpr class, because they will attempt to fold the constant
1022 // expression into something simpler if possible.
1023
1024 /// getAlignOf constant expr - computes the alignment of a type in a target
1025 /// independent way (Note: the return type is an i64).
1026 static Constant *getAlignOf(Type *Ty);
1027
1028 /// getSizeOf constant expr - computes the (alloc) size of a type (in
1029 /// address-units, not bits) in a target independent way (Note: the return
1030 /// type is an i64).
1031 ///
1032 static Constant *getSizeOf(Type *Ty);
1033
1034 static Constant *getNeg(Constant *C, bool HasNUW = false,
1035 bool HasNSW = false);
1036 static Constant *getNot(Constant *C);
1037 static Constant *getAdd(Constant *C1, Constant *C2, bool HasNUW = false,
1038 bool HasNSW = false);
1039 static Constant *getSub(Constant *C1, Constant *C2, bool HasNUW = false,
1040 bool HasNSW = false);
1041 static Constant *getMul(Constant *C1, Constant *C2, bool HasNUW = false,
1042 bool HasNSW = false);
1043 static Constant *getXor(Constant *C1, Constant *C2);
1044 static Constant *getShl(Constant *C1, Constant *C2, bool HasNUW = false,
1045 bool HasNSW = false);
1046 static Constant *getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced = false);
1047 static Constant *getPtrToInt(Constant *C, Type *Ty,
1048 bool OnlyIfReduced = false);
1049 static Constant *getIntToPtr(Constant *C, Type *Ty,
1050 bool OnlyIfReduced = false);
1051 static Constant *getBitCast(Constant *C, Type *Ty,
1052 bool OnlyIfReduced = false);
1053 static Constant *getAddrSpaceCast(Constant *C, Type *Ty,
1054 bool OnlyIfReduced = false);
1055
1056 static Constant *getNSWNeg(Constant *C) { return getNeg(C, HasNUW: false, HasNSW: true); }
1057 static Constant *getNUWNeg(Constant *C) { return getNeg(C, HasNUW: true, HasNSW: false); }
1058
1059 static Constant *getNSWAdd(Constant *C1, Constant *C2) {
1060 return getAdd(C1, C2, HasNUW: false, HasNSW: true);
1061 }
1062
1063 static Constant *getNUWAdd(Constant *C1, Constant *C2) {
1064 return getAdd(C1, C2, HasNUW: true, HasNSW: false);
1065 }
1066
1067 static Constant *getNSWSub(Constant *C1, Constant *C2) {
1068 return getSub(C1, C2, HasNUW: false, HasNSW: true);
1069 }
1070
1071 static Constant *getNUWSub(Constant *C1, Constant *C2) {
1072 return getSub(C1, C2, HasNUW: true, HasNSW: false);
1073 }
1074
1075 static Constant *getNSWMul(Constant *C1, Constant *C2) {
1076 return getMul(C1, C2, HasNUW: false, HasNSW: true);
1077 }
1078
1079 static Constant *getNUWMul(Constant *C1, Constant *C2) {
1080 return getMul(C1, C2, HasNUW: true, HasNSW: false);
1081 }
1082
1083 static Constant *getNSWShl(Constant *C1, Constant *C2) {
1084 return getShl(C1, C2, HasNUW: false, HasNSW: true);
1085 }
1086
1087 static Constant *getNUWShl(Constant *C1, Constant *C2) {
1088 return getShl(C1, C2, HasNUW: true, HasNSW: false);
1089 }
1090
1091 /// If C is a scalar/fixed width vector of known powers of 2, then this
1092 /// function returns a new scalar/fixed width vector obtained from logBase2
1093 /// of C. Undef vector elements are set to zero.
1094 /// Return a null pointer otherwise.
1095 static Constant *getExactLogBase2(Constant *C);
1096
1097 /// Return the identity constant for a binary opcode.
1098 /// If the binop is not commutative, callers can acquire the operand 1
1099 /// identity constant by setting AllowRHSConstant to true. For example, any
1100 /// shift has a zero identity constant for operand 1: X shift 0 = X. If this
1101 /// is a fadd/fsub operation and we don't care about signed zeros, then
1102 /// setting NSZ to true returns the identity +0.0 instead of -0.0. Return
1103 /// nullptr if the operator does not have an identity constant.
1104 static Constant *getBinOpIdentity(unsigned Opcode, Type *Ty,
1105 bool AllowRHSConstant = false,
1106 bool NSZ = false);
1107
1108 static Constant *getIntrinsicIdentity(Intrinsic::ID, Type *Ty);
1109
1110 /// Return the identity constant for a binary or intrinsic Instruction.
1111 /// The identity constant C is defined as X op C = X and C op X = X where C
1112 /// and X are the first two operands, and the operation is commutative.
1113 static Constant *getIdentity(Instruction *I, Type *Ty,
1114 bool AllowRHSConstant = false, bool NSZ = false);
1115
1116 /// Return the absorbing element for the given binary
1117 /// operation, i.e. a constant C such that X op C = C and C op X = C for
1118 /// every X. For example, this returns zero for integer multiplication.
1119 /// It returns null if the operator doesn't have an absorbing element.
1120 static Constant *getBinOpAbsorber(unsigned Opcode, Type *Ty);
1121
1122 /// Transparently provide more efficient getOperand methods.
1123 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
1124
1125 /// Convenience function for getting a Cast operation.
1126 ///
1127 /// \param ops The opcode for the conversion
1128 /// \param C The constant to be converted
1129 /// \param Ty The type to which the constant is converted
1130 /// \param OnlyIfReduced see \a getWithOperands() docs.
1131 static Constant *getCast(unsigned ops, Constant *C, Type *Ty,
1132 bool OnlyIfReduced = false);
1133
1134 // Create a Trunc or BitCast cast constant expression
1135 static Constant *
1136 getTruncOrBitCast(Constant *C, ///< The constant to trunc or bitcast
1137 Type *Ty ///< The type to trunc or bitcast C to
1138 );
1139
1140 /// Create a BitCast, AddrSpaceCast, or a PtrToInt cast constant
1141 /// expression.
1142 static Constant *
1143 getPointerCast(Constant *C, ///< The pointer value to be casted (operand 0)
1144 Type *Ty ///< The type to which cast should be made
1145 );
1146
1147 /// Create a BitCast or AddrSpaceCast for a pointer type depending on
1148 /// the address space.
1149 static Constant *getPointerBitCastOrAddrSpaceCast(
1150 Constant *C, ///< The constant to addrspacecast or bitcast
1151 Type *Ty ///< The type to bitcast or addrspacecast C to
1152 );
1153
1154 /// Return true if this is a convert constant expression
1155 bool isCast() const;
1156
1157 /// Return true if this is a compare constant expression
1158 bool isCompare() const;
1159
1160 /// get - Return a binary or shift operator constant expression,
1161 /// folding if possible.
1162 ///
1163 /// \param OnlyIfReducedTy see \a getWithOperands() docs.
1164 static Constant *get(unsigned Opcode, Constant *C1, Constant *C2,
1165 unsigned Flags = 0, Type *OnlyIfReducedTy = nullptr);
1166
1167 /// Return an ICmp or FCmp comparison operator constant expression.
1168 ///
1169 /// \param OnlyIfReduced see \a getWithOperands() docs.
1170 static Constant *getCompare(unsigned short pred, Constant *C1, Constant *C2,
1171 bool OnlyIfReduced = false);
1172
1173 /// get* - Return some common constants without having to
1174 /// specify the full Instruction::OPCODE identifier.
1175 ///
1176 static Constant *getICmp(unsigned short pred, Constant *LHS, Constant *RHS,
1177 bool OnlyIfReduced = false);
1178 static Constant *getFCmp(unsigned short pred, Constant *LHS, Constant *RHS,
1179 bool OnlyIfReduced = false);
1180
1181 /// Getelementptr form. Value* is only accepted for convenience;
1182 /// all elements must be Constants.
1183 ///
1184 /// \param InRangeIndex the inrange index if present or std::nullopt.
1185 /// \param OnlyIfReducedTy see \a getWithOperands() docs.
1186 static Constant *
1187 getGetElementPtr(Type *Ty, Constant *C, ArrayRef<Constant *> IdxList,
1188 bool InBounds = false,
1189 std::optional<unsigned> InRangeIndex = std::nullopt,
1190 Type *OnlyIfReducedTy = nullptr) {
1191 return getGetElementPtr(
1192 Ty, C, IdxList: ArrayRef((Value *const *)IdxList.data(), IdxList.size()),
1193 InBounds, InRangeIndex, OnlyIfReducedTy);
1194 }
1195 static Constant *
1196 getGetElementPtr(Type *Ty, Constant *C, Constant *Idx, bool InBounds = false,
1197 std::optional<unsigned> InRangeIndex = std::nullopt,
1198 Type *OnlyIfReducedTy = nullptr) {
1199 // This form of the function only exists to avoid ambiguous overload
1200 // warnings about whether to convert Idx to ArrayRef<Constant *> or
1201 // ArrayRef<Value *>.
1202 return getGetElementPtr(Ty, C, IdxList: cast<Value>(Val: Idx), InBounds, InRangeIndex,
1203 OnlyIfReducedTy);
1204 }
1205 static Constant *
1206 getGetElementPtr(Type *Ty, Constant *C, ArrayRef<Value *> IdxList,
1207 bool InBounds = false,
1208 std::optional<unsigned> InRangeIndex = std::nullopt,
1209 Type *OnlyIfReducedTy = nullptr);
1210
1211 /// Create an "inbounds" getelementptr. See the documentation for the
1212 /// "inbounds" flag in LangRef.html for details.
1213 static Constant *getInBoundsGetElementPtr(Type *Ty, Constant *C,
1214 ArrayRef<Constant *> IdxList) {
1215 return getGetElementPtr(Ty, C, IdxList, InBounds: true);
1216 }
1217 static Constant *getInBoundsGetElementPtr(Type *Ty, Constant *C,
1218 Constant *Idx) {
1219 // This form of the function only exists to avoid ambiguous overload
1220 // warnings about whether to convert Idx to ArrayRef<Constant *> or
1221 // ArrayRef<Value *>.
1222 return getGetElementPtr(Ty, C, Idx, InBounds: true);
1223 }
1224 static Constant *getInBoundsGetElementPtr(Type *Ty, Constant *C,
1225 ArrayRef<Value *> IdxList) {
1226 return getGetElementPtr(Ty, C, IdxList, InBounds: true);
1227 }
1228
1229 static Constant *getExtractElement(Constant *Vec, Constant *Idx,
1230 Type *OnlyIfReducedTy = nullptr);
1231 static Constant *getInsertElement(Constant *Vec, Constant *Elt, Constant *Idx,
1232 Type *OnlyIfReducedTy = nullptr);
1233 static Constant *getShuffleVector(Constant *V1, Constant *V2,
1234 ArrayRef<int> Mask,
1235 Type *OnlyIfReducedTy = nullptr);
1236
1237 /// Return the opcode at the root of this constant expression
1238 unsigned getOpcode() const { return getSubclassDataFromValue(); }
1239
1240 /// Return the ICMP or FCMP predicate value. Assert if this is not an ICMP or
1241 /// FCMP constant expression.
1242 unsigned getPredicate() const;
1243
1244 /// Assert that this is a shufflevector and return the mask. See class
1245 /// ShuffleVectorInst for a description of the mask representation.
1246 ArrayRef<int> getShuffleMask() const;
1247
1248 /// Assert that this is a shufflevector and return the mask.
1249 ///
1250 /// TODO: This is a temporary hack until we update the bitcode format for
1251 /// shufflevector.
1252 Constant *getShuffleMaskForBitcode() const;
1253
1254 /// Return a string representation for an opcode.
1255 const char *getOpcodeName() const;
1256
1257 /// This returns the current constant expression with the operands replaced
1258 /// with the specified values. The specified array must have the same number
1259 /// of operands as our current one.
1260 Constant *getWithOperands(ArrayRef<Constant *> Ops) const {
1261 return getWithOperands(Ops, Ty: getType());
1262 }
1263
1264 /// Get the current expression with the operands replaced.
1265 ///
1266 /// Return the current constant expression with the operands replaced with \c
1267 /// Ops and the type with \c Ty. The new operands must have the same number
1268 /// as the current ones.
1269 ///
1270 /// If \c OnlyIfReduced is \c true, nullptr will be returned unless something
1271 /// gets constant-folded, the type changes, or the expression is otherwise
1272 /// canonicalized. This parameter should almost always be \c false.
1273 Constant *getWithOperands(ArrayRef<Constant *> Ops, Type *Ty,
1274 bool OnlyIfReduced = false,
1275 Type *SrcTy = nullptr) const;
1276
1277 /// Returns an Instruction which implements the same operation as this
1278 /// ConstantExpr. If \p InsertBefore is not null, the new instruction is
1279 /// inserted before it, otherwise it is not inserted into any basic block.
1280 ///
1281 /// A better approach to this could be to have a constructor for Instruction
1282 /// which would take a ConstantExpr parameter, but that would have spread
1283 /// implementation details of ConstantExpr outside of Constants.cpp, which
1284 /// would make it harder to remove ConstantExprs altogether.
1285 Instruction *getAsInstruction(Instruction *InsertBefore = nullptr) const;
1286
1287 /// Whether creating a constant expression for this binary operator is
1288 /// desirable.
1289 static bool isDesirableBinOp(unsigned Opcode);
1290
1291 /// Whether creating a constant expression for this binary operator is
1292 /// supported.
1293 static bool isSupportedBinOp(unsigned Opcode);
1294
1295 /// Whether creating a constant expression for this cast is desirable.
1296 static bool isDesirableCastOp(unsigned Opcode);
1297
1298 /// Whether creating a constant expression for this cast is supported.
1299 static bool isSupportedCastOp(unsigned Opcode);
1300
1301 /// Whether creating a constant expression for this getelementptr type is
1302 /// supported.
1303 static bool isSupportedGetElementPtr(const Type *SrcElemTy) {
1304 return !SrcElemTy->isScalableTy();
1305 }
1306
1307 /// Methods for support type inquiry through isa, cast, and dyn_cast:
1308 static bool classof(const Value *V) {
1309 return V->getValueID() == ConstantExprVal;
1310 }
1311
1312private:
1313 // Shadow Value::setValueSubclassData with a private forwarding method so that
1314 // subclasses cannot accidentally use it.
1315 void setValueSubclassData(unsigned short D) {
1316 Value::setValueSubclassData(D);
1317 }
1318};
1319
1320template <>
1321struct OperandTraits<ConstantExpr>
1322 : public VariadicOperandTraits<ConstantExpr, 1> {};
1323
1324DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantExpr, Constant)
1325
1326//===----------------------------------------------------------------------===//
1327/// 'undef' values are things that do not have specified contents.
1328/// These are used for a variety of purposes, including global variable
1329/// initializers and operands to instructions. 'undef' values can occur with
1330/// any first-class type.
1331///
1332/// Undef values aren't exactly constants; if they have multiple uses, they
1333/// can appear to have different bit patterns at each use. See
1334/// LangRef.html#undefvalues for details.
1335///
1336class UndefValue : public ConstantData {
1337 friend class Constant;
1338
1339 explicit UndefValue(Type *T) : ConstantData(T, UndefValueVal) {}
1340
1341 void destroyConstantImpl();
1342
1343protected:
1344 explicit UndefValue(Type *T, ValueTy vty) : ConstantData(T, vty) {}
1345
1346public:
1347 UndefValue(const UndefValue &) = delete;
1348
1349 /// Static factory methods - Return an 'undef' object of the specified type.
1350 static UndefValue *get(Type *T);
1351
1352 /// If this Undef has array or vector type, return a undef with the right
1353 /// element type.
1354 UndefValue *getSequentialElement() const;
1355
1356 /// If this undef has struct type, return a undef with the right element type
1357 /// for the specified element.
1358 UndefValue *getStructElement(unsigned Elt) const;
1359
1360 /// Return an undef of the right value for the specified GEP index if we can,
1361 /// otherwise return null (e.g. if C is a ConstantExpr).
1362 UndefValue *getElementValue(Constant *C) const;
1363
1364 /// Return an undef of the right value for the specified GEP index.
1365 UndefValue *getElementValue(unsigned Idx) const;
1366
1367 /// Return the number of elements in the array, vector, or struct.
1368 unsigned getNumElements() const;
1369
1370 /// Methods for support type inquiry through isa, cast, and dyn_cast:
1371 static bool classof(const Value *V) {
1372 return V->getValueID() == UndefValueVal ||
1373 V->getValueID() == PoisonValueVal;
1374 }
1375};
1376
1377//===----------------------------------------------------------------------===//
1378/// In order to facilitate speculative execution, many instructions do not
1379/// invoke immediate undefined behavior when provided with illegal operands,
1380/// and return a poison value instead.
1381///
1382/// see LangRef.html#poisonvalues for details.
1383///
1384class PoisonValue final : public UndefValue {
1385 friend class Constant;
1386
1387 explicit PoisonValue(Type *T) : UndefValue(T, PoisonValueVal) {}
1388
1389 void destroyConstantImpl();
1390
1391public:
1392 PoisonValue(const PoisonValue &) = delete;
1393
1394 /// Static factory methods - Return an 'poison' object of the specified type.
1395 static PoisonValue *get(Type *T);
1396
1397 /// If this poison has array or vector type, return a poison with the right
1398 /// element type.
1399 PoisonValue *getSequentialElement() const;
1400
1401 /// If this poison has struct type, return a poison with the right element
1402 /// type for the specified element.
1403 PoisonValue *getStructElement(unsigned Elt) const;
1404
1405 /// Return an poison of the right value for the specified GEP index if we can,
1406 /// otherwise return null (e.g. if C is a ConstantExpr).
1407 PoisonValue *getElementValue(Constant *C) const;
1408
1409 /// Return an poison of the right value for the specified GEP index.
1410 PoisonValue *getElementValue(unsigned Idx) const;
1411
1412 /// Methods for support type inquiry through isa, cast, and dyn_cast:
1413 static bool classof(const Value *V) {
1414 return V->getValueID() == PoisonValueVal;
1415 }
1416};
1417
1418} // end namespace llvm
1419
1420#endif // LLVM_IR_CONSTANTS_H
1421

source code of llvm/include/llvm/IR/Constants.h