LLVM  14.0.0git
IntrinsicInst.h
Go to the documentation of this file.
1 //===-- llvm/IntrinsicInst.h - Intrinsic Instruction Wrappers ---*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines classes that make it really easy to deal with intrinsic
10 // functions with the isa/dyncast family of functions. In particular, this
11 // allows you to do things like:
12 //
13 // if (MemCpyInst *MCI = dyn_cast<MemCpyInst>(Inst))
14 // ... MCI->getDest() ... MCI->getSource() ...
15 //
16 // All intrinsic function calls are instances of the call instruction, so these
17 // are all subclasses of the CallInst class. Note that none of these classes
18 // has state or virtual methods, which is an important part of this gross/neat
19 // hack working.
20 //
21 //===----------------------------------------------------------------------===//
22 
23 #ifndef LLVM_IR_INTRINSICINST_H
24 #define LLVM_IR_INTRINSICINST_H
25 
26 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/DerivedTypes.h"
29 #include "llvm/IR/FPEnv.h"
30 #include "llvm/IR/Function.h"
31 #include "llvm/IR/GlobalVariable.h"
32 #include "llvm/IR/Instructions.h"
33 #include "llvm/IR/Intrinsics.h"
34 #include "llvm/IR/Metadata.h"
35 #include "llvm/IR/Value.h"
36 #include "llvm/Support/Casting.h"
37 #include <cassert>
38 #include <cstdint>
39 
40 namespace llvm {
41 
42 /// A wrapper class for inspecting calls to intrinsic functions.
43 /// This allows the standard isa/dyncast/cast functionality to work with calls
44 /// to intrinsic functions.
45 class IntrinsicInst : public CallInst {
46 public:
47  IntrinsicInst() = delete;
48  IntrinsicInst(const IntrinsicInst &) = delete;
49  IntrinsicInst &operator=(const IntrinsicInst &) = delete;
50 
51  /// Return the intrinsic ID of this intrinsic.
54  }
55 
56  /// Return true if swapping the first two arguments to the intrinsic produces
57  /// the same result.
58  bool isCommutative() const {
59  switch (getIntrinsicID()) {
60  case Intrinsic::maxnum:
61  case Intrinsic::minnum:
62  case Intrinsic::maximum:
63  case Intrinsic::minimum:
64  case Intrinsic::smax:
65  case Intrinsic::smin:
66  case Intrinsic::umax:
67  case Intrinsic::umin:
68  case Intrinsic::sadd_sat:
69  case Intrinsic::uadd_sat:
70  case Intrinsic::sadd_with_overflow:
71  case Intrinsic::uadd_with_overflow:
72  case Intrinsic::smul_with_overflow:
73  case Intrinsic::umul_with_overflow:
74  case Intrinsic::smul_fix:
75  case Intrinsic::umul_fix:
76  case Intrinsic::smul_fix_sat:
77  case Intrinsic::umul_fix_sat:
78  case Intrinsic::fma:
79  case Intrinsic::fmuladd:
80  return true;
81  default:
82  return false;
83  }
84  }
85 
86  // Checks if the intrinsic is an annotation.
87  bool isAssumeLikeIntrinsic() const {
88  switch (getIntrinsicID()) {
89  default: break;
90  case Intrinsic::assume:
91  case Intrinsic::sideeffect:
92  case Intrinsic::pseudoprobe:
93  case Intrinsic::dbg_declare:
94  case Intrinsic::dbg_value:
95  case Intrinsic::dbg_label:
96  case Intrinsic::invariant_start:
97  case Intrinsic::invariant_end:
98  case Intrinsic::lifetime_start:
99  case Intrinsic::lifetime_end:
100  case Intrinsic::experimental_noalias_scope_decl:
101  case Intrinsic::objectsize:
102  case Intrinsic::ptr_annotation:
103  case Intrinsic::var_annotation:
104  return true;
105  }
106  return false;
107  }
108 
109  // Methods for support type inquiry through isa, cast, and dyn_cast:
110  static bool classof(const CallInst *I) {
111  if (const Function *CF = I->getCalledFunction())
112  return CF->isIntrinsic();
113  return false;
114  }
115  static bool classof(const Value *V) {
116  return isa<CallInst>(V) && classof(cast<CallInst>(V));
117  }
118 };
119 
120 /// Check if \p ID corresponds to a debug info intrinsic.
121 static inline bool isDbgInfoIntrinsic(Intrinsic::ID ID) {
122  switch (ID) {
123  case Intrinsic::dbg_declare:
124  case Intrinsic::dbg_value:
125  case Intrinsic::dbg_addr:
126  case Intrinsic::dbg_label:
127  return true;
128  default:
129  return false;
130  }
131 }
132 
133 /// This is the common base class for debug info intrinsics.
135 public:
136  /// \name Casting methods
137  /// @{
138  static bool classof(const IntrinsicInst *I) {
139  return isDbgInfoIntrinsic(I->getIntrinsicID());
140  }
141  static bool classof(const Value *V) {
142  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
143  }
144  /// @}
145 };
146 
147 /// This is the common base class for debug info intrinsics for variables.
149 public:
150  // Iterator for ValueAsMetadata that internally uses direct pointer iteration
151  // over either a ValueAsMetadata* or a ValueAsMetadata**, dereferencing to the
152  // ValueAsMetadata .
154  : public iterator_facade_base<location_op_iterator,
155  std::bidirectional_iterator_tag, Value *> {
157 
158  public:
159  location_op_iterator(ValueAsMetadata *SingleIter) : I(SingleIter) {}
160  location_op_iterator(ValueAsMetadata **MultiIter) : I(MultiIter) {}
161 
164  I = R.I;
165  return *this;
166  }
167  bool operator==(const location_op_iterator &RHS) const {
168  return I == RHS.I;
169  }
170  const Value *operator*() const {
171  ValueAsMetadata *VAM = I.is<ValueAsMetadata *>()
172  ? I.get<ValueAsMetadata *>()
173  : *I.get<ValueAsMetadata **>();
174  return VAM->getValue();
175  };
177  ValueAsMetadata *VAM = I.is<ValueAsMetadata *>()
178  ? I.get<ValueAsMetadata *>()
179  : *I.get<ValueAsMetadata **>();
180  return VAM->getValue();
181  }
183  if (I.is<ValueAsMetadata *>())
184  I = I.get<ValueAsMetadata *>() + 1;
185  else
186  I = I.get<ValueAsMetadata **>() + 1;
187  return *this;
188  }
190  if (I.is<ValueAsMetadata *>())
191  I = I.get<ValueAsMetadata *>() - 1;
192  else
193  I = I.get<ValueAsMetadata **>() - 1;
194  return *this;
195  }
196  };
197 
198  /// Get the locations corresponding to the variable referenced by the debug
199  /// info intrinsic. Depending on the intrinsic, this could be the
200  /// variable's value or its address.
202 
203  Value *getVariableLocationOp(unsigned OpIdx) const;
204 
205  void replaceVariableLocationOp(Value *OldValue, Value *NewValue);
206  void replaceVariableLocationOp(unsigned OpIdx, Value *NewValue);
207  /// Adding a new location operand will always result in this intrinsic using
208  /// an ArgList, and must always be accompanied by a new expression that uses
209  /// the new operand.
212 
213  void setVariable(DILocalVariable *NewVar) {
214  setArgOperand(1, MetadataAsValue::get(NewVar->getContext(), NewVar));
215  }
216 
218  setArgOperand(2, MetadataAsValue::get(NewExpr->getContext(), NewExpr));
219  }
220 
221  unsigned getNumVariableLocationOps() const {
222  if (hasArgList())
223  return cast<DIArgList>(getRawLocation())->getArgs().size();
224  return 1;
225  }
226 
227  bool hasArgList() const { return isa<DIArgList>(getRawLocation()); }
228 
229  /// Does this describe the address of a local variable. True for dbg.addr
230  /// and dbg.declare, but not dbg.value, which describes its value.
231  bool isAddressOfVariable() const {
232  return getIntrinsicID() != Intrinsic::dbg_value;
233  }
234 
235  void setUndef() {
236  // TODO: When/if we remove duplicate values from DIArgLists, we don't need
237  // this set anymore.
238  SmallPtrSet<Value *, 4> RemovedValues;
239  for (Value *OldValue : location_ops()) {
240  if (!RemovedValues.insert(OldValue).second)
241  continue;
242  Value *Undef = UndefValue::get(OldValue->getType());
243  replaceVariableLocationOp(OldValue, Undef);
244  }
245  }
246 
247  bool isUndef() const {
248  return (getNumVariableLocationOps() == 0 &&
249  !getExpression()->isComplex()) ||
250  any_of(location_ops(), [](Value *V) { return isa<UndefValue>(V); });
251  }
252 
254  return cast<DILocalVariable>(getRawVariable());
255  }
256 
258  return cast<DIExpression>(getRawExpression());
259  }
260 
262  return cast<MetadataAsValue>(getArgOperand(0))->getMetadata();
263  }
264 
266  return cast<MetadataAsValue>(getArgOperand(1))->getMetadata();
267  }
268 
270  return cast<MetadataAsValue>(getArgOperand(2))->getMetadata();
271  }
272 
273  /// Use of this should generally be avoided; instead,
274  /// replaceVariableLocationOp and addVariableLocationOps should be used where
275  /// possible to avoid creating invalid state.
276  void setRawLocation(Metadata *Location) {
277  return setArgOperand(0, MetadataAsValue::get(getContext(), Location));
278  }
279 
280  /// Get the size (in bits) of the variable, or fragment of the variable that
281  /// is described.
283 
284  /// \name Casting methods
285  /// @{
286  static bool classof(const IntrinsicInst *I) {
287  switch (I->getIntrinsicID()) {
288  case Intrinsic::dbg_declare:
289  case Intrinsic::dbg_value:
290  case Intrinsic::dbg_addr:
291  return true;
292  default:
293  return false;
294  }
295  }
296  static bool classof(const Value *V) {
297  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
298  }
299  /// @}
300 private:
301  void setArgOperand(unsigned i, Value *v) {
303  }
304  void setOperand(unsigned i, Value *v) { DbgInfoIntrinsic::setOperand(i, v); }
305 };
306 
307 /// This represents the llvm.dbg.declare instruction.
309 public:
310  Value *getAddress() const {
312  "dbg.declare must have exactly 1 location operand.");
313  return getVariableLocationOp(0);
314  }
315 
316  /// \name Casting methods
317  /// @{
318  static bool classof(const IntrinsicInst *I) {
319  return I->getIntrinsicID() == Intrinsic::dbg_declare;
320  }
321  static bool classof(const Value *V) {
322  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
323  }
324  /// @}
325 };
326 
327 /// This represents the llvm.dbg.addr instruction.
329 public:
330  Value *getAddress() const {
332  "dbg.addr must have exactly 1 location operand.");
333  return getVariableLocationOp(0);
334  }
335 
336  /// \name Casting methods
337  /// @{
338  static bool classof(const IntrinsicInst *I) {
339  return I->getIntrinsicID() == Intrinsic::dbg_addr;
340  }
341  static bool classof(const Value *V) {
342  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
343  }
344 };
345 
346 /// This represents the llvm.dbg.value instruction.
348 public:
349  // The default argument should only be used in ISel, and the default option
350  // should be removed once ISel support for multiple location ops is complete.
351  Value *getValue(unsigned OpIdx = 0) const {
352  return getVariableLocationOp(OpIdx);
353  }
355  return location_ops();
356  }
357 
358  /// \name Casting methods
359  /// @{
360  static bool classof(const IntrinsicInst *I) {
361  return I->getIntrinsicID() == Intrinsic::dbg_value;
362  }
363  static bool classof(const Value *V) {
364  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
365  }
366  /// @}
367 };
368 
369 /// This represents the llvm.dbg.label instruction.
371 public:
372  DILabel *getLabel() const { return cast<DILabel>(getRawLabel()); }
373 
375  return cast<MetadataAsValue>(getArgOperand(0))->getMetadata();
376  }
377 
378  /// Methods for support type inquiry through isa, cast, and dyn_cast:
379  /// @{
380  static bool classof(const IntrinsicInst *I) {
381  return I->getIntrinsicID() == Intrinsic::dbg_label;
382  }
383  static bool classof(const Value *V) {
384  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
385  }
386  /// @}
387 };
388 
389 /// This is the common base class for vector predication intrinsics.
390 class VPIntrinsic : public IntrinsicInst {
391 public:
392  /// \brief Declares a llvm.vp.* intrinsic in \p M that matches the parameters
393  /// \p Params.
395  ArrayRef<Value *> Params);
396 
399 
400  /// The llvm.vp.* intrinsics for this instruction Opcode
401  static Intrinsic::ID getForOpcode(unsigned OC);
402 
403  // Whether \p ID is a VP intrinsic ID.
404  static bool isVPIntrinsic(Intrinsic::ID);
405 
406  /// \return The mask parameter or nullptr.
407  Value *getMaskParam() const;
408  void setMaskParam(Value *);
409 
410  /// \return The vector length parameter or nullptr.
411  Value *getVectorLengthParam() const;
412  void setVectorLengthParam(Value *);
413 
414  /// \return Whether the vector length param can be ignored.
415  bool canIgnoreVectorLengthParam() const;
416 
417  /// \return The static element count (vector number of elements) the vector
418  /// length parameter applies to.
420 
421  /// \return The alignment of the pointer used by this load/store/gather or
422  /// scatter.
424  // MaybeAlign setPointerAlignment(Align NewAlign); // TODO
425 
426  /// \return The pointer operand of this load,store, gather or scatter.
427  Value *getMemoryPointerParam() const;
429 
430  /// \return The data (payload) operand of this store or scatter.
431  Value *getMemoryDataParam() const;
433 
434  // Methods for support type inquiry through isa, cast, and dyn_cast:
435  static bool classof(const IntrinsicInst *I) {
436  return isVPIntrinsic(I->getIntrinsicID());
437  }
438  static bool classof(const Value *V) {
439  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
440  }
441 
442  // Equivalent non-predicated opcode
445  }
446 
447  // Equivalent non-predicated opcode
449 };
450 
451 /// This is the common base class for constrained floating point intrinsics.
453 public:
454  bool isUnaryOp() const;
455  bool isTernaryOp() const;
458  bool isDefaultFPEnvironment() const;
459 
460  // Methods for support type inquiry through isa, cast, and dyn_cast:
461  static bool classof(const IntrinsicInst *I);
462  static bool classof(const Value *V) {
463  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
464  }
465 };
466 
467 /// Constrained floating point compare intrinsics.
469 public:
471 
472  // Methods for support type inquiry through isa, cast, and dyn_cast:
473  static bool classof(const IntrinsicInst *I) {
474  switch (I->getIntrinsicID()) {
475  case Intrinsic::experimental_constrained_fcmp:
476  case Intrinsic::experimental_constrained_fcmps:
477  return true;
478  default:
479  return false;
480  }
481  }
482  static bool classof(const Value *V) {
483  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
484  }
485 };
486 
487 /// This class represents min/max intrinsics.
489 public:
490  static bool classof(const IntrinsicInst *I) {
491  switch (I->getIntrinsicID()) {
492  case Intrinsic::umin:
493  case Intrinsic::umax:
494  case Intrinsic::smin:
495  case Intrinsic::smax:
496  return true;
497  default:
498  return false;
499  }
500  }
501  static bool classof(const Value *V) {
502  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
503  }
504 
505  Value *getLHS() const { return const_cast<Value *>(getArgOperand(0)); }
506  Value *getRHS() const { return const_cast<Value *>(getArgOperand(1)); }
507 
508  /// Returns the comparison predicate underlying the intrinsic.
510  switch (getIntrinsicID()) {
511  case Intrinsic::umin:
512  return ICmpInst::Predicate::ICMP_ULT;
513  case Intrinsic::umax:
514  return ICmpInst::Predicate::ICMP_UGT;
515  case Intrinsic::smin:
516  return ICmpInst::Predicate::ICMP_SLT;
517  case Intrinsic::smax:
518  return ICmpInst::Predicate::ICMP_SGT;
519  default:
520  llvm_unreachable("Invalid intrinsic");
521  }
522  }
523 
524  /// Whether the intrinsic is signed or unsigned.
525  bool isSigned() const { return ICmpInst::isSigned(getPredicate()); };
526 };
527 
528 /// This class represents an intrinsic that is based on a binary operation.
529 /// This includes op.with.overflow and saturating add/sub intrinsics.
531 public:
532  static bool classof(const IntrinsicInst *I) {
533  switch (I->getIntrinsicID()) {
534  case Intrinsic::uadd_with_overflow:
535  case Intrinsic::sadd_with_overflow:
536  case Intrinsic::usub_with_overflow:
537  case Intrinsic::ssub_with_overflow:
538  case Intrinsic::umul_with_overflow:
539  case Intrinsic::smul_with_overflow:
540  case Intrinsic::uadd_sat:
541  case Intrinsic::sadd_sat:
542  case Intrinsic::usub_sat:
543  case Intrinsic::ssub_sat:
544  return true;
545  default:
546  return false;
547  }
548  }
549  static bool classof(const Value *V) {
550  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
551  }
552 
553  Value *getLHS() const { return const_cast<Value *>(getArgOperand(0)); }
554  Value *getRHS() const { return const_cast<Value *>(getArgOperand(1)); }
555 
556  /// Returns the binary operation underlying the intrinsic.
558 
559  /// Whether the intrinsic is signed or unsigned.
560  bool isSigned() const;
561 
562  /// Returns one of OBO::NoSignedWrap or OBO::NoUnsignedWrap.
563  unsigned getNoWrapKind() const;
564 };
565 
566 /// Represents an op.with.overflow intrinsic.
568 public:
569  static bool classof(const IntrinsicInst *I) {
570  switch (I->getIntrinsicID()) {
571  case Intrinsic::uadd_with_overflow:
572  case Intrinsic::sadd_with_overflow:
573  case Intrinsic::usub_with_overflow:
574  case Intrinsic::ssub_with_overflow:
575  case Intrinsic::umul_with_overflow:
576  case Intrinsic::smul_with_overflow:
577  return true;
578  default:
579  return false;
580  }
581  }
582  static bool classof(const Value *V) {
583  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
584  }
585 };
586 
587 /// Represents a saturating add/sub intrinsic.
589 public:
590  static bool classof(const IntrinsicInst *I) {
591  switch (I->getIntrinsicID()) {
592  case Intrinsic::uadd_sat:
593  case Intrinsic::sadd_sat:
594  case Intrinsic::usub_sat:
595  case Intrinsic::ssub_sat:
596  return true;
597  default:
598  return false;
599  }
600  }
601  static bool classof(const Value *V) {
602  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
603  }
604 };
605 
606 /// Common base class for all memory intrinsics. Simply provides
607 /// common methods.
608 /// Written as CRTP to avoid a common base class amongst the
609 /// three atomicity hierarchies.
610 template <typename Derived> class MemIntrinsicBase : public IntrinsicInst {
611 private:
612  enum { ARG_DEST = 0, ARG_LENGTH = 2 };
613 
614 public:
615  Value *getRawDest() const {
616  return const_cast<Value *>(getArgOperand(ARG_DEST));
617  }
618  const Use &getRawDestUse() const { return getArgOperandUse(ARG_DEST); }
619  Use &getRawDestUse() { return getArgOperandUse(ARG_DEST); }
620 
621  Value *getLength() const {
622  return const_cast<Value *>(getArgOperand(ARG_LENGTH));
623  }
624  const Use &getLengthUse() const { return getArgOperandUse(ARG_LENGTH); }
625  Use &getLengthUse() { return getArgOperandUse(ARG_LENGTH); }
626 
627  /// This is just like getRawDest, but it strips off any cast
628  /// instructions (including addrspacecast) that feed it, giving the
629  /// original input. The returned value is guaranteed to be a pointer.
630  Value *getDest() const { return getRawDest()->stripPointerCasts(); }
631 
632  unsigned getDestAddressSpace() const {
633  return cast<PointerType>(getRawDest()->getType())->getAddressSpace();
634  }
635 
636  /// FIXME: Remove this function once transition to Align is over.
637  /// Use getDestAlign() instead.
638  unsigned getDestAlignment() const {
639  if (auto MA = getParamAlign(ARG_DEST))
640  return MA->value();
641  return 0;
642  }
643  MaybeAlign getDestAlign() const { return getParamAlign(ARG_DEST); }
644 
645  /// Set the specified arguments of the instruction.
646  void setDest(Value *Ptr) {
647  assert(getRawDest()->getType() == Ptr->getType() &&
648  "setDest called with pointer of wrong type!");
649  setArgOperand(ARG_DEST, Ptr);
650  }
651 
652  /// FIXME: Remove this function once transition to Align is over.
653  /// Use the version that takes MaybeAlign instead of this one.
654  void setDestAlignment(unsigned Alignment) {
655  setDestAlignment(MaybeAlign(Alignment));
656  }
657  void setDestAlignment(MaybeAlign Alignment) {
658  removeParamAttr(ARG_DEST, Attribute::Alignment);
659  if (Alignment)
660  addParamAttr(ARG_DEST,
661  Attribute::getWithAlignment(getContext(), *Alignment));
662  }
663  void setDestAlignment(Align Alignment) {
664  removeParamAttr(ARG_DEST, Attribute::Alignment);
665  addParamAttr(ARG_DEST,
667  }
668 
669  void setLength(Value *L) {
670  assert(getLength()->getType() == L->getType() &&
671  "setLength called with value of wrong type!");
672  setArgOperand(ARG_LENGTH, L);
673  }
674 };
675 
676 /// Common base class for all memory transfer intrinsics. Simply provides
677 /// common methods.
678 template <class BaseCL> class MemTransferBase : public BaseCL {
679 private:
680  enum { ARG_SOURCE = 1 };
681 
682 public:
683  /// Return the arguments to the instruction.
684  Value *getRawSource() const {
685  return const_cast<Value *>(BaseCL::getArgOperand(ARG_SOURCE));
686  }
687  const Use &getRawSourceUse() const {
688  return BaseCL::getArgOperandUse(ARG_SOURCE);
689  }
690  Use &getRawSourceUse() { return BaseCL::getArgOperandUse(ARG_SOURCE); }
691 
692  /// This is just like getRawSource, but it strips off any cast
693  /// instructions that feed it, giving the original input. The returned
694  /// value is guaranteed to be a pointer.
695  Value *getSource() const { return getRawSource()->stripPointerCasts(); }
696 
697  unsigned getSourceAddressSpace() const {
698  return cast<PointerType>(getRawSource()->getType())->getAddressSpace();
699  }
700 
701  /// FIXME: Remove this function once transition to Align is over.
702  /// Use getSourceAlign() instead.
703  unsigned getSourceAlignment() const {
704  if (auto MA = BaseCL::getParamAlign(ARG_SOURCE))
705  return MA->value();
706  return 0;
707  }
708 
710  return BaseCL::getParamAlign(ARG_SOURCE);
711  }
712 
713  void setSource(Value *Ptr) {
714  assert(getRawSource()->getType() == Ptr->getType() &&
715  "setSource called with pointer of wrong type!");
716  BaseCL::setArgOperand(ARG_SOURCE, Ptr);
717  }
718 
719  /// FIXME: Remove this function once transition to Align is over.
720  /// Use the version that takes MaybeAlign instead of this one.
721  void setSourceAlignment(unsigned Alignment) {
722  setSourceAlignment(MaybeAlign(Alignment));
723  }
724  void setSourceAlignment(MaybeAlign Alignment) {
725  BaseCL::removeParamAttr(ARG_SOURCE, Attribute::Alignment);
726  if (Alignment)
727  BaseCL::addParamAttr(ARG_SOURCE, Attribute::getWithAlignment(
728  BaseCL::getContext(), *Alignment));
729  }
730  void setSourceAlignment(Align Alignment) {
731  BaseCL::removeParamAttr(ARG_SOURCE, Attribute::Alignment);
732  BaseCL::addParamAttr(ARG_SOURCE, Attribute::getWithAlignment(
733  BaseCL::getContext(), Alignment));
734  }
735 };
736 
737 /// Common base class for all memset intrinsics. Simply provides
738 /// common methods.
739 template <class BaseCL> class MemSetBase : public BaseCL {
740 private:
741  enum { ARG_VALUE = 1 };
742 
743 public:
744  Value *getValue() const {
745  return const_cast<Value *>(BaseCL::getArgOperand(ARG_VALUE));
746  }
747  const Use &getValueUse() const { return BaseCL::getArgOperandUse(ARG_VALUE); }
748  Use &getValueUse() { return BaseCL::getArgOperandUse(ARG_VALUE); }
749 
750  void setValue(Value *Val) {
751  assert(getValue()->getType() == Val->getType() &&
752  "setValue called with value of wrong type!");
753  BaseCL::setArgOperand(ARG_VALUE, Val);
754  }
755 };
756 
757 // The common base class for the atomic memset/memmove/memcpy intrinsics
758 // i.e. llvm.element.unordered.atomic.memset/memcpy/memmove
759 class AtomicMemIntrinsic : public MemIntrinsicBase<AtomicMemIntrinsic> {
760 private:
761  enum { ARG_ELEMENTSIZE = 3 };
762 
763 public:
765  return const_cast<Value *>(getArgOperand(ARG_ELEMENTSIZE));
766  }
767 
769  return cast<ConstantInt>(getRawElementSizeInBytes());
770  }
771 
774  }
775 
778  "setElementSizeInBytes called with value of wrong type!");
779  setArgOperand(ARG_ELEMENTSIZE, V);
780  }
781 
782  static bool classof(const IntrinsicInst *I) {
783  switch (I->getIntrinsicID()) {
784  case Intrinsic::memcpy_element_unordered_atomic:
785  case Intrinsic::memmove_element_unordered_atomic:
786  case Intrinsic::memset_element_unordered_atomic:
787  return true;
788  default:
789  return false;
790  }
791  }
792  static bool classof(const Value *V) {
793  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
794  }
795 };
796 
797 /// This class represents atomic memset intrinsic
798 // i.e. llvm.element.unordered.atomic.memset
799 class AtomicMemSetInst : public MemSetBase<AtomicMemIntrinsic> {
800 public:
801  static bool classof(const IntrinsicInst *I) {
802  return I->getIntrinsicID() == Intrinsic::memset_element_unordered_atomic;
803  }
804  static bool classof(const Value *V) {
805  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
806  }
807 };
808 
809 // This class wraps the atomic memcpy/memmove intrinsics
810 // i.e. llvm.element.unordered.atomic.memcpy/memmove
811 class AtomicMemTransferInst : public MemTransferBase<AtomicMemIntrinsic> {
812 public:
813  static bool classof(const IntrinsicInst *I) {
814  switch (I->getIntrinsicID()) {
815  case Intrinsic::memcpy_element_unordered_atomic:
816  case Intrinsic::memmove_element_unordered_atomic:
817  return true;
818  default:
819  return false;
820  }
821  }
822  static bool classof(const Value *V) {
823  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
824  }
825 };
826 
827 /// This class represents the atomic memcpy intrinsic
828 /// i.e. llvm.element.unordered.atomic.memcpy
830 public:
831  static bool classof(const IntrinsicInst *I) {
832  return I->getIntrinsicID() == Intrinsic::memcpy_element_unordered_atomic;
833  }
834  static bool classof(const Value *V) {
835  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
836  }
837 };
838 
839 /// This class represents the atomic memmove intrinsic
840 /// i.e. llvm.element.unordered.atomic.memmove
842 public:
843  static bool classof(const IntrinsicInst *I) {
844  return I->getIntrinsicID() == Intrinsic::memmove_element_unordered_atomic;
845  }
846  static bool classof(const Value *V) {
847  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
848  }
849 };
850 
851 /// This is the common base class for memset/memcpy/memmove.
852 class MemIntrinsic : public MemIntrinsicBase<MemIntrinsic> {
853 private:
854  enum { ARG_VOLATILE = 3 };
855 
856 public:
858  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(ARG_VOLATILE)));
859  }
860 
861  bool isVolatile() const { return !getVolatileCst()->isZero(); }
862 
863  void setVolatile(Constant *V) { setArgOperand(ARG_VOLATILE, V); }
864 
865  // Methods for support type inquiry through isa, cast, and dyn_cast:
866  static bool classof(const IntrinsicInst *I) {
867  switch (I->getIntrinsicID()) {
868  case Intrinsic::memcpy:
869  case Intrinsic::memmove:
870  case Intrinsic::memset:
871  case Intrinsic::memcpy_inline:
872  return true;
873  default:
874  return false;
875  }
876  }
877  static bool classof(const Value *V) {
878  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
879  }
880 };
881 
882 /// This class wraps the llvm.memset intrinsic.
883 class MemSetInst : public MemSetBase<MemIntrinsic> {
884 public:
885  // Methods for support type inquiry through isa, cast, and dyn_cast:
886  static bool classof(const IntrinsicInst *I) {
887  return I->getIntrinsicID() == Intrinsic::memset;
888  }
889  static bool classof(const Value *V) {
890  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
891  }
892 };
893 
894 /// This class wraps the llvm.memcpy/memmove intrinsics.
895 class MemTransferInst : public MemTransferBase<MemIntrinsic> {
896 public:
897  // Methods for support type inquiry through isa, cast, and dyn_cast:
898  static bool classof(const IntrinsicInst *I) {
899  switch (I->getIntrinsicID()) {
900  case Intrinsic::memcpy:
901  case Intrinsic::memmove:
902  case Intrinsic::memcpy_inline:
903  return true;
904  default:
905  return false;
906  }
907  }
908  static bool classof(const Value *V) {
909  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
910  }
911 };
912 
913 /// This class wraps the llvm.memcpy intrinsic.
914 class MemCpyInst : public MemTransferInst {
915 public:
916  // Methods for support type inquiry through isa, cast, and dyn_cast:
917  static bool classof(const IntrinsicInst *I) {
918  return I->getIntrinsicID() == Intrinsic::memcpy ||
919  I->getIntrinsicID() == Intrinsic::memcpy_inline;
920  }
921  static bool classof(const Value *V) {
922  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
923  }
924 };
925 
926 /// This class wraps the llvm.memmove intrinsic.
927 class MemMoveInst : public MemTransferInst {
928 public:
929  // Methods for support type inquiry through isa, cast, and dyn_cast:
930  static bool classof(const IntrinsicInst *I) {
931  return I->getIntrinsicID() == Intrinsic::memmove;
932  }
933  static bool classof(const Value *V) {
934  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
935  }
936 };
937 
938 /// This class wraps the llvm.memcpy.inline intrinsic.
939 class MemCpyInlineInst : public MemCpyInst {
940 public:
942  return cast<ConstantInt>(MemCpyInst::getLength());
943  }
944  // Methods for support type inquiry through isa, cast, and dyn_cast:
945  static bool classof(const IntrinsicInst *I) {
946  return I->getIntrinsicID() == Intrinsic::memcpy_inline;
947  }
948  static bool classof(const Value *V) {
949  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
950  }
951 };
952 
953 // The common base class for any memset/memmove/memcpy intrinsics;
954 // whether they be atomic or non-atomic.
955 // i.e. llvm.element.unordered.atomic.memset/memcpy/memmove
956 // and llvm.memset/memcpy/memmove
957 class AnyMemIntrinsic : public MemIntrinsicBase<AnyMemIntrinsic> {
958 public:
959  bool isVolatile() const {
960  // Only the non-atomic intrinsics can be volatile
961  if (auto *MI = dyn_cast<MemIntrinsic>(this))
962  return MI->isVolatile();
963  return false;
964  }
965 
966  static bool classof(const IntrinsicInst *I) {
967  switch (I->getIntrinsicID()) {
968  case Intrinsic::memcpy:
969  case Intrinsic::memcpy_inline:
970  case Intrinsic::memmove:
971  case Intrinsic::memset:
972  case Intrinsic::memcpy_element_unordered_atomic:
973  case Intrinsic::memmove_element_unordered_atomic:
974  case Intrinsic::memset_element_unordered_atomic:
975  return true;
976  default:
977  return false;
978  }
979  }
980  static bool classof(const Value *V) {
981  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
982  }
983 };
984 
985 /// This class represents any memset intrinsic
986 // i.e. llvm.element.unordered.atomic.memset
987 // and llvm.memset
988 class AnyMemSetInst : public MemSetBase<AnyMemIntrinsic> {
989 public:
990  static bool classof(const IntrinsicInst *I) {
991  switch (I->getIntrinsicID()) {
992  case Intrinsic::memset:
993  case Intrinsic::memset_element_unordered_atomic:
994  return true;
995  default:
996  return false;
997  }
998  }
999  static bool classof(const Value *V) {
1000  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1001  }
1002 };
1003 
1004 // This class wraps any memcpy/memmove intrinsics
1005 // i.e. llvm.element.unordered.atomic.memcpy/memmove
1006 // and llvm.memcpy/memmove
1007 class AnyMemTransferInst : public MemTransferBase<AnyMemIntrinsic> {
1008 public:
1009  static bool classof(const IntrinsicInst *I) {
1010  switch (I->getIntrinsicID()) {
1011  case Intrinsic::memcpy:
1012  case Intrinsic::memcpy_inline:
1013  case Intrinsic::memmove:
1014  case Intrinsic::memcpy_element_unordered_atomic:
1015  case Intrinsic::memmove_element_unordered_atomic:
1016  return true;
1017  default:
1018  return false;
1019  }
1020  }
1021  static bool classof(const Value *V) {
1022  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1023  }
1024 };
1025 
1026 /// This class represents any memcpy intrinsic
1027 /// i.e. llvm.element.unordered.atomic.memcpy
1028 /// and llvm.memcpy
1030 public:
1031  static bool classof(const IntrinsicInst *I) {
1032  switch (I->getIntrinsicID()) {
1033  case Intrinsic::memcpy:
1034  case Intrinsic::memcpy_inline:
1035  case Intrinsic::memcpy_element_unordered_atomic:
1036  return true;
1037  default:
1038  return false;
1039  }
1040  }
1041  static bool classof(const Value *V) {
1042  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1043  }
1044 };
1045 
1046 /// This class represents any memmove intrinsic
1047 /// i.e. llvm.element.unordered.atomic.memmove
1048 /// and llvm.memmove
1050 public:
1051  static bool classof(const IntrinsicInst *I) {
1052  switch (I->getIntrinsicID()) {
1053  case Intrinsic::memmove:
1054  case Intrinsic::memmove_element_unordered_atomic:
1055  return true;
1056  default:
1057  return false;
1058  }
1059  }
1060  static bool classof(const Value *V) {
1061  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1062  }
1063 };
1064 
1065 /// This represents the llvm.va_start intrinsic.
1066 class VAStartInst : public IntrinsicInst {
1067 public:
1068  static bool classof(const IntrinsicInst *I) {
1069  return I->getIntrinsicID() == Intrinsic::vastart;
1070  }
1071  static bool classof(const Value *V) {
1072  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1073  }
1074 
1075  Value *getArgList() const { return const_cast<Value *>(getArgOperand(0)); }
1076 };
1077 
1078 /// This represents the llvm.va_end intrinsic.
1079 class VAEndInst : public IntrinsicInst {
1080 public:
1081  static bool classof(const IntrinsicInst *I) {
1082  return I->getIntrinsicID() == Intrinsic::vaend;
1083  }
1084  static bool classof(const Value *V) {
1085  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1086  }
1087 
1088  Value *getArgList() const { return const_cast<Value *>(getArgOperand(0)); }
1089 };
1090 
1091 /// This represents the llvm.va_copy intrinsic.
1092 class VACopyInst : public IntrinsicInst {
1093 public:
1094  static bool classof(const IntrinsicInst *I) {
1095  return I->getIntrinsicID() == Intrinsic::vacopy;
1096  }
1097  static bool classof(const Value *V) {
1098  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1099  }
1100 
1101  Value *getDest() const { return const_cast<Value *>(getArgOperand(0)); }
1102  Value *getSrc() const { return const_cast<Value *>(getArgOperand(1)); }
1103 };
1104 
1105 /// This represents the llvm.instrprof_increment intrinsic.
1107 public:
1108  static bool classof(const IntrinsicInst *I) {
1109  return I->getIntrinsicID() == Intrinsic::instrprof_increment;
1110  }
1111  static bool classof(const Value *V) {
1112  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1113  }
1114 
1116  return cast<GlobalVariable>(
1117  const_cast<Value *>(getArgOperand(0))->stripPointerCasts());
1118  }
1119 
1121  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
1122  }
1123 
1125  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(2)));
1126  }
1127 
1129  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
1130  }
1131 
1132  Value *getStep() const;
1133 };
1134 
1136 public:
1137  static bool classof(const IntrinsicInst *I) {
1138  return I->getIntrinsicID() == Intrinsic::instrprof_increment_step;
1139  }
1140  static bool classof(const Value *V) {
1141  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1142  }
1143 };
1144 
1145 /// This represents the llvm.instrprof_value_profile intrinsic.
1147 public:
1148  static bool classof(const IntrinsicInst *I) {
1149  return I->getIntrinsicID() == Intrinsic::instrprof_value_profile;
1150  }
1151  static bool classof(const Value *V) {
1152  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1153  }
1154 
1156  return cast<GlobalVariable>(
1157  const_cast<Value *>(getArgOperand(0))->stripPointerCasts());
1158  }
1159 
1161  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
1162  }
1163 
1165  return cast<Value>(const_cast<Value *>(getArgOperand(2)));
1166  }
1167 
1169  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
1170  }
1171 
1172  // Returns the value site index.
1174  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(4)));
1175  }
1176 };
1177 
1179 public:
1180  static bool classof(const IntrinsicInst *I) {
1181  return I->getIntrinsicID() == Intrinsic::pseudoprobe;
1182  }
1183 
1184  static bool classof(const Value *V) {
1185  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1186  }
1187 
1189  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(0)));
1190  }
1191 
1193  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
1194  }
1195 
1197  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(2)));
1198  }
1199 
1201  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
1202  }
1203 };
1204 
1206 public:
1207  static bool classof(const IntrinsicInst *I) {
1208  return I->getIntrinsicID() == Intrinsic::experimental_noalias_scope_decl;
1209  }
1210 
1211  static bool classof(const Value *V) {
1212  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1213  }
1214 
1216  auto *MV =
1217  cast<MetadataAsValue>(getOperand(Intrinsic::NoAliasScopeDeclScopeArg));
1218  return cast<MDNode>(MV->getMetadata());
1219  }
1220 
1221  void setScopeList(MDNode *ScopeList) {
1223  MetadataAsValue::get(getContext(), ScopeList));
1224  }
1225 };
1226 
1227 // Defined in Statepoint.h -- NOT a subclass of IntrinsicInst
1228 class GCStatepointInst;
1229 
1230 /// Common base class for representing values projected from a statepoint.
1231 /// Currently, the only projections available are gc.result and gc.relocate.
1233 public:
1234  static bool classof(const IntrinsicInst *I) {
1235  return I->getIntrinsicID() == Intrinsic::experimental_gc_relocate ||
1236  I->getIntrinsicID() == Intrinsic::experimental_gc_result;
1237  }
1238 
1239  static bool classof(const Value *V) {
1240  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1241  }
1242 
1243  /// Return true if this relocate is tied to the invoke statepoint.
1244  /// This includes relocates which are on the unwinding path.
1245  bool isTiedToInvoke() const {
1246  const Value *Token = getArgOperand(0);
1247 
1248  return isa<LandingPadInst>(Token) || isa<InvokeInst>(Token);
1249  }
1250 
1251  /// The statepoint with which this gc.relocate is associated.
1252  const GCStatepointInst *getStatepoint() const;
1253 };
1254 
1255 /// Represents calls to the gc.relocate intrinsic.
1257 public:
1258  static bool classof(const IntrinsicInst *I) {
1259  return I->getIntrinsicID() == Intrinsic::experimental_gc_relocate;
1260  }
1261 
1262  static bool classof(const Value *V) {
1263  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1264  }
1265 
1266  /// The index into the associate statepoint's argument list
1267  /// which contains the base pointer of the pointer whose
1268  /// relocation this gc.relocate describes.
1269  unsigned getBasePtrIndex() const {
1270  return cast<ConstantInt>(getArgOperand(1))->getZExtValue();
1271  }
1272 
1273  /// The index into the associate statepoint's argument list which
1274  /// contains the pointer whose relocation this gc.relocate describes.
1275  unsigned getDerivedPtrIndex() const {
1276  return cast<ConstantInt>(getArgOperand(2))->getZExtValue();
1277  }
1278 
1279  Value *getBasePtr() const;
1280  Value *getDerivedPtr() const;
1281 };
1282 
1283 /// Represents calls to the gc.result intrinsic.
1285 public:
1286  static bool classof(const IntrinsicInst *I) {
1287  return I->getIntrinsicID() == Intrinsic::experimental_gc_result;
1288  }
1289 
1290  static bool classof(const Value *V) {
1291  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1292  }
1293 };
1294 
1295 
1296 /// This represents the llvm.assume intrinsic.
1297 class AssumeInst : public IntrinsicInst {
1298 public:
1299  static bool classof(const IntrinsicInst *I) {
1300  return I->getIntrinsicID() == Intrinsic::assume;
1301  }
1302  static bool classof(const Value *V) {
1303  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1304  }
1305 };
1306 
1307 } // end namespace llvm
1308 
1309 #endif // LLVM_IR_INTRINSICINST_H
llvm::DbgVariableIntrinsic::setRawLocation
void setRawLocation(Metadata *Location)
Use of this should generally be avoided; instead, replaceVariableLocationOp and addVariableLocationOp...
Definition: IntrinsicInst.h:276
llvm::NoAliasScopeDeclInst
Definition: IntrinsicInst.h:1205
i
i
Definition: README.txt:29
llvm::DbgDeclareInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:321
llvm::DbgVariableIntrinsic::getExpression
DIExpression * getExpression() const
Definition: IntrinsicInst.h:257
llvm::BinaryOpIntrinsic::getBinaryOp
Instruction::BinaryOps getBinaryOp() const
Returns the binary operation underlying the intrinsic.
Definition: IntrinsicInst.cpp:507
llvm::VPIntrinsic::getVectorLengthParamPos
static Optional< unsigned > getVectorLengthParamPos(Intrinsic::ID IntrinsicID)
Definition: IntrinsicInst.cpp:331
llvm::DbgAddrIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:338
llvm::SaturatingInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:590
llvm::MemCpyInlineInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:948
llvm::MemSetInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:886
llvm::DbgInfoIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:138
llvm::MemCpyInlineInst::getLength
ConstantInt * getLength() const
Definition: IntrinsicInst.h:941
llvm::MemIntrinsicBase::getDestAlignment
unsigned getDestAlignment() const
FIXME: Remove this function once transition to Align is over.
Definition: IntrinsicInst.h:638
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:102
llvm::DbgVariableIntrinsic::getRawExpression
Metadata * getRawExpression() const
Definition: IntrinsicInst.h:269
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::DbgDeclareInst::getAddress
Value * getAddress() const
Definition: IntrinsicInst.h:310
llvm::InstrProfIncrementInst::getStep
Value * getStep() const
Definition: IntrinsicInst.cpp:181
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::PseudoProbeInst
Definition: IntrinsicInst.h:1178
llvm::DbgValueInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:360
llvm::InstrProfIncrementInstStep::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1140
llvm::MinMaxIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:490
llvm::WithOverflowInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:569
Metadata.h
llvm::CmpInst::Predicate
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:720
llvm::MemIntrinsicBase::getDestAlign
MaybeAlign getDestAlign() const
Definition: IntrinsicInst.h:643
llvm::InstrProfValueProfileInst::getHash
ConstantInt * getHash() const
Definition: IntrinsicInst.h:1160
llvm::ElementCount
Definition: TypeSize.h:386
llvm::ConstrainedFPCmpIntrinsic
Constrained floating point compare intrinsics.
Definition: IntrinsicInst.h:468
DebugInfoMetadata.h
llvm::ConstrainedFPCmpIntrinsic::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:482
llvm::MemTransferInst
This class wraps the llvm.memcpy/memmove intrinsics.
Definition: IntrinsicInst.h:895
llvm::Function
Definition: Function.h:61
llvm::AtomicMemIntrinsic::getElementSizeInBytes
uint32_t getElementSizeInBytes() const
Definition: IntrinsicInst.h:772
llvm::GCRelocateInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1258
llvm::DbgVariableIntrinsic::location_op_iterator::operator*
Value * operator*()
Definition: IntrinsicInst.h:176
llvm::IntrinsicInst::getIntrinsicID
Intrinsic::ID getIntrinsicID() const
Return the intrinsic ID of this intrinsic.
Definition: IntrinsicInst.h:52
llvm::MemMoveInst
This class wraps the llvm.memmove intrinsic.
Definition: IntrinsicInst.h:927
minimum
Should compile r2 movcc movcs str strb mov lr r1 movcs movcc mov lr r1 str mov mov cmp r1 movlo r2 str bx lr r0 mov mov cmp r0 movhs r2 mov r1 bx lr Some of the NEON intrinsics may be appropriate for more general either as target independent intrinsics or perhaps elsewhere in the ARM backend Some of them may also be lowered to target independent and perhaps some new SDNodes could be added For minimum
Definition: README.txt:489
llvm::AtomicMemIntrinsic::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:792
llvm::AnyMemSetInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:999
llvm::AtomicMemIntrinsic::getRawElementSizeInBytes
Value * getRawElementSizeInBytes() const
Definition: IntrinsicInst.h:764
llvm::BinaryOpIntrinsic::getRHS
Value * getRHS() const
Definition: IntrinsicInst.h:554
llvm::MemIntrinsicBase::getDestAddressSpace
unsigned getDestAddressSpace() const
Definition: IntrinsicInst.h:632
llvm::RegState::Undef
@ Undef
Value of the register doesn't matter.
Definition: MachineInstrBuilder.h:52
llvm::BinaryOpIntrinsic::getLHS
Value * getLHS() const
Definition: IntrinsicInst.h:553
llvm::InstrProfIncrementInstStep::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1137
llvm::VACopyInst::getSrc
Value * getSrc() const
Definition: IntrinsicInst.h:1102
llvm::VPIntrinsic::setVectorLengthParam
void setVectorLengthParam(Value *)
Definition: IntrinsicInst.cpp:313
llvm::VAStartInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1071
llvm::GlobalVariable
Definition: GlobalVariable.h:40
llvm::BinaryOpIntrinsic
This class represents an intrinsic that is based on a binary operation.
Definition: IntrinsicInst.h:530
llvm::MemIntrinsic::getVolatileCst
ConstantInt * getVolatileCst() const
Definition: IntrinsicInst.h:857
llvm::MemMoveInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:930
llvm::DbgVariableIntrinsic::replaceVariableLocationOp
void replaceVariableLocationOp(Value *OldValue, Value *NewValue)
Definition: IntrinsicInst.cpp:82
llvm::VPIntrinsic::canIgnoreVectorLengthParam
bool canIgnoreVectorLengthParam() const
Definition: IntrinsicInst.cpp:429
llvm::DbgVariableIntrinsic::location_op_iterator::operator==
bool operator==(const location_op_iterator &RHS) const
Definition: IntrinsicInst.h:167
llvm::ConstrainedFPIntrinsic::isDefaultFPEnvironment
bool isDefaultFPEnvironment() const
Definition: IntrinsicInst.cpp:213
llvm::CallBase::getArgOperandUse
const Use & getArgOperandUse(unsigned i) const
Wrappers for getting the Use of a call argument.
Definition: InstrTypes.h:1349
llvm::NoAliasScopeDeclInst::getScopeList
MDNode * getScopeList() const
Definition: IntrinsicInst.h:1215
llvm::AtomicMemIntrinsic::getElementSizeInBytesCst
ConstantInt * getElementSizeInBytesCst() const
Definition: IntrinsicInst.h:768
NewExpr
Definition: ItaniumDemangle.h:1773
llvm::AssumeInst
This represents the llvm.assume intrinsic.
Definition: IntrinsicInst.h:1297
llvm::GCProjectionInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1239
llvm::AnyMemIntrinsic::isVolatile
bool isVolatile() const
Definition: IntrinsicInst.h:959
llvm::MemIntrinsic::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:877
llvm::VPIntrinsic::getMemoryDataParam
Value * getMemoryDataParam() const
Definition: IntrinsicInst.cpp:371
llvm::GCRelocateInst::getBasePtrIndex
unsigned getBasePtrIndex() const
The index into the associate statepoint's argument list which contains the base pointer of the pointe...
Definition: IntrinsicInst.h:1269
llvm::DbgVariableIntrinsic::getVariable
DILocalVariable * getVariable() const
Definition: IntrinsicInst.h:253
llvm::MemIntrinsic
This is the common base class for memset/memcpy/memmove.
Definition: IntrinsicInst.h:852
llvm::VPIntrinsic::getFunctionalOpcodeForVP
static Optional< unsigned > getFunctionalOpcodeForVP(Intrinsic::ID ID)
Definition: IntrinsicInst.cpp:404
llvm::Optional< uint64_t >
llvm::SmallPtrSet< Value *, 4 >
llvm::MemIntrinsicBase::setDestAlignment
void setDestAlignment(MaybeAlign Alignment)
Definition: IntrinsicInst.h:657
llvm::ConstrainedFPIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.cpp:273
llvm::InstrProfIncrementInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1111
llvm::DIExpression
DWARF expression.
Definition: DebugInfoMetadata.h:2557
llvm::DbgLabelInst::getRawLabel
Metadata * getRawLabel() const
Definition: IntrinsicInst.h:374
llvm::WithOverflowInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:582
llvm::AnyMemSetInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:990
llvm::CallBase::addParamAttr
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Adds the attribute to the indicated argument.
Definition: InstrTypes.h:1503
llvm::Type::getInt8Ty
static IntegerType * getInt8Ty(LLVMContext &C)
Definition: Type.cpp:201
llvm::DbgVariableIntrinsic::getRawVariable
Metadata * getRawVariable() const
Definition: IntrinsicInst.h:265
llvm::DbgVariableIntrinsic::getVariableLocationOp
Value * getVariableLocationOp(unsigned OpIdx) const
Definition: IntrinsicInst.cpp:60
llvm::APIntOps::umin
const APInt & umin(const APInt &A, const APInt &B)
Determine the smaller of two APInts considered to be unsigned.
Definition: APInt.h:2178
llvm::InstrProfIncrementInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1108
llvm::MemSetBase::getValue
Value * getValue() const
Definition: IntrinsicInst.h:744
llvm::VPIntrinsic::setMaskParam
void setMaskParam(Value *)
Definition: IntrinsicInst.cpp:302
llvm::GCResultInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1290
llvm::DbgVariableIntrinsic::setVariable
void setVariable(DILocalVariable *NewVar)
Definition: IntrinsicInst.h:213
llvm::GCRelocateInst::getDerivedPtrIndex
unsigned getDerivedPtrIndex() const
The index into the associate statepoint's argument list which contains the pointer whose relocation t...
Definition: IntrinsicInst.h:1275
llvm::InstrProfValueProfileInst::getValueKind
ConstantInt * getValueKind() const
Definition: IntrinsicInst.h:1168
llvm::VAStartInst
This represents the llvm.va_start intrinsic.
Definition: IntrinsicInst.h:1066
llvm::GCStatepointInst
Represents a gc.statepoint intrinsic call.
Definition: Statepoint.h:63
llvm::DbgVariableIntrinsic::location_op_iterator::operator=
location_op_iterator & operator=(const location_op_iterator &R)
Definition: IntrinsicInst.h:163
llvm::MemIntrinsicBase::setDestAlignment
void setDestAlignment(Align Alignment)
Definition: IntrinsicInst.h:663
llvm::ConstantInt
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
llvm::MemCpyInlineInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:945
llvm::Intrinsic::getType
FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > Tys=None)
Return the function type for an intrinsic.
Definition: Function.cpp:1292
llvm::CallBase::removeParamAttr
void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Removes the attribute from the given argument.
Definition: InstrTypes.h:1539
llvm::GCProjectionInst
Common base class for representing values projected from a statepoint.
Definition: IntrinsicInst.h:1232
llvm::MemTransferBase::getSourceAddressSpace
unsigned getSourceAddressSpace() const
Definition: IntrinsicInst.h:697
llvm::DbgVariableIntrinsic::addVariableLocationOps
void addVariableLocationOps(ArrayRef< Value * > NewValues, DIExpression *NewExpr)
Adding a new location operand will always result in this intrinsic using an ArgList,...
Definition: IntrinsicInst.cpp:121
Constants.h
llvm::DbgValueInst
This represents the llvm.dbg.value instruction.
Definition: IntrinsicInst.h:347
BaseCL
llvm::MemSetBase::getValueUse
const Use & getValueUse() const
Definition: IntrinsicInst.h:747
llvm::DILocalVariable
Local variable.
Definition: DebugInfoMetadata.h:3053
llvm::DbgVariableIntrinsic::isAddressOfVariable
bool isAddressOfVariable() const
Does this describe the address of a local variable.
Definition: IntrinsicInst.h:231
Intrinsics.h
llvm::ConstrainedFPIntrinsic
This is the common base class for constrained floating point intrinsics.
Definition: IntrinsicInst.h:452
llvm::MemSetBase::setValue
void setValue(Value *Val)
Definition: IntrinsicInst.h:750
llvm::AtomicMemTransferInst
Definition: IntrinsicInst.h:811
llvm::CallBase::getCalledFunction
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation.
Definition: InstrTypes.h:1393
llvm::PseudoProbeInst::getFactor
ConstantInt * getFactor() const
Definition: IntrinsicInst.h:1200
llvm::InstrProfValueProfileInst::getTargetValue
Value * getTargetValue() const
Definition: IntrinsicInst.h:1164
llvm::MemTransferBase::getRawSourceUse
Use & getRawSourceUse()
Definition: IntrinsicInst.h:690
llvm::AnyMemMoveInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1051
llvm::MemTransferBase::getRawSource
Value * getRawSource() const
Return the arguments to the instruction.
Definition: IntrinsicInst.h:684
llvm::DbgDeclareInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:318
llvm::MemCpyInlineInst
This class wraps the llvm.memcpy.inline intrinsic.
Definition: IntrinsicInst.h:939
llvm::VACopyInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1097
llvm::MemCpyInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:917
llvm::BinaryOpIntrinsic::getNoWrapKind
unsigned getNoWrapKind() const
Returns one of OBO::NoSignedWrap or OBO::NoUnsignedWrap.
Definition: IntrinsicInst.cpp:540
llvm::DbgInfoIntrinsic::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:141
llvm::MaybeAlign
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:109
llvm::MinMaxIntrinsic::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:501
llvm::DbgVariableIntrinsic::setExpression
void setExpression(DIExpression *NewExpr)
Definition: IntrinsicInst.h:217
llvm::SaturatingInst
Represents a saturating add/sub intrinsic.
Definition: IntrinsicInst.h:588
llvm::InstrProfIncrementInstStep
Definition: IntrinsicInst.h:1135
llvm::UndefValue::get
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1784
llvm::VPIntrinsic::getForOpcode
static Intrinsic::ID getForOpcode(unsigned OC)
The llvm.vp.* intrinsics for this instruction Opcode.
Definition: IntrinsicInst.cpp:418
llvm::IntrinsicInst::operator=
IntrinsicInst & operator=(const IntrinsicInst &)=delete
llvm::MemTransferBase::setSourceAlignment
void setSourceAlignment(MaybeAlign Alignment)
Definition: IntrinsicInst.h:724
llvm::InstrProfValueProfileInst::getIndex
ConstantInt * getIndex() const
Definition: IntrinsicInst.h:1173
llvm::DbgVariableIntrinsic::hasArgList
bool hasArgList() const
Definition: IntrinsicInst.h:227
llvm::DbgInfoIntrinsic
This is the common base class for debug info intrinsics.
Definition: IntrinsicInst.h:134
llvm::VPIntrinsic::getDeclarationForParams
static Function * getDeclarationForParams(Module *M, Intrinsic::ID, ArrayRef< Value * > Params)
Declares a llvm.vp.
Definition: IntrinsicInst.cpp:471
llvm::AtomicMemCpyInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:834
llvm::AnyMemIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:966
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::Metadata
Root of the metadata hierarchy.
Definition: Metadata.h:62
llvm::AtomicMemCpyInst
This class represents the atomic memcpy intrinsic i.e.
Definition: IntrinsicInst.h:829
llvm::MemTransferBase::getSourceAlign
MaybeAlign getSourceAlign() const
Definition: IntrinsicInst.h:709
llvm::MemTransferInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:898
llvm::DbgVariableIntrinsic::getNumVariableLocationOps
unsigned getNumVariableLocationOps() const
Definition: IntrinsicInst.h:221
llvm::MemSetInst
This class wraps the llvm.memset intrinsic.
Definition: IntrinsicInst.h:883
llvm::AnyMemTransferInst
Definition: IntrinsicInst.h:1007
llvm::maxnum
LLVM_READONLY APFloat maxnum(const APFloat &A, const APFloat &B)
Implements IEEE maxNum semantics.
Definition: APFloat.h:1309
llvm::VPIntrinsic::getMemoryPointerParamPos
static Optional< unsigned > getMemoryPointerParamPos(Intrinsic::ID)
Definition: IntrinsicInst.cpp:358
llvm::AtomicMemSetInst
This class represents atomic memset intrinsic.
Definition: IntrinsicInst.h:799
llvm::VAEndInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1084
llvm::VPIntrinsic::getVectorLengthParam
Value * getVectorLengthParam() const
Definition: IntrinsicInst.cpp:307
llvm::NoAliasScopeDeclInst::setScopeList
void setScopeList(MDNode *ScopeList)
Definition: IntrinsicInst.h:1221
llvm::VPIntrinsic::getFunctionalOpcode
Optional< unsigned > getFunctionalOpcode() const
Definition: IntrinsicInst.h:443
llvm::Value::Value
Value(Type *Ty, unsigned scid)
Definition: Value.cpp:53
llvm::DbgVariableIntrinsic::location_op_iterator::operator*
const Value * operator*() const
Definition: IntrinsicInst.h:170
llvm::BinaryOpIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:532
llvm::PseudoProbeInst::getFuncGuid
ConstantInt * getFuncGuid() const
Definition: IntrinsicInst.h:1188
llvm::DbgVariableIntrinsic
This is the common base class for debug info intrinsics for variables.
Definition: IntrinsicInst.h:148
llvm::VPIntrinsic::getStaticVectorLength
ElementCount getStaticVectorLength() const
Definition: IntrinsicInst.cpp:284
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::DbgVariableIntrinsic::location_op_iterator::location_op_iterator
location_op_iterator(ValueAsMetadata **MultiIter)
Definition: IntrinsicInst.h:160
llvm::VPIntrinsic::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:438
llvm::GCRelocateInst
Represents calls to the gc.relocate intrinsic.
Definition: IntrinsicInst.h:1256
llvm::DbgVariableIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:286
llvm::InstrProfValueProfileInst
This represents the llvm.instrprof_value_profile intrinsic.
Definition: IntrinsicInst.h:1146
llvm::BinaryOpIntrinsic::isSigned
bool isSigned() const
Whether the intrinsic is signed or unsigned.
Definition: IntrinsicInst.cpp:527
llvm::DbgVariableIntrinsic::setUndef
void setUndef()
Definition: IntrinsicInst.h:235
llvm::AtomicMemSetInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:801
llvm::DbgDeclareInst
This represents the llvm.dbg.declare instruction.
Definition: IntrinsicInst.h:308
llvm::VPIntrinsic::getPointerAlignment
MaybeAlign getPointerAlignment() const
Definition: IntrinsicInst.cpp:345
llvm::DbgLabelInst
This represents the llvm.dbg.label instruction.
Definition: IntrinsicInst.h:370
llvm::GCRelocateInst::getDerivedPtr
Value * getDerivedPtr() const
Definition: IntrinsicInst.cpp:572
llvm::MemTransferBase::setSource
void setSource(Value *Ptr)
Definition: IntrinsicInst.h:713
llvm::DbgLabelInst::getLabel
DILabel * getLabel() const
Definition: IntrinsicInst.h:372
llvm::ConstrainedFPIntrinsic::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:462
llvm::AssumeInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1299
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::iterator_facade_base
CRTP base class which implements the entire standard iterator facade in terms of a minimal subset of ...
Definition: iterator.h:66
llvm::IntrinsicInst::classof
static bool classof(const CallInst *I)
Definition: IntrinsicInst.h:110
llvm::InstrProfIncrementInst::getIndex
ConstantInt * getIndex() const
Definition: IntrinsicInst.h:1128
llvm::VPIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:435
llvm::VPIntrinsic::isVPIntrinsic
static bool isVPIntrinsic(Intrinsic::ID)
Definition: IntrinsicInst.cpp:390
llvm::GCProjectionInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1234
llvm::MemTransferBase
Common base class for all memory transfer intrinsics.
Definition: IntrinsicInst.h:678
llvm::AtomicMemCpyInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:831
maximum
Should compile r2 movcc movcs str strb mov lr r1 movcs movcc mov lr r1 str mov mov cmp r1 movlo r2 str bx lr r0 mov mov cmp r0 movhs r2 mov r1 bx lr Some of the NEON intrinsics may be appropriate for more general either as target independent intrinsics or perhaps elsewhere in the ARM backend Some of them may also be lowered to target independent and perhaps some new SDNodes could be added For maximum
Definition: README.txt:489
llvm::MemCpyInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:921
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::MemIntrinsicBase::setDest
void setDest(Value *Ptr)
Set the specified arguments of the instruction.
Definition: IntrinsicInst.h:646
llvm::MinMaxIntrinsic::isSigned
bool isSigned() const
Whether the intrinsic is signed or unsigned.
Definition: IntrinsicInst.h:525
memcpy
<%struct.s * > cast struct s *S to sbyte *< sbyte * > sbyte uint cast struct s *agg result to sbyte *< sbyte * > sbyte uint cast struct s *memtmp to sbyte *< sbyte * > sbyte uint ret void llc ends up issuing two memcpy or custom lower memcpy(of small size) to be ldmia/stmia. I think option 2 is better but the current register allocator cannot allocate a chunk of registers at a time. A feasible temporary solution is to use specific physical registers at the lowering time for small(<
llvm::AssumeInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1302
llvm::DbgVariableIntrinsic::location_op_iterator::operator++
location_op_iterator & operator++()
Definition: IntrinsicInst.h:182
llvm::SystemZISD::OC
@ OC
Definition: SystemZISelLowering.h:128
llvm::MemTransferInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:908
llvm::DbgVariableIntrinsic::location_op_iterator::location_op_iterator
location_op_iterator(ValueAsMetadata *SingleIter)
Definition: IntrinsicInst.h:159
llvm::MinMaxIntrinsic::getPredicate
ICmpInst::Predicate getPredicate() const
Returns the comparison predicate underlying the intrinsic.
Definition: IntrinsicInst.h:509
llvm::MemIntrinsicBase::getLengthUse
Use & getLengthUse()
Definition: IntrinsicInst.h:625
llvm::ValueAsMetadata::getValue
Value * getValue() const
Definition: Metadata.h:384
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::MDNode
Metadata node.
Definition: Metadata.h:897
llvm::InstrProfIncrementInst::getNumCounters
ConstantInt * getNumCounters() const
Definition: IntrinsicInst.h:1124
llvm::MemSetInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:889
llvm::MinMaxIntrinsic::getLHS
Value * getLHS() const
Definition: IntrinsicInst.h:505
llvm::MemIntrinsicBase::setLength
void setLength(Value *L)
Definition: IntrinsicInst.h:669
llvm::AnyMemTransferInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1009
llvm::VPIntrinsic::getMemoryDataParamPos
static Optional< unsigned > getMemoryDataParamPos(Intrinsic::ID)
Definition: IntrinsicInst.cpp:378
llvm::VACopyInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1094
llvm::MemTransferBase::setSourceAlignment
void setSourceAlignment(Align Alignment)
Definition: IntrinsicInst.h:730
llvm::User::setOperand
void setOperand(unsigned i, Value *Val)
Definition: User.h:174
llvm::AtomicMemMoveInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:843
llvm::Intrinsic::NoAliasScopeDeclScopeArg
static const int NoAliasScopeDeclScopeArg
Definition: Intrinsics.h:38
llvm::ConstrainedFPCmpIntrinsic::getPredicate
FCmpInst::Predicate getPredicate() const
Definition: IntrinsicInst.cpp:229
llvm::Function::getIntrinsicID
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
Definition: Function.h:205
llvm::APIntOps::smin
const APInt & smin(const APInt &A, const APInt &B)
Determine the smaller of two APInts considered to be signed.
Definition: APInt.h:2168
llvm::NoAliasScopeDeclInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1211
llvm::InstrProfIncrementInst::getHash
ConstantInt * getHash() const
Definition: IntrinsicInst.h:1120
llvm::MemSetBase
Common base class for all memset intrinsics.
Definition: IntrinsicInst.h:739
llvm::MemIntrinsicBase::getDest
Value * getDest() const
This is just like getRawDest, but it strips off any cast instructions (including addrspacecast) that ...
Definition: IntrinsicInst.h:630
llvm::AnyMemMoveInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1060
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::ConstrainedFPIntrinsic::getExceptionBehavior
Optional< fp::ExceptionBehavior > getExceptionBehavior() const
Definition: IntrinsicInst.cpp:202
llvm::VAEndInst
This represents the llvm.va_end intrinsic.
Definition: IntrinsicInst.h:1079
llvm::AnyMemIntrinsic::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:980
llvm::any_of
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1554
llvm::CallBase::getParamAlign
MaybeAlign getParamAlign(unsigned ArgNo) const
Extract the alignment for a call or parameter (0=unknown).
Definition: InstrTypes.h:1709
llvm::MemTransferBase::setSourceAlignment
void setSourceAlignment(unsigned Alignment)
FIXME: Remove this function once transition to Align is over.
Definition: IntrinsicInst.h:721
llvm::PseudoProbeInst::getIndex
ConstantInt * getIndex() const
Definition: IntrinsicInst.h:1192
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
llvm::Value::getType
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:256
llvm::GCResultInst
Represents calls to the gc.result intrinsic.
Definition: IntrinsicInst.h:1284
llvm::ConstantInt::isZero
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
Definition: Constants.h:194
llvm::PseudoProbeInst::getAttributes
ConstantInt * getAttributes() const
Definition: IntrinsicInst.h:1196
llvm::DbgVariableIntrinsic::getRawLocation
Metadata * getRawLocation() const
Definition: IntrinsicInst.h:261
uint32_t
llvm::Value::getContext
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:979
llvm::InstrProfValueProfileInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1151
llvm::AtomicMemIntrinsic::setElementSizeInBytes
void setElementSizeInBytes(Constant *V)
Definition: IntrinsicInst.h:776
llvm::DbgVariableIntrinsic::getFragmentSizeInBits
Optional< uint64_t > getFragmentSizeInBits() const
Get the size (in bits) of the variable, or fragment of the variable that is described.
Definition: IntrinsicInst.cpp:138
llvm::WithOverflowInst
Represents an op.with.overflow intrinsic.
Definition: IntrinsicInst.h:567
llvm::MemMoveInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:933
llvm::CallBase::setArgOperand
void setArgOperand(unsigned i, Value *v)
Definition: InstrTypes.h:1343
llvm::PointerUnion
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
Definition: PointerUnion.h:119
llvm::Value::stripPointerCasts
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
Definition: Value.cpp:675
llvm::VAEndInst::getArgList
Value * getArgList() const
Definition: IntrinsicInst.h:1088
llvm::AtomicMemTransferInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:813
llvm::ConstantInt::getZExtValue
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
Definition: Constants.h:142
llvm::MDNode::getContext
LLVMContext & getContext() const
Definition: Metadata.h:957
llvm::Attribute::getWithAlignment
static Attribute getWithAlignment(LLVMContext &Context, Align Alignment)
Return a uniquified Attribute object that has the specific alignment set.
Definition: Attributes.cpp:166
llvm::IntrinsicInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:115
llvm::APIntOps::umax
const APInt & umax(const APInt &A, const APInt &B)
Determine the larger of two APInts considered to be unsigned.
Definition: APInt.h:2183
llvm::GCResultInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1286
llvm::GCRelocateInst::getBasePtr
Value * getBasePtr() const
Definition: IntrinsicInst.cpp:566
llvm::MemIntrinsicBase::getRawDestUse
Use & getRawDestUse()
Definition: IntrinsicInst.h:619
llvm::minnum
LLVM_READONLY APFloat minnum(const APFloat &A, const APFloat &B)
Implements IEEE minNum semantics.
Definition: APFloat.h:1298
FPEnv.h
llvm::AtomicMemTransferInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:822
llvm::InstrProfValueProfileInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1148
llvm::GCRelocateInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1262
llvm::MemIntrinsicBase::getLength
Value * getLength() const
Definition: IntrinsicInst.h:621
llvm::ConstrainedFPIntrinsic::isUnaryOp
bool isUnaryOp() const
Definition: IntrinsicInst.cpp:251
llvm::AnyMemSetInst
This class represents any memset intrinsic.
Definition: IntrinsicInst.h:988
llvm::VPIntrinsic::getMemoryPointerParam
Value * getMemoryPointerParam() const
Definition: IntrinsicInst.cpp:352
llvm::MetadataAsValue::get
static MetadataAsValue * get(LLVMContext &Context, Metadata *MD)
Definition: Metadata.cpp:106
llvm::SaturatingInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:601
llvm::VACopyInst
This represents the llvm.va_copy intrinsic.
Definition: IntrinsicInst.h:1092
llvm::VAStartInst::getArgList
Value * getArgList() const
Definition: IntrinsicInst.h:1075
llvm::VPIntrinsic
This is the common base class for vector predication intrinsics.
Definition: IntrinsicInst.h:390
GlobalVariable.h
llvm::MemIntrinsicBase
Common base class for all memory intrinsics.
Definition: IntrinsicInst.h:610
llvm::MemIntrinsicBase::setDestAlignment
void setDestAlignment(unsigned Alignment)
FIXME: Remove this function once transition to Align is over.
Definition: IntrinsicInst.h:654
Casting.h
Function.h
llvm::NoAliasScopeDeclInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1207
llvm::isDbgInfoIntrinsic
static bool isDbgInfoIntrinsic(Intrinsic::ID ID)
Check if ID corresponds to a debug info intrinsic.
Definition: IntrinsicInst.h:121
llvm::MemTransferBase::getSourceAlignment
unsigned getSourceAlignment() const
FIXME: Remove this function once transition to Align is over.
Definition: IntrinsicInst.h:703
llvm::CmpInst::isSigned
bool isSigned() const
Definition: InstrTypes.h:934
llvm::VACopyInst::getDest
Value * getDest() const
Definition: IntrinsicInst.h:1101
llvm::MemIntrinsicBase::getLengthUse
const Use & getLengthUse() const
Definition: IntrinsicInst.h:624
llvm::ConstrainedFPIntrinsic::isTernaryOp
bool isTernaryOp() const
Definition: IntrinsicInst.cpp:262
llvm::VAEndInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1081
llvm::VPIntrinsic::getMaskParamPos
static Optional< unsigned > getMaskParamPos(Intrinsic::ID IntrinsicID)
Definition: IntrinsicInst.cpp:318
llvm::AnyMemMoveInst
This class represents any memmove intrinsic i.e.
Definition: IntrinsicInst.h:1049
llvm::IntrinsicInst
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:45
llvm::InstrProfIncrementInst
This represents the llvm.instrprof_increment intrinsic.
Definition: IntrinsicInst.h:1106
llvm::AtomicMemIntrinsic
Definition: IntrinsicInst.h:759
llvm::Instruction::BinaryOps
BinaryOps
Definition: Instruction.h:787
llvm::MemIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:866
llvm::AtomicMemSetInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:804
Instructions.h
llvm::MemCpyInst
This class wraps the llvm.memcpy intrinsic.
Definition: IntrinsicInst.h:914
llvm::MemIntrinsicBase::getRawDestUse
const Use & getRawDestUse() const
Definition: IntrinsicInst.h:618
llvm::MinMaxIntrinsic
This class represents min/max intrinsics.
Definition: IntrinsicInst.h:488
llvm::PseudoProbeInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1180
llvm::MemIntrinsic::isVolatile
bool isVolatile() const
Definition: IntrinsicInst.h:861
llvm::DbgVariableIntrinsic::location_op_iterator
Definition: IntrinsicInst.h:153
llvm::DbgValueInst::getValue
Value * getValue(unsigned OpIdx=0) const
Definition: IntrinsicInst.h:351
llvm::CallBase::getArgOperand
Value * getArgOperand(unsigned i) const
Definition: InstrTypes.h:1338
llvm::DbgAddrIntrinsic::getAddress
Value * getAddress() const
Definition: IntrinsicInst.h:330
llvm::IntrinsicInst::isCommutative
bool isCommutative() const
Return true if swapping the first two arguments to the intrinsic produces the same result.
Definition: IntrinsicInst.h:58
llvm::DbgAddrIntrinsic::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:341
llvm::DbgVariableIntrinsic::location_ops
iterator_range< location_op_iterator > location_ops() const
Get the locations corresponding to the variable referenced by the debug info intrinsic.
Definition: IntrinsicInst.cpp:43
llvm::DbgVariableIntrinsic::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:296
llvm::InstrProfValueProfileInst::getName
GlobalVariable * getName() const
Definition: IntrinsicInst.h:1155
llvm::iterator_range
A range adaptor for a pair of iterators.
Definition: iterator_range.h:30
llvm::AtomicMemMoveInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:846
llvm::IntrinsicInst::isAssumeLikeIntrinsic
bool isAssumeLikeIntrinsic() const
Definition: IntrinsicInst.h:87
llvm::MemIntrinsicBase::getRawDest
Value * getRawDest() const
Definition: IntrinsicInst.h:615
llvm::ConstrainedFPCmpIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:473
llvm::MemIntrinsic::setVolatile
void setVolatile(Constant *V)
Definition: IntrinsicInst.h:863
llvm::AtomicMemIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:782
llvm::ValueAsMetadata
Value wrapper in the Metadata hierarchy.
Definition: Metadata.h:344
llvm::BinaryOpIntrinsic::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:549
llvm::ConstrainedFPIntrinsic::getRoundingMode
Optional< RoundingMode > getRoundingMode() const
Definition: IntrinsicInst.cpp:190
DerivedTypes.h
llvm::IntrinsicInst::IntrinsicInst
IntrinsicInst()=delete
llvm::CallInst
This class represents a function call, abstracting a target machine's calling convention.
Definition: Instructions.h:1475
llvm::GCProjectionInst::isTiedToInvoke
bool isTiedToInvoke() const
Return true if this relocate is tied to the invoke statepoint.
Definition: IntrinsicInst.h:1245
llvm::VPIntrinsic::getMaskParam
Value * getMaskParam() const
Definition: IntrinsicInst.cpp:296
llvm::DILabel
Label.
Definition: DebugInfoMetadata.h:3133
llvm::MemTransferBase::getRawSourceUse
const Use & getRawSourceUse() const
Definition: IntrinsicInst.h:687
llvm::AnyMemTransferInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1021
llvm::User::getOperand
Value * getOperand(unsigned i) const
Definition: User.h:169
llvm::InstrProfIncrementInst::getName
GlobalVariable * getName() const
Definition: IntrinsicInst.h:1115
llvm::AtomicMemMoveInst
This class represents the atomic memmove intrinsic i.e.
Definition: IntrinsicInst.h:841
llvm::DbgLabelInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:383
llvm::DbgVariableIntrinsic::location_op_iterator::location_op_iterator
location_op_iterator(const location_op_iterator &R)
Definition: IntrinsicInst.h:162
llvm::PseudoProbeInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1184
llvm::DbgVariableIntrinsic::location_op_iterator::operator--
location_op_iterator & operator--()
Definition: IntrinsicInst.h:189
Value.h
llvm::AnyMemIntrinsic
Definition: IntrinsicInst.h:957
llvm::MemSetBase::getValueUse
Use & getValueUse()
Definition: IntrinsicInst.h:748
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::DbgAddrIntrinsic
This represents the llvm.dbg.addr instruction.
Definition: IntrinsicInst.h:328
llvm::APIntOps::smax
const APInt & smax(const APInt &A, const APInt &B)
Determine the larger of two APInts considered to be signed.
Definition: APInt.h:2173
llvm::DbgValueInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:363
llvm::DbgLabelInst::classof
static bool classof(const IntrinsicInst *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: IntrinsicInst.h:380
llvm::DbgValueInst::getValues
iterator_range< location_op_iterator > getValues() const
Definition: IntrinsicInst.h:354
llvm::AnyMemCpyInst
This class represents any memcpy intrinsic i.e.
Definition: IntrinsicInst.h:1029
llvm::GCProjectionInst::getStatepoint
const GCStatepointInst * getStatepoint() const
The statepoint with which this gc.relocate is associated.
Definition: IntrinsicInst.cpp:547
llvm::MinMaxIntrinsic::getRHS
Value * getRHS() const
Definition: IntrinsicInst.h:506
llvm::Use
A Use represents the edge between a Value definition and its users.
Definition: Use.h:44
llvm::AnyMemCpyInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1031
llvm::AnyMemCpyInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1041
llvm::MemTransferBase::getSource
Value * getSource() const
This is just like getRawSource, but it strips off any cast instructions that feed it,...
Definition: IntrinsicInst.h:695
llvm::SmallPtrSetImpl::insert
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:364
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:38
llvm::DbgVariableIntrinsic::isUndef
bool isUndef() const
Definition: IntrinsicInst.h:247
llvm::VAStartInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1068