WebSVN – QNX 8.QNX8 LLVM/Clang compiler suite – Blame – /llvm-build/x86_64/include/llvm/IR/IntrinsicInst.h

Rev	Author	Line No.	Line
14	pmbaty	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 <cassert>
		37	#include <cstdint>
		38	#include <optional>
		39
		40	namespace llvm {
		41
		42	class Metadata;
		43
		44	/// A wrapper class for inspecting calls to intrinsic functions.
		45	/// This allows the standard isa/dyncast/cast functionality to work with calls
		46	/// to intrinsic functions.
		47	class IntrinsicInst : public CallInst {
		48	public:
		49	IntrinsicInst() = delete;
		50	IntrinsicInst(const IntrinsicInst &) = delete;
		51	IntrinsicInst &operator=(const IntrinsicInst &) = delete;
		52
		53	/// Return the intrinsic ID of this intrinsic.
		54	Intrinsic::ID getIntrinsicID() const {
		55	return getCalledFunction()->getIntrinsicID();
		56	}
		57
		58	/// Return true if swapping the first two arguments to the intrinsic produces
		59	/// the same result.
		60	bool isCommutative() const {
		61	switch (getIntrinsicID()) {
		62	case Intrinsic::maxnum:
		63	case Intrinsic::minnum:
		64	case Intrinsic::maximum:
		65	case Intrinsic::minimum:
		66	case Intrinsic::smax:
		67	case Intrinsic::smin:
		68	case Intrinsic::umax:
		69	case Intrinsic::umin:
		70	case Intrinsic::sadd_sat:
		71	case Intrinsic::uadd_sat:
		72	case Intrinsic::sadd_with_overflow:
		73	case Intrinsic::uadd_with_overflow:
		74	case Intrinsic::smul_with_overflow:
		75	case Intrinsic::umul_with_overflow:
		76	case Intrinsic::smul_fix:
		77	case Intrinsic::umul_fix:
		78	case Intrinsic::smul_fix_sat:
		79	case Intrinsic::umul_fix_sat:
		80	case Intrinsic::fma:
		81	case Intrinsic::fmuladd:
		82	return true;
		83	default:
		84	return false;
		85	}
		86	}
		87
		88	/// Checks if the intrinsic is an annotation.
		89	bool isAssumeLikeIntrinsic() const {
		90	switch (getIntrinsicID()) {
		91	default: break;
		92	case Intrinsic::assume:
		93	case Intrinsic::sideeffect:
		94	case Intrinsic::pseudoprobe:
		95	case Intrinsic::dbg_assign:
		96	case Intrinsic::dbg_declare:
		97	case Intrinsic::dbg_value:
		98	case Intrinsic::dbg_label:
		99	case Intrinsic::invariant_start:
		100	case Intrinsic::invariant_end:
		101	case Intrinsic::lifetime_start:
		102	case Intrinsic::lifetime_end:
		103	case Intrinsic::experimental_noalias_scope_decl:
		104	case Intrinsic::objectsize:
		105	case Intrinsic::ptr_annotation:
		106	case Intrinsic::var_annotation:
		107	return true;
		108	}
		109	return false;
		110	}
		111
		112	/// Check if the intrinsic might lower into a regular function call in the
		113	/// course of IR transformations
		114	static bool mayLowerToFunctionCall(Intrinsic::ID IID);
		115
		116	/// Methods for support type inquiry through isa, cast, and dyn_cast:
		117	static bool classof(const CallInst *I) {
		118	if (const Function *CF = I->getCalledFunction())
		119	return CF->isIntrinsic();
		120	return false;
		121	}
		122	static bool classof(const Value *V) {
		123	return isa<CallInst>(V) && classof(cast<CallInst>(V));
		124	}
		125	};
		126
		127	/// Check if \p ID corresponds to a lifetime intrinsic.
		128	static inline bool isLifetimeIntrinsic(Intrinsic::ID ID) {
		129	switch (ID) {
		130	case Intrinsic::lifetime_start:
		131	case Intrinsic::lifetime_end:
		132	return true;
		133	default:
		134	return false;
		135	}
		136	}
		137
		138	/// This is the common base class for lifetime intrinsics.
		139	class LifetimeIntrinsic : public IntrinsicInst {
		140	public:
		141	/// \name Casting methods
		142	/// @{
		143	static bool classof(const IntrinsicInst *I) {
		144	return isLifetimeIntrinsic(I->getIntrinsicID());
		145	}
		146	static bool classof(const Value *V) {
		147	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		148	}
		149	/// @}
		150	};
		151
		152	/// Check if \p ID corresponds to a debug info intrinsic.
		153	static inline bool isDbgInfoIntrinsic(Intrinsic::ID ID) {
		154	switch (ID) {
		155	case Intrinsic::dbg_declare:
		156	case Intrinsic::dbg_value:
		157	case Intrinsic::dbg_addr:
		158	case Intrinsic::dbg_label:
		159	case Intrinsic::dbg_assign:
		160	return true;
		161	default:
		162	return false;
		163	}
		164	}
		165
		166	/// This is the common base class for debug info intrinsics.
		167	class DbgInfoIntrinsic : public IntrinsicInst {
		168	public:
		169	/// \name Casting methods
		170	/// @{
		171	static bool classof(const IntrinsicInst *I) {
		172	return isDbgInfoIntrinsic(I->getIntrinsicID());
		173	}
		174	static bool classof(const Value *V) {
		175	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		176	}
		177	/// @}
		178	};
		179
		180	/// This is the common base class for debug info intrinsics for variables.
		181	class DbgVariableIntrinsic : public DbgInfoIntrinsic {
		182	public:
		183	// Iterator for ValueAsMetadata that internally uses direct pointer iteration
		184	// over either a ValueAsMetadata* or a ValueAsMetadata**, dereferencing to the
		185	// ValueAsMetadata .
		186	class location_op_iterator
		187	: public iterator_facade_base<location_op_iterator,
		188	std::bidirectional_iterator_tag, Value *> {
		189	PointerUnion<ValueAsMetadata , ValueAsMetadata *> I;
		190
		191	public:
		192	location_op_iterator(ValueAsMetadata *SingleIter) : I(SingleIter) {}
		193	location_op_iterator(ValueAsMetadata **MultiIter) : I(MultiIter) {}
		194
		195	location_op_iterator(const location_op_iterator &R) : I(R.I) {}
		196	location_op_iterator &operator=(const location_op_iterator &R) {
		197	I = R.I;
		198	return *this;
		199	}
		200	bool operator==(const location_op_iterator &RHS) const {
		201	return I == RHS.I;
		202	}
		203	const Value operator() const {
		204	ValueAsMetadata VAM = I.is<ValueAsMetadata >()
		205	? I.get<ValueAsMetadata *>()
		206	: I.get<ValueAsMetadata *>();
		207	return VAM->getValue();
		208	};
		209	Value operator() {
		210	ValueAsMetadata VAM = I.is<ValueAsMetadata >()
		211	? I.get<ValueAsMetadata *>()
		212	: I.get<ValueAsMetadata *>();
		213	return VAM->getValue();
		214	}
		215	location_op_iterator &operator++() {
		216	if (I.is<ValueAsMetadata *>())
		217	I = I.get<ValueAsMetadata *>() + 1;
		218	else
		219	I = I.get<ValueAsMetadata **>() + 1;
		220	return *this;
		221	}
		222	location_op_iterator &operator--() {
		223	if (I.is<ValueAsMetadata *>())
		224	I = I.get<ValueAsMetadata *>() - 1;
		225	else
		226	I = I.get<ValueAsMetadata **>() - 1;
		227	return *this;
		228	}
		229	};
		230
		231	/// Get the locations corresponding to the variable referenced by the debug
		232	/// info intrinsic. Depending on the intrinsic, this could be the
		233	/// variable's value or its address.
		234	iterator_range<location_op_iterator> location_ops() const;
		235
		236	Value *getVariableLocationOp(unsigned OpIdx) const;
		237
		238	void replaceVariableLocationOp(Value OldValue, Value NewValue);
		239	void replaceVariableLocationOp(unsigned OpIdx, Value *NewValue);
		240	/// Adding a new location operand will always result in this intrinsic using
		241	/// an ArgList, and must always be accompanied by a new expression that uses
		242	/// the new operand.
		243	void addVariableLocationOps(ArrayRef<Value *> NewValues,
		244	DIExpression *NewExpr);
		245
		246	void setVariable(DILocalVariable *NewVar) {
		247	setArgOperand(1, MetadataAsValue::get(NewVar->getContext(), NewVar));
		248	}
		249
		250	void setExpression(DIExpression *NewExpr) {
		251	setArgOperand(2, MetadataAsValue::get(NewExpr->getContext(), NewExpr));
		252	}
		253
		254	unsigned getNumVariableLocationOps() const {
		255	if (hasArgList())
		256	return cast<DIArgList>(getRawLocation())->getArgs().size();
		257	return 1;
		258	}
		259
		260	bool hasArgList() const { return isa<DIArgList>(getRawLocation()); }
		261
		262	/// Does this describe the address of a local variable. True for dbg.addr and
		263	/// dbg.declare, but not dbg.value, which describes its value, or dbg.assign,
		264	/// which describes a combination of the variable's value and address.
		265	bool isAddressOfVariable() const {
		266	return getIntrinsicID() != Intrinsic::dbg_value &&
		267	getIntrinsicID() != Intrinsic::dbg_assign;
		268	}
		269
		270	void setKillLocation() {
		271	// TODO: When/if we remove duplicate values from DIArgLists, we don't need
		272	// this set anymore.
		273	SmallPtrSet<Value *, 4> RemovedValues;
		274	for (Value *OldValue : location_ops()) {
		275	if (!RemovedValues.insert(OldValue).second)
		276	continue;
		277	Value *Poison = PoisonValue::get(OldValue->getType());
		278	replaceVariableLocationOp(OldValue, Poison);
		279	}
		280	}
		281
		282	bool isKillLocation() const {
		283	return (getNumVariableLocationOps() == 0 &&
		284	!getExpression()->isComplex()) \|\|
		285	any_of(location_ops(), [](Value *V) { return isa<UndefValue>(V); });
		286	}
		287
		288	DILocalVariable *getVariable() const {
		289	return cast<DILocalVariable>(getRawVariable());
		290	}
		291
		292	DIExpression *getExpression() const {
		293	return cast<DIExpression>(getRawExpression());
		294	}
		295
		296	Metadata *getRawLocation() const {
		297	return cast<MetadataAsValue>(getArgOperand(0))->getMetadata();
		298	}
		299
		300	Metadata *getRawVariable() const {
		301	return cast<MetadataAsValue>(getArgOperand(1))->getMetadata();
		302	}
		303
		304	Metadata *getRawExpression() const {
		305	return cast<MetadataAsValue>(getArgOperand(2))->getMetadata();
		306	}
		307
		308	/// Use of this should generally be avoided; instead,
		309	/// replaceVariableLocationOp and addVariableLocationOps should be used where
		310	/// possible to avoid creating invalid state.
		311	void setRawLocation(Metadata *Location) {
		312	return setArgOperand(0, MetadataAsValue::get(getContext(), Location));
		313	}
		314
		315	/// Get the size (in bits) of the variable, or fragment of the variable that
		316	/// is described.
		317	std::optional<uint64_t> getFragmentSizeInBits() const;
		318
		319	/// Get the FragmentInfo for the variable.
		320	std::optional<DIExpression::FragmentInfo> getFragment() const {
		321	return getExpression()->getFragmentInfo();
		322	}
		323
		324	/// \name Casting methods
		325	/// @{
		326	static bool classof(const IntrinsicInst *I) {
		327	switch (I->getIntrinsicID()) {
		328	case Intrinsic::dbg_declare:
		329	case Intrinsic::dbg_value:
		330	case Intrinsic::dbg_addr:
		331	case Intrinsic::dbg_assign:
		332	return true;
		333	default:
		334	return false;
		335	}
		336	}
		337	static bool classof(const Value *V) {
		338	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		339	}
		340	/// @}
		341	protected:
		342	void setArgOperand(unsigned i, Value *v) {
		343	DbgInfoIntrinsic::setArgOperand(i, v);
		344	}
		345	void setOperand(unsigned i, Value *v) { DbgInfoIntrinsic::setOperand(i, v); }
		346	};
		347
		348	/// This represents the llvm.dbg.declare instruction.
		349	class DbgDeclareInst : public DbgVariableIntrinsic {
		350	public:
		351	Value *getAddress() const {
		352	assert(getNumVariableLocationOps() == 1 &&
		353	"dbg.declare must have exactly 1 location operand.");
		354	return getVariableLocationOp(0);
		355	}
		356
		357	/// \name Casting methods
		358	/// @{
		359	static bool classof(const IntrinsicInst *I) {
		360	return I->getIntrinsicID() == Intrinsic::dbg_declare;
		361	}
		362	static bool classof(const Value *V) {
		363	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		364	}
		365	/// @}
		366	};
		367
		368	/// This represents the llvm.dbg.addr instruction.
		369	class DbgAddrIntrinsic : public DbgVariableIntrinsic {
		370	public:
		371	Value *getAddress() const {
		372	assert(getNumVariableLocationOps() == 1 &&
		373	"dbg.addr must have exactly 1 location operand.");
		374	return getVariableLocationOp(0);
		375	}
		376
		377	/// \name Casting methods
		378	/// @{
		379	static bool classof(const IntrinsicInst *I) {
		380	return I->getIntrinsicID() == Intrinsic::dbg_addr;
		381	}
		382	static bool classof(const Value *V) {
		383	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		384	}
		385	};
		386
		387	/// This represents the llvm.dbg.value instruction.
		388	class DbgValueInst : public DbgVariableIntrinsic {
		389	public:
		390	// The default argument should only be used in ISel, and the default option
		391	// should be removed once ISel support for multiple location ops is complete.
		392	Value *getValue(unsigned OpIdx = 0) const {
		393	return getVariableLocationOp(OpIdx);
		394	}
		395	iterator_range<location_op_iterator> getValues() const {
		396	return location_ops();
		397	}
		398
		399	/// \name Casting methods
		400	/// @{
		401	static bool classof(const IntrinsicInst *I) {
		402	return I->getIntrinsicID() == Intrinsic::dbg_value \|\|
		403	I->getIntrinsicID() == Intrinsic::dbg_assign;
		404	}
		405	static bool classof(const Value *V) {
		406	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		407	}
		408	/// @}
		409	};
		410
		411	/// This represents the llvm.dbg.assign instruction.
		412	class DbgAssignIntrinsic : public DbgValueInst {
		413	enum Operands {
		414	OpValue,
		415	OpVar,
		416	OpExpr,
		417	OpAssignID,
		418	OpAddress,
		419	OpAddressExpr,
		420	};
		421
		422	public:
		423	Value *getAddress() const;
		424	Metadata *getRawAddress() const {
		425	return cast<MetadataAsValue>(getArgOperand(OpAddress))->getMetadata();
		426	}
		427	Metadata *getRawAssignID() const {
		428	return cast<MetadataAsValue>(getArgOperand(OpAssignID))->getMetadata();
		429	}
		430	DIAssignID *getAssignID() const { return cast<DIAssignID>(getRawAssignID()); }
		431	Metadata *getRawAddressExpression() const {
		432	return cast<MetadataAsValue>(getArgOperand(OpAddressExpr))->getMetadata();
		433	}
		434	DIExpression *getAddressExpression() const {
		435	return cast<DIExpression>(getRawAddressExpression());
		436	}
		437	void setAddressExpression(DIExpression *NewExpr) {
		438	setArgOperand(OpAddressExpr,
		439	MetadataAsValue::get(NewExpr->getContext(), NewExpr));
		440	}
		441	void setAssignId(DIAssignID *New);
		442	void setAddress(Value *V);
		443	/// Kill the address component.
		444	void setKillAddress();
		445	/// Check whether this kills the address component. This doesn't take into
		446	/// account the position of the intrinsic, therefore a returned value of false
		447	/// does not guarentee the address is a valid location for the variable at the
		448	/// intrinsic's position in IR.
		449	bool isKillAddress() const;
		450	void setValue(Value *V);
		451	/// \name Casting methods
		452	/// @{
		453	static bool classof(const IntrinsicInst *I) {
		454	return I->getIntrinsicID() == Intrinsic::dbg_assign;
		455	}
		456	static bool classof(const Value *V) {
		457	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		458	}
		459	/// @}
		460	};
		461
		462	/// This represents the llvm.dbg.label instruction.
		463	class DbgLabelInst : public DbgInfoIntrinsic {
		464	public:
		465	DILabel *getLabel() const { return cast<DILabel>(getRawLabel()); }
		466
		467	Metadata *getRawLabel() const {
		468	return cast<MetadataAsValue>(getArgOperand(0))->getMetadata();
		469	}
		470
		471	/// Methods for support type inquiry through isa, cast, and dyn_cast:
		472	/// @{
		473	static bool classof(const IntrinsicInst *I) {
		474	return I->getIntrinsicID() == Intrinsic::dbg_label;
		475	}
		476	static bool classof(const Value *V) {
		477	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		478	}
		479	/// @}
		480	};
		481
		482	/// This is the common base class for vector predication intrinsics.
		483	class VPIntrinsic : public IntrinsicInst {
		484	public:
		485	/// \brief Declares a llvm.vp.* intrinsic in \p M that matches the parameters
		486	/// \p Params. Additionally, the load and gather intrinsics require
		487	/// \p ReturnType to be specified.
		488	static Function getDeclarationForParams(Module M, Intrinsic::ID,
		489	Type *ReturnType,
		490	ArrayRef<Value *> Params);
		491
		492	static std::optional<unsigned> getMaskParamPos(Intrinsic::ID IntrinsicID);
		493	static std::optional<unsigned> getVectorLengthParamPos(
		494	Intrinsic::ID IntrinsicID);
		495
		496	/// The llvm.vp.* intrinsics for this instruction Opcode
		497	static Intrinsic::ID getForOpcode(unsigned OC);
		498
		499	// Whether \p ID is a VP intrinsic ID.
		500	static bool isVPIntrinsic(Intrinsic::ID);
		501
		502	/// \return The mask parameter or nullptr.
		503	Value *getMaskParam() const;
		504	void setMaskParam(Value *);
		505
		506	/// \return The vector length parameter or nullptr.
		507	Value *getVectorLengthParam() const;
		508	void setVectorLengthParam(Value *);
		509
		510	/// \return Whether the vector length param can be ignored.
		511	bool canIgnoreVectorLengthParam() const;
		512
		513	/// \return The static element count (vector number of elements) the vector
		514	/// length parameter applies to.
		515	ElementCount getStaticVectorLength() const;
		516
		517	/// \return The alignment of the pointer used by this load/store/gather or
		518	/// scatter.
		519	MaybeAlign getPointerAlignment() const;
		520	// MaybeAlign setPointerAlignment(Align NewAlign); // TODO
		521
		522	/// \return The pointer operand of this load,store, gather or scatter.
		523	Value *getMemoryPointerParam() const;
		524	static std::optional<unsigned> getMemoryPointerParamPos(Intrinsic::ID);
		525
		526	/// \return The data (payload) operand of this store or scatter.
		527	Value *getMemoryDataParam() const;
		528	static std::optional<unsigned> getMemoryDataParamPos(Intrinsic::ID);
		529
		530	// Methods for support type inquiry through isa, cast, and dyn_cast:
		531	static bool classof(const IntrinsicInst *I) {
		532	return isVPIntrinsic(I->getIntrinsicID());
		533	}
		534	static bool classof(const Value *V) {
		535	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		536	}
		537
		538	// Equivalent non-predicated opcode
		539	std::optional<unsigned> getFunctionalOpcode() const {
		540	return getFunctionalOpcodeForVP(getIntrinsicID());
		541	}
		542
		543	// Equivalent non-predicated opcode
		544	static std::optional<unsigned> getFunctionalOpcodeForVP(Intrinsic::ID ID);
		545	};
		546
		547	/// This represents vector predication reduction intrinsics.
		548	class VPReductionIntrinsic : public VPIntrinsic {
		549	public:
		550	static bool isVPReduction(Intrinsic::ID ID);
		551
		552	unsigned getStartParamPos() const;
		553	unsigned getVectorParamPos() const;
		554
		555	static std::optional<unsigned> getStartParamPos(Intrinsic::ID ID);
		556	static std::optional<unsigned> getVectorParamPos(Intrinsic::ID ID);
		557
		558	/// Methods for support type inquiry through isa, cast, and dyn_cast:
		559	/// @{
		560	static bool classof(const IntrinsicInst *I) {
		561	return VPReductionIntrinsic::isVPReduction(I->getIntrinsicID());
		562	}
		563	static bool classof(const Value *V) {
		564	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		565	}
		566	/// @}
		567	};
		568
		569	class VPCastIntrinsic : public VPIntrinsic {
		570	public:
		571	static bool isVPCast(Intrinsic::ID ID);
		572
		573	/// Methods for support type inquiry through isa, cast, and dyn_cast:
		574	/// @{
		575	static bool classof(const IntrinsicInst *I) {
		576	return VPCastIntrinsic::isVPCast(I->getIntrinsicID());
		577	}
		578	static bool classof(const Value *V) {
		579	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		580	}
		581	/// @}
		582	};
		583
		584	class VPCmpIntrinsic : public VPIntrinsic {
		585	public:
		586	static bool isVPCmp(Intrinsic::ID ID);
		587
		588	CmpInst::Predicate getPredicate() const;
		589
		590	/// Methods for support type inquiry through isa, cast, and dyn_cast:
		591	/// @{
		592	static bool classof(const IntrinsicInst *I) {
		593	return VPCmpIntrinsic::isVPCmp(I->getIntrinsicID());
		594	}
		595	static bool classof(const Value *V) {
		596	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		597	}
		598	/// @}
		599	};
		600
		601	/// This is the common base class for constrained floating point intrinsics.
		602	class ConstrainedFPIntrinsic : public IntrinsicInst {
		603	public:
		604	bool isUnaryOp() const;
		605	bool isTernaryOp() const;
		606	std::optional<RoundingMode> getRoundingMode() const;
		607	std::optional<fp::ExceptionBehavior> getExceptionBehavior() const;
		608	bool isDefaultFPEnvironment() const;
		609
		610	// Methods for support type inquiry through isa, cast, and dyn_cast:
		611	static bool classof(const IntrinsicInst *I);
		612	static bool classof(const Value *V) {
		613	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		614	}
		615	};
		616
		617	/// Constrained floating point compare intrinsics.
		618	class ConstrainedFPCmpIntrinsic : public ConstrainedFPIntrinsic {
		619	public:
		620	FCmpInst::Predicate getPredicate() const;
		621	bool isSignaling() const {
		622	return getIntrinsicID() == Intrinsic::experimental_constrained_fcmps;
		623	}
		624
		625	// Methods for support type inquiry through isa, cast, and dyn_cast:
		626	static bool classof(const IntrinsicInst *I) {
		627	switch (I->getIntrinsicID()) {
		628	case Intrinsic::experimental_constrained_fcmp:
		629	case Intrinsic::experimental_constrained_fcmps:
		630	return true;
		631	default:
		632	return false;
		633	}
		634	}
		635	static bool classof(const Value *V) {
		636	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		637	}
		638	};
		639
		640	/// This class represents min/max intrinsics.
		641	class MinMaxIntrinsic : public IntrinsicInst {
		642	public:
		643	static bool classof(const IntrinsicInst *I) {
		644	switch (I->getIntrinsicID()) {
		645	case Intrinsic::umin:
		646	case Intrinsic::umax:
		647	case Intrinsic::smin:
		648	case Intrinsic::smax:
		649	return true;
		650	default:
		651	return false;
		652	}
		653	}
		654	static bool classof(const Value *V) {
		655	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		656	}
		657
		658	Value getLHS() const { return const_cast<Value >(getArgOperand(0)); }
		659	Value getRHS() const { return const_cast<Value >(getArgOperand(1)); }
		660
		661	/// Returns the comparison predicate underlying the intrinsic.
		662	static ICmpInst::Predicate getPredicate(Intrinsic::ID ID) {
		663	switch (ID) {
		664	case Intrinsic::umin:
		665	return ICmpInst::Predicate::ICMP_ULT;
		666	case Intrinsic::umax:
		667	return ICmpInst::Predicate::ICMP_UGT;
		668	case Intrinsic::smin:
		669	return ICmpInst::Predicate::ICMP_SLT;
		670	case Intrinsic::smax:
		671	return ICmpInst::Predicate::ICMP_SGT;
		672	default:
		673	llvm_unreachable("Invalid intrinsic");
		674	}
		675	}
		676
		677	/// Returns the comparison predicate underlying the intrinsic.
		678	ICmpInst::Predicate getPredicate() const {
		679	return getPredicate(getIntrinsicID());
		680	}
		681
		682	/// Whether the intrinsic is signed or unsigned.
		683	static bool isSigned(Intrinsic::ID ID) {
		684	return ICmpInst::isSigned(getPredicate(ID));
		685	};
		686
		687	/// Whether the intrinsic is signed or unsigned.
		688	bool isSigned() const { return isSigned(getIntrinsicID()); };
		689
		690	/// Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values,
		691	/// so there is a certain threshold value, upon reaching which,
		692	/// their value can no longer change. Return said threshold.
		693	static APInt getSaturationPoint(Intrinsic::ID ID, unsigned numBits) {
		694	switch (ID) {
		695	case Intrinsic::umin:
		696	return APInt::getMinValue(numBits);
		697	case Intrinsic::umax:
		698	return APInt::getMaxValue(numBits);
		699	case Intrinsic::smin:
		700	return APInt::getSignedMinValue(numBits);
		701	case Intrinsic::smax:
		702	return APInt::getSignedMaxValue(numBits);
		703	default:
		704	llvm_unreachable("Invalid intrinsic");
		705	}
		706	}
		707
		708	/// Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values,
		709	/// so there is a certain threshold value, upon reaching which,
		710	/// their value can no longer change. Return said threshold.
		711	APInt getSaturationPoint(unsigned numBits) const {
		712	return getSaturationPoint(getIntrinsicID(), numBits);
		713	}
		714
		715	/// Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values,
		716	/// so there is a certain threshold value, upon reaching which,
		717	/// their value can no longer change. Return said threshold.
		718	static Constant getSaturationPoint(Intrinsic::ID ID, Type Ty) {
		719	return Constant::getIntegerValue(
		720	Ty, getSaturationPoint(ID, Ty->getScalarSizeInBits()));
		721	}
		722
		723	/// Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values,
		724	/// so there is a certain threshold value, upon reaching which,
		725	/// their value can no longer change. Return said threshold.
		726	Constant getSaturationPoint(Type Ty) const {
		727	return getSaturationPoint(getIntrinsicID(), Ty);
		728	}
		729	};
		730
		731	/// This class represents an intrinsic that is based on a binary operation.
		732	/// This includes op.with.overflow and saturating add/sub intrinsics.
		733	class BinaryOpIntrinsic : public IntrinsicInst {
		734	public:
		735	static bool classof(const IntrinsicInst *I) {
		736	switch (I->getIntrinsicID()) {
		737	case Intrinsic::uadd_with_overflow:
		738	case Intrinsic::sadd_with_overflow:
		739	case Intrinsic::usub_with_overflow:
		740	case Intrinsic::ssub_with_overflow:
		741	case Intrinsic::umul_with_overflow:
		742	case Intrinsic::smul_with_overflow:
		743	case Intrinsic::uadd_sat:
		744	case Intrinsic::sadd_sat:
		745	case Intrinsic::usub_sat:
		746	case Intrinsic::ssub_sat:
		747	return true;
		748	default:
		749	return false;
		750	}
		751	}
		752	static bool classof(const Value *V) {
		753	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		754	}
		755
		756	Value getLHS() const { return const_cast<Value >(getArgOperand(0)); }
		757	Value getRHS() const { return const_cast<Value >(getArgOperand(1)); }
		758
		759	/// Returns the binary operation underlying the intrinsic.
		760	Instruction::BinaryOps getBinaryOp() const;
		761
		762	/// Whether the intrinsic is signed or unsigned.
		763	bool isSigned() const;
		764
		765	/// Returns one of OBO::NoSignedWrap or OBO::NoUnsignedWrap.
		766	unsigned getNoWrapKind() const;
		767	};
		768
		769	/// Represents an op.with.overflow intrinsic.
		770	class WithOverflowInst : public BinaryOpIntrinsic {
		771	public:
		772	static bool classof(const IntrinsicInst *I) {
		773	switch (I->getIntrinsicID()) {
		774	case Intrinsic::uadd_with_overflow:
		775	case Intrinsic::sadd_with_overflow:
		776	case Intrinsic::usub_with_overflow:
		777	case Intrinsic::ssub_with_overflow:
		778	case Intrinsic::umul_with_overflow:
		779	case Intrinsic::smul_with_overflow:
		780	return true;
		781	default:
		782	return false;
		783	}
		784	}
		785	static bool classof(const Value *V) {
		786	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		787	}
		788	};
		789
		790	/// Represents a saturating add/sub intrinsic.
		791	class SaturatingInst : public BinaryOpIntrinsic {
		792	public:
		793	static bool classof(const IntrinsicInst *I) {
		794	switch (I->getIntrinsicID()) {
		795	case Intrinsic::uadd_sat:
		796	case Intrinsic::sadd_sat:
		797	case Intrinsic::usub_sat:
		798	case Intrinsic::ssub_sat:
		799	return true;
		800	default:
		801	return false;
		802	}
		803	}
		804	static bool classof(const Value *V) {
		805	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		806	}
		807	};
		808
		809	/// Common base class for all memory intrinsics. Simply provides
		810	/// common methods.
		811	/// Written as CRTP to avoid a common base class amongst the
		812	/// three atomicity hierarchies.
		813	template <typename Derived> class MemIntrinsicBase : public IntrinsicInst {
		814	private:
		815	enum { ARG_DEST = 0, ARG_LENGTH = 2 };
		816
		817	public:
		818	Value *getRawDest() const {
		819	return const_cast<Value *>(getArgOperand(ARG_DEST));
		820	}
		821	const Use &getRawDestUse() const { return getArgOperandUse(ARG_DEST); }
		822	Use &getRawDestUse() { return getArgOperandUse(ARG_DEST); }
		823
		824	Value *getLength() const {
		825	return const_cast<Value *>(getArgOperand(ARG_LENGTH));
		826	}
		827	const Use &getLengthUse() const { return getArgOperandUse(ARG_LENGTH); }
		828	Use &getLengthUse() { return getArgOperandUse(ARG_LENGTH); }
		829
		830	/// This is just like getRawDest, but it strips off any cast
		831	/// instructions (including addrspacecast) that feed it, giving the
		832	/// original input. The returned value is guaranteed to be a pointer.
		833	Value *getDest() const { return getRawDest()->stripPointerCasts(); }
		834
		835	unsigned getDestAddressSpace() const {
		836	return cast<PointerType>(getRawDest()->getType())->getAddressSpace();
		837	}
		838
		839	/// FIXME: Remove this function once transition to Align is over.
		840	/// Use getDestAlign() instead.
		841	LLVM_DEPRECATED("Use getDestAlign() instead", "getDestAlign")
		842	unsigned getDestAlignment() const {
		843	if (auto MA = getParamAlign(ARG_DEST))
		844	return MA->value();
		845	return 0;
		846	}
		847	MaybeAlign getDestAlign() const { return getParamAlign(ARG_DEST); }
		848
		849	/// Set the specified arguments of the instruction.
		850	void setDest(Value *Ptr) {
		851	assert(getRawDest()->getType() == Ptr->getType() &&
		852	"setDest called with pointer of wrong type!");
		853	setArgOperand(ARG_DEST, Ptr);
		854	}
		855
		856	void setDestAlignment(MaybeAlign Alignment) {
		857	removeParamAttr(ARG_DEST, Attribute::Alignment);
		858	if (Alignment)
		859	addParamAttr(ARG_DEST,
		860	Attribute::getWithAlignment(getContext(), *Alignment));
		861	}
		862	void setDestAlignment(Align Alignment) {
		863	removeParamAttr(ARG_DEST, Attribute::Alignment);
		864	addParamAttr(ARG_DEST,
		865	Attribute::getWithAlignment(getContext(), Alignment));
		866	}
		867
		868	void setLength(Value *L) {
		869	assert(getLength()->getType() == L->getType() &&
		870	"setLength called with value of wrong type!");
		871	setArgOperand(ARG_LENGTH, L);
		872	}
		873	};
		874
		875	/// Common base class for all memory transfer intrinsics. Simply provides
		876	/// common methods.
		877	template <class BaseCL> class MemTransferBase : public BaseCL {
		878	private:
		879	enum { ARG_SOURCE = 1 };
		880
		881	public:
		882	/// Return the arguments to the instruction.
		883	Value *getRawSource() const {
		884	return const_cast<Value *>(BaseCL::getArgOperand(ARG_SOURCE));
		885	}
		886	const Use &getRawSourceUse() const {
		887	return BaseCL::getArgOperandUse(ARG_SOURCE);
		888	}
		889	Use &getRawSourceUse() { return BaseCL::getArgOperandUse(ARG_SOURCE); }
		890
		891	/// This is just like getRawSource, but it strips off any cast
		892	/// instructions that feed it, giving the original input. The returned
		893	/// value is guaranteed to be a pointer.
		894	Value *getSource() const { return getRawSource()->stripPointerCasts(); }
		895
		896	unsigned getSourceAddressSpace() const {
		897	return cast<PointerType>(getRawSource()->getType())->getAddressSpace();
		898	}
		899
		900	/// FIXME: Remove this function once transition to Align is over.
		901	/// Use getSourceAlign() instead.
		902	LLVM_DEPRECATED("Use getSourceAlign() instead", "getSourceAlign")
		903	unsigned getSourceAlignment() const {
		904	if (auto MA = BaseCL::getParamAlign(ARG_SOURCE))
		905	return MA->value();
		906	return 0;
		907	}
		908
		909	MaybeAlign getSourceAlign() const {
		910	return BaseCL::getParamAlign(ARG_SOURCE);
		911	}
		912
		913	void setSource(Value *Ptr) {
		914	assert(getRawSource()->getType() == Ptr->getType() &&
		915	"setSource called with pointer of wrong type!");
		916	BaseCL::setArgOperand(ARG_SOURCE, Ptr);
		917	}
		918
		919	void setSourceAlignment(MaybeAlign Alignment) {
		920	BaseCL::removeParamAttr(ARG_SOURCE, Attribute::Alignment);
		921	if (Alignment)
		922	BaseCL::addParamAttr(ARG_SOURCE, Attribute::getWithAlignment(
		923	BaseCL::getContext(), *Alignment));
		924	}
		925
		926	void setSourceAlignment(Align Alignment) {
		927	BaseCL::removeParamAttr(ARG_SOURCE, Attribute::Alignment);
		928	BaseCL::addParamAttr(ARG_SOURCE, Attribute::getWithAlignment(
		929	BaseCL::getContext(), Alignment));
		930	}
		931	};
		932
		933	/// Common base class for all memset intrinsics. Simply provides
		934	/// common methods.
		935	template <class BaseCL> class MemSetBase : public BaseCL {
		936	private:
		937	enum { ARG_VALUE = 1 };
		938
		939	public:
		940	Value *getValue() const {
		941	return const_cast<Value *>(BaseCL::getArgOperand(ARG_VALUE));
		942	}
		943	const Use &getValueUse() const { return BaseCL::getArgOperandUse(ARG_VALUE); }
		944	Use &getValueUse() { return BaseCL::getArgOperandUse(ARG_VALUE); }
		945
		946	void setValue(Value *Val) {
		947	assert(getValue()->getType() == Val->getType() &&
		948	"setValue called with value of wrong type!");
		949	BaseCL::setArgOperand(ARG_VALUE, Val);
		950	}
		951	};
		952
		953	// The common base class for the atomic memset/memmove/memcpy intrinsics
		954	// i.e. llvm.element.unordered.atomic.memset/memcpy/memmove
		955	class AtomicMemIntrinsic : public MemIntrinsicBase<AtomicMemIntrinsic> {
		956	private:
		957	enum { ARG_ELEMENTSIZE = 3 };
		958
		959	public:
		960	Value *getRawElementSizeInBytes() const {
		961	return const_cast<Value *>(getArgOperand(ARG_ELEMENTSIZE));
		962	}
		963
		964	ConstantInt *getElementSizeInBytesCst() const {
		965	return cast<ConstantInt>(getRawElementSizeInBytes());
		966	}
		967
		968	uint32_t getElementSizeInBytes() const {
		969	return getElementSizeInBytesCst()->getZExtValue();
		970	}
		971
		972	void setElementSizeInBytes(Constant *V) {
		973	assert(V->getType() == Type::getInt8Ty(getContext()) &&
		974	"setElementSizeInBytes called with value of wrong type!");
		975	setArgOperand(ARG_ELEMENTSIZE, V);
		976	}
		977
		978	static bool classof(const IntrinsicInst *I) {
		979	switch (I->getIntrinsicID()) {
		980	case Intrinsic::memcpy_element_unordered_atomic:
		981	case Intrinsic::memmove_element_unordered_atomic:
		982	case Intrinsic::memset_element_unordered_atomic:
		983	return true;
		984	default:
		985	return false;
		986	}
		987	}
		988	static bool classof(const Value *V) {
		989	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		990	}
		991	};
		992
		993	/// This class represents atomic memset intrinsic
		994	// i.e. llvm.element.unordered.atomic.memset
		995	class AtomicMemSetInst : public MemSetBase<AtomicMemIntrinsic> {
		996	public:
		997	static bool classof(const IntrinsicInst *I) {
		998	return I->getIntrinsicID() == Intrinsic::memset_element_unordered_atomic;
		999	}
		1000	static bool classof(const Value *V) {
		1001	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1002	}
		1003	};
		1004
		1005	// This class wraps the atomic memcpy/memmove intrinsics
		1006	// i.e. llvm.element.unordered.atomic.memcpy/memmove
		1007	class AtomicMemTransferInst : public MemTransferBase<AtomicMemIntrinsic> {
		1008	public:
		1009	static bool classof(const IntrinsicInst *I) {
		1010	switch (I->getIntrinsicID()) {
		1011	case Intrinsic::memcpy_element_unordered_atomic:
		1012	case Intrinsic::memmove_element_unordered_atomic:
		1013	return true;
		1014	default:
		1015	return false;
		1016	}
		1017	}
		1018	static bool classof(const Value *V) {
		1019	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1020	}
		1021	};
		1022
		1023	/// This class represents the atomic memcpy intrinsic
		1024	/// i.e. llvm.element.unordered.atomic.memcpy
		1025	class AtomicMemCpyInst : public AtomicMemTransferInst {
		1026	public:
		1027	static bool classof(const IntrinsicInst *I) {
		1028	return I->getIntrinsicID() == Intrinsic::memcpy_element_unordered_atomic;
		1029	}
		1030	static bool classof(const Value *V) {
		1031	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1032	}
		1033	};
		1034
		1035	/// This class represents the atomic memmove intrinsic
		1036	/// i.e. llvm.element.unordered.atomic.memmove
		1037	class AtomicMemMoveInst : public AtomicMemTransferInst {
		1038	public:
		1039	static bool classof(const IntrinsicInst *I) {
		1040	return I->getIntrinsicID() == Intrinsic::memmove_element_unordered_atomic;
		1041	}
		1042	static bool classof(const Value *V) {
		1043	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1044	}
		1045	};
		1046
		1047	/// This is the common base class for memset/memcpy/memmove.
		1048	class MemIntrinsic : public MemIntrinsicBase<MemIntrinsic> {
		1049	private:
		1050	enum { ARG_VOLATILE = 3 };
		1051
		1052	public:
		1053	ConstantInt *getVolatileCst() const {
		1054	return cast<ConstantInt>(const_cast<Value *>(getArgOperand(ARG_VOLATILE)));
		1055	}
		1056
		1057	bool isVolatile() const { return !getVolatileCst()->isZero(); }
		1058
		1059	void setVolatile(Constant *V) { setArgOperand(ARG_VOLATILE, V); }
		1060
		1061	// Methods for support type inquiry through isa, cast, and dyn_cast:
		1062	static bool classof(const IntrinsicInst *I) {
		1063	switch (I->getIntrinsicID()) {
		1064	case Intrinsic::memcpy:
		1065	case Intrinsic::memmove:
		1066	case Intrinsic::memset:
		1067	case Intrinsic::memset_inline:
		1068	case Intrinsic::memcpy_inline:
		1069	return true;
		1070	default:
		1071	return false;
		1072	}
		1073	}
		1074	static bool classof(const Value *V) {
		1075	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1076	}
		1077	};
		1078
		1079	/// This class wraps the llvm.memset and llvm.memset.inline intrinsics.
		1080	class MemSetInst : public MemSetBase<MemIntrinsic> {
		1081	public:
		1082	// Methods for support type inquiry through isa, cast, and dyn_cast:
		1083	static bool classof(const IntrinsicInst *I) {
		1084	switch (I->getIntrinsicID()) {
		1085	case Intrinsic::memset:
		1086	case Intrinsic::memset_inline:
		1087	return true;
		1088	default:
		1089	return false;
		1090	}
		1091	}
		1092	static bool classof(const Value *V) {
		1093	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1094	}
		1095	};
		1096
		1097	/// This class wraps the llvm.memset.inline intrinsic.
		1098	class MemSetInlineInst : public MemSetInst {
		1099	public:
		1100	ConstantInt *getLength() const {
		1101	return cast<ConstantInt>(MemSetInst::getLength());
		1102	}
		1103	// Methods for support type inquiry through isa, cast, and dyn_cast:
		1104	static bool classof(const IntrinsicInst *I) {
		1105	return I->getIntrinsicID() == Intrinsic::memset_inline;
		1106	}
		1107	static bool classof(const Value *V) {
		1108	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1109	}
		1110	};
		1111
		1112	/// This class wraps the llvm.memcpy/memmove intrinsics.
		1113	class MemTransferInst : public MemTransferBase<MemIntrinsic> {
		1114	public:
		1115	// Methods for support type inquiry through isa, cast, and dyn_cast:
		1116	static bool classof(const IntrinsicInst *I) {
		1117	switch (I->getIntrinsicID()) {
		1118	case Intrinsic::memcpy:
		1119	case Intrinsic::memmove:
		1120	case Intrinsic::memcpy_inline:
		1121	return true;
		1122	default:
		1123	return false;
		1124	}
		1125	}
		1126	static bool classof(const Value *V) {
		1127	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1128	}
		1129	};
		1130
		1131	/// This class wraps the llvm.memcpy intrinsic.
		1132	class MemCpyInst : public MemTransferInst {
		1133	public:
		1134	// Methods for support type inquiry through isa, cast, and dyn_cast:
		1135	static bool classof(const IntrinsicInst *I) {
		1136	return I->getIntrinsicID() == Intrinsic::memcpy \|\|
		1137	I->getIntrinsicID() == Intrinsic::memcpy_inline;
		1138	}
		1139	static bool classof(const Value *V) {
		1140	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1141	}
		1142	};
		1143
		1144	/// This class wraps the llvm.memmove intrinsic.
		1145	class MemMoveInst : public MemTransferInst {
		1146	public:
		1147	// Methods for support type inquiry through isa, cast, and dyn_cast:
		1148	static bool classof(const IntrinsicInst *I) {
		1149	return I->getIntrinsicID() == Intrinsic::memmove;
		1150	}
		1151	static bool classof(const Value *V) {
		1152	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1153	}
		1154	};
		1155
		1156	/// This class wraps the llvm.memcpy.inline intrinsic.
		1157	class MemCpyInlineInst : public MemCpyInst {
		1158	public:
		1159	ConstantInt *getLength() const {
		1160	return cast<ConstantInt>(MemCpyInst::getLength());
		1161	}
		1162	// Methods for support type inquiry through isa, cast, and dyn_cast:
		1163	static bool classof(const IntrinsicInst *I) {
		1164	return I->getIntrinsicID() == Intrinsic::memcpy_inline;
		1165	}
		1166	static bool classof(const Value *V) {
		1167	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1168	}
		1169	};
		1170
		1171	// The common base class for any memset/memmove/memcpy intrinsics;
		1172	// whether they be atomic or non-atomic.
		1173	// i.e. llvm.element.unordered.atomic.memset/memcpy/memmove
		1174	// and llvm.memset/memcpy/memmove
		1175	class AnyMemIntrinsic : public MemIntrinsicBase<AnyMemIntrinsic> {
		1176	public:
		1177	bool isVolatile() const {
		1178	// Only the non-atomic intrinsics can be volatile
		1179	if (auto *MI = dyn_cast<MemIntrinsic>(this))
		1180	return MI->isVolatile();
		1181	return false;
		1182	}
		1183
		1184	static bool classof(const IntrinsicInst *I) {
		1185	switch (I->getIntrinsicID()) {
		1186	case Intrinsic::memcpy:
		1187	case Intrinsic::memcpy_inline:
		1188	case Intrinsic::memmove:
		1189	case Intrinsic::memset:
		1190	case Intrinsic::memset_inline:
		1191	case Intrinsic::memcpy_element_unordered_atomic:
		1192	case Intrinsic::memmove_element_unordered_atomic:
		1193	case Intrinsic::memset_element_unordered_atomic:
		1194	return true;
		1195	default:
		1196	return false;
		1197	}
		1198	}
		1199	static bool classof(const Value *V) {
		1200	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1201	}
		1202	};
		1203
		1204	/// This class represents any memset intrinsic
		1205	// i.e. llvm.element.unordered.atomic.memset
		1206	// and llvm.memset
		1207	class AnyMemSetInst : public MemSetBase<AnyMemIntrinsic> {
		1208	public:
		1209	static bool classof(const IntrinsicInst *I) {
		1210	switch (I->getIntrinsicID()) {
		1211	case Intrinsic::memset:
		1212	case Intrinsic::memset_inline:
		1213	case Intrinsic::memset_element_unordered_atomic:
		1214	return true;
		1215	default:
		1216	return false;
		1217	}
		1218	}
		1219	static bool classof(const Value *V) {
		1220	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1221	}
		1222	};
		1223
		1224	// This class wraps any memcpy/memmove intrinsics
		1225	// i.e. llvm.element.unordered.atomic.memcpy/memmove
		1226	// and llvm.memcpy/memmove
		1227	class AnyMemTransferInst : public MemTransferBase<AnyMemIntrinsic> {
		1228	public:
		1229	static bool classof(const IntrinsicInst *I) {
		1230	switch (I->getIntrinsicID()) {
		1231	case Intrinsic::memcpy:
		1232	case Intrinsic::memcpy_inline:
		1233	case Intrinsic::memmove:
		1234	case Intrinsic::memcpy_element_unordered_atomic:
		1235	case Intrinsic::memmove_element_unordered_atomic:
		1236	return true;
		1237	default:
		1238	return false;
		1239	}
		1240	}
		1241	static bool classof(const Value *V) {
		1242	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1243	}
		1244	};
		1245
		1246	/// This class represents any memcpy intrinsic
		1247	/// i.e. llvm.element.unordered.atomic.memcpy
		1248	/// and llvm.memcpy
		1249	class AnyMemCpyInst : public AnyMemTransferInst {
		1250	public:
		1251	static bool classof(const IntrinsicInst *I) {
		1252	switch (I->getIntrinsicID()) {
		1253	case Intrinsic::memcpy:
		1254	case Intrinsic::memcpy_inline:
		1255	case Intrinsic::memcpy_element_unordered_atomic:
		1256	return true;
		1257	default:
		1258	return false;
		1259	}
		1260	}
		1261	static bool classof(const Value *V) {
		1262	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1263	}
		1264	};
		1265
		1266	/// This class represents any memmove intrinsic
		1267	/// i.e. llvm.element.unordered.atomic.memmove
		1268	/// and llvm.memmove
		1269	class AnyMemMoveInst : public AnyMemTransferInst {
		1270	public:
		1271	static bool classof(const IntrinsicInst *I) {
		1272	switch (I->getIntrinsicID()) {
		1273	case Intrinsic::memmove:
		1274	case Intrinsic::memmove_element_unordered_atomic:
		1275	return true;
		1276	default:
		1277	return false;
		1278	}
		1279	}
		1280	static bool classof(const Value *V) {
		1281	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1282	}
		1283	};
		1284
		1285	/// This represents the llvm.va_start intrinsic.
		1286	class VAStartInst : public IntrinsicInst {
		1287	public:
		1288	static bool classof(const IntrinsicInst *I) {
		1289	return I->getIntrinsicID() == Intrinsic::vastart;
		1290	}
		1291	static bool classof(const Value *V) {
		1292	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1293	}
		1294
		1295	Value getArgList() const { return const_cast<Value >(getArgOperand(0)); }
		1296	};
		1297
		1298	/// This represents the llvm.va_end intrinsic.
		1299	class VAEndInst : public IntrinsicInst {
		1300	public:
		1301	static bool classof(const IntrinsicInst *I) {
		1302	return I->getIntrinsicID() == Intrinsic::vaend;
		1303	}
		1304	static bool classof(const Value *V) {
		1305	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1306	}
		1307
		1308	Value getArgList() const { return const_cast<Value >(getArgOperand(0)); }
		1309	};
		1310
		1311	/// This represents the llvm.va_copy intrinsic.
		1312	class VACopyInst : public IntrinsicInst {
		1313	public:
		1314	static bool classof(const IntrinsicInst *I) {
		1315	return I->getIntrinsicID() == Intrinsic::vacopy;
		1316	}
		1317	static bool classof(const Value *V) {
		1318	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1319	}
		1320
		1321	Value getDest() const { return const_cast<Value >(getArgOperand(0)); }
		1322	Value getSrc() const { return const_cast<Value >(getArgOperand(1)); }
		1323	};
		1324
		1325	/// A base class for all instrprof intrinsics.
		1326	class InstrProfInstBase : public IntrinsicInst {
		1327	public:
		1328	// The name of the instrumented function.
		1329	GlobalVariable *getName() const {
		1330	return cast<GlobalVariable>(
		1331	const_cast<Value *>(getArgOperand(0))->stripPointerCasts());
		1332	}
		1333	// The hash of the CFG for the instrumented function.
		1334	ConstantInt *getHash() const {
		1335	return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
		1336	}
		1337	// The number of counters for the instrumented function.
		1338	ConstantInt *getNumCounters() const;
		1339	// The index of the counter that this instruction acts on.
		1340	ConstantInt *getIndex() const;
		1341	};
		1342
		1343	/// This represents the llvm.instrprof.cover intrinsic.
		1344	class InstrProfCoverInst : public InstrProfInstBase {
		1345	public:
		1346	static bool classof(const IntrinsicInst *I) {
		1347	return I->getIntrinsicID() == Intrinsic::instrprof_cover;
		1348	}
		1349	static bool classof(const Value *V) {
		1350	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1351	}
		1352	};
		1353
		1354	/// This represents the llvm.instrprof.increment intrinsic.
		1355	class InstrProfIncrementInst : public InstrProfInstBase {
		1356	public:
		1357	static bool classof(const IntrinsicInst *I) {
		1358	return I->getIntrinsicID() == Intrinsic::instrprof_increment \|\|
		1359	I->getIntrinsicID() == Intrinsic::instrprof_increment_step;
		1360	}
		1361	static bool classof(const Value *V) {
		1362	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1363	}
		1364	Value *getStep() const;
		1365	};
		1366
		1367	/// This represents the llvm.instrprof.increment.step intrinsic.
		1368	class InstrProfIncrementInstStep : public InstrProfIncrementInst {
		1369	public:
		1370	static bool classof(const IntrinsicInst *I) {
		1371	return I->getIntrinsicID() == Intrinsic::instrprof_increment_step;
		1372	}
		1373	static bool classof(const Value *V) {
		1374	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1375	}
		1376	};
		1377
		1378	/// This represents the llvm.instrprof.value.profile intrinsic.
		1379	class InstrProfValueProfileInst : public InstrProfInstBase {
		1380	public:
		1381	static bool classof(const IntrinsicInst *I) {
		1382	return I->getIntrinsicID() == Intrinsic::instrprof_value_profile;
		1383	}
		1384	static bool classof(const Value *V) {
		1385	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1386	}
		1387
		1388	Value *getTargetValue() const {
		1389	return cast<Value>(const_cast<Value *>(getArgOperand(2)));
		1390	}
		1391
		1392	ConstantInt *getValueKind() const {
		1393	return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
		1394	}
		1395
		1396	// Returns the value site index.
		1397	ConstantInt *getIndex() const {
		1398	return cast<ConstantInt>(const_cast<Value *>(getArgOperand(4)));
		1399	}
		1400	};
		1401
		1402	class PseudoProbeInst : public IntrinsicInst {
		1403	public:
		1404	static bool classof(const IntrinsicInst *I) {
		1405	return I->getIntrinsicID() == Intrinsic::pseudoprobe;
		1406	}
		1407
		1408	static bool classof(const Value *V) {
		1409	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1410	}
		1411
		1412	ConstantInt *getFuncGuid() const {
		1413	return cast<ConstantInt>(const_cast<Value *>(getArgOperand(0)));
		1414	}
		1415
		1416	ConstantInt *getIndex() const {
		1417	return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
		1418	}
		1419
		1420	ConstantInt *getAttributes() const {
		1421	return cast<ConstantInt>(const_cast<Value *>(getArgOperand(2)));
		1422	}
		1423
		1424	ConstantInt *getFactor() const {
		1425	return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
		1426	}
		1427	};
		1428
		1429	class NoAliasScopeDeclInst : public IntrinsicInst {
		1430	public:
		1431	static bool classof(const IntrinsicInst *I) {
		1432	return I->getIntrinsicID() == Intrinsic::experimental_noalias_scope_decl;
		1433	}
		1434
		1435	static bool classof(const Value *V) {
		1436	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1437	}
		1438
		1439	MDNode *getScopeList() const {
		1440	auto *MV =
		1441	cast<MetadataAsValue>(getOperand(Intrinsic::NoAliasScopeDeclScopeArg));
		1442	return cast<MDNode>(MV->getMetadata());
		1443	}
		1444
		1445	void setScopeList(MDNode *ScopeList) {
		1446	setOperand(Intrinsic::NoAliasScopeDeclScopeArg,
		1447	MetadataAsValue::get(getContext(), ScopeList));
		1448	}
		1449	};
		1450
		1451	/// Common base class for representing values projected from a statepoint.
		1452	/// Currently, the only projections available are gc.result and gc.relocate.
		1453	class GCProjectionInst : public IntrinsicInst {
		1454	public:
		1455	static bool classof(const IntrinsicInst *I) {
		1456	return I->getIntrinsicID() == Intrinsic::experimental_gc_relocate \|\|
		1457	I->getIntrinsicID() == Intrinsic::experimental_gc_result;
		1458	}
		1459
		1460	static bool classof(const Value *V) {
		1461	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1462	}
		1463
		1464	/// Return true if this relocate is tied to the invoke statepoint.
		1465	/// This includes relocates which are on the unwinding path.
		1466	bool isTiedToInvoke() const {
		1467	const Value *Token = getArgOperand(0);
		1468
		1469	return isa<LandingPadInst>(Token) \|\| isa<InvokeInst>(Token);
		1470	}
		1471
		1472	/// The statepoint with which this gc.relocate is associated.
		1473	const Value *getStatepoint() const;
		1474	};
		1475
		1476	/// Represents calls to the gc.relocate intrinsic.
		1477	class GCRelocateInst : public GCProjectionInst {
		1478	public:
		1479	static bool classof(const IntrinsicInst *I) {
		1480	return I->getIntrinsicID() == Intrinsic::experimental_gc_relocate;
		1481	}
		1482
		1483	static bool classof(const Value *V) {
		1484	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1485	}
		1486
		1487	/// The index into the associate statepoint's argument list
		1488	/// which contains the base pointer of the pointer whose
		1489	/// relocation this gc.relocate describes.
		1490	unsigned getBasePtrIndex() const {
		1491	return cast<ConstantInt>(getArgOperand(1))->getZExtValue();
		1492	}
		1493
		1494	/// The index into the associate statepoint's argument list which
		1495	/// contains the pointer whose relocation this gc.relocate describes.
		1496	unsigned getDerivedPtrIndex() const {
		1497	return cast<ConstantInt>(getArgOperand(2))->getZExtValue();
		1498	}
		1499
		1500	Value *getBasePtr() const;
		1501	Value *getDerivedPtr() const;
		1502	};
		1503
		1504	/// Represents calls to the gc.result intrinsic.
		1505	class GCResultInst : public GCProjectionInst {
		1506	public:
		1507	static bool classof(const IntrinsicInst *I) {
		1508	return I->getIntrinsicID() == Intrinsic::experimental_gc_result;
		1509	}
		1510
		1511	static bool classof(const Value *V) {
		1512	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1513	}
		1514	};
		1515
		1516	/// This represents intrinsics that guard a condition
		1517	class CondGuardInst : public IntrinsicInst {
		1518	public:
		1519	static bool classof(const IntrinsicInst *I) {
		1520	return I->getIntrinsicID() == Intrinsic::assume \|\|
		1521	I->getIntrinsicID() == Intrinsic::experimental_guard;
		1522	}
		1523	static bool classof(const Value *V) {
		1524	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1525	}
		1526	};
		1527
		1528	/// This represents the llvm.assume intrinsic.
		1529	class AssumeInst : public CondGuardInst {
		1530	public:
		1531	static bool classof(const IntrinsicInst *I) {
		1532	return I->getIntrinsicID() == Intrinsic::assume;
		1533	}
		1534	static bool classof(const Value *V) {
		1535	return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
		1536	}
		1537	};
		1538
		1539	} // end namespace llvm
		1540
		1541	#endif // LLVM_IR_INTRINSICINST_H

Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

QNX 8.QNX8 LLVM/Clang compiler suite/llvm-build/x86_64/include/llvm/IR/IntrinsicInst.h – Rev 14