LLVM 20.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"
29#include "llvm/IR/FPEnv.h"
30#include "llvm/IR/Function.h"
33#include "llvm/IR/Intrinsics.h"
34#include "llvm/IR/Value.h"
37#include <cassert>
38#include <cstdint>
39#include <optional>
40
41namespace llvm {
42
43class Metadata;
44
45/// A wrapper class for inspecting calls to intrinsic functions.
46/// This allows the standard isa/dyncast/cast functionality to work with calls
47/// to intrinsic functions.
48class IntrinsicInst : public CallInst {
49public:
50 IntrinsicInst() = delete;
51 IntrinsicInst(const IntrinsicInst &) = delete;
53
54 /// Return the intrinsic ID of this intrinsic.
57 }
58
59 bool isAssociative() const {
60 switch (getIntrinsicID()) {
61 case Intrinsic::smax:
62 case Intrinsic::smin:
63 case Intrinsic::umax:
64 case Intrinsic::umin:
65 return true;
66 default:
67 return false;
68 }
69 }
70
71 /// Return true if swapping the first two arguments to the intrinsic produces
72 /// the same result.
73 bool isCommutative() const {
74 switch (getIntrinsicID()) {
75 case Intrinsic::maxnum:
76 case Intrinsic::minnum:
77 case Intrinsic::maximum:
78 case Intrinsic::minimum:
79 case Intrinsic::smax:
80 case Intrinsic::smin:
81 case Intrinsic::umax:
82 case Intrinsic::umin:
83 case Intrinsic::sadd_sat:
84 case Intrinsic::uadd_sat:
85 case Intrinsic::sadd_with_overflow:
86 case Intrinsic::uadd_with_overflow:
87 case Intrinsic::smul_with_overflow:
88 case Intrinsic::umul_with_overflow:
89 case Intrinsic::smul_fix:
90 case Intrinsic::umul_fix:
91 case Intrinsic::smul_fix_sat:
92 case Intrinsic::umul_fix_sat:
93 case Intrinsic::fma:
94 case Intrinsic::fmuladd:
95 return true;
96 default:
97 return false;
98 }
99 }
100
101 /// Checks if the intrinsic is an annotation.
103 switch (getIntrinsicID()) {
104 default: break;
105 case Intrinsic::assume:
106 case Intrinsic::sideeffect:
107 case Intrinsic::pseudoprobe:
108 case Intrinsic::dbg_assign:
109 case Intrinsic::dbg_declare:
110 case Intrinsic::dbg_value:
111 case Intrinsic::dbg_label:
112 case Intrinsic::invariant_start:
113 case Intrinsic::invariant_end:
114 case Intrinsic::lifetime_start:
115 case Intrinsic::lifetime_end:
116 case Intrinsic::experimental_noalias_scope_decl:
117 case Intrinsic::objectsize:
118 case Intrinsic::ptr_annotation:
119 case Intrinsic::var_annotation:
120 return true;
121 }
122 return false;
123 }
124
125 /// Check if the intrinsic might lower into a regular function call in the
126 /// course of IR transformations
127 static bool mayLowerToFunctionCall(Intrinsic::ID IID);
128
129 /// Methods for support type inquiry through isa, cast, and dyn_cast:
130 static bool classof(const CallInst *I) {
131 if (const Function *CF = I->getCalledFunction())
132 return CF->isIntrinsic();
133 return false;
134 }
135 static bool classof(const Value *V) {
136 return isa<CallInst>(V) && classof(cast<CallInst>(V));
137 }
138};
139
140/// Check if \p ID corresponds to a lifetime intrinsic.
142 switch (ID) {
143 case Intrinsic::lifetime_start:
144 case Intrinsic::lifetime_end:
145 return true;
146 default:
147 return false;
148 }
149}
150
151/// This is the common base class for lifetime intrinsics.
153public:
154 /// \name Casting methods
155 /// @{
156 static bool classof(const IntrinsicInst *I) {
157 return isLifetimeIntrinsic(I->getIntrinsicID());
158 }
159 static bool classof(const Value *V) {
160 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
161 }
162 /// @}
163};
164
165/// Check if \p ID corresponds to a debug info intrinsic.
167 switch (ID) {
168 case Intrinsic::dbg_declare:
169 case Intrinsic::dbg_value:
170 case Intrinsic::dbg_label:
171 case Intrinsic::dbg_assign:
172 return true;
173 default:
174 return false;
175 }
176}
177
178/// This is the common base class for debug info intrinsics.
180public:
181 /// \name Casting methods
182 /// @{
183 static bool classof(const IntrinsicInst *I) {
184 return isDbgInfoIntrinsic(I->getIntrinsicID());
185 }
186 static bool classof(const Value *V) {
187 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
188 }
189 /// @}
190};
191
192// Iterator for ValueAsMetadata that internally uses direct pointer iteration
193// over either a ValueAsMetadata* or a ValueAsMetadata**, dereferencing to the
194// ValueAsMetadata .
196 : public iterator_facade_base<location_op_iterator,
197 std::bidirectional_iterator_tag, Value *> {
199
200public:
201 location_op_iterator(ValueAsMetadata *SingleIter) : I(SingleIter) {}
202 location_op_iterator(ValueAsMetadata **MultiIter) : I(MultiIter) {}
203
206 I = R.I;
207 return *this;
208 }
209 bool operator==(const location_op_iterator &RHS) const { return I == RHS.I; }
210 const Value *operator*() const {
211 ValueAsMetadata *VAM = isa<ValueAsMetadata *>(I)
212 ? cast<ValueAsMetadata *>(I)
213 : *cast<ValueAsMetadata **>(I);
214 return VAM->getValue();
215 };
217 ValueAsMetadata *VAM = isa<ValueAsMetadata *>(I)
218 ? cast<ValueAsMetadata *>(I)
219 : *cast<ValueAsMetadata **>(I);
220 return VAM->getValue();
221 }
223 if (isa<ValueAsMetadata *>(I))
224 I = cast<ValueAsMetadata *>(I) + 1;
225 else
226 I = cast<ValueAsMetadata **>(I) + 1;
227 return *this;
228 }
230 if (isa<ValueAsMetadata *>(I))
231 I = cast<ValueAsMetadata *>(I) - 1;
232 else
233 I = cast<ValueAsMetadata **>(I) - 1;
234 return *this;
235 }
236};
237
238/// Lightweight class that wraps the location operand metadata of a debug
239/// intrinsic. The raw location may be a ValueAsMetadata, an empty MDTuple,
240/// or a DIArgList.
242 Metadata *RawLocation = nullptr;
243
244public:
246 explicit RawLocationWrapper(Metadata *RawLocation)
247 : RawLocation(RawLocation) {
248 // Allow ValueAsMetadata, empty MDTuple, DIArgList.
249 assert(RawLocation && "unexpected null RawLocation");
250 assert(isa<ValueAsMetadata>(RawLocation) || isa<DIArgList>(RawLocation) ||
251 (isa<MDNode>(RawLocation) &&
252 !cast<MDNode>(RawLocation)->getNumOperands()));
253 }
254 Metadata *getRawLocation() const { return RawLocation; }
255 /// Get the locations corresponding to the variable referenced by the debug
256 /// info intrinsic. Depending on the intrinsic, this could be the
257 /// variable's value or its address.
259 Value *getVariableLocationOp(unsigned OpIdx) const;
260 unsigned getNumVariableLocationOps() const {
261 if (hasArgList())
262 return cast<DIArgList>(getRawLocation())->getArgs().size();
263 return 1;
264 }
265 bool hasArgList() const { return isa<DIArgList>(getRawLocation()); }
267 // Check for "kill" sentinel values.
268 // Non-variadic: empty metadata.
269 if (!hasArgList() && isa<MDNode>(getRawLocation()))
270 return true;
271 // Variadic: empty DIArgList with empty expression.
272 if (getNumVariableLocationOps() == 0 && !Expression->isComplex())
273 return true;
274 // Variadic and non-variadic: Interpret expressions using undef or poison
275 // values as kills.
276 return any_of(location_ops(), [](Value *V) { return isa<UndefValue>(V); });
277 }
278
279 friend bool operator==(const RawLocationWrapper &A,
280 const RawLocationWrapper &B) {
281 return A.RawLocation == B.RawLocation;
282 }
283 friend bool operator!=(const RawLocationWrapper &A,
284 const RawLocationWrapper &B) {
285 return !(A == B);
286 }
287 friend bool operator>(const RawLocationWrapper &A,
288 const RawLocationWrapper &B) {
289 return A.RawLocation > B.RawLocation;
290 }
291 friend bool operator>=(const RawLocationWrapper &A,
292 const RawLocationWrapper &B) {
293 return A.RawLocation >= B.RawLocation;
294 }
295 friend bool operator<(const RawLocationWrapper &A,
296 const RawLocationWrapper &B) {
297 return A.RawLocation < B.RawLocation;
298 }
299 friend bool operator<=(const RawLocationWrapper &A,
300 const RawLocationWrapper &B) {
301 return A.RawLocation <= B.RawLocation;
302 }
303};
304
305/// This is the common base class for debug info intrinsics for variables.
307public:
308 /// Get the locations corresponding to the variable referenced by the debug
309 /// info intrinsic. Depending on the intrinsic, this could be the
310 /// variable's value or its address.
312
313 Value *getVariableLocationOp(unsigned OpIdx) const;
314
315 void replaceVariableLocationOp(Value *OldValue, Value *NewValue,
316 bool AllowEmpty = false);
317 void replaceVariableLocationOp(unsigned OpIdx, Value *NewValue);
318 /// Adding a new location operand will always result in this intrinsic using
319 /// an ArgList, and must always be accompanied by a new expression that uses
320 /// the new operand.
323
325 setArgOperand(1, MetadataAsValue::get(NewVar->getContext(), NewVar));
326 }
327
330 }
331
332 unsigned getNumVariableLocationOps() const {
334 }
335
336 bool hasArgList() const { return getWrappedLocation().hasArgList(); }
337
338 /// Does this describe the address of a local variable. True for dbg.declare,
339 /// but not dbg.value, which describes its value, or dbg.assign, which
340 /// describes a combination of the variable's value and address.
341 bool isAddressOfVariable() const {
342 return getIntrinsicID() == Intrinsic::dbg_declare;
343 }
344
346 // TODO: When/if we remove duplicate values from DIArgLists, we don't need
347 // this set anymore.
348 SmallPtrSet<Value *, 4> RemovedValues;
349 for (Value *OldValue : location_ops()) {
350 if (!RemovedValues.insert(OldValue).second)
351 continue;
352 Value *Poison = PoisonValue::get(OldValue->getType());
354 }
355 }
356
357 bool isKillLocation() const {
359 }
360
362 return cast<DILocalVariable>(getRawVariable());
363 }
364
366 return cast<DIExpression>(getRawExpression());
367 }
368
370 return cast<MetadataAsValue>(getArgOperand(0))->getMetadata();
371 }
372
375 }
376
378 return cast<MetadataAsValue>(getArgOperand(1))->getMetadata();
379 }
380
382 return cast<MetadataAsValue>(getArgOperand(2))->getMetadata();
383 }
384
385 /// Use of this should generally be avoided; instead,
386 /// replaceVariableLocationOp and addVariableLocationOps should be used where
387 /// possible to avoid creating invalid state.
388 void setRawLocation(Metadata *Location) {
389 return setArgOperand(0, MetadataAsValue::get(getContext(), Location));
390 }
391
392 /// Get the size (in bits) of the variable, or fragment of the variable that
393 /// is described.
394 std::optional<uint64_t> getFragmentSizeInBits() const;
395
396 /// Get the FragmentInfo for the variable.
397 std::optional<DIExpression::FragmentInfo> getFragment() const {
398 return getExpression()->getFragmentInfo();
399 }
400
401 /// Get the FragmentInfo for the variable if it exists, otherwise return a
402 /// FragmentInfo that covers the entire variable if the variable size is
403 /// known, otherwise return a zero-sized fragment.
405 DIExpression::FragmentInfo VariableSlice(0, 0);
406 // Get the fragment or variable size, or zero.
407 if (auto Sz = getFragmentSizeInBits())
408 VariableSlice.SizeInBits = *Sz;
409 if (auto Frag = getExpression()->getFragmentInfo())
410 VariableSlice.OffsetInBits = Frag->OffsetInBits;
411 return VariableSlice;
412 }
413
414 /// \name Casting methods
415 /// @{
416 static bool classof(const IntrinsicInst *I) {
417 switch (I->getIntrinsicID()) {
418 case Intrinsic::dbg_declare:
419 case Intrinsic::dbg_value:
420 case Intrinsic::dbg_assign:
421 return true;
422 default:
423 return false;
424 }
425 }
426 static bool classof(const Value *V) {
427 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
428 }
429 /// @}
430protected:
431 void setArgOperand(unsigned i, Value *v) {
433 }
434 void setOperand(unsigned i, Value *v) { DbgInfoIntrinsic::setOperand(i, v); }
435};
436
437/// This represents the llvm.dbg.declare instruction.
439public:
440 Value *getAddress() const {
442 "dbg.declare must have exactly 1 location operand.");
443 return getVariableLocationOp(0);
444 }
445
446 /// \name Casting methods
447 /// @{
448 static bool classof(const IntrinsicInst *I) {
449 return I->getIntrinsicID() == Intrinsic::dbg_declare;
450 }
451 static bool classof(const Value *V) {
452 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
453 }
454 /// @}
455};
456
457/// This represents the llvm.dbg.value instruction.
459public:
460 // The default argument should only be used in ISel, and the default option
461 // should be removed once ISel support for multiple location ops is complete.
462 Value *getValue(unsigned OpIdx = 0) const {
463 return getVariableLocationOp(OpIdx);
464 }
466 return location_ops();
467 }
468
469 /// \name Casting methods
470 /// @{
471 static bool classof(const IntrinsicInst *I) {
472 return I->getIntrinsicID() == Intrinsic::dbg_value ||
473 I->getIntrinsicID() == Intrinsic::dbg_assign;
474 }
475 static bool classof(const Value *V) {
476 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
477 }
478 /// @}
479};
480
481/// This represents the llvm.dbg.assign instruction.
483 enum Operands {
484 OpValue,
485 OpVar,
486 OpExpr,
487 OpAssignID,
488 OpAddress,
489 OpAddressExpr,
490 };
491
492public:
493 Value *getAddress() const;
495 return cast<MetadataAsValue>(getArgOperand(OpAddress))->getMetadata();
496 }
498 return cast<MetadataAsValue>(getArgOperand(OpAssignID))->getMetadata();
499 }
500 DIAssignID *getAssignID() const { return cast<DIAssignID>(getRawAssignID()); }
502 return cast<MetadataAsValue>(getArgOperand(OpAddressExpr))->getMetadata();
503 }
505 return cast<DIExpression>(getRawAddressExpression());
506 }
508 setArgOperand(OpAddressExpr,
509 MetadataAsValue::get(NewExpr->getContext(), NewExpr));
510 }
511 void setAssignId(DIAssignID *New);
512 void setAddress(Value *V);
513 /// Kill the address component.
514 void setKillAddress();
515 /// Check whether this kills the address component. This doesn't take into
516 /// account the position of the intrinsic, therefore a returned value of false
517 /// does not guarentee the address is a valid location for the variable at the
518 /// intrinsic's position in IR.
519 bool isKillAddress() const;
520 void setValue(Value *V);
521 /// \name Casting methods
522 /// @{
523 static bool classof(const IntrinsicInst *I) {
524 return I->getIntrinsicID() == Intrinsic::dbg_assign;
525 }
526 static bool classof(const Value *V) {
527 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
528 }
529 /// @}
530};
531
532/// This represents the llvm.dbg.label instruction.
534public:
535 DILabel *getLabel() const { return cast<DILabel>(getRawLabel()); }
536 void setLabel(DILabel *NewLabel) {
538 }
539
541 return cast<MetadataAsValue>(getArgOperand(0))->getMetadata();
542 }
543
544 /// Methods for support type inquiry through isa, cast, and dyn_cast:
545 /// @{
546 static bool classof(const IntrinsicInst *I) {
547 return I->getIntrinsicID() == Intrinsic::dbg_label;
548 }
549 static bool classof(const Value *V) {
550 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
551 }
552 /// @}
553};
554
555/// This is the common base class for vector predication intrinsics.
557public:
558 /// \brief Declares a llvm.vp.* intrinsic in \p M that matches the parameters
559 /// \p Params. Additionally, the load and gather intrinsics require
560 /// \p ReturnType to be specified.
562 Type *ReturnType,
563 ArrayRef<Value *> Params);
564
565 static std::optional<unsigned> getMaskParamPos(Intrinsic::ID IntrinsicID);
566 static std::optional<unsigned> getVectorLengthParamPos(
567 Intrinsic::ID IntrinsicID);
568
569 /// The llvm.vp.* intrinsics for this instruction Opcode
570 static Intrinsic::ID getForOpcode(unsigned OC);
571
572 /// The llvm.vp.* intrinsics for this intrinsic ID \p Id. Return \p Id if it
573 /// is already a VP intrinsic.
575
576 // Whether \p ID is a VP intrinsic ID.
577 static bool isVPIntrinsic(Intrinsic::ID);
578
579 /// \return The mask parameter or nullptr.
580 Value *getMaskParam() const;
581 void setMaskParam(Value *);
582
583 /// \return The vector length parameter or nullptr.
586
587 /// \return Whether the vector length param can be ignored.
588 bool canIgnoreVectorLengthParam() const;
589
590 /// \return The static element count (vector number of elements) the vector
591 /// length parameter applies to.
593
594 /// \return The alignment of the pointer used by this load/store/gather or
595 /// scatter.
597 // MaybeAlign setPointerAlignment(Align NewAlign); // TODO
598
599 /// \return The pointer operand of this load,store, gather or scatter.
601 static std::optional<unsigned> getMemoryPointerParamPos(Intrinsic::ID);
602
603 /// \return The data (payload) operand of this store or scatter.
604 Value *getMemoryDataParam() const;
605 static std::optional<unsigned> getMemoryDataParamPos(Intrinsic::ID);
606
607 // Methods for support type inquiry through isa, cast, and dyn_cast:
608 static bool classof(const IntrinsicInst *I) {
609 return isVPIntrinsic(I->getIntrinsicID());
610 }
611 static bool classof(const Value *V) {
612 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
613 }
614
615 // Equivalent non-predicated opcode
616 std::optional<unsigned> getFunctionalOpcode() const {
618 }
619
620 // Equivalent non-predicated intrinsic ID
621 std::optional<unsigned> getFunctionalIntrinsicID() const {
623 }
624
625 // Equivalent non-predicated constrained ID
626 std::optional<unsigned> getConstrainedIntrinsicID() const {
628 }
629
630 // Equivalent non-predicated opcode
631 static std::optional<unsigned> getFunctionalOpcodeForVP(Intrinsic::ID ID);
632
633 // Equivalent non-predicated intrinsic ID
634 static std::optional<Intrinsic::ID>
636
637 // Equivalent non-predicated constrained ID
638 static std::optional<Intrinsic::ID>
640};
641
642/// This represents vector predication reduction intrinsics.
644public:
645 static bool isVPReduction(Intrinsic::ID ID);
646
647 unsigned getStartParamPos() const;
648 unsigned getVectorParamPos() const;
649
650 static std::optional<unsigned> getStartParamPos(Intrinsic::ID ID);
651 static std::optional<unsigned> getVectorParamPos(Intrinsic::ID ID);
652
653 /// Methods for support type inquiry through isa, cast, and dyn_cast:
654 /// @{
655 static bool classof(const IntrinsicInst *I) {
656 return VPReductionIntrinsic::isVPReduction(I->getIntrinsicID());
657 }
658 static bool classof(const Value *V) {
659 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
660 }
661 /// @}
662};
663
665public:
666 static bool isVPCast(Intrinsic::ID ID);
667
668 /// Methods for support type inquiry through isa, cast, and dyn_cast:
669 /// @{
670 static bool classof(const IntrinsicInst *I) {
671 return VPCastIntrinsic::isVPCast(I->getIntrinsicID());
672 }
673 static bool classof(const Value *V) {
674 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
675 }
676 /// @}
677};
678
680public:
681 static bool isVPCmp(Intrinsic::ID ID);
682
684
685 /// Methods for support type inquiry through isa, cast, and dyn_cast:
686 /// @{
687 static bool classof(const IntrinsicInst *I) {
688 return VPCmpIntrinsic::isVPCmp(I->getIntrinsicID());
689 }
690 static bool classof(const Value *V) {
691 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
692 }
693 /// @}
694};
695
697public:
698 static bool isVPBinOp(Intrinsic::ID ID);
699
700 /// Methods for support type inquiry through isa, cast, and dyn_cast:
701 /// @{
702 static bool classof(const IntrinsicInst *I) {
703 return VPBinOpIntrinsic::isVPBinOp(I->getIntrinsicID());
704 }
705 static bool classof(const Value *V) {
706 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
707 }
708 /// @}
709};
710
711
712/// This is the common base class for constrained floating point intrinsics.
714public:
715 unsigned getNonMetadataArgCount() const;
716 std::optional<RoundingMode> getRoundingMode() const;
717 std::optional<fp::ExceptionBehavior> getExceptionBehavior() const;
718 bool isDefaultFPEnvironment() const;
719
720 // Methods for support type inquiry through isa, cast, and dyn_cast:
721 static bool classof(const IntrinsicInst *I);
722 static bool classof(const Value *V) {
723 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
724 }
725};
726
727/// Constrained floating point compare intrinsics.
729public:
731 bool isSignaling() const {
732 return getIntrinsicID() == Intrinsic::experimental_constrained_fcmps;
733 }
734
735 // Methods for support type inquiry through isa, cast, and dyn_cast:
736 static bool classof(const IntrinsicInst *I) {
737 switch (I->getIntrinsicID()) {
738 case Intrinsic::experimental_constrained_fcmp:
739 case Intrinsic::experimental_constrained_fcmps:
740 return true;
741 default:
742 return false;
743 }
744 }
745 static bool classof(const Value *V) {
746 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
747 }
748};
749
750/// This class represents min/max intrinsics.
752public:
753 static bool classof(const IntrinsicInst *I) {
754 switch (I->getIntrinsicID()) {
755 case Intrinsic::umin:
756 case Intrinsic::umax:
757 case Intrinsic::smin:
758 case Intrinsic::smax:
759 return true;
760 default:
761 return false;
762 }
763 }
764 static bool classof(const Value *V) {
765 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
766 }
767
768 Value *getLHS() const { return const_cast<Value *>(getArgOperand(0)); }
769 Value *getRHS() const { return const_cast<Value *>(getArgOperand(1)); }
770
771 /// Returns the comparison predicate underlying the intrinsic.
773 switch (ID) {
774 case Intrinsic::umin:
776 case Intrinsic::umax:
778 case Intrinsic::smin:
780 case Intrinsic::smax:
782 default:
783 llvm_unreachable("Invalid intrinsic");
784 }
785 }
786
787 /// Returns the comparison predicate underlying the intrinsic.
790 }
791
792 /// Whether the intrinsic is signed or unsigned.
793 static bool isSigned(Intrinsic::ID ID) {
795 };
796
797 /// Whether the intrinsic is signed or unsigned.
798 bool isSigned() const { return isSigned(getIntrinsicID()); };
799
800 /// Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values,
801 /// so there is a certain threshold value, upon reaching which,
802 /// their value can no longer change. Return said threshold.
803 static APInt getSaturationPoint(Intrinsic::ID ID, unsigned numBits) {
804 switch (ID) {
805 case Intrinsic::umin:
806 return APInt::getMinValue(numBits);
807 case Intrinsic::umax:
808 return APInt::getMaxValue(numBits);
809 case Intrinsic::smin:
810 return APInt::getSignedMinValue(numBits);
811 case Intrinsic::smax:
812 return APInt::getSignedMaxValue(numBits);
813 default:
814 llvm_unreachable("Invalid intrinsic");
815 }
816 }
817
818 /// Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values,
819 /// so there is a certain threshold value, upon reaching which,
820 /// their value can no longer change. Return said threshold.
821 APInt getSaturationPoint(unsigned numBits) const {
822 return getSaturationPoint(getIntrinsicID(), numBits);
823 }
824
825 /// Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values,
826 /// so there is a certain threshold value, upon reaching which,
827 /// their value can no longer change. Return said threshold.
831 }
832
833 /// Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values,
834 /// so there is a certain threshold value, upon reaching which,
835 /// their value can no longer change. Return said threshold.
838 }
839};
840
841/// This class represents a ucmp/scmp intrinsic
843public:
844 static bool classof(const IntrinsicInst *I) {
845 switch (I->getIntrinsicID()) {
846 case Intrinsic::scmp:
847 case Intrinsic::ucmp:
848 return true;
849 default:
850 return false;
851 }
852 }
853 static bool classof(const Value *V) {
854 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
855 }
856
857 Value *getLHS() const { return const_cast<Value *>(getArgOperand(0)); }
858 Value *getRHS() const { return const_cast<Value *>(getArgOperand(1)); }
859
860 static bool isSigned(Intrinsic::ID ID) { return ID == Intrinsic::scmp; }
861 bool isSigned() const { return isSigned(getIntrinsicID()); }
862
865 }
868 }
869
872 }
875 }
876};
877
878/// This class represents an intrinsic that is based on a binary operation.
879/// This includes op.with.overflow and saturating add/sub intrinsics.
881public:
882 static bool classof(const IntrinsicInst *I) {
883 switch (I->getIntrinsicID()) {
884 case Intrinsic::uadd_with_overflow:
885 case Intrinsic::sadd_with_overflow:
886 case Intrinsic::usub_with_overflow:
887 case Intrinsic::ssub_with_overflow:
888 case Intrinsic::umul_with_overflow:
889 case Intrinsic::smul_with_overflow:
890 case Intrinsic::uadd_sat:
891 case Intrinsic::sadd_sat:
892 case Intrinsic::usub_sat:
893 case Intrinsic::ssub_sat:
894 return true;
895 default:
896 return false;
897 }
898 }
899 static bool classof(const Value *V) {
900 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
901 }
902
903 Value *getLHS() const { return const_cast<Value *>(getArgOperand(0)); }
904 Value *getRHS() const { return const_cast<Value *>(getArgOperand(1)); }
905
906 /// Returns the binary operation underlying the intrinsic.
908
909 /// Whether the intrinsic is signed or unsigned.
910 bool isSigned() const;
911
912 /// Returns one of OBO::NoSignedWrap or OBO::NoUnsignedWrap.
913 unsigned getNoWrapKind() const;
914};
915
916/// Represents an op.with.overflow intrinsic.
918public:
919 static bool classof(const IntrinsicInst *I) {
920 switch (I->getIntrinsicID()) {
921 case Intrinsic::uadd_with_overflow:
922 case Intrinsic::sadd_with_overflow:
923 case Intrinsic::usub_with_overflow:
924 case Intrinsic::ssub_with_overflow:
925 case Intrinsic::umul_with_overflow:
926 case Intrinsic::smul_with_overflow:
927 return true;
928 default:
929 return false;
930 }
931 }
932 static bool classof(const Value *V) {
933 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
934 }
935};
936
937/// Represents a saturating add/sub intrinsic.
939public:
940 static bool classof(const IntrinsicInst *I) {
941 switch (I->getIntrinsicID()) {
942 case Intrinsic::uadd_sat:
943 case Intrinsic::sadd_sat:
944 case Intrinsic::usub_sat:
945 case Intrinsic::ssub_sat:
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/// Common base class for all memory intrinsics. Simply provides
957/// common methods.
958/// Written as CRTP to avoid a common base class amongst the
959/// three atomicity hierarchies.
960template <typename Derived> class MemIntrinsicBase : public IntrinsicInst {
961private:
962 enum { ARG_DEST = 0, ARG_LENGTH = 2 };
963
964public:
965 Value *getRawDest() const {
966 return const_cast<Value *>(getArgOperand(ARG_DEST));
967 }
968 const Use &getRawDestUse() const { return getArgOperandUse(ARG_DEST); }
969 Use &getRawDestUse() { return getArgOperandUse(ARG_DEST); }
970
971 Value *getLength() const {
972 return const_cast<Value *>(getArgOperand(ARG_LENGTH));
973 }
974 const Use &getLengthUse() const { return getArgOperandUse(ARG_LENGTH); }
975 Use &getLengthUse() { return getArgOperandUse(ARG_LENGTH); }
976
977 /// This is just like getRawDest, but it strips off any cast
978 /// instructions (including addrspacecast) that feed it, giving the
979 /// original input. The returned value is guaranteed to be a pointer.
980 Value *getDest() const { return getRawDest()->stripPointerCasts(); }
981
982 unsigned getDestAddressSpace() const {
983 return cast<PointerType>(getRawDest()->getType())->getAddressSpace();
984 }
985
986 /// FIXME: Remove this function once transition to Align is over.
987 /// Use getDestAlign() instead.
988 LLVM_DEPRECATED("Use getDestAlign() instead", "getDestAlign")
990 if (auto MA = getParamAlign(ARG_DEST))
991 return MA->value();
992 return 0;
993 }
994 MaybeAlign getDestAlign() const { return getParamAlign(ARG_DEST); }
995
996 /// Set the specified arguments of the instruction.
998 assert(getRawDest()->getType() == Ptr->getType() &&
999 "setDest called with pointer of wrong type!");
1000 setArgOperand(ARG_DEST, Ptr);
1001 }
1002
1004 removeParamAttr(ARG_DEST, Attribute::Alignment);
1005 if (Alignment)
1006 addParamAttr(ARG_DEST,
1008 }
1009 void setDestAlignment(Align Alignment) {
1010 removeParamAttr(ARG_DEST, Attribute::Alignment);
1011 addParamAttr(ARG_DEST,
1013 }
1014
1015 void setLength(Value *L) {
1016 assert(getLength()->getType() == L->getType() &&
1017 "setLength called with value of wrong type!");
1018 setArgOperand(ARG_LENGTH, L);
1019 }
1020};
1021
1022/// Common base class for all memory transfer intrinsics. Simply provides
1023/// common methods.
1024template <class BaseCL> class MemTransferBase : public BaseCL {
1025private:
1026 enum { ARG_SOURCE = 1 };
1027
1028public:
1029 /// Return the arguments to the instruction.
1031 return const_cast<Value *>(BaseCL::getArgOperand(ARG_SOURCE));
1032 }
1033 const Use &getRawSourceUse() const {
1034 return BaseCL::getArgOperandUse(ARG_SOURCE);
1035 }
1036 Use &getRawSourceUse() { return BaseCL::getArgOperandUse(ARG_SOURCE); }
1037
1038 /// This is just like getRawSource, but it strips off any cast
1039 /// instructions that feed it, giving the original input. The returned
1040 /// value is guaranteed to be a pointer.
1042
1043 unsigned getSourceAddressSpace() const {
1044 return cast<PointerType>(getRawSource()->getType())->getAddressSpace();
1045 }
1046
1047 /// FIXME: Remove this function once transition to Align is over.
1048 /// Use getSourceAlign() instead.
1049 LLVM_DEPRECATED("Use getSourceAlign() instead", "getSourceAlign")
1051 if (auto MA = BaseCL::getParamAlign(ARG_SOURCE))
1052 return MA->value();
1053 return 0;
1054 }
1055
1057 return BaseCL::getParamAlign(ARG_SOURCE);
1058 }
1059
1061 assert(getRawSource()->getType() == Ptr->getType() &&
1062 "setSource called with pointer of wrong type!");
1063 BaseCL::setArgOperand(ARG_SOURCE, Ptr);
1064 }
1065
1067 BaseCL::removeParamAttr(ARG_SOURCE, Attribute::Alignment);
1068 if (Alignment)
1069 BaseCL::addParamAttr(ARG_SOURCE, Attribute::getWithAlignment(
1070 BaseCL::getContext(), *Alignment));
1071 }
1072
1073 void setSourceAlignment(Align Alignment) {
1074 BaseCL::removeParamAttr(ARG_SOURCE, Attribute::Alignment);
1075 BaseCL::addParamAttr(ARG_SOURCE, Attribute::getWithAlignment(
1076 BaseCL::getContext(), Alignment));
1077 }
1078};
1079
1080/// Common base class for all memset intrinsics. Simply provides
1081/// common methods.
1082template <class BaseCL> class MemSetBase : public BaseCL {
1083private:
1084 enum { ARG_VALUE = 1 };
1085
1086public:
1087 Value *getValue() const {
1088 return const_cast<Value *>(BaseCL::getArgOperand(ARG_VALUE));
1089 }
1090 const Use &getValueUse() const { return BaseCL::getArgOperandUse(ARG_VALUE); }
1091 Use &getValueUse() { return BaseCL::getArgOperandUse(ARG_VALUE); }
1092
1093 void setValue(Value *Val) {
1094 assert(getValue()->getType() == Val->getType() &&
1095 "setValue called with value of wrong type!");
1096 BaseCL::setArgOperand(ARG_VALUE, Val);
1097 }
1098};
1099
1100// The common base class for the atomic memset/memmove/memcpy intrinsics
1101// i.e. llvm.element.unordered.atomic.memset/memcpy/memmove
1102class AtomicMemIntrinsic : public MemIntrinsicBase<AtomicMemIntrinsic> {
1103private:
1104 enum { ARG_ELEMENTSIZE = 3 };
1105
1106public:
1108 return const_cast<Value *>(getArgOperand(ARG_ELEMENTSIZE));
1109 }
1110
1112 return cast<ConstantInt>(getRawElementSizeInBytes());
1113 }
1114
1117 }
1118
1120 assert(V->getType() == Type::getInt8Ty(getContext()) &&
1121 "setElementSizeInBytes called with value of wrong type!");
1122 setArgOperand(ARG_ELEMENTSIZE, V);
1123 }
1124
1125 static bool classof(const IntrinsicInst *I) {
1126 switch (I->getIntrinsicID()) {
1127 case Intrinsic::memcpy_element_unordered_atomic:
1128 case Intrinsic::memmove_element_unordered_atomic:
1129 case Intrinsic::memset_element_unordered_atomic:
1130 return true;
1131 default:
1132 return false;
1133 }
1134 }
1135 static bool classof(const Value *V) {
1136 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1137 }
1138};
1139
1140/// This class represents atomic memset intrinsic
1141// i.e. llvm.element.unordered.atomic.memset
1142class AtomicMemSetInst : public MemSetBase<AtomicMemIntrinsic> {
1143public:
1144 static bool classof(const IntrinsicInst *I) {
1145 return I->getIntrinsicID() == Intrinsic::memset_element_unordered_atomic;
1146 }
1147 static bool classof(const Value *V) {
1148 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1149 }
1150};
1151
1152// This class wraps the atomic memcpy/memmove intrinsics
1153// i.e. llvm.element.unordered.atomic.memcpy/memmove
1154class AtomicMemTransferInst : public MemTransferBase<AtomicMemIntrinsic> {
1155public:
1156 static bool classof(const IntrinsicInst *I) {
1157 switch (I->getIntrinsicID()) {
1158 case Intrinsic::memcpy_element_unordered_atomic:
1159 case Intrinsic::memmove_element_unordered_atomic:
1160 return true;
1161 default:
1162 return false;
1163 }
1164 }
1165 static bool classof(const Value *V) {
1166 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1167 }
1168};
1169
1170/// This class represents the atomic memcpy intrinsic
1171/// i.e. llvm.element.unordered.atomic.memcpy
1173public:
1174 static bool classof(const IntrinsicInst *I) {
1175 return I->getIntrinsicID() == Intrinsic::memcpy_element_unordered_atomic;
1176 }
1177 static bool classof(const Value *V) {
1178 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1179 }
1180};
1181
1182/// This class represents the atomic memmove intrinsic
1183/// i.e. llvm.element.unordered.atomic.memmove
1185public:
1186 static bool classof(const IntrinsicInst *I) {
1187 return I->getIntrinsicID() == Intrinsic::memmove_element_unordered_atomic;
1188 }
1189 static bool classof(const Value *V) {
1190 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1191 }
1192};
1193
1194/// This is the common base class for memset/memcpy/memmove.
1195class MemIntrinsic : public MemIntrinsicBase<MemIntrinsic> {
1196private:
1197 enum { ARG_VOLATILE = 3 };
1198
1199public:
1201 return cast<ConstantInt>(const_cast<Value *>(getArgOperand(ARG_VOLATILE)));
1202 }
1203
1204 bool isVolatile() const { return !getVolatileCst()->isZero(); }
1205
1206 void setVolatile(Constant *V) { setArgOperand(ARG_VOLATILE, V); }
1207
1208 // Methods for support type inquiry through isa, cast, and dyn_cast:
1209 static bool classof(const IntrinsicInst *I) {
1210 switch (I->getIntrinsicID()) {
1211 case Intrinsic::memcpy:
1212 case Intrinsic::memmove:
1213 case Intrinsic::memset:
1214 case Intrinsic::memset_inline:
1215 case Intrinsic::memcpy_inline:
1216 return true;
1217 default:
1218 return false;
1219 }
1220 }
1221 static bool classof(const Value *V) {
1222 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1223 }
1224};
1225
1226/// This class wraps the llvm.memset and llvm.memset.inline intrinsics.
1227class MemSetInst : public MemSetBase<MemIntrinsic> {
1228public:
1229 // Methods for support type inquiry through isa, cast, and dyn_cast:
1230 static bool classof(const IntrinsicInst *I) {
1231 switch (I->getIntrinsicID()) {
1232 case Intrinsic::memset:
1233 case Intrinsic::memset_inline:
1234 return true;
1235 default:
1236 return false;
1237 }
1238 }
1239 static bool classof(const Value *V) {
1240 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1241 }
1242};
1243
1244/// This class wraps the llvm.memset.inline intrinsic.
1246public:
1247 // Methods for support type inquiry through isa, cast, and dyn_cast:
1248 static bool classof(const IntrinsicInst *I) {
1249 return I->getIntrinsicID() == Intrinsic::memset_inline;
1250 }
1251 static bool classof(const Value *V) {
1252 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1253 }
1254};
1255
1256/// This class wraps the llvm.memcpy/memmove intrinsics.
1257class MemTransferInst : public MemTransferBase<MemIntrinsic> {
1258public:
1259 // Methods for support type inquiry through isa, cast, and dyn_cast:
1260 static bool classof(const IntrinsicInst *I) {
1261 switch (I->getIntrinsicID()) {
1262 case Intrinsic::memcpy:
1263 case Intrinsic::memmove:
1264 case Intrinsic::memcpy_inline:
1265 return true;
1266 default:
1267 return false;
1268 }
1269 }
1270 static bool classof(const Value *V) {
1271 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1272 }
1273};
1274
1275/// This class wraps the llvm.memcpy intrinsic.
1277public:
1278 // Methods for support type inquiry through isa, cast, and dyn_cast:
1279 static bool classof(const IntrinsicInst *I) {
1280 return I->getIntrinsicID() == Intrinsic::memcpy ||
1281 I->getIntrinsicID() == Intrinsic::memcpy_inline;
1282 }
1283 static bool classof(const Value *V) {
1284 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1285 }
1286};
1287
1288/// This class wraps the llvm.memmove intrinsic.
1290public:
1291 // Methods for support type inquiry through isa, cast, and dyn_cast:
1292 static bool classof(const IntrinsicInst *I) {
1293 return I->getIntrinsicID() == Intrinsic::memmove;
1294 }
1295 static bool classof(const Value *V) {
1296 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1297 }
1298};
1299
1300/// This class wraps the llvm.memcpy.inline intrinsic.
1302public:
1303 // Methods for support type inquiry through isa, cast, and dyn_cast:
1304 static bool classof(const IntrinsicInst *I) {
1305 return I->getIntrinsicID() == Intrinsic::memcpy_inline;
1306 }
1307 static bool classof(const Value *V) {
1308 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1309 }
1310};
1311
1312// The common base class for any memset/memmove/memcpy intrinsics;
1313// whether they be atomic or non-atomic.
1314// i.e. llvm.element.unordered.atomic.memset/memcpy/memmove
1315// and llvm.memset/memcpy/memmove
1316class AnyMemIntrinsic : public MemIntrinsicBase<AnyMemIntrinsic> {
1317public:
1318 bool isVolatile() const {
1319 // Only the non-atomic intrinsics can be volatile
1320 if (auto *MI = dyn_cast<MemIntrinsic>(this))
1321 return MI->isVolatile();
1322 return false;
1323 }
1324
1325 static bool classof(const IntrinsicInst *I) {
1326 switch (I->getIntrinsicID()) {
1327 case Intrinsic::memcpy:
1328 case Intrinsic::memcpy_inline:
1329 case Intrinsic::memmove:
1330 case Intrinsic::memset:
1331 case Intrinsic::memset_inline:
1332 case Intrinsic::memcpy_element_unordered_atomic:
1333 case Intrinsic::memmove_element_unordered_atomic:
1334 case Intrinsic::memset_element_unordered_atomic:
1335 return true;
1336 default:
1337 return false;
1338 }
1339 }
1340 static bool classof(const Value *V) {
1341 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1342 }
1343};
1344
1345/// This class represents any memset intrinsic
1346// i.e. llvm.element.unordered.atomic.memset
1347// and llvm.memset
1348class AnyMemSetInst : public MemSetBase<AnyMemIntrinsic> {
1349public:
1350 static bool classof(const IntrinsicInst *I) {
1351 switch (I->getIntrinsicID()) {
1352 case Intrinsic::memset:
1353 case Intrinsic::memset_inline:
1354 case Intrinsic::memset_element_unordered_atomic:
1355 return true;
1356 default:
1357 return false;
1358 }
1359 }
1360 static bool classof(const Value *V) {
1361 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1362 }
1363};
1364
1365// This class wraps any memcpy/memmove intrinsics
1366// i.e. llvm.element.unordered.atomic.memcpy/memmove
1367// and llvm.memcpy/memmove
1368class AnyMemTransferInst : public MemTransferBase<AnyMemIntrinsic> {
1369public:
1370 static bool classof(const IntrinsicInst *I) {
1371 switch (I->getIntrinsicID()) {
1372 case Intrinsic::memcpy:
1373 case Intrinsic::memcpy_inline:
1374 case Intrinsic::memmove:
1375 case Intrinsic::memcpy_element_unordered_atomic:
1376 case Intrinsic::memmove_element_unordered_atomic:
1377 return true;
1378 default:
1379 return false;
1380 }
1381 }
1382 static bool classof(const Value *V) {
1383 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1384 }
1385};
1386
1387/// This class represents any memcpy intrinsic
1388/// i.e. llvm.element.unordered.atomic.memcpy
1389/// and llvm.memcpy
1391public:
1392 static bool classof(const IntrinsicInst *I) {
1393 switch (I->getIntrinsicID()) {
1394 case Intrinsic::memcpy:
1395 case Intrinsic::memcpy_inline:
1396 case Intrinsic::memcpy_element_unordered_atomic:
1397 return true;
1398 default:
1399 return false;
1400 }
1401 }
1402 static bool classof(const Value *V) {
1403 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1404 }
1405};
1406
1407/// This class represents any memmove intrinsic
1408/// i.e. llvm.element.unordered.atomic.memmove
1409/// and llvm.memmove
1411public:
1412 static bool classof(const IntrinsicInst *I) {
1413 switch (I->getIntrinsicID()) {
1414 case Intrinsic::memmove:
1415 case Intrinsic::memmove_element_unordered_atomic:
1416 return true;
1417 default:
1418 return false;
1419 }
1420 }
1421 static bool classof(const Value *V) {
1422 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1423 }
1424};
1425
1426/// This represents the llvm.va_start intrinsic.
1428public:
1429 static bool classof(const IntrinsicInst *I) {
1430 return I->getIntrinsicID() == Intrinsic::vastart;
1431 }
1432 static bool classof(const Value *V) {
1433 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1434 }
1435
1436 Value *getArgList() const { return const_cast<Value *>(getArgOperand(0)); }
1437};
1438
1439/// This represents the llvm.va_end intrinsic.
1440class VAEndInst : public IntrinsicInst {
1441public:
1442 static bool classof(const IntrinsicInst *I) {
1443 return I->getIntrinsicID() == Intrinsic::vaend;
1444 }
1445 static bool classof(const Value *V) {
1446 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1447 }
1448
1449 Value *getArgList() const { return const_cast<Value *>(getArgOperand(0)); }
1450};
1451
1452/// This represents the llvm.va_copy intrinsic.
1454public:
1455 static bool classof(const IntrinsicInst *I) {
1456 return I->getIntrinsicID() == Intrinsic::vacopy;
1457 }
1458 static bool classof(const Value *V) {
1459 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1460 }
1461
1462 Value *getDest() const { return const_cast<Value *>(getArgOperand(0)); }
1463 Value *getSrc() const { return const_cast<Value *>(getArgOperand(1)); }
1464};
1465
1466/// A base class for all instrprof intrinsics.
1468protected:
1469 static bool isCounterBase(const IntrinsicInst &I) {
1470 switch (I.getIntrinsicID()) {
1471 case Intrinsic::instrprof_cover:
1472 case Intrinsic::instrprof_increment:
1473 case Intrinsic::instrprof_increment_step:
1474 case Intrinsic::instrprof_callsite:
1475 case Intrinsic::instrprof_timestamp:
1476 case Intrinsic::instrprof_value_profile:
1477 return true;
1478 }
1479 return false;
1480 }
1481 static bool isMCDCBitmapBase(const IntrinsicInst &I) {
1482 switch (I.getIntrinsicID()) {
1483 case Intrinsic::instrprof_mcdc_parameters:
1484 case Intrinsic::instrprof_mcdc_tvbitmap_update:
1485 return true;
1486 }
1487 return false;
1488 }
1489
1490public:
1491 static bool classof(const Value *V) {
1492 if (const auto *Instr = dyn_cast<IntrinsicInst>(V))
1493 return isCounterBase(*Instr) || isMCDCBitmapBase(*Instr);
1494 return false;
1495 }
1496 // The name of the instrumented function.
1498 return cast<GlobalVariable>(
1499 const_cast<Value *>(getArgOperand(0))->stripPointerCasts());
1500 }
1501 // The hash of the CFG for the instrumented function.
1503 return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
1504 }
1505};
1506
1507/// A base class for all instrprof counter intrinsics.
1509public:
1510 static bool classof(const Value *V) {
1511 if (const auto *Instr = dyn_cast<IntrinsicInst>(V))
1512 return InstrProfInstBase::isCounterBase(*Instr);
1513 return false;
1514 }
1515
1516 // The number of counters for the instrumented function.
1517 ConstantInt *getNumCounters() const;
1518 // The index of the counter that this instruction acts on.
1519 ConstantInt *getIndex() const;
1520};
1521
1522/// This represents the llvm.instrprof.cover intrinsic.
1524public:
1525 static bool classof(const IntrinsicInst *I) {
1526 return I->getIntrinsicID() == Intrinsic::instrprof_cover;
1527 }
1528 static bool classof(const Value *V) {
1529 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1530 }
1531};
1532
1533/// This represents the llvm.instrprof.increment intrinsic.
1535public:
1536 static bool classof(const IntrinsicInst *I) {
1537 return I->getIntrinsicID() == Intrinsic::instrprof_increment ||
1538 I->getIntrinsicID() == Intrinsic::instrprof_increment_step;
1539 }
1540 static bool classof(const Value *V) {
1541 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1542 }
1543 Value *getStep() const;
1544};
1545
1546/// This represents the llvm.instrprof.increment.step intrinsic.
1548public:
1549 static bool classof(const IntrinsicInst *I) {
1550 return I->getIntrinsicID() == Intrinsic::instrprof_increment_step;
1551 }
1552 static bool classof(const Value *V) {
1553 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1554 }
1555};
1556
1557/// This represents the llvm.instrprof.callsite intrinsic.
1558/// It is structurally like the increment or step counters, hence the
1559/// inheritance relationship, albeit somewhat tenuous (it's not 'counting' per
1560/// se)
1562public:
1563 static bool classof(const IntrinsicInst *I) {
1564 return I->getIntrinsicID() == Intrinsic::instrprof_callsite;
1565 }
1566 static bool classof(const Value *V) {
1567 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1568 }
1569 Value *getCallee() const;
1570};
1571
1572/// This represents the llvm.instrprof.timestamp intrinsic.
1574public:
1575 static bool classof(const IntrinsicInst *I) {
1576 return I->getIntrinsicID() == Intrinsic::instrprof_timestamp;
1577 }
1578 static bool classof(const Value *V) {
1579 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1580 }
1581};
1582
1583/// This represents the llvm.instrprof.value.profile intrinsic.
1585public:
1586 static bool classof(const IntrinsicInst *I) {
1587 return I->getIntrinsicID() == Intrinsic::instrprof_value_profile;
1588 }
1589 static bool classof(const Value *V) {
1590 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1591 }
1592
1594 return cast<Value>(const_cast<Value *>(getArgOperand(2)));
1595 }
1596
1598 return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
1599 }
1600
1601 // Returns the value site index.
1603 return cast<ConstantInt>(const_cast<Value *>(getArgOperand(4)));
1604 }
1605};
1606
1607/// A base class for instrprof mcdc intrinsics that require global bitmap bytes.
1609public:
1610 static bool classof(const IntrinsicInst *I) {
1612 }
1613 static bool classof(const Value *V) {
1614 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1615 }
1616
1617 /// \return The number of bits used for the MCDC bitmaps for the instrumented
1618 /// function.
1620 return cast<ConstantInt>(const_cast<Value *>(getArgOperand(2)));
1621 }
1622
1623 /// \return The number of bytes used for the MCDC bitmaps for the instrumented
1624 /// function.
1625 auto getNumBitmapBytes() const {
1626 return alignTo(getNumBitmapBits()->getZExtValue(), CHAR_BIT) / CHAR_BIT;
1627 }
1628};
1629
1630/// This represents the llvm.instrprof.mcdc.parameters intrinsic.
1632public:
1633 static bool classof(const IntrinsicInst *I) {
1634 return I->getIntrinsicID() == Intrinsic::instrprof_mcdc_parameters;
1635 }
1636 static bool classof(const Value *V) {
1637 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1638 }
1639};
1640
1641/// This represents the llvm.instrprof.mcdc.tvbitmap.update intrinsic.
1643public:
1644 static bool classof(const IntrinsicInst *I) {
1645 return I->getIntrinsicID() == Intrinsic::instrprof_mcdc_tvbitmap_update;
1646 }
1647 static bool classof(const Value *V) {
1648 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1649 }
1650
1651 /// \return The index of the TestVector Bitmap upon which this intrinsic
1652 /// acts.
1654 return cast<ConstantInt>(const_cast<Value *>(getArgOperand(2)));
1655 }
1656
1657 /// \return The address of the corresponding condition bitmap containing
1658 /// the index of the TestVector to update within the TestVector Bitmap.
1660 return cast<Value>(const_cast<Value *>(getArgOperand(3)));
1661 }
1662};
1663
1665public:
1666 static bool classof(const IntrinsicInst *I) {
1667 return I->getIntrinsicID() == Intrinsic::pseudoprobe;
1668 }
1669
1670 static bool classof(const Value *V) {
1671 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1672 }
1673
1675 return cast<ConstantInt>(const_cast<Value *>(getArgOperand(0)));
1676 }
1677
1679 return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
1680 }
1681
1683 return cast<ConstantInt>(const_cast<Value *>(getArgOperand(2)));
1684 }
1685
1687 return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
1688 }
1689};
1690
1692public:
1693 static bool classof(const IntrinsicInst *I) {
1694 return I->getIntrinsicID() == Intrinsic::experimental_noalias_scope_decl;
1695 }
1696
1697 static bool classof(const Value *V) {
1698 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1699 }
1700
1702 auto *MV =
1703 cast<MetadataAsValue>(getOperand(Intrinsic::NoAliasScopeDeclScopeArg));
1704 return cast<MDNode>(MV->getMetadata());
1705 }
1706
1707 void setScopeList(MDNode *ScopeList) {
1709 MetadataAsValue::get(getContext(), ScopeList));
1710 }
1711};
1712
1713/// Common base class for representing values projected from a statepoint.
1714/// Currently, the only projections available are gc.result and gc.relocate.
1716public:
1717 static bool classof(const IntrinsicInst *I) {
1718 return I->getIntrinsicID() == Intrinsic::experimental_gc_relocate ||
1719 I->getIntrinsicID() == Intrinsic::experimental_gc_result;
1720 }
1721
1722 static bool classof(const Value *V) {
1723 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1724 }
1725
1726 /// Return true if this relocate is tied to the invoke statepoint.
1727 /// This includes relocates which are on the unwinding path.
1728 bool isTiedToInvoke() const {
1729 const Value *Token = getArgOperand(0);
1730
1731 return isa<LandingPadInst>(Token) || isa<InvokeInst>(Token);
1732 }
1733
1734 /// The statepoint with which this gc.relocate is associated.
1735 const Value *getStatepoint() const;
1736};
1737
1738/// Represents calls to the gc.relocate intrinsic.
1740public:
1741 static bool classof(const IntrinsicInst *I) {
1742 return I->getIntrinsicID() == Intrinsic::experimental_gc_relocate;
1743 }
1744
1745 static bool classof(const Value *V) {
1746 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1747 }
1748
1749 /// The index into the associate statepoint's argument list
1750 /// which contains the base pointer of the pointer whose
1751 /// relocation this gc.relocate describes.
1752 unsigned getBasePtrIndex() const {
1753 return cast<ConstantInt>(getArgOperand(1))->getZExtValue();
1754 }
1755
1756 /// The index into the associate statepoint's argument list which
1757 /// contains the pointer whose relocation this gc.relocate describes.
1758 unsigned getDerivedPtrIndex() const {
1759 return cast<ConstantInt>(getArgOperand(2))->getZExtValue();
1760 }
1761
1762 Value *getBasePtr() const;
1763 Value *getDerivedPtr() const;
1764};
1765
1766/// Represents calls to the gc.result intrinsic.
1768public:
1769 static bool classof(const IntrinsicInst *I) {
1770 return I->getIntrinsicID() == Intrinsic::experimental_gc_result;
1771 }
1772
1773 static bool classof(const Value *V) {
1774 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1775 }
1776};
1777
1778
1779/// This represents the llvm.assume intrinsic.
1781public:
1782 static bool classof(const IntrinsicInst *I) {
1783 return I->getIntrinsicID() == Intrinsic::assume;
1784 }
1785 static bool classof(const Value *V) {
1786 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1787 }
1788};
1789
1790/// Check if \p ID corresponds to a convergence control intrinsic.
1791static inline bool isConvergenceControlIntrinsic(unsigned IntrinsicID) {
1792 switch (IntrinsicID) {
1793 default:
1794 return false;
1795 case Intrinsic::experimental_convergence_anchor:
1796 case Intrinsic::experimental_convergence_entry:
1797 case Intrinsic::experimental_convergence_loop:
1798 return true;
1799 }
1800}
1801
1802/// Represents calls to the llvm.experimintal.convergence.* intrinsics.
1804public:
1805 static bool classof(const IntrinsicInst *I) {
1806 return isConvergenceControlIntrinsic(I->getIntrinsicID());
1807 }
1808
1809 static bool classof(const Value *V) {
1810 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
1811 }
1812
1813 bool isAnchor() {
1814 return getIntrinsicID() == Intrinsic::experimental_convergence_anchor;
1815 }
1816 bool isEntry() {
1817 return getIntrinsicID() == Intrinsic::experimental_convergence_entry;
1818 }
1819 bool isLoop() {
1820 return getIntrinsicID() == Intrinsic::experimental_convergence_loop;
1821 }
1822};
1823
1824} // end namespace llvm
1825
1826#endif // LLVM_IR_INTRINSICINST_H
@ Poison
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
#define LLVM_DEPRECATED(MSG, FIX)
Definition: Compiler.h:157
This file contains the declarations for the subclasses of Constant, which represent the different fla...
This file contains the declarations of entities that describe floating point environment and related ...
IRTranslator LLVM IR MI
#define I(x, y, z)
Definition: MD5.cpp:58
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static SymbolRef::Type getType(const Symbol *Sym)
Definition: TapiFile.cpp:40
Value * RHS
Class for arbitrary precision integers.
Definition: APInt.h:78
static APInt getMaxValue(unsigned numBits)
Gets maximum unsigned value of APInt for specific bit width.
Definition: APInt.h:186
static APInt getSignedMaxValue(unsigned numBits)
Gets maximum signed value of APInt for a specific bit width.
Definition: APInt.h:189
static APInt getMinValue(unsigned numBits)
Gets minimum unsigned value of APInt for a specific bit width.
Definition: APInt.h:196
static APInt getSignedMinValue(unsigned numBits)
Gets minimum signed value of APInt for a specific bit width.
Definition: APInt.h:199
This class represents any memcpy intrinsic i.e.
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
This class represents any memmove intrinsic i.e.
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
This class represents any memset intrinsic.
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
This represents the llvm.assume intrinsic.
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
This class represents the atomic memcpy intrinsic i.e.
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
ConstantInt * getElementSizeInBytesCst() const
static bool classof(const IntrinsicInst *I)
Value * getRawElementSizeInBytes() const
static bool classof(const Value *V)
void setElementSizeInBytes(Constant *V)
uint32_t getElementSizeInBytes() const
This class represents the atomic memmove intrinsic i.e.
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
This class represents atomic memset intrinsic.
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
static Attribute getWithAlignment(LLVMContext &Context, Align Alignment)
Return a uniquified Attribute object that has the specific alignment set.
Definition: Attributes.cpp:233
This class represents an intrinsic that is based on a binary operation.
Value * getRHS() const
static bool classof(const Value *V)
unsigned getNoWrapKind() const
Returns one of OBO::NoSignedWrap or OBO::NoUnsignedWrap.
bool isSigned() const
Whether the intrinsic is signed or unsigned.
static bool classof(const IntrinsicInst *I)
Instruction::BinaryOps getBinaryOp() const
Returns the binary operation underlying the intrinsic.
Value * getLHS() const
void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Removes the attribute from the given argument.
Definition: InstrTypes.h:1641
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
Definition: InstrTypes.h:1465
MaybeAlign getParamAlign(unsigned ArgNo) const
Extract the alignment for a call or parameter (0=unknown).
Definition: InstrTypes.h:1838
const Use & getArgOperandUse(unsigned i) const
Wrappers for getting the Use of a call argument.
Definition: InstrTypes.h:1421
Value * getArgOperand(unsigned i) const
Definition: InstrTypes.h:1410
void setArgOperand(unsigned i, Value *v)
Definition: InstrTypes.h:1415
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Adds the attribute to the indicated argument.
Definition: InstrTypes.h:1594
This class represents a function call, abstracting a target machine's calling convention.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:757
@ ICMP_SLT
signed less than
Definition: InstrTypes.h:786
@ ICMP_UGT
unsigned greater than
Definition: InstrTypes.h:780
@ ICMP_SGT
signed greater than
Definition: InstrTypes.h:784
@ ICMP_ULT
unsigned less than
Definition: InstrTypes.h:782
bool isSigned() const
Definition: InstrTypes.h:1007
This class represents a ucmp/scmp intrinsic.
static CmpInst::Predicate getGTPredicate(Intrinsic::ID ID)
Value * getRHS() const
CmpInst::Predicate getLTPredicate() const
static CmpInst::Predicate getLTPredicate(Intrinsic::ID ID)
static bool classof(const IntrinsicInst *I)
static bool isSigned(Intrinsic::ID ID)
bool isSigned() const
CmpInst::Predicate getGTPredicate() const
Value * getLHS() const
static bool classof(const Value *V)
This is the shared class of boolean and integer constants.
Definition: Constants.h:81
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
Definition: Constants.h:206
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:155
This is an important base class in LLVM.
Definition: Constant.h:42
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:400
Constrained floating point compare intrinsics.
FCmpInst::Predicate getPredicate() const
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
This is the common base class for constrained floating point intrinsics.
std::optional< fp::ExceptionBehavior > getExceptionBehavior() const
std::optional< RoundingMode > getRoundingMode() const
unsigned getNonMetadataArgCount() const
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
Represents calls to the llvm.experimintal.convergence.* intrinsics.
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
Assignment ID.
DWARF expression.
static std::optional< FragmentInfo > getFragmentInfo(expr_op_iterator Start, expr_op_iterator End)
Retrieve the details of this fragment expression.
This represents the llvm.dbg.assign instruction.
DIAssignID * getAssignID() const
static bool classof(const Value *V)
void setAssignId(DIAssignID *New)
void setKillAddress()
Kill the address component.
bool isKillAddress() const
Check whether this kills the address component.
Metadata * getRawAddress() const
DIExpression * getAddressExpression() const
Value * getAddress() const
static bool classof(const IntrinsicInst *I)
Metadata * getRawAddressExpression() const
Metadata * getRawAssignID() const
void setAddressExpression(DIExpression *NewExpr)
This represents the llvm.dbg.declare instruction.
static bool classof(const Value *V)
Value * getAddress() const
static bool classof(const IntrinsicInst *I)
This is the common base class for debug info intrinsics.
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
This represents the llvm.dbg.label instruction.
Metadata * getRawLabel() const
static bool classof(const IntrinsicInst *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
DILabel * getLabel() const
static bool classof(const Value *V)
void setLabel(DILabel *NewLabel)
This represents the llvm.dbg.value instruction.
iterator_range< location_op_iterator > getValues() const
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
Value * getValue(unsigned OpIdx=0) const
This is the common base class for debug info intrinsics for variables.
DIExpression::FragmentInfo getFragmentOrEntireVariable() const
Get the FragmentInfo for the variable if it exists, otherwise return a FragmentInfo that covers the e...
void setVariable(DILocalVariable *NewVar)
iterator_range< location_op_iterator > location_ops() const
Get the locations corresponding to the variable referenced by the debug info intrinsic.
void addVariableLocationOps(ArrayRef< Value * > NewValues, DIExpression *NewExpr)
Adding a new location operand will always result in this intrinsic using an ArgList,...
void setRawLocation(Metadata *Location)
Use of this should generally be avoided; instead, replaceVariableLocationOp and addVariableLocationOp...
void replaceVariableLocationOp(Value *OldValue, Value *NewValue, bool AllowEmpty=false)
Value * getVariableLocationOp(unsigned OpIdx) const
std::optional< DIExpression::FragmentInfo > getFragment() const
Get the FragmentInfo for the variable.
static bool classof(const Value *V)
void setExpression(DIExpression *NewExpr)
Metadata * getRawLocation() const
DILocalVariable * getVariable() const
unsigned getNumVariableLocationOps() const
bool isAddressOfVariable() const
Does this describe the address of a local variable.
void setOperand(unsigned i, Value *v)
Metadata * getRawVariable() const
static bool classof(const IntrinsicInst *I)
std::optional< uint64_t > getFragmentSizeInBits() const
Get the size (in bits) of the variable, or fragment of the variable that is described.
DIExpression * getExpression() const
void setArgOperand(unsigned i, Value *v)
Metadata * getRawExpression() const
RawLocationWrapper getWrappedLocation() const
Class representing an expression and its matching format.
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
Definition: Function.h:249
Common base class for representing values projected from a statepoint.
const Value * getStatepoint() const
The statepoint with which this gc.relocate is associated.
bool isTiedToInvoke() const
Return true if this relocate is tied to the invoke statepoint.
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
Represents calls to the gc.relocate intrinsic.
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
Value * getBasePtr() const
unsigned getBasePtrIndex() const
The index into the associate statepoint's argument list which contains the base pointer of the pointe...
Value * getDerivedPtr() const
unsigned getDerivedPtrIndex() const
The index into the associate statepoint's argument list which contains the pointer whose relocation t...
Represents calls to the gc.result intrinsic.
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
This represents the llvm.instrprof.callsite intrinsic.
Value * getCallee() const
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
A base class for all instrprof counter intrinsics.
static bool classof(const Value *V)
ConstantInt * getIndex() const
ConstantInt * getNumCounters() const
This represents the llvm.instrprof.cover intrinsic.
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
This represents the llvm.instrprof.increment.step intrinsic.
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
This represents the llvm.instrprof.increment intrinsic.
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
A base class for all instrprof intrinsics.
static bool classof(const Value *V)
GlobalVariable * getName() const
ConstantInt * getHash() const
static bool isCounterBase(const IntrinsicInst &I)
static bool isMCDCBitmapBase(const IntrinsicInst &I)
A base class for instrprof mcdc intrinsics that require global bitmap bytes.
ConstantInt * getNumBitmapBits() const
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
This represents the llvm.instrprof.mcdc.parameters intrinsic.
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
This represents the llvm.instrprof.mcdc.tvbitmap.update intrinsic.
ConstantInt * getBitmapIndex() const
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
This represents the llvm.instrprof.timestamp intrinsic.
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
This represents the llvm.instrprof.value.profile intrinsic.
ConstantInt * getIndex() const
static bool classof(const IntrinsicInst *I)
ConstantInt * getValueKind() const
static bool classof(const Value *V)
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:48
bool isAssumeLikeIntrinsic() const
Checks if the intrinsic is an annotation.
static bool mayLowerToFunctionCall(Intrinsic::ID IID)
Check if the intrinsic might lower into a regular function call in the course of IR transformations.
IntrinsicInst(const IntrinsicInst &)=delete
Intrinsic::ID getIntrinsicID() const
Return the intrinsic ID of this intrinsic.
Definition: IntrinsicInst.h:55
bool isCommutative() const
Return true if swapping the first two arguments to the intrinsic produces the same result.
Definition: IntrinsicInst.h:73
static bool classof(const Value *V)
IntrinsicInst & operator=(const IntrinsicInst &)=delete
static bool classof(const CallInst *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
bool isAssociative() const
Definition: IntrinsicInst.h:59
This is the common base class for lifetime intrinsics.
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
Metadata node.
Definition: Metadata.h:1069
LLVMContext & getContext() const
Definition: Metadata.h:1233
This class wraps the llvm.memcpy.inline intrinsic.
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
This class wraps the llvm.memcpy intrinsic.
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
Common base class for all memory intrinsics.
const Use & getRawDestUse() const
Value * getLength() const
Value * getRawDest() const
void setDestAlignment(Align Alignment)
void setLength(Value *L)
Value * getDest() const
This is just like getRawDest, but it strips off any cast instructions (including addrspacecast) that ...
void setDestAlignment(MaybeAlign Alignment)
void setDest(Value *Ptr)
Set the specified arguments of the instruction.
unsigned getDestAlignment() const
FIXME: Remove this function once transition to Align is over.
MaybeAlign getDestAlign() const
const Use & getLengthUse() const
unsigned getDestAddressSpace() const
This is the common base class for memset/memcpy/memmove.
ConstantInt * getVolatileCst() const
void setVolatile(Constant *V)
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
bool isVolatile() const
This class wraps the llvm.memmove intrinsic.
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
Common base class for all memset intrinsics.
void setValue(Value *Val)
const Use & getValueUse() const
Value * getValue() const
This class wraps the llvm.memset.inline intrinsic.
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
This class wraps the llvm.memset and llvm.memset.inline intrinsics.
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
Common base class for all memory transfer intrinsics.
unsigned getSourceAlignment() const
FIXME: Remove this function once transition to Align is over.
void setSource(Value *Ptr)
Value * getRawSource() const
Return the arguments to the instruction.
unsigned getSourceAddressSpace() const
MaybeAlign getSourceAlign() const
Value * getSource() const
This is just like getRawSource, but it strips off any cast instructions that feed it,...
void setSourceAlignment(MaybeAlign Alignment)
void setSourceAlignment(Align Alignment)
const Use & getRawSourceUse() const
This class wraps the llvm.memcpy/memmove intrinsics.
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
static MetadataAsValue * get(LLVMContext &Context, Metadata *MD)
Definition: Metadata.cpp:103
Root of the metadata hierarchy.
Definition: Metadata.h:62
This class represents min/max intrinsics.
static bool classof(const Value *V)
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...
APInt getSaturationPoint(unsigned numBits) const
Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values, so there is a certain thre...
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...
Value * getLHS() const
Value * getRHS() const
static ICmpInst::Predicate getPredicate(Intrinsic::ID ID)
Returns the comparison predicate underlying the intrinsic.
ICmpInst::Predicate getPredicate() const
Returns the comparison predicate underlying the intrinsic.
static bool isSigned(Intrinsic::ID ID)
Whether the intrinsic is signed or unsigned.
static bool classof(const IntrinsicInst *I)
bool isSigned() const
Whether the intrinsic is signed or unsigned.
Constant * getSaturationPoint(Type *Ty) const
Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values, so there is a certain thre...
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
static bool classof(const IntrinsicInst *I)
void setScopeList(MDNode *ScopeList)
static bool classof(const Value *V)
MDNode * getScopeList() const
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
Definition: PointerUnion.h:118
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
Definition: Constants.cpp:1852
ConstantInt * getAttributes() const
ConstantInt * getIndex() const
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
ConstantInt * getFactor() const
ConstantInt * getFuncGuid() const
Lightweight class that wraps the location operand metadata of a debug intrinsic.
friend bool operator<=(const RawLocationWrapper &A, const RawLocationWrapper &B)
Metadata * getRawLocation() const
friend bool operator>(const RawLocationWrapper &A, const RawLocationWrapper &B)
RawLocationWrapper(Metadata *RawLocation)
friend bool operator<(const RawLocationWrapper &A, const RawLocationWrapper &B)
friend bool operator==(const RawLocationWrapper &A, const RawLocationWrapper &B)
iterator_range< location_op_iterator > location_ops() const
Get the locations corresponding to the variable referenced by the debug info intrinsic.
Value * getVariableLocationOp(unsigned OpIdx) const
bool isKillLocation(const DIExpression *Expression) const
friend bool operator!=(const RawLocationWrapper &A, const RawLocationWrapper &B)
unsigned getNumVariableLocationOps() const
friend bool operator>=(const RawLocationWrapper &A, const RawLocationWrapper &B)
Represents a saturating add/sub intrinsic.
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
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:368
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:503
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
static IntegerType * getInt8Ty(LLVMContext &C)
A Use represents the edge between a Value definition and its users.
Definition: Use.h:43
void setOperand(unsigned i, Value *Val)
Definition: User.h:174
Value * getOperand(unsigned i) const
Definition: User.h:169
This represents the llvm.va_copy intrinsic.
Value * getSrc() const
static bool classof(const Value *V)
Value * getDest() const
static bool classof(const IntrinsicInst *I)
This represents the llvm.va_end intrinsic.
Value * getArgList() const
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
This represents the llvm.va_start intrinsic.
static bool classof(const IntrinsicInst *I)
static bool classof(const Value *V)
Value * getArgList() const
static bool isVPBinOp(Intrinsic::ID ID)
static bool classof(const IntrinsicInst *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Value *V)
static bool isVPCast(Intrinsic::ID ID)
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const IntrinsicInst *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Value *V)
static bool isVPCmp(Intrinsic::ID ID)
CmpInst::Predicate getPredicate() const
This is the common base class for vector predication intrinsics.
std::optional< unsigned > getFunctionalIntrinsicID() const
static bool classof(const Value *V)
static Function * getDeclarationForParams(Module *M, Intrinsic::ID, Type *ReturnType, ArrayRef< Value * > Params)
Declares a llvm.vp.
static std::optional< unsigned > getMaskParamPos(Intrinsic::ID IntrinsicID)
bool canIgnoreVectorLengthParam() const
void setMaskParam(Value *)
static std::optional< unsigned > getFunctionalOpcodeForVP(Intrinsic::ID ID)
static std::optional< unsigned > getMemoryDataParamPos(Intrinsic::ID)
Value * getVectorLengthParam() const
static bool classof(const IntrinsicInst *I)
static std::optional< Intrinsic::ID > getFunctionalIntrinsicIDForVP(Intrinsic::ID ID)
void setVectorLengthParam(Value *)
static std::optional< unsigned > getVectorLengthParamPos(Intrinsic::ID IntrinsicID)
static Intrinsic::ID getForOpcode(unsigned OC)
The llvm.vp.* intrinsics for this instruction Opcode.
static std::optional< unsigned > getMemoryPointerParamPos(Intrinsic::ID)
static bool isVPIntrinsic(Intrinsic::ID)
Value * getMemoryDataParam() const
static Intrinsic::ID getForIntrinsic(Intrinsic::ID Id)
The llvm.vp.
Value * getMemoryPointerParam() const
std::optional< unsigned > getConstrainedIntrinsicID() const
MaybeAlign getPointerAlignment() const
Value * getMaskParam() const
ElementCount getStaticVectorLength() const
static std::optional< Intrinsic::ID > getConstrainedIntrinsicIDForVP(Intrinsic::ID ID)
std::optional< unsigned > getFunctionalOpcode() const
This represents vector predication reduction intrinsics.
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
static bool isVPReduction(Intrinsic::ID ID)
unsigned getStartParamPos() const
unsigned getVectorParamPos() const
Value wrapper in the Metadata hierarchy.
Definition: Metadata.h:450
Value * getValue() const
Definition: Metadata.h:490
LLVM Value Representation.
Definition: Value.h:74
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
Definition: Value.cpp:694
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:1075
Represents an op.with.overflow intrinsic.
static bool classof(const Value *V)
static bool classof(const IntrinsicInst *I)
CRTP base class which implements the entire standard iterator facade in terms of a minimal subset of ...
Definition: iterator.h:80
A range adaptor for a pair of iterators.
bool operator==(const location_op_iterator &RHS) const
location_op_iterator & operator=(const location_op_iterator &R)
location_op_iterator(ValueAsMetadata **MultiIter)
location_op_iterator(const location_op_iterator &R)
location_op_iterator & operator++()
location_op_iterator(ValueAsMetadata *SingleIter)
location_op_iterator & operator--()
const Value * operator*() const
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
static const int NoAliasScopeDeclScopeArg
Definition: Intrinsics.h:37
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
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:1729
static bool isLifetimeIntrinsic(Intrinsic::ID ID)
Check if ID corresponds to a lifetime intrinsic.
static bool isDbgInfoIntrinsic(Intrinsic::ID ID)
Check if ID corresponds to a debug info intrinsic.
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:155
static bool isConvergenceControlIntrinsic(unsigned IntrinsicID)
Check if ID corresponds to a convergence control intrinsic.
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:117