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