LLVM  6.0.0svn
Constants.h
Go to the documentation of this file.
1 //===-- llvm/Constants.h - Constant class subclass definitions --*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 /// @file
11 /// This file contains the declarations for the subclasses of Constant,
12 /// which represent the different flavors of constant values that live in LLVM.
13 /// Note that Constants are immutable (once created they never change) and are
14 /// fully shared by structural equivalence. This means that two structurally
15 /// equivalent constants will always have the same address. Constants are
16 /// created on demand as needed and never deleted: thus clients don't have to
17 /// worry about the lifetime of the objects.
18 //
19 //===----------------------------------------------------------------------===//
20 
21 #ifndef LLVM_IR_CONSTANTS_H
22 #define LLVM_IR_CONSTANTS_H
23 
24 #include "llvm/ADT/APFloat.h"
25 #include "llvm/ADT/APInt.h"
26 #include "llvm/ADT/ArrayRef.h"
27 #include "llvm/ADT/None.h"
28 #include "llvm/ADT/Optional.h"
29 #include "llvm/ADT/STLExtras.h"
30 #include "llvm/ADT/StringRef.h"
31 #include "llvm/IR/Constant.h"
32 #include "llvm/IR/DerivedTypes.h"
33 #include "llvm/IR/OperandTraits.h"
34 #include "llvm/IR/User.h"
35 #include "llvm/IR/Value.h"
36 #include "llvm/Support/Casting.h"
37 #include "llvm/Support/Compiler.h"
39 #include <cassert>
40 #include <cstddef>
41 #include <cstdint>
42 
43 namespace llvm {
44 
45 class ArrayType;
46 class IntegerType;
47 class PointerType;
48 class SequentialType;
49 class StructType;
50 class VectorType;
51 template <class ConstantClass> struct ConstantAggrKeyType;
52 
53 /// Base class for constants with no operands.
54 ///
55 /// These constants have no operands; they represent their data directly.
56 /// Since they can be in use by unrelated modules (and are never based on
57 /// GlobalValues), it never makes sense to RAUW them.
58 class ConstantData : public Constant {
59  friend class Constant;
60 
61  Value *handleOperandChangeImpl(Value *From, Value *To) {
62  llvm_unreachable("Constant data does not have operands!");
63  }
64 
65 protected:
66  explicit ConstantData(Type *Ty, ValueTy VT) : Constant(Ty, VT, nullptr, 0) {}
67 
68  void *operator new(size_t s) { return User::operator new(s, 0); }
69 
70 public:
71  ConstantData(const ConstantData &) = delete;
72 
73  /// Methods to support type inquiry through isa, cast, and dyn_cast.
74  static bool classof(const Value *V) {
75  return V->getValueID() >= ConstantDataFirstVal &&
76  V->getValueID() <= ConstantDataLastVal;
77  }
78 };
79 
80 //===----------------------------------------------------------------------===//
81 /// This is the shared class of boolean and integer constants. This class
82 /// represents both boolean and integral constants.
83 /// @brief Class for constant integers.
84 class ConstantInt final : public ConstantData {
85  friend class Constant;
86 
87  APInt Val;
88 
89  ConstantInt(IntegerType *Ty, const APInt& V);
90 
91  void destroyConstantImpl();
92 
93 public:
94  ConstantInt(const ConstantInt &) = delete;
95 
98  static Constant *getTrue(Type *Ty);
99  static Constant *getFalse(Type *Ty);
100 
101  /// If Ty is a vector type, return a Constant with a splat of the given
102  /// value. Otherwise return a ConstantInt for the given value.
103  static Constant *get(Type *Ty, uint64_t V, bool isSigned = false);
104 
105  /// Return a ConstantInt with the specified integer value for the specified
106  /// type. If the type is wider than 64 bits, the value will be zero-extended
107  /// to fit the type, unless isSigned is true, in which case the value will
108  /// be interpreted as a 64-bit signed integer and sign-extended to fit
109  /// the type.
110  /// @brief Get a ConstantInt for a specific value.
111  static ConstantInt *get(IntegerType *Ty, uint64_t V,
112  bool isSigned = false);
113 
114  /// Return a ConstantInt with the specified value for the specified type. The
115  /// value V will be canonicalized to a an unsigned APInt. Accessing it with
116  /// either getSExtValue() or getZExtValue() will yield a correctly sized and
117  /// signed value for the type Ty.
118  /// @brief Get a ConstantInt for a specific signed value.
119  static ConstantInt *getSigned(IntegerType *Ty, int64_t V);
120  static Constant *getSigned(Type *Ty, int64_t V);
121 
122  /// Return a ConstantInt with the specified value and an implied Type. The
123  /// type is the integer type that corresponds to the bit width of the value.
124  static ConstantInt *get(LLVMContext &Context, const APInt &V);
125 
126  /// Return a ConstantInt constructed from the string strStart with the given
127  /// radix.
128  static ConstantInt *get(IntegerType *Ty, StringRef Str,
129  uint8_t radix);
130 
131  /// If Ty is a vector type, return a Constant with a splat of the given
132  /// value. Otherwise return a ConstantInt for the given value.
133  static Constant *get(Type* Ty, const APInt& V);
134 
135  /// Return the constant as an APInt value reference. This allows clients to
136  /// obtain a full-precision copy of the value.
137  /// @brief Return the constant's value.
138  inline const APInt &getValue() const {
139  return Val;
140  }
141 
142  /// getBitWidth - Return the bitwidth of this constant.
143  unsigned getBitWidth() const { return Val.getBitWidth(); }
144 
145  /// Return the constant as a 64-bit unsigned integer value after it
146  /// has been zero extended as appropriate for the type of this constant. Note
147  /// that this method can assert if the value does not fit in 64 bits.
148  /// @brief Return the zero extended value.
149  inline uint64_t getZExtValue() const {
150  return Val.getZExtValue();
151  }
152 
153  /// Return the constant as a 64-bit integer value after it has been sign
154  /// extended as appropriate for the type of this constant. Note that
155  /// this method can assert if the value does not fit in 64 bits.
156  /// @brief Return the sign extended value.
157  inline int64_t getSExtValue() const {
158  return Val.getSExtValue();
159  }
160 
161  /// A helper method that can be used to determine if the constant contained
162  /// within is equal to a constant. This only works for very small values,
163  /// because this is all that can be represented with all types.
164  /// @brief Determine if this constant's value is same as an unsigned char.
165  bool equalsInt(uint64_t V) const {
166  return Val == V;
167  }
168 
169  /// getType - Specialize the getType() method to always return an IntegerType,
170  /// which reduces the amount of casting needed in parts of the compiler.
171  ///
172  inline IntegerType *getType() const {
173  return cast<IntegerType>(Value::getType());
174  }
175 
176  /// This static method returns true if the type Ty is big enough to
177  /// represent the value V. This can be used to avoid having the get method
178  /// assert when V is larger than Ty can represent. Note that there are two
179  /// versions of this method, one for unsigned and one for signed integers.
180  /// Although ConstantInt canonicalizes everything to an unsigned integer,
181  /// the signed version avoids callers having to convert a signed quantity
182  /// to the appropriate unsigned type before calling the method.
183  /// @returns true if V is a valid value for type Ty
184  /// @brief Determine if the value is in range for the given type.
185  static bool isValueValidForType(Type *Ty, uint64_t V);
186  static bool isValueValidForType(Type *Ty, int64_t V);
187 
188  bool isNegative() const { return Val.isNegative(); }
189 
190  /// This is just a convenience method to make client code smaller for a
191  /// common code. It also correctly performs the comparison without the
192  /// potential for an assertion from getZExtValue().
193  bool isZero() const {
194  return Val.isNullValue();
195  }
196 
197  /// This is just a convenience method to make client code smaller for a
198  /// common case. It also correctly performs the comparison without the
199  /// potential for an assertion from getZExtValue().
200  /// @brief Determine if the value is one.
201  bool isOne() const {
202  return Val.isOneValue();
203  }
204 
205  /// This function will return true iff every bit in this constant is set
206  /// to true.
207  /// @returns true iff this constant's bits are all set to true.
208  /// @brief Determine if the value is all ones.
209  bool isMinusOne() const {
210  return Val.isAllOnesValue();
211  }
212 
213  /// This function will return true iff this constant represents the largest
214  /// value that may be represented by the constant's type.
215  /// @returns true iff this is the largest value that may be represented
216  /// by this type.
217  /// @brief Determine if the value is maximal.
218  bool isMaxValue(bool isSigned) const {
219  if (isSigned)
220  return Val.isMaxSignedValue();
221  else
222  return Val.isMaxValue();
223  }
224 
225  /// This function will return true iff this constant represents the smallest
226  /// value that may be represented by this constant's type.
227  /// @returns true if this is the smallest value that may be represented by
228  /// this type.
229  /// @brief Determine if the value is minimal.
230  bool isMinValue(bool isSigned) const {
231  if (isSigned)
232  return Val.isMinSignedValue();
233  else
234  return Val.isMinValue();
235  }
236 
237  /// This function will return true iff this constant represents a value with
238  /// active bits bigger than 64 bits or a value greater than the given uint64_t
239  /// value.
240  /// @returns true iff this constant is greater or equal to the given number.
241  /// @brief Determine if the value is greater or equal to the given number.
242  bool uge(uint64_t Num) const {
243  return Val.uge(Num);
244  }
245 
246  /// getLimitedValue - If the value is smaller than the specified limit,
247  /// return it, otherwise return the limit value. This causes the value
248  /// to saturate to the limit.
249  /// @returns the min of the value of the constant and the specified value
250  /// @brief Get the constant's value with a saturation limit
251  uint64_t getLimitedValue(uint64_t Limit = ~0ULL) const {
252  return Val.getLimitedValue(Limit);
253  }
254 
255  /// @brief Methods to support type inquiry through isa, cast, and dyn_cast.
256  static bool classof(const Value *V) {
257  return V->getValueID() == ConstantIntVal;
258  }
259 };
260 
261 //===----------------------------------------------------------------------===//
262 /// ConstantFP - Floating Point Values [float, double]
263 ///
264 class ConstantFP final : public ConstantData {
265  friend class Constant;
266 
267  APFloat Val;
268 
269  ConstantFP(Type *Ty, const APFloat& V);
270 
271  void destroyConstantImpl();
272 
273 public:
274  ConstantFP(const ConstantFP &) = delete;
275 
276  /// Floating point negation must be implemented with f(x) = -0.0 - x. This
277  /// method returns the negative zero constant for floating point or vector
278  /// floating point types; for all other types, it returns the null value.
279  static Constant *getZeroValueForNegation(Type *Ty);
280 
281  /// This returns a ConstantFP, or a vector containing a splat of a ConstantFP,
282  /// for the specified value in the specified type. This should only be used
283  /// for simple constant values like 2.0/1.0 etc, that are known-valid both as
284  /// host double and as the target format.
285  static Constant *get(Type* Ty, double V);
286  static Constant *get(Type* Ty, StringRef Str);
287  static ConstantFP *get(LLVMContext &Context, const APFloat &V);
288  static Constant *getNaN(Type *Ty, bool Negative = false, unsigned type = 0);
289  static Constant *getNegativeZero(Type *Ty);
290  static Constant *getInfinity(Type *Ty, bool Negative = false);
291 
292  /// Return true if Ty is big enough to represent V.
293  static bool isValueValidForType(Type *Ty, const APFloat &V);
294  inline const APFloat &getValueAPF() const { return Val; }
295 
296  /// Return true if the value is positive or negative zero.
297  bool isZero() const { return Val.isZero(); }
298 
299  /// Return true if the sign bit is set.
300  bool isNegative() const { return Val.isNegative(); }
301 
302  /// Return true if the value is infinity
303  bool isInfinity() const { return Val.isInfinity(); }
304 
305  /// Return true if the value is a NaN.
306  bool isNaN() const { return Val.isNaN(); }
307 
308  /// We don't rely on operator== working on double values, as it returns true
309  /// for things that are clearly not equal, like -0.0 and 0.0.
310  /// As such, this method can be used to do an exact bit-for-bit comparison of
311  /// two floating point values. The version with a double operand is retained
312  /// because it's so convenient to write isExactlyValue(2.0), but please use
313  /// it only for simple constants.
314  bool isExactlyValue(const APFloat &V) const;
315 
316  bool isExactlyValue(double V) const {
317  bool ignored;
318  APFloat FV(V);
320  return isExactlyValue(FV);
321  }
322 
323  /// Methods for support type inquiry through isa, cast, and dyn_cast:
324  static bool classof(const Value *V) {
325  return V->getValueID() == ConstantFPVal;
326  }
327 };
328 
329 //===----------------------------------------------------------------------===//
330 /// All zero aggregate value
331 ///
332 class ConstantAggregateZero final : public ConstantData {
333  friend class Constant;
334 
335  explicit ConstantAggregateZero(Type *Ty)
336  : ConstantData(Ty, ConstantAggregateZeroVal) {}
337 
338  void destroyConstantImpl();
339 
340 public:
342 
343  static ConstantAggregateZero *get(Type *Ty);
344 
345  /// If this CAZ has array or vector type, return a zero with the right element
346  /// type.
347  Constant *getSequentialElement() const;
348 
349  /// If this CAZ has struct type, return a zero with the right element type for
350  /// the specified element.
351  Constant *getStructElement(unsigned Elt) const;
352 
353  /// Return a zero of the right value for the specified GEP index if we can,
354  /// otherwise return null (e.g. if C is a ConstantExpr).
355  Constant *getElementValue(Constant *C) const;
356 
357  /// Return a zero of the right value for the specified GEP index.
358  Constant *getElementValue(unsigned Idx) const;
359 
360  /// Return the number of elements in the array, vector, or struct.
361  unsigned getNumElements() const;
362 
363  /// Methods for support type inquiry through isa, cast, and dyn_cast:
364  ///
365  static bool classof(const Value *V) {
366  return V->getValueID() == ConstantAggregateZeroVal;
367  }
368 };
369 
370 /// Base class for aggregate constants (with operands).
371 ///
372 /// These constants are aggregates of other constants, which are stored as
373 /// operands.
374 ///
375 /// Subclasses are \a ConstantStruct, \a ConstantArray, and \a
376 /// ConstantVector.
377 ///
378 /// \note Some subclasses of \a ConstantData are semantically aggregates --
379 /// such as \a ConstantDataArray -- but are not subclasses of this because they
380 /// use operands.
381 class ConstantAggregate : public Constant {
382 protected:
384 
385 public:
386  /// Transparently provide more efficient getOperand methods.
388 
389  /// Methods for support type inquiry through isa, cast, and dyn_cast:
390  static bool classof(const Value *V) {
391  return V->getValueID() >= ConstantAggregateFirstVal &&
392  V->getValueID() <= ConstantAggregateLastVal;
393  }
394 };
395 
396 template <>
398  : public VariadicOperandTraits<ConstantAggregate> {};
399 
401 
402 //===----------------------------------------------------------------------===//
403 /// ConstantArray - Constant Array Declarations
404 ///
405 class ConstantArray final : public ConstantAggregate {
407  friend class Constant;
408 
410 
411  void destroyConstantImpl();
412  Value *handleOperandChangeImpl(Value *From, Value *To);
413 
414 public:
415  // ConstantArray accessors
416  static Constant *get(ArrayType *T, ArrayRef<Constant*> V);
417 
418 private:
420 
421 public:
422  /// Specialize the getType() method to always return an ArrayType,
423  /// which reduces the amount of casting needed in parts of the compiler.
424  inline ArrayType *getType() const {
425  return cast<ArrayType>(Value::getType());
426  }
427 
428  /// Methods for support type inquiry through isa, cast, and dyn_cast:
429  static bool classof(const Value *V) {
430  return V->getValueID() == ConstantArrayVal;
431  }
432 };
433 
434 //===----------------------------------------------------------------------===//
435 // Constant Struct Declarations
436 //
437 class ConstantStruct final : public ConstantAggregate {
439  friend class Constant;
440 
442 
443  void destroyConstantImpl();
444  Value *handleOperandChangeImpl(Value *From, Value *To);
445 
446 public:
447  // ConstantStruct accessors
448  static Constant *get(StructType *T, ArrayRef<Constant*> V);
449 
450  template <typename... Csts>
451  static typename std::enable_if<are_base_of<Constant, Csts...>::value,
452  Constant *>::type
453  get(StructType *T, Csts *... Vs) {
454  SmallVector<Constant *, 8> Values({Vs...});
455  return get(T, Values);
456  }
457 
458  /// Return an anonymous struct that has the specified elements.
459  /// If the struct is possibly empty, then you must specify a context.
460  static Constant *getAnon(ArrayRef<Constant*> V, bool Packed = false) {
461  return get(getTypeForElements(V, Packed), V);
462  }
463  static Constant *getAnon(LLVMContext &Ctx,
464  ArrayRef<Constant*> V, bool Packed = false) {
465  return get(getTypeForElements(Ctx, V, Packed), V);
466  }
467 
468  /// Return an anonymous struct type to use for a constant with the specified
469  /// set of elements. The list must not be empty.
470  static StructType *getTypeForElements(ArrayRef<Constant*> V,
471  bool Packed = false);
472  /// This version of the method allows an empty list.
473  static StructType *getTypeForElements(LLVMContext &Ctx,
475  bool Packed = false);
476 
477  /// Specialization - reduce amount of casting.
478  inline StructType *getType() const {
479  return cast<StructType>(Value::getType());
480  }
481 
482  /// Methods for support type inquiry through isa, cast, and dyn_cast:
483  static bool classof(const Value *V) {
484  return V->getValueID() == ConstantStructVal;
485  }
486 };
487 
488 //===----------------------------------------------------------------------===//
489 /// Constant Vector Declarations
490 ///
491 class ConstantVector final : public ConstantAggregate {
493  friend class Constant;
494 
496 
497  void destroyConstantImpl();
498  Value *handleOperandChangeImpl(Value *From, Value *To);
499 
500 public:
501  // ConstantVector accessors
502  static Constant *get(ArrayRef<Constant*> V);
503 
504 private:
506 
507 public:
508  /// Return a ConstantVector with the specified constant in each element.
509  static Constant *getSplat(unsigned NumElts, Constant *Elt);
510 
511  /// Specialize the getType() method to always return a VectorType,
512  /// which reduces the amount of casting needed in parts of the compiler.
513  inline VectorType *getType() const {
514  return cast<VectorType>(Value::getType());
515  }
516 
517  /// If this is a splat constant, meaning that all of the elements have the
518  /// same value, return that value. Otherwise return NULL.
519  Constant *getSplatValue() const;
520 
521  /// Methods for support type inquiry through isa, cast, and dyn_cast:
522  static bool classof(const Value *V) {
523  return V->getValueID() == ConstantVectorVal;
524  }
525 };
526 
527 //===----------------------------------------------------------------------===//
528 /// A constant pointer value that points to null
529 ///
530 class ConstantPointerNull final : public ConstantData {
531  friend class Constant;
532 
534  : ConstantData(T, Value::ConstantPointerNullVal) {}
535 
536  void destroyConstantImpl();
537 
538 public:
539  ConstantPointerNull(const ConstantPointerNull &) = delete;
540 
541  /// Static factory methods - Return objects of the specified value
542  static ConstantPointerNull *get(PointerType *T);
543 
544  /// Specialize the getType() method to always return an PointerType,
545  /// which reduces the amount of casting needed in parts of the compiler.
546  inline PointerType *getType() const {
547  return cast<PointerType>(Value::getType());
548  }
549 
550  /// Methods for support type inquiry through isa, cast, and dyn_cast:
551  static bool classof(const Value *V) {
552  return V->getValueID() == ConstantPointerNullVal;
553  }
554 };
555 
556 //===----------------------------------------------------------------------===//
557 /// ConstantDataSequential - A vector or array constant whose element type is a
558 /// simple 1/2/4/8-byte integer or float/double, and whose elements are just
559 /// simple data values (i.e. ConstantInt/ConstantFP). This Constant node has no
560 /// operands because it stores all of the elements of the constant as densely
561 /// packed data, instead of as Value*'s.
562 ///
563 /// This is the common base class of ConstantDataArray and ConstantDataVector.
564 ///
566  friend class LLVMContextImpl;
567  friend class Constant;
568 
569  /// A pointer to the bytes underlying this constant (which is owned by the
570  /// uniquing StringMap).
571  const char *DataElements;
572 
573  /// This forms a link list of ConstantDataSequential nodes that have
574  /// the same value but different type. For example, 0,0,0,1 could be a 4
575  /// element array of i8, or a 1-element array of i32. They'll both end up in
576  /// the same StringMap bucket, linked up.
578 
579  void destroyConstantImpl();
580 
581 protected:
582  explicit ConstantDataSequential(Type *ty, ValueTy VT, const char *Data)
583  : ConstantData(ty, VT), DataElements(Data), Next(nullptr) {}
584  ~ConstantDataSequential() { delete Next; }
585 
586  static Constant *getImpl(StringRef Bytes, Type *Ty);
587 
588 public:
590 
591  /// Return true if a ConstantDataSequential can be formed with a vector or
592  /// array of the specified element type.
593  /// ConstantDataArray only works with normal float and int types that are
594  /// stored densely in memory, not with things like i42 or x86_f80.
595  static bool isElementTypeCompatible(Type *Ty);
596 
597  /// If this is a sequential container of integers (of any size), return the
598  /// specified element in the low bits of a uint64_t.
599  uint64_t getElementAsInteger(unsigned i) const;
600 
601  /// If this is a sequential container of integers (of any size), return the
602  /// specified element as an APInt.
603  APInt getElementAsAPInt(unsigned i) const;
604 
605  /// If this is a sequential container of floating point type, return the
606  /// specified element as an APFloat.
607  APFloat getElementAsAPFloat(unsigned i) const;
608 
609  /// If this is an sequential container of floats, return the specified element
610  /// as a float.
611  float getElementAsFloat(unsigned i) const;
612 
613  /// If this is an sequential container of doubles, return the specified
614  /// element as a double.
615  double getElementAsDouble(unsigned i) const;
616 
617  /// Return a Constant for a specified index's element.
618  /// Note that this has to compute a new constant to return, so it isn't as
619  /// efficient as getElementAsInteger/Float/Double.
620  Constant *getElementAsConstant(unsigned i) const;
621 
622  /// Specialize the getType() method to always return a SequentialType, which
623  /// reduces the amount of casting needed in parts of the compiler.
624  inline SequentialType *getType() const {
625  return cast<SequentialType>(Value::getType());
626  }
627 
628  /// Return the element type of the array/vector.
629  Type *getElementType() const;
630 
631  /// Return the number of elements in the array or vector.
632  unsigned getNumElements() const;
633 
634  /// Return the size (in bytes) of each element in the array/vector.
635  /// The size of the elements is known to be a multiple of one byte.
636  uint64_t getElementByteSize() const;
637 
638  /// This method returns true if this is an array of \p CharSize integers.
639  bool isString(unsigned CharSize = 8) const;
640 
641  /// This method returns true if the array "isString", ends with a null byte,
642  /// and does not contains any other null bytes.
643  bool isCString() const;
644 
645  /// If this array is isString(), then this method returns the array as a
646  /// StringRef. Otherwise, it asserts out.
648  assert(isString() && "Not a string");
649  return getRawDataValues();
650  }
651 
652  /// If this array is isCString(), then this method returns the array (without
653  /// the trailing null byte) as a StringRef. Otherwise, it asserts out.
655  assert(isCString() && "Isn't a C string");
656  StringRef Str = getAsString();
657  return Str.substr(0, Str.size()-1);
658  }
659 
660  /// Return the raw, underlying, bytes of this data. Note that this is an
661  /// extremely tricky thing to work with, as it exposes the host endianness of
662  /// the data elements.
663  StringRef getRawDataValues() const;
664 
665  /// Methods for support type inquiry through isa, cast, and dyn_cast:
666  static bool classof(const Value *V) {
667  return V->getValueID() == ConstantDataArrayVal ||
668  V->getValueID() == ConstantDataVectorVal;
669  }
670 
671 private:
672  const char *getElementPointer(unsigned Elt) const;
673 };
674 
675 //===----------------------------------------------------------------------===//
676 /// An array constant whose element type is a simple 1/2/4/8-byte integer or
677 /// float/double, and whose elements are just simple data values
678 /// (i.e. ConstantInt/ConstantFP). This Constant node has no operands because it
679 /// stores all of the elements of the constant as densely packed data, instead
680 /// of as Value*'s.
683 
684  explicit ConstantDataArray(Type *ty, const char *Data)
685  : ConstantDataSequential(ty, ConstantDataArrayVal, Data) {}
686 
687 public:
688  ConstantDataArray(const ConstantDataArray &) = delete;
689 
690  /// get() constructors - Return a constant with array type with an element
691  /// count and element type matching the ArrayRef passed in. Note that this
692  /// can return a ConstantAggregateZero object.
693  static Constant *get(LLVMContext &Context, ArrayRef<uint8_t> Elts);
694  static Constant *get(LLVMContext &Context, ArrayRef<uint16_t> Elts);
695  static Constant *get(LLVMContext &Context, ArrayRef<uint32_t> Elts);
696  static Constant *get(LLVMContext &Context, ArrayRef<uint64_t> Elts);
697  static Constant *get(LLVMContext &Context, ArrayRef<float> Elts);
698  static Constant *get(LLVMContext &Context, ArrayRef<double> Elts);
699 
700  /// getFP() constructors - Return a constant with array type with an element
701  /// count and element type of float with precision matching the number of
702  /// bits in the ArrayRef passed in. (i.e. half for 16bits, float for 32bits,
703  /// double for 64bits) Note that this can return a ConstantAggregateZero
704  /// object.
705  static Constant *getFP(LLVMContext &Context, ArrayRef<uint16_t> Elts);
706  static Constant *getFP(LLVMContext &Context, ArrayRef<uint32_t> Elts);
707  static Constant *getFP(LLVMContext &Context, ArrayRef<uint64_t> Elts);
708 
709  /// This method constructs a CDS and initializes it with a text string.
710  /// The default behavior (AddNull==true) causes a null terminator to
711  /// be placed at the end of the array (increasing the length of the string by
712  /// one more than the StringRef would normally indicate. Pass AddNull=false
713  /// to disable this behavior.
714  static Constant *getString(LLVMContext &Context, StringRef Initializer,
715  bool AddNull = true);
716 
717  /// Specialize the getType() method to always return an ArrayType,
718  /// which reduces the amount of casting needed in parts of the compiler.
719  inline ArrayType *getType() const {
720  return cast<ArrayType>(Value::getType());
721  }
722 
723  /// Methods for support type inquiry through isa, cast, and dyn_cast:
724  static bool classof(const Value *V) {
725  return V->getValueID() == ConstantDataArrayVal;
726  }
727 };
728 
729 //===----------------------------------------------------------------------===//
730 /// A vector constant whose element type is a simple 1/2/4/8-byte integer or
731 /// float/double, and whose elements are just simple data values
732 /// (i.e. ConstantInt/ConstantFP). This Constant node has no operands because it
733 /// stores all of the elements of the constant as densely packed data, instead
734 /// of as Value*'s.
737 
738  explicit ConstantDataVector(Type *ty, const char *Data)
739  : ConstantDataSequential(ty, ConstantDataVectorVal, Data) {}
740 
741 public:
742  ConstantDataVector(const ConstantDataVector &) = delete;
743 
744  /// get() constructors - Return a constant with vector type with an element
745  /// count and element type matching the ArrayRef passed in. Note that this
746  /// can return a ConstantAggregateZero object.
747  static Constant *get(LLVMContext &Context, ArrayRef<uint8_t> Elts);
748  static Constant *get(LLVMContext &Context, ArrayRef<uint16_t> Elts);
749  static Constant *get(LLVMContext &Context, ArrayRef<uint32_t> Elts);
750  static Constant *get(LLVMContext &Context, ArrayRef<uint64_t> Elts);
751  static Constant *get(LLVMContext &Context, ArrayRef<float> Elts);
752  static Constant *get(LLVMContext &Context, ArrayRef<double> Elts);
753 
754  /// getFP() constructors - Return a constant with vector type with an element
755  /// count and element type of float with the precision matching the number of
756  /// bits in the ArrayRef passed in. (i.e. half for 16bits, float for 32bits,
757  /// double for 64bits) Note that this can return a ConstantAggregateZero
758  /// object.
759  static Constant *getFP(LLVMContext &Context, ArrayRef<uint16_t> Elts);
760  static Constant *getFP(LLVMContext &Context, ArrayRef<uint32_t> Elts);
761  static Constant *getFP(LLVMContext &Context, ArrayRef<uint64_t> Elts);
762 
763  /// Return a ConstantVector with the specified constant in each element.
764  /// The specified constant has to be a of a compatible type (i8/i16/
765  /// i32/i64/float/double) and must be a ConstantFP or ConstantInt.
766  static Constant *getSplat(unsigned NumElts, Constant *Elt);
767 
768  /// Returns true if this is a splat constant, meaning that all elements have
769  /// the same value.
770  bool isSplat() const;
771 
772  /// If this is a splat constant, meaning that all of the elements have the
773  /// same value, return that value. Otherwise return NULL.
774  Constant *getSplatValue() const;
775 
776  /// Specialize the getType() method to always return a VectorType,
777  /// which reduces the amount of casting needed in parts of the compiler.
778  inline VectorType *getType() const {
779  return cast<VectorType>(Value::getType());
780  }
781 
782  /// Methods for support type inquiry through isa, cast, and dyn_cast:
783  static bool classof(const Value *V) {
784  return V->getValueID() == ConstantDataVectorVal;
785  }
786 };
787 
788 //===----------------------------------------------------------------------===//
789 /// A constant token which is empty
790 ///
791 class ConstantTokenNone final : public ConstantData {
792  friend class Constant;
793 
795  : ConstantData(Type::getTokenTy(Context), ConstantTokenNoneVal) {}
796 
797  void destroyConstantImpl();
798 
799 public:
800  ConstantTokenNone(const ConstantTokenNone &) = delete;
801 
802  /// Return the ConstantTokenNone.
803  static ConstantTokenNone *get(LLVMContext &Context);
804 
805  /// @brief Methods to support type inquiry through isa, cast, and dyn_cast.
806  static bool classof(const Value *V) {
807  return V->getValueID() == ConstantTokenNoneVal;
808  }
809 };
810 
811 /// The address of a basic block.
812 ///
813 class BlockAddress final : public Constant {
814  friend class Constant;
815 
817 
818  void *operator new(size_t s) { return User::operator new(s, 2); }
819 
820  void destroyConstantImpl();
821  Value *handleOperandChangeImpl(Value *From, Value *To);
822 
823 public:
824  /// Return a BlockAddress for the specified function and basic block.
825  static BlockAddress *get(Function *F, BasicBlock *BB);
826 
827  /// Return a BlockAddress for the specified basic block. The basic
828  /// block must be embedded into a function.
829  static BlockAddress *get(BasicBlock *BB);
830 
831  /// Lookup an existing \c BlockAddress constant for the given BasicBlock.
832  ///
833  /// \returns 0 if \c !BB->hasAddressTaken(), otherwise the \c BlockAddress.
834  static BlockAddress *lookup(const BasicBlock *BB);
835 
836  /// Transparently provide more efficient getOperand methods.
838 
839  Function *getFunction() const { return (Function*)Op<0>().get(); }
840  BasicBlock *getBasicBlock() const { return (BasicBlock*)Op<1>().get(); }
841 
842  /// Methods for support type inquiry through isa, cast, and dyn_cast:
843  static bool classof(const Value *V) {
844  return V->getValueID() == BlockAddressVal;
845  }
846 };
847 
848 template <>
850  public FixedNumOperandTraits<BlockAddress, 2> {
851 };
852 
854 
855 //===----------------------------------------------------------------------===//
856 /// A constant value that is initialized with an expression using
857 /// other constant values.
858 ///
859 /// This class uses the standard Instruction opcodes to define the various
860 /// constant expressions. The Opcode field for the ConstantExpr class is
861 /// maintained in the Value::SubclassData field.
862 class ConstantExpr : public Constant {
863  friend struct ConstantExprKeyType;
864  friend class Constant;
865 
866  void destroyConstantImpl();
867  Value *handleOperandChangeImpl(Value *From, Value *To);
868 
869 protected:
870  ConstantExpr(Type *ty, unsigned Opcode, Use *Ops, unsigned NumOps)
871  : Constant(ty, ConstantExprVal, Ops, NumOps) {
872  // Operation type (an Instruction opcode) is stored as the SubclassData.
873  setValueSubclassData(Opcode);
874  }
875 
876 public:
877  // Static methods to construct a ConstantExpr of different kinds. Note that
878  // these methods may return a object that is not an instance of the
879  // ConstantExpr class, because they will attempt to fold the constant
880  // expression into something simpler if possible.
881 
882  /// getAlignOf constant expr - computes the alignment of a type in a target
883  /// independent way (Note: the return type is an i64).
884  static Constant *getAlignOf(Type *Ty);
885 
886  /// getSizeOf constant expr - computes the (alloc) size of a type (in
887  /// address-units, not bits) in a target independent way (Note: the return
888  /// type is an i64).
889  ///
890  static Constant *getSizeOf(Type *Ty);
891 
892  /// getOffsetOf constant expr - computes the offset of a struct field in a
893  /// target independent way (Note: the return type is an i64).
894  ///
895  static Constant *getOffsetOf(StructType *STy, unsigned FieldNo);
896 
897  /// getOffsetOf constant expr - This is a generalized form of getOffsetOf,
898  /// which supports any aggregate type, and any Constant index.
899  ///
900  static Constant *getOffsetOf(Type *Ty, Constant *FieldNo);
901 
902  static Constant *getNeg(Constant *C, bool HasNUW = false, bool HasNSW =false);
903  static Constant *getFNeg(Constant *C);
904  static Constant *getNot(Constant *C);
905  static Constant *getAdd(Constant *C1, Constant *C2,
906  bool HasNUW = false, bool HasNSW = false);
907  static Constant *getFAdd(Constant *C1, Constant *C2);
908  static Constant *getSub(Constant *C1, Constant *C2,
909  bool HasNUW = false, bool HasNSW = false);
910  static Constant *getFSub(Constant *C1, Constant *C2);
911  static Constant *getMul(Constant *C1, Constant *C2,
912  bool HasNUW = false, bool HasNSW = false);
913  static Constant *getFMul(Constant *C1, Constant *C2);
914  static Constant *getUDiv(Constant *C1, Constant *C2, bool isExact = false);
915  static Constant *getSDiv(Constant *C1, Constant *C2, bool isExact = false);
916  static Constant *getFDiv(Constant *C1, Constant *C2);
917  static Constant *getURem(Constant *C1, Constant *C2);
918  static Constant *getSRem(Constant *C1, Constant *C2);
919  static Constant *getFRem(Constant *C1, Constant *C2);
920  static Constant *getAnd(Constant *C1, Constant *C2);
921  static Constant *getOr(Constant *C1, Constant *C2);
922  static Constant *getXor(Constant *C1, Constant *C2);
923  static Constant *getShl(Constant *C1, Constant *C2,
924  bool HasNUW = false, bool HasNSW = false);
925  static Constant *getLShr(Constant *C1, Constant *C2, bool isExact = false);
926  static Constant *getAShr(Constant *C1, Constant *C2, bool isExact = false);
927  static Constant *getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced = false);
928  static Constant *getSExt(Constant *C, Type *Ty, bool OnlyIfReduced = false);
929  static Constant *getZExt(Constant *C, Type *Ty, bool OnlyIfReduced = false);
930  static Constant *getFPTrunc(Constant *C, Type *Ty,
931  bool OnlyIfReduced = false);
932  static Constant *getFPExtend(Constant *C, Type *Ty,
933  bool OnlyIfReduced = false);
934  static Constant *getUIToFP(Constant *C, Type *Ty, bool OnlyIfReduced = false);
935  static Constant *getSIToFP(Constant *C, Type *Ty, bool OnlyIfReduced = false);
936  static Constant *getFPToUI(Constant *C, Type *Ty, bool OnlyIfReduced = false);
937  static Constant *getFPToSI(Constant *C, Type *Ty, bool OnlyIfReduced = false);
938  static Constant *getPtrToInt(Constant *C, Type *Ty,
939  bool OnlyIfReduced = false);
940  static Constant *getIntToPtr(Constant *C, Type *Ty,
941  bool OnlyIfReduced = false);
942  static Constant *getBitCast(Constant *C, Type *Ty,
943  bool OnlyIfReduced = false);
944  static Constant *getAddrSpaceCast(Constant *C, Type *Ty,
945  bool OnlyIfReduced = false);
946 
947  static Constant *getNSWNeg(Constant *C) { return getNeg(C, false, true); }
948  static Constant *getNUWNeg(Constant *C) { return getNeg(C, true, false); }
949 
950  static Constant *getNSWAdd(Constant *C1, Constant *C2) {
951  return getAdd(C1, C2, false, true);
952  }
953 
954  static Constant *getNUWAdd(Constant *C1, Constant *C2) {
955  return getAdd(C1, C2, true, false);
956  }
957 
958  static Constant *getNSWSub(Constant *C1, Constant *C2) {
959  return getSub(C1, C2, false, true);
960  }
961 
962  static Constant *getNUWSub(Constant *C1, Constant *C2) {
963  return getSub(C1, C2, true, false);
964  }
965 
966  static Constant *getNSWMul(Constant *C1, Constant *C2) {
967  return getMul(C1, C2, false, true);
968  }
969 
970  static Constant *getNUWMul(Constant *C1, Constant *C2) {
971  return getMul(C1, C2, true, false);
972  }
973 
974  static Constant *getNSWShl(Constant *C1, Constant *C2) {
975  return getShl(C1, C2, false, true);
976  }
977 
978  static Constant *getNUWShl(Constant *C1, Constant *C2) {
979  return getShl(C1, C2, true, false);
980  }
981 
983  return getSDiv(C1, C2, true);
984  }
985 
987  return getUDiv(C1, C2, true);
988  }
989 
991  return getAShr(C1, C2, true);
992  }
993 
995  return getLShr(C1, C2, true);
996  }
997 
998  /// Return the identity for the given binary operation,
999  /// i.e. a constant C such that X op C = X and C op X = X for every X. It
1000  /// returns null if the operator doesn't have an identity.
1001  static Constant *getBinOpIdentity(unsigned Opcode, Type *Ty);
1002 
1003  /// Return the absorbing element for the given binary
1004  /// operation, i.e. a constant C such that X op C = C and C op X = C for
1005  /// every X. For example, this returns zero for integer multiplication.
1006  /// It returns null if the operator doesn't have an absorbing element.
1007  static Constant *getBinOpAbsorber(unsigned Opcode, Type *Ty);
1008 
1009  /// Transparently provide more efficient getOperand methods.
1011 
1012  /// \brief Convenience function for getting a Cast operation.
1013  ///
1014  /// \param ops The opcode for the conversion
1015  /// \param C The constant to be converted
1016  /// \param Ty The type to which the constant is converted
1017  /// \param OnlyIfReduced see \a getWithOperands() docs.
1018  static Constant *getCast(unsigned ops, Constant *C, Type *Ty,
1019  bool OnlyIfReduced = false);
1020 
1021  // @brief Create a ZExt or BitCast cast constant expression
1022  static Constant *getZExtOrBitCast(
1023  Constant *C, ///< The constant to zext or bitcast
1024  Type *Ty ///< The type to zext or bitcast C to
1025  );
1026 
1027  // @brief Create a SExt or BitCast cast constant expression
1028  static Constant *getSExtOrBitCast(
1029  Constant *C, ///< The constant to sext or bitcast
1030  Type *Ty ///< The type to sext or bitcast C to
1031  );
1032 
1033  // @brief Create a Trunc or BitCast cast constant expression
1034  static Constant *getTruncOrBitCast(
1035  Constant *C, ///< The constant to trunc or bitcast
1036  Type *Ty ///< The type to trunc or bitcast C to
1037  );
1038 
1039  /// @brief Create a BitCast, AddrSpaceCast, or a PtrToInt cast constant
1040  /// expression.
1041  static Constant *getPointerCast(
1042  Constant *C, ///< The pointer value to be casted (operand 0)
1043  Type *Ty ///< The type to which cast should be made
1044  );
1045 
1046  /// @brief Create a BitCast or AddrSpaceCast for a pointer type depending on
1047  /// the address space.
1048  static Constant *getPointerBitCastOrAddrSpaceCast(
1049  Constant *C, ///< The constant to addrspacecast or bitcast
1050  Type *Ty ///< The type to bitcast or addrspacecast C to
1051  );
1052 
1053  /// @brief Create a ZExt, Bitcast or Trunc for integer -> integer casts
1054  static Constant *getIntegerCast(
1055  Constant *C, ///< The integer constant to be casted
1056  Type *Ty, ///< The integer type to cast to
1057  bool isSigned ///< Whether C should be treated as signed or not
1058  );
1059 
1060  /// @brief Create a FPExt, Bitcast or FPTrunc for fp -> fp casts
1061  static Constant *getFPCast(
1062  Constant *C, ///< The integer constant to be casted
1063  Type *Ty ///< The integer type to cast to
1064  );
1065 
1066  /// @brief Return true if this is a convert constant expression
1067  bool isCast() const;
1068 
1069  /// @brief Return true if this is a compare constant expression
1070  bool isCompare() const;
1071 
1072  /// @brief Return true if this is an insertvalue or extractvalue expression,
1073  /// and the getIndices() method may be used.
1074  bool hasIndices() const;
1075 
1076  /// @brief Return true if this is a getelementptr expression and all
1077  /// the index operands are compile-time known integers within the
1078  /// corresponding notional static array extents. Note that this is
1079  /// not equivalant to, a subset of, or a superset of the "inbounds"
1080  /// property.
1081  bool isGEPWithNoNotionalOverIndexing() const;
1082 
1083  /// Select constant expr
1084  ///
1085  /// \param OnlyIfReducedTy see \a getWithOperands() docs.
1086  static Constant *getSelect(Constant *C, Constant *V1, Constant *V2,
1087  Type *OnlyIfReducedTy = nullptr);
1088 
1089  /// get - Return a binary or shift operator constant expression,
1090  /// folding if possible.
1091  ///
1092  /// \param OnlyIfReducedTy see \a getWithOperands() docs.
1093  static Constant *get(unsigned Opcode, Constant *C1, Constant *C2,
1094  unsigned Flags = 0, Type *OnlyIfReducedTy = nullptr);
1095 
1096  /// \brief Return an ICmp or FCmp comparison operator constant expression.
1097  ///
1098  /// \param OnlyIfReduced see \a getWithOperands() docs.
1099  static Constant *getCompare(unsigned short pred, Constant *C1, Constant *C2,
1100  bool OnlyIfReduced = false);
1101 
1102  /// get* - Return some common constants without having to
1103  /// specify the full Instruction::OPCODE identifier.
1104  ///
1105  static Constant *getICmp(unsigned short pred, Constant *LHS, Constant *RHS,
1106  bool OnlyIfReduced = false);
1107  static Constant *getFCmp(unsigned short pred, Constant *LHS, Constant *RHS,
1108  bool OnlyIfReduced = false);
1109 
1110  /// Getelementptr form. Value* is only accepted for convenience;
1111  /// all elements must be Constants.
1112  ///
1113  /// \param InRangeIndex the inrange index if present or None.
1114  /// \param OnlyIfReducedTy see \a getWithOperands() docs.
1116  ArrayRef<Constant *> IdxList,
1117  bool InBounds = false,
1118  Optional<unsigned> InRangeIndex = None,
1119  Type *OnlyIfReducedTy = nullptr) {
1120  return getGetElementPtr(
1121  Ty, C, makeArrayRef((Value * const *)IdxList.data(), IdxList.size()),
1122  InBounds, InRangeIndex, OnlyIfReducedTy);
1123  }
1125  bool InBounds = false,
1126  Optional<unsigned> InRangeIndex = None,
1127  Type *OnlyIfReducedTy = nullptr) {
1128  // This form of the function only exists to avoid ambiguous overload
1129  // warnings about whether to convert Idx to ArrayRef<Constant *> or
1130  // ArrayRef<Value *>.
1131  return getGetElementPtr(Ty, C, cast<Value>(Idx), InBounds, InRangeIndex,
1132  OnlyIfReducedTy);
1133  }
1134  static Constant *getGetElementPtr(Type *Ty, Constant *C,
1135  ArrayRef<Value *> IdxList,
1136  bool InBounds = false,
1137  Optional<unsigned> InRangeIndex = None,
1138  Type *OnlyIfReducedTy = nullptr);
1139 
1140  /// Create an "inbounds" getelementptr. See the documentation for the
1141  /// "inbounds" flag in LangRef.html for details.
1143  ArrayRef<Constant *> IdxList) {
1144  return getGetElementPtr(Ty, C, IdxList, true);
1145  }
1147  Constant *Idx) {
1148  // This form of the function only exists to avoid ambiguous overload
1149  // warnings about whether to convert Idx to ArrayRef<Constant *> or
1150  // ArrayRef<Value *>.
1151  return getGetElementPtr(Ty, C, Idx, true);
1152  }
1154  ArrayRef<Value *> IdxList) {
1155  return getGetElementPtr(Ty, C, IdxList, true);
1156  }
1157 
1158  static Constant *getExtractElement(Constant *Vec, Constant *Idx,
1159  Type *OnlyIfReducedTy = nullptr);
1160  static Constant *getInsertElement(Constant *Vec, Constant *Elt, Constant *Idx,
1161  Type *OnlyIfReducedTy = nullptr);
1162  static Constant *getShuffleVector(Constant *V1, Constant *V2, Constant *Mask,
1163  Type *OnlyIfReducedTy = nullptr);
1164  static Constant *getExtractValue(Constant *Agg, ArrayRef<unsigned> Idxs,
1165  Type *OnlyIfReducedTy = nullptr);
1166  static Constant *getInsertValue(Constant *Agg, Constant *Val,
1167  ArrayRef<unsigned> Idxs,
1168  Type *OnlyIfReducedTy = nullptr);
1169 
1170  /// Return the opcode at the root of this constant expression
1171  unsigned getOpcode() const { return getSubclassDataFromValue(); }
1172 
1173  /// Return the ICMP or FCMP predicate value. Assert if this is not an ICMP or
1174  /// FCMP constant expression.
1175  unsigned getPredicate() const;
1176 
1177  /// Assert that this is an insertvalue or exactvalue
1178  /// expression and return the list of indices.
1179  ArrayRef<unsigned> getIndices() const;
1180 
1181  /// Return a string representation for an opcode.
1182  const char *getOpcodeName() const;
1183 
1184  /// Return a constant expression identical to this one, but with the specified
1185  /// operand set to the specified value.
1186  Constant *getWithOperandReplaced(unsigned OpNo, Constant *Op) const;
1187 
1188  /// This returns the current constant expression with the operands replaced
1189  /// with the specified values. The specified array must have the same number
1190  /// of operands as our current one.
1192  return getWithOperands(Ops, getType());
1193  }
1194 
1195  /// Get the current expression with the operands replaced.
1196  ///
1197  /// Return the current constant expression with the operands replaced with \c
1198  /// Ops and the type with \c Ty. The new operands must have the same number
1199  /// as the current ones.
1200  ///
1201  /// If \c OnlyIfReduced is \c true, nullptr will be returned unless something
1202  /// gets constant-folded, the type changes, or the expression is otherwise
1203  /// canonicalized. This parameter should almost always be \c false.
1204  Constant *getWithOperands(ArrayRef<Constant *> Ops, Type *Ty,
1205  bool OnlyIfReduced = false,
1206  Type *SrcTy = nullptr) const;
1207 
1208  /// Returns an Instruction which implements the same operation as this
1209  /// ConstantExpr. The instruction is not linked to any basic block.
1210  ///
1211  /// A better approach to this could be to have a constructor for Instruction
1212  /// which would take a ConstantExpr parameter, but that would have spread
1213  /// implementation details of ConstantExpr outside of Constants.cpp, which
1214  /// would make it harder to remove ConstantExprs altogether.
1215  Instruction *getAsInstruction();
1216 
1217  /// Methods for support type inquiry through isa, cast, and dyn_cast:
1218  static bool classof(const Value *V) {
1219  return V->getValueID() == ConstantExprVal;
1220  }
1221 
1222 private:
1223  // Shadow Value::setValueSubclassData with a private forwarding method so that
1224  // subclasses cannot accidentally use it.
1225  void setValueSubclassData(unsigned short D) {
1227  }
1228 };
1229 
1230 template <>
1232  public VariadicOperandTraits<ConstantExpr, 1> {
1233 };
1234 
1236 
1237 //===----------------------------------------------------------------------===//
1238 /// 'undef' values are things that do not have specified contents.
1239 /// These are used for a variety of purposes, including global variable
1240 /// initializers and operands to instructions. 'undef' values can occur with
1241 /// any first-class type.
1242 ///
1243 /// Undef values aren't exactly constants; if they have multiple uses, they
1244 /// can appear to have different bit patterns at each use. See
1245 /// LangRef.html#undefvalues for details.
1246 ///
1247 class UndefValue final : public ConstantData {
1248  friend class Constant;
1249 
1250  explicit UndefValue(Type *T) : ConstantData(T, UndefValueVal) {}
1251 
1252  void destroyConstantImpl();
1253 
1254 public:
1255  UndefValue(const UndefValue &) = delete;
1256 
1257  /// Static factory methods - Return an 'undef' object of the specified type.
1258  static UndefValue *get(Type *T);
1259 
1260  /// If this Undef has array or vector type, return a undef with the right
1261  /// element type.
1262  UndefValue *getSequentialElement() const;
1263 
1264  /// If this undef has struct type, return a undef with the right element type
1265  /// for the specified element.
1266  UndefValue *getStructElement(unsigned Elt) const;
1267 
1268  /// Return an undef of the right value for the specified GEP index if we can,
1269  /// otherwise return null (e.g. if C is a ConstantExpr).
1270  UndefValue *getElementValue(Constant *C) const;
1271 
1272  /// Return an undef of the right value for the specified GEP index.
1273  UndefValue *getElementValue(unsigned Idx) const;
1274 
1275  /// Return the number of elements in the array, vector, or struct.
1276  unsigned getNumElements() const;
1277 
1278  /// Methods for support type inquiry through isa, cast, and dyn_cast:
1279  static bool classof(const Value *V) {
1280  return V->getValueID() == UndefValueVal;
1281  }
1282 };
1283 
1284 } // end namespace llvm
1285 
1286 #endif // LLVM_IR_CONSTANTS_H
A vector constant whose element type is a simple 1/2/4/8-byte integer or float/double, and whose elements are just simple data values (i.e.
Definition: Constants.h:735
uint64_t CallInst * C
unsigned short getSubclassDataFromValue() const
Definition: Value.h:659
IntegerType * getType() const
getType - Specialize the getType() method to always return an IntegerType, which reduces the amount o...
Definition: Constants.h:172
bool isZero() const
Definition: APFloat.h:1143
unsigned getOpcode() const
Return the opcode at the root of this constant expression.
Definition: Constants.h:1171
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1542
unsigned getValueID() const
Return an ID for the concrete type of this object.
Definition: Value.h:469
LLVMContext & Context
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
static Constant * getNSWAdd(Constant *C1, Constant *C2)
Definition: Constants.h:950
static Constant * getGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant *> IdxList, bool InBounds=false, Optional< unsigned > InRangeIndex=None, Type *OnlyIfReducedTy=nullptr)
Getelementptr form.
Definition: Constants.h:1115
ConstantDataSequential(Type *ty, ValueTy VT, const char *Data)
Definition: Constants.h:582
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
static Constant * getExactSDiv(Constant *C1, Constant *C2)
Definition: Constants.h:982
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Constants.h:551
StringRef getAsCString() const
If this array is isCString(), then this method returns the array (without the trailing null byte) as ...
Definition: Constants.h:654
static Constant * getNUWShl(Constant *C1, Constant *C2)
Definition: Constants.h:978
F(f)
const fltSemantics & getSemantics() const
Definition: APFloat.h:1155
bool equalsInt(uint64_t V) const
A helper method that can be used to determine if the constant contained within is equal to a constant...
Definition: Constants.h:165
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Constants.h:843
static Constant * getTrue(Type *Ty)
For a boolean type or a vector of boolean type, return true or a vector with every element true...
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Constants.h:1279
unsigned getBitWidth() const
getBitWidth - Return the bitwidth of this constant.
Definition: Constants.h:143
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1488
Function * getFunction() const
Definition: Constants.h:839
The address of a basic block.
Definition: Constants.h:813
bool isExactlyValue(double V) const
Definition: Constants.h:316
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:451
&#39;undef&#39; values are things that do not have specified contents.
Definition: Constants.h:1247
Class to represent struct types.
Definition: DerivedTypes.h:201
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Constants.h:483
static Constant * getNUWNeg(Constant *C)
Definition: Constants.h:948
bool uge(uint64_t Num) const
This function will return true iff this constant represents a value with active bits bigger than 64 b...
Definition: Constants.h:242
static Constant * getExactAShr(Constant *C1, Constant *C2)
Definition: Constants.h:990
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Constants.h:522
static const uint16_t * lookup(unsigned opcode, unsigned domain, ArrayRef< uint16_t[3]> Table)
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Constants.h:724
This file implements a class to represent arbitrary precision integral constant values and operations...
All zero aggregate value.
Definition: Constants.h:332
bool isOne() const
This is just a convenience method to make client code smaller for a common case.
Definition: Constants.h:201
#define DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CLASS, VALUECLASS)
Macro for generating out-of-class operand accessor definitions.
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:862
int64_t getSExtValue() const
Get sign extended value.
Definition: APInt.h:1554
bool isInfinity() const
Definition: APFloat.h:1144
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
ArrayType * getType() const
Specialize the getType() method to always return an ArrayType, which reduces the amount of casting ne...
Definition: Constants.h:719
opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
Definition: APFloat.cpp:4441
static bool classof(const Value *V)
Methods to support type inquiry through isa, cast, and dyn_cast.
Definition: Constants.h:806
static Constant * getGetElementPtr(Type *Ty, Constant *C, Constant *Idx, bool InBounds=false, Optional< unsigned > InRangeIndex=None, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.h:1124
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Constants.h:365
ConstantDataSequential - A vector or array constant whose element type is a simple 1/2/4/8-byte integ...
Definition: Constants.h:565
#define T
bool isNegative() const
Return true if the sign bit is set.
Definition: Constants.h:300
Class to represent array types.
Definition: DerivedTypes.h:369
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Constants.h:783
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:138
BasicBlock * getBasicBlock() const
Definition: Constants.h:840
bool isMinusOne() const
This function will return true iff every bit in this constant is set to true.
Definition: Constants.h:209
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:598
static Constant * getNSWNeg(Constant *C)
Definition: Constants.h:947
Class to represent pointers.
Definition: DerivedTypes.h:467
VectorType * getType() const
Specialize the getType() method to always return a VectorType, which reduces the amount of casting ne...
Definition: Constants.h:778
bool isNegative() const
Determine sign of this APInt.
Definition: APInt.h:357
bool isAllOnesValue() const
Determine if all bits are set.
Definition: APInt.h:389
ConstantExpr(Type *ty, unsigned Opcode, Use *Ops, unsigned NumOps)
Definition: Constants.h:870
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
Definition: Constants.h:149
bool isNegative() const
Definition: APFloat.h:1147
An array constant whose element type is a simple 1/2/4/8-byte integer or float/double, and whose elements are just simple data values (i.e.
Definition: Constants.h:681
LLVM Basic Block Representation.
Definition: BasicBlock.h:59
static Constant * getAnon(LLVMContext &Ctx, ArrayRef< Constant *> V, bool Packed=false)
Definition: Constants.h:463
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:69
A constant token which is empty.
Definition: Constants.h:791
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:149
bool isNaN() const
Definition: APFloat.h:1145
This is an important base class in LLVM.
Definition: Constant.h:42
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:264
bool isOneValue() const
Determine if this is a value of 1.
Definition: APInt.h:404
static Constant * getNSWShl(Constant *C1, Constant *C2)
Definition: Constants.h:974
bool isMinSignedValue() const
Determine if this is the smallest signed value.
Definition: APInt.h:436
This file declares a class to represent arbitrary precision floating point values and provide a varie...
bool isMaxValue(bool isSigned) const
This function will return true iff this constant represents the largest value that may be represented...
Definition: Constants.h:218
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Constants.h:429
static bool classof(const Value *V)
Methods to support type inquiry through isa, cast, and dyn_cast.
Definition: Constants.h:256
Class to represent integer types.
Definition: DerivedTypes.h:40
Constant Vector Declarations.
Definition: Constants.h:491
#define DECLARE_TRANSPARENT_OPERAND_ACCESSORS(VALUECLASS)
Macro for generating in-class operand accessor declarations.
friend class Constant
Definition: Constants.h:59
Constant * getWithOperands(ArrayRef< Constant *> Ops) const
This returns the current constant expression with the operands replaced with the specified values...
Definition: Constants.h:1191
static Constant * getInBoundsGetElementPtr(Type *Ty, Constant *C, Constant *Idx)
Definition: Constants.h:1146
Constant * getSplatValue() const
If this is a splat vector constant, meaning that all of the elements have the same value...
Definition: Constants.cpp:1272
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
const T * data() const
Definition: ArrayRef.h:146
bool isNegative() const
Definition: Constants.h:188
hexagon gen pred
const APFloat & getValueAPF() const
Definition: Constants.h:294
bool isMinValue(bool isSigned) const
This function will return true iff this constant represents the smallest value that may be represente...
Definition: Constants.h:230
This is the superclass of the array and vector type classes.
Definition: DerivedTypes.h:343
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Constants.h:324
Predicate getPredicate(unsigned Condition, unsigned Hint)
Return predicate consisting of specified condition and hint bits.
Definition: PPCPredicates.h:85
uint64_t getLimitedValue(uint64_t Limit=~0ULL) const
getLimitedValue - If the value is smaller than the specified limit, return it, otherwise return the l...
Definition: Constants.h:251
bool isMaxSignedValue() const
Determine if this is the largest signed value.
Definition: APInt.h:420
This is the shared class of boolean and integer constants.
Definition: Constants.h:84
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:864
StringRef getAsString() const
If this array is isString(), then this method returns the array as a StringRef.
Definition: Constants.h:647
A constant pointer value that points to null.
Definition: Constants.h:530
static Constant * getNUWMul(Constant *C1, Constant *C2)
Definition: Constants.h:970
bool isMaxValue() const
Determine if this is the largest unsigned value.
Definition: APInt.h:414
static Constant * getNSWSub(Constant *C1, Constant *C2)
Definition: Constants.h:958
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Constants.h:1218
bool uge(const APInt &RHS) const
Unsigned greater or equal comparison.
Definition: APInt.h:1272
ValueTy
Concrete subclass of this.
Definition: Value.h:450
void setValueSubclassData(unsigned short D)
Definition: Value.h:660
Class to represent vector types.
Definition: DerivedTypes.h:393
ConstantArray - Constant Array Declarations.
Definition: Constants.h:405
Class for arbitrary precision integers.
Definition: APInt.h:69
static Constant * getFalse(Type *Ty)
For a boolean type or a vector of boolean type, return false or a vector with every element false...
ArrayType * getType() const
Specialize the getType() method to always return an ArrayType, which reduces the amount of casting ne...
Definition: Constants.h:424
Common super class of ArrayType, StructType and VectorType.
Definition: DerivedTypes.h:162
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Constants.h:390
static Constant * getInBoundsGetElementPtr(Type *Ty, Constant *C, ArrayRef< Value *> IdxList)
Definition: Constants.h:1153
static Constant * getNSWMul(Constant *C1, Constant *C2)
Definition: Constants.h:966
SequentialType * getType() const
Specialize the getType() method to always return a SequentialType, which reduces the amount of castin...
Definition: Constants.h:624
xray Insert XRay ops
uint64_t getLimitedValue(uint64_t Limit=UINT64_MAX) const
If this value is smaller than the specified limit, return it, otherwise return the limit value...
Definition: APInt.h:475
bool isZero() const
Return true if the value is positive or negative zero.
Definition: Constants.h:297
VectorType * getType() const
Specialize the getType() method to always return a VectorType, which reduces the amount of casting ne...
Definition: Constants.h:513
bool isNaN() const
Return true if the value is a NaN.
Definition: Constants.h:306
static Constant * getInBoundsGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant *> IdxList)
Create an "inbounds" getelementptr.
Definition: Constants.h:1142
static Constant * getExactLShr(Constant *C1, Constant *C2)
Definition: Constants.h:994
PointerType * getType() const
Specialize the getType() method to always return an PointerType, which reduces the amount of casting ...
Definition: Constants.h:546
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
Definition: Constants.h:193
bool isInfinity() const
Return true if the value is infinity.
Definition: Constants.h:303
Compile-time customization of User operands.
Definition: User.h:43
bool isMinValue() const
Determine if this is the smallest unsigned value.
Definition: APInt.h:430
static bool classof(const Value *V)
Methods to support type inquiry through isa, cast, and dyn_cast.
Definition: Constants.h:74
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Base class for aggregate constants (with operands).
Definition: Constants.h:381
traits class for checking whether type T is a base class for all the given types in the variadic list...
Definition: STLExtras.h:704
LLVM Value Representation.
Definition: Value.h:73
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E&#39;s largest value.
Definition: BitmaskEnum.h:81
static Constant * getAnon(ArrayRef< Constant *> V, bool Packed=false)
Return an anonymous struct that has the specified elements.
Definition: Constants.h:460
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
FixedNumOperandTraits - determine the allocation regime of the Use array when it is a prefix to the U...
Definition: OperandTraits.h:31
static bool isSplat(ArrayRef< Value *> VL)
ConstantData(Type *Ty, ValueTy VT)
Definition: Constants.h:66
Use & Op()
Definition: User.h:118
static Constant * getExactUDiv(Constant *C1, Constant *C2)
Definition: Constants.h:986
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Constants.h:666
VariadicOperandTraits - determine the allocation regime of the Use array when it is a prefix to the U...
Definition: OperandTraits.h:69
int64_t getSExtValue() const
Return the constant as a 64-bit integer value after it has been sign extended as appropriate for the ...
Definition: Constants.h:157
static LazyValueInfoImpl & getImpl(void *&PImpl, AssumptionCache *AC, const DataLayout *DL, DominatorTree *DT=nullptr)
This lazily constructs the LazyValueInfoImpl.
static Constant * getNUWSub(Constant *C1, Constant *C2)
Definition: Constants.h:962
Base class for constants with no operands.
Definition: Constants.h:58
static Constant * getNUWAdd(Constant *C1, Constant *C2)
Definition: Constants.h:954
StructType * getType() const
Specialization - reduce amount of casting.
Definition: Constants.h:478
bool isNullValue() const
Determine if all bits are clear.
Definition: APInt.h:399