include/llvm/Constants.h

   1 //===-- llvm/Constants.h - Constant class subclass definitions ---*- C++ -*--=//
   2 //
   3 // This file contains the declarations for the subclasses of Constant, which
   4 // represent the different type of constant pool values
   5 //
   6 //===----------------------------------------------------------------------===//
   7
   8 #ifndef LLVM_CONSTANTS_H
   9 #define LLVM_CONSTANTS_H
  10
  11 #include "llvm/Constant.h"
  12 #include "Support/DataTypes.h"
  13
  14 class ArrayType;
  15 class StructType;
  16 class PointerType;
  17
  18
  19 //===---------------------------------------------------------------------------
  20 /// ConstantIntegral - Shared superclass of boolean and integer constants.
  21 ///
  22 /// This class just defines some common interfaces to be implemented.
  23 ///
  24 class ConstantIntegral : public Constant {
  25 protected:
  26   ConstantIntegral(const Type *Ty) : Constant(Ty) {}
  27 public:
  28
  29   /// isNullValue - Return true if this is the value that would be returned by
  30   /// getNullValue.
  31   ///
  32   virtual bool isNullValue() const = 0;
  33
  34   /// isMaxValue - Return true if this is the largest value that may be
  35   /// represented by this type.
  36   ///
  37   virtual bool isMaxValue() const = 0;
  38
  39   /// isMinValue - Return true if this is the smallest value that may be
  40   /// represented by this type.
  41   ///
  42   virtual bool isMinValue() const = 0;
  43
  44   /// isAllOnesValue - Return true if every bit in this constant is set to true.
  45   ///
  46   virtual bool isAllOnesValue() const = 0;
  47
  48   /// Static constructor to get the maximum/minimum/allones constant of
  49   /// specified (integral) type...
  50   ///
  51   static ConstantIntegral *getMaxValue(const Type *Ty);
  52   static ConstantIntegral *getMinValue(const Type *Ty);
  53   static ConstantIntegral *getAllOnesValue(const Type *Ty);
  54
  55   /// Methods for support type inquiry through isa, cast, and dyn_cast:
  56   static inline bool classof(const ConstantIntegral *) { return true; }
  57   static bool classof(const Constant *CPV);  // defined in Constants.cpp
  58   static inline bool classof(const Value *V) {
  59     return isa<Constant>(V) && classof(cast<Constant>(V));
  60   }
  61 };
  62
  63
  64 //===---------------------------------------------------------------------------
  65 /// ConstantBool - Boolean Values
  66 ///
  67 class ConstantBool : public ConstantIntegral {
  68   bool Val;
  69   ConstantBool(bool V);
  70   ~ConstantBool() {}
  71 public:
  72   static ConstantBool *True, *False;  // The True & False values
  73
  74   /// get() - Static factory methods - Return objects of the specified value
  75   static ConstantBool *get(bool Value) { return Value ? True : False; }
  76   static ConstantBool *get(const Type *Ty, bool Value) { return get(Value); }
  77
  78   /// inverted - Return the opposite value of the current value.
  79   inline ConstantBool *inverted() const { return (this==True) ? False : True; }
  80
  81   /// getValue - return the boolean value of this constant.
  82   ///
  83   inline bool getValue() const { return Val; }
  84
  85   /// isNullValue - Return true if this is the value that would be returned by
  86   /// getNullValue.
  87   ///
  88   virtual bool isNullValue() const { return this == False; }
  89   virtual bool isMaxValue() const { return this == True; }
  90   virtual bool isMinValue() const { return this == False; }
  91   virtual bool isAllOnesValue() const { return this == True; }
  92
  93   /// Methods for support type inquiry through isa, cast, and dyn_cast:
  94   static inline bool classof(const ConstantBool *) { return true; }
  95   static bool classof(const Constant *CPV) {
  96     return (CPV == True) | (CPV == False);
  97   }
  98   static inline bool classof(const Value *V) {
  99     return isa<Constant>(V) && classof(cast<Constant>(V));
 100   }
 101 };
 102
 103
 104 //===---------------------------------------------------------------------------
 105 /// ConstantInt - Superclass of ConstantSInt & ConstantUInt, to make dealing
 106 /// with integral constants easier.
 107 ///
 108 class ConstantInt : public ConstantIntegral {
 109 protected:
 110   union {
 111     int64_t  Signed;
 112     uint64_t Unsigned;
 113   } Val;
 114   ConstantInt(const ConstantInt &);      // DO NOT IMPLEMENT
 115   ConstantInt(const Type *Ty, uint64_t V);
 116   ~ConstantInt() {}
 117 public:
 118   /// equalsInt - Provide a helper method that can be used to determine if the
 119   /// constant contained within is equal to a constant.  This only works for
 120   /// very small values, because this is all that can be represented with all
 121   /// types.
 122   ///
 123   bool equalsInt(unsigned char V) const {
 124     assert(V <= 127 &&
 125            "equals: Can only be used with very small positive constants!");
 126     return Val.Unsigned == V;
 127   }
 128
 129   /// ConstantInt::get static method: return a ConstantInt with the specified
 130   /// value.  as above, we work only with very small values here.
 131   ///
 132   static ConstantInt *get(const Type *Ty, unsigned char V);
 133
 134   /// isNullValue - Return true if this is the value that would be returned by
 135   /// getNullValue.
 136   virtual bool isNullValue() const { return Val.Unsigned == 0; }
 137   virtual bool isAllOnesValue() const { return Val.Signed == -1; }
 138   virtual bool isMaxValue() const = 0;
 139   virtual bool isMinValue() const = 0;
 140
 141   /// Methods for support type inquiry through isa, cast, and dyn_cast:
 142   static inline bool classof(const ConstantInt *) { return true; }
 143   static bool classof(const Constant *CPV);  // defined in Constants.cpp
 144   static inline bool classof(const Value *V) {
 145     return isa<Constant>(V) && classof(cast<Constant>(V));
 146   }
 147 };
 148
 149
 150 //===---------------------------------------------------------------------------
 151 /// ConstantSInt - Signed Integer Values [sbyte, short, int, long]
 152 ///
 153 class ConstantSInt : public ConstantInt {
 154   ConstantSInt(const ConstantSInt &);      // DO NOT IMPLEMENT
 155 protected:
 156   ConstantSInt(const Type *Ty, int64_t V);
 157   ~ConstantSInt() {}
 158 public:
 159   /// get() - Static factory methods - Return objects of the specified value
 160   static ConstantSInt *get(const Type *Ty, int64_t V);
 161
 162   /// isValueValidForType - return true if Ty is big enough to represent V.
 163   static bool isValueValidForType(const Type *Ty, int64_t V);
 164
 165   /// getValue - return the underlying value of this constant.
 166   inline int64_t getValue() const { return Val.Signed; }
 167
 168   /// isMaxValue - Return true if this is the largest value that may be
 169   /// represented by this type.
 170   ///
 171   virtual bool isMaxValue() const {
 172     int64_t V = getValue();
 173     if (V < 0) return false;    // Be careful about wrap-around on 'long's
 174     ++V;
 175     return !isValueValidForType(getType(), V) || V < 0;
 176   }
 177
 178   /// isMinValue - Return true if this is the smallest value that may be
 179   /// represented by this type.
 180   ///
 181   virtual bool isMinValue() const {
 182     int64_t V = getValue();
 183     if (V > 0) return false;    // Be careful about wrap-around on 'long's
 184     --V;
 185     return !isValueValidForType(getType(), V) || V > 0;
 186   }
 187
 188   /// Methods for support type inquiry through isa, cast, and dyn_cast:
 189   static inline bool classof(const ConstantSInt *) { return true; }
 190   static bool classof(const Constant *CPV);  // defined in Constants.cpp
 191   static inline bool classof(const Value *V) {
 192     return isa<Constant>(V) && classof(cast<Constant>(V));
 193   }
 194 };
 195
 196 //===---------------------------------------------------------------------------
 197 /// ConstantUInt - Unsigned Integer Values [ubyte, ushort, uint, ulong]
 198 ///
 199 class ConstantUInt : public ConstantInt {
 200   ConstantUInt(const ConstantUInt &);      // DO NOT IMPLEMENT
 201 protected:
 202   ConstantUInt(const Type *Ty, uint64_t V);
 203   ~ConstantUInt() {}
 204 public:
 205   /// get() - Static factory methods - Return objects of the specified value
 206   static ConstantUInt *get(const Type *Ty, uint64_t V);
 207
 208   /// isValueValidForType - return true if Ty is big enough to represent V.
 209   static bool isValueValidForType(const Type *Ty, uint64_t V);
 210
 211   /// getValue - return the underlying value of this constant.
 212   inline uint64_t getValue() const { return Val.Unsigned; }
 213
 214   /// isMaxValue - Return true if this is the largest value that may be
 215   /// represented by this type.
 216   ///
 217   virtual bool isMaxValue() const { return isAllOnesValue(); }
 218   virtual bool isMinValue() const { return getValue() == 0; }
 219
 220   /// Methods for support type inquiry through isa, cast, and dyn_cast:
 221   static inline bool classof(const ConstantUInt *) { return true; }
 222   static bool classof(const Constant *CPV);  // defined in Constants.cpp
 223   static inline bool classof(const Value *V) {
 224     return isa<Constant>(V) && classof(cast<Constant>(V));
 225   }
 226 };
 227
 228
 229 //===---------------------------------------------------------------------------
 230 /// ConstantFP - Floating Point Values [float, double]
 231 ///
 232 class ConstantFP : public Constant {
 233   double Val;
 234   ConstantFP(const ConstantFP &);      // DO NOT IMPLEMENT
 235 protected:
 236   ConstantFP(const Type *Ty, double V);
 237   ~ConstantFP() {}
 238 public:
 239   /// get() - Static factory methods - Return objects of the specified value
 240   static ConstantFP *get(const Type *Ty, double V);
 241
 242   /// isValueValidForType - return true if Ty is big enough to represent V.
 243   static bool isValueValidForType(const Type *Ty, double V);
 244   inline double getValue() const { return Val; }
 245
 246   /// isNullValue - Return true if this is the value that would be returned by
 247   /// getNullValue.
 248   virtual bool isNullValue() const { return Val == 0; }
 249
 250   /// Methods for support type inquiry through isa, cast, and dyn_cast:
 251   static inline bool classof(const ConstantFP *) { return true; }
 252   static bool classof(const Constant *CPV);  // defined in Constants.cpp
 253   static inline bool classof(const Value *V) {
 254     return isa<Constant>(V) && classof(cast<Constant>(V));
 255   }
 256 };
 257
 258
 259 //===---------------------------------------------------------------------------
 260 /// ConstantArray - Constant Array Declarations
 261 ///
 262 class ConstantArray : public Constant {
 263   ConstantArray(const ConstantArray &);      // DO NOT IMPLEMENT
 264 protected:
 265   ConstantArray(const ArrayType *T, const std::vector<Constant*> &Val);
 266   ~ConstantArray() {}
 267
 268 public:
 269   /// get() - Static factory methods - Return objects of the specified value
 270   static ConstantArray *get(const ArrayType *T, const std::vector<Constant*> &);
 271   static ConstantArray *get(const std::string &Initializer);
 272
 273   /// getType - Specialize the getType() method to always return an ArrayType,
 274   /// which reduces the amount of casting needed in parts of the compiler.
 275   ///
 276   inline const ArrayType *getType() const {
 277     return (ArrayType*)Value::getType();
 278   }
 279
 280   /// getAsString - If the sub-element type of this array is either sbyte or
 281   /// ubyte, then this method converts the array to an std::string and returns
 282   /// it.  Otherwise, it asserts out.
 283   ///
 284   std::string getAsString() const;
 285
 286   /// getValues - Return a vector of the component constants that make up this
 287   /// array.
 288   inline const std::vector<Use> &getValues() const { return Operands; }
 289
 290   /// isNullValue - Return true if this is the value that would be returned by
 291   /// getNullValue.
 292   virtual bool isNullValue() const { return false; }
 293
 294   virtual void destroyConstant();
 295   virtual void replaceUsesOfWithOnConstant(Value *From, Value *To);
 296
 297   /// Methods for support type inquiry through isa, cast, and dyn_cast:
 298   static inline bool classof(const ConstantArray *) { return true; }
 299   static bool classof(const Constant *CPV);  // defined in Constants.cpp
 300   static inline bool classof(const Value *V) {
 301     return isa<Constant>(V) && classof(cast<Constant>(V));
 302   }
 303 };
 304
 305
 306 //===---------------------------------------------------------------------------
 307 // ConstantStruct - Constant Struct Declarations
 308 //
 309 class ConstantStruct : public Constant {
 310   ConstantStruct(const ConstantStruct &);      // DO NOT IMPLEMENT
 311 protected:
 312   ConstantStruct(const StructType *T, const std::vector<Constant*> &Val);
 313   ~ConstantStruct() {}
 314
 315 public:
 316   /// get() - Static factory methods - Return objects of the specified value
 317   static ConstantStruct *get(const StructType *T,
 318                              const std::vector<Constant*> &V);
 319
 320   /// getType() specialization - Reduce amount of casting...
 321   inline const StructType *getType() const {
 322     return (StructType*)Value::getType();
 323   }
 324
 325   /// getValues - Return a vector of the component constants that make up this
 326   /// structure.
 327   inline const std::vector<Use> &getValues() const { return Operands; }
 328
 329   /// isNullValue - Return true if this is the value that would be returned by
 330   /// getNullValue.
 331   virtual bool isNullValue() const { return false; }
 332
 333   virtual void destroyConstant();
 334   virtual void replaceUsesOfWithOnConstant(Value *From, Value *To);
 335
 336   /// Methods for support type inquiry through isa, cast, and dyn_cast:
 337   static inline bool classof(const ConstantStruct *) { return true; }
 338   static bool classof(const Constant *CPV);  // defined in Constants.cpp
 339   static inline bool classof(const Value *V) {
 340     return isa<Constant>(V) && classof(cast<Constant>(V));
 341   }
 342 };
 343
 344 //===---------------------------------------------------------------------------
 345 /// ConstantPointer - Constant Pointer Declarations
 346 ///
 347 /// The ConstantPointer class represents a null pointer of a specific type. For
 348 /// a more specific/useful instance, a subclass of ConstantPointer should be
 349 /// used.
 350 ///
 351 class ConstantPointer : public Constant {
 352   ConstantPointer(const ConstantPointer &);      // DO NOT IMPLEMENT
 353 protected:
 354   inline ConstantPointer(const PointerType *T) : Constant((const Type*)T){}
 355   ~ConstantPointer() {}
 356 public:
 357   inline const PointerType *getType() const {
 358     return (PointerType*)Value::getType();
 359   }
 360
 361   /// isNullValue - Return true if this is the value that would be returned by
 362   /// getNullValue.
 363   virtual bool isNullValue() const { return false; }
 364
 365   /// Methods for support type inquiry through isa, cast, and dyn_cast:
 366   static inline bool classof(const ConstantPointer *) { return true; }
 367   static bool classof(const Constant *CPV);  // defined in Constants.cpp
 368   static inline bool classof(const Value *V) {
 369     return isa<Constant>(V) && classof(cast<Constant>(V));
 370   }
 371 };
 372
 373 /// ConstantPointerNull - a constant pointer value that points to null
 374 ///
 375 class ConstantPointerNull : public ConstantPointer {
 376   ConstantPointerNull(const ConstantPointerNull &);      // DO NOT IMPLEMENT
 377 protected:
 378   inline ConstantPointerNull(const PointerType *T) : ConstantPointer(T) {}
 379   inline ~ConstantPointerNull() {}
 380 public:
 381
 382   /// get() - Static factory methods - Return objects of the specified value
 383   static ConstantPointerNull *get(const PointerType *T);
 384
 385   /// isNullValue - Return true if this is the value that would be returned by
 386   /// getNullValue.
 387   virtual bool isNullValue() const { return true; }
 388
 389   virtual void destroyConstant();
 390
 391   /// Methods for support type inquiry through isa, cast, and dyn_cast:
 392   static inline bool classof(const ConstantPointerNull *) { return true; }
 393   static inline bool classof(const ConstantPointer *P) {
 394     return (P->getNumOperands() == 0 && P->isNullValue());
 395   }
 396   static inline bool classof(const Constant *CPV) {
 397     return isa<ConstantPointer>(CPV) && classof(cast<ConstantPointer>(CPV));
 398   }
 399   static inline bool classof(const Value *V) {
 400     return isa<ConstantPointer>(V) && classof(cast<ConstantPointer>(V));
 401   }
 402 };
 403
 404
 405 /// ConstantPointerRef - a constant pointer value that is initialized to
 406 /// point to a global value, which lies at a constant, fixed address.
 407 ///
 408 class ConstantPointerRef : public ConstantPointer {
 409   friend class Module;   // Modules maintain these references
 410   ConstantPointerRef(const ConstantPointerRef &); // DNI!
 411
 412 protected:
 413   ConstantPointerRef(GlobalValue *GV);
 414   ~ConstantPointerRef() {}
 415 public:
 416   /// get() - Static factory methods - Return objects of the specified value
 417   static ConstantPointerRef *get(GlobalValue *GV);
 418
 419   const GlobalValue *getValue() const {
 420     return cast<GlobalValue>(Operands[0].get());
 421   }
 422
 423   GlobalValue *getValue() {
 424     return cast<GlobalValue>(Operands[0].get());
 425   }
 426
 427   virtual void destroyConstant();
 428   virtual void replaceUsesOfWithOnConstant(Value *From, Value *To);
 429
 430   /// Methods for support type inquiry through isa, cast, and dyn_cast:
 431   static inline bool classof(const ConstantPointerRef *) { return true; }
 432   static inline bool classof(const ConstantPointer *CPV) {
 433     // check for a single operand (the target value)
 434     return (CPV->getNumOperands() == 1);
 435   }
 436   static inline bool classof(const Constant *CPV) {
 437     return isa<ConstantPointer>(CPV) && classof(cast<ConstantPointer>(CPV));
 438   }
 439   static inline bool classof(const Value *V) {
 440     return isa<ConstantPointer>(V) && classof(cast<ConstantPointer>(V));
 441   }
 442
 443   // WARNING: Only to be used by Bytecode & Assembly Parsers!  USER CODE SHOULD
 444   // NOT USE THIS!!
 445   // Returns the number of uses of OldV that were replaced.
 446   virtual unsigned mutateReferences(Value* OldV, Value *NewV);
 447   // END WARNING!!
 448 };
 449
 450
 451 // ConstantExpr - a constant value that is initialized with
 452 // an expression using other constant values.  This is only used
 453 // to represent values that cannot be evaluated at compile-time
 454 // (e.g., something derived from an address) because it does
 455 // not have a mechanism to store the actual value.
 456 // Use the appropriate Constant subclass above for known constants.
 457 //
 458 class ConstantExpr : public Constant {
 459   unsigned iType;      // Operation type
 460
 461 protected:
 462   ConstantExpr(unsigned Opcode, Constant *C,  const Type *Ty);
 463   ConstantExpr(unsigned Opcode, Constant *C1, Constant *C2);
 464   ConstantExpr(Constant *C, const std::vector<Constant*> &IdxList,
 465                const Type *DestTy);
 466   ~ConstantExpr() {}
 467
 468 public:
 469   // Static methods to construct a ConstantExpr of different kinds.
 470
 471   /// Cast constant expr
 472   static ConstantExpr *getCast(Constant *C, const Type *Ty);
 473
 474   /// Binary constant expr - Use with binary operators...
 475   static ConstantExpr *get(unsigned Opcode, Constant *C1, Constant *C2);
 476
 477   /// Getelementptr form...
 478   static ConstantExpr *getGetElementPtr(Constant *C,
 479                                         const std::vector<Constant*> &IdxList);
 480
 481   /// isNullValue - Return true if this is the value that would be returned by
 482   /// getNullValue.
 483   virtual bool isNullValue() const { return false; }
 484
 485   /// getOpcode - Return the opcode at the root of this constant expression
 486   unsigned getOpcode() const { return iType; }
 487
 488   /// getOpcodeName - Return a string representation for an opcode.
 489   const char *getOpcodeName() const;
 490
 491   /// isConstantExpr - Return true if this is a ConstantExpr
 492   virtual bool isConstantExpr() const { return true; }
 493
 494   virtual void destroyConstant();
 495   virtual void replaceUsesOfWithOnConstant(Value *From, Value *To);
 496
 497   /// Methods for support type inquiry through isa, cast, and dyn_cast:
 498   static inline bool classof(const ConstantExpr *) { return true; }
 499   static inline bool classof(const Constant *CPV) {
 500     return CPV->isConstantExpr();
 501   }
 502   static inline bool classof(const Value *V) {
 503     return isa<Constant>(V) && classof(cast<Constant>(V));
 504   }
 505
 506 public:
 507   // WARNING: Only to be used by Bytecode & Assembly Parsers!  USER CODE SHOULD
 508   // NOT USE THIS!!
 509   // Returns the number of uses of OldV that were replaced.
 510   virtual unsigned mutateReferences(Value* OldV, Value *NewV);
 511   // END WARNING!!
 512 };
 513
 514
 515 #endif