include/llvm/Constants.h

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