include/llvm/Operator.h

   1 //===-- llvm/Operator.h - Operator utility subclass -------------*- 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 // This file defines various classes for working with Instructions and
  11 // ConstantExprs.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_OPERATOR_H
  16 #define LLVM_OPERATOR_H
  17
  18 #include "llvm/Constants.h"
  19 #include "llvm/DerivedTypes.h"
  20 #include "llvm/Instruction.h"
  21 #include "llvm/Type.h"
  22
  23 namespace llvm {
  24
  25 class GetElementPtrInst;
  26 class BinaryOperator;
  27 class ConstantExpr;
  28
  29 /// Operator - This is a utility class that provides an abstraction for the
  30 /// common functionality between Instructions and ConstantExprs.
  31 ///
  32 class Operator : public User {
  33 private:
  34   // Do not implement any of these. The Operator class is intended to be used
  35   // as a utility, and is never itself instantiated.
  36   void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
  37   void *operator new(size_t s) LLVM_DELETED_FUNCTION;
  38   Operator() LLVM_DELETED_FUNCTION;
  39
  40 protected:
  41   // NOTE: Cannot use LLVM_DELETED_FUNCTION because it's not legal to delete
  42   // an overridden method that's not deleted in the base class. Cannot leave
  43   // this unimplemented because that leads to an ODR-violation.
  44   ~Operator();
  45
  46 public:
  47   /// getOpcode - Return the opcode for this Instruction or ConstantExpr.
  48   ///
  49   unsigned getOpcode() const {
  50     if (const Instruction *I = dyn_cast<Instruction>(this))
  51       return I->getOpcode();
  52     return cast<ConstantExpr>(this)->getOpcode();
  53   }
  54
  55   /// getOpcode - If V is an Instruction or ConstantExpr, return its
  56   /// opcode. Otherwise return UserOp1.
  57   ///
  58   static unsigned getOpcode(const Value *V) {
  59     if (const Instruction *I = dyn_cast<Instruction>(V))
  60       return I->getOpcode();
  61     if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
  62       return CE->getOpcode();
  63     return Instruction::UserOp1;
  64   }
  65
  66   static inline bool classof(const Instruction *) { return true; }
  67   static inline bool classof(const ConstantExpr *) { return true; }
  68   static inline bool classof(const Value *V) {
  69     return isa<Instruction>(V) || isa<ConstantExpr>(V);
  70   }
  71 };
  72
  73 /// OverflowingBinaryOperator - Utility class for integer arithmetic operators
  74 /// which may exhibit overflow - Add, Sub, and Mul. It does not include SDiv,
  75 /// despite that operator having the potential for overflow.
  76 ///
  77 class OverflowingBinaryOperator : public Operator {
  78 public:
  79   enum {
  80     NoUnsignedWrap = (1 << 0),
  81     NoSignedWrap   = (1 << 1)
  82   };
  83
  84 private:
  85   friend class BinaryOperator;
  86   friend class ConstantExpr;
  87   void setHasNoUnsignedWrap(bool B) {
  88     SubclassOptionalData =
  89       (SubclassOptionalData & ~NoUnsignedWrap) | (B * NoUnsignedWrap);
  90   }
  91   void setHasNoSignedWrap(bool B) {
  92     SubclassOptionalData =
  93       (SubclassOptionalData & ~NoSignedWrap) | (B * NoSignedWrap);
  94   }
  95
  96 public:
  97   /// hasNoUnsignedWrap - Test whether this operation is known to never
  98   /// undergo unsigned overflow, aka the nuw property.
  99   bool hasNoUnsignedWrap() const {
 100     return SubclassOptionalData & NoUnsignedWrap;
 101   }
 102
 103   /// hasNoSignedWrap - Test whether this operation is known to never
 104   /// undergo signed overflow, aka the nsw property.
 105   bool hasNoSignedWrap() const {
 106     return (SubclassOptionalData & NoSignedWrap) != 0;
 107   }
 108
 109   static inline bool classof(const Instruction *I) {
 110     return I->getOpcode() == Instruction::Add ||
 111            I->getOpcode() == Instruction::Sub ||
 112            I->getOpcode() == Instruction::Mul ||
 113            I->getOpcode() == Instruction::Shl;
 114   }
 115   static inline bool classof(const ConstantExpr *CE) {
 116     return CE->getOpcode() == Instruction::Add ||
 117            CE->getOpcode() == Instruction::Sub ||
 118            CE->getOpcode() == Instruction::Mul ||
 119            CE->getOpcode() == Instruction::Shl;
 120   }
 121   static inline bool classof(const Value *V) {
 122     return (isa<Instruction>(V) && classof(cast<Instruction>(V))) ||
 123            (isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V)));
 124   }
 125 };
 126
 127 /// PossiblyExactOperator - A udiv or sdiv instruction, which can be marked as
 128 /// "exact", indicating that no bits are destroyed.
 129 class PossiblyExactOperator : public Operator {
 130 public:
 131   enum {
 132     IsExact = (1 << 0)
 133   };
 134
 135 private:
 136   friend class BinaryOperator;
 137   friend class ConstantExpr;
 138   void setIsExact(bool B) {
 139     SubclassOptionalData = (SubclassOptionalData & ~IsExact) | (B * IsExact);
 140   }
 141
 142 public:
 143   /// isExact - Test whether this division is known to be exact, with
 144   /// zero remainder.
 145   bool isExact() const {
 146     return SubclassOptionalData & IsExact;
 147   }
 148
 149   static bool isPossiblyExactOpcode(unsigned OpC) {
 150     return OpC == Instruction::SDiv ||
 151            OpC == Instruction::UDiv ||
 152            OpC == Instruction::AShr ||
 153            OpC == Instruction::LShr;
 154   }
 155   static inline bool classof(const ConstantExpr *CE) {
 156     return isPossiblyExactOpcode(CE->getOpcode());
 157   }
 158   static inline bool classof(const Instruction *I) {
 159     return isPossiblyExactOpcode(I->getOpcode());
 160   }
 161   static inline bool classof(const Value *V) {
 162     return (isa<Instruction>(V) && classof(cast<Instruction>(V))) ||
 163            (isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V)));
 164   }
 165 };
 166
 167 /// Convenience struct for specifying and reasoning about fast-math flags.
 168 struct FastMathFlags {
 169   bool UnsafeAlgebra   : 1;
 170   bool NoNaNs          : 1;
 171   bool NoInfs          : 1;
 172   bool NoSignedZeros   : 1;
 173   bool AllowReciprocal : 1;
 174
 175   FastMathFlags() : UnsafeAlgebra(false), NoNaNs(false), NoInfs(false),
 176                     NoSignedZeros(false), AllowReciprocal(false)
 177   { }
 178
 179   bool any() {
 180     return UnsafeAlgebra || NoNaNs || NoInfs || NoSignedZeros ||
 181       AllowReciprocal;
 182   }
 183 };
 184
 185
 186 /// FPMathOperator - Utility class for floating point operations which can have
 187 /// information about relaxed accuracy requirements attached to them.
 188 class FPMathOperator : public Operator {
 189 public:
 190   enum {
 191     UnsafeAlgebra   = (1 << 0),
 192     NoNaNs          = (1 << 1),
 193     NoInfs          = (1 << 2),
 194     NoSignedZeros   = (1 << 3),
 195     AllowReciprocal = (1 << 4)
 196   };
 197
 198 private:
 199   friend class Instruction;
 200
 201   void setHasUnsafeAlgebra(bool B) {
 202     SubclassOptionalData =
 203       (SubclassOptionalData & ~UnsafeAlgebra) | (B * UnsafeAlgebra);
 204
 205     // Unsafe algebra implies all the others
 206     if (B) {
 207       setHasNoNaNs(true);
 208       setHasNoInfs(true);
 209       setHasNoSignedZeros(true);
 210       setHasAllowReciprocal(true);
 211     }
 212   }
 213   void setHasNoNaNs(bool B) {
 214     SubclassOptionalData =
 215       (SubclassOptionalData & ~NoNaNs) | (B * NoNaNs);
 216   }
 217   void setHasNoInfs(bool B) {
 218     SubclassOptionalData =
 219       (SubclassOptionalData & ~NoInfs) | (B * NoInfs);
 220   }
 221   void setHasNoSignedZeros(bool B) {
 222     SubclassOptionalData =
 223       (SubclassOptionalData & ~NoSignedZeros) | (B * NoSignedZeros);
 224   }
 225   void setHasAllowReciprocal(bool B) {
 226     SubclassOptionalData =
 227       (SubclassOptionalData & ~AllowReciprocal) | (B * AllowReciprocal);
 228   }
 229
 230   /// Convenience function for setting all the fast-math flags
 231   void setFastMathFlags(FastMathFlags FMF) {
 232     if (FMF.UnsafeAlgebra) {
 233       // Set all the bits to true
 234       setHasUnsafeAlgebra(true);
 235       return;
 236     }
 237
 238     setHasUnsafeAlgebra(FMF.UnsafeAlgebra);
 239     setHasNoNaNs(FMF.NoNaNs);
 240     setHasNoInfs(FMF.NoInfs);
 241     setHasNoSignedZeros(FMF.NoSignedZeros);
 242     setHasAllowReciprocal(FMF.AllowReciprocal);
 243   }
 244
 245 public:
 246   /// Test whether this operation is permitted to be
 247   /// algebraically transformed, aka the 'A' fast-math property.
 248   bool hasUnsafeAlgebra() const {
 249     return (SubclassOptionalData & UnsafeAlgebra) != 0;
 250   }
 251
 252   /// Test whether this operation's arguments and results are to be
 253   /// treated as non-NaN, aka the 'N' fast-math property.
 254   bool hasNoNaNs() const {
 255     return (SubclassOptionalData & NoNaNs) != 0;
 256   }
 257
 258   /// Test whether this operation's arguments and results are to be
 259   /// treated as NoN-Inf, aka the 'I' fast-math property.
 260   bool hasNoInfs() const {
 261     return (SubclassOptionalData & NoInfs) != 0;
 262   }
 263
 264   /// Test whether this operation can treat the sign of zero
 265   /// as insignificant, aka the 'S' fast-math property.
 266   bool hasNoSignedZeros() const {
 267     return (SubclassOptionalData & NoSignedZeros) != 0;
 268   }
 269
 270   /// Test whether this operation is permitted to use
 271   /// reciprocal instead of division, aka the 'R' fast-math property.
 272   bool hasAllowReciprocal() const {
 273     return (SubclassOptionalData & AllowReciprocal) != 0;
 274   }
 275
 276   /// Convenience function for getting all the fast-math flags
 277   FastMathFlags getFastMathFlags() const {
 278     FastMathFlags FMF;
 279     FMF.UnsafeAlgebra   = hasUnsafeAlgebra();
 280     FMF.NoNaNs          = hasNoNaNs();
 281     FMF.NoInfs          = hasNoInfs();
 282     FMF.NoSignedZeros   = hasNoSignedZeros();
 283     FMF.AllowReciprocal = hasAllowReciprocal();
 284     return FMF;
 285   }
 286
 287
 288   /// \brief Get the maximum error permitted by this operation in ULPs.  An
 289   /// accuracy of 0.0 means that the operation should be performed with the
 290   /// default precision.
 291   float getFPAccuracy() const;
 292
 293   static inline bool classof(const Instruction *I) {
 294     return I->getType()->isFPOrFPVectorTy();
 295   }
 296   static inline bool classof(const Value *V) {
 297     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 298   }
 299 };
 300
 301
 302 /// ConcreteOperator - A helper template for defining operators for individual
 303 /// opcodes.
 304 template<typename SuperClass, unsigned Opc>
 305 class ConcreteOperator : public SuperClass {
 306 public:
 307   static inline bool classof(const Instruction *I) {
 308     return I->getOpcode() == Opc;
 309   }
 310   static inline bool classof(const ConstantExpr *CE) {
 311     return CE->getOpcode() == Opc;
 312   }
 313   static inline bool classof(const Value *V) {
 314     return (isa<Instruction>(V) && classof(cast<Instruction>(V))) ||
 315            (isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V)));
 316   }
 317 };
 318
 319 class AddOperator
 320   : public ConcreteOperator<OverflowingBinaryOperator, Instruction::Add> {
 321 };
 322 class SubOperator
 323   : public ConcreteOperator<OverflowingBinaryOperator, Instruction::Sub> {
 324 };
 325 class MulOperator
 326   : public ConcreteOperator<OverflowingBinaryOperator, Instruction::Mul> {
 327 };
 328 class ShlOperator
 329   : public ConcreteOperator<OverflowingBinaryOperator, Instruction::Shl> {
 330 };
 331
 332
 333 class SDivOperator
 334   : public ConcreteOperator<PossiblyExactOperator, Instruction::SDiv> {
 335 };
 336 class UDivOperator
 337   : public ConcreteOperator<PossiblyExactOperator, Instruction::UDiv> {
 338 };
 339 class AShrOperator
 340   : public ConcreteOperator<PossiblyExactOperator, Instruction::AShr> {
 341 };
 342 class LShrOperator
 343   : public ConcreteOperator<PossiblyExactOperator, Instruction::LShr> {
 344 };
 345
 346
 347
 348 class GEPOperator
 349   : public ConcreteOperator<Operator, Instruction::GetElementPtr> {
 350   enum {
 351     IsInBounds = (1 << 0)
 352   };
 353
 354   friend class GetElementPtrInst;
 355   friend class ConstantExpr;
 356   void setIsInBounds(bool B) {
 357     SubclassOptionalData =
 358       (SubclassOptionalData & ~IsInBounds) | (B * IsInBounds);
 359   }
 360
 361 public:
 362   /// isInBounds - Test whether this is an inbounds GEP, as defined
 363   /// by LangRef.html.
 364   bool isInBounds() const {
 365     return SubclassOptionalData & IsInBounds;
 366   }
 367
 368   inline op_iterator       idx_begin()       { return op_begin()+1; }
 369   inline const_op_iterator idx_begin() const { return op_begin()+1; }
 370   inline op_iterator       idx_end()         { return op_end(); }
 371   inline const_op_iterator idx_end()   const { return op_end(); }
 372
 373   Value *getPointerOperand() {
 374     return getOperand(0);
 375   }
 376   const Value *getPointerOperand() const {
 377     return getOperand(0);
 378   }
 379   static unsigned getPointerOperandIndex() {
 380     return 0U;                      // get index for modifying correct operand
 381   }
 382
 383   /// getPointerOperandType - Method to return the pointer operand as a
 384   /// PointerType.
 385   Type *getPointerOperandType() const {
 386     return getPointerOperand()->getType();
 387   }
 388
 389   /// getPointerAddressSpace - Method to return the address space of the
 390   /// pointer operand.
 391   unsigned getPointerAddressSpace() const {
 392     return cast<PointerType>(getPointerOperandType())->getAddressSpace();
 393   }
 394
 395   unsigned getNumIndices() const {  // Note: always non-negative
 396     return getNumOperands() - 1;
 397   }
 398
 399   bool hasIndices() const {
 400     return getNumOperands() > 1;
 401   }
 402
 403   /// hasAllZeroIndices - Return true if all of the indices of this GEP are
 404   /// zeros.  If so, the result pointer and the first operand have the same
 405   /// value, just potentially different types.
 406   bool hasAllZeroIndices() const {
 407     for (const_op_iterator I = idx_begin(), E = idx_end(); I != E; ++I) {
 408       if (ConstantInt *C = dyn_cast<ConstantInt>(I))
 409         if (C->isZero())
 410           continue;
 411       return false;
 412     }
 413     return true;
 414   }
 415
 416   /// hasAllConstantIndices - Return true if all of the indices of this GEP are
 417   /// constant integers.  If so, the result pointer and the first operand have
 418   /// a constant offset between them.
 419   bool hasAllConstantIndices() const {
 420     for (const_op_iterator I = idx_begin(), E = idx_end(); I != E; ++I) {
 421       if (!isa<ConstantInt>(I))
 422         return false;
 423     }
 424     return true;
 425   }
 426 };
 427
 428 } // End llvm namespace
 429
 430 #endif