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