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