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