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"
27#include "llvm/IR/DebugInfoMetadata.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/Value.h"
35#include "llvm/Support/Casting.h"
36#include "llvm/Support/MathExtras.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;
52 IntrinsicInst &operator=(const IntrinsicInst &) = delete;
53
54 /// Return the intrinsic ID of this intrinsic.
55 Intrinsic::ID getIntrinsicID() const {
56 return getCalledFunction()->getIntrinsicID();
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.
102 bool isAssumeLikeIntrinsic() const {
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>(Val: V) && classof(I: cast<CallInst>(Val: V));
137 }
138};
139
140/// Check if \p ID corresponds to a lifetime intrinsic.
141static inline bool isLifetimeIntrinsic(Intrinsic::ID ID) {
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.
152class LifetimeIntrinsic : public IntrinsicInst {
153public:
154 /// \name Casting methods
155 /// @{
156 static bool classof(const IntrinsicInst *I) {
157 return isLifetimeIntrinsic(ID: I->getIntrinsicID());
158 }
159 static bool classof(const Value *V) {
160 return isa<IntrinsicInst>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
161 }
162 /// @}
163};
164
165/// Check if \p ID corresponds to a debug info intrinsic.
166static inline bool isDbgInfoIntrinsic(Intrinsic::ID ID) {
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.
179class DbgInfoIntrinsic : public IntrinsicInst {
180public:
181 /// \name Casting methods
182 /// @{
183 static bool classof(const IntrinsicInst *I) {
184 return isDbgInfoIntrinsic(ID: I->getIntrinsicID());
185 }
186 static bool classof(const Value *V) {
187 return isa<IntrinsicInst>(Val: V) && classof(I: cast<IntrinsicInst>(Val: 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 .
195class location_op_iterator
196 : public iterator_facade_base<location_op_iterator,
197 std::bidirectional_iterator_tag, Value *> {
198 PointerUnion<ValueAsMetadata *, ValueAsMetadata **> I;
199
200public:
201 location_op_iterator(ValueAsMetadata *SingleIter) : I(SingleIter) {}
202 location_op_iterator(ValueAsMetadata **MultiIter) : I(MultiIter) {}
203
204 location_op_iterator(const location_op_iterator &R) : I(R.I) {}
205 location_op_iterator &operator=(const location_op_iterator &R) {
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 *>(Val: I)
212 ? cast<ValueAsMetadata *>(Val: I)
213 : *cast<ValueAsMetadata **>(Val: I);
214 return VAM->getValue();
215 };
216 Value *operator*() {
217 ValueAsMetadata *VAM = isa<ValueAsMetadata *>(Val: I)
218 ? cast<ValueAsMetadata *>(Val&: I)
219 : *cast<ValueAsMetadata **>(Val&: I);
220 return VAM->getValue();
221 }
222 location_op_iterator &operator++() {
223 if (isa<ValueAsMetadata *>(Val: I))
224 I = cast<ValueAsMetadata *>(Val&: I) + 1;
225 else
226 I = cast<ValueAsMetadata **>(Val&: I) + 1;
227 return *this;
228 }
229 location_op_iterator &operator--() {
230 if (isa<ValueAsMetadata *>(Val: I))
231 I = cast<ValueAsMetadata *>(Val&: I) - 1;
232 else
233 I = cast<ValueAsMetadata **>(Val&: 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.
241class RawLocationWrapper {
242 Metadata *RawLocation = nullptr;
243
244public:
245 RawLocationWrapper() = default;
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.
258 iterator_range<location_op_iterator> location_ops() const;
259 Value *getVariableLocationOp(unsigned OpIdx) const;
260 unsigned getNumVariableLocationOps() const {
261 if (hasArgList())
262 return cast<DIArgList>(Val: getRawLocation())->getArgs().size();
263 return 1;
264 }
265 bool hasArgList() const { return isa<DIArgList>(Val: getRawLocation()); }
266 bool isKillLocation(const DIExpression *Expression) const {
267 // Check for "kill" sentinel values.
268 // Non-variadic: empty metadata.
269 if (!hasArgList() && isa<MDNode>(Val: 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(Range: location_ops(), P: [](Value *V) { return isa<UndefValue>(Val: 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.
306class DbgVariableIntrinsic : public DbgInfoIntrinsic {
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.
311 iterator_range<location_op_iterator> location_ops() const;
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.
321 void addVariableLocationOps(ArrayRef<Value *> NewValues,
322 DIExpression *NewExpr);
323
324 void setVariable(DILocalVariable *NewVar) {
325 setArgOperand(i: 1, v: MetadataAsValue::get(Context&: NewVar->getContext(), MD: NewVar));
326 }
327
328 void setExpression(DIExpression *NewExpr) {
329 setArgOperand(i: 2, v: MetadataAsValue::get(Context&: NewExpr->getContext(), MD: NewExpr));
330 }
331
332 unsigned getNumVariableLocationOps() const {
333 return getWrappedLocation().getNumVariableLocationOps();
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
345 void setKillLocation() {
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(Ptr: OldValue).second)
351 continue;
352 Value *Poison = PoisonValue::get(T: OldValue->getType());
353 replaceVariableLocationOp(OldValue, NewValue: Poison);
354 }
355 }
356
357 bool isKillLocation() const {
358 return getWrappedLocation().isKillLocation(Expression: getExpression());
359 }
360
361 DILocalVariable *getVariable() const {
362 return cast<DILocalVariable>(Val: getRawVariable());
363 }
364
365 DIExpression *getExpression() const {
366 return cast<DIExpression>(Val: getRawExpression());
367 }
368
369 Metadata *getRawLocation() const {
370 return cast<MetadataAsValue>(Val: getArgOperand(i: 0))->getMetadata();
371 }
372
373 RawLocationWrapper getWrappedLocation() const {
374 return RawLocationWrapper(getRawLocation());
375 }
376
377 Metadata *getRawVariable() const {
378 return cast<MetadataAsValue>(Val: getArgOperand(i: 1))->getMetadata();
379 }
380
381 Metadata *getRawExpression() const {
382 return cast<MetadataAsValue>(Val: getArgOperand(i: 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(i: 0, v: MetadataAsValue::get(Context&: getContext(), MD: 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.
404 DIExpression::FragmentInfo getFragmentOrEntireVariable() const {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
428 }
429 /// @}
430protected:
431 void setArgOperand(unsigned i, Value *v) {
432 DbgInfoIntrinsic::setArgOperand(i, v);
433 }
434 void setOperand(unsigned i, Value *v) { DbgInfoIntrinsic::setOperand(i_nocapture: i, Val_nocapture: v); }
435};
436
437/// This represents the llvm.dbg.declare instruction.
438class DbgDeclareInst : public DbgVariableIntrinsic {
439public:
440 Value *getAddress() const {
441 assert(getNumVariableLocationOps() == 1 &&
442 "dbg.declare must have exactly 1 location operand.");
443 return getVariableLocationOp(OpIdx: 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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
453 }
454 /// @}
455};
456
457/// This represents the llvm.dbg.value instruction.
458class DbgValueInst : public DbgVariableIntrinsic {
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 }
465 iterator_range<location_op_iterator> getValues() const {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
477 }
478 /// @}
479};
480
481/// This represents the llvm.dbg.assign instruction.
482class DbgAssignIntrinsic : public DbgValueInst {
483 enum Operands {
484 OpValue,
485 OpVar,
486 OpExpr,
487 OpAssignID,
488 OpAddress,
489 OpAddressExpr,
490 };
491
492public:
493 Value *getAddress() const;
494 Metadata *getRawAddress() const {
495 return cast<MetadataAsValue>(Val: getArgOperand(i: OpAddress))->getMetadata();
496 }
497 Metadata *getRawAssignID() const {
498 return cast<MetadataAsValue>(Val: getArgOperand(i: OpAssignID))->getMetadata();
499 }
500 DIAssignID *getAssignID() const { return cast<DIAssignID>(Val: getRawAssignID()); }
501 Metadata *getRawAddressExpression() const {
502 return cast<MetadataAsValue>(Val: getArgOperand(i: OpAddressExpr))->getMetadata();
503 }
504 DIExpression *getAddressExpression() const {
505 return cast<DIExpression>(Val: getRawAddressExpression());
506 }
507 void setAddressExpression(DIExpression *NewExpr) {
508 setArgOperand(i: OpAddressExpr,
509 v: MetadataAsValue::get(Context&: NewExpr->getContext(), MD: 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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
528 }
529 /// @}
530};
531
532/// This represents the llvm.dbg.label instruction.
533class DbgLabelInst : public DbgInfoIntrinsic {
534public:
535 DILabel *getLabel() const { return cast<DILabel>(Val: getRawLabel()); }
536 void setLabel(DILabel *NewLabel) {
537 setArgOperand(i: 0, v: MetadataAsValue::get(Context&: getContext(), MD: NewLabel));
538 }
539
540 Metadata *getRawLabel() const {
541 return cast<MetadataAsValue>(Val: getArgOperand(i: 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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
551 }
552 /// @}
553};
554
555/// This is the common base class for vector predication intrinsics.
556class VPIntrinsic : public IntrinsicInst {
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.
561 static Function *getDeclarationForParams(Module *M, Intrinsic::ID,
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.
574 static Intrinsic::ID getForIntrinsic(Intrinsic::ID Id);
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.
584 Value *getVectorLengthParam() const;
585 void setVectorLengthParam(Value *);
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.
592 ElementCount getStaticVectorLength() const;
593
594 /// \return The alignment of the pointer used by this load/store/gather or
595 /// scatter.
596 MaybeAlign getPointerAlignment() const;
597 // MaybeAlign setPointerAlignment(Align NewAlign); // TODO
598
599 /// \return The pointer operand of this load,store, gather or scatter.
600 Value *getMemoryPointerParam() const;
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
613 }
614
615 // Equivalent non-predicated opcode
616 std::optional<unsigned> getFunctionalOpcode() const {
617 return getFunctionalOpcodeForVP(ID: getIntrinsicID());
618 }
619
620 // Equivalent non-predicated intrinsic ID
621 std::optional<unsigned> getFunctionalIntrinsicID() const {
622 return getFunctionalIntrinsicIDForVP(ID: getIntrinsicID());
623 }
624
625 // Equivalent non-predicated constrained ID
626 std::optional<unsigned> getConstrainedIntrinsicID() const {
627 return getConstrainedIntrinsicIDForVP(ID: getIntrinsicID());
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>
635 getFunctionalIntrinsicIDForVP(Intrinsic::ID ID);
636
637 // Equivalent non-predicated constrained ID
638 static std::optional<Intrinsic::ID>
639 getConstrainedIntrinsicIDForVP(Intrinsic::ID ID);
640};
641
642/// This represents vector predication reduction intrinsics.
643class VPReductionIntrinsic : public VPIntrinsic {
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(ID: I->getIntrinsicID());
657 }
658 static bool classof(const Value *V) {
659 return isa<IntrinsicInst>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
660 }
661 /// @}
662};
663
664class VPCastIntrinsic : public VPIntrinsic {
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(ID: I->getIntrinsicID());
672 }
673 static bool classof(const Value *V) {
674 return isa<IntrinsicInst>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
675 }
676 /// @}
677};
678
679class VPCmpIntrinsic : public VPIntrinsic {
680public:
681 static bool isVPCmp(Intrinsic::ID ID);
682
683 CmpInst::Predicate getPredicate() const;
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(ID: I->getIntrinsicID());
689 }
690 static bool classof(const Value *V) {
691 return isa<IntrinsicInst>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
692 }
693 /// @}
694};
695
696class VPBinOpIntrinsic : public VPIntrinsic {
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(ID: I->getIntrinsicID());
704 }
705 static bool classof(const Value *V) {
706 return isa<IntrinsicInst>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
707 }
708 /// @}
709};
710
711
712/// This is the common base class for constrained floating point intrinsics.
713class ConstrainedFPIntrinsic : public IntrinsicInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
724 }
725};
726
727/// Constrained floating point compare intrinsics.
728class ConstrainedFPCmpIntrinsic : public ConstrainedFPIntrinsic {
729public:
730 FCmpInst::Predicate getPredicate() const;
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
747 }
748};
749
750/// This class represents min/max intrinsics.
751class MinMaxIntrinsic : public IntrinsicInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
766 }
767
768 Value *getLHS() const { return const_cast<Value *>(getArgOperand(i: 0)); }
769 Value *getRHS() const { return const_cast<Value *>(getArgOperand(i: 1)); }
770
771 /// Returns the comparison predicate underlying the intrinsic.
772 static ICmpInst::Predicate getPredicate(Intrinsic::ID ID) {
773 switch (ID) {
774 case Intrinsic::umin:
775 return ICmpInst::Predicate::ICMP_ULT;
776 case Intrinsic::umax:
777 return ICmpInst::Predicate::ICMP_UGT;
778 case Intrinsic::smin:
779 return ICmpInst::Predicate::ICMP_SLT;
780 case Intrinsic::smax:
781 return ICmpInst::Predicate::ICMP_SGT;
782 default:
783 llvm_unreachable("Invalid intrinsic");
784 }
785 }
786
787 /// Returns the comparison predicate underlying the intrinsic.
788 ICmpInst::Predicate getPredicate() const {
789 return getPredicate(ID: getIntrinsicID());
790 }
791
792 /// Whether the intrinsic is signed or unsigned.
793 static bool isSigned(Intrinsic::ID ID) {
794 return ICmpInst::isSigned(predicate: getPredicate(ID));
795 };
796
797 /// Whether the intrinsic is signed or unsigned.
798 bool isSigned() const { return isSigned(ID: 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(ID: 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.
828 static Constant *getSaturationPoint(Intrinsic::ID ID, Type *Ty) {
829 return Constant::getIntegerValue(
830 Ty, V: getSaturationPoint(ID, numBits: Ty->getScalarSizeInBits()));
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.
836 Constant *getSaturationPoint(Type *Ty) const {
837 return getSaturationPoint(ID: getIntrinsicID(), Ty);
838 }
839};
840
841/// This class represents a ucmp/scmp intrinsic
842class CmpIntrinsic : public IntrinsicInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
855 }
856
857 Value *getLHS() const { return const_cast<Value *>(getArgOperand(i: 0)); }
858 Value *getRHS() const { return const_cast<Value *>(getArgOperand(i: 1)); }
859
860 static bool isSigned(Intrinsic::ID ID) { return ID == Intrinsic::scmp; }
861 bool isSigned() const { return isSigned(ID: getIntrinsicID()); }
862
863 static CmpInst::Predicate getGTPredicate(Intrinsic::ID ID) {
864 return isSigned(ID) ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
865 }
866 CmpInst::Predicate getGTPredicate() const {
867 return getGTPredicate(ID: getIntrinsicID());
868 }
869
870 static CmpInst::Predicate getLTPredicate(Intrinsic::ID ID) {
871 return isSigned(ID) ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
872 }
873 CmpInst::Predicate getLTPredicate() const {
874 return getLTPredicate(ID: getIntrinsicID());
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.
880class BinaryOpIntrinsic : public IntrinsicInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
901 }
902
903 Value *getLHS() const { return const_cast<Value *>(getArgOperand(i: 0)); }
904 Value *getRHS() const { return const_cast<Value *>(getArgOperand(i: 1)); }
905
906 /// Returns the binary operation underlying the intrinsic.
907 Instruction::BinaryOps getBinaryOp() const;
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.
917class WithOverflowInst : public BinaryOpIntrinsic {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
934 }
935};
936
937/// Represents a saturating add/sub intrinsic.
938class SaturatingInst : public BinaryOpIntrinsic {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: 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(i: 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(i: 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")
989 unsigned getDestAlignment() const {
990 if (auto MA = getParamAlign(ArgNo: ARG_DEST))
991 return MA->value();
992 return 0;
993 }
994 MaybeAlign getDestAlign() const { return getParamAlign(ArgNo: ARG_DEST); }
995
996 /// Set the specified arguments of the instruction.
997 void setDest(Value *Ptr) {
998 assert(getRawDest()->getType() == Ptr->getType() &&
999 "setDest called with pointer of wrong type!");
1000 setArgOperand(i: ARG_DEST, v: Ptr);
1001 }
1002
1003 void setDestAlignment(MaybeAlign Alignment) {
1004 removeParamAttr(ARG_DEST, Attribute::Alignment);
1005 if (Alignment)
1006 addParamAttr(ARG_DEST,
1007 Attribute::getWithAlignment(Context&: getContext(), Alignment: *Alignment));
1008 }
1009 void setDestAlignment(Align Alignment) {
1010 removeParamAttr(ARG_DEST, Attribute::Alignment);
1011 addParamAttr(ARG_DEST,
1012 Attribute::getWithAlignment(Context&: getContext(), Alignment));
1013 }
1014
1015 void setLength(Value *L) {
1016 assert(getLength()->getType() == L->getType() &&
1017 "setLength called with value of wrong type!");
1018 setArgOperand(i: ARG_LENGTH, v: 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.
1030 Value *getRawSource() const {
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.
1041 Value *getSource() const { return getRawSource()->stripPointerCasts(); }
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")
1050 unsigned getSourceAlignment() const {
1051 if (auto MA = BaseCL::getParamAlign(ARG_SOURCE))
1052 return MA->value();
1053 return 0;
1054 }
1055
1056 MaybeAlign getSourceAlign() const {
1057 return BaseCL::getParamAlign(ARG_SOURCE);
1058 }
1059
1060 void setSource(Value *Ptr) {
1061 assert(getRawSource()->getType() == Ptr->getType() &&
1062 "setSource called with pointer of wrong type!");
1063 BaseCL::setArgOperand(ARG_SOURCE, Ptr);
1064 }
1065
1066 void setSourceAlignment(MaybeAlign Alignment) {
1067 BaseCL::removeParamAttr(ARG_SOURCE, Attribute::Alignment);
1068 if (Alignment)
1069 BaseCL::addParamAttr(ARG_SOURCE, Attribute::getWithAlignment(
1070 Context&: BaseCL::getContext(), Alignment: *Alignment));
1071 }
1072
1073 void setSourceAlignment(Align Alignment) {
1074 BaseCL::removeParamAttr(ARG_SOURCE, Attribute::Alignment);
1075 BaseCL::addParamAttr(ARG_SOURCE, Attribute::getWithAlignment(
1076 Context&: 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:
1107 Value *getRawElementSizeInBytes() const {
1108 return const_cast<Value *>(getArgOperand(i: ARG_ELEMENTSIZE));
1109 }
1110
1111 ConstantInt *getElementSizeInBytesCst() const {
1112 return cast<ConstantInt>(Val: getRawElementSizeInBytes());
1113 }
1114
1115 uint32_t getElementSizeInBytes() const {
1116 return getElementSizeInBytesCst()->getZExtValue();
1117 }
1118
1119 void setElementSizeInBytes(Constant *V) {
1120 assert(V->getType() == Type::getInt8Ty(getContext()) &&
1121 "setElementSizeInBytes called with value of wrong type!");
1122 setArgOperand(i: ARG_ELEMENTSIZE, v: 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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: 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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: 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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1167 }
1168};
1169
1170/// This class represents the atomic memcpy intrinsic
1171/// i.e. llvm.element.unordered.atomic.memcpy
1172class AtomicMemCpyInst : public AtomicMemTransferInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1179 }
1180};
1181
1182/// This class represents the atomic memmove intrinsic
1183/// i.e. llvm.element.unordered.atomic.memmove
1184class AtomicMemMoveInst : public AtomicMemTransferInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: 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:
1200 ConstantInt *getVolatileCst() const {
1201 return cast<ConstantInt>(Val: const_cast<Value *>(getArgOperand(i: ARG_VOLATILE)));
1202 }
1203
1204 bool isVolatile() const { return !getVolatileCst()->isZero(); }
1205
1206 void setVolatile(Constant *V) { setArgOperand(i: ARG_VOLATILE, v: 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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: 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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1241 }
1242};
1243
1244/// This class wraps the llvm.memset.inline intrinsic.
1245class MemSetInlineInst : public MemSetInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: 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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1272 }
1273};
1274
1275/// This class wraps the llvm.memcpy intrinsic.
1276class MemCpyInst : public MemTransferInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1285 }
1286};
1287
1288/// This class wraps the llvm.memmove intrinsic.
1289class MemMoveInst : public MemTransferInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1297 }
1298};
1299
1300/// This class wraps the llvm.memcpy.inline intrinsic.
1301class MemCpyInlineInst : public MemCpyInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: 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>(Val: 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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: 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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: 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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1384 }
1385};
1386
1387/// This class represents any memcpy intrinsic
1388/// i.e. llvm.element.unordered.atomic.memcpy
1389/// and llvm.memcpy
1390class AnyMemCpyInst : public AnyMemTransferInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1404 }
1405};
1406
1407/// This class represents any memmove intrinsic
1408/// i.e. llvm.element.unordered.atomic.memmove
1409/// and llvm.memmove
1410class AnyMemMoveInst : public AnyMemTransferInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1423 }
1424};
1425
1426/// This represents the llvm.va_start intrinsic.
1427class VAStartInst : public IntrinsicInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1434 }
1435
1436 Value *getArgList() const { return const_cast<Value *>(getArgOperand(i: 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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1447 }
1448
1449 Value *getArgList() const { return const_cast<Value *>(getArgOperand(i: 0)); }
1450};
1451
1452/// This represents the llvm.va_copy intrinsic.
1453class VACopyInst : public IntrinsicInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1460 }
1461
1462 Value *getDest() const { return const_cast<Value *>(getArgOperand(i: 0)); }
1463 Value *getSrc() const { return const_cast<Value *>(getArgOperand(i: 1)); }
1464};
1465
1466/// A base class for all instrprof intrinsics.
1467class InstrProfInstBase : public IntrinsicInst {
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>(Val: V))
1493 return isCounterBase(I: *Instr) || isMCDCBitmapBase(I: *Instr);
1494 return false;
1495 }
1496 // The name of the instrumented function.
1497 GlobalVariable *getName() const {
1498 return cast<GlobalVariable>(
1499 Val: const_cast<Value *>(getArgOperand(i: 0))->stripPointerCasts());
1500 }
1501 // The hash of the CFG for the instrumented function.
1502 ConstantInt *getHash() const {
1503 return cast<ConstantInt>(Val: const_cast<Value *>(getArgOperand(i: 1)));
1504 }
1505};
1506
1507/// A base class for all instrprof counter intrinsics.
1508class InstrProfCntrInstBase : public InstrProfInstBase {
1509public:
1510 static bool classof(const Value *V) {
1511 if (const auto *Instr = dyn_cast<IntrinsicInst>(Val: V))
1512 return InstrProfInstBase::isCounterBase(I: *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.
1523class InstrProfCoverInst : public InstrProfCntrInstBase {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1530 }
1531};
1532
1533/// This represents the llvm.instrprof.increment intrinsic.
1534class InstrProfIncrementInst : public InstrProfCntrInstBase {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1542 }
1543 Value *getStep() const;
1544};
1545
1546/// This represents the llvm.instrprof.increment.step intrinsic.
1547class InstrProfIncrementInstStep : public InstrProfIncrementInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: 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)
1561class InstrProfCallsite : public InstrProfCntrInstBase {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1568 }
1569 Value *getCallee() const;
1570};
1571
1572/// This represents the llvm.instrprof.timestamp intrinsic.
1573class InstrProfTimestampInst : public InstrProfCntrInstBase {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1580 }
1581};
1582
1583/// This represents the llvm.instrprof.value.profile intrinsic.
1584class InstrProfValueProfileInst : public InstrProfCntrInstBase {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1591 }
1592
1593 Value *getTargetValue() const {
1594 return cast<Value>(Val: const_cast<Value *>(getArgOperand(i: 2)));
1595 }
1596
1597 ConstantInt *getValueKind() const {
1598 return cast<ConstantInt>(Val: const_cast<Value *>(getArgOperand(i: 3)));
1599 }
1600
1601 // Returns the value site index.
1602 ConstantInt *getIndex() const {
1603 return cast<ConstantInt>(Val: const_cast<Value *>(getArgOperand(i: 4)));
1604 }
1605};
1606
1607/// A base class for instrprof mcdc intrinsics that require global bitmap bytes.
1608class InstrProfMCDCBitmapInstBase : public InstrProfInstBase {
1609public:
1610 static bool classof(const IntrinsicInst *I) {
1611 return InstrProfInstBase::isMCDCBitmapBase(I: *I);
1612 }
1613 static bool classof(const Value *V) {
1614 return isa<IntrinsicInst>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1615 }
1616
1617 /// \return The number of bits used for the MCDC bitmaps for the instrumented
1618 /// function.
1619 ConstantInt *getNumBitmapBits() const {
1620 return cast<ConstantInt>(Val: const_cast<Value *>(getArgOperand(i: 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(Value: getNumBitmapBits()->getZExtValue(), CHAR_BIT) / CHAR_BIT;
1627 }
1628};
1629
1630/// This represents the llvm.instrprof.mcdc.parameters intrinsic.
1631class InstrProfMCDCBitmapParameters : public InstrProfMCDCBitmapInstBase {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1638 }
1639};
1640
1641/// This represents the llvm.instrprof.mcdc.tvbitmap.update intrinsic.
1642class InstrProfMCDCTVBitmapUpdate : public InstrProfMCDCBitmapInstBase {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1649 }
1650
1651 /// \return The index of the TestVector Bitmap upon which this intrinsic
1652 /// acts.
1653 ConstantInt *getBitmapIndex() const {
1654 return cast<ConstantInt>(Val: const_cast<Value *>(getArgOperand(i: 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.
1659 Value *getMCDCCondBitmapAddr() const {
1660 return cast<Value>(Val: const_cast<Value *>(getArgOperand(i: 3)));
1661 }
1662};
1663
1664class PseudoProbeInst : public IntrinsicInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1672 }
1673
1674 ConstantInt *getFuncGuid() const {
1675 return cast<ConstantInt>(Val: const_cast<Value *>(getArgOperand(i: 0)));
1676 }
1677
1678 ConstantInt *getIndex() const {
1679 return cast<ConstantInt>(Val: const_cast<Value *>(getArgOperand(i: 1)));
1680 }
1681
1682 ConstantInt *getAttributes() const {
1683 return cast<ConstantInt>(Val: const_cast<Value *>(getArgOperand(i: 2)));
1684 }
1685
1686 ConstantInt *getFactor() const {
1687 return cast<ConstantInt>(Val: const_cast<Value *>(getArgOperand(i: 3)));
1688 }
1689};
1690
1691class NoAliasScopeDeclInst : public IntrinsicInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1699 }
1700
1701 MDNode *getScopeList() const {
1702 auto *MV =
1703 cast<MetadataAsValue>(Val: getOperand(i_nocapture: Intrinsic::NoAliasScopeDeclScopeArg));
1704 return cast<MDNode>(Val: MV->getMetadata());
1705 }
1706
1707 void setScopeList(MDNode *ScopeList) {
1708 setOperand(i_nocapture: Intrinsic::NoAliasScopeDeclScopeArg,
1709 Val_nocapture: MetadataAsValue::get(Context&: getContext(), MD: 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.
1715class GCProjectionInst : public IntrinsicInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: 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(i: 0);
1730
1731 return isa<LandingPadInst>(Val: Token) || isa<InvokeInst>(Val: 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.
1739class GCRelocateInst : public GCProjectionInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: 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>(Val: getArgOperand(i: 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>(Val: getArgOperand(i: 2))->getZExtValue();
1760 }
1761
1762 Value *getBasePtr() const;
1763 Value *getDerivedPtr() const;
1764};
1765
1766/// Represents calls to the gc.result intrinsic.
1767class GCResultInst : public GCProjectionInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: V));
1775 }
1776};
1777
1778
1779/// This represents the llvm.assume intrinsic.
1780class AssumeInst : public IntrinsicInst {
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>(Val: V) && classof(I: cast<IntrinsicInst>(Val: 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.
1803class ConvergenceControlInst : public IntrinsicInst {
1804public:
1805 static bool classof(const IntrinsicInst *I) {
1806 return isConvergenceControlIntrinsic(IntrinsicID: I->getIntrinsicID());
1807 }
1808
1809 static bool classof(const Value *V) {
1810 return isa<IntrinsicInst>(Val: V) && classof(I: cast<IntrinsicInst>(Val: 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
1827