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