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 #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 
    376   /// This represents the llvm.instrprof_value_profile intrinsic.
    377   class InstrProfValueProfileInst : public IntrinsicInst {
    378   public:
    379     static inline bool classof(const IntrinsicInst *I) {
    380       return I->getIntrinsicID() == Intrinsic::instrprof_value_profile;
    381     }
    382     static inline bool classof(const Value *V) {
    383       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
    384     }
    385 
    386     GlobalVariable *getName() const {
    387       return cast<GlobalVariable>(
    388           const_cast<Value *>(getArgOperand(0))->stripPointerCasts());
    389     }
    390 
    391     ConstantInt *getHash() const {
    392       return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
    393     }
    394 
    395     Value *getTargetValue() const {
    396       return cast<Value>(const_cast<Value *>(getArgOperand(2)));
    397     }
    398 
    399     ConstantInt *getValueKind() const {
    400       return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
    401     }
    402 
    403     // Returns the value site index.
    404     ConstantInt *getIndex() const {
    405       return cast<ConstantInt>(const_cast<Value *>(getArgOperand(4)));
    406     }
    407   };
    408 } // namespace llvm
    409 
    410 #endif
    411