LCOV - code coverage report
Current view: top level - include/llvm/IR - Instructions.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 1677 1998 83.9 %
Date: 2018-10-20 13:21:21 Functions: 108 163 66.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- llvm/Instructions.h - Instruction subclass definitions ---*- 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 exposes the class definitions of all of the subclasses of the
      11             : // Instruction class.  This is meant to be an easy way to get access to all
      12             : // instruction subclasses.
      13             : //
      14             : //===----------------------------------------------------------------------===//
      15             : 
      16             : #ifndef LLVM_IR_INSTRUCTIONS_H
      17             : #define LLVM_IR_INSTRUCTIONS_H
      18             : 
      19             : #include "llvm/ADT/ArrayRef.h"
      20             : #include "llvm/ADT/None.h"
      21             : #include "llvm/ADT/STLExtras.h"
      22             : #include "llvm/ADT/SmallVector.h"
      23             : #include "llvm/ADT/StringRef.h"
      24             : #include "llvm/ADT/Twine.h"
      25             : #include "llvm/ADT/iterator.h"
      26             : #include "llvm/ADT/iterator_range.h"
      27             : #include "llvm/IR/Attributes.h"
      28             : #include "llvm/IR/BasicBlock.h"
      29             : #include "llvm/IR/CallingConv.h"
      30             : #include "llvm/IR/Constant.h"
      31             : #include "llvm/IR/DerivedTypes.h"
      32             : #include "llvm/IR/Function.h"
      33             : #include "llvm/IR/InstrTypes.h"
      34             : #include "llvm/IR/Instruction.h"
      35             : #include "llvm/IR/OperandTraits.h"
      36             : #include "llvm/IR/Type.h"
      37             : #include "llvm/IR/Use.h"
      38             : #include "llvm/IR/User.h"
      39             : #include "llvm/IR/Value.h"
      40             : #include "llvm/Support/AtomicOrdering.h"
      41             : #include "llvm/Support/Casting.h"
      42             : #include "llvm/Support/ErrorHandling.h"
      43             : #include <cassert>
      44             : #include <cstddef>
      45             : #include <cstdint>
      46             : #include <iterator>
      47             : 
      48             : namespace llvm {
      49             : 
      50             : class APInt;
      51             : class ConstantInt;
      52             : class DataLayout;
      53             : class LLVMContext;
      54             : 
      55             : //===----------------------------------------------------------------------===//
      56             : //                                AllocaInst Class
      57             : //===----------------------------------------------------------------------===//
      58             : 
      59             : /// an instruction to allocate memory on the stack
      60     4542173 : class AllocaInst : public UnaryInstruction {
      61             :   Type *AllocatedType;
      62             : 
      63             : protected:
      64             :   // Note: Instruction needs to be a friend here to call cloneImpl.
      65             :   friend class Instruction;
      66             : 
      67             :   AllocaInst *cloneImpl() const;
      68             : 
      69             : public:
      70             :   explicit AllocaInst(Type *Ty, unsigned AddrSpace,
      71             :                       Value *ArraySize = nullptr,
      72             :                       const Twine &Name = "",
      73             :                       Instruction *InsertBefore = nullptr);
      74             :   AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
      75             :              const Twine &Name, BasicBlock *InsertAtEnd);
      76             : 
      77             :   AllocaInst(Type *Ty, unsigned AddrSpace,
      78             :              const Twine &Name, Instruction *InsertBefore = nullptr);
      79             :   AllocaInst(Type *Ty, unsigned AddrSpace,
      80             :              const Twine &Name, BasicBlock *InsertAtEnd);
      81             : 
      82             :   AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, unsigned Align,
      83             :              const Twine &Name = "", Instruction *InsertBefore = nullptr);
      84             :   AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, unsigned Align,
      85             :              const Twine &Name, BasicBlock *InsertAtEnd);
      86             : 
      87             :   /// Return true if there is an allocation size parameter to the allocation
      88             :   /// instruction that is not 1.
      89             :   bool isArrayAllocation() const;
      90             : 
      91             :   /// Get the number of elements allocated. For a simple allocation of a single
      92             :   /// element, this will return a constant 1 value.
      93             :   const Value *getArraySize() const { return getOperand(0); }
      94             :   Value *getArraySize() { return getOperand(0); }
      95             : 
      96             :   /// Overload to return most specific pointer type.
      97             :   PointerType *getType() const {
      98     8649086 :     return cast<PointerType>(Instruction::getType());
      99             :   }
     100             : 
     101             :   /// Get allocation size in bits. Returns None if size can't be determined,
     102             :   /// e.g. in case of a VLA.
     103             :   Optional<uint64_t> getAllocationSizeInBits(const DataLayout &DL) const;
     104             : 
     105             :   /// Return the type that is being allocated by the instruction.
     106           0 :   Type *getAllocatedType() const { return AllocatedType; }
     107             :   /// for use only in special circumstances that need to generically
     108             :   /// transform a whole instruction (eg: IR linking and vectorization).
     109          84 :   void setAllocatedType(Type *Ty) { AllocatedType = Ty; }
     110             : 
     111             :   /// Return the alignment of the memory that is being allocated by the
     112             :   /// instruction.
     113             :   unsigned getAlignment() const {
     114    20951944 :     return (1u << (getSubclassDataFromInstruction() & 31)) >> 1;
     115             :   }
     116             :   void setAlignment(unsigned Align);
     117             : 
     118             :   /// Return true if this alloca is in the entry block of the function and is a
     119             :   /// constant size. If so, the code generator will fold it into the
     120             :   /// prolog/epilog code, so it is basically free.
     121             :   bool isStaticAlloca() const;
     122             : 
     123             :   /// Return true if this alloca is used as an inalloca argument to a call. Such
     124             :   /// allocas are never considered static even if they are in the entry block.
     125             :   bool isUsedWithInAlloca() const {
     126       24583 :     return getSubclassDataFromInstruction() & 32;
     127             :   }
     128             : 
     129             :   /// Specify whether this alloca is used to represent the arguments to a call.
     130             :   void setUsedWithInAlloca(bool V) {
     131    15828718 :     setInstructionSubclassData((getSubclassDataFromInstruction() & ~32) |
     132             :                                (V ? 32 : 0));
     133             :   }
     134             : 
     135             :   /// Return true if this alloca is used as a swifterror argument to a call.
     136             :   bool isSwiftError() const {
     137      123248 :     return getSubclassDataFromInstruction() & 64;
     138             :   }
     139             : 
     140             :   /// Specify whether this alloca is used to represent a swifterror.
     141             :   void setSwiftError(bool V) {
     142     7998932 :     setInstructionSubclassData((getSubclassDataFromInstruction() & ~64) |
     143             :                                (V ? 64 : 0));
     144             :   }
     145             : 
     146             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
     147             :   static bool classof(const Instruction *I) {
     148           0 :     return (I->getOpcode() == Instruction::Alloca);
     149             :   }
     150             :   static bool classof(const Value *V) {
     151   342835798 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
     152             :   }
     153             : 
     154             : private:
     155             :   // Shadow Instruction::setInstructionSubclassData with a private forwarding
     156             :   // method so that subclasses cannot accidentally use it.
     157             :   void setInstructionSubclassData(unsigned short D) {
     158             :     Instruction::setInstructionSubclassData(D);
     159             :   }
     160             : };
     161             : 
     162             : //===----------------------------------------------------------------------===//
     163             : //                                LoadInst Class
     164             : //===----------------------------------------------------------------------===//
     165             : 
     166             : /// An instruction for reading from memory. This uses the SubclassData field in
     167             : /// Value to store whether or not the load is volatile.
     168     5457180 : class LoadInst : public UnaryInstruction {
     169             :   void AssertOK();
     170             : 
     171             : protected:
     172             :   // Note: Instruction needs to be a friend here to call cloneImpl.
     173             :   friend class Instruction;
     174             : 
     175             :   LoadInst *cloneImpl() const;
     176             : 
     177             : public:
     178             :   LoadInst(Value *Ptr, const Twine &NameStr, Instruction *InsertBefore);
     179             :   LoadInst(Value *Ptr, const Twine &NameStr, BasicBlock *InsertAtEnd);
     180             :   LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile = false,
     181             :            Instruction *InsertBefore = nullptr);
     182             :   LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile = false,
     183             :            Instruction *InsertBefore = nullptr)
     184        2991 :       : LoadInst(cast<PointerType>(Ptr->getType())->getElementType(), Ptr,
     185        2991 :                  NameStr, isVolatile, InsertBefore) {}
     186             :   LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
     187             :            BasicBlock *InsertAtEnd);
     188             :   LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, unsigned Align,
     189             :            Instruction *InsertBefore = nullptr)
     190         172 :       : LoadInst(cast<PointerType>(Ptr->getType())->getElementType(), Ptr,
     191         172 :                  NameStr, isVolatile, Align, InsertBefore) {}
     192             :   LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
     193             :            unsigned Align, Instruction *InsertBefore = nullptr);
     194             :   LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
     195             :            unsigned Align, BasicBlock *InsertAtEnd);
     196             :   LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, unsigned Align,
     197             :            AtomicOrdering Order, SyncScope::ID SSID = SyncScope::System,
     198             :            Instruction *InsertBefore = nullptr)
     199     9452094 :       : LoadInst(cast<PointerType>(Ptr->getType())->getElementType(), Ptr,
     200     9452094 :                  NameStr, isVolatile, Align, Order, SSID, InsertBefore) {}
     201             :   LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
     202             :            unsigned Align, AtomicOrdering Order,
     203             :            SyncScope::ID SSID = SyncScope::System,
     204             :            Instruction *InsertBefore = nullptr);
     205             :   LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
     206             :            unsigned Align, AtomicOrdering Order, SyncScope::ID SSID,
     207             :            BasicBlock *InsertAtEnd);
     208             :   LoadInst(Value *Ptr, const char *NameStr, Instruction *InsertBefore);
     209             :   LoadInst(Value *Ptr, const char *NameStr, BasicBlock *InsertAtEnd);
     210             :   LoadInst(Type *Ty, Value *Ptr, const char *NameStr = nullptr,
     211             :            bool isVolatile = false, Instruction *InsertBefore = nullptr);
     212             :   explicit LoadInst(Value *Ptr, const char *NameStr = nullptr,
     213             :                     bool isVolatile = false,
     214             :                     Instruction *InsertBefore = nullptr)
     215     3528295 :       : LoadInst(cast<PointerType>(Ptr->getType())->getElementType(), Ptr,
     216     3528295 :                  NameStr, isVolatile, InsertBefore) {}
     217             :   LoadInst(Value *Ptr, const char *NameStr, bool isVolatile,
     218             :            BasicBlock *InsertAtEnd);
     219             : 
     220             :   /// Return true if this is a load from a volatile memory location.
     221    16630344 :   bool isVolatile() const { return getSubclassDataFromInstruction() & 1; }
     222             : 
     223             :   /// Specify whether this is a volatile load or not.
     224             :   void setVolatile(bool V) {
     225    26365682 :     setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
     226             :                                (V ? 1 : 0));
     227             :   }
     228             : 
     229             :   /// Return the alignment of the access that is being performed.
     230             :   unsigned getAlignment() const {
     231    32989917 :     return (1 << ((getSubclassDataFromInstruction() >> 1) & 31)) >> 1;
     232             :   }
     233             : 
     234             :   void setAlignment(unsigned Align);
     235             : 
     236             :   /// Returns the ordering constraint of this load instruction.
     237             :   AtomicOrdering getOrdering() const {
     238    59955344 :     return AtomicOrdering((getSubclassDataFromInstruction() >> 7) & 7);
     239             :   }
     240             : 
     241             :   /// Sets the ordering constraint of this load instruction.  May not be Release
     242             :   /// or AcquireRelease.
     243             :   void setOrdering(AtomicOrdering Ordering) {
     244     3549041 :     setInstructionSubclassData((getSubclassDataFromInstruction() & ~(7 << 7)) |
     245     9670052 :                                ((unsigned)Ordering << 7));
     246             :   }
     247             : 
     248             :   /// Returns the synchronization scope ID of this load instruction.
     249           0 :   SyncScope::ID getSyncScopeID() const {
     250           0 :     return SSID;
     251             :   }
     252             : 
     253             :   /// Sets the synchronization scope ID of this load instruction.
     254             :   void setSyncScopeID(SyncScope::ID SSID) {
     255    13202659 :     this->SSID = SSID;
     256             :   }
     257             : 
     258             :   /// Sets the ordering constraint and the synchronization scope ID of this load
     259             :   /// instruction.
     260             :   void setAtomic(AtomicOrdering Ordering,
     261             :                  SyncScope::ID SSID = SyncScope::System) {
     262             :     setOrdering(Ordering);
     263             :     setSyncScopeID(SSID);
     264             :   }
     265             : 
     266     8499380 :   bool isSimple() const { return !isAtomic() && !isVolatile(); }
     267             : 
     268             :   bool isUnordered() const {
     269       24708 :     return (getOrdering() == AtomicOrdering::NotAtomic ||
     270    40249608 :             getOrdering() == AtomicOrdering::Unordered) &&
     271             :            !isVolatile();
     272             :   }
     273             : 
     274             :   Value *getPointerOperand() { return getOperand(0); }
     275             :   const Value *getPointerOperand() const { return getOperand(0); }
     276             :   static unsigned getPointerOperandIndex() { return 0U; }
     277     2018267 :   Type *getPointerOperandType() const { return getPointerOperand()->getType(); }
     278             : 
     279             :   /// Returns the address space of the pointer operand.
     280             :   unsigned getPointerAddressSpace() const {
     281             :     return getPointerOperandType()->getPointerAddressSpace();
     282             :   }
     283             : 
     284             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
     285             :   static bool classof(const Instruction *I) {
     286     2524190 :     return I->getOpcode() == Instruction::Load;
     287             :   }
     288             :   static bool classof(const Value *V) {
     289    62328608 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
     290             :   }
     291             : 
     292             : private:
     293             :   // Shadow Instruction::setInstructionSubclassData with a private forwarding
     294             :   // method so that subclasses cannot accidentally use it.
     295             :   void setInstructionSubclassData(unsigned short D) {
     296             :     Instruction::setInstructionSubclassData(D);
     297             :   }
     298             : 
     299             :   /// The synchronization scope ID of this load instruction.  Not quite enough
     300             :   /// room in SubClassData for everything, so synchronization scope ID gets its
     301             :   /// own field.
     302             :   SyncScope::ID SSID;
     303             : };
     304             : 
     305             : //===----------------------------------------------------------------------===//
     306             : //                                StoreInst Class
     307             : //===----------------------------------------------------------------------===//
     308             : 
     309             : /// An instruction for storing to memory.
     310     5469742 : class StoreInst : public Instruction {
     311             :   void AssertOK();
     312             : 
     313             : protected:
     314             :   // Note: Instruction needs to be a friend here to call cloneImpl.
     315             :   friend class Instruction;
     316             : 
     317             :   StoreInst *cloneImpl() const;
     318             : 
     319             : public:
     320             :   StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore);
     321             :   StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd);
     322             :   StoreInst(Value *Val, Value *Ptr, bool isVolatile = false,
     323             :             Instruction *InsertBefore = nullptr);
     324             :   StoreInst(Value *Val, Value *Ptr, bool isVolatile, BasicBlock *InsertAtEnd);
     325             :   StoreInst(Value *Val, Value *Ptr, bool isVolatile,
     326             :             unsigned Align, Instruction *InsertBefore = nullptr);
     327             :   StoreInst(Value *Val, Value *Ptr, bool isVolatile,
     328             :             unsigned Align, BasicBlock *InsertAtEnd);
     329             :   StoreInst(Value *Val, Value *Ptr, bool isVolatile,
     330             :             unsigned Align, AtomicOrdering Order,
     331             :             SyncScope::ID SSID = SyncScope::System,
     332             :             Instruction *InsertBefore = nullptr);
     333             :   StoreInst(Value *Val, Value *Ptr, bool isVolatile,
     334             :             unsigned Align, AtomicOrdering Order, SyncScope::ID SSID,
     335             :             BasicBlock *InsertAtEnd);
     336             : 
     337             :   // allocate space for exactly two operands
     338             :   void *operator new(size_t s) {
     339    12250736 :     return User::operator new(s, 2);
     340             :   }
     341             : 
     342             :   /// Return true if this is a store to a volatile memory location.
     343    14185810 :   bool isVolatile() const { return getSubclassDataFromInstruction() & 1; }
     344             : 
     345             :   /// Specify whether this is a volatile store or not.
     346             :   void setVolatile(bool V) {
     347    24488259 :     setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
     348             :                                (V ? 1 : 0));
     349             :   }
     350             : 
     351             :   /// Transparently provide more efficient getOperand methods.
     352             :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
     353             : 
     354             :   /// Return the alignment of the access that is being performed
     355             :   unsigned getAlignment() const {
     356    27939737 :     return (1 << ((getSubclassDataFromInstruction() >> 1) & 31)) >> 1;
     357             :   }
     358             : 
     359             :   void setAlignment(unsigned Align);
     360             : 
     361             :   /// Returns the ordering constraint of this store instruction.
     362             :   AtomicOrdering getOrdering() const {
     363    53980524 :     return AtomicOrdering((getSubclassDataFromInstruction() >> 7) & 7);
     364             :   }
     365             : 
     366             :   /// Sets the ordering constraint of this store instruction.  May not be
     367             :   /// Acquire or AcquireRelease.
     368             :   void setOrdering(AtomicOrdering Ordering) {
     369    24505114 :     setInstructionSubclassData((getSubclassDataFromInstruction() & ~(7 << 7)) |
     370    12252449 :                                ((unsigned)Ordering << 7));
     371             :   }
     372             : 
     373             :   /// Returns the synchronization scope ID of this store instruction.
     374           0 :   SyncScope::ID getSyncScopeID() const {
     375           0 :     return SSID;
     376             :   }
     377             : 
     378             :   /// Sets the synchronization scope ID of this store instruction.
     379             :   void setSyncScopeID(SyncScope::ID SSID) {
     380    12252540 :     this->SSID = SSID;
     381             :   }
     382             : 
     383             :   /// Sets the ordering constraint and the synchronization scope ID of this
     384             :   /// store instruction.
     385             :   void setAtomic(AtomicOrdering Ordering,
     386             :                  SyncScope::ID SSID = SyncScope::System) {
     387             :     setOrdering(Ordering);
     388             :     setSyncScopeID(SSID);
     389             :   }
     390             : 
     391     9024024 :   bool isSimple() const { return !isAtomic() && !isVolatile(); }
     392             : 
     393             :   bool isUnordered() const {
     394        2712 :     return (getOrdering() == AtomicOrdering::NotAtomic ||
     395    27588661 :             getOrdering() == AtomicOrdering::Unordered) &&
     396             :            !isVolatile();
     397             :   }
     398             : 
     399             :   Value *getValueOperand() { return getOperand(0); }
     400             :   const Value *getValueOperand() const { return getOperand(0); }
     401             : 
     402             :   Value *getPointerOperand() { return getOperand(1); }
     403             :   const Value *getPointerOperand() const { return getOperand(1); }
     404             :   static unsigned getPointerOperandIndex() { return 1U; }
     405     8428486 :   Type *getPointerOperandType() const { return getPointerOperand()->getType(); }
     406             : 
     407             :   /// Returns the address space of the pointer operand.
     408             :   unsigned getPointerAddressSpace() const {
     409             :     return getPointerOperandType()->getPointerAddressSpace();
     410             :   }
     411             : 
     412             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
     413             :   static bool classof(const Instruction *I) {
     414     1828974 :     return I->getOpcode() == Instruction::Store;
     415             :   }
     416             :   static bool classof(const Value *V) {
     417    15977664 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
     418             :   }
     419             : 
     420             : private:
     421             :   // Shadow Instruction::setInstructionSubclassData with a private forwarding
     422             :   // method so that subclasses cannot accidentally use it.
     423             :   void setInstructionSubclassData(unsigned short D) {
     424             :     Instruction::setInstructionSubclassData(D);
     425             :   }
     426             : 
     427             :   /// The synchronization scope ID of this store instruction.  Not quite enough
     428             :   /// room in SubClassData for everything, so synchronization scope ID gets its
     429             :   /// own field.
     430             :   SyncScope::ID SSID;
     431             : };
     432             : 
     433             : template <>
     434             : struct OperandTraits<StoreInst> : public FixedNumOperandTraits<StoreInst, 2> {
     435             : };
     436             : 
     437   147239458 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(StoreInst, Value)
     438             : 
     439             : //===----------------------------------------------------------------------===//
     440             : //                                FenceInst Class
     441             : //===----------------------------------------------------------------------===//
     442             : 
     443             : /// An instruction for ordering other memory operations.
     444        1012 : class FenceInst : public Instruction {
     445             :   void Init(AtomicOrdering Ordering, SyncScope::ID SSID);
     446             : 
     447             : protected:
     448             :   // Note: Instruction needs to be a friend here to call cloneImpl.
     449             :   friend class Instruction;
     450             : 
     451             :   FenceInst *cloneImpl() const;
     452             : 
     453             : public:
     454             :   // Ordering may only be Acquire, Release, AcquireRelease, or
     455             :   // SequentiallyConsistent.
     456             :   FenceInst(LLVMContext &C, AtomicOrdering Ordering,
     457             :             SyncScope::ID SSID = SyncScope::System,
     458             :             Instruction *InsertBefore = nullptr);
     459             :   FenceInst(LLVMContext &C, AtomicOrdering Ordering, SyncScope::ID SSID,
     460             :             BasicBlock *InsertAtEnd);
     461             : 
     462             :   // allocate space for exactly zero operands
     463             :   void *operator new(size_t s) {
     464        1032 :     return User::operator new(s, 0);
     465             :   }
     466             : 
     467             :   /// Returns the ordering constraint of this fence instruction.
     468             :   AtomicOrdering getOrdering() const {
     469        3168 :     return AtomicOrdering(getSubclassDataFromInstruction() >> 1);
     470             :   }
     471             : 
     472             :   /// Sets the ordering constraint of this fence instruction.  May only be
     473             :   /// Acquire, Release, AcquireRelease, or SequentiallyConsistent.
     474             :   void setOrdering(AtomicOrdering Ordering) {
     475        2064 :     setInstructionSubclassData((getSubclassDataFromInstruction() & 1) |
     476        1032 :                                ((unsigned)Ordering << 1));
     477             :   }
     478             : 
     479             :   /// Returns the synchronization scope ID of this fence instruction.
     480           0 :   SyncScope::ID getSyncScopeID() const {
     481           0 :     return SSID;
     482             :   }
     483             : 
     484             :   /// Sets the synchronization scope ID of this fence instruction.
     485             :   void setSyncScopeID(SyncScope::ID SSID) {
     486        1032 :     this->SSID = SSID;
     487             :   }
     488             : 
     489             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
     490             :   static bool classof(const Instruction *I) {
     491           0 :     return I->getOpcode() == Instruction::Fence;
     492             :   }
     493             :   static bool classof(const Value *V) {
     494             :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
     495             :   }
     496             : 
     497             : private:
     498             :   // Shadow Instruction::setInstructionSubclassData with a private forwarding
     499             :   // method so that subclasses cannot accidentally use it.
     500             :   void setInstructionSubclassData(unsigned short D) {
     501             :     Instruction::setInstructionSubclassData(D);
     502             :   }
     503             : 
     504             :   /// The synchronization scope ID of this fence instruction.  Not quite enough
     505             :   /// room in SubClassData for everything, so synchronization scope ID gets its
     506             :   /// own field.
     507             :   SyncScope::ID SSID;
     508             : };
     509             : 
     510             : //===----------------------------------------------------------------------===//
     511             : //                                AtomicCmpXchgInst Class
     512             : //===----------------------------------------------------------------------===//
     513             : 
     514             : /// an instruction that atomically checks whether a
     515             : /// specified value is in a memory location, and, if it is, stores a new value
     516             : /// there.  Returns the value that was loaded.
     517             : ///
     518        5311 : class AtomicCmpXchgInst : public Instruction {
     519             :   void Init(Value *Ptr, Value *Cmp, Value *NewVal,
     520             :             AtomicOrdering SuccessOrdering, AtomicOrdering FailureOrdering,
     521             :             SyncScope::ID SSID);
     522             : 
     523             : protected:
     524             :   // Note: Instruction needs to be a friend here to call cloneImpl.
     525             :   friend class Instruction;
     526             : 
     527             :   AtomicCmpXchgInst *cloneImpl() const;
     528             : 
     529             : public:
     530             :   AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal,
     531             :                     AtomicOrdering SuccessOrdering,
     532             :                     AtomicOrdering FailureOrdering,
     533             :                     SyncScope::ID SSID, Instruction *InsertBefore = nullptr);
     534             :   AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal,
     535             :                     AtomicOrdering SuccessOrdering,
     536             :                     AtomicOrdering FailureOrdering,
     537             :                     SyncScope::ID SSID, BasicBlock *InsertAtEnd);
     538             : 
     539             :   // allocate space for exactly three operands
     540             :   void *operator new(size_t s) {
     541       10272 :     return User::operator new(s, 3);
     542             :   }
     543             : 
     544             :   /// Return true if this is a cmpxchg from a volatile memory
     545             :   /// location.
     546             :   ///
     547             :   bool isVolatile() const {
     548        5013 :     return getSubclassDataFromInstruction() & 1;
     549             :   }
     550             : 
     551             :   /// Specify whether this is a volatile cmpxchg.
     552             :   ///
     553             :   void setVolatile(bool V) {
     554        8541 :      setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
     555             :                                 (unsigned)V);
     556             :   }
     557             : 
     558             :   /// Return true if this cmpxchg may spuriously fail.
     559             :   bool isWeak() const {
     560        5007 :     return getSubclassDataFromInstruction() & 0x100;
     561             :   }
     562             : 
     563             :   void setWeak(bool IsWeak) {
     564       16924 :     setInstructionSubclassData((getSubclassDataFromInstruction() & ~0x100) |
     565        8462 :                                (IsWeak << 8));
     566             :   }
     567             : 
     568             :   /// Transparently provide more efficient getOperand methods.
     569             :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
     570             : 
     571             :   /// Returns the success ordering constraint of this cmpxchg instruction.
     572             :   AtomicOrdering getSuccessOrdering() const {
     573       18275 :     return AtomicOrdering((getSubclassDataFromInstruction() >> 2) & 7);
     574             :   }
     575             : 
     576             :   /// Sets the success ordering constraint of this cmpxchg instruction.
     577             :   void setSuccessOrdering(AtomicOrdering Ordering) {
     578             :     assert(Ordering != AtomicOrdering::NotAtomic &&
     579             :            "CmpXchg instructions can only be atomic.");
     580       20695 :     setInstructionSubclassData((getSubclassDataFromInstruction() & ~0x1c) |
     581       10278 :                                ((unsigned)Ordering << 2));
     582             :   }
     583             : 
     584             :   /// Returns the failure ordering constraint of this cmpxchg instruction.
     585             :   AtomicOrdering getFailureOrdering() const {
     586       16479 :     return AtomicOrdering((getSubclassDataFromInstruction() >> 5) & 7);
     587             :   }
     588             : 
     589             :   /// Sets the failure ordering constraint of this cmpxchg instruction.
     590             :   void setFailureOrdering(AtomicOrdering Ordering) {
     591             :     assert(Ordering != AtomicOrdering::NotAtomic &&
     592             :            "CmpXchg instructions can only be atomic.");
     593       20683 :     setInstructionSubclassData((getSubclassDataFromInstruction() & ~0xe0) |
     594       10272 :                                ((unsigned)Ordering << 5));
     595             :   }
     596             : 
     597             :   /// Returns the synchronization scope ID of this cmpxchg instruction.
     598           0 :   SyncScope::ID getSyncScopeID() const {
     599           0 :     return SSID;
     600             :   }
     601             : 
     602             :   /// Sets the synchronization scope ID of this cmpxchg instruction.
     603             :   void setSyncScopeID(SyncScope::ID SSID) {
     604       10272 :     this->SSID = SSID;
     605             :   }
     606             : 
     607             :   Value *getPointerOperand() { return getOperand(0); }
     608             :   const Value *getPointerOperand() const { return getOperand(0); }
     609             :   static unsigned getPointerOperandIndex() { return 0U; }
     610             : 
     611             :   Value *getCompareOperand() { return getOperand(1); }
     612             :   const Value *getCompareOperand() const { return getOperand(1); }
     613             : 
     614             :   Value *getNewValOperand() { return getOperand(2); }
     615             :   const Value *getNewValOperand() const { return getOperand(2); }
     616             : 
     617             :   /// Returns the address space of the pointer operand.
     618             :   unsigned getPointerAddressSpace() const {
     619        1581 :     return getPointerOperand()->getType()->getPointerAddressSpace();
     620             :   }
     621             : 
     622             :   /// Returns the strongest permitted ordering on failure, given the
     623             :   /// desired ordering on success.
     624             :   ///
     625             :   /// If the comparison in a cmpxchg operation fails, there is no atomic store
     626             :   /// so release semantics cannot be provided. So this function drops explicit
     627             :   /// Release requests from the AtomicOrdering. A SequentiallyConsistent
     628             :   /// operation would remain SequentiallyConsistent.
     629             :   static AtomicOrdering
     630             :   getStrongestFailureOrdering(AtomicOrdering SuccessOrdering) {
     631        1992 :     switch (SuccessOrdering) {
     632           0 :     default:
     633           0 :       llvm_unreachable("invalid cmpxchg success ordering");
     634             :     case AtomicOrdering::Release:
     635             :     case AtomicOrdering::Monotonic:
     636             :       return AtomicOrdering::Monotonic;
     637         603 :     case AtomicOrdering::AcquireRelease:
     638             :     case AtomicOrdering::Acquire:
     639             :       return AtomicOrdering::Acquire;
     640         350 :     case AtomicOrdering::SequentiallyConsistent:
     641             :       return AtomicOrdering::SequentiallyConsistent;
     642             :     }
     643             :   }
     644             : 
     645             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
     646             :   static bool classof(const Instruction *I) {
     647           0 :     return I->getOpcode() == Instruction::AtomicCmpXchg;
     648             :   }
     649             :   static bool classof(const Value *V) {
     650     1065053 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
     651             :   }
     652             : 
     653             : private:
     654             :   // Shadow Instruction::setInstructionSubclassData with a private forwarding
     655             :   // method so that subclasses cannot accidentally use it.
     656             :   void setInstructionSubclassData(unsigned short D) {
     657             :     Instruction::setInstructionSubclassData(D);
     658             :   }
     659             : 
     660             :   /// The synchronization scope ID of this cmpxchg instruction.  Not quite
     661             :   /// enough room in SubClassData for everything, so synchronization scope ID
     662             :   /// gets its own field.
     663             :   SyncScope::ID SSID;
     664             : };
     665             : 
     666             : template <>
     667             : struct OperandTraits<AtomicCmpXchgInst> :
     668             :     public FixedNumOperandTraits<AtomicCmpXchgInst, 3> {
     669             : };
     670             : 
     671       75417 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(AtomicCmpXchgInst, Value)
     672             : 
     673             : //===----------------------------------------------------------------------===//
     674             : //                                AtomicRMWInst Class
     675             : //===----------------------------------------------------------------------===//
     676             : 
     677             : /// an instruction that atomically reads a memory location,
     678             : /// combines it with another value, and then stores the result back.  Returns
     679             : /// the old value.
     680             : ///
     681       16075 : class AtomicRMWInst : public Instruction {
     682             : protected:
     683             :   // Note: Instruction needs to be a friend here to call cloneImpl.
     684             :   friend class Instruction;
     685             : 
     686             :   AtomicRMWInst *cloneImpl() const;
     687             : 
     688             : public:
     689             :   /// This enumeration lists the possible modifications atomicrmw can make.  In
     690             :   /// the descriptions, 'p' is the pointer to the instruction's memory location,
     691             :   /// 'old' is the initial value of *p, and 'v' is the other value passed to the
     692             :   /// instruction.  These instructions always return 'old'.
     693             :   enum BinOp {
     694             :     /// *p = v
     695             :     Xchg,
     696             :     /// *p = old + v
     697             :     Add,
     698             :     /// *p = old - v
     699             :     Sub,
     700             :     /// *p = old & v
     701             :     And,
     702             :     /// *p = ~(old & v)
     703             :     Nand,
     704             :     /// *p = old | v
     705             :     Or,
     706             :     /// *p = old ^ v
     707             :     Xor,
     708             :     /// *p = old >signed v ? old : v
     709             :     Max,
     710             :     /// *p = old <signed v ? old : v
     711             :     Min,
     712             :     /// *p = old >unsigned v ? old : v
     713             :     UMax,
     714             :     /// *p = old <unsigned v ? old : v
     715             :     UMin,
     716             : 
     717             :     FIRST_BINOP = Xchg,
     718             :     LAST_BINOP = UMin,
     719             :     BAD_BINOP
     720             :   };
     721             : 
     722             :   AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val,
     723             :                 AtomicOrdering Ordering, SyncScope::ID SSID,
     724             :                 Instruction *InsertBefore = nullptr);
     725             :   AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val,
     726             :                 AtomicOrdering Ordering, SyncScope::ID SSID,
     727             :                 BasicBlock *InsertAtEnd);
     728             : 
     729             :   // allocate space for exactly two operands
     730             :   void *operator new(size_t s) {
     731       19898 :     return User::operator new(s, 2);
     732             :   }
     733             : 
     734             :   BinOp getOperation() const {
     735       55910 :     return static_cast<BinOp>(getSubclassDataFromInstruction() >> 5);
     736             :   }
     737             : 
     738             :   static StringRef getOperationName(BinOp Op);
     739             : 
     740             :   void setOperation(BinOp Operation) {
     741             :     unsigned short SubclassData = getSubclassDataFromInstruction();
     742       39796 :     setInstructionSubclassData((SubclassData & 31) |
     743       19898 :                                (Operation << 5));
     744             :   }
     745             : 
     746             :   /// Return true if this is a RMW on a volatile memory location.
     747             :   ///
     748             :   bool isVolatile() const {
     749        9067 :     return getSubclassDataFromInstruction() & 1;
     750             :   }
     751             : 
     752             :   /// Specify whether this is a volatile RMW or not.
     753             :   ///
     754             :   void setVolatile(bool V) {
     755       18899 :      setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
     756             :                                 (unsigned)V);
     757             :   }
     758             : 
     759             :   /// Transparently provide more efficient getOperand methods.
     760             :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
     761             : 
     762             :   /// Returns the ordering constraint of this rmw instruction.
     763             :   AtomicOrdering getOrdering() const {
     764       40018 :     return AtomicOrdering((getSubclassDataFromInstruction() >> 2) & 7);
     765             :   }
     766             : 
     767             :   /// Sets the ordering constraint of this rmw instruction.
     768             :   void setOrdering(AtomicOrdering Ordering) {
     769             :     assert(Ordering != AtomicOrdering::NotAtomic &&
     770             :            "atomicrmw instructions can only be atomic.");
     771       40260 :     setInstructionSubclassData((getSubclassDataFromInstruction() & ~(7 << 2)) |
     772       19904 :                                ((unsigned)Ordering << 2));
     773             :   }
     774             : 
     775             :   /// Returns the synchronization scope ID of this rmw instruction.
     776           0 :   SyncScope::ID getSyncScopeID() const {
     777           0 :     return SSID;
     778             :   }
     779             : 
     780             :   /// Sets the synchronization scope ID of this rmw instruction.
     781             :   void setSyncScopeID(SyncScope::ID SSID) {
     782       19898 :     this->SSID = SSID;
     783             :   }
     784             : 
     785             :   Value *getPointerOperand() { return getOperand(0); }
     786             :   const Value *getPointerOperand() const { return getOperand(0); }
     787             :   static unsigned getPointerOperandIndex() { return 0U; }
     788             : 
     789             :   Value *getValOperand() { return getOperand(1); }
     790             :   const Value *getValOperand() const { return getOperand(1); }
     791             : 
     792             :   /// Returns the address space of the pointer operand.
     793             :   unsigned getPointerAddressSpace() const {
     794        5352 :     return getPointerOperand()->getType()->getPointerAddressSpace();
     795             :   }
     796             : 
     797             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
     798             :   static bool classof(const Instruction *I) {
     799           0 :     return I->getOpcode() == Instruction::AtomicRMW;
     800             :   }
     801             :   static bool classof(const Value *V) {
     802     1068277 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
     803             :   }
     804             : 
     805             : private:
     806             :   void Init(BinOp Operation, Value *Ptr, Value *Val,
     807             :             AtomicOrdering Ordering, SyncScope::ID SSID);
     808             : 
     809             :   // Shadow Instruction::setInstructionSubclassData with a private forwarding
     810             :   // method so that subclasses cannot accidentally use it.
     811             :   void setInstructionSubclassData(unsigned short D) {
     812             :     Instruction::setInstructionSubclassData(D);
     813             :   }
     814             : 
     815             :   /// The synchronization scope ID of this rmw instruction.  Not quite enough
     816             :   /// room in SubClassData for everything, so synchronization scope ID gets its
     817             :   /// own field.
     818             :   SyncScope::ID SSID;
     819             : };
     820             : 
     821             : template <>
     822             : struct OperandTraits<AtomicRMWInst>
     823             :     : public FixedNumOperandTraits<AtomicRMWInst,2> {
     824             : };
     825             : 
     826      117494 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(AtomicRMWInst, Value)
     827             : 
     828             : //===----------------------------------------------------------------------===//
     829             : //                             GetElementPtrInst Class
     830             : //===----------------------------------------------------------------------===//
     831             : 
     832             : // checkGEPType - Simple wrapper function to give a better assertion failure
     833             : // message on bad indexes for a gep instruction.
     834             : //
     835             : inline Type *checkGEPType(Type *Ty) {
     836             :   assert(Ty && "Invalid GetElementPtrInst indices for type!");
     837             :   return Ty;
     838             : }
     839             : 
     840             : /// an instruction for type-safe pointer arithmetic to
     841             : /// access elements of arrays and structs
     842             : ///
     843     2343698 : class GetElementPtrInst : public Instruction {
     844             :   Type *SourceElementType;
     845             :   Type *ResultElementType;
     846             : 
     847             :   GetElementPtrInst(const GetElementPtrInst &GEPI);
     848             : 
     849             :   /// Constructors - Create a getelementptr instruction with a base pointer an
     850             :   /// list of indices. The first ctor can optionally insert before an existing
     851             :   /// instruction, the second appends the new instruction to the specified
     852             :   /// BasicBlock.
     853             :   inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
     854             :                            ArrayRef<Value *> IdxList, unsigned Values,
     855             :                            const Twine &NameStr, Instruction *InsertBefore);
     856             :   inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
     857             :                            ArrayRef<Value *> IdxList, unsigned Values,
     858             :                            const Twine &NameStr, BasicBlock *InsertAtEnd);
     859             : 
     860             :   void init(Value *Ptr, ArrayRef<Value *> IdxList, const Twine &NameStr);
     861             : 
     862             : protected:
     863             :   // Note: Instruction needs to be a friend here to call cloneImpl.
     864             :   friend class Instruction;
     865             : 
     866             :   GetElementPtrInst *cloneImpl() const;
     867             : 
     868             : public:
     869     1896776 :   static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr,
     870             :                                    ArrayRef<Value *> IdxList,
     871             :                                    const Twine &NameStr = "",
     872             :                                    Instruction *InsertBefore = nullptr) {
     873     1896776 :     unsigned Values = 1 + unsigned(IdxList.size());
     874     1896776 :     if (!PointeeType)
     875             :       PointeeType =
     876      316692 :           cast<PointerType>(Ptr->getType()->getScalarType())->getElementType();
     877             :     else
     878             :       assert(
     879             :           PointeeType ==
     880             :           cast<PointerType>(Ptr->getType()->getScalarType())->getElementType());
     881             :     return new (Values) GetElementPtrInst(PointeeType, Ptr, IdxList, Values,
     882     1896776 :                                           NameStr, InsertBefore);
     883             :   }
     884             : 
     885          20 :   static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr,
     886             :                                    ArrayRef<Value *> IdxList,
     887             :                                    const Twine &NameStr,
     888             :                                    BasicBlock *InsertAtEnd) {
     889          20 :     unsigned Values = 1 + unsigned(IdxList.size());
     890          20 :     if (!PointeeType)
     891             :       PointeeType =
     892           0 :           cast<PointerType>(Ptr->getType()->getScalarType())->getElementType();
     893             :     else
     894             :       assert(
     895             :           PointeeType ==
     896             :           cast<PointerType>(Ptr->getType()->getScalarType())->getElementType());
     897             :     return new (Values) GetElementPtrInst(PointeeType, Ptr, IdxList, Values,
     898          20 :                                           NameStr, InsertAtEnd);
     899             :   }
     900             : 
     901             :   /// Create an "inbounds" getelementptr. See the documentation for the
     902             :   /// "inbounds" flag in LangRef.html for details.
     903       14555 :   static GetElementPtrInst *CreateInBounds(Value *Ptr,
     904             :                                            ArrayRef<Value *> IdxList,
     905             :                                            const Twine &NameStr = "",
     906             :                                            Instruction *InsertBefore = nullptr){
     907       14555 :     return CreateInBounds(nullptr, Ptr, IdxList, NameStr, InsertBefore);
     908             :   }
     909             : 
     910             :   static GetElementPtrInst *
     911             :   CreateInBounds(Type *PointeeType, Value *Ptr, ArrayRef<Value *> IdxList,
     912             :                  const Twine &NameStr = "",
     913             :                  Instruction *InsertBefore = nullptr) {
     914             :     GetElementPtrInst *GEP =
     915     1722083 :         Create(PointeeType, Ptr, IdxList, NameStr, InsertBefore);
     916     1722083 :     GEP->setIsInBounds(true);
     917             :     return GEP;
     918             :   }
     919             : 
     920             :   static GetElementPtrInst *CreateInBounds(Value *Ptr,
     921             :                                            ArrayRef<Value *> IdxList,
     922             :                                            const Twine &NameStr,
     923             :                                            BasicBlock *InsertAtEnd) {
     924             :     return CreateInBounds(nullptr, Ptr, IdxList, NameStr, InsertAtEnd);
     925             :   }
     926             : 
     927             :   static GetElementPtrInst *CreateInBounds(Type *PointeeType, Value *Ptr,
     928             :                                            ArrayRef<Value *> IdxList,
     929             :                                            const Twine &NameStr,
     930             :                                            BasicBlock *InsertAtEnd) {
     931             :     GetElementPtrInst *GEP =
     932             :         Create(PointeeType, Ptr, IdxList, NameStr, InsertAtEnd);
     933             :     GEP->setIsInBounds(true);
     934             :     return GEP;
     935             :   }
     936             : 
     937             :   /// Transparently provide more efficient getOperand methods.
     938             :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
     939             : 
     940           0 :   Type *getSourceElementType() const { return SourceElementType; }
     941             : 
     942          80 :   void setSourceElementType(Type *Ty) { SourceElementType = Ty; }
     943          78 :   void setResultElementType(Type *Ty) { ResultElementType = Ty; }
     944             : 
     945           0 :   Type *getResultElementType() const {
     946             :     assert(ResultElementType ==
     947             :            cast<PointerType>(getType()->getScalarType())->getElementType());
     948           0 :     return ResultElementType;
     949             :   }
     950             : 
     951             :   /// Returns the address space of this instruction's pointer type.
     952             :   unsigned getAddressSpace() const {
     953             :     // Note that this is always the same as the pointer operand's address space
     954             :     // and that is cheaper to compute, so cheat here.
     955             :     return getPointerAddressSpace();
     956             :   }
     957             : 
     958             :   /// Returns the type of the element that would be loaded with
     959             :   /// a load instruction with the specified parameters.
     960             :   ///
     961             :   /// Null is returned if the indices are invalid for the specified
     962             :   /// pointer type.
     963             :   ///
     964             :   static Type *getIndexedType(Type *Ty, ArrayRef<Value *> IdxList);
     965             :   static Type *getIndexedType(Type *Ty, ArrayRef<Constant *> IdxList);
     966             :   static Type *getIndexedType(Type *Ty, ArrayRef<uint64_t> IdxList);
     967             : 
     968      821473 :   inline op_iterator       idx_begin()       { return op_begin()+1; }
     969           3 :   inline const_op_iterator idx_begin() const { return op_begin()+1; }
     970             :   inline op_iterator       idx_end()         { return op_end(); }
     971             :   inline const_op_iterator idx_end()   const { return op_end(); }
     972             : 
     973             :   inline iterator_range<op_iterator> indices() {
     974             :     return make_range(idx_begin(), idx_end());
     975             :   }
     976             : 
     977             :   inline iterator_range<const_op_iterator> indices() const {
     978             :     return make_range(idx_begin(), idx_end());
     979             :   }
     980             : 
     981             :   Value *getPointerOperand() {
     982             :     return getOperand(0);
     983             :   }
     984             :   const Value *getPointerOperand() const {
     985             :     return getOperand(0);
     986             :   }
     987             :   static unsigned getPointerOperandIndex() {
     988             :     return 0U;    // get index for modifying correct operand.
     989             :   }
     990             : 
     991             :   /// Method to return the pointer operand as a
     992             :   /// PointerType.
     993             :   Type *getPointerOperandType() const {
     994     2418553 :     return getPointerOperand()->getType();
     995             :   }
     996             : 
     997             :   /// Returns the address space of the pointer operand.
     998             :   unsigned getPointerAddressSpace() const {
     999             :     return getPointerOperandType()->getPointerAddressSpace();
    1000             :   }
    1001             : 
    1002             :   /// Returns the pointer type returned by the GEP
    1003             :   /// instruction, which may be a vector of pointers.
    1004    18118846 :   static Type *getGEPReturnType(Value *Ptr, ArrayRef<Value *> IdxList) {
    1005    18118876 :     return getGEPReturnType(
    1006             :       cast<PointerType>(Ptr->getType()->getScalarType())->getElementType(),
    1007    18118846 :       Ptr, IdxList);
    1008             :   }
    1009    20015642 :   static Type *getGEPReturnType(Type *ElTy, Value *Ptr,
    1010             :                                 ArrayRef<Value *> IdxList) {
    1011    20015929 :     Type *PtrTy = PointerType::get(checkGEPType(getIndexedType(ElTy, IdxList)),
    1012             :                                    Ptr->getType()->getPointerAddressSpace());
    1013             :     // Vector GEP
    1014    40031284 :     if (Ptr->getType()->isVectorTy()) {
    1015             :       unsigned NumElem = Ptr->getType()->getVectorNumElements();
    1016         287 :       return VectorType::get(PtrTy, NumElem);
    1017             :     }
    1018    59800463 :     for (Value *Index : IdxList)
    1019    79570920 :       if (Index->getType()->isVectorTy()) {
    1020             :         unsigned NumElem = Index->getType()->getVectorNumElements();
    1021         352 :         return VectorType::get(PtrTy, NumElem);
    1022             :       }
    1023             :     // Scalar GEP
    1024             :     return PtrTy;
    1025             :   }
    1026             : 
    1027             :   unsigned getNumIndices() const {  // Note: always non-negative
    1028       80067 :     return getNumOperands() - 1;
    1029             :   }
    1030             : 
    1031             :   bool hasIndices() const {
    1032             :     return getNumOperands() > 1;
    1033             :   }
    1034             : 
    1035             :   /// Return true if all of the indices of this GEP are
    1036             :   /// zeros.  If so, the result pointer and the first operand have the same
    1037             :   /// value, just potentially different types.
    1038             :   bool hasAllZeroIndices() const;
    1039             : 
    1040             :   /// Return true if all of the indices of this GEP are
    1041             :   /// constant integers.  If so, the result pointer and the first operand have
    1042             :   /// a constant offset between them.
    1043             :   bool hasAllConstantIndices() const;
    1044             : 
    1045             :   /// Set or clear the inbounds flag on this GEP instruction.
    1046             :   /// See LangRef.html for the meaning of inbounds on a getelementptr.
    1047             :   void setIsInBounds(bool b = true);
    1048             : 
    1049             :   /// Determine whether the GEP has the inbounds flag.
    1050             :   bool isInBounds() const;
    1051             : 
    1052             :   /// Accumulate the constant address offset of this GEP if possible.
    1053             :   ///
    1054             :   /// This routine accepts an APInt into which it will accumulate the constant
    1055             :   /// offset of this GEP if the GEP is in fact constant. If the GEP is not
    1056             :   /// all-constant, it returns false and the value of the offset APInt is
    1057             :   /// undefined (it is *not* preserved!). The APInt passed into this routine
    1058             :   /// must be at least as wide as the IntPtr type for the address space of
    1059             :   /// the base GEP pointer.
    1060             :   bool accumulateConstantOffset(const DataLayout &DL, APInt &Offset) const;
    1061             : 
    1062             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    1063             :   static bool classof(const Instruction *I) {
    1064           1 :     return (I->getOpcode() == Instruction::GetElementPtr);
    1065             :   }
    1066             :   static bool classof(const Value *V) {
    1067   160282354 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    1068             :   }
    1069             : };
    1070             : 
    1071             : template <>
    1072             : struct OperandTraits<GetElementPtrInst> :
    1073             :   public VariadicOperandTraits<GetElementPtrInst, 1> {
    1074             : };
    1075             : 
    1076     1896776 : GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
    1077             :                                      ArrayRef<Value *> IdxList, unsigned Values,
    1078             :                                      const Twine &NameStr,
    1079     1896776 :                                      Instruction *InsertBefore)
    1080             :     : Instruction(getGEPReturnType(PointeeType, Ptr, IdxList), GetElementPtr,
    1081     1896776 :                   OperandTraits<GetElementPtrInst>::op_end(this) - Values,
    1082             :                   Values, InsertBefore),
    1083             :       SourceElementType(PointeeType),
    1084     1896776 :       ResultElementType(getIndexedType(PointeeType, IdxList)) {
    1085             :   assert(ResultElementType ==
    1086             :          cast<PointerType>(getType()->getScalarType())->getElementType());
    1087     1896776 :   init(Ptr, IdxList, NameStr);
    1088     1896776 : }
    1089             : 
    1090          20 : GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
    1091             :                                      ArrayRef<Value *> IdxList, unsigned Values,
    1092             :                                      const Twine &NameStr,
    1093          20 :                                      BasicBlock *InsertAtEnd)
    1094             :     : Instruction(getGEPReturnType(PointeeType, Ptr, IdxList), GetElementPtr,
    1095          20 :                   OperandTraits<GetElementPtrInst>::op_end(this) - Values,
    1096             :                   Values, InsertAtEnd),
    1097             :       SourceElementType(PointeeType),
    1098          20 :       ResultElementType(getIndexedType(PointeeType, IdxList)) {
    1099             :   assert(ResultElementType ==
    1100             :          cast<PointerType>(getType()->getScalarType())->getElementType());
    1101          20 :   init(Ptr, IdxList, NameStr);
    1102          20 : }
    1103             : 
    1104    11827872 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GetElementPtrInst, Value)
    1105             : 
    1106             : //===----------------------------------------------------------------------===//
    1107             : //                               ICmpInst Class
    1108             : //===----------------------------------------------------------------------===//
    1109             : 
    1110             : /// This instruction compares its operands according to the predicate given
    1111             : /// to the constructor. It only operates on integers or pointers. The operands
    1112             : /// must be identical types.
    1113             : /// Represent an integer comparison operator.
    1114      367922 : class ICmpInst: public CmpInst {
    1115             :   void AssertOK() {
    1116             :     assert(isIntPredicate() &&
    1117             :            "Invalid ICmp predicate value");
    1118             :     assert(getOperand(0)->getType() == getOperand(1)->getType() &&
    1119             :           "Both operands to ICmp instruction are not of the same type!");
    1120             :     // Check that the operands are the right type
    1121             :     assert((getOperand(0)->getType()->isIntOrIntVectorTy() ||
    1122             :             getOperand(0)->getType()->isPtrOrPtrVectorTy()) &&
    1123             :            "Invalid operand types for ICmp instruction");
    1124             :   }
    1125             : 
    1126             : protected:
    1127             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    1128             :   friend class Instruction;
    1129             : 
    1130             :   /// Clone an identical ICmpInst
    1131             :   ICmpInst *cloneImpl() const;
    1132             : 
    1133             : public:
    1134             :   /// Constructor with insert-before-instruction semantics.
    1135        2643 :   ICmpInst(
    1136             :     Instruction *InsertBefore,  ///< Where to insert
    1137             :     Predicate pred,  ///< The predicate to use for the comparison
    1138             :     Value *LHS,      ///< The left-hand-side of the expression
    1139             :     Value *RHS,      ///< The right-hand-side of the expression
    1140             :     const Twine &NameStr = ""  ///< Name of the instruction
    1141        2643 :   ) : CmpInst(makeCmpResultType(LHS->getType()),
    1142             :               Instruction::ICmp, pred, LHS, RHS, NameStr,
    1143        2643 :               InsertBefore) {
    1144             : #ifndef NDEBUG
    1145             :   AssertOK();
    1146             : #endif
    1147        2643 :   }
    1148             : 
    1149             :   /// Constructor with insert-at-end semantics.
    1150          88 :   ICmpInst(
    1151             :     BasicBlock &InsertAtEnd, ///< Block to insert into.
    1152             :     Predicate pred,  ///< The predicate to use for the comparison
    1153             :     Value *LHS,      ///< The left-hand-side of the expression
    1154             :     Value *RHS,      ///< The right-hand-side of the expression
    1155             :     const Twine &NameStr = ""  ///< Name of the instruction
    1156          88 :   ) : CmpInst(makeCmpResultType(LHS->getType()),
    1157             :               Instruction::ICmp, pred, LHS, RHS, NameStr,
    1158          88 :               &InsertAtEnd) {
    1159             : #ifndef NDEBUG
    1160             :   AssertOK();
    1161             : #endif
    1162          88 :   }
    1163             : 
    1164             :   /// Constructor with no-insertion semantics
    1165      875552 :   ICmpInst(
    1166             :     Predicate pred, ///< The predicate to use for the comparison
    1167             :     Value *LHS,     ///< The left-hand-side of the expression
    1168             :     Value *RHS,     ///< The right-hand-side of the expression
    1169             :     const Twine &NameStr = "" ///< Name of the instruction
    1170      875552 :   ) : CmpInst(makeCmpResultType(LHS->getType()),
    1171      875552 :               Instruction::ICmp, pred, LHS, RHS, NameStr) {
    1172             : #ifndef NDEBUG
    1173             :   AssertOK();
    1174             : #endif
    1175      875552 :   }
    1176             : 
    1177             :   /// For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.
    1178             :   /// @returns the predicate that would be the result if the operand were
    1179             :   /// regarded as signed.
    1180             :   /// Return the signed version of the predicate
    1181             :   Predicate getSignedPredicate() const {
    1182           8 :     return getSignedPredicate(getPredicate());
    1183             :   }
    1184             : 
    1185             :   /// This is a static version that you can use without an instruction.
    1186             :   /// Return the signed version of the predicate.
    1187             :   static Predicate getSignedPredicate(Predicate pred);
    1188             : 
    1189             :   /// For example, EQ->EQ, SLE->ULE, UGT->UGT, etc.
    1190             :   /// @returns the predicate that would be the result if the operand were
    1191             :   /// regarded as unsigned.
    1192             :   /// Return the unsigned version of the predicate
    1193             :   Predicate getUnsignedPredicate() const {
    1194         637 :     return getUnsignedPredicate(getPredicate());
    1195             :   }
    1196             : 
    1197             :   /// This is a static version that you can use without an instruction.
    1198             :   /// Return the unsigned version of the predicate.
    1199             :   static Predicate getUnsignedPredicate(Predicate pred);
    1200             : 
    1201             :   /// Return true if this predicate is either EQ or NE.  This also
    1202             :   /// tests for commutativity.
    1203             :   static bool isEquality(Predicate P) {
    1204     4983787 :     return P == ICMP_EQ || P == ICMP_NE;
    1205             :   }
    1206             : 
    1207             :   /// Return true if this predicate is either EQ or NE.  This also
    1208             :   /// tests for commutativity.
    1209             :   bool isEquality() const {
    1210             :     return isEquality(getPredicate());
    1211             :   }
    1212             : 
    1213             :   /// @returns true if the predicate of this ICmpInst is commutative
    1214             :   /// Determine if this relation is commutative.
    1215             :   bool isCommutative() const { return isEquality(); }
    1216             : 
    1217             :   /// Return true if the predicate is relational (not EQ or NE).
    1218             :   ///
    1219             :   bool isRelational() const {
    1220             :     return !isEquality();
    1221             :   }
    1222             : 
    1223             :   /// Return true if the predicate is relational (not EQ or NE).
    1224             :   ///
    1225             :   static bool isRelational(Predicate P) {
    1226           4 :     return !isEquality(P);
    1227             :   }
    1228             : 
    1229             :   /// Exchange the two operands to this instruction in such a way that it does
    1230             :   /// not modify the semantics of the instruction. The predicate value may be
    1231             :   /// changed to retain the same result if the predicate is order dependent
    1232             :   /// (e.g. ult).
    1233             :   /// Swap operands and adjust predicate.
    1234        3444 :   void swapOperands() {
    1235             :     setPredicate(getSwappedPredicate());
    1236        3444 :     Op<0>().swap(Op<1>());
    1237        3444 :   }
    1238             : 
    1239             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    1240             :   static bool classof(const Instruction *I) {
    1241           0 :     return I->getOpcode() == Instruction::ICmp;
    1242             :   }
    1243             :   static bool classof(const Value *V) {
    1244     6568980 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    1245             :   }
    1246             : };
    1247             : 
    1248             : //===----------------------------------------------------------------------===//
    1249             : //                               FCmpInst Class
    1250             : //===----------------------------------------------------------------------===//
    1251             : 
    1252             : /// This instruction compares its operands according to the predicate given
    1253             : /// to the constructor. It only operates on floating point values or packed
    1254             : /// vectors of floating point values. The operands must be identical types.
    1255             : /// Represents a floating point comparison operator.
    1256       17864 : class FCmpInst: public CmpInst {
    1257           0 :   void AssertOK() {
    1258             :     assert(isFPPredicate() && "Invalid FCmp predicate value");
    1259             :     assert(getOperand(0)->getType() == getOperand(1)->getType() &&
    1260             :            "Both operands to FCmp instruction are not of the same type!");
    1261             :     // Check that the operands are the right type
    1262             :     assert(getOperand(0)->getType()->isFPOrFPVectorTy() &&
    1263             :            "Invalid operand types for FCmp instruction");
    1264           0 :   }
    1265             : 
    1266             : protected:
    1267             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    1268             :   friend class Instruction;
    1269             : 
    1270             :   /// Clone an identical FCmpInst
    1271             :   FCmpInst *cloneImpl() const;
    1272             : 
    1273             : public:
    1274             :   /// Constructor with insert-before-instruction semantics.
    1275         127 :   FCmpInst(
    1276             :     Instruction *InsertBefore, ///< Where to insert
    1277             :     Predicate pred,  ///< The predicate to use for the comparison
    1278             :     Value *LHS,      ///< The left-hand-side of the expression
    1279             :     Value *RHS,      ///< The right-hand-side of the expression
    1280             :     const Twine &NameStr = ""  ///< Name of the instruction
    1281         127 :   ) : CmpInst(makeCmpResultType(LHS->getType()),
    1282             :               Instruction::FCmp, pred, LHS, RHS, NameStr,
    1283         127 :               InsertBefore) {
    1284             :     AssertOK();
    1285         127 :   }
    1286             : 
    1287             :   /// Constructor with insert-at-end semantics.
    1288           0 :   FCmpInst(
    1289             :     BasicBlock &InsertAtEnd, ///< Block to insert into.
    1290             :     Predicate pred,  ///< The predicate to use for the comparison
    1291             :     Value *LHS,      ///< The left-hand-side of the expression
    1292             :     Value *RHS,      ///< The right-hand-side of the expression
    1293             :     const Twine &NameStr = ""  ///< Name of the instruction
    1294           0 :   ) : CmpInst(makeCmpResultType(LHS->getType()),
    1295             :               Instruction::FCmp, pred, LHS, RHS, NameStr,
    1296           0 :               &InsertAtEnd) {
    1297             :     AssertOK();
    1298           0 :   }
    1299             : 
    1300             :   /// Constructor with no-insertion semantics
    1301       26457 :   FCmpInst(
    1302             :     Predicate pred, ///< The predicate to use for the comparison
    1303             :     Value *LHS,     ///< The left-hand-side of the expression
    1304             :     Value *RHS,     ///< The right-hand-side of the expression
    1305             :     const Twine &NameStr = "" ///< Name of the instruction
    1306       26457 :   ) : CmpInst(makeCmpResultType(LHS->getType()),
    1307       26457 :               Instruction::FCmp, pred, LHS, RHS, NameStr) {
    1308             :     AssertOK();
    1309       26457 :   }
    1310             : 
    1311             :   /// @returns true if the predicate of this instruction is EQ or NE.
    1312             :   /// Determine if this is an equality predicate.
    1313             :   static bool isEquality(Predicate Pred) {
    1314       16135 :     return Pred == FCMP_OEQ || Pred == FCMP_ONE || Pred == FCMP_UEQ ||
    1315       13627 :            Pred == FCMP_UNE;
    1316             :   }
    1317             : 
    1318             :   /// @returns true if the predicate of this instruction is EQ or NE.
    1319             :   /// Determine if this is an equality predicate.
    1320             :   bool isEquality() const { return isEquality(getPredicate()); }
    1321             : 
    1322             :   /// @returns true if the predicate of this instruction is commutative.
    1323             :   /// Determine if this is a commutative predicate.
    1324           0 :   bool isCommutative() const {
    1325           0 :     return isEquality() ||
    1326           0 :            getPredicate() == FCMP_FALSE ||
    1327           0 :            getPredicate() == FCMP_TRUE ||
    1328           0 :            getPredicate() == FCMP_ORD ||
    1329           0 :            getPredicate() == FCMP_UNO;
    1330             :   }
    1331             : 
    1332             :   /// @returns true if the predicate is relational (not EQ or NE).
    1333             :   /// Determine if this a relational predicate.
    1334             :   bool isRelational() const { return !isEquality(); }
    1335             : 
    1336             :   /// Exchange the two operands to this instruction in such a way that it does
    1337             :   /// not modify the semantics of the instruction. The predicate value may be
    1338             :   /// changed to retain the same result if the predicate is order dependent
    1339             :   /// (e.g. ult).
    1340             :   /// Swap operands and adjust predicate.
    1341          57 :   void swapOperands() {
    1342             :     setPredicate(getSwappedPredicate());
    1343          57 :     Op<0>().swap(Op<1>());
    1344          57 :   }
    1345             : 
    1346             :   /// Methods for support type inquiry through isa, cast, and dyn_cast:
    1347             :   static bool classof(const Instruction *I) {
    1348           0 :     return I->getOpcode() == Instruction::FCmp;
    1349             :   }
    1350             :   static bool classof(const Value *V) {
    1351     1279998 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    1352             :   }
    1353             : };
    1354             : 
    1355             : class CallInst;
    1356             : class InvokeInst;
    1357             : 
    1358             : template <class T> struct CallBaseParent { using type = Instruction; };
    1359             : 
    1360             : template <> struct CallBaseParent<InvokeInst> { using type = TerminatorInst; };
    1361             : 
    1362             : //===----------------------------------------------------------------------===//
    1363             : /// Base class for all callable instructions (InvokeInst and CallInst)
    1364             : /// Holds everything related to calling a function, abstracting from the base
    1365             : /// type @p BaseInstTy and the concrete instruction @p InstTy
    1366             : ///
    1367             : template <class InstTy>
    1368     2430078 : class CallBase : public CallBaseParent<InstTy>::type,
    1369             :                  public OperandBundleUser<InstTy, User::op_iterator> {
    1370             : protected:
    1371             :   AttributeList Attrs; ///< parameter attributes for callable
    1372             :   FunctionType *FTy;
    1373             :   using BaseInstTy = typename CallBaseParent<InstTy>::type;
    1374             : 
    1375             :   template <class... ArgsTy>
    1376      187776 :   CallBase(AttributeList const &A, FunctionType *FT, ArgsTy &&... Args)
    1377     1888643 :       : BaseInstTy(std::forward<ArgsTy>(Args)...), Attrs(A), FTy(FT) {}
    1378   177124263 :   bool hasDescriptor() const { return Value::HasDescriptor; }
    1379             : 
    1380     3725577 :   using BaseInstTy::BaseInstTy;
    1381             : 
    1382             :   using OperandBundleUser<InstTy,
    1383             :                           User::op_iterator>::isFnAttrDisallowedByOpBundle;
    1384             :   using OperandBundleUser<InstTy, User::op_iterator>::getNumTotalBundleOperands;
    1385             :   using OperandBundleUser<InstTy, User::op_iterator>::bundleOperandHasAttr;
    1386             :   using Instruction::getSubclassDataFromInstruction;
    1387             :   using Instruction::setInstructionSubclassData;
    1388             : 
    1389             : public:
    1390             :   using Instruction::getContext;
    1391             :   using OperandBundleUser<InstTy, User::op_iterator>::hasOperandBundles;
    1392             :   using OperandBundleUser<InstTy,
    1393             :                           User::op_iterator>::getBundleOperandsStartIndex;
    1394             : 
    1395             :   static bool classof(const Instruction *I) {
    1396             :     llvm_unreachable(
    1397             :         "CallBase is not meant to be used as part of the classof hierarchy");
    1398             :   }
    1399             : 
    1400             : public:
    1401             :   /// Return the parameter attributes for this call.
    1402             :   ///
    1403           0 :   AttributeList getAttributes() const { return Attrs; }
    1404             : 
    1405             :   /// Set the parameter attributes for this call.
    1406             :   ///
    1407     4246469 :   void setAttributes(AttributeList A) { Attrs = A; }
    1408             : 
    1409           0 :   FunctionType *getFunctionType() const { return FTy; }
    1410             : 
    1411             :   void mutateFunctionType(FunctionType *FTy) {
    1412         573 :     Value::mutateType(FTy->getReturnType());
    1413         592 :     this->FTy = FTy;
    1414             :   }
    1415             : 
    1416             :   /// Return the number of call arguments.
    1417             :   ///
    1418             :   unsigned getNumArgOperands() const {
    1419     7249148 :     return getNumOperands() - getNumTotalBundleOperands() - InstTy::ArgOffset;
    1420             :   }
    1421             : 
    1422             :   /// getArgOperand/setArgOperand - Return/set the i-th call argument.
    1423             :   ///
    1424             :   Value *getArgOperand(unsigned i) const {
    1425             :     assert(i < getNumArgOperands() && "Out of bounds!");
    1426             :     return getOperand(i);
    1427             :   }
    1428             :   void setArgOperand(unsigned i, Value *v) {
    1429             :     assert(i < getNumArgOperands() && "Out of bounds!");
    1430             :     setOperand(i, v);
    1431             :   }
    1432             : 
    1433             :   /// Return the iterator pointing to the beginning of the argument list.
    1434             :   User::op_iterator arg_begin() { return op_begin(); }
    1435             : 
    1436             :   /// Return the iterator pointing to the end of the argument list.
    1437             :   User::op_iterator arg_end() {
    1438             :     // [ call args ], [ operand bundles ], callee
    1439    14040308 :     return op_end() - getNumTotalBundleOperands() - InstTy::ArgOffset;
    1440             :   }
    1441             : 
    1442             :   /// Iteration adapter for range-for loops.
    1443        9040 :   iterator_range<User::op_iterator> arg_operands() {
    1444        9040 :     return make_range(arg_begin(), arg_end());
    1445             :   }
    1446           1 : 
    1447           1 :   /// Return the iterator pointing to the beginning of the argument list.
    1448             :   User::const_op_iterator arg_begin() const { return op_begin(); }
    1449           1 : 
    1450           1 :   /// Return the iterator pointing to the end of the argument list.
    1451             :   User::const_op_iterator arg_end() const {
    1452             :     // [ call args ], [ operand bundles ], callee
    1453    13340523 :     return op_end() - getNumTotalBundleOperands() - InstTy::ArgOffset;
    1454             :   }
    1455             : 
    1456             :   /// Iteration adapter for range-for loops.
    1457        1803 :   iterator_range<User::const_op_iterator> arg_operands() const {
    1458        1803 :     return make_range(arg_begin(), arg_end());
    1459             :   }
    1460           6 : 
    1461           6 :   /// Wrappers for getting the \c Use of a call argument.
    1462             :   const Use &getArgOperandUse(unsigned i) const {
    1463         169 :     assert(i < getNumArgOperands() && "Out of bounds!");
    1464         169 :     return User::getOperandUse(i);
    1465             :   }
    1466             :   Use &getArgOperandUse(unsigned i) {
    1467             :     assert(i < getNumArgOperands() && "Out of bounds!");
    1468        4655 :     return User::getOperandUse(i);
    1469             :   }
    1470             : 
    1471             :   /// If one of the arguments has the 'returned' attribute, return its
    1472             :   /// operand value. Otherwise, return nullptr.
    1473     2588643 :   Value *getReturnedArgOperand() const {
    1474             :     unsigned Index;
    1475             : 
    1476     2588643 :     if (Attrs.hasAttrSomewhere(Attribute::Returned, &Index) && Index)
    1477          11 :       return getArgOperand(Index - AttributeList::FirstArgIndex);
    1478             :     if (const Function *F = getCalledFunction())
    1479     2529853 :       if (F->getAttributes().hasAttrSomewhere(Attribute::Returned, &Index) &&
    1480             :           Index)
    1481         781 :         return getArgOperand(Index - AttributeList::FirstArgIndex);
    1482             : 
    1483             :     return nullptr;
    1484             :   }
    1485      455017 : 
    1486             :   User::op_iterator op_begin() {
    1487             :     return OperandTraits<CallBase>::op_begin(this);
    1488      455017 :   }
    1489           0 : 
    1490             :   User::const_op_iterator op_begin() const {
    1491      430130 :     return OperandTraits<CallBase>::op_begin(const_cast<CallBase *>(this));
    1492             :   }
    1493         120 : 
    1494             :   User::op_iterator op_end() { return OperandTraits<CallBase>::op_end(this); }
    1495             : 
    1496             :   User::const_op_iterator op_end() const {
    1497     2133414 :     return OperandTraits<CallBase>::op_end(const_cast<CallBase *>(this));
    1498             :   }
    1499             : 
    1500     2133414 :   Value *getOperand(unsigned i_nocapture) const {
    1501          11 :     assert(i_nocapture < OperandTraits<CallBase>::operands(this) &&
    1502             :            "getOperand() out of range!");
    1503    17652124 :     return cast_or_null<Value>(OperandTraits<CallBase>::op_begin(
    1504      920441 :                                    const_cast<CallBase *>(this))[i_nocapture]
    1505         523 :                                    .get());
    1506             :   }
    1507             : 
    1508             :   void setOperand(unsigned i_nocapture, Value *Val_nocapture) {
    1509         121 :     assert(i_nocapture < OperandTraits<CallBase>::operands(this) &&
    1510          39 :            "setOperand() out of range!");
    1511       27109 :     OperandTraits<CallBase>::op_begin(this)[i_nocapture] = Val_nocapture;
    1512             :   }
    1513             : 
    1514             :   unsigned getNumOperands() const {
    1515             :     return OperandTraits<CallBase>::operands(this);
    1516             :   }
    1517             :   template <int Idx_nocapture> Use &Op() {
    1518             :     return User::OpFrom<Idx_nocapture>(this);
    1519             :   }
    1520             :   template <int Idx_nocapture> const Use &Op() const {
    1521             :     return User::OpFrom<Idx_nocapture>(this);
    1522             :   }
    1523             : 
    1524             :   /// Return the function called, or null if this is an
    1525             :   /// indirect function invocation.
    1526             :   ///
    1527       63516 :   Function *getCalledFunction() const {
    1528     3331451 :     return dyn_cast<Function>(Op<-InstTy::ArgOffset>());
    1529             :   }
    1530             : 
    1531             :   /// Determine whether this call has the given attribute.
    1532             :   bool hasFnAttr(Attribute::AttrKind Kind) const {
    1533             :     assert(Kind != Attribute::NoBuiltin &&
    1534             :            "Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin");
    1535   113058076 :     return hasFnAttrImpl(Kind);
    1536             :   }
    1537             : 
    1538             :   /// Determine whether this call has the given attribute.
    1539     1654174 :   bool hasFnAttr(StringRef Kind) const { return hasFnAttrImpl(Kind); }
    1540             : 
    1541          28 :   /// getCallingConv/setCallingConv - Get or set the calling convention of this
    1542             :   /// function call.
    1543             :   CallingConv::ID getCallingConv() const {
    1544    10438422 :     return static_cast<CallingConv::ID>(getSubclassDataFromInstruction() >> 2);
    1545             :   }
    1546             :   void setCallingConv(CallingConv::ID CC) {
    1547             :     auto ID = static_cast<unsigned>(CC);
    1548             :     assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention");
    1549    10195759 :     setInstructionSubclassData((getSubclassDataFromInstruction() & 3) |
    1550     4926124 :                                (ID << 2));
    1551             :   }
    1552             : 
    1553             : 
    1554             :   /// adds the attribute to the list of attributes.
    1555      837331 :   void addAttribute(unsigned i, Attribute::AttrKind Kind) {
    1556      837331 :     AttributeList PAL = getAttributes();
    1557      837331 :     PAL = PAL.addAttribute(getContext(), i, Kind);
    1558             :     setAttributes(PAL);
    1559     1140781 :   }
    1560       13014 : 
    1561       13014 :   /// adds the attribute to the list of attributes.
    1562       42746 :   void addAttribute(unsigned i, Attribute Attr) {
    1563       29732 :     AttributeList PAL = getAttributes();
    1564       42746 :     PAL = PAL.addAttribute(getContext(), i, Attr);
    1565      173429 :     setAttributes(PAL);
    1566      203161 :   }
    1567      173431 : 
    1568           2 :   /// Adds the attribute to the indicated argument
    1569      173676 :   void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
    1570             :     assert(ArgNo < getNumArgOperands() && "Out of bounds");
    1571         247 :     AttributeList PAL = getAttributes();
    1572         255 :     PAL = PAL.addParamAttribute(getContext(), ArgNo, Kind);
    1573          10 :     setAttributes(PAL);
    1574         255 :   }
    1575           0 : 
    1576          10 :   /// Adds the attribute to the indicated argument
    1577      358718 :   void addParamAttr(unsigned ArgNo, Attribute Attr) {
    1578           0 :     assert(ArgNo < getNumArgOperands() && "Out of bounds");
    1579      358718 :     AttributeList PAL = getAttributes();
    1580      358718 :     PAL = PAL.addParamAttribute(getContext(), ArgNo, Attr);
    1581          54 :     setAttributes(PAL);
    1582      358718 :   }
    1583          54 : 
    1584          54 :   /// removes the attribute from the list of attributes.
    1585          54 :   void removeAttribute(unsigned i, Attribute::AttrKind Kind) {
    1586         108 :     AttributeList PAL = getAttributes();
    1587       14100 :     PAL = PAL.removeAttribute(getContext(), i, Kind);
    1588             :     setAttributes(PAL);
    1589       14100 :   }
    1590       14049 : 
    1591           3 :   /// removes the attribute from the list of attributes.
    1592       14049 :   void removeAttribute(unsigned i, StringRef Kind) {
    1593             :     AttributeList PAL = getAttributes();
    1594           3 :     PAL = PAL.removeAttribute(getContext(), i, Kind);
    1595           9 :     setAttributes(PAL);
    1596           9 :   }
    1597           9 : 
    1598             :   /// Removes the attribute from the given argument
    1599      358732 :   void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
    1600           0 :     assert(ArgNo < getNumArgOperands() && "Out of bounds");
    1601      358723 :     AttributeList PAL = getAttributes();
    1602      358723 :     PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind);
    1603             :     setAttributes(PAL);
    1604      358723 :   }
    1605           9 : 
    1606           9 :   /// Removes the attribute from the given argument
    1607           9 :   void removeParamAttr(unsigned ArgNo, StringRef Kind) {
    1608             :     assert(ArgNo < getNumArgOperands() && "Out of bounds");
    1609           9 :     AttributeList PAL = getAttributes();
    1610             :     PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind);
    1611         100 :     setAttributes(PAL);
    1612           0 :   }
    1613         100 : 
    1614         100 :   /// adds the dereferenceable attribute to the list of attributes.
    1615          66 :   void addDereferenceableAttr(unsigned i, uint64_t Bytes) {
    1616         166 :     AttributeList PAL = getAttributes();
    1617          66 :     PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes);
    1618           0 :     setAttributes(PAL);
    1619       14112 :   }
    1620           0 : 
    1621       14046 :   /// adds the dereferenceable_or_null attribute to the list of
    1622       14046 :   /// attributes.
    1623         100 :   void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) {
    1624       14046 :     AttributeList PAL = getAttributes();
    1625         100 :     PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes);
    1626         100 :     setAttributes(PAL);
    1627             :   }
    1628         100 : 
    1629             :   /// Determine whether the return value has the given attribute.
    1630     7951979 :   bool hasRetAttr(Attribute::AttrKind Kind) const {
    1631     7951979 :     if (Attrs.hasAttribute(AttributeList::ReturnIndex, Kind))
    1632             :       return true;
    1633             : 
    1634             :     // Look at the callee, if available.
    1635             :     if (const Function *F = getCalledFunction())
    1636     7600798 :       return F->getAttributes().hasAttribute(AttributeList::ReturnIndex, Kind);
    1637             :     return false;
    1638             :   }
    1639     2087061 : 
    1640     2087061 :   /// Determine whether the argument or parameter has the given attribute.
    1641    47740692 :   bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
    1642             :     assert(ArgNo < getNumArgOperands() && "Param index out of bounds!");
    1643             : 
    1644    47740692 :     if (Attrs.hasParamAttribute(ArgNo, Kind))
    1645     1995681 :       return true;
    1646             :     if (const Function *F = getCalledFunction())
    1647    46409549 :       return F->getAttributes().hasParamAttribute(ArgNo, Kind);
    1648     5864894 :     return false;
    1649     5864894 :   }
    1650    15792824 : 
    1651             :   /// Get the attribute of a given kind at a position.
    1652             :   Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const {
    1653    15792824 :     return getAttributes().getAttribute(i, Kind);
    1654     5732936 :   }
    1655      127821 : 
    1656    15107123 :   /// Get the attribute of a given kind at a position.
    1657             :   Attribute getAttribute(unsigned i, StringRef Kind) const {
    1658             :     return getAttributes().getAttribute(i, Kind);
    1659    41381724 :   }
    1660      124882 : 
    1661     3204757 :   /// Get the attribute of a given kind from a given arg
    1662    41381724 :   Attribute getParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
    1663       24744 :     assert(ArgNo < getNumArgOperands() && "Out of bounds");
    1664     3229501 :     return getAttributes().getParamAttr(ArgNo, Kind);
    1665    40698644 :   }
    1666             : 
    1667     1322379 :   /// Get the attribute of a given kind from a given arg
    1668     1604241 :   Attribute getParamAttr(unsigned ArgNo, StringRef Kind) const {
    1669       23235 :     assert(ArgNo < getNumArgOperands() && "Out of bounds");
    1670      960666 :     return getAttributes().getParamAttr(ArgNo, Kind);
    1671     1604241 :   }
    1672      103077 :   /// Return true if the data operand at index \p i has the attribute \p
    1673     1063743 :   /// A.
    1674     1592236 :   ///
    1675             :   /// Data operands include call arguments and values used in operand bundles,
    1676      374545 :   /// but does not include the callee operand.  This routine dispatches to the
    1677     7830804 :   /// underlying AttributeList or the OperandBundleUser as appropriate.
    1678      101647 :   ///
    1679     2244091 :   /// The index \p i is interpreted as
    1680     7830804 :   ///
    1681             :   ///  \p i == Attribute::ReturnIndex  -> the return value
    1682     2244091 :   ///  \p i in [1, arg_size + 1)  -> argument number (\p i - 1)
    1683     7806136 :   ///  \p i in [arg_size + 1, data_operand_size + 1) -> bundle operand at index
    1684             :   ///     (\p i - 1) in the operand list.
    1685      947834 :   bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind Kind) const {
    1686         308 :     // There are getNumOperands() - (InstTy::ArgOffset - 1) data operands.
    1687             :     // The last operand is the callee.
    1688           0 :     assert(i < (getNumOperands() - InstTy::ArgOffset + 1) &&
    1689         308 :            "Data operand index out of bounds!");
    1690             : 
    1691             :     // The attribute A can either be directly specified, if the operand in
    1692             :     // question is a call argument; or be indirectly implied by the kind of its
    1693             :     // containing operand bundle, if the operand is a bundle operand.
    1694             : 
    1695             :     if (i == AttributeList::ReturnIndex)
    1696             :       return hasRetAttr(Kind);
    1697             : 
    1698             :     // FIXME: Avoid these i - 1 calculations and update the API to use
    1699             :     // zero-based indices.
    1700             :     if (i < (getNumArgOperands() + 1))
    1701             :       return paramHasAttr(i - 1, Kind);
    1702             : 
    1703             :     assert(hasOperandBundles() && i >= (getBundleOperandsStartIndex() + 1) &&
    1704             :            "Must be either a call argument or an operand bundle!");
    1705             :     return bundleOperandHasAttr(i - 1, Kind);
    1706             :   }
    1707             : 
    1708             :   /// Extract the alignment of the return value.
    1709             :   unsigned getRetAlignment() const { return Attrs.getRetAlignment(); }
    1710             : 
    1711             :   /// Extract the alignment for a call or parameter (0=unknown).
    1712             :   unsigned getParamAlignment(unsigned ArgNo) const {
    1713        5661 :     return Attrs.getParamAlignment(ArgNo);
    1714             :   }
    1715             : 
    1716             :   /// Extract the number of dereferenceable bytes for a call or
    1717             :   /// parameter (0=unknown).
    1718             :   uint64_t getDereferenceableBytes(unsigned i) const {
    1719        1280 :     return Attrs.getDereferenceableBytes(i);
    1720             :   }
    1721     5277586 : 
    1722             :   /// Extract the number of dereferenceable_or_null bytes for a call or
    1723             :   /// parameter (0=unknown).
    1724             :   uint64_t getDereferenceableOrNullBytes(unsigned i) const {
    1725        1278 :     return Attrs.getDereferenceableOrNullBytes(i);
    1726             :   }
    1727             : 
    1728             :   /// Determine if the return value is marked with NoAlias attribute.
    1729             :   bool returnDoesNotAlias() const {
    1730             :     return Attrs.hasAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
    1731     9779715 :   }
    1732           0 : 
    1733             :   /// Return true if the call should not be treated as a call to a
    1734             :   /// builtin.
    1735    13636670 :   bool isNoBuiltin() const {
    1736    19390701 :     return hasFnAttrImpl(Attribute::NoBuiltin) &&
    1737     5753925 :       !hasFnAttrImpl(Attribute::Builtin);
    1738             :   }
    1739      202253 : 
    1740      207526 :   /// Determine if the call requires strict floating point semantics.
    1741        5379 :   bool isStrictFP() const { return hasFnAttr(Attribute::StrictFP); }
    1742             : 
    1743    11979034 :   /// Return true if the call should not be inlined.
    1744    11239244 :   bool isNoInline() const { return hasFnAttr(Attribute::NoInline); }
    1745      440629 :   void setIsNoInline() {
    1746           0 :     addAttribute(AttributeList::FunctionIndex, Attribute::NoInline);
    1747             :   }
    1748             :   /// Determine if the call does not access memory.
    1749       16089 :   bool doesNotAccessMemory() const {
    1750             :     return hasFnAttr(Attribute::ReadNone);
    1751      371989 :   }
    1752             :   void setDoesNotAccessMemory() {
    1753    15403689 :     addAttribute(AttributeList::FunctionIndex, Attribute::ReadNone);
    1754    14691738 :   }
    1755      431362 : 
    1756             :   /// Determine if the call does not access or only reads memory.
    1757    16666877 :   bool onlyReadsMemory() const {
    1758    31521197 :     return doesNotAccessMemory() || hasFnAttr(Attribute::ReadOnly);
    1759     1172831 :   }
    1760      756499 :   void setOnlyReadsMemory() {
    1761    13601116 :     addAttribute(AttributeList::FunctionIndex, Attribute::ReadOnly);
    1762    12361498 :   }
    1763    14422967 : 
    1764    26877806 :   /// Determine if the call does not access or only writes memory.
    1765     4136335 :   bool doesNotReadMemory() const {
    1766        3789 :     return doesNotAccessMemory() || hasFnAttr(Attribute::WriteOnly);
    1767             :   }
    1768             :   void setDoesNotReadMemory() {
    1769             :     addAttribute(AttributeList::FunctionIndex, Attribute::WriteOnly);
    1770             :   }
    1771          11 : 
    1772             :   /// Determine if the call can access memmory only using pointers based
    1773             :   /// on its arguments.
    1774             :   bool onlyAccessesArgMemory() const {
    1775     4927850 :     return hasFnAttr(Attribute::ArgMemOnly);
    1776     1581226 :   }
    1777             :   void setOnlyAccessesArgMemory() {
    1778      184201 :     addAttribute(AttributeList::FunctionIndex, Attribute::ArgMemOnly);
    1779      368402 :   }
    1780     4134437 : 
    1781     4742218 :   /// Determine if the function may only access memory that is
    1782     1210815 :   /// inaccessible from the IR.
    1783             :   bool onlyAccessesInaccessibleMemory() const {
    1784             :     return hasFnAttr(Attribute::InaccessibleMemOnly);
    1785         106 :   }
    1786             :   void setOnlyAccessesInaccessibleMemory() {
    1787             :     addAttribute(AttributeList::FunctionIndex, Attribute::InaccessibleMemOnly);
    1788             :   }
    1789             : 
    1790             :   /// Determine if the function may only access memory that is
    1791             :   /// either inaccessible from the IR or pointed to by its arguments.
    1792             :   bool onlyAccessesInaccessibleMemOrArgMem() const {
    1793        1143 :     return hasFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
    1794             :   }
    1795             :   void setOnlyAccessesInaccessibleMemOrArgMem() {
    1796             :     addAttribute(AttributeList::FunctionIndex, Attribute::InaccessibleMemOrArgMemOnly);
    1797             :   }
    1798             :   /// Determine if the call cannot return.
    1799      258535 :   bool doesNotReturn() const { return hasFnAttr(Attribute::NoReturn); }
    1800      278080 :   void setDoesNotReturn() {
    1801       50580 :     addAttribute(AttributeList::FunctionIndex, Attribute::NoReturn);
    1802           0 :   }
    1803           0 : 
    1804             :   /// Determine if the call should not perform indirect branch tracking.
    1805      258535 :   bool doesNoCfCheck() const { return hasFnAttr(Attribute::NoCfCheck); }
    1806      278080 : 
    1807             :   /// Determine if the call cannot unwind.
    1808             :   bool doesNotThrow() const { return hasFnAttr(Attribute::NoUnwind); }
    1809             :   void setDoesNotThrow() {
    1810      114275 :     addAttribute(AttributeList::FunctionIndex, Attribute::NoUnwind);
    1811        2959 :   }
    1812             : 
    1813             :   /// Determine if the invoke cannot be duplicated.
    1814             :   bool cannotDuplicate() const {return hasFnAttr(Attribute::NoDuplicate); }
    1815             :   void setCannotDuplicate() {
    1816             :     addAttribute(AttributeList::FunctionIndex, Attribute::NoDuplicate);
    1817             :   }
    1818             : 
    1819             :   /// Determine if the invoke is convergent
    1820        5846 :   bool isConvergent() const { return hasFnAttr(Attribute::Convergent); }
    1821       15000 :   void setConvergent() {
    1822           3 :     addAttribute(AttributeList::FunctionIndex, Attribute::Convergent);
    1823             :   }
    1824             :   void setNotConvergent() {
    1825             :     removeAttribute(AttributeList::FunctionIndex, Attribute::Convergent);
    1826          87 :   }
    1827             : 
    1828      468023 :   /// Determine if the call returns a structure through first
    1829             :   /// pointer argument.
    1830      135834 :   bool hasStructRetAttr() const {
    1831           1 :     if (getNumArgOperands() == 0)
    1832             :       return false;
    1833             : 
    1834             :     // Be friendly and also check the callee.
    1835           1 :     return paramHasAttr(0, Attribute::StructRet);
    1836             :   }
    1837    16117019 : 
    1838    32232749 :   /// Determine if any call argument is an aggregate passed by value.
    1839             :   bool hasByValArgument() const {
    1840     2083602 :     return Attrs.hasAttrSomewhere(Attribute::ByVal);
    1841     4167204 :   }
    1842             :   /// Get a pointer to the function that is invoked by this
    1843    14033417 :   /// instruction.
    1844    30718846 :   const Value *getCalledValue() const { return Op<-InstTy::ArgOffset>(); }
    1845      675962 :   Value *getCalledValue() { return Op<-InstTy::ArgOffset>(); }
    1846             : 
    1847             :   /// Set the function called.
    1848        1334 :   void setCalledFunction(Value* Fn) {
    1849         362 :     setCalledFunction(
    1850          12 :         cast<FunctionType>(cast<PointerType>(Fn->getType())->getElementType()),
    1851    10266453 :         Fn);
    1852    20532906 :   }
    1853     4972410 :   void setCalledFunction(FunctionType *FTy, Value *Fn) {
    1854      816893 :     this->FTy = FTy;
    1855     1633098 :     assert(FTy == cast<FunctionType>(
    1856             :                       cast<PointerType>(Fn->getType())->getElementType()));
    1857     9449921 :     Op<-InstTy::ArgOffset>() = Fn;
    1858    18899842 :   }
    1859             : 
    1860             : protected:
    1861    14037153 :   template <typename AttrKind> bool hasFnAttrImpl(AttrKind Kind) const {
    1862    18130298 :     if (Attrs.hasAttribute(AttributeList::FunctionIndex, Kind))
    1863      125221 :       return true;
    1864             : 
    1865          61 :     // Operand bundles override attributes on the called function, but don't
    1866             :     // override attributes directly present on the call instruction.
    1867    45440897 :     if (isFnAttrDisallowedByOpBundle(Kind))
    1868    31910606 :       return false;
    1869    26799869 : 
    1870    26799869 :     if (const Function *F = getCalledFunction())
    1871    13782143 :       return F->getAttributes().hasAttribute(AttributeList::FunctionIndex,
    1872    13782143 :                                              Kind);
    1873    31060290 :     return false;
    1874             :   }
    1875    27349924 : };
    1876     1164917 : 
    1877    30416350 : //===----------------------------------------------------------------------===//
    1878    30416292 : /// This class represents a function call, abstracting a target
    1879    32236828 : /// machine's calling convention.  This class uses low bit of the SubClassData
    1880    32236828 : /// field to indicate whether or not this is a tail call.  The rest of the bits
    1881     5015392 : /// hold the calling convention of the call.
    1882     4332287 : ///
    1883      409692 : class CallInst : public CallBase<CallInst> {
    1884      409503 :   friend class OperandBundleUser<CallInst, User::op_iterator>;
    1885    84023222 : 
    1886    79917492 :   CallInst(const CallInst &CI);
    1887    18417015 : 
    1888    14201806 :   /// Construct a CallInst given a range of arguments.
    1889    10125711 :   /// Construct a CallInst from a range of arguments
    1890     9721273 :   inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
    1891    82871665 :                   ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
    1892     4141126 :                   Instruction *InsertBefore);
    1893    16764052 : 
    1894     2844750 :   inline CallInst(Value *Func, ArrayRef<Value *> Args,
    1895   112687317 :                   ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
    1896   108145066 :                   Instruction *InsertBefore)
    1897    34723197 :       : CallInst(cast<FunctionType>(
    1898    34723197 :                      cast<PointerType>(Func->getType())->getElementType()),
    1899    16294732 :                  Func, Args, Bundles, NameStr, InsertBefore) {}
    1900    15040908 : 
    1901    31713076 :   inline CallInst(Value *Func, ArrayRef<Value *> Args, const Twine &NameStr,
    1902     1840308 :                   Instruction *InsertBefore)
    1903    24082232 :       : CallInst(Func, Args, None, NameStr, InsertBefore) {}
    1904     2859955 : 
    1905    39735214 :   /// Construct a CallInst given a range of arguments.
    1906    29280471 :   /// Construct a CallInst from a range of arguments
    1907    26835688 :   inline CallInst(Value *Func, ArrayRef<Value *> Args,
    1908    22592611 :                   ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
    1909    13450094 :                   BasicBlock *InsertAtEnd);
    1910    12968321 : 
    1911     1781319 :   explicit CallInst(Value *F, const Twine &NameStr, Instruction *InsertBefore);
    1912     1780597 : 
    1913    72502350 :   CallInst(Value *F, const Twine &NameStr, BasicBlock *InsertAtEnd);
    1914    71813815 : 
    1915    14854380 :   void init(Value *Func, ArrayRef<Value *> Args,
    1916    12361498 :             ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr) {
    1917      698871 :     init(cast<FunctionType>(
    1918      660693 :              cast<PointerType>(Func->getType())->getElementType()),
    1919    73759769 :          Func, Args, Bundles, NameStr);
    1920     2469151 :   }
    1921    14449319 :   void init(FunctionType *FTy, Value *Func, ArrayRef<Value *> Args,
    1922     2343749 :             ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr);
    1923    70145582 :   void init(Value *Func, const Twine &NameStr);
    1924    70145582 : 
    1925    16247236 : protected:
    1926    16247236 :   // Note: Instruction needs to be a friend here to call cloneImpl.
    1927     4237127 :   friend class Instruction;
    1928     2073801 : 
    1929        7399 :   CallInst *cloneImpl() const;
    1930             : 
    1931     6689039 : public:
    1932     2130747 :   static constexpr int ArgOffset = 1;
    1933     1957780 : 
    1934        6917 :   static CallInst *Create(Value *Func, ArrayRef<Value *> Args,
    1935     4455673 :                           ArrayRef<OperandBundleDef> Bundles = None,
    1936     4455673 :                           const Twine &NameStr = "",
    1937     2512731 :                           Instruction *InsertBefore = nullptr) {
    1938     2516271 :     return Create(cast<FunctionType>(
    1939             :                       cast<PointerType>(Func->getType())->getElementType()),
    1940             :                   Func, Args, Bundles, NameStr, InsertBefore);
    1941         456 :   }
    1942         456 : 
    1943      499373 :   static CallInst *Create(Value *Func, ArrayRef<Value *> Args,
    1944             :                           const Twine &NameStr,
    1945             :                           Instruction *InsertBefore = nullptr) {
    1946      267912 :     return Create(cast<FunctionType>(
    1947    11585747 :                       cast<PointerType>(Func->getType())->getElementType()),
    1948    11585296 :                   Func, Args, None, NameStr, InsertBefore);
    1949             :   }
    1950             : 
    1951         451 :   static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
    1952         451 :                           const Twine &NameStr,
    1953    11089140 :                           Instruction *InsertBefore = nullptr) {
    1954           0 :     return new (unsigned(Args.size() + 1))
    1955           0 :         CallInst(Ty, Func, Args, None, NameStr, InsertBefore);
    1956           0 :   }
    1957    11059193 : 
    1958    11766086 :   static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
    1959           0 :                           ArrayRef<OperandBundleDef> Bundles = None,
    1960             :                           const Twine &NameStr = "",
    1961     2529548 :                           Instruction *InsertBefore = nullptr) {
    1962     2529612 :     const unsigned TotalOps =
    1963      706893 :         unsigned(Args.size()) + CountBundleInputs(Bundles) + 1;
    1964      706893 :     const unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
    1965           0 : 
    1966           3 :     return new (TotalOps, DescriptorBytes)
    1967     3236441 :         CallInst(Ty, Func, Args, Bundles, NameStr, InsertBefore);
    1968           0 :   }
    1969         456 : 
    1970         456 :   static CallInst *Create(Value *Func, ArrayRef<Value *> Args,
    1971     2522407 :                           ArrayRef<OperandBundleDef> Bundles,
    1972     2522409 :                           const Twine &NameStr, BasicBlock *InsertAtEnd) {
    1973           0 :     const unsigned TotalOps =
    1974         302 :         unsigned(Args.size()) + CountBundleInputs(Bundles) + 1;
    1975     8560653 :     const unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
    1976     8560202 : 
    1977           0 :     return new (TotalOps, DescriptorBytes)
    1978           0 :         CallInst(Func, Args, Bundles, NameStr, InsertAtEnd);
    1979         451 :   }
    1980         452 : 
    1981     8597762 :   static CallInst *Create(Value *Func, ArrayRef<Value *> Args,
    1982          64 :                           const Twine &NameStr, BasicBlock *InsertAtEnd) {
    1983       38170 :     return new (unsigned(Args.size() + 1))
    1984       76349 :         CallInst(Func, Args, None, NameStr, InsertAtEnd);
    1985     8536786 :   }
    1986    10832240 : 
    1987          64 :   static CallInst *Create(Value *F, const Twine &NameStr = "",
    1988          71 :                           Instruction *InsertBefore = nullptr) {
    1989          55 :     return new (1) CallInst(F, NameStr, InsertBefore);
    1990             :   }
    1991         369 : 
    1992         360 :   static CallInst *Create(Value *F, const Twine &NameStr,
    1993           7 :                           BasicBlock *InsertAtEnd) {
    1994         311 :     return new (1) CallInst(F, NameStr, InsertAtEnd);
    1995         305 :   }
    1996          50 : 
    1997          10 :   /// Create a clone of \p CI with a different set of operand bundles and
    1998           3 :   /// insert it before \p InsertPt.
    1999         248 :   ///
    2000         268 :   /// The returned call instruction is identical \p CI in every way except that
    2001          53 :   /// the operand bundles for the new instruction are set to the operand bundles
    2002        8313 :   /// in \p Bundles.
    2003         248 :   static CallInst *Create(CallInst *CI, ArrayRef<OperandBundleDef> Bundles,
    2004        1897 :                           Instruction *InsertPt = nullptr);
    2005          70 : 
    2006     2295299 :   /// Generate the IR for a call to malloc:
    2007             :   /// 1. Compute the malloc call's argument as the specified type's size,
    2008             :   ///    possibly multiplied by the array size if the array size is not
    2009          20 :   ///    constant 1.
    2010          21 :   /// 2. Call malloc with that argument.
    2011     2295279 :   /// 3. Bitcast the result of the malloc call to the specified type.
    2012     2295279 :   static Instruction *CreateMalloc(Instruction *InsertBefore, Type *IntPtrTy,
    2013           0 :                                    Type *AllocTy, Value *AllocSize,
    2014             :                                    Value *ArraySize = nullptr,
    2015     2295297 :                                    Function *MallocF = nullptr,
    2016             :                                    const Twine &Name = "");
    2017         740 :   static Instruction *CreateMalloc(BasicBlock *InsertAtEnd, Type *IntPtrTy,
    2018             :                                    Type *AllocTy, Value *AllocSize,
    2019             :                                    Value *ArraySize = nullptr,
    2020             :                                    Function *MallocF = nullptr,
    2021             :                                    const Twine &Name = "");
    2022        8284 :   static Instruction *CreateMalloc(Instruction *InsertBefore, Type *IntPtrTy,
    2023             :                                    Type *AllocTy, Value *AllocSize,
    2024         118 :                                    Value *ArraySize = nullptr,
    2025             :                                    ArrayRef<OperandBundleDef> Bundles = None,
    2026             :                                    Function *MallocF = nullptr,
    2027        8284 :                                    const Twine &Name = "");
    2028        8284 :   static Instruction *CreateMalloc(BasicBlock *InsertAtEnd, Type *IntPtrTy,
    2029         118 :                                    Type *AllocTy, Value *AllocSize,
    2030         118 :                                    Value *ArraySize = nullptr,
    2031        8284 :                                    ArrayRef<OperandBundleDef> Bundles = None,
    2032             :                                    Function *MallocF = nullptr,
    2033         118 :                                    const Twine &Name = "");
    2034             :   /// Generate the IR for a call to the builtin free function.
    2035             :   static Instruction *CreateFree(Value *Source, Instruction *InsertBefore);
    2036             :   static Instruction *CreateFree(Value *Source, BasicBlock *InsertAtEnd);
    2037             :   static Instruction *CreateFree(Value *Source,
    2038             :                                  ArrayRef<OperandBundleDef> Bundles,
    2039             :                                  Instruction *InsertBefore);
    2040             :   static Instruction *CreateFree(Value *Source,
    2041             :                                  ArrayRef<OperandBundleDef> Bundles,
    2042             :                                  BasicBlock *InsertAtEnd);
    2043             : 
    2044             :   // Note that 'musttail' implies 'tail'.
    2045             :   enum TailCallKind {
    2046             :     TCK_None = 0,
    2047             :     TCK_Tail = 1,
    2048             :     TCK_MustTail = 2,
    2049             :     TCK_NoTail = 3
    2050             :   };
    2051             :   TailCallKind getTailCallKind() const {
    2052             :     return TailCallKind(getSubclassDataFromInstruction() & 3);
    2053         103 :   }
    2054             : 
    2055             :   bool isTailCall() const {
    2056      200487 :     unsigned Kind = getSubclassDataFromInstruction() & 3;
    2057      200487 :     return Kind == TCK_Tail || Kind == TCK_MustTail;
    2058             :   }
    2059             : 
    2060             :   bool isMustTailCall() const {
    2061       17155 :     return (getSubclassDataFromInstruction() & 3) == TCK_MustTail;
    2062             :   }
    2063             : 
    2064             :   bool isNoTailCall() const {
    2065       16313 :     return (getSubclassDataFromInstruction() & 3) == TCK_NoTail;
    2066          13 :   }
    2067             : 
    2068             :   void setTailCall(bool isTC = true) {
    2069         631 :     setInstructionSubclassData((getSubclassDataFromInstruction() & ~3) |
    2070             :                                unsigned(isTC ? TCK_Tail : TCK_None));
    2071          13 :   }
    2072          13 : 
    2073             :   void setTailCallKind(TailCallKind TCK) {
    2074     1884557 :     setInstructionSubclassData((getSubclassDataFromInstruction() & ~3) |
    2075         619 :                                unsigned(TCK));
    2076             :   }
    2077             : 
    2078             :   /// Return true if the call can return twice
    2079          75 :   bool canReturnTwice() const { return hasFnAttr(Attribute::ReturnsTwice); }
    2080             :   void setCanReturnTwice() {
    2081             :     addAttribute(AttributeList::FunctionIndex, Attribute::ReturnsTwice);
    2082             :   }
    2083             : 
    2084             :   /// Check if this call is an inline asm statement.
    2085             :   bool isInlineAsm() const { return isa<InlineAsm>(Op<-1>()); }
    2086          13 : 
    2087           5 :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    2088             :   static bool classof(const Instruction *I) {
    2089           0 :     return I->getOpcode() == Instruction::Call;
    2090      103504 :   }
    2091      103504 :   static bool classof(const Value *V) {
    2092   364001496 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    2093           2 :   }
    2094             : 
    2095             : private:
    2096             :   // Shadow Instruction::setInstructionSubclassData with a private forwarding
    2097          27 :   // method so that subclasses cannot accidentally use it.
    2098     1999948 :   void setInstructionSubclassData(unsigned short D) {
    2099         832 :     Instruction::setInstructionSubclassData(D);
    2100             :   }
    2101             : };
    2102     3935516 : 
    2103      751954 : template <>
    2104             : struct OperandTraits<CallBase<CallInst>>
    2105             :     : public VariadicOperandTraits<CallBase<CallInst>, 1> {};
    2106             : 
    2107     1657076 : CallInst::CallInst(Value *Func, ArrayRef<Value *> Args,
    2108           5 :                    ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
    2109       38170 :                    BasicBlock *InsertAtEnd)
    2110      859006 :     : CallBase<CallInst>(
    2111             :           cast<FunctionType>(
    2112             :               cast<PointerType>(Func->getType())->getElementType())
    2113           0 :               ->getReturnType(),
    2114             :           Instruction::Call,
    2115       38170 :           OperandTraits<CallBase<CallInst>>::op_end(this) -
    2116     1171279 :               (Args.size() + CountBundleInputs(Bundles) + 1),
    2117     1242749 :           unsigned(Args.size() + CountBundleInputs(Bundles) + 1), InsertAtEnd) {
    2118       38170 :   init(Func, Args, Bundles, NameStr);
    2119       38206 : }
    2120     3573201 : 
    2121      706893 : CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
    2122          12 :                    ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
    2123      706893 :                    Instruction *InsertBefore)
    2124             :     : CallBase<CallInst>(Ty->getReturnType(), Instruction::Call,
    2125      706893 :                          OperandTraits<CallBase<CallInst>>::op_end(this) -
    2126      720376 :                              (Args.size() + CountBundleInputs(Bundles) + 1),
    2127     1413786 :                          unsigned(Args.size() + CountBundleInputs(Bundles) + 1),
    2128     2120679 :                          InsertBefore) {
    2129      706893 :   init(Ty, Func, Args, Bundles, NameStr);
    2130      707053 : }
    2131     1518637 : 
    2132             : //===----------------------------------------------------------------------===//
    2133           0 : //                               SelectInst Class
    2134        1345 : //===----------------------------------------------------------------------===//
    2135           0 : 
    2136           0 : /// This class represents the LLVM 'select' instruction.
    2137           0 : ///
    2138    53886668 : class SelectInst : public Instruction {
    2139       49382 :   SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
    2140        5231 :              Instruction *InsertBefore)
    2141       49382 :     : Instruction(S1->getType(), Instruction::Select,
    2142       98764 :                   &Op<0>(), 3, InsertBefore) {
    2143       49382 :     init(C, S1, S2);
    2144    26708632 :     setName(NameStr);
    2145       49446 :   }
    2146    76618520 : 
    2147          64 :   SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
    2148           0 :              BasicBlock *InsertAtEnd)
    2149        3202 :     : Instruction(S1->getType(), Instruction::Select,
    2150          64 :                   &Op<0>(), 3, InsertAtEnd) {
    2151        3273 :     init(C, S1, S2);
    2152       12455 :     setName(NameStr);
    2153        3209 :   }
    2154        3202 : 
    2155       52835 :   void init(Value *C, Value *S1, Value *S2) {
    2156    80883614 :     assert(!areInvalidOperands(C, S1, S2) && "Invalid operands for select");
    2157         570 :     Op<0>() = C;
    2158     3868747 :     Op<1>() = S1;
    2159         308 :     Op<2>() = S2;
    2160       49392 :   }
    2161         304 : 
    2162       48374 : protected:
    2163         569 :   // Note: Instruction needs to be a friend here to call cloneImpl.
    2164         797 :   friend class Instruction;
    2165        3201 : 
    2166         398 :   SelectInst *cloneImpl() const;
    2167          77 : 
    2168     3457451 : public:
    2169     2295462 :   static SelectInst *Create(Value *C, Value *S1, Value *S2,
    2170      375556 :                             const Twine &NameStr = "",
    2171     2667955 :                             Instruction *InsertBefore = nullptr,
    2172     3398105 :                             Instruction *MDFrom = nullptr) {
    2173     2344604 :     SelectInst *Sel = new(3) SelectInst(C, S1, S2, NameStr, InsertBefore);
    2174     2295415 :     if (MDFrom)
    2175     4590753 :       Sel->copyMetadata(*MDFrom);
    2176     8114675 :     return Sel;
    2177     3524040 :   }
    2178     2295397 : 
    2179          59 :   static SelectInst *Create(Value *C, Value *S1, Value *S2,
    2180          59 :                             const Twine &NameStr,
    2181          59 :                             BasicBlock *InsertAtEnd) {
    2182             :     return new(3) SelectInst(C, S1, S2, NameStr, InsertAtEnd);
    2183       41494 :   }
    2184             : 
    2185        8866 :   const Value *getCondition() const { return Op<0>(); }
    2186          80 :   const Value *getTrueValue() const { return Op<1>(); }
    2187        8929 :   const Value *getFalseValue() const { return Op<2>(); }
    2188     1356337 :   Value *getCondition() { return Op<0>(); }
    2189      108559 :   Value *getTrueValue() { return Op<1>(); }
    2190      780826 :   Value *getFalseValue() { return Op<2>(); }
    2191       16756 : 
    2192       24981 :   void setCondition(Value *V) { Op<0>() = V; }
    2193        8533 :   void setTrueValue(Value *V) { Op<1>() = V; }
    2194        8638 :   void setFalseValue(Value *V) { Op<2>() = V; }
    2195         120 : 
    2196         181 :   /// Return a string if the specified operands are invalid
    2197           2 :   /// for a select operation, otherwise return null.
    2198           2 :   static const char *areInvalidOperands(Value *Cond, Value *True, Value *False);
    2199           2 : 
    2200        1213 :   /// Transparently provide more efficient getOperand methods.
    2201           1 :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
    2202             : 
    2203          11 :   OtherOps getOpcode() const {
    2204             :     return static_cast<OtherOps>(Instruction::getOpcode());
    2205           0 :   }
    2206     5925957 : 
    2207          64 :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    2208        1397 :   static bool classof(const Instruction *I) {
    2209          61 :     return I->getOpcode() == Instruction::Select;
    2210           0 :   }
    2211           0 :   static bool classof(const Value *V) {
    2212    47053649 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    2213       10629 :   }
    2214      113399 : };
    2215             : 
    2216           9 : template <>
    2217          54 : struct OperandTraits<SelectInst> : public FixedNumOperandTraits<SelectInst, 3> {
    2218          54 : };
    2219           9 : 
    2220       20085 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(SelectInst, Value)
    2221         122 : 
    2222          18 : //===----------------------------------------------------------------------===//
    2223          28 : //                                VAArgInst Class
    2224          28 : //===----------------------------------------------------------------------===//
    2225           9 : 
    2226           0 : /// This class represents the va_arg llvm instruction, which returns
    2227           2 : /// an argument of the specified type given a va_list and increments that list
    2228             : ///
    2229          13 : class VAArgInst : public UnaryInstruction {
    2230      213606 : protected:
    2231        9791 :   // Note: Instruction needs to be a friend here to call cloneImpl.
    2232             :   friend class Instruction;
    2233          13 : 
    2234          13 :   VAArgInst *cloneImpl() const;
    2235          35 : 
    2236    21173597 : public:
    2237          13 :   VAArgInst(Value *List, Type *Ty, const Twine &NameStr = "",
    2238        4355 :              Instruction *InsertBefore = nullptr)
    2239         268 :     : UnaryInstruction(Ty, VAArg, List, InsertBefore) {
    2240       14351 :     setName(NameStr);
    2241      117449 :   }
    2242       12148 : 
    2243         276 :   VAArgInst(Value *List, Type *Ty, const Twine &NameStr,
    2244         276 :             BasicBlock *InsertAtEnd)
    2245           1 :     : UnaryInstruction(Ty, VAArg, List, InsertAtEnd) {
    2246         801 :     setName(NameStr);
    2247             :   }
    2248             : 
    2249             :   Value *getPointerOperand() { return getOperand(0); }
    2250             :   const Value *getPointerOperand() const { return getOperand(0); }
    2251             :   static unsigned getPointerOperandIndex() { return 0U; }
    2252             : 
    2253         288 :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    2254             :   static bool classof(const Instruction *I) {
    2255          26 :     return I->getOpcode() == VAArg;
    2256          52 :   }
    2257          26 :   static bool classof(const Value *V) {
    2258          26 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    2259          26 :   }
    2260             : };
    2261             : 
    2262       10964 : //===----------------------------------------------------------------------===//
    2263        4194 : //                                ExtractElementInst Class
    2264      325095 : //===----------------------------------------------------------------------===//
    2265       20025 : 
    2266      320208 : /// This instruction extracts a single (scalar)
    2267             : /// element from a VectorType value
    2268             : ///
    2269          26 : class ExtractElementInst : public Instruction {
    2270           0 :   ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr = "",
    2271             :                      Instruction *InsertBefore = nullptr);
    2272      105303 :   ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr,
    2273             :                      BasicBlock *InsertAtEnd);
    2274          26 : 
    2275             : protected:
    2276             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    2277             :   friend class Instruction;
    2278             : 
    2279             :   ExtractElementInst *cloneImpl() const;
    2280             : 
    2281             : public:
    2282             :   static ExtractElementInst *Create(Value *Vec, Value *Idx,
    2283           0 :                                    const Twine &NameStr = "",
    2284             :                                    Instruction *InsertBefore = nullptr) {
    2285       74302 :     return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertBefore);
    2286             :   }
    2287          26 : 
    2288     9301919 :   static ExtractElementInst *Create(Value *Vec, Value *Idx,
    2289             :                                    const Twine &NameStr,
    2290             :                                    BasicBlock *InsertAtEnd) {
    2291             :     return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertAtEnd);
    2292             :   }
    2293       74249 : 
    2294             :   /// Return true if an extractelement instruction can be
    2295             :   /// formed with the specified operands.
    2296             :   static bool isValidOperands(const Value *Vec, const Value *Idx);
    2297             : 
    2298       29927 :   Value *getVectorOperand() { return Op<0>(); }
    2299       34256 :   Value *getIndexOperand() { return Op<1>(); }
    2300       14439 :   const Value *getVectorOperand() const { return Op<0>(); }
    2301           0 :   const Value *getIndexOperand() const { return Op<1>(); }
    2302          26 : 
    2303         209 :   VectorType *getVectorOperandType() const {
    2304       14622 :     return cast<VectorType>(getVectorOperand()->getType());
    2305         720 :   }
    2306       18462 : 
    2307       13786 :   /// Transparently provide more efficient getOperand methods.
    2308             :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
    2309             : 
    2310             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    2311             :   static bool classof(const Instruction *I) {
    2312           0 :     return I->getOpcode() == Instruction::ExtractElement;
    2313          23 :   }
    2314             :   static bool classof(const Value *V) {
    2315      452524 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    2316             :   }
    2317             : };
    2318             : 
    2319             : template <>
    2320             : struct OperandTraits<ExtractElementInst> :
    2321             :   public FixedNumOperandTraits<ExtractElementInst, 2> {
    2322       19010 : };
    2323       19010 : 
    2324       60147 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ExtractElementInst, Value)
    2325             : 
    2326      626783 : //===----------------------------------------------------------------------===//
    2327           7 : //                                InsertElementInst Class
    2328             : //===----------------------------------------------------------------------===//
    2329             : 
    2330             : /// This instruction inserts a single (scalar)
    2331             : /// element into a VectorType value
    2332     8457193 : ///
    2333             : class InsertElementInst : public Instruction {
    2334        1179 :   InsertElementInst(Value *Vec, Value *NewElt, Value *Idx,
    2335           0 :                     const Twine &NameStr = "",
    2336             :                     Instruction *InsertBefore = nullptr);
    2337             :   InsertElementInst(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr,
    2338             :                     BasicBlock *InsertAtEnd);
    2339             : 
    2340           0 : protected:
    2341             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    2342           6 :   friend class Instruction;
    2343        1740 : 
    2344             :   InsertElementInst *cloneImpl() const;
    2345           0 : 
    2346             : public:
    2347             :   static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
    2348             :                                    const Twine &NameStr = "",
    2349             :                                    Instruction *InsertBefore = nullptr) {
    2350       58428 :     return new(3) InsertElementInst(Vec, NewElt, Idx, NameStr, InsertBefore);
    2351         115 :   }
    2352          19 : 
    2353             :   static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
    2354             :                                    const Twine &NameStr,
    2355             :                                    BasicBlock *InsertAtEnd) {
    2356             :     return new(3) InsertElementInst(Vec, NewElt, Idx, NameStr, InsertAtEnd);
    2357       58377 :   }
    2358             : 
    2359             :   /// Return true if an insertelement instruction can be
    2360             :   /// formed with the specified operands.
    2361      115830 :   static bool isValidOperands(const Value *Vec, const Value *NewElt,
    2362             :                               const Value *Idx);
    2363             : 
    2364           0 :   /// Overload to return most specific vector type.
    2365             :   ///
    2366             :   VectorType *getType() const {
    2367       37270 :     return cast<VectorType>(Instruction::getType());
    2368           0 :   }
    2369           0 : 
    2370             :   /// Transparently provide more efficient getOperand methods.
    2371             :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
    2372             : 
    2373             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    2374             :   static bool classof(const Instruction *I) {
    2375           0 :     return I->getOpcode() == Instruction::InsertElement;
    2376      114858 :   }
    2377             :   static bool classof(const Value *V) {
    2378       86179 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    2379             :   }
    2380           0 : };
    2381             : 
    2382             : template <>
    2383             : struct OperandTraits<InsertElementInst> :
    2384             :   public FixedNumOperandTraits<InsertElementInst, 3> {
    2385             : };
    2386             : 
    2387      156514 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertElementInst, Value)
    2388             : 
    2389             : //===----------------------------------------------------------------------===//
    2390             : //                           ShuffleVectorInst Class
    2391             : //===----------------------------------------------------------------------===//
    2392             : 
    2393             : /// This instruction constructs a fixed permutation of two
    2394             : /// input vectors.
    2395             : ///
    2396             : class ShuffleVectorInst : public Instruction {
    2397             : protected:
    2398             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    2399             :   friend class Instruction;
    2400             : 
    2401             :   ShuffleVectorInst *cloneImpl() const;
    2402             : 
    2403           0 : public:
    2404             :   ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
    2405          22 :                     const Twine &NameStr = "",
    2406        1484 :                     Instruction *InsertBefor = nullptr);
    2407             :   ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
    2408           0 :                     const Twine &NameStr, BasicBlock *InsertAtEnd);
    2409             : 
    2410             :   // allocate space for exactly three operands
    2411       20282 :   void *operator new(size_t s) {
    2412       63563 :     return User::operator new(s, 3);
    2413          12 :   }
    2414             : 
    2415         256 :   /// Return true if a shufflevector instruction can be
    2416          40 :   /// formed with the specified operands.
    2417             :   static bool isValidOperands(const Value *V1, const Value *V2,
    2418             :                               const Value *Mask);
    2419             : 
    2420       63861 :   /// Overload to return most specific vector type.
    2421           0 :   ///
    2422             :   VectorType *getType() const {
    2423       29785 :     return cast<VectorType>(Instruction::getType());
    2424             :   }
    2425             : 
    2426             :   /// Transparently provide more efficient getOperand methods.
    2427             :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
    2428             : 
    2429          17 :   Constant *getMask() const {
    2430          15 :     return cast<Constant>(getOperand(2));
    2431             :   }
    2432             : 
    2433             :   /// Return the shuffle mask value for the specified element of the mask.
    2434             :   /// Return -1 if the element is undef.
    2435             :   static int getMaskValue(const Constant *Mask, unsigned Elt);
    2436             : 
    2437             :   /// Return the shuffle mask value of this instruction for the given element
    2438          48 :   /// index. Return -1 if the element is undef.
    2439      109291 :   int getMaskValue(unsigned Elt) const {
    2440       96444 :     return getMaskValue(getMask(), Elt);
    2441             :   }
    2442           0 : 
    2443             :   /// Convert the input shuffle mask operand to a vector of integers. Undefined
    2444             :   /// elements of the mask are returned as -1.
    2445             :   static void getShuffleMask(const Constant *Mask,
    2446          12 :                              SmallVectorImpl<int> &Result);
    2447        6094 : 
    2448             :   /// Return the mask for this instruction as a vector of integers. Undefined
    2449             :   /// elements of the mask are returned as -1.
    2450             :   void getShuffleMask(SmallVectorImpl<int> &Result) const {
    2451       33749 :     return getShuffleMask(getMask(), Result);
    2452             :   }
    2453             : 
    2454             :   SmallVector<int, 16> getShuffleMask() const {
    2455             :     SmallVector<int, 16> Mask;
    2456             :     getShuffleMask(Mask);
    2457             :     return Mask;
    2458             :   }
    2459             : 
    2460             :   /// Return true if this shuffle returns a vector with a different number of
    2461             :   /// elements than its source vectors.
    2462             :   /// Examples: shufflevector <4 x n> A, <4 x n> B, <1,2,3>
    2463             :   ///           shufflevector <4 x n> A, <4 x n> B, <1,2,3,4,5>
    2464         665 :   bool changesLength() const {
    2465        9047 :     unsigned NumSourceElts = Op<0>()->getType()->getVectorNumElements();
    2466       20159 :     unsigned NumMaskElts = getMask()->getType()->getVectorNumElements();
    2467             :     return NumSourceElts != NumMaskElts;
    2468             :   }
    2469        4237 : 
    2470             :   /// Return true if this shuffle returns a vector with a greater number of
    2471             :   /// elements than its source vectors.
    2472             :   /// Example: shufflevector <2 x n> A, <2 x n> B, <1,2,3>
    2473             :   bool increasesLength() const {
    2474             :     unsigned NumSourceElts = Op<0>()->getType()->getVectorNumElements();
    2475             :     unsigned NumMaskElts = getMask()->getType()->getVectorNumElements();
    2476             :     return NumSourceElts < NumMaskElts;
    2477             :   }
    2478         269 : 
    2479             :   /// Return true if this shuffle mask chooses elements from exactly one source
    2480             :   /// vector.
    2481             :   /// Example: <7,5,undef,7>
    2482             :   /// This assumes that vector operands are the same length as the mask.
    2483             :   static bool isSingleSourceMask(ArrayRef<int> Mask);
    2484         829 :   static bool isSingleSourceMask(const Constant *Mask) {
    2485           1 :     assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
    2486       11264 :     SmallVector<int, 16> MaskAsInts;
    2487         829 :     getShuffleMask(Mask, MaskAsInts);
    2488         829 :     return isSingleSourceMask(MaskAsInts);
    2489             :   }
    2490             : 
    2491             :   /// Return true if this shuffle chooses elements from exactly one source
    2492             :   /// vector without changing the length of that vector.
    2493             :   /// Example: shufflevector <4 x n> A, <4 x n> B, <3,0,undef,3>
    2494             :   /// TODO: Optionally allow length-changing shuffles.
    2495         829 :   bool isSingleSource() const {
    2496         829 :     return !changesLength() && isSingleSourceMask(getMask());
    2497             :   }
    2498             : 
    2499          12 :   /// Return true if this shuffle mask chooses elements from exactly one source
    2500          12 :   /// vector without lane crossings. A shuffle using this mask is not
    2501             :   /// necessarily a no-op because it may change the number of elements from its
    2502             :   /// input vectors or it may provide demanded bits knowledge via undef lanes.
    2503             :   /// Example: <undef,undef,2,3>
    2504             :   static bool isIdentityMask(ArrayRef<int> Mask);
    2505             :   static bool isIdentityMask(const Constant *Mask) {
    2506             :     assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
    2507             :     SmallVector<int, 16> MaskAsInts;
    2508             :     getShuffleMask(Mask, MaskAsInts);
    2509             :     return isIdentityMask(MaskAsInts);
    2510             :   }
    2511             : 
    2512             :   /// Return true if this shuffle chooses elements from exactly one source
    2513             :   /// vector without lane crossings and does not change the number of elements
    2514             :   /// from its input vectors.
    2515             :   /// Example: shufflevector <4 x n> A, <4 x n> B, <4,undef,6,undef>
    2516        2480 :   bool isIdentity() const {
    2517        4960 :     return !changesLength() && isIdentityMask(getShuffleMask());
    2518           8 :   }
    2519             : 
    2520             :   /// Return true if this shuffle lengthens exactly one source vector with
    2521           8 :   /// undefs in the high elements.
    2522           8 :   bool isIdentityWithPadding() const;
    2523             : 
    2524             :   /// Return true if this shuffle extracts the first N elements of exactly one
    2525             :   /// source vector.
    2526             :   bool isIdentityWithExtract() const;
    2527             : 
    2528             :   /// Return true if this shuffle concatenates its 2 source vectors. This
    2529             :   /// returns false if either input is undefined. In that case, the shuffle is
    2530             :   /// is better classified as an identity with padding operation.
    2531             :   bool isConcat() const;
    2532             : 
    2533             :   /// Return true if this shuffle mask chooses elements from its source vectors
    2534             :   /// without lane crossings. A shuffle using this mask would be
    2535             :   /// equivalent to a vector select with a constant condition operand.
    2536             :   /// Example: <4,1,6,undef>
    2537             :   /// This returns false if the mask does not choose from both input vectors.
    2538             :   /// In that case, the shuffle is better classified as an identity shuffle.
    2539           8 :   /// This assumes that vector operands are the same length as the mask
    2540             :   /// (a length-changing shuffle can never be equivalent to a vector select).
    2541             :   static bool isSelectMask(ArrayRef<int> Mask);
    2542        7354 :   static bool isSelectMask(const Constant *Mask) {
    2543           8 :     assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
    2544             :     SmallVector<int, 16> MaskAsInts;
    2545        7346 :     getShuffleMask(Mask, MaskAsInts);
    2546        7346 :     return isSelectMask(MaskAsInts);
    2547             :   }
    2548             : 
    2549             :   /// Return true if this shuffle chooses elements from its source vectors
    2550          12 :   /// without lane crossings and all operands have the same number of elements.
    2551          13 :   /// In other words, this shuffle is equivalent to a vector select with a
    2552             :   /// constant condition operand.
    2553             :   /// Example: shufflevector <4 x n> A, <4 x n> B, <undef,1,6,3>
    2554             :   /// This returns false if the mask does not choose from both input vectors.
    2555             :   /// In that case, the shuffle is better classified as an identity shuffle.
    2556             :   /// TODO: Optionally allow length-changing shuffles.
    2557        8647 :   bool isSelect() const {
    2558        8647 :     return !changesLength() && isSelectMask(getMask());
    2559             :   }
    2560             : 
    2561             :   /// Return true if this shuffle mask swaps the order of elements from exactly
    2562             :   /// one source vector.
    2563             :   /// Example: <7,6,undef,4>
    2564             :   /// This assumes that vector operands are the same length as the mask.
    2565             :   static bool isReverseMask(ArrayRef<int> Mask);
    2566        2387 :   static bool isReverseMask(const Constant *Mask) {
    2567             :     assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
    2568             :     SmallVector<int, 16> MaskAsInts;
    2569        2387 :     getShuffleMask(Mask, MaskAsInts);
    2570        2387 :     return isReverseMask(MaskAsInts);
    2571             :   }
    2572             : 
    2573             :   /// Return true if this shuffle swaps the order of elements from exactly
    2574             :   /// one source vector.
    2575             :   /// Example: shufflevector <4 x n> A, <4 x n> B, <3,undef,1,undef>
    2576           8 :   /// TODO: Optionally allow length-changing shuffles.
    2577        2387 :   bool isReverse() const {
    2578        2387 :     return !changesLength() && isReverseMask(getMask());
    2579           8 :   }
    2580           8 : 
    2581             :   /// Return true if this shuffle mask chooses all elements with the same value
    2582             :   /// as the first element of exactly one source vector.
    2583             :   /// Example: <4,undef,undef,4>
    2584             :   /// This assumes that vector operands are the same length as the mask.
    2585             :   static bool isZeroEltSplatMask(ArrayRef<int> Mask);
    2586        1657 :   static bool isZeroEltSplatMask(const Constant *Mask) {
    2587             :     assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
    2588             :     SmallVector<int, 16> MaskAsInts;
    2589        1657 :     getShuffleMask(Mask, MaskAsInts);
    2590        1657 :     return isZeroEltSplatMask(MaskAsInts);
    2591             :   }
    2592             : 
    2593             :   /// Return true if all elements of this shuffle are the same value as the
    2594             :   /// first element of exactly one source vector without changing the length
    2595             :   /// of that vector.
    2596             :   /// Example: shufflevector <4 x n> A, <4 x n> B, <undef,0,undef,0>
    2597             :   /// TODO: Optionally allow length-changing shuffles.
    2598             :   /// TODO: Optionally allow splats from other elements.
    2599        1657 :   bool isZeroEltSplat() const {
    2600        1665 :     return !changesLength() && isZeroEltSplatMask(getMask());
    2601             :   }
    2602             : 
    2603           8 :   /// Return true if this shuffle mask is a transpose mask.
    2604           8 :   /// Transpose vector masks transpose a 2xn matrix. They read corresponding
    2605             :   /// even- or odd-numbered vector elements from two n-dimensional source
    2606             :   /// vectors and write each result into consecutive elements of an
    2607             :   /// n-dimensional destination vector. Two shuffles are necessary to complete
    2608             :   /// the transpose, one for the even elements and another for the odd elements.
    2609             :   /// This description closely follows how the TRN1 and TRN2 AArch64
    2610             :   /// instructions operate.
    2611             :   ///
    2612             :   /// For example, a simple 2x2 matrix can be transposed with:
    2613             :   ///
    2614             :   ///   ; Original matrix
    2615             :   ///   m0 = < a, b >
    2616             :   ///   m1 = < c, d >
    2617             :   ///
    2618             :   ///   ; Transposed matrix
    2619             :   ///   t0 = < a, c > = shufflevector m0, m1, < 0, 2 >
    2620           8 :   ///   t1 = < b, d > = shufflevector m0, m1, < 1, 3 >
    2621             :   ///
    2622             :   /// For matrices having greater than n columns, the resulting nx2 transposed
    2623           8 :   /// matrix is stored in two result vectors such that one vector contains
    2624           8 :   /// interleaved elements from all the even-numbered rows and the other vector
    2625             :   /// contains interleaved elements from all the odd-numbered rows. For example,
    2626             :   /// a 2x4 matrix can be transposed with:
    2627             :   ///
    2628             :   ///   ; Original matrix
    2629             :   ///   m0 = < a, b, c, d >
    2630             :   ///   m1 = < e, f, g, h >
    2631             :   ///
    2632             :   ///   ; Transposed matrix
    2633             :   ///   t0 = < a, e, c, g > = shufflevector m0, m1 < 0, 4, 2, 6 >
    2634             :   ///   t1 = < b, f, d, h > = shufflevector m0, m1 < 1, 5, 3, 7 >
    2635             :   static bool isTransposeMask(ArrayRef<int> Mask);
    2636        1679 :   static bool isTransposeMask(const Constant *Mask) {
    2637             :     assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
    2638             :     SmallVector<int, 16> MaskAsInts;
    2639        1679 :     getShuffleMask(Mask, MaskAsInts);
    2640        1679 :     return isTransposeMask(MaskAsInts);
    2641             :   }
    2642             : 
    2643             :   /// Return true if this shuffle transposes the elements of its inputs without
    2644             :   /// changing the length of the vectors. This operation may also be known as a
    2645             :   /// merge or interleave. See the description for isTransposeMask() for the
    2646             :   /// exact specification.
    2647             :   /// Example: shufflevector <4 x n> A, <4 x n> B, <0,4,2,6>
    2648        1679 :   bool isTranspose() const {
    2649        1679 :     return !changesLength() && isTransposeMask(getMask());
    2650             :   }
    2651             : 
    2652             :   /// Change values in a shuffle permute mask assuming the two vector operands
    2653             :   /// of length InVecNumElts have swapped position.
    2654             :   static void commuteShuffleMask(MutableArrayRef<int> Mask,
    2655             :                                  unsigned InVecNumElts) {
    2656             :     for (int &Idx : Mask) {
    2657             :       if (Idx == -1)
    2658             :         continue;
    2659             :       Idx = Idx < (int)InVecNumElts ? Idx + InVecNumElts : Idx - InVecNumElts;
    2660             :       assert(Idx >= 0 && Idx < (int)InVecNumElts * 2 &&
    2661             :              "shufflevector mask index out of range");
    2662             :     }
    2663             :   }
    2664             : 
    2665             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    2666             :   static bool classof(const Instruction *I) {
    2667           0 :     return I->getOpcode() == Instruction::ShuffleVector;
    2668             :   }
    2669             :   static bool classof(const Value *V) {
    2670     1428495 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    2671             :   }
    2672             : };
    2673           8 : 
    2674           8 : template <>
    2675             : struct OperandTraits<ShuffleVectorInst> :
    2676             :   public FixedNumOperandTraits<ShuffleVectorInst, 3> {
    2677             : };
    2678             : 
    2679      198909 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ShuffleVectorInst, Value)
    2680           0 : 
    2681           0 : //===----------------------------------------------------------------------===//
    2682             : //                                ExtractValueInst Class
    2683           0 : //===----------------------------------------------------------------------===//
    2684             : 
    2685             : /// This instruction extracts a struct member or array
    2686             : /// element value from an aggregate value.
    2687             : ///
    2688             : class ExtractValueInst : public UnaryInstruction {
    2689             :   SmallVector<unsigned, 4> Indices;
    2690           4 : 
    2691           3 :   ExtractValueInst(const ExtractValueInst &EVI);
    2692             : 
    2693           2 :   /// Constructors - Create a extractvalue instruction with a base aggregate
    2694       21538 :   /// value and a list of indices.  The first ctor can optionally insert before
    2695             :   /// an existing instruction, the second appends the new instruction to the
    2696             :   /// specified BasicBlock.
    2697           6 :   inline ExtractValueInst(Value *Agg,
    2698        1124 :                           ArrayRef<unsigned> Idxs,
    2699             :                           const Twine &NameStr,
    2700           0 :                           Instruction *InsertBefore);
    2701             :   inline ExtractValueInst(Value *Agg,
    2702             :                           ArrayRef<unsigned> Idxs,
    2703        7376 :                           const Twine &NameStr, BasicBlock *InsertAtEnd);
    2704             : 
    2705             :   void init(ArrayRef<unsigned> Idxs, const Twine &NameStr);
    2706             : 
    2707          60 : protected:
    2708             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    2709             :   friend class Instruction;
    2710             : 
    2711             :   ExtractValueInst *cloneImpl() const;
    2712             : 
    2713          12 : public:
    2714       16603 :   static ExtractValueInst *Create(Value *Agg,
    2715             :                                   ArrayRef<unsigned> Idxs,
    2716      120067 :                                   const Twine &NameStr = "",
    2717             :                                   Instruction *InsertBefore = nullptr) {
    2718             :     return new
    2719       16603 :       ExtractValueInst(Agg, Idxs, NameStr, InsertBefore);
    2720             :   }
    2721             : 
    2722             :   static ExtractValueInst *Create(Value *Agg,
    2723             :                                   ArrayRef<unsigned> Idxs,
    2724      594521 :                                   const Twine &NameStr,
    2725       11264 :                                   BasicBlock *InsertAtEnd) {
    2726             :     return new ExtractValueInst(Agg, Idxs, NameStr, InsertAtEnd);
    2727             :   }
    2728             : 
    2729      594521 :   /// Returns the type of the element that would be extracted
    2730             :   /// with an extractvalue instruction with the specified parameters.
    2731      146430 :   ///
    2732          48 :   /// Null is returned if the indices are invalid for the specified type.
    2733             :   static Type *getIndexedType(Type *Agg, ArrayRef<unsigned> Idxs);
    2734             : 
    2735             :   using idx_iterator = const unsigned*;
    2736             : 
    2737          48 :   inline idx_iterator idx_begin() const { return Indices.begin(); }
    2738             :   inline idx_iterator idx_end()   const { return Indices.end(); }
    2739             :   inline iterator_range<idx_iterator> indices() const {
    2740             :     return make_range(idx_begin(), idx_end());
    2741             :   }
    2742             : 
    2743             :   Value *getAggregateOperand() {
    2744           6 :     return getOperand(0);
    2745             :   }
    2746             :   const Value *getAggregateOperand() const {
    2747             :     return getOperand(0);
    2748             :   }
    2749           6 :   static unsigned getAggregateOperandIndex() {
    2750             :     return 0U;                      // get index for modifying correct operand
    2751             :   }
    2752           1 : 
    2753             :   ArrayRef<unsigned> getIndices() const {
    2754             :     return Indices;
    2755             :   }
    2756             : 
    2757           1 :   unsigned getNumIndices() const {
    2758      303115 :     return (unsigned)Indices.size();
    2759             :   }
    2760             : 
    2761           0 :   bool hasIndices() const {
    2762       27888 :     return true;
    2763             :   }
    2764             : 
    2765             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    2766             :   static bool classof(const Instruction *I) {
    2767       27888 :     return I->getOpcode() == Instruction::ExtractValue;
    2768             :   }
    2769             :   static bool classof(const Value *V) {
    2770      493878 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    2771             :   }
    2772             : };
    2773             : 
    2774       16603 : ExtractValueInst::ExtractValueInst(Value *Agg,
    2775             :                                    ArrayRef<unsigned> Idxs,
    2776          29 :                                    const Twine &NameStr,
    2777       16603 :                                    Instruction *InsertBefore)
    2778             :   : UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)),
    2779       16603 :                      ExtractValue, Agg, InsertBefore) {
    2780       16603 :   init(Idxs, NameStr);
    2781       16603 : }
    2782        1025 : 
    2783             : ExtractValueInst::ExtractValueInst(Value *Agg,
    2784      594521 :                                    ArrayRef<unsigned> Idxs,
    2785             :                                    const Twine &NameStr,
    2786             :                                    BasicBlock *InsertAtEnd)
    2787      594521 :   : UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)),
    2788           6 :                      ExtractValue, Agg, InsertAtEnd) {
    2789      594521 :   init(Idxs, NameStr);
    2790      594521 : }
    2791      594521 : 
    2792          48 : //===----------------------------------------------------------------------===//
    2793             : //                                InsertValueInst Class
    2794         374 : //===----------------------------------------------------------------------===//
    2795          48 : 
    2796             : /// This instruction inserts a struct field of array element
    2797          48 : /// value into an aggregate value.
    2798         151 : ///
    2799          48 : class InsertValueInst : public Instruction {
    2800          20 :   SmallVector<unsigned, 4> Indices;
    2801           0 : 
    2802             :   InsertValueInst(const InsertValueInst &IVI);
    2803           0 : 
    2804           6 :   /// Constructors - Create a insertvalue instruction with a base aggregate
    2805             :   /// value, a value to insert, and a list of indices.  The first ctor can
    2806             :   /// optionally insert before an existing instruction, the second appends
    2807           6 :   /// the new instruction to the specified BasicBlock.
    2808             :   inline InsertValueInst(Value *Agg, Value *Val,
    2809           6 :                          ArrayRef<unsigned> Idxs,
    2810           6 :                          const Twine &NameStr,
    2811           6 :                          Instruction *InsertBefore);
    2812           1 :   inline InsertValueInst(Value *Agg, Value *Val,
    2813             :                          ArrayRef<unsigned> Idxs,
    2814             :                          const Twine &NameStr, BasicBlock *InsertAtEnd);
    2815           1 : 
    2816      121053 :   /// Constructors - These two constructors are convenience methods because one
    2817           1 :   /// and two index insertvalue instructions are so common.
    2818           1 :   InsertValueInst(Value *Agg, Value *Val, unsigned Idx,
    2819           1 :                   const Twine &NameStr = "",
    2820             :                   Instruction *InsertBefore = nullptr);
    2821             :   InsertValueInst(Value *Agg, Value *Val, unsigned Idx, const Twine &NameStr,
    2822       27888 :                   BasicBlock *InsertAtEnd);
    2823             : 
    2824             :   void init(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
    2825       27888 :             const Twine &NameStr);
    2826             : 
    2827       27888 : protected:
    2828       27888 :   // Note: Instruction needs to be a friend here to call cloneImpl.
    2829       27888 :   friend class Instruction;
    2830      639642 : 
    2831             :   InsertValueInst *cloneImpl() const;
    2832             : 
    2833           0 : public:
    2834       31463 :   // allocate space for exactly two operands
    2835             :   void *operator new(size_t s) {
    2836      148215 :     return User::operator new(s, 2);
    2837             :   }
    2838             : 
    2839       93536 :   static InsertValueInst *Create(Value *Agg, Value *Val,
    2840             :                                  ArrayRef<unsigned> Idxs,
    2841             :                                  const Twine &NameStr = "",
    2842             :                                  Instruction *InsertBefore = nullptr) {
    2843       93536 :     return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertBefore);
    2844             :   }
    2845             : 
    2846         336 :   static InsertValueInst *Create(Value *Agg, Value *Val,
    2847             :                                  ArrayRef<unsigned> Idxs,
    2848             :                                  const Twine &NameStr,
    2849          26 :                                  BasicBlock *InsertAtEnd) {
    2850             :     return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertAtEnd);
    2851             :   }
    2852             : 
    2853          26 :   /// Transparently provide more efficient getOperand methods.
    2854          38 :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
    2855             : 
    2856             :   using idx_iterator = const unsigned*;
    2857          38 : 
    2858             :   inline idx_iterator idx_begin() const { return Indices.begin(); }
    2859             :   inline idx_iterator idx_end()   const { return Indices.end(); }
    2860             :   inline iterator_range<idx_iterator> indices() const {
    2861          38 :     return make_range(idx_begin(), idx_end());
    2862             :   }
    2863             : 
    2864             :   Value *getAggregateOperand() {
    2865             :     return getOperand(0);
    2866           4 :   }
    2867             :   const Value *getAggregateOperand() const {
    2868             :     return getOperand(0);
    2869           4 :   }
    2870             :   static unsigned getAggregateOperandIndex() {
    2871             :     return 0U;                      // get index for modifying correct operand
    2872             :   }
    2873           4 : 
    2874          16 :   Value *getInsertedValueOperand() {
    2875             :     return getOperand(1);
    2876             :   }
    2877          16 :   const Value *getInsertedValueOperand() const {
    2878             :     return getOperand(1);
    2879             :   }
    2880             :   static unsigned getInsertedValueOperandIndex() {
    2881          16 :     return 1U;                      // get index for modifying correct operand
    2882             :   }
    2883             : 
    2884         763 :   ArrayRef<unsigned> getIndices() const {
    2885             :     return Indices;
    2886             :   }
    2887         763 : 
    2888           0 :   unsigned getNumIndices() const {
    2889       22457 :     return (unsigned)Indices.size();
    2890             :   }
    2891         763 : 
    2892           0 :   bool hasIndices() const {
    2893           0 :     return true;
    2894           0 :   }
    2895           0 : 
    2896             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    2897             :   static bool classof(const Instruction *I) {
    2898           0 :     return I->getOpcode() == Instruction::InsertValue;
    2899             :   }
    2900             :   static bool classof(const Value *V) {
    2901      725337 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    2902          34 :   }
    2903             : };
    2904             : 
    2905          34 : template <>
    2906             : struct OperandTraits<InsertValueInst> :
    2907           8 :   public FixedNumOperandTraits<InsertValueInst, 2> {
    2908             : };
    2909          34 : 
    2910       93536 : InsertValueInst::InsertValueInst(Value *Agg,
    2911             :                                  Value *Val,
    2912           0 :                                  ArrayRef<unsigned> Idxs,
    2913             :                                  const Twine &NameStr,
    2914       93536 :                                  Instruction *InsertBefore)
    2915           0 :   : Instruction(Agg->getType(), InsertValue,
    2916             :                 OperandTraits<InsertValueInst>::op_begin(this),
    2917      187072 :                 2, InsertBefore) {
    2918       93536 :   init(Agg, Val, Idxs, NameStr);
    2919       93540 : }
    2920          26 : 
    2921             : InsertValueInst::InsertValueInst(Value *Agg,
    2922             :                                  Value *Val,
    2923             :                                  ArrayRef<unsigned> Idxs,
    2924          26 :                                  const Twine &NameStr,
    2925         449 :                                  BasicBlock *InsertAtEnd)
    2926             :   : Instruction(Agg->getType(), InsertValue,
    2927          52 :                 OperandTraits<InsertValueInst>::op_begin(this),
    2928          64 :                 2, InsertAtEnd) {
    2929          26 :   init(Agg, Val, Idxs, NameStr);
    2930             : }
    2931           8 : 
    2932      185454 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertValueInst, Value)
    2933             : 
    2934           0 : //===----------------------------------------------------------------------===//
    2935          76 : //                               PHINode Class
    2936          38 : //===----------------------------------------------------------------------===//
    2937          38 : 
    2938             : // PHINode - The PHINode class is used to represent the magical mystical PHI
    2939             : // node, that can not exist in nature, but can be synthesized in a computer
    2940           4 : // scientist's overactive imagination.
    2941             : //
    2942        5006 : class PHINode : public Instruction {
    2943             :   /// The number of operands actually allocated.  NumOperands is
    2944           4 :   /// the number actually in use.
    2945             :   unsigned ReservedSpace;
    2946             : 
    2947       17989 :   PHINode(const PHINode &PN);
    2948          20 : 
    2949      492941 :   explicit PHINode(Type *Ty, unsigned NumReservedValues,
    2950          87 :                    const Twine &NameStr = "",
    2951             :                    Instruction *InsertBefore = nullptr)
    2952      492953 :     : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertBefore),
    2953      493000 :       ReservedSpace(NumReservedValues) {
    2954      492937 :     setName(NameStr);
    2955      492969 :     allocHungoffUses(ReservedSpace);
    2956      572970 :   }
    2957          79 : 
    2958       13756 :   PHINode(Type *Ty, unsigned NumReservedValues, const Twine &NameStr,
    2959        4959 :           BasicBlock *InsertAtEnd)
    2960       12993 :     : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertAtEnd),
    2961       12993 :       ReservedSpace(NumReservedValues) {
    2962       18715 :     setName(NameStr);
    2963       17952 :     allocHungoffUses(ReservedSpace);
    2964       17952 :   }
    2965        6485 : 
    2966      499071 : protected:
    2967         763 :   // Note: Instruction needs to be a friend here to call cloneImpl.
    2968          31 :   friend class Instruction;
    2969             : 
    2970           0 :   PHINode *cloneImpl() const;
    2971           0 : 
    2972           0 :   // allocHungoffUses - this is more complicated than the generic
    2973           0 :   // User::allocHungoffUses, because we have to allocate Uses for the incoming
    2974           0 :   // values and pointers to the incoming blocks, all in one allocation.
    2975             :   void allocHungoffUses(unsigned N) {
    2976      667347 :     User::allocHungoffUses(N, /* IsPhi */ true);
    2977         272 :   }
    2978             : 
    2979           3 : public:
    2980         289 :   /// Constructors - NumReservedValues is a hint for the number of incoming
    2981         255 :   /// edges that this phi node will have (use 0 if you really have no idea).
    2982         258 :   static PHINode *Create(Type *Ty, unsigned NumReservedValues,
    2983         363 :                          const Twine &NameStr = "",
    2984       12202 :                          Instruction *InsertBefore = nullptr) {
    2985      491955 :     return new PHINode(Ty, NumReservedValues, NameStr, InsertBefore);
    2986        4999 :   }
    2987          48 : 
    2988         224 :   static PHINode *Create(Type *Ty, unsigned NumReservedValues,
    2989         224 :                          const Twine &NameStr, BasicBlock *InsertAtEnd) {
    2990       13221 :     return new PHINode(Ty, NumReservedValues, NameStr, InsertAtEnd);
    2991         248 :   }
    2992         198 : 
    2993          11 :   /// Provide fast operand accessors
    2994          61 :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
    2995       12578 : 
    2996          50 :   // Block iterator interface. This provides access to the list of incoming
    2997          52 :   // basic blocks, which parallels the list of incoming values.
    2998        7619 : 
    2999        7569 :   using block_iterator = BasicBlock **;
    3000        7571 :   using const_block_iterator = BasicBlock * const *;
    3001        7571 : 
    3002        7571 :   block_iterator block_begin() {
    3003          22 :     Use::UserRef *ref =
    3004     1527639 :       reinterpret_cast<Use::UserRef*>(op_begin() + ReservedSpace);
    3005      220016 :     return reinterpret_cast<block_iterator>(ref + 1);
    3006          11 :   }
    3007           8 : 
    3008          23 :   const_block_iterator block_begin() const {
    3009           8 :     const Use::UserRef *ref =
    3010     9625166 :       reinterpret_cast<const Use::UserRef*>(op_begin() + ReservedSpace);
    3011      161383 :     return reinterpret_cast<const_block_iterator>(ref + 1);
    3012         187 :   }
    3013         139 : 
    3014        5545 :   block_iterator block_end() {
    3015     6406834 :     return block_begin() + getNumOperands();
    3016          37 :   }
    3017             : 
    3018          50 :   const_block_iterator block_end() const {
    3019      161384 :     return block_begin() + getNumOperands();
    3020             :   }
    3021         187 : 
    3022        7575 :   iterator_range<block_iterator> blocks() {
    3023          11 :     return make_range(block_begin(), block_end());
    3024          65 :   }
    3025             : 
    3026             :   iterator_range<const_block_iterator> blocks() const {
    3027          50 :     return make_range(block_begin(), block_end());
    3028      234969 :   }
    3029       17216 : 
    3030     1262594 :   op_range incoming_values() { return operands(); }
    3031        7695 : 
    3032       99991 :   const_op_range incoming_values() const { return operands(); }
    3033          65 : 
    3034      161316 :   /// Return the number of incoming edges
    3035             :   ///
    3036             :   unsigned getNumIncomingValues() const { return getNumOperands(); }
    3037             : 
    3038        3074 :   /// Return incoming value number x
    3039       17224 :   ///
    3040          86 :   Value *getIncomingValue(unsigned i) const {
    3041             :     return getOperand(i);
    3042           0 :   }
    3043             :   void setIncomingValue(unsigned i, Value *V) {
    3044        2528 :     assert(V && "PHI node got a null value!");
    3045        2472 :     assert(getType() == V->getType() &&
    3046         129 :            "All operands to PHI node must be the same type as the PHI node!");
    3047     1305393 :     setOperand(i, V);
    3048          20 :   }
    3049             : 
    3050           0 :   static unsigned getOperandNumForIncomingValue(unsigned i) {
    3051             :     return i;
    3052         100 :   }
    3053        1236 : 
    3054      128054 :   static unsigned getIncomingValueNumForOperand(unsigned i) {
    3055             :     return i;
    3056      442202 :   }
    3057        5534 : 
    3058         267 :   /// Return incoming basic block number @p i.
    3059             :   ///
    3060             :   BasicBlock *getIncomingBlock(unsigned i) const {
    3061     3706310 :     return block_begin()[i];
    3062      832107 :   }
    3063         273 : 
    3064          24 :   /// Return incoming basic block corresponding
    3065         491 :   /// to an operand of the PHI.
    3066     1143093 :   ///
    3067         310 :   BasicBlock *getIncomingBlock(const Use &U) const {
    3068      861885 :     assert(this == U.getUser() && "Iterator doesn't point to PHI's Uses?");
    3069     2098188 :     return getIncomingBlock(unsigned(&U - op_begin()));
    3070      303955 :   }
    3071             : 
    3072             :   /// Return incoming basic block corresponding
    3073             :   /// to value use iterator.
    3074      512172 :   ///
    3075         332 :   BasicBlock *getIncomingBlock(Value::const_user_iterator I) const {
    3076             :     return getIncomingBlock(I.getUse());
    3077           7 :   }
    3078             : 
    3079     1079302 :   void setIncomingBlock(unsigned i, BasicBlock *BB) {
    3080             :     assert(BB && "PHI node got a null basic block!");
    3081     1422564 :     block_begin()[i] = BB;
    3082       85032 :   }
    3083          79 : 
    3084             :   /// Add an incoming value to the end of the PHI list
    3085      157226 :   ///
    3086     1008446 :   void addIncoming(Value *V, BasicBlock *BB) {
    3087     1008446 :     if (getNumOperands() == ReservedSpace)
    3088       10561 :       growOperands();  // Get more space!
    3089         980 :     // Initialize some new operands.
    3090     1008719 :     setNumHungOffUseOperands(getNumOperands() + 1);
    3091     1013987 :     setIncomingValue(getNumOperands() - 1, V);
    3092     1008446 :     setIncomingBlock(getNumOperands() - 1, BB);
    3093     1008446 :   }
    3094             : 
    3095          60 :   /// Remove an incoming value.  This is useful if a
    3096        5534 :   /// predecessor basic block is deleted.  The value removed is returned.
    3097        5536 :   ///
    3098           0 :   /// If the last incoming value for a PHI node is removed (and DeletePHIIfEmpty
    3099         299 :   /// is true), the PHI node is destroyed and any uses of it are replaced with
    3100        5534 :   /// dummy values.  The only time there should be zero incoming values to a PHI
    3101        5546 :   /// node is when the block is dead, so this strategy is sound.
    3102        5534 :   ///
    3103        5546 :   Value *removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty = true);
    3104           6 : 
    3105       23637 :   Value *removeIncomingValue(const BasicBlock *BB, bool DeletePHIIfEmpty=true) {
    3106      468566 :     int Idx = getBasicBlockIndex(BB);
    3107          20 :     assert(Idx >= 0 && "Invalid basic block argument to remove!");
    3108     3180350 :     return removeIncomingValue(Idx, DeletePHIIfEmpty);
    3109         340 :   }
    3110           6 : 
    3111          18 :   /// Return the first index of the specified basic
    3112             :   /// block in the value list for this PHI.  Returns -1 if no instance.
    3113      832107 :   ///
    3114     1990662 :   int getBasicBlockIndex(const BasicBlock *BB) const {
    3115     3830719 :     for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
    3116     3693001 :       if (block_begin()[i] == BB)
    3117     1853060 :         return i;
    3118         347 :     return -1;
    3119         343 :   }
    3120         423 : 
    3121     1692854 :   Value *getIncomingValueForBlock(const BasicBlock *BB) const {
    3122     1692517 :     int Idx = getBasicBlockIndex(BB);
    3123         186 :     assert(Idx >= 0 && "Invalid basic block argument!");
    3124     3384935 :     return getIncomingValue(Idx);
    3125      322401 :   }
    3126         152 : 
    3127         152 :   /// If the specified PHI node always merges together the
    3128         179 :   /// same value, return the value, otherwise return null.
    3129         183 :   Value *hasConstantValue() const;
    3130      234578 : 
    3131           0 :   /// Whether the specified PHI node always merges
    3132         100 :   /// together the same value, assuming undefs are equal to a unique
    3133        5979 :   /// non-undef value.
    3134         139 :   bool hasConstantOrUndefValue() const;
    3135         116 : 
    3136          35 :   /// Methods for support type inquiry through isa, cast, and dyn_cast:
    3137           0 :   static bool classof(const Instruction *I) {
    3138        2678 :     return I->getOpcode() == Instruction::PHI;
    3139        4087 :   }
    3140        4099 :   static bool classof(const Value *V) {
    3141    50746666 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    3142        1493 :   }
    3143        2218 : 
    3144       11913 : private:
    3145       32636 :   void growOperands();
    3146        2683 : };
    3147          12 : 
    3148        5342 : template <>
    3149        1353 : struct OperandTraits<PHINode> : public HungoffOperandTraits<2> {
    3150       29911 : };
    3151       28558 : 
    3152    41675935 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(PHINode, Value)
    3153             : 
    3154       28558 : //===----------------------------------------------------------------------===//
    3155       28558 : //                           LandingPadInst Class
    3156       28614 : //===----------------------------------------------------------------------===//
    3157       28642 : 
    3158         157 : //===---------------------------------------------------------------------------
    3159          56 : /// The landingpad instruction holds all of the information
    3160      222568 : /// necessary to generate correct exception handling. The landingpad instruction
    3161      442202 : /// cannot be moved from the top of a landing pad block, which itself is
    3162      458804 : /// accessible only from the 'unwind' edge of an invoke. This uses the
    3163      222624 : /// SubclassData field in Value to store whether or not the landingpad is a
    3164          56 : /// cleanup.
    3165     3047433 : ///
    3166         113 : class LandingPadInst : public Instruction {
    3167      222568 :   /// The number of operands actually allocated.  NumOperands is
    3168      222568 :   /// the number actually in use.
    3169        2299 :   unsigned ReservedSpace;
    3170     2178360 : 
    3171           0 :   LandingPadInst(const LandingPadInst &LP);
    3172       29857 : 
    3173             : public:
    3174      193205 :   enum ClauseType { Catch, Filter };
    3175      304380 : 
    3176      583914 : private:
    3177      193205 :   explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
    3178       65257 :                           const Twine &NameStr, Instruction *InsertBefore);
    3179      184000 :   explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
    3180      191187 :                           const Twine &NameStr, BasicBlock *InsertAtEnd);
    3181      359667 : 
    3182      193247 :   // Allocate space for exactly zero operands.
    3183             :   void *operator new(size_t s) {
    3184      827676 :     return User::operator new(s);
    3185       35400 :   }
    3186       38203 : 
    3187      158434 :   void growOperands(unsigned Size);
    3188       71037 :   void init(unsigned NumReservedValues, const Twine &NameStr);
    3189             : 
    3190      103640 : protected:
    3191             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    3192             :   friend class Instruction;
    3193             : 
    3194         520 :   LandingPadInst *cloneImpl() const;
    3195           0 : 
    3196             : public:
    3197             :   /// Constructors - NumReservedClauses is a hint for the number of incoming
    3198      887338 :   /// clauses that this landingpad will have (use 0 if you really have no idea).
    3199             :   static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
    3200          12 :                                 const Twine &NameStr = "",
    3201           0 :                                 Instruction *InsertBefore = nullptr);
    3202           0 :   static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
    3203             :                                 const Twine &NameStr, BasicBlock *InsertAtEnd);
    3204     1656359 : 
    3205      125965 :   /// Provide fast operand accessors
    3206          52 :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
    3207           9 : 
    3208             :   /// Return 'true' if this landingpad instruction is a
    3209             :   /// cleanup. I.e., it should be run when unwinding even if its landing pad
    3210             :   /// doesn't catch the exception.
    3211      891715 :   bool isCleanup() const { return getSubclassDataFromInstruction() & 1; }
    3212      690092 : 
    3213             :   /// Indicate that this landingpad instruction is a cleanup.
    3214             :   void setCleanup(bool V) {
    3215      377842 :     setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
    3216     1952566 :                                (V ? 1 : 0));
    3217     6525311 :   }
    3218             : 
    3219             :   /// Add a catch or filter clause to the landing pad.
    3220             :   void addClause(Constant *ClauseVal);
    3221             : 
    3222             :   /// Get the value of the clause at index Idx. Use isCatch/isFilter to
    3223             :   /// determine what type of clause this is.
    3224             :   Constant *getClause(unsigned Idx) const {
    3225      435186 :     return cast<Constant>(getOperandList()[Idx]);
    3226             :   }
    3227             : 
    3228    13360565 :   /// Return 'true' if the clause and index Idx is a catch clause.
    3229             :   bool isCatch(unsigned Idx) const {
    3230      537372 :     return !isa<ArrayType>(getOperandList()[Idx]->getType());
    3231             :   }
    3232             : 
    3233             :   /// Return 'true' if the clause and index Idx is a filter clause.
    3234      101205 :   bool isFilter(unsigned Idx) const {
    3235      133373 :     return isa<ArrayType>(getOperandList()[Idx]->getType());
    3236      133373 :   }
    3237      101205 : 
    3238             :   /// Get the number of clauses for this landing pad.
    3239             :   unsigned getNumClauses() const { return getNumOperands(); }
    3240             : 
    3241      101206 :   /// Grow the size of the operand list to accommodate the new
    3242      101205 :   /// number of clauses.
    3243             :   void reserveClauses(unsigned Size) { growOperands(Size); }
    3244      202410 : 
    3245           1 :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    3246           0 :   static bool classof(const Instruction *I) {
    3247      367557 :     return I->getOpcode() == Instruction::LandingPad;
    3248             :   }
    3249             :   static bool classof(const Value *V) {
    3250        1213 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    3251             :   }
    3252           0 : };
    3253             : 
    3254             : template <>
    3255     1233676 : struct OperandTraits<LandingPadInst> : public HungoffOperandTraits<1> {
    3256             : };
    3257             : 
    3258             : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(LandingPadInst, Value)
    3259             : 
    3260          16 : //===----------------------------------------------------------------------===//
    3261    25276999 : //                               ReturnInst Class
    3262             : //===----------------------------------------------------------------------===//
    3263          20 : 
    3264             : //===---------------------------------------------------------------------------
    3265             : /// Return a value (possibly void), from a function.  Execution
    3266        2126 : /// does not continue in this function any longer.
    3267             : ///
    3268             : class ReturnInst : public TerminatorInst {
    3269             :   ReturnInst(const ReturnInst &RI);
    3270             : 
    3271           0 : private:
    3272      538193 :   // ReturnInst constructors:
    3273          10 :   // ReturnInst()                  - 'ret void' instruction
    3274             :   // ReturnInst(    null)          - 'ret void' instruction
    3275             :   // ReturnInst(Value* X)          - 'ret X'    instruction
    3276             :   // ReturnInst(    null, Inst *I) - 'ret void' instruction, insert before I
    3277        4660 :   // ReturnInst(Value* X, Inst *I) - 'ret X'    instruction, insert before I
    3278         433 :   // ReturnInst(    null, BB *B)   - 'ret void' instruction, insert @ end of B
    3279             :   // ReturnInst(Value* X, BB *B)   - 'ret X'    instruction, insert @ end of B
    3280           0 :   //
    3281             :   // NOTE: If the Value* passed is of type void then the constructor behaves as
    3282        2330 :   // if it was passed NULL.
    3283             :   explicit ReturnInst(LLVMContext &C, Value *retVal = nullptr,
    3284             :                       Instruction *InsertBefore = nullptr);
    3285           0 :   ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd);
    3286             :   explicit ReturnInst(LLVMContext &C, BasicBlock *InsertAtEnd);
    3287             : 
    3288             : protected:
    3289           0 :   // Note: Instruction needs to be a friend here to call cloneImpl.
    3290             :   friend class Instruction;
    3291             : 
    3292     2287925 :   ReturnInst *cloneImpl() const;
    3293           0 : 
    3294             : public:
    3295      184719 :   static ReturnInst* Create(LLVMContext &C, Value *retVal = nullptr,
    3296             :                             Instruction *InsertBefore = nullptr) {
    3297      274721 :     return new(!!retVal) ReturnInst(C, retVal, InsertBefore);
    3298             :   }
    3299           0 : 
    3300         291 :   static ReturnInst* Create(LLVMContext &C, Value *retVal,
    3301             :                             BasicBlock *InsertAtEnd) {
    3302        3619 :     return new(!!retVal) ReturnInst(C, retVal, InsertAtEnd);
    3303             :   }
    3304             : 
    3305         227 :   static ReturnInst* Create(LLVMContext &C, BasicBlock *InsertAtEnd) {
    3306         426 :     return new(0) ReturnInst(C, InsertAtEnd);
    3307         183 :   }
    3308             : 
    3309             :   /// Provide fast operand accessors
    3310             :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
    3311             : 
    3312             :   /// Convenience accessor. Returns null if there is no return value.
    3313             :   Value *getReturnValue() const {
    3314       94430 :     return getNumOperands() != 0 ? getOperand(0) : nullptr;
    3315           2 :   }
    3316           2 : 
    3317             :   unsigned getNumSuccessors() const { return 0; }
    3318             : 
    3319             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    3320        1200 :   static bool classof(const Instruction *I) {
    3321           1 :     return (I->getOpcode() == Instruction::Ret);
    3322             :   }
    3323          27 :   static bool classof(const Value *V) {
    3324       13091 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    3325          45 :   }
    3326             : 
    3327          23 : private:
    3328             :   friend TerminatorInst;
    3329           1 : 
    3330             :   BasicBlock *getSuccessor(unsigned idx) const {
    3331           2 :     llvm_unreachable("ReturnInst has no successors!");
    3332       87569 :   }
    3333             : 
    3334           0 :   void setSuccessor(unsigned idx, BasicBlock *B) {
    3335             :     llvm_unreachable("ReturnInst has no successors!");
    3336             :   }
    3337             : };
    3338             : 
    3339             : template <>
    3340             : struct OperandTraits<ReturnInst> : public VariadicOperandTraits<ReturnInst> {
    3341         122 : };
    3342             : 
    3343      792677 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ReturnInst, Value)
    3344             : 
    3345      828986 : //===----------------------------------------------------------------------===//
    3346             : //                               BranchInst Class
    3347             : //===----------------------------------------------------------------------===//
    3348         211 : 
    3349         929 : //===---------------------------------------------------------------------------
    3350             : /// Conditional or Unconditional Branch instruction.
    3351           0 : ///
    3352             : class BranchInst : public TerminatorInst {
    3353             :   /// Ops list - Branches are strange.  The operands are ordered:
    3354           0 :   ///  [Cond, FalseDest,] TrueDest.  This makes some accessors faster because
    3355           0 :   /// they don't have to check for cond/uncond branchness. These are mostly
    3356             :   /// accessed relative from op_end().
    3357             :   BranchInst(const BranchInst &BI);
    3358             :   // BranchInst constructors (where {B, T, F} are blocks, and C is a condition):
    3359           0 :   // BranchInst(BB *B)                           - 'br B'
    3360     1620281 :   // BranchInst(BB* T, BB *F, Value *C)          - 'br C, T, F'
    3361       43306 :   // BranchInst(BB* B, Inst *I)                  - 'br B'        insert before I
    3362             :   // BranchInst(BB* T, BB *F, Value *C, Inst *I) - 'br C, T, F', insert before I
    3363           0 :   // BranchInst(BB* B, BB *I)                    - 'br B'        insert at end
    3364           0 :   // BranchInst(BB* T, BB *F, Value *C, BB *I)   - 'br C, T, F', insert at end
    3365           0 :   explicit BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore = nullptr);
    3366         557 :   BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
    3367        4360 :              Instruction *InsertBefore = nullptr);
    3368           0 :   BranchInst(BasicBlock *IfTrue, BasicBlock *InsertAtEnd);
    3369           0 :   BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
    3370       19523 :              BasicBlock *InsertAtEnd);
    3371             : 
    3372             :   void AssertOK();
    3373           0 : 
    3374             : protected:
    3375             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    3376     2329664 :   friend class Instruction;
    3377          52 : 
    3378             :   BranchInst *cloneImpl() const;
    3379             : 
    3380         191 : public:
    3381             :   /// Iterator type that casts an operand to a basic block.
    3382             :   ///
    3383             :   /// This only makes sense because the successors are stored as adjacent
    3384             :   /// operands for branch instructions.
    3385             :   struct succ_op_iterator
    3386           2 :       : iterator_adaptor_base<succ_op_iterator, value_op_iterator,
    3387           0 :                               std::random_access_iterator_tag, BasicBlock *,
    3388             :                               ptrdiff_t, BasicBlock *, BasicBlock *> {
    3389     1895208 :     explicit succ_op_iterator(value_op_iterator I) : iterator_adaptor_base(I) {}
    3390             : 
    3391             :     BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
    3392             :     BasicBlock *operator->() const { return operator*(); }
    3393             :   };
    3394             : 
    3395      554011 :   /// The const version of `succ_op_iterator`.
    3396             :   struct const_succ_op_iterator
    3397           0 :       : iterator_adaptor_base<const_succ_op_iterator, const_value_op_iterator,
    3398             :                               std::random_access_iterator_tag,
    3399             :                               const BasicBlock *, ptrdiff_t, const BasicBlock *,
    3400             :                               const BasicBlock *> {
    3401             :     explicit const_succ_op_iterator(const_value_op_iterator I)
    3402             :         : iterator_adaptor_base(I) {}
    3403       71420 : 
    3404             :     const BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
    3405             :     const BasicBlock *operator->() const { return operator*(); }
    3406             :   };
    3407             : 
    3408       13770 :   static BranchInst *Create(BasicBlock *IfTrue,
    3409             :                             Instruction *InsertBefore = nullptr) {
    3410     1804572 :     return new(1) BranchInst(IfTrue, InsertBefore);
    3411             :   }
    3412             : 
    3413         544 :   static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
    3414             :                             Value *Cond, Instruction *InsertBefore = nullptr) {
    3415      469481 :     return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertBefore);
    3416             :   }
    3417             : 
    3418       12367 :   static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *InsertAtEnd) {
    3419      573818 :     return new(1) BranchInst(IfTrue, InsertAtEnd);
    3420          22 :   }
    3421             : 
    3422         281 :   static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
    3423             :                             Value *Cond, BasicBlock *InsertAtEnd) {
    3424        1153 :     return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertAtEnd);
    3425        4006 :   }
    3426             : 
    3427             :   /// Transparently provide more efficient getOperand methods.
    3428        1666 :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
    3429           0 : 
    3430           1 :   bool isUnconditional() const { return getNumOperands() == 1; }
    3431        4640 :   bool isConditional()   const { return getNumOperands() == 3; }
    3432             : 
    3433             :   Value *getCondition() const {
    3434             :     assert(isConditional() && "Cannot get condition of an uncond branch!");
    3435     8807341 :     return Op<-3>();
    3436             :   }
    3437             : 
    3438     1522834 :   void setCondition(Value *V) {
    3439             :     assert(isConditional() && "Cannot set condition of unconditional branch!");
    3440           3 :     Op<-3>() = V;
    3441          27 :   }
    3442             : 
    3443        1457 :   unsigned getNumSuccessors() const { return 1+isConditional(); }
    3444           1 : 
    3445          14 :   BasicBlock *getSuccessor(unsigned i) const {
    3446         402 :     assert(i < getNumSuccessors() && "Successor # out of range for Branch!");
    3447     8386682 :     return cast_or_null<BasicBlock>((&Op<-1>() - i)->get());
    3448          26 :   }
    3449           1 : 
    3450          14 :   void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
    3451         113 :     assert(idx < getNumSuccessors() && "Successor # out of range for Branch!");
    3452       19512 :     *(&Op<-1>() - idx) = NewSucc;
    3453         285 :   }
    3454             : 
    3455             :   /// Swap the successors of this branch instruction.
    3456      267280 :   ///
    3457        1760 :   /// Swaps the successors of the branch instruction. This also swaps any
    3458             :   /// branch weight metadata associated with the instruction so that it
    3459       95337 :   /// continues to map correctly to each operand.
    3460             :   void swapSuccessors();
    3461          17 : 
    3462        1325 :   iterator_range<succ_op_iterator> successors() {
    3463        8888 :     return make_range(
    3464        7838 :         succ_op_iterator(std::next(value_op_begin(), isConditional() ? 1 : 0)),
    3465    67064693 :         succ_op_iterator(value_op_end()));
    3466             :   }
    3467             : 
    3468             :   iterator_range<const_succ_op_iterator> successors() const {
    3469           1 :     return make_range(const_succ_op_iterator(
    3470             :                           std::next(value_op_begin(), isConditional() ? 1 : 0)),
    3471      107965 :                       const_succ_op_iterator(value_op_end()));
    3472        8271 :   }
    3473             : 
    3474        8271 :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    3475        1973 :   static bool classof(const Instruction *I) {
    3476           0 :     return (I->getOpcode() == Instruction::Br);
    3477    67054311 :   }
    3478             :   static bool classof(const Value *V) {
    3479      430268 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    3480         120 :   }
    3481    62568670 : };
    3482             : 
    3483             : template <>
    3484             : struct OperandTraits<BranchInst> : public VariadicOperandTraits<BranchInst, 1> {
    3485             : };
    3486       11046 : 
    3487      872116 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BranchInst, Value)
    3488             : 
    3489             : //===----------------------------------------------------------------------===//
    3490             : //                               SwitchInst Class
    3491             : //===----------------------------------------------------------------------===//
    3492             : 
    3493      573705 : //===---------------------------------------------------------------------------
    3494             : /// Multiway switch
    3495      634572 : ///
    3496           0 : class SwitchInst : public TerminatorInst {
    3497             :   unsigned ReservedSpace;
    3498             : 
    3499     1891940 :   // Operand[0]    = Value to switch on
    3500           0 :   // Operand[1]    = Default basic block destination
    3501             :   // Operand[2n  ] = Value to match
    3502             :   // Operand[2n+1] = BasicBlock to go to on match
    3503       58536 :   SwitchInst(const SwitchInst &SI);
    3504           0 : 
    3505             :   /// Create a new switch instruction, specifying a value to switch on and a
    3506             :   /// default destination. The number of additional cases can be specified here
    3507     2423305 :   /// to make memory allocation more efficient. This constructor can also
    3508             :   /// auto-insert before another instruction.
    3509           0 :   SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
    3510           0 :              Instruction *InsertBefore);
    3511     1928413 : 
    3512             :   /// Create a new switch instruction, specifying a value to switch on and a
    3513             :   /// default destination. The number of additional cases can be specified here
    3514             :   /// to make memory allocation more efficient. This constructor also
    3515             :   /// auto-inserts at the end of the specified BasicBlock.
    3516             :   SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
    3517             :              BasicBlock *InsertAtEnd);
    3518           0 : 
    3519             :   // allocate space for exactly zero operands
    3520       10627 :   void *operator new(size_t s) {
    3521       21559 :     return User::operator new(s);
    3522             :   }
    3523      289291 : 
    3524          29 :   void init(Value *Value, BasicBlock *Default, unsigned NumReserved);
    3525             :   void growOperands();
    3526             : 
    3527             : protected:
    3528           0 :   // Note: Instruction needs to be a friend here to call cloneImpl.
    3529             :   friend class Instruction;
    3530             : 
    3531             :   SwitchInst *cloneImpl() const;
    3532             : 
    3533          27 : public:
    3534             :   // -2
    3535             :   static const unsigned DefaultPseudoIndex = static_cast<unsigned>(~0L-1);
    3536             : 
    3537             :   template <typename CaseHandleT> class CaseIteratorImpl;
    3538             : 
    3539             :   /// A handle to a particular switch case. It exposes a convenient interface
    3540           0 :   /// to both the case value and the successor block.
    3541             :   ///
    3542             :   /// We define this as a template and instantiate it to form both a const and
    3543             :   /// non-const handle.
    3544             :   template <typename SwitchInstT, typename ConstantIntT, typename BasicBlockT>
    3545             :   class CaseHandleImpl {
    3546             :     // Directly befriend both const and non-const iterators.
    3547             :     friend class SwitchInst::CaseIteratorImpl<
    3548             :         CaseHandleImpl<SwitchInstT, ConstantIntT, BasicBlockT>>;
    3549          19 : 
    3550             :   protected:
    3551           0 :     // Expose the switch type we're parameterized with to the iterator.
    3552             :     using SwitchInstType = SwitchInstT;
    3553             : 
    3554             :     SwitchInstT *SI;
    3555      298461 :     ptrdiff_t Index;
    3556             : 
    3557             :     CaseHandleImpl() = default;
    3558           1 :     CaseHandleImpl(SwitchInstT *SI, ptrdiff_t Index) : SI(SI), Index(Index) {}
    3559           5 : 
    3560             :   public:
    3561      197055 :     /// Resolves case value for current case.
    3562           0 :     ConstantIntT *getCaseValue() const {
    3563             :       assert((unsigned)Index < SI->getNumCases() &&
    3564             :              "Index out the number of cases.");
    3565      204571 :       return reinterpret_cast<ConstantIntT *>(SI->getOperand(2 + Index * 2));
    3566             :     }
    3567             : 
    3568           0 :     /// Resolves successor for current case.
    3569      169744 :     BasicBlockT *getCaseSuccessor() const {
    3570             :       assert(((unsigned)Index < SI->getNumCases() ||
    3571           8 :               (unsigned)Index == DefaultPseudoIndex) &&
    3572             :              "Index out the number of cases.");
    3573      339488 :       return SI->getSuccessor(getSuccessorIndex());
    3574             :     }
    3575           8 : 
    3576             :     /// Returns number of current case.
    3577         951 :     unsigned getCaseIndex() const { return Index; }
    3578             : 
    3579          16 :     /// Returns TerminatorInst's successor index for current case successor.
    3580           0 :     unsigned getSuccessorIndex() const {
    3581             :       assert(((unsigned)Index == DefaultPseudoIndex ||
    3582             :               (unsigned)Index < SI->getNumCases()) &&
    3583        1318 :              "Index out the number of cases.");
    3584      170080 :       return (unsigned)Index != DefaultPseudoIndex ? Index + 1 : 0;
    3585             :     }
    3586           0 : 
    3587          27 :     bool operator==(const CaseHandleImpl &RHS) const {
    3588             :       assert(SI == RHS.SI && "Incompatible operators.");
    3589          32 :       return Index == RHS.Index;
    3590           8 :     }
    3591          54 :   };
    3592             : 
    3593         510 :   using ConstCaseHandle =
    3594             :       CaseHandleImpl<const SwitchInst, const ConstantInt, const BasicBlock>;
    3595           0 : 
    3596           0 :   class CaseHandle
    3597        1782 :       : public CaseHandleImpl<SwitchInst, ConstantInt, BasicBlock> {
    3598           0 :     friend class SwitchInst::CaseIteratorImpl<CaseHandle>;
    3599           7 : 
    3600             :   public:
    3601        3308 :     CaseHandle(SwitchInst *SI, ptrdiff_t Index) : CaseHandleImpl(SI, Index) {}
    3602          27 : 
    3603             :     /// Sets the new value for current case.
    3604           0 :     void setValue(ConstantInt *V) {
    3605           0 :       assert((unsigned)Index < SI->getNumCases() &&
    3606           0 :              "Index out the number of cases.");
    3607       50841 :       SI->setOperand(2 + Index*2, reinterpret_cast<Value*>(V));
    3608          64 :     }
    3609           0 : 
    3610             :     /// Sets the new successor for current case.
    3611       46766 :     void setSuccessor(BasicBlock *S) {
    3612        1722 :       SI->setSuccessor(getSuccessorIndex(), S);
    3613           7 :     }
    3614           0 :   };
    3615       47199 : 
    3616             :   template <typename CaseHandleT>
    3617       20215 :   class CaseIteratorImpl
    3618             :       : public iterator_facade_base<CaseIteratorImpl<CaseHandleT>,
    3619       94402 :                                     std::random_access_iterator_tag,
    3620             :                                     CaseHandleT> {
    3621         181 :     using SwitchInstT = typename CaseHandleT::SwitchInstType;
    3622             : 
    3623           8 :     CaseHandleT Case;
    3624             : 
    3625         365 :   public:
    3626           0 :     /// Default constructed iterator is in an invalid state until assigned to
    3627             :     /// a case for a particular switch.
    3628             :     CaseIteratorImpl() = default;
    3629      106092 : 
    3630       51835 :     /// Initializes case iterator for given SwitchInst and for given
    3631             :     /// case number.
    3632       30895 :     CaseIteratorImpl(SwitchInstT *SI, unsigned CaseNum) : Case(SI, CaseNum) {}
    3633      140108 : 
    3634             :     /// Initializes case iterator for given SwitchInst and for given
    3635           0 :     /// TerminatorInst's successor index.
    3636         181 :     static CaseIteratorImpl fromSuccessorIndex(SwitchInstT *SI,
    3637      280216 :                                                unsigned SuccessorIndex) {
    3638           3 :       assert(SuccessorIndex < SI->getNumSuccessors() &&
    3639           0 :              "Successor index # out of range!");
    3640          75 :       return SuccessorIndex != 0 ? CaseIteratorImpl(SI, SuccessorIndex - 1)
    3641           3 :                                  : CaseIteratorImpl(SI, DefaultPseudoIndex);
    3642           0 :     }
    3643             : 
    3644           0 :     /// Support converting to the const variant. This will be a no-op for const
    3645             :     /// variant.
    3646           0 :     operator CaseIteratorImpl<ConstCaseHandle>() const {
    3647             :       return CaseIteratorImpl<ConstCaseHandle>(Case.SI, Case.Index);
    3648      140108 :     }
    3649             : 
    3650         619 :     CaseIteratorImpl &operator+=(ptrdiff_t N) {
    3651           0 :       // Check index correctness after addition.
    3652           0 :       // Note: Index == getNumCases() means end().
    3653           0 :       assert(Case.Index + N >= 0 &&
    3654             :              (unsigned)(Case.Index + N) <= Case.SI->getNumCases() &&
    3655           0 :              "Case.Index out the number of cases.");
    3656      233234 :       Case.Index += N;
    3657           0 :       return *this;
    3658             :     }
    3659           0 :     CaseIteratorImpl &operator-=(ptrdiff_t N) {
    3660          53 :       // Check index correctness after subtraction.
    3661           0 :       // Note: Case.Index == getNumCases() means end().
    3662           8 :       assert(Case.Index - N >= 0 &&
    3663           0 :              (unsigned)(Case.Index - N) <= Case.SI->getNumCases() &&
    3664             :              "Case.Index out the number of cases.");
    3665          29 :       Case.Index -= N;
    3666             :       return *this;
    3667             :     }
    3668           0 :     ptrdiff_t operator-(const CaseIteratorImpl &RHS) const {
    3669             :       assert(Case.SI == RHS.Case.SI && "Incompatible operators.");
    3670        3471 :       return Case.Index - RHS.Case.Index;
    3671             :     }
    3672             :     bool operator==(const CaseIteratorImpl &RHS) const {
    3673       99513 :       return Case == RHS.Case;
    3674        1290 :     }
    3675             :     bool operator<(const CaseIteratorImpl &RHS) const {
    3676             :       assert(Case.SI == RHS.Case.SI && "Incompatible operators.");
    3677             :       return Case.Index < RHS.Case.Index;
    3678       11463 :     }
    3679          11 :     CaseHandleT &operator*() { return Case; }
    3680          64 :     const CaseHandleT &operator*() const { return Case; }
    3681             :   };
    3682             : 
    3683             :   using CaseIt = CaseIteratorImpl<CaseHandle>;
    3684        8849 :   using ConstCaseIt = CaseIteratorImpl<ConstCaseHandle>;
    3685             : 
    3686             :   static SwitchInst *Create(Value *Value, BasicBlock *Default,
    3687             :                             unsigned NumCases,
    3688             :                             Instruction *InsertBefore = nullptr) {
    3689       12614 :     return new SwitchInst(Value, Default, NumCases, InsertBefore);
    3690             :   }
    3691        1909 : 
    3692             :   static SwitchInst *Create(Value *Value, BasicBlock *Default,
    3693           0 :                             unsigned NumCases, BasicBlock *InsertAtEnd) {
    3694         118 :     return new SwitchInst(Value, Default, NumCases, InsertAtEnd);
    3695             :   }
    3696       31445 : 
    3697             :   /// Provide fast operand accessors
    3698           0 :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
    3699             : 
    3700             :   // Accessor Methods for Switch stmt
    3701         188 :   Value *getCondition() const { return getOperand(0); }
    3702       47346 :   void setCondition(Value *V) { setOperand(0, V); }
    3703             : 
    3704             :   BasicBlock *getDefaultDest() const {
    3705             :     return cast<BasicBlock>(getOperand(1));
    3706             :   }
    3707             : 
    3708       20206 :   void setDefaultDest(BasicBlock *DefaultCase) {
    3709        4681 :     setOperand(1, reinterpret_cast<Value*>(DefaultCase));
    3710             :   }
    3711             : 
    3712             :   /// Return the number of 'cases' in this switch instruction, excluding the
    3713             :   /// default case.
    3714             :   unsigned getNumCases() const {
    3715      123719 :     return getNumOperands()/2 - 1;
    3716             :   }
    3717             : 
    3718             :   /// Returns a read/write iterator that points to the first case in the
    3719           0 :   /// SwitchInst.
    3720      105338 :   CaseIt case_begin() {
    3721           3 :     return CaseIt(this, 0);
    3722          19 :   }
    3723           0 : 
    3724             :   /// Returns a read-only iterator that points to the first case in the
    3725       24814 :   /// SwitchInst.
    3726             :   ConstCaseIt case_begin() const {
    3727           5 :     return ConstCaseIt(this, 0);
    3728             :   }
    3729             : 
    3730             :   /// Returns a read/write iterator that points one past the last in the
    3731             :   /// SwitchInst.
    3732          12 :   CaseIt case_end() {
    3733         619 :     return CaseIt(this, getNumCases());
    3734             :   }
    3735             : 
    3736             :   /// Returns a read-only iterator that points one past the last in the
    3737      136838 :   /// SwitchInst.
    3738             :   ConstCaseIt case_end() const {
    3739          32 :     return ConstCaseIt(this, getNumCases());
    3740             :   }
    3741           0 : 
    3742             :   /// Iteration adapter for range-for loops.
    3743         680 :   iterator_range<CaseIt> cases() {
    3744           0 :     return make_range(case_begin(), case_end());
    3745             :   }
    3746           4 : 
    3747             :   /// Constant iteration adapter for range-for loops.
    3748           0 :   iterator_range<ConstCaseIt> cases() const {
    3749             :     return make_range(case_begin(), case_end());
    3750           0 :   }
    3751             : 
    3752           0 :   /// Returns an iterator that points to the default case.
    3753             :   /// Note: this iterator allows to resolve successor only. Attempt
    3754           0 :   /// to resolve case value causes an assertion.
    3755             :   /// Also note, that increment and decrement also causes an assertion and
    3756             :   /// makes iterator invalid.
    3757          10 :   CaseIt case_default() {
    3758             :     return CaseIt(this, DefaultPseudoIndex);
    3759             :   }
    3760             :   ConstCaseIt case_default() const {
    3761       53593 :     return ConstCaseIt(this, DefaultPseudoIndex);
    3762             :   }
    3763             : 
    3764             :   /// Search all of the case values for the specified constant. If it is
    3765             :   /// explicitly handled, return the case iterator of it, otherwise return
    3766             :   /// default case iterator to indicate that it is handled by the default
    3767       15201 :   /// handler.
    3768        1456 :   CaseIt findCaseValue(const ConstantInt *C) {
    3769             :     CaseIt I = llvm::find_if(
    3770        1456 :         cases(), [C](CaseHandle &Case) { return Case.getCaseValue() == C; });
    3771        1456 :     if (I != case_end())
    3772         901 :       return I;
    3773             : 
    3774             :     return case_default();
    3775             :   }
    3776          30 :   ConstCaseIt findCaseValue(const ConstantInt *C) const {
    3777             :     ConstCaseIt I = llvm::find_if(cases(), [C](ConstCaseHandle &Case) {
    3778           1 :       return Case.getCaseValue() == C;
    3779       32047 :     });
    3780          30 :     if (I != case_end())
    3781          27 :       return I;
    3782             : 
    3783             :     return case_default();
    3784             :   }
    3785             : 
    3786             :   /// Finds the unique case value for a given successor. Returns null if the
    3787             :   /// successor is not found, not unique, or is the default case.
    3788           0 :   ConstantInt *findCaseDest(BasicBlock *BB) {
    3789           0 :     if (BB == getDefaultDest())
    3790             :       return nullptr;
    3791             : 
    3792             :     ConstantInt *CI = nullptr;
    3793           0 :     for (auto Case : cases()) {
    3794           0 :       if (Case.getCaseSuccessor() != BB)
    3795             :         continue;
    3796         146 : 
    3797           0 :       if (CI)
    3798         146 :         return nullptr; // Multiple cases lead to BB.
    3799         151 : 
    3800         128 :       CI = Case.getCaseValue();
    3801             :     }
    3802             : 
    3803           0 :     return CI;
    3804             :   }
    3805             : 
    3806             :   /// Add an entry to the switch instruction.
    3807             :   /// Note:
    3808             :   /// This action invalidates case_end(). Old case_end() iterator will
    3809             :   /// point to the added case.
    3810             :   void addCase(ConstantInt *OnVal, BasicBlock *Dest);
    3811             : 
    3812          32 :   /// This method removes the specified case and its successor from the switch
    3813          32 :   /// instruction. Note that this operation may reorder the remaining cases at
    3814             :   /// index idx and above.
    3815             :   /// Note:
    3816         110 :   /// This action invalidates iterators for all cases following the one removed,
    3817         206 :   /// including the case_end() iterator. It returns an iterator for the next
    3818          64 :   /// case.
    3819             :   CaseIt removeCase(CaseIt I);
    3820         181 : 
    3821        3549 :   unsigned getNumSuccessors() const { return getNumOperands()/2; }
    3822        1815 :   BasicBlock *getSuccessor(unsigned idx) const {
    3823         181 :     assert(idx < getNumSuccessors() &&"Successor idx out of range for switch!");
    3824      161551 :     return cast<BasicBlock>(getOperand(idx*2+1));
    3825         206 :   }
    3826          96 :   void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
    3827          32 :     assert(idx < getNumSuccessors() && "Successor # out of range for switch!");
    3828       50446 :     setOperand(idx * 2 + 1, NewSucc);
    3829             :   }
    3830           8 : 
    3831          14 :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    3832             :   static bool classof(const Instruction *I) {
    3833          15 :     return I->getOpcode() == Instruction::Switch;
    3834             :   }
    3835             :   static bool classof(const Value *V) {
    3836           0 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    3837             :   }
    3838             : };
    3839             : 
    3840             : template <>
    3841             : struct OperandTraits<SwitchInst> : public HungoffOperandTraits<2> {
    3842          27 : };
    3843             : 
    3844     1156631 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(SwitchInst, Value)
    3845             : 
    3846             : //===----------------------------------------------------------------------===//
    3847             : //                             IndirectBrInst Class
    3848          64 : //===----------------------------------------------------------------------===//
    3849             : 
    3850          41 : //===---------------------------------------------------------------------------
    3851             : /// Indirect Branch Instruction.
    3852        1654 : ///
    3853           0 : class IndirectBrInst : public TerminatorInst {
    3854             :   unsigned ReservedSpace;
    3855      807626 : 
    3856          68 :   // Operand[0]   = Address to jump to
    3857           0 :   // Operand[n+1] = n-th destination
    3858     1555060 :   IndirectBrInst(const IndirectBrInst &IBI);
    3859             : 
    3860             :   /// Create a new indirectbr instruction, specifying an
    3861           0 :   /// Address to jump to.  The number of expected destinations can be specified
    3862        6247 :   /// here to make memory allocation more efficient.  This constructor can also
    3863             :   /// autoinsert before another instruction.
    3864             :   IndirectBrInst(Value *Address, unsigned NumDests, Instruction *InsertBefore);
    3865             : 
    3866           0 :   /// Create a new indirectbr instruction, specifying an
    3867           0 :   /// Address to jump to.  The number of expected destinations can be specified
    3868         414 :   /// here to make memory allocation more efficient.  This constructor also
    3869             :   /// autoinserts at the end of the specified BasicBlock.
    3870       47199 :   IndirectBrInst(Value *Address, unsigned NumDests, BasicBlock *InsertAtEnd);
    3871             : 
    3872        9795 :   // allocate space for exactly zero operands
    3873             :   void *operator new(size_t s) {
    3874         461 :     return User::operator new(s);
    3875             :   }
    3876         181 : 
    3877         461 :   void init(Value *Address, unsigned NumDests);
    3878     3110604 :   void growOperands();
    3879             : 
    3880             : protected:
    3881             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    3882       85449 :   friend class Instruction;
    3883             : 
    3884             :   IndirectBrInst *cloneImpl() const;
    3885          28 : 
    3886             : public:
    3887             :   /// Iterator type that casts an operand to a basic block.
    3888      140108 :   ///
    3889             :   /// This only makes sense because the successors are stored as adjacent
    3890      229936 :   /// operands for indirectbr instructions.
    3891             :   struct succ_op_iterator
    3892             :       : iterator_adaptor_base<succ_op_iterator, value_op_iterator,
    3893             :                               std::random_access_iterator_tag, BasicBlock *,
    3894             :                               ptrdiff_t, BasicBlock *, BasicBlock *> {
    3895             :     explicit succ_op_iterator(value_op_iterator I) : iterator_adaptor_base(I) {}
    3896       87234 : 
    3897           0 :     BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
    3898             :     BasicBlock *operator->() const { return operator*(); }
    3899             :   };
    3900             : 
    3901             :   /// The const version of `succ_op_iterator`.
    3902             :   struct const_succ_op_iterator
    3903             :       : iterator_adaptor_base<const_succ_op_iterator, const_value_op_iterator,
    3904           0 :                               std::random_access_iterator_tag,
    3905             :                               const BasicBlock *, ptrdiff_t, const BasicBlock *,
    3906             :                               const BasicBlock *> {
    3907             :     explicit const_succ_op_iterator(const_value_op_iterator I)
    3908      587877 :         : iterator_adaptor_base(I) {}
    3909             : 
    3910             :     const BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
    3911             :     const BasicBlock *operator->() const { return operator*(); }
    3912             :   };
    3913             : 
    3914             :   static IndirectBrInst *Create(Value *Address, unsigned NumDests,
    3915             :                                 Instruction *InsertBefore = nullptr) {
    3916         461 :     return new IndirectBrInst(Address, NumDests, InsertBefore);
    3917             :   }
    3918             : 
    3919             :   static IndirectBrInst *Create(Value *Address, unsigned NumDests,
    3920             :                                 BasicBlock *InsertAtEnd) {
    3921             :     return new IndirectBrInst(Address, NumDests, InsertAtEnd);
    3922             :   }
    3923             : 
    3924             :   /// Provide fast operand accessors.
    3925             :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
    3926             : 
    3927             :   // Accessor Methods for IndirectBrInst instruction.
    3928          28 :   Value *getAddress() { return getOperand(0); }
    3929             :   const Value *getAddress() const { return getOperand(0); }
    3930           1 :   void setAddress(Value *V) { setOperand(0, V); }
    3931             : 
    3932             :   /// return the number of possible destinations in this
    3933             :   /// indirectbr instruction.
    3934          40 :   unsigned getNumDestinations() const { return getNumOperands()-1; }
    3935             : 
    3936             :   /// Return the specified destination.
    3937             :   BasicBlock *getDestination(unsigned i) { return getSuccessor(i); }
    3938             :   const BasicBlock *getDestination(unsigned i) const { return getSuccessor(i); }
    3939             : 
    3940             :   /// Add a destination.
    3941             :   ///
    3942             :   void addDestination(BasicBlock *Dest);
    3943             : 
    3944             :   /// This method removes the specified successor from the
    3945             :   /// indirectbr instruction.
    3946           0 :   void removeDestination(unsigned i);
    3947           0 : 
    3948         114 :   unsigned getNumSuccessors() const { return getNumOperands()-1; }
    3949             :   BasicBlock *getSuccessor(unsigned i) const {
    3950         432 :     return cast<BasicBlock>(getOperand(i+1));
    3951             :   }
    3952             :   void setSuccessor(unsigned i, BasicBlock *NewSucc) {
    3953             :     setOperand(i + 1, NewSucc);
    3954             :   }
    3955             : 
    3956             :   iterator_range<succ_op_iterator> successors() {
    3957             :     return make_range(succ_op_iterator(std::next(value_op_begin())),
    3958          18 :                       succ_op_iterator(value_op_end()));
    3959             :   }
    3960             : 
    3961             :   iterator_range<const_succ_op_iterator> successors() const {
    3962             :     return make_range(const_succ_op_iterator(std::next(value_op_begin())),
    3963           1 :                       const_succ_op_iterator(value_op_end()));
    3964             :   }
    3965             : 
    3966             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    3967             :   static bool classof(const Instruction *I) {
    3968           0 :     return I->getOpcode() == Instruction::IndirectBr;
    3969             :   }
    3970             :   static bool classof(const Value *V) {
    3971             :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    3972             :   }
    3973             : };
    3974             : 
    3975             : template <>
    3976             : struct OperandTraits<IndirectBrInst> : public HungoffOperandTraits<1> {
    3977             : };
    3978             : 
    3979        1217 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(IndirectBrInst, Value)
    3980             : 
    3981           4 : //===----------------------------------------------------------------------===//
    3982       13177 : //                               InvokeInst Class
    3983             : //===----------------------------------------------------------------------===//
    3984       18567 : 
    3985           6 : /// Invoke instruction.  The SubclassData field is used to hold the
    3986         797 : /// calling convention of the call.
    3987           0 : ///
    3988             : class InvokeInst : public CallBase<InvokeInst> {
    3989             :   friend class OperandBundleUser<InvokeInst, User::op_iterator>;
    3990             : 
    3991             :   InvokeInst(const InvokeInst &BI);
    3992             : 
    3993             :   /// Construct an InvokeInst given a range of arguments.
    3994          97 :   ///
    3995             :   /// Construct an InvokeInst from a range of arguments
    3996      120961 :   inline InvokeInst(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
    3997             :                     ArrayRef<Value *> Args, ArrayRef<OperandBundleDef> Bundles,
    3998           8 :                     unsigned Values, const Twine &NameStr,
    3999             :                     Instruction *InsertBefore)
    4000             :       : InvokeInst(cast<FunctionType>(
    4001           0 :                        cast<PointerType>(Func->getType())->getElementType()),
    4002        2311 :                    Func, IfNormal, IfException, Args, Bundles, Values, NameStr,
    4003             :                    InsertBefore) {}
    4004             : 
    4005             :   inline InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
    4006             :                     BasicBlock *IfException, ArrayRef<Value *> Args,
    4007             :                     ArrayRef<OperandBundleDef> Bundles, unsigned Values,
    4008             :                     const Twine &NameStr, Instruction *InsertBefore);
    4009             :   /// Construct an InvokeInst given a range of arguments.
    4010           0 :   ///
    4011             :   /// Construct an InvokeInst from a range of arguments
    4012      366754 :   inline InvokeInst(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
    4013       37134 :                     ArrayRef<Value *> Args, ArrayRef<OperandBundleDef> Bundles,
    4014          20 :                     unsigned Values, const Twine &NameStr,
    4015             :                     BasicBlock *InsertAtEnd);
    4016             : 
    4017             : 
    4018             :   void init(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
    4019             :             ArrayRef<Value *> Args, ArrayRef<OperandBundleDef> Bundles,
    4020           0 :             const Twine &NameStr) {
    4021         109 :     init(cast<FunctionType>(
    4022             :              cast<PointerType>(Func->getType())->getElementType()),
    4023             :          Func, IfNormal, IfException, Args, Bundles, NameStr);
    4024             :   }
    4025         766 : 
    4026             :   void init(FunctionType *FTy, Value *Func, BasicBlock *IfNormal,
    4027             :             BasicBlock *IfException, ArrayRef<Value *> Args,
    4028             :             ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr);
    4029             : 
    4030             : protected:
    4031        3905 :   // Note: Instruction needs to be a friend here to call cloneImpl.
    4032           0 :   friend class Instruction;
    4033             : 
    4034             :   InvokeInst *cloneImpl() const;
    4035             : 
    4036             : public:
    4037             :   static constexpr int ArgOffset = 3;
    4038             :   static InvokeInst *Create(Value *Func, BasicBlock *IfNormal,
    4039             :                             BasicBlock *IfException, ArrayRef<Value *> Args,
    4040             :                             const Twine &NameStr,
    4041             :                             Instruction *InsertBefore = nullptr) {
    4042          34 :     return Create(cast<FunctionType>(
    4043         423 :                       cast<PointerType>(Func->getType())->getElementType()),
    4044             :                   Func, IfNormal, IfException, Args, None, NameStr,
    4045             :                   InsertBefore);
    4046             :   }
    4047             : 
    4048             :   static InvokeInst *Create(Value *Func, BasicBlock *IfNormal,
    4049             :                             BasicBlock *IfException, ArrayRef<Value *> Args,
    4050             :                             ArrayRef<OperandBundleDef> Bundles = None,
    4051             :                             const Twine &NameStr = "",
    4052             :                             Instruction *InsertBefore = nullptr) {
    4053         250 :     return Create(cast<FunctionType>(
    4054             :                       cast<PointerType>(Func->getType())->getElementType()),
    4055             :                   Func, IfNormal, IfException, Args, Bundles, NameStr,
    4056             :                   InsertBefore);
    4057             :   }
    4058             : 
    4059             :   static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
    4060             :                             BasicBlock *IfException, ArrayRef<Value *> Args,
    4061             :                             const Twine &NameStr,
    4062             :                             Instruction *InsertBefore = nullptr) {
    4063             :     unsigned Values = unsigned(Args.size()) + 3;
    4064             :     return new (Values) InvokeInst(Ty, Func, IfNormal, IfException, Args, None,
    4065             :                                    Values, NameStr, InsertBefore);
    4066             :   }
    4067             : 
    4068        2281 :   static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
    4069             :                             BasicBlock *IfException, ArrayRef<Value *> Args,
    4070             :                             ArrayRef<OperandBundleDef> Bundles = None,
    4071             :                             const Twine &NameStr = "",
    4072           3 :                             Instruction *InsertBefore = nullptr) {
    4073        2281 :     unsigned Values = unsigned(Args.size()) + CountBundleInputs(Bundles) + 3;
    4074        2281 :     unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
    4075             : 
    4076             :     return new (Values, DescriptorBytes)
    4077           0 :         InvokeInst(Ty, Func, IfNormal, IfException, Args, Bundles, Values,
    4078        2281 :                    NameStr, InsertBefore);
    4079             :   }
    4080             : 
    4081           3 :   static InvokeInst *Create(Value *Func,
    4082             :                             BasicBlock *IfNormal, BasicBlock *IfException,
    4083           6 :                             ArrayRef<Value *> Args, const Twine &NameStr,
    4084             :                             BasicBlock *InsertAtEnd) {
    4085      125202 :     unsigned Values = unsigned(Args.size()) + 3;
    4086             :     return new (Values) InvokeInst(Func, IfNormal, IfException, Args, None,
    4087           2 :                                    Values, NameStr, InsertAtEnd);
    4088             :   }
    4089             : 
    4090         108 :   static InvokeInst *Create(Value *Func, BasicBlock *IfNormal,
    4091             :                             BasicBlock *IfException, ArrayRef<Value *> Args,
    4092           0 :                             ArrayRef<OperandBundleDef> Bundles,
    4093             :                             const Twine &NameStr, BasicBlock *InsertAtEnd) {
    4094         108 :     unsigned Values = unsigned(Args.size()) + CountBundleInputs(Bundles) + 3;
    4095         108 :     unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
    4096           2 : 
    4097           0 :     return new (Values, DescriptorBytes)
    4098           6 :         InvokeInst(Func, IfNormal, IfException, Args, Bundles, Values, NameStr,
    4099         108 :                    InsertAtEnd);
    4100             :   }
    4101      547567 : 
    4102           2 :   /// Create a clone of \p II with a different set of operand bundles and
    4103           6 :   /// insert it before \p InsertPt.
    4104           6 :   ///
    4105             :   /// The returned invoke instruction is identical to \p II in every way except
    4106           2 :   /// that the operand bundles for the new instruction are set to the operand
    4107             :   /// bundles in \p Bundles.
    4108           6 :   static InvokeInst *Create(InvokeInst *II, ArrayRef<OperandBundleDef> Bundles,
    4109             :                             Instruction *InsertPt = nullptr);
    4110             : 
    4111             :   /// Determine if the call should not perform indirect branch tracking.
    4112             :   bool doesNoCfCheck() const { return hasFnAttr(Attribute::NoCfCheck); }
    4113             : 
    4114             :   /// Determine if the call cannot unwind.
    4115             :   bool doesNotThrow() const { return hasFnAttr(Attribute::NoUnwind); }
    4116      547565 :   void setDoesNotThrow() {
    4117             :     addAttribute(AttributeList::FunctionIndex, Attribute::NoUnwind);
    4118             :   }
    4119           3 : 
    4120             :   /// Return the function called, or null if this is an
    4121      547565 :   /// indirect function invocation.
    4122      547565 :   ///
    4123             :   Function *getCalledFunction() const {
    4124             :     return dyn_cast<Function>(Op<-3>());
    4125             :   }
    4126      547565 : 
    4127             :   /// Get a pointer to the function that is invoked by this
    4128             :   /// instruction
    4129        3423 :   const Value *getCalledValue() const { return Op<-3>(); }
    4130          15 :         Value *getCalledValue()       { return Op<-3>(); }
    4131             : 
    4132             :   /// Set the function called.
    4133             :   void setCalledFunction(Value* Fn) {
    4134           3 :     setCalledFunction(
    4135           9 :         cast<FunctionType>(cast<PointerType>(Fn->getType())->getElementType()),
    4136             :         Fn);
    4137           2 :   }
    4138             :   void setCalledFunction(FunctionType *FTy, Value *Fn) {
    4139           3 :     this->FTy = FTy;
    4140           3 :     assert(FTy == cast<FunctionType>(
    4141             :                       cast<PointerType>(Fn->getType())->getElementType()));
    4142             :     Op<-3>() = Fn;
    4143       58170 :   }
    4144           3 : 
    4145             :   // get*Dest - Return the destination basic blocks...
    4146             :   BasicBlock *getNormalDest() const {
    4147             :     return cast<BasicBlock>(Op<-2>());
    4148             :   }
    4149             :   BasicBlock *getUnwindDest() const {
    4150             :     return cast<BasicBlock>(Op<-1>());
    4151             :   }
    4152           2 :   void setNormalDest(BasicBlock *B) {
    4153          26 :     Op<-2>() = reinterpret_cast<Value*>(B);
    4154      621785 :   }
    4155             :   void setUnwindDest(BasicBlock *B) {
    4156             :     Op<-1>() = reinterpret_cast<Value*>(B);
    4157           2 :   }
    4158      125203 : 
    4159      125201 :   /// Get the landingpad instruction from the landing pad
    4160             :   /// block (the unwind destination).
    4161      267176 :   LandingPadInst *getLandingPadInst() const;
    4162           2 : 
    4163      125201 :   BasicBlock *getSuccessor(unsigned i) const {
    4164             :     assert(i < 2 && "Successor # out of range for invoke!");
    4165             :     return i == 0 ? getNormalDest() : getUnwindDest();
    4166             :   }
    4167             : 
    4168          28 :   void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
    4169             :     assert(idx < 2 && "Successor # out of range for invoke!");
    4170             :     *(&Op<-2>() + idx) = reinterpret_cast<Value*>(NewSucc);
    4171             :   }
    4172           0 : 
    4173             :   unsigned getNumSuccessors() const { return 2; }
    4174             : 
    4175      496991 :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    4176             :   static bool classof(const Instruction *I) {
    4177           0 :     return (I->getOpcode() == Instruction::Invoke);
    4178             :   }
    4179      698251 :   static bool classof(const Value *V) {
    4180     1070103 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    4181           0 :   }
    4182             : 
    4183           0 : private:
    4184             : 
    4185             :   // Shadow Instruction::setInstructionSubclassData with a private forwarding
    4186             :   // method so that subclasses cannot accidentally use it.
    4187           0 :   void setInstructionSubclassData(unsigned short D) {
    4188             :     Instruction::setInstructionSubclassData(D);
    4189             :   }
    4190             : };
    4191        7391 : 
    4192             : template <>
    4193             : struct OperandTraits<CallBase<InvokeInst>>
    4194      706517 :     : public VariadicOperandTraits<CallBase<InvokeInst>, 3> {};
    4195             : 
    4196        2281 : InvokeInst::InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
    4197             :                        BasicBlock *IfException, ArrayRef<Value *> Args,
    4198             :                        ArrayRef<OperandBundleDef> Bundles, unsigned Values,
    4199    23107961 :                        const Twine &NameStr, Instruction *InsertBefore)
    4200           0 :     : CallBase<InvokeInst>(Ty->getReturnType(), Instruction::Invoke,
    4201        2281 :                            OperandTraits<CallBase<InvokeInst>>::op_end(this) -
    4202             :                                Values,
    4203        2281 :                            Values, InsertBefore) {
    4204        2547 :   init(Ty, Func, IfNormal, IfException, Args, Bundles, NameStr);
    4205        2281 : }
    4206             : 
    4207         109 : InvokeInst::InvokeInst(Value *Func, BasicBlock *IfNormal,
    4208       25758 :                        BasicBlock *IfException, ArrayRef<Value *> Args,
    4209             :                        ArrayRef<OperandBundleDef> Bundles, unsigned Values,
    4210         109 :                        const Twine &NameStr, BasicBlock *InsertAtEnd)
    4211           0 :     : CallBase<InvokeInst>(
    4212             :           cast<FunctionType>(
    4213             :               cast<PointerType>(Func->getType())->getElementType())
    4214        2996 :               ->getReturnType(),
    4215           0 :           Instruction::Invoke,
    4216         109 :           OperandTraits<CallBase<InvokeInst>>::op_end(this) - Values, Values,
    4217         109 :           InsertAtEnd) {
    4218         109 :   init(Func, IfNormal, IfException, Args, Bundles, NameStr);
    4219         109 : }
    4220           0 : 
    4221             : 
    4222             : //===----------------------------------------------------------------------===//
    4223           0 : //                              ResumeInst Class
    4224           2 : //===----------------------------------------------------------------------===//
    4225           0 : 
    4226          84 : //===---------------------------------------------------------------------------
    4227           2 : /// Resume the propagation of an exception.
    4228           0 : ///
    4229          10 : class ResumeInst : public TerminatorInst {
    4230             :   ResumeInst(const ResumeInst &RI);
    4231           8 : 
    4232        3677 :   explicit ResumeInst(Value *Exn, Instruction *InsertBefore=nullptr);
    4233           8 :   ResumeInst(Value *Exn, BasicBlock *InsertAtEnd);
    4234           6 : 
    4235           6 : protected:
    4236             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    4237           0 :   friend class Instruction;
    4238             : 
    4239             :   ResumeInst *cloneImpl() const;
    4240             : 
    4241           0 : public:
    4242             :   static ResumeInst *Create(Value *Exn, Instruction *InsertBefore = nullptr) {
    4243       45612 :     return new(1) ResumeInst(Exn, InsertBefore);
    4244      547565 :   }
    4245             : 
    4246             :   static ResumeInst *Create(Value *Exn, BasicBlock *InsertAtEnd) {
    4247      547569 :     return new(1) ResumeInst(Exn, InsertAtEnd);
    4248             :   }
    4249      547565 : 
    4250             :   /// Provide fast operand accessors
    4251      547565 :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
    4252      547565 : 
    4253      619507 :   /// Convenience accessor.
    4254           0 :   Value *getValue() const { return Op<0>(); }
    4255             : 
    4256             :   unsigned getNumSuccessors() const { return 0; }
    4257             : 
    4258             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    4259             :   static bool classof(const Instruction *I) {
    4260           0 :     return I->getOpcode() == Instruction::Resume;
    4261             :   }
    4262           3 :   static bool classof(const Value *V) {
    4263             :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    4264             :   }
    4265           3 : 
    4266             : private:
    4267           3 :   friend TerminatorInst;
    4268             : 
    4269           3 :   BasicBlock *getSuccessor(unsigned idx) const {
    4270           3 :     llvm_unreachable("ResumeInst has no successors!");
    4271      125204 :   }
    4272             : 
    4273           1 :   void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
    4274      125201 :     llvm_unreachable("ResumeInst has no successors!");
    4275             :   }
    4276             : };
    4277             : 
    4278             : template <>
    4279             : struct OperandTraits<ResumeInst> :
    4280      125203 :     public FixedNumOperandTraits<ResumeInst, 1> {
    4281      125201 : };
    4282      125201 : 
    4283      125203 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ResumeInst, Value)
    4284             : 
    4285           2 : //===----------------------------------------------------------------------===//
    4286             : //                         CatchSwitchInst Class
    4287           2 : //===----------------------------------------------------------------------===//
    4288           2 : class CatchSwitchInst : public TerminatorInst {
    4289           2 :   /// The number of operands actually allocated.  NumOperands is
    4290           0 :   /// the number actually in use.
    4291           0 :   unsigned ReservedSpace;
    4292           1 : 
    4293           0 :   // Operand[0] = Outer scope
    4294    23670074 :   // Operand[1] = Unwind block destination
    4295             :   // Operand[n] = BasicBlock to go to on match
    4296             :   CatchSwitchInst(const CatchSwitchInst &CSI);
    4297             : 
    4298           0 :   /// Create a new switch instruction, specifying a
    4299             :   /// default destination.  The number of additional handlers can be specified
    4300             :   /// here to make memory allocation more efficient.
    4301             :   /// This constructor can also autoinsert before another instruction.
    4302             :   CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest,
    4303           0 :                   unsigned NumHandlers, const Twine &NameStr,
    4304           0 :                   Instruction *InsertBefore);
    4305             : 
    4306        1040 :   /// Create a new switch instruction, specifying a
    4307           0 :   /// default destination.  The number of additional handlers can be specified
    4308           0 :   /// here to make memory allocation more efficient.
    4309             :   /// This constructor also autoinserts at the end of the specified BasicBlock.
    4310             :   CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest,
    4311             :                   unsigned NumHandlers, const Twine &NameStr,
    4312         471 :                   BasicBlock *InsertAtEnd);
    4313             : 
    4314             :   // allocate space for exactly zero operands
    4315         458 :   void *operator new(size_t s) { return User::operator new(s); }
    4316             : 
    4317             :   void init(Value *ParentPad, BasicBlock *UnwindDest, unsigned NumReserved);
    4318             :   void growOperands(unsigned Size);
    4319             : 
    4320             : protected:
    4321             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    4322             :   friend class Instruction;
    4323             : 
    4324             :   CatchSwitchInst *cloneImpl() const;
    4325             : 
    4326           0 : public:
    4327             :   static CatchSwitchInst *Create(Value *ParentPad, BasicBlock *UnwindDest,
    4328             :                                  unsigned NumHandlers,
    4329           0 :                                  const Twine &NameStr = "",
    4330             :                                  Instruction *InsertBefore = nullptr) {
    4331             :     return new CatchSwitchInst(ParentPad, UnwindDest, NumHandlers, NameStr,
    4332         432 :                                InsertBefore);
    4333             :   }
    4334             : 
    4335             :   static CatchSwitchInst *Create(Value *ParentPad, BasicBlock *UnwindDest,
    4336           0 :                                  unsigned NumHandlers, const Twine &NameStr,
    4337             :                                  BasicBlock *InsertAtEnd) {
    4338             :     return new CatchSwitchInst(ParentPad, UnwindDest, NumHandlers, NameStr,
    4339             :                                InsertAtEnd);
    4340             :   }
    4341             : 
    4342             :   /// Provide fast operand accessors
    4343             :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
    4344             : 
    4345           2 :   // Accessor Methods for CatchSwitch stmt
    4346             :   Value *getParentPad() const { return getOperand(0); }
    4347             :   void setParentPad(Value *ParentPad) { setOperand(0, ParentPad); }
    4348             : 
    4349             :   // Accessor Methods for CatchSwitch stmt
    4350             :   bool hasUnwindDest() const { return getSubclassDataFromInstruction() & 1; }
    4351             :   bool unwindsToCaller() const { return !hasUnwindDest(); }
    4352             :   BasicBlock *getUnwindDest() const {
    4353         342 :     if (hasUnwindDest())
    4354             :       return cast<BasicBlock>(getOperand(1));
    4355             :     return nullptr;
    4356             :   }
    4357             :   void setUnwindDest(BasicBlock *UnwindDest) {
    4358             :     assert(UnwindDest);
    4359             :     assert(hasUnwindDest());
    4360         132 :     setOperand(1, UnwindDest);
    4361           0 :   }
    4362           2 : 
    4363             :   /// return the number of 'handlers' in this catchswitch
    4364             :   /// instruction, except the default handler
    4365             :   unsigned getNumHandlers() const {
    4366          21 :     if (hasUnwindDest())
    4367           8 :       return getNumOperands() - 2;
    4368          13 :     return getNumOperands() - 1;
    4369             :   }
    4370             : 
    4371             : private:
    4372           8 :   static BasicBlock *handler_helper(Value *V) { return cast<BasicBlock>(V); }
    4373         353 :   static const BasicBlock *handler_helper(const Value *V) {
    4374         353 :     return cast<BasicBlock>(V);
    4375             :   }
    4376             : 
    4377             : public:
    4378           0 :   using DerefFnTy = BasicBlock *(*)(Value *);
    4379           5 :   using handler_iterator = mapped_iterator<op_iterator, DerefFnTy>;
    4380             :   using handler_range = iterator_range<handler_iterator>;
    4381          54 :   using ConstDerefFnTy = const BasicBlock *(*)(const Value *);
    4382             :   using const_handler_iterator =
    4383           2 :       mapped_iterator<const_op_iterator, ConstDerefFnTy>;
    4384             :   using const_handler_range = iterator_range<const_handler_iterator>;
    4385         105 : 
    4386             :   /// Returns an iterator that points to the first handler in CatchSwitchInst.
    4387             :   handler_iterator handler_begin() {
    4388           0 :     op_iterator It = op_begin() + 1;
    4389           0 :     if (hasUnwindDest())
    4390           0 :       ++It;
    4391             :     return handler_iterator(It, DerefFnTy(handler_helper));
    4392             :   }
    4393           0 : 
    4394             :   /// Returns an iterator that points to the first handler in the
    4395             :   /// CatchSwitchInst.
    4396           7 :   const_handler_iterator handler_begin() const {
    4397         340 :     const_op_iterator It = op_begin() + 1;
    4398         338 :     if (hasUnwindDest())
    4399         224 :       ++It;
    4400             :     return const_handler_iterator(It, ConstDerefFnTy(handler_helper));
    4401         154 :   }
    4402         157 : 
    4403             :   /// Returns a read-only iterator that points one past the last
    4404             :   /// handler in the CatchSwitchInst.
    4405        1913 :   handler_iterator handler_end() {
    4406             :     return handler_iterator(op_end(), DerefFnTy(handler_helper));
    4407             :   }
    4408             : 
    4409             :   /// Returns an iterator that points one past the last handler in the
    4410             :   /// CatchSwitchInst.
    4411             :   const_handler_iterator handler_end() const {
    4412           0 :     return const_handler_iterator(op_end(), ConstDerefFnTy(handler_helper));
    4413           0 :   }
    4414           0 : 
    4415             :   /// iteration adapter for range-for loops.
    4416             :   handler_range handlers() {
    4417           5 :     return make_range(handler_begin(), handler_end());
    4418         832 :   }
    4419         339 : 
    4420         733 :   /// iteration adapter for range-for loops.
    4421             :   const_handler_range handlers() const {
    4422             :     return make_range(handler_begin(), handler_end());
    4423             :   }
    4424         844 : 
    4425         145 :   /// Add an entry to the switch instruction...
    4426         145 :   /// Note:
    4427          34 :   /// This action invalidates handler_end(). Old handler_end() iterator will
    4428             :   /// point to the added handler.
    4429             :   void addHandler(BasicBlock *Dest);
    4430           5 : 
    4431           5 :   void removeHandler(handler_iterator HI);
    4432           0 : 
    4433             :   unsigned getNumSuccessors() const { return getNumOperands() - 1; }
    4434          32 :   BasicBlock *getSuccessor(unsigned Idx) const {
    4435          16 :     assert(Idx < getNumSuccessors() &&
    4436         341 :            "Successor # out of range for catchswitch!");
    4437             :     return cast<BasicBlock>(getOperand(Idx + 1));
    4438             :   }
    4439             :   void setSuccessor(unsigned Idx, BasicBlock *NewSucc) {
    4440         788 :     assert(Idx < getNumSuccessors() &&
    4441         788 :            "Successor # out of range for catchswitch!");
    4442         197 :     setOperand(Idx + 1, NewSucc);
    4443         129 :   }
    4444         129 : 
    4445          31 :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    4446             :   static bool classof(const Instruction *I) {
    4447           0 :     return I->getOpcode() == Instruction::CatchSwitch;
    4448             :   }
    4449             :   static bool classof(const Value *V) {
    4450             :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    4451             :   }
    4452         318 : };
    4453         318 : 
    4454          76 : template <>
    4455             : struct OperandTraits<CatchSwitchInst> : public HungoffOperandTraits<2> {};
    4456             : 
    4457        1774 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CatchSwitchInst, Value)
    4458             : 
    4459             : //===----------------------------------------------------------------------===//
    4460             : //                               CleanupPadInst Class
    4461             : //===----------------------------------------------------------------------===//
    4462             : class CleanupPadInst : public FuncletPadInst {
    4463             : private:
    4464             :   explicit CleanupPadInst(Value *ParentPad, ArrayRef<Value *> Args,
    4465             :                           unsigned Values, const Twine &NameStr,
    4466             :                           Instruction *InsertBefore)
    4467        9492 :       : FuncletPadInst(Instruction::CleanupPad, ParentPad, Args, Values,
    4468         516 :                        NameStr, InsertBefore) {}
    4469             :   explicit CleanupPadInst(Value *ParentPad, ArrayRef<Value *> Args,
    4470             :                           unsigned Values, const Twine &NameStr,
    4471        6914 :                           BasicBlock *InsertAtEnd)
    4472           7 :       : FuncletPadInst(Instruction::CleanupPad, ParentPad, Args, Values,
    4473           7 :                        NameStr, InsertAtEnd) {}
    4474             : 
    4475           0 : public:
    4476         516 :   static CleanupPadInst *Create(Value *ParentPad, ArrayRef<Value *> Args = None,
    4477             :                                 const Twine &NameStr = "",
    4478           7 :                                 Instruction *InsertBefore = nullptr) {
    4479         516 :     unsigned Values = 1 + Args.size();
    4480           8 :     return new (Values)
    4481         516 :         CleanupPadInst(ParentPad, Args, Values, NameStr, InsertBefore);
    4482             :   }
    4483             : 
    4484           7 :   static CleanupPadInst *Create(Value *ParentPad, ArrayRef<Value *> Args,
    4485         740 :                                 const Twine &NameStr, BasicBlock *InsertAtEnd) {
    4486         619 :     unsigned Values = 1 + Args.size();
    4487           6 :     return new (Values)
    4488           7 :         CleanupPadInst(ParentPad, Args, Values, NameStr, InsertAtEnd);
    4489             :   }
    4490             : 
    4491       13828 :   /// Methods for support type inquiry through isa, cast, and dyn_cast:
    4492             :   static bool classof(const Instruction *I) {
    4493           0 :     return I->getOpcode() == Instruction::CleanupPad;
    4494             :   }
    4495             :   static bool classof(const Value *V) {
    4496         130 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    4497           2 :   }
    4498           2 : };
    4499           0 : 
    4500             : //===----------------------------------------------------------------------===//
    4501             : //                               CatchPadInst Class
    4502        4290 : //===----------------------------------------------------------------------===//
    4503         392 : class CatchPadInst : public FuncletPadInst {
    4504             : private:
    4505             :   explicit CatchPadInst(Value *CatchSwitch, ArrayRef<Value *> Args,
    4506           2 :                         unsigned Values, const Twine &NameStr,
    4507             :                         Instruction *InsertBefore)
    4508         461 :       : FuncletPadInst(Instruction::CatchPad, CatchSwitch, Args, Values,
    4509        6266 :                        NameStr, InsertBefore) {}
    4510             :   explicit CatchPadInst(Value *CatchSwitch, ArrayRef<Value *> Args,
    4511           2 :                         unsigned Values, const Twine &NameStr,
    4512             :                         BasicBlock *InsertAtEnd)
    4513             :       : FuncletPadInst(Instruction::CatchPad, CatchSwitch, Args, Values,
    4514             :                        NameStr, InsertAtEnd) {}
    4515             : 
    4516             : public:
    4517         461 :   static CatchPadInst *Create(Value *CatchSwitch, ArrayRef<Value *> Args,
    4518             :                               const Twine &NameStr = "",
    4519             :                               Instruction *InsertBefore = nullptr) {
    4520         461 :     unsigned Values = 1 + Args.size();
    4521         328 :     return new (Values)
    4522         461 :         CatchPadInst(CatchSwitch, Args, Values, NameStr, InsertBefore);
    4523           0 :   }
    4524           4 : 
    4525             :   static CatchPadInst *Create(Value *CatchSwitch, ArrayRef<Value *> Args,
    4526           0 :                               const Twine &NameStr, BasicBlock *InsertAtEnd) {
    4527         486 :     unsigned Values = 1 + Args.size();
    4528             :     return new (Values)
    4529             :         CatchPadInst(CatchSwitch, Args, Values, NameStr, InsertAtEnd);
    4530             :   }
    4531             : 
    4532             :   /// Convenience accessors
    4533             :   CatchSwitchInst *getCatchSwitch() const {
    4534             :     return cast<CatchSwitchInst>(Op<-1>());
    4535             :   }
    4536             :   void setCatchSwitch(Value *CatchSwitch) {
    4537             :     assert(CatchSwitch);
    4538           3 :     Op<-1>() = CatchSwitch;
    4539           3 :   }
    4540             : 
    4541           0 :   /// Methods for support type inquiry through isa, cast, and dyn_cast:
    4542         138 :   static bool classof(const Instruction *I) {
    4543           0 :     return I->getOpcode() == Instruction::CatchPad;
    4544             :   }
    4545           0 :   static bool classof(const Value *V) {
    4546             :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    4547           3 :   }
    4548        1547 : };
    4549             : 
    4550           3 : //===----------------------------------------------------------------------===//
    4551             : //                               CatchReturnInst Class
    4552           3 : //===----------------------------------------------------------------------===//
    4553             : 
    4554             : class CatchReturnInst : public TerminatorInst {
    4555             :   CatchReturnInst(const CatchReturnInst &RI);
    4556             :   CatchReturnInst(Value *CatchPad, BasicBlock *BB, Instruction *InsertBefore);
    4557             :   CatchReturnInst(Value *CatchPad, BasicBlock *BB, BasicBlock *InsertAtEnd);
    4558             : 
    4559             :   void init(Value *CatchPad, BasicBlock *BB);
    4560             : 
    4561             : protected:
    4562             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    4563             :   friend class Instruction;
    4564             : 
    4565             :   CatchReturnInst *cloneImpl() const;
    4566             : 
    4567             : public:
    4568             :   static CatchReturnInst *Create(Value *CatchPad, BasicBlock *BB,
    4569             :                                  Instruction *InsertBefore = nullptr) {
    4570             :     assert(CatchPad);
    4571           0 :     assert(BB);
    4572         350 :     return new (2) CatchReturnInst(CatchPad, BB, InsertBefore);
    4573             :   }
    4574             : 
    4575             :   static CatchReturnInst *Create(Value *CatchPad, BasicBlock *BB,
    4576           0 :                                  BasicBlock *InsertAtEnd) {
    4577             :     assert(CatchPad);
    4578         357 :     assert(BB);
    4579             :     return new (2) CatchReturnInst(CatchPad, BB, InsertAtEnd);
    4580             :   }
    4581             : 
    4582           0 :   /// Provide fast operand accessors
    4583             :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
    4584             : 
    4585             :   /// Convenience accessors.
    4586             :   CatchPadInst *getCatchPad() const { return cast<CatchPadInst>(Op<0>()); }
    4587             :   void setCatchPad(CatchPadInst *CatchPad) {
    4588             :     assert(CatchPad);
    4589           0 :     Op<0>() = CatchPad;
    4590             :   }
    4591             : 
    4592             :   BasicBlock *getSuccessor() const { return cast<BasicBlock>(Op<1>()); }
    4593             :   void setSuccessor(BasicBlock *NewSucc) {
    4594             :     assert(NewSucc);
    4595           0 :     Op<1>() = NewSucc;
    4596             :   }
    4597             :   unsigned getNumSuccessors() const { return 1; }
    4598         716 : 
    4599             :   /// Get the parentPad of this catchret's catchpad's catchswitch.
    4600             :   /// The successor block is implicitly a member of this funclet.
    4601             :   Value *getCatchSwitchParentPad() const {
    4602           1 :     return getCatchPad()->getCatchSwitch()->getParentPad();
    4603             :   }
    4604             : 
    4605             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    4606             :   static bool classof(const Instruction *I) {
    4607           0 :     return (I->getOpcode() == Instruction::CatchRet);
    4608             :   }
    4609             :   static bool classof(const Value *V) {
    4610           2 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    4611             :   }
    4612             : 
    4613             : private:
    4614             :   friend TerminatorInst;
    4615             : 
    4616             :   BasicBlock *getSuccessor(unsigned Idx) const {
    4617             :     assert(Idx < getNumSuccessors() && "Successor # out of range for catchret!");
    4618             :     return getSuccessor();
    4619             :   }
    4620             : 
    4621             :   void setSuccessor(unsigned Idx, BasicBlock *B) {
    4622             :     assert(Idx < getNumSuccessors() && "Successor # out of range for catchret!");
    4623             :     setSuccessor(B);
    4624             :   }
    4625             : };
    4626             : 
    4627             : template <>
    4628             : struct OperandTraits<CatchReturnInst>
    4629             :     : public FixedNumOperandTraits<CatchReturnInst, 2> {};
    4630             : 
    4631         466 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CatchReturnInst, Value)
    4632             : 
    4633             : //===----------------------------------------------------------------------===//
    4634             : //                               CleanupReturnInst Class
    4635           0 : //===----------------------------------------------------------------------===//
    4636             : 
    4637             : class CleanupReturnInst : public TerminatorInst {
    4638             : private:
    4639             :   CleanupReturnInst(const CleanupReturnInst &RI);
    4640           0 :   CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, unsigned Values,
    4641             :                     Instruction *InsertBefore = nullptr);
    4642             :   CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, unsigned Values,
    4643             :                     BasicBlock *InsertAtEnd);
    4644             : 
    4645             :   void init(Value *CleanupPad, BasicBlock *UnwindBB);
    4646             : 
    4647             : protected:
    4648             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    4649             :   friend class Instruction;
    4650           0 : 
    4651             :   CleanupReturnInst *cloneImpl() const;
    4652           0 : 
    4653             : public:
    4654         387 :   static CleanupReturnInst *Create(Value *CleanupPad,
    4655           0 :                                    BasicBlock *UnwindBB = nullptr,
    4656             :                                    Instruction *InsertBefore = nullptr) {
    4657             :     assert(CleanupPad);
    4658           0 :     unsigned Values = 1;
    4659         387 :     if (UnwindBB)
    4660             :       ++Values;
    4661         460 :     return new (Values)
    4662        1037 :         CleanupReturnInst(CleanupPad, UnwindBB, Values, InsertBefore);
    4663             :   }
    4664             : 
    4665           7 :   static CleanupReturnInst *Create(Value *CleanupPad, BasicBlock *UnwindBB,
    4666             :                                    BasicBlock *InsertAtEnd) {
    4667             :     assert(CleanupPad);
    4668             :     unsigned Values = 1;
    4669           7 :     if (UnwindBB)
    4670             :       ++Values;
    4671             :     return new (Values)
    4672           7 :         CleanupReturnInst(CleanupPad, UnwindBB, Values, InsertAtEnd);
    4673             :   }
    4674             : 
    4675             :   /// Provide fast operand accessors
    4676             :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
    4677             : 
    4678             :   bool hasUnwindDest() const { return getSubclassDataFromInstruction() & 1; }
    4679             :   bool unwindsToCaller() const { return !hasUnwindDest(); }
    4680             : 
    4681             :   /// Convenience accessor.
    4682             :   CleanupPadInst *getCleanupPad() const {
    4683         652 :     return cast<CleanupPadInst>(Op<0>());
    4684           2 :   }
    4685             :   void setCleanupPad(CleanupPadInst *CleanupPad) {
    4686             :     assert(CleanupPad);
    4687             :     Op<0>() = CleanupPad;
    4688             :   }
    4689           2 : 
    4690             :   unsigned getNumSuccessors() const { return hasUnwindDest() ? 1 : 0; }
    4691             : 
    4692           2 :   BasicBlock *getUnwindDest() const {
    4693         103 :     return hasUnwindDest() ? cast<BasicBlock>(Op<1>()) : nullptr;
    4694             :   }
    4695             :   void setUnwindDest(BasicBlock *NewDest) {
    4696             :     assert(NewDest);
    4697             :     assert(hasUnwindDest());
    4698             :     Op<1>() = NewDest;
    4699             :   }
    4700           8 : 
    4701             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    4702             :   static bool classof(const Instruction *I) {
    4703           0 :     return (I->getOpcode() == Instruction::CleanupRet);
    4704             :   }
    4705           8 :   static bool classof(const Value *V) {
    4706           2 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    4707             :   }
    4708           8 : 
    4709             : private:
    4710             :   friend TerminatorInst;
    4711             : 
    4712             :   BasicBlock *getSuccessor(unsigned Idx) const {
    4713          67 :     assert(Idx == 0);
    4714             :     return getUnwindDest();
    4715             :   }
    4716             : 
    4717             :   void setSuccessor(unsigned Idx, BasicBlock *B) {
    4718           1 :     assert(Idx == 0);
    4719             :     setUnwindDest(B);
    4720             :   }
    4721          54 : 
    4722             :   // Shadow Instruction::setInstructionSubclassData with a private forwarding
    4723           3 :   // method so that subclasses cannot accidentally use it.
    4724        3544 :   void setInstructionSubclassData(unsigned short D) {
    4725             :     Instruction::setInstructionSubclassData(D);
    4726           1 :   }
    4727         964 : };
    4728             : 
    4729             : template <>
    4730             : struct OperandTraits<CleanupReturnInst>
    4731           0 :     : public VariadicOperandTraits<CleanupReturnInst, /*MINARITY=*/1> {};
    4732             : 
    4733         448 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CleanupReturnInst, Value)
    4734          85 : 
    4735             : //===----------------------------------------------------------------------===//
    4736          10 : //                           UnreachableInst Class
    4737           0 : //===----------------------------------------------------------------------===//
    4738             : 
    4739          47 : //===---------------------------------------------------------------------------
    4740             : /// This function has undefined behavior.  In particular, the
    4741             : /// presence of this instruction indicates some higher level knowledge that the
    4742             : /// end of the block cannot be reached.
    4743             : ///
    4744             : class UnreachableInst : public TerminatorInst {
    4745        1495 : protected:
    4746           0 :   // Note: Instruction needs to be a friend here to call cloneImpl.
    4747             :   friend class Instruction;
    4748           0 : 
    4749           0 :   UnreachableInst *cloneImpl() const;
    4750             : 
    4751           0 : public:
    4752          86 :   explicit UnreachableInst(LLVMContext &C, Instruction *InsertBefore = nullptr);
    4753             :   explicit UnreachableInst(LLVMContext &C, BasicBlock *InsertAtEnd);
    4754           0 : 
    4755           0 :   // allocate space for exactly zero operands
    4756             :   void *operator new(size_t s) {
    4757      440345 :     return User::operator new(s, 0);
    4758        3393 :   }
    4759             : 
    4760             :   unsigned getNumSuccessors() const { return 0; }
    4761             : 
    4762             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    4763             :   static bool classof(const Instruction *I) {
    4764          72 :     return I->getOpcode() == Instruction::Unreachable;
    4765             :   }
    4766             :   static bool classof(const Value *V) {
    4767        9394 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    4768      261571 :   }
    4769             : 
    4770             : private:
    4771             :   friend TerminatorInst;
    4772             : 
    4773             :   BasicBlock *getSuccessor(unsigned idx) const {
    4774             :     llvm_unreachable("UnreachableInst has no successors!");
    4775             :   }
    4776             : 
    4777             :   void setSuccessor(unsigned idx, BasicBlock *B) {
    4778             :     llvm_unreachable("UnreachableInst has no successors!");
    4779           0 :   }
    4780             : };
    4781             : 
    4782             : //===----------------------------------------------------------------------===//
    4783             : //                                 TruncInst Class
    4784             : //===----------------------------------------------------------------------===//
    4785        1099 : 
    4786             : /// This class represents a truncation of integer types.
    4787           4 : class TruncInst : public CastInst {
    4788           0 : protected:
    4789             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    4790             :   friend class Instruction;
    4791             : 
    4792           0 :   /// Clone an identical TruncInst
    4793             :   TruncInst *cloneImpl() const;
    4794           0 : 
    4795          23 : public:
    4796             :   /// Constructor with insert-before-instruction semantics
    4797           0 :   TruncInst(
    4798             :     Value *S,                           ///< The value to be truncated
    4799             :     Type *Ty,                           ///< The (smaller) type to truncate to
    4800             :     const Twine &NameStr = "",          ///< A name for the new instruction
    4801             :     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
    4802             :   );
    4803             : 
    4804             :   /// Constructor with insert-at-end-of-block semantics
    4805       11609 :   TruncInst(
    4806             :     Value *S,                     ///< The value to be truncated
    4807           0 :     Type *Ty,                     ///< The (smaller) type to truncate to
    4808           0 :     const Twine &NameStr,         ///< A name for the new instruction
    4809             :     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
    4810           0 :   );
    4811       56545 : 
    4812           0 :   /// Methods for support type inquiry through isa, cast, and dyn_cast:
    4813             :   static bool classof(const Instruction *I) {
    4814           0 :     return I->getOpcode() == Trunc;
    4815             :   }
    4816           0 :   static bool classof(const Value *V) {
    4817      466905 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    4818             :   }
    4819             : };
    4820             : 
    4821       56573 : //===----------------------------------------------------------------------===//
    4822             : //                                 ZExtInst Class
    4823             : //===----------------------------------------------------------------------===//
    4824             : 
    4825             : /// This class represents zero extension of integer types.
    4826             : class ZExtInst : public CastInst {
    4827             : protected:
    4828           0 :   // Note: Instruction needs to be a friend here to call cloneImpl.
    4829             :   friend class Instruction;
    4830             : 
    4831             :   /// Clone an identical ZExtInst
    4832             :   ZExtInst *cloneImpl() const;
    4833             : 
    4834             : public:
    4835          21 :   /// Constructor with insert-before-instruction semantics
    4836             :   ZExtInst(
    4837             :     Value *S,                           ///< The value to be zero extended
    4838           0 :     Type *Ty,                           ///< The type to zero extend to
    4839             :     const Twine &NameStr = "",          ///< A name for the new instruction
    4840           0 :     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
    4841             :   );
    4842             : 
    4843             :   /// Constructor with insert-at-end semantics.
    4844             :   ZExtInst(
    4845             :     Value *S,                     ///< The value to be zero extended
    4846             :     Type *Ty,                     ///< The type to zero extend to
    4847           0 :     const Twine &NameStr,         ///< A name for the new instruction
    4848             :     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
    4849             :   );
    4850      103237 : 
    4851             :   /// Methods for support type inquiry through isa, cast, and dyn_cast:
    4852             :   static bool classof(const Instruction *I) {
    4853         349 :     return I->getOpcode() == ZExt;
    4854             :   }
    4855             :   static bool classof(const Value *V) {
    4856      695345 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    4857             :   }
    4858             : };
    4859             : 
    4860             : //===----------------------------------------------------------------------===//
    4861             : //                                 SExtInst Class
    4862             : //===----------------------------------------------------------------------===//
    4863             : 
    4864             : /// This class represents a sign extension of integer types.
    4865             : class SExtInst : public CastInst {
    4866             : protected:
    4867             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    4868             :   friend class Instruction;
    4869             : 
    4870             :   /// Clone an identical SExtInst
    4871         136 :   SExtInst *cloneImpl() const;
    4872             : 
    4873             : public:
    4874             :   /// Constructor with insert-before-instruction semantics
    4875             :   SExtInst(
    4876             :     Value *S,                           ///< The value to be sign extended
    4877     2079040 :     Type *Ty,                           ///< The type to sign extend to
    4878           0 :     const Twine &NameStr = "",          ///< A name for the new instruction
    4879             :     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
    4880       36120 :   );
    4881             : 
    4882             :   /// Constructor with insert-at-end-of-block semantics
    4883             :   SExtInst(
    4884             :     Value *S,                     ///< The value to be sign extended
    4885             :     Type *Ty,                     ///< The type to sign extend to
    4886           0 :     const Twine &NameStr,         ///< A name for the new instruction
    4887             :     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
    4888             :   );
    4889       57623 : 
    4890             :   /// Methods for support type inquiry through isa, cast, and dyn_cast:
    4891             :   static bool classof(const Instruction *I) {
    4892       18611 :     return I->getOpcode() == SExt;
    4893             :   }
    4894             :   static bool classof(const Value *V) {
    4895       27517 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    4896             :   }
    4897             : };
    4898             : 
    4899             : //===----------------------------------------------------------------------===//
    4900             : //                                 FPTruncInst Class
    4901             : //===----------------------------------------------------------------------===//
    4902             : 
    4903             : /// This class represents a truncation of floating point types.
    4904             : class FPTruncInst : public CastInst {
    4905             : protected:
    4906             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    4907             :   friend class Instruction;
    4908             : 
    4909             :   /// Clone an identical FPTruncInst
    4910             :   FPTruncInst *cloneImpl() const;
    4911             : 
    4912             : public:
    4913             :   /// Constructor with insert-before-instruction semantics
    4914             :   FPTruncInst(
    4915             :     Value *S,                           ///< The value to be truncated
    4916             :     Type *Ty,                           ///< The type to truncate to
    4917             :     const Twine &NameStr = "",          ///< A name for the new instruction
    4918             :     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
    4919       30341 :   );
    4920       30267 : 
    4921             :   /// Constructor with insert-before-instruction semantics
    4922             :   FPTruncInst(
    4923             :     Value *S,                     ///< The value to be truncated
    4924             :     Type *Ty,                     ///< The type to truncate to
    4925           0 :     const Twine &NameStr,         ///< A name for the new instruction
    4926             :     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
    4927             :   );
    4928        2770 : 
    4929             :   /// Methods for support type inquiry through isa, cast, and dyn_cast:
    4930             :   static bool classof(const Instruction *I) {
    4931             :     return I->getOpcode() == FPTrunc;
    4932     2632948 :   }
    4933             :   static bool classof(const Value *V) {
    4934         180 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    4935             :   }
    4936             : };
    4937             : 
    4938             : //===----------------------------------------------------------------------===//
    4939             : //                                 FPExtInst Class
    4940             : //===----------------------------------------------------------------------===//
    4941             : 
    4942             : /// This class represents an extension of floating point types.
    4943             : class FPExtInst : public CastInst {
    4944             : protected:
    4945             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    4946             :   friend class Instruction;
    4947             : 
    4948             :   /// Clone an identical FPExtInst
    4949             :   FPExtInst *cloneImpl() const;
    4950             : 
    4951             : public:
    4952             :   /// Constructor with insert-before-instruction semantics
    4953             :   FPExtInst(
    4954             :     Value *S,                           ///< The value to be extended
    4955             :     Type *Ty,                           ///< The type to extend to
    4956             :     const Twine &NameStr = "",          ///< A name for the new instruction
    4957             :     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
    4958             :   );
    4959       30267 : 
    4960             :   /// Constructor with insert-at-end-of-block semantics
    4961             :   FPExtInst(
    4962             :     Value *S,                     ///< The value to be extended
    4963             :     Type *Ty,                     ///< The type to extend to
    4964           0 :     const Twine &NameStr,         ///< A name for the new instruction
    4965             :     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
    4966             :   );
    4967        6507 : 
    4968             :   /// Methods for support type inquiry through isa, cast, and dyn_cast:
    4969             :   static bool classof(const Instruction *I) {
    4970           0 :     return I->getOpcode() == FPExt;
    4971     2624936 :   }
    4972             :   static bool classof(const Value *V) {
    4973        6248 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    4974             :   }
    4975             : };
    4976      375384 : 
    4977             : //===----------------------------------------------------------------------===//
    4978             : //                                 UIToFPInst Class
    4979             : //===----------------------------------------------------------------------===//
    4980             : 
    4981             : /// This class represents a cast unsigned integer to floating point.
    4982             : class UIToFPInst : public CastInst {
    4983             : protected:
    4984             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    4985             :   friend class Instruction;
    4986             : 
    4987             :   /// Clone an identical UIToFPInst
    4988             :   UIToFPInst *cloneImpl() const;
    4989             : 
    4990             : public:
    4991             :   /// Constructor with insert-before-instruction semantics
    4992             :   UIToFPInst(
    4993             :     Value *S,                           ///< The value to be converted
    4994             :     Type *Ty,                           ///< The type to convert to
    4995             :     const Twine &NameStr = "",          ///< A name for the new instruction
    4996             :     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
    4997             :   );
    4998             : 
    4999             :   /// Constructor with insert-at-end-of-block semantics
    5000             :   UIToFPInst(
    5001             :     Value *S,                     ///< The value to be converted
    5002             :     Type *Ty,                     ///< The type to convert to
    5003           0 :     const Twine &NameStr,         ///< A name for the new instruction
    5004             :     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
    5005             :   );
    5006        8876 : 
    5007             :   /// Methods for support type inquiry through isa, cast, and dyn_cast:
    5008             :   static bool classof(const Instruction *I) {
    5009          63 :     return I->getOpcode() == UIToFP;
    5010             :   }
    5011             :   static bool classof(const Value *V) {
    5012         505 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    5013             :   }
    5014             : };
    5015      390511 : 
    5016             : //===----------------------------------------------------------------------===//
    5017             : //                                 SIToFPInst Class
    5018             : //===----------------------------------------------------------------------===//
    5019             : 
    5020             : /// This class represents a cast from signed integer to floating point.
    5021             : class SIToFPInst : public CastInst {
    5022             : protected:
    5023             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    5024             :   friend class Instruction;
    5025             : 
    5026             :   /// Clone an identical SIToFPInst
    5027             :   SIToFPInst *cloneImpl() const;
    5028             : 
    5029             : public:
    5030             :   /// Constructor with insert-before-instruction semantics
    5031             :   SIToFPInst(
    5032             :     Value *S,                           ///< The value to be converted
    5033             :     Type *Ty,                           ///< The type to convert to
    5034             :     const Twine &NameStr = "",          ///< A name for the new instruction
    5035             :     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
    5036             :   );
    5037             : 
    5038             :   /// Constructor with insert-at-end-of-block semantics
    5039             :   SIToFPInst(
    5040             :     Value *S,                     ///< The value to be converted
    5041             :     Type *Ty,                     ///< The type to convert to
    5042           0 :     const Twine &NameStr,         ///< A name for the new instruction
    5043             :     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
    5044             :   );
    5045        9062 : 
    5046             :   /// Methods for support type inquiry through isa, cast, and dyn_cast:
    5047             :   static bool classof(const Instruction *I) {
    5048          16 :     return I->getOpcode() == SIToFP;
    5049             :   }
    5050             :   static bool classof(const Value *V) {
    5051        4646 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    5052             :   }
    5053             : };
    5054             : 
    5055             : //===----------------------------------------------------------------------===//
    5056             : //                                 FPToUIInst Class
    5057             : //===----------------------------------------------------------------------===//
    5058             : 
    5059             : /// This class represents a cast from floating point to unsigned integer
    5060             : class FPToUIInst  : public CastInst {
    5061             : protected:
    5062             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    5063             :   friend class Instruction;
    5064             : 
    5065             :   /// Clone an identical FPToUIInst
    5066             :   FPToUIInst *cloneImpl() const;
    5067             : 
    5068             : public:
    5069             :   /// Constructor with insert-before-instruction semantics
    5070             :   FPToUIInst(
    5071             :     Value *S,                           ///< The value to be converted
    5072             :     Type *Ty,                           ///< The type to convert to
    5073             :     const Twine &NameStr = "",          ///< A name for the new instruction
    5074             :     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
    5075             :   );
    5076             : 
    5077             :   /// Constructor with insert-at-end-of-block semantics
    5078             :   FPToUIInst(
    5079             :     Value *S,                     ///< The value to be converted
    5080             :     Type *Ty,                     ///< The type to convert to
    5081           0 :     const Twine &NameStr,         ///< A name for the new instruction
    5082             :     BasicBlock *InsertAtEnd       ///< Where to insert the new instruction
    5083             :   );
    5084        3907 : 
    5085             :   /// Methods for support type inquiry through isa, cast, and dyn_cast:
    5086             :   static bool classof(const Instruction *I) {
    5087           0 :     return I->getOpcode() == FPToUI;
    5088        1174 :   }
    5089             :   static bool classof(const Value *V) {
    5090             :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    5091             :   }
    5092             : };
    5093             : 
    5094             : //===----------------------------------------------------------------------===//
    5095             : //                                 FPToSIInst Class
    5096             : //===----------------------------------------------------------------------===//
    5097             : 
    5098             : /// This class represents a cast from floating point to signed integer.
    5099             : class FPToSIInst  : public CastInst {
    5100             : protected:
    5101             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    5102             :   friend class Instruction;
    5103             : 
    5104             :   /// Clone an identical FPToSIInst
    5105             :   FPToSIInst *cloneImpl() const;
    5106             : 
    5107             : public:
    5108             :   /// Constructor with insert-before-instruction semantics
    5109             :   FPToSIInst(
    5110             :     Value *S,                           ///< The value to be converted
    5111             :     Type *Ty,                           ///< The type to convert to
    5112             :     const Twine &NameStr = "",          ///< A name for the new instruction
    5113             :     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
    5114             :   );
    5115             : 
    5116             :   /// Constructor with insert-at-end-of-block semantics
    5117             :   FPToSIInst(
    5118             :     Value *S,                     ///< The value to be converted
    5119             :     Type *Ty,                     ///< The type to convert to
    5120           0 :     const Twine &NameStr,         ///< A name for the new instruction
    5121             :     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
    5122             :   );
    5123        4341 : 
    5124             :   /// Methods for support type inquiry through isa, cast, and dyn_cast:
    5125             :   static bool classof(const Instruction *I) {
    5126          16 :     return I->getOpcode() == FPToSI;
    5127        1174 :   }
    5128             :   static bool classof(const Value *V) {
    5129             :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    5130             :   }
    5131             : };
    5132             : 
    5133             : //===----------------------------------------------------------------------===//
    5134             : //                                 IntToPtrInst Class
    5135             : //===----------------------------------------------------------------------===//
    5136             : 
    5137             : /// This class represents a cast from an integer to a pointer.
    5138             : class IntToPtrInst : public CastInst {
    5139             : public:
    5140             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    5141             :   friend class Instruction;
    5142             : 
    5143             :   /// Constructor with insert-before-instruction semantics
    5144             :   IntToPtrInst(
    5145             :     Value *S,                           ///< The value to be converted
    5146             :     Type *Ty,                           ///< The type to convert to
    5147             :     const Twine &NameStr = "",          ///< A name for the new instruction
    5148             :     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
    5149             :   );
    5150             : 
    5151             :   /// Constructor with insert-at-end-of-block semantics
    5152             :   IntToPtrInst(
    5153             :     Value *S,                     ///< The value to be converted
    5154             :     Type *Ty,                     ///< The type to convert to
    5155             :     const Twine &NameStr,         ///< A name for the new instruction
    5156             :     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
    5157             :   );
    5158             : 
    5159           0 :   /// Clone an identical IntToPtrInst.
    5160             :   IntToPtrInst *cloneImpl() const;
    5161             : 
    5162       28026 :   /// Returns the address space of this instruction's pointer type.
    5163             :   unsigned getAddressSpace() const {
    5164       22792 :     return getType()->getPointerAddressSpace();
    5165             :   }
    5166             : 
    5167             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    5168             :   static bool classof(const Instruction *I) {
    5169           0 :     return I->getOpcode() == IntToPtr;
    5170             :   }
    5171             :   static bool classof(const Value *V) {
    5172      115313 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    5173             :   }
    5174             : };
    5175             : 
    5176             : //===----------------------------------------------------------------------===//
    5177             : //                                 PtrToIntInst Class
    5178             : //===----------------------------------------------------------------------===//
    5179             : 
    5180             : /// This class represents a cast from a pointer to an integer.
    5181             : class PtrToIntInst : public CastInst {
    5182             : protected:
    5183             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    5184             :   friend class Instruction;
    5185             : 
    5186             :   /// Clone an identical PtrToIntInst.
    5187             :   PtrToIntInst *cloneImpl() const;
    5188             : 
    5189             : public:
    5190             :   /// Constructor with insert-before-instruction semantics
    5191             :   PtrToIntInst(
    5192             :     Value *S,                           ///< The value to be converted
    5193           0 :     Type *Ty,                           ///< The type to convert to
    5194             :     const Twine &NameStr = "",          ///< A name for the new instruction
    5195             :     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
    5196             :   );
    5197             : 
    5198             :   /// Constructor with insert-at-end-of-block semantics
    5199             :   PtrToIntInst(
    5200             :     Value *S,                     ///< The value to be converted
    5201             :     Type *Ty,                     ///< The type to convert to
    5202           0 :     const Twine &NameStr,         ///< A name for the new instruction
    5203             :     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
    5204             :   );
    5205       75668 : 
    5206             :   /// Gets the pointer operand.
    5207             :   Value *getPointerOperand() { return getOperand(0); }
    5208             :   /// Gets the pointer operand.
    5209             :   const Value *getPointerOperand() const { return getOperand(0); }
    5210             :   /// Gets the operand index of the pointer operand.
    5211             :   static unsigned getPointerOperandIndex() { return 0U; }
    5212             : 
    5213             :   /// Returns the address space of the pointer operand.
    5214             :   unsigned getPointerAddressSpace() const {
    5215       61647 :     return getPointerOperand()->getType()->getPointerAddressSpace();
    5216             :   }
    5217             : 
    5218             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    5219             :   static bool classof(const Instruction *I) {
    5220           0 :     return I->getOpcode() == PtrToInt;
    5221             :   }
    5222             :   static bool classof(const Value *V) {
    5223      111652 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    5224             :   }
    5225             : };
    5226             : 
    5227             : //===----------------------------------------------------------------------===//
    5228             : //                             BitCastInst Class
    5229             : //===----------------------------------------------------------------------===//
    5230             : 
    5231             : /// This class represents a no-op cast from one type to another.
    5232          91 : class BitCastInst : public CastInst {
    5233             : protected:
    5234             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    5235             :   friend class Instruction;
    5236             : 
    5237             :   /// Clone an identical BitCastInst.
    5238             :   BitCastInst *cloneImpl() const;
    5239             : 
    5240             : public:
    5241             :   /// Constructor with insert-before-instruction semantics
    5242             :   BitCastInst(
    5243             :     Value *S,                           ///< The value to be casted
    5244           0 :     Type *Ty,                           ///< The type to casted to
    5245             :     const Twine &NameStr = "",          ///< A name for the new instruction
    5246             :     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
    5247         612 :   );
    5248             : 
    5249             :   /// Constructor with insert-at-end-of-block semantics
    5250             :   BitCastInst(
    5251           0 :     Value *S,                     ///< The value to be casted
    5252             :     Type *Ty,                     ///< The type to casted to
    5253           0 :     const Twine &NameStr,         ///< A name for the new instruction
    5254             :     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
    5255             :   );
    5256     2710941 : 
    5257             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    5258             :   static bool classof(const Instruction *I) {
    5259           1 :     return I->getOpcode() == BitCast;
    5260             :   }
    5261             :   static bool classof(const Value *V) {
    5262     2300673 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    5263             :   }
    5264             : };
    5265             : 
    5266             : //===----------------------------------------------------------------------===//
    5267             : //                          AddrSpaceCastInst Class
    5268             : //===----------------------------------------------------------------------===//
    5269             : 
    5270             : /// This class represents a conversion between pointers from one address space
    5271             : /// to another.
    5272             : class AddrSpaceCastInst : public CastInst {
    5273             : protected:
    5274             :   // Note: Instruction needs to be a friend here to call cloneImpl.
    5275             :   friend class Instruction;
    5276             : 
    5277             :   /// Clone an identical AddrSpaceCastInst.
    5278             :   AddrSpaceCastInst *cloneImpl() const;
    5279             : 
    5280         237 : public:
    5281             :   /// Constructor with insert-before-instruction semantics
    5282             :   AddrSpaceCastInst(
    5283           0 :     Value *S,                           ///< The value to be casted
    5284             :     Type *Ty,                           ///< The type to casted to
    5285             :     const Twine &NameStr = "",          ///< A name for the new instruction
    5286             :     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
    5287             :   );
    5288             : 
    5289             :   /// Constructor with insert-at-end-of-block semantics
    5290          16 :   AddrSpaceCastInst(
    5291             :     Value *S,                     ///< The value to be casted
    5292           0 :     Type *Ty,                     ///< The type to casted to
    5293             :     const Twine &NameStr,         ///< A name for the new instruction
    5294             :     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
    5295             :   );
    5296        1719 : 
    5297             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
    5298             :   static bool classof(const Instruction *I) {
    5299           0 :     return I->getOpcode() == AddrSpaceCast;
    5300             :   }
    5301           0 :   static bool classof(const Value *V) {
    5302     1377655 :     return isa<Instruction>(V) && classof(cast<Instruction>(V));
    5303             :   }
    5304             : 
    5305             :   /// Gets the pointer operand.
    5306             :   Value *getPointerOperand() {
    5307           0 :     return getOperand(0);
    5308          81 :   }
    5309             : 
    5310          38 :   /// Gets the pointer operand.
    5311           0 :   const Value *getPointerOperand() const {
    5312             :     return getOperand(0);
    5313             :   }
    5314             : 
    5315             :   /// Gets the operand index of the pointer operand.
    5316          97 :   static unsigned getPointerOperandIndex() {
    5317             :     return 0U;
    5318             :   }
    5319             : 
    5320             :   /// Returns the address space of the pointer operand.
    5321             :   unsigned getSrcAddressSpace() const {
    5322         294 :     return getPointerOperand()->getType()->getPointerAddressSpace();
    5323             :   }
    5324             : 
    5325             :   /// Returns the address space of the result.
    5326             :   unsigned getDestAddressSpace() const {
    5327         294 :     return getType()->getPointerAddressSpace();
    5328           8 :   }
    5329             : };
    5330             : 
    5331             : /// A helper function that returns the pointer operand of a load or store
    5332           0 : /// instruction. Returns nullptr if not load or store.
    5333             : inline Value *getLoadStorePointerOperand(Value *V) {
    5334             :   if (auto *Load = dyn_cast<LoadInst>(V))
    5335             :     return Load->getPointerOperand();
    5336             :   if (auto *Store = dyn_cast<StoreInst>(V))
    5337             :     return Store->getPointerOperand();
    5338             :   return nullptr;
    5339             : }
    5340             : 
    5341             : /// A helper function that returns the pointer operand of a load, store
    5342         252 : /// or GEP instruction. Returns nullptr if not load, store, or GEP.
    5343         165 : inline Value *getPointerOperand(Value *V) {
    5344         104 :   if (auto *Ptr = getLoadStorePointerOperand(V))
    5345             :     return Ptr;
    5346             :   if (auto *Gep = dyn_cast<GetElementPtrInst>(V))
    5347             :     return Gep->getPointerOperand();
    5348             :   return nullptr;
    5349             : }
    5350             : 
    5351             : /// A helper function that returns the alignment of load or store instruction.
    5352             : inline unsigned getLoadStoreAlignment(Value *I) {
    5353             :   assert((isa<LoadInst>(I) || isa<StoreInst>(I)) &&
    5354             :          "Expected Load or Store instruction");
    5355             :   if (auto *LI = dyn_cast<LoadInst>(I))
    5356             :     return LI->getAlignment();
    5357             :   return cast<StoreInst>(I)->getAlignment();
    5358             : }
    5359             : 
    5360             : /// A helper function that returns the address space of the pointer operand of
    5361             : /// load or store instruction.
    5362        5500 : inline unsigned getLoadStoreAddressSpace(Value *I) {
    5363             :   assert((isa<LoadInst>(I) || isa<StoreInst>(I)) &&
    5364             :          "Expected Load or Store instruction");
    5365             :   if (auto *LI = dyn_cast<LoadInst>(I))
    5366        3162 :     return LI->getPointerAddressSpace();
    5367        2338 :   return cast<StoreInst>(I)->getPointerAddressSpace();
    5368             : }
    5369             : 
    5370             : } // end namespace llvm
    5371             : 
    5372             : #endif // LLVM_IR_INSTRUCTIONS_H

Generated by: LCOV version 1.13