include/llvm/IntrinsicInst.h

   1 //===-- llvm/IntrinsicInst.h - Intrinsic Instruction Wrappers ---*- 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 classes that make it really easy to deal with intrinsic
  11 // functions with the isa/dyncast family of functions.  In particular, this
  12 // allows you to do things like:
  13 //
  14 //     if (MemCpyInst *MCI = dyn_cast<MemCpyInst>(Inst))
  15 //        ... MCI->getDest() ... MCI->getSource() ...
  16 //
  17 // All intrinsic function calls are instances of the call instruction, so these
  18 // are all subclasses of the CallInst class.  Note that none of these classes
  19 // has state or virtual methods, which is an important part of this gross/neat
  20 // hack working.
  21 //
  22 //===----------------------------------------------------------------------===//
  23
  24 #ifndef LLVM_INTRINSICINST_H
  25 #define LLVM_INTRINSICINST_H
  26
  27 #include "llvm/Constants.h"
  28 #include "llvm/Function.h"
  29 #include "llvm/Instructions.h"
  30 #include "llvm/Intrinsics.h"
  31
  32 namespace llvm {
  33   /// IntrinsicInst - A useful wrapper class for inspecting calls to intrinsic
  34   /// functions.  This allows the standard isa/dyncast/cast functionality to
  35   /// work with calls to intrinsic functions.
  36   class IntrinsicInst : public CallInst {
  37     IntrinsicInst();                      // DO NOT IMPLEMENT
  38     IntrinsicInst(const IntrinsicInst&);  // DO NOT IMPLEMENT
  39     void operator=(const IntrinsicInst&); // DO NOT IMPLEMENT
  40   public:
  41     /// getIntrinsicID - Return the intrinsic ID of this intrinsic.
  42     ///
  43     Intrinsic::ID getIntrinsicID() const {
  44       return (Intrinsic::ID)getCalledFunction()->getIntrinsicID();
  45     }
  46
  47     // Methods for support type inquiry through isa, cast, and dyn_cast:
  48     static inline bool classof(const IntrinsicInst *) { return true; }
  49     static inline bool classof(const CallInst *I) {
  50       if (const Function *CF = I->getCalledFunction())
  51         return CF->getIntrinsicID() != 0;
  52       return false;
  53     }
  54     static inline bool classof(const Value *V) {
  55       return isa<CallInst>(V) && classof(cast<CallInst>(V));
  56     }
  57   };
  58
  59   /// DbgInfoIntrinsic - This is the common base class for debug info intrinsics
  60   ///
  61   class DbgInfoIntrinsic : public IntrinsicInst {
  62   public:
  63
  64     // Methods for support type inquiry through isa, cast, and dyn_cast:
  65     static inline bool classof(const DbgInfoIntrinsic *) { return true; }
  66     static inline bool classof(const IntrinsicInst *I) {
  67       switch (I->getIntrinsicID()) {
  68       case Intrinsic::dbg_declare:
  69       case Intrinsic::dbg_value:
  70         return true;
  71       default: return false;
  72       }
  73     }
  74     static inline bool classof(const Value *V) {
  75       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
  76     }
  77
  78     static Value *StripCast(Value *C);
  79   };
  80
  81   /// DbgDeclareInst - This represents the llvm.dbg.declare instruction.
  82   ///
  83   class DbgDeclareInst : public DbgInfoIntrinsic {
  84   public:
  85     Value *getAddress() const;
  86     MDNode *getVariable() const { return cast<MDNode>(getArgOperand(1)); }
  87
  88     // Methods for support type inquiry through isa, cast, and dyn_cast:
  89     static inline bool classof(const DbgDeclareInst *) { return true; }
  90     static inline bool classof(const IntrinsicInst *I) {
  91       return I->getIntrinsicID() == Intrinsic::dbg_declare;
  92     }
  93     static inline bool classof(const Value *V) {
  94       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
  95     }
  96   };
  97
  98   /// DbgValueInst - This represents the llvm.dbg.value instruction.
  99   ///
 100   class DbgValueInst : public DbgInfoIntrinsic {
 101   public:
 102     const Value *getValue() const;
 103     Value *getValue();
 104     uint64_t getOffset() const {
 105       return cast<ConstantInt>(
 106                           const_cast<Value*>(getArgOperand(1)))->getZExtValue();
 107     }
 108     MDNode *getVariable() const { return cast<MDNode>(getArgOperand(2)); }
 109
 110     // Methods for support type inquiry through isa, cast, and dyn_cast:
 111     static inline bool classof(const DbgValueInst *) { return true; }
 112     static inline bool classof(const IntrinsicInst *I) {
 113       return I->getIntrinsicID() == Intrinsic::dbg_value;
 114     }
 115     static inline bool classof(const Value *V) {
 116       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
 117     }
 118   };
 119
 120   /// MemIntrinsic - This is the common base class for memset/memcpy/memmove.
 121   ///
 122   class MemIntrinsic : public IntrinsicInst {
 123   public:
 124     Value *getRawDest() const { return const_cast<Value*>(getArgOperand(0)); }
 125
 126     Value *getLength() const { return const_cast<Value*>(getArgOperand(2)); }
 127     ConstantInt *getAlignmentCst() const {
 128       return cast<ConstantInt>(const_cast<Value*>(getArgOperand(3)));
 129     }
 130
 131     unsigned getAlignment() const {
 132       return getAlignmentCst()->getZExtValue();
 133     }
 134
 135     ConstantInt *getVolatileCst() const {
 136       return cast<ConstantInt>(const_cast<Value*>(getArgOperand(4)));
 137     }
 138     bool isVolatile() const {
 139       return !getVolatileCst()->isZero();
 140     }
 141
 142     /// getDest - This is just like getRawDest, but it strips off any cast
 143     /// instructions that feed it, giving the original input.  The returned
 144     /// value is guaranteed to be a pointer.
 145     Value *getDest() const { return getRawDest()->stripPointerCasts(); }
 146
 147     /// set* - Set the specified arguments of the instruction.
 148     ///
 149     void setDest(Value *Ptr) {
 150       assert(getRawDest()->getType() == Ptr->getType() &&
 151              "setDest called with pointer of wrong type!");
 152       setArgOperand(0, Ptr);
 153     }
 154
 155     void setLength(Value *L) {
 156       assert(getLength()->getType() == L->getType() &&
 157              "setLength called with value of wrong type!");
 158       setArgOperand(2, L);
 159     }
 160
 161     void setAlignment(Constant* A) {
 162       setArgOperand(3, A);
 163     }
 164
 165     void setVolatile(Constant* V) {
 166       setArgOperand(4, V);
 167     }
 168
 169     const Type *getAlignmentType() const {
 170       return getArgOperand(3)->getType();
 171     }
 172
 173     // Methods for support type inquiry through isa, cast, and dyn_cast:
 174     static inline bool classof(const MemIntrinsic *) { return true; }
 175     static inline bool classof(const IntrinsicInst *I) {
 176       switch (I->getIntrinsicID()) {
 177       case Intrinsic::memcpy:
 178       case Intrinsic::memmove:
 179       case Intrinsic::memset:
 180         return true;
 181       default: return false;
 182       }
 183     }
 184     static inline bool classof(const Value *V) {
 185       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
 186     }
 187   };
 188
 189   /// MemSetInst - This class wraps the llvm.memset intrinsic.
 190   ///
 191   class MemSetInst : public MemIntrinsic {
 192   public:
 193     /// get* - Return the arguments to the instruction.
 194     ///
 195     Value *getValue() const { return const_cast<Value*>(getArgOperand(1)); }
 196
 197     void setValue(Value *Val) {
 198       assert(getValue()->getType() == Val->getType() &&
 199              "setValue called with value of wrong type!");
 200       setArgOperand(1, Val);
 201     }
 202
 203     // Methods for support type inquiry through isa, cast, and dyn_cast:
 204     static inline bool classof(const MemSetInst *) { return true; }
 205     static inline bool classof(const IntrinsicInst *I) {
 206       return I->getIntrinsicID() == Intrinsic::memset;
 207     }
 208     static inline bool classof(const Value *V) {
 209       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
 210     }
 211   };
 212
 213   /// MemTransferInst - This class wraps the llvm.memcpy/memmove intrinsics.
 214   ///
 215   class MemTransferInst : public MemIntrinsic {
 216   public:
 217     /// get* - Return the arguments to the instruction.
 218     ///
 219     Value *getRawSource() const { return const_cast<Value*>(getArgOperand(1)); }
 220
 221     /// getSource - This is just like getRawSource, but it strips off any cast
 222     /// instructions that feed it, giving the original input.  The returned
 223     /// value is guaranteed to be a pointer.
 224     Value *getSource() const { return getRawSource()->stripPointerCasts(); }
 225
 226     void setSource(Value *Ptr) {
 227       assert(getRawSource()->getType() == Ptr->getType() &&
 228              "setSource called with pointer of wrong type!");
 229       setArgOperand(1, Ptr);
 230     }
 231
 232     // Methods for support type inquiry through isa, cast, and dyn_cast:
 233     static inline bool classof(const MemTransferInst *) { return true; }
 234     static inline bool classof(const IntrinsicInst *I) {
 235       return I->getIntrinsicID() == Intrinsic::memcpy ||
 236              I->getIntrinsicID() == Intrinsic::memmove;
 237     }
 238     static inline bool classof(const Value *V) {
 239       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
 240     }
 241   };
 242
 243
 244   /// MemCpyInst - This class wraps the llvm.memcpy intrinsic.
 245   ///
 246   class MemCpyInst : public MemTransferInst {
 247   public:
 248     // Methods for support type inquiry through isa, cast, and dyn_cast:
 249     static inline bool classof(const MemCpyInst *) { return true; }
 250     static inline bool classof(const IntrinsicInst *I) {
 251       return I->getIntrinsicID() == Intrinsic::memcpy;
 252     }
 253     static inline bool classof(const Value *V) {
 254       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
 255     }
 256   };
 257
 258   /// MemMoveInst - This class wraps the llvm.memmove intrinsic.
 259   ///
 260   class MemMoveInst : public MemTransferInst {
 261   public:
 262     // Methods for support type inquiry through isa, cast, and dyn_cast:
 263     static inline bool classof(const MemMoveInst *) { return true; }
 264     static inline bool classof(const IntrinsicInst *I) {
 265       return I->getIntrinsicID() == Intrinsic::memmove;
 266     }
 267     static inline bool classof(const Value *V) {
 268       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
 269     }
 270   };
 271
 272   /// EHExceptionInst - This represents the llvm.eh.exception instruction.
 273   ///
 274   class EHExceptionInst : public IntrinsicInst {
 275   public:
 276     // Methods for support type inquiry through isa, cast, and dyn_cast:
 277     static inline bool classof(const EHExceptionInst *) { return true; }
 278     static inline bool classof(const IntrinsicInst *I) {
 279       return I->getIntrinsicID() == Intrinsic::eh_exception;
 280     }
 281     static inline bool classof(const Value *V) {
 282       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
 283     }
 284   };
 285
 286   /// EHSelectorInst - This represents the llvm.eh.selector instruction.
 287   ///
 288   class EHSelectorInst : public IntrinsicInst {
 289   public:
 290     // Methods for support type inquiry through isa, cast, and dyn_cast:
 291     static inline bool classof(const EHSelectorInst *) { return true; }
 292     static inline bool classof(const IntrinsicInst *I) {
 293       return I->getIntrinsicID() == Intrinsic::eh_selector;
 294     }
 295     static inline bool classof(const Value *V) {
 296       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
 297     }
 298   };
 299
 300   /// MemoryUseIntrinsic - This is the common base class for the memory use
 301   /// marker intrinsics.
 302   ///
 303   class MemoryUseIntrinsic : public IntrinsicInst {
 304   public:
 305
 306     // Methods for support type inquiry through isa, cast, and dyn_cast:
 307     static inline bool classof(const MemoryUseIntrinsic *) { return true; }
 308     static inline bool classof(const IntrinsicInst *I) {
 309       switch (I->getIntrinsicID()) {
 310       case Intrinsic::lifetime_start:
 311       case Intrinsic::lifetime_end:
 312       case Intrinsic::invariant_start:
 313       case Intrinsic::invariant_end:
 314         return true;
 315       default: return false;
 316       }
 317     }
 318     static inline bool classof(const Value *V) {
 319       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
 320     }
 321   };
 322
 323 }
 324
 325 #endif