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/None.h"
27#include "llvm/ADT/Optional.h"
28#include "llvm/ADT/STLExtras.h"
29#include "llvm/ADT/StringRef.h"
30#include "llvm/IR/Constant.h"
31#include "llvm/IR/DerivedTypes.h"
32#include "llvm/IR/OperandTraits.h"
33#include "llvm/IR/User.h"
34#include "llvm/IR/Value.h"
35#include "llvm/Support/Casting.h"
36#include "llvm/Support/Compiler.h"
37#include "llvm/Support/ErrorHandling.h"
38#include <cassert>
39#include <cstddef>
40#include <cstdint>
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(s, 0); }
62
63public:
64 ConstantData(const ConstantData &) = delete;
65
66 /// Methods to support type inquiry through isa, cast, and dyn_cast.
67 static bool classof(const Value *V) {
68 return V->getValueID() >= ConstantDataFirstVal &&
69 V->getValueID() <= ConstantDataLastVal;
70 }
71};
72
73//===----------------------------------------------------------------------===//
74/// This is the shared class of boolean and integer constants. This class
75/// represents both boolean and integral constants.
76/// Class for constant integers.
77class ConstantInt final : public ConstantData {
78 friend class Constant;
79
80 APInt Val;
81
82 ConstantInt(IntegerType *Ty, const APInt &V);
83
84 void destroyConstantImpl();
85
86public:
87 ConstantInt(const ConstantInt &) = delete;
88
89 static ConstantInt *getTrue(LLVMContext &Context);
90 static ConstantInt *getFalse(LLVMContext &Context);
91 static ConstantInt *getBool(LLVMContext &Context, bool V);
92 static Constant *getTrue(Type *Ty);
93 static Constant *getFalse(Type *Ty);
94 static Constant *getBool(Type *Ty, bool V);
95
96 /// If Ty is a vector type, return a Constant with a splat of the given
97 /// value. Otherwise return a ConstantInt for the given value.
98 static Constant *get(Type *Ty, uint64_t V, bool IsSigned = false);
99
100 /// Return a ConstantInt with the specified integer value for the specified
101 /// type. If the type is wider than 64 bits, the value will be zero-extended
102 /// to fit the type, unless IsSigned is true, in which case the value will
103 /// be interpreted as a 64-bit signed integer and sign-extended to fit
104 /// the type.
105 /// Get a ConstantInt for a specific value.
106 static ConstantInt *get(IntegerType *Ty, uint64_t V, bool IsSigned = false);
107
108 /// Return a ConstantInt with the specified value for the specified type. The
109 /// value V will be canonicalized to a an unsigned APInt. Accessing it with
110 /// either getSExtValue() or getZExtValue() will yield a correctly sized and
111 /// signed value for the type Ty.
112 /// Get a ConstantInt for a specific signed value.
113 static ConstantInt *getSigned(IntegerType *Ty, int64_t V);
114 static Constant *getSigned(Type *Ty, int64_t V);
115
116 /// Return a ConstantInt with the specified value and an implied Type. The
117 /// type is the integer type that corresponds to the bit width of the value.
118 static ConstantInt *get(LLVMContext &Context, const APInt &V);
119
120 /// Return a ConstantInt constructed from the string strStart with the given
121 /// radix.
122 static ConstantInt *get(IntegerType *Ty, StringRef Str, uint8_t Radix);
123
124 /// If Ty is a vector type, return a Constant with a splat of the given
125 /// value. Otherwise return a ConstantInt for the given value.
126 static Constant *get(Type *Ty, const APInt &V);
127
128 /// Return the constant as an APInt value reference. This allows clients to
129 /// obtain a full-precision copy of the value.
130 /// Return the constant's value.
131 inline const APInt &getValue() const { return Val; }
132
133 /// getBitWidth - Return the bitwidth of this constant.
134 unsigned getBitWidth() const { return Val.getBitWidth(); }
135
136 /// Return the constant as a 64-bit unsigned integer value after it
137 /// has been zero extended as appropriate for the type of this constant. Note
138 /// that this method can assert if the value does not fit in 64 bits.
139 /// Return the zero extended value.
140 inline uint64_t getZExtValue() const { return Val.getZExtValue(); }
141
142 /// Return the constant as a 64-bit integer value after it has been sign
143 /// extended as appropriate for the type of this constant. Note that
144 /// this method can assert if the value does not fit in 64 bits.
145 /// Return the sign extended value.
146 inline int64_t getSExtValue() const { return Val.getSExtValue(); }
147
148 /// Return the constant as an llvm::MaybeAlign.
149 /// Note that this method can assert if the value does not fit in 64 bits or
150 /// is not a power of two.
151 inline MaybeAlign getMaybeAlignValue() const {
152 return MaybeAlign(getZExtValue());
153 }
154
155 /// Return the constant as an llvm::Align, interpreting `0` as `Align(1)`.
156 /// Note that this method can assert if the value does not fit in 64 bits or
157 /// is not a power of two.
158 inline Align getAlignValue() const {
159 return getMaybeAlignValue().valueOrOne();
160 }
161
162 /// A helper method that can be used to determine if the constant contained
163 /// within is equal to a constant. This only works for very small values,
164 /// because this is all that can be represented with all types.
165 /// Determine if this constant's value is same as an unsigned char.
166 bool equalsInt(uint64_t V) const { return Val == V; }
167
168 /// getType - Specialize the getType() method to always return an IntegerType,
169 /// which reduces the amount of casting needed in parts of the compiler.
170 ///
171 inline IntegerType *getType() const {
172 return cast<IntegerType>(Value::getType());
173 }
174
175 /// This static method returns true if the type Ty is big enough to
176 /// represent the value V. This can be used to avoid having the get method
177 /// assert when V is larger than Ty can represent. Note that there are two
178 /// versions of this method, one for unsigned and one for signed integers.
179 /// Although ConstantInt canonicalizes everything to an unsigned integer,
180 /// the signed version avoids callers having to convert a signed quantity
181 /// to the appropriate unsigned type before calling the method.
182 /// @returns true if V is a valid value for type Ty
183 /// Determine if the value is in range for the given type.
184 static bool isValueValidForType(Type *Ty, uint64_t V);
185 static bool isValueValidForType(Type *Ty, int64_t V);
186
187 bool isNegative() const { return Val.isNegative(); }
188
189 /// This is just a convenience method to make client code smaller for a
190 /// common code. It also correctly performs the comparison without the
191 /// potential for an assertion from getZExtValue().
192 bool isZero() const { return Val.isNullValue(); }
193
194 /// This is just a convenience method to make client code smaller for a
195 /// common case. It also correctly performs the comparison without the
196 /// potential for an assertion from getZExtValue().
197 /// Determine if the value is one.
198 bool isOne() const { return Val.isOneValue(); }
199
200 /// This function will return true iff every bit in this constant is set
201 /// to true.
202 /// @returns true iff this constant's bits are all set to true.
203 /// Determine if the value is all ones.
204 bool isMinusOne() const { return Val.isAllOnesValue(); }
205
206 /// This function will return true iff this constant represents the largest
207 /// value that may be represented by the constant's type.
208 /// @returns true iff this is the largest value that may be represented
209 /// by this type.
210 /// Determine if the value is maximal.
211 bool isMaxValue(bool IsSigned) const {
212 if (IsSigned)
213 return Val.isMaxSignedValue();
214 else
215 return Val.isMaxValue();
216 }
217
218 /// This function will return true iff this constant represents the smallest
219 /// value that may be represented by this constant's type.
220 /// @returns true if this is the smallest value that may be represented by
221 /// this type.
222 /// Determine if the value is minimal.
223 bool isMinValue(bool IsSigned) const {
224 if (IsSigned)
225 return Val.isMinSignedValue();
226 else
227 return Val.isMinValue();
228 }
229
230 /// This function will return true iff this constant represents a value with
231 /// active bits bigger than 64 bits or a value greater than the given uint64_t
232 /// value.
233 /// @returns true iff this constant is greater or equal to the given number.
234 /// Determine if the value is greater or equal to the given number.
235 bool uge(uint64_t Num) const { return Val.uge(Num); }
236
237 /// getLimitedValue - If the value is smaller than the specified limit,
238 /// return it, otherwise return the limit value. This causes the value
239 /// to saturate to the limit.
240 /// @returns the min of the value of the constant and the specified value
241 /// Get the constant's value with a saturation limit
242 uint64_t getLimitedValue(uint64_t Limit = ~0ULL) const {
243 return Val.getLimitedValue(Limit);
244 }
245
246 /// Methods to support type inquiry through isa, cast, and dyn_cast.
247 static bool classof(const Value *V) {
248 return V->getValueID() == ConstantIntVal;
249 }
250};
251
252//===----------------------------------------------------------------------===//
253/// ConstantFP - Floating Point Values [float, double]
254///
255class ConstantFP final : public ConstantData {
256 friend class Constant;
257
258 APFloat Val;
259
260 ConstantFP(Type *Ty, const APFloat &V);
261
262 void destroyConstantImpl();
263
264public:
265 ConstantFP(const ConstantFP &) = delete;
266
267 /// Floating point negation must be implemented with f(x) = -0.0 - x. This
268 /// method returns the negative zero constant for floating point or vector
269 /// floating point types; for all other types, it returns the null value.
270 static Constant *getZeroValueForNegation(Type *Ty);
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 *getNegativeZero(Type *Ty);
291 static Constant *getInfinity(Type *Ty, bool Negative = false);
292
293 /// Return true if Ty is big enough to represent V.
294 static bool isValueValidForType(Type *Ty, const APFloat &V);
295 inline const APFloat &getValueAPF() const { return Val; }
296 inline const APFloat &getValue() const { return Val; }
297
298 /// Return true if the value is positive or negative zero.
299 bool isZero() const { return Val.isZero(); }
300
301 /// Return true if the sign bit is set.
302 bool isNegative() const { return Val.isNegative(); }
303
304 /// Return true if the value is infinity
305 bool isInfinity() const { return Val.isInfinity(); }
306
307 /// Return true if the value is a NaN.
308 bool isNaN() const { return Val.isNaN(); }
309
310 /// We don't rely on operator== working on double values, as it returns true
311 /// for things that are clearly not equal, like -0.0 and 0.0.
312 /// As such, this method can be used to do an exact bit-for-bit comparison of
313 /// two floating point values. The version with a double operand is retained
314 /// because it's so convenient to write isExactlyValue(2.0), but please use
315 /// it only for simple constants.
316 bool isExactlyValue(const APFloat &V) const;
317
318 bool isExactlyValue(double V) const {
319 bool ignored;
320 APFloat FV(V);
321 FV.convert(Val.getSemantics(), APFloat::rmNearestTiesToEven, &ignored);
322 return isExactlyValue(FV);
323 }
324
325 /// Methods for support type inquiry through isa, cast, and dyn_cast:
326 static bool classof(const Value *V) {
327 return V->getValueID() == ConstantFPVal;
328 }
329};
330
331//===----------------------------------------------------------------------===//
332/// All zero aggregate value
333///
334class ConstantAggregateZero final : public ConstantData {
335 friend class Constant;
336
337 explicit ConstantAggregateZero(Type *Ty)
338 : ConstantData(Ty, ConstantAggregateZeroVal) {}
339
340 void destroyConstantImpl();
341
342public:
343 ConstantAggregateZero(const ConstantAggregateZero &) = delete;
344
345 static ConstantAggregateZero *get(Type *Ty);
346
347 /// If this CAZ has array or vector type, return a zero with the right element
348 /// type.
349 Constant *getSequentialElement() const;
350
351 /// If this CAZ has struct type, return a zero with the right element type for
352 /// the specified element.
353 Constant *getStructElement(unsigned Elt) const;
354
355 /// Return a zero of the right value for the specified GEP index if we can,
356 /// otherwise return null (e.g. if C is a ConstantExpr).
357 Constant *getElementValue(Constant *C) const;
358
359 /// Return a zero of the right value for the specified GEP index.
360 Constant *getElementValue(unsigned Idx) const;
361
362 /// Return the number of elements in the array, vector, or struct.
363 unsigned getNumElements() const;
364
365 /// Methods for support type inquiry through isa, cast, and dyn_cast:
366 ///
367 static bool classof(const Value *V) {
368 return V->getValueID() == ConstantAggregateZeroVal;
369 }
370};
371
372/// Base class for aggregate constants (with operands).
373///
374/// These constants are aggregates of other constants, which are stored as
375/// operands.
376///
377/// Subclasses are \a ConstantStruct, \a ConstantArray, and \a
378/// ConstantVector.
379///
380/// \note Some subclasses of \a ConstantData are semantically aggregates --
381/// such as \a ConstantDataArray -- but are not subclasses of this because they
382/// use operands.
383class ConstantAggregate : public Constant {
384protected:
385 ConstantAggregate(Type *T, ValueTy VT, ArrayRef<Constant *> V);
386
387public:
388 /// Transparently provide more efficient getOperand methods.
389 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
390
391 /// Methods for support type inquiry through isa, cast, and dyn_cast:
392 static bool classof(const Value *V) {
393 return V->getValueID() >= ConstantAggregateFirstVal &&
394 V->getValueID() <= ConstantAggregateLastVal;
395 }
396};
397
398template <>
399struct OperandTraits<ConstantAggregate>
400 : public VariadicOperandTraits<ConstantAggregate> {};
401
402DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantAggregate, Constant)
403
404//===----------------------------------------------------------------------===//
405/// ConstantArray - Constant Array Declarations
406///
407class ConstantArray final : public ConstantAggregate {
408 friend struct ConstantAggrKeyType<ConstantArray>;
409 friend class Constant;
410
411 ConstantArray(ArrayType *T, ArrayRef<Constant *> Val);
412
413 void destroyConstantImpl();
414 Value *handleOperandChangeImpl(Value *From, Value *To);
415
416public:
417 // ConstantArray accessors
418 static Constant *get(ArrayType *T, ArrayRef<Constant *> V);
419
420private:
421 static Constant *getImpl(ArrayType *T, ArrayRef<Constant *> V);
422
423public:
424 /// Specialize the getType() method to always return an ArrayType,
425 /// which reduces the amount of casting needed in parts of the compiler.
426 inline ArrayType *getType() const {
427 return cast<ArrayType>(Value::getType());
428 }
429
430 /// Methods for support type inquiry through isa, cast, and dyn_cast:
431 static bool classof(const Value *V) {
432 return V->getValueID() == ConstantArrayVal;
433 }
434};
435
436//===----------------------------------------------------------------------===//
437// Constant Struct Declarations
438//
439class ConstantStruct final : public ConstantAggregate {
440 friend struct ConstantAggrKeyType<ConstantStruct>;
441 friend class Constant;
442
443 ConstantStruct(StructType *T, ArrayRef<Constant *> Val);
444
445 void destroyConstantImpl();
446 Value *handleOperandChangeImpl(Value *From, Value *To);
447
448public:
449 // ConstantStruct accessors
450 static Constant *get(StructType *T, ArrayRef<Constant *> V);
451
452 template <typename... Csts>
453 static std::enable_if_t<are_base_of<Constant, Csts...>::value, Constant *>
454 get(StructType *T, Csts *...Vs) {
455 SmallVector<Constant *, 8> Values({Vs...});
456 return get(T, Values);
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(getTypeForElements(V, Packed), V);
463 }
464 static Constant *getAnon(LLVMContext &Ctx, ArrayRef<Constant *> V,
465 bool Packed = false) {
466 return get(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>(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>(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>(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(0, 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(StringRef(Data, Elts.size() * sizeof(ElementTy)), Elts.size(),
693 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, makeArrayRef(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(ElementTy, NumElements);
712 return getImpl(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>(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(ElementTy, ElementCount::getFixed(NumElements));
784 return getImpl(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>(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(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/// The address of a basic block.
846///
847class BlockAddress final : public Constant {
848 friend class Constant;
849
850 BlockAddress(Function *F, BasicBlock *BB);
851
852 void *operator new(size_t s) { return User::operator new(s, 2); }
853
854 void destroyConstantImpl();
855 Value *handleOperandChangeImpl(Value *From, Value *To);
856
857public:
858 /// Return a BlockAddress for the specified function and basic block.
859 static BlockAddress *get(Function *F, BasicBlock *BB);
860
861 /// Return a BlockAddress for the specified basic block. The basic
862 /// block must be embedded into a function.
863 static BlockAddress *get(BasicBlock *BB);
864
865 /// Lookup an existing \c BlockAddress constant for the given BasicBlock.
866 ///
867 /// \returns 0 if \c !BB->hasAddressTaken(), otherwise the \c BlockAddress.
868 static BlockAddress *lookup(const BasicBlock *BB);
869
870 /// Transparently provide more efficient getOperand methods.
871 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
872
873 Function *getFunction() const { return (Function *)Op<0>().get(); }
874 BasicBlock *getBasicBlock() const { return (BasicBlock *)Op<1>().get(); }
875
876 /// Methods for support type inquiry through isa, cast, and dyn_cast:
877 static bool classof(const Value *V) {
878 return V->getValueID() == BlockAddressVal;
879 }
880};
881
882template <>
883struct OperandTraits<BlockAddress>
884 : public FixedNumOperandTraits<BlockAddress, 2> {};
885
886DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BlockAddress, Value)
887
888/// Wrapper for a function that represents a value that
889/// functionally represents the original function. This can be a function,
890/// global alias to a function, or an ifunc.
891class DSOLocalEquivalent final : public Constant {
892 friend class Constant;
893
894 DSOLocalEquivalent(GlobalValue *GV);
895
896 void *operator new(size_t s) { return User::operator new(s, 1); }
897
898 void destroyConstantImpl();
899 Value *handleOperandChangeImpl(Value *From, Value *To);
900
901public:
902 /// Return a DSOLocalEquivalent for the specified global value.
903 static DSOLocalEquivalent *get(GlobalValue *GV);
904
905 /// Transparently provide more efficient getOperand methods.
906 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
907
908 GlobalValue *getGlobalValue() const {
909 return cast<GlobalValue>(Op<0>().get());
910 }
911
912 /// Methods for support type inquiry through isa, cast, and dyn_cast:
913 static bool classof(const Value *V) {
914 return V->getValueID() == DSOLocalEquivalentVal;
915 }
916};
917
918template <>
919struct OperandTraits<DSOLocalEquivalent>
920 : public FixedNumOperandTraits<DSOLocalEquivalent, 1> {};
921
922DEFINE_TRANSPARENT_OPERAND_ACCESSORS(DSOLocalEquivalent, Value)
923
924//===----------------------------------------------------------------------===//
925/// A constant value that is initialized with an expression using
926/// other constant values.
927///
928/// This class uses the standard Instruction opcodes to define the various
929/// constant expressions. The Opcode field for the ConstantExpr class is
930/// maintained in the Value::SubclassData field.
931class ConstantExpr : public Constant {
932 friend struct ConstantExprKeyType;
933 friend class Constant;
934
935 void destroyConstantImpl();
936 Value *handleOperandChangeImpl(Value *From, Value *To);
937
938protected:
939 ConstantExpr(Type *ty, unsigned Opcode, Use *Ops, unsigned NumOps)
940 : Constant(ty, ConstantExprVal, Ops, NumOps) {
941 // Operation type (an Instruction opcode) is stored as the SubclassData.
942 setValueSubclassData(Opcode);
943 }
944
945 ~ConstantExpr() = default;
946
947public:
948 // Static methods to construct a ConstantExpr of different kinds. Note that
949 // these methods may return a object that is not an instance of the
950 // ConstantExpr class, because they will attempt to fold the constant
951 // expression into something simpler if possible.
952
953 /// getAlignOf constant expr - computes the alignment of a type in a target
954 /// independent way (Note: the return type is an i64).
955 static Constant *getAlignOf(Type *Ty);
956
957 /// getSizeOf constant expr - computes the (alloc) size of a type (in
958 /// address-units, not bits) in a target independent way (Note: the return
959 /// type is an i64).
960 ///
961 static Constant *getSizeOf(Type *Ty);
962
963 /// getOffsetOf constant expr - computes the offset of a struct field in a
964 /// target independent way (Note: the return type is an i64).
965 ///
966 static Constant *getOffsetOf(StructType *STy, unsigned FieldNo);
967
968 /// getOffsetOf constant expr - This is a generalized form of getOffsetOf,
969 /// which supports any aggregate type, and any Constant index.
970 ///
971 static Constant *getOffsetOf(Type *Ty, Constant *FieldNo);
972
973 static Constant *getNeg(Constant *C, bool HasNUW = false,
974 bool HasNSW = false);
975 static Constant *getFNeg(Constant *C);
976 static Constant *getNot(Constant *C);
977 static Constant *getAdd(Constant *C1, Constant *C2, bool HasNUW = false,
978 bool HasNSW = false);
979 static Constant *getFAdd(Constant *C1, Constant *C2);
980 static Constant *getSub(Constant *C1, Constant *C2, bool HasNUW = false,
981 bool HasNSW = false);
982 static Constant *getFSub(Constant *C1, Constant *C2);
983 static Constant *getMul(Constant *C1, Constant *C2, bool HasNUW = false,
984 bool HasNSW = false);
985 static Constant *getFMul(Constant *C1, Constant *C2);
986 static Constant *getUDiv(Constant *C1, Constant *C2, bool isExact = false);
987 static Constant *getSDiv(Constant *C1, Constant *C2, bool isExact = false);
988 static Constant *getFDiv(Constant *C1, Constant *C2);
989 static Constant *getURem(Constant *C1, Constant *C2);
990 static Constant *getSRem(Constant *C1, Constant *C2);
991 static Constant *getFRem(Constant *C1, Constant *C2);
992 static Constant *getAnd(Constant *C1, Constant *C2);
993 static Constant *getOr(Constant *C1, Constant *C2);
994 static Constant *getXor(Constant *C1, Constant *C2);
995 static Constant *getUMin(Constant *C1, Constant *C2);
996 static Constant *getShl(Constant *C1, Constant *C2, bool HasNUW = false,
997 bool HasNSW = false);
998 static Constant *getLShr(Constant *C1, Constant *C2, bool isExact = false);
999 static Constant *getAShr(Constant *C1, Constant *C2, bool isExact = false);
1000 static Constant *getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced = false);
1001 static Constant *getSExt(Constant *C, Type *Ty, bool OnlyIfReduced = false);
1002 static Constant *getZExt(Constant *C, Type *Ty, bool OnlyIfReduced = false);
1003 static Constant *getFPTrunc(Constant *C, Type *Ty,
1004 bool OnlyIfReduced = false);
1005 static Constant *getFPExtend(Constant *C, Type *Ty,
1006 bool OnlyIfReduced = false);
1007 static Constant *getUIToFP(Constant *C, Type *Ty, bool OnlyIfReduced = false);
1008 static Constant *getSIToFP(Constant *C, Type *Ty, bool OnlyIfReduced = false);
1009 static Constant *getFPToUI(Constant *C, Type *Ty, bool OnlyIfReduced = false);
1010 static Constant *getFPToSI(Constant *C, Type *Ty, bool OnlyIfReduced = false);
1011 static Constant *getPtrToInt(Constant *C, Type *Ty,
1012 bool OnlyIfReduced = false);
1013 static Constant *getIntToPtr(Constant *C, Type *Ty,
1014 bool OnlyIfReduced = false);
1015 static Constant *getBitCast(Constant *C, Type *Ty,
1016 bool OnlyIfReduced = false);
1017 static Constant *getAddrSpaceCast(Constant *C, Type *Ty,
1018 bool OnlyIfReduced = false);
1019
1020 static Constant *getNSWNeg(Constant *C) { return getNeg(C, false, true); }
1021 static Constant *getNUWNeg(Constant *C) { return getNeg(C, true, false); }
1022
1023 static Constant *getNSWAdd(Constant *C1, Constant *C2) {
1024 return getAdd(C1, C2, false, true);
1025 }
1026
1027 static Constant *getNUWAdd(Constant *C1, Constant *C2) {
1028 return getAdd(C1, C2, true, false);
1029 }
1030
1031 static Constant *getNSWSub(Constant *C1, Constant *C2) {
1032 return getSub(C1, C2, false, true);
1033 }
1034
1035 static Constant *getNUWSub(Constant *C1, Constant *C2) {
1036 return getSub(C1, C2, true, false);
1037 }
1038
1039 static Constant *getNSWMul(Constant *C1, Constant *C2) {
1040 return getMul(C1, C2, false, true);
1041 }
1042
1043 static Constant *getNUWMul(Constant *C1, Constant *C2) {
1044 return getMul(C1, C2, true, false);
1045 }
1046
1047 static Constant *getNSWShl(Constant *C1, Constant *C2) {
1048 return getShl(C1, C2, false, true);
1049 }
1050
1051 static Constant *getNUWShl(Constant *C1, Constant *C2) {
1052 return getShl(C1, C2, true, false);
1053 }
1054
1055 static Constant *getExactSDiv(Constant *C1, Constant *C2) {
1056 return getSDiv(C1, C2, true);
1057 }
1058
1059 static Constant *getExactUDiv(Constant *C1, Constant *C2) {
1060 return getUDiv(C1, C2, true);
1061 }
1062
1063 static Constant *getExactAShr(Constant *C1, Constant *C2) {
1064 return getAShr(C1, C2, true);
1065 }
1066
1067 static Constant *getExactLShr(Constant *C1, Constant *C2) {
1068 return getLShr(C1, C2, true);
1069 }
1070
1071 /// If C is a scalar/fixed width vector of known powers of 2, then this
1072 /// function returns a new scalar/fixed width vector obtained from logBase2
1073 /// of C. Undef vector elements are set to zero.
1074 /// Return a null pointer otherwise.
1075 static Constant *getExactLogBase2(Constant *C);
1076
1077 /// Return the identity constant for a binary opcode.
1078 /// The identity constant C is defined as X op C = X and C op X = X for every
1079 /// X when the binary operation is commutative. If the binop is not
1080 /// commutative, callers can acquire the operand 1 identity constant by
1081 /// setting AllowRHSConstant to true. For example, any shift has a zero
1082 /// identity constant for operand 1: X shift 0 = X.
1083 /// Return nullptr if the operator does not have an identity constant.
1084 static Constant *getBinOpIdentity(unsigned Opcode, Type *Ty,
1085 bool AllowRHSConstant = false);
1086
1087 /// Return the absorbing element for the given binary
1088 /// operation, i.e. a constant C such that X op C = C and C op X = C for
1089 /// every X. For example, this returns zero for integer multiplication.
1090 /// It returns null if the operator doesn't have an absorbing element.
1091 static Constant *getBinOpAbsorber(unsigned Opcode, Type *Ty);
1092
1093 /// Transparently provide more efficient getOperand methods.
1094 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
1095
1096 /// Convenience function for getting a Cast operation.
1097 ///
1098 /// \param ops The opcode for the conversion
1099 /// \param C The constant to be converted
1100 /// \param Ty The type to which the constant is converted
1101 /// \param OnlyIfReduced see \a getWithOperands() docs.
1102 static Constant *getCast(unsigned ops, Constant *C, Type *Ty,
1103 bool OnlyIfReduced = false);
1104
1105 // Create a ZExt or BitCast cast constant expression
1106 static Constant *
1107 getZExtOrBitCast(Constant *C, ///< The constant to zext or bitcast
1108 Type *Ty ///< The type to zext or bitcast C to
1109 );
1110
1111 // Create a SExt or BitCast cast constant expression
1112 static Constant *
1113 getSExtOrBitCast(Constant *C, ///< The constant to sext or bitcast
1114 Type *Ty ///< The type to sext or bitcast C to
1115 );
1116
1117 // Create a Trunc or BitCast cast constant expression
1118 static Constant *
1119 getTruncOrBitCast(Constant *C, ///< The constant to trunc or bitcast
1120 Type *Ty ///< The type to trunc or bitcast C to
1121 );
1122
1123 /// Create a BitCast, AddrSpaceCast, or a PtrToInt cast constant
1124 /// expression.
1125 static Constant *
1126 getPointerCast(Constant *C, ///< The pointer value to be casted (operand 0)
1127 Type *Ty ///< The type to which cast should be made
1128 );
1129
1130 /// Create a BitCast or AddrSpaceCast for a pointer type depending on
1131 /// the address space.
1132 static Constant *getPointerBitCastOrAddrSpaceCast(
1133 Constant *C, ///< The constant to addrspacecast or bitcast
1134 Type *Ty ///< The type to bitcast or addrspacecast C to
1135 );
1136
1137 /// Create a ZExt, Bitcast or Trunc for integer -> integer casts
1138 static Constant *
1139 getIntegerCast(Constant *C, ///< The integer constant to be casted
1140 Type *Ty, ///< The integer type to cast to
1141 bool IsSigned ///< Whether C should be treated as signed or not
1142 );
1143
1144 /// Create a FPExt, Bitcast or FPTrunc for fp -> fp casts
1145 static Constant *getFPCast(Constant *C, ///< The integer constant to be casted
1146 Type *Ty ///< The integer type to cast to
1147 );
1148
1149 /// Return true if this is a convert constant expression
1150 bool isCast() const;
1151
1152 /// Return true if this is a compare constant expression
1153 bool isCompare() const;
1154
1155 /// Return true if this is an insertvalue or extractvalue expression,
1156 /// and the getIndices() method may be used.
1157 bool hasIndices() const;
1158
1159 /// Return true if this is a getelementptr expression and all
1160 /// the index operands are compile-time known integers within the
1161 /// corresponding notional static array extents. Note that this is
1162 /// not equivalant to, a subset of, or a superset of the "inbounds"
1163 /// property.
1164 bool isGEPWithNoNotionalOverIndexing() const;
1165
1166 /// Select constant expr
1167 ///
1168 /// \param OnlyIfReducedTy see \a getWithOperands() docs.
1169 static Constant *getSelect(Constant *C, Constant *V1, Constant *V2,
1170 Type *OnlyIfReducedTy = nullptr);
1171
1172 /// get - Return a unary operator constant expression,
1173 /// folding if possible.
1174 ///
1175 /// \param OnlyIfReducedTy see \a getWithOperands() docs.
1176 static Constant *get(unsigned Opcode, Constant *C1, unsigned Flags = 0,
1177 Type *OnlyIfReducedTy = nullptr);
1178
1179 /// get - Return a binary or shift operator constant expression,
1180 /// folding if possible.
1181 ///
1182 /// \param OnlyIfReducedTy see \a getWithOperands() docs.
1183 static Constant *get(unsigned Opcode, Constant *C1, Constant *C2,
1184 unsigned Flags = 0, Type *OnlyIfReducedTy = nullptr);
1185
1186 /// Return an ICmp or FCmp comparison operator constant expression.
1187 ///
1188 /// \param OnlyIfReduced see \a getWithOperands() docs.
1189 static Constant *getCompare(unsigned short pred, Constant *C1, Constant *C2,
1190 bool OnlyIfReduced = false);
1191
1192 /// get* - Return some common constants without having to
1193 /// specify the full Instruction::OPCODE identifier.
1194 ///
1195 static Constant *getICmp(unsigned short pred, Constant *LHS, Constant *RHS,
1196 bool OnlyIfReduced = false);
1197 static Constant *getFCmp(unsigned short pred, Constant *LHS, Constant *RHS,
1198 bool OnlyIfReduced = false);
1199
1200 /// Getelementptr form. Value* is only accepted for convenience;
1201 /// all elements must be Constants.
1202 ///
1203 /// \param InRangeIndex the inrange index if present or None.
1204 /// \param OnlyIfReducedTy see \a getWithOperands() docs.
1205 static Constant *getGetElementPtr(Type *Ty, Constant *C,
1206 ArrayRef<Constant *> IdxList,
1207 bool InBounds = false,
1208 Optional<unsigned> InRangeIndex = None,
1209 Type *OnlyIfReducedTy = nullptr) {
1210 return getGetElementPtr(
1211 Ty, C, makeArrayRef((Value *const *)IdxList.data(), IdxList.size()),
1212 InBounds, InRangeIndex, OnlyIfReducedTy);
1213 }
1214 static Constant *getGetElementPtr(Type *Ty, Constant *C, Constant *Idx,
1215 bool InBounds = false,
1216 Optional<unsigned> InRangeIndex = None,
1217 Type *OnlyIfReducedTy = nullptr) {
1218 // This form of the function only exists to avoid ambiguous overload
1219 // warnings about whether to convert Idx to ArrayRef<Constant *> or
1220 // ArrayRef<Value *>.
1221 return getGetElementPtr(Ty, C, cast<Value>(Idx), InBounds, InRangeIndex,
1222 OnlyIfReducedTy);
1223 }
1224 static Constant *getGetElementPtr(Type *Ty, Constant *C,
1225 ArrayRef<Value *> IdxList,
1226 bool InBounds = false,
1227 Optional<unsigned> InRangeIndex = None,
1228 Type *OnlyIfReducedTy = nullptr);
1229
1230 /// Create an "inbounds" getelementptr. See the documentation for the
1231 /// "inbounds" flag in LangRef.html for details.
1232 static Constant *getInBoundsGetElementPtr(Type *Ty, Constant *C,
1233 ArrayRef<Constant *> IdxList) {
1234 return getGetElementPtr(Ty, C, IdxList, true);
1235 }
1236 static Constant *getInBoundsGetElementPtr(Type *Ty, Constant *C,
1237 Constant *Idx) {
1238 // This form of the function only exists to avoid ambiguous overload
1239 // warnings about whether to convert Idx to ArrayRef<Constant *> or
1240 // ArrayRef<Value *>.
1241 return getGetElementPtr(Ty, C, Idx, true);
1242 }
1243 static Constant *getInBoundsGetElementPtr(Type *Ty, Constant *C,
1244 ArrayRef<Value *> IdxList) {
1245 return getGetElementPtr(Ty, C, IdxList, true);
1246 }
1247
1248 static Constant *getExtractElement(Constant *Vec, Constant *Idx,
1249 Type *OnlyIfReducedTy = nullptr);
1250 static Constant *getInsertElement(Constant *Vec, Constant *Elt, Constant *Idx,
1251 Type *OnlyIfReducedTy = nullptr);
1252 static Constant *getShuffleVector(Constant *V1, Constant *V2,
1253 ArrayRef<int> Mask,
1254 Type *OnlyIfReducedTy = nullptr);
1255 static Constant *getExtractValue(Constant *Agg, ArrayRef<unsigned> Idxs,
1256 Type *OnlyIfReducedTy = nullptr);
1257 static Constant *getInsertValue(Constant *Agg, Constant *Val,
1258 ArrayRef<unsigned> Idxs,
1259 Type *OnlyIfReducedTy = nullptr);
1260
1261 /// Return the opcode at the root of this constant expression
1262 unsigned getOpcode() const { return getSubclassDataFromValue(); }
1263
1264 /// Return the ICMP or FCMP predicate value. Assert if this is not an ICMP or
1265 /// FCMP constant expression.
1266 unsigned getPredicate() const;
1267
1268 /// Assert that this is an insertvalue or exactvalue
1269 /// expression and return the list of indices.
1270 ArrayRef<unsigned> getIndices() const;
1271
1272 /// Assert that this is a shufflevector and return the mask. See class
1273 /// ShuffleVectorInst for a description of the mask representation.
1274 ArrayRef<int> getShuffleMask() const;
1275
1276 /// Assert that this is a shufflevector and return the mask.
1277 ///
1278 /// TODO: This is a temporary hack until we update the bitcode format for
1279 /// shufflevector.
1280 Constant *getShuffleMaskForBitcode() const;
1281
1282 /// Return a string representation for an opcode.
1283 const char *getOpcodeName() const;
1284
1285 /// Return a constant expression identical to this one, but with the specified
1286 /// operand set to the specified value.
1287 Constant *getWithOperandReplaced(unsigned OpNo, Constant *Op) const;
1288
1289 /// This returns the current constant expression with the operands replaced
1290 /// with the specified values. The specified array must have the same number
1291 /// of operands as our current one.
1292 Constant *getWithOperands(ArrayRef<Constant *> Ops) const {
1293 return getWithOperands(Ops, getType());
1294 }
1295
1296 /// Get the current expression with the operands replaced.
1297 ///
1298 /// Return the current constant expression with the operands replaced with \c
1299 /// Ops and the type with \c Ty. The new operands must have the same number
1300 /// as the current ones.
1301 ///
1302 /// If \c OnlyIfReduced is \c true, nullptr will be returned unless something
1303 /// gets constant-folded, the type changes, or the expression is otherwise
1304 /// canonicalized. This parameter should almost always be \c false.
1305 Constant *getWithOperands(ArrayRef<Constant *> Ops, Type *Ty,
1306 bool OnlyIfReduced = false,
1307 Type *SrcTy = nullptr) const;
1308
1309 /// Returns an Instruction which implements the same operation as this
1310 /// ConstantExpr. The instruction is not linked to any basic block.
1311 ///
1312 /// A better approach to this could be to have a constructor for Instruction
1313 /// which would take a ConstantExpr parameter, but that would have spread
1314 /// implementation details of ConstantExpr outside of Constants.cpp, which
1315 /// would make it harder to remove ConstantExprs altogether.
1316 Instruction *getAsInstruction() const;
1317
1318 /// Methods for support type inquiry through isa, cast, and dyn_cast:
1319 static bool classof(const Value *V) {
1320 return V->getValueID() == ConstantExprVal;
1321 }
1322
1323private:
1324 // Shadow Value::setValueSubclassData with a private forwarding method so that
1325 // subclasses cannot accidentally use it.
1326 void setValueSubclassData(unsigned short D) {
1327 Value::setValueSubclassData(D);
1328 }
1329};
1330
1331template <>
1332struct OperandTraits<ConstantExpr>
1333 : public VariadicOperandTraits<ConstantExpr, 1> {};
1334
1335DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantExpr, Constant)
1336
1337//===----------------------------------------------------------------------===//
1338/// 'undef' values are things that do not have specified contents.
1339/// These are used for a variety of purposes, including global variable
1340/// initializers and operands to instructions. 'undef' values can occur with
1341/// any first-class type.
1342///
1343/// Undef values aren't exactly constants; if they have multiple uses, they
1344/// can appear to have different bit patterns at each use. See
1345/// LangRef.html#undefvalues for details.
1346///
1347class UndefValue : public ConstantData {
1348 friend class Constant;
1349
1350 explicit UndefValue(Type *T) : ConstantData(T, UndefValueVal) {}
1351
1352 void destroyConstantImpl();
1353
1354protected:
1355 explicit UndefValue(Type *T, ValueTy vty) : ConstantData(T, vty) {}
1356
1357public:
1358 UndefValue(const UndefValue &) = delete;
1359
1360 /// Static factory methods - Return an 'undef' object of the specified type.
1361 static UndefValue *get(Type *T);
1362
1363 /// If this Undef has array or vector type, return a undef with the right
1364 /// element type.
1365 UndefValue *getSequentialElement() const;
1366
1367 /// If this undef has struct type, return a undef with the right element type
1368 /// for the specified element.
1369 UndefValue *getStructElement(unsigned Elt) const;
1370
1371 /// Return an undef of the right value for the specified GEP index if we can,
1372 /// otherwise return null (e.g. if C is a ConstantExpr).
1373 UndefValue *getElementValue(Constant *C) const;
1374
1375 /// Return an undef of the right value for the specified GEP index.
1376 UndefValue *getElementValue(unsigned Idx) const;
1377
1378 /// Return the number of elements in the array, vector, or struct.
1379 unsigned getNumElements() const;
1380
1381 /// Methods for support type inquiry through isa, cast, and dyn_cast:
1382 static bool classof(const Value *V) {
1383 return V->getValueID() == UndefValueVal ||
1384 V->getValueID() == PoisonValueVal;
1385 }
1386};
1387
1388//===----------------------------------------------------------------------===//
1389/// In order to facilitate speculative execution, many instructions do not
1390/// invoke immediate undefined behavior when provided with illegal operands,
1391/// and return a poison value instead.
1392///
1393/// see LangRef.html#poisonvalues for details.
1394///
1395class PoisonValue final : public UndefValue {
1396 friend class Constant;
1397
1398 explicit PoisonValue(Type *T) : UndefValue(T, PoisonValueVal) {}
1399
1400 void destroyConstantImpl();
1401
1402public:
1403 PoisonValue(const PoisonValue &) = delete;
1404
1405 /// Static factory methods - Return an 'poison' object of the specified type.
1406 static PoisonValue *get(Type *T);
1407
1408 /// If this poison has array or vector type, return a poison with the right
1409 /// element type.
1410 PoisonValue *getSequentialElement() const;
1411
1412 /// If this poison has struct type, return a poison with the right element
1413 /// type for the specified element.
1414 PoisonValue *getStructElement(unsigned Elt) const;
1415
1416 /// Return an poison of the right value for the specified GEP index if we can,
1417 /// otherwise return null (e.g. if C is a ConstantExpr).
1418 PoisonValue *getElementValue(Constant *C) const;
1419
1420 /// Return an poison of the right value for the specified GEP index.
1421 PoisonValue *getElementValue(unsigned Idx) const;
1422
1423 /// Methods for support type inquiry through isa, cast, and dyn_cast:
1424 static bool classof(const Value *V) {
1425 return V->getValueID() == PoisonValueVal;
1426 }
1427};
1428
1429} // end namespace llvm
1430
1431#endif // LLVM_IR_CONSTANTS_H
1432