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