LCOV - code coverage report
Current view: top level - include/llvm/IR - InstrTypes.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 187 196 95.4 %
Date: 2018-05-20 00:06:23 Functions: 50 53 94.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- llvm/InstrTypes.h - Important Instruction subclasses -----*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file defines various meta classes of instructions that exist in the VM
      11             : // representation.  Specific concrete subclasses of these may be found in the
      12             : // i*.h files...
      13             : //
      14             : //===----------------------------------------------------------------------===//
      15             : 
      16             : #ifndef LLVM_IR_INSTRTYPES_H
      17             : #define LLVM_IR_INSTRTYPES_H
      18             : 
      19             : #include "llvm/ADT/ArrayRef.h"
      20             : #include "llvm/ADT/None.h"
      21             : #include "llvm/ADT/Optional.h"
      22             : #include "llvm/ADT/STLExtras.h"
      23             : #include "llvm/ADT/StringMap.h"
      24             : #include "llvm/ADT/StringRef.h"
      25             : #include "llvm/ADT/Twine.h"
      26             : #include "llvm/ADT/iterator_range.h"
      27             : #include "llvm/IR/Attributes.h"
      28             : #include "llvm/IR/Constants.h"
      29             : #include "llvm/IR/DerivedTypes.h"
      30             : #include "llvm/IR/Instruction.h"
      31             : #include "llvm/IR/LLVMContext.h"
      32             : #include "llvm/IR/OperandTraits.h"
      33             : #include "llvm/IR/Type.h"
      34             : #include "llvm/IR/User.h"
      35             : #include "llvm/IR/Value.h"
      36             : #include "llvm/Support/Casting.h"
      37             : #include "llvm/Support/ErrorHandling.h"
      38             : #include <algorithm>
      39             : #include <cassert>
      40             : #include <cstddef>
      41             : #include <cstdint>
      42             : #include <iterator>
      43             : #include <string>
      44             : #include <vector>
      45             : 
      46             : namespace llvm {
      47             : 
      48             : //===----------------------------------------------------------------------===//
      49             : //                            TerminatorInst Class
      50             : //===----------------------------------------------------------------------===//
      51             : 
      52             : /// Subclasses of this class are all able to terminate a basic
      53             : /// block. Thus, these are all the flow control type of operations.
      54             : ///
      55     1080603 : class TerminatorInst : public Instruction {
      56             : protected:
      57             :   TerminatorInst(Type *Ty, Instruction::TermOps iType,
      58             :                  Use *Ops, unsigned NumOps,
      59             :                  Instruction *InsertBefore = nullptr)
      60     1159999 :     : Instruction(Ty, iType, Ops, NumOps, InsertBefore) {}
      61             : 
      62             :   TerminatorInst(Type *Ty, Instruction::TermOps iType,
      63             :                  Use *Ops, unsigned NumOps, BasicBlock *InsertAtEnd)
      64      135543 :     : Instruction(Ty, iType, Ops, NumOps, InsertAtEnd) {}
      65             : 
      66             : public:
      67             :   /// Return the number of successors that this terminator has.
      68             :   unsigned getNumSuccessors() const;
      69             : 
      70             :   /// Return the specified successor.
      71             :   BasicBlock *getSuccessor(unsigned idx) const;
      72             : 
      73             :   /// Update the specified successor to point at the provided block.
      74             :   void setSuccessor(unsigned idx, BasicBlock *B);
      75             : 
      76             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
      77             :   static bool classof(const Instruction *I) {
      78             :     return I->isTerminator();
      79             :   }
      80             :   static bool classof(const Value *V) {
      81    50787314 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
      82             :   }
      83             : 
      84             :   // Returns true if this terminator relates to exception handling.
      85             :   bool isExceptional() const {
      86             :     switch (getOpcode()) {
      87             :     case Instruction::CatchSwitch:
      88             :     case Instruction::CatchRet:
      89             :     case Instruction::CleanupRet:
      90             :     case Instruction::Invoke:
      91             :     case Instruction::Resume:
      92             :       return true;
      93      240444 :     default:
      94             :       return false;
      95             :     }
      96             :   }
      97             : 
      98             :   //===--------------------------------------------------------------------===//
      99             :   // succ_iterator definition
     100             :   //===--------------------------------------------------------------------===//
     101             : 
     102             :   template <class Term, class BB> // Successor Iterator
     103             :   class SuccIterator : public std::iterator<std::random_access_iterator_tag, BB,
     104             :                                             int, BB *, BB *> {
     105             :     using super =
     106             :         std::iterator<std::random_access_iterator_tag, BB, int, BB *, BB *>;
     107             : 
     108             :   public:
     109             :     using pointer = typename super::pointer;
     110             :     using reference = typename super::reference;
     111             : 
     112             :   private:
     113             :     Term TermInst;
     114             :     unsigned idx;
     115             :     using Self = SuccIterator<Term, BB>;
     116             : 
     117             :     inline bool index_is_valid(unsigned idx) {
     118             :       return idx < TermInst->getNumSuccessors();
     119             :     }
     120             : 
     121             :     /// Proxy object to allow write access in operator[]
     122             :     class SuccessorProxy {
     123             :       Self it;
     124             : 
     125             :     public:
     126             :       explicit SuccessorProxy(const Self &it) : it(it) {}
     127             : 
     128             :       SuccessorProxy(const SuccessorProxy &) = default;
     129             : 
     130           1 :       SuccessorProxy &operator=(SuccessorProxy r) {
     131             :         *this = reference(r);
     132           1 :         return *this;
     133             :       }
     134             : 
     135             :       SuccessorProxy &operator=(reference r) {
     136           2 :         it.TermInst->setSuccessor(it.idx, r);
     137             :         return *this;
     138             :       }
     139             : 
     140           1 :       operator reference() const { return *it; }
     141             :     };
     142             : 
     143             :   public:
     144             :     // begin iterator
     145             :     explicit inline SuccIterator(Term T) : TermInst(T), idx(0) {}
     146             :     // end iterator
     147             :     inline SuccIterator(Term T, bool) : TermInst(T) {
     148    49825075 :       if (TermInst)
     149    51993637 :         idx = TermInst->getNumSuccessors();
     150             :       else
     151             :         // Term == NULL happens, if a basic block is not fully constructed and
     152             :         // consequently getTerminator() returns NULL. In this case we construct
     153             :         // a SuccIterator which describes a basic block that has zero
     154             :         // successors.
     155             :         // Defining SuccIterator for incomplete and malformed CFGs is especially
     156             :         // useful for debugging.
     157             :         idx = 0;
     158             :     }
     159             : 
     160             :     /// This is used to interface between code that wants to
     161             :     /// operate on terminator instructions directly.
     162             :     unsigned getSuccessorIndex() const { return idx; }
     163             : 
     164     1004045 :     inline bool operator==(const Self &x) const { return idx == x.idx; }
     165    27473937 :     inline bool operator!=(const Self &x) const { return !operator==(x); }
     166             : 
     167    43564483 :     inline reference operator*() const { return TermInst->getSuccessor(idx); }
     168           0 :     inline pointer operator->() const { return operator*(); }
     169             : 
     170             :     inline Self &operator++() {
     171    30460022 :       ++idx;
     172             :       return *this;
     173             :     } // Preincrement
     174             : 
     175             :     inline Self operator++(int) { // Postincrement
     176    11757677 :       Self tmp = *this;
     177             :       ++*this;
     178             :       return tmp;
     179             :     }
     180             : 
     181             :     inline Self &operator--() {
     182    17345112 :       --idx;
     183             :       return *this;
     184             :     }                             // Predecrement
     185             :     inline Self operator--(int) { // Postdecrement
     186             :       Self tmp = *this;
     187             :       --*this;
     188             :       return tmp;
     189             :     }
     190             : 
     191             :     inline bool operator<(const Self &x) const {
     192             :       assert(TermInst == x.TermInst &&
     193             :              "Cannot compare iterators of different blocks!");
     194             :       return idx < x.idx;
     195             :     }
     196             : 
     197             :     inline bool operator<=(const Self &x) const {
     198             :       assert(TermInst == x.TermInst &&
     199             :              "Cannot compare iterators of different blocks!");
     200             :       return idx <= x.idx;
     201             :     }
     202             :     inline bool operator>=(const Self &x) const {
     203             :       assert(TermInst == x.TermInst &&
     204             :              "Cannot compare iterators of different blocks!");
     205             :       return idx >= x.idx;
     206             :     }
     207             : 
     208             :     inline bool operator>(const Self &x) const {
     209             :       assert(TermInst == x.TermInst &&
     210             :              "Cannot compare iterators of different blocks!");
     211             :       return idx > x.idx;
     212             :     }
     213             : 
     214             :     inline Self &operator+=(int Right) {
     215         117 :       unsigned new_idx = idx + Right;
     216             :       assert(index_is_valid(new_idx) && "Iterator index out of bound");
     217             :       idx = new_idx;
     218             :       return *this;
     219             :     }
     220             : 
     221             :     inline Self operator+(int Right) const {
     222             :       Self tmp = *this;
     223             :       tmp += Right;
     224             :       return tmp;
     225             :     }
     226             : 
     227             :     inline Self &operator-=(int Right) { return operator+=(-Right); }
     228             : 
     229             :     inline Self operator-(int Right) const { return operator+(-Right); }
     230             : 
     231             :     inline int operator-(const Self &x) const {
     232             :       assert(TermInst == x.TermInst &&
     233             :              "Cannot work on iterators of different blocks!");
     234    13320866 :       int distance = idx - x.idx;
     235             :       return distance;
     236             :     }
     237             : 
     238             :     inline SuccessorProxy operator[](int offset) {
     239             :       Self tmp = *this;
     240             :       tmp += offset;
     241             :       return SuccessorProxy(tmp);
     242             :     }
     243             : 
     244             :     /// Get the source BB of this iterator.
     245             :     inline BB *getSource() {
     246             :       assert(TermInst && "Source not available, if basic block was malformed");
     247             :       return TermInst->getParent();
     248             :     }
     249             :   };
     250             : 
     251             :   using succ_iterator = SuccIterator<TerminatorInst *, BasicBlock>;
     252             :   using succ_const_iterator =
     253             :       SuccIterator<const TerminatorInst *, const BasicBlock>;
     254             :   using succ_range = iterator_range<succ_iterator>;
     255             :   using succ_const_range = iterator_range<succ_const_iterator>;
     256             : 
     257             : private:
     258             :   inline succ_iterator succ_begin() { return succ_iterator(this); }
     259             :   inline succ_const_iterator succ_begin() const {
     260             :     return succ_const_iterator(this);
     261             :   }
     262             :   inline succ_iterator succ_end() { return succ_iterator(this, true); }
     263             :   inline succ_const_iterator succ_end() const {
     264             :     return succ_const_iterator(this, true);
     265             :   }
     266             : 
     267             : public:
     268             :   inline succ_range successors() {
     269             :     return succ_range(succ_begin(), succ_end());
     270             :   }
     271             :   inline succ_const_range successors() const {
     272             :     return succ_const_range(succ_begin(), succ_end());
     273             :   }
     274             : };
     275             : 
     276             : //===----------------------------------------------------------------------===//
     277             : //                          UnaryInstruction Class
     278             : //===----------------------------------------------------------------------===//
     279             : 
     280     2680207 : class UnaryInstruction : public Instruction {
     281             : protected:
     282     3137221 :   UnaryInstruction(Type *Ty, unsigned iType, Value *V,
     283             :                    Instruction *IB = nullptr)
     284     6274442 :     : Instruction(Ty, iType, &Op<0>(), 1, IB) {
     285             :     Op<0>() = V;
     286     3137221 :   }
     287      174775 :   UnaryInstruction(Type *Ty, unsigned iType, Value *V, BasicBlock *IAE)
     288      349550 :     : Instruction(Ty, iType, &Op<0>(), 1, IAE) {
     289             :     Op<0>() = V;
     290      174775 :   }
     291             : 
     292             : public:
     293             :   // allocate space for exactly one operand
     294             :   void *operator new(size_t s) {
     295     3311996 :     return User::operator new(s, 1);
     296             :   }
     297             : 
     298             :   /// Transparently provide more efficient getOperand methods.
     299             :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
     300             : 
     301             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
     302             :   static bool classof(const Instruction *I) {
     303          22 :     return I->getOpcode() == Instruction::Alloca ||
     304          22 :            I->getOpcode() == Instruction::Load ||
     305          22 :            I->getOpcode() == Instruction::VAArg ||
     306          44 :            I->getOpcode() == Instruction::ExtractValue ||
     307           8 :            (I->getOpcode() >= CastOpsBegin && I->getOpcode() < CastOpsEnd);
     308             :   }
     309             :   static bool classof(const Value *V) {
     310           0 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
     311             :   }
     312             : };
     313             : 
     314             : template <>
     315             : struct OperandTraits<UnaryInstruction> :
     316             :   public FixedNumOperandTraits<UnaryInstruction, 1> {
     317             : };
     318             : 
     319    54206426 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(UnaryInstruction, Value)
     320             : 
     321             : //===----------------------------------------------------------------------===//
     322             : //                           BinaryOperator Class
     323             : //===----------------------------------------------------------------------===//
     324             : 
     325      630282 : class BinaryOperator : public Instruction {
     326             :   void AssertOK();
     327             : 
     328             : protected:
     329             :   BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
     330             :                  const Twine &Name, Instruction *InsertBefore);
     331             :   BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
     332             :                  const Twine &Name, BasicBlock *InsertAtEnd);
     333             : 
     334             :   // Note: Instruction needs to be a friend here to call cloneImpl.
     335             :   friend class Instruction;
     336             : 
     337             :   BinaryOperator *cloneImpl() const;
     338             : 
     339             : public:
     340             :   // allocate space for exactly two operands
     341             :   void *operator new(size_t s) {
     342      843649 :     return User::operator new(s, 2);
     343             :   }
     344             : 
     345             :   /// Transparently provide more efficient getOperand methods.
     346             :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
     347             : 
     348             :   /// Construct a binary instruction, given the opcode and the two
     349             :   /// operands.  Optionally (if InstBefore is specified) insert the instruction
     350             :   /// into a BasicBlock right before the specified instruction.  The specified
     351             :   /// Instruction is allowed to be a dereferenced end iterator.
     352             :   ///
     353             :   static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2,
     354             :                                 const Twine &Name = Twine(),
     355             :                                 Instruction *InsertBefore = nullptr);
     356             : 
     357             :   /// Construct a binary instruction, given the opcode and the two
     358             :   /// operands.  Also automatically insert this instruction to the end of the
     359             :   /// BasicBlock specified.
     360             :   ///
     361             :   static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2,
     362             :                                 const Twine &Name, BasicBlock *InsertAtEnd);
     363             : 
     364             :   /// These methods just forward to Create, and are useful when you
     365             :   /// statically know what type of instruction you're going to create.  These
     366             :   /// helpers just save some typing.
     367             : #define HANDLE_BINARY_INST(N, OPC, CLASS) \
     368             :   static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
     369             :                                      const Twine &Name = "") {\
     370             :     return Create(Instruction::OPC, V1, V2, Name);\
     371             :   }
     372             : #include "llvm/IR/Instruction.def"
     373             : #define HANDLE_BINARY_INST(N, OPC, CLASS) \
     374             :   static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
     375             :                                      const Twine &Name, BasicBlock *BB) {\
     376             :     return Create(Instruction::OPC, V1, V2, Name, BB);\
     377             :   }
     378             : #include "llvm/IR/Instruction.def"
     379             : #define HANDLE_BINARY_INST(N, OPC, CLASS) \
     380             :   static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
     381             :                                      const Twine &Name, Instruction *I) {\
     382             :     return Create(Instruction::OPC, V1, V2, Name, I);\
     383             :   }
     384             : #include "llvm/IR/Instruction.def"
     385             : 
     386             :   static BinaryOperator *CreateWithCopiedFlags(BinaryOps Opc,
     387             :                                                Value *V1, Value *V2,
     388             :                                                BinaryOperator *CopyBO,
     389             :                                                const Twine &Name = "") {
     390         167 :     BinaryOperator *BO = Create(Opc, V1, V2, Name);
     391         167 :     BO->copyIRFlags(CopyBO);
     392             :     return BO;
     393             :   }
     394             : 
     395          32 :   static BinaryOperator *CreateFAddFMF(Value *V1, Value *V2,
     396             :                                        BinaryOperator *FMFSource,
     397             :                                        const Twine &Name = "") {
     398          32 :     return CreateWithCopiedFlags(Instruction::FAdd, V1, V2, FMFSource, Name);
     399             :   }
     400          13 :   static BinaryOperator *CreateFSubFMF(Value *V1, Value *V2,
     401             :                                        BinaryOperator *FMFSource,
     402             :                                        const Twine &Name = "") {
     403          13 :     return CreateWithCopiedFlags(Instruction::FSub, V1, V2, FMFSource, Name);
     404             :   }
     405          60 :   static BinaryOperator *CreateFMulFMF(Value *V1, Value *V2,
     406             :                                        BinaryOperator *FMFSource,
     407             :                                        const Twine &Name = "") {
     408          60 :     return CreateWithCopiedFlags(Instruction::FMul, V1, V2, FMFSource, Name);
     409             :   }
     410          18 :   static BinaryOperator *CreateFDivFMF(Value *V1, Value *V2,
     411             :                                        BinaryOperator *FMFSource,
     412             :                                        const Twine &Name = "") {
     413          18 :     return CreateWithCopiedFlags(Instruction::FDiv, V1, V2, FMFSource, Name);
     414             :   }
     415             :   static BinaryOperator *CreateFRemFMF(Value *V1, Value *V2,
     416             :                                        BinaryOperator *FMFSource,
     417             :                                        const Twine &Name = "") {
     418             :     return CreateWithCopiedFlags(Instruction::FRem, V1, V2, FMFSource, Name);
     419             :   }
     420          29 :   static BinaryOperator *CreateFNegFMF(Value *Op, BinaryOperator *FMFSource,
     421             :                                        const Twine &Name = "") {
     422          29 :     Value *Zero = ConstantFP::getNegativeZero(Op->getType());
     423          29 :     return CreateWithCopiedFlags(Instruction::FSub, Zero, Op, FMFSource);
     424             :   }
     425             : 
     426             :   static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2,
     427             :                                    const Twine &Name = "") {
     428           4 :     BinaryOperator *BO = Create(Opc, V1, V2, Name);
     429           4 :     BO->setHasNoSignedWrap(true);
     430             :     return BO;
     431             :   }
     432             :   static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2,
     433             :                                    const Twine &Name, BasicBlock *BB) {
     434          20 :     BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
     435          20 :     BO->setHasNoSignedWrap(true);
     436             :     return BO;
     437             :   }
     438             :   static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2,
     439             :                                    const Twine &Name, Instruction *I) {
     440           0 :     BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
     441           0 :     BO->setHasNoSignedWrap(true);
     442             :     return BO;
     443             :   }
     444             : 
     445             :   static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2,
     446             :                                    const Twine &Name = "") {
     447           4 :     BinaryOperator *BO = Create(Opc, V1, V2, Name);
     448           4 :     BO->setHasNoUnsignedWrap(true);
     449             :     return BO;
     450             :   }
     451             :   static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2,
     452             :                                    const Twine &Name, BasicBlock *BB) {
     453           0 :     BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
     454           0 :     BO->setHasNoUnsignedWrap(true);
     455             :     return BO;
     456             :   }
     457             :   static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2,
     458             :                                    const Twine &Name, Instruction *I) {
     459           0 :     BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
     460           0 :     BO->setHasNoUnsignedWrap(true);
     461             :     return BO;
     462             :   }
     463             : 
     464             :   static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2,
     465             :                                      const Twine &Name = "") {
     466        1852 :     BinaryOperator *BO = Create(Opc, V1, V2, Name);
     467        1852 :     BO->setIsExact(true);
     468             :     return BO;
     469             :   }
     470             :   static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2,
     471             :                                      const Twine &Name, BasicBlock *BB) {
     472             :     BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
     473             :     BO->setIsExact(true);
     474             :     return BO;
     475             :   }
     476             :   static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2,
     477             :                                      const Twine &Name, Instruction *I) {
     478           2 :     BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
     479           2 :     BO->setIsExact(true);
     480             :     return BO;
     481             :   }
     482             : 
     483             : #define DEFINE_HELPERS(OPC, NUWNSWEXACT)                                       \
     484             :   static BinaryOperator *Create##NUWNSWEXACT##OPC(Value *V1, Value *V2,        \
     485             :                                                   const Twine &Name = "") {    \
     486             :     return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name);                \
     487             :   }                                                                            \
     488             :   static BinaryOperator *Create##NUWNSWEXACT##OPC(                             \
     489             :       Value *V1, Value *V2, const Twine &Name, BasicBlock *BB) {               \
     490             :     return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name, BB);            \
     491             :   }                                                                            \
     492             :   static BinaryOperator *Create##NUWNSWEXACT##OPC(                             \
     493             :       Value *V1, Value *V2, const Twine &Name, Instruction *I) {               \
     494             :     return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name, I);             \
     495             :   }
     496             : 
     497             :   DEFINE_HELPERS(Add, NSW) // CreateNSWAdd
     498             :   DEFINE_HELPERS(Add, NUW) // CreateNUWAdd
     499             :   DEFINE_HELPERS(Sub, NSW) // CreateNSWSub
     500             :   DEFINE_HELPERS(Sub, NUW) // CreateNUWSub
     501             :   DEFINE_HELPERS(Mul, NSW) // CreateNSWMul
     502             :   DEFINE_HELPERS(Mul, NUW) // CreateNUWMul
     503           8 :   DEFINE_HELPERS(Shl, NSW) // CreateNSWShl
     504           8 :   DEFINE_HELPERS(Shl, NUW) // CreateNUWShl
     505             : 
     506        2918 :   DEFINE_HELPERS(SDiv, Exact)  // CreateExactSDiv
     507          68 :   DEFINE_HELPERS(UDiv, Exact)  // CreateExactUDiv
     508         714 :   DEFINE_HELPERS(AShr, Exact)  // CreateExactAShr
     509           4 :   DEFINE_HELPERS(LShr, Exact)  // CreateExactLShr
     510             : 
     511             : #undef DEFINE_HELPERS
     512             : 
     513             :   /// Helper functions to construct and inspect unary operations (NEG and NOT)
     514             :   /// via binary operators SUB and XOR:
     515             :   ///
     516             :   /// Create the NEG and NOT instructions out of SUB and XOR instructions.
     517             :   ///
     518             :   static BinaryOperator *CreateNeg(Value *Op, const Twine &Name = "",
     519             :                                    Instruction *InsertBefore = nullptr);
     520             :   static BinaryOperator *CreateNeg(Value *Op, const Twine &Name,
     521             :                                    BasicBlock *InsertAtEnd);
     522             :   static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name = "",
     523             :                                       Instruction *InsertBefore = nullptr);
     524             :   static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name,
     525             :                                       BasicBlock *InsertAtEnd);
     526             :   static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name = "",
     527             :                                       Instruction *InsertBefore = nullptr);
     528             :   static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name,
     529             :                                       BasicBlock *InsertAtEnd);
     530             :   static BinaryOperator *CreateFNeg(Value *Op, const Twine &Name = "",
     531             :                                     Instruction *InsertBefore = nullptr);
     532             :   static BinaryOperator *CreateFNeg(Value *Op, const Twine &Name,
     533             :                                     BasicBlock *InsertAtEnd);
     534             :   static BinaryOperator *CreateNot(Value *Op, const Twine &Name = "",
     535             :                                    Instruction *InsertBefore = nullptr);
     536             :   static BinaryOperator *CreateNot(Value *Op, const Twine &Name,
     537             :                                    BasicBlock *InsertAtEnd);
     538             : 
     539             :   /// Check if the given Value is a NEG, FNeg, or NOT instruction.
     540             :   ///
     541             :   static bool isNeg(const Value *V);
     542             :   static bool isFNeg(const Value *V, bool IgnoreZeroSign=false);
     543             :   static bool isNot(const Value *V);
     544             : 
     545             :   /// Helper functions to extract the unary argument of a NEG, FNEG or NOT
     546             :   /// operation implemented via Sub, FSub, or Xor.
     547             :   ///
     548             :   static const Value *getNegArgument(const Value *BinOp);
     549             :   static       Value *getNegArgument(      Value *BinOp);
     550             :   static const Value *getFNegArgument(const Value *BinOp);
     551             :   static       Value *getFNegArgument(      Value *BinOp);
     552             :   static const Value *getNotArgument(const Value *BinOp);
     553             :   static       Value *getNotArgument(      Value *BinOp);
     554             : 
     555             :   BinaryOps getOpcode() const {
     556             :     return static_cast<BinaryOps>(Instruction::getOpcode());
     557             :   }
     558             : 
     559             :   /// Exchange the two operands to this instruction.
     560             :   /// This instruction is safe to use on any binary instruction and
     561             :   /// does not modify the semantics of the instruction.  If the instruction
     562             :   /// cannot be reversed (ie, it's a Div), then return true.
     563             :   ///
     564             :   bool swapOperands();
     565             : 
     566             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
     567             :   static bool classof(const Instruction *I) {
     568             :     return I->isBinaryOp();
     569             :   }
     570             :   static bool classof(const Value *V) {
     571    91575883 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
     572             :   }
     573             : };
     574             : 
     575             : template <>
     576             : struct OperandTraits<BinaryOperator> :
     577             :   public FixedNumOperandTraits<BinaryOperator, 2> {
     578             : };
     579             : 
     580    94695215 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BinaryOperator, Value)
     581             : 
     582             : //===----------------------------------------------------------------------===//
     583             : //                               CastInst Class
     584             : //===----------------------------------------------------------------------===//
     585             : 
     586             : /// This is the base class for all instructions that perform data
     587             : /// casts. It is simply provided so that instruction category testing
     588             : /// can be performed with code like:
     589             : ///
     590             : /// if (isa<CastInst>(Instr)) { ... }
     591             : /// Base class of casting instructions.
     592           7 : class CastInst : public UnaryInstruction {
     593             : protected:
     594             :   /// Constructor with insert-before-instruction semantics for subclasses
     595             :   CastInst(Type *Ty, unsigned iType, Value *S,
     596             :            const Twine &NameStr = "", Instruction *InsertBefore = nullptr)
     597      751853 :     : UnaryInstruction(Ty, iType, S, InsertBefore) {
     598      751853 :     setName(NameStr);
     599             :   }
     600             :   /// Constructor with insert-at-end-of-block semantics for subclasses
     601             :   CastInst(Type *Ty, unsigned iType, Value *S,
     602             :            const Twine &NameStr, BasicBlock *InsertAtEnd)
     603      174731 :     : UnaryInstruction(Ty, iType, S, InsertAtEnd) {
     604      174731 :     setName(NameStr);
     605             :   }
     606             : 
     607             : public:
     608             :   /// Provides a way to construct any of the CastInst subclasses using an
     609             :   /// opcode instead of the subclass's constructor. The opcode must be in the
     610             :   /// CastOps category (Instruction::isCast(opcode) returns true). This
     611             :   /// constructor has insert-before-instruction semantics to automatically
     612             :   /// insert the new CastInst before InsertBefore (if it is non-null).
     613             :   /// Construct any of the CastInst subclasses
     614             :   static CastInst *Create(
     615             :     Instruction::CastOps,    ///< The opcode of the cast instruction
     616             :     Value *S,                ///< The value to be casted (operand 0)
     617             :     Type *Ty,          ///< The type to which cast should be made
     618             :     const Twine &Name = "", ///< Name for the instruction
     619             :     Instruction *InsertBefore = nullptr ///< Place to insert the instruction
     620             :   );
     621             :   /// Provides a way to construct any of the CastInst subclasses using an
     622             :   /// opcode instead of the subclass's constructor. The opcode must be in the
     623             :   /// CastOps category. This constructor has insert-at-end-of-block semantics
     624             :   /// to automatically insert the new CastInst at the end of InsertAtEnd (if
     625             :   /// its non-null).
     626             :   /// Construct any of the CastInst subclasses
     627             :   static CastInst *Create(
     628             :     Instruction::CastOps,    ///< The opcode for the cast instruction
     629             :     Value *S,                ///< The value to be casted (operand 0)
     630             :     Type *Ty,          ///< The type to which operand is casted
     631             :     const Twine &Name, ///< The name for the instruction
     632             :     BasicBlock *InsertAtEnd  ///< The block to insert the instruction into
     633             :   );
     634             : 
     635             :   /// Create a ZExt or BitCast cast instruction
     636             :   static CastInst *CreateZExtOrBitCast(
     637             :     Value *S,                ///< The value to be casted (operand 0)
     638             :     Type *Ty,          ///< The type to which cast should be made
     639             :     const Twine &Name = "", ///< Name for the instruction
     640             :     Instruction *InsertBefore = nullptr ///< Place to insert the instruction
     641             :   );
     642             : 
     643             :   /// Create a ZExt or BitCast cast instruction
     644             :   static CastInst *CreateZExtOrBitCast(
     645             :     Value *S,                ///< The value to be casted (operand 0)
     646             :     Type *Ty,          ///< The type to which operand is casted
     647             :     const Twine &Name, ///< The name for the instruction
     648             :     BasicBlock *InsertAtEnd  ///< The block to insert the instruction into
     649             :   );
     650             : 
     651             :   /// Create a SExt or BitCast cast instruction
     652             :   static CastInst *CreateSExtOrBitCast(
     653             :     Value *S,                ///< The value to be casted (operand 0)
     654             :     Type *Ty,          ///< The type to which cast should be made
     655             :     const Twine &Name = "", ///< Name for the instruction
     656             :     Instruction *InsertBefore = nullptr ///< Place to insert the instruction
     657             :   );
     658             : 
     659             :   /// Create a SExt or BitCast cast instruction
     660             :   static CastInst *CreateSExtOrBitCast(
     661             :     Value *S,                ///< The value to be casted (operand 0)
     662             :     Type *Ty,          ///< The type to which operand is casted
     663             :     const Twine &Name, ///< The name for the instruction
     664             :     BasicBlock *InsertAtEnd  ///< The block to insert the instruction into
     665             :   );
     666             : 
     667             :   /// Create a BitCast AddrSpaceCast, or a PtrToInt cast instruction.
     668             :   static CastInst *CreatePointerCast(
     669             :     Value *S,                ///< The pointer value to be casted (operand 0)
     670             :     Type *Ty,          ///< The type to which operand is casted
     671             :     const Twine &Name, ///< The name for the instruction
     672             :     BasicBlock *InsertAtEnd  ///< The block to insert the instruction into
     673             :   );
     674             : 
     675             :   /// Create a BitCast, AddrSpaceCast or a PtrToInt cast instruction.
     676             :   static CastInst *CreatePointerCast(
     677             :     Value *S,                ///< The pointer value to be casted (operand 0)
     678             :     Type *Ty,          ///< The type to which cast should be made
     679             :     const Twine &Name = "", ///< Name for the instruction
     680             :     Instruction *InsertBefore = nullptr ///< Place to insert the instruction
     681             :   );
     682             : 
     683             :   /// Create a BitCast or an AddrSpaceCast cast instruction.
     684             :   static CastInst *CreatePointerBitCastOrAddrSpaceCast(
     685             :     Value *S,                ///< The pointer value to be casted (operand 0)
     686             :     Type *Ty,          ///< The type to which operand is casted
     687             :     const Twine &Name, ///< The name for the instruction
     688             :     BasicBlock *InsertAtEnd  ///< The block to insert the instruction into
     689             :   );
     690             : 
     691             :   /// Create a BitCast or an AddrSpaceCast cast instruction.
     692             :   static CastInst *CreatePointerBitCastOrAddrSpaceCast(
     693             :     Value *S,                ///< The pointer value to be casted (operand 0)
     694             :     Type *Ty,          ///< The type to which cast should be made
     695             :     const Twine &Name = "", ///< Name for the instruction
     696             :     Instruction *InsertBefore = nullptr ///< Place to insert the instruction
     697             :   );
     698             : 
     699             :   /// Create a BitCast, a PtrToInt, or an IntToPTr cast instruction.
     700             :   ///
     701             :   /// If the value is a pointer type and the destination an integer type,
     702             :   /// creates a PtrToInt cast. If the value is an integer type and the
     703             :   /// destination a pointer type, creates an IntToPtr cast. Otherwise, creates
     704             :   /// a bitcast.
     705             :   static CastInst *CreateBitOrPointerCast(
     706             :     Value *S,                ///< The pointer value to be casted (operand 0)
     707             :     Type *Ty,          ///< The type to which cast should be made
     708             :     const Twine &Name = "", ///< Name for the instruction
     709             :     Instruction *InsertBefore = nullptr ///< Place to insert the instruction
     710             :   );
     711             : 
     712             :   /// Create a ZExt, BitCast, or Trunc for int -> int casts.
     713             :   static CastInst *CreateIntegerCast(
     714             :     Value *S,                ///< The pointer value to be casted (operand 0)
     715             :     Type *Ty,          ///< The type to which cast should be made
     716             :     bool isSigned,           ///< Whether to regard S as signed or not
     717             :     const Twine &Name = "", ///< Name for the instruction
     718             :     Instruction *InsertBefore = nullptr ///< Place to insert the instruction
     719             :   );
     720             : 
     721             :   /// Create a ZExt, BitCast, or Trunc for int -> int casts.
     722             :   static CastInst *CreateIntegerCast(
     723             :     Value *S,                ///< The integer value to be casted (operand 0)
     724             :     Type *Ty,          ///< The integer type to which operand is casted
     725             :     bool isSigned,           ///< Whether to regard S as signed or not
     726             :     const Twine &Name, ///< The name for the instruction
     727             :     BasicBlock *InsertAtEnd  ///< The block to insert the instruction into
     728             :   );
     729             : 
     730             :   /// Create an FPExt, BitCast, or FPTrunc for fp -> fp casts
     731             :   static CastInst *CreateFPCast(
     732             :     Value *S,                ///< The floating point value to be casted
     733             :     Type *Ty,          ///< The floating point type to cast to
     734             :     const Twine &Name = "", ///< Name for the instruction
     735             :     Instruction *InsertBefore = nullptr ///< Place to insert the instruction
     736             :   );
     737             : 
     738             :   /// Create an FPExt, BitCast, or FPTrunc for fp -> fp casts
     739             :   static CastInst *CreateFPCast(
     740             :     Value *S,                ///< The floating point value to be casted
     741             :     Type *Ty,          ///< The floating point type to cast to
     742             :     const Twine &Name, ///< The name for the instruction
     743             :     BasicBlock *InsertAtEnd  ///< The block to insert the instruction into
     744             :   );
     745             : 
     746             :   /// Create a Trunc or BitCast cast instruction
     747             :   static CastInst *CreateTruncOrBitCast(
     748             :     Value *S,                ///< The value to be casted (operand 0)
     749             :     Type *Ty,          ///< The type to which cast should be made
     750             :     const Twine &Name = "", ///< Name for the instruction
     751             :     Instruction *InsertBefore = nullptr ///< Place to insert the instruction
     752             :   );
     753             : 
     754             :   /// Create a Trunc or BitCast cast instruction
     755             :   static CastInst *CreateTruncOrBitCast(
     756             :     Value *S,                ///< The value to be casted (operand 0)
     757             :     Type *Ty,          ///< The type to which operand is casted
     758             :     const Twine &Name, ///< The name for the instruction
     759             :     BasicBlock *InsertAtEnd  ///< The block to insert the instruction into
     760             :   );
     761             : 
     762             :   /// Check whether it is valid to call getCastOpcode for these types.
     763             :   static bool isCastable(
     764             :     Type *SrcTy, ///< The Type from which the value should be cast.
     765             :     Type *DestTy ///< The Type to which the value should be cast.
     766             :   );
     767             : 
     768             :   /// Check whether a bitcast between these types is valid
     769             :   static bool isBitCastable(
     770             :     Type *SrcTy, ///< The Type from which the value should be cast.
     771             :     Type *DestTy ///< The Type to which the value should be cast.
     772             :   );
     773             : 
     774             :   /// Check whether a bitcast, inttoptr, or ptrtoint cast between these
     775             :   /// types is valid and a no-op.
     776             :   ///
     777             :   /// This ensures that any pointer<->integer cast has enough bits in the
     778             :   /// integer and any other cast is a bitcast.
     779             :   static bool isBitOrNoopPointerCastable(
     780             :       Type *SrcTy,  ///< The Type from which the value should be cast.
     781             :       Type *DestTy, ///< The Type to which the value should be cast.
     782             :       const DataLayout &DL);
     783             : 
     784             :   /// Returns the opcode necessary to cast Val into Ty using usual casting
     785             :   /// rules.
     786             :   /// Infer the opcode for cast operand and type
     787             :   static Instruction::CastOps getCastOpcode(
     788             :     const Value *Val, ///< The value to cast
     789             :     bool SrcIsSigned, ///< Whether to treat the source as signed
     790             :     Type *Ty,   ///< The Type to which the value should be casted
     791             :     bool DstIsSigned  ///< Whether to treate the dest. as signed
     792             :   );
     793             : 
     794             :   /// There are several places where we need to know if a cast instruction
     795             :   /// only deals with integer source and destination types. To simplify that
     796             :   /// logic, this method is provided.
     797             :   /// @returns true iff the cast has only integral typed operand and dest type.
     798             :   /// Determine if this is an integer-only cast.
     799             :   bool isIntegerCast() const;
     800             : 
     801             :   /// A lossless cast is one that does not alter the basic value. It implies
     802             :   /// a no-op cast but is more stringent, preventing things like int->float,
     803             :   /// long->double, or int->ptr.
     804             :   /// @returns true iff the cast is lossless.
     805             :   /// Determine if this is a lossless cast.
     806             :   bool isLosslessCast() const;
     807             : 
     808             :   /// A no-op cast is one that can be effected without changing any bits.
     809             :   /// It implies that the source and destination types are the same size. The
     810             :   /// DataLayout argument is to determine the pointer size when examining casts
     811             :   /// involving Integer and Pointer types. They are no-op casts if the integer
     812             :   /// is the same size as the pointer. However, pointer size varies with
     813             :   /// platform.
     814             :   /// Determine if the described cast is a no-op cast.
     815             :   static bool isNoopCast(
     816             :     Instruction::CastOps Opcode, ///< Opcode of cast
     817             :     Type *SrcTy,         ///< SrcTy of cast
     818             :     Type *DstTy,         ///< DstTy of cast
     819             :     const DataLayout &DL ///< DataLayout to get the Int Ptr type from.
     820             :   );
     821             : 
     822             :   /// Determine if this cast is a no-op cast.
     823             :   ///
     824             :   /// \param DL is the DataLayout to determine pointer size.
     825             :   bool isNoopCast(const DataLayout &DL) const;
     826             : 
     827             :   /// Determine how a pair of casts can be eliminated, if they can be at all.
     828             :   /// This is a helper function for both CastInst and ConstantExpr.
     829             :   /// @returns 0 if the CastInst pair can't be eliminated, otherwise
     830             :   /// returns Instruction::CastOps value for a cast that can replace
     831             :   /// the pair, casting SrcTy to DstTy.
     832             :   /// Determine if a cast pair is eliminable
     833             :   static unsigned isEliminableCastPair(
     834             :     Instruction::CastOps firstOpcode,  ///< Opcode of first cast
     835             :     Instruction::CastOps secondOpcode, ///< Opcode of second cast
     836             :     Type *SrcTy, ///< SrcTy of 1st cast
     837             :     Type *MidTy, ///< DstTy of 1st cast & SrcTy of 2nd cast
     838             :     Type *DstTy, ///< DstTy of 2nd cast
     839             :     Type *SrcIntPtrTy, ///< Integer type corresponding to Ptr SrcTy, or null
     840             :     Type *MidIntPtrTy, ///< Integer type corresponding to Ptr MidTy, or null
     841             :     Type *DstIntPtrTy  ///< Integer type corresponding to Ptr DstTy, or null
     842             :   );
     843             : 
     844             :   /// Return the opcode of this CastInst
     845             :   Instruction::CastOps getOpcode() const {
     846             :     return Instruction::CastOps(Instruction::getOpcode());
     847             :   }
     848             : 
     849             :   /// Return the source type, as a convenience
     850       46950 :   Type* getSrcTy() const { return getOperand(0)->getType(); }
     851             :   /// Return the destination type, as a convenience
     852       13015 :   Type* getDestTy() const { return getType(); }
     853             : 
     854             :   /// This method can be used to determine if a cast from S to DstTy using
     855             :   /// Opcode op is valid or not.
     856             :   /// @returns true iff the proposed cast is valid.
     857             :   /// Determine if a cast is valid without creating one.
     858             :   static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy);
     859             : 
     860             :   /// Methods for support type inquiry through isa, cast, and dyn_cast:
     861             :   static bool classof(const Instruction *I) {
     862             :     return I->isCast();
     863             :   }
     864             :   static bool classof(const Value *V) {
     865    27160739 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
     866             :   }
     867             : };
     868             : 
     869             : //===----------------------------------------------------------------------===//
     870             : //                               CmpInst Class
     871             : //===----------------------------------------------------------------------===//
     872             : 
     873             : /// This class is the base class for the comparison instructions.
     874             : /// Abstract base class of comparison instructions.
     875      178634 : class CmpInst : public Instruction {
     876             : public:
     877             :   /// This enumeration lists the possible predicates for CmpInst subclasses.
     878             :   /// Values in the range 0-31 are reserved for FCmpInst, while values in the
     879             :   /// range 32-64 are reserved for ICmpInst. This is necessary to ensure the
     880             :   /// predicate values are not overlapping between the classes.
     881             :   ///
     882             :   /// Some passes (e.g. InstCombine) depend on the bit-wise characteristics of
     883             :   /// FCMP_* values. Changing the bit patterns requires a potential change to
     884             :   /// those passes.
     885             :   enum Predicate {
     886             :     // Opcode              U L G E    Intuitive operation
     887             :     FCMP_FALSE =  0,  ///< 0 0 0 0    Always false (always folded)
     888             :     FCMP_OEQ   =  1,  ///< 0 0 0 1    True if ordered and equal
     889             :     FCMP_OGT   =  2,  ///< 0 0 1 0    True if ordered and greater than
     890             :     FCMP_OGE   =  3,  ///< 0 0 1 1    True if ordered and greater than or equal
     891             :     FCMP_OLT   =  4,  ///< 0 1 0 0    True if ordered and less than
     892             :     FCMP_OLE   =  5,  ///< 0 1 0 1    True if ordered and less than or equal
     893             :     FCMP_ONE   =  6,  ///< 0 1 1 0    True if ordered and operands are unequal
     894             :     FCMP_ORD   =  7,  ///< 0 1 1 1    True if ordered (no nans)
     895             :     FCMP_UNO   =  8,  ///< 1 0 0 0    True if unordered: isnan(X) | isnan(Y)
     896             :     FCMP_UEQ   =  9,  ///< 1 0 0 1    True if unordered or equal
     897             :     FCMP_UGT   = 10,  ///< 1 0 1 0    True if unordered or greater than
     898             :     FCMP_UGE   = 11,  ///< 1 0 1 1    True if unordered, greater than, or equal
     899             :     FCMP_ULT   = 12,  ///< 1 1 0 0    True if unordered or less than
     900             :     FCMP_ULE   = 13,  ///< 1 1 0 1    True if unordered, less than, or equal
     901             :     FCMP_UNE   = 14,  ///< 1 1 1 0    True if unordered or not equal
     902             :     FCMP_TRUE  = 15,  ///< 1 1 1 1    Always true (always folded)
     903             :     FIRST_FCMP_PREDICATE = FCMP_FALSE,
     904             :     LAST_FCMP_PREDICATE = FCMP_TRUE,
     905             :     BAD_FCMP_PREDICATE = FCMP_TRUE + 1,
     906             :     ICMP_EQ    = 32,  ///< equal
     907             :     ICMP_NE    = 33,  ///< not equal
     908             :     ICMP_UGT   = 34,  ///< unsigned greater than
     909             :     ICMP_UGE   = 35,  ///< unsigned greater or equal
     910             :     ICMP_ULT   = 36,  ///< unsigned less than
     911             :     ICMP_ULE   = 37,  ///< unsigned less or equal
     912             :     ICMP_SGT   = 38,  ///< signed greater than
     913             :     ICMP_SGE   = 39,  ///< signed greater or equal
     914             :     ICMP_SLT   = 40,  ///< signed less than
     915             :     ICMP_SLE   = 41,  ///< signed less or equal
     916             :     FIRST_ICMP_PREDICATE = ICMP_EQ,
     917             :     LAST_ICMP_PREDICATE = ICMP_SLE,
     918             :     BAD_ICMP_PREDICATE = ICMP_SLE + 1
     919             :   };
     920             : 
     921             : protected:
     922             :   CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred,
     923             :           Value *LHS, Value *RHS, const Twine &Name = "",
     924             :           Instruction *InsertBefore = nullptr);
     925             : 
     926             :   CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred,
     927             :           Value *LHS, Value *RHS, const Twine &Name,
     928             :           BasicBlock *InsertAtEnd);
     929             : 
     930             : public:
     931             :   // allocate space for exactly two operands
     932             :   void *operator new(size_t s) {
     933      215416 :     return User::operator new(s, 2);
     934             :   }
     935             : 
     936             :   /// Construct a compare instruction, given the opcode, the predicate and
     937             :   /// the two operands.  Optionally (if InstBefore is specified) insert the
     938             :   /// instruction into a BasicBlock right before the specified instruction.
     939             :   /// The specified Instruction is allowed to be a dereferenced end iterator.
     940             :   /// Create a CmpInst
     941             :   static CmpInst *Create(OtherOps Op,
     942             :                          Predicate predicate, Value *S1,
     943             :                          Value *S2, const Twine &Name = "",
     944             :                          Instruction *InsertBefore = nullptr);
     945             : 
     946             :   /// Construct a compare instruction, given the opcode, the predicate and the
     947             :   /// two operands.  Also automatically insert this instruction to the end of
     948             :   /// the BasicBlock specified.
     949             :   /// Create a CmpInst
     950             :   static CmpInst *Create(OtherOps Op, Predicate predicate, Value *S1,
     951             :                          Value *S2, const Twine &Name, BasicBlock *InsertAtEnd);
     952             : 
     953             :   /// Get the opcode casted to the right type
     954             :   OtherOps getOpcode() const {
     955             :     return static_cast<OtherOps>(Instruction::getOpcode());
     956             :   }
     957             : 
     958             :   /// Return the predicate for this instruction.
     959             :   Predicate getPredicate() const {
     960             :     return Predicate(getSubclassDataFromInstruction());
     961             :   }
     962             : 
     963             :   /// Set the predicate for this instruction to the specified value.
     964      221176 :   void setPredicate(Predicate P) { setInstructionSubclassData(P); }
     965             : 
     966             :   static bool isFPPredicate(Predicate P) {
     967             :     return P >= FIRST_FCMP_PREDICATE && P <= LAST_FCMP_PREDICATE;
     968             :   }
     969             : 
     970             :   static bool isIntPredicate(Predicate P) {
     971      680789 :     return P >= FIRST_ICMP_PREDICATE && P <= LAST_ICMP_PREDICATE;
     972             :   }
     973             : 
     974             :   static StringRef getPredicateName(Predicate P);
     975             : 
     976             :   bool isFPPredicate() const { return isFPPredicate(getPredicate()); }
     977             :   bool isIntPredicate() const { return isIntPredicate(getPredicate()); }
     978             : 
     979             :   /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE,
     980             :   ///              OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
     981             :   /// @returns the inverse predicate for the instruction's current predicate.
     982             :   /// Return the inverse of the instruction's predicate.
     983             :   Predicate getInversePredicate() const {
     984      235915 :     return getInversePredicate(getPredicate());
     985             :   }
     986             : 
     987             :   /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE,
     988             :   ///              OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
     989             :   /// @returns the inverse predicate for predicate provided in \p pred.
     990             :   /// Return the inverse of a given predicate
     991             :   static Predicate getInversePredicate(Predicate pred);
     992             : 
     993             :   /// For example, EQ->EQ, SLE->SGE, ULT->UGT,
     994             :   ///              OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
     995             :   /// @returns the predicate that would be the result of exchanging the two
     996             :   /// operands of the CmpInst instruction without changing the result
     997             :   /// produced.
     998             :   /// Return the predicate as if the operands were swapped
     999             :   Predicate getSwappedPredicate() const {
    1000      247200 :     return getSwappedPredicate(getPredicate());
    1001             :   }
    1002             : 
    1003             :   /// This is a static version that you can use without an instruction
    1004             :   /// available.
    1005             :   /// Return the predicate as if the operands were swapped.
    1006             :   static Predicate getSwappedPredicate(Predicate pred);
    1007             : 
    1008             :   /// For predicate of kind "is X or equal to 0" returns the predicate "is X".
    1009             :   /// For predicate of kind "is X" returns the predicate "is X or equal to 0".
    1010             :   /// does not support other kind of predicates.
    1011             :   /// @returns the predicate that does not contains is equal to zero if
    1012             :   /// it had and vice versa.
    1013             :   /// Return the flipped strictness of predicate
    1014             :   Predicate getFlippedStrictnessPredicate() const {
    1015             :     return getFlippedStrictnessPredicate(getPredicate());
    1016             :   }
    1017             : 
    1018             :   /// This is a static version that you can use without an instruction
    1019             :   /// available.
    1020             :   /// Return the flipped strictness of predicate
    1021             :   static Predicate getFlippedStrictnessPredicate(Predicate pred);
    1022             : 
    1023             :   /// For example, SGT -> SGE, SLT -> SLE, ULT -> ULE, UGT -> UGE.
    1024             :   /// Returns the non-strict version of strict comparisons.
    1025             :   Predicate getNonStrictPredicate() const {
    1026             :     return getNonStrictPredicate(getPredicate());
    1027             :   }
    1028             : 
    1029             :   /// This is a static version that you can use without an instruction
    1030             :   /// available.
    1031             :   /// @returns the non-strict version of comparison provided in \p pred.
    1032             :   /// If \p pred is not a strict comparison predicate, returns \p pred.
    1033             :   /// Returns the non-strict version of strict comparisons.
    1034             :   static Predicate getNonStrictPredicate(Predicate pred);
    1035             : 
    1036             :   /// Provide more efficient getOperand methods.
    1037             :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
    1038             : 
    1039             :   /// This is just a convenience that dispatches to the subclasses.
    1040             :   /// Swap the operands and adjust predicate accordingly to retain
    1041             :   /// the same comparison.
    1042             :   void swapOperands();
    1043             : 
    1044             :   /// This is just a convenience that dispatches to the subclasses.
    1045             :   /// Determine if this CmpInst is commutative.
    1046             :   bool isCommutative() const;
    1047             : 
    1048             :   /// This is just a convenience that dispatches to the subclasses.
    1049             :   /// Determine if this is an equals/not equals predicate.
    1050             :   bool isEquality() const;
    1051             : 
    1052             :   /// @returns true if the comparison is signed, false otherwise.
    1053             :   /// Determine if this instruction is using a signed comparison.
    1054             :   bool isSigned() const {
    1055      841473 :     return isSigned(getPredicate());
    1056             :   }
    1057             : 
    1058             :   /// @returns true if the comparison is unsigned, false otherwise.
    1059             :   /// Determine if this instruction is using an unsigned comparison.
    1060             :   bool isUnsigned() const {
    1061      105921 :     return isUnsigned(getPredicate());
    1062             :   }
    1063             : 
    1064             :   /// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert
    1065             :   /// @returns the signed version of the unsigned predicate pred.
    1066             :   /// return the signed version of a predicate
    1067             :   static Predicate getSignedPredicate(Predicate pred);
    1068             : 
    1069             :   /// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert
    1070             :   /// @returns the signed version of the predicate for this instruction (which
    1071             :   /// has to be an unsigned predicate).
    1072             :   /// return the signed version of a predicate
    1073             :   Predicate getSignedPredicate() {
    1074             :     return getSignedPredicate(getPredicate());
    1075             :   }
    1076             : 
    1077             :   /// This is just a convenience.
    1078             :   /// Determine if this is true when both operands are the same.
    1079             :   bool isTrueWhenEqual() const {
    1080         529 :     return isTrueWhenEqual(getPredicate());
    1081             :   }
    1082             : 
    1083             :   /// This is just a convenience.
    1084             :   /// Determine if this is false when both operands are the same.
    1085             :   bool isFalseWhenEqual() const {
    1086          12 :     return isFalseWhenEqual(getPredicate());
    1087             :   }
    1088             : 
    1089             :   /// @returns true if the predicate is unsigned, false otherwise.
    1090             :   /// Determine if the predicate is an unsigned operation.
    1091             :   static bool isUnsigned(Predicate predicate);
    1092             : 
    1093             :   /// @returns true if the predicate is signed, false otherwise.
    1094             :   /// Determine if the predicate is an signed operation.
    1095             :   static bool isSigned(Predicate predicate);
    1096             : 
    1097             :   /// Determine if the predicate is an ordered operation.
    1098             :   static bool isOrdered(Predicate predicate);
    1099             : 
    1100             :   /// Determine if the predicate is an unordered operation.
    1101             :   static bool isUnordered(Predicate predicate);
    1102             : 
    1103             :   /// Determine if the predicate is true when comparing a value with itself.
    1104             :   static bool isTrueWhenEqual(Predicate predicate);
    1105             : 
    1106             :   /// Determine if the predicate is false when comparing a value with itself.
    1107             :   static bool isFalseWhenEqual(Predicate predicate);
    1108             : 
    1109             :   /// Determine if Pred1 implies Pred2 is true when two compares have matching
    1110             :   /// operands.
    1111             :   static bool isImpliedTrueByMatchingCmp(Predicate Pred1, Predicate Pred2);
    1112             : 
    1113             :   /// Determine if Pred1 implies Pred2 is false when two compares have matching
    1114             :   /// operands.
    1115             :   static bool isImpliedFalseByMatchingCmp(Predicate Pred1, Predicate Pred2);
    1116             : 
    1117             :   /// Methods for support type inquiry through isa, cast, and dyn_cast:
    1118             :   static bool classof(const Instruction *I) {
    1119    31614408 :     return I->getOpcode() == Instruction::ICmp ||
    1120             :            I->getOpcode() == Instruction::FCmp;
    1121             :   }
    1122             :   static bool classof(const Value *V) {
    1123     5196675 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    1124             :   }
    1125             : 
    1126             :   /// Create a result type for fcmp/icmp
    1127     4017539 :   static Type* makeCmpResultType(Type* opnd_type) {
    1128             :     if (VectorType* vt = dyn_cast<VectorType>(opnd_type)) {
    1129       61644 :       return VectorType::get(Type::getInt1Ty(opnd_type->getContext()),
    1130      123288 :                              vt->getNumElements());
    1131             :     }
    1132     3955895 :     return Type::getInt1Ty(opnd_type->getContext());
    1133             :   }
    1134             : 
    1135             : private:
    1136             :   // Shadow Value::setValueSubclassData with a private forwarding method so that
    1137             :   // subclasses cannot accidentally use it.
    1138             :   void setValueSubclassData(unsigned short D) {
    1139             :     Value::setValueSubclassData(D);
    1140             :   }
    1141             : };
    1142             : 
    1143             : // FIXME: these are redundant if CmpInst < BinaryOperator
    1144             : template <>
    1145             : struct OperandTraits<CmpInst> : public FixedNumOperandTraits<CmpInst, 2> {
    1146             : };
    1147             : 
    1148    23854526 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CmpInst, Value)
    1149             : 
    1150             : //===----------------------------------------------------------------------===//
    1151             : //                           FuncletPadInst Class
    1152             : //===----------------------------------------------------------------------===//
    1153         991 : class FuncletPadInst : public Instruction {
    1154             : private:
    1155             :   FuncletPadInst(const FuncletPadInst &CPI);
    1156             : 
    1157             :   explicit FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad,
    1158             :                           ArrayRef<Value *> Args, unsigned Values,
    1159             :                           const Twine &NameStr, Instruction *InsertBefore);
    1160             :   explicit FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad,
    1161             :                           ArrayRef<Value *> Args, unsigned Values,
    1162             :                           const Twine &NameStr, BasicBlock *InsertAtEnd);
    1163             : 
    1164             :   void init(Value *ParentPad, ArrayRef<Value *> Args, const Twine &NameStr);
    1165             : 
    1166             : protected:
    1167             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    1168             :   friend class Instruction;
    1169             :   friend class CatchPadInst;
    1170             :   friend class CleanupPadInst;
    1171             : 
    1172             :   FuncletPadInst *cloneImpl() const;
    1173             : 
    1174             : public:
    1175             :   /// Provide fast operand accessors
    1176             :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
    1177             : 
    1178             :   /// getNumArgOperands - Return the number of funcletpad arguments.
    1179             :   ///
    1180         742 :   unsigned getNumArgOperands() const { return getNumOperands() - 1; }
    1181             : 
    1182             :   /// Convenience accessors
    1183             : 
    1184             :   /// Return the outer EH-pad this funclet is nested within.
    1185             :   ///
    1186             :   /// Note: This returns the associated CatchSwitchInst if this FuncletPadInst
    1187             :   /// is a CatchPadInst.
    1188        5467 :   Value *getParentPad() const { return Op<-1>(); }
    1189             :   void setParentPad(Value *ParentPad) {
    1190             :     assert(ParentPad);
    1191             :     Op<-1>() = ParentPad;
    1192             :   }
    1193             : 
    1194             :   /// getArgOperand/setArgOperand - Return/set the i-th funcletpad argument.
    1195             :   ///
    1196             :   Value *getArgOperand(unsigned i) const { return getOperand(i); }
    1197             :   void setArgOperand(unsigned i, Value *v) { setOperand(i, v); }
    1198             : 
    1199             :   /// arg_operands - iteration adapter for range-for loops.
    1200             :   op_range arg_operands() { return op_range(op_begin(), op_end() - 1); }
    1201             : 
    1202             :   /// arg_operands - iteration adapter for range-for loops.
    1203             :   const_op_range arg_operands() const {
    1204             :     return const_op_range(op_begin(), op_end() - 1);
    1205             :   }
    1206             : 
    1207             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    1208             :   static bool classof(const Instruction *I) { return I->isFuncletPad(); }
    1209             :   static bool classof(const Value *V) {
    1210        9054 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    1211             :   }
    1212             : };
    1213             : 
    1214             : template <>
    1215             : struct OperandTraits<FuncletPadInst>
    1216             :     : public VariadicOperandTraits<FuncletPadInst, /*MINARITY=*/1> {};
    1217             : 
    1218         784 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(FuncletPadInst, Value)
    1219             : 
    1220             : /// A lightweight accessor for an operand bundle meant to be passed
    1221             : /// around by value.
    1222             : struct OperandBundleUse {
    1223             :   ArrayRef<Use> Inputs;
    1224             : 
    1225             :   OperandBundleUse() = default;
    1226             :   explicit OperandBundleUse(StringMapEntry<uint32_t> *Tag, ArrayRef<Use> Inputs)
    1227        5971 :       : Inputs(Inputs), Tag(Tag) {}
    1228             : 
    1229             :   /// Return true if the operand at index \p Idx in this operand bundle
    1230             :   /// has the attribute A.
    1231             :   bool operandHasAttr(unsigned Idx, Attribute::AttrKind A) const {
    1232         106 :     if (isDeoptOperandBundle())
    1233          77 :       if (A == Attribute::ReadOnly || A == Attribute::NoCapture)
    1234         132 :         return Inputs[Idx]->getType()->isPointerTy();
    1235             : 
    1236             :     // Conservative answer:  no operands have any attributes.
    1237             :     return false;
    1238             :   }
    1239             : 
    1240             :   /// Return the tag of this operand bundle as a string.
    1241             :   StringRef getTagName() const {
    1242             :     return Tag->getKey();
    1243             :   }
    1244             : 
    1245             :   /// Return the tag of this operand bundle as an integer.
    1246             :   ///
    1247             :   /// Operand bundle tags are interned by LLVMContextImpl::getOrInsertBundleTag,
    1248             :   /// and this function returns the unique integer getOrInsertBundleTag
    1249             :   /// associated the tag of this operand bundle to.
    1250             :   uint32_t getTagID() const {
    1251        4659 :     return Tag->getValue();
    1252             :   }
    1253             : 
    1254             :   /// Return true if this is a "deopt" operand bundle.
    1255             :   bool isDeoptOperandBundle() const {
    1256             :     return getTagID() == LLVMContext::OB_deopt;
    1257             :   }
    1258             : 
    1259             :   /// Return true if this is a "funclet" operand bundle.
    1260             :   bool isFuncletOperandBundle() const {
    1261             :     return getTagID() == LLVMContext::OB_funclet;
    1262             :   }
    1263             : 
    1264             : private:
    1265             :   /// Pointer to an entry in LLVMContextImpl::getOrInsertBundleTag.
    1266             :   StringMapEntry<uint32_t> *Tag;
    1267             : };
    1268             : 
    1269             : /// A container for an operand bundle being viewed as a set of values
    1270             : /// rather than a set of uses.
    1271             : ///
    1272             : /// Unlike OperandBundleUse, OperandBundleDefT owns the memory it carries, and
    1273             : /// so it is possible to create and pass around "self-contained" instances of
    1274             : /// OperandBundleDef and ConstOperandBundleDef.
    1275        3756 : template <typename InputTy> class OperandBundleDefT {
    1276             :   std::string Tag;
    1277             :   std::vector<InputTy> Inputs;
    1278             : 
    1279             : public:
    1280        1293 :   explicit OperandBundleDefT(std::string Tag, std::vector<InputTy> Inputs)
    1281             :       : Tag(std::move(Tag)), Inputs(std::move(Inputs)) {}
    1282         187 :   explicit OperandBundleDefT(std::string Tag, ArrayRef<InputTy> Inputs)
    1283         187 :       : Tag(std::move(Tag)), Inputs(Inputs) {}
    1284             : 
    1285         566 :   explicit OperandBundleDefT(const OperandBundleUse &OBU) {
    1286         849 :     Tag = OBU.getTagName();
    1287             :     Inputs.insert(Inputs.end(), OBU.Inputs.begin(), OBU.Inputs.end());
    1288         283 :   }
    1289             : 
    1290             :   ArrayRef<InputTy> inputs() const { return Inputs; }
    1291             : 
    1292             :   using input_iterator = typename std::vector<InputTy>::const_iterator;
    1293             : 
    1294        5584 :   size_t input_size() const { return Inputs.size(); }
    1295        1543 :   input_iterator input_begin() const { return Inputs.begin(); }
    1296        1543 :   input_iterator input_end() const { return Inputs.end(); }
    1297             : 
    1298             :   StringRef getTag() const { return Tag; }
    1299             : };
    1300             : 
    1301             : using OperandBundleDef = OperandBundleDefT<Value *>;
    1302             : using ConstOperandBundleDef = OperandBundleDefT<const Value *>;
    1303             : 
    1304             : /// A mixin to add operand bundle functionality to llvm instruction
    1305             : /// classes.
    1306             : ///
    1307             : /// OperandBundleUser uses the descriptor area co-allocated with the host User
    1308             : /// to store some meta information about which operands are "normal" operands,
    1309             : /// and which ones belong to some operand bundle.
    1310             : ///
    1311             : /// The layout of an operand bundle user is
    1312             : ///
    1313             : ///          +-----------uint32_t End-------------------------------------+
    1314             : ///          |                                                            |
    1315             : ///          |  +--------uint32_t Begin--------------------+              |
    1316             : ///          |  |                                          |              |
    1317             : ///          ^  ^                                          v              v
    1318             : ///  |------|------|----|----|----|----|----|---------|----|---------|----|-----
    1319             : ///  | BOI0 | BOI1 | .. | DU | U0 | U1 | .. | BOI0_U0 | .. | BOI1_U0 | .. | Un
    1320             : ///  |------|------|----|----|----|----|----|---------|----|---------|----|-----
    1321             : ///   v  v                                  ^              ^
    1322             : ///   |  |                                  |              |
    1323             : ///   |  +--------uint32_t Begin------------+              |
    1324             : ///   |                                                    |
    1325             : ///   +-----------uint32_t End-----------------------------+
    1326             : ///
    1327             : ///
    1328             : /// BOI0, BOI1 ... are descriptions of operand bundles in this User's use list.
    1329             : /// These descriptions are installed and managed by this class, and they're all
    1330             : /// instances of OperandBundleUser<T>::BundleOpInfo.
    1331             : ///
    1332             : /// DU is an additional descriptor installed by User's 'operator new' to keep
    1333             : /// track of the 'BOI0 ... BOIN' co-allocation.  OperandBundleUser does not
    1334             : /// access or modify DU in any way, it's an implementation detail private to
    1335             : /// User.
    1336             : ///
    1337             : /// The regular Use& vector for the User starts at U0.  The operand bundle uses
    1338             : /// are part of the Use& vector, just like normal uses.  In the diagram above,
    1339             : /// the operand bundle uses start at BOI0_U0.  Each instance of BundleOpInfo has
    1340             : /// information about a contiguous set of uses constituting an operand bundle,
    1341             : /// and the total set of operand bundle uses themselves form a contiguous set of
    1342             : /// uses (i.e. there are no gaps between uses corresponding to individual
    1343             : /// operand bundles).
    1344             : ///
    1345             : /// This class does not know the location of the set of operand bundle uses
    1346             : /// within the use list -- that is decided by the User using this class via the
    1347             : /// BeginIdx argument in populateBundleOperandInfos.
    1348             : ///
    1349             : /// Currently operand bundle users with hung-off operands are not supported.
    1350             : template <typename InstrTy, typename OpIteratorTy> class OperandBundleUser {
    1351             : public:
    1352             :   /// Return the number of operand bundles associated with this User.
    1353   100700987 :   unsigned getNumOperandBundles() const {
    1354   100700987 :     return std::distance(bundle_op_info_begin(), bundle_op_info_end());
    1355             :   }
    1356             : 
    1357             :   /// Return true if this User has any operand bundles.
    1358    95616183 :   bool hasOperandBundles() const { return getNumOperandBundles() != 0; }
    1359             : 
    1360             :   /// Return the index of the first bundle operand in the Use array.
    1361             :   unsigned getBundleOperandsStartIndex() const {
    1362             :     assert(hasOperandBundles() && "Don't call otherwise!");
    1363       12610 :     return bundle_op_info_begin()->Begin;
    1364             :   }
    1365             : 
    1366             :   /// Return the index of the last bundle operand in the Use array.
    1367             :   unsigned getBundleOperandsEndIndex() const {
    1368             :     assert(hasOperandBundles() && "Don't call otherwise!");
    1369       12555 :     return bundle_op_info_end()[-1].End;
    1370             :   }
    1371             : 
    1372             :   /// Return true if the operand at index \p Idx is a bundle operand.
    1373      298274 :   bool isBundleOperand(unsigned Idx) const {
    1374      298526 :     return hasOperandBundles() && Idx >= getBundleOperandsStartIndex() &&
    1375      298274 :            Idx < getBundleOperandsEndIndex();
    1376             :   }
    1377             : 
    1378             :   /// Return the total number operands (not operand bundles) used by
    1379             :   /// every operand bundle in this OperandBundleUser.
    1380    20876837 :   unsigned getNumTotalBundleOperands() const {
    1381    20876837 :     if (!hasOperandBundles())
    1382             :       return 0;
    1383             : 
    1384             :     unsigned Begin = getBundleOperandsStartIndex();
    1385             :     unsigned End = getBundleOperandsEndIndex();
    1386             : 
    1387             :     assert(Begin <= End && "Should be!");
    1388       12454 :     return End - Begin;
    1389             :   }
    1390             : 
    1391             :   /// Return the operand bundle at a specific index.
    1392        5971 :   OperandBundleUse getOperandBundleAt(unsigned Index) const {
    1393             :     assert(Index < getNumOperandBundles() && "Index out of bounds!");
    1394       11942 :     return operandBundleFromBundleOpInfo(*(bundle_op_info_begin() + Index));
    1395             :   }
    1396             : 
    1397             :   /// Return the number of operand bundles with the tag Name attached to
    1398             :   /// this instruction.
    1399             :   unsigned countOperandBundlesOfType(StringRef Name) const {
    1400             :     unsigned Count = 0;
    1401             :     for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i)
    1402             :       if (getOperandBundleAt(i).getTagName() == Name)
    1403             :         Count++;
    1404             : 
    1405             :     return Count;
    1406             :   }
    1407             : 
    1408             :   /// Return the number of operand bundles with the tag ID attached to
    1409             :   /// this instruction.
    1410      170585 :   unsigned countOperandBundlesOfType(uint32_t ID) const {
    1411             :     unsigned Count = 0;
    1412      171488 :     for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i)
    1413        1806 :       if (getOperandBundleAt(i).getTagID() == ID)
    1414         817 :         Count++;
    1415             : 
    1416      170585 :     return Count;
    1417             :   }
    1418             : 
    1419             :   /// Return an operand bundle by name, if present.
    1420             :   ///
    1421             :   /// It is an error to call this for operand bundle types that may have
    1422             :   /// multiple instances of them on the same instruction.
    1423           2 :   Optional<OperandBundleUse> getOperandBundle(StringRef Name) const {
    1424             :     assert(countOperandBundlesOfType(Name) < 2 && "Precondition violated!");
    1425             : 
    1426           2 :     for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) {
    1427           2 :       OperandBundleUse U = getOperandBundleAt(i);
    1428           2 :       if (U.getTagName() == Name)
    1429           2 :         return U;
    1430             :     }
    1431             : 
    1432             :     return None;
    1433             :   }
    1434             : 
    1435             :   /// Return an operand bundle by tag ID, if present.
    1436             :   ///
    1437             :   /// It is an error to call this for operand bundle types that may have
    1438             :   /// multiple instances of them on the same instruction.
    1439      104259 :   Optional<OperandBundleUse> getOperandBundle(uint32_t ID) const {
    1440             :     assert(countOperandBundlesOfType(ID) < 2 && "Precondition violated!");
    1441             : 
    1442      104519 :     for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) {
    1443        1256 :       OperandBundleUse U = getOperandBundleAt(i);
    1444        2512 :       if (U.getTagID() == ID)
    1445         996 :         return U;
    1446             :     }
    1447             : 
    1448             :     return None;
    1449             :   }
    1450             : 
    1451             :   /// Return the list of operand bundles attached to this instruction as
    1452             :   /// a vector of OperandBundleDefs.
    1453             :   ///
    1454             :   /// This function copies the OperandBundeUse instances associated with this
    1455             :   /// OperandBundleUser to a vector of OperandBundleDefs.  Note:
    1456             :   /// OperandBundeUses and OperandBundleDefs are non-trivially *different*
    1457             :   /// representations of operand bundles (see documentation above).
    1458     4019317 :   void getOperandBundlesAsDefs(SmallVectorImpl<OperandBundleDef> &Defs) const {
    1459     4019583 :     for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i)
    1460         266 :       Defs.emplace_back(getOperandBundleAt(i));
    1461     4019317 :   }
    1462             : 
    1463             :   /// Return the operand bundle for the operand at index OpIdx.
    1464             :   ///
    1465             :   /// It is an error to call this with an OpIdx that does not correspond to an
    1466             :   /// bundle operand.
    1467             :   OperandBundleUse getOperandBundleForOperand(unsigned OpIdx) const {
    1468             :     return operandBundleFromBundleOpInfo(getBundleOpInfoForOperand(OpIdx));
    1469             :   }
    1470             : 
    1471             :   /// Return true if this operand bundle user has operand bundles that
    1472             :   /// may read from the heap.
    1473             :   bool hasReadingOperandBundles() const {
    1474             :     // Implementation note: this is a conservative implementation of operand
    1475             :     // bundle semantics, where *any* operand bundle forces a callsite to be at
    1476             :     // least readonly.
    1477             :     return hasOperandBundles();
    1478             :   }
    1479             : 
    1480             :   /// Return true if this operand bundle user has operand bundles that
    1481             :   /// may write to the heap.
    1482    22633146 :   bool hasClobberingOperandBundles() const {
    1483    22633921 :     for (auto &BOI : bundle_op_infos()) {
    1484         940 :       if (BOI.Tag->second == LLVMContext::OB_deopt ||
    1485             :           BOI.Tag->second == LLVMContext::OB_funclet)
    1486             :         continue;
    1487             : 
    1488             :       // This instruction has an operand bundle that is not known to us.
    1489             :       // Assume the worst.
    1490             :       return true;
    1491             :     }
    1492             : 
    1493             :     return false;
    1494             :   }
    1495             : 
    1496             :   /// Return true if the bundle operand at index \p OpIdx has the
    1497             :   /// attribute \p A.
    1498         106 :   bool bundleOperandHasAttr(unsigned OpIdx,  Attribute::AttrKind A) const {
    1499         106 :     auto &BOI = getBundleOpInfoForOperand(OpIdx);
    1500             :     auto OBU = operandBundleFromBundleOpInfo(BOI);
    1501         212 :     return OBU.operandHasAttr(OpIdx - BOI.Begin, A);
    1502             :   }
    1503             : 
    1504             :   /// Return true if \p Other has the same sequence of operand bundle
    1505             :   /// tags with the same number of operands on each one of them as this
    1506             :   /// OperandBundleUser.
    1507       51217 :   bool hasIdenticalOperandBundleSchema(
    1508             :       const OperandBundleUser<InstrTy, OpIteratorTy> &Other) const {
    1509       51217 :     if (getNumOperandBundles() != Other.getNumOperandBundles())
    1510             :       return false;
    1511             : 
    1512             :     return std::equal(bundle_op_info_begin(), bundle_op_info_end(),
    1513             :                       Other.bundle_op_info_begin());
    1514             :   }
    1515             : 
    1516             :   /// Return true if this operand bundle user contains operand bundles
    1517             :   /// with tags other than those specified in \p IDs.
    1518             :   bool hasOperandBundlesOtherThan(ArrayRef<uint32_t> IDs) const {
    1519             :     for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) {
    1520             :       uint32_t ID = getOperandBundleAt(i).getTagID();
    1521             :       if (!is_contained(IDs, ID))
    1522             :         return true;
    1523             :     }
    1524             :     return false;
    1525             :   }
    1526             : 
    1527             : protected:
    1528             :   /// Is the function attribute S disallowed by some operand bundle on
    1529             :   /// this operand bundle user?
    1530             :   bool isFnAttrDisallowedByOpBundle(StringRef S) const {
    1531             :     // Operand bundles only possibly disallow readnone, readonly and argmenonly
    1532             :     // attributes.  All String attributes are fine.
    1533             :     return false;
    1534             :   }
    1535             : 
    1536             :   /// Is the function attribute A disallowed by some operand bundle on
    1537             :   /// this operand bundle user?
    1538   134450409 :   bool isFnAttrDisallowedByOpBundle(Attribute::AttrKind A) const {
    1539   134450409 :     switch (A) {
    1540             :     default:
    1541             :       return false;
    1542             : 
    1543             :     case Attribute::InaccessibleMemOrArgMemOnly:
    1544     2055000 :       return hasReadingOperandBundles();
    1545             : 
    1546             :     case Attribute::InaccessibleMemOnly:
    1547     2055284 :       return hasReadingOperandBundles();
    1548             : 
    1549             :     case Attribute::ArgMemOnly:
    1550     9021508 :       return hasReadingOperandBundles();
    1551             : 
    1552             :     case Attribute::ReadNone:
    1553    42912746 :       return hasReadingOperandBundles();
    1554             : 
    1555    22633146 :     case Attribute::ReadOnly:
    1556    22633146 :       return hasClobberingOperandBundles();
    1557             :     }
    1558             : 
    1559             :     llvm_unreachable("switch has a default case!");
    1560             :   }
    1561             : 
    1562             :   /// Used to keep track of an operand bundle.  See the main comment on
    1563             :   /// OperandBundleUser above.
    1564             :   struct BundleOpInfo {
    1565             :     /// The operand bundle tag, interned by
    1566             :     /// LLVMContextImpl::getOrInsertBundleTag.
    1567             :     StringMapEntry<uint32_t> *Tag;
    1568             : 
    1569             :     /// The index in the Use& vector where operands for this operand
    1570             :     /// bundle starts.
    1571             :     uint32_t Begin;
    1572             : 
    1573             :     /// The index in the Use& vector where operands for this operand
    1574             :     /// bundle ends.
    1575             :     uint32_t End;
    1576             : 
    1577             :     bool operator==(const BundleOpInfo &Other) const {
    1578          10 :       return Tag == Other.Tag && Begin == Other.Begin && End == Other.End;
    1579             :     }
    1580             :   };
    1581             : 
    1582             :   /// Simple helper function to map a BundleOpInfo to an
    1583             :   /// OperandBundleUse.
    1584             :   OperandBundleUse
    1585             :   operandBundleFromBundleOpInfo(const BundleOpInfo &BOI) const {
    1586        6077 :     auto op_begin = static_cast<const InstrTy *>(this)->op_begin();
    1587        6077 :     ArrayRef<Use> Inputs(op_begin + BOI.Begin, op_begin + BOI.End);
    1588        6077 :     return OperandBundleUse(BOI.Tag, Inputs);
    1589             :   }
    1590             : 
    1591             :   using bundle_op_iterator = BundleOpInfo *;
    1592             :   using const_bundle_op_iterator = const BundleOpInfo *;
    1593             : 
    1594             :   /// Return the start of the list of BundleOpInfo instances associated
    1595             :   /// with this OperandBundleUser.
    1596             :   bundle_op_iterator bundle_op_info_begin() {
    1597   124653829 :     if (!static_cast<InstrTy *>(this)->hasDescriptor())
    1598             :       return nullptr;
    1599             : 
    1600       86794 :     uint8_t *BytesBegin = static_cast<InstrTy *>(this)->getDescriptor().begin();
    1601             :     return reinterpret_cast<bundle_op_iterator>(BytesBegin);
    1602             :   }
    1603             : 
    1604             :   /// Return the start of the list of BundleOpInfo instances associated
    1605             :   /// with this OperandBundleUser.
    1606             :   const_bundle_op_iterator bundle_op_info_begin() const {
    1607             :     auto *NonConstThis =
    1608             :         const_cast<OperandBundleUser<InstrTy, OpIteratorTy> *>(this);
    1609             :     return NonConstThis->bundle_op_info_begin();
    1610             :   }
    1611             : 
    1612             :   /// Return the end of the list of BundleOpInfo instances associated
    1613             :   /// with this OperandBundleUser.
    1614             :   bundle_op_iterator bundle_op_info_end() {
    1615   124417855 :     if (!static_cast<InstrTy *>(this)->hasDescriptor())
    1616             :       return nullptr;
    1617             : 
    1618       74502 :     uint8_t *BytesEnd = static_cast<InstrTy *>(this)->getDescriptor().end();
    1619             :     return reinterpret_cast<bundle_op_iterator>(BytesEnd);
    1620             :   }
    1621             : 
    1622             :   /// Return the end of the list of BundleOpInfo instances associated
    1623             :   /// with this OperandBundleUser.
    1624             :   const_bundle_op_iterator bundle_op_info_end() const {
    1625             :     auto *NonConstThis =
    1626             :         const_cast<OperandBundleUser<InstrTy, OpIteratorTy> *>(this);
    1627             :     return NonConstThis->bundle_op_info_end();
    1628             :   }
    1629             : 
    1630             :   /// Return the range [\p bundle_op_info_begin, \p bundle_op_info_end).
    1631      841113 :   iterator_range<bundle_op_iterator> bundle_op_infos() {
    1632      841113 :     return make_range(bundle_op_info_begin(), bundle_op_info_end());
    1633             :   }
    1634             : 
    1635             :   /// Return the range [\p bundle_op_info_begin, \p bundle_op_info_end).
    1636    22633252 :   iterator_range<const_bundle_op_iterator> bundle_op_infos() const {
    1637    22633252 :     return make_range(bundle_op_info_begin(), bundle_op_info_end());
    1638             :   }
    1639             : 
    1640             :   /// Populate the BundleOpInfo instances and the Use& vector from \p
    1641             :   /// Bundles.  Return the op_iterator pointing to the Use& one past the last
    1642             :   /// last bundle operand use.
    1643             :   ///
    1644             :   /// Each \p OperandBundleDef instance is tracked by a OperandBundleInfo
    1645             :   /// instance allocated in this User's descriptor.
    1646      841112 :   OpIteratorTy populateBundleOperandInfos(ArrayRef<OperandBundleDef> Bundles,
    1647             :                                           const unsigned BeginIndex) {
    1648     1682224 :     auto It = static_cast<InstrTy *>(this)->op_begin() + BeginIndex;
    1649      844198 :     for (auto &B : Bundles)
    1650             :       It = std::copy(B.input_begin(), B.input_end(), It);
    1651             : 
    1652      841112 :     auto *ContextImpl = static_cast<InstrTy *>(this)->getContext().pImpl;
    1653             :     auto BI = Bundles.begin();
    1654             :     unsigned CurrentIndex = BeginIndex;
    1655             : 
    1656      842655 :     for (auto &BOI : bundle_op_infos()) {
    1657             :       assert(BI != Bundles.end() && "Incorrect allocation?");
    1658             : 
    1659        1543 :       BOI.Tag = ContextImpl->getOrInsertBundleTag(BI->getTag());
    1660        1543 :       BOI.Begin = CurrentIndex;
    1661        1543 :       BOI.End = CurrentIndex + BI->input_size();
    1662             :       CurrentIndex = BOI.End;
    1663        1543 :       BI++;
    1664             :     }
    1665             : 
    1666             :     assert(BI == Bundles.end() && "Incorrect allocation?");
    1667             : 
    1668      841112 :     return It;
    1669             :   }
    1670             : 
    1671             :   /// Return the BundleOpInfo for the operand at index OpIdx.
    1672             :   ///
    1673             :   /// It is an error to call this with an OpIdx that does not correspond to an
    1674             :   /// bundle operand.
    1675         106 :   const BundleOpInfo &getBundleOpInfoForOperand(unsigned OpIdx) const {
    1676         106 :     for (auto &BOI : bundle_op_infos())
    1677         106 :       if (BOI.Begin <= OpIdx && OpIdx < BOI.End)
    1678         106 :         return BOI;
    1679             : 
    1680           0 :     llvm_unreachable("Did not find operand bundle for operand!");
    1681             :   }
    1682             : 
    1683             :   /// Return the total number of values used in \p Bundles.
    1684             :   static unsigned CountBundleInputs(ArrayRef<OperandBundleDef> Bundles) {
    1685             :     unsigned Total = 0;
    1686     2407066 :     for (auto &B : Bundles)
    1687        4041 :       Total += B.input_size();
    1688             :     return Total;
    1689             :   }
    1690             : };
    1691             : 
    1692             : } // end namespace llvm
    1693             : 
    1694             : #endif // LLVM_IR_INSTRTYPES_H

Generated by: LCOV version 1.13