Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

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