InstrTypes.h source code [llvm/include/llvm/IR/InstrTypes.h]

1	//===- llvm/InstrTypes.h - Important Instruction subclasses ------ 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 various meta classes of instructions that exist in the VM
10	// representation. Specific concrete subclasses of these may be found in the
11	// i.h files...*
12	//
13	//===----------------------------------------------------------------------===//
14
15	#ifndef LLVM_IR_INSTRTYPES_H
16	#define LLVM_IR_INSTRTYPES_H
17
18	#include "llvm/ADT/ArrayRef.h"
19	#include "llvm/ADT/None.h"
20	#include "llvm/ADT/Optional.h"
21	#include "llvm/ADT/STLExtras.h"
22	#include "llvm/ADT/StringMap.h"
23	#include "llvm/ADT/StringRef.h"
24	#include "llvm/ADT/Twine.h"
25	#include "llvm/ADT/iterator_range.h"
26	#include "llvm/IR/Attributes.h"
27	#include "llvm/IR/CallingConv.h"
28	#include "llvm/IR/Constants.h"
29	#include "llvm/IR/DerivedTypes.h"
30	#include "llvm/IR/Function.h"
31	#include "llvm/IR/Instruction.h"
32	#include "llvm/IR/LLVMContext.h"
33	#include "llvm/IR/OperandTraits.h"
34	#include "llvm/IR/Type.h"
35	#include "llvm/IR/User.h"
36	#include "llvm/IR/Value.h"
37	#include "llvm/Support/Casting.h"
38	#include "llvm/Support/ErrorHandling.h"
39	#include <algorithm>
40	#include <cassert>
41	#include <cstddef>
42	#include <cstdint>
43	#include <iterator>
44	#include <string>
45	#include <vector>
46
47	namespace llvm {
48
49	namespace Intrinsic {
50	typedef unsigned ID;
51	}
52
53	//===----------------------------------------------------------------------===//
54	// UnaryInstruction Class
55	//===----------------------------------------------------------------------===//
56
57	class UnaryInstruction : public Instruction {
58	protected:
59	UnaryInstruction(Type Ty, unsigned* iType, Value *V,
60	Instruction IB = nullptr*)
61	: Instruction (Ty, iType, &Op<`0`>(), `1`, IB) {
62	Op<`0`>() = V;
63	}
64	UnaryInstruction(Type Ty, unsigned* iType, Value V, BasicBlock IAE)
65	: Instruction (Ty, iType, &Op<`0`>(), `1`, IAE) {
66	Op<`0`>() = V;
67	}
68
69	public:
70	// allocate space for exactly one operand
71	void *operator new(size_t s) {
72	return User::operator new(s, `1`);
73	}
74
75	/// Transparently provide more efficient getOperand methods.
76	DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
77
78	// Methods for support type inquiry through isa, cast, and dyn_cast:
79	static bool classof(const Instruction *I) {
80	return I->isUnaryOp() \|\|
81	I->getOpcode() == Instruction::Alloca \|\|
82	I->getOpcode() == Instruction::Load \|\|
83	I->getOpcode() == Instruction::VAArg \|\|
84	I->getOpcode() == Instruction::ExtractValue \|\|
85	(I->getOpcode() >= CastOpsBegin && I->getOpcode() < CastOpsEnd);
86	}
87	static bool classof(const Value *V) {
88	return isa<Instruction>(V) && classof(cast<Instruction>(V));
89	}
90	};
91
92	template <>
93	struct OperandTraits<UnaryInstruction> :
94	public FixedNumOperandTraits<UnaryInstruction, `1`> {
95	};
96
97	DEFINE_TRANSPARENT_OPERAND_ACCESSORS(UnaryInstruction, Value)
98
99	//===----------------------------------------------------------------------===//
100	// UnaryOperator Class
101	//===----------------------------------------------------------------------===//
102
103	class UnaryOperator : public UnaryInstruction {
104	void AssertOK();
105
106	protected:
107	UnaryOperator(UnaryOps iType, Value S, Type Ty,
108	const Twine &Name, Instruction *InsertBefore);
109	UnaryOperator(UnaryOps iType, Value S, Type Ty,
110	const Twine &Name, BasicBlock *InsertAtEnd);
111
112	// Note: Instruction needs to be a friend here to call cloneImpl.
113	friend class Instruction;
114
115	UnaryOperator cloneImpl() const*;
116
117	public:
118
119	/// Construct a unary instruction, given the opcode and an operand.
120	/// Optionally (if InstBefore is specified) insert the instruction
121	/// into a BasicBlock right before the specified instruction. The specified
122	/// Instruction is allowed to be a dereferenced end iterator.
123	///
124	static UnaryOperator Create(UnaryOps Op, Value S,
125	const Twine &Name = Twine (),
126	Instruction InsertBefore = nullptr*);
127
128	/// Construct a unary instruction, given the opcode and an operand.
129	/// Also automatically insert this instruction to the end of the
130	/// BasicBlock specified.
131	///
132	static UnaryOperator Create(UnaryOps Op, Value S,
133	const Twine &Name,
134	BasicBlock *InsertAtEnd);
135
136	/// These methods just forward to Create, and are useful when you
137	/// statically know what type of instruction you're going to create. These
138	/// helpers just save some typing.
139	#define HANDLE_UNARY_INST(N, OPC, CLASS) \
140	static UnaryOperator Create##OPC(Value V, const Twine &Name = "") {\
141	return Create(Instruction::OPC, V, Name);\
142	}
143	#include "llvm/IR/Instruction.def"
144	#define HANDLE_UNARY_INST(N, OPC, CLASS) \
145	static UnaryOperator Create##OPC(Value V, const Twine &Name, \
146	BasicBlock *BB) {\
147	return Create(Instruction::OPC, V, Name, BB);\
148	}
149	#include "llvm/IR/Instruction.def"
150	#define HANDLE_UNARY_INST(N, OPC, CLASS) \
151	static UnaryOperator Create##OPC(Value V, const Twine &Name, \
152	Instruction *I) {\
153	return Create(Instruction::OPC, V, Name, I);\
154	}
155	#include "llvm/IR/Instruction.def"
156
157	static UnaryOperator *
158	CreateWithCopiedFlags(UnaryOps Opc, Value V, Instruction CopyO,
159	const Twine &Name = "",
160	Instruction InsertBefore = nullptr*) {
161	UnaryOperator *UO = Create(Opc, V, Name, InsertBefore);
162	UO->copyIRFlags(CopyO);
163	return UO;
164	}
165
166	static UnaryOperator CreateFNegFMF(Value Op, Instruction *FMFSource,
167	const Twine &Name = "",
168	Instruction InsertBefore = nullptr*) {
169	return CreateWithCopiedFlags(Instruction::FNeg, Op, FMFSource, Name,
170	InsertBefore);
171	}
172
173	UnaryOps getOpcode() const {
174	return static_cast<UnaryOps>(Instruction::getOpcode());
175	}
176
177	// Methods for support type inquiry through isa, cast, and dyn_cast:
178	static bool classof(const Instruction *I) {
179	return I->isUnaryOp();
180	}
181	static bool classof(const Value *V) {
182	return isa<Instruction>(V) && classof(cast<Instruction>(V));
183	}
184	};
185
186	//===----------------------------------------------------------------------===//
187	// BinaryOperator Class
188	//===----------------------------------------------------------------------===//
189
190	class BinaryOperator : public Instruction {
191	void AssertOK();
192
193	protected:
194	BinaryOperator(BinaryOps iType, Value S1, Value S2, Type *Ty,
195	const Twine &Name, Instruction *InsertBefore);
196	BinaryOperator(BinaryOps iType, Value S1, Value S2, Type *Ty,
197	const Twine &Name, BasicBlock *InsertAtEnd);
198
199	// Note: Instruction needs to be a friend here to call cloneImpl.
200	friend class Instruction;
201
202	BinaryOperator cloneImpl() const*;
203
204	public:
205	// allocate space for exactly two operands
206	void *operator new(size_t s) {
207	return User::operator new(s, `2`);
208	}
209
210	/// Transparently provide more efficient getOperand methods.
211	DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
212
213	/// Construct a binary instruction, given the opcode and the two
214	/// operands. Optionally (if InstBefore is specified) insert the instruction
215	/// into a BasicBlock right before the specified instruction. The specified
216	/// Instruction is allowed to be a dereferenced end iterator.
217	///
218	static BinaryOperator Create(BinaryOps Op, Value S1, Value *S2,
219	const Twine &Name = Twine (),
220	Instruction InsertBefore = nullptr*);
221
222	/// Construct a binary instruction, given the opcode and the two
223	/// operands. Also automatically insert this instruction to the end of the
224	/// BasicBlock specified.
225	///
226	static BinaryOperator Create(BinaryOps Op, Value S1, Value *S2,
227	const Twine &Name, BasicBlock *InsertAtEnd);
228
229	/// These methods just forward to Create, and are useful when you
230	/// statically know what type of instruction you're going to create. These
231	/// helpers just save some typing.
232	#define HANDLE_BINARY_INST(N, OPC, CLASS) \
233	static BinaryOperator Create##OPC(Value V1, Value *V2, \
234	const Twine &Name = "") {\
235	return Create(Instruction::OPC, V1, V2, Name);\
236	}
237	#include "llvm/IR/Instruction.def"
238	#define HANDLE_BINARY_INST(N, OPC, CLASS) \
239	static BinaryOperator Create##OPC(Value V1, Value *V2, \
240	const Twine &Name, BasicBlock *BB) {\
241	return Create(Instruction::OPC, V1, V2, Name, BB);\
242	}
243	#include "llvm/IR/Instruction.def"
244	#define HANDLE_BINARY_INST(N, OPC, CLASS) \
245	static BinaryOperator Create##OPC(Value V1, Value *V2, \
246	const Twine &Name, Instruction *I) {\
247	return Create(Instruction::OPC, V1, V2, Name, I);\
248	}
249	#include "llvm/IR/Instruction.def"
250
251	static BinaryOperator *CreateWithCopiedFlags(BinaryOps Opc,
252	Value V1, Value V2,
253	Instruction *CopyO,
254	const Twine &Name = "") {
255	BinaryOperator *BO = Create(Opc, V1, V2, Name);
256	BO->copyIRFlags(CopyO);
257	return BO;
258	}
259
260	static BinaryOperator CreateFAddFMF(Value V1, Value *V2,
261	Instruction *FMFSource,
262	const Twine &Name = "") {
263	return CreateWithCopiedFlags(Instruction::FAdd, V1, V2, FMFSource, Name);
264	}
265	static BinaryOperator CreateFSubFMF(Value V1, Value *V2,
266	Instruction *FMFSource,
267	const Twine &Name = "") {
268	return CreateWithCopiedFlags(Instruction::FSub, V1, V2, FMFSource, Name);
269	}
270	static BinaryOperator CreateFMulFMF(Value V1, Value *V2,
271	Instruction *FMFSource,
272	const Twine &Name = "") {
273	return CreateWithCopiedFlags(Instruction::FMul, V1, V2, FMFSource, Name);
274	}
275	static BinaryOperator CreateFDivFMF(Value V1, Value *V2,
276	Instruction *FMFSource,
277	const Twine &Name = "") {
278	return CreateWithCopiedFlags(Instruction::FDiv, V1, V2, FMFSource, Name);
279	}
280	static BinaryOperator CreateFRemFMF(Value V1, Value *V2,
281	Instruction *FMFSource,
282	const Twine &Name = "") {
283	return CreateWithCopiedFlags(Instruction::FRem, V1, V2, FMFSource, Name);
284	}
285
286	static BinaryOperator CreateNSW(BinaryOps Opc, Value V1, Value *V2,
287	const Twine &Name = "") {
288	BinaryOperator *BO = Create(Opc, V1, V2, Name);
289	BO->setHasNoSignedWrap(true);
290	return BO;
291	}
292	static BinaryOperator CreateNSW(BinaryOps Opc, Value V1, Value *V2,
293	const Twine &Name, BasicBlock *BB) {
294	BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
295	BO->setHasNoSignedWrap(true);
296	return BO;
297	}
298	static BinaryOperator CreateNSW(BinaryOps Opc, Value V1, Value *V2,
299	const Twine &Name, Instruction *I) {
300	BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
301	BO->setHasNoSignedWrap(true);
302	return BO;
303	}
304
305	static BinaryOperator CreateNUW(BinaryOps Opc, Value V1, Value *V2,
306	const Twine &Name = "") {
307	BinaryOperator *BO = Create(Opc, V1, V2, Name);
308	BO->setHasNoUnsignedWrap(true);
309	return BO;
310	}
311	static BinaryOperator CreateNUW(BinaryOps Opc, Value V1, Value *V2,
312	const Twine &Name, BasicBlock *BB) {
313	BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
314	BO->setHasNoUnsignedWrap(true);
315	return BO;
316	}
317	static BinaryOperator CreateNUW(BinaryOps Opc, Value V1, Value *V2,
318	const Twine &Name, Instruction *I) {
319	BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
320	BO->setHasNoUnsignedWrap(true);
321	return BO;
322	}
323
324	static BinaryOperator CreateExact(BinaryOps Opc, Value V1, Value *V2,
325	const Twine &Name = "") {
326	BinaryOperator *BO = Create(Opc, V1, V2, Name);
327	BO->setIsExact(true);
328	return BO;
329	}
330	static BinaryOperator CreateExact(BinaryOps Opc, Value V1, Value *V2,
331	const Twine &Name, BasicBlock *BB) {
332	BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
333	BO->setIsExact(true);
334	return BO;
335	}
336	static BinaryOperator CreateExact(BinaryOps Opc, Value V1, Value *V2,
337	const Twine &Name, Instruction *I) {
338	BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
339	BO->setIsExact(true);
340	return BO;
341	}
342
343	#define DEFINE_HELPERS(OPC, NUWNSWEXACT) \
344	static BinaryOperator Create##NUWNSWEXACT##OPC(Value V1, Value *V2, \
345	const Twine &Name = "") { \
346	return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name); \
347	} \
348	static BinaryOperator *Create##NUWNSWEXACT##OPC( \
349	Value V1, Value V2, const Twine &Name, BasicBlock *BB) { \
350	return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name, BB); \
351	} \
352	static BinaryOperator *Create##NUWNSWEXACT##OPC( \
353	Value V1, Value V2, const Twine &Name, Instruction *I) { \
354	return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name, I); \
355	}
356
357	DEFINE_HELPERS(Add, NSW) // CreateNSWAdd
358	DEFINE_HELPERS(Add, NUW) // CreateNUWAdd
359	DEFINE_HELPERS(Sub, NSW) // CreateNSWSub
360	DEFINE_HELPERS(Sub, NUW) // CreateNUWSub
361	DEFINE_HELPERS(Mul, NSW) // CreateNSWMul
362	DEFINE_HELPERS(Mul, NUW) // CreateNUWMul
363	DEFINE_HELPERS(Shl, NSW) // CreateNSWShl
364	DEFINE_HELPERS(Shl, NUW) // CreateNUWShl
365
366	DEFINE_HELPERS(SDiv, Exact) // CreateExactSDiv
367	DEFINE_HELPERS(UDiv, Exact) // CreateExactUDiv
368	DEFINE_HELPERS(AShr, Exact) // CreateExactAShr
369	DEFINE_HELPERS(LShr, Exact) // CreateExactLShr
370
371	#undef DEFINE_HELPERS
372
373	/// Helper functions to construct and inspect unary operations (NEG and NOT)
374	/// via binary operators SUB and XOR:
375	///
376	/// Create the NEG and NOT instructions out of SUB and XOR instructions.
377	///
378	static BinaryOperator CreateNeg(Value Op, const Twine &Name = "",
379	Instruction InsertBefore = nullptr*);
380	static BinaryOperator CreateNeg(Value Op, const Twine &Name,
381	BasicBlock *InsertAtEnd);
382	static BinaryOperator CreateNSWNeg(Value Op, const Twine &Name = "",
383	Instruction InsertBefore = nullptr*);
384	static BinaryOperator CreateNSWNeg(Value Op, const Twine &Name,
385	BasicBlock *InsertAtEnd);
386	static BinaryOperator CreateNUWNeg(Value Op, const Twine &Name = "",
387	Instruction InsertBefore = nullptr*);
388	static BinaryOperator CreateNUWNeg(Value Op, const Twine &Name,
389	BasicBlock *InsertAtEnd);
390	static BinaryOperator CreateNot(Value Op, const Twine &Name = "",
391	Instruction InsertBefore = nullptr*);
392	static BinaryOperator CreateNot(Value Op, const Twine &Name,
393	BasicBlock *InsertAtEnd);
394
395	BinaryOps getOpcode() const {
396	return static_cast<BinaryOps>(Instruction::getOpcode());
397	}
398
399	/// Exchange the two operands to this instruction.
400	/// This instruction is safe to use on any binary instruction and
401	/// does not modify the semantics of the instruction. If the instruction
402	/// cannot be reversed (ie, it's a Div), then return true.
403	///
404	bool swapOperands();
405
406	// Methods for support type inquiry through isa, cast, and dyn_cast:
407	static bool classof(const Instruction *I) {
408	return I->isBinaryOp();
409	}
410	static bool classof(const Value *V) {
411	return isa<Instruction>(V) && classof(cast<Instruction>(V));
412	}
413	};
414
415	template <>
416	struct OperandTraits<BinaryOperator> :
417	public FixedNumOperandTraits<BinaryOperator, `2`> {
418	};
419
420	DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BinaryOperator, Value)
421
422	//===----------------------------------------------------------------------===//
423	// CastInst Class
424	//===----------------------------------------------------------------------===//
425
426	/// This is the base class for all instructions that perform data
427	/// casts. It is simply provided so that instruction category testing
428	/// can be performed with code like:
429	///
430	/// if (isa<CastInst>(Instr)) { ... }
431	/// Base class of casting instructions.
432	class CastInst : public UnaryInstruction {
433	protected:
434	/// Constructor with insert-before-instruction semantics for subclasses
435	CastInst(Type Ty, unsigned* iType, Value *S,
436	const Twine &NameStr = "", Instruction InsertBefore = nullptr*)
437	: UnaryInstruction (Ty, iType, S, InsertBefore) {
438	setName(NameStr);
439	}
440	/// Constructor with insert-at-end-of-block semantics for subclasses
441	CastInst(Type Ty, unsigned* iType, Value *S,
442	const Twine &NameStr, BasicBlock *InsertAtEnd)
443	: UnaryInstruction (Ty, iType, S, InsertAtEnd) {
444	setName(NameStr);
445	}
446
447	public:
448	/// Provides a way to construct any of the CastInst subclasses using an
449	/// opcode instead of the subclass's constructor. The opcode must be in the
450	/// CastOps category (Instruction::isCast(opcode) returns true). This
451	/// constructor has insert-before-instruction semantics to automatically
452	/// insert the new CastInst before InsertBefore (if it is non-null).
453	/// Construct any of the CastInst subclasses
454	static CastInst *Create(
455	Instruction::CastOps, ///< The opcode of the cast instruction
456	Value S, ///< The value to be casted (operand 0)*
457	Type Ty, ///< The type to which cast should be made*
458	const Twine &Name = "", ///< Name for the instruction
459	Instruction InsertBefore = nullptr* ///< Place to insert the instruction
460	);
461	/// Provides a way to construct any of the CastInst subclasses using an
462	/// opcode instead of the subclass's constructor. The opcode must be in the
463	/// CastOps category. This constructor has insert-at-end-of-block semantics
464	/// to automatically insert the new CastInst at the end of InsertAtEnd (if
465	/// its non-null).
466	/// Construct any of the CastInst subclasses
467	static CastInst *Create(
468	Instruction::CastOps, ///< The opcode for the cast instruction
469	Value S, ///< The value to be casted (operand 0)*
470	Type Ty, ///< The type to which operand is casted*
471	const Twine &Name, ///< The name for the instruction
472	BasicBlock InsertAtEnd ///< The block to insert the instruction into*
473	);
474
475	/// Create a ZExt or BitCast cast instruction
476	static CastInst *CreateZExtOrBitCast(
477	Value S, ///< The value to be casted (operand 0)*
478	Type Ty, ///< The type to which cast should be made*
479	const Twine &Name = "", ///< Name for the instruction
480	Instruction InsertBefore = nullptr* ///< Place to insert the instruction
481	);
482
483	/// Create a ZExt or BitCast cast instruction
484	static CastInst *CreateZExtOrBitCast(
485	Value S, ///< The value to be casted (operand 0)*
486	Type Ty, ///< The type to which operand is casted*
487	const Twine &Name, ///< The name for the instruction
488	BasicBlock InsertAtEnd ///< The block to insert the instruction into*
489	);
490
491	/// Create a SExt or BitCast cast instruction
492	static CastInst *CreateSExtOrBitCast(
493	Value S, ///< The value to be casted (operand 0)*
494	Type Ty, ///< The type to which cast should be made*
495	const Twine &Name = "", ///< Name for the instruction
496	Instruction InsertBefore = nullptr* ///< Place to insert the instruction
497	);
498
499	/// Create a SExt or BitCast cast instruction
500	static CastInst *CreateSExtOrBitCast(
501	Value S, ///< The value to be casted (operand 0)*
502	Type Ty, ///< The type to which operand is casted*
503	const Twine &Name, ///< The name for the instruction
504	BasicBlock InsertAtEnd ///< The block to insert the instruction into*
505	);
506
507	/// Create a BitCast AddrSpaceCast, or a PtrToInt cast instruction.
508	static CastInst *CreatePointerCast(
509	Value S, ///< The pointer value to be casted (operand 0)*
510	Type Ty, ///< The type to which operand is casted*
511	const Twine &Name, ///< The name for the instruction
512	BasicBlock InsertAtEnd ///< The block to insert the instruction into*
513	);
514
515	/// Create a BitCast, AddrSpaceCast or a PtrToInt cast instruction.
516	static CastInst *CreatePointerCast(
517	Value S, ///< The pointer value to be casted (operand 0)*
518	Type Ty, ///< The type to which cast should be made*
519	const Twine &Name = "", ///< Name for the instruction
520	Instruction InsertBefore = nullptr* ///< Place to insert the instruction
521	);
522
523	/// Create a BitCast or an AddrSpaceCast cast instruction.
524	static CastInst *CreatePointerBitCastOrAddrSpaceCast(
525	Value S, ///< The pointer value to be casted (operand 0)*
526	Type Ty, ///< The type to which operand is casted*
527	const Twine &Name, ///< The name for the instruction
528	BasicBlock InsertAtEnd ///< The block to insert the instruction into*
529	);
530
531	/// Create a BitCast or an AddrSpaceCast cast instruction.
532	static CastInst *CreatePointerBitCastOrAddrSpaceCast(
533	Value S, ///< The pointer value to be casted (operand 0)*
534	Type Ty, ///< The type to which cast should be made*
535	const Twine &Name = "", ///< Name for the instruction
536	Instruction InsertBefore = nullptr* ///< Place to insert the instruction
537	);
538
539	/// Create a BitCast, a PtrToInt, or an IntToPTr cast instruction.
540	///
541	/// If the value is a pointer type and the destination an integer type,
542	/// creates a PtrToInt cast. If the value is an integer type and the
543	/// destination a pointer type, creates an IntToPtr cast. Otherwise, creates
544	/// a bitcast.
545	static CastInst *CreateBitOrPointerCast(
546	Value S, ///< The pointer value to be casted (operand 0)*
547	Type Ty, ///< The type to which cast should be made*
548	const Twine &Name = "", ///< Name for the instruction
549	Instruction InsertBefore = nullptr* ///< Place to insert the instruction
550	);
551
552	/// Create a ZExt, BitCast, or Trunc for int -> int casts.
553	static CastInst *CreateIntegerCast(
554	Value S, ///< The pointer value to be casted (operand 0)*
555	Type Ty, ///< The type to which cast should be made*
556	bool isSigned, ///< Whether to regard S as signed or not
557	const Twine &Name = "", ///< Name for the instruction
558	Instruction InsertBefore = nullptr* ///< Place to insert the instruction
559	);
560
561	/// Create a ZExt, BitCast, or Trunc for int -> int casts.
562	static CastInst *CreateIntegerCast(
563	Value S, ///< The integer value to be casted (operand 0)*
564	Type Ty, ///< The integer type to which operand is casted*
565	bool isSigned, ///< Whether to regard S as signed or not
566	const Twine &Name, ///< The name for the instruction
567	BasicBlock InsertAtEnd ///< The block to insert the instruction into*
568	);
569
570	/// Create an FPExt, BitCast, or FPTrunc for fp -> fp casts
571	static CastInst *CreateFPCast(
572	Value S, ///< The floating point value to be casted*
573	Type Ty, ///< The floating point type to cast to*
574	const Twine &Name = "", ///< Name for the instruction
575	Instruction InsertBefore = nullptr* ///< Place to insert the instruction
576	);
577
578	/// Create an FPExt, BitCast, or FPTrunc for fp -> fp casts
579	static CastInst *CreateFPCast(
580	Value S, ///< The floating point value to be casted*
581	Type Ty, ///< The floating point type to cast to*
582	const Twine &Name, ///< The name for the instruction
583	BasicBlock InsertAtEnd ///< The block to insert the instruction into*
584	);
585
586	/// Create a Trunc or BitCast cast instruction
587	static CastInst *CreateTruncOrBitCast(
588	Value S, ///< The value to be casted (operand 0)*
589	Type Ty, ///< The type to which cast should be made*
590	const Twine &Name = "", ///< Name for the instruction
591	Instruction InsertBefore = nullptr* ///< Place to insert the instruction
592	);
593
594	/// Create a Trunc or BitCast cast instruction
595	static CastInst *CreateTruncOrBitCast(
596	Value S, ///< The value to be casted (operand 0)*
597	Type Ty, ///< The type to which operand is casted*
598	const Twine &Name, ///< The name for the instruction
599	BasicBlock InsertAtEnd ///< The block to insert the instruction into*
600	);
601
602	/// Check whether a bitcast between these types is valid
603	static bool isBitCastable(
604	Type SrcTy, ///< The Type from which the value should be cast.*
605	Type DestTy ///< The Type to which the value should be cast.*
606	);
607
608	/// Check whether a bitcast, inttoptr, or ptrtoint cast between these
609	/// types is valid and a no-op.
610	///
611	/// This ensures that any pointer<->integer cast has enough bits in the
612	/// integer and any other cast is a bitcast.
613	static bool isBitOrNoopPointerCastable(
614	Type SrcTy, ///< The Type from which the value should be cast.*
615	Type DestTy, ///< The Type to which the value should be cast.*
616	const DataLayout &DL);
617
618	/// Returns the opcode necessary to cast Val into Ty using usual casting
619	/// rules.
620	/// Infer the opcode for cast operand and type
621	static Instruction::CastOps getCastOpcode(
622	const Value Val, ///< The value to cast*
623	bool SrcIsSigned, ///< Whether to treat the source as signed
624	Type Ty, ///< The Type to which the value should be casted*
625	bool DstIsSigned ///< Whether to treate the dest. as signed
626	);
627
628	/// There are several places where we need to know if a cast instruction
629	/// only deals with integer source and destination types. To simplify that
630	/// logic, this method is provided.
631	/// @returns true iff the cast has only integral typed operand and dest type.
632	/// Determine if this is an integer-only cast.
633	bool isIntegerCast() const;
634
635	/// A lossless cast is one that does not alter the basic value. It implies
636	/// a no-op cast but is more stringent, preventing things like int->float,
637	/// long->double, or int->ptr.
638	/// @returns true iff the cast is lossless.
639	/// Determine if this is a lossless cast.
640	bool isLosslessCast() const;
641
642	/// A no-op cast is one that can be effected without changing any bits.
643	/// It implies that the source and destination types are the same size. The
644	/// DataLayout argument is to determine the pointer size when examining casts
645	/// involving Integer and Pointer types. They are no-op casts if the integer
646	/// is the same size as the pointer. However, pointer size varies with
647	/// platform. Note that a precondition of this method is that the cast is
648	/// legal - i.e. the instruction formed with these operands would verify.
649	static bool isNoopCast(
650	Instruction::CastOps Opcode, ///< Opcode of cast
651	Type SrcTy, ///< SrcTy of cast*
652	Type DstTy, ///< DstTy of cast*
653	const DataLayout &DL ///< DataLayout to get the Int Ptr type from.
654	);
655
656	/// Determine if this cast is a no-op cast.
657	///
658	/// \param DL is the DataLayout to determine pointer size.
659	bool isNoopCast(const DataLayout &DL) const;
660
661	/// Determine how a pair of casts can be eliminated, if they can be at all.
662	/// This is a helper function for both CastInst and ConstantExpr.
663	/// @returns 0 if the CastInst pair can't be eliminated, otherwise
664	/// returns Instruction::CastOps value for a cast that can replace
665	/// the pair, casting SrcTy to DstTy.
666	/// Determine if a cast pair is eliminable
667	static unsigned isEliminableCastPair(
668	Instruction::CastOps firstOpcode, ///< Opcode of first cast
669	Instruction::CastOps secondOpcode, ///< Opcode of second cast
670	Type SrcTy, ///< SrcTy of 1st cast*
671	Type MidTy, ///< DstTy of 1st cast & SrcTy of 2nd cast*
672	Type DstTy, ///< DstTy of 2nd cast*
673	Type SrcIntPtrTy, ///< Integer type corresponding to Ptr SrcTy, or null*
674	Type MidIntPtrTy, ///< Integer type corresponding to Ptr MidTy, or null*
675	Type DstIntPtrTy ///< Integer type corresponding to Ptr DstTy, or null*
676	);
677
678	/// Return the opcode of this CastInst
679	Instruction::CastOps getOpcode() const {
680	return Instruction::CastOps(Instruction::getOpcode());
681	}
682
683	/// Return the source type, as a convenience
684	Type* getSrcTy() const { return getOperand(`0`)->getType(); }
685	/// Return the destination type, as a convenience
686	Type* getDestTy() const { return getType(); }
687
688	/// This method can be used to determine if a cast from SrcTy to DstTy using
689	/// Opcode op is valid or not.
690	/// @returns true iff the proposed cast is valid.
691	/// Determine if a cast is valid without creating one.
692	static bool castIsValid(Instruction::CastOps op, Type SrcTy, Type DstTy);
693	static bool castIsValid(Instruction::CastOps op, Value S, Type DstTy) {
694	return castIsValid(op, S->getType(), DstTy);
695	}
696
697	/// Methods for support type inquiry through isa, cast, and dyn_cast:
698	static bool classof(const Instruction *I) {
699	return I->isCast();
700	}
701	static bool classof(const Value *V) {
702	return isa<Instruction>(V) && classof(cast<Instruction>(V));
703	}
704	};
705
706	//===----------------------------------------------------------------------===//
707	// CmpInst Class
708	//===----------------------------------------------------------------------===//
709
710	/// This class is the base class for the comparison instructions.
711	/// Abstract base class of comparison instructions.
712	class CmpInst : public Instruction {
713	public:
714	/// This enumeration lists the possible predicates for CmpInst subclasses.
715	/// Values in the range 0-31 are reserved for FCmpInst, while values in the
716	/// range 32-64 are reserved for ICmpInst. This is necessary to ensure the
717	/// predicate values are not overlapping between the classes.
718	///
719	/// Some passes (e.g. InstCombine) depend on the bit-wise characteristics of
720	/// FCMP_ values. Changing the bit patterns requires a potential change to*
721	/// those passes.
722	enum Predicate : unsigned {
723	// Opcode U L G E Intuitive operation
724	FCMP_FALSE = `0`, ///< 0 0 0 0 Always false (always folded)
725	FCMP_OEQ = `1`, ///< 0 0 0 1 True if ordered and equal
726	FCMP_OGT = `2`, ///< 0 0 1 0 True if ordered and greater than
727	FCMP_OGE = `3`, ///< 0 0 1 1 True if ordered and greater than or equal
728	FCMP_OLT = `4`, ///< 0 1 0 0 True if ordered and less than
729	FCMP_OLE = `5`, ///< 0 1 0 1 True if ordered and less than or equal
730	FCMP_ONE = `6`, ///< 0 1 1 0 True if ordered and operands are unequal
731	FCMP_ORD = `7`, ///< 0 1 1 1 True if ordered (no nans)
732	FCMP_UNO = `8`, ///< 1 0 0 0 True if unordered: isnan(X) \| isnan(Y)
733	FCMP_UEQ = `9`, ///< 1 0 0 1 True if unordered or equal
734	FCMP_UGT = `10`, ///< 1 0 1 0 True if unordered or greater than
735	FCMP_UGE = `11`, ///< 1 0 1 1 True if unordered, greater than, or equal
736	FCMP_ULT = `12`, ///< 1 1 0 0 True if unordered or less than
737	FCMP_ULE = `13`, ///< 1 1 0 1 True if unordered, less than, or equal
738	FCMP_UNE = `14`, ///< 1 1 1 0 True if unordered or not equal
739	FCMP_TRUE = `15`, ///< 1 1 1 1 Always true (always folded)
740	FIRST_FCMP_PREDICATE = FCMP_FALSE,
741	LAST_FCMP_PREDICATE = FCMP_TRUE,
742	BAD_FCMP_PREDICATE = FCMP_TRUE + `1`,
743	ICMP_EQ = `32`, ///< equal
744	ICMP_NE = `33`, ///< not equal
745	ICMP_UGT = `34`, ///< unsigned greater than
746	ICMP_UGE = `35`, ///< unsigned greater or equal
747	ICMP_ULT = `36`, ///< unsigned less than
748	ICMP_ULE = `37`, ///< unsigned less or equal
749	ICMP_SGT = `38`, ///< signed greater than
750	ICMP_SGE = `39`, ///< signed greater or equal
751	ICMP_SLT = `40`, ///< signed less than
752	ICMP_SLE = `41`, ///< signed less or equal
753	FIRST_ICMP_PREDICATE = ICMP_EQ,
754	LAST_ICMP_PREDICATE = ICMP_SLE,
755	BAD_ICMP_PREDICATE = ICMP_SLE + `1`
756	};
757	using PredicateField =
758	Bitfield::Element<Predicate, `0`, `6`, LAST_ICMP_PREDICATE>;
759
760	protected:
761	CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred,
762	Value LHS, Value RHS, const Twine &Name = "",
763	Instruction InsertBefore = nullptr*,
764	Instruction FlagsSource = nullptr*);
765
766	CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred,
767	Value LHS, Value RHS, const Twine &Name,
768	BasicBlock *InsertAtEnd);
769
770	public:
771	// allocate space for exactly two operands
772	void *operator new(size_t s) {
773	return User::operator new(s, `2`);
774	}
775
776	/// Construct a compare instruction, given the opcode, the predicate and
777	/// the two operands. Optionally (if InstBefore is specified) insert the
778	/// instruction into a BasicBlock right before the specified instruction.
779	/// The specified Instruction is allowed to be a dereferenced end iterator.
780	/// Create a CmpInst
781	static CmpInst *Create(OtherOps Op,
782	Predicate predicate, Value *S1,
783	Value S2, const* Twine &Name = "",
784	Instruction InsertBefore = nullptr*);
785
786	/// Construct a compare instruction, given the opcode, the predicate and the
787	/// two operands. Also automatically insert this instruction to the end of
788	/// the BasicBlock specified.
789	/// Create a CmpInst
790	static CmpInst Create(OtherOps Op, Predicate predicate, Value S1,
791	Value S2, const* Twine &Name, BasicBlock *InsertAtEnd);
792
793	/// Get the opcode casted to the right type
794	OtherOps getOpcode() const {
795	return static_cast<OtherOps>(Instruction::getOpcode());
796	}
797
798	/// Return the predicate for this instruction.
799	Predicate getPredicate() const { return getSubclassData<PredicateField>(); }
800
801	/// Set the predicate for this instruction to the specified value.
802	void setPredicate(Predicate P) { setSubclassData<PredicateField>(P); }
803
804	static bool isFPPredicate(Predicate P) {
805	static_assert(FIRST_FCMP_PREDICATE == `0`,
806	"FIRST_FCMP_PREDICATE is required to be 0");
807	return P <= LAST_FCMP_PREDICATE;
808	}
809
810	static bool isIntPredicate(Predicate P) {
811	return P >= FIRST_ICMP_PREDICATE && P <= LAST_ICMP_PREDICATE;
812	}
813
814	static StringRef getPredicateName(Predicate P);
815
816	bool isFPPredicate() const { return isFPPredicate(getPredicate()); }
817	bool isIntPredicate() const { return isIntPredicate(getPredicate()); }
818
819	/// For example, EQ -> NE, UGT -> ULE, SLT -> SGE,
820	/// OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
821	/// @returns the inverse predicate for the instruction's current predicate.
822	/// Return the inverse of the instruction's predicate.
823	Predicate getInversePredicate() const {
824	return getInversePredicate(getPredicate());
825	}
826
827	/// For example, EQ -> NE, UGT -> ULE, SLT -> SGE,
828	/// OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
829	/// @returns the inverse predicate for predicate provided in \p pred.
830	/// Return the inverse of a given predicate
831	static Predicate getInversePredicate(Predicate pred);
832
833	/// For example, EQ->EQ, SLE->SGE, ULT->UGT,
834	/// OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
835	/// @returns the predicate that would be the result of exchanging the two
836	/// operands of the CmpInst instruction without changing the result
837	/// produced.
838	/// Return the predicate as if the operands were swapped
839	Predicate getSwappedPredicate() const {
840	return getSwappedPredicate(getPredicate());
841	}
842
843	/// This is a static version that you can use without an instruction
844	/// available.
845	/// Return the predicate as if the operands were swapped.
846	static Predicate getSwappedPredicate(Predicate pred);
847
848	/// This is a static version that you can use without an instruction
849	/// available.
850	/// @returns true if the comparison predicate is strict, false otherwise.
851	static bool isStrictPredicate(Predicate predicate);
852
853	/// @returns true if the comparison predicate is strict, false otherwise.
854	/// Determine if this instruction is using an strict comparison predicate.
855	bool isStrictPredicate() const { return isStrictPredicate(getPredicate()); }
856
857	/// This is a static version that you can use without an instruction
858	/// available.
859	/// @returns true if the comparison predicate is non-strict, false otherwise.
860	static bool isNonStrictPredicate(Predicate predicate);
861
862	/// @returns true if the comparison predicate is non-strict, false otherwise.
863	/// Determine if this instruction is using an non-strict comparison predicate.
864	bool isNonStrictPredicate() const {
865	return isNonStrictPredicate(getPredicate());
866	}
867
868	/// For example, SGE -> SGT, SLE -> SLT, ULE -> ULT, UGE -> UGT.
869	/// Returns the strict version of non-strict comparisons.
870	Predicate getStrictPredicate() const {
871	return getStrictPredicate(getPredicate());
872	}
873
874	/// This is a static version that you can use without an instruction
875	/// available.
876	/// @returns the strict version of comparison provided in \p pred.
877	/// If \p pred is not a strict comparison predicate, returns \p pred.
878	/// Returns the strict version of non-strict comparisons.
879	static Predicate getStrictPredicate(Predicate pred);
880
881	/// For example, SGT -> SGE, SLT -> SLE, ULT -> ULE, UGT -> UGE.
882	/// Returns the non-strict version of strict comparisons.
883	Predicate getNonStrictPredicate() const {
884	return getNonStrictPredicate(getPredicate());
885	}
886
887	/// This is a static version that you can use without an instruction
888	/// available.
889	/// @returns the non-strict version of comparison provided in \p pred.
890	/// If \p pred is not a strict comparison predicate, returns \p pred.
891	/// Returns the non-strict version of strict comparisons.
892	static Predicate getNonStrictPredicate(Predicate pred);
893
894	/// This is a static version that you can use without an instruction
895	/// available.
896	/// Return the flipped strictness of predicate
897	static Predicate getFlippedStrictnessPredicate(Predicate pred);
898
899	/// For predicate of kind "is X or equal to 0" returns the predicate "is X".
900	/// For predicate of kind "is X" returns the predicate "is X or equal to 0".
901	/// does not support other kind of predicates.
902	/// @returns the predicate that does not contains is equal to zero if
903	/// it had and vice versa.
904	/// Return the flipped strictness of predicate
905	Predicate getFlippedStrictnessPredicate() const {
906	return getFlippedStrictnessPredicate(getPredicate());
907	}
908
909	/// Provide more efficient getOperand methods.
910	DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
911
912	/// This is just a convenience that dispatches to the subclasses.
913	/// Swap the operands and adjust predicate accordingly to retain
914	/// the same comparison.
915	void swapOperands();
916
917	/// This is just a convenience that dispatches to the subclasses.
918	/// Determine if this CmpInst is commutative.
919	bool isCommutative() const;
920
921	/// Determine if this is an equals/not equals predicate.
922	/// This is a static version that you can use without an instruction
923	/// available.
924	static bool isEquality(Predicate pred);
925
926	/// Determine if this is an equals/not equals predicate.
927	bool isEquality() const { return isEquality(getPredicate()); }
928
929	/// Return true if the predicate is relational (not EQ or NE).
930	static bool isRelational(Predicate P) { return !isEquality(P); }
931
932	/// Return true if the predicate is relational (not EQ or NE).
933	bool isRelational() const { return !isEquality(); }
934
935	/// @returns true if the comparison is signed, false otherwise.
936	/// Determine if this instruction is using a signed comparison.
937	bool isSigned() const {
938	return isSigned(getPredicate());
939	}
940
941	/// @returns true if the comparison is unsigned, false otherwise.
942	/// Determine if this instruction is using an unsigned comparison.
943	bool isUnsigned() const {
944	return isUnsigned(getPredicate());
945	}
946
947	/// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert
948	/// @returns the signed version of the unsigned predicate pred.
949	/// return the signed version of a predicate
950	static Predicate getSignedPredicate(Predicate pred);
951
952	/// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert
953	/// @returns the signed version of the predicate for this instruction (which
954	/// has to be an unsigned predicate).
955	/// return the signed version of a predicate
956	Predicate getSignedPredicate() {
957	return getSignedPredicate(getPredicate());
958	}
959
960	/// For example, SLT->ULT, SLE->ULE, SGT->UGT, SGE->UGE, ULT->Failed assert
961	/// @returns the unsigned version of the signed predicate pred.
962	static Predicate getUnsignedPredicate(Predicate pred);
963
964	/// For example, SLT->ULT, SLE->ULE, SGT->UGT, SGE->UGE, ULT->Failed assert
965	/// @returns the unsigned version of the predicate for this instruction (which
966	/// has to be an signed predicate).
967	/// return the unsigned version of a predicate
968	Predicate getUnsignedPredicate() {
969	return getUnsignedPredicate(getPredicate());
970	}
971
972	/// For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->Failed assert
973	/// @returns the unsigned version of the signed predicate pred or
974	/// the signed version of the signed predicate pred.
975	static Predicate getFlippedSignednessPredicate(Predicate pred);
976
977	/// For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->Failed assert
978	/// @returns the unsigned version of the signed predicate pred or
979	/// the signed version of the signed predicate pred.
980	Predicate getFlippedSignednessPredicate() {
981	return getFlippedSignednessPredicate(getPredicate());
982	}
983
984	/// This is just a convenience.
985	/// Determine if this is true when both operands are the same.
986	bool isTrueWhenEqual() const {
987	return isTrueWhenEqual(getPredicate());
988	}
989
990	/// This is just a convenience.
991	/// Determine if this is false when both operands are the same.
992	bool isFalseWhenEqual() const {
993	return isFalseWhenEqual(getPredicate());
994	}
995
996	/// @returns true if the predicate is unsigned, false otherwise.
997	/// Determine if the predicate is an unsigned operation.
998	static bool isUnsigned(Predicate predicate);
999
1000	/// @returns true if the predicate is signed, false otherwise.
1001	/// Determine if the predicate is an signed operation.
1002	static bool isSigned(Predicate predicate);
1003
1004	/// Determine if the predicate is an ordered operation.
1005	static bool isOrdered(Predicate predicate);
1006
1007	/// Determine if the predicate is an unordered operation.
1008	static bool isUnordered(Predicate predicate);
1009
1010	/// Determine if the predicate is true when comparing a value with itself.
1011	static bool isTrueWhenEqual(Predicate predicate);
1012
1013	/// Determine if the predicate is false when comparing a value with itself.
1014	static bool isFalseWhenEqual(Predicate predicate);
1015
1016	/// Determine if Pred1 implies Pred2 is true when two compares have matching
1017	/// operands.
1018	static bool isImpliedTrueByMatchingCmp(Predicate Pred1, Predicate Pred2);
1019
1020	/// Determine if Pred1 implies Pred2 is false when two compares have matching
1021	/// operands.
1022	static bool isImpliedFalseByMatchingCmp(Predicate Pred1, Predicate Pred2);
1023
1024	/// Methods for support type inquiry through isa, cast, and dyn_cast:
1025	static bool classof(const Instruction *I) {
1026	return I->getOpcode() == Instruction::ICmp \|\|
1027	I->getOpcode() == Instruction::FCmp;
1028	}
1029	static bool classof(const Value *V) {
1030	return isa<Instruction>(V) && classof(cast<Instruction>(V));
1031	}
1032
1033	/// Create a result type for fcmp/icmp
1034	static Type* makeCmpResultType(Type* opnd_type) {
1035	if (VectorType* vt = dyn_cast<VectorType>(opnd_type)) {
1036	return VectorType::get(Type::getInt1Ty(opnd_type->getContext()),
1037	vt->getElementCount());
1038	}
1039	return Type::getInt1Ty(opnd_type->getContext());
1040	}
1041
1042	private:
1043	// Shadow Value::setValueSubclassData with a private forwarding method so that
1044	// subclasses cannot accidentally use it.
1045	void setValueSubclassData(unsigned short D) {
1046	Value::setValueSubclassData(D);
1047	}
1048	};
1049
1050	// FIXME: these are redundant if CmpInst < BinaryOperator
1051	template <>
1052	struct OperandTraits<CmpInst> : public FixedNumOperandTraits<CmpInst, `2`> {
1053	};
1054
1055	DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CmpInst, Value)
1056
1057	/// A lightweight accessor for an operand bundle meant to be passed
1058	/// around by value.
1059	struct OperandBundleUse {
1060	ArrayRef<Use> Inputs;
1061
1062	OperandBundleUse() = default;
1063	explicit OperandBundleUse(StringMapEntry<uint32_t> *Tag, ArrayRef<Use> Inputs)
1064	: Inputs (Inputs), Tag(Tag) {}
1065
1066	/// Return true if the operand at index \p Idx in this operand bundle
1067	/// has the attribute A.
1068	bool operandHasAttr(unsigned Idx, Attribute::AttrKind A) const {
1069	if (isDeoptOperandBundle())
1070	if (A == Attribute::ReadOnly \|\| A == Attribute::NoCapture)
1071	return Inputs [Idx]->getType()->isPointerTy();
1072
1073	// Conservative answer: no operands have any attributes.
1074	return false;
1075	}
1076
1077	/// Return the tag of this operand bundle as a string.
1078	StringRef getTagName() const {
1079	return Tag->getKey();
1080	}
1081
1082	/// Return the tag of this operand bundle as an integer.
1083	///
1084	/// Operand bundle tags are interned by LLVMContextImpl::getOrInsertBundleTag,
1085	/// and this function returns the unique integer getOrInsertBundleTag
1086	/// associated the tag of this operand bundle to.
1087	uint32_t getTagID() const {
1088	return Tag->getValue();
1089	}
1090
1091	/// Return true if this is a "deopt" operand bundle.
1092	bool isDeoptOperandBundle() const {
1093	return getTagID() == LLVMContext::OB_deopt;
1094	}
1095
1096	/// Return true if this is a "funclet" operand bundle.
1097	bool isFuncletOperandBundle() const {
1098	return getTagID() == LLVMContext::OB_funclet;
1099	}
1100
1101	/// Return true if this is a "cfguardtarget" operand bundle.
1102	bool isCFGuardTargetOperandBundle() const {
1103	return getTagID() == LLVMContext::OB_cfguardtarget;
1104	}
1105
1106	private:
1107	/// Pointer to an entry in LLVMContextImpl::getOrInsertBundleTag.
1108	StringMapEntry<uint32_t> *Tag;
1109	};
1110
1111	/// A container for an operand bundle being viewed as a set of values
1112	/// rather than a set of uses.
1113	///
1114	/// Unlike OperandBundleUse, OperandBundleDefT owns the memory it carries, and
1115	/// so it is possible to create and pass around "self-contained" instances of
1116	/// OperandBundleDef and ConstOperandBundleDef.
1117	template <typename InputTy> class OperandBundleDefT {
1118	std::string Tag;
1119	std::vector<InputTy> Inputs;
1120
1121	public:
1122	explicit OperandBundleDefT(std::string Tag, std::vector<InputTy> Inputs)
1123	: Tag (std::move(Tag)), Inputs(std::move(Inputs)) {}
1124	explicit OperandBundleDefT(std::string Tag, ArrayRef<InputTy> Inputs)
1125	: Tag (std::move(Tag)), Inputs(Inputs) {}
1126
1127	explicit OperandBundleDefT(const OperandBundleUse &OBU) {
1128	Tag = std::string (OBU.getTagName());
1129	llvm::append_range(Inputs, OBU.Inputs);
1130	}
1131
1132	ArrayRef<InputTy> inputs() const { return Inputs; }
1133
1134	using input_iterator = typename std::vector<InputTy>::const_iterator;
1135
1136	size_t input_size() const { return Inputs.size(); }
1137	input_iterator input_begin() const { return Inputs.begin(); }
1138	input_iterator input_end() const { return Inputs.end(); }
1139
1140	StringRef getTag() const { return Tag; }
1141	};
1142
1143	using OperandBundleDef = OperandBundleDefT<Value *>;
1144	using ConstOperandBundleDef = OperandBundleDefT<const Value *>;
1145
1146	//===----------------------------------------------------------------------===//
1147	// CallBase Class
1148	//===----------------------------------------------------------------------===//
1149
1150	/// Base class for all callable instructions (InvokeInst and CallInst)
1151	/// Holds everything related to calling a function.
1152	///
1153	/// All call-like instructions are required to use a common operand layout:
1154	/// - Zero or more arguments to the call,
1155	/// - Zero or more operand bundles with zero or more operand inputs each
1156	/// bundle,
1157	/// - Zero or more subclass controlled operands
1158	/// - The called function.
1159	///
1160	/// This allows this base class to easily access the called function and the
1161	/// start of the arguments without knowing how many other operands a particular
1162	/// subclass requires. Note that accessing the end of the argument list isn't
1163	/// as cheap as most other operations on the base class.
1164	class CallBase : public Instruction {
1165	protected:
1166	// The first two bits are reserved by CallInst for fast retrieval,
1167	using CallInstReservedField = Bitfield::Element<unsigned, `0`, `2`>;
1168	using CallingConvField =
1169	Bitfield::Element<CallingConv::ID, CallInstReservedField::NextBit, `10`,
1170	CallingConv::MaxID>;
1171	static_assert(
1172	Bitfield::areContiguous<CallInstReservedField, CallingConvField>(),
1173	"Bitfields must be contiguous");
1174
1175	/// The last operand is the called operand.
1176	static constexpr int CalledOperandOpEndIdx = -`1`;
1177
1178	AttributeList Attrs; ///< parameter attributes for callable
1179	FunctionType *FTy;
1180
1181	template <class... ArgsTy>
1182	CallBase(AttributeList const &A, FunctionType *FT, ArgsTy &&... Args)
1183	: Instruction(std::forward<ArgsTy>(Args)...), Attrs (A), FTy(FT) {}
1184
1185	using Instruction::Instruction;
1186
1187	bool hasDescriptor() const { return Value::HasDescriptor; }
1188
1189	unsigned getNumSubclassExtraOperands() const {
1190	switch (getOpcode()) {
1191	case Instruction::Call:
1192	return `0`;
1193	case Instruction::Invoke:
1194	return `2`;
1195	case Instruction::CallBr:
1196	return getNumSubclassExtraOperandsDynamic();
1197	}
1198	llvm_unreachable("Invalid opcode!");
1199	}
1200
1201	/// Get the number of extra operands for instructions that don't have a fixed
1202	/// number of extra operands.
1203	unsigned getNumSubclassExtraOperandsDynamic() const;
1204
1205	public:
1206	using Instruction::getContext;
1207
1208	/// Create a clone of \p CB with a different set of operand bundles and
1209	/// insert it before \p InsertPt.
1210	///
1211	/// The returned call instruction is identical \p CB in every way except that
1212	/// the operand bundles for the new instruction are set to the operand bundles
1213	/// in \p Bundles.
1214	static CallBase Create(CallBase CB, ArrayRef<OperandBundleDef> Bundles,
1215	Instruction InsertPt = nullptr*);
1216
1217	/// Create a clone of \p CB with the operand bundle with the tag matching
1218	/// \p Bundle's tag replaced with Bundle, and insert it before \p InsertPt.
1219	///
1220	/// The returned call instruction is identical \p CI in every way except that
1221	/// the specified operand bundle has been replaced.
1222	static CallBase Create(CallBase CB,
1223	OperandBundleDef Bundle,
1224	Instruction InsertPt = nullptr*);
1225
1226	/// Create a clone of \p CB with operand bundle \p OB added.
1227	static CallBase addOperandBundle(CallBase CB, uint32_t ID,
1228	OperandBundleDef OB,
1229	Instruction InsertPt = nullptr*);
1230
1231	/// Create a clone of \p CB with operand bundle \p ID removed.
1232	static CallBase removeOperandBundle(CallBase CB, uint32_t ID,
1233	Instruction InsertPt = nullptr*);
1234
1235	static bool classof(const Instruction *I) {
1236	return I->getOpcode() == Instruction::Call \|\|
1237	I->getOpcode() == Instruction::Invoke \|\|
1238	I->getOpcode() == Instruction::CallBr;
1239	}
1240	static bool classof(const Value *V) {
1241	return isa<Instruction>(V) && classof(cast<Instruction>(V));
1242	}
1243
1244	FunctionType getFunctionType() const* { return FTy; }
1245
1246	void mutateFunctionType(FunctionType *FTy) {
1247	Value::mutateType(FTy->getReturnType());
1248	this->FTy = FTy;
1249	}
1250
1251	DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1252
1253	/// data_operands_begin/data_operands_end - Return iterators iterating over
1254	/// the call / invoke argument list and bundle operands. For invokes, this is
1255	/// the set of instruction operands except the invoke target and the two
1256	/// successor blocks; and for calls this is the set of instruction operands
1257	/// except the call target.
1258	User::op_iterator data_operands_begin() { return op_begin(); }
1259	User::const_op_iterator data_operands_begin() const {
1260	return const_cast<CallBase >(this*)->data_operands_begin();
1261	}
1262	User::op_iterator data_operands_end() {
1263	// Walk from the end of the operands over the called operand and any
1264	// subclass operands.
1265	return op_end() - getNumSubclassExtraOperands() - `1`;
1266	}
1267	User::const_op_iterator data_operands_end() const {
1268	return const_cast<CallBase >(this*)->data_operands_end();
1269	}
1270	iterator_range<User::op_iterator> data_ops() {
1271	return make_range(data_operands_begin(), data_operands_end());
1272	}
1273	iterator_range<User::const_op_iterator> data_ops() const {
1274	return make_range(data_operands_begin(), data_operands_end());
1275	}
1276	bool data_operands_empty() const {
1277	return data_operands_end() == data_operands_begin();
1278	}
1279	unsigned data_operands_size() const {
1280	return std::distance(data_operands_begin(), data_operands_end());
1281	}
1282
1283	bool isDataOperand(const Use U) const* {
1284	assert(this == U->getUser() &&
1285	"Only valid to query with a use of this instruction!");
1286	return data_operands_begin() <= U && U < data_operands_end();
1287	}
1288	bool isDataOperand(Value::const_user_iterator UI) const {
1289	return isDataOperand(&UI.getUse());
1290	}
1291
1292	/// Given a value use iterator, return the data operand corresponding to it.
1293	/// Iterator must actually correspond to a data operand.
1294	unsigned getDataOperandNo(Value::const_user_iterator UI) const {
1295	return getDataOperandNo(&UI.getUse());
1296	}
1297
1298	/// Given a use for a data operand, get the data operand number that
1299	/// corresponds to it.
1300	unsigned getDataOperandNo(const Use U) const* {
1301	assert(isDataOperand(U) && "Data operand # out of range!");
1302	return U - data_operands_begin();
1303	}
1304
1305	/// Return the iterator pointing to the beginning of the argument list.
1306	User::op_iterator arg_begin() { return op_begin(); }
1307	User::const_op_iterator arg_begin() const {
1308	return const_cast<CallBase >(this*)->arg_begin();
1309	}
1310
1311	/// Return the iterator pointing to the end of the argument list.
1312	User::op_iterator arg_end() {
1313	// From the end of the data operands, walk backwards past the bundle
1314	// operands.
1315	return data_operands_end() - getNumTotalBundleOperands();
1316	}
1317	User::const_op_iterator arg_end() const {
1318	return const_cast<CallBase >(this*)->arg_end();
1319	}
1320
1321	/// Iteration adapter for range-for loops.
1322	iterator_range<User::op_iterator> args() {
1323	return make_range(arg_begin(), arg_end());
1324	}
1325	iterator_range<User::const_op_iterator> args() const {
1326	return make_range(arg_begin(), arg_end());
1327	}
1328	bool arg_empty() const { return arg_end() == arg_begin(); }
1329	unsigned arg_size() const { return arg_end() - arg_begin(); }
1330
1331	// Legacy API names that duplicate the above and will be removed once users
1332	// are migrated.
1333	iterator_range<User::op_iterator> arg_operands() {
1334	return make_range(arg_begin(), arg_end());
1335	}
1336	iterator_range<User::const_op_iterator> arg_operands() const {
1337	return make_range(arg_begin(), arg_end());
1338	}
1339	unsigned getNumArgOperands() const { return arg_size(); }
1340
1341	Value getArgOperand(unsigned* i) const {
1342	assert(i < getNumArgOperands() && "Out of bounds!");
1343	return getOperand(i);
1344	}
1345
1346	void setArgOperand(unsigned i, Value *v) {
1347	assert(i < getNumArgOperands() && "Out of bounds!");
1348	setOperand(i, v);
1349	}
1350
1351	/// Wrappers for getting the \c Use of a call argument.
1352	const Use &getArgOperandUse(unsigned i) const {
1353	assert(i < getNumArgOperands() && "Out of bounds!");
1354	return User::getOperandUse(i);
1355	}
1356	Use &getArgOperandUse(unsigned i) {
1357	assert(i < getNumArgOperands() && "Out of bounds!");
1358	return User::getOperandUse(i);
1359	}
1360
1361	bool isArgOperand(const Use U) const* {
1362	assert(this == U->getUser() &&
1363	"Only valid to query with a use of this instruction!");
1364	return arg_begin() <= U && U < arg_end();
1365	}
1366	bool isArgOperand(Value::const_user_iterator UI) const {
1367	return isArgOperand(&UI.getUse());
1368	}
1369
1370	/// Given a use for a arg operand, get the arg operand number that
1371	/// corresponds to it.
1372	unsigned getArgOperandNo(const Use U) const* {
1373	assert(isArgOperand(U) && "Arg operand # out of range!");
1374	return U - arg_begin();
1375	}
1376
1377	/// Given a value use iterator, return the arg operand number corresponding to
1378	/// it. Iterator must actually correspond to a data operand.
1379	unsigned getArgOperandNo(Value::const_user_iterator UI) const {
1380	return getArgOperandNo(&UI.getUse());
1381	}
1382
1383	/// Returns true if this CallSite passes the given Value as an argument to*
1384	/// the called function.
1385	bool hasArgument(const Value V) const* {
1386	return llvm::is_contained(args(), V);
1387	}
1388
1389	Value getCalledOperand() const* { return Op<CalledOperandOpEndIdx>(); }
1390
1391	const Use &getCalledOperandUse() const { return Op<CalledOperandOpEndIdx>(); }
1392	Use &getCalledOperandUse() { return Op<CalledOperandOpEndIdx>(); }
1393
1394	/// Returns the function called, or null if this is an
1395	/// indirect function invocation.
1396	Function getCalledFunction() const* {
1397	return dyn_cast_or_null<Function>(getCalledOperand());
1398	}
1399
1400	/// Return true if the callsite is an indirect call.
1401	bool isIndirectCall() const;
1402
1403	/// Determine whether the passed iterator points to the callee operand's Use.
1404	bool isCallee(Value::const_user_iterator UI) const {
1405	return isCallee(&UI.getUse());
1406	}
1407
1408	/// Determine whether this Use is the callee operand's Use.
1409	bool isCallee(const Use U) const* { return &getCalledOperandUse() == U; }
1410
1411	/// Helper to get the caller (the parent function).
1412	Function *getCaller();
1413	const Function getCaller() const* {
1414	return const_cast<CallBase >(this*)->getCaller();
1415	}
1416
1417	/// Tests if this call site must be tail call optimized. Only a CallInst can
1418	/// be tail call optimized.
1419	bool isMustTailCall() const;
1420
1421	/// Tests if this call site is marked as a tail call.
1422	bool isTailCall() const;
1423
1424	/// Returns the intrinsic ID of the intrinsic called or
1425	/// Intrinsic::not_intrinsic if the called function is not an intrinsic, or if
1426	/// this is an indirect call.
1427	Intrinsic::ID getIntrinsicID() const;
1428
1429	void setCalledOperand(Value *V) { Op<CalledOperandOpEndIdx>() = V; }
1430
1431	/// Sets the function called, including updating the function type.
1432	void setCalledFunction(Function *Fn) {
1433	setCalledFunction(Fn->getFunctionType(), Fn);
1434	}
1435
1436	/// Sets the function called, including updating the function type.
1437	void setCalledFunction(FunctionCallee Fn) {
1438	setCalledFunction(Fn.getFunctionType(), Fn.getCallee());
1439	}
1440
1441	/// Sets the function called, including updating to the specified function
1442	/// type.
1443	void setCalledFunction(FunctionType FTy, Value Fn) {
1444	this->FTy = FTy;
1445	assert(FTy == cast<FunctionType>(
1446	cast<PointerType>(Fn->getType())->getElementType()));
1447	// This function doesn't mutate the return type, only the function
1448	// type. Seems broken, but I'm just gonna stick an assert in for now.
1449	assert(getType() == FTy->getReturnType());
1450	setCalledOperand(Fn);
1451	}
1452
1453	CallingConv::ID getCallingConv() const {
1454	return getSubclassData<CallingConvField>();
1455	}
1456
1457	void setCallingConv(CallingConv::ID CC) {
1458	setSubclassData<CallingConvField>(CC);
1459	}
1460
1461	/// Check if this call is an inline asm statement.
1462	bool isInlineAsm() const { return isa<InlineAsm>(getCalledOperand()); }
1463
1464	/// \name Attribute API
1465	///
1466	/// These methods access and modify attributes on this call (including
1467	/// looking through to the attributes on the called function when necessary).
1468	///@{
1469
1470	/// Return the parameter attributes for this call.
1471	///
1472	AttributeList getAttributes() const { return Attrs; }
1473
1474	/// Set the parameter attributes for this call.
1475	///
1476	void setAttributes(AttributeList A) { Attrs = A; }
1477
1478	/// Determine whether this call has the given attribute. If it does not
1479	/// then determine if the called function has the attribute, but only if
1480	/// the attribute is allowed for the call.
1481	bool hasFnAttr(Attribute::AttrKind Kind) const {
1482	assert(Kind != Attribute::NoBuiltin &&
1483	"Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin");
1484	return hasFnAttrImpl(Kind);
1485	}
1486
1487	/// Determine whether this call has the given attribute. If it does not
1488	/// then determine if the called function has the attribute, but only if
1489	/// the attribute is allowed for the call.
1490	bool hasFnAttr(StringRef Kind) const { return hasFnAttrImpl(Kind); }
1491
1492	/// adds the attribute to the list of attributes.
1493	void addAttribute(unsigned i, Attribute::AttrKind Kind) {
1494	AttributeList PAL = getAttributes();
1495	PAL = PAL.addAttribute(getContext(), i, Kind);
1496	setAttributes(PAL);
1497	}
1498
1499	/// adds the attribute to the list of attributes.
1500	void addAttribute(unsigned i, Attribute Attr) {
1501	AttributeList PAL = getAttributes();
1502	PAL = PAL.addAttribute(getContext(), i, Attr);
1503	setAttributes(PAL);
1504	}
1505
1506	/// Adds the attribute to the indicated argument
1507	void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
1508	assert(ArgNo < getNumArgOperands() && "Out of bounds");
1509	AttributeList PAL = getAttributes();
1510	PAL = PAL.addParamAttribute(getContext(), ArgNo, Kind);
1511	setAttributes(PAL);
1512	}
1513
1514	/// Adds the attribute to the indicated argument
1515	void addParamAttr(unsigned ArgNo, Attribute Attr) {
1516	assert(ArgNo < getNumArgOperands() && "Out of bounds");
1517	AttributeList PAL = getAttributes();
1518	PAL = PAL.addParamAttribute(getContext(), ArgNo, Attr);
1519	setAttributes(PAL);
1520	}
1521
1522	/// removes the attribute from the list of attributes.
1523	void removeAttribute(unsigned i, Attribute::AttrKind Kind) {
1524	AttributeList PAL = getAttributes();
1525	PAL = PAL.removeAttribute(getContext(), i, Kind);
1526	setAttributes(PAL);
1527	}
1528
1529	/// removes the attribute from the list of attributes.
1530	void removeAttribute(unsigned i, StringRef Kind) {
1531	AttributeList PAL = getAttributes();
1532	PAL = PAL.removeAttribute(getContext(), i, Kind);
1533	setAttributes(PAL);
1534	}
1535
1536	void removeAttributes(unsigned i, const AttrBuilder &Attrs) {
1537	AttributeList PAL = getAttributes();
1538	PAL = PAL.removeAttributes(getContext(), i, Attrs);
1539	setAttributes(PAL);
1540	}
1541
1542	/// Removes the attribute from the given argument
1543	void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
1544	assert(ArgNo < getNumArgOperands() && "Out of bounds");
1545	AttributeList PAL = getAttributes();
1546	PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind);
1547	setAttributes(PAL);
1548	}
1549
1550	/// Removes the attribute from the given argument
1551	void removeParamAttr(unsigned ArgNo, StringRef Kind) {
1552	assert(ArgNo < getNumArgOperands() && "Out of bounds");
1553	AttributeList PAL = getAttributes();
1554	PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind);
1555	setAttributes(PAL);
1556	}
1557
1558	/// Removes noundef and other attributes that imply undefined behavior if a
1559	/// `undef` or `poison` value is passed from the given argument.
1560	void removeParamUndefImplyingAttrs(unsigned ArgNo) {
1561	assert(ArgNo < getNumArgOperands() && "Out of bounds");
1562	AttributeList PAL = getAttributes();
1563	PAL = PAL.removeParamUndefImplyingAttributes(getContext(), ArgNo);
1564	setAttributes(PAL);
1565	}
1566
1567	/// adds the dereferenceable attribute to the list of attributes.
1568	void addDereferenceableAttr(unsigned i, uint64_t Bytes) {
1569	AttributeList PAL = getAttributes();
1570	PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes);
1571	setAttributes(PAL);
1572	}
1573
1574	/// adds the dereferenceable_or_null attribute to the list of
1575	/// attributes.
1576	void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) {
1577	AttributeList PAL = getAttributes();
1578	PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes);
1579	setAttributes(PAL);
1580	}
1581
1582	/// Determine whether the return value has the given attribute.
1583	bool hasRetAttr(Attribute::AttrKind Kind) const {
1584	return hasRetAttrImpl(Kind);
1585	}
1586	/// Determine whether the return value has the given attribute.
1587	bool hasRetAttr(StringRef Kind) const { return hasRetAttrImpl(Kind); }
1588
1589	/// Determine whether the argument or parameter has the given attribute.
1590	bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const;
1591
1592	/// Get the attribute of a given kind at a position.
1593	Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const {
1594	return getAttributes().getAttribute(i, Kind);
1595	}
1596
1597	/// Get the attribute of a given kind at a position.
1598	Attribute getAttribute(unsigned i, StringRef Kind) const {
1599	return getAttributes().getAttribute(i, Kind);
1600	}
1601
1602	/// Get the attribute of a given kind from a given arg
1603	Attribute getParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
1604	assert(ArgNo < getNumArgOperands() && "Out of bounds");
1605	return getAttributes().getParamAttr(ArgNo, Kind);
1606	}
1607
1608	/// Get the attribute of a given kind from a given arg
1609	Attribute getParamAttr(unsigned ArgNo, StringRef Kind) const {
1610	assert(ArgNo < getNumArgOperands() && "Out of bounds");
1611	return getAttributes().getParamAttr(ArgNo, Kind);
1612	}
1613
1614	/// Return true if the data operand at index \p i has the attribute \p
1615	/// A.
1616	///
1617	/// Data operands include call arguments and values used in operand bundles,
1618	/// but does not include the callee operand. This routine dispatches to the
1619	/// underlying AttributeList or the OperandBundleUser as appropriate.
1620	///
1621	/// The index \p i is interpreted as
1622	///
1623	/// \p i == Attribute::ReturnIndex -> the return value
1624	/// \p i in [1, arg_size + 1) -> argument number (\p i - 1)
1625	/// \p i in [arg_size + 1, data_operand_size + 1) -> bundle operand at index
1626	/// (\p i - 1) in the operand list.
1627	bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind Kind) const {
1628	// Note that we have to add one because `i` isn't zero-indexed.
1629	assert(i < (getNumArgOperands() + getNumTotalBundleOperands() + `1`) &&
1630	"Data operand index out of bounds!");
1631
1632	// The attribute A can either be directly specified, if the operand in
1633	// question is a call argument; or be indirectly implied by the kind of its
1634	// containing operand bundle, if the operand is a bundle operand.
1635
1636	if (i == AttributeList::ReturnIndex)
1637	return hasRetAttr(Kind);
1638
1639	// FIXME: Avoid these i - 1 calculations and update the API to use
1640	// zero-based indices.
1641	if (i < (getNumArgOperands() + `1`))
1642	return paramHasAttr(i - `1`, Kind);
1643
1644	assert(hasOperandBundles() && i >= (getBundleOperandsStartIndex() + `1`) &&
1645	"Must be either a call argument or an operand bundle!");
1646	return bundleOperandHasAttr(i - `1`, Kind);
1647	}
1648
1649	/// Determine whether this data operand is not captured.
1650	// FIXME: Once this API is no longer duplicated in `CallSite`, rename this to
1651	// better indicate that this may return a conservative answer.
1652	bool doesNotCapture(unsigned OpNo) const {
1653	return dataOperandHasImpliedAttr(OpNo + `1`, Attribute::NoCapture);
1654	}
1655
1656	/// Determine whether this argument is passed by value.
1657	bool isByValArgument(unsigned ArgNo) const {
1658	return paramHasAttr(ArgNo, Attribute::ByVal);
1659	}
1660
1661	/// Determine whether this argument is passed in an alloca.
1662	bool isInAllocaArgument(unsigned ArgNo) const {
1663	return paramHasAttr(ArgNo, Attribute::InAlloca);
1664	}
1665
1666	/// Determine whether this argument is passed by value, in an alloca, or is
1667	/// preallocated.
1668	bool isPassPointeeByValueArgument(unsigned ArgNo) const {
1669	return paramHasAttr(ArgNo, Attribute::ByVal) \|\|
1670	paramHasAttr(ArgNo, Attribute::InAlloca) \|\|
1671	paramHasAttr(ArgNo, Attribute::Preallocated);
1672	}
1673
1674	/// Determine whether passing undef to this argument is undefined behavior.
1675	/// If passing undef to this argument is UB, passing poison is UB as well
1676	/// because poison is more undefined than undef.
1677	bool isPassingUndefUB(unsigned ArgNo) const {
1678	return paramHasAttr(ArgNo, Attribute::NoUndef) \|\|
1679	// dereferenceable implies noundef.
1680	paramHasAttr(ArgNo, Attribute::Dereferenceable) \|\|
1681	// dereferenceable implies noundef, and null is a well-defined value.
1682	paramHasAttr(ArgNo, Attribute::DereferenceableOrNull);
1683	}
1684
1685	/// Determine if there are is an inalloca argument. Only the last argument can
1686	/// have the inalloca attribute.
1687	bool hasInAllocaArgument() const {
1688	return !arg_empty() && paramHasAttr(arg_size() - `1`, Attribute::InAlloca);
1689	}
1690
1691	// FIXME: Once this API is no longer duplicated in `CallSite`, rename this to
1692	// better indicate that this may return a conservative answer.
1693	bool doesNotAccessMemory(unsigned OpNo) const {
1694	return dataOperandHasImpliedAttr(OpNo + `1`, Attribute::ReadNone);
1695	}
1696
1697	// FIXME: Once this API is no longer duplicated in `CallSite`, rename this to
1698	// better indicate that this may return a conservative answer.
1699	bool onlyReadsMemory(unsigned OpNo) const {
1700	return dataOperandHasImpliedAttr(OpNo + `1`, Attribute::ReadOnly) \|\|
1701	dataOperandHasImpliedAttr(OpNo + `1`, Attribute::ReadNone);
1702	}
1703
1704	// FIXME: Once this API is no longer duplicated in `CallSite`, rename this to
1705	// better indicate that this may return a conservative answer.
1706	bool doesNotReadMemory(unsigned OpNo) const {
1707	return dataOperandHasImpliedAttr(OpNo + `1`, Attribute::WriteOnly) \|\|
1708	dataOperandHasImpliedAttr(OpNo + `1`, Attribute::ReadNone);
1709	}
1710
1711	LLVM_ATTRIBUTE_DEPRECATED(unsigned getRetAlignment() const,
1712	"Use getRetAlign() instead") {
1713	if (const auto MA = Attrs.getRetAlignment())
1714	return MA ->value();
1715	return `0`;
1716	}
1717
1718	/// Extract the alignment of the return value.
1719	MaybeAlign getRetAlign() const { return Attrs.getRetAlignment(); }
1720
1721	/// Extract the alignment for a call or parameter (0=unknown).
1722	LLVM_ATTRIBUTE_DEPRECATED(unsigned getParamAlignment(unsigned ArgNo) const,
1723	"Use getParamAlign() instead") {
1724	if (const auto MA = Attrs.getParamAlignment(ArgNo))
1725	return MA ->value();
1726	return `0`;
1727	}
1728
1729	/// Extract the alignment for a call or parameter (0=unknown).
1730	MaybeAlign getParamAlign(unsigned ArgNo) const {
1731	return Attrs.getParamAlignment(ArgNo);
1732	}
1733
1734	MaybeAlign getParamStackAlign(unsigned ArgNo) const {
1735	return Attrs.getParamStackAlignment(ArgNo);
1736	}
1737
1738	/// Extract the byval type for a call or parameter.
1739	Type getParamByValType(unsigned* ArgNo) const {
1740	Type *Ty = Attrs.getParamByValType(ArgNo);
1741	return Ty ? Ty : getArgOperand(ArgNo)->getType()->getPointerElementType();
1742	}
1743
1744	/// Extract the preallocated type for a call or parameter.
1745	Type getParamPreallocatedType(unsigned* ArgNo) const {
1746	Type *Ty = Attrs.getParamPreallocatedType(ArgNo);
1747	return Ty ? Ty : getArgOperand(ArgNo)->getType()->getPointerElementType();
1748	}
1749
1750	/// Extract the number of dereferenceable bytes for a call or
1751	/// parameter (0=unknown).
1752	uint64_t getDereferenceableBytes(unsigned i) const {
1753	return Attrs.getDereferenceableBytes(i);
1754	}
1755
1756	/// Extract the number of dereferenceable_or_null bytes for a call or
1757	/// parameter (0=unknown).
1758	uint64_t getDereferenceableOrNullBytes(unsigned i) const {
1759	return Attrs.getDereferenceableOrNullBytes(i);
1760	}
1761
1762	/// Return true if the return value is known to be not null.
1763	/// This may be because it has the nonnull attribute, or because at least
1764	/// one byte is dereferenceable and the pointer is in addrspace(0).
1765	bool isReturnNonNull() const;
1766
1767	/// Determine if the return value is marked with NoAlias attribute.
1768	bool returnDoesNotAlias() const {
1769	return Attrs.hasAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
1770	}
1771
1772	/// If one of the arguments has the 'returned' attribute, returns its
1773	/// operand value. Otherwise, return nullptr.
1774	Value getReturnedArgOperand() const*;
1775
1776	/// Return true if the call should not be treated as a call to a
1777	/// builtin.
1778	bool isNoBuiltin() const {
1779	return hasFnAttrImpl(Attribute::NoBuiltin) &&
1780	!hasFnAttrImpl(Attribute::Builtin);
1781	}
1782
1783	/// Determine if the call requires strict floating point semantics.
1784	bool isStrictFP() const { return hasFnAttr(Attribute::StrictFP); }
1785
1786	/// Return true if the call should not be inlined.
1787	bool isNoInline() const { return hasFnAttr(Attribute::NoInline); }
1788	void setIsNoInline() {
1789	addAttribute(AttributeList::FunctionIndex, Attribute::NoInline);
1790	}
1791	/// Determine if the call does not access memory.
1792	bool doesNotAccessMemory() const { return hasFnAttr(Attribute::ReadNone); }
1793	void setDoesNotAccessMemory() {
1794	addAttribute(AttributeList::FunctionIndex, Attribute::ReadNone);
1795	}
1796
1797	/// Determine if the call does not access or only reads memory.
1798	bool onlyReadsMemory() const {
1799	return doesNotAccessMemory() \|\| hasFnAttr(Attribute::ReadOnly);
1800	}
1801
1802	void setOnlyReadsMemory() {
1803	addAttribute(AttributeList::FunctionIndex, Attribute::ReadOnly);
1804	}
1805
1806	/// Determine if the call does not access or only writes memory.
1807	bool doesNotReadMemory() const {
1808	return doesNotAccessMemory() \|\| hasFnAttr(Attribute::WriteOnly);
1809	}
1810	void setDoesNotReadMemory() {
1811	addAttribute(AttributeList::FunctionIndex, Attribute::WriteOnly);
1812	}
1813
1814	/// Determine if the call can access memmory only using pointers based
1815	/// on its arguments.
1816	bool onlyAccessesArgMemory() const {
1817	return hasFnAttr(Attribute::ArgMemOnly);
1818	}
1819	void setOnlyAccessesArgMemory() {
1820	addAttribute(AttributeList::FunctionIndex, Attribute::ArgMemOnly);
1821	}
1822
1823	/// Determine if the function may only access memory that is
1824	/// inaccessible from the IR.
1825	bool onlyAccessesInaccessibleMemory() const {
1826	return hasFnAttr(Attribute::InaccessibleMemOnly);
1827	}
1828	void setOnlyAccessesInaccessibleMemory() {
1829	addAttribute(AttributeList::FunctionIndex, Attribute::InaccessibleMemOnly);
1830	}
1831
1832	/// Determine if the function may only access memory that is
1833	/// either inaccessible from the IR or pointed to by its arguments.
1834	bool onlyAccessesInaccessibleMemOrArgMem() const {
1835	return hasFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
1836	}
1837	void setOnlyAccessesInaccessibleMemOrArgMem() {
1838	addAttribute(AttributeList::FunctionIndex,
1839	Attribute::InaccessibleMemOrArgMemOnly);
1840	}
1841	/// Determine if the call cannot return.
1842	bool doesNotReturn() const { return hasFnAttr(Attribute::NoReturn); }
1843	void setDoesNotReturn() {
1844	addAttribute(AttributeList::FunctionIndex, Attribute::NoReturn);
1845	}
1846
1847	/// Determine if the call should not perform indirect branch tracking.
1848	bool doesNoCfCheck() const { return hasFnAttr(Attribute::NoCfCheck); }
1849
1850	/// Determine if the call cannot unwind.
1851	bool doesNotThrow() const { return hasFnAttr(Attribute::NoUnwind); }
1852	void setDoesNotThrow() {
1853	addAttribute(AttributeList::FunctionIndex, Attribute::NoUnwind);
1854	}
1855
1856	/// Determine if the invoke cannot be duplicated.
1857	bool cannotDuplicate() const { return hasFnAttr(Attribute::NoDuplicate); }
1858	void setCannotDuplicate() {
1859	addAttribute(AttributeList::FunctionIndex, Attribute::NoDuplicate);
1860	}
1861
1862	/// Determine if the call cannot be tail merged.
1863	bool cannotMerge() const { return hasFnAttr(Attribute::NoMerge); }
1864	void setCannotMerge() {
1865	addAttribute(AttributeList::FunctionIndex, Attribute::NoMerge);
1866	}
1867
1868	/// Determine if the invoke is convergent
1869	bool isConvergent() const { return hasFnAttr(Attribute::Convergent); }
1870	void setConvergent() {
1871	addAttribute(AttributeList::FunctionIndex, Attribute::Convergent);
1872	}
1873	void setNotConvergent() {
1874	removeAttribute(AttributeList::FunctionIndex, Attribute::Convergent);
1875	}
1876
1877	/// Determine if the call returns a structure through first
1878	/// pointer argument.
1879	bool hasStructRetAttr() const {
1880	if (getNumArgOperands() == `0`)
1881	return false;
1882
1883	// Be friendly and also check the callee.
1884	return paramHasAttr(`0`, Attribute::StructRet);
1885	}
1886
1887	/// Determine if any call argument is an aggregate passed by value.
1888	bool hasByValArgument() const {
1889	return Attrs.hasAttrSomewhere(Attribute::ByVal);
1890	}
1891
1892	///@{
1893	// End of attribute API.
1894
1895	/// \name Operand Bundle API
1896	///
1897	/// This group of methods provides the API to access and manipulate operand
1898	/// bundles on this call.
1899	/// @{
1900
1901	/// Return the number of operand bundles associated with this User.
1902	unsigned getNumOperandBundles() const {
1903	return std::distance(bundle_op_info_begin(), bundle_op_info_end());
1904	}
1905
1906	/// Return true if this User has any operand bundles.
1907	bool hasOperandBundles() const { return getNumOperandBundles() != `0`; }
1908
1909	/// Return the index of the first bundle operand in the Use array.
1910	unsigned getBundleOperandsStartIndex() const {
1911	assert(hasOperandBundles() && "Don't call otherwise!");
1912	return bundle_op_info_begin()->Begin;
1913	}
1914
1915	/// Return the index of the last bundle operand in the Use array.
1916	unsigned getBundleOperandsEndIndex() const {
1917	assert(hasOperandBundles() && "Don't call otherwise!");
1918	return bundle_op_info_end()[-`1`].End;
1919	}
1920
1921	/// Return true if the operand at index \p Idx is a bundle operand.
1922	bool isBundleOperand(unsigned Idx) const {
1923	return hasOperandBundles() && Idx >= getBundleOperandsStartIndex() &&
1924	Idx < getBundleOperandsEndIndex();
1925	}
1926
1927	/// Returns true if the use is a bundle operand.
1928	bool isBundleOperand(const Use U) const* {
1929	assert(this == U->getUser() &&
1930	"Only valid to query with a use of this instruction!");
1931	return hasOperandBundles() && isBundleOperand(U - op_begin());
1932	}
1933	bool isBundleOperand(Value::const_user_iterator UI) const {
1934	return isBundleOperand(&UI.getUse());
1935	}
1936
1937	/// Return the total number operands (not operand bundles) used by
1938	/// every operand bundle in this OperandBundleUser.
1939	unsigned getNumTotalBundleOperands() const {
1940	if (!hasOperandBundles())
1941	return `0`;
1942
1943	unsigned Begin = getBundleOperandsStartIndex();
1944	unsigned End = getBundleOperandsEndIndex();
1945
1946	assert(Begin <= End && "Should be!");
1947	return End - Begin;
1948	}
1949
1950	/// Return the operand bundle at a specific index.
1951	OperandBundleUse getOperandBundleAt(unsigned Index) const {
1952	assert(Index < getNumOperandBundles() && "Index out of bounds!");
1953	return operandBundleFromBundleOpInfo(*(bundle_op_info_begin() + Index));
1954	}
1955
1956	/// Return the number of operand bundles with the tag Name attached to
1957	/// this instruction.
1958	unsigned countOperandBundlesOfType(StringRef Name) const {
1959	unsigned Count = `0`;
1960	for (unsigned i = `0`, e = getNumOperandBundles(); i != e; ++i)
1961	if (getOperandBundleAt(i).getTagName() == Name)
1962	Count++;
1963
1964	return Count;
1965	}
1966
1967	/// Return the number of operand bundles with the tag ID attached to
1968	/// this instruction.
1969	unsigned countOperandBundlesOfType(uint32_t ID) const {
1970	unsigned Count = `0`;
1971	for (unsigned i = `0`, e = getNumOperandBundles(); i != e; ++i)
1972	if (getOperandBundleAt(i).getTagID() == ID)
1973	Count++;
1974
1975	return Count;
1976	}
1977
1978	/// Return an operand bundle by name, if present.
1979	///
1980	/// It is an error to call this for operand bundle types that may have
1981	/// multiple instances of them on the same instruction.
1982	Optional<OperandBundleUse> getOperandBundle(StringRef Name) const {
1983	assert(countOperandBundlesOfType(Name) < `2` && "Precondition violated!");
1984
1985	for (unsigned i = `0`, e = getNumOperandBundles(); i != e; ++i) {
1986	OperandBundleUse U = getOperandBundleAt(i);
1987	if (U.getTagName() == Name)
1988	return U;
1989	}
1990
1991	return None;
1992	}
1993
1994	/// Return an operand bundle by tag ID, if present.
1995	///
1996	/// It is an error to call this for operand bundle types that may have
1997	/// multiple instances of them on the same instruction.
1998	Optional<OperandBundleUse> getOperandBundle(uint32_t ID) const {
1999	assert(countOperandBundlesOfType(ID) < `2` && "Precondition violated!");
2000
2001	for (unsigned i = `0`, e = getNumOperandBundles(); i != e; ++i) {
2002	OperandBundleUse U = getOperandBundleAt(i);
2003	if (U.getTagID() == ID)
2004	return U;
2005	}
2006
2007	return None;
2008	}
2009
2010	/// Return the list of operand bundles attached to this instruction as
2011	/// a vector of OperandBundleDefs.
2012	///
2013	/// This function copies the OperandBundeUse instances associated with this
2014	/// OperandBundleUser to a vector of OperandBundleDefs. Note:
2015	/// OperandBundeUses and OperandBundleDefs are non-trivially different
2016	/// representations of operand bundles (see documentation above).
2017	void getOperandBundlesAsDefs(SmallVectorImpl<OperandBundleDef> &Defs) const;
2018
2019	/// Return the operand bundle for the operand at index OpIdx.
2020	///
2021	/// It is an error to call this with an OpIdx that does not correspond to an
2022	/// bundle operand.
2023	OperandBundleUse getOperandBundleForOperand(unsigned OpIdx) const {
2024	return operandBundleFromBundleOpInfo(getBundleOpInfoForOperand(OpIdx));
2025	}
2026
2027	/// Return true if this operand bundle user has operand bundles that
2028	/// may read from the heap.
2029	bool hasReadingOperandBundles() const;
2030
2031	/// Return true if this operand bundle user has operand bundles that
2032	/// may write to the heap.
2033	bool hasClobberingOperandBundles() const {
2034	for (auto &BOI : bundle_op_infos()) {
2035	if (BOI.Tag->second == LLVMContext::OB_deopt \|\|
2036	BOI.Tag->second == LLVMContext::OB_funclet)
2037	continue;
2038
2039	// This instruction has an operand bundle that is not known to us.
2040	// Assume the worst.
2041	return true;
2042	}
2043
2044	return false;
2045	}
2046
2047	/// Return true if the bundle operand at index \p OpIdx has the
2048	/// attribute \p A.
2049	bool bundleOperandHasAttr(unsigned OpIdx, Attribute::AttrKind A) const {
2050	auto &BOI = getBundleOpInfoForOperand(OpIdx);
2051	auto OBU = operandBundleFromBundleOpInfo(BOI);
2052	return OBU.operandHasAttr(OpIdx - BOI.Begin, A);
2053	}
2054
2055	/// Return true if \p Other has the same sequence of operand bundle
2056	/// tags with the same number of operands on each one of them as this
2057	/// OperandBundleUser.
2058	bool hasIdenticalOperandBundleSchema(const CallBase &Other) const {
2059	if (getNumOperandBundles() != Other.getNumOperandBundles())
2060	return false;
2061
2062	return std::equal(bundle_op_info_begin(), bundle_op_info_end(),
2063	Other.bundle_op_info_begin());
2064	}
2065
2066	/// Return true if this operand bundle user contains operand bundles
2067	/// with tags other than those specified in \p IDs.
2068	bool hasOperandBundlesOtherThan(ArrayRef<uint32_t> IDs) const {
2069	for (unsigned i = `0`, e = getNumOperandBundles(); i != e; ++i) {
2070	uint32_t ID = getOperandBundleAt(i).getTagID();
2071	if (!is_contained(IDs, ID))
2072	return true;
2073	}
2074	return false;
2075	}
2076
2077	/// Is the function attribute S disallowed by some operand bundle on
2078	/// this operand bundle user?
2079	bool isFnAttrDisallowedByOpBundle(StringRef S) const {
2080	// Operand bundles only possibly disallow readnone, readonly and argmemonly
2081	// attributes. All String attributes are fine.
2082	return false;
2083	}
2084
2085	/// Is the function attribute A disallowed by some operand bundle on
2086	/// this operand bundle user?
2087	bool isFnAttrDisallowedByOpBundle(Attribute::AttrKind A) const {
2088	switch (A) {
2089	default:
2090	return false;
2091
2092	case Attribute::InaccessibleMemOrArgMemOnly:
2093	return hasReadingOperandBundles();
2094
2095	case Attribute::InaccessibleMemOnly:
2096	return hasReadingOperandBundles();
2097
2098	case Attribute::ArgMemOnly:
2099	return hasReadingOperandBundles();
2100
2101	case Attribute::ReadNone:
2102	return hasReadingOperandBundles();
2103
2104	case Attribute::ReadOnly:
2105	return hasClobberingOperandBundles();
2106	}
2107
2108	llvm_unreachable("switch has a default case!");
2109	}
2110
2111	/// Used to keep track of an operand bundle. See the main comment on
2112	/// OperandBundleUser above.
2113	struct BundleOpInfo {
2114	/// The operand bundle tag, interned by
2115	/// LLVMContextImpl::getOrInsertBundleTag.
2116	StringMapEntry<uint32_t> *Tag;
2117
2118	/// The index in the Use& vector where operands for this operand
2119	/// bundle starts.
2120	uint32_t Begin;
2121
2122	/// The index in the Use& vector where operands for this operand
2123	/// bundle ends.
2124	uint32_t End;
2125
2126	bool operator==(const BundleOpInfo &Other) const {
2127	return Tag == Other.Tag && Begin == Other.Begin && End == Other.End;
2128	}
2129	};
2130
2131	/// Simple helper function to map a BundleOpInfo to an
2132	/// OperandBundleUse.
2133	OperandBundleUse
2134	operandBundleFromBundleOpInfo(const BundleOpInfo &BOI) const {
2135	auto begin = op_begin();
2136	ArrayRef<Use> Inputs(begin + BOI.Begin, begin + BOI.End);
2137	return OperandBundleUse (BOI.Tag, Inputs);
2138	}
2139
2140	using bundle_op_iterator = BundleOpInfo *;
2141	using const_bundle_op_iterator = const BundleOpInfo *;
2142
2143	/// Return the start of the list of BundleOpInfo instances associated
2144	/// with this OperandBundleUser.
2145	///
2146	/// OperandBundleUser uses the descriptor area co-allocated with the host User
2147	/// to store some meta information about which operands are "normal" operands,
2148	/// and which ones belong to some operand bundle.
2149	///
2150	/// The layout of an operand bundle user is
2151	///
2152	/// +-----------uint32_t End-------------------------------------+
2153	/// \| \|
2154	/// \| +--------uint32_t Begin--------------------+ \|
2155	/// \| \| \| \|
2156	/// ^ ^ v v
2157	/// \|------\|------\|----\|----\|----\|----\|----\|---------\|----\|---------\|----\|-----
2158	/// \| BOI0 \| BOI1 \| .. \| DU \| U0 \| U1 \| .. \| BOI0_U0 \| .. \| BOI1_U0 \| .. \| Un
2159	/// \|------\|------\|----\|----\|----\|----\|----\|---------\|----\|---------\|----\|-----
2160	/// v v ^ ^
2161	/// \| \| \| \|
2162	/// \| +--------uint32_t Begin------------+ \|
2163	/// \| \|
2164	/// +-----------uint32_t End-----------------------------+
2165	///
2166	///
2167	/// BOI0, BOI1 ... are descriptions of operand bundles in this User's use
2168	/// list. These descriptions are installed and managed by this class, and
2169	/// they're all instances of OperandBundleUser<T>::BundleOpInfo.
2170	///
2171	/// DU is an additional descriptor installed by User's 'operator new' to keep
2172	/// track of the 'BOI0 ... BOIN' co-allocation. OperandBundleUser does not
2173	/// access or modify DU in any way, it's an implementation detail private to
2174	/// User.
2175	///
2176	/// The regular Use& vector for the User starts at U0. The operand bundle
2177	/// uses are part of the Use& vector, just like normal uses. In the diagram
2178	/// above, the operand bundle uses start at BOI0_U0. Each instance of
2179	/// BundleOpInfo has information about a contiguous set of uses constituting
2180	/// an operand bundle, and the total set of operand bundle uses themselves
2181	/// form a contiguous set of uses (i.e. there are no gaps between uses
2182	/// corresponding to individual operand bundles).
2183	///
2184	/// This class does not know the location of the set of operand bundle uses
2185	/// within the use list -- that is decided by the User using this class via
2186	/// the BeginIdx argument in populateBundleOperandInfos.
2187	///
2188	/// Currently operand bundle users with hung-off operands are not supported.
2189	bundle_op_iterator bundle_op_info_begin() {
2190	if (!hasDescriptor())
2191	return nullptr;
2192
2193	uint8_t *BytesBegin = getDescriptor().begin();
2194	return reinterpret_cast<bundle_op_iterator>(BytesBegin);
2195	}
2196
2197	/// Return the start of the list of BundleOpInfo instances associated
2198	/// with this OperandBundleUser.
2199	const_bundle_op_iterator bundle_op_info_begin() const {
2200	auto NonConstThis = const_cast<CallBase >(this);
2201	return NonConstThis->bundle_op_info_begin();
2202	}
2203
2204	/// Return the end of the list of BundleOpInfo instances associated
2205	/// with this OperandBundleUser.
2206	bundle_op_iterator bundle_op_info_end() {
2207	if (!hasDescriptor())
2208	return nullptr;
2209
2210	uint8_t *BytesEnd = getDescriptor().end();
2211	return reinterpret_cast<bundle_op_iterator>(BytesEnd);
2212	}
2213
2214	/// Return the end of the list of BundleOpInfo instances associated
2215	/// with this OperandBundleUser.
2216	const_bundle_op_iterator bundle_op_info_end() const {
2217	auto NonConstThis = const_cast<CallBase >(this);
2218	return NonConstThis->bundle_op_info_end();
2219	}
2220
2221	/// Return the range [\p bundle_op_info_begin, \p bundle_op_info_end).
2222	iterator_range<bundle_op_iterator> bundle_op_infos() {
2223	return make_range(bundle_op_info_begin(), bundle_op_info_end());
2224	}
2225
2226	/// Return the range [\p bundle_op_info_begin, \p bundle_op_info_end).
2227	iterator_range<const_bundle_op_iterator> bundle_op_infos() const {
2228	return make_range(bundle_op_info_begin(), bundle_op_info_end());
2229	}
2230
2231	/// Populate the BundleOpInfo instances and the Use& vector from \p
2232	/// Bundles. Return the op_iterator pointing to the Use& one past the last
2233	/// last bundle operand use.
2234	///
2235	/// Each \p OperandBundleDef instance is tracked by a OperandBundleInfo
2236	/// instance allocated in this User's descriptor.
2237	op_iterator populateBundleOperandInfos(ArrayRef<OperandBundleDef> Bundles,
2238	const unsigned BeginIndex);
2239
2240	public:
2241	/// Return the BundleOpInfo for the operand at index OpIdx.
2242	///
2243	/// It is an error to call this with an OpIdx that does not correspond to an
2244	/// bundle operand.
2245	BundleOpInfo &getBundleOpInfoForOperand(unsigned OpIdx);
2246	const BundleOpInfo &getBundleOpInfoForOperand(unsigned OpIdx) const {
2247	return const_cast<CallBase >(this*)->getBundleOpInfoForOperand(OpIdx);
2248	}
2249
2250	protected:
2251	/// Return the total number of values used in \p Bundles.
2252	static unsigned CountBundleInputs(ArrayRef<OperandBundleDef> Bundles) {
2253	unsigned Total = `0`;
2254	for (auto &B : Bundles)
2255	Total += B.input_size();
2256	return Total;
2257	}
2258
2259	/// @}
2260	// End of operand bundle API.
2261
2262	private:
2263	bool hasFnAttrOnCalledFunction(Attribute::AttrKind Kind) const;
2264	bool hasFnAttrOnCalledFunction(StringRef Kind) const;
2265
2266	template <typename AttrKind> bool hasFnAttrImpl(AttrKind Kind) const {
2267	if (Attrs.hasFnAttribute(Kind))
2268	return true;
2269
2270	// Operand bundles override attributes on the called function, but don't
2271	// override attributes directly present on the call instruction.
2272	if (isFnAttrDisallowedByOpBundle(Kind))
2273	return false;
2274
2275	return hasFnAttrOnCalledFunction(Kind);
2276	}
2277
2278	/// Determine whether the return value has the given attribute. Supports
2279	/// Attribute::AttrKind and StringRef as \p AttrKind types.
2280	template <typename AttrKind> bool hasRetAttrImpl(AttrKind Kind) const {
2281	if (Attrs.hasAttribute(AttributeList::ReturnIndex, Kind))
2282	return true;
2283
2284	// Look at the callee, if available.
2285	if (const Function *F = getCalledFunction())
2286	return F->getAttributes().hasAttribute(AttributeList::ReturnIndex, Kind);
2287	return false;
2288	}
2289	};
2290
2291	template <>
2292	struct OperandTraits<CallBase> : public VariadicOperandTraits<CallBase, `1`> {};
2293
2294	DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CallBase, Value)
2295
2296	//===----------------------------------------------------------------------===//
2297	// FuncletPadInst Class
2298	//===----------------------------------------------------------------------===//
2299	class FuncletPadInst : public Instruction {
2300	private:
2301	FuncletPadInst(const FuncletPadInst &CPI);
2302
2303	explicit FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad,
2304	ArrayRef<Value > Args, unsigned* Values,
2305	const Twine &NameStr, Instruction *InsertBefore);
2306	explicit FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad,
2307	ArrayRef<Value > Args, unsigned* Values,
2308	const Twine &NameStr, BasicBlock *InsertAtEnd);
2309
2310	void init(Value ParentPad, ArrayRef<Value > Args, const Twine &NameStr);
2311
2312	protected:
2313	// Note: Instruction needs to be a friend here to call cloneImpl.
2314	friend class Instruction;
2315	friend class CatchPadInst;
2316	friend class CleanupPadInst;
2317
2318	FuncletPadInst cloneImpl() const*;
2319
2320	public:
2321	/// Provide fast operand accessors
2322	DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2323
2324	/// getNumArgOperands - Return the number of funcletpad arguments.
2325	///
2326	unsigned getNumArgOperands() const { return getNumOperands() - `1`; }
2327
2328	/// Convenience accessors
2329
2330	/// Return the outer EH-pad this funclet is nested within.
2331	///
2332	/// Note: This returns the associated CatchSwitchInst if this FuncletPadInst
2333	/// is a CatchPadInst.
2334	Value getParentPad() const* { return Op<-`1`>(); }
2335	void setParentPad(Value *ParentPad) {
2336	assert(ParentPad);
2337	Op<-`1`>() = ParentPad;
2338	}
2339
2340	/// getArgOperand/setArgOperand - Return/set the i-th funcletpad argument.
2341	///
2342	Value getArgOperand(unsigned* i) const { return getOperand(i); }
2343	void setArgOperand(unsigned i, Value *v) { setOperand(i, v); }
2344
2345	/// arg_operands - iteration adapter for range-for loops.
2346	op_range arg_operands() { return op_range (op_begin(), op_end() - `1`); }
2347
2348	/// arg_operands - iteration adapter for range-for loops.
2349	const_op_range arg_operands() const {
2350	return const_op_range (op_begin(), op_end() - `1`);
2351	}
2352
2353	// Methods for support type inquiry through isa, cast, and dyn_cast:
2354	static bool classof(const Instruction I) { return* I->isFuncletPad(); }
2355	static bool classof(const Value *V) {
2356	return isa<Instruction>(V) && classof(cast<Instruction>(V));
2357	}
2358	};
2359
2360	template <>
2361	struct OperandTraits<FuncletPadInst>
2362	: public VariadicOperandTraits<FuncletPadInst, /MINARITY=/`1`> {};
2363
2364	DEFINE_TRANSPARENT_OPERAND_ACCESSORS(FuncletPadInst, Value)
2365
2366	} // end namespace llvm
2367
2368	#endif // LLVM_IR_INSTRTYPES_H
2369

Browse the source code of llvm/include/llvm/IR/InstrTypes.h