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