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
47namespace llvm {
48
49namespace Intrinsic {
50typedef unsigned ID;
51}
52
53//===----------------------------------------------------------------------===//
54// UnaryInstruction Class
55//===----------------------------------------------------------------------===//
56
57class UnaryInstruction : public Instruction {
58protected:
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
69public:
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
92template <>
93struct OperandTraits<UnaryInstruction> :
94 public FixedNumOperandTraits<UnaryInstruction, 1> {
95};
96
97DEFINE_TRANSPARENT_OPERAND_ACCESSORS(UnaryInstruction, Value)
98
99//===----------------------------------------------------------------------===//
100// UnaryOperator Class
101//===----------------------------------------------------------------------===//
102
103class UnaryOperator : public UnaryInstruction {
104 void AssertOK();
105
106protected:
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
117public:
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
190class BinaryOperator : public Instruction {
191 void AssertOK();
192
193protected:
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
204public:
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
415template <>
416struct OperandTraits<BinaryOperator> :
417 public FixedNumOperandTraits<BinaryOperator, 2> {
418};
419
420DEFINE_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.
432class CastInst : public UnaryInstruction {
433protected:
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
447public:
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.
712class CmpInst : public Instruction {
713public:
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
760protected:
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
770public:
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
1042private:
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
1051template <>
1052struct OperandTraits<CmpInst> : public FixedNumOperandTraits<CmpInst, 2> {
1053};
1054
1055DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CmpInst, Value)
1056
1057/// A lightweight accessor for an operand bundle meant to be passed
1058/// around by value.
1059struct 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
1106private:
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.
1117template <typename InputTy> class OperandBundleDefT {
1118 std::string Tag;
1119 std::vector<InputTy> Inputs;
1120
1121public:
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
1143using OperandBundleDef = OperandBundleDefT<Value *>;
1144using 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.
1164class CallBase : public Instruction {
1165protected:
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
1205public:
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
2240public:
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
2250protected:
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
2262private:
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
2291template <>
2292struct OperandTraits<CallBase> : public VariadicOperandTraits<CallBase, 1> {};
2293
2294DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CallBase, Value)
2295
2296//===----------------------------------------------------------------------===//
2297// FuncletPadInst Class
2298//===----------------------------------------------------------------------===//
2299class FuncletPadInst : public Instruction {
2300private:
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
2312protected:
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
2320public:
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
2360template <>
2361struct OperandTraits<FuncletPadInst>
2362 : public VariadicOperandTraits<FuncletPadInst, /*MINARITY=*/1> {};
2363
2364DEFINE_TRANSPARENT_OPERAND_ACCESSORS(FuncletPadInst, Value)
2365
2366} // end namespace llvm
2367
2368#endif // LLVM_IR_INSTRTYPES_H
2369