1 //===-- llvm/Instructions.h - Instruction subclass definitions --*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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.
14 //===----------------------------------------------------------------------===//
16 #ifndef LLVM_INSTRUCTIONS_H
17 #define LLVM_INSTRUCTIONS_H
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"
39 // Consume = 3, // Not specified yet.
43 SequentiallyConsistent = 7
46 enum SynchronizationScope {
51 //===----------------------------------------------------------------------===//
53 //===----------------------------------------------------------------------===//
55 /// AllocaInst - an instruction to allocate memory on the stack
57 class AllocaInst : public UnaryInstruction {
59 virtual AllocaInst *clone_impl() const;
61 explicit AllocaInst(Type *Ty, Value *ArraySize = 0,
62 const Twine &Name = "", Instruction *InsertBefore = 0);
63 AllocaInst(Type *Ty, Value *ArraySize,
64 const Twine &Name, BasicBlock *InsertAtEnd);
66 AllocaInst(Type *Ty, const Twine &Name, Instruction *InsertBefore = 0);
67 AllocaInst(Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd);
69 AllocaInst(Type *Ty, Value *ArraySize, unsigned Align,
70 const Twine &Name = "", Instruction *InsertBefore = 0);
71 AllocaInst(Type *Ty, Value *ArraySize, unsigned Align,
72 const Twine &Name, BasicBlock *InsertAtEnd);
74 // Out of line virtual method, so the vtable, etc. has a home.
75 virtual ~AllocaInst();
77 /// isArrayAllocation - Return true if there is an allocation size parameter
78 /// to the allocation instruction that is not 1.
80 bool isArrayAllocation() const;
82 /// getArraySize - Get the number of elements allocated. For a simple
83 /// allocation of a single element, this will return a constant 1 value.
85 const Value *getArraySize() const { return getOperand(0); }
86 Value *getArraySize() { return getOperand(0); }
88 /// getType - Overload to return most specific pointer type
90 PointerType *getType() const {
91 return reinterpret_cast<PointerType*>(Instruction::getType());
94 /// getAllocatedType - Return the type that is being allocated by the
97 Type *getAllocatedType() const;
99 /// getAlignment - Return the alignment of the memory that is being allocated
100 /// by the instruction.
102 unsigned getAlignment() const {
103 return (1u << getSubclassDataFromInstruction()) >> 1;
105 void setAlignment(unsigned Align);
107 /// isStaticAlloca - Return true if this alloca is in the entry block of the
108 /// function and is a constant size. If so, the code generator will fold it
109 /// into the prolog/epilog code, so it is basically free.
110 bool isStaticAlloca() const;
112 // Methods for support type inquiry through isa, cast, and dyn_cast:
113 static inline bool classof(const AllocaInst *) { return true; }
114 static inline bool classof(const Instruction *I) {
115 return (I->getOpcode() == Instruction::Alloca);
117 static inline bool classof(const Value *V) {
118 return isa<Instruction>(V) && classof(cast<Instruction>(V));
121 // Shadow Instruction::setInstructionSubclassData with a private forwarding
122 // method so that subclasses cannot accidentally use it.
123 void setInstructionSubclassData(unsigned short D) {
124 Instruction::setInstructionSubclassData(D);
129 //===----------------------------------------------------------------------===//
131 //===----------------------------------------------------------------------===//
133 /// LoadInst - an instruction for reading from memory. This uses the
134 /// SubclassData field in Value to store whether or not the load is volatile.
136 class LoadInst : public UnaryInstruction {
139 virtual LoadInst *clone_impl() const;
141 LoadInst(Value *Ptr, const Twine &NameStr, Instruction *InsertBefore);
142 LoadInst(Value *Ptr, const Twine &NameStr, BasicBlock *InsertAtEnd);
143 LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile = false,
144 Instruction *InsertBefore = 0);
145 LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
146 BasicBlock *InsertAtEnd);
147 LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
148 unsigned Align, Instruction *InsertBefore = 0);
149 LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
150 unsigned Align, BasicBlock *InsertAtEnd);
151 LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
152 unsigned Align, AtomicOrdering Order,
153 SynchronizationScope SynchScope = CrossThread,
154 Instruction *InsertBefore = 0);
155 LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
156 unsigned Align, AtomicOrdering Order,
157 SynchronizationScope SynchScope,
158 BasicBlock *InsertAtEnd);
160 LoadInst(Value *Ptr, const char *NameStr, Instruction *InsertBefore);
161 LoadInst(Value *Ptr, const char *NameStr, BasicBlock *InsertAtEnd);
162 explicit LoadInst(Value *Ptr, const char *NameStr = 0,
163 bool isVolatile = false, Instruction *InsertBefore = 0);
164 LoadInst(Value *Ptr, const char *NameStr, bool isVolatile,
165 BasicBlock *InsertAtEnd);
167 /// isVolatile - Return true if this is a load from a volatile memory
170 bool isVolatile() const { return getSubclassDataFromInstruction() & 1; }
172 /// setVolatile - Specify whether this is a volatile load or not.
174 void setVolatile(bool V) {
175 setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
179 /// getAlignment - Return the alignment of the access that is being performed
181 unsigned getAlignment() const {
182 return (1 << ((getSubclassDataFromInstruction() >> 1) & 31)) >> 1;
185 void setAlignment(unsigned Align);
187 /// Returns the ordering effect of this fence.
188 AtomicOrdering getOrdering() const {
189 return AtomicOrdering((getSubclassDataFromInstruction() >> 7) & 7);
192 /// Set the ordering constraint on this load. May not be Release or
194 void setOrdering(AtomicOrdering Ordering) {
195 setInstructionSubclassData((getSubclassDataFromInstruction() & ~(7 << 7)) |
199 SynchronizationScope getSynchScope() const {
200 return SynchronizationScope((getSubclassDataFromInstruction() >> 6) & 1);
203 /// Specify whether this load is ordered with respect to all
204 /// concurrently executing threads, or only with respect to signal handlers
205 /// executing in the same thread.
206 void setSynchScope(SynchronizationScope xthread) {
207 setInstructionSubclassData((getSubclassDataFromInstruction() & ~(1 << 6)) |
211 bool isAtomic() const { return getOrdering() != NotAtomic; }
212 void setAtomic(AtomicOrdering Ordering,
213 SynchronizationScope SynchScope = CrossThread) {
214 setOrdering(Ordering);
215 setSynchScope(SynchScope);
218 bool isSimple() const { return !isAtomic() && !isVolatile(); }
219 bool isUnordered() const {
220 return getOrdering() <= Unordered && !isVolatile();
223 Value *getPointerOperand() { return getOperand(0); }
224 const Value *getPointerOperand() const { return getOperand(0); }
225 static unsigned getPointerOperandIndex() { return 0U; }
227 unsigned getPointerAddressSpace() const {
228 return cast<PointerType>(getPointerOperand()->getType())->getAddressSpace();
232 // Methods for support type inquiry through isa, cast, and dyn_cast:
233 static inline bool classof(const LoadInst *) { return true; }
234 static inline bool classof(const Instruction *I) {
235 return I->getOpcode() == Instruction::Load;
237 static inline bool classof(const Value *V) {
238 return isa<Instruction>(V) && classof(cast<Instruction>(V));
241 // Shadow Instruction::setInstructionSubclassData with a private forwarding
242 // method so that subclasses cannot accidentally use it.
243 void setInstructionSubclassData(unsigned short D) {
244 Instruction::setInstructionSubclassData(D);
249 //===----------------------------------------------------------------------===//
251 //===----------------------------------------------------------------------===//
253 /// StoreInst - an instruction for storing to memory
255 class StoreInst : public Instruction {
256 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
259 virtual StoreInst *clone_impl() const;
261 // allocate space for exactly two operands
262 void *operator new(size_t s) {
263 return User::operator new(s, 2);
265 StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore);
266 StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd);
267 StoreInst(Value *Val, Value *Ptr, bool isVolatile = false,
268 Instruction *InsertBefore = 0);
269 StoreInst(Value *Val, Value *Ptr, bool isVolatile, BasicBlock *InsertAtEnd);
270 StoreInst(Value *Val, Value *Ptr, bool isVolatile,
271 unsigned Align, Instruction *InsertBefore = 0);
272 StoreInst(Value *Val, Value *Ptr, bool isVolatile,
273 unsigned Align, BasicBlock *InsertAtEnd);
274 StoreInst(Value *Val, Value *Ptr, bool isVolatile,
275 unsigned Align, AtomicOrdering Order,
276 SynchronizationScope SynchScope = CrossThread,
277 Instruction *InsertBefore = 0);
278 StoreInst(Value *Val, Value *Ptr, bool isVolatile,
279 unsigned Align, AtomicOrdering Order,
280 SynchronizationScope SynchScope,
281 BasicBlock *InsertAtEnd);
284 /// isVolatile - Return true if this is a store to a volatile memory
287 bool isVolatile() const { return getSubclassDataFromInstruction() & 1; }
289 /// setVolatile - Specify whether this is a volatile store or not.
291 void setVolatile(bool V) {
292 setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
296 /// Transparently provide more efficient getOperand methods.
297 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
299 /// getAlignment - Return the alignment of the access that is being performed
301 unsigned getAlignment() const {
302 return (1 << ((getSubclassDataFromInstruction() >> 1) & 31)) >> 1;
305 void setAlignment(unsigned Align);
307 /// Returns the ordering effect of this store.
308 AtomicOrdering getOrdering() const {
309 return AtomicOrdering((getSubclassDataFromInstruction() >> 7) & 7);
312 /// Set the ordering constraint on this store. May not be Acquire or
314 void setOrdering(AtomicOrdering Ordering) {
315 setInstructionSubclassData((getSubclassDataFromInstruction() & ~(7 << 7)) |
319 SynchronizationScope getSynchScope() const {
320 return SynchronizationScope((getSubclassDataFromInstruction() >> 6) & 1);
323 /// Specify whether this store instruction is ordered with respect to all
324 /// concurrently executing threads, or only with respect to signal handlers
325 /// executing in the same thread.
326 void setSynchScope(SynchronizationScope xthread) {
327 setInstructionSubclassData((getSubclassDataFromInstruction() & ~(1 << 6)) |
331 bool isAtomic() const { return getOrdering() != NotAtomic; }
332 void setAtomic(AtomicOrdering Ordering,
333 SynchronizationScope SynchScope = CrossThread) {
334 setOrdering(Ordering);
335 setSynchScope(SynchScope);
338 bool isSimple() const { return !isAtomic() && !isVolatile(); }
339 bool isUnordered() const {
340 return getOrdering() <= Unordered && !isVolatile();
343 Value *getValueOperand() { return getOperand(0); }
344 const Value *getValueOperand() const { return getOperand(0); }
346 Value *getPointerOperand() { return getOperand(1); }
347 const Value *getPointerOperand() const { return getOperand(1); }
348 static unsigned getPointerOperandIndex() { return 1U; }
350 unsigned getPointerAddressSpace() const {
351 return cast<PointerType>(getPointerOperand()->getType())->getAddressSpace();
354 // Methods for support type inquiry through isa, cast, and dyn_cast:
355 static inline bool classof(const StoreInst *) { return true; }
356 static inline bool classof(const Instruction *I) {
357 return I->getOpcode() == Instruction::Store;
359 static inline bool classof(const Value *V) {
360 return isa<Instruction>(V) && classof(cast<Instruction>(V));
363 // Shadow Instruction::setInstructionSubclassData with a private forwarding
364 // method so that subclasses cannot accidentally use it.
365 void setInstructionSubclassData(unsigned short D) {
366 Instruction::setInstructionSubclassData(D);
371 struct OperandTraits<StoreInst> : public FixedNumOperandTraits<StoreInst, 2> {
374 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(StoreInst, Value)
376 //===----------------------------------------------------------------------===//
378 //===----------------------------------------------------------------------===//
380 /// FenceInst - an instruction for ordering other memory operations
382 class FenceInst : public Instruction {
383 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
384 void Init(AtomicOrdering Ordering, SynchronizationScope SynchScope);
386 virtual FenceInst *clone_impl() const;
388 // allocate space for exactly zero operands
389 void *operator new(size_t s) {
390 return User::operator new(s, 0);
393 // Ordering may only be Acquire, Release, AcquireRelease, or
394 // SequentiallyConsistent.
395 FenceInst(LLVMContext &C, AtomicOrdering Ordering,
396 SynchronizationScope SynchScope = CrossThread,
397 Instruction *InsertBefore = 0);
398 FenceInst(LLVMContext &C, AtomicOrdering Ordering,
399 SynchronizationScope SynchScope,
400 BasicBlock *InsertAtEnd);
402 /// Returns the ordering effect of this fence.
403 AtomicOrdering getOrdering() const {
404 return AtomicOrdering(getSubclassDataFromInstruction() >> 1);
407 /// Set the ordering constraint on this fence. May only be Acquire, Release,
408 /// AcquireRelease, or SequentiallyConsistent.
409 void setOrdering(AtomicOrdering Ordering) {
410 setInstructionSubclassData((getSubclassDataFromInstruction() & 1) |
414 SynchronizationScope getSynchScope() const {
415 return SynchronizationScope(getSubclassDataFromInstruction() & 1);
418 /// Specify whether this fence orders other operations with respect to all
419 /// concurrently executing threads, or only with respect to signal handlers
420 /// executing in the same thread.
421 void setSynchScope(SynchronizationScope xthread) {
422 setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
426 // Methods for support type inquiry through isa, cast, and dyn_cast:
427 static inline bool classof(const FenceInst *) { return true; }
428 static inline bool classof(const Instruction *I) {
429 return I->getOpcode() == Instruction::Fence;
431 static inline bool classof(const Value *V) {
432 return isa<Instruction>(V) && classof(cast<Instruction>(V));
435 // Shadow Instruction::setInstructionSubclassData with a private forwarding
436 // method so that subclasses cannot accidentally use it.
437 void setInstructionSubclassData(unsigned short D) {
438 Instruction::setInstructionSubclassData(D);
442 //===----------------------------------------------------------------------===//
443 // AtomicCmpXchgInst Class
444 //===----------------------------------------------------------------------===//
446 /// AtomicCmpXchgInst - an instruction that atomically checks whether a
447 /// specified value is in a memory location, and, if it is, stores a new value
448 /// there. Returns the value that was loaded.
450 class AtomicCmpXchgInst : public Instruction {
451 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
452 void Init(Value *Ptr, Value *Cmp, Value *NewVal,
453 AtomicOrdering Ordering, SynchronizationScope SynchScope);
455 virtual AtomicCmpXchgInst *clone_impl() const;
457 // allocate space for exactly three operands
458 void *operator new(size_t s) {
459 return User::operator new(s, 3);
461 AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal,
462 AtomicOrdering Ordering, SynchronizationScope SynchScope,
463 Instruction *InsertBefore = 0);
464 AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal,
465 AtomicOrdering Ordering, SynchronizationScope SynchScope,
466 BasicBlock *InsertAtEnd);
468 /// isVolatile - Return true if this is a cmpxchg from a volatile memory
471 bool isVolatile() const {
472 return getSubclassDataFromInstruction() & 1;
475 /// setVolatile - Specify whether this is a volatile cmpxchg.
477 void setVolatile(bool V) {
478 setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
482 /// Transparently provide more efficient getOperand methods.
483 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
485 /// Set the ordering constraint on this cmpxchg.
486 void setOrdering(AtomicOrdering Ordering) {
487 assert(Ordering != NotAtomic &&
488 "CmpXchg instructions can only be atomic.");
489 setInstructionSubclassData((getSubclassDataFromInstruction() & 3) |
493 /// Specify whether this cmpxchg is atomic and orders other operations with
494 /// respect to all concurrently executing threads, or only with respect to
495 /// signal handlers executing in the same thread.
496 void setSynchScope(SynchronizationScope SynchScope) {
497 setInstructionSubclassData((getSubclassDataFromInstruction() & ~2) |
501 /// Returns the ordering constraint on this cmpxchg.
502 AtomicOrdering getOrdering() const {
503 return AtomicOrdering(getSubclassDataFromInstruction() >> 2);
506 /// Returns whether this cmpxchg is atomic between threads or only within a
508 SynchronizationScope getSynchScope() const {
509 return SynchronizationScope((getSubclassDataFromInstruction() & 2) >> 1);
512 Value *getPointerOperand() { return getOperand(0); }
513 const Value *getPointerOperand() const { return getOperand(0); }
514 static unsigned getPointerOperandIndex() { return 0U; }
516 Value *getCompareOperand() { return getOperand(1); }
517 const Value *getCompareOperand() const { return getOperand(1); }
519 Value *getNewValOperand() { return getOperand(2); }
520 const Value *getNewValOperand() const { return getOperand(2); }
522 unsigned getPointerAddressSpace() const {
523 return cast<PointerType>(getPointerOperand()->getType())->getAddressSpace();
526 // Methods for support type inquiry through isa, cast, and dyn_cast:
527 static inline bool classof(const AtomicCmpXchgInst *) { return true; }
528 static inline bool classof(const Instruction *I) {
529 return I->getOpcode() == Instruction::AtomicCmpXchg;
531 static inline bool classof(const Value *V) {
532 return isa<Instruction>(V) && classof(cast<Instruction>(V));
535 // Shadow Instruction::setInstructionSubclassData with a private forwarding
536 // method so that subclasses cannot accidentally use it.
537 void setInstructionSubclassData(unsigned short D) {
538 Instruction::setInstructionSubclassData(D);
543 struct OperandTraits<AtomicCmpXchgInst> :
544 public FixedNumOperandTraits<AtomicCmpXchgInst, 3> {
547 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(AtomicCmpXchgInst, Value)
549 //===----------------------------------------------------------------------===//
550 // AtomicRMWInst Class
551 //===----------------------------------------------------------------------===//
553 /// AtomicRMWInst - an instruction that atomically reads a memory location,
554 /// combines it with another value, and then stores the result back. Returns
557 class AtomicRMWInst : public Instruction {
558 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
560 virtual AtomicRMWInst *clone_impl() const;
562 /// This enumeration lists the possible modifications atomicrmw can make. In
563 /// the descriptions, 'p' is the pointer to the instruction's memory location,
564 /// 'old' is the initial value of *p, and 'v' is the other value passed to the
565 /// instruction. These instructions always return 'old'.
581 /// *p = old >signed v ? old : v
583 /// *p = old <signed v ? old : v
585 /// *p = old >unsigned v ? old : v
587 /// *p = old <unsigned v ? old : v
595 // allocate space for exactly two operands
596 void *operator new(size_t s) {
597 return User::operator new(s, 2);
599 AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val,
600 AtomicOrdering Ordering, SynchronizationScope SynchScope,
601 Instruction *InsertBefore = 0);
602 AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val,
603 AtomicOrdering Ordering, SynchronizationScope SynchScope,
604 BasicBlock *InsertAtEnd);
606 BinOp getOperation() const {
607 return static_cast<BinOp>(getSubclassDataFromInstruction() >> 5);
610 void setOperation(BinOp Operation) {
611 unsigned short SubclassData = getSubclassDataFromInstruction();
612 setInstructionSubclassData((SubclassData & 31) |
616 /// isVolatile - Return true if this is a RMW on a volatile memory location.
618 bool isVolatile() const {
619 return getSubclassDataFromInstruction() & 1;
622 /// setVolatile - Specify whether this is a volatile RMW or not.
624 void setVolatile(bool V) {
625 setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
629 /// Transparently provide more efficient getOperand methods.
630 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
632 /// Set the ordering constraint on this RMW.
633 void setOrdering(AtomicOrdering Ordering) {
634 assert(Ordering != NotAtomic &&
635 "atomicrmw instructions can only be atomic.");
636 setInstructionSubclassData((getSubclassDataFromInstruction() & ~(7 << 2)) |
640 /// Specify whether this RMW orders other operations with respect to all
641 /// concurrently executing threads, or only with respect to signal handlers
642 /// executing in the same thread.
643 void setSynchScope(SynchronizationScope SynchScope) {
644 setInstructionSubclassData((getSubclassDataFromInstruction() & ~2) |
648 /// Returns the ordering constraint on this RMW.
649 AtomicOrdering getOrdering() const {
650 return AtomicOrdering((getSubclassDataFromInstruction() >> 2) & 7);
653 /// Returns whether this RMW is atomic between threads or only within a
655 SynchronizationScope getSynchScope() const {
656 return SynchronizationScope((getSubclassDataFromInstruction() & 2) >> 1);
659 Value *getPointerOperand() { return getOperand(0); }
660 const Value *getPointerOperand() const { return getOperand(0); }
661 static unsigned getPointerOperandIndex() { return 0U; }
663 Value *getValOperand() { return getOperand(1); }
664 const Value *getValOperand() const { return getOperand(1); }
666 unsigned getPointerAddressSpace() const {
667 return cast<PointerType>(getPointerOperand()->getType())->getAddressSpace();
670 // Methods for support type inquiry through isa, cast, and dyn_cast:
671 static inline bool classof(const AtomicRMWInst *) { return true; }
672 static inline bool classof(const Instruction *I) {
673 return I->getOpcode() == Instruction::AtomicRMW;
675 static inline bool classof(const Value *V) {
676 return isa<Instruction>(V) && classof(cast<Instruction>(V));
679 void Init(BinOp Operation, Value *Ptr, Value *Val,
680 AtomicOrdering Ordering, SynchronizationScope SynchScope);
681 // Shadow Instruction::setInstructionSubclassData with a private forwarding
682 // method so that subclasses cannot accidentally use it.
683 void setInstructionSubclassData(unsigned short D) {
684 Instruction::setInstructionSubclassData(D);
689 struct OperandTraits<AtomicRMWInst>
690 : public FixedNumOperandTraits<AtomicRMWInst,2> {
693 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(AtomicRMWInst, Value)
695 //===----------------------------------------------------------------------===//
696 // GetElementPtrInst Class
697 //===----------------------------------------------------------------------===//
699 // checkGEPType - Simple wrapper function to give a better assertion failure
700 // message on bad indexes for a gep instruction.
702 static inline Type *checkGEPType(Type *Ty) {
703 assert(Ty && "Invalid GetElementPtrInst indices for type!");
707 /// GetElementPtrInst - an instruction for type-safe pointer arithmetic to
708 /// access elements of arrays and structs
710 class GetElementPtrInst : public Instruction {
711 GetElementPtrInst(const GetElementPtrInst &GEPI);
712 void init(Value *Ptr, ArrayRef<Value *> IdxList, const Twine &NameStr);
714 /// Constructors - Create a getelementptr instruction with a base pointer an
715 /// list of indices. The first ctor can optionally insert before an existing
716 /// instruction, the second appends the new instruction to the specified
718 inline GetElementPtrInst(Value *Ptr, ArrayRef<Value *> IdxList,
719 unsigned Values, const Twine &NameStr,
720 Instruction *InsertBefore);
721 inline GetElementPtrInst(Value *Ptr, ArrayRef<Value *> IdxList,
722 unsigned Values, const Twine &NameStr,
723 BasicBlock *InsertAtEnd);
725 virtual GetElementPtrInst *clone_impl() const;
727 static GetElementPtrInst *Create(Value *Ptr, ArrayRef<Value *> IdxList,
728 const Twine &NameStr = "",
729 Instruction *InsertBefore = 0) {
730 unsigned Values = 1 + unsigned(IdxList.size());
732 GetElementPtrInst(Ptr, IdxList, Values, NameStr, InsertBefore);
734 static GetElementPtrInst *Create(Value *Ptr, ArrayRef<Value *> IdxList,
735 const Twine &NameStr,
736 BasicBlock *InsertAtEnd) {
737 unsigned Values = 1 + unsigned(IdxList.size());
739 GetElementPtrInst(Ptr, IdxList, Values, NameStr, InsertAtEnd);
742 /// Create an "inbounds" getelementptr. See the documentation for the
743 /// "inbounds" flag in LangRef.html for details.
744 static GetElementPtrInst *CreateInBounds(Value *Ptr,
745 ArrayRef<Value *> IdxList,
746 const Twine &NameStr = "",
747 Instruction *InsertBefore = 0) {
748 GetElementPtrInst *GEP = Create(Ptr, IdxList, NameStr, InsertBefore);
749 GEP->setIsInBounds(true);
752 static GetElementPtrInst *CreateInBounds(Value *Ptr,
753 ArrayRef<Value *> IdxList,
754 const Twine &NameStr,
755 BasicBlock *InsertAtEnd) {
756 GetElementPtrInst *GEP = Create(Ptr, IdxList, NameStr, InsertAtEnd);
757 GEP->setIsInBounds(true);
761 /// Transparently provide more efficient getOperand methods.
762 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
764 // getType - Overload to return most specific pointer type...
765 PointerType *getType() const {
766 return reinterpret_cast<PointerType*>(Instruction::getType());
769 /// getIndexedType - Returns the type of the element that would be loaded with
770 /// a load instruction with the specified parameters.
772 /// Null is returned if the indices are invalid for the specified
775 static Type *getIndexedType(Type *Ptr, ArrayRef<Value *> IdxList);
776 static Type *getIndexedType(Type *Ptr, ArrayRef<Constant *> IdxList);
777 static Type *getIndexedType(Type *Ptr, ArrayRef<uint64_t> IdxList);
779 inline op_iterator idx_begin() { return op_begin()+1; }
780 inline const_op_iterator idx_begin() const { return op_begin()+1; }
781 inline op_iterator idx_end() { return op_end(); }
782 inline const_op_iterator idx_end() const { return op_end(); }
784 Value *getPointerOperand() {
785 return getOperand(0);
787 const Value *getPointerOperand() const {
788 return getOperand(0);
790 static unsigned getPointerOperandIndex() {
791 return 0U; // get index for modifying correct operand
794 unsigned getPointerAddressSpace() const {
795 return cast<PointerType>(getType())->getAddressSpace();
798 /// getPointerOperandType - Method to return the pointer operand as a
800 PointerType *getPointerOperandType() const {
801 return reinterpret_cast<PointerType*>(getPointerOperand()->getType());
805 unsigned getNumIndices() const { // Note: always non-negative
806 return getNumOperands() - 1;
809 bool hasIndices() const {
810 return getNumOperands() > 1;
813 /// hasAllZeroIndices - Return true if all of the indices of this GEP are
814 /// zeros. If so, the result pointer and the first operand have the same
815 /// value, just potentially different types.
816 bool hasAllZeroIndices() const;
818 /// hasAllConstantIndices - Return true if all of the indices of this GEP are
819 /// constant integers. If so, the result pointer and the first operand have
820 /// a constant offset between them.
821 bool hasAllConstantIndices() const;
823 /// setIsInBounds - Set or clear the inbounds flag on this GEP instruction.
824 /// See LangRef.html for the meaning of inbounds on a getelementptr.
825 void setIsInBounds(bool b = true);
827 /// isInBounds - Determine whether the GEP has the inbounds flag.
828 bool isInBounds() const;
830 // Methods for support type inquiry through isa, cast, and dyn_cast:
831 static inline bool classof(const GetElementPtrInst *) { return true; }
832 static inline bool classof(const Instruction *I) {
833 return (I->getOpcode() == Instruction::GetElementPtr);
835 static inline bool classof(const Value *V) {
836 return isa<Instruction>(V) && classof(cast<Instruction>(V));
841 struct OperandTraits<GetElementPtrInst> :
842 public VariadicOperandTraits<GetElementPtrInst, 1> {
845 GetElementPtrInst::GetElementPtrInst(Value *Ptr,
846 ArrayRef<Value *> IdxList,
848 const Twine &NameStr,
849 Instruction *InsertBefore)
850 : Instruction(PointerType::get(checkGEPType(
851 getIndexedType(Ptr->getType(), IdxList)),
852 cast<PointerType>(Ptr->getType())
853 ->getAddressSpace()),
855 OperandTraits<GetElementPtrInst>::op_end(this) - Values,
856 Values, InsertBefore) {
857 init(Ptr, IdxList, NameStr);
859 GetElementPtrInst::GetElementPtrInst(Value *Ptr,
860 ArrayRef<Value *> IdxList,
862 const Twine &NameStr,
863 BasicBlock *InsertAtEnd)
864 : Instruction(PointerType::get(checkGEPType(
865 getIndexedType(Ptr->getType(), IdxList)),
866 cast<PointerType>(Ptr->getType())
867 ->getAddressSpace()),
869 OperandTraits<GetElementPtrInst>::op_end(this) - Values,
870 Values, InsertAtEnd) {
871 init(Ptr, IdxList, NameStr);
875 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GetElementPtrInst, Value)
878 //===----------------------------------------------------------------------===//
880 //===----------------------------------------------------------------------===//
882 /// This instruction compares its operands according to the predicate given
883 /// to the constructor. It only operates on integers or pointers. The operands
884 /// must be identical types.
885 /// @brief Represent an integer comparison operator.
886 class ICmpInst: public CmpInst {
888 /// @brief Clone an identical ICmpInst
889 virtual ICmpInst *clone_impl() const;
891 /// @brief Constructor with insert-before-instruction semantics.
893 Instruction *InsertBefore, ///< Where to insert
894 Predicate pred, ///< The predicate to use for the comparison
895 Value *LHS, ///< The left-hand-side of the expression
896 Value *RHS, ///< The right-hand-side of the expression
897 const Twine &NameStr = "" ///< Name of the instruction
898 ) : CmpInst(makeCmpResultType(LHS->getType()),
899 Instruction::ICmp, pred, LHS, RHS, NameStr,
901 assert(pred >= CmpInst::FIRST_ICMP_PREDICATE &&
902 pred <= CmpInst::LAST_ICMP_PREDICATE &&
903 "Invalid ICmp predicate value");
904 assert(getOperand(0)->getType() == getOperand(1)->getType() &&
905 "Both operands to ICmp instruction are not of the same type!");
906 // Check that the operands are the right type
907 assert((getOperand(0)->getType()->isIntOrIntVectorTy() ||
908 getOperand(0)->getType()->isPointerTy()) &&
909 "Invalid operand types for ICmp instruction");
912 /// @brief Constructor with insert-at-end semantics.
914 BasicBlock &InsertAtEnd, ///< Block to insert into.
915 Predicate pred, ///< The predicate to use for the comparison
916 Value *LHS, ///< The left-hand-side of the expression
917 Value *RHS, ///< The right-hand-side of the expression
918 const Twine &NameStr = "" ///< Name of the instruction
919 ) : CmpInst(makeCmpResultType(LHS->getType()),
920 Instruction::ICmp, pred, LHS, RHS, NameStr,
922 assert(pred >= CmpInst::FIRST_ICMP_PREDICATE &&
923 pred <= CmpInst::LAST_ICMP_PREDICATE &&
924 "Invalid ICmp predicate value");
925 assert(getOperand(0)->getType() == getOperand(1)->getType() &&
926 "Both operands to ICmp instruction are not of the same type!");
927 // Check that the operands are the right type
928 assert((getOperand(0)->getType()->isIntOrIntVectorTy() ||
929 getOperand(0)->getType()->isPointerTy()) &&
930 "Invalid operand types for ICmp instruction");
933 /// @brief Constructor with no-insertion semantics
935 Predicate pred, ///< The predicate to use for the comparison
936 Value *LHS, ///< The left-hand-side of the expression
937 Value *RHS, ///< The right-hand-side of the expression
938 const Twine &NameStr = "" ///< Name of the instruction
939 ) : CmpInst(makeCmpResultType(LHS->getType()),
940 Instruction::ICmp, pred, LHS, RHS, NameStr) {
941 assert(pred >= CmpInst::FIRST_ICMP_PREDICATE &&
942 pred <= CmpInst::LAST_ICMP_PREDICATE &&
943 "Invalid ICmp predicate value");
944 assert(getOperand(0)->getType() == getOperand(1)->getType() &&
945 "Both operands to ICmp instruction are not of the same type!");
946 // Check that the operands are the right type
947 assert((getOperand(0)->getType()->isIntOrIntVectorTy() ||
948 getOperand(0)->getType()->isPointerTy()) &&
949 "Invalid operand types for ICmp instruction");
952 /// For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.
953 /// @returns the predicate that would be the result if the operand were
954 /// regarded as signed.
955 /// @brief Return the signed version of the predicate
956 Predicate getSignedPredicate() const {
957 return getSignedPredicate(getPredicate());
960 /// This is a static version that you can use without an instruction.
961 /// @brief Return the signed version of the predicate.
962 static Predicate getSignedPredicate(Predicate pred);
964 /// For example, EQ->EQ, SLE->ULE, UGT->UGT, etc.
965 /// @returns the predicate that would be the result if the operand were
966 /// regarded as unsigned.
967 /// @brief Return the unsigned version of the predicate
968 Predicate getUnsignedPredicate() const {
969 return getUnsignedPredicate(getPredicate());
972 /// This is a static version that you can use without an instruction.
973 /// @brief Return the unsigned version of the predicate.
974 static Predicate getUnsignedPredicate(Predicate pred);
976 /// isEquality - Return true if this predicate is either EQ or NE. This also
977 /// tests for commutativity.
978 static bool isEquality(Predicate P) {
979 return P == ICMP_EQ || P == ICMP_NE;
982 /// isEquality - Return true if this predicate is either EQ or NE. This also
983 /// tests for commutativity.
984 bool isEquality() const {
985 return isEquality(getPredicate());
988 /// @returns true if the predicate of this ICmpInst is commutative
989 /// @brief Determine if this relation is commutative.
990 bool isCommutative() const { return isEquality(); }
992 /// isRelational - Return true if the predicate is relational (not EQ or NE).
994 bool isRelational() const {
995 return !isEquality();
998 /// isRelational - Return true if the predicate is relational (not EQ or NE).
1000 static bool isRelational(Predicate P) {
1001 return !isEquality(P);
1004 /// Initialize a set of values that all satisfy the predicate with C.
1005 /// @brief Make a ConstantRange for a relation with a constant value.
1006 static ConstantRange makeConstantRange(Predicate pred, const APInt &C);
1008 /// Exchange the two operands to this instruction in such a way that it does
1009 /// not modify the semantics of the instruction. The predicate value may be
1010 /// changed to retain the same result if the predicate is order dependent
1012 /// @brief Swap operands and adjust predicate.
1013 void swapOperands() {
1014 setPredicate(getSwappedPredicate());
1015 Op<0>().swap(Op<1>());
1018 // Methods for support type inquiry through isa, cast, and dyn_cast:
1019 static inline bool classof(const ICmpInst *) { return true; }
1020 static inline bool classof(const Instruction *I) {
1021 return I->getOpcode() == Instruction::ICmp;
1023 static inline bool classof(const Value *V) {
1024 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1029 //===----------------------------------------------------------------------===//
1031 //===----------------------------------------------------------------------===//
1033 /// This instruction compares its operands according to the predicate given
1034 /// to the constructor. It only operates on floating point values or packed
1035 /// vectors of floating point values. The operands must be identical types.
1036 /// @brief Represents a floating point comparison operator.
1037 class FCmpInst: public CmpInst {
1039 /// @brief Clone an identical FCmpInst
1040 virtual FCmpInst *clone_impl() const;
1042 /// @brief Constructor with insert-before-instruction semantics.
1044 Instruction *InsertBefore, ///< Where to insert
1045 Predicate pred, ///< The predicate to use for the comparison
1046 Value *LHS, ///< The left-hand-side of the expression
1047 Value *RHS, ///< The right-hand-side of the expression
1048 const Twine &NameStr = "" ///< Name of the instruction
1049 ) : CmpInst(makeCmpResultType(LHS->getType()),
1050 Instruction::FCmp, pred, LHS, RHS, NameStr,
1052 assert(pred <= FCmpInst::LAST_FCMP_PREDICATE &&
1053 "Invalid FCmp predicate value");
1054 assert(getOperand(0)->getType() == getOperand(1)->getType() &&
1055 "Both operands to FCmp instruction are not of the same type!");
1056 // Check that the operands are the right type
1057 assert(getOperand(0)->getType()->isFPOrFPVectorTy() &&
1058 "Invalid operand types for FCmp instruction");
1061 /// @brief Constructor with insert-at-end semantics.
1063 BasicBlock &InsertAtEnd, ///< Block to insert into.
1064 Predicate pred, ///< The predicate to use for the comparison
1065 Value *LHS, ///< The left-hand-side of the expression
1066 Value *RHS, ///< The right-hand-side of the expression
1067 const Twine &NameStr = "" ///< Name of the instruction
1068 ) : CmpInst(makeCmpResultType(LHS->getType()),
1069 Instruction::FCmp, pred, LHS, RHS, NameStr,
1071 assert(pred <= FCmpInst::LAST_FCMP_PREDICATE &&
1072 "Invalid FCmp predicate value");
1073 assert(getOperand(0)->getType() == getOperand(1)->getType() &&
1074 "Both operands to FCmp instruction are not of the same type!");
1075 // Check that the operands are the right type
1076 assert(getOperand(0)->getType()->isFPOrFPVectorTy() &&
1077 "Invalid operand types for FCmp instruction");
1080 /// @brief Constructor with no-insertion semantics
1082 Predicate pred, ///< The predicate to use for the comparison
1083 Value *LHS, ///< The left-hand-side of the expression
1084 Value *RHS, ///< The right-hand-side of the expression
1085 const Twine &NameStr = "" ///< Name of the instruction
1086 ) : CmpInst(makeCmpResultType(LHS->getType()),
1087 Instruction::FCmp, pred, LHS, RHS, NameStr) {
1088 assert(pred <= FCmpInst::LAST_FCMP_PREDICATE &&
1089 "Invalid FCmp predicate value");
1090 assert(getOperand(0)->getType() == getOperand(1)->getType() &&
1091 "Both operands to FCmp instruction are not of the same type!");
1092 // Check that the operands are the right type
1093 assert(getOperand(0)->getType()->isFPOrFPVectorTy() &&
1094 "Invalid operand types for FCmp instruction");
1097 /// @returns true if the predicate of this instruction is EQ or NE.
1098 /// @brief Determine if this is an equality predicate.
1099 bool isEquality() const {
1100 return getPredicate() == FCMP_OEQ || getPredicate() == FCMP_ONE ||
1101 getPredicate() == FCMP_UEQ || getPredicate() == FCMP_UNE;
1104 /// @returns true if the predicate of this instruction is commutative.
1105 /// @brief Determine if this is a commutative predicate.
1106 bool isCommutative() const {
1107 return isEquality() ||
1108 getPredicate() == FCMP_FALSE ||
1109 getPredicate() == FCMP_TRUE ||
1110 getPredicate() == FCMP_ORD ||
1111 getPredicate() == FCMP_UNO;
1114 /// @returns true if the predicate is relational (not EQ or NE).
1115 /// @brief Determine if this a relational predicate.
1116 bool isRelational() const { return !isEquality(); }
1118 /// Exchange the two operands to this instruction in such a way that it does
1119 /// not modify the semantics of the instruction. The predicate value may be
1120 /// changed to retain the same result if the predicate is order dependent
1122 /// @brief Swap operands and adjust predicate.
1123 void swapOperands() {
1124 setPredicate(getSwappedPredicate());
1125 Op<0>().swap(Op<1>());
1128 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
1129 static inline bool classof(const FCmpInst *) { return true; }
1130 static inline bool classof(const Instruction *I) {
1131 return I->getOpcode() == Instruction::FCmp;
1133 static inline bool classof(const Value *V) {
1134 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1138 //===----------------------------------------------------------------------===//
1139 /// CallInst - This class represents a function call, abstracting a target
1140 /// machine's calling convention. This class uses low bit of the SubClassData
1141 /// field to indicate whether or not this is a tail call. The rest of the bits
1142 /// hold the calling convention of the call.
1144 class CallInst : public Instruction {
1145 AttrListPtr AttributeList; ///< parameter attributes for call
1146 CallInst(const CallInst &CI);
1147 void init(Value *Func, ArrayRef<Value *> Args, const Twine &NameStr);
1148 void init(Value *Func, const Twine &NameStr);
1150 /// Construct a CallInst given a range of arguments.
1151 /// @brief Construct a CallInst from a range of arguments
1152 inline CallInst(Value *Func, ArrayRef<Value *> Args,
1153 const Twine &NameStr, Instruction *InsertBefore);
1155 /// Construct a CallInst given a range of arguments.
1156 /// @brief Construct a CallInst from a range of arguments
1157 inline CallInst(Value *Func, ArrayRef<Value *> Args,
1158 const Twine &NameStr, BasicBlock *InsertAtEnd);
1160 CallInst(Value *F, Value *Actual, const Twine &NameStr,
1161 Instruction *InsertBefore);
1162 CallInst(Value *F, Value *Actual, const Twine &NameStr,
1163 BasicBlock *InsertAtEnd);
1164 explicit CallInst(Value *F, const Twine &NameStr,
1165 Instruction *InsertBefore);
1166 CallInst(Value *F, const Twine &NameStr, BasicBlock *InsertAtEnd);
1168 virtual CallInst *clone_impl() const;
1170 static CallInst *Create(Value *Func,
1171 ArrayRef<Value *> Args,
1172 const Twine &NameStr = "",
1173 Instruction *InsertBefore = 0) {
1174 return new(unsigned(Args.size() + 1))
1175 CallInst(Func, Args, NameStr, InsertBefore);
1177 static CallInst *Create(Value *Func,
1178 ArrayRef<Value *> Args,
1179 const Twine &NameStr, BasicBlock *InsertAtEnd) {
1180 return new(unsigned(Args.size() + 1))
1181 CallInst(Func, Args, NameStr, InsertAtEnd);
1183 static CallInst *Create(Value *F, const Twine &NameStr = "",
1184 Instruction *InsertBefore = 0) {
1185 return new(1) CallInst(F, NameStr, InsertBefore);
1187 static CallInst *Create(Value *F, const Twine &NameStr,
1188 BasicBlock *InsertAtEnd) {
1189 return new(1) CallInst(F, NameStr, InsertAtEnd);
1191 /// CreateMalloc - Generate the IR for a call to malloc:
1192 /// 1. Compute the malloc call's argument as the specified type's size,
1193 /// possibly multiplied by the array size if the array size is not
1195 /// 2. Call malloc with that argument.
1196 /// 3. Bitcast the result of the malloc call to the specified type.
1197 static Instruction *CreateMalloc(Instruction *InsertBefore,
1198 Type *IntPtrTy, Type *AllocTy,
1199 Value *AllocSize, Value *ArraySize = 0,
1200 Function* MallocF = 0,
1201 const Twine &Name = "");
1202 static Instruction *CreateMalloc(BasicBlock *InsertAtEnd,
1203 Type *IntPtrTy, Type *AllocTy,
1204 Value *AllocSize, Value *ArraySize = 0,
1205 Function* MallocF = 0,
1206 const Twine &Name = "");
1207 /// CreateFree - Generate the IR for a call to the builtin free function.
1208 static Instruction* CreateFree(Value* Source, Instruction *InsertBefore);
1209 static Instruction* CreateFree(Value* Source, BasicBlock *InsertAtEnd);
1213 bool isTailCall() const { return getSubclassDataFromInstruction() & 1; }
1214 void setTailCall(bool isTC = true) {
1215 setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
1219 /// Provide fast operand accessors
1220 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1222 /// getNumArgOperands - Return the number of call arguments.
1224 unsigned getNumArgOperands() const { return getNumOperands() - 1; }
1226 /// getArgOperand/setArgOperand - Return/set the i-th call argument.
1228 Value *getArgOperand(unsigned i) const { return getOperand(i); }
1229 void setArgOperand(unsigned i, Value *v) { setOperand(i, v); }
1231 /// getCallingConv/setCallingConv - Get or set the calling convention of this
1233 CallingConv::ID getCallingConv() const {
1234 return static_cast<CallingConv::ID>(getSubclassDataFromInstruction() >> 1);
1236 void setCallingConv(CallingConv::ID CC) {
1237 setInstructionSubclassData((getSubclassDataFromInstruction() & 1) |
1238 (static_cast<unsigned>(CC) << 1));
1241 /// getAttributes - Return the parameter attributes for this call.
1243 const AttrListPtr &getAttributes() const { return AttributeList; }
1245 /// setAttributes - Set the parameter attributes for this call.
1247 void setAttributes(const AttrListPtr &Attrs) { AttributeList = Attrs; }
1249 /// addAttribute - adds the attribute to the list of attributes.
1250 void addAttribute(unsigned i, Attributes attr);
1252 /// removeAttribute - removes the attribute from the list of attributes.
1253 void removeAttribute(unsigned i, Attributes attr);
1255 /// @brief Determine whether the call or the callee has the given attribute.
1256 bool paramHasAttr(unsigned i, Attributes attr) const;
1258 /// @brief Extract the alignment for a call or parameter (0=unknown).
1259 unsigned getParamAlignment(unsigned i) const {
1260 return AttributeList.getParamAlignment(i);
1263 /// @brief Return true if the call should not be inlined.
1264 bool isNoInline() const { return paramHasAttr(~0, Attribute::NoInline); }
1265 void setIsNoInline(bool Value = true) {
1266 if (Value) addAttribute(~0, Attribute::NoInline);
1267 else removeAttribute(~0, Attribute::NoInline);
1270 /// @brief Determine if the call does not access memory.
1271 bool doesNotAccessMemory() const {
1272 return paramHasAttr(~0, Attribute::ReadNone);
1274 void setDoesNotAccessMemory(bool NotAccessMemory = true) {
1275 if (NotAccessMemory) addAttribute(~0, Attribute::ReadNone);
1276 else removeAttribute(~0, Attribute::ReadNone);
1279 /// @brief Determine if the call does not access or only reads memory.
1280 bool onlyReadsMemory() const {
1281 return doesNotAccessMemory() || paramHasAttr(~0, Attribute::ReadOnly);
1283 void setOnlyReadsMemory(bool OnlyReadsMemory = true) {
1284 if (OnlyReadsMemory) addAttribute(~0, Attribute::ReadOnly);
1285 else removeAttribute(~0, Attribute::ReadOnly | Attribute::ReadNone);
1288 /// @brief Determine if the call cannot return.
1289 bool doesNotReturn() const { return paramHasAttr(~0, Attribute::NoReturn); }
1290 void setDoesNotReturn(bool DoesNotReturn = true) {
1291 if (DoesNotReturn) addAttribute(~0, Attribute::NoReturn);
1292 else removeAttribute(~0, Attribute::NoReturn);
1295 /// @brief Determine if the call cannot unwind.
1296 bool doesNotThrow() const { return paramHasAttr(~0, Attribute::NoUnwind); }
1297 void setDoesNotThrow(bool DoesNotThrow = true) {
1298 if (DoesNotThrow) addAttribute(~0, Attribute::NoUnwind);
1299 else removeAttribute(~0, Attribute::NoUnwind);
1302 /// @brief Determine if the call returns a structure through first
1303 /// pointer argument.
1304 bool hasStructRetAttr() const {
1305 // Be friendly and also check the callee.
1306 return paramHasAttr(1, Attribute::StructRet);
1309 /// @brief Determine if any call argument is an aggregate passed by value.
1310 bool hasByValArgument() const {
1311 return AttributeList.hasAttrSomewhere(Attribute::ByVal);
1314 /// getCalledFunction - Return the function called, or null if this is an
1315 /// indirect function invocation.
1317 Function *getCalledFunction() const {
1318 return dyn_cast<Function>(Op<-1>());
1321 /// getCalledValue - Get a pointer to the function that is invoked by this
1323 const Value *getCalledValue() const { return Op<-1>(); }
1324 Value *getCalledValue() { return Op<-1>(); }
1326 /// setCalledFunction - Set the function called.
1327 void setCalledFunction(Value* Fn) {
1331 /// isInlineAsm - Check if this call is an inline asm statement.
1332 bool isInlineAsm() const {
1333 return isa<InlineAsm>(Op<-1>());
1336 // Methods for support type inquiry through isa, cast, and dyn_cast:
1337 static inline bool classof(const CallInst *) { return true; }
1338 static inline bool classof(const Instruction *I) {
1339 return I->getOpcode() == Instruction::Call;
1341 static inline bool classof(const Value *V) {
1342 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1345 // Shadow Instruction::setInstructionSubclassData with a private forwarding
1346 // method so that subclasses cannot accidentally use it.
1347 void setInstructionSubclassData(unsigned short D) {
1348 Instruction::setInstructionSubclassData(D);
1353 struct OperandTraits<CallInst> : public VariadicOperandTraits<CallInst, 1> {
1356 CallInst::CallInst(Value *Func, ArrayRef<Value *> Args,
1357 const Twine &NameStr, BasicBlock *InsertAtEnd)
1358 : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
1359 ->getElementType())->getReturnType(),
1361 OperandTraits<CallInst>::op_end(this) - (Args.size() + 1),
1362 unsigned(Args.size() + 1), InsertAtEnd) {
1363 init(Func, Args, NameStr);
1366 CallInst::CallInst(Value *Func, ArrayRef<Value *> Args,
1367 const Twine &NameStr, Instruction *InsertBefore)
1368 : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
1369 ->getElementType())->getReturnType(),
1371 OperandTraits<CallInst>::op_end(this) - (Args.size() + 1),
1372 unsigned(Args.size() + 1), InsertBefore) {
1373 init(Func, Args, NameStr);
1377 // Note: if you get compile errors about private methods then
1378 // please update your code to use the high-level operand
1379 // interfaces. See line 943 above.
1380 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CallInst, Value)
1382 //===----------------------------------------------------------------------===//
1384 //===----------------------------------------------------------------------===//
1386 /// SelectInst - This class represents the LLVM 'select' instruction.
1388 class SelectInst : public Instruction {
1389 void init(Value *C, Value *S1, Value *S2) {
1390 assert(!areInvalidOperands(C, S1, S2) && "Invalid operands for select");
1396 SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
1397 Instruction *InsertBefore)
1398 : Instruction(S1->getType(), Instruction::Select,
1399 &Op<0>(), 3, InsertBefore) {
1403 SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
1404 BasicBlock *InsertAtEnd)
1405 : Instruction(S1->getType(), Instruction::Select,
1406 &Op<0>(), 3, InsertAtEnd) {
1411 virtual SelectInst *clone_impl() const;
1413 static SelectInst *Create(Value *C, Value *S1, Value *S2,
1414 const Twine &NameStr = "",
1415 Instruction *InsertBefore = 0) {
1416 return new(3) SelectInst(C, S1, S2, NameStr, InsertBefore);
1418 static SelectInst *Create(Value *C, Value *S1, Value *S2,
1419 const Twine &NameStr,
1420 BasicBlock *InsertAtEnd) {
1421 return new(3) SelectInst(C, S1, S2, NameStr, InsertAtEnd);
1424 const Value *getCondition() const { return Op<0>(); }
1425 const Value *getTrueValue() const { return Op<1>(); }
1426 const Value *getFalseValue() const { return Op<2>(); }
1427 Value *getCondition() { return Op<0>(); }
1428 Value *getTrueValue() { return Op<1>(); }
1429 Value *getFalseValue() { return Op<2>(); }
1431 /// areInvalidOperands - Return a string if the specified operands are invalid
1432 /// for a select operation, otherwise return null.
1433 static const char *areInvalidOperands(Value *Cond, Value *True, Value *False);
1435 /// Transparently provide more efficient getOperand methods.
1436 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1438 OtherOps getOpcode() const {
1439 return static_cast<OtherOps>(Instruction::getOpcode());
1442 // Methods for support type inquiry through isa, cast, and dyn_cast:
1443 static inline bool classof(const SelectInst *) { return true; }
1444 static inline bool classof(const Instruction *I) {
1445 return I->getOpcode() == Instruction::Select;
1447 static inline bool classof(const Value *V) {
1448 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1453 struct OperandTraits<SelectInst> : public FixedNumOperandTraits<SelectInst, 3> {
1456 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(SelectInst, Value)
1458 //===----------------------------------------------------------------------===//
1460 //===----------------------------------------------------------------------===//
1462 /// VAArgInst - This class represents the va_arg llvm instruction, which returns
1463 /// an argument of the specified type given a va_list and increments that list
1465 class VAArgInst : public UnaryInstruction {
1467 virtual VAArgInst *clone_impl() const;
1470 VAArgInst(Value *List, Type *Ty, const Twine &NameStr = "",
1471 Instruction *InsertBefore = 0)
1472 : UnaryInstruction(Ty, VAArg, List, InsertBefore) {
1475 VAArgInst(Value *List, Type *Ty, const Twine &NameStr,
1476 BasicBlock *InsertAtEnd)
1477 : UnaryInstruction(Ty, VAArg, List, InsertAtEnd) {
1481 Value *getPointerOperand() { return getOperand(0); }
1482 const Value *getPointerOperand() const { return getOperand(0); }
1483 static unsigned getPointerOperandIndex() { return 0U; }
1485 // Methods for support type inquiry through isa, cast, and dyn_cast:
1486 static inline bool classof(const VAArgInst *) { return true; }
1487 static inline bool classof(const Instruction *I) {
1488 return I->getOpcode() == VAArg;
1490 static inline bool classof(const Value *V) {
1491 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1495 //===----------------------------------------------------------------------===//
1496 // ExtractElementInst Class
1497 //===----------------------------------------------------------------------===//
1499 /// ExtractElementInst - This instruction extracts a single (scalar)
1500 /// element from a VectorType value
1502 class ExtractElementInst : public Instruction {
1503 ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr = "",
1504 Instruction *InsertBefore = 0);
1505 ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr,
1506 BasicBlock *InsertAtEnd);
1508 virtual ExtractElementInst *clone_impl() const;
1511 static ExtractElementInst *Create(Value *Vec, Value *Idx,
1512 const Twine &NameStr = "",
1513 Instruction *InsertBefore = 0) {
1514 return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertBefore);
1516 static ExtractElementInst *Create(Value *Vec, Value *Idx,
1517 const Twine &NameStr,
1518 BasicBlock *InsertAtEnd) {
1519 return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertAtEnd);
1522 /// isValidOperands - Return true if an extractelement instruction can be
1523 /// formed with the specified operands.
1524 static bool isValidOperands(const Value *Vec, const Value *Idx);
1526 Value *getVectorOperand() { return Op<0>(); }
1527 Value *getIndexOperand() { return Op<1>(); }
1528 const Value *getVectorOperand() const { return Op<0>(); }
1529 const Value *getIndexOperand() const { return Op<1>(); }
1531 VectorType *getVectorOperandType() const {
1532 return reinterpret_cast<VectorType*>(getVectorOperand()->getType());
1536 /// Transparently provide more efficient getOperand methods.
1537 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1539 // Methods for support type inquiry through isa, cast, and dyn_cast:
1540 static inline bool classof(const ExtractElementInst *) { return true; }
1541 static inline bool classof(const Instruction *I) {
1542 return I->getOpcode() == Instruction::ExtractElement;
1544 static inline bool classof(const Value *V) {
1545 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1550 struct OperandTraits<ExtractElementInst> :
1551 public FixedNumOperandTraits<ExtractElementInst, 2> {
1554 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ExtractElementInst, Value)
1556 //===----------------------------------------------------------------------===//
1557 // InsertElementInst Class
1558 //===----------------------------------------------------------------------===//
1560 /// InsertElementInst - This instruction inserts a single (scalar)
1561 /// element into a VectorType value
1563 class InsertElementInst : public Instruction {
1564 InsertElementInst(Value *Vec, Value *NewElt, Value *Idx,
1565 const Twine &NameStr = "",
1566 Instruction *InsertBefore = 0);
1567 InsertElementInst(Value *Vec, Value *NewElt, Value *Idx,
1568 const Twine &NameStr, BasicBlock *InsertAtEnd);
1570 virtual InsertElementInst *clone_impl() const;
1573 static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
1574 const Twine &NameStr = "",
1575 Instruction *InsertBefore = 0) {
1576 return new(3) InsertElementInst(Vec, NewElt, Idx, NameStr, InsertBefore);
1578 static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
1579 const Twine &NameStr,
1580 BasicBlock *InsertAtEnd) {
1581 return new(3) InsertElementInst(Vec, NewElt, Idx, NameStr, InsertAtEnd);
1584 /// isValidOperands - Return true if an insertelement instruction can be
1585 /// formed with the specified operands.
1586 static bool isValidOperands(const Value *Vec, const Value *NewElt,
1589 /// getType - Overload to return most specific vector type.
1591 VectorType *getType() const {
1592 return reinterpret_cast<VectorType*>(Instruction::getType());
1595 /// Transparently provide more efficient getOperand methods.
1596 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1598 // Methods for support type inquiry through isa, cast, and dyn_cast:
1599 static inline bool classof(const InsertElementInst *) { return true; }
1600 static inline bool classof(const Instruction *I) {
1601 return I->getOpcode() == Instruction::InsertElement;
1603 static inline bool classof(const Value *V) {
1604 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1609 struct OperandTraits<InsertElementInst> :
1610 public FixedNumOperandTraits<InsertElementInst, 3> {
1613 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertElementInst, Value)
1615 //===----------------------------------------------------------------------===//
1616 // ShuffleVectorInst Class
1617 //===----------------------------------------------------------------------===//
1619 /// ShuffleVectorInst - This instruction constructs a fixed permutation of two
1622 class ShuffleVectorInst : public Instruction {
1624 virtual ShuffleVectorInst *clone_impl() const;
1627 // allocate space for exactly three operands
1628 void *operator new(size_t s) {
1629 return User::operator new(s, 3);
1631 ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
1632 const Twine &NameStr = "",
1633 Instruction *InsertBefor = 0);
1634 ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
1635 const Twine &NameStr, BasicBlock *InsertAtEnd);
1637 /// isValidOperands - Return true if a shufflevector instruction can be
1638 /// formed with the specified operands.
1639 static bool isValidOperands(const Value *V1, const Value *V2,
1642 /// getType - Overload to return most specific vector type.
1644 VectorType *getType() const {
1645 return reinterpret_cast<VectorType*>(Instruction::getType());
1648 /// Transparently provide more efficient getOperand methods.
1649 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1651 /// getMaskValue - Return the index from the shuffle mask for the specified
1652 /// output result. This is either -1 if the element is undef or a number less
1653 /// than 2*numelements.
1654 int getMaskValue(unsigned i) const;
1656 // Methods for support type inquiry through isa, cast, and dyn_cast:
1657 static inline bool classof(const ShuffleVectorInst *) { return true; }
1658 static inline bool classof(const Instruction *I) {
1659 return I->getOpcode() == Instruction::ShuffleVector;
1661 static inline bool classof(const Value *V) {
1662 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1667 struct OperandTraits<ShuffleVectorInst> :
1668 public FixedNumOperandTraits<ShuffleVectorInst, 3> {
1671 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ShuffleVectorInst, Value)
1673 //===----------------------------------------------------------------------===//
1674 // ExtractValueInst Class
1675 //===----------------------------------------------------------------------===//
1677 /// ExtractValueInst - This instruction extracts a struct member or array
1678 /// element value from an aggregate value.
1680 class ExtractValueInst : public UnaryInstruction {
1681 SmallVector<unsigned, 4> Indices;
1683 ExtractValueInst(const ExtractValueInst &EVI);
1684 void init(ArrayRef<unsigned> Idxs, const Twine &NameStr);
1686 /// Constructors - Create a extractvalue instruction with a base aggregate
1687 /// value and a list of indices. The first ctor can optionally insert before
1688 /// an existing instruction, the second appends the new instruction to the
1689 /// specified BasicBlock.
1690 inline ExtractValueInst(Value *Agg,
1691 ArrayRef<unsigned> Idxs,
1692 const Twine &NameStr,
1693 Instruction *InsertBefore);
1694 inline ExtractValueInst(Value *Agg,
1695 ArrayRef<unsigned> Idxs,
1696 const Twine &NameStr, BasicBlock *InsertAtEnd);
1698 // allocate space for exactly one operand
1699 void *operator new(size_t s) {
1700 return User::operator new(s, 1);
1703 virtual ExtractValueInst *clone_impl() const;
1706 static ExtractValueInst *Create(Value *Agg,
1707 ArrayRef<unsigned> Idxs,
1708 const Twine &NameStr = "",
1709 Instruction *InsertBefore = 0) {
1711 ExtractValueInst(Agg, Idxs, NameStr, InsertBefore);
1713 static ExtractValueInst *Create(Value *Agg,
1714 ArrayRef<unsigned> Idxs,
1715 const Twine &NameStr,
1716 BasicBlock *InsertAtEnd) {
1717 return new ExtractValueInst(Agg, Idxs, NameStr, InsertAtEnd);
1720 /// getIndexedType - Returns the type of the element that would be extracted
1721 /// with an extractvalue instruction with the specified parameters.
1723 /// Null is returned if the indices are invalid for the specified type.
1724 static Type *getIndexedType(Type *Agg, ArrayRef<unsigned> Idxs);
1726 typedef const unsigned* idx_iterator;
1727 inline idx_iterator idx_begin() const { return Indices.begin(); }
1728 inline idx_iterator idx_end() const { return Indices.end(); }
1730 Value *getAggregateOperand() {
1731 return getOperand(0);
1733 const Value *getAggregateOperand() const {
1734 return getOperand(0);
1736 static unsigned getAggregateOperandIndex() {
1737 return 0U; // get index for modifying correct operand
1740 ArrayRef<unsigned> getIndices() const {
1744 unsigned getNumIndices() const {
1745 return (unsigned)Indices.size();
1748 bool hasIndices() const {
1752 // Methods for support type inquiry through isa, cast, and dyn_cast:
1753 static inline bool classof(const ExtractValueInst *) { return true; }
1754 static inline bool classof(const Instruction *I) {
1755 return I->getOpcode() == Instruction::ExtractValue;
1757 static inline bool classof(const Value *V) {
1758 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1762 ExtractValueInst::ExtractValueInst(Value *Agg,
1763 ArrayRef<unsigned> Idxs,
1764 const Twine &NameStr,
1765 Instruction *InsertBefore)
1766 : UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)),
1767 ExtractValue, Agg, InsertBefore) {
1768 init(Idxs, NameStr);
1770 ExtractValueInst::ExtractValueInst(Value *Agg,
1771 ArrayRef<unsigned> Idxs,
1772 const Twine &NameStr,
1773 BasicBlock *InsertAtEnd)
1774 : UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)),
1775 ExtractValue, Agg, InsertAtEnd) {
1776 init(Idxs, NameStr);
1780 //===----------------------------------------------------------------------===//
1781 // InsertValueInst Class
1782 //===----------------------------------------------------------------------===//
1784 /// InsertValueInst - This instruction inserts a struct field of array element
1785 /// value into an aggregate value.
1787 class InsertValueInst : public Instruction {
1788 SmallVector<unsigned, 4> Indices;
1790 void *operator new(size_t, unsigned); // Do not implement
1791 InsertValueInst(const InsertValueInst &IVI);
1792 void init(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
1793 const Twine &NameStr);
1795 /// Constructors - Create a insertvalue instruction with a base aggregate
1796 /// value, a value to insert, and a list of indices. The first ctor can
1797 /// optionally insert before an existing instruction, the second appends
1798 /// the new instruction to the specified BasicBlock.
1799 inline InsertValueInst(Value *Agg, Value *Val,
1800 ArrayRef<unsigned> Idxs,
1801 const Twine &NameStr,
1802 Instruction *InsertBefore);
1803 inline InsertValueInst(Value *Agg, Value *Val,
1804 ArrayRef<unsigned> Idxs,
1805 const Twine &NameStr, BasicBlock *InsertAtEnd);
1807 /// Constructors - These two constructors are convenience methods because one
1808 /// and two index insertvalue instructions are so common.
1809 InsertValueInst(Value *Agg, Value *Val,
1810 unsigned Idx, const Twine &NameStr = "",
1811 Instruction *InsertBefore = 0);
1812 InsertValueInst(Value *Agg, Value *Val, unsigned Idx,
1813 const Twine &NameStr, BasicBlock *InsertAtEnd);
1815 virtual InsertValueInst *clone_impl() const;
1817 // allocate space for exactly two operands
1818 void *operator new(size_t s) {
1819 return User::operator new(s, 2);
1822 static InsertValueInst *Create(Value *Agg, Value *Val,
1823 ArrayRef<unsigned> Idxs,
1824 const Twine &NameStr = "",
1825 Instruction *InsertBefore = 0) {
1826 return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertBefore);
1828 static InsertValueInst *Create(Value *Agg, Value *Val,
1829 ArrayRef<unsigned> Idxs,
1830 const Twine &NameStr,
1831 BasicBlock *InsertAtEnd) {
1832 return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertAtEnd);
1835 /// Transparently provide more efficient getOperand methods.
1836 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1838 typedef const unsigned* idx_iterator;
1839 inline idx_iterator idx_begin() const { return Indices.begin(); }
1840 inline idx_iterator idx_end() const { return Indices.end(); }
1842 Value *getAggregateOperand() {
1843 return getOperand(0);
1845 const Value *getAggregateOperand() const {
1846 return getOperand(0);
1848 static unsigned getAggregateOperandIndex() {
1849 return 0U; // get index for modifying correct operand
1852 Value *getInsertedValueOperand() {
1853 return getOperand(1);
1855 const Value *getInsertedValueOperand() const {
1856 return getOperand(1);
1858 static unsigned getInsertedValueOperandIndex() {
1859 return 1U; // get index for modifying correct operand
1862 ArrayRef<unsigned> getIndices() const {
1866 unsigned getNumIndices() const {
1867 return (unsigned)Indices.size();
1870 bool hasIndices() const {
1874 // Methods for support type inquiry through isa, cast, and dyn_cast:
1875 static inline bool classof(const InsertValueInst *) { return true; }
1876 static inline bool classof(const Instruction *I) {
1877 return I->getOpcode() == Instruction::InsertValue;
1879 static inline bool classof(const Value *V) {
1880 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1885 struct OperandTraits<InsertValueInst> :
1886 public FixedNumOperandTraits<InsertValueInst, 2> {
1889 InsertValueInst::InsertValueInst(Value *Agg,
1891 ArrayRef<unsigned> Idxs,
1892 const Twine &NameStr,
1893 Instruction *InsertBefore)
1894 : Instruction(Agg->getType(), InsertValue,
1895 OperandTraits<InsertValueInst>::op_begin(this),
1897 init(Agg, Val, Idxs, NameStr);
1899 InsertValueInst::InsertValueInst(Value *Agg,
1901 ArrayRef<unsigned> Idxs,
1902 const Twine &NameStr,
1903 BasicBlock *InsertAtEnd)
1904 : Instruction(Agg->getType(), InsertValue,
1905 OperandTraits<InsertValueInst>::op_begin(this),
1907 init(Agg, Val, Idxs, NameStr);
1910 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertValueInst, Value)
1912 //===----------------------------------------------------------------------===//
1914 //===----------------------------------------------------------------------===//
1916 // PHINode - The PHINode class is used to represent the magical mystical PHI
1917 // node, that can not exist in nature, but can be synthesized in a computer
1918 // scientist's overactive imagination.
1920 class PHINode : public Instruction {
1921 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
1922 /// ReservedSpace - The number of operands actually allocated. NumOperands is
1923 /// the number actually in use.
1924 unsigned ReservedSpace;
1925 PHINode(const PHINode &PN);
1926 // allocate space for exactly zero operands
1927 void *operator new(size_t s) {
1928 return User::operator new(s, 0);
1930 explicit PHINode(Type *Ty, unsigned NumReservedValues,
1931 const Twine &NameStr = "", Instruction *InsertBefore = 0)
1932 : Instruction(Ty, Instruction::PHI, 0, 0, InsertBefore),
1933 ReservedSpace(NumReservedValues) {
1935 OperandList = allocHungoffUses(ReservedSpace);
1938 PHINode(Type *Ty, unsigned NumReservedValues, const Twine &NameStr,
1939 BasicBlock *InsertAtEnd)
1940 : Instruction(Ty, Instruction::PHI, 0, 0, InsertAtEnd),
1941 ReservedSpace(NumReservedValues) {
1943 OperandList = allocHungoffUses(ReservedSpace);
1946 // allocHungoffUses - this is more complicated than the generic
1947 // User::allocHungoffUses, because we have to allocate Uses for the incoming
1948 // values and pointers to the incoming blocks, all in one allocation.
1949 Use *allocHungoffUses(unsigned) const;
1951 virtual PHINode *clone_impl() const;
1953 /// Constructors - NumReservedValues is a hint for the number of incoming
1954 /// edges that this phi node will have (use 0 if you really have no idea).
1955 static PHINode *Create(Type *Ty, unsigned NumReservedValues,
1956 const Twine &NameStr = "",
1957 Instruction *InsertBefore = 0) {
1958 return new PHINode(Ty, NumReservedValues, NameStr, InsertBefore);
1960 static PHINode *Create(Type *Ty, unsigned NumReservedValues,
1961 const Twine &NameStr, BasicBlock *InsertAtEnd) {
1962 return new PHINode(Ty, NumReservedValues, NameStr, InsertAtEnd);
1966 /// Provide fast operand accessors
1967 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1969 // Block iterator interface. This provides access to the list of incoming
1970 // basic blocks, which parallels the list of incoming values.
1972 typedef BasicBlock **block_iterator;
1973 typedef BasicBlock * const *const_block_iterator;
1975 block_iterator block_begin() {
1977 reinterpret_cast<Use::UserRef*>(op_begin() + ReservedSpace);
1978 return reinterpret_cast<block_iterator>(ref + 1);
1981 const_block_iterator block_begin() const {
1982 const Use::UserRef *ref =
1983 reinterpret_cast<const Use::UserRef*>(op_begin() + ReservedSpace);
1984 return reinterpret_cast<const_block_iterator>(ref + 1);
1987 block_iterator block_end() {
1988 return block_begin() + getNumOperands();
1991 const_block_iterator block_end() const {
1992 return block_begin() + getNumOperands();
1995 /// getNumIncomingValues - Return the number of incoming edges
1997 unsigned getNumIncomingValues() const { return getNumOperands(); }
1999 /// getIncomingValue - Return incoming value number x
2001 Value *getIncomingValue(unsigned i) const {
2002 return getOperand(i);
2004 void setIncomingValue(unsigned i, Value *V) {
2007 static unsigned getOperandNumForIncomingValue(unsigned i) {
2010 static unsigned getIncomingValueNumForOperand(unsigned i) {
2014 /// getIncomingBlock - Return incoming basic block number @p i.
2016 BasicBlock *getIncomingBlock(unsigned i) const {
2017 return block_begin()[i];
2020 /// getIncomingBlock - Return incoming basic block corresponding
2021 /// to an operand of the PHI.
2023 BasicBlock *getIncomingBlock(const Use &U) const {
2024 assert(this == U.getUser() && "Iterator doesn't point to PHI's Uses?");
2025 return getIncomingBlock(unsigned(&U - op_begin()));
2028 /// getIncomingBlock - Return incoming basic block corresponding
2029 /// to value use iterator.
2031 template <typename U>
2032 BasicBlock *getIncomingBlock(value_use_iterator<U> I) const {
2033 return getIncomingBlock(I.getUse());
2036 void setIncomingBlock(unsigned i, BasicBlock *BB) {
2037 block_begin()[i] = BB;
2040 /// addIncoming - Add an incoming value to the end of the PHI list
2042 void addIncoming(Value *V, BasicBlock *BB) {
2043 assert(V && "PHI node got a null value!");
2044 assert(BB && "PHI node got a null basic block!");
2045 assert(getType() == V->getType() &&
2046 "All operands to PHI node must be the same type as the PHI node!");
2047 if (NumOperands == ReservedSpace)
2048 growOperands(); // Get more space!
2049 // Initialize some new operands.
2051 setIncomingValue(NumOperands - 1, V);
2052 setIncomingBlock(NumOperands - 1, BB);
2055 /// removeIncomingValue - Remove an incoming value. This is useful if a
2056 /// predecessor basic block is deleted. The value removed is returned.
2058 /// If the last incoming value for a PHI node is removed (and DeletePHIIfEmpty
2059 /// is true), the PHI node is destroyed and any uses of it are replaced with
2060 /// dummy values. The only time there should be zero incoming values to a PHI
2061 /// node is when the block is dead, so this strategy is sound.
2063 Value *removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty = true);
2065 Value *removeIncomingValue(const BasicBlock *BB, bool DeletePHIIfEmpty=true) {
2066 int Idx = getBasicBlockIndex(BB);
2067 assert(Idx >= 0 && "Invalid basic block argument to remove!");
2068 return removeIncomingValue(Idx, DeletePHIIfEmpty);
2071 /// getBasicBlockIndex - Return the first index of the specified basic
2072 /// block in the value list for this PHI. Returns -1 if no instance.
2074 int getBasicBlockIndex(const BasicBlock *BB) const {
2075 for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
2076 if (block_begin()[i] == BB)
2081 Value *getIncomingValueForBlock(const BasicBlock *BB) const {
2082 int Idx = getBasicBlockIndex(BB);
2083 assert(Idx >= 0 && "Invalid basic block argument!");
2084 return getIncomingValue(Idx);
2087 /// hasConstantValue - If the specified PHI node always merges together the
2088 /// same value, return the value, otherwise return null.
2089 Value *hasConstantValue() const;
2091 /// Methods for support type inquiry through isa, cast, and dyn_cast:
2092 static inline bool classof(const PHINode *) { return true; }
2093 static inline bool classof(const Instruction *I) {
2094 return I->getOpcode() == Instruction::PHI;
2096 static inline bool classof(const Value *V) {
2097 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2100 void growOperands();
2104 struct OperandTraits<PHINode> : public HungoffOperandTraits<2> {
2107 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(PHINode, Value)
2109 //===----------------------------------------------------------------------===//
2110 // LandingPadInst Class
2111 //===----------------------------------------------------------------------===//
2113 //===---------------------------------------------------------------------------
2114 /// LandingPadInst - The landingpad instruction holds all of the information
2115 /// necessary to generate correct exception handling. The landingpad instruction
2116 /// cannot be moved from the top of a landing pad block, which itself is
2117 /// accessible only from the 'unwind' edge of an invoke. This uses the
2118 /// SubclassData field in Value to store whether or not the landingpad is a
2121 class LandingPadInst : public Instruction {
2122 /// ReservedSpace - The number of operands actually allocated. NumOperands is
2123 /// the number actually in use.
2124 unsigned ReservedSpace;
2125 LandingPadInst(const LandingPadInst &LP);
2127 enum ClauseType { Catch, Filter };
2129 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
2130 // Allocate space for exactly zero operands.
2131 void *operator new(size_t s) {
2132 return User::operator new(s, 0);
2134 void growOperands(unsigned Size);
2135 void init(Value *PersFn, unsigned NumReservedValues, const Twine &NameStr);
2137 explicit LandingPadInst(Type *RetTy, Value *PersonalityFn,
2138 unsigned NumReservedValues, const Twine &NameStr,
2139 Instruction *InsertBefore);
2140 explicit LandingPadInst(Type *RetTy, Value *PersonalityFn,
2141 unsigned NumReservedValues, const Twine &NameStr,
2142 BasicBlock *InsertAtEnd);
2144 virtual LandingPadInst *clone_impl() const;
2146 /// Constructors - NumReservedClauses is a hint for the number of incoming
2147 /// clauses that this landingpad will have (use 0 if you really have no idea).
2148 static LandingPadInst *Create(Type *RetTy, Value *PersonalityFn,
2149 unsigned NumReservedClauses,
2150 const Twine &NameStr = "",
2151 Instruction *InsertBefore = 0);
2152 static LandingPadInst *Create(Type *RetTy, Value *PersonalityFn,
2153 unsigned NumReservedClauses,
2154 const Twine &NameStr, BasicBlock *InsertAtEnd);
2157 /// Provide fast operand accessors
2158 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2160 /// getPersonalityFn - Get the personality function associated with this
2162 Value *getPersonalityFn() const { return getOperand(0); }
2164 /// isCleanup - Return 'true' if this landingpad instruction is a
2165 /// cleanup. I.e., it should be run when unwinding even if its landing pad
2166 /// doesn't catch the exception.
2167 bool isCleanup() const { return getSubclassDataFromInstruction() & 1; }
2169 /// setCleanup - Indicate that this landingpad instruction is a cleanup.
2170 void setCleanup(bool V) {
2171 setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
2175 /// addClause - Add a catch or filter clause to the landing pad.
2176 void addClause(Value *ClauseVal);
2178 /// getClause - Get the value of the clause at index Idx. Use isCatch/isFilter
2179 /// to determine what type of clause this is.
2180 Value *getClause(unsigned Idx) const { return OperandList[Idx + 1]; }
2182 /// isCatch - Return 'true' if the clause and index Idx is a catch clause.
2183 bool isCatch(unsigned Idx) const {
2184 return !isa<ArrayType>(OperandList[Idx + 1]->getType());
2187 /// isFilter - Return 'true' if the clause and index Idx is a filter clause.
2188 bool isFilter(unsigned Idx) const {
2189 return isa<ArrayType>(OperandList[Idx + 1]->getType());
2192 /// getNumClauses - Get the number of clauses for this landing pad.
2193 unsigned getNumClauses() const { return getNumOperands() - 1; }
2195 /// reserveClauses - Grow the size of the operand list to accomodate the new
2196 /// number of clauses.
2197 void reserveClauses(unsigned Size) { growOperands(Size); }
2199 // Methods for support type inquiry through isa, cast, and dyn_cast:
2200 static inline bool classof(const LandingPadInst *) { return true; }
2201 static inline bool classof(const Instruction *I) {
2202 return I->getOpcode() == Instruction::LandingPad;
2204 static inline bool classof(const Value *V) {
2205 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2210 struct OperandTraits<LandingPadInst> : public HungoffOperandTraits<2> {
2213 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(LandingPadInst, Value)
2215 //===----------------------------------------------------------------------===//
2217 //===----------------------------------------------------------------------===//
2219 //===---------------------------------------------------------------------------
2220 /// ReturnInst - Return a value (possibly void), from a function. Execution
2221 /// does not continue in this function any longer.
2223 class ReturnInst : public TerminatorInst {
2224 ReturnInst(const ReturnInst &RI);
2227 // ReturnInst constructors:
2228 // ReturnInst() - 'ret void' instruction
2229 // ReturnInst( null) - 'ret void' instruction
2230 // ReturnInst(Value* X) - 'ret X' instruction
2231 // ReturnInst( null, Inst *I) - 'ret void' instruction, insert before I
2232 // ReturnInst(Value* X, Inst *I) - 'ret X' instruction, insert before I
2233 // ReturnInst( null, BB *B) - 'ret void' instruction, insert @ end of B
2234 // ReturnInst(Value* X, BB *B) - 'ret X' instruction, insert @ end of B
2236 // NOTE: If the Value* passed is of type void then the constructor behaves as
2237 // if it was passed NULL.
2238 explicit ReturnInst(LLVMContext &C, Value *retVal = 0,
2239 Instruction *InsertBefore = 0);
2240 ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd);
2241 explicit ReturnInst(LLVMContext &C, BasicBlock *InsertAtEnd);
2243 virtual ReturnInst *clone_impl() const;
2245 static ReturnInst* Create(LLVMContext &C, Value *retVal = 0,
2246 Instruction *InsertBefore = 0) {
2247 return new(!!retVal) ReturnInst(C, retVal, InsertBefore);
2249 static ReturnInst* Create(LLVMContext &C, Value *retVal,
2250 BasicBlock *InsertAtEnd) {
2251 return new(!!retVal) ReturnInst(C, retVal, InsertAtEnd);
2253 static ReturnInst* Create(LLVMContext &C, BasicBlock *InsertAtEnd) {
2254 return new(0) ReturnInst(C, InsertAtEnd);
2256 virtual ~ReturnInst();
2258 /// Provide fast operand accessors
2259 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2261 /// Convenience accessor. Returns null if there is no return value.
2262 Value *getReturnValue() const {
2263 return getNumOperands() != 0 ? getOperand(0) : 0;
2266 unsigned getNumSuccessors() const { return 0; }
2268 // Methods for support type inquiry through isa, cast, and dyn_cast:
2269 static inline bool classof(const ReturnInst *) { return true; }
2270 static inline bool classof(const Instruction *I) {
2271 return (I->getOpcode() == Instruction::Ret);
2273 static inline bool classof(const Value *V) {
2274 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2277 virtual BasicBlock *getSuccessorV(unsigned idx) const;
2278 virtual unsigned getNumSuccessorsV() const;
2279 virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2283 struct OperandTraits<ReturnInst> : public VariadicOperandTraits<ReturnInst> {
2286 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ReturnInst, Value)
2288 //===----------------------------------------------------------------------===//
2290 //===----------------------------------------------------------------------===//
2292 //===---------------------------------------------------------------------------
2293 /// BranchInst - Conditional or Unconditional Branch instruction.
2295 class BranchInst : public TerminatorInst {
2296 /// Ops list - Branches are strange. The operands are ordered:
2297 /// [Cond, FalseDest,] TrueDest. This makes some accessors faster because
2298 /// they don't have to check for cond/uncond branchness. These are mostly
2299 /// accessed relative from op_end().
2300 BranchInst(const BranchInst &BI);
2302 // BranchInst constructors (where {B, T, F} are blocks, and C is a condition):
2303 // BranchInst(BB *B) - 'br B'
2304 // BranchInst(BB* T, BB *F, Value *C) - 'br C, T, F'
2305 // BranchInst(BB* B, Inst *I) - 'br B' insert before I
2306 // BranchInst(BB* T, BB *F, Value *C, Inst *I) - 'br C, T, F', insert before I
2307 // BranchInst(BB* B, BB *I) - 'br B' insert at end
2308 // BranchInst(BB* T, BB *F, Value *C, BB *I) - 'br C, T, F', insert at end
2309 explicit BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore = 0);
2310 BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
2311 Instruction *InsertBefore = 0);
2312 BranchInst(BasicBlock *IfTrue, BasicBlock *InsertAtEnd);
2313 BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
2314 BasicBlock *InsertAtEnd);
2316 virtual BranchInst *clone_impl() const;
2318 static BranchInst *Create(BasicBlock *IfTrue, Instruction *InsertBefore = 0) {
2319 return new(1) BranchInst(IfTrue, InsertBefore);
2321 static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
2322 Value *Cond, Instruction *InsertBefore = 0) {
2323 return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertBefore);
2325 static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *InsertAtEnd) {
2326 return new(1) BranchInst(IfTrue, InsertAtEnd);
2328 static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
2329 Value *Cond, BasicBlock *InsertAtEnd) {
2330 return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertAtEnd);
2333 /// Transparently provide more efficient getOperand methods.
2334 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2336 bool isUnconditional() const { return getNumOperands() == 1; }
2337 bool isConditional() const { return getNumOperands() == 3; }
2339 Value *getCondition() const {
2340 assert(isConditional() && "Cannot get condition of an uncond branch!");
2344 void setCondition(Value *V) {
2345 assert(isConditional() && "Cannot set condition of unconditional branch!");
2349 unsigned getNumSuccessors() const { return 1+isConditional(); }
2351 BasicBlock *getSuccessor(unsigned i) const {
2352 assert(i < getNumSuccessors() && "Successor # out of range for Branch!");
2353 return cast_or_null<BasicBlock>((&Op<-1>() - i)->get());
2356 void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
2357 assert(idx < getNumSuccessors() && "Successor # out of range for Branch!");
2358 *(&Op<-1>() - idx) = (Value*)NewSucc;
2361 // Methods for support type inquiry through isa, cast, and dyn_cast:
2362 static inline bool classof(const BranchInst *) { return true; }
2363 static inline bool classof(const Instruction *I) {
2364 return (I->getOpcode() == Instruction::Br);
2366 static inline bool classof(const Value *V) {
2367 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2370 virtual BasicBlock *getSuccessorV(unsigned idx) const;
2371 virtual unsigned getNumSuccessorsV() const;
2372 virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2376 struct OperandTraits<BranchInst> : public VariadicOperandTraits<BranchInst, 1> {
2379 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BranchInst, Value)
2381 //===----------------------------------------------------------------------===//
2383 //===----------------------------------------------------------------------===//
2385 //===---------------------------------------------------------------------------
2386 /// SwitchInst - Multiway switch
2388 class SwitchInst : public TerminatorInst {
2389 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
2390 unsigned ReservedSpace;
2391 // Operand[0] = Value to switch on
2392 // Operand[1] = Default basic block destination
2393 // Operand[2n ] = Value to match
2394 // Operand[2n+1] = BasicBlock to go to on match
2395 SwitchInst(const SwitchInst &SI);
2396 void init(Value *Value, BasicBlock *Default, unsigned NumReserved);
2397 void growOperands();
2398 // allocate space for exactly zero operands
2399 void *operator new(size_t s) {
2400 return User::operator new(s, 0);
2402 /// SwitchInst ctor - Create a new switch instruction, specifying a value to
2403 /// switch on and a default destination. The number of additional cases can
2404 /// be specified here to make memory allocation more efficient. This
2405 /// constructor can also autoinsert before another instruction.
2406 SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
2407 Instruction *InsertBefore);
2409 /// SwitchInst ctor - Create a new switch instruction, specifying a value to
2410 /// switch on and a default destination. The number of additional cases can
2411 /// be specified here to make memory allocation more efficient. This
2412 /// constructor also autoinserts at the end of the specified BasicBlock.
2413 SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
2414 BasicBlock *InsertAtEnd);
2416 virtual SwitchInst *clone_impl() const;
2418 static SwitchInst *Create(Value *Value, BasicBlock *Default,
2419 unsigned NumCases, Instruction *InsertBefore = 0) {
2420 return new SwitchInst(Value, Default, NumCases, InsertBefore);
2422 static SwitchInst *Create(Value *Value, BasicBlock *Default,
2423 unsigned NumCases, BasicBlock *InsertAtEnd) {
2424 return new SwitchInst(Value, Default, NumCases, InsertAtEnd);
2428 /// Provide fast operand accessors
2429 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2431 // Accessor Methods for Switch stmt
2432 Value *getCondition() const { return getOperand(0); }
2433 void setCondition(Value *V) { setOperand(0, V); }
2435 BasicBlock *getDefaultDest() const {
2436 return cast<BasicBlock>(getOperand(1));
2439 /// getNumCases - return the number of 'cases' in this switch instruction.
2440 /// Note that case #0 is always the default case.
2441 unsigned getNumCases() const {
2442 return getNumOperands()/2;
2445 /// getCaseValue - Return the specified case value. Note that case #0, the
2446 /// default destination, does not have a case value.
2447 ConstantInt *getCaseValue(unsigned i) {
2448 assert(i && i < getNumCases() && "Illegal case value to get!");
2449 return getSuccessorValue(i);
2452 /// getCaseValue - Return the specified case value. Note that case #0, the
2453 /// default destination, does not have a case value.
2454 const ConstantInt *getCaseValue(unsigned i) const {
2455 assert(i && i < getNumCases() && "Illegal case value to get!");
2456 return getSuccessorValue(i);
2459 /// findCaseValue - Search all of the case values for the specified constant.
2460 /// If it is explicitly handled, return the case number of it, otherwise
2461 /// return 0 to indicate that it is handled by the default handler.
2462 unsigned findCaseValue(const ConstantInt *C) const {
2463 for (unsigned i = 1, e = getNumCases(); i != e; ++i)
2464 if (getCaseValue(i) == C)
2469 /// findCaseDest - Finds the unique case value for a given successor. Returns
2470 /// null if the successor is not found, not unique, or is the default case.
2471 ConstantInt *findCaseDest(BasicBlock *BB) {
2472 if (BB == getDefaultDest()) return NULL;
2474 ConstantInt *CI = NULL;
2475 for (unsigned i = 1, e = getNumCases(); i != e; ++i) {
2476 if (getSuccessor(i) == BB) {
2477 if (CI) return NULL; // Multiple cases lead to BB.
2478 else CI = getCaseValue(i);
2484 /// addCase - Add an entry to the switch instruction...
2486 void addCase(ConstantInt *OnVal, BasicBlock *Dest);
2488 /// removeCase - This method removes the specified successor from the switch
2489 /// instruction. Note that this cannot be used to remove the default
2490 /// destination (successor #0). Also note that this operation may reorder the
2491 /// remaining cases at index idx and above.
2493 void removeCase(unsigned idx);
2495 unsigned getNumSuccessors() const { return getNumOperands()/2; }
2496 BasicBlock *getSuccessor(unsigned idx) const {
2497 assert(idx < getNumSuccessors() &&"Successor idx out of range for switch!");
2498 return cast<BasicBlock>(getOperand(idx*2+1));
2500 void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
2501 assert(idx < getNumSuccessors() && "Successor # out of range for switch!");
2502 setOperand(idx*2+1, (Value*)NewSucc);
2505 // getSuccessorValue - Return the value associated with the specified
2507 ConstantInt *getSuccessorValue(unsigned idx) const {
2508 assert(idx < getNumSuccessors() && "Successor # out of range!");
2509 return reinterpret_cast<ConstantInt*>(getOperand(idx*2));
2512 // Methods for support type inquiry through isa, cast, and dyn_cast:
2513 static inline bool classof(const SwitchInst *) { return true; }
2514 static inline bool classof(const Instruction *I) {
2515 return I->getOpcode() == Instruction::Switch;
2517 static inline bool classof(const Value *V) {
2518 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2521 virtual BasicBlock *getSuccessorV(unsigned idx) const;
2522 virtual unsigned getNumSuccessorsV() const;
2523 virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2527 struct OperandTraits<SwitchInst> : public HungoffOperandTraits<2> {
2530 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(SwitchInst, Value)
2533 //===----------------------------------------------------------------------===//
2534 // IndirectBrInst Class
2535 //===----------------------------------------------------------------------===//
2537 //===---------------------------------------------------------------------------
2538 /// IndirectBrInst - Indirect Branch Instruction.
2540 class IndirectBrInst : public TerminatorInst {
2541 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
2542 unsigned ReservedSpace;
2543 // Operand[0] = Value to switch on
2544 // Operand[1] = Default basic block destination
2545 // Operand[2n ] = Value to match
2546 // Operand[2n+1] = BasicBlock to go to on match
2547 IndirectBrInst(const IndirectBrInst &IBI);
2548 void init(Value *Address, unsigned NumDests);
2549 void growOperands();
2550 // allocate space for exactly zero operands
2551 void *operator new(size_t s) {
2552 return User::operator new(s, 0);
2554 /// IndirectBrInst ctor - Create a new indirectbr instruction, specifying an
2555 /// Address to jump to. The number of expected destinations can be specified
2556 /// here to make memory allocation more efficient. This constructor can also
2557 /// autoinsert before another instruction.
2558 IndirectBrInst(Value *Address, unsigned NumDests, Instruction *InsertBefore);
2560 /// IndirectBrInst ctor - Create a new indirectbr instruction, specifying an
2561 /// Address to jump to. The number of expected destinations can be specified
2562 /// here to make memory allocation more efficient. This constructor also
2563 /// autoinserts at the end of the specified BasicBlock.
2564 IndirectBrInst(Value *Address, unsigned NumDests, BasicBlock *InsertAtEnd);
2566 virtual IndirectBrInst *clone_impl() const;
2568 static IndirectBrInst *Create(Value *Address, unsigned NumDests,
2569 Instruction *InsertBefore = 0) {
2570 return new IndirectBrInst(Address, NumDests, InsertBefore);
2572 static IndirectBrInst *Create(Value *Address, unsigned NumDests,
2573 BasicBlock *InsertAtEnd) {
2574 return new IndirectBrInst(Address, NumDests, InsertAtEnd);
2578 /// Provide fast operand accessors.
2579 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2581 // Accessor Methods for IndirectBrInst instruction.
2582 Value *getAddress() { return getOperand(0); }
2583 const Value *getAddress() const { return getOperand(0); }
2584 void setAddress(Value *V) { setOperand(0, V); }
2587 /// getNumDestinations - return the number of possible destinations in this
2588 /// indirectbr instruction.
2589 unsigned getNumDestinations() const { return getNumOperands()-1; }
2591 /// getDestination - Return the specified destination.
2592 BasicBlock *getDestination(unsigned i) { return getSuccessor(i); }
2593 const BasicBlock *getDestination(unsigned i) const { return getSuccessor(i); }
2595 /// addDestination - Add a destination.
2597 void addDestination(BasicBlock *Dest);
2599 /// removeDestination - This method removes the specified successor from the
2600 /// indirectbr instruction.
2601 void removeDestination(unsigned i);
2603 unsigned getNumSuccessors() const { return getNumOperands()-1; }
2604 BasicBlock *getSuccessor(unsigned i) const {
2605 return cast<BasicBlock>(getOperand(i+1));
2607 void setSuccessor(unsigned i, BasicBlock *NewSucc) {
2608 setOperand(i+1, (Value*)NewSucc);
2611 // Methods for support type inquiry through isa, cast, and dyn_cast:
2612 static inline bool classof(const IndirectBrInst *) { return true; }
2613 static inline bool classof(const Instruction *I) {
2614 return I->getOpcode() == Instruction::IndirectBr;
2616 static inline bool classof(const Value *V) {
2617 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2620 virtual BasicBlock *getSuccessorV(unsigned idx) const;
2621 virtual unsigned getNumSuccessorsV() const;
2622 virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2626 struct OperandTraits<IndirectBrInst> : public HungoffOperandTraits<1> {
2629 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(IndirectBrInst, Value)
2632 //===----------------------------------------------------------------------===//
2634 //===----------------------------------------------------------------------===//
2636 /// InvokeInst - Invoke instruction. The SubclassData field is used to hold the
2637 /// calling convention of the call.
2639 class InvokeInst : public TerminatorInst {
2640 AttrListPtr AttributeList;
2641 InvokeInst(const InvokeInst &BI);
2642 void init(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
2643 ArrayRef<Value *> Args, const Twine &NameStr);
2645 /// Construct an InvokeInst given a range of arguments.
2647 /// @brief Construct an InvokeInst from a range of arguments
2648 inline InvokeInst(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
2649 ArrayRef<Value *> Args, unsigned Values,
2650 const Twine &NameStr, Instruction *InsertBefore);
2652 /// Construct an InvokeInst given a range of arguments.
2654 /// @brief Construct an InvokeInst from a range of arguments
2655 inline InvokeInst(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
2656 ArrayRef<Value *> Args, unsigned Values,
2657 const Twine &NameStr, BasicBlock *InsertAtEnd);
2659 virtual InvokeInst *clone_impl() const;
2661 static InvokeInst *Create(Value *Func,
2662 BasicBlock *IfNormal, BasicBlock *IfException,
2663 ArrayRef<Value *> Args, const Twine &NameStr = "",
2664 Instruction *InsertBefore = 0) {
2665 unsigned Values = unsigned(Args.size()) + 3;
2666 return new(Values) InvokeInst(Func, IfNormal, IfException, Args,
2667 Values, NameStr, InsertBefore);
2669 static InvokeInst *Create(Value *Func,
2670 BasicBlock *IfNormal, BasicBlock *IfException,
2671 ArrayRef<Value *> Args, const Twine &NameStr,
2672 BasicBlock *InsertAtEnd) {
2673 unsigned Values = unsigned(Args.size()) + 3;
2674 return new(Values) InvokeInst(Func, IfNormal, IfException, Args,
2675 Values, NameStr, InsertAtEnd);
2678 /// Provide fast operand accessors
2679 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2681 /// getNumArgOperands - Return the number of invoke arguments.
2683 unsigned getNumArgOperands() const { return getNumOperands() - 3; }
2685 /// getArgOperand/setArgOperand - Return/set the i-th invoke argument.
2687 Value *getArgOperand(unsigned i) const { return getOperand(i); }
2688 void setArgOperand(unsigned i, Value *v) { setOperand(i, v); }
2690 /// getCallingConv/setCallingConv - Get or set the calling convention of this
2692 CallingConv::ID getCallingConv() const {
2693 return static_cast<CallingConv::ID>(getSubclassDataFromInstruction());
2695 void setCallingConv(CallingConv::ID CC) {
2696 setInstructionSubclassData(static_cast<unsigned>(CC));
2699 /// getAttributes - Return the parameter attributes for this invoke.
2701 const AttrListPtr &getAttributes() const { return AttributeList; }
2703 /// setAttributes - Set the parameter attributes for this invoke.
2705 void setAttributes(const AttrListPtr &Attrs) { AttributeList = Attrs; }
2707 /// addAttribute - adds the attribute to the list of attributes.
2708 void addAttribute(unsigned i, Attributes attr);
2710 /// removeAttribute - removes the attribute from the list of attributes.
2711 void removeAttribute(unsigned i, Attributes attr);
2713 /// @brief Determine whether the call or the callee has the given attribute.
2714 bool paramHasAttr(unsigned i, Attributes attr) const;
2716 /// @brief Extract the alignment for a call or parameter (0=unknown).
2717 unsigned getParamAlignment(unsigned i) const {
2718 return AttributeList.getParamAlignment(i);
2721 /// @brief Return true if the call should not be inlined.
2722 bool isNoInline() const { return paramHasAttr(~0, Attribute::NoInline); }
2723 void setIsNoInline(bool Value = true) {
2724 if (Value) addAttribute(~0, Attribute::NoInline);
2725 else removeAttribute(~0, Attribute::NoInline);
2728 /// @brief Determine if the call does not access memory.
2729 bool doesNotAccessMemory() const {
2730 return paramHasAttr(~0, Attribute::ReadNone);
2732 void setDoesNotAccessMemory(bool NotAccessMemory = true) {
2733 if (NotAccessMemory) addAttribute(~0, Attribute::ReadNone);
2734 else removeAttribute(~0, Attribute::ReadNone);
2737 /// @brief Determine if the call does not access or only reads memory.
2738 bool onlyReadsMemory() const {
2739 return doesNotAccessMemory() || paramHasAttr(~0, Attribute::ReadOnly);
2741 void setOnlyReadsMemory(bool OnlyReadsMemory = true) {
2742 if (OnlyReadsMemory) addAttribute(~0, Attribute::ReadOnly);
2743 else removeAttribute(~0, Attribute::ReadOnly | Attribute::ReadNone);
2746 /// @brief Determine if the call cannot return.
2747 bool doesNotReturn() const { return paramHasAttr(~0, Attribute::NoReturn); }
2748 void setDoesNotReturn(bool DoesNotReturn = true) {
2749 if (DoesNotReturn) addAttribute(~0, Attribute::NoReturn);
2750 else removeAttribute(~0, Attribute::NoReturn);
2753 /// @brief Determine if the call cannot unwind.
2754 bool doesNotThrow() const { return paramHasAttr(~0, Attribute::NoUnwind); }
2755 void setDoesNotThrow(bool DoesNotThrow = true) {
2756 if (DoesNotThrow) addAttribute(~0, Attribute::NoUnwind);
2757 else removeAttribute(~0, Attribute::NoUnwind);
2760 /// @brief Determine if the call returns a structure through first
2761 /// pointer argument.
2762 bool hasStructRetAttr() const {
2763 // Be friendly and also check the callee.
2764 return paramHasAttr(1, Attribute::StructRet);
2767 /// @brief Determine if any call argument is an aggregate passed by value.
2768 bool hasByValArgument() const {
2769 return AttributeList.hasAttrSomewhere(Attribute::ByVal);
2772 /// getCalledFunction - Return the function called, or null if this is an
2773 /// indirect function invocation.
2775 Function *getCalledFunction() const {
2776 return dyn_cast<Function>(Op<-3>());
2779 /// getCalledValue - Get a pointer to the function that is invoked by this
2781 const Value *getCalledValue() const { return Op<-3>(); }
2782 Value *getCalledValue() { return Op<-3>(); }
2784 /// setCalledFunction - Set the function called.
2785 void setCalledFunction(Value* Fn) {
2789 // get*Dest - Return the destination basic blocks...
2790 BasicBlock *getNormalDest() const {
2791 return cast<BasicBlock>(Op<-2>());
2793 BasicBlock *getUnwindDest() const {
2794 return cast<BasicBlock>(Op<-1>());
2796 void setNormalDest(BasicBlock *B) {
2797 Op<-2>() = reinterpret_cast<Value*>(B);
2799 void setUnwindDest(BasicBlock *B) {
2800 Op<-1>() = reinterpret_cast<Value*>(B);
2803 /// getLandingPadInst - Get the landingpad instruction from the landing pad
2804 /// block (the unwind destination).
2805 LandingPadInst *getLandingPadInst() const;
2807 BasicBlock *getSuccessor(unsigned i) const {
2808 assert(i < 2 && "Successor # out of range for invoke!");
2809 return i == 0 ? getNormalDest() : getUnwindDest();
2812 void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
2813 assert(idx < 2 && "Successor # out of range for invoke!");
2814 *(&Op<-2>() + idx) = reinterpret_cast<Value*>(NewSucc);
2817 unsigned getNumSuccessors() const { return 2; }
2819 // Methods for support type inquiry through isa, cast, and dyn_cast:
2820 static inline bool classof(const InvokeInst *) { return true; }
2821 static inline bool classof(const Instruction *I) {
2822 return (I->getOpcode() == Instruction::Invoke);
2824 static inline bool classof(const Value *V) {
2825 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2829 virtual BasicBlock *getSuccessorV(unsigned idx) const;
2830 virtual unsigned getNumSuccessorsV() const;
2831 virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2833 // Shadow Instruction::setInstructionSubclassData with a private forwarding
2834 // method so that subclasses cannot accidentally use it.
2835 void setInstructionSubclassData(unsigned short D) {
2836 Instruction::setInstructionSubclassData(D);
2841 struct OperandTraits<InvokeInst> : public VariadicOperandTraits<InvokeInst, 3> {
2844 InvokeInst::InvokeInst(Value *Func,
2845 BasicBlock *IfNormal, BasicBlock *IfException,
2846 ArrayRef<Value *> Args, unsigned Values,
2847 const Twine &NameStr, Instruction *InsertBefore)
2848 : TerminatorInst(cast<FunctionType>(cast<PointerType>(Func->getType())
2849 ->getElementType())->getReturnType(),
2850 Instruction::Invoke,
2851 OperandTraits<InvokeInst>::op_end(this) - Values,
2852 Values, InsertBefore) {
2853 init(Func, IfNormal, IfException, Args, NameStr);
2855 InvokeInst::InvokeInst(Value *Func,
2856 BasicBlock *IfNormal, BasicBlock *IfException,
2857 ArrayRef<Value *> Args, unsigned Values,
2858 const Twine &NameStr, BasicBlock *InsertAtEnd)
2859 : TerminatorInst(cast<FunctionType>(cast<PointerType>(Func->getType())
2860 ->getElementType())->getReturnType(),
2861 Instruction::Invoke,
2862 OperandTraits<InvokeInst>::op_end(this) - Values,
2863 Values, InsertAtEnd) {
2864 init(Func, IfNormal, IfException, Args, NameStr);
2867 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InvokeInst, Value)
2869 //===----------------------------------------------------------------------===//
2871 //===----------------------------------------------------------------------===//
2873 //===---------------------------------------------------------------------------
2874 /// UnwindInst - Immediately exit the current function, unwinding the stack
2875 /// until an invoke instruction is found.
2877 class UnwindInst : public TerminatorInst {
2878 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
2880 virtual UnwindInst *clone_impl() const;
2882 // allocate space for exactly zero operands
2883 void *operator new(size_t s) {
2884 return User::operator new(s, 0);
2886 explicit UnwindInst(LLVMContext &C, Instruction *InsertBefore = 0);
2887 explicit UnwindInst(LLVMContext &C, BasicBlock *InsertAtEnd);
2889 unsigned getNumSuccessors() const { return 0; }
2891 // Methods for support type inquiry through isa, cast, and dyn_cast:
2892 static inline bool classof(const UnwindInst *) { return true; }
2893 static inline bool classof(const Instruction *I) {
2894 return I->getOpcode() == Instruction::Unwind;
2896 static inline bool classof(const Value *V) {
2897 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2900 virtual BasicBlock *getSuccessorV(unsigned idx) const;
2901 virtual unsigned getNumSuccessorsV() const;
2902 virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2905 //===----------------------------------------------------------------------===//
2907 //===----------------------------------------------------------------------===//
2909 //===---------------------------------------------------------------------------
2910 /// ResumeInst - Resume the propagation of an exception.
2912 class ResumeInst : public TerminatorInst {
2913 ResumeInst(const ResumeInst &RI);
2915 explicit ResumeInst(Value *Exn, Instruction *InsertBefore=0);
2916 ResumeInst(Value *Exn, BasicBlock *InsertAtEnd);
2918 virtual ResumeInst *clone_impl() const;
2920 static ResumeInst *Create(Value *Exn, Instruction *InsertBefore = 0) {
2921 return new(1) ResumeInst(Exn, InsertBefore);
2923 static ResumeInst *Create(Value *Exn, BasicBlock *InsertAtEnd) {
2924 return new(1) ResumeInst(Exn, InsertAtEnd);
2927 /// Provide fast operand accessors
2928 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2930 /// Convenience accessor.
2931 Value *getValue() const { return Op<0>(); }
2933 unsigned getNumSuccessors() const { return 0; }
2935 // Methods for support type inquiry through isa, cast, and dyn_cast:
2936 static inline bool classof(const ResumeInst *) { return true; }
2937 static inline bool classof(const Instruction *I) {
2938 return I->getOpcode() == Instruction::Resume;
2940 static inline bool classof(const Value *V) {
2941 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2944 virtual BasicBlock *getSuccessorV(unsigned idx) const;
2945 virtual unsigned getNumSuccessorsV() const;
2946 virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2950 struct OperandTraits<ResumeInst> :
2951 public FixedNumOperandTraits<ResumeInst, 1> {
2954 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ResumeInst, Value)
2956 //===----------------------------------------------------------------------===//
2957 // UnreachableInst Class
2958 //===----------------------------------------------------------------------===//
2960 //===---------------------------------------------------------------------------
2961 /// UnreachableInst - This function has undefined behavior. In particular, the
2962 /// presence of this instruction indicates some higher level knowledge that the
2963 /// end of the block cannot be reached.
2965 class UnreachableInst : public TerminatorInst {
2966 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
2968 virtual UnreachableInst *clone_impl() const;
2971 // allocate space for exactly zero operands
2972 void *operator new(size_t s) {
2973 return User::operator new(s, 0);
2975 explicit UnreachableInst(LLVMContext &C, Instruction *InsertBefore = 0);
2976 explicit UnreachableInst(LLVMContext &C, BasicBlock *InsertAtEnd);
2978 unsigned getNumSuccessors() const { return 0; }
2980 // Methods for support type inquiry through isa, cast, and dyn_cast:
2981 static inline bool classof(const UnreachableInst *) { return true; }
2982 static inline bool classof(const Instruction *I) {
2983 return I->getOpcode() == Instruction::Unreachable;
2985 static inline bool classof(const Value *V) {
2986 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2989 virtual BasicBlock *getSuccessorV(unsigned idx) const;
2990 virtual unsigned getNumSuccessorsV() const;
2991 virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2994 //===----------------------------------------------------------------------===//
2996 //===----------------------------------------------------------------------===//
2998 /// @brief This class represents a truncation of integer types.
2999 class TruncInst : public CastInst {
3001 /// @brief Clone an identical TruncInst
3002 virtual TruncInst *clone_impl() const;
3005 /// @brief Constructor with insert-before-instruction semantics
3007 Value *S, ///< The value to be truncated
3008 Type *Ty, ///< The (smaller) type to truncate to
3009 const Twine &NameStr = "", ///< A name for the new instruction
3010 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3013 /// @brief Constructor with insert-at-end-of-block semantics
3015 Value *S, ///< The value to be truncated
3016 Type *Ty, ///< The (smaller) type to truncate to
3017 const Twine &NameStr, ///< A name for the new instruction
3018 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
3021 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
3022 static inline bool classof(const TruncInst *) { return true; }
3023 static inline bool classof(const Instruction *I) {
3024 return I->getOpcode() == Trunc;
3026 static inline bool classof(const Value *V) {
3027 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3031 //===----------------------------------------------------------------------===//
3033 //===----------------------------------------------------------------------===//
3035 /// @brief This class represents zero extension of integer types.
3036 class ZExtInst : public CastInst {
3038 /// @brief Clone an identical ZExtInst
3039 virtual ZExtInst *clone_impl() const;
3042 /// @brief Constructor with insert-before-instruction semantics
3044 Value *S, ///< The value to be zero extended
3045 Type *Ty, ///< The type to zero extend to
3046 const Twine &NameStr = "", ///< A name for the new instruction
3047 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3050 /// @brief Constructor with insert-at-end semantics.
3052 Value *S, ///< The value to be zero extended
3053 Type *Ty, ///< The type to zero extend to
3054 const Twine &NameStr, ///< A name for the new instruction
3055 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
3058 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
3059 static inline bool classof(const ZExtInst *) { return true; }
3060 static inline bool classof(const Instruction *I) {
3061 return I->getOpcode() == ZExt;
3063 static inline bool classof(const Value *V) {
3064 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3068 //===----------------------------------------------------------------------===//
3070 //===----------------------------------------------------------------------===//
3072 /// @brief This class represents a sign extension of integer types.
3073 class SExtInst : public CastInst {
3075 /// @brief Clone an identical SExtInst
3076 virtual SExtInst *clone_impl() const;
3079 /// @brief Constructor with insert-before-instruction semantics
3081 Value *S, ///< The value to be sign extended
3082 Type *Ty, ///< The type to sign extend to
3083 const Twine &NameStr = "", ///< A name for the new instruction
3084 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3087 /// @brief Constructor with insert-at-end-of-block semantics
3089 Value *S, ///< The value to be sign extended
3090 Type *Ty, ///< The type to sign extend to
3091 const Twine &NameStr, ///< A name for the new instruction
3092 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
3095 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
3096 static inline bool classof(const SExtInst *) { return true; }
3097 static inline bool classof(const Instruction *I) {
3098 return I->getOpcode() == SExt;
3100 static inline bool classof(const Value *V) {
3101 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3105 //===----------------------------------------------------------------------===//
3106 // FPTruncInst Class
3107 //===----------------------------------------------------------------------===//
3109 /// @brief This class represents a truncation of floating point types.
3110 class FPTruncInst : public CastInst {
3112 /// @brief Clone an identical FPTruncInst
3113 virtual FPTruncInst *clone_impl() const;
3116 /// @brief Constructor with insert-before-instruction semantics
3118 Value *S, ///< The value to be truncated
3119 Type *Ty, ///< The type to truncate to
3120 const Twine &NameStr = "", ///< A name for the new instruction
3121 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3124 /// @brief Constructor with insert-before-instruction semantics
3126 Value *S, ///< The value to be truncated
3127 Type *Ty, ///< The type to truncate to
3128 const Twine &NameStr, ///< A name for the new instruction
3129 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
3132 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
3133 static inline bool classof(const FPTruncInst *) { return true; }
3134 static inline bool classof(const Instruction *I) {
3135 return I->getOpcode() == FPTrunc;
3137 static inline bool classof(const Value *V) {
3138 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3142 //===----------------------------------------------------------------------===//
3144 //===----------------------------------------------------------------------===//
3146 /// @brief This class represents an extension of floating point types.
3147 class FPExtInst : public CastInst {
3149 /// @brief Clone an identical FPExtInst
3150 virtual FPExtInst *clone_impl() const;
3153 /// @brief Constructor with insert-before-instruction semantics
3155 Value *S, ///< The value to be extended
3156 Type *Ty, ///< The type to extend to
3157 const Twine &NameStr = "", ///< A name for the new instruction
3158 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3161 /// @brief Constructor with insert-at-end-of-block semantics
3163 Value *S, ///< The value to be extended
3164 Type *Ty, ///< The type to extend to
3165 const Twine &NameStr, ///< A name for the new instruction
3166 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
3169 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
3170 static inline bool classof(const FPExtInst *) { return true; }
3171 static inline bool classof(const Instruction *I) {
3172 return I->getOpcode() == FPExt;
3174 static inline bool classof(const Value *V) {
3175 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3179 //===----------------------------------------------------------------------===//
3181 //===----------------------------------------------------------------------===//
3183 /// @brief This class represents a cast unsigned integer to floating point.
3184 class UIToFPInst : public CastInst {
3186 /// @brief Clone an identical UIToFPInst
3187 virtual UIToFPInst *clone_impl() const;
3190 /// @brief Constructor with insert-before-instruction semantics
3192 Value *S, ///< The value to be converted
3193 Type *Ty, ///< The type to convert to
3194 const Twine &NameStr = "", ///< A name for the new instruction
3195 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3198 /// @brief Constructor with insert-at-end-of-block semantics
3200 Value *S, ///< The value to be converted
3201 Type *Ty, ///< The type to convert to
3202 const Twine &NameStr, ///< A name for the new instruction
3203 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
3206 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
3207 static inline bool classof(const UIToFPInst *) { return true; }
3208 static inline bool classof(const Instruction *I) {
3209 return I->getOpcode() == UIToFP;
3211 static inline bool classof(const Value *V) {
3212 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3216 //===----------------------------------------------------------------------===//
3218 //===----------------------------------------------------------------------===//
3220 /// @brief This class represents a cast from signed integer to floating point.
3221 class SIToFPInst : public CastInst {
3223 /// @brief Clone an identical SIToFPInst
3224 virtual SIToFPInst *clone_impl() const;
3227 /// @brief Constructor with insert-before-instruction semantics
3229 Value *S, ///< The value to be converted
3230 Type *Ty, ///< The type to convert to
3231 const Twine &NameStr = "", ///< A name for the new instruction
3232 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3235 /// @brief Constructor with insert-at-end-of-block semantics
3237 Value *S, ///< The value to be converted
3238 Type *Ty, ///< The type to convert to
3239 const Twine &NameStr, ///< A name for the new instruction
3240 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
3243 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
3244 static inline bool classof(const SIToFPInst *) { return true; }
3245 static inline bool classof(const Instruction *I) {
3246 return I->getOpcode() == SIToFP;
3248 static inline bool classof(const Value *V) {
3249 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3253 //===----------------------------------------------------------------------===//
3255 //===----------------------------------------------------------------------===//
3257 /// @brief This class represents a cast from floating point to unsigned integer
3258 class FPToUIInst : public CastInst {
3260 /// @brief Clone an identical FPToUIInst
3261 virtual FPToUIInst *clone_impl() const;
3264 /// @brief Constructor with insert-before-instruction semantics
3266 Value *S, ///< The value to be converted
3267 Type *Ty, ///< The type to convert to
3268 const Twine &NameStr = "", ///< A name for the new instruction
3269 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3272 /// @brief Constructor with insert-at-end-of-block semantics
3274 Value *S, ///< The value to be converted
3275 Type *Ty, ///< The type to convert to
3276 const Twine &NameStr, ///< A name for the new instruction
3277 BasicBlock *InsertAtEnd ///< Where to insert the new instruction
3280 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
3281 static inline bool classof(const FPToUIInst *) { return true; }
3282 static inline bool classof(const Instruction *I) {
3283 return I->getOpcode() == FPToUI;
3285 static inline bool classof(const Value *V) {
3286 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3290 //===----------------------------------------------------------------------===//
3292 //===----------------------------------------------------------------------===//
3294 /// @brief This class represents a cast from floating point to signed integer.
3295 class FPToSIInst : public CastInst {
3297 /// @brief Clone an identical FPToSIInst
3298 virtual FPToSIInst *clone_impl() const;
3301 /// @brief Constructor with insert-before-instruction semantics
3303 Value *S, ///< The value to be converted
3304 Type *Ty, ///< The type to convert to
3305 const Twine &NameStr = "", ///< A name for the new instruction
3306 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3309 /// @brief Constructor with insert-at-end-of-block semantics
3311 Value *S, ///< The value to be converted
3312 Type *Ty, ///< The type to convert to
3313 const Twine &NameStr, ///< A name for the new instruction
3314 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
3317 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
3318 static inline bool classof(const FPToSIInst *) { return true; }
3319 static inline bool classof(const Instruction *I) {
3320 return I->getOpcode() == FPToSI;
3322 static inline bool classof(const Value *V) {
3323 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3327 //===----------------------------------------------------------------------===//
3328 // IntToPtrInst Class
3329 //===----------------------------------------------------------------------===//
3331 /// @brief This class represents a cast from an integer to a pointer.
3332 class IntToPtrInst : public CastInst {
3334 /// @brief Constructor with insert-before-instruction semantics
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
3342 /// @brief Constructor with insert-at-end-of-block semantics
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 ///< The block to insert the instruction into
3350 /// @brief Clone an identical IntToPtrInst
3351 virtual IntToPtrInst *clone_impl() const;
3353 // Methods for support type inquiry through isa, cast, and dyn_cast:
3354 static inline bool classof(const IntToPtrInst *) { return true; }
3355 static inline bool classof(const Instruction *I) {
3356 return I->getOpcode() == IntToPtr;
3358 static inline bool classof(const Value *V) {
3359 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3363 //===----------------------------------------------------------------------===//
3364 // PtrToIntInst Class
3365 //===----------------------------------------------------------------------===//
3367 /// @brief This class represents a cast from a pointer to an integer
3368 class PtrToIntInst : public CastInst {
3370 /// @brief Clone an identical PtrToIntInst
3371 virtual PtrToIntInst *clone_impl() const;
3374 /// @brief Constructor with insert-before-instruction semantics
3376 Value *S, ///< The value to be converted
3377 Type *Ty, ///< The type to convert to
3378 const Twine &NameStr = "", ///< A name for the new instruction
3379 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3382 /// @brief Constructor with insert-at-end-of-block semantics
3384 Value *S, ///< The value to be converted
3385 Type *Ty, ///< The type to convert to
3386 const Twine &NameStr, ///< A name for the new instruction
3387 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
3390 // Methods for support type inquiry through isa, cast, and dyn_cast:
3391 static inline bool classof(const PtrToIntInst *) { return true; }
3392 static inline bool classof(const Instruction *I) {
3393 return I->getOpcode() == PtrToInt;
3395 static inline bool classof(const Value *V) {
3396 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3400 //===----------------------------------------------------------------------===//
3401 // BitCastInst Class
3402 //===----------------------------------------------------------------------===//
3404 /// @brief This class represents a no-op cast from one type to another.
3405 class BitCastInst : public CastInst {
3407 /// @brief Clone an identical BitCastInst
3408 virtual BitCastInst *clone_impl() const;
3411 /// @brief Constructor with insert-before-instruction semantics
3413 Value *S, ///< The value to be casted
3414 Type *Ty, ///< The type to casted to
3415 const Twine &NameStr = "", ///< A name for the new instruction
3416 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3419 /// @brief Constructor with insert-at-end-of-block semantics
3421 Value *S, ///< The value to be casted
3422 Type *Ty, ///< The type to casted to
3423 const Twine &NameStr, ///< A name for the new instruction
3424 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
3427 // Methods for support type inquiry through isa, cast, and dyn_cast:
3428 static inline bool classof(const BitCastInst *) { return true; }
3429 static inline bool classof(const Instruction *I) {
3430 return I->getOpcode() == BitCast;
3432 static inline bool classof(const Value *V) {
3433 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3437 } // End llvm namespace