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 /// Wrapper for a value that won't be replaced with a CFI jump table
930 /// pointer in LowerTypeTestsModule.
931 class NoCFIValue final : public Constant {
932  friend class Constant;
933 
934  NoCFIValue(GlobalValue *GV);
935 
936  void *operator new(size_t S) { return User::operator new(S, 1); }
937 
938  void destroyConstantImpl();
939  Value *handleOperandChangeImpl(Value *From, Value *To);
940 
941 public:
942  /// Return a NoCFIValue for the specified function.
943  static NoCFIValue *get(GlobalValue *GV);
944 
945  /// Transparently provide more efficient getOperand methods.
947 
949  return cast<GlobalValue>(Op<0>().get());
950  }
951 
952  /// Methods for support type inquiry through isa, cast, and dyn_cast:
953  static bool classof(const Value *V) {
954  return V->getValueID() == NoCFIValueVal;
955  }
956 };
957 
958 template <>
959 struct OperandTraits<NoCFIValue> : public FixedNumOperandTraits<NoCFIValue, 1> {
960 };
961 
963 
964 //===----------------------------------------------------------------------===//
965 /// A constant value that is initialized with an expression using
966 /// other constant values.
967 ///
968 /// This class uses the standard Instruction opcodes to define the various
969 /// constant expressions. The Opcode field for the ConstantExpr class is
970 /// maintained in the Value::SubclassData field.
971 class ConstantExpr : public Constant {
972  friend struct ConstantExprKeyType;
973  friend class Constant;
974 
975  void destroyConstantImpl();
976  Value *handleOperandChangeImpl(Value *From, Value *To);
977 
978 protected:
979  ConstantExpr(Type *ty, unsigned Opcode, Use *Ops, unsigned NumOps)
980  : Constant(ty, ConstantExprVal, Ops, NumOps) {
981  // Operation type (an Instruction opcode) is stored as the SubclassData.
982  setValueSubclassData(Opcode);
983  }
984 
985  ~ConstantExpr() = default;
986 
987 public:
988  // Static methods to construct a ConstantExpr of different kinds. Note that
989  // these methods may return a object that is not an instance of the
990  // ConstantExpr class, because they will attempt to fold the constant
991  // expression into something simpler if possible.
992 
993  /// getAlignOf constant expr - computes the alignment of a type in a target
994  /// independent way (Note: the return type is an i64).
995  static Constant *getAlignOf(Type *Ty);
996 
997  /// getSizeOf constant expr - computes the (alloc) size of a type (in
998  /// address-units, not bits) in a target independent way (Note: the return
999  /// type is an i64).
1000  ///
1001  static Constant *getSizeOf(Type *Ty);
1002 
1003  /// getOffsetOf constant expr - computes the offset of a struct field in a
1004  /// target independent way (Note: the return type is an i64).
1005  ///
1006  static Constant *getOffsetOf(StructType *STy, unsigned FieldNo);
1007 
1008  /// getOffsetOf constant expr - This is a generalized form of getOffsetOf,
1009  /// which supports any aggregate type, and any Constant index.
1010  ///
1011  static Constant *getOffsetOf(Type *Ty, Constant *FieldNo);
1012 
1013  static Constant *getNeg(Constant *C, bool HasNUW = false,
1014  bool HasNSW = false);
1015  static Constant *getFNeg(Constant *C);
1016  static Constant *getNot(Constant *C);
1017  static Constant *getAdd(Constant *C1, Constant *C2, bool HasNUW = false,
1018  bool HasNSW = false);
1019  static Constant *getFAdd(Constant *C1, Constant *C2);
1020  static Constant *getSub(Constant *C1, Constant *C2, bool HasNUW = false,
1021  bool HasNSW = false);
1022  static Constant *getFSub(Constant *C1, Constant *C2);
1023  static Constant *getMul(Constant *C1, Constant *C2, bool HasNUW = false,
1024  bool HasNSW = false);
1025  static Constant *getFMul(Constant *C1, Constant *C2);
1026  static Constant *getUDiv(Constant *C1, Constant *C2, bool isExact = false);
1027  static Constant *getSDiv(Constant *C1, Constant *C2, bool isExact = false);
1028  static Constant *getFDiv(Constant *C1, Constant *C2);
1029  static Constant *getURem(Constant *C1, Constant *C2);
1030  static Constant *getSRem(Constant *C1, Constant *C2);
1031  static Constant *getFRem(Constant *C1, Constant *C2);
1032  static Constant *getAnd(Constant *C1, Constant *C2);
1033  static Constant *getOr(Constant *C1, Constant *C2);
1034  static Constant *getXor(Constant *C1, Constant *C2);
1035  static Constant *getUMin(Constant *C1, Constant *C2);
1036  static Constant *getShl(Constant *C1, Constant *C2, bool HasNUW = false,
1037  bool HasNSW = false);
1038  static Constant *getLShr(Constant *C1, Constant *C2, bool isExact = false);
1039  static Constant *getAShr(Constant *C1, Constant *C2, bool isExact = false);
1040  static Constant *getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced = false);
1041  static Constant *getSExt(Constant *C, Type *Ty, bool OnlyIfReduced = false);
1042  static Constant *getZExt(Constant *C, Type *Ty, bool OnlyIfReduced = false);
1043  static Constant *getFPTrunc(Constant *C, Type *Ty,
1044  bool OnlyIfReduced = false);
1045  static Constant *getFPExtend(Constant *C, Type *Ty,
1046  bool OnlyIfReduced = false);
1047  static Constant *getUIToFP(Constant *C, Type *Ty, bool OnlyIfReduced = false);
1048  static Constant *getSIToFP(Constant *C, Type *Ty, bool OnlyIfReduced = false);
1049  static Constant *getFPToUI(Constant *C, Type *Ty, bool OnlyIfReduced = false);
1050  static Constant *getFPToSI(Constant *C, Type *Ty, bool OnlyIfReduced = false);
1051  static Constant *getPtrToInt(Constant *C, Type *Ty,
1052  bool OnlyIfReduced = false);
1053  static Constant *getIntToPtr(Constant *C, Type *Ty,
1054  bool OnlyIfReduced = false);
1055  static Constant *getBitCast(Constant *C, Type *Ty,
1056  bool OnlyIfReduced = false);
1057  static Constant *getAddrSpaceCast(Constant *C, Type *Ty,
1058  bool OnlyIfReduced = false);
1059 
1060  static Constant *getNSWNeg(Constant *C) { return getNeg(C, false, true); }
1061  static Constant *getNUWNeg(Constant *C) { return getNeg(C, true, false); }
1062 
1064  return getAdd(C1, C2, false, true);
1065  }
1066 
1068  return getAdd(C1, C2, true, false);
1069  }
1070 
1072  return getSub(C1, C2, false, true);
1073  }
1074 
1076  return getSub(C1, C2, true, false);
1077  }
1078 
1080  return getMul(C1, C2, false, true);
1081  }
1082 
1084  return getMul(C1, C2, true, false);
1085  }
1086 
1088  return getShl(C1, C2, false, true);
1089  }
1090 
1092  return getShl(C1, C2, true, false);
1093  }
1094 
1096  return getSDiv(C1, C2, true);
1097  }
1098 
1100  return getUDiv(C1, C2, true);
1101  }
1102 
1104  return getAShr(C1, C2, true);
1105  }
1106 
1108  return getLShr(C1, C2, true);
1109  }
1110 
1111  /// If C is a scalar/fixed width vector of known powers of 2, then this
1112  /// function returns a new scalar/fixed width vector obtained from logBase2
1113  /// of C. Undef vector elements are set to zero.
1114  /// Return a null pointer otherwise.
1115  static Constant *getExactLogBase2(Constant *C);
1116 
1117  /// Return the identity constant for a binary opcode.
1118  /// The identity constant C is defined as X op C = X and C op X = X for every
1119  /// X when the binary operation is commutative. If the binop is not
1120  /// commutative, callers can acquire the operand 1 identity constant by
1121  /// setting AllowRHSConstant to true. For example, any shift has a zero
1122  /// identity constant for operand 1: X shift 0 = X.
1123  /// Return nullptr if the operator does not have an identity constant.
1124  static Constant *getBinOpIdentity(unsigned Opcode, Type *Ty,
1125  bool AllowRHSConstant = false);
1126 
1127  /// Return the absorbing element for the given binary
1128  /// operation, i.e. a constant C such that X op C = C and C op X = C for
1129  /// every X. For example, this returns zero for integer multiplication.
1130  /// It returns null if the operator doesn't have an absorbing element.
1131  static Constant *getBinOpAbsorber(unsigned Opcode, Type *Ty);
1132 
1133  /// Transparently provide more efficient getOperand methods.
1135 
1136  /// Convenience function for getting a Cast operation.
1137  ///
1138  /// \param ops The opcode for the conversion
1139  /// \param C The constant to be converted
1140  /// \param Ty The type to which the constant is converted
1141  /// \param OnlyIfReduced see \a getWithOperands() docs.
1142  static Constant *getCast(unsigned ops, Constant *C, Type *Ty,
1143  bool OnlyIfReduced = false);
1144 
1145  // Create a ZExt or BitCast cast constant expression
1146  static Constant *
1147  getZExtOrBitCast(Constant *C, ///< The constant to zext or bitcast
1148  Type *Ty ///< The type to zext or bitcast C to
1149  );
1150 
1151  // Create a SExt or BitCast cast constant expression
1152  static Constant *
1153  getSExtOrBitCast(Constant *C, ///< The constant to sext or bitcast
1154  Type *Ty ///< The type to sext or bitcast C to
1155  );
1156 
1157  // Create a Trunc or BitCast cast constant expression
1158  static Constant *
1159  getTruncOrBitCast(Constant *C, ///< The constant to trunc or bitcast
1160  Type *Ty ///< The type to trunc or bitcast C to
1161  );
1162 
1163  /// Create a BitCast, AddrSpaceCast, or a PtrToInt cast constant
1164  /// expression.
1165  static Constant *
1166  getPointerCast(Constant *C, ///< The pointer value to be casted (operand 0)
1167  Type *Ty ///< The type to which cast should be made
1168  );
1169 
1170  /// Create a BitCast or AddrSpaceCast for a pointer type depending on
1171  /// the address space.
1172  static Constant *getPointerBitCastOrAddrSpaceCast(
1173  Constant *C, ///< The constant to addrspacecast or bitcast
1174  Type *Ty ///< The type to bitcast or addrspacecast C to
1175  );
1176 
1177  /// Create a ZExt, Bitcast or Trunc for integer -> integer casts
1178  static Constant *
1179  getIntegerCast(Constant *C, ///< The integer constant to be casted
1180  Type *Ty, ///< The integer type to cast to
1181  bool IsSigned ///< Whether C should be treated as signed or not
1182  );
1183 
1184  /// Create a FPExt, Bitcast or FPTrunc for fp -> fp casts
1185  static Constant *getFPCast(Constant *C, ///< The integer constant to be casted
1186  Type *Ty ///< The integer type to cast to
1187  );
1188 
1189  /// Return true if this is a convert constant expression
1190  bool isCast() const;
1191 
1192  /// Return true if this is a compare constant expression
1193  bool isCompare() const;
1194 
1195  /// Return true if this is an insertvalue or extractvalue expression,
1196  /// and the getIndices() method may be used.
1197  bool hasIndices() const;
1198 
1199  /// Select constant expr
1200  ///
1201  /// \param OnlyIfReducedTy see \a getWithOperands() docs.
1202  static Constant *getSelect(Constant *C, Constant *V1, Constant *V2,
1203  Type *OnlyIfReducedTy = nullptr);
1204 
1205  /// get - Return a unary operator constant expression,
1206  /// folding if possible.
1207  ///
1208  /// \param OnlyIfReducedTy see \a getWithOperands() docs.
1209  static Constant *get(unsigned Opcode, Constant *C1, unsigned Flags = 0,
1210  Type *OnlyIfReducedTy = nullptr);
1211 
1212  /// get - Return a binary or shift operator constant expression,
1213  /// folding if possible.
1214  ///
1215  /// \param OnlyIfReducedTy see \a getWithOperands() docs.
1216  static Constant *get(unsigned Opcode, Constant *C1, Constant *C2,
1217  unsigned Flags = 0, Type *OnlyIfReducedTy = nullptr);
1218 
1219  /// Return an ICmp or FCmp comparison operator constant expression.
1220  ///
1221  /// \param OnlyIfReduced see \a getWithOperands() docs.
1222  static Constant *getCompare(unsigned short pred, Constant *C1, Constant *C2,
1223  bool OnlyIfReduced = false);
1224 
1225  /// get* - Return some common constants without having to
1226  /// specify the full Instruction::OPCODE identifier.
1227  ///
1228  static Constant *getICmp(unsigned short pred, Constant *LHS, Constant *RHS,
1229  bool OnlyIfReduced = false);
1230  static Constant *getFCmp(unsigned short pred, Constant *LHS, Constant *RHS,
1231  bool OnlyIfReduced = false);
1232 
1233  /// Getelementptr form. Value* is only accepted for convenience;
1234  /// all elements must be Constants.
1235  ///
1236  /// \param InRangeIndex the inrange index if present or None.
1237  /// \param OnlyIfReducedTy see \a getWithOperands() docs.
1239  ArrayRef<Constant *> IdxList,
1240  bool InBounds = false,
1241  Optional<unsigned> InRangeIndex = None,
1242  Type *OnlyIfReducedTy = nullptr) {
1243  return getGetElementPtr(
1244  Ty, C, makeArrayRef((Value *const *)IdxList.data(), IdxList.size()),
1245  InBounds, InRangeIndex, OnlyIfReducedTy);
1246  }
1248  bool InBounds = false,
1249  Optional<unsigned> InRangeIndex = None,
1250  Type *OnlyIfReducedTy = nullptr) {
1251  // This form of the function only exists to avoid ambiguous overload
1252  // warnings about whether to convert Idx to ArrayRef<Constant *> or
1253  // ArrayRef<Value *>.
1254  return getGetElementPtr(Ty, C, cast<Value>(Idx), InBounds, InRangeIndex,
1255  OnlyIfReducedTy);
1256  }
1257  static Constant *getGetElementPtr(Type *Ty, Constant *C,
1258  ArrayRef<Value *> IdxList,
1259  bool InBounds = false,
1260  Optional<unsigned> InRangeIndex = None,
1261  Type *OnlyIfReducedTy = nullptr);
1262 
1263  /// Create an "inbounds" getelementptr. See the documentation for the
1264  /// "inbounds" flag in LangRef.html for details.
1266  ArrayRef<Constant *> IdxList) {
1267  return getGetElementPtr(Ty, C, IdxList, true);
1268  }
1270  Constant *Idx) {
1271  // This form of the function only exists to avoid ambiguous overload
1272  // warnings about whether to convert Idx to ArrayRef<Constant *> or
1273  // ArrayRef<Value *>.
1274  return getGetElementPtr(Ty, C, Idx, true);
1275  }
1277  ArrayRef<Value *> IdxList) {
1278  return getGetElementPtr(Ty, C, IdxList, true);
1279  }
1280 
1281  static Constant *getExtractElement(Constant *Vec, Constant *Idx,
1282  Type *OnlyIfReducedTy = nullptr);
1283  static Constant *getInsertElement(Constant *Vec, Constant *Elt, Constant *Idx,
1284  Type *OnlyIfReducedTy = nullptr);
1285  static Constant *getShuffleVector(Constant *V1, Constant *V2,
1287  Type *OnlyIfReducedTy = nullptr);
1288  static Constant *getExtractValue(Constant *Agg, ArrayRef<unsigned> Idxs,
1289  Type *OnlyIfReducedTy = nullptr);
1290  static Constant *getInsertValue(Constant *Agg, Constant *Val,
1291  ArrayRef<unsigned> Idxs,
1292  Type *OnlyIfReducedTy = nullptr);
1293 
1294  /// Return the opcode at the root of this constant expression
1295  unsigned getOpcode() const { return getSubclassDataFromValue(); }
1296 
1297  /// Return the ICMP or FCMP predicate value. Assert if this is not an ICMP or
1298  /// FCMP constant expression.
1299  unsigned getPredicate() const;
1300 
1301  /// Assert that this is an insertvalue or exactvalue
1302  /// expression and return the list of indices.
1303  ArrayRef<unsigned> getIndices() const;
1304 
1305  /// Assert that this is a shufflevector and return the mask. See class
1306  /// ShuffleVectorInst for a description of the mask representation.
1307  ArrayRef<int> getShuffleMask() const;
1308 
1309  /// Assert that this is a shufflevector and return the mask.
1310  ///
1311  /// TODO: This is a temporary hack until we update the bitcode format for
1312  /// shufflevector.
1313  Constant *getShuffleMaskForBitcode() const;
1314 
1315  /// Return a string representation for an opcode.
1316  const char *getOpcodeName() const;
1317 
1318  /// This returns the current constant expression with the operands replaced
1319  /// with the specified values. The specified array must have the same number
1320  /// of operands as our current one.
1322  return getWithOperands(Ops, getType());
1323  }
1324 
1325  /// Get the current expression with the operands replaced.
1326  ///
1327  /// Return the current constant expression with the operands replaced with \c
1328  /// Ops and the type with \c Ty. The new operands must have the same number
1329  /// as the current ones.
1330  ///
1331  /// If \c OnlyIfReduced is \c true, nullptr will be returned unless something
1332  /// gets constant-folded, the type changes, or the expression is otherwise
1333  /// canonicalized. This parameter should almost always be \c false.
1334  Constant *getWithOperands(ArrayRef<Constant *> Ops, Type *Ty,
1335  bool OnlyIfReduced = false,
1336  Type *SrcTy = nullptr) const;
1337 
1338  /// Returns an Instruction which implements the same operation as this
1339  /// ConstantExpr. If \p InsertBefore is not null, the new instruction is
1340  /// inserted before it, otherwise it is not inserted into any basic block.
1341  ///
1342  /// A better approach to this could be to have a constructor for Instruction
1343  /// which would take a ConstantExpr parameter, but that would have spread
1344  /// implementation details of ConstantExpr outside of Constants.cpp, which
1345  /// would make it harder to remove ConstantExprs altogether.
1346  Instruction *getAsInstruction(Instruction *InsertBefore = nullptr) const;
1347 
1348  /// Methods for support type inquiry through isa, cast, and dyn_cast:
1349  static bool classof(const Value *V) {
1350  return V->getValueID() == ConstantExprVal;
1351  }
1352 
1353 private:
1354  // Shadow Value::setValueSubclassData with a private forwarding method so that
1355  // subclasses cannot accidentally use it.
1356  void setValueSubclassData(unsigned short D) {
1358  }
1359 };
1360 
1361 template <>
1363  : public VariadicOperandTraits<ConstantExpr, 1> {};
1364 
1366 
1367 //===----------------------------------------------------------------------===//
1368 /// 'undef' values are things that do not have specified contents.
1369 /// These are used for a variety of purposes, including global variable
1370 /// initializers and operands to instructions. 'undef' values can occur with
1371 /// any first-class type.
1372 ///
1373 /// Undef values aren't exactly constants; if they have multiple uses, they
1374 /// can appear to have different bit patterns at each use. See
1375 /// LangRef.html#undefvalues for details.
1376 ///
1377 class UndefValue : public ConstantData {
1378  friend class Constant;
1379 
1380  explicit UndefValue(Type *T) : ConstantData(T, UndefValueVal) {}
1381 
1382  void destroyConstantImpl();
1383 
1384 protected:
1385  explicit UndefValue(Type *T, ValueTy vty) : ConstantData(T, vty) {}
1386 
1387 public:
1388  UndefValue(const UndefValue &) = delete;
1389 
1390  /// Static factory methods - Return an 'undef' object of the specified type.
1391  static UndefValue *get(Type *T);
1392 
1393  /// If this Undef has array or vector type, return a undef with the right
1394  /// element type.
1395  UndefValue *getSequentialElement() const;
1396 
1397  /// If this undef has struct type, return a undef with the right element type
1398  /// for the specified element.
1399  UndefValue *getStructElement(unsigned Elt) const;
1400 
1401  /// Return an undef of the right value for the specified GEP index if we can,
1402  /// otherwise return null (e.g. if C is a ConstantExpr).
1403  UndefValue *getElementValue(Constant *C) const;
1404 
1405  /// Return an undef of the right value for the specified GEP index.
1406  UndefValue *getElementValue(unsigned Idx) const;
1407 
1408  /// Return the number of elements in the array, vector, or struct.
1409  unsigned getNumElements() const;
1410 
1411  /// Methods for support type inquiry through isa, cast, and dyn_cast:
1412  static bool classof(const Value *V) {
1413  return V->getValueID() == UndefValueVal ||
1414  V->getValueID() == PoisonValueVal;
1415  }
1416 };
1417 
1418 //===----------------------------------------------------------------------===//
1419 /// In order to facilitate speculative execution, many instructions do not
1420 /// invoke immediate undefined behavior when provided with illegal operands,
1421 /// and return a poison value instead.
1422 ///
1423 /// see LangRef.html#poisonvalues for details.
1424 ///
1425 class PoisonValue final : public UndefValue {
1426  friend class Constant;
1427 
1428  explicit PoisonValue(Type *T) : UndefValue(T, PoisonValueVal) {}
1429 
1430  void destroyConstantImpl();
1431 
1432 public:
1433  PoisonValue(const PoisonValue &) = delete;
1434 
1435  /// Static factory methods - Return an 'poison' object of the specified type.
1436  static PoisonValue *get(Type *T);
1437 
1438  /// If this poison has array or vector type, return a poison with the right
1439  /// element type.
1441 
1442  /// If this poison has struct type, return a poison with the right element
1443  /// type for the specified element.
1444  PoisonValue *getStructElement(unsigned Elt) const;
1445 
1446  /// Return an poison of the right value for the specified GEP index if we can,
1447  /// otherwise return null (e.g. if C is a ConstantExpr).
1449 
1450  /// Return an poison of the right value for the specified GEP index.
1451  PoisonValue *getElementValue(unsigned Idx) const;
1452 
1453  /// Methods for support type inquiry through isa, cast, and dyn_cast:
1454  static bool classof(const Value *V) {
1455  return V->getValueID() == PoisonValueVal;
1456  }
1457 };
1458 
1459 } // end namespace llvm
1460 
1461 #endif // LLVM_IR_CONSTANTS_H
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 is an optimization pass for GlobalISel generic memory operations.
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:2967
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:1600
llvm::UndefValue::UndefValue
UndefValue(Type *T, ValueTy vty)
Definition: Constants.h:1385
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:1095
llvm::ConstantExpr::getNSWNeg
static Constant * getNSWNeg(Constant *C)
Definition: Constants.h:1060
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:1116
llvm::ElementCount
Definition: TypeSize.h:385
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:1360
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:1295
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:1186
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:1522
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:1196
llvm::APInt::getSExtValue
int64_t getSExtValue() const
Get sign extended value.
Definition: APInt.h:1479
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:3217
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:1454
llvm::ConstantFP::getInfinity
static Constant * getInfinity(Type *Ty, bool Negative=false)
Definition: Constants.cpp:1087
llvm::ConstantExpr::getInBoundsGetElementPtr
static Constant * getInBoundsGetElementPtr(Type *Ty, Constant *C, Constant *Idx)
Definition: Constants.h:1269
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:3109
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:3290
llvm::ConstantAggregateZero::getElementCount
ElementCount getElementCount() const
Return the number of elements in the array, vector, or struct.
Definition: Constants.cpp:1138
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::NoCFIValue
Wrapper for a value that won't be replaced with a CFI jump table pointer in LowerTypeTestsModule.
Definition: Constants.h:931
llvm::APInt::getBitWidth
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1412
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:1083
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:2944
llvm::ConstantExpr::getExactLShr
static Constant * getExactLShr(Constant *C1, Constant *C2)
Definition: Constants.h:1107
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:1265
STLExtras.h
RHS
Value * RHS
Definition: X86PartialReduction.cpp:74
llvm::ArrayType
Class to represent array types.
Definition: DerivedTypes.h:357
llvm::ConstantFP::getNegativeZero
static Constant * getNegativeZero(Type *Ty)
Definition: Constants.cpp:1053
llvm::Value::setValueSubclassData
void setValueSubclassData(unsigned short D)
Definition: Value.h:853
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:3310
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:160
F
#define F(x, y, z)
Definition: MD5.cpp:55
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:1321
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:1247
Context
ManagedStatic< detail::RecordContext > Context
Definition: Record.cpp:96
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
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:3265
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:1154
LHS
Value * LHS
Definition: X86PartialReduction.cpp:73
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:1355
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:1333
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:456
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:1079
llvm::Value::getValueID
unsigned getValueID() const
Return an ID for the concrete type of this object.
Definition: Value.h:532
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:1099
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:3347
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:1061
llvm::APInt::getZExtValue
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1467
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:1445
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:1103
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:932
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:2990
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:1192
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:1273
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:1042
llvm::None
const NoneType None
Definition: None.h:23
llvm::LinearPolySize< ElementCount >::getFixed
static ElementCount getFixed(ScalarTy MinVal)
Definition: TypeSize.h:283
llvm::ConstantExpr::getNSWAdd
static Constant * getNSWAdd(Constant *C1, Constant *C2)
Definition: Constants.h:1063
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:3314
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:2940
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:1031
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:3146
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:1768
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:1276
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
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:3339
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:1377
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:2934
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:3302
ops
xray Insert XRay ops
Definition: XRayInstrumentation.cpp:269
llvm::ConstantFP::getZeroValueForNegation
static Constant * getZeroValueForNegation(Type *Ty)
Floating point negation must be implemented with f(x) = -0.0 - x.
Definition: Constants.cpp:1065
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:1126
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:1729
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:1020
llvm::ConstantExpr::ConstantExpr
ConstantExpr(Type *ty, unsigned Opcode, Use *Ops, unsigned NumOps)
Definition: Constants.h:979
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:1067
llvm::BlockAddress
The address of a basic block.
Definition: Constants.h:848
llvm::Value::ValueTy
ValueTy
Concrete subclass of this.
Definition: Value.h:513
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:1075
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
llvm::UndefValue::classof
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Constants.h:1412
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:3237
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:255
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:3093
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:1087
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:1402
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::NoCFIValue::classof
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Constants.h:953
llvm::ConstantExpr::getNSWSub
static Constant * getNSWSub(Constant *C1, Constant *C2)
Definition: Constants.h:1071
llvm::ConstantInt::getFalse
static ConstantInt * getFalse(LLVMContext &Context)
Definition: Constants.cpp:887
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:3072
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:1122
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:971
llvm::ConstantInt::getTrue
static ConstantInt * getTrue(LLVMContext &Context)
Definition: Constants.cpp:880
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:1349
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:3296
llvm::ConstantInt::getBool
static ConstantInt * getBool(LLVMContext &Context, bool V)
Definition: Constants.cpp:894
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:979
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:1475
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:946
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:1238
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:474
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:3170
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:1820
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:163
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:1586
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:1346
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
llvm::NoCFIValue::getGlobalValue
GlobalValue * getGlobalValue() const
Definition: Constants.h:948
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:1838
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:1103
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:1661
llvm::ConstantExpr::getNUWShl
static Constant * getNUWShl(Constant *C1, Constant *C2)
Definition: Constants.h:1091
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:74
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:1425
llvm::PoisonValue::get
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
Definition: Constants.cpp:1801
llvm::ConstantDataSequential::getNumElements
unsigned getNumElements() const
Return the number of elements in the array or vector.
Definition: Constants.cpp:2960
llvm::ConstantAggregateZero::classof
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Constants.h:369