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