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