contrib/llvm/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 /// FPMathOperator - Utility class for floating point operations which can have
 168 /// information about relaxed accuracy requirements attached to them.
 169 class FPMathOperator : public Operator {
 170 public:
 171
 172   /// \brief Get the maximum error permitted by this operation in ULPs.  An
 173   /// accuracy of 0.0 means that the operation should be performed with the
 174   /// default precision.
 175   float getFPAccuracy() const;
 176
 177   static inline bool classof(const Instruction *I) {
 178     return I->getType()->isFPOrFPVectorTy();
 179   }
 180   static inline bool classof(const Value *V) {
 181     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 182   }
 183 };
 184
 185
 186 /// ConcreteOperator - A helper template for defining operators for individual
 187 /// opcodes.
 188 template<typename SuperClass, unsigned Opc>
 189 class ConcreteOperator : public SuperClass {
 190 public:
 191   static inline bool classof(const Instruction *I) {
 192     return I->getOpcode() == Opc;
 193   }
 194   static inline bool classof(const ConstantExpr *CE) {
 195     return CE->getOpcode() == Opc;
 196   }
 197   static inline bool classof(const Value *V) {
 198     return (isa<Instruction>(V) && classof(cast<Instruction>(V))) ||
 199            (isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V)));
 200   }
 201 };
 202
 203 class AddOperator
 204   : public ConcreteOperator<OverflowingBinaryOperator, Instruction::Add> {
 205 };
 206 class SubOperator
 207   : public ConcreteOperator<OverflowingBinaryOperator, Instruction::Sub> {
 208 };
 209 class MulOperator
 210   : public ConcreteOperator<OverflowingBinaryOperator, Instruction::Mul> {
 211 };
 212 class ShlOperator
 213   : public ConcreteOperator<OverflowingBinaryOperator, Instruction::Shl> {
 214 };
 215
 216
 217 class SDivOperator
 218   : public ConcreteOperator<PossiblyExactOperator, Instruction::SDiv> {
 219 };
 220 class UDivOperator
 221   : public ConcreteOperator<PossiblyExactOperator, Instruction::UDiv> {
 222 };
 223 class AShrOperator
 224   : public ConcreteOperator<PossiblyExactOperator, Instruction::AShr> {
 225 };
 226 class LShrOperator
 227   : public ConcreteOperator<PossiblyExactOperator, Instruction::LShr> {
 228 };
 229
 230
 231
 232 class GEPOperator
 233   : public ConcreteOperator<Operator, Instruction::GetElementPtr> {
 234   enum {
 235     IsInBounds = (1 << 0)
 236   };
 237
 238   friend class GetElementPtrInst;
 239   friend class ConstantExpr;
 240   void setIsInBounds(bool B) {
 241     SubclassOptionalData =
 242       (SubclassOptionalData & ~IsInBounds) | (B * IsInBounds);
 243   }
 244
 245 public:
 246   /// isInBounds - Test whether this is an inbounds GEP, as defined
 247   /// by LangRef.html.
 248   bool isInBounds() const {
 249     return SubclassOptionalData & IsInBounds;
 250   }
 251
 252   inline op_iterator       idx_begin()       { return op_begin()+1; }
 253   inline const_op_iterator idx_begin() const { return op_begin()+1; }
 254   inline op_iterator       idx_end()         { return op_end(); }
 255   inline const_op_iterator idx_end()   const { return op_end(); }
 256
 257   Value *getPointerOperand() {
 258     return getOperand(0);
 259   }
 260   const Value *getPointerOperand() const {
 261     return getOperand(0);
 262   }
 263   static unsigned getPointerOperandIndex() {
 264     return 0U;                      // get index for modifying correct operand
 265   }
 266
 267   /// getPointerOperandType - Method to return the pointer operand as a
 268   /// PointerType.
 269   Type *getPointerOperandType() const {
 270     return getPointerOperand()->getType();
 271   }
 272
 273   /// getPointerAddressSpace - Method to return the address space of the
 274   /// pointer operand.
 275   unsigned getPointerAddressSpace() const {
 276     return cast<PointerType>(getPointerOperandType())->getAddressSpace();
 277   }
 278
 279   unsigned getNumIndices() const {  // Note: always non-negative
 280     return getNumOperands() - 1;
 281   }
 282
 283   bool hasIndices() const {
 284     return getNumOperands() > 1;
 285   }
 286
 287   /// hasAllZeroIndices - Return true if all of the indices of this GEP are
 288   /// zeros.  If so, the result pointer and the first operand have the same
 289   /// value, just potentially different types.
 290   bool hasAllZeroIndices() const {
 291     for (const_op_iterator I = idx_begin(), E = idx_end(); I != E; ++I) {
 292       if (ConstantInt *C = dyn_cast<ConstantInt>(I))
 293         if (C->isZero())
 294           continue;
 295       return false;
 296     }
 297     return true;
 298   }
 299
 300   /// hasAllConstantIndices - Return true if all of the indices of this GEP are
 301   /// constant integers.  If so, the result pointer and the first operand have
 302   /// a constant offset between them.
 303   bool hasAllConstantIndices() const {
 304     for (const_op_iterator I = idx_begin(), E = idx_end(); I != E; ++I) {
 305       if (!isa<ConstantInt>(I))
 306         return false;
 307     }
 308     return true;
 309   }
 310 };
 311
 312 } // End llvm namespace
 313
 314 #endif