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 unsigned getDestAddressSpace() const { 143 return cast<PointerType>(getRawDest()->getType())->getAddressSpace(); 144 } 145 146 /// getDest - This is just like getRawDest, but it strips off any cast 147 /// instructions that feed it, giving the original input. The returned 148 /// value is guaranteed to be a pointer. 149 Value *getDest() const { return getRawDest()->stripPointerCasts(); } 150 151 /// set* - Set the specified arguments of the instruction. 152 /// 153 void setDest(Value *Ptr) { 154 assert(getRawDest()->getType() == Ptr->getType() && 155 "setDest called with pointer of wrong type!"); 156 setArgOperand(0, Ptr); 157 } 158 159 void setLength(Value *L) { 160 assert(getLength()->getType() == L->getType() && 161 "setLength called with value of wrong type!"); 162 setArgOperand(2, L); 163 } 164 165 void setAlignment(Constant* A) { 166 setArgOperand(3, A); 167 } 168 169 void setVolatile(Constant* V) { 170 setArgOperand(4, V); 171 } 172 173 Type *getAlignmentType() const { 174 return getArgOperand(3)->getType(); 175 } 176 177 // Methods for support type inquiry through isa, cast, and dyn_cast: 178 static inline bool classof(const MemIntrinsic *) { return true; } 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 201 void setValue(Value *Val) { 202 assert(getValue()->getType() == Val->getType() && 203 "setValue called with value of wrong type!"); 204 setArgOperand(1, Val); 205 } 206 207 // Methods for support type inquiry through isa, cast, and dyn_cast: 208 static inline bool classof(const MemSetInst *) { return true; } 209 static inline bool classof(const IntrinsicInst *I) { 210 return I->getIntrinsicID() == Intrinsic::memset; 211 } 212 static inline bool classof(const Value *V) { 213 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V)); 214 } 215 }; 216 217 /// MemTransferInst - This class wraps the llvm.memcpy/memmove intrinsics. 218 /// 219 class MemTransferInst : public MemIntrinsic { 220 public: 221 /// get* - Return the arguments to the instruction. 222 /// 223 Value *getRawSource() const { return const_cast<Value*>(getArgOperand(1)); } 224 225 /// getSource - This is just like getRawSource, but it strips off any cast 226 /// instructions that feed it, giving the original input. The returned 227 /// value is guaranteed to be a pointer. 228 Value *getSource() const { return getRawSource()->stripPointerCasts(); } 229 230 unsigned getSourceAddressSpace() const { 231 return cast<PointerType>(getRawSource()->getType())->getAddressSpace(); 232 } 233 234 void setSource(Value *Ptr) { 235 assert(getRawSource()->getType() == Ptr->getType() && 236 "setSource called with pointer of wrong type!"); 237 setArgOperand(1, Ptr); 238 } 239 240 // Methods for support type inquiry through isa, cast, and dyn_cast: 241 static inline bool classof(const MemTransferInst *) { return true; } 242 static inline bool classof(const IntrinsicInst *I) { 243 return I->getIntrinsicID() == Intrinsic::memcpy || 244 I->getIntrinsicID() == Intrinsic::memmove; 245 } 246 static inline bool classof(const Value *V) { 247 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V)); 248 } 249 }; 250 251 252 /// MemCpyInst - This class wraps the llvm.memcpy intrinsic. 253 /// 254 class MemCpyInst : public MemTransferInst { 255 public: 256 // Methods for support type inquiry through isa, cast, and dyn_cast: 257 static inline bool classof(const MemCpyInst *) { return true; } 258 static inline bool classof(const IntrinsicInst *I) { 259 return I->getIntrinsicID() == Intrinsic::memcpy; 260 } 261 static inline bool classof(const Value *V) { 262 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V)); 263 } 264 }; 265 266 /// MemMoveInst - This class wraps the llvm.memmove intrinsic. 267 /// 268 class MemMoveInst : public MemTransferInst { 269 public: 270 // Methods for support type inquiry through isa, cast, and dyn_cast: 271 static inline bool classof(const MemMoveInst *) { return true; } 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 } 281 282 #endif 283
