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

Generated by: LCOV version 1.13