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. Additionally, the load and gather intrinsics require
394  /// \p ReturnType to be specified.
396  Type *ReturnType,
397  ArrayRef<Value *> Params);
398 
401 
402  /// The llvm.vp.* intrinsics for this instruction Opcode
403  static Intrinsic::ID getForOpcode(unsigned OC);
404 
405  // Whether \p ID is a VP intrinsic ID.
406  static bool isVPIntrinsic(Intrinsic::ID);
407 
408  /// \return The mask parameter or nullptr.
409  Value *getMaskParam() const;
410  void setMaskParam(Value *);
411 
412  /// \return The vector length parameter or nullptr.
413  Value *getVectorLengthParam() const;
414  void setVectorLengthParam(Value *);
415 
416  /// \return Whether the vector length param can be ignored.
417  bool canIgnoreVectorLengthParam() const;
418 
419  /// \return The static element count (vector number of elements) the vector
420  /// length parameter applies to.
422 
423  /// \return The alignment of the pointer used by this load/store/gather or
424  /// scatter.
426  // MaybeAlign setPointerAlignment(Align NewAlign); // TODO
427 
428  /// \return The pointer operand of this load,store, gather or scatter.
429  Value *getMemoryPointerParam() const;
431 
432  /// \return The data (payload) operand of this store or scatter.
433  Value *getMemoryDataParam() const;
435 
436  // Methods for support type inquiry through isa, cast, and dyn_cast:
437  static bool classof(const IntrinsicInst *I) {
438  return isVPIntrinsic(I->getIntrinsicID());
439  }
440  static bool classof(const Value *V) {
441  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
442  }
443 
444  // Equivalent non-predicated opcode
447  }
448 
449  // Equivalent non-predicated opcode
451 };
452 
453 /// This represents vector predication reduction intrinsics.
455 public:
456  static bool isVPReduction(Intrinsic::ID ID);
457 
458  unsigned getStartParamPos() const;
459  unsigned getVectorParamPos() const;
460 
463 
464  /// Methods for support type inquiry through isa, cast, and dyn_cast:
465  /// @{
466  static bool classof(const IntrinsicInst *I) {
467  return VPReductionIntrinsic::isVPReduction(I->getIntrinsicID());
468  }
469  static bool classof(const Value *V) {
470  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
471  }
472  /// @}
473 };
474 
475 /// This is the common base class for constrained floating point intrinsics.
477 public:
478  bool isUnaryOp() const;
479  bool isTernaryOp() const;
482  bool isDefaultFPEnvironment() const;
483 
484  // Methods for support type inquiry through isa, cast, and dyn_cast:
485  static bool classof(const IntrinsicInst *I);
486  static bool classof(const Value *V) {
487  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
488  }
489 };
490 
491 /// Constrained floating point compare intrinsics.
493 public:
495 
496  // Methods for support type inquiry through isa, cast, and dyn_cast:
497  static bool classof(const IntrinsicInst *I) {
498  switch (I->getIntrinsicID()) {
499  case Intrinsic::experimental_constrained_fcmp:
500  case Intrinsic::experimental_constrained_fcmps:
501  return true;
502  default:
503  return false;
504  }
505  }
506  static bool classof(const Value *V) {
507  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
508  }
509 };
510 
511 /// This class represents min/max intrinsics.
513 public:
514  static bool classof(const IntrinsicInst *I) {
515  switch (I->getIntrinsicID()) {
516  case Intrinsic::umin:
517  case Intrinsic::umax:
518  case Intrinsic::smin:
519  case Intrinsic::smax:
520  return true;
521  default:
522  return false;
523  }
524  }
525  static bool classof(const Value *V) {
526  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
527  }
528 
529  Value *getLHS() const { return const_cast<Value *>(getArgOperand(0)); }
530  Value *getRHS() const { return const_cast<Value *>(getArgOperand(1)); }
531 
532  /// Returns the comparison predicate underlying the intrinsic.
534  switch (ID) {
535  case Intrinsic::umin:
536  return ICmpInst::Predicate::ICMP_ULT;
537  case Intrinsic::umax:
538  return ICmpInst::Predicate::ICMP_UGT;
539  case Intrinsic::smin:
540  return ICmpInst::Predicate::ICMP_SLT;
541  case Intrinsic::smax:
542  return ICmpInst::Predicate::ICMP_SGT;
543  default:
544  llvm_unreachable("Invalid intrinsic");
545  }
546  }
547 
548  /// Returns the comparison predicate underlying the intrinsic.
550  return getPredicate(getIntrinsicID());
551  }
552 
553  /// Whether the intrinsic is signed or unsigned.
554  static bool isSigned(Intrinsic::ID ID) {
556  };
557 
558  /// Whether the intrinsic is signed or unsigned.
559  bool isSigned() const { return isSigned(getIntrinsicID()); };
560 
561  /// Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values,
562  /// so there is a certain threshold value, upon reaching which,
563  /// their value can no longer change. Return said threshold.
564  static APInt getSaturationPoint(Intrinsic::ID ID, unsigned numBits) {
565  switch (ID) {
566  case Intrinsic::umin:
567  return APInt::getMinValue(numBits);
568  case Intrinsic::umax:
569  return APInt::getMaxValue(numBits);
570  case Intrinsic::smin:
571  return APInt::getSignedMinValue(numBits);
572  case Intrinsic::smax:
573  return APInt::getSignedMaxValue(numBits);
574  default:
575  llvm_unreachable("Invalid intrinsic");
576  }
577  }
578 
579  /// Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values,
580  /// so there is a certain threshold value, upon reaching which,
581  /// their value can no longer change. Return said threshold.
582  APInt getSaturationPoint(unsigned numBits) const {
583  return getSaturationPoint(getIntrinsicID(), numBits);
584  }
585 
586  /// Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values,
587  /// so there is a certain threshold value, upon reaching which,
588  /// their value can no longer change. Return said threshold.
592  }
593 
594  /// Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values,
595  /// so there is a certain threshold value, upon reaching which,
596  /// their value can no longer change. Return said threshold.
598  return getSaturationPoint(getIntrinsicID(), Ty);
599  }
600 };
601 
602 /// This class represents an intrinsic that is based on a binary operation.
603 /// This includes op.with.overflow and saturating add/sub intrinsics.
605 public:
606  static bool classof(const IntrinsicInst *I) {
607  switch (I->getIntrinsicID()) {
608  case Intrinsic::uadd_with_overflow:
609  case Intrinsic::sadd_with_overflow:
610  case Intrinsic::usub_with_overflow:
611  case Intrinsic::ssub_with_overflow:
612  case Intrinsic::umul_with_overflow:
613  case Intrinsic::smul_with_overflow:
614  case Intrinsic::uadd_sat:
615  case Intrinsic::sadd_sat:
616  case Intrinsic::usub_sat:
617  case Intrinsic::ssub_sat:
618  return true;
619  default:
620  return false;
621  }
622  }
623  static bool classof(const Value *V) {
624  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
625  }
626 
627  Value *getLHS() const { return const_cast<Value *>(getArgOperand(0)); }
628  Value *getRHS() const { return const_cast<Value *>(getArgOperand(1)); }
629 
630  /// Returns the binary operation underlying the intrinsic.
632 
633  /// Whether the intrinsic is signed or unsigned.
634  bool isSigned() const;
635 
636  /// Returns one of OBO::NoSignedWrap or OBO::NoUnsignedWrap.
637  unsigned getNoWrapKind() const;
638 };
639 
640 /// Represents an op.with.overflow intrinsic.
642 public:
643  static bool classof(const IntrinsicInst *I) {
644  switch (I->getIntrinsicID()) {
645  case Intrinsic::uadd_with_overflow:
646  case Intrinsic::sadd_with_overflow:
647  case Intrinsic::usub_with_overflow:
648  case Intrinsic::ssub_with_overflow:
649  case Intrinsic::umul_with_overflow:
650  case Intrinsic::smul_with_overflow:
651  return true;
652  default:
653  return false;
654  }
655  }
656  static bool classof(const Value *V) {
657  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
658  }
659 };
660 
661 /// Represents a saturating add/sub intrinsic.
663 public:
664  static bool classof(const IntrinsicInst *I) {
665  switch (I->getIntrinsicID()) {
666  case Intrinsic::uadd_sat:
667  case Intrinsic::sadd_sat:
668  case Intrinsic::usub_sat:
669  case Intrinsic::ssub_sat:
670  return true;
671  default:
672  return false;
673  }
674  }
675  static bool classof(const Value *V) {
676  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
677  }
678 };
679 
680 /// Common base class for all memory intrinsics. Simply provides
681 /// common methods.
682 /// Written as CRTP to avoid a common base class amongst the
683 /// three atomicity hierarchies.
684 template <typename Derived> class MemIntrinsicBase : public IntrinsicInst {
685 private:
686  enum { ARG_DEST = 0, ARG_LENGTH = 2 };
687 
688 public:
689  Value *getRawDest() const {
690  return const_cast<Value *>(getArgOperand(ARG_DEST));
691  }
692  const Use &getRawDestUse() const { return getArgOperandUse(ARG_DEST); }
693  Use &getRawDestUse() { return getArgOperandUse(ARG_DEST); }
694 
695  Value *getLength() const {
696  return const_cast<Value *>(getArgOperand(ARG_LENGTH));
697  }
698  const Use &getLengthUse() const { return getArgOperandUse(ARG_LENGTH); }
699  Use &getLengthUse() { return getArgOperandUse(ARG_LENGTH); }
700 
701  /// This is just like getRawDest, but it strips off any cast
702  /// instructions (including addrspacecast) that feed it, giving the
703  /// original input. The returned value is guaranteed to be a pointer.
704  Value *getDest() const { return getRawDest()->stripPointerCasts(); }
705 
706  unsigned getDestAddressSpace() const {
707  return cast<PointerType>(getRawDest()->getType())->getAddressSpace();
708  }
709 
710  /// FIXME: Remove this function once transition to Align is over.
711  /// Use getDestAlign() instead.
712  unsigned getDestAlignment() const {
713  if (auto MA = getParamAlign(ARG_DEST))
714  return MA->value();
715  return 0;
716  }
717  MaybeAlign getDestAlign() const { return getParamAlign(ARG_DEST); }
718 
719  /// Set the specified arguments of the instruction.
720  void setDest(Value *Ptr) {
721  assert(getRawDest()->getType() == Ptr->getType() &&
722  "setDest called with pointer of wrong type!");
723  setArgOperand(ARG_DEST, Ptr);
724  }
725 
726  /// FIXME: Remove this function once transition to Align is over.
727  /// Use the version that takes MaybeAlign instead of this one.
728  void setDestAlignment(unsigned Alignment) {
729  setDestAlignment(MaybeAlign(Alignment));
730  }
731  void setDestAlignment(MaybeAlign Alignment) {
732  removeParamAttr(ARG_DEST, Attribute::Alignment);
733  if (Alignment)
734  addParamAttr(ARG_DEST,
735  Attribute::getWithAlignment(getContext(), *Alignment));
736  }
737  void setDestAlignment(Align Alignment) {
738  removeParamAttr(ARG_DEST, Attribute::Alignment);
739  addParamAttr(ARG_DEST,
741  }
742 
743  void setLength(Value *L) {
744  assert(getLength()->getType() == L->getType() &&
745  "setLength called with value of wrong type!");
746  setArgOperand(ARG_LENGTH, L);
747  }
748 };
749 
750 /// Common base class for all memory transfer intrinsics. Simply provides
751 /// common methods.
752 template <class BaseCL> class MemTransferBase : public BaseCL {
753 private:
754  enum { ARG_SOURCE = 1 };
755 
756 public:
757  /// Return the arguments to the instruction.
758  Value *getRawSource() const {
759  return const_cast<Value *>(BaseCL::getArgOperand(ARG_SOURCE));
760  }
761  const Use &getRawSourceUse() const {
762  return BaseCL::getArgOperandUse(ARG_SOURCE);
763  }
764  Use &getRawSourceUse() { return BaseCL::getArgOperandUse(ARG_SOURCE); }
765 
766  /// This is just like getRawSource, but it strips off any cast
767  /// instructions that feed it, giving the original input. The returned
768  /// value is guaranteed to be a pointer.
769  Value *getSource() const { return getRawSource()->stripPointerCasts(); }
770 
771  unsigned getSourceAddressSpace() const {
772  return cast<PointerType>(getRawSource()->getType())->getAddressSpace();
773  }
774 
775  /// FIXME: Remove this function once transition to Align is over.
776  /// Use getSourceAlign() instead.
777  unsigned getSourceAlignment() const {
778  if (auto MA = BaseCL::getParamAlign(ARG_SOURCE))
779  return MA->value();
780  return 0;
781  }
782 
784  return BaseCL::getParamAlign(ARG_SOURCE);
785  }
786 
787  void setSource(Value *Ptr) {
788  assert(getRawSource()->getType() == Ptr->getType() &&
789  "setSource called with pointer of wrong type!");
790  BaseCL::setArgOperand(ARG_SOURCE, Ptr);
791  }
792 
793  /// FIXME: Remove this function once transition to Align is over.
794  /// Use the version that takes MaybeAlign instead of this one.
795  void setSourceAlignment(unsigned Alignment) {
796  setSourceAlignment(MaybeAlign(Alignment));
797  }
798  void setSourceAlignment(MaybeAlign Alignment) {
799  BaseCL::removeParamAttr(ARG_SOURCE, Attribute::Alignment);
800  if (Alignment)
801  BaseCL::addParamAttr(ARG_SOURCE, Attribute::getWithAlignment(
802  BaseCL::getContext(), *Alignment));
803  }
804  void setSourceAlignment(Align Alignment) {
805  BaseCL::removeParamAttr(ARG_SOURCE, Attribute::Alignment);
806  BaseCL::addParamAttr(ARG_SOURCE, Attribute::getWithAlignment(
807  BaseCL::getContext(), Alignment));
808  }
809 };
810 
811 /// Common base class for all memset intrinsics. Simply provides
812 /// common methods.
813 template <class BaseCL> class MemSetBase : public BaseCL {
814 private:
815  enum { ARG_VALUE = 1 };
816 
817 public:
818  Value *getValue() const {
819  return const_cast<Value *>(BaseCL::getArgOperand(ARG_VALUE));
820  }
821  const Use &getValueUse() const { return BaseCL::getArgOperandUse(ARG_VALUE); }
822  Use &getValueUse() { return BaseCL::getArgOperandUse(ARG_VALUE); }
823 
824  void setValue(Value *Val) {
825  assert(getValue()->getType() == Val->getType() &&
826  "setValue called with value of wrong type!");
827  BaseCL::setArgOperand(ARG_VALUE, Val);
828  }
829 };
830 
831 // The common base class for the atomic memset/memmove/memcpy intrinsics
832 // i.e. llvm.element.unordered.atomic.memset/memcpy/memmove
833 class AtomicMemIntrinsic : public MemIntrinsicBase<AtomicMemIntrinsic> {
834 private:
835  enum { ARG_ELEMENTSIZE = 3 };
836 
837 public:
839  return const_cast<Value *>(getArgOperand(ARG_ELEMENTSIZE));
840  }
841 
843  return cast<ConstantInt>(getRawElementSizeInBytes());
844  }
845 
848  }
849 
852  "setElementSizeInBytes called with value of wrong type!");
853  setArgOperand(ARG_ELEMENTSIZE, V);
854  }
855 
856  static bool classof(const IntrinsicInst *I) {
857  switch (I->getIntrinsicID()) {
858  case Intrinsic::memcpy_element_unordered_atomic:
859  case Intrinsic::memmove_element_unordered_atomic:
860  case Intrinsic::memset_element_unordered_atomic:
861  return true;
862  default:
863  return false;
864  }
865  }
866  static bool classof(const Value *V) {
867  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
868  }
869 };
870 
871 /// This class represents atomic memset intrinsic
872 // i.e. llvm.element.unordered.atomic.memset
873 class AtomicMemSetInst : public MemSetBase<AtomicMemIntrinsic> {
874 public:
875  static bool classof(const IntrinsicInst *I) {
876  return I->getIntrinsicID() == Intrinsic::memset_element_unordered_atomic;
877  }
878  static bool classof(const Value *V) {
879  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
880  }
881 };
882 
883 // This class wraps the atomic memcpy/memmove intrinsics
884 // i.e. llvm.element.unordered.atomic.memcpy/memmove
885 class AtomicMemTransferInst : public MemTransferBase<AtomicMemIntrinsic> {
886 public:
887  static bool classof(const IntrinsicInst *I) {
888  switch (I->getIntrinsicID()) {
889  case Intrinsic::memcpy_element_unordered_atomic:
890  case Intrinsic::memmove_element_unordered_atomic:
891  return true;
892  default:
893  return false;
894  }
895  }
896  static bool classof(const Value *V) {
897  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
898  }
899 };
900 
901 /// This class represents the atomic memcpy intrinsic
902 /// i.e. llvm.element.unordered.atomic.memcpy
904 public:
905  static bool classof(const IntrinsicInst *I) {
906  return I->getIntrinsicID() == Intrinsic::memcpy_element_unordered_atomic;
907  }
908  static bool classof(const Value *V) {
909  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
910  }
911 };
912 
913 /// This class represents the atomic memmove intrinsic
914 /// i.e. llvm.element.unordered.atomic.memmove
916 public:
917  static bool classof(const IntrinsicInst *I) {
918  return I->getIntrinsicID() == Intrinsic::memmove_element_unordered_atomic;
919  }
920  static bool classof(const Value *V) {
921  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
922  }
923 };
924 
925 /// This is the common base class for memset/memcpy/memmove.
926 class MemIntrinsic : public MemIntrinsicBase<MemIntrinsic> {
927 private:
928  enum { ARG_VOLATILE = 3 };
929 
930 public:
932  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(ARG_VOLATILE)));
933  }
934 
935  bool isVolatile() const { return !getVolatileCst()->isZero(); }
936 
937  void setVolatile(Constant *V) { setArgOperand(ARG_VOLATILE, V); }
938 
939  // Methods for support type inquiry through isa, cast, and dyn_cast:
940  static bool classof(const IntrinsicInst *I) {
941  switch (I->getIntrinsicID()) {
942  case Intrinsic::memcpy:
943  case Intrinsic::memmove:
944  case Intrinsic::memset:
945  case Intrinsic::memcpy_inline:
946  return true;
947  default:
948  return false;
949  }
950  }
951  static bool classof(const Value *V) {
952  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
953  }
954 };
955 
956 /// This class wraps the llvm.memset intrinsic.
957 class MemSetInst : public MemSetBase<MemIntrinsic> {
958 public:
959  // Methods for support type inquiry through isa, cast, and dyn_cast:
960  static bool classof(const IntrinsicInst *I) {
961  return I->getIntrinsicID() == Intrinsic::memset;
962  }
963  static bool classof(const Value *V) {
964  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
965  }
966 };
967 
968 /// This class wraps the llvm.memcpy/memmove intrinsics.
969 class MemTransferInst : public MemTransferBase<MemIntrinsic> {
970 public:
971  // Methods for support type inquiry through isa, cast, and dyn_cast:
972  static bool classof(const IntrinsicInst *I) {
973  switch (I->getIntrinsicID()) {
974  case Intrinsic::memcpy:
975  case Intrinsic::memmove:
976  case Intrinsic::memcpy_inline:
977  return true;
978  default:
979  return false;
980  }
981  }
982  static bool classof(const Value *V) {
983  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
984  }
985 };
986 
987 /// This class wraps the llvm.memcpy intrinsic.
988 class MemCpyInst : public MemTransferInst {
989 public:
990  // Methods for support type inquiry through isa, cast, and dyn_cast:
991  static bool classof(const IntrinsicInst *I) {
992  return I->getIntrinsicID() == Intrinsic::memcpy ||
993  I->getIntrinsicID() == Intrinsic::memcpy_inline;
994  }
995  static bool classof(const Value *V) {
996  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
997  }
998 };
999 
1000 /// This class wraps the llvm.memmove intrinsic.
1002 public:
1003  // Methods for support type inquiry through isa, cast, and dyn_cast:
1004  static bool classof(const IntrinsicInst *I) {
1005  return I->getIntrinsicID() == Intrinsic::memmove;
1006  }
1007  static bool classof(const Value *V) {
1008  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1009  }
1010 };
1011 
1012 /// This class wraps the llvm.memcpy.inline intrinsic.
1014 public:
1016  return cast<ConstantInt>(MemCpyInst::getLength());
1017  }
1018  // Methods for support type inquiry through isa, cast, and dyn_cast:
1019  static bool classof(const IntrinsicInst *I) {
1020  return I->getIntrinsicID() == Intrinsic::memcpy_inline;
1021  }
1022  static bool classof(const Value *V) {
1023  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1024  }
1025 };
1026 
1027 // The common base class for any memset/memmove/memcpy intrinsics;
1028 // whether they be atomic or non-atomic.
1029 // i.e. llvm.element.unordered.atomic.memset/memcpy/memmove
1030 // and llvm.memset/memcpy/memmove
1031 class AnyMemIntrinsic : public MemIntrinsicBase<AnyMemIntrinsic> {
1032 public:
1033  bool isVolatile() const {
1034  // Only the non-atomic intrinsics can be volatile
1035  if (auto *MI = dyn_cast<MemIntrinsic>(this))
1036  return MI->isVolatile();
1037  return false;
1038  }
1039 
1040  static bool classof(const IntrinsicInst *I) {
1041  switch (I->getIntrinsicID()) {
1042  case Intrinsic::memcpy:
1043  case Intrinsic::memcpy_inline:
1044  case Intrinsic::memmove:
1045  case Intrinsic::memset:
1046  case Intrinsic::memcpy_element_unordered_atomic:
1047  case Intrinsic::memmove_element_unordered_atomic:
1048  case Intrinsic::memset_element_unordered_atomic:
1049  return true;
1050  default:
1051  return false;
1052  }
1053  }
1054  static bool classof(const Value *V) {
1055  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1056  }
1057 };
1058 
1059 /// This class represents any memset intrinsic
1060 // i.e. llvm.element.unordered.atomic.memset
1061 // and llvm.memset
1062 class AnyMemSetInst : public MemSetBase<AnyMemIntrinsic> {
1063 public:
1064  static bool classof(const IntrinsicInst *I) {
1065  switch (I->getIntrinsicID()) {
1066  case Intrinsic::memset:
1067  case Intrinsic::memset_element_unordered_atomic:
1068  return true;
1069  default:
1070  return false;
1071  }
1072  }
1073  static bool classof(const Value *V) {
1074  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1075  }
1076 };
1077 
1078 // This class wraps any memcpy/memmove intrinsics
1079 // i.e. llvm.element.unordered.atomic.memcpy/memmove
1080 // and llvm.memcpy/memmove
1081 class AnyMemTransferInst : public MemTransferBase<AnyMemIntrinsic> {
1082 public:
1083  static bool classof(const IntrinsicInst *I) {
1084  switch (I->getIntrinsicID()) {
1085  case Intrinsic::memcpy:
1086  case Intrinsic::memcpy_inline:
1087  case Intrinsic::memmove:
1088  case Intrinsic::memcpy_element_unordered_atomic:
1089  case Intrinsic::memmove_element_unordered_atomic:
1090  return true;
1091  default:
1092  return false;
1093  }
1094  }
1095  static bool classof(const Value *V) {
1096  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1097  }
1098 };
1099 
1100 /// This class represents any memcpy intrinsic
1101 /// i.e. llvm.element.unordered.atomic.memcpy
1102 /// and llvm.memcpy
1104 public:
1105  static bool classof(const IntrinsicInst *I) {
1106  switch (I->getIntrinsicID()) {
1107  case Intrinsic::memcpy:
1108  case Intrinsic::memcpy_inline:
1109  case Intrinsic::memcpy_element_unordered_atomic:
1110  return true;
1111  default:
1112  return false;
1113  }
1114  }
1115  static bool classof(const Value *V) {
1116  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1117  }
1118 };
1119 
1120 /// This class represents any memmove intrinsic
1121 /// i.e. llvm.element.unordered.atomic.memmove
1122 /// and llvm.memmove
1124 public:
1125  static bool classof(const IntrinsicInst *I) {
1126  switch (I->getIntrinsicID()) {
1127  case Intrinsic::memmove:
1128  case Intrinsic::memmove_element_unordered_atomic:
1129  return true;
1130  default:
1131  return false;
1132  }
1133  }
1134  static bool classof(const Value *V) {
1135  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1136  }
1137 };
1138 
1139 /// This represents the llvm.va_start intrinsic.
1140 class VAStartInst : public IntrinsicInst {
1141 public:
1142  static bool classof(const IntrinsicInst *I) {
1143  return I->getIntrinsicID() == Intrinsic::vastart;
1144  }
1145  static bool classof(const Value *V) {
1146  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1147  }
1148 
1149  Value *getArgList() const { return const_cast<Value *>(getArgOperand(0)); }
1150 };
1151 
1152 /// This represents the llvm.va_end intrinsic.
1153 class VAEndInst : public IntrinsicInst {
1154 public:
1155  static bool classof(const IntrinsicInst *I) {
1156  return I->getIntrinsicID() == Intrinsic::vaend;
1157  }
1158  static bool classof(const Value *V) {
1159  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1160  }
1161 
1162  Value *getArgList() const { return const_cast<Value *>(getArgOperand(0)); }
1163 };
1164 
1165 /// This represents the llvm.va_copy intrinsic.
1166 class VACopyInst : public IntrinsicInst {
1167 public:
1168  static bool classof(const IntrinsicInst *I) {
1169  return I->getIntrinsicID() == Intrinsic::vacopy;
1170  }
1171  static bool classof(const Value *V) {
1172  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1173  }
1174 
1175  Value *getDest() const { return const_cast<Value *>(getArgOperand(0)); }
1176  Value *getSrc() const { return const_cast<Value *>(getArgOperand(1)); }
1177 };
1178 
1179 /// This represents the llvm.instrprof_increment intrinsic.
1181 public:
1182  static bool classof(const IntrinsicInst *I) {
1183  return I->getIntrinsicID() == Intrinsic::instrprof_increment;
1184  }
1185  static bool classof(const Value *V) {
1186  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1187  }
1188 
1190  return cast<GlobalVariable>(
1191  const_cast<Value *>(getArgOperand(0))->stripPointerCasts());
1192  }
1193 
1195  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
1196  }
1197 
1199  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(2)));
1200  }
1201 
1203  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
1204  }
1205 
1206  Value *getStep() const;
1207 };
1208 
1210 public:
1211  static bool classof(const IntrinsicInst *I) {
1212  return I->getIntrinsicID() == Intrinsic::instrprof_increment_step;
1213  }
1214  static bool classof(const Value *V) {
1215  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1216  }
1217 };
1218 
1219 /// This represents the llvm.instrprof_value_profile intrinsic.
1221 public:
1222  static bool classof(const IntrinsicInst *I) {
1223  return I->getIntrinsicID() == Intrinsic::instrprof_value_profile;
1224  }
1225  static bool classof(const Value *V) {
1226  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1227  }
1228 
1230  return cast<GlobalVariable>(
1231  const_cast<Value *>(getArgOperand(0))->stripPointerCasts());
1232  }
1233 
1235  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
1236  }
1237 
1239  return cast<Value>(const_cast<Value *>(getArgOperand(2)));
1240  }
1241 
1243  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
1244  }
1245 
1246  // Returns the value site index.
1248  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(4)));
1249  }
1250 };
1251 
1253 public:
1254  static bool classof(const IntrinsicInst *I) {
1255  return I->getIntrinsicID() == Intrinsic::pseudoprobe;
1256  }
1257 
1258  static bool classof(const Value *V) {
1259  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1260  }
1261 
1263  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(0)));
1264  }
1265 
1267  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
1268  }
1269 
1271  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(2)));
1272  }
1273 
1275  return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
1276  }
1277 };
1278 
1280 public:
1281  static bool classof(const IntrinsicInst *I) {
1282  return I->getIntrinsicID() == Intrinsic::experimental_noalias_scope_decl;
1283  }
1284 
1285  static bool classof(const Value *V) {
1286  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1287  }
1288 
1290  auto *MV =
1291  cast<MetadataAsValue>(getOperand(Intrinsic::NoAliasScopeDeclScopeArg));
1292  return cast<MDNode>(MV->getMetadata());
1293  }
1294 
1295  void setScopeList(MDNode *ScopeList) {
1297  MetadataAsValue::get(getContext(), ScopeList));
1298  }
1299 };
1300 
1301 // Defined in Statepoint.h -- NOT a subclass of IntrinsicInst
1302 class GCStatepointInst;
1303 
1304 /// Common base class for representing values projected from a statepoint.
1305 /// Currently, the only projections available are gc.result and gc.relocate.
1307 public:
1308  static bool classof(const IntrinsicInst *I) {
1309  return I->getIntrinsicID() == Intrinsic::experimental_gc_relocate ||
1310  I->getIntrinsicID() == Intrinsic::experimental_gc_result;
1311  }
1312 
1313  static bool classof(const Value *V) {
1314  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1315  }
1316 
1317  /// Return true if this relocate is tied to the invoke statepoint.
1318  /// This includes relocates which are on the unwinding path.
1319  bool isTiedToInvoke() const {
1320  const Value *Token = getArgOperand(0);
1321 
1322  return isa<LandingPadInst>(Token) || isa<InvokeInst>(Token);
1323  }
1324 
1325  /// The statepoint with which this gc.relocate is associated.
1326  const GCStatepointInst *getStatepoint() const;
1327 };
1328 
1329 /// Represents calls to the gc.relocate intrinsic.
1331 public:
1332  static bool classof(const IntrinsicInst *I) {
1333  return I->getIntrinsicID() == Intrinsic::experimental_gc_relocate;
1334  }
1335 
1336  static bool classof(const Value *V) {
1337  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1338  }
1339 
1340  /// The index into the associate statepoint's argument list
1341  /// which contains the base pointer of the pointer whose
1342  /// relocation this gc.relocate describes.
1343  unsigned getBasePtrIndex() const {
1344  return cast<ConstantInt>(getArgOperand(1))->getZExtValue();
1345  }
1346 
1347  /// The index into the associate statepoint's argument list which
1348  /// contains the pointer whose relocation this gc.relocate describes.
1349  unsigned getDerivedPtrIndex() const {
1350  return cast<ConstantInt>(getArgOperand(2))->getZExtValue();
1351  }
1352 
1353  Value *getBasePtr() const;
1354  Value *getDerivedPtr() const;
1355 };
1356 
1357 /// Represents calls to the gc.result intrinsic.
1359 public:
1360  static bool classof(const IntrinsicInst *I) {
1361  return I->getIntrinsicID() == Intrinsic::experimental_gc_result;
1362  }
1363 
1364  static bool classof(const Value *V) {
1365  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1366  }
1367 };
1368 
1369 
1370 /// This represents the llvm.assume intrinsic.
1371 class AssumeInst : public IntrinsicInst {
1372 public:
1373  static bool classof(const IntrinsicInst *I) {
1374  return I->getIntrinsicID() == Intrinsic::assume;
1375  }
1376  static bool classof(const Value *V) {
1377  return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1378  }
1379 };
1380 
1381 } // end namespace llvm
1382 
1383 #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:1279
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:554
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:664
llvm::MemCpyInlineInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1022
llvm::MemSetInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:960
llvm::DbgInfoIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:138
llvm::MemCpyInlineInst::getLength
ConstantInt * getLength() const
Definition: IntrinsicInst.h:1015
llvm::MemIntrinsicBase::getDestAlignment
unsigned getDestAlignment() const
FIXME: Remove this function once transition to Align is over.
Definition: IntrinsicInst.h:712
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:105
llvm::DbgVariableIntrinsic::getRawExpression
Metadata * getRawExpression() const
Definition: IntrinsicInst.h:269
llvm
This is an optimization pass for GlobalISel generic memory operations.
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:1252
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:1214
llvm::MinMaxIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:514
llvm::WithOverflowInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:643
Metadata.h
llvm::CmpInst::Predicate
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:721
llvm::MemIntrinsicBase::getDestAlign
MaybeAlign getDestAlign() const
Definition: IntrinsicInst.h:717
llvm::InstrProfValueProfileInst::getHash
ConstantInt * getHash() const
Definition: IntrinsicInst.h:1234
llvm::ElementCount
Definition: TypeSize.h:385
llvm::ConstrainedFPCmpIntrinsic
Constrained floating point compare intrinsics.
Definition: IntrinsicInst.h:492
DebugInfoMetadata.h
llvm::ConstrainedFPCmpIntrinsic::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:506
llvm::MemTransferInst
This class wraps the llvm.memcpy/memmove intrinsics.
Definition: IntrinsicInst.h:969
llvm::Function
Definition: Function.h:62
llvm::AtomicMemIntrinsic::getElementSizeInBytes
uint32_t getElementSizeInBytes() const
Definition: IntrinsicInst.h:846
llvm::GCRelocateInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1332
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:1001
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::VPReductionIntrinsic::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:469
llvm::AtomicMemIntrinsic::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:866
llvm::AnyMemSetInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1073
llvm::AtomicMemIntrinsic::getRawElementSizeInBytes
Value * getRawElementSizeInBytes() const
Definition: IntrinsicInst.h:838
llvm::BinaryOpIntrinsic::getRHS
Value * getRHS() const
Definition: IntrinsicInst.h:628
llvm::MemIntrinsicBase::getDestAddressSpace
unsigned getDestAddressSpace() const
Definition: IntrinsicInst.h:706
llvm::APInt::getMinValue
static APInt getMinValue(unsigned numBits)
Gets minimum unsigned value of APInt for a specific bit width.
Definition: APInt.h:196
llvm::BinaryOpIntrinsic::getLHS
Value * getLHS() const
Definition: IntrinsicInst.h:627
llvm::InstrProfIncrementInstStep::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1211
llvm::APInt::getMaxValue
static APInt getMaxValue(unsigned numBits)
Gets maximum unsigned value of APInt for specific bit width.
Definition: APInt.h:186
llvm::VACopyInst::getSrc
Value * getSrc() const
Definition: IntrinsicInst.h:1176
llvm::VPIntrinsic::setVectorLengthParam
void setVectorLengthParam(Value *)
Definition: IntrinsicInst.cpp:313
llvm::VAStartInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1145
llvm::GlobalVariable
Definition: GlobalVariable.h:39
llvm::BinaryOpIntrinsic
This class represents an intrinsic that is based on a binary operation.
Definition: IntrinsicInst.h:604
llvm::MemIntrinsic::getVolatileCst
ConstantInt * getVolatileCst() const
Definition: IntrinsicInst.h:931
llvm::VPReductionIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: IntrinsicInst.h:466
llvm::MemMoveInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1004
llvm::DbgVariableIntrinsic::replaceVariableLocationOp
void replaceVariableLocationOp(Value *OldValue, Value *NewValue)
Definition: IntrinsicInst.cpp:82
llvm::VPIntrinsic::canIgnoreVectorLengthParam
bool canIgnoreVectorLengthParam() const
Definition: IntrinsicInst.cpp:428
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:1354
llvm::NoAliasScopeDeclInst::getScopeList
MDNode * getScopeList() const
Definition: IntrinsicInst.h:1289
llvm::AtomicMemIntrinsic::getElementSizeInBytesCst
ConstantInt * getElementSizeInBytesCst() const
Definition: IntrinsicInst.h:842
NewExpr
Definition: ItaniumDemangle.h:1916
llvm::AssumeInst
This represents the llvm.assume intrinsic.
Definition: IntrinsicInst.h:1371
llvm::GCProjectionInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1313
llvm::APInt::getSignedMaxValue
static APInt getSignedMaxValue(unsigned numBits)
Gets maximum signed value of APInt for a specific bit width.
Definition: APInt.h:189
llvm::AnyMemIntrinsic::isVolatile
bool isVolatile() const
Definition: IntrinsicInst.h:1033
llvm::VPIntrinsic::getDeclarationForParams
static Function * getDeclarationForParams(Module *M, Intrinsic::ID, Type *ReturnType, ArrayRef< Value * > Params)
Declares a llvm.vp.
Definition: IntrinsicInst.cpp:470
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::MemIntrinsic::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:951
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:1343
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:926
llvm::VPIntrinsic::getFunctionalOpcodeForVP
static Optional< unsigned > getFunctionalOpcodeForVP(Intrinsic::ID ID)
Definition: IntrinsicInst.cpp:403
llvm::Optional< uint64_t >
llvm::MinMaxIntrinsic::getPredicate
static ICmpInst::Predicate getPredicate(Intrinsic::ID ID)
Returns the comparison predicate underlying the intrinsic.
Definition: IntrinsicInst.h:533
llvm::SmallPtrSet< Value *, 4 >
llvm::MemIntrinsicBase::setDestAlignment
void setDestAlignment(MaybeAlign Alignment)
Definition: IntrinsicInst.h:731
llvm::ConstrainedFPIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.cpp:273
llvm::RegState::Undef
@ Undef
Value of the register doesn't matter.
Definition: MachineInstrBuilder.h:52
llvm::InstrProfIncrementInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1185
llvm::DIExpression
DWARF expression.
Definition: DebugInfoMetadata.h:2596
RHS
Value * RHS
Definition: X86PartialReduction.cpp:74
llvm::DbgLabelInst::getRawLabel
Metadata * getRawLabel() const
Definition: IntrinsicInst.h:374
llvm::WithOverflowInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:656
llvm::AnyMemSetInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1064
llvm::CallBase::addParamAttr
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Adds the attribute to the indicated argument.
Definition: InstrTypes.h:1525
llvm::Type::getInt8Ty
static IntegerType * getInt8Ty(LLVMContext &C)
Definition: Type.cpp:239
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:2133
llvm::InstrProfIncrementInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1182
llvm::MemSetBase::getValue
Value * getValue() const
Definition: IntrinsicInst.h:818
llvm::VPIntrinsic::setMaskParam
void setMaskParam(Value *)
Definition: IntrinsicInst.cpp:302
llvm::GCResultInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1364
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:1349
llvm::InstrProfValueProfileInst::getValueKind
ConstantInt * getValueKind() const
Definition: IntrinsicInst.h:1242
llvm::VAStartInst
This represents the llvm.va_start intrinsic.
Definition: IntrinsicInst.h:1140
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:737
llvm::VPReductionIntrinsic::isVPReduction
static bool isVPReduction(Intrinsic::ID ID)
Definition: IntrinsicInst.cpp:510
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:1019
llvm::Intrinsic::getType
FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > Tys=None)
Return the function type for an intrinsic.
Definition: Function.cpp:1355
llvm::CallBase::removeParamAttr
void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Removes the attribute from the given argument.
Definition: InstrTypes.h:1567
llvm::GCProjectionInst
Common base class for representing values projected from a statepoint.
Definition: IntrinsicInst.h:1306
llvm::MemTransferBase::getSourceAddressSpace
unsigned getSourceAddressSpace() const
Definition: IntrinsicInst.h:771
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:821
llvm::DILocalVariable
Local variable.
Definition: DebugInfoMetadata.h:3104
llvm::DbgVariableIntrinsic::isAddressOfVariable
bool isAddressOfVariable() const
Does this describe the address of a local variable.
Definition: IntrinsicInst.h:231
llvm::VPReductionIntrinsic
This represents vector predication reduction intrinsics.
Definition: IntrinsicInst.h:454
Intrinsics.h
llvm::ConstrainedFPIntrinsic
This is the common base class for constrained floating point intrinsics.
Definition: IntrinsicInst.h:476
llvm::MemSetBase::setValue
void setValue(Value *Val)
Definition: IntrinsicInst.h:824
llvm::AtomicMemTransferInst
Definition: IntrinsicInst.h:885
llvm::CallBase::getCalledFunction
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation.
Definition: InstrTypes.h:1398
llvm::PseudoProbeInst::getFactor
ConstantInt * getFactor() const
Definition: IntrinsicInst.h:1274
llvm::InstrProfValueProfileInst::getTargetValue
Value * getTargetValue() const
Definition: IntrinsicInst.h:1238
llvm::MemTransferBase::getRawSourceUse
Use & getRawSourceUse()
Definition: IntrinsicInst.h:764
llvm::AnyMemMoveInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1125
llvm::MemTransferBase::getRawSource
Value * getRawSource() const
Return the arguments to the instruction.
Definition: IntrinsicInst.h:758
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:1013
llvm::VACopyInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1171
llvm::MemCpyInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:991
llvm::BinaryOpIntrinsic::getNoWrapKind
unsigned getNoWrapKind() const
Returns one of OBO::NoSignedWrap or OBO::NoUnsignedWrap.
Definition: IntrinsicInst.cpp:587
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:525
llvm::DbgVariableIntrinsic::setExpression
void setExpression(DIExpression *NewExpr)
Definition: IntrinsicInst.h:217
llvm::SaturatingInst
Represents a saturating add/sub intrinsic.
Definition: IntrinsicInst.h:662
llvm::Type::getScalarSizeInBits
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
Definition: Type.cpp:191
llvm::InstrProfIncrementInstStep
Definition: IntrinsicInst.h:1209
llvm::UndefValue::get
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1804
llvm::VPIntrinsic::getForOpcode
static Intrinsic::ID getForOpcode(unsigned OC)
The llvm.vp.* intrinsics for this instruction Opcode.
Definition: IntrinsicInst.cpp:415
llvm::IntrinsicInst::operator=
IntrinsicInst & operator=(const IntrinsicInst &)=delete
llvm::MemTransferBase::setSourceAlignment
void setSourceAlignment(MaybeAlign Alignment)
Definition: IntrinsicInst.h:798
llvm::InstrProfValueProfileInst::getIndex
ConstantInt * getIndex() const
Definition: IntrinsicInst.h:1247
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::AtomicMemCpyInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:908
llvm::MinMaxIntrinsic::getSaturationPoint
static Constant * getSaturationPoint(Intrinsic::ID ID, Type *Ty)
Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values, so there is a certain thre...
Definition: IntrinsicInst.h:589
llvm::AnyMemIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1040
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:903
llvm::MemTransferBase::getSourceAlign
MaybeAlign getSourceAlign() const
Definition: IntrinsicInst.h:783
llvm::MemTransferInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:972
llvm::DbgVariableIntrinsic::getNumVariableLocationOps
unsigned getNumVariableLocationOps() const
Definition: IntrinsicInst.h:221
llvm::MemSetInst
This class wraps the llvm.memset intrinsic.
Definition: IntrinsicInst.h:957
llvm::AnyMemTransferInst
Definition: IntrinsicInst.h:1081
llvm::maxnum
LLVM_READONLY APFloat maxnum(const APFloat &A, const APFloat &B)
Implements IEEE maxNum semantics.
Definition: APFloat.h:1307
llvm::VPIntrinsic::getMemoryPointerParamPos
static Optional< unsigned > getMemoryPointerParamPos(Intrinsic::ID)
Definition: IntrinsicInst.cpp:358
llvm::AtomicMemSetInst
This class represents atomic memset intrinsic.
Definition: IntrinsicInst.h:873
llvm::VAEndInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1158
llvm::VPIntrinsic::getVectorLengthParam
Value * getVectorLengthParam() const
Definition: IntrinsicInst.cpp:307
llvm::NoAliasScopeDeclInst::setScopeList
void setScopeList(MDNode *ScopeList)
Definition: IntrinsicInst.h:1295
llvm::VPIntrinsic::getFunctionalOpcode
Optional< unsigned > getFunctionalOpcode() const
Definition: IntrinsicInst.h:445
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:606
llvm::PseudoProbeInst::getFuncGuid
ConstantInt * getFuncGuid() const
Definition: IntrinsicInst.h:1262
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:440
llvm::GCRelocateInst
Represents calls to the gc.relocate intrinsic.
Definition: IntrinsicInst.h:1330
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:1220
llvm::BinaryOpIntrinsic::isSigned
bool isSigned() const
Whether the intrinsic is signed or unsigned.
Definition: IntrinsicInst.cpp:574
llvm::DbgVariableIntrinsic::setUndef
void setUndef()
Definition: IntrinsicInst.h:235
llvm::AtomicMemSetInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:875
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::MinMaxIntrinsic::isSigned
static bool isSigned(Intrinsic::ID ID)
Whether the intrinsic is signed or unsigned.
Definition: IntrinsicInst.h:554
llvm::GCRelocateInst::getDerivedPtr
Value * getDerivedPtr() const
Definition: IntrinsicInst.cpp:619
llvm::MemTransferBase::setSource
void setSource(Value *Ptr)
Definition: IntrinsicInst.h:787
llvm::DbgLabelInst::getLabel
DILabel * getLabel() const
Definition: IntrinsicInst.h:372
llvm::ConstrainedFPIntrinsic::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:486
llvm::AssumeInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1373
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::iterator_facade_base
CRTP base class which implements the entire standard iterator facade in terms of a minimal subset of ...
Definition: iterator.h:80
llvm::IntrinsicInst::classof
static bool classof(const CallInst *I)
Definition: IntrinsicInst.h:110
llvm::InstrProfIncrementInst::getIndex
ConstantInt * getIndex() const
Definition: IntrinsicInst.h:1202
llvm::VPIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:437
llvm::VPIntrinsic::isVPIntrinsic
static bool isVPIntrinsic(Intrinsic::ID)
Definition: IntrinsicInst.cpp:390
llvm::GCProjectionInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1308
llvm::MemTransferBase
Common base class for all memory transfer intrinsics.
Definition: IntrinsicInst.h:752
llvm::AtomicMemCpyInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:905
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:995
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:720
llvm::MinMaxIntrinsic::isSigned
bool isSigned() const
Whether the intrinsic is signed or unsigned.
Definition: IntrinsicInst.h:559
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:1376
llvm::DbgVariableIntrinsic::location_op_iterator::operator++
location_op_iterator & operator++()
Definition: IntrinsicInst.h:182
llvm::SystemZISD::OC
@ OC
Definition: SystemZISelLowering.h:122
llvm::MemTransferInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:982
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:549
llvm::MemIntrinsicBase::getLengthUse
Use & getLengthUse()
Definition: IntrinsicInst.h:699
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:65
llvm::MDNode
Metadata node.
Definition: Metadata.h:906
llvm::InstrProfIncrementInst::getNumCounters
ConstantInt * getNumCounters() const
Definition: IntrinsicInst.h:1198
llvm::MemSetInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:963
llvm::MinMaxIntrinsic::getLHS
Value * getLHS() const
Definition: IntrinsicInst.h:529
llvm::MemIntrinsicBase::setLength
void setLength(Value *L)
Definition: IntrinsicInst.h:743
llvm::AnyMemTransferInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1083
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:1168
llvm::ARM::WinEH::ReturnType
ReturnType
Definition: ARMWinEH.h:25
llvm::MemTransferBase::setSourceAlignment
void setSourceAlignment(Align Alignment)
Definition: IntrinsicInst.h:804
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:75
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:917
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:207
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:2123
llvm::NoAliasScopeDeclInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1285
llvm::InstrProfIncrementInst::getHash
ConstantInt * getHash() const
Definition: IntrinsicInst.h:1194
llvm::MemSetBase
Common base class for all memset intrinsics.
Definition: IntrinsicInst.h:813
llvm::MemIntrinsicBase::getDest
Value * getDest() const
This is just like getRawDest, but it strips off any cast instructions (including addrspacecast) that ...
Definition: IntrinsicInst.h:704
llvm::AnyMemMoveInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1134
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:1153
llvm::AnyMemIntrinsic::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1054
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:1656
llvm::CallBase::getParamAlign
MaybeAlign getParamAlign(unsigned ArgNo) const
Extract the alignment for a call or parameter (0=unknown).
Definition: InstrTypes.h:1729
llvm::MemTransferBase::setSourceAlignment
void setSourceAlignment(unsigned Alignment)
FIXME: Remove this function once transition to Align is over.
Definition: IntrinsicInst.h:795
llvm::PseudoProbeInst::getIndex
ConstantInt * getIndex() const
Definition: IntrinsicInst.h:1266
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:134
llvm::Value::getType
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
llvm::GCResultInst
Represents calls to the gc.result intrinsic.
Definition: IntrinsicInst.h:1358
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:1270
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:991
llvm::InstrProfValueProfileInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1225
llvm::AtomicMemIntrinsic::setElementSizeInBytes
void setElementSizeInBytes(Constant *V)
Definition: IntrinsicInst.h:850
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:641
llvm::VPReductionIntrinsic::getStartParamPos
unsigned getStartParamPos() const
Definition: IntrinsicInst.cpp:526
llvm::MemMoveInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1007
llvm::CallBase::setArgOperand
void setArgOperand(unsigned i, Value *v)
Definition: InstrTypes.h:1348
llvm::PointerUnion
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
Definition: PointerUnion.h:107
llvm::Value::stripPointerCasts
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
Definition: Value.cpp:685
llvm::VAEndInst::getArgList
Value * getArgList() const
Definition: IntrinsicInst.h:1162
llvm::AtomicMemTransferInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:887
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:967
llvm::Attribute::getWithAlignment
static Attribute getWithAlignment(LLVMContext &Context, Align Alignment)
Return a uniquified Attribute object that has the specific alignment set.
Definition: Attributes.cpp:169
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:2138
llvm::GCResultInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1360
llvm::GCRelocateInst::getBasePtr
Value * getBasePtr() const
Definition: IntrinsicInst.cpp:613
llvm::MemIntrinsicBase::getRawDestUse
Use & getRawDestUse()
Definition: IntrinsicInst.h:693
llvm::minnum
LLVM_READONLY APFloat minnum(const APFloat &A, const APFloat &B)
Implements IEEE minNum semantics.
Definition: APFloat.h:1296
llvm::MinMaxIntrinsic::getSaturationPoint
Constant * getSaturationPoint(Type *Ty) const
Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values, so there is a certain thre...
Definition: IntrinsicInst.h:597
FPEnv.h
llvm::AtomicMemTransferInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:896
llvm::InstrProfValueProfileInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1222
llvm::GCRelocateInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1336
llvm::MemIntrinsicBase::getLength
Value * getLength() const
Definition: IntrinsicInst.h:695
llvm::ConstrainedFPIntrinsic::isUnaryOp
bool isUnaryOp() const
Definition: IntrinsicInst.cpp:251
llvm::AnyMemSetInst
This class represents any memset intrinsic.
Definition: IntrinsicInst.h:1062
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:675
llvm::VACopyInst
This represents the llvm.va_copy intrinsic.
Definition: IntrinsicInst.h:1166
llvm::VAStartInst::getArgList
Value * getArgList() const
Definition: IntrinsicInst.h:1149
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:684
llvm::VPReductionIntrinsic::getVectorParamPos
unsigned getVectorParamPos() const
Definition: IntrinsicInst.cpp:522
llvm::MemIntrinsicBase::setDestAlignment
void setDestAlignment(unsigned Alignment)
FIXME: Remove this function once transition to Align is over.
Definition: IntrinsicInst.h:728
Casting.h
Function.h
llvm::NoAliasScopeDeclInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1281
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:777
llvm::CmpInst::isSigned
bool isSigned() const
Definition: InstrTypes.h:949
llvm::VACopyInst::getDest
Value * getDest() const
Definition: IntrinsicInst.h:1175
llvm::MemIntrinsicBase::getLengthUse
const Use & getLengthUse() const
Definition: IntrinsicInst.h:698
llvm::ConstrainedFPIntrinsic::isTernaryOp
bool isTernaryOp() const
Definition: IntrinsicInst.cpp:262
llvm::VAEndInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1155
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:1123
llvm::APInt::getSignedMinValue
static APInt getSignedMinValue(unsigned numBits)
Gets minimum signed value of APInt for a specific bit width.
Definition: APInt.h:199
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:1180
llvm::AtomicMemIntrinsic
Definition: IntrinsicInst.h:833
llvm::MinMaxIntrinsic::getSaturationPoint
static APInt getSaturationPoint(Intrinsic::ID ID, unsigned numBits)
Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values, so there is a certain thre...
Definition: IntrinsicInst.h:564
llvm::Instruction::BinaryOps
BinaryOps
Definition: Instruction.h:789
llvm::MemIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:940
llvm::AtomicMemSetInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:878
Instructions.h
llvm::MemCpyInst
This class wraps the llvm.memcpy intrinsic.
Definition: IntrinsicInst.h:988
llvm::MemIntrinsicBase::getRawDestUse
const Use & getRawDestUse() const
Definition: IntrinsicInst.h:692
llvm::Constant::getIntegerValue
static Constant * getIntegerValue(Type *Ty, const APInt &V)
Return the value for an integer or pointer constant, or a vector thereof, with the given scalar value...
Definition: Constants.cpp:388
llvm::MinMaxIntrinsic
This class represents min/max intrinsics.
Definition: IntrinsicInst.h:512
llvm::PseudoProbeInst::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1254
llvm::MemIntrinsic::isVolatile
bool isVolatile() const
Definition: IntrinsicInst.h:935
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:1343
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:1229
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:920
llvm::IntrinsicInst::isAssumeLikeIntrinsic
bool isAssumeLikeIntrinsic() const
Definition: IntrinsicInst.h:87
llvm::MemIntrinsicBase::getRawDest
Value * getRawDest() const
Definition: IntrinsicInst.h:689
llvm::ConstrainedFPCmpIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:497
llvm::MemIntrinsic::setVolatile
void setVolatile(Constant *V)
Definition: IntrinsicInst.h:937
llvm::AtomicMemIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:856
llvm::ValueAsMetadata
Value wrapper in the Metadata hierarchy.
Definition: Metadata.h:344
llvm::BinaryOpIntrinsic::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:623
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:1478
llvm::GCProjectionInst::isTiedToInvoke
bool isTiedToInvoke() const
Return true if this relocate is tied to the invoke statepoint.
Definition: IntrinsicInst.h:1319
llvm::VPIntrinsic::getMaskParam
Value * getMaskParam() const
Definition: IntrinsicInst.cpp:296
llvm::DILabel
Label.
Definition: DebugInfoMetadata.h:3194
llvm::MemTransferBase::getRawSourceUse
const Use & getRawSourceUse() const
Definition: IntrinsicInst.h:761
llvm::AnyMemTransferInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1095
llvm::User::getOperand
Value * getOperand(unsigned i) const
Definition: User.h:169
llvm::InstrProfIncrementInst::getName
GlobalVariable * getName() const
Definition: IntrinsicInst.h:1189
llvm::AtomicMemMoveInst
This class represents the atomic memmove intrinsic i.e.
Definition: IntrinsicInst.h:915
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:1258
llvm::DbgVariableIntrinsic::location_op_iterator::operator--
location_op_iterator & operator--()
Definition: IntrinsicInst.h:189
Value.h
llvm::AnyMemIntrinsic
Definition: IntrinsicInst.h:1031
llvm::MemSetBase::getValueUse
Use & getValueUse()
Definition: IntrinsicInst.h:822
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::MinMaxIntrinsic::getSaturationPoint
APInt getSaturationPoint(unsigned numBits) const
Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values, so there is a certain thre...
Definition: IntrinsicInst.h:582
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:2128
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:1103
llvm::GCProjectionInst::getStatepoint
const GCStatepointInst * getStatepoint() const
The statepoint with which this gc.relocate is associated.
Definition: IntrinsicInst.cpp:594
llvm::MinMaxIntrinsic::getRHS
Value * getRHS() const
Definition: IntrinsicInst.h:530
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:1105
llvm::AnyMemCpyInst::classof
static bool classof(const Value *V)
Definition: IntrinsicInst.h:1115
llvm::MemTransferBase::getSource
Value * getSource() const
This is just like getRawSource, but it strips off any cast instructions that feed it,...
Definition: IntrinsicInst.h:769
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:1142