IntrinsicInst.h revision 283ba2fbb4a40d5f7615aba070f2f7ec161d19ac 
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/Metadata.h"
29#include "llvm/Function.h"
30#include "llvm/Instructions.h"
31#include "llvm/Intrinsics.h"
32
33namespace 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();                      // DO NOT IMPLEMENT
39    IntrinsicInst(const IntrinsicInst&);  // DO NOT IMPLEMENT
40    void operator=(const IntrinsicInst&); // DO NOT IMPLEMENT
41  public:
42    /// getIntrinsicID - Return the intrinsic ID of this intrinsic.
43    ///
44    Intrinsic::ID getIntrinsicID() const {
45      return (Intrinsic::ID)getCalledFunction()->getIntrinsicID();
46    }
47
48    // Methods for support type inquiry through isa, cast, and dyn_cast:
49    static inline bool classof(const IntrinsicInst *) { return true; }
50    static inline bool classof(const CallInst *I) {
51      if (const Function *CF = I->getCalledFunction())
52        return CF->getIntrinsicID() != 0;
53      return false;
54    }
55    static inline bool classof(const Value *V) {
56      return isa<CallInst>(V) && classof(cast<CallInst>(V));
57    }
58  };
59
60  /// DbgInfoIntrinsic - This is the common base class for debug info intrinsics
61  ///
62  class DbgInfoIntrinsic : public IntrinsicInst {
63  public:
64
65    // Methods for support type inquiry through isa, cast, and dyn_cast:
66    static inline bool classof(const DbgInfoIntrinsic *) { return true; }
67    static inline bool classof(const IntrinsicInst *I) {
68      switch (I->getIntrinsicID()) {
69      case Intrinsic::dbg_declare:
70      case Intrinsic::dbg_value:
71        return true;
72      default: return false;
73      }
74    }
75    static inline bool classof(const Value *V) {
76      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
77    }
78
79    static Value *StripCast(Value *C);
80  };
81
82  /// DbgDeclareInst - This represents the llvm.dbg.declare instruction.
83  ///
84  class DbgDeclareInst : public DbgInfoIntrinsic {
85  public:
86    Value *getAddress() const {
87      if (MDNode* MD = dyn_cast<MDNode>(getOperand(1)))
88      	return MD->getOperand(0);
89      else
90      	return NULL;
91    }
92    MDNode *getVariable() const { return cast<MDNode>(getOperand(2)); }
93
94    // Methods for support type inquiry through isa, cast, and dyn_cast:
95    static inline bool classof(const DbgDeclareInst *) { return true; }
96    static inline bool classof(const IntrinsicInst *I) {
97      return I->getIntrinsicID() == Intrinsic::dbg_declare;
98    }
99    static inline bool classof(const Value *V) {
100      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
101    }
102  };
103
104  /// DbgValueInst - This represents the llvm.dbg.value instruction.
105  ///
106  class DbgValueInst : public DbgInfoIntrinsic {
107  public:
108    const Value *getValue() const;
109    Value *getValue();
110    uint64_t getOffset() const {
111      return cast<ConstantInt>(
112                             const_cast<Value*>(getOperand(2)))->getZExtValue();
113    }
114    const MDNode *getVariable() const { return cast<MDNode>(getOperand(3)); }
115    MDNode *getVariable() { return cast<MDNode>(getOperand(3)); }
116
117    // Methods for support type inquiry through isa, cast, and dyn_cast:
118    static inline bool classof(const DbgValueInst *) { return true; }
119    static inline bool classof(const IntrinsicInst *I) {
120      return I->getIntrinsicID() == Intrinsic::dbg_value;
121    }
122    static inline bool classof(const Value *V) {
123      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
124    }
125  };
126
127  /// MemIntrinsic - This is the common base class for memset/memcpy/memmove.
128  ///
129  class MemIntrinsic : public IntrinsicInst {
130  public:
131    Value *getRawDest() const { return const_cast<Value*>(getOperand(1)); }
132
133    Value *getLength() const { return const_cast<Value*>(getOperand(3)); }
134    ConstantInt *getAlignmentCst() const {
135      return cast<ConstantInt>(const_cast<Value*>(getOperand(4)));
136    }
137
138    unsigned getAlignment() const {
139      return getAlignmentCst()->getZExtValue();
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    const Type *getAlignmentType() const {
166      return getOperand(4)->getType();
167    }
168
169    // Methods for support type inquiry through isa, cast, and dyn_cast:
170    static inline bool classof(const MemIntrinsic *) { return true; }
171    static inline bool classof(const IntrinsicInst *I) {
172      switch (I->getIntrinsicID()) {
173      case Intrinsic::memcpy:
174      case Intrinsic::memmove:
175      case Intrinsic::memset:
176        return true;
177      default: return false;
178      }
179    }
180    static inline bool classof(const Value *V) {
181      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
182    }
183  };
184
185  /// MemSetInst - This class wraps the llvm.memset intrinsic.
186  ///
187  class MemSetInst : public MemIntrinsic {
188  public:
189    /// get* - Return the arguments to the instruction.
190    ///
191    Value *getValue() const { return const_cast<Value*>(getOperand(2)); }
192
193    void setValue(Value *Val) {
194      assert(getValue()->getType() == Val->getType() &&
195             "setSource called with pointer of wrong type!");
196      setOperand(2, Val);
197    }
198
199    // Methods for support type inquiry through isa, cast, and dyn_cast:
200    static inline bool classof(const MemSetInst *) { return true; }
201    static inline bool classof(const IntrinsicInst *I) {
202      return I->getIntrinsicID() == Intrinsic::memset;
203    }
204    static inline bool classof(const Value *V) {
205      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
206    }
207  };
208
209  /// MemTransferInst - This class wraps the llvm.memcpy/memmove intrinsics.
210  ///
211  class MemTransferInst : public MemIntrinsic {
212  public:
213    /// get* - Return the arguments to the instruction.
214    ///
215    Value *getRawSource() const { return const_cast<Value*>(getOperand(2)); }
216
217    /// getSource - This is just like getRawSource, but it strips off any cast
218    /// instructions that feed it, giving the original input.  The returned
219    /// value is guaranteed to be a pointer.
220    Value *getSource() const { return getRawSource()->stripPointerCasts(); }
221
222    void setSource(Value *Ptr) {
223      assert(getRawSource()->getType() == Ptr->getType() &&
224             "setSource called with pointer of wrong type!");
225      setOperand(2, Ptr);
226    }
227
228    // Methods for support type inquiry through isa, cast, and dyn_cast:
229    static inline bool classof(const MemTransferInst *) { return true; }
230    static inline bool classof(const IntrinsicInst *I) {
231      return I->getIntrinsicID() == Intrinsic::memcpy ||
232             I->getIntrinsicID() == Intrinsic::memmove;
233    }
234    static inline bool classof(const Value *V) {
235      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
236    }
237  };
238
239
240  /// MemCpyInst - This class wraps the llvm.memcpy intrinsic.
241  ///
242  class MemCpyInst : public MemTransferInst {
243  public:
244    // Methods for support type inquiry through isa, cast, and dyn_cast:
245    static inline bool classof(const MemCpyInst *) { return true; }
246    static inline bool classof(const IntrinsicInst *I) {
247      return I->getIntrinsicID() == Intrinsic::memcpy;
248    }
249    static inline bool classof(const Value *V) {
250      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
251    }
252  };
253
254  /// MemMoveInst - This class wraps the llvm.memmove intrinsic.
255  ///
256  class MemMoveInst : public MemTransferInst {
257  public:
258    // Methods for support type inquiry through isa, cast, and dyn_cast:
259    static inline bool classof(const MemMoveInst *) { return true; }
260    static inline bool classof(const IntrinsicInst *I) {
261      return I->getIntrinsicID() == Intrinsic::memmove;
262    }
263    static inline bool classof(const Value *V) {
264      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
265    }
266  };
267
268  /// EHSelectorInst - This represents the llvm.eh.selector instruction.
269  ///
270  class EHSelectorInst : public IntrinsicInst {
271  public:
272    // Methods for support type inquiry through isa, cast, and dyn_cast:
273    static inline bool classof(const EHSelectorInst *) { return true; }
274    static inline bool classof(const IntrinsicInst *I) {
275      return I->getIntrinsicID() == Intrinsic::eh_selector;
276    }
277    static inline bool classof(const Value *V) {
278      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
279    }
280  };
281
282  /// MemoryUseIntrinsic - This is the common base class for the memory use
283  /// marker intrinsics.
284  ///
285  class MemoryUseIntrinsic : public IntrinsicInst {
286  public:
287
288    // Methods for support type inquiry through isa, cast, and dyn_cast:
289    static inline bool classof(const MemoryUseIntrinsic *) { return true; }
290    static inline bool classof(const IntrinsicInst *I) {
291      switch (I->getIntrinsicID()) {
292      case Intrinsic::lifetime_start:
293      case Intrinsic::lifetime_end:
294      case Intrinsic::invariant_start:
295      case Intrinsic::invariant_end:
296        return true;
297      default: return false;
298      }
299    }
300    static inline bool classof(const Value *V) {
301      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
302    }
303  };
304
305}
306
307#endif
308