include/llvm/Instructions.h

   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_INSTRUCTIONS_H
  17 #define LLVM_INSTRUCTIONS_H
  18
  19 #include <iterator>
  20
  21 #include "llvm/InstrTypes.h"
  22 #include "llvm/DerivedTypes.h"
  23 #include "llvm/ParameterAttributes.h"
  24 #include "llvm/BasicBlock.h"
  25 #include "llvm/ADT/SmallVector.h"
  26
  27 namespace llvm {
  28
  29 class ConstantInt;
  30 class PointerType;
  31 class VectorType;
  32 class ConstantRange;
  33 class APInt;
  34
  35 //===----------------------------------------------------------------------===//
  36 //                             AllocationInst Class
  37 //===----------------------------------------------------------------------===//
  38
  39 /// AllocationInst - This class is the common base class of MallocInst and
  40 /// AllocaInst.
  41 ///
  42 class AllocationInst : public UnaryInstruction {
  43 protected:
  44   AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, unsigned Align,
  45                  const std::string &Name = "", Instruction *InsertBefore = 0);
  46   AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, unsigned Align,
  47                  const std::string &Name, BasicBlock *InsertAtEnd);
  48 public:
  49   // Out of line virtual method, so the vtable, etc. has a home.
  50   virtual ~AllocationInst();
  51
  52   /// isArrayAllocation - Return true if there is an allocation size parameter
  53   /// to the allocation instruction that is not 1.
  54   ///
  55   bool isArrayAllocation() const;
  56
  57   /// getArraySize - Get the number of element allocated, for a simple
  58   /// allocation of a single element, this will return a constant 1 value.
  59   ///
  60   const Value *getArraySize() const { return getOperand(0); }
  61   Value *getArraySize() { return getOperand(0); }
  62
  63   /// getType - Overload to return most specific pointer type
  64   ///
  65   const PointerType *getType() const {
  66     return reinterpret_cast<const PointerType*>(Instruction::getType());
  67   }
  68
  69   /// getAllocatedType - Return the type that is being allocated by the
  70   /// instruction.
  71   ///
  72   const Type *getAllocatedType() const;
  73
  74   /// getAlignment - Return the alignment of the memory that is being allocated
  75   /// by the instruction.
  76   ///
  77   unsigned getAlignment() const { return (1u << SubclassData) >> 1; }
  78   void setAlignment(unsigned Align);
  79
  80   virtual Instruction *clone() const = 0;
  81
  82   // Methods for support type inquiry through isa, cast, and dyn_cast:
  83   static inline bool classof(const AllocationInst *) { return true; }
  84   static inline bool classof(const Instruction *I) {
  85     return I->getOpcode() == Instruction::Alloca ||
  86            I->getOpcode() == Instruction::Malloc;
  87   }
  88   static inline bool classof(const Value *V) {
  89     return isa<Instruction>(V) && classof(cast<Instruction>(V));
  90   }
  91 };
  92
  93
  94 //===----------------------------------------------------------------------===//
  95 //                                MallocInst Class
  96 //===----------------------------------------------------------------------===//
  97
  98 /// MallocInst - an instruction to allocated memory on the heap
  99 ///
 100 class MallocInst : public AllocationInst {
 101   MallocInst(const MallocInst &MI);
 102 public:
 103   explicit MallocInst(const Type *Ty, Value *ArraySize = 0,
 104                       const std::string &Name = "",
 105                       Instruction *InsertBefore = 0)
 106     : AllocationInst(Ty, ArraySize, Malloc, 0, Name, InsertBefore) {}
 107   MallocInst(const Type *Ty, Value *ArraySize, const std::string &Name,
 108              BasicBlock *InsertAtEnd)
 109     : AllocationInst(Ty, ArraySize, Malloc, 0, Name, InsertAtEnd) {}
 110
 111   MallocInst(const Type *Ty, const std::string &Name,
 112              Instruction *InsertBefore = 0)
 113     : AllocationInst(Ty, 0, Malloc, 0, Name, InsertBefore) {}
 114   MallocInst(const Type *Ty, const std::string &Name, BasicBlock *InsertAtEnd)
 115     : AllocationInst(Ty, 0, Malloc, 0, Name, InsertAtEnd) {}
 116
 117   MallocInst(const Type *Ty, Value *ArraySize, unsigned Align,
 118              const std::string &Name, BasicBlock *InsertAtEnd)
 119     : AllocationInst(Ty, ArraySize, Malloc, Align, Name, InsertAtEnd) {}
 120   MallocInst(const Type *Ty, Value *ArraySize, unsigned Align,
 121                       const std::string &Name = "",
 122                       Instruction *InsertBefore = 0)
 123     : AllocationInst(Ty, ArraySize, Malloc, Align, Name, InsertBefore) {}
 124
 125   virtual MallocInst *clone() const;
 126
 127   // Methods for support type inquiry through isa, cast, and dyn_cast:
 128   static inline bool classof(const MallocInst *) { return true; }
 129   static inline bool classof(const Instruction *I) {
 130     return (I->getOpcode() == Instruction::Malloc);
 131   }
 132   static inline bool classof(const Value *V) {
 133     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 134   }
 135 };
 136
 137
 138 //===----------------------------------------------------------------------===//
 139 //                                AllocaInst Class
 140 //===----------------------------------------------------------------------===//
 141
 142 /// AllocaInst - an instruction to allocate memory on the stack
 143 ///
 144 class AllocaInst : public AllocationInst {
 145   AllocaInst(const AllocaInst &);
 146 public:
 147   explicit AllocaInst(const Type *Ty, Value *ArraySize = 0,
 148                       const std::string &Name = "",
 149                       Instruction *InsertBefore = 0)
 150     : AllocationInst(Ty, ArraySize, Alloca, 0, Name, InsertBefore) {}
 151   AllocaInst(const Type *Ty, Value *ArraySize, const std::string &Name,
 152              BasicBlock *InsertAtEnd)
 153     : AllocationInst(Ty, ArraySize, Alloca, 0, Name, InsertAtEnd) {}
 154
 155   AllocaInst(const Type *Ty, const std::string &Name,
 156              Instruction *InsertBefore = 0)
 157     : AllocationInst(Ty, 0, Alloca, 0, Name, InsertBefore) {}
 158   AllocaInst(const Type *Ty, const std::string &Name, BasicBlock *InsertAtEnd)
 159     : AllocationInst(Ty, 0, Alloca, 0, Name, InsertAtEnd) {}
 160
 161   AllocaInst(const Type *Ty, Value *ArraySize, unsigned Align,
 162              const std::string &Name = "", Instruction *InsertBefore = 0)
 163     : AllocationInst(Ty, ArraySize, Alloca, Align, Name, InsertBefore) {}
 164   AllocaInst(const Type *Ty, Value *ArraySize, unsigned Align,
 165              const std::string &Name, BasicBlock *InsertAtEnd)
 166     : AllocationInst(Ty, ArraySize, Alloca, Align, Name, InsertAtEnd) {}
 167
 168   virtual AllocaInst *clone() const;
 169
 170   // Methods for support type inquiry through isa, cast, and dyn_cast:
 171   static inline bool classof(const AllocaInst *) { return true; }
 172   static inline bool classof(const Instruction *I) {
 173     return (I->getOpcode() == Instruction::Alloca);
 174   }
 175   static inline bool classof(const Value *V) {
 176     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 177   }
 178 };
 179
 180
 181 //===----------------------------------------------------------------------===//
 182 //                                 FreeInst Class
 183 //===----------------------------------------------------------------------===//
 184
 185 /// FreeInst - an instruction to deallocate memory
 186 ///
 187 class FreeInst : public UnaryInstruction {
 188   void AssertOK();
 189 public:
 190   explicit FreeInst(Value *Ptr, Instruction *InsertBefore = 0);
 191   FreeInst(Value *Ptr, BasicBlock *InsertAfter);
 192
 193   virtual FreeInst *clone() const;
 194
 195   // Accessor methods for consistency with other memory operations
 196   Value *getPointerOperand() { return getOperand(0); }
 197   const Value *getPointerOperand() const { return getOperand(0); }
 198
 199   // Methods for support type inquiry through isa, cast, and dyn_cast:
 200   static inline bool classof(const FreeInst *) { return true; }
 201   static inline bool classof(const Instruction *I) {
 202     return (I->getOpcode() == Instruction::Free);
 203   }
 204   static inline bool classof(const Value *V) {
 205     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 206   }
 207 };
 208
 209
 210 //===----------------------------------------------------------------------===//
 211 //                                LoadInst Class
 212 //===----------------------------------------------------------------------===//
 213
 214 /// LoadInst - an instruction for reading from memory.  This uses the
 215 /// SubclassData field in Value to store whether or not the load is volatile.
 216 ///
 217 class LoadInst : public UnaryInstruction {
 218
 219   LoadInst(const LoadInst &LI)
 220     : UnaryInstruction(LI.getType(), Load, LI.getOperand(0)) {
 221     setVolatile(LI.isVolatile());
 222     setAlignment(LI.getAlignment());
 223
 224 #ifndef NDEBUG
 225     AssertOK();
 226 #endif
 227   }
 228   void AssertOK();
 229 public:
 230   LoadInst(Value *Ptr, const std::string &Name, Instruction *InsertBefore);
 231   LoadInst(Value *Ptr, const std::string &Name, BasicBlock *InsertAtEnd);
 232   LoadInst(Value *Ptr, const std::string &Name, bool isVolatile = false,
 233            Instruction *InsertBefore = 0);
 234   LoadInst(Value *Ptr, const std::string &Name, bool isVolatile, unsigned Align,
 235            Instruction *InsertBefore = 0);
 236   LoadInst(Value *Ptr, const std::string &Name, bool isVolatile,
 237            BasicBlock *InsertAtEnd);
 238   LoadInst(Value *Ptr, const std::string &Name, bool isVolatile, unsigned Align,
 239            BasicBlock *InsertAtEnd);
 240
 241   LoadInst(Value *Ptr, const char *Name, Instruction *InsertBefore);
 242   LoadInst(Value *Ptr, const char *Name, BasicBlock *InsertAtEnd);
 243   explicit LoadInst(Value *Ptr, const char *Name = 0, bool isVolatile = false,
 244                     Instruction *InsertBefore = 0);
 245   LoadInst(Value *Ptr, const char *Name, bool isVolatile,
 246            BasicBlock *InsertAtEnd);
 247
 248   /// isVolatile - Return true if this is a load from a volatile memory
 249   /// location.
 250   ///
 251   bool isVolatile() const { return SubclassData & 1; }
 252
 253   /// setVolatile - Specify whether this is a volatile load or not.
 254   ///
 255   void setVolatile(bool V) {
 256     SubclassData = (SubclassData & ~1) | (V ? 1 : 0);
 257   }
 258
 259   virtual LoadInst *clone() const;
 260
 261   /// getAlignment - Return the alignment of the access that is being performed
 262   ///
 263   unsigned getAlignment() const {
 264     return (1 << (SubclassData>>1)) >> 1;
 265   }
 266
 267   void setAlignment(unsigned Align);
 268
 269   Value *getPointerOperand() { return getOperand(0); }
 270   const Value *getPointerOperand() const { return getOperand(0); }
 271   static unsigned getPointerOperandIndex() { return 0U; }
 272
 273   // Methods for support type inquiry through isa, cast, and dyn_cast:
 274   static inline bool classof(const LoadInst *) { return true; }
 275   static inline bool classof(const Instruction *I) {
 276     return I->getOpcode() == Instruction::Load;
 277   }
 278   static inline bool classof(const Value *V) {
 279     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 280   }
 281 };
 282
 283
 284 //===----------------------------------------------------------------------===//
 285 //                                StoreInst Class
 286 //===----------------------------------------------------------------------===//
 287
 288 /// StoreInst - an instruction for storing to memory
 289 ///
 290 class StoreInst : public Instruction {
 291   void *operator new(size_t, unsigned);  // DO NOT IMPLEMENT
 292
 293   StoreInst(const StoreInst &SI) : Instruction(SI.getType(), Store,
 294                                                &Op<0>(), 2) {
 295     Op<0>() = SI.Op<0>();
 296     Op<1>() = SI.Op<1>();
 297     setVolatile(SI.isVolatile());
 298     setAlignment(SI.getAlignment());
 299
 300 #ifndef NDEBUG
 301     AssertOK();
 302 #endif
 303   }
 304   void AssertOK();
 305 public:
 306   // allocate space for exactly two operands
 307   void *operator new(size_t s) {
 308     return User::operator new(s, 2);
 309   }
 310   StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore);
 311   StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd);
 312   StoreInst(Value *Val, Value *Ptr, bool isVolatile = false,
 313             Instruction *InsertBefore = 0);
 314   StoreInst(Value *Val, Value *Ptr, bool isVolatile,
 315             unsigned Align, Instruction *InsertBefore = 0);
 316   StoreInst(Value *Val, Value *Ptr, bool isVolatile, BasicBlock *InsertAtEnd);
 317   StoreInst(Value *Val, Value *Ptr, bool isVolatile,
 318             unsigned Align, BasicBlock *InsertAtEnd);
 319
 320
 321   /// isVolatile - Return true if this is a load from a volatile memory
 322   /// location.
 323   ///
 324   bool isVolatile() const { return SubclassData & 1; }
 325
 326   /// setVolatile - Specify whether this is a volatile load or not.
 327   ///
 328   void setVolatile(bool V) {
 329     SubclassData = (SubclassData & ~1) | (V ? 1 : 0);
 330   }
 331
 332   /// Transparently provide more efficient getOperand methods.
 333   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 334
 335   /// getAlignment - Return the alignment of the access that is being performed
 336   ///
 337   unsigned getAlignment() const {
 338     return (1 << (SubclassData>>1)) >> 1;
 339   }
 340
 341   void setAlignment(unsigned Align);
 342
 343   virtual StoreInst *clone() const;
 344
 345   Value *getPointerOperand() { return getOperand(1); }
 346   const Value *getPointerOperand() const { return getOperand(1); }
 347   static unsigned getPointerOperandIndex() { return 1U; }
 348
 349   // Methods for support type inquiry through isa, cast, and dyn_cast:
 350   static inline bool classof(const StoreInst *) { return true; }
 351   static inline bool classof(const Instruction *I) {
 352     return I->getOpcode() == Instruction::Store;
 353   }
 354   static inline bool classof(const Value *V) {
 355     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 356   }
 357 };
 358
 359 template <>
 360 struct OperandTraits<StoreInst> : FixedNumOperandTraits<2> {
 361 };
 362
 363 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(StoreInst, Value)
 364
 365 //===----------------------------------------------------------------------===//
 366 //                             GetElementPtrInst Class
 367 //===----------------------------------------------------------------------===//
 368
 369 // checkType - Simple wrapper function to give a better assertion failure
 370 // message on bad indexes for a gep instruction.
 371 //
 372 static inline const Type *checkType(const Type *Ty) {
 373   assert(Ty && "Invalid GetElementPtrInst indices for type!");
 374   return Ty;
 375 }
 376
 377 /// GetElementPtrInst - an instruction for type-safe pointer arithmetic to
 378 /// access elements of arrays and structs
 379 ///
 380 class GetElementPtrInst : public Instruction {
 381   GetElementPtrInst(const GetElementPtrInst &GEPI);
 382   void init(Value *Ptr, Value* const *Idx, unsigned NumIdx,
 383             const std::string &Name);
 384   void init(Value *Ptr, Value *Idx, const std::string &Name);
 385
 386   template<typename InputIterator>
 387   void init(Value *Ptr, InputIterator IdxBegin, InputIterator IdxEnd,
 388             const std::string &Name,
 389             // This argument ensures that we have an iterator we can
 390             // do arithmetic on in constant time
 391             std::random_access_iterator_tag) {
 392     unsigned NumIdx = static_cast<unsigned>(std::distance(IdxBegin, IdxEnd));
 393
 394     if (NumIdx > 0) {
 395       // This requires that the iterator points to contiguous memory.
 396       init(Ptr, &*IdxBegin, NumIdx, Name); // FIXME: for the general case
 397                                      // we have to build an array here
 398     }
 399     else {
 400       init(Ptr, 0, NumIdx, Name);
 401     }
 402   }
 403
 404   /// getIndexedType - Returns the type of the element that would be loaded with
 405   /// a load instruction with the specified parameters.
 406   ///
 407   /// Null is returned if the indices are invalid for the specified
 408   /// pointer type.
 409   ///
 410   static const Type *getIndexedType(const Type *Ptr,
 411                                     Value* const *Idx, unsigned NumIdx);
 412
 413   template<typename InputIterator>
 414   static const Type *getIndexedType(const Type *Ptr,
 415                                     InputIterator IdxBegin,
 416                                     InputIterator IdxEnd,
 417                                     // This argument ensures that we
 418                                     // have an iterator we can do
 419                                     // arithmetic on in constant time
 420                                     std::random_access_iterator_tag) {
 421     unsigned NumIdx = static_cast<unsigned>(std::distance(IdxBegin, IdxEnd));
 422
 423     if (NumIdx > 0)
 424       // This requires that the iterator points to contiguous memory.
 425       return getIndexedType(Ptr, (Value *const *)&*IdxBegin, NumIdx);
 426     else
 427       return getIndexedType(Ptr, (Value *const*)0, NumIdx);
 428   }
 429
 430   /// Constructors - Create a getelementptr instruction with a base pointer an
 431   /// list of indices.  The first ctor can optionally insert before an existing
 432   /// instruction, the second appends the new instruction to the specified
 433   /// BasicBlock.
 434   template<typename InputIterator>
 435   inline GetElementPtrInst(Value *Ptr, InputIterator IdxBegin,
 436                            InputIterator IdxEnd,
 437                            unsigned Values,
 438                            const std::string &Name,
 439                            Instruction *InsertBefore);
 440   template<typename InputIterator>
 441   inline GetElementPtrInst(Value *Ptr,
 442                            InputIterator IdxBegin, InputIterator IdxEnd,
 443                            unsigned Values,
 444                            const std::string &Name, BasicBlock *InsertAtEnd);
 445
 446   /// Constructors - These two constructors are convenience methods because one
 447   /// and two index getelementptr instructions are so common.
 448   GetElementPtrInst(Value *Ptr, Value *Idx, const std::string &Name = "",
 449                     Instruction *InsertBefore = 0);
 450   GetElementPtrInst(Value *Ptr, Value *Idx,
 451                     const std::string &Name, BasicBlock *InsertAtEnd);
 452 public:
 453   template<typename InputIterator>
 454   static GetElementPtrInst *Create(Value *Ptr, InputIterator IdxBegin,
 455                                    InputIterator IdxEnd,
 456                                    const std::string &Name = "",
 457                                    Instruction *InsertBefore = 0) {
 458     typename std::iterator_traits<InputIterator>::difference_type Values =
 459       1 + std::distance(IdxBegin, IdxEnd);
 460     return new(Values)
 461       GetElementPtrInst(Ptr, IdxBegin, IdxEnd, Values, Name, InsertBefore);
 462   }
 463   template<typename InputIterator>
 464   static GetElementPtrInst *Create(Value *Ptr,
 465                                    InputIterator IdxBegin, InputIterator IdxEnd,
 466                                    const std::string &Name,
 467                                    BasicBlock *InsertAtEnd) {
 468     typename std::iterator_traits<InputIterator>::difference_type Values =
 469       1 + std::distance(IdxBegin, IdxEnd);
 470     return new(Values)
 471       GetElementPtrInst(Ptr, IdxBegin, IdxEnd, Values, Name, InsertAtEnd);
 472   }
 473
 474   /// Constructors - These two creators are convenience methods because one
 475   /// index getelementptr instructions are so common.
 476   static GetElementPtrInst *Create(Value *Ptr, Value *Idx,
 477                                    const std::string &Name = "",
 478                                    Instruction *InsertBefore = 0) {
 479     return new(2) GetElementPtrInst(Ptr, Idx, Name, InsertBefore);
 480   }
 481   static GetElementPtrInst *Create(Value *Ptr, Value *Idx,
 482                                    const std::string &Name,
 483                                    BasicBlock *InsertAtEnd) {
 484     return new(2) GetElementPtrInst(Ptr, Idx, Name, InsertAtEnd);
 485   }
 486
 487   virtual GetElementPtrInst *clone() const;
 488
 489   /// Transparently provide more efficient getOperand methods.
 490   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 491
 492   // getType - Overload to return most specific pointer type...
 493   const PointerType *getType() const {
 494     return reinterpret_cast<const PointerType*>(Instruction::getType());
 495   }
 496
 497   /// getIndexedType - Returns the type of the element that would be loaded with
 498   /// a load instruction with the specified parameters.
 499   ///
 500   /// Null is returned if the indices are invalid for the specified
 501   /// pointer type.
 502   ///
 503   template<typename InputIterator>
 504   static const Type *getIndexedType(const Type *Ptr,
 505                                     InputIterator IdxBegin,
 506                                     InputIterator IdxEnd) {
 507     return getIndexedType(Ptr, IdxBegin, IdxEnd,
 508                           typename std::iterator_traits<InputIterator>::
 509                           iterator_category());
 510   }
 511   static const Type *getIndexedType(const Type *Ptr, Value *Idx);
 512
 513   inline op_iterator       idx_begin()       { return op_begin()+1; }
 514   inline const_op_iterator idx_begin() const { return op_begin()+1; }
 515   inline op_iterator       idx_end()         { return op_end(); }
 516   inline const_op_iterator idx_end()   const { return op_end(); }
 517
 518   Value *getPointerOperand() {
 519     return getOperand(0);
 520   }
 521   const Value *getPointerOperand() const {
 522     return getOperand(0);
 523   }
 524   static unsigned getPointerOperandIndex() {
 525     return 0U;                      // get index for modifying correct operand
 526   }
 527
 528   unsigned getNumIndices() const {  // Note: always non-negative
 529     return getNumOperands() - 1;
 530   }
 531
 532   bool hasIndices() const {
 533     return getNumOperands() > 1;
 534   }
 535
 536   /// hasAllZeroIndices - Return true if all of the indices of this GEP are
 537   /// zeros.  If so, the result pointer and the first operand have the same
 538   /// value, just potentially different types.
 539   bool hasAllZeroIndices() const;
 540
 541   /// hasAllConstantIndices - Return true if all of the indices of this GEP are
 542   /// constant integers.  If so, the result pointer and the first operand have
 543   /// a constant offset between them.
 544   bool hasAllConstantIndices() const;
 545
 546
 547   // Methods for support type inquiry through isa, cast, and dyn_cast:
 548   static inline bool classof(const GetElementPtrInst *) { return true; }
 549   static inline bool classof(const Instruction *I) {
 550     return (I->getOpcode() == Instruction::GetElementPtr);
 551   }
 552   static inline bool classof(const Value *V) {
 553     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 554   }
 555 };
 556
 557 template <>
 558 struct OperandTraits<GetElementPtrInst> : VariadicOperandTraits<1> {
 559 };
 560
 561 template<typename InputIterator>
 562 GetElementPtrInst::GetElementPtrInst(Value *Ptr,
 563                                      InputIterator IdxBegin,
 564                                      InputIterator IdxEnd,
 565                                      unsigned Values,
 566                                      const std::string &Name,
 567                                      Instruction *InsertBefore)
 568   : Instruction(PointerType::get(checkType(
 569                                    getIndexedType(Ptr->getType(),
 570                                                   IdxBegin, IdxEnd)),
 571                                  cast<PointerType>(Ptr->getType())
 572                                    ->getAddressSpace()),
 573                 GetElementPtr,
 574                 OperandTraits<GetElementPtrInst>::op_end(this) - Values,
 575                 Values, InsertBefore) {
 576   init(Ptr, IdxBegin, IdxEnd, Name,
 577        typename std::iterator_traits<InputIterator>::iterator_category());
 578 }
 579 template<typename InputIterator>
 580 GetElementPtrInst::GetElementPtrInst(Value *Ptr,
 581                                      InputIterator IdxBegin,
 582                                      InputIterator IdxEnd,
 583                                      unsigned Values,
 584                                      const std::string &Name,
 585                                      BasicBlock *InsertAtEnd)
 586   : Instruction(PointerType::get(checkType(
 587                                    getIndexedType(Ptr->getType(),
 588                                                   IdxBegin, IdxEnd)),
 589                                  cast<PointerType>(Ptr->getType())
 590                                    ->getAddressSpace()),
 591                 GetElementPtr,
 592                 OperandTraits<GetElementPtrInst>::op_end(this) - Values,
 593                 Values, InsertAtEnd) {
 594   init(Ptr, IdxBegin, IdxEnd, Name,
 595        typename std::iterator_traits<InputIterator>::iterator_category());
 596 }
 597
 598
 599 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GetElementPtrInst, Value)
 600
 601
 602 //===----------------------------------------------------------------------===//
 603 //                               ICmpInst Class
 604 //===----------------------------------------------------------------------===//
 605
 606 /// This instruction compares its operands according to the predicate given
 607 /// to the constructor. It only operates on integers or pointers. The operands
 608 /// must be identical types.
 609 /// @brief Represent an integer comparison operator.
 610 class ICmpInst: public CmpInst {
 611 public:
 612   /// @brief Constructor with insert-before-instruction semantics.
 613   ICmpInst(
 614     Predicate pred,  ///< The predicate to use for the comparison
 615     Value *LHS,      ///< The left-hand-side of the expression
 616     Value *RHS,      ///< The right-hand-side of the expression
 617     const std::string &Name = "",  ///< Name of the instruction
 618     Instruction *InsertBefore = 0  ///< Where to insert
 619   ) : CmpInst(Type::Int1Ty, Instruction::ICmp, pred, LHS, RHS, Name,
 620               InsertBefore) {
 621     assert(pred >= CmpInst::FIRST_ICMP_PREDICATE &&
 622            pred <= CmpInst::LAST_ICMP_PREDICATE &&
 623            "Invalid ICmp predicate value");
 624     assert(getOperand(0)->getType() == getOperand(1)->getType() &&
 625           "Both operands to ICmp instruction are not of the same type!");
 626     // Check that the operands are the right type
 627     assert((getOperand(0)->getType()->isInteger() ||
 628             isa<PointerType>(getOperand(0)->getType())) &&
 629            "Invalid operand types for ICmp instruction");
 630   }
 631
 632   /// @brief Constructor with insert-at-block-end semantics.
 633   ICmpInst(
 634     Predicate pred, ///< The predicate to use for the comparison
 635     Value *LHS,     ///< The left-hand-side of the expression
 636     Value *RHS,     ///< The right-hand-side of the expression
 637     const std::string &Name,  ///< Name of the instruction
 638     BasicBlock *InsertAtEnd   ///< Block to insert into.
 639   ) : CmpInst(Type::Int1Ty, Instruction::ICmp, pred, LHS, RHS, Name,
 640               InsertAtEnd) {
 641     assert(pred >= CmpInst::FIRST_ICMP_PREDICATE &&
 642            pred <= CmpInst::LAST_ICMP_PREDICATE &&
 643            "Invalid ICmp predicate value");
 644     assert(getOperand(0)->getType() == getOperand(1)->getType() &&
 645           "Both operands to ICmp instruction are not of the same type!");
 646     // Check that the operands are the right type
 647     assert((getOperand(0)->getType()->isInteger() ||
 648             isa<PointerType>(getOperand(0)->getType())) &&
 649            "Invalid operand types for ICmp instruction");
 650   }
 651
 652   /// For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.
 653   /// @returns the predicate that would be the result if the operand were
 654   /// regarded as signed.
 655   /// @brief Return the signed version of the predicate
 656   Predicate getSignedPredicate() const {
 657     return getSignedPredicate(getPredicate());
 658   }
 659
 660   /// This is a static version that you can use without an instruction.
 661   /// @brief Return the signed version of the predicate.
 662   static Predicate getSignedPredicate(Predicate pred);
 663
 664   /// For example, EQ->EQ, SLE->ULE, UGT->UGT, etc.
 665   /// @returns the predicate that would be the result if the operand were
 666   /// regarded as unsigned.
 667   /// @brief Return the unsigned version of the predicate
 668   Predicate getUnsignedPredicate() const {
 669     return getUnsignedPredicate(getPredicate());
 670   }
 671
 672   /// This is a static version that you can use without an instruction.
 673   /// @brief Return the unsigned version of the predicate.
 674   static Predicate getUnsignedPredicate(Predicate pred);
 675
 676   /// isEquality - Return true if this predicate is either EQ or NE.  This also
 677   /// tests for commutativity.
 678   static bool isEquality(Predicate P) {
 679     return P == ICMP_EQ || P == ICMP_NE;
 680   }
 681
 682   /// isEquality - Return true if this predicate is either EQ or NE.  This also
 683   /// tests for commutativity.
 684   bool isEquality() const {
 685     return isEquality(getPredicate());
 686   }
 687
 688   /// @returns true if the predicate of this ICmpInst is commutative
 689   /// @brief Determine if this relation is commutative.
 690   bool isCommutative() const { return isEquality(); }
 691
 692   /// isRelational - Return true if the predicate is relational (not EQ or NE).
 693   ///
 694   bool isRelational() const {
 695     return !isEquality();
 696   }
 697
 698   /// isRelational - Return true if the predicate is relational (not EQ or NE).
 699   ///
 700   static bool isRelational(Predicate P) {
 701     return !isEquality(P);
 702   }
 703
 704   /// @returns true if the predicate of this ICmpInst is signed, false otherwise
 705   /// @brief Determine if this instruction's predicate is signed.
 706   bool isSignedPredicate() const { return isSignedPredicate(getPredicate()); }
 707
 708   /// @returns true if the predicate provided is signed, false otherwise
 709   /// @brief Determine if the predicate is signed.
 710   static bool isSignedPredicate(Predicate pred);
 711
 712   /// @returns true if the specified compare predicate is
 713   /// true when both operands are equal...
 714   /// @brief Determine if the icmp is true when both operands are equal
 715   static bool isTrueWhenEqual(ICmpInst::Predicate pred) {
 716     return pred == ICmpInst::ICMP_EQ  || pred == ICmpInst::ICMP_UGE ||
 717            pred == ICmpInst::ICMP_SGE || pred == ICmpInst::ICMP_ULE ||
 718            pred == ICmpInst::ICMP_SLE;
 719   }
 720
 721   /// @returns true if the specified compare instruction is
 722   /// true when both operands are equal...
 723   /// @brief Determine if the ICmpInst returns true when both operands are equal
 724   bool isTrueWhenEqual() {
 725     return isTrueWhenEqual(getPredicate());
 726   }
 727
 728   /// Initialize a set of values that all satisfy the predicate with C.
 729   /// @brief Make a ConstantRange for a relation with a constant value.
 730   static ConstantRange makeConstantRange(Predicate pred, const APInt &C);
 731
 732   /// Exchange the two operands to this instruction in such a way that it does
 733   /// not modify the semantics of the instruction. The predicate value may be
 734   /// changed to retain the same result if the predicate is order dependent
 735   /// (e.g. ult).
 736   /// @brief Swap operands and adjust predicate.
 737   void swapOperands() {
 738     SubclassData = getSwappedPredicate();
 739     Op<0>().swap(Op<1>());
 740   }
 741
 742   virtual ICmpInst *clone() const;
 743
 744   // Methods for support type inquiry through isa, cast, and dyn_cast:
 745   static inline bool classof(const ICmpInst *) { return true; }
 746   static inline bool classof(const Instruction *I) {
 747     return I->getOpcode() == Instruction::ICmp;
 748   }
 749   static inline bool classof(const Value *V) {
 750     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 751   }
 752 };
 753
 754 //===----------------------------------------------------------------------===//
 755 //                               FCmpInst Class
 756 //===----------------------------------------------------------------------===//
 757
 758 /// This instruction compares its operands according to the predicate given
 759 /// to the constructor. It only operates on floating point values or packed
 760 /// vectors of floating point values. The operands must be identical types.
 761 /// @brief Represents a floating point comparison operator.
 762 class FCmpInst: public CmpInst {
 763 public:
 764   /// @brief Constructor with insert-before-instruction semantics.
 765   FCmpInst(
 766     Predicate pred,  ///< The predicate to use for the comparison
 767     Value *LHS,      ///< The left-hand-side of the expression
 768     Value *RHS,      ///< The right-hand-side of the expression
 769     const std::string &Name = "",  ///< Name of the instruction
 770     Instruction *InsertBefore = 0  ///< Where to insert
 771   ) : CmpInst(Type::Int1Ty, Instruction::FCmp, pred, LHS, RHS, Name,
 772               InsertBefore) {
 773     assert(pred <= FCmpInst::LAST_FCMP_PREDICATE &&
 774            "Invalid FCmp predicate value");
 775     assert(getOperand(0)->getType() == getOperand(1)->getType() &&
 776            "Both operands to FCmp instruction are not of the same type!");
 777     // Check that the operands are the right type
 778     assert(getOperand(0)->getType()->isFloatingPoint() &&
 779            "Invalid operand types for FCmp instruction");
 780   }
 781
 782   /// @brief Constructor with insert-at-block-end semantics.
 783   FCmpInst(
 784     Predicate pred, ///< The predicate to use for the comparison
 785     Value *LHS,     ///< The left-hand-side of the expression
 786     Value *RHS,     ///< The right-hand-side of the expression
 787     const std::string &Name,  ///< Name of the instruction
 788     BasicBlock *InsertAtEnd   ///< Block to insert into.
 789   ) : CmpInst(Type::Int1Ty, Instruction::FCmp, pred, LHS, RHS, Name,
 790               InsertAtEnd) {
 791     assert(pred <= FCmpInst::LAST_FCMP_PREDICATE &&
 792            "Invalid FCmp predicate value");
 793     assert(getOperand(0)->getType() == getOperand(1)->getType() &&
 794            "Both operands to FCmp instruction are not of the same type!");
 795     // Check that the operands are the right type
 796     assert(getOperand(0)->getType()->isFloatingPoint() &&
 797            "Invalid operand types for FCmp instruction");
 798   }
 799
 800   /// This also tests for commutativity. If isEquality() returns true then
 801   /// the predicate is also commutative. Only the equality predicates are
 802   /// commutative.
 803   /// @returns true if the predicate of this instruction is EQ or NE.
 804   /// @brief Determine if this is an equality predicate.
 805   bool isEquality() const {
 806     return SubclassData == FCMP_OEQ || SubclassData == FCMP_ONE ||
 807            SubclassData == FCMP_UEQ || SubclassData == FCMP_UNE;
 808   }
 809   bool isCommutative() const { return isEquality(); }
 810
 811   /// @returns true if the predicate is relational (not EQ or NE).
 812   /// @brief Determine if this a relational predicate.
 813   bool isRelational() const { return !isEquality(); }
 814
 815   /// Exchange the two operands to this instruction in such a way that it does
 816   /// not modify the semantics of the instruction. The predicate value may be
 817   /// changed to retain the same result if the predicate is order dependent
 818   /// (e.g. ult).
 819   /// @brief Swap operands and adjust predicate.
 820   void swapOperands() {
 821     SubclassData = getSwappedPredicate();
 822     Op<0>().swap(Op<1>());
 823   }
 824
 825   virtual FCmpInst *clone() const;
 826
 827   /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
 828   static inline bool classof(const FCmpInst *) { return true; }
 829   static inline bool classof(const Instruction *I) {
 830     return I->getOpcode() == Instruction::FCmp;
 831   }
 832   static inline bool classof(const Value *V) {
 833     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 834   }
 835 };
 836
 837 //===----------------------------------------------------------------------===//
 838 //                               VICmpInst Class
 839 //===----------------------------------------------------------------------===//
 840
 841 /// This instruction compares its operands according to the predicate given
 842 /// to the constructor. It only operates on vectors of integers.
 843 /// The operands must be identical types.
 844 /// @brief Represents a vector integer comparison operator.
 845 class VICmpInst: public CmpInst {
 846 public:
 847   /// @brief Constructor with insert-before-instruction semantics.
 848   VICmpInst(
 849     Predicate pred,  ///< The predicate to use for the comparison
 850     Value *LHS,      ///< The left-hand-side of the expression
 851     Value *RHS,      ///< The right-hand-side of the expression
 852     const std::string &Name = "",  ///< Name of the instruction
 853     Instruction *InsertBefore = 0  ///< Where to insert
 854   ) : CmpInst(LHS->getType(), Instruction::VICmp, pred, LHS, RHS, Name,
 855               InsertBefore) {
 856     assert(pred >= CmpInst::FIRST_ICMP_PREDICATE &&
 857            pred <= CmpInst::LAST_ICMP_PREDICATE &&
 858            "Invalid VICmp predicate value");
 859     assert(getOperand(0)->getType() == getOperand(1)->getType() &&
 860           "Both operands to VICmp instruction are not of the same type!");
 861   }
 862
 863   /// @brief Constructor with insert-at-block-end semantics.
 864   VICmpInst(
 865     Predicate pred, ///< The predicate to use for the comparison
 866     Value *LHS,     ///< The left-hand-side of the expression
 867     Value *RHS,     ///< The right-hand-side of the expression
 868     const std::string &Name,  ///< Name of the instruction
 869     BasicBlock *InsertAtEnd   ///< Block to insert into.
 870   ) : CmpInst(LHS->getType(), Instruction::VICmp, pred, LHS, RHS, Name,
 871               InsertAtEnd) {
 872     assert(pred >= CmpInst::FIRST_ICMP_PREDICATE &&
 873            pred <= CmpInst::LAST_ICMP_PREDICATE &&
 874            "Invalid VICmp predicate value");
 875     assert(getOperand(0)->getType() == getOperand(1)->getType() &&
 876           "Both operands to VICmp instruction are not of the same type!");
 877   }
 878
 879   /// @brief Return the predicate for this instruction.
 880   Predicate getPredicate() const { return Predicate(SubclassData); }
 881
 882   virtual VICmpInst *clone() const;
 883
 884   // Methods for support type inquiry through isa, cast, and dyn_cast:
 885   static inline bool classof(const VICmpInst *) { return true; }
 886   static inline bool classof(const Instruction *I) {
 887     return I->getOpcode() == Instruction::VICmp;
 888   }
 889   static inline bool classof(const Value *V) {
 890     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 891   }
 892 };
 893
 894 //===----------------------------------------------------------------------===//
 895 //                               VFCmpInst Class
 896 //===----------------------------------------------------------------------===//
 897
 898 /// This instruction compares its operands according to the predicate given
 899 /// to the constructor. It only operates on vectors of floating point values.
 900 /// The operands must be identical types.
 901 /// @brief Represents a vector floating point comparison operator.
 902 class VFCmpInst: public CmpInst {
 903 public:
 904   /// @brief Constructor with insert-before-instruction semantics.
 905   VFCmpInst(
 906     Predicate pred,  ///< The predicate to use for the comparison
 907     Value *LHS,      ///< The left-hand-side of the expression
 908     Value *RHS,      ///< The right-hand-side of the expression
 909     const std::string &Name = "",  ///< Name of the instruction
 910     Instruction *InsertBefore = 0  ///< Where to insert
 911   ) : CmpInst(VectorType::getInteger(cast<VectorType>(LHS->getType())),
 912               Instruction::VFCmp, pred, LHS, RHS, Name, InsertBefore) {
 913     assert(pred <= CmpInst::LAST_FCMP_PREDICATE &&
 914            "Invalid VFCmp predicate value");
 915     assert(getOperand(0)->getType() == getOperand(1)->getType() &&
 916            "Both operands to VFCmp instruction are not of the same type!");
 917   }
 918
 919   /// @brief Constructor with insert-at-block-end semantics.
 920   VFCmpInst(
 921     Predicate pred, ///< The predicate to use for the comparison
 922     Value *LHS,     ///< The left-hand-side of the expression
 923     Value *RHS,     ///< The right-hand-side of the expression
 924     const std::string &Name,  ///< Name of the instruction
 925     BasicBlock *InsertAtEnd   ///< Block to insert into.
 926   ) : CmpInst(VectorType::getInteger(cast<VectorType>(LHS->getType())),
 927               Instruction::VFCmp, pred, LHS, RHS, Name, InsertAtEnd) {
 928     assert(pred <= CmpInst::LAST_FCMP_PREDICATE &&
 929            "Invalid VFCmp predicate value");
 930     assert(getOperand(0)->getType() == getOperand(1)->getType() &&
 931            "Both operands to VFCmp instruction are not of the same type!");
 932   }
 933
 934   /// @brief Return the predicate for this instruction.
 935   Predicate getPredicate() const { return Predicate(SubclassData); }
 936
 937   virtual VFCmpInst *clone() const;
 938
 939   /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
 940   static inline bool classof(const VFCmpInst *) { return true; }
 941   static inline bool classof(const Instruction *I) {
 942     return I->getOpcode() == Instruction::VFCmp;
 943   }
 944   static inline bool classof(const Value *V) {
 945     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 946   }
 947 };
 948
 949 //===----------------------------------------------------------------------===//
 950 //                                 CallInst Class
 951 //===----------------------------------------------------------------------===//
 952 /// CallInst - This class represents a function call, abstracting a target
 953 /// machine's calling convention.  This class uses low bit of the SubClassData
 954 /// field to indicate whether or not this is a tail call.  The rest of the bits
 955 /// hold the calling convention of the call.
 956 ///
 957
 958 class CallInst : public Instruction {
 959   PAListPtr ParamAttrs; ///< parameter attributes for call
 960   CallInst(const CallInst &CI);
 961   void init(Value *Func, Value* const *Params, unsigned NumParams);
 962   void init(Value *Func, Value *Actual1, Value *Actual2);
 963   void init(Value *Func, Value *Actual);
 964   void init(Value *Func);
 965
 966   template<typename InputIterator>
 967   void init(Value *Func, InputIterator ArgBegin, InputIterator ArgEnd,
 968             const std::string &Name,
 969             // This argument ensures that we have an iterator we can
 970             // do arithmetic on in constant time
 971             std::random_access_iterator_tag) {
 972     unsigned NumArgs = (unsigned)std::distance(ArgBegin, ArgEnd);
 973
 974     // This requires that the iterator points to contiguous memory.
 975     init(Func, NumArgs ? &*ArgBegin : 0, NumArgs);
 976     setName(Name);
 977   }
 978
 979   /// Construct a CallInst given a range of arguments.  InputIterator
 980   /// must be a random-access iterator pointing to contiguous storage
 981   /// (e.g. a std::vector<>::iterator).  Checks are made for
 982   /// random-accessness but not for contiguous storage as that would
 983   /// incur runtime overhead.
 984   /// @brief Construct a CallInst from a range of arguments
 985   template<typename InputIterator>
 986   CallInst(Value *Func, InputIterator ArgBegin, InputIterator ArgEnd,
 987            const std::string &Name, Instruction *InsertBefore);
 988
 989   /// Construct a CallInst given a range of arguments.  InputIterator
 990   /// must be a random-access iterator pointing to contiguous storage
 991   /// (e.g. a std::vector<>::iterator).  Checks are made for
 992   /// random-accessness but not for contiguous storage as that would
 993   /// incur runtime overhead.
 994   /// @brief Construct a CallInst from a range of arguments
 995   template<typename InputIterator>
 996   inline CallInst(Value *Func, InputIterator ArgBegin, InputIterator ArgEnd,
 997                   const std::string &Name, BasicBlock *InsertAtEnd);
 998
 999   CallInst(Value *F, Value *Actual, const std::string& Name,
1000            Instruction *InsertBefore);
1001   CallInst(Value *F, Value *Actual, const std::string& Name,
1002            BasicBlock *InsertAtEnd);
1003   explicit CallInst(Value *F, const std::string &Name,
1004                     Instruction *InsertBefore);
1005   CallInst(Value *F, const std::string &Name, BasicBlock *InsertAtEnd);
1006 public:
1007   template<typename InputIterator>
1008   static CallInst *Create(Value *Func,
1009                           InputIterator ArgBegin, InputIterator ArgEnd,
1010                           const std::string &Name = "",
1011                           Instruction *InsertBefore = 0) {
1012     return new((unsigned)(ArgEnd - ArgBegin + 1))
1013       CallInst(Func, ArgBegin, ArgEnd, Name, InsertBefore);
1014   }
1015   template<typename InputIterator>
1016   static CallInst *Create(Value *Func,
1017                           InputIterator ArgBegin, InputIterator ArgEnd,
1018                           const std::string &Name, BasicBlock *InsertAtEnd) {
1019     return new((unsigned)(ArgEnd - ArgBegin + 1))
1020       CallInst(Func, ArgBegin, ArgEnd, Name, InsertAtEnd);
1021   }
1022   static CallInst *Create(Value *F, Value *Actual, const std::string& Name = "",
1023                           Instruction *InsertBefore = 0) {
1024     return new(2) CallInst(F, Actual, Name, InsertBefore);
1025   }
1026   static CallInst *Create(Value *F, Value *Actual, const std::string& Name,
1027                           BasicBlock *InsertAtEnd) {
1028     return new(2) CallInst(F, Actual, Name, InsertAtEnd);
1029   }
1030   static CallInst *Create(Value *F, const std::string &Name = "",
1031                           Instruction *InsertBefore = 0) {
1032     return new(1) CallInst(F, Name, InsertBefore);
1033   }
1034   static CallInst *Create(Value *F, const std::string &Name,
1035                           BasicBlock *InsertAtEnd) {
1036     return new(1) CallInst(F, Name, InsertAtEnd);
1037   }
1038
1039   ~CallInst();
1040
1041   virtual CallInst *clone() const;
1042
1043   /// Provide fast operand accessors
1044   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1045
1046   bool isTailCall() const           { return SubclassData & 1; }
1047   void setTailCall(bool isTailCall = true) {
1048     SubclassData = (SubclassData & ~1) | unsigned(isTailCall);
1049   }
1050
1051   /// getCallingConv/setCallingConv - Get or set the calling convention of this
1052   /// function call.
1053   unsigned getCallingConv() const { return SubclassData >> 1; }
1054   void setCallingConv(unsigned CC) {
1055     SubclassData = (SubclassData & 1) | (CC << 1);
1056   }
1057
1058   /// getParamAttrs - Return the parameter attributes for this call.
1059   ///
1060   const PAListPtr &getParamAttrs() const { return ParamAttrs; }
1061
1062   /// setParamAttrs - Sets the parameter attributes for this call.
1063   void setParamAttrs(const PAListPtr &Attrs) { ParamAttrs = Attrs; }
1064
1065   /// addParamAttr - adds the attribute to the list of attributes.
1066   void addParamAttr(unsigned i, ParameterAttributes attr);
1067
1068   /// removeParamAttr - removes the attribute from the list of attributes.
1069   void removeParamAttr(unsigned i, ParameterAttributes attr);
1070
1071   /// @brief Determine whether the call or the callee has the given attribute.
1072   bool paramHasAttr(unsigned i, unsigned attr) const;
1073
1074   /// @brief Extract the alignment for a call or parameter (0=unknown).
1075   unsigned getParamAlignment(unsigned i) const {
1076     return ParamAttrs.getParamAlignment(i);
1077   }
1078
1079   /// @brief Determine if the call does not access memory.
1080   bool doesNotAccessMemory() const {
1081     return paramHasAttr(0, ParamAttr::ReadNone);
1082   }
1083   void setDoesNotAccessMemory(bool doesNotAccessMemory = true) {
1084     if (doesNotAccessMemory) addParamAttr(0, ParamAttr::ReadNone);
1085     else removeParamAttr(0, ParamAttr::ReadNone);
1086   }
1087
1088   /// @brief Determine if the call does not access or only reads memory.
1089   bool onlyReadsMemory() const {
1090     return doesNotAccessMemory() || paramHasAttr(0, ParamAttr::ReadOnly);
1091   }
1092   void setOnlyReadsMemory(bool onlyReadsMemory = true) {
1093     if (onlyReadsMemory) addParamAttr(0, ParamAttr::ReadOnly);
1094     else removeParamAttr(0, ParamAttr::ReadOnly | ParamAttr::ReadNone);
1095   }
1096
1097   /// @brief Determine if the call cannot return.
1098   bool doesNotReturn() const {
1099     return paramHasAttr(0, ParamAttr::NoReturn);
1100   }
1101   void setDoesNotReturn(bool doesNotReturn = true) {
1102     if (doesNotReturn) addParamAttr(0, ParamAttr::NoReturn);
1103     else removeParamAttr(0, ParamAttr::NoReturn);
1104   }
1105
1106   /// @brief Determine if the call cannot unwind.
1107   bool doesNotThrow() const {
1108     return paramHasAttr(0, ParamAttr::NoUnwind);
1109   }
1110   void setDoesNotThrow(bool doesNotThrow = true) {
1111     if (doesNotThrow) addParamAttr(0, ParamAttr::NoUnwind);
1112     else removeParamAttr(0, ParamAttr::NoUnwind);
1113   }
1114
1115   /// @brief Determine if the call returns a structure through first
1116   /// pointer argument.
1117   bool hasStructRetAttr() const {
1118     // Be friendly and also check the callee.
1119     return paramHasAttr(1, ParamAttr::StructRet);
1120   }
1121
1122   /// @brief Determine if any call argument is an aggregate passed by value.
1123   bool hasByValArgument() const {
1124     return ParamAttrs.hasAttrSomewhere(ParamAttr::ByVal);
1125   }
1126
1127   /// getCalledFunction - Return the function being called by this instruction
1128   /// if it is a direct call.  If it is a call through a function pointer,
1129   /// return null.
1130   Function *getCalledFunction() const {
1131     return dyn_cast<Function>(getOperand(0));
1132   }
1133
1134   /// getCalledValue - Get a pointer to the function that is invoked by this
1135   /// instruction
1136   const Value *getCalledValue() const { return getOperand(0); }
1137         Value *getCalledValue()       { return getOperand(0); }
1138
1139   // Methods for support type inquiry through isa, cast, and dyn_cast:
1140   static inline bool classof(const CallInst *) { return true; }
1141   static inline bool classof(const Instruction *I) {
1142     return I->getOpcode() == Instruction::Call;
1143   }
1144   static inline bool classof(const Value *V) {
1145     return isa<Instruction>(V) && classof(cast<Instruction>(V));
1146   }
1147 };
1148
1149 template <>
1150 struct OperandTraits<CallInst> : VariadicOperandTraits<1> {
1151 };
1152
1153 template<typename InputIterator>
1154 CallInst::CallInst(Value *Func, InputIterator ArgBegin, InputIterator ArgEnd,
1155                    const std::string &Name, BasicBlock *InsertAtEnd)
1156   : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
1157                                    ->getElementType())->getReturnType(),
1158                 Instruction::Call,
1159                 OperandTraits<CallInst>::op_end(this) - (ArgEnd - ArgBegin + 1),
1160                 (unsigned)(ArgEnd - ArgBegin + 1), InsertAtEnd) {
1161   init(Func, ArgBegin, ArgEnd, Name,
1162        typename std::iterator_traits<InputIterator>::iterator_category());
1163 }
1164
1165 template<typename InputIterator>
1166 CallInst::CallInst(Value *Func, InputIterator ArgBegin, InputIterator ArgEnd,
1167                    const std::string &Name, Instruction *InsertBefore)
1168   : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
1169                                    ->getElementType())->getReturnType(),
1170                 Instruction::Call,
1171                 OperandTraits<CallInst>::op_end(this) - (ArgEnd - ArgBegin + 1),
1172                 (unsigned)(ArgEnd - ArgBegin + 1), InsertBefore) {
1173   init(Func, ArgBegin, ArgEnd, Name,
1174        typename std::iterator_traits<InputIterator>::iterator_category());
1175 }
1176
1177 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CallInst, Value)
1178
1179 //===----------------------------------------------------------------------===//
1180 //                               SelectInst Class
1181 //===----------------------------------------------------------------------===//
1182
1183 /// SelectInst - This class represents the LLVM 'select' instruction.
1184 ///
1185 class SelectInst : public Instruction {
1186   void init(Value *C, Value *S1, Value *S2) {
1187     Op<0>() = C;
1188     Op<1>() = S1;
1189     Op<2>() = S2;
1190   }
1191
1192   SelectInst(const SelectInst &SI)
1193     : Instruction(SI.getType(), SI.getOpcode(), &Op<0>(), 3) {
1194     init(SI.Op<0>(), SI.Op<1>(), SI.Op<2>());
1195   }
1196   SelectInst(Value *C, Value *S1, Value *S2, const std::string &Name,
1197              Instruction *InsertBefore)
1198     : Instruction(S1->getType(), Instruction::Select,
1199                   &Op<0>(), 3, InsertBefore) {
1200     init(C, S1, S2);
1201     setName(Name);
1202   }
1203   SelectInst(Value *C, Value *S1, Value *S2, const std::string &Name,
1204              BasicBlock *InsertAtEnd)
1205     : Instruction(S1->getType(), Instruction::Select,
1206                   &Op<0>(), 3, InsertAtEnd) {
1207     init(C, S1, S2);
1208     setName(Name);
1209   }
1210 public:
1211   static SelectInst *Create(Value *C, Value *S1, Value *S2,
1212                             const std::string &Name = "",
1213                             Instruction *InsertBefore = 0) {
1214     return new(3) SelectInst(C, S1, S2, Name, InsertBefore);
1215   }
1216   static SelectInst *Create(Value *C, Value *S1, Value *S2,
1217                             const std::string &Name, BasicBlock *InsertAtEnd) {
1218     return new(3) SelectInst(C, S1, S2, Name, InsertAtEnd);
1219   }
1220
1221   Value *getCondition() const { return Op<0>(); }
1222   Value *getTrueValue() const { return Op<1>(); }
1223   Value *getFalseValue() const { return Op<2>(); }
1224
1225   /// Transparently provide more efficient getOperand methods.
1226   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1227
1228   OtherOps getOpcode() const {
1229     return static_cast<OtherOps>(Instruction::getOpcode());
1230   }
1231
1232   virtual SelectInst *clone() const;
1233
1234   // Methods for support type inquiry through isa, cast, and dyn_cast:
1235   static inline bool classof(const SelectInst *) { return true; }
1236   static inline bool classof(const Instruction *I) {
1237     return I->getOpcode() == Instruction::Select;
1238   }
1239   static inline bool classof(const Value *V) {
1240     return isa<Instruction>(V) && classof(cast<Instruction>(V));
1241   }
1242 };
1243
1244 template <>
1245 struct OperandTraits<SelectInst> : FixedNumOperandTraits<3> {
1246 };
1247
1248 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(SelectInst, Value)
1249
1250 //===----------------------------------------------------------------------===//
1251 //                                VAArgInst Class
1252 //===----------------------------------------------------------------------===//
1253
1254 /// VAArgInst - This class represents the va_arg llvm instruction, which returns
1255 /// an argument of the specified type given a va_list and increments that list
1256 ///
1257 class VAArgInst : public UnaryInstruction {
1258   VAArgInst(const VAArgInst &VAA)
1259     : UnaryInstruction(VAA.getType(), VAArg, VAA.getOperand(0)) {}
1260 public:
1261   VAArgInst(Value *List, const Type *Ty, const std::string &Name = "",
1262              Instruction *InsertBefore = 0)
1263     : UnaryInstruction(Ty, VAArg, List, InsertBefore) {
1264     setName(Name);
1265   }
1266   VAArgInst(Value *List, const Type *Ty, const std::string &Name,
1267             BasicBlock *InsertAtEnd)
1268     : UnaryInstruction(Ty, VAArg, List, InsertAtEnd) {
1269     setName(Name);
1270   }
1271
1272   virtual VAArgInst *clone() const;
1273
1274   // Methods for support type inquiry through isa, cast, and dyn_cast:
1275   static inline bool classof(const VAArgInst *) { return true; }
1276   static inline bool classof(const Instruction *I) {
1277     return I->getOpcode() == VAArg;
1278   }
1279   static inline bool classof(const Value *V) {
1280     return isa<Instruction>(V) && classof(cast<Instruction>(V));
1281   }
1282 };
1283
1284 //===----------------------------------------------------------------------===//
1285 //                                ExtractElementInst Class
1286 //===----------------------------------------------------------------------===//
1287
1288 /// ExtractElementInst - This instruction extracts a single (scalar)
1289 /// element from a VectorType value
1290 ///
1291 class ExtractElementInst : public Instruction {
1292   ExtractElementInst(const ExtractElementInst &EE) :
1293     Instruction(EE.getType(), ExtractElement, &Op<0>(), 2) {
1294     Op<0>() = EE.Op<0>();
1295     Op<1>() = EE.Op<1>();
1296   }
1297
1298 public:
1299   // allocate space for exactly two operands
1300   void *operator new(size_t s) {
1301     return User::operator new(s, 2); // FIXME: "unsigned Idx" forms of ctor?
1302   }
1303   ExtractElementInst(Value *Vec, Value *Idx, const std::string &Name = "",
1304                      Instruction *InsertBefore = 0);
1305   ExtractElementInst(Value *Vec, unsigned Idx, const std::string &Name = "",
1306                      Instruction *InsertBefore = 0);
1307   ExtractElementInst(Value *Vec, Value *Idx, const std::string &Name,
1308                      BasicBlock *InsertAtEnd);
1309   ExtractElementInst(Value *Vec, unsigned Idx, const std::string &Name,
1310                      BasicBlock *InsertAtEnd);
1311
1312   /// isValidOperands - Return true if an extractelement instruction can be
1313   /// formed with the specified operands.
1314   static bool isValidOperands(const Value *Vec, const Value *Idx);
1315
1316   virtual ExtractElementInst *clone() const;
1317
1318   /// Transparently provide more efficient getOperand methods.
1319   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1320
1321   // Methods for support type inquiry through isa, cast, and dyn_cast:
1322   static inline bool classof(const ExtractElementInst *) { return true; }
1323   static inline bool classof(const Instruction *I) {
1324     return I->getOpcode() == Instruction::ExtractElement;
1325   }
1326   static inline bool classof(const Value *V) {
1327     return isa<Instruction>(V) && classof(cast<Instruction>(V));
1328   }
1329 };
1330
1331 template <>
1332 struct OperandTraits<ExtractElementInst> : FixedNumOperandTraits<2> {
1333 };
1334
1335 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ExtractElementInst, Value)
1336
1337 //===----------------------------------------------------------------------===//
1338 //                                InsertElementInst Class
1339 //===----------------------------------------------------------------------===//
1340
1341 /// InsertElementInst - This instruction inserts a single (scalar)
1342 /// element into a VectorType value
1343 ///
1344 class InsertElementInst : public Instruction {
1345   InsertElementInst(const InsertElementInst &IE);
1346   InsertElementInst(Value *Vec, Value *NewElt, Value *Idx,
1347                     const std::string &Name = "",Instruction *InsertBefore = 0);
1348   InsertElementInst(Value *Vec, Value *NewElt, unsigned Idx,
1349                     const std::string &Name = "",Instruction *InsertBefore = 0);
1350   InsertElementInst(Value *Vec, Value *NewElt, Value *Idx,
1351                     const std::string &Name, BasicBlock *InsertAtEnd);
1352   InsertElementInst(Value *Vec, Value *NewElt, unsigned Idx,
1353                     const std::string &Name, BasicBlock *InsertAtEnd);
1354 public:
1355   static InsertElementInst *Create(const InsertElementInst &IE) {
1356     return new(IE.getNumOperands()) InsertElementInst(IE);
1357   }
1358   static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
1359                                    const std::string &Name = "",
1360                                    Instruction *InsertBefore = 0) {
1361     return new(3) InsertElementInst(Vec, NewElt, Idx, Name, InsertBefore);
1362   }
1363   static InsertElementInst *Create(Value *Vec, Value *NewElt, unsigned Idx,
1364                                    const std::string &Name = "",
1365                                    Instruction *InsertBefore = 0) {
1366     return new(3) InsertElementInst(Vec, NewElt, Idx, Name, InsertBefore);
1367   }
1368   static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
1369                                    const std::string &Name,
1370                                    BasicBlock *InsertAtEnd) {
1371     return new(3) InsertElementInst(Vec, NewElt, Idx, Name, InsertAtEnd);
1372   }
1373   static InsertElementInst *Create(Value *Vec, Value *NewElt, unsigned Idx,
1374                                    const std::string &Name,
1375                                    BasicBlock *InsertAtEnd) {
1376     return new(3) InsertElementInst(Vec, NewElt, Idx, Name, InsertAtEnd);
1377   }
1378
1379   /// isValidOperands - Return true if an insertelement instruction can be
1380   /// formed with the specified operands.
1381   static bool isValidOperands(const Value *Vec, const Value *NewElt,
1382                               const Value *Idx);
1383
1384   virtual InsertElementInst *clone() const;
1385
1386   /// getType - Overload to return most specific vector type.
1387   ///
1388   const VectorType *getType() const {
1389     return reinterpret_cast<const VectorType*>(Instruction::getType());
1390   }
1391
1392   /// Transparently provide more efficient getOperand methods.
1393   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1394
1395   // Methods for support type inquiry through isa, cast, and dyn_cast:
1396   static inline bool classof(const InsertElementInst *) { return true; }
1397   static inline bool classof(const Instruction *I) {
1398     return I->getOpcode() == Instruction::InsertElement;
1399   }
1400   static inline bool classof(const Value *V) {
1401     return isa<Instruction>(V) && classof(cast<Instruction>(V));
1402   }
1403 };
1404
1405 template <>
1406 struct OperandTraits<InsertElementInst> : FixedNumOperandTraits<3> {
1407 };
1408
1409 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertElementInst, Value)
1410
1411 //===----------------------------------------------------------------------===//
1412 //                           ShuffleVectorInst Class
1413 //===----------------------------------------------------------------------===//
1414
1415 /// ShuffleVectorInst - This instruction constructs a fixed permutation of two
1416 /// input vectors.
1417 ///
1418 class ShuffleVectorInst : public Instruction {
1419   ShuffleVectorInst(const ShuffleVectorInst &IE);
1420 public:
1421   // allocate space for exactly three operands
1422   void *operator new(size_t s) {
1423     return User::operator new(s, 3);
1424   }
1425   ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
1426                     const std::string &Name = "", Instruction *InsertBefor = 0);
1427   ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
1428                     const std::string &Name, BasicBlock *InsertAtEnd);
1429
1430   /// isValidOperands - Return true if a shufflevector instruction can be
1431   /// formed with the specified operands.
1432   static bool isValidOperands(const Value *V1, const Value *V2,
1433                               const Value *Mask);
1434
1435   virtual ShuffleVectorInst *clone() const;
1436
1437   /// getType - Overload to return most specific vector type.
1438   ///
1439   const VectorType *getType() const {
1440     return reinterpret_cast<const VectorType*>(Instruction::getType());
1441   }
1442
1443   /// Transparently provide more efficient getOperand methods.
1444   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1445
1446   /// getMaskValue - Return the index from the shuffle mask for the specified
1447   /// output result.  This is either -1 if the element is undef or a number less
1448   /// than 2*numelements.
1449   int getMaskValue(unsigned i) const;
1450
1451   // Methods for support type inquiry through isa, cast, and dyn_cast:
1452   static inline bool classof(const ShuffleVectorInst *) { return true; }
1453   static inline bool classof(const Instruction *I) {
1454     return I->getOpcode() == Instruction::ShuffleVector;
1455   }
1456   static inline bool classof(const Value *V) {
1457     return isa<Instruction>(V) && classof(cast<Instruction>(V));
1458   }
1459 };
1460
1461 template <>
1462 struct OperandTraits<ShuffleVectorInst> : FixedNumOperandTraits<3> {
1463 };
1464
1465 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ShuffleVectorInst, Value)
1466
1467 //===----------------------------------------------------------------------===//
1468 //                                ExtractValueInst Class
1469 //===----------------------------------------------------------------------===//
1470
1471 /// ExtractValueInst - This instruction extracts a struct member or array
1472 /// element value from an aggregate value.
1473 ///
1474 class ExtractValueInst : public UnaryInstruction {
1475   SmallVector<unsigned, 4> Indices;
1476
1477   ExtractValueInst(const ExtractValueInst &EVI);
1478   void init(const unsigned *Idx, unsigned NumIdx,
1479             const std::string &Name);
1480   void init(unsigned Idx, const std::string &Name);
1481
1482   template<typename InputIterator>
1483   void init(InputIterator IdxBegin, InputIterator IdxEnd,
1484             const std::string &Name,
1485             // This argument ensures that we have an iterator we can
1486             // do arithmetic on in constant time
1487             std::random_access_iterator_tag) {
1488     unsigned NumIdx = static_cast<unsigned>(std::distance(IdxBegin, IdxEnd));
1489
1490     // There's no fundamental reason why we require at least one index
1491     // (other than weirdness with &*IdxBegin being invalid; see
1492     // getelementptr's init routine for example). But there's no
1493     // present need to support it.
1494     assert(NumIdx > 0 && "ExtractValueInst must have at least one index");
1495
1496     // This requires that the iterator points to contiguous memory.
1497     init(&*IdxBegin, NumIdx, Name); // FIXME: for the general case
1498                                          // we have to build an array here
1499   }
1500
1501   /// getIndexedType - Returns the type of the element that would be extracted
1502   /// with an extractvalue instruction with the specified parameters.
1503   ///
1504   /// Null is returned if the indices are invalid for the specified
1505   /// pointer type.
1506   ///
1507   static const Type *getIndexedType(const Type *Agg,
1508                                     const unsigned *Idx, unsigned NumIdx);
1509
1510   template<typename InputIterator>
1511   static const Type *getIndexedType(const Type *Ptr,
1512                                     InputIterator IdxBegin,
1513                                     InputIterator IdxEnd,
1514                                     // This argument ensures that we
1515                                     // have an iterator we can do
1516                                     // arithmetic on in constant time
1517                                     std::random_access_iterator_tag) {
1518     unsigned NumIdx = static_cast<unsigned>(std::distance(IdxBegin, IdxEnd));
1519
1520     if (NumIdx > 0)
1521       // This requires that the iterator points to contiguous memory.
1522       return getIndexedType(Ptr, &*IdxBegin, NumIdx);
1523     else
1524       return getIndexedType(Ptr, (const unsigned *)0, NumIdx);
1525   }
1526
1527   /// Constructors - Create a extractvalue instruction with a base aggregate
1528   /// value and a list of indices.  The first ctor can optionally insert before
1529   /// an existing instruction, the second appends the new instruction to the
1530   /// specified BasicBlock.
1531   template<typename InputIterator>
1532   inline ExtractValueInst(Value *Agg, InputIterator IdxBegin,
1533                           InputIterator IdxEnd,
1534                           const std::string &Name,
1535                           Instruction *InsertBefore);
1536   template<typename InputIterator>
1537   inline ExtractValueInst(Value *Agg,
1538                           InputIterator IdxBegin, InputIterator IdxEnd,
1539                           const std::string &Name, BasicBlock *InsertAtEnd);
1540
1541   // allocate space for exactly one operand
1542   void *operator new(size_t s) {
1543     return User::operator new(s, 1);
1544   }
1545
1546 public:
1547   template<typename InputIterator>
1548   static ExtractValueInst *Create(Value *Agg, InputIterator IdxBegin,
1549                                   InputIterator IdxEnd,
1550                                   const std::string &Name = "",
1551                                   Instruction *InsertBefore = 0) {
1552     return new
1553       ExtractValueInst(Agg, IdxBegin, IdxEnd, Name, InsertBefore);
1554   }
1555   template<typename InputIterator>
1556   static ExtractValueInst *Create(Value *Agg,
1557                                   InputIterator IdxBegin, InputIterator IdxEnd,
1558                                   const std::string &Name,
1559                                   BasicBlock *InsertAtEnd) {
1560     return new ExtractValueInst(Agg, IdxBegin, IdxEnd, Name, InsertAtEnd);
1561   }
1562
1563   /// Constructors - These two creators are convenience methods because one
1564   /// index extractvalue instructions are much more common than those with
1565   /// more than one.
1566   static ExtractValueInst *Create(Value *Agg, unsigned Idx,
1567                                   const std::string &Name = "",
1568                                   Instruction *InsertBefore = 0) {
1569     unsigned Idxs[1] = { Idx };
1570     return new ExtractValueInst(Agg, Idxs, Idxs + 1, Name, InsertBefore);
1571   }
1572   static ExtractValueInst *Create(Value *Agg, unsigned Idx,
1573                                   const std::string &Name,
1574                                   BasicBlock *InsertAtEnd) {
1575     unsigned Idxs[1] = { Idx };
1576     return new ExtractValueInst(Agg, Idxs, Idxs + 1, Name, InsertAtEnd);
1577   }
1578
1579   virtual ExtractValueInst *clone() const;
1580
1581   // getType - Overload to return most specific pointer type...
1582   const PointerType *getType() const {
1583     return reinterpret_cast<const PointerType*>(Instruction::getType());
1584   }
1585
1586   /// getIndexedType - Returns the type of the element that would be extracted
1587   /// with an extractvalue instruction with the specified parameters.
1588   ///
1589   /// Null is returned if the indices are invalid for the specified
1590   /// pointer type.
1591   ///
1592   template<typename InputIterator>
1593   static const Type *getIndexedType(const Type *Ptr,
1594                                     InputIterator IdxBegin,
1595                                     InputIterator IdxEnd) {
1596     return getIndexedType(Ptr, IdxBegin, IdxEnd,
1597                           typename std::iterator_traits<InputIterator>::
1598                           iterator_category());
1599   }
1600   static const Type *getIndexedType(const Type *Ptr, unsigned Idx);
1601
1602   typedef const unsigned* idx_iterator;
1603   inline idx_iterator idx_begin() const { return Indices.begin(); }
1604   inline idx_iterator idx_end()   const { return Indices.end(); }
1605
1606   Value *getAggregateOperand() {
1607     return getOperand(0);
1608   }
1609   const Value *getAggregateOperand() const {
1610     return getOperand(0);
1611   }
1612   static unsigned getAggregateOperandIndex() {
1613     return 0U;                      // get index for modifying correct operand
1614   }
1615
1616   unsigned getNumIndices() const {  // Note: always non-negative
1617     return (unsigned)Indices.size();
1618   }
1619
1620   bool hasIndices() const {
1621     return true;
1622   }
1623
1624   // Methods for support type inquiry through isa, cast, and dyn_cast:
1625   static inline bool classof(const ExtractValueInst *) { return true; }
1626   static inline bool classof(const Instruction *I) {
1627     return I->getOpcode() == Instruction::ExtractValue;
1628   }
1629   static inline bool classof(const Value *V) {
1630     return isa<Instruction>(V) && classof(cast<Instruction>(V));
1631   }
1632 };
1633
1634 template<typename InputIterator>
1635 ExtractValueInst::ExtractValueInst(Value *Agg,
1636                                    InputIterator IdxBegin,
1637                                    InputIterator IdxEnd,
1638                                    const std::string &Name,
1639                                    Instruction *InsertBefore)
1640   : UnaryInstruction(checkType(getIndexedType(Agg->getType(),
1641                                               IdxBegin, IdxEnd)),
1642                      ExtractValue, Agg, InsertBefore) {
1643   init(IdxBegin, IdxEnd, Name,
1644        typename std::iterator_traits<InputIterator>::iterator_category());
1645 }
1646 template<typename InputIterator>
1647 ExtractValueInst::ExtractValueInst(Value *Agg,
1648                                    InputIterator IdxBegin,
1649                                    InputIterator IdxEnd,
1650                                    const std::string &Name,
1651                                    BasicBlock *InsertAtEnd)
1652   : UnaryInstruction(checkType(getIndexedType(Agg->getType(),
1653                                               IdxBegin, IdxEnd)),
1654                      ExtractValue, Agg, InsertAtEnd) {
1655   init(IdxBegin, IdxEnd, Name,
1656        typename std::iterator_traits<InputIterator>::iterator_category());
1657 }
1658
1659
1660 //===----------------------------------------------------------------------===//
1661 //                                InsertValueInst Class
1662 //===----------------------------------------------------------------------===//
1663
1664 /// InsertValueInst - This instruction inserts a struct field of array element
1665 /// value into an aggregate value.
1666 ///
1667 class InsertValueInst : public Instruction {
1668   SmallVector<unsigned, 4> Indices;
1669
1670   void *operator new(size_t, unsigned); // Do not implement
1671   InsertValueInst(const InsertValueInst &IVI);
1672   void init(Value *Agg, Value *Val, const unsigned *Idx, unsigned NumIdx,
1673             const std::string &Name);
1674   void init(Value *Agg, Value *Val, unsigned Idx, const std::string &Name);
1675
1676   template<typename InputIterator>
1677   void init(Value *Agg, Value *Val,
1678             InputIterator IdxBegin, InputIterator IdxEnd,
1679             const std::string &Name,
1680             // This argument ensures that we have an iterator we can
1681             // do arithmetic on in constant time
1682             std::random_access_iterator_tag) {
1683     unsigned NumIdx = static_cast<unsigned>(std::distance(IdxBegin, IdxEnd));
1684
1685     // There's no fundamental reason why we require at least one index
1686     // (other than weirdness with &*IdxBegin being invalid; see
1687     // getelementptr's init routine for example). But there's no
1688     // present need to support it.
1689     assert(NumIdx > 0 && "InsertValueInst must have at least one index");
1690
1691     // This requires that the iterator points to contiguous memory.
1692     init(Agg, Val, &*IdxBegin, NumIdx, Name); // FIXME: for the general case
1693                                               // we have to build an array here
1694   }
1695
1696   /// Constructors - Create a insertvalue instruction with a base aggregate
1697   /// value, a value to insert, and a list of indices.  The first ctor can
1698   /// optionally insert before an existing instruction, the second appends
1699   /// the new instruction to the specified BasicBlock.
1700   template<typename InputIterator>
1701   inline InsertValueInst(Value *Agg, Value *Val, InputIterator IdxBegin,
1702                          InputIterator IdxEnd,
1703                          const std::string &Name,
1704                          Instruction *InsertBefore);
1705   template<typename InputIterator>
1706   inline InsertValueInst(Value *Agg, Value *Val,
1707                          InputIterator IdxBegin, InputIterator IdxEnd,
1708                          const std::string &Name, BasicBlock *InsertAtEnd);
1709
1710   /// Constructors - These two constructors are convenience methods because one
1711   /// and two index insertvalue instructions are so common.
1712   InsertValueInst(Value *Agg, Value *Val,
1713                   unsigned Idx, const std::string &Name = "",
1714                   Instruction *InsertBefore = 0);
1715   InsertValueInst(Value *Agg, Value *Val, unsigned Idx,
1716                   const std::string &Name, BasicBlock *InsertAtEnd);
1717 public:
1718   // allocate space for exactly two operands
1719   void *operator new(size_t s) {
1720     return User::operator new(s, 2);
1721   }
1722
1723   template<typename InputIterator>
1724   static InsertValueInst *Create(Value *Agg, Value *Val, InputIterator IdxBegin,
1725                                  InputIterator IdxEnd,
1726                                  const std::string &Name = "",
1727                                  Instruction *InsertBefore = 0) {
1728     return new InsertValueInst(Agg, Val, IdxBegin, IdxEnd,
1729                                Name, InsertBefore);
1730   }
1731   template<typename InputIterator>
1732   static InsertValueInst *Create(Value *Agg, Value *Val,
1733                                  InputIterator IdxBegin, InputIterator IdxEnd,
1734                                  const std::string &Name,
1735                                  BasicBlock *InsertAtEnd) {
1736     return new InsertValueInst(Agg, Val, IdxBegin, IdxEnd,
1737                                Name, InsertAtEnd);
1738   }
1739
1740   /// Constructors - These two creators are convenience methods because one
1741   /// index insertvalue instructions are much more common than those with
1742   /// more than one.
1743   static InsertValueInst *Create(Value *Agg, Value *Val, unsigned Idx,
1744                                  const std::string &Name = "",
1745                                  Instruction *InsertBefore = 0) {
1746     return new InsertValueInst(Agg, Val, Idx, Name, InsertBefore);
1747   }
1748   static InsertValueInst *Create(Value *Agg, Value *Val, unsigned Idx,
1749                                  const std::string &Name,
1750                                  BasicBlock *InsertAtEnd) {
1751     return new InsertValueInst(Agg, Val, Idx, Name, InsertAtEnd);
1752   }
1753
1754   virtual InsertValueInst *clone() const;
1755
1756   /// Transparently provide more efficient getOperand methods.
1757   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1758
1759   // getType - Overload to return most specific pointer type...
1760   const PointerType *getType() const {
1761     return reinterpret_cast<const PointerType*>(Instruction::getType());
1762   }
1763
1764   typedef const unsigned* idx_iterator;
1765   inline idx_iterator idx_begin() const { return Indices.begin(); }
1766   inline idx_iterator idx_end()   const { return Indices.end(); }
1767
1768   Value *getAggregateOperand() {
1769     return getOperand(0);
1770   }
1771   const Value *getAggregateOperand() const {
1772     return getOperand(0);
1773   }
1774   static unsigned getAggregateOperandIndex() {
1775     return 0U;                      // get index for modifying correct operand
1776   }
1777
1778   Value *getInsertedValueOperand() {
1779     return getOperand(1);
1780   }
1781   const Value *getInsertedValueOperand() const {
1782     return getOperand(1);
1783   }
1784   static unsigned getInsertedValueOperandIndex() {
1785     return 1U;                      // get index for modifying correct operand
1786   }
1787
1788   unsigned getNumIndices() const {  // Note: always non-negative
1789     return (unsigned)Indices.size();
1790   }
1791
1792   bool hasIndices() const {
1793     return true;
1794   }
1795
1796   // Methods for support type inquiry through isa, cast, and dyn_cast:
1797   static inline bool classof(const InsertValueInst *) { return true; }
1798   static inline bool classof(const Instruction *I) {
1799     return I->getOpcode() == Instruction::InsertValue;
1800   }
1801   static inline bool classof(const Value *V) {
1802     return isa<Instruction>(V) && classof(cast<Instruction>(V));
1803   }
1804 };
1805
1806 template <>
1807 struct OperandTraits<InsertValueInst> : FixedNumOperandTraits<2> {
1808 };
1809
1810 template<typename InputIterator>
1811 InsertValueInst::InsertValueInst(Value *Agg,
1812                                  Value *Val,
1813                                  InputIterator IdxBegin,
1814                                  InputIterator IdxEnd,
1815                                  const std::string &Name,
1816                                  Instruction *InsertBefore)
1817   : Instruction(Agg->getType(), InsertValue,
1818                 OperandTraits<InsertValueInst>::op_begin(this),
1819                 2, InsertBefore) {
1820   init(Agg, Val, IdxBegin, IdxEnd, Name,
1821        typename std::iterator_traits<InputIterator>::iterator_category());
1822 }
1823 template<typename InputIterator>
1824 InsertValueInst::InsertValueInst(Value *Agg,
1825                                  Value *Val,
1826                                  InputIterator IdxBegin,
1827                                  InputIterator IdxEnd,
1828                                  const std::string &Name,
1829                                  BasicBlock *InsertAtEnd)
1830   : Instruction(Agg->getType(), InsertValue,
1831                 OperandTraits<InsertValueInst>::op_begin(this),
1832                 2, InsertAtEnd) {
1833   init(Agg, Val, IdxBegin, IdxEnd, Name,
1834        typename std::iterator_traits<InputIterator>::iterator_category());
1835 }
1836
1837 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertValueInst, Value)
1838
1839 //===----------------------------------------------------------------------===//
1840 //                               PHINode Class
1841 //===----------------------------------------------------------------------===//
1842
1843 // PHINode - The PHINode class is used to represent the magical mystical PHI
1844 // node, that can not exist in nature, but can be synthesized in a computer
1845 // scientist's overactive imagination.
1846 //
1847 class PHINode : public Instruction {
1848   void *operator new(size_t, unsigned);  // DO NOT IMPLEMENT
1849   /// ReservedSpace - The number of operands actually allocated.  NumOperands is
1850   /// the number actually in use.
1851   unsigned ReservedSpace;
1852   PHINode(const PHINode &PN);
1853   // allocate space for exactly zero operands
1854   void *operator new(size_t s) {
1855     return User::operator new(s, 0);
1856   }
1857   explicit PHINode(const Type *Ty, const std::string &Name = "",
1858                    Instruction *InsertBefore = 0)
1859     : Instruction(Ty, Instruction::PHI, 0, 0, InsertBefore),
1860       ReservedSpace(0) {
1861     setName(Name);
1862   }
1863
1864   PHINode(const Type *Ty, const std::string &Name, BasicBlock *InsertAtEnd)
1865     : Instruction(Ty, Instruction::PHI, 0, 0, InsertAtEnd),
1866       ReservedSpace(0) {
1867     setName(Name);
1868   }
1869 public:
1870   static PHINode *Create(const Type *Ty, const std::string &Name = "",
1871                          Instruction *InsertBefore = 0) {
1872     return new PHINode(Ty, Name, InsertBefore);
1873   }
1874   static PHINode *Create(const Type *Ty, const std::string &Name,
1875                          BasicBlock *InsertAtEnd) {
1876     return new PHINode(Ty, Name, InsertAtEnd);
1877   }
1878   ~PHINode();
1879
1880   /// reserveOperandSpace - This method can be used to avoid repeated
1881   /// reallocation of PHI operand lists by reserving space for the correct
1882   /// number of operands before adding them.  Unlike normal vector reserves,
1883   /// this method can also be used to trim the operand space.
1884   void reserveOperandSpace(unsigned NumValues) {
1885     resizeOperands(NumValues*2);
1886   }
1887
1888   virtual PHINode *clone() const;
1889
1890   /// Provide fast operand accessors
1891   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1892
1893   /// getNumIncomingValues - Return the number of incoming edges
1894   ///
1895   unsigned getNumIncomingValues() const { return getNumOperands()/2; }
1896
1897   /// getIncomingValue - Return incoming value number x
1898   ///
1899   Value *getIncomingValue(unsigned i) const {
1900     assert(i*2 < getNumOperands() && "Invalid value number!");
1901     return getOperand(i*2);
1902   }
1903   void setIncomingValue(unsigned i, Value *V) {
1904     assert(i*2 < getNumOperands() && "Invalid value number!");
1905     setOperand(i*2, V);
1906   }
1907   unsigned getOperandNumForIncomingValue(unsigned i) {
1908     return i*2;
1909   }
1910
1911   /// getIncomingBlock - Return incoming basic block number x
1912   ///
1913   BasicBlock *getIncomingBlock(unsigned i) const {
1914     return static_cast<BasicBlock*>(getOperand(i*2+1));
1915   }
1916   void setIncomingBlock(unsigned i, BasicBlock *BB) {
1917     setOperand(i*2+1, BB);
1918   }
1919   unsigned getOperandNumForIncomingBlock(unsigned i) {
1920     return i*2+1;
1921   }
1922
1923   /// addIncoming - Add an incoming value to the end of the PHI list
1924   ///
1925   void addIncoming(Value *V, BasicBlock *BB) {
1926     assert(V && "PHI node got a null value!");
1927     assert(BB && "PHI node got a null basic block!");
1928     assert(getType() == V->getType() &&
1929            "All operands to PHI node must be the same type as the PHI node!");
1930     unsigned OpNo = NumOperands;
1931     if (OpNo+2 > ReservedSpace)
1932       resizeOperands(0);  // Get more space!
1933     // Initialize some new operands.
1934     NumOperands = OpNo+2;
1935     OperandList[OpNo] = V;
1936     OperandList[OpNo+1] = BB;
1937   }
1938
1939   /// removeIncomingValue - Remove an incoming value.  This is useful if a
1940   /// predecessor basic block is deleted.  The value removed is returned.
1941   ///
1942   /// If the last incoming value for a PHI node is removed (and DeletePHIIfEmpty
1943   /// is true), the PHI node is destroyed and any uses of it are replaced with
1944   /// dummy values.  The only time there should be zero incoming values to a PHI
1945   /// node is when the block is dead, so this strategy is sound.
1946   ///
1947   Value *removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty = true);
1948
1949   Value *removeIncomingValue(const BasicBlock *BB, bool DeletePHIIfEmpty=true) {
1950     int Idx = getBasicBlockIndex(BB);
1951     assert(Idx >= 0 && "Invalid basic block argument to remove!");
1952     return removeIncomingValue(Idx, DeletePHIIfEmpty);
1953   }
1954
1955   /// getBasicBlockIndex - Return the first index of the specified basic
1956   /// block in the value list for this PHI.  Returns -1 if no instance.
1957   ///
1958   int getBasicBlockIndex(const BasicBlock *BB) const {
1959     Use *OL = OperandList;
1960     for (unsigned i = 0, e = getNumOperands(); i != e; i += 2)
1961       if (OL[i+1].get() == BB) return i/2;
1962     return -1;
1963   }
1964
1965   Value *getIncomingValueForBlock(const BasicBlock *BB) const {
1966     return getIncomingValue(getBasicBlockIndex(BB));
1967   }
1968
1969   /// hasConstantValue - If the specified PHI node always merges together the
1970   /// same value, return the value, otherwise return null.
1971   ///
1972   Value *hasConstantValue(bool AllowNonDominatingInstruction = false) const;
1973
1974   /// Methods for support type inquiry through isa, cast, and dyn_cast:
1975   static inline bool classof(const PHINode *) { return true; }
1976   static inline bool classof(const Instruction *I) {
1977     return I->getOpcode() == Instruction::PHI;
1978   }
1979   static inline bool classof(const Value *V) {
1980     return isa<Instruction>(V) && classof(cast<Instruction>(V));
1981   }
1982  private:
1983   void resizeOperands(unsigned NumOperands);
1984 };
1985
1986 template <>
1987 struct OperandTraits<PHINode> : HungoffOperandTraits<2> {
1988 };
1989
1990 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(PHINode, Value)
1991
1992
1993 //===----------------------------------------------------------------------===//
1994 //                               ReturnInst Class
1995 //===----------------------------------------------------------------------===//
1996
1997 //===---------------------------------------------------------------------------
1998 /// ReturnInst - Return a value (possibly void), from a function.  Execution
1999 /// does not continue in this function any longer.
2000 ///
2001 class ReturnInst : public TerminatorInst {
2002   ReturnInst(const ReturnInst &RI);
2003   void init(Value * const* retVals, unsigned N);
2004
2005 private:
2006   // ReturnInst constructors:
2007   // ReturnInst()                  - 'ret void' instruction
2008   // ReturnInst(    null)          - 'ret void' instruction
2009   // ReturnInst(Value* X)          - 'ret X'    instruction
2010   // ReturnInst(    null, Inst *I) - 'ret void' instruction, insert before I
2011   // ReturnInst(Value* X, Inst *I) - 'ret X'    instruction, insert before I
2012   // ReturnInst(    null, BB *B)   - 'ret void' instruction, insert @ end of B
2013   // ReturnInst(Value* X, BB *B)   - 'ret X'    instruction, insert @ end of B
2014   // ReturnInst(Value* X, N)          - 'ret X,X+1...X+N-1' instruction
2015   // ReturnInst(Value* X, N, Inst *I) - 'ret X,X+1...X+N-1', insert before I
2016   // ReturnInst(Value* X, N, BB *B)   - 'ret X,X+1...X+N-1', insert @ end of B
2017   //
2018   // NOTE: If the Value* passed is of type void then the constructor behaves as
2019   // if it was passed NULL.
2020   explicit ReturnInst(Value *retVal = 0, Instruction *InsertBefore = 0);
2021   ReturnInst(Value *retVal, BasicBlock *InsertAtEnd);
2022   ReturnInst(Value * const* retVals, unsigned N, Instruction *InsertBefore = 0);
2023   ReturnInst(Value * const* retVals, unsigned N, BasicBlock *InsertAtEnd);
2024   explicit ReturnInst(BasicBlock *InsertAtEnd);
2025 public:
2026   static ReturnInst* Create(Value *retVal = 0, Instruction *InsertBefore = 0) {
2027     return new(!!retVal) ReturnInst(retVal, InsertBefore);
2028   }
2029   static ReturnInst* Create(Value *retVal, BasicBlock *InsertAtEnd) {
2030     return new(!!retVal) ReturnInst(retVal, InsertAtEnd);
2031   }
2032   static ReturnInst* Create(Value * const* retVals, unsigned N,
2033                             Instruction *InsertBefore = 0) {
2034     return new(N) ReturnInst(retVals, N, InsertBefore);
2035   }
2036   static ReturnInst* Create(Value * const* retVals, unsigned N,
2037                             BasicBlock *InsertAtEnd) {
2038     return new(N) ReturnInst(retVals, N, InsertAtEnd);
2039   }
2040   static ReturnInst* Create(BasicBlock *InsertAtEnd) {
2041     return new(0) ReturnInst(InsertAtEnd);
2042   }
2043   virtual ~ReturnInst();
2044   inline void operator delete(void*);
2045
2046   virtual ReturnInst *clone() const;
2047
2048   /// Provide fast operand accessors
2049   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2050
2051   /// Convenience accessor
2052   Value *getReturnValue(unsigned n = 0) const {
2053     return n < getNumOperands()
2054       ? getOperand(n)
2055       : 0;
2056   }
2057
2058   unsigned getNumSuccessors() const { return 0; }
2059
2060   // Methods for support type inquiry through isa, cast, and dyn_cast:
2061   static inline bool classof(const ReturnInst *) { return true; }
2062   static inline bool classof(const Instruction *I) {
2063     return (I->getOpcode() == Instruction::Ret);
2064   }
2065   static inline bool classof(const Value *V) {
2066     return isa<Instruction>(V) && classof(cast<Instruction>(V));
2067   }
2068  private:
2069   virtual BasicBlock *getSuccessorV(unsigned idx) const;
2070   virtual unsigned getNumSuccessorsV() const;
2071   virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2072 };
2073
2074 template <>
2075 struct OperandTraits<ReturnInst> : VariadicOperandTraits<> {
2076 };
2077
2078 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ReturnInst, Value)
2079 void ReturnInst::operator delete(void *it) {
2080   ReturnInst* me(static_cast<ReturnInst*>(it));
2081   Use::zap(OperandTraits<ReturnInst>::op_begin(me),
2082            OperandTraits<ReturnInst>::op_end(me),
2083            true);
2084 }
2085
2086 //===----------------------------------------------------------------------===//
2087 //                               BranchInst Class
2088 //===----------------------------------------------------------------------===//
2089
2090 //===---------------------------------------------------------------------------
2091 /// BranchInst - Conditional or Unconditional Branch instruction.
2092 ///
2093 class BranchInst : public TerminatorInst {
2094   /// Ops list - Branches are strange.  The operands are ordered:
2095   ///  TrueDest, FalseDest, Cond.  This makes some accessors faster because
2096   /// they don't have to check for cond/uncond branchness.
2097   BranchInst(const BranchInst &BI);
2098   void AssertOK();
2099   // BranchInst constructors (where {B, T, F} are blocks, and C is a condition):
2100   // BranchInst(BB *B)                           - 'br B'
2101   // BranchInst(BB* T, BB *F, Value *C)          - 'br C, T, F'
2102   // BranchInst(BB* B, Inst *I)                  - 'br B'        insert before I
2103   // BranchInst(BB* T, BB *F, Value *C, Inst *I) - 'br C, T, F', insert before I
2104   // BranchInst(BB* B, BB *I)                    - 'br B'        insert at end
2105   // BranchInst(BB* T, BB *F, Value *C, BB *I)   - 'br C, T, F', insert at end
2106   explicit BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore = 0);
2107   BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
2108              Instruction *InsertBefore = 0);
2109   BranchInst(BasicBlock *IfTrue, BasicBlock *InsertAtEnd);
2110   BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
2111              BasicBlock *InsertAtEnd);
2112 public:
2113   static BranchInst *Create(BasicBlock *IfTrue, Instruction *InsertBefore = 0) {
2114     return new(1) BranchInst(IfTrue, InsertBefore);
2115   }
2116   static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
2117                             Value *Cond, Instruction *InsertBefore = 0) {
2118     return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertBefore);
2119   }
2120   static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *InsertAtEnd) {
2121     return new(1) BranchInst(IfTrue, InsertAtEnd);
2122   }
2123   static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
2124                             Value *Cond, BasicBlock *InsertAtEnd) {
2125     return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertAtEnd);
2126   }
2127
2128   ~BranchInst() {
2129     if (NumOperands == 1)
2130       NumOperands = (unsigned)((Use*)this - OperandList);
2131   }
2132
2133   /// Transparently provide more efficient getOperand methods.
2134   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2135
2136   virtual BranchInst *clone() const;
2137
2138   bool isUnconditional() const { return getNumOperands() == 1; }
2139   bool isConditional()   const { return getNumOperands() == 3; }
2140
2141   Value *getCondition() const {
2142     assert(isConditional() && "Cannot get condition of an uncond branch!");
2143     return getOperand(2);
2144   }
2145
2146   void setCondition(Value *V) {
2147     assert(isConditional() && "Cannot set condition of unconditional branch!");
2148     setOperand(2, V);
2149   }
2150
2151   // setUnconditionalDest - Change the current branch to an unconditional branch
2152   // targeting the specified block.
2153   // FIXME: Eliminate this ugly method.
2154   void setUnconditionalDest(BasicBlock *Dest) {
2155     Op<0>() = Dest;
2156     if (isConditional()) {  // Convert this to an uncond branch.
2157       Op<1>().set(0);
2158       Op<2>().set(0);
2159       NumOperands = 1;
2160     }
2161   }
2162
2163   unsigned getNumSuccessors() const { return 1+isConditional(); }
2164
2165   BasicBlock *getSuccessor(unsigned i) const {
2166     assert(i < getNumSuccessors() && "Successor # out of range for Branch!");
2167     return cast<BasicBlock>(getOperand(i));
2168   }
2169
2170   void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
2171     assert(idx < getNumSuccessors() && "Successor # out of range for Branch!");
2172     setOperand(idx, NewSucc);
2173   }
2174
2175   // Methods for support type inquiry through isa, cast, and dyn_cast:
2176   static inline bool classof(const BranchInst *) { return true; }
2177   static inline bool classof(const Instruction *I) {
2178     return (I->getOpcode() == Instruction::Br);
2179   }
2180   static inline bool classof(const Value *V) {
2181     return isa<Instruction>(V) && classof(cast<Instruction>(V));
2182   }
2183 private:
2184   virtual BasicBlock *getSuccessorV(unsigned idx) const;
2185   virtual unsigned getNumSuccessorsV() const;
2186   virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2187 };
2188
2189 template <>
2190 struct OperandTraits<BranchInst> : HungoffOperandTraits<> {
2191   // we need to access operands via OperandList, since
2192   // the NumOperands may change from 3 to 1
2193   static inline void *allocate(unsigned); // FIXME
2194 };
2195
2196 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BranchInst, Value)
2197
2198 //===----------------------------------------------------------------------===//
2199 //                               SwitchInst Class
2200 //===----------------------------------------------------------------------===//
2201
2202 //===---------------------------------------------------------------------------
2203 /// SwitchInst - Multiway switch
2204 ///
2205 class SwitchInst : public TerminatorInst {
2206   void *operator new(size_t, unsigned);  // DO NOT IMPLEMENT
2207   unsigned ReservedSpace;
2208   // Operand[0]    = Value to switch on
2209   // Operand[1]    = Default basic block destination
2210   // Operand[2n  ] = Value to match
2211   // Operand[2n+1] = BasicBlock to go to on match
2212   SwitchInst(const SwitchInst &RI);
2213   void init(Value *Value, BasicBlock *Default, unsigned NumCases);
2214   void resizeOperands(unsigned No);
2215   // allocate space for exactly zero operands
2216   void *operator new(size_t s) {
2217     return User::operator new(s, 0);
2218   }
2219   /// SwitchInst ctor - Create a new switch instruction, specifying a value to
2220   /// switch on and a default destination.  The number of additional cases can
2221   /// be specified here to make memory allocation more efficient.  This
2222   /// constructor can also autoinsert before another instruction.
2223   SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
2224              Instruction *InsertBefore = 0);
2225
2226   /// SwitchInst ctor - Create a new switch instruction, specifying a value to
2227   /// switch on and a default destination.  The number of additional cases can
2228   /// be specified here to make memory allocation more efficient.  This
2229   /// constructor also autoinserts at the end of the specified BasicBlock.
2230   SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
2231              BasicBlock *InsertAtEnd);
2232 public:
2233   static SwitchInst *Create(Value *Value, BasicBlock *Default,
2234                             unsigned NumCases, Instruction *InsertBefore = 0) {
2235     return new SwitchInst(Value, Default, NumCases, InsertBefore);
2236   }
2237   static SwitchInst *Create(Value *Value, BasicBlock *Default,
2238                             unsigned NumCases, BasicBlock *InsertAtEnd) {
2239     return new SwitchInst(Value, Default, NumCases, InsertAtEnd);
2240   }
2241   ~SwitchInst();
2242
2243   /// Provide fast operand accessors
2244   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2245
2246   // Accessor Methods for Switch stmt
2247   Value *getCondition() const { return getOperand(0); }
2248   void setCondition(Value *V) { setOperand(0, V); }
2249
2250   BasicBlock *getDefaultDest() const {
2251     return cast<BasicBlock>(getOperand(1));
2252   }
2253
2254   /// getNumCases - return the number of 'cases' in this switch instruction.
2255   /// Note that case #0 is always the default case.
2256   unsigned getNumCases() const {
2257     return getNumOperands()/2;
2258   }
2259
2260   /// getCaseValue - Return the specified case value.  Note that case #0, the
2261   /// default destination, does not have a case value.
2262   ConstantInt *getCaseValue(unsigned i) {
2263     assert(i && i < getNumCases() && "Illegal case value to get!");
2264     return getSuccessorValue(i);
2265   }
2266
2267   /// getCaseValue - Return the specified case value.  Note that case #0, the
2268   /// default destination, does not have a case value.
2269   const ConstantInt *getCaseValue(unsigned i) const {
2270     assert(i && i < getNumCases() && "Illegal case value to get!");
2271     return getSuccessorValue(i);
2272   }
2273
2274   /// findCaseValue - Search all of the case values for the specified constant.
2275   /// If it is explicitly handled, return the case number of it, otherwise
2276   /// return 0 to indicate that it is handled by the default handler.
2277   unsigned findCaseValue(const ConstantInt *C) const {
2278     for (unsigned i = 1, e = getNumCases(); i != e; ++i)
2279       if (getCaseValue(i) == C)
2280         return i;
2281     return 0;
2282   }
2283
2284   /// findCaseDest - Finds the unique case value for a given successor. Returns
2285   /// null if the successor is not found, not unique, or is the default case.
2286   ConstantInt *findCaseDest(BasicBlock *BB) {
2287     if (BB == getDefaultDest()) return NULL;
2288
2289     ConstantInt *CI = NULL;
2290     for (unsigned i = 1, e = getNumCases(); i != e; ++i) {
2291       if (getSuccessor(i) == BB) {
2292         if (CI) return NULL;   // Multiple cases lead to BB.
2293         else CI = getCaseValue(i);
2294       }
2295     }
2296     return CI;
2297   }
2298
2299   /// addCase - Add an entry to the switch instruction...
2300   ///
2301   void addCase(ConstantInt *OnVal, BasicBlock *Dest);
2302
2303   /// removeCase - This method removes the specified successor from the switch
2304   /// instruction.  Note that this cannot be used to remove the default
2305   /// destination (successor #0).
2306   ///
2307   void removeCase(unsigned idx);
2308
2309   virtual SwitchInst *clone() const;
2310
2311   unsigned getNumSuccessors() const { return getNumOperands()/2; }
2312   BasicBlock *getSuccessor(unsigned idx) const {
2313     assert(idx < getNumSuccessors() &&"Successor idx out of range for switch!");
2314     return cast<BasicBlock>(getOperand(idx*2+1));
2315   }
2316   void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
2317     assert(idx < getNumSuccessors() && "Successor # out of range for switch!");
2318     setOperand(idx*2+1, NewSucc);
2319   }
2320
2321   // getSuccessorValue - Return the value associated with the specified
2322   // successor.
2323   ConstantInt *getSuccessorValue(unsigned idx) const {
2324     assert(idx < getNumSuccessors() && "Successor # out of range!");
2325     return reinterpret_cast<ConstantInt*>(getOperand(idx*2));
2326   }
2327
2328   // Methods for support type inquiry through isa, cast, and dyn_cast:
2329   static inline bool classof(const SwitchInst *) { return true; }
2330   static inline bool classof(const Instruction *I) {
2331     return I->getOpcode() == Instruction::Switch;
2332   }
2333   static inline bool classof(const Value *V) {
2334     return isa<Instruction>(V) && classof(cast<Instruction>(V));
2335   }
2336 private:
2337   virtual BasicBlock *getSuccessorV(unsigned idx) const;
2338   virtual unsigned getNumSuccessorsV() const;
2339   virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2340 };
2341
2342 template <>
2343 struct OperandTraits<SwitchInst> : HungoffOperandTraits<2> {
2344 };
2345
2346 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(SwitchInst, Value)
2347
2348
2349 //===----------------------------------------------------------------------===//
2350 //                               InvokeInst Class
2351 //===----------------------------------------------------------------------===//
2352
2353 /// InvokeInst - Invoke instruction.  The SubclassData field is used to hold the
2354 /// calling convention of the call.
2355 ///
2356 class InvokeInst : public TerminatorInst {
2357   PAListPtr ParamAttrs;
2358   InvokeInst(const InvokeInst &BI);
2359   void init(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
2360             Value* const *Args, unsigned NumArgs);
2361
2362   template<typename InputIterator>
2363   void init(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
2364             InputIterator ArgBegin, InputIterator ArgEnd,
2365             const std::string &Name,
2366             // This argument ensures that we have an iterator we can
2367             // do arithmetic on in constant time
2368             std::random_access_iterator_tag) {
2369     unsigned NumArgs = (unsigned)std::distance(ArgBegin, ArgEnd);
2370
2371     // This requires that the iterator points to contiguous memory.
2372     init(Func, IfNormal, IfException, NumArgs ? &*ArgBegin : 0, NumArgs);
2373     setName(Name);
2374   }
2375
2376   /// Construct an InvokeInst given a range of arguments.
2377   /// InputIterator must be a random-access iterator pointing to
2378   /// contiguous storage (e.g. a std::vector<>::iterator).  Checks are
2379   /// made for random-accessness but not for contiguous storage as
2380   /// that would incur runtime overhead.
2381   ///
2382   /// @brief Construct an InvokeInst from a range of arguments
2383   template<typename InputIterator>
2384   inline InvokeInst(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
2385                     InputIterator ArgBegin, InputIterator ArgEnd,
2386                     unsigned Values,
2387                     const std::string &Name, Instruction *InsertBefore);
2388
2389   /// Construct an InvokeInst given a range of arguments.
2390   /// InputIterator must be a random-access iterator pointing to
2391   /// contiguous storage (e.g. a std::vector<>::iterator).  Checks are
2392   /// made for random-accessness but not for contiguous storage as
2393   /// that would incur runtime overhead.
2394   ///
2395   /// @brief Construct an InvokeInst from a range of arguments
2396   template<typename InputIterator>
2397   inline InvokeInst(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
2398                     InputIterator ArgBegin, InputIterator ArgEnd,
2399                     unsigned Values,
2400                     const std::string &Name, BasicBlock *InsertAtEnd);
2401 public:
2402   template<typename InputIterator>
2403   static InvokeInst *Create(Value *Func,
2404                             BasicBlock *IfNormal, BasicBlock *IfException,
2405                             InputIterator ArgBegin, InputIterator ArgEnd,
2406                             const std::string &Name = "",
2407                             Instruction *InsertBefore = 0) {
2408     unsigned Values(ArgEnd - ArgBegin + 3);
2409     return new(Values) InvokeInst(Func, IfNormal, IfException, ArgBegin, ArgEnd,
2410                                   Values, Name, InsertBefore);
2411   }
2412   template<typename InputIterator>
2413   static InvokeInst *Create(Value *Func,
2414                             BasicBlock *IfNormal, BasicBlock *IfException,
2415                             InputIterator ArgBegin, InputIterator ArgEnd,
2416                             const std::string &Name, BasicBlock *InsertAtEnd) {
2417     unsigned Values(ArgEnd - ArgBegin + 3);
2418     return new(Values) InvokeInst(Func, IfNormal, IfException, ArgBegin, ArgEnd,
2419                                   Values, Name, InsertAtEnd);
2420   }
2421
2422   virtual InvokeInst *clone() const;
2423
2424   /// Provide fast operand accessors
2425   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2426
2427   /// getCallingConv/setCallingConv - Get or set the calling convention of this
2428   /// function call.
2429   unsigned getCallingConv() const { return SubclassData; }
2430   void setCallingConv(unsigned CC) {
2431     SubclassData = CC;
2432   }
2433
2434   /// getParamAttrs - Return the parameter attributes for this invoke.
2435   ///
2436   const PAListPtr &getParamAttrs() const { return ParamAttrs; }
2437
2438   /// setParamAttrs - Set the parameter attributes for this invoke.
2439   ///
2440   void setParamAttrs(const PAListPtr &Attrs) { ParamAttrs = Attrs; }
2441
2442   /// @brief Determine whether the call or the callee has the given attribute.
2443   bool paramHasAttr(unsigned i, ParameterAttributes attr) const;
2444
2445   /// addParamAttr - adds the attribute to the list of attributes.
2446   void addParamAttr(unsigned i, ParameterAttributes attr);
2447
2448   /// removeParamAttr - removes the attribute from the list of attributes.
2449   void removeParamAttr(unsigned i, ParameterAttributes attr);
2450
2451   /// @brief Extract the alignment for a call or parameter (0=unknown).
2452   unsigned getParamAlignment(unsigned i) const {
2453     return ParamAttrs.getParamAlignment(i);
2454   }
2455
2456   /// @brief Determine if the call does not access memory.
2457   bool doesNotAccessMemory() const {
2458     return paramHasAttr(0, ParamAttr::ReadNone);
2459   }
2460   void setDoesNotAccessMemory(bool doesNotAccessMemory = true) {
2461     if (doesNotAccessMemory) addParamAttr(0, ParamAttr::ReadNone);
2462     else removeParamAttr(0, ParamAttr::ReadNone);
2463   }
2464
2465   /// @brief Determine if the call does not access or only reads memory.
2466   bool onlyReadsMemory() const {
2467     return doesNotAccessMemory() || paramHasAttr(0, ParamAttr::ReadOnly);
2468   }
2469   void setOnlyReadsMemory(bool onlyReadsMemory = true) {
2470     if (onlyReadsMemory) addParamAttr(0, ParamAttr::ReadOnly);
2471     else removeParamAttr(0, ParamAttr::ReadOnly | ParamAttr::ReadNone);
2472   }
2473
2474   /// @brief Determine if the call cannot return.
2475   bool doesNotReturn() const {
2476     return paramHasAttr(0, ParamAttr::NoReturn);
2477   }
2478   void setDoesNotReturn(bool doesNotReturn = true) {
2479     if (doesNotReturn) addParamAttr(0, ParamAttr::NoReturn);
2480     else removeParamAttr(0, ParamAttr::NoReturn);
2481   }
2482
2483   /// @brief Determine if the call cannot unwind.
2484   bool doesNotThrow() const {
2485     return paramHasAttr(0, ParamAttr::NoUnwind);
2486   }
2487   void setDoesNotThrow(bool doesNotThrow = true) {
2488     if (doesNotThrow) addParamAttr(0, ParamAttr::NoUnwind);
2489     else removeParamAttr(0, ParamAttr::NoUnwind);
2490   }
2491
2492   /// @brief Determine if the call returns a structure through first
2493   /// pointer argument.
2494   bool hasStructRetAttr() const {
2495     // Be friendly and also check the callee.
2496     return paramHasAttr(1, ParamAttr::StructRet);
2497   }
2498
2499   /// getCalledFunction - Return the function called, or null if this is an
2500   /// indirect function invocation.
2501   ///
2502   Function *getCalledFunction() const {
2503     return dyn_cast<Function>(getOperand(0));
2504   }
2505
2506   // getCalledValue - Get a pointer to a function that is invoked by this inst.
2507   Value *getCalledValue() const { return getOperand(0); }
2508
2509   // get*Dest - Return the destination basic blocks...
2510   BasicBlock *getNormalDest() const {
2511     return cast<BasicBlock>(getOperand(1));
2512   }
2513   BasicBlock *getUnwindDest() const {
2514     return cast<BasicBlock>(getOperand(2));
2515   }
2516   void setNormalDest(BasicBlock *B) {
2517     setOperand(1, B);
2518   }
2519
2520   void setUnwindDest(BasicBlock *B) {
2521     setOperand(2, B);
2522   }
2523
2524   BasicBlock *getSuccessor(unsigned i) const {
2525     assert(i < 2 && "Successor # out of range for invoke!");
2526     return i == 0 ? getNormalDest() : getUnwindDest();
2527   }
2528
2529   void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
2530     assert(idx < 2 && "Successor # out of range for invoke!");
2531     setOperand(idx+1, NewSucc);
2532   }
2533
2534   unsigned getNumSuccessors() const { return 2; }
2535
2536   // Methods for support type inquiry through isa, cast, and dyn_cast:
2537   static inline bool classof(const InvokeInst *) { return true; }
2538   static inline bool classof(const Instruction *I) {
2539     return (I->getOpcode() == Instruction::Invoke);
2540   }
2541   static inline bool classof(const Value *V) {
2542     return isa<Instruction>(V) && classof(cast<Instruction>(V));
2543   }
2544 private:
2545   virtual BasicBlock *getSuccessorV(unsigned idx) const;
2546   virtual unsigned getNumSuccessorsV() const;
2547   virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2548 };
2549
2550 template <>
2551 struct OperandTraits<InvokeInst> : VariadicOperandTraits<3> {
2552 };
2553
2554 template<typename InputIterator>
2555 InvokeInst::InvokeInst(Value *Func,
2556                        BasicBlock *IfNormal, BasicBlock *IfException,
2557                        InputIterator ArgBegin, InputIterator ArgEnd,
2558                        unsigned Values,
2559                        const std::string &Name, Instruction *InsertBefore)
2560   : TerminatorInst(cast<FunctionType>(cast<PointerType>(Func->getType())
2561                                       ->getElementType())->getReturnType(),
2562                    Instruction::Invoke,
2563                    OperandTraits<InvokeInst>::op_end(this) - Values,
2564                    Values, InsertBefore) {
2565   init(Func, IfNormal, IfException, ArgBegin, ArgEnd, Name,
2566        typename std::iterator_traits<InputIterator>::iterator_category());
2567 }
2568 template<typename InputIterator>
2569 InvokeInst::InvokeInst(Value *Func,
2570                        BasicBlock *IfNormal, BasicBlock *IfException,
2571                        InputIterator ArgBegin, InputIterator ArgEnd,
2572                        unsigned Values,
2573                        const std::string &Name, BasicBlock *InsertAtEnd)
2574   : TerminatorInst(cast<FunctionType>(cast<PointerType>(Func->getType())
2575                                       ->getElementType())->getReturnType(),
2576                    Instruction::Invoke,
2577                    OperandTraits<InvokeInst>::op_end(this) - Values,
2578                    Values, InsertAtEnd) {
2579   init(Func, IfNormal, IfException, ArgBegin, ArgEnd, Name,
2580        typename std::iterator_traits<InputIterator>::iterator_category());
2581 }
2582
2583 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InvokeInst, Value)
2584
2585 //===----------------------------------------------------------------------===//
2586 //                              UnwindInst Class
2587 //===----------------------------------------------------------------------===//
2588
2589 //===---------------------------------------------------------------------------
2590 /// UnwindInst - Immediately exit the current function, unwinding the stack
2591 /// until an invoke instruction is found.
2592 ///
2593 class UnwindInst : public TerminatorInst {
2594   void *operator new(size_t, unsigned);  // DO NOT IMPLEMENT
2595 public:
2596   // allocate space for exactly zero operands
2597   void *operator new(size_t s) {
2598     return User::operator new(s, 0);
2599   }
2600   explicit UnwindInst(Instruction *InsertBefore = 0);
2601   explicit UnwindInst(BasicBlock *InsertAtEnd);
2602
2603   virtual UnwindInst *clone() const;
2604
2605   unsigned getNumSuccessors() const { return 0; }
2606
2607   // Methods for support type inquiry through isa, cast, and dyn_cast:
2608   static inline bool classof(const UnwindInst *) { return true; }
2609   static inline bool classof(const Instruction *I) {
2610     return I->getOpcode() == Instruction::Unwind;
2611   }
2612   static inline bool classof(const Value *V) {
2613     return isa<Instruction>(V) && classof(cast<Instruction>(V));
2614   }
2615 private:
2616   virtual BasicBlock *getSuccessorV(unsigned idx) const;
2617   virtual unsigned getNumSuccessorsV() const;
2618   virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2619 };
2620
2621 //===----------------------------------------------------------------------===//
2622 //                           UnreachableInst Class
2623 //===----------------------------------------------------------------------===//
2624
2625 //===---------------------------------------------------------------------------
2626 /// UnreachableInst - This function has undefined behavior.  In particular, the
2627 /// presence of this instruction indicates some higher level knowledge that the
2628 /// end of the block cannot be reached.
2629 ///
2630 class UnreachableInst : public TerminatorInst {
2631   void *operator new(size_t, unsigned);  // DO NOT IMPLEMENT
2632 public:
2633   // allocate space for exactly zero operands
2634   void *operator new(size_t s) {
2635     return User::operator new(s, 0);
2636   }
2637   explicit UnreachableInst(Instruction *InsertBefore = 0);
2638   explicit UnreachableInst(BasicBlock *InsertAtEnd);
2639
2640   virtual UnreachableInst *clone() const;
2641
2642   unsigned getNumSuccessors() const { return 0; }
2643
2644   // Methods for support type inquiry through isa, cast, and dyn_cast:
2645   static inline bool classof(const UnreachableInst *) { return true; }
2646   static inline bool classof(const Instruction *I) {
2647     return I->getOpcode() == Instruction::Unreachable;
2648   }
2649   static inline bool classof(const Value *V) {
2650     return isa<Instruction>(V) && classof(cast<Instruction>(V));
2651   }
2652 private:
2653   virtual BasicBlock *getSuccessorV(unsigned idx) const;
2654   virtual unsigned getNumSuccessorsV() const;
2655   virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2656 };
2657
2658 //===----------------------------------------------------------------------===//
2659 //                                 TruncInst Class
2660 //===----------------------------------------------------------------------===//
2661
2662 /// @brief This class represents a truncation of integer types.
2663 class TruncInst : public CastInst {
2664   /// Private copy constructor
2665   TruncInst(const TruncInst &CI)
2666     : CastInst(CI.getType(), Trunc, CI.getOperand(0)) {
2667   }
2668 public:
2669   /// @brief Constructor with insert-before-instruction semantics
2670   TruncInst(
2671     Value *S,                     ///< The value to be truncated
2672     const Type *Ty,               ///< The (smaller) type to truncate to
2673     const std::string &Name = "", ///< A name for the new instruction
2674     Instruction *InsertBefore = 0 ///< Where to insert the new instruction
2675   );
2676
2677   /// @brief Constructor with insert-at-end-of-block semantics
2678   TruncInst(
2679     Value *S,                     ///< The value to be truncated
2680     const Type *Ty,               ///< The (smaller) type to truncate to
2681     const std::string &Name,      ///< A name for the new instruction
2682     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
2683   );
2684
2685   /// @brief Clone an identical TruncInst
2686   virtual CastInst *clone() const;
2687
2688   /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
2689   static inline bool classof(const TruncInst *) { return true; }
2690   static inline bool classof(const Instruction *I) {
2691     return I->getOpcode() == Trunc;
2692   }
2693   static inline bool classof(const Value *V) {
2694     return isa<Instruction>(V) && classof(cast<Instruction>(V));
2695   }
2696 };
2697
2698 //===----------------------------------------------------------------------===//
2699 //                                 ZExtInst Class
2700 //===----------------------------------------------------------------------===//
2701
2702 /// @brief This class represents zero extension of integer types.
2703 class ZExtInst : public CastInst {
2704   /// @brief Private copy constructor
2705   ZExtInst(const ZExtInst &CI)
2706     : CastInst(CI.getType(), ZExt, CI.getOperand(0)) {
2707   }
2708 public:
2709   /// @brief Constructor with insert-before-instruction semantics
2710   ZExtInst(
2711     Value *S,                     ///< The value to be zero extended
2712     const Type *Ty,               ///< The type to zero extend to
2713     const std::string &Name = "", ///< A name for the new instruction
2714     Instruction *InsertBefore = 0 ///< Where to insert the new instruction
2715   );
2716
2717   /// @brief Constructor with insert-at-end semantics.
2718   ZExtInst(
2719     Value *S,                     ///< The value to be zero extended
2720     const Type *Ty,               ///< The type to zero extend to
2721     const std::string &Name,      ///< A name for the new instruction
2722     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
2723   );
2724
2725   /// @brief Clone an identical ZExtInst
2726   virtual CastInst *clone() const;
2727
2728   /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
2729   static inline bool classof(const ZExtInst *) { return true; }
2730   static inline bool classof(const Instruction *I) {
2731     return I->getOpcode() == ZExt;
2732   }
2733   static inline bool classof(const Value *V) {
2734     return isa<Instruction>(V) && classof(cast<Instruction>(V));
2735   }
2736 };
2737
2738 //===----------------------------------------------------------------------===//
2739 //                                 SExtInst Class
2740 //===----------------------------------------------------------------------===//
2741
2742 /// @brief This class represents a sign extension of integer types.
2743 class SExtInst : public CastInst {
2744   /// @brief Private copy constructor
2745   SExtInst(const SExtInst &CI)
2746     : CastInst(CI.getType(), SExt, CI.getOperand(0)) {
2747   }
2748 public:
2749   /// @brief Constructor with insert-before-instruction semantics
2750   SExtInst(
2751     Value *S,                     ///< The value to be sign extended
2752     const Type *Ty,               ///< The type to sign extend to
2753     const std::string &Name = "", ///< A name for the new instruction
2754     Instruction *InsertBefore = 0 ///< Where to insert the new instruction
2755   );
2756
2757   /// @brief Constructor with insert-at-end-of-block semantics
2758   SExtInst(
2759     Value *S,                     ///< The value to be sign extended
2760     const Type *Ty,               ///< The type to sign extend to
2761     const std::string &Name,      ///< A name for the new instruction
2762     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
2763   );
2764
2765   /// @brief Clone an identical SExtInst
2766   virtual CastInst *clone() const;
2767
2768   /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
2769   static inline bool classof(const SExtInst *) { return true; }
2770   static inline bool classof(const Instruction *I) {
2771     return I->getOpcode() == SExt;
2772   }
2773   static inline bool classof(const Value *V) {
2774     return isa<Instruction>(V) && classof(cast<Instruction>(V));
2775   }
2776 };
2777
2778 //===----------------------------------------------------------------------===//
2779 //                                 FPTruncInst Class
2780 //===----------------------------------------------------------------------===//
2781
2782 /// @brief This class represents a truncation of floating point types.
2783 class FPTruncInst : public CastInst {
2784   FPTruncInst(const FPTruncInst &CI)
2785     : CastInst(CI.getType(), FPTrunc, CI.getOperand(0)) {
2786   }
2787 public:
2788   /// @brief Constructor with insert-before-instruction semantics
2789   FPTruncInst(
2790     Value *S,                     ///< The value to be truncated
2791     const Type *Ty,               ///< The type to truncate to
2792     const std::string &Name = "", ///< A name for the new instruction
2793     Instruction *InsertBefore = 0 ///< Where to insert the new instruction
2794   );
2795
2796   /// @brief Constructor with insert-before-instruction semantics
2797   FPTruncInst(
2798     Value *S,                     ///< The value to be truncated
2799     const Type *Ty,               ///< The type to truncate to
2800     const std::string &Name,      ///< A name for the new instruction
2801     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
2802   );
2803
2804   /// @brief Clone an identical FPTruncInst
2805   virtual CastInst *clone() const;
2806
2807   /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
2808   static inline bool classof(const FPTruncInst *) { return true; }
2809   static inline bool classof(const Instruction *I) {
2810     return I->getOpcode() == FPTrunc;
2811   }
2812   static inline bool classof(const Value *V) {
2813     return isa<Instruction>(V) && classof(cast<Instruction>(V));
2814   }
2815 };
2816
2817 //===----------------------------------------------------------------------===//
2818 //                                 FPExtInst Class
2819 //===----------------------------------------------------------------------===//
2820
2821 /// @brief This class represents an extension of floating point types.
2822 class FPExtInst : public CastInst {
2823   FPExtInst(const FPExtInst &CI)
2824     : CastInst(CI.getType(), FPExt, CI.getOperand(0)) {
2825   }
2826 public:
2827   /// @brief Constructor with insert-before-instruction semantics
2828   FPExtInst(
2829     Value *S,                     ///< The value to be extended
2830     const Type *Ty,               ///< The type to extend to
2831     const std::string &Name = "", ///< A name for the new instruction
2832     Instruction *InsertBefore = 0 ///< Where to insert the new instruction
2833   );
2834
2835   /// @brief Constructor with insert-at-end-of-block semantics
2836   FPExtInst(
2837     Value *S,                     ///< The value to be extended
2838     const Type *Ty,               ///< The type to extend to
2839     const std::string &Name,      ///< A name for the new instruction
2840     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
2841   );
2842
2843   /// @brief Clone an identical FPExtInst
2844   virtual CastInst *clone() const;
2845
2846   /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
2847   static inline bool classof(const FPExtInst *) { return true; }
2848   static inline bool classof(const Instruction *I) {
2849     return I->getOpcode() == FPExt;
2850   }
2851   static inline bool classof(const Value *V) {
2852     return isa<Instruction>(V) && classof(cast<Instruction>(V));
2853   }
2854 };
2855
2856 //===----------------------------------------------------------------------===//
2857 //                                 UIToFPInst Class
2858 //===----------------------------------------------------------------------===//
2859
2860 /// @brief This class represents a cast unsigned integer to floating point.
2861 class UIToFPInst : public CastInst {
2862   UIToFPInst(const UIToFPInst &CI)
2863     : CastInst(CI.getType(), UIToFP, CI.getOperand(0)) {
2864   }
2865 public:
2866   /// @brief Constructor with insert-before-instruction semantics
2867   UIToFPInst(
2868     Value *S,                     ///< The value to be converted
2869     const Type *Ty,               ///< The type to convert to
2870     const std::string &Name = "", ///< A name for the new instruction
2871     Instruction *InsertBefore = 0 ///< Where to insert the new instruction
2872   );
2873
2874   /// @brief Constructor with insert-at-end-of-block semantics
2875   UIToFPInst(
2876     Value *S,                     ///< The value to be converted
2877     const Type *Ty,               ///< The type to convert to
2878     const std::string &Name,      ///< A name for the new instruction
2879     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
2880   );
2881
2882   /// @brief Clone an identical UIToFPInst
2883   virtual CastInst *clone() const;
2884
2885   /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
2886   static inline bool classof(const UIToFPInst *) { return true; }
2887   static inline bool classof(const Instruction *I) {
2888     return I->getOpcode() == UIToFP;
2889   }
2890   static inline bool classof(const Value *V) {
2891     return isa<Instruction>(V) && classof(cast<Instruction>(V));
2892   }
2893 };
2894
2895 //===----------------------------------------------------------------------===//
2896 //                                 SIToFPInst Class
2897 //===----------------------------------------------------------------------===//
2898
2899 /// @brief This class represents a cast from signed integer to floating point.
2900 class SIToFPInst : public CastInst {
2901   SIToFPInst(const SIToFPInst &CI)
2902     : CastInst(CI.getType(), SIToFP, CI.getOperand(0)) {
2903   }
2904 public:
2905   /// @brief Constructor with insert-before-instruction semantics
2906   SIToFPInst(
2907     Value *S,                     ///< The value to be converted
2908     const Type *Ty,               ///< The type to convert to
2909     const std::string &Name = "", ///< A name for the new instruction
2910     Instruction *InsertBefore = 0 ///< Where to insert the new instruction
2911   );
2912
2913   /// @brief Constructor with insert-at-end-of-block semantics
2914   SIToFPInst(
2915     Value *S,                     ///< The value to be converted
2916     const Type *Ty,               ///< The type to convert to
2917     const std::string &Name,      ///< A name for the new instruction
2918     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
2919   );
2920
2921   /// @brief Clone an identical SIToFPInst
2922   virtual CastInst *clone() const;
2923
2924   /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
2925   static inline bool classof(const SIToFPInst *) { return true; }
2926   static inline bool classof(const Instruction *I) {
2927     return I->getOpcode() == SIToFP;
2928   }
2929   static inline bool classof(const Value *V) {
2930     return isa<Instruction>(V) && classof(cast<Instruction>(V));
2931   }
2932 };
2933
2934 //===----------------------------------------------------------------------===//
2935 //                                 FPToUIInst Class
2936 //===----------------------------------------------------------------------===//
2937
2938 /// @brief This class represents a cast from floating point to unsigned integer
2939 class FPToUIInst  : public CastInst {
2940   FPToUIInst(const FPToUIInst &CI)
2941     : CastInst(CI.getType(), FPToUI, CI.getOperand(0)) {
2942   }
2943 public:
2944   /// @brief Constructor with insert-before-instruction semantics
2945   FPToUIInst(
2946     Value *S,                     ///< The value to be converted
2947     const Type *Ty,               ///< The type to convert to
2948     const std::string &Name = "", ///< A name for the new instruction
2949     Instruction *InsertBefore = 0 ///< Where to insert the new instruction
2950   );
2951
2952   /// @brief Constructor with insert-at-end-of-block semantics
2953   FPToUIInst(
2954     Value *S,                     ///< The value to be converted
2955     const Type *Ty,               ///< The type to convert to
2956     const std::string &Name,      ///< A name for the new instruction
2957     BasicBlock *InsertAtEnd       ///< Where to insert the new instruction
2958   );
2959
2960   /// @brief Clone an identical FPToUIInst
2961   virtual CastInst *clone() const;
2962
2963   /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
2964   static inline bool classof(const FPToUIInst *) { return true; }
2965   static inline bool classof(const Instruction *I) {
2966     return I->getOpcode() == FPToUI;
2967   }
2968   static inline bool classof(const Value *V) {
2969     return isa<Instruction>(V) && classof(cast<Instruction>(V));
2970   }
2971 };
2972
2973 //===----------------------------------------------------------------------===//
2974 //                                 FPToSIInst Class
2975 //===----------------------------------------------------------------------===//
2976
2977 /// @brief This class represents a cast from floating point to signed integer.
2978 class FPToSIInst  : public CastInst {
2979   FPToSIInst(const FPToSIInst &CI)
2980     : CastInst(CI.getType(), FPToSI, CI.getOperand(0)) {
2981   }
2982 public:
2983   /// @brief Constructor with insert-before-instruction semantics
2984   FPToSIInst(
2985     Value *S,                     ///< The value to be converted
2986     const Type *Ty,               ///< The type to convert to
2987     const std::string &Name = "", ///< A name for the new instruction
2988     Instruction *InsertBefore = 0 ///< Where to insert the new instruction
2989   );
2990
2991   /// @brief Constructor with insert-at-end-of-block semantics
2992   FPToSIInst(
2993     Value *S,                     ///< The value to be converted
2994     const Type *Ty,               ///< The type to convert to
2995     const std::string &Name,      ///< A name for the new instruction
2996     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
2997   );
2998
2999   /// @brief Clone an identical FPToSIInst
3000   virtual CastInst *clone() const;
3001
3002   /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
3003   static inline bool classof(const FPToSIInst *) { return true; }
3004   static inline bool classof(const Instruction *I) {
3005     return I->getOpcode() == FPToSI;
3006   }
3007   static inline bool classof(const Value *V) {
3008     return isa<Instruction>(V) && classof(cast<Instruction>(V));
3009   }
3010 };
3011
3012 //===----------------------------------------------------------------------===//
3013 //                                 IntToPtrInst Class
3014 //===----------------------------------------------------------------------===//
3015
3016 /// @brief This class represents a cast from an integer to a pointer.
3017 class IntToPtrInst : public CastInst {
3018   IntToPtrInst(const IntToPtrInst &CI)
3019     : CastInst(CI.getType(), IntToPtr, CI.getOperand(0)) {
3020   }
3021 public:
3022   /// @brief Constructor with insert-before-instruction semantics
3023   IntToPtrInst(
3024     Value *S,                     ///< The value to be converted
3025     const Type *Ty,               ///< The type to convert to
3026     const std::string &Name = "", ///< A name for the new instruction
3027     Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3028   );
3029
3030   /// @brief Constructor with insert-at-end-of-block semantics
3031   IntToPtrInst(
3032     Value *S,                     ///< The value to be converted
3033     const Type *Ty,               ///< The type to convert to
3034     const std::string &Name,      ///< A name for the new instruction
3035     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
3036   );
3037
3038   /// @brief Clone an identical IntToPtrInst
3039   virtual CastInst *clone() const;
3040
3041   // Methods for support type inquiry through isa, cast, and dyn_cast:
3042   static inline bool classof(const IntToPtrInst *) { return true; }
3043   static inline bool classof(const Instruction *I) {
3044     return I->getOpcode() == IntToPtr;
3045   }
3046   static inline bool classof(const Value *V) {
3047     return isa<Instruction>(V) && classof(cast<Instruction>(V));
3048   }
3049 };
3050
3051 //===----------------------------------------------------------------------===//
3052 //                                 PtrToIntInst Class
3053 //===----------------------------------------------------------------------===//
3054
3055 /// @brief This class represents a cast from a pointer to an integer
3056 class PtrToIntInst : public CastInst {
3057   PtrToIntInst(const PtrToIntInst &CI)
3058     : CastInst(CI.getType(), PtrToInt, CI.getOperand(0)) {
3059   }
3060 public:
3061   /// @brief Constructor with insert-before-instruction semantics
3062   PtrToIntInst(
3063     Value *S,                     ///< The value to be converted
3064     const Type *Ty,               ///< The type to convert to
3065     const std::string &Name = "", ///< A name for the new instruction
3066     Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3067   );
3068
3069   /// @brief Constructor with insert-at-end-of-block semantics
3070   PtrToIntInst(
3071     Value *S,                     ///< The value to be converted
3072     const Type *Ty,               ///< The type to convert to
3073     const std::string &Name,      ///< A name for the new instruction
3074     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
3075   );
3076
3077   /// @brief Clone an identical PtrToIntInst
3078   virtual CastInst *clone() const;
3079
3080   // Methods for support type inquiry through isa, cast, and dyn_cast:
3081   static inline bool classof(const PtrToIntInst *) { return true; }
3082   static inline bool classof(const Instruction *I) {
3083     return I->getOpcode() == PtrToInt;
3084   }
3085   static inline bool classof(const Value *V) {
3086     return isa<Instruction>(V) && classof(cast<Instruction>(V));
3087   }
3088 };
3089
3090 //===----------------------------------------------------------------------===//
3091 //                             BitCastInst Class
3092 //===----------------------------------------------------------------------===//
3093
3094 /// @brief This class represents a no-op cast from one type to another.
3095 class BitCastInst : public CastInst {
3096   BitCastInst(const BitCastInst &CI)
3097     : CastInst(CI.getType(), BitCast, CI.getOperand(0)) {
3098   }
3099 public:
3100   /// @brief Constructor with insert-before-instruction semantics
3101   BitCastInst(
3102     Value *S,                     ///< The value to be casted
3103     const Type *Ty,               ///< The type to casted to
3104     const std::string &Name = "", ///< A name for the new instruction
3105     Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3106   );
3107
3108   /// @brief Constructor with insert-at-end-of-block semantics
3109   BitCastInst(
3110     Value *S,                     ///< The value to be casted
3111     const Type *Ty,               ///< The type to casted to
3112     const std::string &Name,      ///< A name for the new instruction
3113     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
3114   );
3115
3116   /// @brief Clone an identical BitCastInst
3117   virtual CastInst *clone() const;
3118
3119   // Methods for support type inquiry through isa, cast, and dyn_cast:
3120   static inline bool classof(const BitCastInst *) { return true; }
3121   static inline bool classof(const Instruction *I) {
3122     return I->getOpcode() == BitCast;
3123   }
3124   static inline bool classof(const Value *V) {
3125     return isa<Instruction>(V) && classof(cast<Instruction>(V));
3126   }
3127 };
3128
3129 //===----------------------------------------------------------------------===//
3130 //                             GetResultInst Class
3131 //===----------------------------------------------------------------------===//
3132
3133 /// GetResultInst - This instruction extracts individual result value from
3134 /// aggregate value, where aggregate value is returned by CallInst.
3135 ///
3136 class GetResultInst : public UnaryInstruction {
3137   unsigned Idx;
3138   GetResultInst(const GetResultInst &GRI) :
3139     UnaryInstruction(GRI.getType(), Instruction::GetResult, GRI.getOperand(0)),
3140     Idx(GRI.Idx) {
3141   }
3142
3143 public:
3144   GetResultInst(Value *Aggr, unsigned index,
3145                 const std::string &Name = "",
3146                 Instruction *InsertBefore = 0);
3147
3148   /// isValidOperands - Return true if an getresult instruction can be
3149   /// formed with the specified operands.
3150   static bool isValidOperands(const Value *Aggr, unsigned index);
3151
3152   virtual GetResultInst *clone() const;
3153
3154   Value *getAggregateValue() {
3155     return getOperand(0);
3156   }
3157
3158   const Value *getAggregateValue() const {
3159     return getOperand(0);
3160   }
3161
3162   unsigned getIndex() const {
3163     return Idx;
3164   }
3165
3166   // Methods for support type inquiry through isa, cast, and dyn_cast:
3167   static inline bool classof(const GetResultInst *) { return true; }
3168   static inline bool classof(const Instruction *I) {
3169     return (I->getOpcode() == Instruction::GetResult);
3170   }
3171   static inline bool classof(const Value *V) {
3172     return isa<Instruction>(V) && classof(cast<Instruction>(V));
3173   }
3174 };
3175
3176 } // End llvm namespace
3177
3178 #endif