IntrinsicInst.h revision 75d4ec3caeb6bf6e27b06b3071fb4577d4c7030d
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 32namespace 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>(getOperand(2)); } 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*>(getOperand(2)))->getZExtValue(); 107 } 108 MDNode *getVariable() const { return cast<MDNode>(getOperand(3)); } 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*>(getOperand(1)); } 125 126 Value *getLength() const { return const_cast<Value*>(getOperand(3)); } 127 ConstantInt *getAlignmentCst() const { 128 return cast<ConstantInt>(const_cast<Value*>(getOperand(4))); 129 } 130 131 unsigned getAlignment() const { 132 return getAlignmentCst()->getZExtValue(); 133 } 134 135 ConstantInt *getVolatileCst() const { 136 return cast<ConstantInt>(const_cast<Value*>(getOperand(5))); 137 } 138 bool isVolatile() const { 139 return getVolatileCst()->getZExtValue() != 0; 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 setOperand(1, Ptr); 153 } 154 155 void setLength(Value *L) { 156 assert(getLength()->getType() == L->getType() && 157 "setLength called with value of wrong type!"); 158 setOperand(3, L); 159 } 160 161 void setAlignment(Constant* A) { 162 setOperand(4, A); 163 } 164 165 void setVolatile(Constant* V) { 166 setOperand(5, V); 167 } 168 169 const Type *getAlignmentType() const { 170 return getOperand(4)->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*>(getOperand(2)); } 196 197 void setValue(Value *Val) { 198 assert(getValue()->getType() == Val->getType() && 199 "setSource called with pointer of wrong type!"); 200 setOperand(2, 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*>(getOperand(2)); } 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 setOperand(2, 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 /// EHSelectorInst - This represents the llvm.eh.selector instruction. 273 /// 274 class EHSelectorInst : public IntrinsicInst { 275 public: 276 // Methods for support type inquiry through isa, cast, and dyn_cast: 277 static inline bool classof(const EHSelectorInst *) { return true; } 278 static inline bool classof(const IntrinsicInst *I) { 279 return I->getIntrinsicID() == Intrinsic::eh_selector; 280 } 281 static inline bool classof(const Value *V) { 282 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V)); 283 } 284 }; 285 286 /// MemoryUseIntrinsic - This is the common base class for the memory use 287 /// marker intrinsics. 288 /// 289 class MemoryUseIntrinsic : public IntrinsicInst { 290 public: 291 292 // Methods for support type inquiry through isa, cast, and dyn_cast: 293 static inline bool classof(const MemoryUseIntrinsic *) { return true; } 294 static inline bool classof(const IntrinsicInst *I) { 295 switch (I->getIntrinsicID()) { 296 case Intrinsic::lifetime_start: 297 case Intrinsic::lifetime_end: 298 case Intrinsic::invariant_start: 299 case Intrinsic::invariant_end: 300 return true; 301 default: return false; 302 } 303 } 304 static inline bool classof(const Value *V) { 305 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V)); 306 } 307 }; 308 309} 310 311#endif 312