LCOV - code coverage report
Current view: top level - include/llvm/IR - Constants.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 95 106 89.6 %
Date: 2018-05-20 00:06:23 Functions: 20 20 100.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13