1 //===-- llvm/IntrinsicInst.h - Intrinsic Instruction Wrappers ---*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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:
14 // if (MemCpyInst *MCI = dyn_cast<MemCpyInst>(Inst))
15 // ... MCI->getDest() ... MCI->getSource() ...
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
22 //===----------------------------------------------------------------------===//
24 #ifndef LLVM_IR_INTRINSICINST_H
25 #define LLVM_IR_INTRINSICINST_H
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"
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;
42 /// getIntrinsicID - Return the intrinsic ID of this intrinsic.
44 Intrinsic::ID getIntrinsicID() const {
45 return getCalledFunction()->getIntrinsicID();
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();
54 static inline bool classof(const Value *V) {
55 return isa<CallInst>(V) && classof(cast<CallInst>(V));
59 /// DbgInfoIntrinsic - This is the common base class for debug info intrinsics
61 class DbgInfoIntrinsic : public IntrinsicInst {
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:
70 default: return false;
73 static inline bool classof(const Value *V) {
74 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
77 static Value *StripCast(Value *C);
80 /// DbgDeclareInst - This represents the llvm.dbg.declare instruction.
82 class DbgDeclareInst : public DbgInfoIntrinsic {
84 Value *getAddress() const;
85 DILocalVariable *getVariable() const {
86 return cast<DILocalVariable>(getRawVariable());
88 DIExpression *getExpression() const {
89 return cast<DIExpression>(getRawExpression());
92 Metadata *getRawVariable() const {
93 return cast<MetadataAsValue>(getArgOperand(1))->getMetadata();
95 Metadata *getRawExpression() const {
96 return cast<MetadataAsValue>(getArgOperand(2))->getMetadata();
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;
103 static inline bool classof(const Value *V) {
104 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
108 /// DbgValueInst - This represents the llvm.dbg.value instruction.
110 class DbgValueInst : public DbgInfoIntrinsic {
112 const Value *getValue() const;
114 uint64_t getOffset() const {
115 return cast<ConstantInt>(
116 const_cast<Value*>(getArgOperand(1)))->getZExtValue();
118 DILocalVariable *getVariable() const {
119 return cast<DILocalVariable>(getRawVariable());
121 DIExpression *getExpression() const {
122 return cast<DIExpression>(getRawExpression());
125 Metadata *getRawVariable() const {
126 return cast<MetadataAsValue>(getArgOperand(2))->getMetadata();
128 Metadata *getRawExpression() const {
129 return cast<MetadataAsValue>(getArgOperand(3))->getMetadata();
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;
136 static inline bool classof(const Value *V) {
137 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
141 /// MemIntrinsic - This is the common base class for memset/memcpy/memmove.
143 class MemIntrinsic : public IntrinsicInst {
145 Value *getRawDest() const { return const_cast<Value*>(getArgOperand(0)); }
146 const Use &getRawDestUse() const { return getArgOperandUse(0); }
147 Use &getRawDestUse() { return getArgOperandUse(0); }
149 Value *getLength() const { return const_cast<Value*>(getArgOperand(2)); }
150 const Use &getLengthUse() const { return getArgOperandUse(2); }
151 Use &getLengthUse() { return getArgOperandUse(2); }
153 ConstantInt *getAlignmentCst() const {
154 return cast<ConstantInt>(const_cast<Value*>(getArgOperand(3)));
157 unsigned getAlignment() const {
158 return getAlignmentCst()->getZExtValue();
161 ConstantInt *getVolatileCst() const {
162 return cast<ConstantInt>(const_cast<Value*>(getArgOperand(4)));
164 bool isVolatile() const {
165 return !getVolatileCst()->isZero();
168 unsigned getDestAddressSpace() const {
169 return cast<PointerType>(getRawDest()->getType())->getAddressSpace();
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(); }
177 /// set* - Set the specified arguments of the instruction.
179 void setDest(Value *Ptr) {
180 assert(getRawDest()->getType() == Ptr->getType() &&
181 "setDest called with pointer of wrong type!");
182 setArgOperand(0, Ptr);
185 void setLength(Value *L) {
186 assert(getLength()->getType() == L->getType() &&
187 "setLength called with value of wrong type!");
191 void setAlignment(Constant* A) {
195 void setVolatile(Constant* V) {
199 Type *getAlignmentType() const {
200 return getArgOperand(3)->getType();
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:
210 default: return false;
213 static inline bool classof(const Value *V) {
214 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
218 /// MemSetInst - This class wraps the llvm.memset intrinsic.
220 class MemSetInst : public MemIntrinsic {
222 /// get* - Return the arguments to the instruction.
224 Value *getValue() const { return const_cast<Value*>(getArgOperand(1)); }
225 const Use &getValueUse() const { return getArgOperandUse(1); }
226 Use &getValueUse() { return getArgOperandUse(1); }
228 void setValue(Value *Val) {
229 assert(getValue()->getType() == Val->getType() &&
230 "setValue called with value of wrong type!");
231 setArgOperand(1, Val);
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;
238 static inline bool classof(const Value *V) {
239 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
243 /// MemTransferInst - This class wraps the llvm.memcpy/memmove intrinsics.
245 class MemTransferInst : public MemIntrinsic {
247 /// get* - Return the arguments to the instruction.
249 Value *getRawSource() const { return const_cast<Value*>(getArgOperand(1)); }
250 const Use &getRawSourceUse() const { return getArgOperandUse(1); }
251 Use &getRawSourceUse() { return getArgOperandUse(1); }
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(); }
258 unsigned getSourceAddressSpace() const {
259 return cast<PointerType>(getRawSource()->getType())->getAddressSpace();
262 void setSource(Value *Ptr) {
263 assert(getRawSource()->getType() == Ptr->getType() &&
264 "setSource called with pointer of wrong type!");
265 setArgOperand(1, Ptr);
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;
273 static inline bool classof(const Value *V) {
274 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
279 /// MemCpyInst - This class wraps the llvm.memcpy intrinsic.
281 class MemCpyInst : public MemTransferInst {
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;
287 static inline bool classof(const Value *V) {
288 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
292 /// MemMoveInst - This class wraps the llvm.memmove intrinsic.
294 class MemMoveInst : public MemTransferInst {
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;
300 static inline bool classof(const Value *V) {
301 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
305 /// VAStartInst - This represents the llvm.va_start intrinsic.
307 class VAStartInst : public IntrinsicInst {
309 static inline bool classof(const IntrinsicInst *I) {
310 return I->getIntrinsicID() == Intrinsic::vastart;
312 static inline bool classof(const Value *V) {
313 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
316 Value *getArgList() const { return const_cast<Value*>(getArgOperand(0)); }
319 /// VAEndInst - This represents the llvm.va_end intrinsic.
321 class VAEndInst : public IntrinsicInst {
323 static inline bool classof(const IntrinsicInst *I) {
324 return I->getIntrinsicID() == Intrinsic::vaend;
326 static inline bool classof(const Value *V) {
327 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
330 Value *getArgList() const { return const_cast<Value*>(getArgOperand(0)); }
333 /// VACopyInst - This represents the llvm.va_copy intrinsic.
335 class VACopyInst : public IntrinsicInst {
337 static inline bool classof(const IntrinsicInst *I) {
338 return I->getIntrinsicID() == Intrinsic::vacopy;
340 static inline bool classof(const Value *V) {
341 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
344 Value *getDest() const { return const_cast<Value*>(getArgOperand(0)); }
345 Value *getSrc() const { return const_cast<Value*>(getArgOperand(1)); }
348 /// This represents the llvm.instrprof_increment intrinsic.
349 class InstrProfIncrementInst : public IntrinsicInst {
351 static inline bool classof(const IntrinsicInst *I) {
352 return I->getIntrinsicID() == Intrinsic::instrprof_increment;
354 static inline bool classof(const Value *V) {
355 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
358 GlobalVariable *getName() const {
359 return cast<GlobalVariable>(
360 const_cast<Value *>(getArgOperand(0))->stripPointerCasts());
363 ConstantInt *getHash() const {
364 return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
367 ConstantInt *getNumCounters() const {
368 return cast<ConstantInt>(const_cast<Value *>(getArgOperand(2)));
371 ConstantInt *getIndex() const {
372 return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));