include/llvm/Instructions.h

   1 //===-- llvm/Instructions.h - Instruction subclass definitions --*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source 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/Instruction.h"
  20 #include "llvm/InstrTypes.h"
  21
  22 namespace llvm {
  23
  24 class BasicBlock;
  25 class ConstantInt;
  26 class PointerType;
  27
  28 //===----------------------------------------------------------------------===//
  29 //                             AllocationInst Class
  30 //===----------------------------------------------------------------------===//
  31
  32 /// AllocationInst - This class is the common base class of MallocInst and
  33 /// AllocaInst.
  34 ///
  35 class AllocationInst : public UnaryInstruction {
  36 protected:
  37   AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy,
  38                  const std::string &Name = "", Instruction *InsertBefore = 0);
  39   AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy,
  40                  const std::string &Name, BasicBlock *InsertAtEnd);
  41
  42 public:
  43
  44   /// isArrayAllocation - Return true if there is an allocation size parameter
  45   /// to the allocation instruction that is not 1.
  46   ///
  47   bool isArrayAllocation() const;
  48
  49   /// getArraySize - Get the number of element allocated, for a simple
  50   /// allocation of a single element, this will return a constant 1 value.
  51   ///
  52   inline const Value *getArraySize() const { return getOperand(0); }
  53   inline Value *getArraySize() { return getOperand(0); }
  54
  55   /// getType - Overload to return most specific pointer type
  56   ///
  57   inline const PointerType *getType() const {
  58     return reinterpret_cast<const PointerType*>(Instruction::getType());
  59   }
  60
  61   /// getAllocatedType - Return the type that is being allocated by the
  62   /// instruction.
  63   ///
  64   const Type *getAllocatedType() const;
  65
  66   virtual Instruction *clone() const = 0;
  67
  68   // Methods for support type inquiry through isa, cast, and dyn_cast:
  69   static inline bool classof(const AllocationInst *) { return true; }
  70   static inline bool classof(const Instruction *I) {
  71     return I->getOpcode() == Instruction::Alloca ||
  72            I->getOpcode() == Instruction::Malloc;
  73   }
  74   static inline bool classof(const Value *V) {
  75     return isa<Instruction>(V) && classof(cast<Instruction>(V));
  76   }
  77 };
  78
  79
  80 //===----------------------------------------------------------------------===//
  81 //                                MallocInst Class
  82 //===----------------------------------------------------------------------===//
  83
  84 /// MallocInst - an instruction to allocated memory on the heap
  85 ///
  86 class MallocInst : public AllocationInst {
  87   MallocInst(const MallocInst &MI);
  88 public:
  89   explicit MallocInst(const Type *Ty, Value *ArraySize = 0,
  90                       const std::string &Name = "",
  91                       Instruction *InsertBefore = 0)
  92     : AllocationInst(Ty, ArraySize, Malloc, Name, InsertBefore) {}
  93   MallocInst(const Type *Ty, Value *ArraySize, const std::string &Name,
  94              BasicBlock *InsertAtEnd)
  95     : AllocationInst(Ty, ArraySize, Malloc, Name, InsertAtEnd) {}
  96
  97   virtual MallocInst *clone() const;
  98
  99   // Methods for support type inquiry through isa, cast, and dyn_cast:
 100   static inline bool classof(const MallocInst *) { return true; }
 101   static inline bool classof(const Instruction *I) {
 102     return (I->getOpcode() == Instruction::Malloc);
 103   }
 104   static inline bool classof(const Value *V) {
 105     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 106   }
 107 };
 108
 109
 110 //===----------------------------------------------------------------------===//
 111 //                                AllocaInst Class
 112 //===----------------------------------------------------------------------===//
 113
 114 /// AllocaInst - an instruction to allocate memory on the stack
 115 ///
 116 class AllocaInst : public AllocationInst {
 117   AllocaInst(const AllocaInst &);
 118 public:
 119   explicit AllocaInst(const Type *Ty, Value *ArraySize = 0,
 120                       const std::string &Name = "",
 121                       Instruction *InsertBefore = 0)
 122     : AllocationInst(Ty, ArraySize, Alloca, Name, InsertBefore) {}
 123   AllocaInst(const Type *Ty, Value *ArraySize, const std::string &Name,
 124              BasicBlock *InsertAtEnd)
 125     : AllocationInst(Ty, ArraySize, Alloca, Name, InsertAtEnd) {}
 126
 127   virtual AllocaInst *clone() const;
 128
 129   // Methods for support type inquiry through isa, cast, and dyn_cast:
 130   static inline bool classof(const AllocaInst *) { return true; }
 131   static inline bool classof(const Instruction *I) {
 132     return (I->getOpcode() == Instruction::Alloca);
 133   }
 134   static inline bool classof(const Value *V) {
 135     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 136   }
 137 };
 138
 139
 140 //===----------------------------------------------------------------------===//
 141 //                                 FreeInst Class
 142 //===----------------------------------------------------------------------===//
 143
 144 /// FreeInst - an instruction to deallocate memory
 145 ///
 146 class FreeInst : public UnaryInstruction {
 147   void AssertOK();
 148 public:
 149   explicit FreeInst(Value *Ptr, Instruction *InsertBefore = 0);
 150   FreeInst(Value *Ptr, BasicBlock *InsertAfter);
 151
 152   virtual FreeInst *clone() const;
 153
 154   virtual bool mayWriteToMemory() const { return true; }
 155
 156   // Methods for support type inquiry through isa, cast, and dyn_cast:
 157   static inline bool classof(const FreeInst *) { return true; }
 158   static inline bool classof(const Instruction *I) {
 159     return (I->getOpcode() == Instruction::Free);
 160   }
 161   static inline bool classof(const Value *V) {
 162     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 163   }
 164 };
 165
 166
 167 //===----------------------------------------------------------------------===//
 168 //                                LoadInst Class
 169 //===----------------------------------------------------------------------===//
 170
 171 /// LoadInst - an instruction for reading from memory.  This uses the
 172 /// SubclassData field in Value to store whether or not the load is volatile.
 173 ///
 174 class LoadInst : public UnaryInstruction {
 175   LoadInst(const LoadInst &LI)
 176     : UnaryInstruction(LI.getType(), Load, LI.getOperand(0)) {
 177     setVolatile(LI.isVolatile());
 178
 179 #ifndef NDEBUG
 180     AssertOK();
 181 #endif
 182   }
 183   void AssertOK();
 184 public:
 185   LoadInst(Value *Ptr, const std::string &Name, Instruction *InsertBefore);
 186   LoadInst(Value *Ptr, const std::string &Name, BasicBlock *InsertAtEnd);
 187   LoadInst(Value *Ptr, const std::string &Name = "", bool isVolatile = false,
 188            Instruction *InsertBefore = 0);
 189   LoadInst(Value *Ptr, const std::string &Name, bool isVolatile,
 190            BasicBlock *InsertAtEnd);
 191
 192   /// isVolatile - Return true if this is a load from a volatile memory
 193   /// location.
 194   ///
 195   bool isVolatile() const { return SubclassData; }
 196
 197   /// setVolatile - Specify whether this is a volatile load or not.
 198   ///
 199   void setVolatile(bool V) { SubclassData = V; }
 200
 201   virtual LoadInst *clone() const;
 202
 203   virtual bool mayWriteToMemory() const { return isVolatile(); }
 204
 205   Value *getPointerOperand() { return getOperand(0); }
 206   const Value *getPointerOperand() const { return getOperand(0); }
 207   static unsigned getPointerOperandIndex() { return 0U; }
 208
 209   // Methods for support type inquiry through isa, cast, and dyn_cast:
 210   static inline bool classof(const LoadInst *) { return true; }
 211   static inline bool classof(const Instruction *I) {
 212     return I->getOpcode() == Instruction::Load;
 213   }
 214   static inline bool classof(const Value *V) {
 215     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 216   }
 217 };
 218
 219
 220 //===----------------------------------------------------------------------===//
 221 //                                StoreInst Class
 222 //===----------------------------------------------------------------------===//
 223
 224 /// StoreInst - an instruction for storing to memory
 225 ///
 226 class StoreInst : public Instruction {
 227   Use Ops[2];
 228   StoreInst(const StoreInst &SI) : Instruction(SI.getType(), Store, Ops, 2) {
 229     Ops[0].init(SI.Ops[0], this);
 230     Ops[1].init(SI.Ops[1], this);
 231     setVolatile(SI.isVolatile());
 232 #ifndef NDEBUG
 233     AssertOK();
 234 #endif
 235   }
 236   void AssertOK();
 237 public:
 238   StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore);
 239   StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd);
 240   StoreInst(Value *Val, Value *Ptr, bool isVolatile = false,
 241             Instruction *InsertBefore = 0);
 242   StoreInst(Value *Val, Value *Ptr, bool isVolatile, BasicBlock *InsertAtEnd);
 243
 244
 245   /// isVolatile - Return true if this is a load from a volatile memory
 246   /// location.
 247   ///
 248   bool isVolatile() const { return SubclassData; }
 249
 250   /// setVolatile - Specify whether this is a volatile load or not.
 251   ///
 252   void setVolatile(bool V) { SubclassData = V; }
 253
 254   /// Transparently provide more efficient getOperand methods.
 255   Value *getOperand(unsigned i) const {
 256     assert(i < 2 && "getOperand() out of range!");
 257     return Ops[i];
 258   }
 259   void setOperand(unsigned i, Value *Val) {
 260     assert(i < 2 && "setOperand() out of range!");
 261     Ops[i] = Val;
 262   }
 263   unsigned getNumOperands() const { return 2; }
 264
 265
 266   virtual StoreInst *clone() const;
 267
 268   virtual bool mayWriteToMemory() const { return true; }
 269
 270   Value *getPointerOperand() { return getOperand(1); }
 271   const Value *getPointerOperand() const { return getOperand(1); }
 272   static unsigned getPointerOperandIndex() { return 1U; }
 273
 274   // Methods for support type inquiry through isa, cast, and dyn_cast:
 275   static inline bool classof(const StoreInst *) { return true; }
 276   static inline bool classof(const Instruction *I) {
 277     return I->getOpcode() == Instruction::Store;
 278   }
 279   static inline bool classof(const Value *V) {
 280     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 281   }
 282 };
 283
 284
 285 //===----------------------------------------------------------------------===//
 286 //                             GetElementPtrInst Class
 287 //===----------------------------------------------------------------------===//
 288
 289 /// GetElementPtrInst - an instruction for type-safe pointer arithmetic to
 290 /// access elements of arrays and structs
 291 ///
 292 class GetElementPtrInst : public Instruction {
 293   GetElementPtrInst(const GetElementPtrInst &GEPI)
 294     : Instruction(reinterpret_cast<const Type*>(GEPI.getType()), GetElementPtr,
 295                   0, GEPI.getNumOperands()) {
 296     Use *OL = OperandList = new Use[NumOperands];
 297     Use *GEPIOL = GEPI.OperandList;
 298     for (unsigned i = 0, E = NumOperands; i != E; ++i)
 299       OL[i].init(GEPIOL[i], this);
 300   }
 301   void init(Value *Ptr, const std::vector<Value*> &Idx);
 302   void init(Value *Ptr, Value *Idx0, Value *Idx1);
 303   void init(Value *Ptr, Value *Idx);
 304 public:
 305   /// Constructors - Create a getelementptr instruction with a base pointer an
 306   /// list of indices.  The first ctor can optionally insert before an existing
 307   /// instruction, the second appends the new instruction to the specified
 308   /// BasicBlock.
 309   GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
 310                     const std::string &Name = "", Instruction *InsertBefore =0);
 311   GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
 312                     const std::string &Name, BasicBlock *InsertAtEnd);
 313
 314   /// Constructors - These two constructors are convenience methods because one
 315   /// and two index getelementptr instructions are so common.
 316   GetElementPtrInst(Value *Ptr, Value *Idx,
 317                     const std::string &Name = "", Instruction *InsertBefore =0);
 318   GetElementPtrInst(Value *Ptr, Value *Idx,
 319                     const std::string &Name, BasicBlock *InsertAtEnd);
 320   GetElementPtrInst(Value *Ptr, Value *Idx0, Value *Idx1,
 321                     const std::string &Name = "", Instruction *InsertBefore =0);
 322   GetElementPtrInst(Value *Ptr, Value *Idx0, Value *Idx1,
 323                     const std::string &Name, BasicBlock *InsertAtEnd);
 324   ~GetElementPtrInst();
 325
 326   virtual GetElementPtrInst *clone() const;
 327
 328   // getType - Overload to return most specific pointer type...
 329   inline const PointerType *getType() const {
 330     return reinterpret_cast<const PointerType*>(Instruction::getType());
 331   }
 332
 333   /// getIndexedType - Returns the type of the element that would be loaded with
 334   /// a load instruction with the specified parameters.
 335   ///
 336   /// A null type is returned if the indices are invalid for the specified
 337   /// pointer type.
 338   ///
 339   static const Type *getIndexedType(const Type *Ptr,
 340                                     const std::vector<Value*> &Indices,
 341                                     bool AllowStructLeaf = false);
 342   static const Type *getIndexedType(const Type *Ptr, Value *Idx0, Value *Idx1,
 343                                     bool AllowStructLeaf = false);
 344   static const Type *getIndexedType(const Type *Ptr, Value *Idx);
 345
 346   inline op_iterator       idx_begin()       { return op_begin()+1; }
 347   inline const_op_iterator idx_begin() const { return op_begin()+1; }
 348   inline op_iterator       idx_end()         { return op_end(); }
 349   inline const_op_iterator idx_end()   const { return op_end(); }
 350
 351   Value *getPointerOperand() {
 352     return getOperand(0);
 353   }
 354   const Value *getPointerOperand() const {
 355     return getOperand(0);
 356   }
 357   static unsigned getPointerOperandIndex() {
 358     return 0U;                      // get index for modifying correct operand
 359   }
 360
 361   inline unsigned getNumIndices() const {  // Note: always non-negative
 362     return getNumOperands() - 1;
 363   }
 364
 365   inline bool hasIndices() const {
 366     return getNumOperands() > 1;
 367   }
 368
 369   // Methods for support type inquiry through isa, cast, and dyn_cast:
 370   static inline bool classof(const GetElementPtrInst *) { return true; }
 371   static inline bool classof(const Instruction *I) {
 372     return (I->getOpcode() == Instruction::GetElementPtr);
 373   }
 374   static inline bool classof(const Value *V) {
 375     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 376   }
 377 };
 378
 379 //===----------------------------------------------------------------------===//
 380 //                            SetCondInst Class
 381 //===----------------------------------------------------------------------===//
 382
 383 /// SetCondInst class - Represent a setCC operator, where CC is eq, ne, lt, gt,
 384 /// le, or ge.
 385 ///
 386 class SetCondInst : public BinaryOperator {
 387 public:
 388   SetCondInst(BinaryOps Opcode, Value *LHS, Value *RHS,
 389               const std::string &Name = "", Instruction *InsertBefore = 0);
 390   SetCondInst(BinaryOps Opcode, Value *LHS, Value *RHS,
 391               const std::string &Name, BasicBlock *InsertAtEnd);
 392
 393   /// getInverseCondition - Return the inverse of the current condition opcode.
 394   /// For example seteq -> setne, setgt -> setle, setlt -> setge, etc...
 395   ///
 396   BinaryOps getInverseCondition() const {
 397     return getInverseCondition(getOpcode());
 398   }
 399
 400   /// getInverseCondition - Static version that you can use without an
 401   /// instruction available.
 402   ///
 403   static BinaryOps getInverseCondition(BinaryOps Opcode);
 404
 405   /// getSwappedCondition - Return the condition opcode that would be the result
 406   /// of exchanging the two operands of the setcc instruction without changing
 407   /// the result produced.  Thus, seteq->seteq, setle->setge, setlt->setgt, etc.
 408   ///
 409   BinaryOps getSwappedCondition() const {
 410     return getSwappedCondition(getOpcode());
 411   }
 412
 413   /// getSwappedCondition - Static version that you can use without an
 414   /// instruction available.
 415   ///
 416   static BinaryOps getSwappedCondition(BinaryOps Opcode);
 417
 418
 419   // Methods for support type inquiry through isa, cast, and dyn_cast:
 420   static inline bool classof(const SetCondInst *) { return true; }
 421   static inline bool classof(const Instruction *I) {
 422     return I->getOpcode() == SetEQ || I->getOpcode() == SetNE ||
 423            I->getOpcode() == SetLE || I->getOpcode() == SetGE ||
 424            I->getOpcode() == SetLT || I->getOpcode() == SetGT;
 425   }
 426   static inline bool classof(const Value *V) {
 427     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 428   }
 429 };
 430
 431 //===----------------------------------------------------------------------===//
 432 //                                 CastInst Class
 433 //===----------------------------------------------------------------------===//
 434
 435 /// CastInst - This class represents a cast from Operand[0] to the type of
 436 /// the instruction (i->getType()).
 437 ///
 438 class CastInst : public UnaryInstruction {
 439   CastInst(const CastInst &CI)
 440     : UnaryInstruction(CI.getType(), Cast, CI.getOperand(0)) {
 441   }
 442 public:
 443   CastInst(Value *S, const Type *Ty, const std::string &Name = "",
 444            Instruction *InsertBefore = 0)
 445     : UnaryInstruction(Ty, Cast, S, Name, InsertBefore) {
 446   }
 447   CastInst(Value *S, const Type *Ty, const std::string &Name,
 448            BasicBlock *InsertAtEnd)
 449     : UnaryInstruction(Ty, Cast, S, Name, InsertAtEnd) {
 450   }
 451
 452   virtual CastInst *clone() const;
 453
 454   // Methods for support type inquiry through isa, cast, and dyn_cast:
 455   static inline bool classof(const CastInst *) { return true; }
 456   static inline bool classof(const Instruction *I) {
 457     return I->getOpcode() == Cast;
 458   }
 459   static inline bool classof(const Value *V) {
 460     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 461   }
 462 };
 463
 464
 465 //===----------------------------------------------------------------------===//
 466 //                                 CallInst Class
 467 //===----------------------------------------------------------------------===//
 468
 469 /// CallInst - This class represents a function call, abstracting a target
 470 /// machine's calling convention.  This class uses low bit of the SubClassData
 471 /// field to indicate whether or not this is a tail call.  The rest of the bits
 472 /// hold the calling convention of the call.
 473 ///
 474 class CallInst : public Instruction {
 475   CallInst(const CallInst &CI);
 476   void init(Value *Func, const std::vector<Value*> &Params);
 477   void init(Value *Func, Value *Actual1, Value *Actual2);
 478   void init(Value *Func, Value *Actual);
 479   void init(Value *Func);
 480
 481 public:
 482   CallInst(Value *F, const std::vector<Value*> &Par,
 483            const std::string &Name = "", Instruction *InsertBefore = 0);
 484   CallInst(Value *F, const std::vector<Value*> &Par,
 485            const std::string &Name, BasicBlock *InsertAtEnd);
 486
 487   // Alternate CallInst ctors w/ two actuals, w/ one actual and no
 488   // actuals, respectively.
 489   CallInst(Value *F, Value *Actual1, Value *Actual2,
 490            const std::string& Name = "", Instruction *InsertBefore = 0);
 491   CallInst(Value *F, Value *Actual1, Value *Actual2,
 492            const std::string& Name, BasicBlock *InsertAtEnd);
 493   CallInst(Value *F, Value *Actual, const std::string& Name = "",
 494            Instruction *InsertBefore = 0);
 495   CallInst(Value *F, Value *Actual, const std::string& Name,
 496            BasicBlock *InsertAtEnd);
 497   explicit CallInst(Value *F, const std::string &Name = "",
 498                     Instruction *InsertBefore = 0);
 499   explicit CallInst(Value *F, const std::string &Name,
 500                     BasicBlock *InsertAtEnd);
 501   ~CallInst();
 502
 503   virtual CallInst *clone() const;
 504   bool mayWriteToMemory() const { return true; }
 505
 506   bool isTailCall() const           { return SubclassData & 1; }
 507   void setTailCall(bool isTailCall = true) {
 508     SubclassData = (SubclassData & ~1) | unsigned(isTailCall);
 509   }
 510
 511   /// getCallingConv/setCallingConv - Get or set the calling convention of this
 512   /// function call.
 513   unsigned getCallingConv() const { return SubclassData >> 1; }
 514   void setCallingConv(unsigned CC) {
 515     SubclassData = (SubclassData & 1) | (CC << 1);
 516   }
 517
 518   /// getCalledFunction - Return the function being called by this instruction
 519   /// if it is a direct call.  If it is a call through a function pointer,
 520   /// return null.
 521   Function *getCalledFunction() const {
 522     return static_cast<Function*>(dyn_cast<Function>(getOperand(0)));
 523   }
 524
 525   // getCalledValue - Get a pointer to a method that is invoked by this inst.
 526   inline const Value *getCalledValue() const { return getOperand(0); }
 527   inline       Value *getCalledValue()       { return getOperand(0); }
 528
 529   // Methods for support type inquiry through isa, cast, and dyn_cast:
 530   static inline bool classof(const CallInst *) { return true; }
 531   static inline bool classof(const Instruction *I) {
 532     return I->getOpcode() == Instruction::Call;
 533   }
 534   static inline bool classof(const Value *V) {
 535     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 536   }
 537 };
 538
 539
 540 //===----------------------------------------------------------------------===//
 541 //                                 ShiftInst Class
 542 //===----------------------------------------------------------------------===//
 543
 544 /// ShiftInst - This class represents left and right shift instructions.
 545 ///
 546 class ShiftInst : public Instruction {
 547   Use Ops[2];
 548   ShiftInst(const ShiftInst &SI)
 549     : Instruction(SI.getType(), SI.getOpcode(), Ops, 2) {
 550     Ops[0].init(SI.Ops[0], this);
 551     Ops[1].init(SI.Ops[1], this);
 552   }
 553   void init(OtherOps Opcode, Value *S, Value *SA) {
 554     assert((Opcode == Shl || Opcode == Shr) && "ShiftInst Opcode invalid!");
 555     Ops[0].init(S, this);
 556     Ops[1].init(SA, this);
 557   }
 558
 559 public:
 560   ShiftInst(OtherOps Opcode, Value *S, Value *SA, const std::string &Name = "",
 561             Instruction *InsertBefore = 0)
 562     : Instruction(S->getType(), Opcode, Ops, 2, Name, InsertBefore) {
 563     init(Opcode, S, SA);
 564   }
 565   ShiftInst(OtherOps Opcode, Value *S, Value *SA, const std::string &Name,
 566             BasicBlock *InsertAtEnd)
 567     : Instruction(S->getType(), Opcode, Ops, 2, Name, InsertAtEnd) {
 568     init(Opcode, S, SA);
 569   }
 570
 571   OtherOps getOpcode() const {
 572     return static_cast<OtherOps>(Instruction::getOpcode());
 573   }
 574
 575   /// Transparently provide more efficient getOperand methods.
 576   Value *getOperand(unsigned i) const {
 577     assert(i < 2 && "getOperand() out of range!");
 578     return Ops[i];
 579   }
 580   void setOperand(unsigned i, Value *Val) {
 581     assert(i < 2 && "setOperand() out of range!");
 582     Ops[i] = Val;
 583   }
 584   unsigned getNumOperands() const { return 2; }
 585
 586   virtual ShiftInst *clone() const;
 587
 588   // Methods for support type inquiry through isa, cast, and dyn_cast:
 589   static inline bool classof(const ShiftInst *) { return true; }
 590   static inline bool classof(const Instruction *I) {
 591     return (I->getOpcode() == Instruction::Shr) |
 592            (I->getOpcode() == Instruction::Shl);
 593   }
 594   static inline bool classof(const Value *V) {
 595     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 596   }
 597 };
 598
 599 //===----------------------------------------------------------------------===//
 600 //                               SelectInst Class
 601 //===----------------------------------------------------------------------===//
 602
 603 /// SelectInst - This class represents the LLVM 'select' instruction.
 604 ///
 605 class SelectInst : public Instruction {
 606   Use Ops[3];
 607
 608   void init(Value *C, Value *S1, Value *S2) {
 609     Ops[0].init(C, this);
 610     Ops[1].init(S1, this);
 611     Ops[2].init(S2, this);
 612   }
 613
 614   SelectInst(const SelectInst &SI)
 615     : Instruction(SI.getType(), SI.getOpcode(), Ops, 3) {
 616     init(SI.Ops[0], SI.Ops[1], SI.Ops[2]);
 617   }
 618 public:
 619   SelectInst(Value *C, Value *S1, Value *S2, const std::string &Name = "",
 620              Instruction *InsertBefore = 0)
 621     : Instruction(S1->getType(), Instruction::Select, Ops, 3,
 622                   Name, InsertBefore) {
 623     init(C, S1, S2);
 624   }
 625   SelectInst(Value *C, Value *S1, Value *S2, const std::string &Name,
 626              BasicBlock *InsertAtEnd)
 627     : Instruction(S1->getType(), Instruction::Select, Ops, 3,
 628                   Name, InsertAtEnd) {
 629     init(C, S1, S2);
 630   }
 631
 632   Value *getCondition() const { return Ops[0]; }
 633   Value *getTrueValue() const { return Ops[1]; }
 634   Value *getFalseValue() const { return Ops[2]; }
 635
 636   /// Transparently provide more efficient getOperand methods.
 637   Value *getOperand(unsigned i) const {
 638     assert(i < 3 && "getOperand() out of range!");
 639     return Ops[i];
 640   }
 641   void setOperand(unsigned i, Value *Val) {
 642     assert(i < 3 && "setOperand() out of range!");
 643     Ops[i] = Val;
 644   }
 645   unsigned getNumOperands() const { return 3; }
 646
 647   OtherOps getOpcode() const {
 648     return static_cast<OtherOps>(Instruction::getOpcode());
 649   }
 650
 651   virtual SelectInst *clone() const;
 652
 653   // Methods for support type inquiry through isa, cast, and dyn_cast:
 654   static inline bool classof(const SelectInst *) { return true; }
 655   static inline bool classof(const Instruction *I) {
 656     return I->getOpcode() == Instruction::Select;
 657   }
 658   static inline bool classof(const Value *V) {
 659     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 660   }
 661 };
 662
 663 //===----------------------------------------------------------------------===//
 664 //                                VAArgInst Class
 665 //===----------------------------------------------------------------------===//
 666
 667 /// VAArgInst - This class represents the va_arg llvm instruction, which returns
 668 /// an argument of the specified type given a va_list and increments that list
 669 ///
 670 class VAArgInst : public UnaryInstruction {
 671   VAArgInst(const VAArgInst &VAA)
 672     : UnaryInstruction(VAA.getType(), VAArg, VAA.getOperand(0)) {}
 673 public:
 674   VAArgInst(Value *List, const Type *Ty, const std::string &Name = "",
 675              Instruction *InsertBefore = 0)
 676     : UnaryInstruction(Ty, VAArg, List, Name, InsertBefore) {
 677   }
 678   VAArgInst(Value *List, const Type *Ty, const std::string &Name,
 679             BasicBlock *InsertAtEnd)
 680     : UnaryInstruction(Ty, VAArg, List, Name, InsertAtEnd) {
 681   }
 682
 683   virtual VAArgInst *clone() const;
 684   bool mayWriteToMemory() const { return true; }
 685
 686   // Methods for support type inquiry through isa, cast, and dyn_cast:
 687   static inline bool classof(const VAArgInst *) { return true; }
 688   static inline bool classof(const Instruction *I) {
 689     return I->getOpcode() == VAArg;
 690   }
 691   static inline bool classof(const Value *V) {
 692     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 693   }
 694 };
 695
 696 //===----------------------------------------------------------------------===//
 697 //                               PHINode Class
 698 //===----------------------------------------------------------------------===//
 699
 700 // PHINode - The PHINode class is used to represent the magical mystical PHI
 701 // node, that can not exist in nature, but can be synthesized in a computer
 702 // scientist's overactive imagination.
 703 //
 704 class PHINode : public Instruction {
 705   /// ReservedSpace - The number of operands actually allocated.  NumOperands is
 706   /// the number actually in use.
 707   unsigned ReservedSpace;
 708   PHINode(const PHINode &PN);
 709 public:
 710   PHINode(const Type *Ty, const std::string &Name = "",
 711           Instruction *InsertBefore = 0)
 712     : Instruction(Ty, Instruction::PHI, 0, 0, Name, InsertBefore),
 713       ReservedSpace(0) {
 714   }
 715
 716   PHINode(const Type *Ty, const std::string &Name, BasicBlock *InsertAtEnd)
 717     : Instruction(Ty, Instruction::PHI, 0, 0, Name, InsertAtEnd),
 718       ReservedSpace(0) {
 719   }
 720
 721   ~PHINode();
 722
 723   /// reserveOperandSpace - This method can be used to avoid repeated
 724   /// reallocation of PHI operand lists by reserving space for the correct
 725   /// number of operands before adding them.  Unlike normal vector reserves,
 726   /// this method can also be used to trim the operand space.
 727   void reserveOperandSpace(unsigned NumValues) {
 728     resizeOperands(NumValues*2);
 729   }
 730
 731   virtual PHINode *clone() const;
 732
 733   /// getNumIncomingValues - Return the number of incoming edges
 734   ///
 735   unsigned getNumIncomingValues() const { return getNumOperands()/2; }
 736
 737   /// getIncomingValue - Return incoming value #x
 738   ///
 739   Value *getIncomingValue(unsigned i) const {
 740     assert(i*2 < getNumOperands() && "Invalid value number!");
 741     return getOperand(i*2);
 742   }
 743   void setIncomingValue(unsigned i, Value *V) {
 744     assert(i*2 < getNumOperands() && "Invalid value number!");
 745     setOperand(i*2, V);
 746   }
 747   unsigned getOperandNumForIncomingValue(unsigned i) {
 748     return i*2;
 749   }
 750
 751   /// getIncomingBlock - Return incoming basic block #x
 752   ///
 753   BasicBlock *getIncomingBlock(unsigned i) const {
 754     return reinterpret_cast<BasicBlock*>(getOperand(i*2+1));
 755   }
 756   void setIncomingBlock(unsigned i, BasicBlock *BB) {
 757     setOperand(i*2+1, reinterpret_cast<Value*>(BB));
 758   }
 759   unsigned getOperandNumForIncomingBlock(unsigned i) {
 760     return i*2+1;
 761   }
 762
 763   /// addIncoming - Add an incoming value to the end of the PHI list
 764   ///
 765   void addIncoming(Value *V, BasicBlock *BB) {
 766     assert(getType() == V->getType() &&
 767            "All operands to PHI node must be the same type as the PHI node!");
 768     unsigned OpNo = NumOperands;
 769     if (OpNo+2 > ReservedSpace)
 770       resizeOperands(0);  // Get more space!
 771     // Initialize some new operands.
 772     NumOperands = OpNo+2;
 773     OperandList[OpNo].init(V, this);
 774     OperandList[OpNo+1].init(reinterpret_cast<Value*>(BB), this);
 775   }
 776
 777   /// removeIncomingValue - Remove an incoming value.  This is useful if a
 778   /// predecessor basic block is deleted.  The value removed is returned.
 779   ///
 780   /// If the last incoming value for a PHI node is removed (and DeletePHIIfEmpty
 781   /// is true), the PHI node is destroyed and any uses of it are replaced with
 782   /// dummy values.  The only time there should be zero incoming values to a PHI
 783   /// node is when the block is dead, so this strategy is sound.
 784   ///
 785   Value *removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty = true);
 786
 787   Value *removeIncomingValue(const BasicBlock *BB, bool DeletePHIIfEmpty =true){
 788     int Idx = getBasicBlockIndex(BB);
 789     assert(Idx >= 0 && "Invalid basic block argument to remove!");
 790     return removeIncomingValue(Idx, DeletePHIIfEmpty);
 791   }
 792
 793   /// getBasicBlockIndex - Return the first index of the specified basic
 794   /// block in the value list for this PHI.  Returns -1 if no instance.
 795   ///
 796   int getBasicBlockIndex(const BasicBlock *BB) const {
 797     Use *OL = OperandList;
 798     for (unsigned i = 0, e = getNumOperands(); i != e; i += 2)
 799       if (OL[i+1] == reinterpret_cast<const Value*>(BB)) return i/2;
 800     return -1;
 801   }
 802
 803   Value *getIncomingValueForBlock(const BasicBlock *BB) const {
 804     return getIncomingValue(getBasicBlockIndex(BB));
 805   }
 806
 807   /// Methods for support type inquiry through isa, cast, and dyn_cast:
 808   static inline bool classof(const PHINode *) { return true; }
 809   static inline bool classof(const Instruction *I) {
 810     return I->getOpcode() == Instruction::PHI;
 811   }
 812   static inline bool classof(const Value *V) {
 813     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 814   }
 815  private:
 816   void resizeOperands(unsigned NumOperands);
 817 };
 818
 819 //===----------------------------------------------------------------------===//
 820 //                               ReturnInst Class
 821 //===----------------------------------------------------------------------===//
 822
 823 //===---------------------------------------------------------------------------
 824 /// ReturnInst - Return a value (possibly void), from a function.  Execution
 825 /// does not continue in this function any longer.
 826 ///
 827 class ReturnInst : public TerminatorInst {
 828   Use RetVal;  // Possibly null retval.
 829   ReturnInst(const ReturnInst &RI) : TerminatorInst(Instruction::Ret, &RetVal,
 830                                                     RI.getNumOperands()) {
 831     if (RI.getNumOperands())
 832       RetVal.init(RI.RetVal, this);
 833   }
 834
 835   void init(Value *RetVal);
 836
 837 public:
 838   // ReturnInst constructors:
 839   // ReturnInst()                  - 'ret void' instruction
 840   // ReturnInst(    null)          - 'ret void' instruction
 841   // ReturnInst(Value* X)          - 'ret X'    instruction
 842   // ReturnInst(    null, Inst *)  - 'ret void' instruction, insert before I
 843   // ReturnInst(Value* X, Inst *I) - 'ret X'    instruction, insert before I
 844   // ReturnInst(    null, BB *B)   - 'ret void' instruction, insert @ end of BB
 845   // ReturnInst(Value* X, BB *B)   - 'ret X'    instruction, insert @ end of BB
 846   //
 847   // NOTE: If the Value* passed is of type void then the constructor behaves as
 848   // if it was passed NULL.
 849   ReturnInst(Value *retVal = 0, Instruction *InsertBefore = 0)
 850     : TerminatorInst(Instruction::Ret, &RetVal, 0, InsertBefore) {
 851     init(retVal);
 852   }
 853   ReturnInst(Value *retVal, BasicBlock *InsertAtEnd)
 854     : TerminatorInst(Instruction::Ret, &RetVal, 0, InsertAtEnd) {
 855     init(retVal);
 856   }
 857   ReturnInst(BasicBlock *InsertAtEnd)
 858     : TerminatorInst(Instruction::Ret, &RetVal, 0, InsertAtEnd) {
 859   }
 860
 861   virtual ReturnInst *clone() const;
 862
 863   // Transparently provide more efficient getOperand methods.
 864   Value *getOperand(unsigned i) const {
 865     assert(i < getNumOperands() && "getOperand() out of range!");
 866     return RetVal;
 867   }
 868   void setOperand(unsigned i, Value *Val) {
 869     assert(i < getNumOperands() && "setOperand() out of range!");
 870     RetVal = Val;
 871   }
 872
 873   Value *getReturnValue() const { return RetVal; }
 874
 875   unsigned getNumSuccessors() const { return 0; }
 876
 877   // Methods for support type inquiry through isa, cast, and dyn_cast:
 878   static inline bool classof(const ReturnInst *) { return true; }
 879   static inline bool classof(const Instruction *I) {
 880     return (I->getOpcode() == Instruction::Ret);
 881   }
 882   static inline bool classof(const Value *V) {
 883     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 884   }
 885  private:
 886   virtual BasicBlock *getSuccessorV(unsigned idx) const;
 887   virtual unsigned getNumSuccessorsV() const;
 888   virtual void setSuccessorV(unsigned idx, BasicBlock *B);
 889 };
 890
 891 //===----------------------------------------------------------------------===//
 892 //                               BranchInst Class
 893 //===----------------------------------------------------------------------===//
 894
 895 //===---------------------------------------------------------------------------
 896 /// BranchInst - Conditional or Unconditional Branch instruction.
 897 ///
 898 class BranchInst : public TerminatorInst {
 899   /// Ops list - Branches are strange.  The operands are ordered:
 900   ///  TrueDest, FalseDest, Cond.  This makes some accessors faster because
 901   /// they don't have to check for cond/uncond branchness.
 902   Use Ops[3];
 903   BranchInst(const BranchInst &BI);
 904   void AssertOK();
 905 public:
 906   // BranchInst constructors (where {B, T, F} are blocks, and C is a condition):
 907   // BranchInst(BB *B)                           - 'br B'
 908   // BranchInst(BB* T, BB *F, Value *C)          - 'br C, T, F'
 909   // BranchInst(BB* B, Inst *I)                  - 'br B'        insert before I
 910   // BranchInst(BB* T, BB *F, Value *C, Inst *I) - 'br C, T, F', insert before I
 911   // BranchInst(BB* B, BB *I)                    - 'br B'        insert at end
 912   // BranchInst(BB* T, BB *F, Value *C, BB *I)   - 'br C, T, F', insert at end
 913   BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore = 0)
 914     : TerminatorInst(Instruction::Br, Ops, 1, InsertBefore) {
 915     assert(IfTrue != 0 && "Branch destination may not be null!");
 916     Ops[0].init(reinterpret_cast<Value*>(IfTrue), this);
 917   }
 918   BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
 919              Instruction *InsertBefore = 0)
 920     : TerminatorInst(Instruction::Br, Ops, 3, InsertBefore) {
 921     Ops[0].init(reinterpret_cast<Value*>(IfTrue), this);
 922     Ops[1].init(reinterpret_cast<Value*>(IfFalse), this);
 923     Ops[2].init(Cond, this);
 924 #ifndef NDEBUG
 925     AssertOK();
 926 #endif
 927   }
 928
 929   BranchInst(BasicBlock *IfTrue, BasicBlock *InsertAtEnd)
 930     : TerminatorInst(Instruction::Br, Ops, 1, InsertAtEnd) {
 931     assert(IfTrue != 0 && "Branch destination may not be null!");
 932     Ops[0].init(reinterpret_cast<Value*>(IfTrue), this);
 933   }
 934
 935   BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
 936              BasicBlock *InsertAtEnd)
 937     : TerminatorInst(Instruction::Br, Ops, 3, InsertAtEnd) {
 938     Ops[0].init(reinterpret_cast<Value*>(IfTrue), this);
 939     Ops[1].init(reinterpret_cast<Value*>(IfFalse), this);
 940     Ops[2].init(Cond, this);
 941 #ifndef NDEBUG
 942     AssertOK();
 943 #endif
 944   }
 945
 946
 947   /// Transparently provide more efficient getOperand methods.
 948   Value *getOperand(unsigned i) const {
 949     assert(i < getNumOperands() && "getOperand() out of range!");
 950     return Ops[i];
 951   }
 952   void setOperand(unsigned i, Value *Val) {
 953     assert(i < getNumOperands() && "setOperand() out of range!");
 954     Ops[i] = Val;
 955   }
 956
 957   virtual BranchInst *clone() const;
 958
 959   inline bool isUnconditional() const { return getNumOperands() == 1; }
 960   inline bool isConditional()   const { return getNumOperands() == 3; }
 961
 962   inline Value *getCondition() const {
 963     assert(isConditional() && "Cannot get condition of an uncond branch!");
 964     return getOperand(2);
 965   }
 966
 967   void setCondition(Value *V) {
 968     assert(isConditional() && "Cannot set condition of unconditional branch!");
 969     setOperand(2, V);
 970   }
 971
 972   // setUnconditionalDest - Change the current branch to an unconditional branch
 973   // targeting the specified block.
 974   // FIXME: Eliminate this ugly method.
 975   void setUnconditionalDest(BasicBlock *Dest) {
 976     if (isConditional()) {  // Convert this to an uncond branch.
 977       NumOperands = 1;
 978       Ops[1].set(0);
 979       Ops[2].set(0);
 980     }
 981     setOperand(0, reinterpret_cast<Value*>(Dest));
 982   }
 983
 984   unsigned getNumSuccessors() const { return 1+isConditional(); }
 985
 986   BasicBlock *getSuccessor(unsigned i) const {
 987     assert(i < getNumSuccessors() && "Successor # out of range for Branch!");
 988     return (i == 0) ? cast<BasicBlock>(getOperand(0)) :
 989                       cast<BasicBlock>(getOperand(1));
 990   }
 991
 992   void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
 993     assert(idx < getNumSuccessors() && "Successor # out of range for Branch!");
 994     setOperand(idx, reinterpret_cast<Value*>(NewSucc));
 995   }
 996
 997   // Methods for support type inquiry through isa, cast, and dyn_cast:
 998   static inline bool classof(const BranchInst *) { return true; }
 999   static inline bool classof(const Instruction *I) {
1000     return (I->getOpcode() == Instruction::Br);
1001   }
1002   static inline bool classof(const Value *V) {
1003     return isa<Instruction>(V) && classof(cast<Instruction>(V));
1004   }
1005 private:
1006   virtual BasicBlock *getSuccessorV(unsigned idx) const;
1007   virtual unsigned getNumSuccessorsV() const;
1008   virtual void setSuccessorV(unsigned idx, BasicBlock *B);
1009 };
1010
1011 //===----------------------------------------------------------------------===//
1012 //                               SwitchInst Class
1013 //===----------------------------------------------------------------------===//
1014
1015 //===---------------------------------------------------------------------------
1016 /// SwitchInst - Multiway switch
1017 ///
1018 class SwitchInst : public TerminatorInst {
1019   unsigned ReservedSpace;
1020   // Operand[0]    = Value to switch on
1021   // Operand[1]    = Default basic block destination
1022   // Operand[2n  ] = Value to match
1023   // Operand[2n+1] = BasicBlock to go to on match
1024   SwitchInst(const SwitchInst &RI);
1025   void init(Value *Value, BasicBlock *Default, unsigned NumCases);
1026   void resizeOperands(unsigned No);
1027 public:
1028   /// SwitchInst ctor - Create a new switch instruction, specifying a value to
1029   /// switch on and a default destination.  The number of additional cases can
1030   /// be specified here to make memory allocation more efficient.  This
1031   /// constructor can also autoinsert before another instruction.
1032   SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
1033              Instruction *InsertBefore = 0)
1034     : TerminatorInst(Instruction::Switch, 0, 0, InsertBefore) {
1035     init(Value, Default, NumCases);
1036   }
1037
1038   /// SwitchInst ctor - Create a new switch instruction, specifying a value to
1039   /// switch on and a default destination.  The number of additional cases can
1040   /// be specified here to make memory allocation more efficient.  This
1041   /// constructor also autoinserts at the end of the specified BasicBlock.
1042   SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
1043              BasicBlock *InsertAtEnd)
1044     : TerminatorInst(Instruction::Switch, 0, 0, InsertAtEnd) {
1045     init(Value, Default, NumCases);
1046   }
1047   ~SwitchInst();
1048
1049
1050   // Accessor Methods for Switch stmt
1051   inline Value *getCondition() const { return getOperand(0); }
1052   void setCondition(Value *V) { setOperand(0, V); }
1053
1054   inline BasicBlock *getDefaultDest() const {
1055     return cast<BasicBlock>(getOperand(1));
1056   }
1057
1058   /// getNumCases - return the number of 'cases' in this switch instruction.
1059   /// Note that case #0 is always the default case.
1060   unsigned getNumCases() const {
1061     return getNumOperands()/2;
1062   }
1063
1064   /// getCaseValue - Return the specified case value.  Note that case #0, the
1065   /// default destination, does not have a case value.
1066   ConstantInt *getCaseValue(unsigned i) {
1067     assert(i && i < getNumCases() && "Illegal case value to get!");
1068     return getSuccessorValue(i);
1069   }
1070
1071   /// getCaseValue - Return the specified case value.  Note that case #0, the
1072   /// default destination, does not have a case value.
1073   const ConstantInt *getCaseValue(unsigned i) const {
1074     assert(i && i < getNumCases() && "Illegal case value to get!");
1075     return getSuccessorValue(i);
1076   }
1077
1078   /// findCaseValue - Search all of the case values for the specified constant.
1079   /// If it is explicitly handled, return the case number of it, otherwise
1080   /// return 0 to indicate that it is handled by the default handler.
1081   unsigned findCaseValue(const ConstantInt *C) const {
1082     for (unsigned i = 1, e = getNumCases(); i != e; ++i)
1083       if (getCaseValue(i) == C)
1084         return i;
1085     return 0;
1086   }
1087
1088   /// addCase - Add an entry to the switch instruction...
1089   ///
1090   void addCase(ConstantInt *OnVal, BasicBlock *Dest);
1091
1092   /// removeCase - This method removes the specified successor from the switch
1093   /// instruction.  Note that this cannot be used to remove the default
1094   /// destination (successor #0).
1095   ///
1096   void removeCase(unsigned idx);
1097
1098   virtual SwitchInst *clone() const;
1099
1100   unsigned getNumSuccessors() const { return getNumOperands()/2; }
1101   BasicBlock *getSuccessor(unsigned idx) const {
1102     assert(idx < getNumSuccessors() &&"Successor idx out of range for switch!");
1103     return cast<BasicBlock>(getOperand(idx*2+1));
1104   }
1105   void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
1106     assert(idx < getNumSuccessors() && "Successor # out of range for switch!");
1107     setOperand(idx*2+1, reinterpret_cast<Value*>(NewSucc));
1108   }
1109
1110   // getSuccessorValue - Return the value associated with the specified
1111   // successor.
1112   inline ConstantInt *getSuccessorValue(unsigned idx) const {
1113     assert(idx < getNumSuccessors() && "Successor # out of range!");
1114     return reinterpret_cast<ConstantInt*>(getOperand(idx*2));
1115   }
1116
1117   // Methods for support type inquiry through isa, cast, and dyn_cast:
1118   static inline bool classof(const SwitchInst *) { return true; }
1119   static inline bool classof(const Instruction *I) {
1120     return I->getOpcode() == Instruction::Switch;
1121   }
1122   static inline bool classof(const Value *V) {
1123     return isa<Instruction>(V) && classof(cast<Instruction>(V));
1124   }
1125 private:
1126   virtual BasicBlock *getSuccessorV(unsigned idx) const;
1127   virtual unsigned getNumSuccessorsV() const;
1128   virtual void setSuccessorV(unsigned idx, BasicBlock *B);
1129 };
1130
1131 //===----------------------------------------------------------------------===//
1132 //                               InvokeInst Class
1133 //===----------------------------------------------------------------------===//
1134
1135 //===---------------------------------------------------------------------------
1136
1137 /// InvokeInst - Invoke instruction.  The SubclassData field is used to hold the
1138 /// calling convention of the call.
1139 ///
1140 class InvokeInst : public TerminatorInst {
1141   InvokeInst(const InvokeInst &BI);
1142   void init(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
1143             const std::vector<Value*> &Params);
1144 public:
1145   InvokeInst(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
1146              const std::vector<Value*> &Params, const std::string &Name = "",
1147              Instruction *InsertBefore = 0);
1148   InvokeInst(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
1149              const std::vector<Value*> &Params, const std::string &Name,
1150              BasicBlock *InsertAtEnd);
1151   ~InvokeInst();
1152
1153   virtual InvokeInst *clone() const;
1154
1155   bool mayWriteToMemory() const { return true; }
1156
1157   /// getCallingConv/setCallingConv - Get or set the calling convention of this
1158   /// function call.
1159   unsigned getCallingConv() const { return SubclassData; }
1160   void setCallingConv(unsigned CC) {
1161     SubclassData = CC;
1162   }
1163
1164   /// getCalledFunction - Return the function called, or null if this is an
1165   /// indirect function invocation.
1166   ///
1167   Function *getCalledFunction() const {
1168     return dyn_cast<Function>(getOperand(0));
1169   }
1170
1171   // getCalledValue - Get a pointer to a function that is invoked by this inst.
1172   inline Value *getCalledValue() const { return getOperand(0); }
1173
1174   // get*Dest - Return the destination basic blocks...
1175   BasicBlock *getNormalDest() const {
1176     return cast<BasicBlock>(getOperand(1));
1177   }
1178   BasicBlock *getUnwindDest() const {
1179     return cast<BasicBlock>(getOperand(2));
1180   }
1181   void setNormalDest(BasicBlock *B) {
1182     setOperand(1, reinterpret_cast<Value*>(B));
1183   }
1184
1185   void setUnwindDest(BasicBlock *B) {
1186     setOperand(2, reinterpret_cast<Value*>(B));
1187   }
1188
1189   inline BasicBlock *getSuccessor(unsigned i) const {
1190     assert(i < 2 && "Successor # out of range for invoke!");
1191     return i == 0 ? getNormalDest() : getUnwindDest();
1192   }
1193
1194   void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
1195     assert(idx < 2 && "Successor # out of range for invoke!");
1196     setOperand(idx+1, reinterpret_cast<Value*>(NewSucc));
1197   }
1198
1199   unsigned getNumSuccessors() const { return 2; }
1200
1201   // Methods for support type inquiry through isa, cast, and dyn_cast:
1202   static inline bool classof(const InvokeInst *) { return true; }
1203   static inline bool classof(const Instruction *I) {
1204     return (I->getOpcode() == Instruction::Invoke);
1205   }
1206   static inline bool classof(const Value *V) {
1207     return isa<Instruction>(V) && classof(cast<Instruction>(V));
1208   }
1209 private:
1210   virtual BasicBlock *getSuccessorV(unsigned idx) const;
1211   virtual unsigned getNumSuccessorsV() const;
1212   virtual void setSuccessorV(unsigned idx, BasicBlock *B);
1213 };
1214
1215
1216 //===----------------------------------------------------------------------===//
1217 //                              UnwindInst Class
1218 //===----------------------------------------------------------------------===//
1219
1220 //===---------------------------------------------------------------------------
1221 /// UnwindInst - Immediately exit the current function, unwinding the stack
1222 /// until an invoke instruction is found.
1223 ///
1224 class UnwindInst : public TerminatorInst {
1225 public:
1226   UnwindInst(Instruction *InsertBefore = 0)
1227     : TerminatorInst(Instruction::Unwind, 0, 0, InsertBefore) {
1228   }
1229   UnwindInst(BasicBlock *InsertAtEnd)
1230     : TerminatorInst(Instruction::Unwind, 0, 0, InsertAtEnd) {
1231   }
1232
1233   virtual UnwindInst *clone() const;
1234
1235   unsigned getNumSuccessors() const { return 0; }
1236
1237   // Methods for support type inquiry through isa, cast, and dyn_cast:
1238   static inline bool classof(const UnwindInst *) { return true; }
1239   static inline bool classof(const Instruction *I) {
1240     return I->getOpcode() == Instruction::Unwind;
1241   }
1242   static inline bool classof(const Value *V) {
1243     return isa<Instruction>(V) && classof(cast<Instruction>(V));
1244   }
1245 private:
1246   virtual BasicBlock *getSuccessorV(unsigned idx) const;
1247   virtual unsigned getNumSuccessorsV() const;
1248   virtual void setSuccessorV(unsigned idx, BasicBlock *B);
1249 };
1250
1251 //===----------------------------------------------------------------------===//
1252 //                           UnreachableInst Class
1253 //===----------------------------------------------------------------------===//
1254
1255 //===---------------------------------------------------------------------------
1256 /// UnreachableInst - This function has undefined behavior.  In particular, the
1257 /// presence of this instruction indicates some higher level knowledge that the
1258 /// end of the block cannot be reached.
1259 ///
1260 class UnreachableInst : public TerminatorInst {
1261 public:
1262   UnreachableInst(Instruction *InsertBefore = 0)
1263     : TerminatorInst(Instruction::Unreachable, 0, 0, InsertBefore) {
1264   }
1265   UnreachableInst(BasicBlock *InsertAtEnd)
1266     : TerminatorInst(Instruction::Unreachable, 0, 0, InsertAtEnd) {
1267   }
1268
1269   virtual UnreachableInst *clone() const;
1270
1271   unsigned getNumSuccessors() const { return 0; }
1272
1273   // Methods for support type inquiry through isa, cast, and dyn_cast:
1274   static inline bool classof(const UnreachableInst *) { return true; }
1275   static inline bool classof(const Instruction *I) {
1276     return I->getOpcode() == Instruction::Unreachable;
1277   }
1278   static inline bool classof(const Value *V) {
1279     return isa<Instruction>(V) && classof(cast<Instruction>(V));
1280   }
1281 private:
1282   virtual BasicBlock *getSuccessorV(unsigned idx) const;
1283   virtual unsigned getNumSuccessorsV() const;
1284   virtual void setSuccessorV(unsigned idx, BasicBlock *B);
1285 };
1286
1287 } // End llvm namespace
1288
1289 #endif