include/llvm/IR/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_IR_INTRINSICINST_H
  25 #define LLVM_IR_INTRINSICINST_H
  26
  27 #include "llvm/IR/Constants.h"
  28 #include "llvm/IR/Function.h"
  29 #include "llvm/IR/Instructions.h"
  30 #include "llvm/IR/Intrinsics.h"
  31 #include "llvm/IR/Metadata.h"
  32
  33 namespace llvm {
  34   /// IntrinsicInst - A useful wrapper class for inspecting calls to intrinsic
  35   /// functions.  This allows the standard isa/dyncast/cast functionality to
  36   /// work with calls to intrinsic functions.
  37   class IntrinsicInst : public CallInst {
  38     IntrinsicInst() = delete;
  39     IntrinsicInst(const IntrinsicInst&) = delete;
  40     void operator=(const IntrinsicInst&) = delete;
  41   public:
  42     /// getIntrinsicID - Return the intrinsic ID of this intrinsic.
  43     ///
  44     Intrinsic::ID getIntrinsicID() const {
  45       return getCalledFunction()->getIntrinsicID();
  46     }
  47
  48     // Methods for support type inquiry through isa, cast, and dyn_cast:
  49     static inline bool classof(const CallInst *I) {
  50       if (const Function *CF = I->getCalledFunction())
  51         return CF->isIntrinsic();
  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 IntrinsicInst *I) {
  66       switch (I->getIntrinsicID()) {
  67       case Intrinsic::dbg_declare:
  68       case Intrinsic::dbg_value:
  69         return true;
  70       default: return false;
  71       }
  72     }
  73     static inline bool classof(const Value *V) {
  74       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
  75     }
  76
  77     static Value *StripCast(Value *C);
  78   };
  79
  80   /// DbgDeclareInst - This represents the llvm.dbg.declare instruction.
  81   ///
  82   class DbgDeclareInst : public DbgInfoIntrinsic {
  83   public:
  84     Value *getAddress() const;
  85     DILocalVariable *getVariable() const {
  86       return cast<DILocalVariable>(getRawVariable());
  87     }
  88     DIExpression *getExpression() const {
  89       return cast<DIExpression>(getRawExpression());
  90     }
  91
  92     Metadata *getRawVariable() const {
  93       return cast<MetadataAsValue>(getArgOperand(1))->getMetadata();
  94     }
  95     Metadata *getRawExpression() const {
  96       return cast<MetadataAsValue>(getArgOperand(2))->getMetadata();
  97     }
  98
  99     // Methods for support type inquiry through isa, cast, and dyn_cast:
 100     static inline bool classof(const IntrinsicInst *I) {
 101       return I->getIntrinsicID() == Intrinsic::dbg_declare;
 102     }
 103     static inline bool classof(const Value *V) {
 104       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
 105     }
 106   };
 107
 108   /// DbgValueInst - This represents the llvm.dbg.value instruction.
 109   ///
 110   class DbgValueInst : public DbgInfoIntrinsic {
 111   public:
 112     const Value *getValue() const;
 113     Value *getValue();
 114     uint64_t getOffset() const {
 115       return cast<ConstantInt>(
 116                           const_cast<Value*>(getArgOperand(1)))->getZExtValue();
 117     }
 118     DILocalVariable *getVariable() const {
 119       return cast<DILocalVariable>(getRawVariable());
 120     }
 121     DIExpression *getExpression() const {
 122       return cast<DIExpression>(getRawExpression());
 123     }
 124
 125     Metadata *getRawVariable() const {
 126       return cast<MetadataAsValue>(getArgOperand(2))->getMetadata();
 127     }
 128     Metadata *getRawExpression() const {
 129       return cast<MetadataAsValue>(getArgOperand(3))->getMetadata();
 130     }
 131
 132     // Methods for support type inquiry through isa, cast, and dyn_cast:
 133     static inline bool classof(const IntrinsicInst *I) {
 134       return I->getIntrinsicID() == Intrinsic::dbg_value;
 135     }
 136     static inline bool classof(const Value *V) {
 137       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
 138     }
 139   };
 140
 141   /// MemIntrinsic - This is the common base class for memset/memcpy/memmove.
 142   ///
 143   class MemIntrinsic : public IntrinsicInst {
 144   public:
 145     Value *getRawDest() const { return const_cast<Value*>(getArgOperand(0)); }
 146     const Use &getRawDestUse() const { return getArgOperandUse(0); }
 147     Use &getRawDestUse() { return getArgOperandUse(0); }
 148
 149     Value *getLength() const { return const_cast<Value*>(getArgOperand(2)); }
 150     const Use &getLengthUse() const { return getArgOperandUse(2); }
 151     Use &getLengthUse() { return getArgOperandUse(2); }
 152
 153     ConstantInt *getAlignmentCst() const {
 154       return cast<ConstantInt>(const_cast<Value*>(getArgOperand(3)));
 155     }
 156
 157     unsigned getAlignment() const {
 158       return getAlignmentCst()->getZExtValue();
 159     }
 160
 161     ConstantInt *getVolatileCst() const {
 162       return cast<ConstantInt>(const_cast<Value*>(getArgOperand(4)));
 163     }
 164     bool isVolatile() const {
 165       return !getVolatileCst()->isZero();
 166     }
 167
 168     unsigned getDestAddressSpace() const {
 169       return cast<PointerType>(getRawDest()->getType())->getAddressSpace();
 170     }
 171
 172     /// getDest - This is just like getRawDest, but it strips off any cast
 173     /// instructions that feed it, giving the original input.  The returned
 174     /// value is guaranteed to be a pointer.
 175     Value *getDest() const { return getRawDest()->stripPointerCasts(); }
 176
 177     /// set* - Set the specified arguments of the instruction.
 178     ///
 179     void setDest(Value *Ptr) {
 180       assert(getRawDest()->getType() == Ptr->getType() &&
 181              "setDest called with pointer of wrong type!");
 182       setArgOperand(0, Ptr);
 183     }
 184
 185     void setLength(Value *L) {
 186       assert(getLength()->getType() == L->getType() &&
 187              "setLength called with value of wrong type!");
 188       setArgOperand(2, L);
 189     }
 190
 191     void setAlignment(Constant* A) {
 192       setArgOperand(3, A);
 193     }
 194
 195     void setVolatile(Constant* V) {
 196       setArgOperand(4, V);
 197     }
 198
 199     Type *getAlignmentType() const {
 200       return getArgOperand(3)->getType();
 201     }
 202
 203     // Methods for support type inquiry through isa, cast, and dyn_cast:
 204     static inline bool classof(const IntrinsicInst *I) {
 205       switch (I->getIntrinsicID()) {
 206       case Intrinsic::memcpy:
 207       case Intrinsic::memmove:
 208       case Intrinsic::memset:
 209         return true;
 210       default: return false;
 211       }
 212     }
 213     static inline bool classof(const Value *V) {
 214       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
 215     }
 216   };
 217
 218   /// MemSetInst - This class wraps the llvm.memset intrinsic.
 219   ///
 220   class MemSetInst : public MemIntrinsic {
 221   public:
 222     /// get* - Return the arguments to the instruction.
 223     ///
 224     Value *getValue() const { return const_cast<Value*>(getArgOperand(1)); }
 225     const Use &getValueUse() const { return getArgOperandUse(1); }
 226     Use &getValueUse() { return getArgOperandUse(1); }
 227
 228     void setValue(Value *Val) {
 229       assert(getValue()->getType() == Val->getType() &&
 230              "setValue called with value of wrong type!");
 231       setArgOperand(1, Val);
 232     }
 233
 234     // Methods for support type inquiry through isa, cast, and dyn_cast:
 235     static inline bool classof(const IntrinsicInst *I) {
 236       return I->getIntrinsicID() == Intrinsic::memset;
 237     }
 238     static inline bool classof(const Value *V) {
 239       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
 240     }
 241   };
 242
 243   /// MemTransferInst - This class wraps the llvm.memcpy/memmove intrinsics.
 244   ///
 245   class MemTransferInst : public MemIntrinsic {
 246   public:
 247     /// get* - Return the arguments to the instruction.
 248     ///
 249     Value *getRawSource() const { return const_cast<Value*>(getArgOperand(1)); }
 250     const Use &getRawSourceUse() const { return getArgOperandUse(1); }
 251     Use &getRawSourceUse() { return getArgOperandUse(1); }
 252
 253     /// getSource - This is just like getRawSource, but it strips off any cast
 254     /// instructions that feed it, giving the original input.  The returned
 255     /// value is guaranteed to be a pointer.
 256     Value *getSource() const { return getRawSource()->stripPointerCasts(); }
 257
 258     unsigned getSourceAddressSpace() const {
 259       return cast<PointerType>(getRawSource()->getType())->getAddressSpace();
 260     }
 261
 262     void setSource(Value *Ptr) {
 263       assert(getRawSource()->getType() == Ptr->getType() &&
 264              "setSource called with pointer of wrong type!");
 265       setArgOperand(1, Ptr);
 266     }
 267
 268     // Methods for support type inquiry through isa, cast, and dyn_cast:
 269     static inline bool classof(const IntrinsicInst *I) {
 270       return I->getIntrinsicID() == Intrinsic::memcpy ||
 271              I->getIntrinsicID() == Intrinsic::memmove;
 272     }
 273     static inline bool classof(const Value *V) {
 274       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
 275     }
 276   };
 277
 278
 279   /// MemCpyInst - This class wraps the llvm.memcpy intrinsic.
 280   ///
 281   class MemCpyInst : public MemTransferInst {
 282   public:
 283     // Methods for support type inquiry through isa, cast, and dyn_cast:
 284     static inline bool classof(const IntrinsicInst *I) {
 285       return I->getIntrinsicID() == Intrinsic::memcpy;
 286     }
 287     static inline bool classof(const Value *V) {
 288       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
 289     }
 290   };
 291
 292   /// MemMoveInst - This class wraps the llvm.memmove intrinsic.
 293   ///
 294   class MemMoveInst : public MemTransferInst {
 295   public:
 296     // Methods for support type inquiry through isa, cast, and dyn_cast:
 297     static inline bool classof(const IntrinsicInst *I) {
 298       return I->getIntrinsicID() == Intrinsic::memmove;
 299     }
 300     static inline bool classof(const Value *V) {
 301       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
 302     }
 303   };
 304
 305   /// VAStartInst - This represents the llvm.va_start intrinsic.
 306   ///
 307   class VAStartInst : public IntrinsicInst {
 308   public:
 309     static inline bool classof(const IntrinsicInst *I) {
 310       return I->getIntrinsicID() == Intrinsic::vastart;
 311     }
 312     static inline bool classof(const Value *V) {
 313       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
 314     }
 315
 316     Value *getArgList() const { return const_cast<Value*>(getArgOperand(0)); }
 317   };
 318
 319   /// VAEndInst - This represents the llvm.va_end intrinsic.
 320   ///
 321   class VAEndInst : public IntrinsicInst {
 322   public:
 323     static inline bool classof(const IntrinsicInst *I) {
 324       return I->getIntrinsicID() == Intrinsic::vaend;
 325     }
 326     static inline bool classof(const Value *V) {
 327       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
 328     }
 329
 330     Value *getArgList() const { return const_cast<Value*>(getArgOperand(0)); }
 331   };
 332
 333   /// VACopyInst - This represents the llvm.va_copy intrinsic.
 334   ///
 335   class VACopyInst : public IntrinsicInst {
 336   public:
 337     static inline bool classof(const IntrinsicInst *I) {
 338       return I->getIntrinsicID() == Intrinsic::vacopy;
 339     }
 340     static inline bool classof(const Value *V) {
 341       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
 342     }
 343
 344     Value *getDest() const { return const_cast<Value*>(getArgOperand(0)); }
 345     Value *getSrc() const { return const_cast<Value*>(getArgOperand(1)); }
 346   };
 347
 348   /// This represents the llvm.instrprof_increment intrinsic.
 349   class InstrProfIncrementInst : public IntrinsicInst {
 350   public:
 351     static inline bool classof(const IntrinsicInst *I) {
 352       return I->getIntrinsicID() == Intrinsic::instrprof_increment;
 353     }
 354     static inline bool classof(const Value *V) {
 355       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
 356     }
 357
 358     GlobalVariable *getName() const {
 359       return cast<GlobalVariable>(
 360           const_cast<Value *>(getArgOperand(0))->stripPointerCasts());
 361     }
 362
 363     ConstantInt *getHash() const {
 364       return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
 365     }
 366
 367     ConstantInt *getNumCounters() const {
 368       return cast<ConstantInt>(const_cast<Value *>(getArgOperand(2)));
 369     }
 370
 371     ConstantInt *getIndex() const {
 372       return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
 373     }
 374   };
 375 } // namespace llvm
 376
 377 #endif