Home | History | Annotate | Download | only in IR 
      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 
     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() LLVM_DELETED_FUNCTION;
     38     IntrinsicInst(const IntrinsicInst&) LLVM_DELETED_FUNCTION;
     39     void operator=(const IntrinsicInst&) LLVM_DELETED_FUNCTION;
     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 CallInst *I) {
     49       if (const Function *CF = I->getCalledFunction())
     50         return CF->isIntrinsic();
     51       return false;
     52     }
     53     static inline bool classof(const Value *V) {
     54       return isa<CallInst>(V) && classof(cast<CallInst>(V));
     55     }
     56   };
     57 
     58   /// DbgInfoIntrinsic - This is the common base class for debug info intrinsics
     59   ///
     60   class DbgInfoIntrinsic : public IntrinsicInst {
     61   public:
     62 
     63     // Methods for support type inquiry through isa, cast, and dyn_cast:
     64     static inline bool classof(const IntrinsicInst *I) {
     65       switch (I->getIntrinsicID()) {
     66       case Intrinsic::dbg_declare:
     67       case Intrinsic::dbg_value:
     68         return true;
     69       default: return false;
     70       }
     71     }
     72     static inline bool classof(const Value *V) {
     73       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
     74     }
     75 
     76     static Value *StripCast(Value *C);
     77   };
     78 
     79   /// DbgDeclareInst - This represents the llvm.dbg.declare instruction.
     80   ///
     81   class DbgDeclareInst : public DbgInfoIntrinsic {
     82   public:
     83     Value *getAddress() const;
     84     MDNode *getVariable() const { return cast<MDNode>(getArgOperand(1)); }
     85 
     86     // Methods for support type inquiry through isa, cast, and dyn_cast:
     87     static inline bool classof(const IntrinsicInst *I) {
     88       return I->getIntrinsicID() == Intrinsic::dbg_declare;
     89     }
     90     static inline bool classof(const Value *V) {
     91       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
     92     }
     93   };
     94 
     95   /// DbgValueInst - This represents the llvm.dbg.value instruction.
     96   ///
     97   class DbgValueInst : public DbgInfoIntrinsic {
     98   public:
     99     const Value *getValue() const;
    100     Value *getValue();
    101     uint64_t getOffset() const {
    102       return cast<ConstantInt>(
    103                           const_cast<Value*>(getArgOperand(1)))->getZExtValue();
    104     }
    105     MDNode *getVariable() const { return cast<MDNode>(getArgOperand(2)); }
    106 
    107     // Methods for support type inquiry through isa, cast, and dyn_cast:
    108     static inline bool classof(const IntrinsicInst *I) {
    109       return I->getIntrinsicID() == Intrinsic::dbg_value;
    110     }
    111     static inline bool classof(const Value *V) {
    112       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
    113     }
    114   };
    115 
    116   /// MemIntrinsic - This is the common base class for memset/memcpy/memmove.
    117   ///
    118   class MemIntrinsic : public IntrinsicInst {
    119   public:
    120     Value *getRawDest() const { return const_cast<Value*>(getArgOperand(0)); }
    121     const Use &getRawDestUse() const { return getArgOperandUse(0); }
    122     Use &getRawDestUse() { return getArgOperandUse(0); }
    123 
    124     Value *getLength() const { return const_cast<Value*>(getArgOperand(2)); }
    125     const Use &getLengthUse() const { return getArgOperandUse(2); }
    126     Use &getLengthUse() { return getArgOperandUse(2); }
    127 
    128     ConstantInt *getAlignmentCst() const {
    129       return cast<ConstantInt>(const_cast<Value*>(getArgOperand(3)));
    130     }
    131 
    132     unsigned getAlignment() const {
    133       return getAlignmentCst()->getZExtValue();
    134     }
    135 
    136     ConstantInt *getVolatileCst() const {
    137       return cast<ConstantInt>(const_cast<Value*>(getArgOperand(4)));
    138     }
    139     bool isVolatile() const {
    140       return !getVolatileCst()->isZero();
    141     }
    142 
    143     unsigned getDestAddressSpace() const {
    144       return cast<PointerType>(getRawDest()->getType())->getAddressSpace();
    145     }
    146 
    147     /// getDest - This is just like getRawDest, but it strips off any cast
    148     /// instructions that feed it, giving the original input.  The returned
    149     /// value is guaranteed to be a pointer.
    150     Value *getDest() const { return getRawDest()->stripPointerCasts(); }
    151 
    152     /// set* - Set the specified arguments of the instruction.
    153     ///
    154     void setDest(Value *Ptr) {
    155       assert(getRawDest()->getType() == Ptr->getType() &&
    156              "setDest called with pointer of wrong type!");
    157       setArgOperand(0, Ptr);
    158     }
    159 
    160     void setLength(Value *L) {
    161       assert(getLength()->getType() == L->getType() &&
    162              "setLength called with value of wrong type!");
    163       setArgOperand(2, L);
    164     }
    165 
    166     void setAlignment(Constant* A) {
    167       setArgOperand(3, A);
    168     }
    169 
    170     void setVolatile(Constant* V) {
    171       setArgOperand(4, V);
    172     }
    173 
    174     Type *getAlignmentType() const {
    175       return getArgOperand(3)->getType();
    176     }
    177 
    178     // Methods for support type inquiry through isa, cast, and dyn_cast:
    179     static inline bool classof(const IntrinsicInst *I) {
    180       switch (I->getIntrinsicID()) {
    181       case Intrinsic::memcpy:
    182       case Intrinsic::memmove:
    183       case Intrinsic::memset:
    184         return true;
    185       default: return false;
    186       }
    187     }
    188     static inline bool classof(const Value *V) {
    189       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
    190     }
    191   };
    192 
    193   /// MemSetInst - This class wraps the llvm.memset intrinsic.
    194   ///
    195   class MemSetInst : public MemIntrinsic {
    196   public:
    197     /// get* - Return the arguments to the instruction.
    198     ///
    199     Value *getValue() const { return const_cast<Value*>(getArgOperand(1)); }
    200     const Use &getValueUse() const { return getArgOperandUse(1); }
    201     Use &getValueUse() { return getArgOperandUse(1); }
    202 
    203     void setValue(Value *Val) {
    204       assert(getValue()->getType() == Val->getType() &&
    205              "setValue called with value of wrong type!");
    206       setArgOperand(1, Val);
    207     }
    208 
    209     // Methods for support type inquiry through isa, cast, and dyn_cast:
    210     static inline bool classof(const IntrinsicInst *I) {
    211       return I->getIntrinsicID() == Intrinsic::memset;
    212     }
    213     static inline bool classof(const Value *V) {
    214       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
    215     }
    216   };
    217 
    218   /// MemTransferInst - This class wraps the llvm.memcpy/memmove intrinsics.
    219   ///
    220   class MemTransferInst : public MemIntrinsic {
    221   public:
    222     /// get* - Return the arguments to the instruction.
    223     ///
    224     Value *getRawSource() const { return const_cast<Value*>(getArgOperand(1)); }
    225     const Use &getRawSourceUse() const { return getArgOperandUse(1); }
    226     Use &getRawSourceUse() { return getArgOperandUse(1); }
    227 
    228     /// getSource - This is just like getRawSource, but it strips off any cast
    229     /// instructions that feed it, giving the original input.  The returned
    230     /// value is guaranteed to be a pointer.
    231     Value *getSource() const { return getRawSource()->stripPointerCasts(); }
    232 
    233     unsigned getSourceAddressSpace() const {
    234       return cast<PointerType>(getRawSource()->getType())->getAddressSpace();
    235     }
    236 
    237     void setSource(Value *Ptr) {
    238       assert(getRawSource()->getType() == Ptr->getType() &&
    239              "setSource called with pointer of wrong type!");
    240       setArgOperand(1, Ptr);
    241     }
    242 
    243     // Methods for support type inquiry through isa, cast, and dyn_cast:
    244     static inline bool classof(const IntrinsicInst *I) {
    245       return I->getIntrinsicID() == Intrinsic::memcpy ||
    246              I->getIntrinsicID() == Intrinsic::memmove;
    247     }
    248     static inline bool classof(const Value *V) {
    249       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
    250     }
    251   };
    252 
    253 
    254   /// MemCpyInst - This class wraps the llvm.memcpy intrinsic.
    255   ///
    256   class MemCpyInst : public MemTransferInst {
    257   public:
    258     // Methods for support type inquiry through isa, cast, and dyn_cast:
    259     static inline bool classof(const IntrinsicInst *I) {
    260       return I->getIntrinsicID() == Intrinsic::memcpy;
    261     }
    262     static inline bool classof(const Value *V) {
    263       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
    264     }
    265   };
    266 
    267   /// MemMoveInst - This class wraps the llvm.memmove intrinsic.
    268   ///
    269   class MemMoveInst : public MemTransferInst {
    270   public:
    271     // Methods for support type inquiry through isa, cast, and dyn_cast:
    272     static inline bool classof(const IntrinsicInst *I) {
    273       return I->getIntrinsicID() == Intrinsic::memmove;
    274     }
    275     static inline bool classof(const Value *V) {
    276       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
    277     }
    278   };
    279 
    280   /// VAStartInst - This represents the llvm.va_start intrinsic.
    281   ///
    282   class VAStartInst : public IntrinsicInst {
    283   public:
    284     static inline bool classof(const IntrinsicInst *I) {
    285       return I->getIntrinsicID() == Intrinsic::vastart;
    286     }
    287     static inline bool classof(const Value *V) {
    288       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
    289     }
    290 
    291     Value *getArgList() const { return const_cast<Value*>(getArgOperand(0)); }
    292   };
    293 
    294   /// VAEndInst - This represents the llvm.va_end intrinsic.
    295   ///
    296   class VAEndInst : public IntrinsicInst {
    297   public:
    298     static inline bool classof(const IntrinsicInst *I) {
    299       return I->getIntrinsicID() == Intrinsic::vaend;
    300     }
    301     static inline bool classof(const Value *V) {
    302       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
    303     }
    304 
    305     Value *getArgList() const { return const_cast<Value*>(getArgOperand(0)); }
    306   };
    307 
    308   /// VACopyInst - This represents the llvm.va_copy intrinsic.
    309   ///
    310   class VACopyInst : public IntrinsicInst {
    311   public:
    312     static inline bool classof(const IntrinsicInst *I) {
    313       return I->getIntrinsicID() == Intrinsic::vacopy;
    314     }
    315     static inline bool classof(const Value *V) {
    316       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
    317     }
    318 
    319     Value *getDest() const { return const_cast<Value*>(getArgOperand(0)); }
    320     Value *getSrc() const { return const_cast<Value*>(getArgOperand(1)); }
    321   };
    322 
    323 }
    324 
    325 #endif
    326