LLVM  6.0.0svn
IntrinsicInst.h
Go to the documentation of this file.
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/DerivedTypes.h"
29 #include "llvm/IR/Function.h"
30 #include "llvm/IR/GlobalVariable.h"
31 #include "llvm/IR/Instructions.h"
32 #include "llvm/IR/Intrinsics.h"
33 #include "llvm/IR/Metadata.h"
34 #include "llvm/IR/Value.h"
35 #include "llvm/Support/Casting.h"
36 #include <cassert>
37 #include <cstdint>
38 
39 namespace llvm {
40 
41  /// A wrapper class for inspecting calls to intrinsic functions.
42  /// This allows the standard isa/dyncast/cast functionality to work with calls
43  /// to intrinsic functions.
44  class IntrinsicInst : public CallInst {
45  public:
46  IntrinsicInst() = delete;
47  IntrinsicInst(const IntrinsicInst &) = delete;
48  IntrinsicInst &operator=(const IntrinsicInst &) = delete;
49 
50  /// Return the intrinsic ID of this intrinsic.
53  }
54 
55  // Methods for support type inquiry through isa, cast, and dyn_cast:
56  static bool classof(const CallInst *I) {
57  if (const Function *CF = I->getCalledFunction())
58  return CF->isIntrinsic();
59  return false;
60  }
61  static bool classof(const Value *V) {
62  return isa<CallInst>(V) && classof(cast<CallInst>(V));
63  }
64  };
65 
66  /// This is the common base class for debug info intrinsics.
68  public:
69  /// Get the location corresponding to the variable referenced by the debug
70  /// info intrinsic. Depending on the intrinsic, this could be the
71  /// variable's value or its address.
72  Value *getVariableLocation(bool AllowNullOp = true) const;
73 
74  /// Does this describe the address of a local variable. True for dbg.addr
75  /// and dbg.declare, but not dbg.value, which describes its value.
76  bool isAddressOfVariable() const {
77  return getIntrinsicID() != Intrinsic::dbg_value;
78  }
79 
81  return cast<DILocalVariable>(getRawVariable());
82  }
83 
85  return cast<DIExpression>(getRawExpression());
86  }
87 
89  return cast<MetadataAsValue>(getArgOperand(1))->getMetadata();
90  }
91 
93  return cast<MetadataAsValue>(getArgOperand(2))->getMetadata();
94  }
95 
96  /// \name Casting methods
97  /// @{
98  static bool classof(const IntrinsicInst *I) {
99  switch (I->getIntrinsicID()) {
100  case Intrinsic::dbg_declare:
101  case Intrinsic::dbg_value:
102  case Intrinsic::dbg_addr:
103  return true;
104  default: return false;
105  }
106  }
107  static bool classof(const Value *V) {
108  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
109  }
110  /// @}
111  };
112 
113  /// This represents the llvm.dbg.declare instruction.
115  public:
116  Value *getAddress() const { return getVariableLocation(); }
117 
118  /// \name Casting methods
119  /// @{
120  static bool classof(const IntrinsicInst *I) {
121  return I->getIntrinsicID() == Intrinsic::dbg_declare;
122  }
123  static bool classof(const Value *V) {
124  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
125  }
126  /// @}
127  };
128 
129  /// This represents the llvm.dbg.addr instruction.
131  public:
132  Value *getAddress() const { return getVariableLocation(); }
133 
134  /// \name Casting methods
135  /// @{
136  static bool classof(const IntrinsicInst *I) {
137  return I->getIntrinsicID() == Intrinsic::dbg_addr;
138  }
139  static bool classof(const Value *V) {
140  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
141  }
142  };
143 
144  /// This represents the llvm.dbg.value instruction.
146  public:
147  Value *getValue() const {
148  return getVariableLocation(/* AllowNullOp = */ false);
149  }
150 
151  /// \name Casting methods
152  /// @{
153  static bool classof(const IntrinsicInst *I) {
154  return I->getIntrinsicID() == Intrinsic::dbg_value;
155  }
156  static bool classof(const Value *V) {
157  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
158  }
159  /// @}
160  };
161 
162  /// This is the common base class for constrained floating point intrinsics.
164  public:
171  rmTowardZero
172  };
173 
178  ebStrict
179  };
180 
181  bool isUnaryOp() const;
182  bool isTernaryOp() const;
183  RoundingMode getRoundingMode() const;
184  ExceptionBehavior getExceptionBehavior() const;
185 
186  // Methods for support type inquiry through isa, cast, and dyn_cast:
187  static bool classof(const IntrinsicInst *I) {
188  switch (I->getIntrinsicID()) {
189  case Intrinsic::experimental_constrained_fadd:
190  case Intrinsic::experimental_constrained_fsub:
191  case Intrinsic::experimental_constrained_fmul:
192  case Intrinsic::experimental_constrained_fdiv:
193  case Intrinsic::experimental_constrained_frem:
194  case Intrinsic::experimental_constrained_fma:
195  case Intrinsic::experimental_constrained_sqrt:
196  case Intrinsic::experimental_constrained_pow:
197  case Intrinsic::experimental_constrained_powi:
198  case Intrinsic::experimental_constrained_sin:
199  case Intrinsic::experimental_constrained_cos:
200  case Intrinsic::experimental_constrained_exp:
201  case Intrinsic::experimental_constrained_exp2:
202  case Intrinsic::experimental_constrained_log:
203  case Intrinsic::experimental_constrained_log10:
204  case Intrinsic::experimental_constrained_log2:
205  case Intrinsic::experimental_constrained_rint:
206  case Intrinsic::experimental_constrained_nearbyint:
207  return true;
208  default: return false;
209  }
210  }
211  static bool classof(const Value *V) {
212  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
213  }
214  };
215 
216  /// This class represents atomic memcpy intrinsic
217  /// TODO: Integrate this class into MemIntrinsic hierarchy; for now this is
218  /// C&P of all methods from that hierarchy
220  private:
221  enum { ARG_DEST = 0, ARG_SOURCE = 1, ARG_LENGTH = 2, ARG_ELEMENTSIZE = 3 };
222 
223  public:
224  Value *getRawDest() const {
225  return const_cast<Value *>(getArgOperand(ARG_DEST));
226  }
227  const Use &getRawDestUse() const { return getArgOperandUse(ARG_DEST); }
228  Use &getRawDestUse() { return getArgOperandUse(ARG_DEST); }
229 
230  /// Return the arguments to the instruction.
231  Value *getRawSource() const {
232  return const_cast<Value *>(getArgOperand(ARG_SOURCE));
233  }
234  const Use &getRawSourceUse() const { return getArgOperandUse(ARG_SOURCE); }
235  Use &getRawSourceUse() { return getArgOperandUse(ARG_SOURCE); }
236 
237  Value *getLength() const {
238  return const_cast<Value *>(getArgOperand(ARG_LENGTH));
239  }
240  const Use &getLengthUse() const { return getArgOperandUse(ARG_LENGTH); }
241  Use &getLengthUse() { return getArgOperandUse(ARG_LENGTH); }
242 
243  bool isVolatile() const { return false; }
244 
246  return const_cast<Value *>(getArgOperand(ARG_ELEMENTSIZE));
247  }
248 
250  return cast<ConstantInt>(getRawElementSizeInBytes());
251  }
252 
254  return getElementSizeInBytesCst()->getZExtValue();
255  }
256 
257  /// This is just like getRawDest, but it strips off any cast
258  /// instructions that feed it, giving the original input. The returned
259  /// value is guaranteed to be a pointer.
260  Value *getDest() const { return getRawDest()->stripPointerCasts(); }
261 
262  /// This is just like getRawSource, but it strips off any cast
263  /// instructions that feed it, giving the original input. The returned
264  /// value is guaranteed to be a pointer.
265  Value *getSource() const { return getRawSource()->stripPointerCasts(); }
266 
267  unsigned getDestAddressSpace() const {
268  return cast<PointerType>(getRawDest()->getType())->getAddressSpace();
269  }
270 
271  unsigned getSourceAddressSpace() const {
272  return cast<PointerType>(getRawSource()->getType())->getAddressSpace();
273  }
274 
275  /// Set the specified arguments of the instruction.
276  void setDest(Value *Ptr) {
277  assert(getRawDest()->getType() == Ptr->getType() &&
278  "setDest called with pointer of wrong type!");
279  setArgOperand(ARG_DEST, Ptr);
280  }
281 
282  void setSource(Value *Ptr) {
283  assert(getRawSource()->getType() == Ptr->getType() &&
284  "setSource called with pointer of wrong type!");
285  setArgOperand(ARG_SOURCE, Ptr);
286  }
287 
288  void setLength(Value *L) {
289  assert(getLength()->getType() == L->getType() &&
290  "setLength called with value of wrong type!");
291  setArgOperand(ARG_LENGTH, L);
292  }
293 
296  "setElementSizeInBytes called with value of wrong type!");
297  setArgOperand(ARG_ELEMENTSIZE, V);
298  }
299 
300  static bool classof(const IntrinsicInst *I) {
301  return I->getIntrinsicID() == Intrinsic::memcpy_element_unordered_atomic;
302  }
303  static bool classof(const Value *V) {
304  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
305  }
306  };
307 
309  private:
310  enum { ARG_DEST = 0, ARG_SOURCE = 1, ARG_LENGTH = 2, ARG_ELEMENTSIZE = 3 };
311 
312  public:
313  Value *getRawDest() const {
314  return const_cast<Value *>(getArgOperand(ARG_DEST));
315  }
316  const Use &getRawDestUse() const { return getArgOperandUse(ARG_DEST); }
317  Use &getRawDestUse() { return getArgOperandUse(ARG_DEST); }
318 
319  /// Return the arguments to the instruction.
320  Value *getRawSource() const {
321  return const_cast<Value *>(getArgOperand(ARG_SOURCE));
322  }
323  const Use &getRawSourceUse() const { return getArgOperandUse(ARG_SOURCE); }
324  Use &getRawSourceUse() { return getArgOperandUse(ARG_SOURCE); }
325 
326  Value *getLength() const {
327  return const_cast<Value *>(getArgOperand(ARG_LENGTH));
328  }
329  const Use &getLengthUse() const { return getArgOperandUse(ARG_LENGTH); }
330  Use &getLengthUse() { return getArgOperandUse(ARG_LENGTH); }
331 
332  bool isVolatile() const { return false; }
333 
335  return const_cast<Value *>(getArgOperand(ARG_ELEMENTSIZE));
336  }
337 
339  return cast<ConstantInt>(getRawElementSizeInBytes());
340  }
341 
343  return getElementSizeInBytesCst()->getZExtValue();
344  }
345 
346  /// This is just like getRawDest, but it strips off any cast
347  /// instructions that feed it, giving the original input. The returned
348  /// value is guaranteed to be a pointer.
349  Value *getDest() const { return getRawDest()->stripPointerCasts(); }
350 
351  /// This is just like getRawSource, but it strips off any cast
352  /// instructions that feed it, giving the original input. The returned
353  /// value is guaranteed to be a pointer.
354  Value *getSource() const { return getRawSource()->stripPointerCasts(); }
355 
356  unsigned getDestAddressSpace() const {
357  return cast<PointerType>(getRawDest()->getType())->getAddressSpace();
358  }
359 
360  unsigned getSourceAddressSpace() const {
361  return cast<PointerType>(getRawSource()->getType())->getAddressSpace();
362  }
363 
364  /// Set the specified arguments of the instruction.
365  void setDest(Value *Ptr) {
366  assert(getRawDest()->getType() == Ptr->getType() &&
367  "setDest called with pointer of wrong type!");
368  setArgOperand(ARG_DEST, Ptr);
369  }
370 
371  void setSource(Value *Ptr) {
372  assert(getRawSource()->getType() == Ptr->getType() &&
373  "setSource called with pointer of wrong type!");
374  setArgOperand(ARG_SOURCE, Ptr);
375  }
376 
377  void setLength(Value *L) {
378  assert(getLength()->getType() == L->getType() &&
379  "setLength called with value of wrong type!");
380  setArgOperand(ARG_LENGTH, L);
381  }
382 
385  "setElementSizeInBytes called with value of wrong type!");
386  setArgOperand(ARG_ELEMENTSIZE, V);
387  }
388 
389  static inline bool classof(const IntrinsicInst *I) {
390  return I->getIntrinsicID() == Intrinsic::memmove_element_unordered_atomic;
391  }
392  static inline bool classof(const Value *V) {
393  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
394  }
395  };
396 
397  /// This class represents atomic memset intrinsic
398  /// TODO: Integrate this class into MemIntrinsic hierarchy; for now this is
399  /// C&P of all methods from that hierarchy
401  private:
402  enum { ARG_DEST = 0, ARG_VALUE = 1, ARG_LENGTH = 2, ARG_ELEMENTSIZE = 3 };
403 
404  public:
405  Value *getRawDest() const {
406  return const_cast<Value *>(getArgOperand(ARG_DEST));
407  }
408  const Use &getRawDestUse() const { return getArgOperandUse(ARG_DEST); }
409  Use &getRawDestUse() { return getArgOperandUse(ARG_DEST); }
410 
411  Value *getValue() const { return const_cast<Value*>(getArgOperand(ARG_VALUE)); }
412  const Use &getValueUse() const { return getArgOperandUse(ARG_VALUE); }
413  Use &getValueUse() { return getArgOperandUse(ARG_VALUE); }
414 
415  Value *getLength() const {
416  return const_cast<Value *>(getArgOperand(ARG_LENGTH));
417  }
418  const Use &getLengthUse() const { return getArgOperandUse(ARG_LENGTH); }
419  Use &getLengthUse() { return getArgOperandUse(ARG_LENGTH); }
420 
421  bool isVolatile() const { return false; }
422 
424  return const_cast<Value *>(getArgOperand(ARG_ELEMENTSIZE));
425  }
426 
428  return cast<ConstantInt>(getRawElementSizeInBytes());
429  }
430 
432  return getElementSizeInBytesCst()->getZExtValue();
433  }
434 
435  /// This is just like getRawDest, but it strips off any cast
436  /// instructions that feed it, giving the original input. The returned
437  /// value is guaranteed to be a pointer.
438  Value *getDest() const { return getRawDest()->stripPointerCasts(); }
439 
440  unsigned getDestAddressSpace() const {
441  return cast<PointerType>(getRawDest()->getType())->getAddressSpace();
442  }
443 
444  /// Set the specified arguments of the instruction.
445  void setDest(Value *Ptr) {
446  assert(getRawDest()->getType() == Ptr->getType() &&
447  "setDest called with pointer of wrong type!");
448  setArgOperand(ARG_DEST, Ptr);
449  }
450 
451  void setValue(Value *Val) {
452  assert(getValue()->getType() == Val->getType() &&
453  "setValue called with value of wrong type!");
454  setArgOperand(ARG_VALUE, Val);
455  }
456 
457  void setLength(Value *L) {
458  assert(getLength()->getType() == L->getType() &&
459  "setLength called with value of wrong type!");
460  setArgOperand(ARG_LENGTH, L);
461  }
462 
465  "setElementSizeInBytes called with value of wrong type!");
466  setArgOperand(ARG_ELEMENTSIZE, V);
467  }
468 
469  static inline bool classof(const IntrinsicInst *I) {
470  return I->getIntrinsicID() == Intrinsic::memset_element_unordered_atomic;
471  }
472  static inline bool classof(const Value *V) {
473  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
474  }
475  };
476 
477  /// This is the common base class for memset/memcpy/memmove.
478  class MemIntrinsic : public IntrinsicInst {
479  public:
480  Value *getRawDest() const { return const_cast<Value*>(getArgOperand(0)); }
481  const Use &getRawDestUse() const { return getArgOperandUse(0); }
483 
484  Value *getLength() const { return const_cast<Value*>(getArgOperand(2)); }
485  const Use &getLengthUse() const { return getArgOperandUse(2); }
487 
489  return cast<ConstantInt>(const_cast<Value*>(getArgOperand(3)));
490  }
491 
492  unsigned getAlignment() const {
493  return getAlignmentCst()->getZExtValue();
494  }
495 
497  return cast<ConstantInt>(const_cast<Value*>(getArgOperand(4)));
498  }
499 
500  bool isVolatile() const {
501  return !getVolatileCst()->isZero();
502  }
503 
504  unsigned getDestAddressSpace() const {
505  return cast<PointerType>(getRawDest()->getType())->getAddressSpace();
506  }
507 
508  /// This is just like getRawDest, but it strips off any cast
509  /// instructions that feed it, giving the original input. The returned
510  /// value is guaranteed to be a pointer.
511  Value *getDest() const { return getRawDest()->stripPointerCasts(); }
512 
513  /// Set the specified arguments of the instruction.
514  void setDest(Value *Ptr) {
515  assert(getRawDest()->getType() == Ptr->getType() &&
516  "setDest called with pointer of wrong type!");
517  setArgOperand(0, Ptr);
518  }
519 
520  void setLength(Value *L) {
521  assert(getLength()->getType() == L->getType() &&
522  "setLength called with value of wrong type!");
523  setArgOperand(2, L);
524  }
525 
527  setArgOperand(3, A);
528  }
529 
531  setArgOperand(4, V);
532  }
533 
535  return getArgOperand(3)->getType();
536  }
537 
538  // Methods for support type inquiry through isa, cast, and dyn_cast:
539  static bool classof(const IntrinsicInst *I) {
540  switch (I->getIntrinsicID()) {
541  case Intrinsic::memcpy:
542  case Intrinsic::memmove:
543  case Intrinsic::memset:
544  return true;
545  default: return false;
546  }
547  }
548  static bool classof(const Value *V) {
549  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
550  }
551  };
552 
553  /// This class wraps the llvm.memset intrinsic.
554  class MemSetInst : public MemIntrinsic {
555  public:
556  /// Return the arguments to the instruction.
557  Value *getValue() const { return const_cast<Value*>(getArgOperand(1)); }
558  const Use &getValueUse() const { return getArgOperandUse(1); }
559  Use &getValueUse() { return getArgOperandUse(1); }
560 
561  void setValue(Value *Val) {
562  assert(getValue()->getType() == Val->getType() &&
563  "setValue called with value of wrong type!");
564  setArgOperand(1, Val);
565  }
566 
567  // Methods for support type inquiry through isa, cast, and dyn_cast:
568  static bool classof(const IntrinsicInst *I) {
569  return I->getIntrinsicID() == Intrinsic::memset;
570  }
571  static bool classof(const Value *V) {
572  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
573  }
574  };
575 
576  /// This class wraps the llvm.memcpy/memmove intrinsics.
577  class MemTransferInst : public MemIntrinsic {
578  public:
579  /// Return the arguments to the instruction.
580  Value *getRawSource() const { return const_cast<Value*>(getArgOperand(1)); }
581  const Use &getRawSourceUse() const { return getArgOperandUse(1); }
583 
584  /// This is just like getRawSource, but it strips off any cast
585  /// instructions that feed it, giving the original input. The returned
586  /// value is guaranteed to be a pointer.
587  Value *getSource() const { return getRawSource()->stripPointerCasts(); }
588 
589  unsigned getSourceAddressSpace() const {
590  return cast<PointerType>(getRawSource()->getType())->getAddressSpace();
591  }
592 
593  void setSource(Value *Ptr) {
594  assert(getRawSource()->getType() == Ptr->getType() &&
595  "setSource called with pointer of wrong type!");
596  setArgOperand(1, Ptr);
597  }
598 
599  // Methods for support type inquiry through isa, cast, and dyn_cast:
600  static bool classof(const IntrinsicInst *I) {
601  return I->getIntrinsicID() == Intrinsic::memcpy ||
602  I->getIntrinsicID() == Intrinsic::memmove;
603  }
604  static bool classof(const Value *V) {
605  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
606  }
607  };
608 
609  /// This class wraps the llvm.memcpy intrinsic.
610  class MemCpyInst : public MemTransferInst {
611  public:
612  // Methods for support type inquiry through isa, cast, and dyn_cast:
613  static bool classof(const IntrinsicInst *I) {
614  return I->getIntrinsicID() == Intrinsic::memcpy;
615  }
616  static bool classof(const Value *V) {
617  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
618  }
619  };
620 
621  /// This class wraps the llvm.memmove intrinsic.
622  class MemMoveInst : public MemTransferInst {
623  public:
624  // Methods for support type inquiry through isa, cast, and dyn_cast:
625  static bool classof(const IntrinsicInst *I) {
626  return I->getIntrinsicID() == Intrinsic::memmove;
627  }
628  static bool classof(const Value *V) {
629  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
630  }
631  };
632 
633  /// This represents the llvm.va_start intrinsic.
634  class VAStartInst : public IntrinsicInst {
635  public:
636  static bool classof(const IntrinsicInst *I) {
637  return I->getIntrinsicID() == Intrinsic::vastart;
638  }
639  static bool classof(const Value *V) {
640  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
641  }
642 
643  Value *getArgList() const { return const_cast<Value*>(getArgOperand(0)); }
644  };
645 
646  /// This represents the llvm.va_end intrinsic.
647  class VAEndInst : public IntrinsicInst {
648  public:
649  static bool classof(const IntrinsicInst *I) {
650  return I->getIntrinsicID() == Intrinsic::vaend;
651  }
652  static bool classof(const Value *V) {
653  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
654  }
655 
656  Value *getArgList() const { return const_cast<Value*>(getArgOperand(0)); }
657  };
658 
659  /// This represents the llvm.va_copy intrinsic.
660  class VACopyInst : public IntrinsicInst {
661  public:
662  static bool classof(const IntrinsicInst *I) {
663  return I->getIntrinsicID() == Intrinsic::vacopy;
664  }
665  static bool classof(const Value *V) {
666  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
667  }
668 
669  Value *getDest() const { return const_cast<Value*>(getArgOperand(0)); }
670  Value *getSrc() const { return const_cast<Value*>(getArgOperand(1)); }
671  };
672 
673  /// This represents the llvm.instrprof_increment intrinsic.
675  public:
676  static bool classof(const IntrinsicInst *I) {
677  return I->getIntrinsicID() == Intrinsic::instrprof_increment;
678  }
679  static bool classof(const Value *V) {
680  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
681  }
682 
684  return cast<GlobalVariable>(
685  const_cast<Value *>(getArgOperand(0))->stripPointerCasts());
686  }
687 
688  ConstantInt *getHash() const {
689  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
690  }
691 
693  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(2)));
694  }
695 
697  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
698  }
699 
700  Value *getStep() const;
701  };
702 
704  public:
705  static bool classof(const IntrinsicInst *I) {
706  return I->getIntrinsicID() == Intrinsic::instrprof_increment_step;
707  }
708  static bool classof(const Value *V) {
709  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
710  }
711  };
712 
713  /// This represents the llvm.instrprof_value_profile intrinsic.
715  public:
716  static bool classof(const IntrinsicInst *I) {
717  return I->getIntrinsicID() == Intrinsic::instrprof_value_profile;
718  }
719  static bool classof(const Value *V) {
720  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
721  }
722 
724  return cast<GlobalVariable>(
725  const_cast<Value *>(getArgOperand(0))->stripPointerCasts());
726  }
727 
728  ConstantInt *getHash() const {
729  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
730  }
731 
733  return cast<Value>(const_cast<Value *>(getArgOperand(2)));
734  }
735 
737  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
738  }
739 
740  // Returns the value site index.
742  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(4)));
743  }
744  };
745 
746 } // end namespace llvm
747 
748 #endif // LLVM_IR_INTRINSICINST_H
void setDest(Value *Ptr)
Set the specified arguments of the instruction.
static bool classof(const Value *V)
IntrinsicInst & operator=(const IntrinsicInst &)=delete
Value * getDest() const
This is just like getRawDest, but it strips off any cast instructions that feed it, giving the original input.
ConstantInt * getIndex() const
static bool classof(const IntrinsicInst *I)
Value * getSrc() const
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
unsigned getDestAddressSpace() const
This represents the llvm.va_end intrinsic.
Metadata * getRawVariable() const
Definition: IntrinsicInst.h:88
static bool classof(const Value *V)
ConstantInt * getElementSizeInBytesCst() const
const Use & getValueUse() const
Value * getSource() const
This is just like getRawSource, but it strips off any cast instructions that feed it...
This class represents a function call, abstracting a target machine&#39;s calling convention.
This file contains the declarations for metadata subclasses.
static bool classof(const CallInst *I)
Definition: IntrinsicInst.h:56
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:697
This class wraps the llvm.memset intrinsic.
void setVolatile(Constant *V)
void setValue(Value *Val)
static bool classof(const IntrinsicInst *I)
This is the common base class for constrained floating point intrinsics.
void setDest(Value *Ptr)
Set the specified arguments of the instruction.
void setAlignment(Constant *A)
Value * getArgList() const
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:98
Value * getRawSource() const
Return the arguments to the instruction.
This class wraps the llvm.memmove intrinsic.
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
Value * getSource() const
This is just like getRawSource, but it strips off any cast instructions that feed it...
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
Value * getRawSource() const
Return the arguments to the instruction.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
This represents the llvm.va_start intrinsic.
unsigned getSourceAddressSpace() const
static bool classof(const Value *V)
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:194
void setDest(Value *Ptr)
Set the specified arguments of the instruction.
static bool classof(const Value *V)
GlobalVariable * getName() const
ConstantInt * getNumCounters() const
static bool classof(const Value *V)
static bool classof(const Value *V)
Metadata * getRawExpression() const
Definition: IntrinsicInst.h:92
ConstantInt * getHash() const
const Use & getLengthUse() const
static bool classof(const Value *V)
ConstantInt * getIndex() const
static bool classof(const IntrinsicInst *I)
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
bool isAddressOfVariable() const
Does this describe the address of a local variable.
Definition: IntrinsicInst.h:76
Value * getAddress() const
This is an important base class in LLVM.
Definition: Constant.h:42
ConstantInt * getElementSizeInBytesCst() const
Value * getValue() const
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static bool classof(const Value *V)
Value * getRawDest() const
DILocalVariable * getVariable() const
Definition: IntrinsicInst.h:80
static bool classof(const Value *V)
DIExpression * getExpression() const
Definition: IntrinsicInst.h:84
static bool classof(const IntrinsicInst *I)
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
const Use & getArgOperandUse(unsigned i) const
Wrappers for getting the Use of a call argument.
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs, and aliases.
Definition: Value.cpp:527
This represents the llvm.dbg.addr instruction.
static bool classof(const IntrinsicInst *I)
Type * getAlignmentType() const
bool isVolatile() const
ConstantInt * getVolatileCst() const
static bool classof(const IntrinsicInst *I)
Intrinsic::ID getIntrinsicID() const
Return the intrinsic ID of this intrinsic.
Definition: IntrinsicInst.h:51
This is the common base class for memset/memcpy/memmove.
Value * getDest() const
This is just like getRawDest, but it strips off any cast instructions that feed it, giving the original input.
This is the shared class of boolean and integer constants.
Definition: Constants.h:84
Value * getArgList() const
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
This is the common base class for debug info intrinsics.
Definition: IntrinsicInst.h:67
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
This class wraps the llvm.memcpy intrinsic.
static bool classof(const Value *V)
This class represents atomic memset intrinsic TODO: Integrate this class into MemIntrinsic hierarchy;...
DWARF expression.
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
Definition: Function.h:175
This class represents atomic memcpy intrinsic TODO: Integrate this class into MemIntrinsic hierarchy;...
static bool classof(const Value *V)
ConstantInt * getAlignmentCst() const
static bool classof(const IntrinsicInst *I)
Value * getDest() const
void setLength(Value *L)
This represents the llvm.instrprof_increment intrinsic.
Function * getCalledFunction() const
Return the function called, or null if this is an indirect function invocation.
This class wraps the llvm.memcpy/memmove intrinsics.
void setDest(Value *Ptr)
Set the specified arguments of the instruction.
This represents the llvm.dbg.value instruction.
ConstantInt * getHash() const
Value * getArgOperand(unsigned i) const
getArgOperand/setArgOperand - Return/set the i-th call argument.
Value * getDest() const
This is just like getRawDest, but it strips off any cast instructions that feed it, giving the original input.
#define I(x, y, z)
Definition: MD5.cpp:58
void setArgOperand(unsigned i, Value *v)
Value * getSource() const
This is just like getRawSource, but it strips off any cast instructions that feed it...
void setSource(Value *Ptr)
Value * getDest() const
This is just like getRawDest, but it strips off any cast instructions that feed it, giving the original input.
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
Value * getValue() const
Return the arguments to the instruction.
static bool classof(const Value *V)
Definition: IntrinsicInst.h:61
unsigned getAlignment() const
static bool classof(const IntrinsicInst *I)
static bool classof(const IntrinsicInst *I)
This represents the llvm.va_copy intrinsic.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Value * getLength() const
LLVM Value Representation.
Definition: Value.h:73
ConstantInt * getElementSizeInBytesCst() const
GlobalVariable * getName() const
Value * getRawSource() const
Return the arguments to the instruction.
static bool classof(const Value *V)
ConstantInt * getValueKind() const
static bool classof(const Value *V)
const Use & getRawDestUse() const
This represents the llvm.instrprof_value_profile intrinsic.
const Use & getRawSourceUse() const
This represents the llvm.dbg.declare instruction.
Root of the metadata hierarchy.
Definition: Metadata.h:58
static IntegerType * getInt8Ty(LLVMContext &C)
Definition: Type.cpp:174
static bool classof(const IntrinsicInst *I)
static bool classof(const IntrinsicInst *I)
static bool classof(const IntrinsicInst *I)
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:44
Value * getAddress() const