LCOV - code coverage report
Current view: top level - include/llvm/IR - Constants.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 135 154 87.7 %
Date: 2018-10-16 05:50:02 Functions: 19 20 95.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           0 :   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     1445610 :   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      683053 :     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             : 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   154222014 :     return Val;
     140             :   }
     141             : 
     142             :   /// getBitWidth - Return the bitwidth of this constant.
     143      309963 :   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     6996521 :     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       13866 :   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   289033356 :     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     8016443 :     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     4823462 :     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        3287 :   bool isMaxValue(bool isSigned) const {
     219        3287 :     if (isSigned)
     220        2568 :       return Val.isMaxSignedValue();
     221             :     else
     222         719 :       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       13435 :   bool isMinValue(bool isSigned) const {
     231       13435 :     if (isSigned)
     232       12571 :       return Val.isMinSignedValue();
     233             :     else
     234         864 :       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      763475 :     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     8495657 :     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   665939347 :     return V->getValueID() == ConstantIntVal;
     258             :   }
     259             : };
     260             : 
     261             : //===----------------------------------------------------------------------===//
     262             : /// ConstantFP - Floating Point Values [float, double]
     263             : ///
     264           0 : 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      226925 :   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        5306 :   bool isExactlyValue(double V) const {
     322             :     bool ignored;
     323        5306 :     APFloat FV(V);
     324        5306 :     FV.convert(Val.getSemantics(), APFloat::rmNearestTiesToEven, &ignored);
     325        5306 :     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     2485018 :     return V->getValueID() == ConstantFPVal;
     331             :   }
     332             : };
     333             : 
     334             : //===----------------------------------------------------------------------===//
     335             : /// All zero aggregate value
     336             : ///
     337       17518 : 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     2675667 :     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     7552057 :     return V->getValueID() >= ConstantAggregateFirstVal &&
     397             :            V->getValueID() <= ConstantAggregateLastVal;
     398             :   }
     399             : };
     400             : 
     401             : template <>
     402             : struct OperandTraits<ConstantAggregate>
     403             :     : public VariadicOperandTraits<ConstantAggregate> {};
     404             : 
     405     4042181 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantAggregate, Constant)
     406             : 
     407             : //===----------------------------------------------------------------------===//
     408             : /// ConstantArray - Constant Array Declarations
     409             : ///
     410         456 : 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      196081 :     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        2343 :     return V->getValueID() == ConstantArrayVal;
     436             :   }
     437             : };
     438             : 
     439             : //===----------------------------------------------------------------------===//
     440             : // Constant Struct Declarations
     441             : //
     442        2407 : 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         541 :   get(StructType *T, Csts *... Vs) {
     459         540 :     SmallVector<Constant *, 8> Values({Vs...});
     460         541 :     return get(T, Values);
     461             :   }
     462         256 : 
     463         256 :   /// Return an anonymous struct that has the specified elements.
     464         256 :   /// If the struct is possibly empty, then you must specify a context.
     465             :   static Constant *getAnon(ArrayRef<Constant*> V, bool Packed = false) {
     466       23128 :     return get(getTypeForElements(V, Packed), V);
     467         266 :   }
     468         266 :   static Constant *getAnon(LLVMContext &Ctx,
     469             :                            ArrayRef<Constant*> V, bool Packed = false) {
     470          40 :     return get(getTypeForElements(Ctx, V, Packed), V);
     471             :   }
     472             : 
     473             :   /// Return an anonymous struct type to use for a constant with the specified
     474         136 :   /// 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      472309 :     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         998 :     return V->getValueID() == ConstantStructVal;
     490             :   }
     491             : };
     492             : 
     493             : //===----------------------------------------------------------------------===//
     494             : /// Constant Vector Declarations
     495             : ///
     496       14322 : 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      139946 :     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   134093901 :     return V->getValueID() == ConstantVectorVal;
     529             :   }
     530             : };
     531             : 
     532             : //===----------------------------------------------------------------------===//
     533             : /// A constant pointer value that points to null
     534             : ///
     535       13658 : class ConstantPointerNull final : public ConstantData {
     536         112 :   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       36357 :     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   141509959 :     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      269088 :       : ConstantData(ty, VT), DataElements(Data), Next(nullptr) {}
     589       73278 :   ~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     6853525 :     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      214830 :     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           4 :     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    80637777 :     return V->getValueID() == ConstantDataArrayVal ||
     673             :            V->getValueID() == ConstantDataVectorVal;
     674             :   }
     675             : 
     676             : private:
     677             :   const char *getElementPointer(unsigned Elt) const;
     678             : };
     679             : 
     680          22 : //===----------------------------------------------------------------------===//
     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      781222 :   static Constant *get(LLVMContext &Context, ArrayRef<ElementTy> Elts) {
     700      781222 :     const char *Data = reinterpret_cast<const char *>(Elts.data());
     701      803239 :     return getRaw(StringRef(Data, Elts.size() * sizeof(ElementTy)), Elts.size(),
     702      781222 :                   Type::getScalarTy<ElementTy>(Context));
     703             :   }
     704        4346 : 
     705        4346 :   /// get() constructor - ArrayTy needs to be compatible with
     706        8692 :   /// ArrayRef<ElementTy>. Calls get(LLVMContext, ArrayRef<ElementTy>).
     707        4346 :   template <typename ArrayTy>
     708             :   static Constant *get(LLVMContext &Context, ArrayTy &Elts) {
     709       17628 :     return ConstantDataArray::get(Context, makeArrayRef(Elts));
     710       13774 :   }
     711       27548 : 
     712       13774 :   /// get() constructor - Return a constant with array type with an element
     713             :   /// count and element type matching the NumElements and ElementTy parameters
     714         156 :   /// passed in. Note that this can return a ConstantAggregateZero object.
     715         156 :   /// ElementTy needs to be one of i8/i16/i32/i64/float/double. Data is the
     716         312 :   /// buffer containing the elements. Be careful to make sure Data uses the
     717         156 :   /// right endianness, the buffer will be used as-is.
     718             :   static Constant *getRaw(StringRef Data, uint64_t NumElements, Type *ElementTy) {
     719      765244 :     Type *Ty = ArrayType::get(ElementTy, NumElements);
     720      762946 :     return getImpl(Data, Ty);
     721      759009 :   }
     722      759009 : 
     723             :   /// getFP() constructors - Return a constant with array type with an element
     724             :   /// count and element type of float with precision matching the number of
     725             :   /// bits in the ArrayRef passed in. (i.e. half for 16bits, float for 32bits,
     726             :   /// double for 64bits) Note that this can return a ConstantAggregateZero
     727             :   /// object.
     728             :   static Constant *getFP(LLVMContext &Context, ArrayRef<uint16_t> Elts);
     729       65606 :   static Constant *getFP(LLVMContext &Context, ArrayRef<uint32_t> Elts);
     730        2316 :   static Constant *getFP(LLVMContext &Context, ArrayRef<uint64_t> Elts);
     731             : 
     732             :   /// This method constructs a CDS and initializes it with a text string.
     733             :   /// The default behavior (AddNull==true) causes a null terminator to
     734             :   /// be placed at the end of the array (increasing the length of the string by
     735             :   /// one more than the StringRef would normally indicate.  Pass AddNull=false
     736             :   /// to disable this behavior.
     737             :   static Constant *getString(LLVMContext &Context, StringRef Initializer,
     738             :                              bool AddNull = true);
     739      774969 : 
     740      774969 :   /// Specialize the getType() method to always return an ArrayType,
     741             :   /// which reduces the amount of casting needed in parts of the compiler.
     742             :   inline ArrayType *getType() const {
     743       14617 :     return cast<ArrayType>(Value::getType());
     744             :   }
     745             : 
     746             :   /// Methods for support type inquiry through isa, cast, and dyn_cast:
     747             :   static bool classof(const Value *V) {
     748        7760 :     return V->getValueID() == ConstantDataArrayVal;
     749             :   }
     750             : };
     751             : 
     752             : //===----------------------------------------------------------------------===//
     753             : /// A vector constant whose element type is a simple 1/2/4/8-byte integer or
     754             : /// float/double, and whose elements are just simple data values
     755             : /// (i.e. ConstantInt/ConstantFP). This Constant node has no operands because it
     756             : /// stores all of the elements of the constant as densely packed data, instead
     757             : /// of as Value*'s.
     758           0 : class ConstantDataVector final : public ConstantDataSequential {
     759             :   friend class ConstantDataSequential;
     760             : 
     761             :   explicit ConstantDataVector(Type *ty, const char *Data)
     762             :       : ConstantDataSequential(ty, ConstantDataVectorVal, Data) {}
     763             : 
     764             : public:
     765             :   ConstantDataVector(const ConstantDataVector &) = delete;
     766             : 
     767             :   /// get() constructors - Return a constant with vector type with an element
     768             :   /// count and element type matching the ArrayRef passed in.  Note that this
     769             :   /// can return a ConstantAggregateZero object.
     770             :   static Constant *get(LLVMContext &Context, ArrayRef<uint8_t> Elts);
     771             :   static Constant *get(LLVMContext &Context, ArrayRef<uint16_t> Elts);
     772             :   static Constant *get(LLVMContext &Context, ArrayRef<uint32_t> Elts);
     773             :   static Constant *get(LLVMContext &Context, ArrayRef<uint64_t> Elts);
     774             :   static Constant *get(LLVMContext &Context, ArrayRef<float> Elts);
     775             :   static Constant *get(LLVMContext &Context, ArrayRef<double> Elts);
     776             : 
     777             :   /// getFP() constructors - Return a constant with vector type with an element
     778             :   /// count and element type of float with the precision matching the number of
     779             :   /// bits in the ArrayRef passed in.  (i.e. half for 16bits, float for 32bits,
     780             :   /// double for 64bits) Note that this can return a ConstantAggregateZero
     781             :   /// object.
     782             :   static Constant *getFP(LLVMContext &Context, ArrayRef<uint16_t> Elts);
     783             :   static Constant *getFP(LLVMContext &Context, ArrayRef<uint32_t> Elts);
     784             :   static Constant *getFP(LLVMContext &Context, ArrayRef<uint64_t> Elts);
     785             : 
     786             :   /// Return a ConstantVector with the specified constant in each element.
     787             :   /// The specified constant has to be a of a compatible type (i8/i16/
     788             :   /// i32/i64/float/double) and must be a ConstantFP or ConstantInt.
     789             :   static Constant *getSplat(unsigned NumElts, Constant *Elt);
     790             : 
     791             :   /// Returns true if this is a splat constant, meaning that all elements have
     792             :   /// the same value.
     793             :   bool isSplat() const;
     794             : 
     795             :   /// If this is a splat constant, meaning that all of the elements have the
     796             :   /// same value, return that value. Otherwise return NULL.
     797             :   Constant *getSplatValue() const;
     798             : 
     799             :   /// Specialize the getType() method to always return a VectorType,
     800             :   /// which reduces the amount of casting needed in parts of the compiler.
     801             :   inline VectorType *getType() const {
     802         115 :     return cast<VectorType>(Value::getType());
     803             :   }
     804             : 
     805             :   /// Methods for support type inquiry through isa, cast, and dyn_cast:
     806             :   static bool classof(const Value *V) {
     807         474 :     return V->getValueID() == ConstantDataVectorVal;
     808             :   }
     809             : };
     810             : 
     811             : //===----------------------------------------------------------------------===//
     812             : /// A constant token which is empty
     813             : ///
     814         291 : class ConstantTokenNone final : public ConstantData {
     815             :   friend class Constant;
     816             : 
     817             :   explicit ConstantTokenNone(LLVMContext &Context)
     818             :       : ConstantData(Type::getTokenTy(Context), ConstantTokenNoneVal) {}
     819             : 
     820             :   void destroyConstantImpl();
     821             : 
     822             : public:
     823             :   ConstantTokenNone(const ConstantTokenNone &) = delete;
     824             : 
     825             :   /// Return the ConstantTokenNone.
     826             :   static ConstantTokenNone *get(LLVMContext &Context);
     827     1762826 : 
     828             :   /// Methods to support type inquiry through isa, cast, and dyn_cast.
     829             :   static bool classof(const Value *V) {
     830        3732 :     return V->getValueID() == ConstantTokenNoneVal;
     831             :   }
     832             : };
     833             : 
     834           0 : /// The address of a basic block.
     835             : ///
     836           0 : class BlockAddress final : public Constant {
     837         304 :   friend class Constant;
     838         304 : 
     839             :   BlockAddress(Function *F, BasicBlock *BB);
     840             : 
     841             :   void *operator new(size_t s) { return User::operator new(s, 2); }
     842             : 
     843             :   void destroyConstantImpl();
     844             :   Value *handleOperandChangeImpl(Value *From, Value *To);
     845             : 
     846             : public:
     847             :   /// Return a BlockAddress for the specified function and basic block.
     848             :   static BlockAddress *get(Function *F, BasicBlock *BB);
     849             : 
     850           0 :   /// Return a BlockAddress for the specified basic block.  The basic
     851             :   /// block must be embedded into a function.
     852             :   static BlockAddress *get(BasicBlock *BB);
     853             : 
     854             :   /// Lookup an existing \c BlockAddress constant for the given BasicBlock.
     855             :   ///
     856             :   /// \returns 0 if \c !BB->hasAddressTaken(), otherwise the \c BlockAddress.
     857             :   static BlockAddress *lookup(const BasicBlock *BB);
     858             : 
     859             :   /// Transparently provide more efficient getOperand methods.
     860             :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
     861         991 : 
     862         549 :   Function *getFunction() const { return (Function*)Op<0>().get(); }
     863        1028 :   BasicBlock *getBasicBlock() const { return (BasicBlock*)Op<1>().get(); }
     864             : 
     865             :   /// Methods for support type inquiry through isa, cast, and dyn_cast:
     866             :   static bool classof(const Value *V) {
     867      631605 :     return V->getValueID() == BlockAddressVal;
     868             :   }
     869             : };
     870             : 
     871             : template <>
     872             : struct OperandTraits<BlockAddress> :
     873             :   public FixedNumOperandTraits<BlockAddress, 2> {
     874             : };
     875             : 
     876             : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BlockAddress, Value)
     877             : 
     878             : //===----------------------------------------------------------------------===//
     879             : /// A constant value that is initialized with an expression using
     880             : /// other constant values.
     881             : ///
     882        1132 : /// This class uses the standard Instruction opcodes to define the various
     883         945 : /// constant expressions.  The Opcode field for the ConstantExpr class is
     884             : /// maintained in the Value::SubclassData field.
     885        4338 : class ConstantExpr : public Constant {
     886             :   friend struct ConstantExprKeyType;
     887         105 :   friend class Constant;
     888             : 
     889             :   void destroyConstantImpl();
     890             :   Value *handleOperandChangeImpl(Value *From, Value *To);
     891             : 
     892             : protected:
     893             :   ConstantExpr(Type *ty, unsigned Opcode, Use *Ops, unsigned NumOps)
     894             :       : Constant(ty, ConstantExprVal, Ops, NumOps) {
     895             :     // Operation type (an Instruction opcode) is stored as the SubclassData.
     896        1000 :     setValueSubclassData(Opcode);
     897             :   }
     898             : 
     899             : public:
     900             :   // Static methods to construct a ConstantExpr of different kinds.  Note that
     901             :   // these methods may return a object that is not an instance of the
     902             :   // ConstantExpr class, because they will attempt to fold the constant
     903             :   // expression into something simpler if possible.
     904             : 
     905             :   /// getAlignOf constant expr - computes the alignment of a type in a target
     906             :   /// independent way (Note: the return type is an i64).
     907             :   static Constant *getAlignOf(Type *Ty);
     908             : 
     909             :   /// getSizeOf constant expr - computes the (alloc) size of a type (in
     910             :   /// address-units, not bits) in a target independent way (Note: the return
     911             :   /// type is an i64).
     912             :   ///
     913             :   static Constant *getSizeOf(Type *Ty);
     914             : 
     915             :   /// getOffsetOf constant expr - computes the offset of a struct field in a
     916      220189 :   /// target independent way (Note: the return type is an i64).
     917             :   ///
     918             :   static Constant *getOffsetOf(StructType *STy, unsigned FieldNo);
     919             : 
     920             :   /// getOffsetOf constant expr - This is a generalized form of getOffsetOf,
     921             :   /// which supports any aggregate type, and any Constant index.
     922             :   ///
     923             :   static Constant *getOffsetOf(Type *Ty, Constant *FieldNo);
     924             : 
     925             :   static Constant *getNeg(Constant *C, bool HasNUW = false, bool HasNSW =false);
     926             :   static Constant *getFNeg(Constant *C);
     927             :   static Constant *getNot(Constant *C);
     928             :   static Constant *getAdd(Constant *C1, Constant *C2,
     929             :                           bool HasNUW = false, bool HasNSW = false);
     930             :   static Constant *getFAdd(Constant *C1, Constant *C2);
     931             :   static Constant *getSub(Constant *C1, Constant *C2,
     932             :                           bool HasNUW = false, bool HasNSW = false);
     933             :   static Constant *getFSub(Constant *C1, Constant *C2);
     934             :   static Constant *getMul(Constant *C1, Constant *C2,
     935             :                           bool HasNUW = false, bool HasNSW = false);
     936             :   static Constant *getFMul(Constant *C1, Constant *C2);
     937             :   static Constant *getUDiv(Constant *C1, Constant *C2, bool isExact = false);
     938             :   static Constant *getSDiv(Constant *C1, Constant *C2, bool isExact = false);
     939             :   static Constant *getFDiv(Constant *C1, Constant *C2);
     940             :   static Constant *getURem(Constant *C1, Constant *C2);
     941             :   static Constant *getSRem(Constant *C1, Constant *C2);
     942             :   static Constant *getFRem(Constant *C1, Constant *C2);
     943             :   static Constant *getAnd(Constant *C1, Constant *C2);
     944             :   static Constant *getOr(Constant *C1, Constant *C2);
     945             :   static Constant *getXor(Constant *C1, Constant *C2);
     946             :   static Constant *getShl(Constant *C1, Constant *C2,
     947             :                           bool HasNUW = false, bool HasNSW = false);
     948             :   static Constant *getLShr(Constant *C1, Constant *C2, bool isExact = false);
     949             :   static Constant *getAShr(Constant *C1, Constant *C2, bool isExact = false);
     950             :   static Constant *getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced = false);
     951             :   static Constant *getSExt(Constant *C, Type *Ty, bool OnlyIfReduced = false);
     952             :   static Constant *getZExt(Constant *C, Type *Ty, bool OnlyIfReduced = false);
     953             :   static Constant *getFPTrunc(Constant *C, Type *Ty,
     954             :                               bool OnlyIfReduced = false);
     955             :   static Constant *getFPExtend(Constant *C, Type *Ty,
     956             :                                bool OnlyIfReduced = false);
     957             :   static Constant *getUIToFP(Constant *C, Type *Ty, bool OnlyIfReduced = false);
     958             :   static Constant *getSIToFP(Constant *C, Type *Ty, bool OnlyIfReduced = false);
     959             :   static Constant *getFPToUI(Constant *C, Type *Ty, bool OnlyIfReduced = false);
     960             :   static Constant *getFPToSI(Constant *C, Type *Ty, bool OnlyIfReduced = false);
     961             :   static Constant *getPtrToInt(Constant *C, Type *Ty,
     962             :                                bool OnlyIfReduced = false);
     963             :   static Constant *getIntToPtr(Constant *C, Type *Ty,
     964             :                                bool OnlyIfReduced = false);
     965             :   static Constant *getBitCast(Constant *C, Type *Ty,
     966             :                               bool OnlyIfReduced = false);
     967             :   static Constant *getAddrSpaceCast(Constant *C, Type *Ty,
     968             :                                     bool OnlyIfReduced = false);
     969             : 
     970           0 :   static Constant *getNSWNeg(Constant *C) { return getNeg(C, false, true); }
     971           0 :   static Constant *getNUWNeg(Constant *C) { return getNeg(C, true, false); }
     972             : 
     973             :   static Constant *getNSWAdd(Constant *C1, Constant *C2) {
     974           8 :     return getAdd(C1, C2, false, true);
     975             :   }
     976             : 
     977             :   static Constant *getNUWAdd(Constant *C1, Constant *C2) {
     978           0 :     return getAdd(C1, C2, true, false);
     979             :   }
     980             : 
     981             :   static Constant *getNSWSub(Constant *C1, Constant *C2) {
     982           0 :     return getSub(C1, C2, false, true);
     983             :   }
     984             : 
     985             :   static Constant *getNUWSub(Constant *C1, Constant *C2) {
     986           0 :     return getSub(C1, C2, true, false);
     987             :   }
     988             : 
     989             :   static Constant *getNSWMul(Constant *C1, Constant *C2) {
     990           0 :     return getMul(C1, C2, false, true);
     991             :   }
     992             : 
     993             :   static Constant *getNUWMul(Constant *C1, Constant *C2) {
     994         134 :     return getMul(C1, C2, true, false);
     995             :   }
     996             : 
     997             :   static Constant *getNSWShl(Constant *C1, Constant *C2) {
     998             :     return getShl(C1, C2, false, true);
     999             :   }
    1000             : 
    1001             :   static Constant *getNUWShl(Constant *C1, Constant *C2) {
    1002           1 :     return getShl(C1, C2, true, false);
    1003             :   }
    1004             : 
    1005             :   static Constant *getExactSDiv(Constant *C1, Constant *C2) {
    1006           0 :     return getSDiv(C1, C2, true);
    1007             :   }
    1008             : 
    1009             :   static Constant *getExactUDiv(Constant *C1, Constant *C2) {
    1010           1 :     return getUDiv(C1, C2, true);
    1011             :   }
    1012             : 
    1013             :   static Constant *getExactAShr(Constant *C1, Constant *C2) {
    1014             :     return getAShr(C1, C2, true);
    1015             :   }
    1016             : 
    1017             :   static Constant *getExactLShr(Constant *C1, Constant *C2) {
    1018             :     return getLShr(C1, C2, true);
    1019             :   }
    1020             : 
    1021             :   /// Return the identity constant for a binary opcode.
    1022             :   /// The identity constant C is defined as X op C = X and C op X = X for every
    1023             :   /// X when the binary operation is commutative. If the binop is not
    1024             :   /// commutative, callers can acquire the operand 1 identity constant by
    1025             :   /// setting AllowRHSConstant to true. For example, any shift has a zero
    1026             :   /// identity constant for operand 1: X shift 0 = X.
    1027             :   /// Return nullptr if the operator does not have an identity constant.
    1028             :   static Constant *getBinOpIdentity(unsigned Opcode, Type *Ty,
    1029             :                                     bool AllowRHSConstant = false);
    1030             : 
    1031             :   /// Return the absorbing element for the given binary
    1032             :   /// operation, i.e. a constant C such that X op C = C and C op X = C for
    1033             :   /// every X.  For example, this returns zero for integer multiplication.
    1034             :   /// It returns null if the operator doesn't have an absorbing element.
    1035             :   static Constant *getBinOpAbsorber(unsigned Opcode, Type *Ty);
    1036             : 
    1037             :   /// Transparently provide more efficient getOperand methods.
    1038             :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
    1039             : 
    1040             :   /// Convenience function for getting a Cast operation.
    1041             :   ///
    1042             :   /// \param ops The opcode for the conversion
    1043             :   /// \param C  The constant to be converted
    1044             :   /// \param Ty The type to which the constant is converted
    1045             :   /// \param OnlyIfReduced see \a getWithOperands() docs.
    1046             :   static Constant *getCast(unsigned ops, Constant *C, Type *Ty,
    1047             :                            bool OnlyIfReduced = false);
    1048             : 
    1049             :   // Create a ZExt or BitCast cast constant expression
    1050             :   static Constant *getZExtOrBitCast(
    1051             :     Constant *C,   ///< The constant to zext or bitcast
    1052             :     Type *Ty ///< The type to zext or bitcast C to
    1053             :   );
    1054             : 
    1055             :   // Create a SExt or BitCast cast constant expression
    1056             :   static Constant *getSExtOrBitCast(
    1057             :     Constant *C,   ///< The constant to sext or bitcast
    1058             :     Type *Ty ///< The type to sext or bitcast C to
    1059             :   );
    1060             : 
    1061             :   // Create a Trunc or BitCast cast constant expression
    1062             :   static Constant *getTruncOrBitCast(
    1063             :     Constant *C,   ///< The constant to trunc or bitcast
    1064             :     Type *Ty ///< The type to trunc or bitcast C to
    1065             :   );
    1066             : 
    1067             :   /// Create a BitCast, AddrSpaceCast, or a PtrToInt cast constant
    1068             :   /// expression.
    1069             :   static Constant *getPointerCast(
    1070             :     Constant *C,   ///< The pointer value to be casted (operand 0)
    1071             :     Type *Ty ///< The type to which cast should be made
    1072             :   );
    1073             : 
    1074             :   /// Create a BitCast or AddrSpaceCast for a pointer type depending on
    1075             :   /// the address space.
    1076             :   static Constant *getPointerBitCastOrAddrSpaceCast(
    1077             :     Constant *C,   ///< The constant to addrspacecast or bitcast
    1078             :     Type *Ty ///< The type to bitcast or addrspacecast C to
    1079             :   );
    1080             : 
    1081             :   /// Create a ZExt, Bitcast or Trunc for integer -> integer casts
    1082             :   static Constant *getIntegerCast(
    1083             :     Constant *C,    ///< The integer constant to be casted
    1084             :     Type *Ty, ///< The integer type to cast to
    1085             :     bool isSigned   ///< Whether C should be treated as signed or not
    1086             :   );
    1087             : 
    1088             :   /// Create a FPExt, Bitcast or FPTrunc for fp -> fp casts
    1089             :   static Constant *getFPCast(
    1090             :     Constant *C,    ///< The integer constant to be casted
    1091             :     Type *Ty ///< The integer type to cast to
    1092             :   );
    1093             : 
    1094             :   /// Return true if this is a convert constant expression
    1095             :   bool isCast() const;
    1096             : 
    1097             :   /// Return true if this is a compare constant expression
    1098             :   bool isCompare() const;
    1099             : 
    1100             :   /// Return true if this is an insertvalue or extractvalue expression,
    1101             :   /// and the getIndices() method may be used.
    1102             :   bool hasIndices() const;
    1103             : 
    1104             :   /// Return true if this is a getelementptr expression and all
    1105             :   /// the index operands are compile-time known integers within the
    1106             :   /// corresponding notional static array extents. Note that this is
    1107             :   /// not equivalant to, a subset of, or a superset of the "inbounds"
    1108             :   /// property.
    1109             :   bool isGEPWithNoNotionalOverIndexing() const;
    1110             : 
    1111             :   /// Select constant expr
    1112             :   ///
    1113             :   /// \param OnlyIfReducedTy see \a getWithOperands() docs.
    1114             :   static Constant *getSelect(Constant *C, Constant *V1, Constant *V2,
    1115             :                              Type *OnlyIfReducedTy = nullptr);
    1116             : 
    1117             :   /// get - Return a binary or shift operator constant expression,
    1118             :   /// folding if possible.
    1119             :   ///
    1120             :   /// \param OnlyIfReducedTy see \a getWithOperands() docs.
    1121             :   static Constant *get(unsigned Opcode, Constant *C1, Constant *C2,
    1122             :                        unsigned Flags = 0, Type *OnlyIfReducedTy = nullptr);
    1123             : 
    1124             :   /// Return an ICmp or FCmp comparison operator constant expression.
    1125             :   ///
    1126             :   /// \param OnlyIfReduced see \a getWithOperands() docs.
    1127             :   static Constant *getCompare(unsigned short pred, Constant *C1, Constant *C2,
    1128             :                               bool OnlyIfReduced = false);
    1129             : 
    1130             :   /// get* - Return some common constants without having to
    1131             :   /// specify the full Instruction::OPCODE identifier.
    1132             :   ///
    1133             :   static Constant *getICmp(unsigned short pred, Constant *LHS, Constant *RHS,
    1134             :                            bool OnlyIfReduced = false);
    1135             :   static Constant *getFCmp(unsigned short pred, Constant *LHS, Constant *RHS,
    1136             :                            bool OnlyIfReduced = false);
    1137             : 
    1138             :   /// Getelementptr form.  Value* is only accepted for convenience;
    1139             :   /// all elements must be Constants.
    1140             :   ///
    1141             :   /// \param InRangeIndex the inrange index if present or None.
    1142             :   /// \param OnlyIfReducedTy see \a getWithOperands() docs.
    1143             :   static Constant *getGetElementPtr(Type *Ty, Constant *C,
    1144             :                                     ArrayRef<Constant *> IdxList,
    1145             :                                     bool InBounds = false,
    1146             :                                     Optional<unsigned> InRangeIndex = None,
    1147             :                                     Type *OnlyIfReducedTy = nullptr) {
    1148    16720228 :     return getGetElementPtr(
    1149             :         Ty, C, makeArrayRef((Value * const *)IdxList.data(), IdxList.size()),
    1150             :         InBounds, InRangeIndex, OnlyIfReducedTy);
    1151             :   }
    1152        8600 :   static Constant *getGetElementPtr(Type *Ty, Constant *C, Constant *Idx,
    1153             :                                     bool InBounds = false,
    1154             :                                     Optional<unsigned> InRangeIndex = None,
    1155             :                                     Type *OnlyIfReducedTy = nullptr) {
    1156          43 :     // This form of the function only exists to avoid ambiguous overload
    1157             :     // warnings about whether to convert Idx to ArrayRef<Constant *> or
    1158         272 :     // ArrayRef<Value *>.
    1159       17200 :     return getGetElementPtr(Ty, C, cast<Value>(Idx), InBounds, InRangeIndex,
    1160        8600 :                             OnlyIfReducedTy);
    1161             :   }
    1162             :   static Constant *getGetElementPtr(Type *Ty, Constant *C,
    1163             :                                     ArrayRef<Value *> IdxList,
    1164             :                                     bool InBounds = false,
    1165             :                                     Optional<unsigned> InRangeIndex = None,
    1166             :                                     Type *OnlyIfReducedTy = nullptr);
    1167             : 
    1168        5402 :   /// Create an "inbounds" getelementptr. See the documentation for the
    1169             :   /// "inbounds" flag in LangRef.html for details.
    1170             :   static Constant *getInBoundsGetElementPtr(Type *Ty, Constant *C,
    1171             :                                             ArrayRef<Constant *> IdxList) {
    1172         797 :     return getGetElementPtr(Ty, C, IdxList, true);
    1173             :   }
    1174             :   static Constant *getInBoundsGetElementPtr(Type *Ty, Constant *C,
    1175             :                                             Constant *Idx) {
    1176             :     // This form of the function only exists to avoid ambiguous overload
    1177             :     // warnings about whether to convert Idx to ArrayRef<Constant *> or
    1178             :     // ArrayRef<Value *>.
    1179        9307 :     return getGetElementPtr(Ty, C, Idx, true);
    1180         797 :   }
    1181             :   static Constant *getInBoundsGetElementPtr(Type *Ty, Constant *C,
    1182             :                                             ArrayRef<Value *> IdxList) {
    1183     1082595 :     return getGetElementPtr(Ty, C, IdxList, true);
    1184             :   }
    1185             : 
    1186             :   static Constant *getExtractElement(Constant *Vec, Constant *Idx,
    1187             :                                      Type *OnlyIfReducedTy = nullptr);
    1188             :   static Constant *getInsertElement(Constant *Vec, Constant *Elt, Constant *Idx,
    1189             :                                     Type *OnlyIfReducedTy = nullptr);
    1190             :   static Constant *getShuffleVector(Constant *V1, Constant *V2, Constant *Mask,
    1191             :                                     Type *OnlyIfReducedTy = nullptr);
    1192             :   static Constant *getExtractValue(Constant *Agg, ArrayRef<unsigned> Idxs,
    1193             :                                    Type *OnlyIfReducedTy = nullptr);
    1194             :   static Constant *getInsertValue(Constant *Agg, Constant *Val,
    1195             :                                   ArrayRef<unsigned> Idxs,
    1196             :                                   Type *OnlyIfReducedTy = nullptr);
    1197             : 
    1198             :   /// Return the opcode at the root of this constant expression
    1199   342832652 :   unsigned getOpcode() const { return getSubclassDataFromValue(); }
    1200             : 
    1201             :   /// Return the ICMP or FCMP predicate value. Assert if this is not an ICMP or
    1202             :   /// FCMP constant expression.
    1203             :   unsigned getPredicate() const;
    1204             : 
    1205             :   /// Assert that this is an insertvalue or exactvalue
    1206             :   /// expression and return the list of indices.
    1207           0 :   ArrayRef<unsigned> getIndices() const;
    1208             : 
    1209          31 :   /// Return a string representation for an opcode.
    1210             :   const char *getOpcodeName() const;
    1211             : 
    1212             :   /// Return a constant expression identical to this one, but with the specified
    1213             :   /// operand set to the specified value.
    1214             :   Constant *getWithOperandReplaced(unsigned OpNo, Constant *Op) const;
    1215             : 
    1216             :   /// This returns the current constant expression with the operands replaced
    1217             :   /// with the specified values. The specified array must have the same number
    1218             :   /// of operands as our current one.
    1219    99500852 :   Constant *getWithOperands(ArrayRef<Constant*> Ops) const {
    1220         454 :     return getWithOperands(Ops, getType());
    1221             :   }
    1222             : 
    1223             :   /// Get the current expression with the operands replaced.
    1224             :   ///
    1225             :   /// Return the current constant expression with the operands replaced with \c
    1226             :   /// Ops and the type with \c Ty.  The new operands must have the same number
    1227             :   /// as the current ones.
    1228             :   ///
    1229             :   /// If \c OnlyIfReduced is \c true, nullptr will be returned unless something
    1230             :   /// gets constant-folded, the type changes, or the expression is otherwise
    1231             :   /// canonicalized.  This parameter should almost always be \c false.
    1232             :   Constant *getWithOperands(ArrayRef<Constant *> Ops, Type *Ty,
    1233             :                             bool OnlyIfReduced = false,
    1234             :                             Type *SrcTy = nullptr) const;
    1235             : 
    1236             :   /// Returns an Instruction which implements the same operation as this
    1237             :   /// ConstantExpr. The instruction is not linked to any basic block.
    1238             :   ///
    1239             :   /// A better approach to this could be to have a constructor for Instruction
    1240           0 :   /// which would take a ConstantExpr parameter, but that would have spread
    1241             :   /// implementation details of ConstantExpr outside of Constants.cpp, which
    1242             :   /// would make it harder to remove ConstantExprs altogether.
    1243             :   Instruction *getAsInstruction();
    1244             : 
    1245             :   /// Methods for support type inquiry through isa, cast, and dyn_cast:
    1246             :   static bool classof(const Value *V) {
    1247    76633358 :     return V->getValueID() == ConstantExprVal;
    1248             :   }
    1249             : 
    1250             : private:
    1251             :   // Shadow Value::setValueSubclassData with a private forwarding method so that
    1252             :   // subclasses cannot accidentally use it.
    1253             :   void setValueSubclassData(unsigned short D) {
    1254             :     Value::setValueSubclassData(D);
    1255           0 :   }
    1256             : };
    1257       28451 : 
    1258             : template <>
    1259             : struct OperandTraits<ConstantExpr> :
    1260             :   public VariadicOperandTraits<ConstantExpr, 1> {
    1261             : };
    1262             : 
    1263    26102806 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantExpr, Constant)
    1264             : 
    1265             : //===----------------------------------------------------------------------===//
    1266             : /// 'undef' values are things that do not have specified contents.
    1267     4127557 : /// These are used for a variety of purposes, including global variable
    1268             : /// initializers and operands to instructions.  'undef' values can occur with
    1269             : /// any first-class type.
    1270             : ///
    1271             : /// Undef values aren't exactly constants; if they have multiple uses, they
    1272             : /// can appear to have different bit patterns at each use. See
    1273        1641 : /// LangRef.html#undefvalues for details.
    1274             : ///
    1275       60053 : class UndefValue final : public ConstantData {
    1276             :   friend class Constant;
    1277             : 
    1278             :   explicit UndefValue(Type *T) : ConstantData(T, UndefValueVal) {}
    1279             : 
    1280             :   void destroyConstantImpl();
    1281             : 
    1282             : public:
    1283    68491807 :   UndefValue(const UndefValue &) = delete;
    1284             : 
    1285             :   /// Static factory methods - Return an 'undef' object of the specified type.
    1286             :   static UndefValue *get(Type *T);
    1287             : 
    1288             :   /// If this Undef has array or vector type, return a undef with the right
    1289             :   /// element type.
    1290             :   UndefValue *getSequentialElement() const;
    1291             : 
    1292             :   /// If this undef has struct type, return a undef with the right element type
    1293             :   /// for the specified element.
    1294             :   UndefValue *getStructElement(unsigned Elt) const;
    1295           0 : 
    1296             :   /// Return an undef of the right value for the specified GEP index if we can,
    1297             :   /// otherwise return null (e.g. if C is a ConstantExpr).
    1298             :   UndefValue *getElementValue(Constant *C) const;
    1299             : 
    1300             :   /// Return an undef of the right value for the specified GEP index.
    1301             :   UndefValue *getElementValue(unsigned Idx) const;
    1302             : 
    1303             :   /// Return the number of elements in the array, vector, or struct.
    1304             :   unsigned getNumElements() const;
    1305             : 
    1306             :   /// Methods for support type inquiry through isa, cast, and dyn_cast:
    1307             :   static bool classof(const Value *V) {
    1308   196279770 :     return V->getValueID() == UndefValueVal;
    1309             :   }
    1310             : };
    1311             : 
    1312             : } // end namespace llvm
    1313             : 
    1314             : #endif // LLVM_IR_CONSTANTS_H

Generated by: LCOV version 1.13