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)
2110 //===----------------------------------------------------------------------===//
2112 //===----------------------------------------------------------------------===//
2114 //===---------------------------------------------------------------------------
2115 /// ReturnInst - Return a value (possibly void), from a function. Execution
2116 /// does not continue in this function any longer.
2118 class ReturnInst : public TerminatorInst {
2119 ReturnInst(const ReturnInst &RI);
2122 // ReturnInst constructors:
2123 // ReturnInst() - 'ret void' instruction
2124 // ReturnInst( null) - 'ret void' instruction
2125 // ReturnInst(Value* X) - 'ret X' instruction
2126 // ReturnInst( null, Inst *I) - 'ret void' instruction, insert before I
2127 // ReturnInst(Value* X, Inst *I) - 'ret X' instruction, insert before I
2128 // ReturnInst( null, BB *B) - 'ret void' instruction, insert @ end of B
2129 // ReturnInst(Value* X, BB *B) - 'ret X' instruction, insert @ end of B
2131 // NOTE: If the Value* passed is of type void then the constructor behaves as
2132 // if it was passed NULL.
2133 explicit ReturnInst(LLVMContext &C, Value *retVal = 0,
2134 Instruction *InsertBefore = 0);
2135 ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd);
2136 explicit ReturnInst(LLVMContext &C, BasicBlock *InsertAtEnd);
2138 virtual ReturnInst *clone_impl() const;
2140 static ReturnInst* Create(LLVMContext &C, Value *retVal = 0,
2141 Instruction *InsertBefore = 0) {
2142 return new(!!retVal) ReturnInst(C, retVal, InsertBefore);
2144 static ReturnInst* Create(LLVMContext &C, Value *retVal,
2145 BasicBlock *InsertAtEnd) {
2146 return new(!!retVal) ReturnInst(C, retVal, InsertAtEnd);
2148 static ReturnInst* Create(LLVMContext &C, BasicBlock *InsertAtEnd) {
2149 return new(0) ReturnInst(C, InsertAtEnd);
2151 virtual ~ReturnInst();
2153 /// Provide fast operand accessors
2154 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2156 /// Convenience accessor. Returns null if there is no return value.
2157 Value *getReturnValue() const {
2158 return getNumOperands() != 0 ? getOperand(0) : 0;
2161 unsigned getNumSuccessors() const { return 0; }
2163 // Methods for support type inquiry through isa, cast, and dyn_cast:
2164 static inline bool classof(const ReturnInst *) { return true; }
2165 static inline bool classof(const Instruction *I) {
2166 return (I->getOpcode() == Instruction::Ret);
2168 static inline bool classof(const Value *V) {
2169 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2172 virtual BasicBlock *getSuccessorV(unsigned idx) const;
2173 virtual unsigned getNumSuccessorsV() const;
2174 virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2178 struct OperandTraits<ReturnInst> : public VariadicOperandTraits<ReturnInst> {
2181 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ReturnInst, Value)
2183 //===----------------------------------------------------------------------===//
2185 //===----------------------------------------------------------------------===//
2187 //===---------------------------------------------------------------------------
2188 /// BranchInst - Conditional or Unconditional Branch instruction.
2190 class BranchInst : public TerminatorInst {
2191 /// Ops list - Branches are strange. The operands are ordered:
2192 /// [Cond, FalseDest,] TrueDest. This makes some accessors faster because
2193 /// they don't have to check for cond/uncond branchness. These are mostly
2194 /// accessed relative from op_end().
2195 BranchInst(const BranchInst &BI);
2197 // BranchInst constructors (where {B, T, F} are blocks, and C is a condition):
2198 // BranchInst(BB *B) - 'br B'
2199 // BranchInst(BB* T, BB *F, Value *C) - 'br C, T, F'
2200 // BranchInst(BB* B, Inst *I) - 'br B' insert before I
2201 // BranchInst(BB* T, BB *F, Value *C, Inst *I) - 'br C, T, F', insert before I
2202 // BranchInst(BB* B, BB *I) - 'br B' insert at end
2203 // BranchInst(BB* T, BB *F, Value *C, BB *I) - 'br C, T, F', insert at end
2204 explicit BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore = 0);
2205 BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
2206 Instruction *InsertBefore = 0);
2207 BranchInst(BasicBlock *IfTrue, BasicBlock *InsertAtEnd);
2208 BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
2209 BasicBlock *InsertAtEnd);
2211 virtual BranchInst *clone_impl() const;
2213 static BranchInst *Create(BasicBlock *IfTrue, Instruction *InsertBefore = 0) {
2214 return new(1) BranchInst(IfTrue, InsertBefore);
2216 static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
2217 Value *Cond, Instruction *InsertBefore = 0) {
2218 return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertBefore);
2220 static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *InsertAtEnd) {
2221 return new(1) BranchInst(IfTrue, InsertAtEnd);
2223 static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
2224 Value *Cond, BasicBlock *InsertAtEnd) {
2225 return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertAtEnd);
2228 /// Transparently provide more efficient getOperand methods.
2229 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2231 bool isUnconditional() const { return getNumOperands() == 1; }
2232 bool isConditional() const { return getNumOperands() == 3; }
2234 Value *getCondition() const {
2235 assert(isConditional() && "Cannot get condition of an uncond branch!");
2239 void setCondition(Value *V) {
2240 assert(isConditional() && "Cannot set condition of unconditional branch!");
2244 unsigned getNumSuccessors() const { return 1+isConditional(); }
2246 BasicBlock *getSuccessor(unsigned i) const {
2247 assert(i < getNumSuccessors() && "Successor # out of range for Branch!");
2248 return cast_or_null<BasicBlock>((&Op<-1>() - i)->get());
2251 void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
2252 assert(idx < getNumSuccessors() && "Successor # out of range for Branch!");
2253 *(&Op<-1>() - idx) = (Value*)NewSucc;
2256 // Methods for support type inquiry through isa, cast, and dyn_cast:
2257 static inline bool classof(const BranchInst *) { return true; }
2258 static inline bool classof(const Instruction *I) {
2259 return (I->getOpcode() == Instruction::Br);
2261 static inline bool classof(const Value *V) {
2262 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2265 virtual BasicBlock *getSuccessorV(unsigned idx) const;
2266 virtual unsigned getNumSuccessorsV() const;
2267 virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2271 struct OperandTraits<BranchInst> : public VariadicOperandTraits<BranchInst, 1> {
2274 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BranchInst, Value)
2276 //===----------------------------------------------------------------------===//
2278 //===----------------------------------------------------------------------===//
2280 //===---------------------------------------------------------------------------
2281 /// SwitchInst - Multiway switch
2283 class SwitchInst : public TerminatorInst {
2284 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
2285 unsigned ReservedSpace;
2286 // Operand[0] = Value to switch on
2287 // Operand[1] = Default basic block destination
2288 // Operand[2n ] = Value to match
2289 // Operand[2n+1] = BasicBlock to go to on match
2290 SwitchInst(const SwitchInst &SI);
2291 void init(Value *Value, BasicBlock *Default, unsigned NumReserved);
2292 void growOperands();
2293 // allocate space for exactly zero operands
2294 void *operator new(size_t s) {
2295 return User::operator new(s, 0);
2297 /// SwitchInst ctor - Create a new switch instruction, specifying a value to
2298 /// switch on and a default destination. The number of additional cases can
2299 /// be specified here to make memory allocation more efficient. This
2300 /// constructor can also autoinsert before another instruction.
2301 SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
2302 Instruction *InsertBefore);
2304 /// SwitchInst ctor - Create a new switch instruction, specifying a value to
2305 /// switch on and a default destination. The number of additional cases can
2306 /// be specified here to make memory allocation more efficient. This
2307 /// constructor also autoinserts at the end of the specified BasicBlock.
2308 SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
2309 BasicBlock *InsertAtEnd);
2311 virtual SwitchInst *clone_impl() const;
2313 static SwitchInst *Create(Value *Value, BasicBlock *Default,
2314 unsigned NumCases, Instruction *InsertBefore = 0) {
2315 return new SwitchInst(Value, Default, NumCases, InsertBefore);
2317 static SwitchInst *Create(Value *Value, BasicBlock *Default,
2318 unsigned NumCases, BasicBlock *InsertAtEnd) {
2319 return new SwitchInst(Value, Default, NumCases, InsertAtEnd);
2323 /// Provide fast operand accessors
2324 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2326 // Accessor Methods for Switch stmt
2327 Value *getCondition() const { return getOperand(0); }
2328 void setCondition(Value *V) { setOperand(0, V); }
2330 BasicBlock *getDefaultDest() const {
2331 return cast<BasicBlock>(getOperand(1));
2334 /// getNumCases - return the number of 'cases' in this switch instruction.
2335 /// Note that case #0 is always the default case.
2336 unsigned getNumCases() const {
2337 return getNumOperands()/2;
2340 /// getCaseValue - Return the specified case value. Note that case #0, the
2341 /// default destination, does not have a case value.
2342 ConstantInt *getCaseValue(unsigned i) {
2343 assert(i && i < getNumCases() && "Illegal case value to get!");
2344 return getSuccessorValue(i);
2347 /// getCaseValue - Return the specified case value. Note that case #0, the
2348 /// default destination, does not have a case value.
2349 const ConstantInt *getCaseValue(unsigned i) const {
2350 assert(i && i < getNumCases() && "Illegal case value to get!");
2351 return getSuccessorValue(i);
2354 /// findCaseValue - Search all of the case values for the specified constant.
2355 /// If it is explicitly handled, return the case number of it, otherwise
2356 /// return 0 to indicate that it is handled by the default handler.
2357 unsigned findCaseValue(const ConstantInt *C) const {
2358 for (unsigned i = 1, e = getNumCases(); i != e; ++i)
2359 if (getCaseValue(i) == C)
2364 /// findCaseDest - Finds the unique case value for a given successor. Returns
2365 /// null if the successor is not found, not unique, or is the default case.
2366 ConstantInt *findCaseDest(BasicBlock *BB) {
2367 if (BB == getDefaultDest()) return NULL;
2369 ConstantInt *CI = NULL;
2370 for (unsigned i = 1, e = getNumCases(); i != e; ++i) {
2371 if (getSuccessor(i) == BB) {
2372 if (CI) return NULL; // Multiple cases lead to BB.
2373 else CI = getCaseValue(i);
2379 /// addCase - Add an entry to the switch instruction...
2381 void addCase(ConstantInt *OnVal, BasicBlock *Dest);
2383 /// removeCase - This method removes the specified successor from the switch
2384 /// instruction. Note that this cannot be used to remove the default
2385 /// destination (successor #0). Also note that this operation may reorder the
2386 /// remaining cases at index idx and above.
2388 void removeCase(unsigned idx);
2390 unsigned getNumSuccessors() const { return getNumOperands()/2; }
2391 BasicBlock *getSuccessor(unsigned idx) const {
2392 assert(idx < getNumSuccessors() &&"Successor idx out of range for switch!");
2393 return cast<BasicBlock>(getOperand(idx*2+1));
2395 void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
2396 assert(idx < getNumSuccessors() && "Successor # out of range for switch!");
2397 setOperand(idx*2+1, (Value*)NewSucc);
2400 // getSuccessorValue - Return the value associated with the specified
2402 ConstantInt *getSuccessorValue(unsigned idx) const {
2403 assert(idx < getNumSuccessors() && "Successor # out of range!");
2404 return reinterpret_cast<ConstantInt*>(getOperand(idx*2));
2407 // Methods for support type inquiry through isa, cast, and dyn_cast:
2408 static inline bool classof(const SwitchInst *) { return true; }
2409 static inline bool classof(const Instruction *I) {
2410 return I->getOpcode() == Instruction::Switch;
2412 static inline bool classof(const Value *V) {
2413 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2416 virtual BasicBlock *getSuccessorV(unsigned idx) const;
2417 virtual unsigned getNumSuccessorsV() const;
2418 virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2422 struct OperandTraits<SwitchInst> : public HungoffOperandTraits<2> {
2425 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(SwitchInst, Value)
2428 //===----------------------------------------------------------------------===//
2429 // IndirectBrInst Class
2430 //===----------------------------------------------------------------------===//
2432 //===---------------------------------------------------------------------------
2433 /// IndirectBrInst - Indirect Branch Instruction.
2435 class IndirectBrInst : public TerminatorInst {
2436 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
2437 unsigned ReservedSpace;
2438 // Operand[0] = Value to switch on
2439 // Operand[1] = Default basic block destination
2440 // Operand[2n ] = Value to match
2441 // Operand[2n+1] = BasicBlock to go to on match
2442 IndirectBrInst(const IndirectBrInst &IBI);
2443 void init(Value *Address, unsigned NumDests);
2444 void growOperands();
2445 // allocate space for exactly zero operands
2446 void *operator new(size_t s) {
2447 return User::operator new(s, 0);
2449 /// IndirectBrInst ctor - Create a new indirectbr instruction, specifying an
2450 /// Address to jump to. The number of expected destinations can be specified
2451 /// here to make memory allocation more efficient. This constructor can also
2452 /// autoinsert before another instruction.
2453 IndirectBrInst(Value *Address, unsigned NumDests, Instruction *InsertBefore);
2455 /// IndirectBrInst ctor - Create a new indirectbr instruction, specifying an
2456 /// Address to jump to. The number of expected destinations can be specified
2457 /// here to make memory allocation more efficient. This constructor also
2458 /// autoinserts at the end of the specified BasicBlock.
2459 IndirectBrInst(Value *Address, unsigned NumDests, BasicBlock *InsertAtEnd);
2461 virtual IndirectBrInst *clone_impl() const;
2463 static IndirectBrInst *Create(Value *Address, unsigned NumDests,
2464 Instruction *InsertBefore = 0) {
2465 return new IndirectBrInst(Address, NumDests, InsertBefore);
2467 static IndirectBrInst *Create(Value *Address, unsigned NumDests,
2468 BasicBlock *InsertAtEnd) {
2469 return new IndirectBrInst(Address, NumDests, InsertAtEnd);
2473 /// Provide fast operand accessors.
2474 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2476 // Accessor Methods for IndirectBrInst instruction.
2477 Value *getAddress() { return getOperand(0); }
2478 const Value *getAddress() const { return getOperand(0); }
2479 void setAddress(Value *V) { setOperand(0, V); }
2482 /// getNumDestinations - return the number of possible destinations in this
2483 /// indirectbr instruction.
2484 unsigned getNumDestinations() const { return getNumOperands()-1; }
2486 /// getDestination - Return the specified destination.
2487 BasicBlock *getDestination(unsigned i) { return getSuccessor(i); }
2488 const BasicBlock *getDestination(unsigned i) const { return getSuccessor(i); }
2490 /// addDestination - Add a destination.
2492 void addDestination(BasicBlock *Dest);
2494 /// removeDestination - This method removes the specified successor from the
2495 /// indirectbr instruction.
2496 void removeDestination(unsigned i);
2498 unsigned getNumSuccessors() const { return getNumOperands()-1; }
2499 BasicBlock *getSuccessor(unsigned i) const {
2500 return cast<BasicBlock>(getOperand(i+1));
2502 void setSuccessor(unsigned i, BasicBlock *NewSucc) {
2503 setOperand(i+1, (Value*)NewSucc);
2506 // Methods for support type inquiry through isa, cast, and dyn_cast:
2507 static inline bool classof(const IndirectBrInst *) { return true; }
2508 static inline bool classof(const Instruction *I) {
2509 return I->getOpcode() == Instruction::IndirectBr;
2511 static inline bool classof(const Value *V) {
2512 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2515 virtual BasicBlock *getSuccessorV(unsigned idx) const;
2516 virtual unsigned getNumSuccessorsV() const;
2517 virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2521 struct OperandTraits<IndirectBrInst> : public HungoffOperandTraits<1> {
2524 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(IndirectBrInst, Value)
2527 //===----------------------------------------------------------------------===//
2529 //===----------------------------------------------------------------------===//
2531 /// InvokeInst - Invoke instruction. The SubclassData field is used to hold the
2532 /// calling convention of the call.
2534 class InvokeInst : public TerminatorInst {
2535 AttrListPtr AttributeList;
2536 InvokeInst(const InvokeInst &BI);
2537 void init(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
2538 ArrayRef<Value *> Args, const Twine &NameStr);
2540 /// Construct an InvokeInst given a range of arguments.
2542 /// @brief Construct an InvokeInst from a range of arguments
2543 inline InvokeInst(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
2544 ArrayRef<Value *> Args, unsigned Values,
2545 const Twine &NameStr, Instruction *InsertBefore);
2547 /// Construct an InvokeInst given a range of arguments.
2549 /// @brief Construct an InvokeInst from a range of arguments
2550 inline InvokeInst(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
2551 ArrayRef<Value *> Args, unsigned Values,
2552 const Twine &NameStr, BasicBlock *InsertAtEnd);
2554 virtual InvokeInst *clone_impl() const;
2556 static InvokeInst *Create(Value *Func,
2557 BasicBlock *IfNormal, BasicBlock *IfException,
2558 ArrayRef<Value *> Args, const Twine &NameStr = "",
2559 Instruction *InsertBefore = 0) {
2560 unsigned Values = unsigned(Args.size()) + 3;
2561 return new(Values) InvokeInst(Func, IfNormal, IfException, Args,
2562 Values, NameStr, InsertBefore);
2564 static InvokeInst *Create(Value *Func,
2565 BasicBlock *IfNormal, BasicBlock *IfException,
2566 ArrayRef<Value *> Args, const Twine &NameStr,
2567 BasicBlock *InsertAtEnd) {
2568 unsigned Values = unsigned(Args.size()) + 3;
2569 return new(Values) InvokeInst(Func, IfNormal, IfException, Args,
2570 Values, NameStr, InsertAtEnd);
2573 /// Provide fast operand accessors
2574 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2576 /// getNumArgOperands - Return the number of invoke arguments.
2578 unsigned getNumArgOperands() const { return getNumOperands() - 3; }
2580 /// getArgOperand/setArgOperand - Return/set the i-th invoke argument.
2582 Value *getArgOperand(unsigned i) const { return getOperand(i); }
2583 void setArgOperand(unsigned i, Value *v) { setOperand(i, v); }
2585 /// getCallingConv/setCallingConv - Get or set the calling convention of this
2587 CallingConv::ID getCallingConv() const {
2588 return static_cast<CallingConv::ID>(getSubclassDataFromInstruction());
2590 void setCallingConv(CallingConv::ID CC) {
2591 setInstructionSubclassData(static_cast<unsigned>(CC));
2594 /// getAttributes - Return the parameter attributes for this invoke.
2596 const AttrListPtr &getAttributes() const { return AttributeList; }
2598 /// setAttributes - Set the parameter attributes for this invoke.
2600 void setAttributes(const AttrListPtr &Attrs) { AttributeList = Attrs; }
2602 /// addAttribute - adds the attribute to the list of attributes.
2603 void addAttribute(unsigned i, Attributes attr);
2605 /// removeAttribute - removes the attribute from the list of attributes.
2606 void removeAttribute(unsigned i, Attributes attr);
2608 /// @brief Determine whether the call or the callee has the given attribute.
2609 bool paramHasAttr(unsigned i, Attributes attr) const;
2611 /// @brief Extract the alignment for a call or parameter (0=unknown).
2612 unsigned getParamAlignment(unsigned i) const {
2613 return AttributeList.getParamAlignment(i);
2616 /// @brief Return true if the call should not be inlined.
2617 bool isNoInline() const { return paramHasAttr(~0, Attribute::NoInline); }
2618 void setIsNoInline(bool Value = true) {
2619 if (Value) addAttribute(~0, Attribute::NoInline);
2620 else removeAttribute(~0, Attribute::NoInline);
2623 /// @brief Determine if the call does not access memory.
2624 bool doesNotAccessMemory() const {
2625 return paramHasAttr(~0, Attribute::ReadNone);
2627 void setDoesNotAccessMemory(bool NotAccessMemory = true) {
2628 if (NotAccessMemory) addAttribute(~0, Attribute::ReadNone);
2629 else removeAttribute(~0, Attribute::ReadNone);
2632 /// @brief Determine if the call does not access or only reads memory.
2633 bool onlyReadsMemory() const {
2634 return doesNotAccessMemory() || paramHasAttr(~0, Attribute::ReadOnly);
2636 void setOnlyReadsMemory(bool OnlyReadsMemory = true) {
2637 if (OnlyReadsMemory) addAttribute(~0, Attribute::ReadOnly);
2638 else removeAttribute(~0, Attribute::ReadOnly | Attribute::ReadNone);
2641 /// @brief Determine if the call cannot return.
2642 bool doesNotReturn() const { return paramHasAttr(~0, Attribute::NoReturn); }
2643 void setDoesNotReturn(bool DoesNotReturn = true) {
2644 if (DoesNotReturn) addAttribute(~0, Attribute::NoReturn);
2645 else removeAttribute(~0, Attribute::NoReturn);
2648 /// @brief Determine if the call cannot unwind.
2649 bool doesNotThrow() const { return paramHasAttr(~0, Attribute::NoUnwind); }
2650 void setDoesNotThrow(bool DoesNotThrow = true) {
2651 if (DoesNotThrow) addAttribute(~0, Attribute::NoUnwind);
2652 else removeAttribute(~0, Attribute::NoUnwind);
2655 /// @brief Determine if the call returns a structure through first
2656 /// pointer argument.
2657 bool hasStructRetAttr() const {
2658 // Be friendly and also check the callee.
2659 return paramHasAttr(1, Attribute::StructRet);
2662 /// @brief Determine if any call argument is an aggregate passed by value.
2663 bool hasByValArgument() const {
2664 return AttributeList.hasAttrSomewhere(Attribute::ByVal);
2667 /// getCalledFunction - Return the function called, or null if this is an
2668 /// indirect function invocation.
2670 Function *getCalledFunction() const {
2671 return dyn_cast<Function>(Op<-3>());
2674 /// getCalledValue - Get a pointer to the function that is invoked by this
2676 const Value *getCalledValue() const { return Op<-3>(); }
2677 Value *getCalledValue() { return Op<-3>(); }
2679 /// setCalledFunction - Set the function called.
2680 void setCalledFunction(Value* Fn) {
2684 // get*Dest - Return the destination basic blocks...
2685 BasicBlock *getNormalDest() const {
2686 return cast<BasicBlock>(Op<-2>());
2688 BasicBlock *getUnwindDest() const {
2689 return cast<BasicBlock>(Op<-1>());
2691 void setNormalDest(BasicBlock *B) {
2692 Op<-2>() = reinterpret_cast<Value*>(B);
2694 void setUnwindDest(BasicBlock *B) {
2695 Op<-1>() = reinterpret_cast<Value*>(B);
2698 BasicBlock *getSuccessor(unsigned i) const {
2699 assert(i < 2 && "Successor # out of range for invoke!");
2700 return i == 0 ? getNormalDest() : getUnwindDest();
2703 void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
2704 assert(idx < 2 && "Successor # out of range for invoke!");
2705 *(&Op<-2>() + idx) = reinterpret_cast<Value*>(NewSucc);
2708 unsigned getNumSuccessors() const { return 2; }
2710 // Methods for support type inquiry through isa, cast, and dyn_cast:
2711 static inline bool classof(const InvokeInst *) { return true; }
2712 static inline bool classof(const Instruction *I) {
2713 return (I->getOpcode() == Instruction::Invoke);
2715 static inline bool classof(const Value *V) {
2716 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2720 virtual BasicBlock *getSuccessorV(unsigned idx) const;
2721 virtual unsigned getNumSuccessorsV() const;
2722 virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2724 // Shadow Instruction::setInstructionSubclassData with a private forwarding
2725 // method so that subclasses cannot accidentally use it.
2726 void setInstructionSubclassData(unsigned short D) {
2727 Instruction::setInstructionSubclassData(D);
2732 struct OperandTraits<InvokeInst> : public VariadicOperandTraits<InvokeInst, 3> {
2735 InvokeInst::InvokeInst(Value *Func,
2736 BasicBlock *IfNormal, BasicBlock *IfException,
2737 ArrayRef<Value *> Args, unsigned Values,
2738 const Twine &NameStr, Instruction *InsertBefore)
2739 : TerminatorInst(cast<FunctionType>(cast<PointerType>(Func->getType())
2740 ->getElementType())->getReturnType(),
2741 Instruction::Invoke,
2742 OperandTraits<InvokeInst>::op_end(this) - Values,
2743 Values, InsertBefore) {
2744 init(Func, IfNormal, IfException, Args, NameStr);
2746 InvokeInst::InvokeInst(Value *Func,
2747 BasicBlock *IfNormal, BasicBlock *IfException,
2748 ArrayRef<Value *> Args, unsigned Values,
2749 const Twine &NameStr, BasicBlock *InsertAtEnd)
2750 : TerminatorInst(cast<FunctionType>(cast<PointerType>(Func->getType())
2751 ->getElementType())->getReturnType(),
2752 Instruction::Invoke,
2753 OperandTraits<InvokeInst>::op_end(this) - Values,
2754 Values, InsertAtEnd) {
2755 init(Func, IfNormal, IfException, Args, NameStr);
2758 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InvokeInst, Value)
2760 //===----------------------------------------------------------------------===//
2762 //===----------------------------------------------------------------------===//
2764 //===---------------------------------------------------------------------------
2765 /// UnwindInst - Immediately exit the current function, unwinding the stack
2766 /// until an invoke instruction is found.
2768 class UnwindInst : public TerminatorInst {
2769 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
2771 virtual UnwindInst *clone_impl() const;
2773 // allocate space for exactly zero operands
2774 void *operator new(size_t s) {
2775 return User::operator new(s, 0);
2777 explicit UnwindInst(LLVMContext &C, Instruction *InsertBefore = 0);
2778 explicit UnwindInst(LLVMContext &C, BasicBlock *InsertAtEnd);
2780 unsigned getNumSuccessors() const { return 0; }
2782 // Methods for support type inquiry through isa, cast, and dyn_cast:
2783 static inline bool classof(const UnwindInst *) { return true; }
2784 static inline bool classof(const Instruction *I) {
2785 return I->getOpcode() == Instruction::Unwind;
2787 static inline bool classof(const Value *V) {
2788 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2791 virtual BasicBlock *getSuccessorV(unsigned idx) const;
2792 virtual unsigned getNumSuccessorsV() const;
2793 virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2796 //===----------------------------------------------------------------------===//
2798 //===----------------------------------------------------------------------===//
2800 //===---------------------------------------------------------------------------
2801 /// ResumeInst - Resume the propagation of an exception.
2803 class ResumeInst : public TerminatorInst {
2804 ResumeInst(const ResumeInst &RI);
2806 explicit ResumeInst(Value *Exn, Instruction *InsertBefore=0);
2807 ResumeInst(Value *Exn, BasicBlock *InsertAtEnd);
2809 virtual ResumeInst *clone_impl() const;
2811 static ResumeInst *Create(Value *Exn, Instruction *InsertBefore = 0) {
2812 return new(1) ResumeInst(Exn, InsertBefore);
2814 static ResumeInst *Create(Value *Exn, BasicBlock *InsertAtEnd) {
2815 return new(1) ResumeInst(Exn, InsertAtEnd);
2818 /// Provide fast operand accessors
2819 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2821 /// Convenience accessor.
2822 Value *getValue() const { return Op<0>(); }
2824 unsigned getNumSuccessors() const { return 0; }
2826 // Methods for support type inquiry through isa, cast, and dyn_cast:
2827 static inline bool classof(const ResumeInst *) { return true; }
2828 static inline bool classof(const Instruction *I) {
2829 return I->getOpcode() == Instruction::Resume;
2831 static inline bool classof(const Value *V) {
2832 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2835 virtual BasicBlock *getSuccessorV(unsigned idx) const;
2836 virtual unsigned getNumSuccessorsV() const;
2837 virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2841 struct OperandTraits<ResumeInst> :
2842 public FixedNumOperandTraits<ResumeInst, 1> {
2845 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ResumeInst, Value)
2847 //===----------------------------------------------------------------------===//
2848 // UnreachableInst Class
2849 //===----------------------------------------------------------------------===//
2851 //===---------------------------------------------------------------------------
2852 /// UnreachableInst - This function has undefined behavior. In particular, the
2853 /// presence of this instruction indicates some higher level knowledge that the
2854 /// end of the block cannot be reached.
2856 class UnreachableInst : public TerminatorInst {
2857 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
2859 virtual UnreachableInst *clone_impl() const;
2862 // allocate space for exactly zero operands
2863 void *operator new(size_t s) {
2864 return User::operator new(s, 0);
2866 explicit UnreachableInst(LLVMContext &C, Instruction *InsertBefore = 0);
2867 explicit UnreachableInst(LLVMContext &C, BasicBlock *InsertAtEnd);
2869 unsigned getNumSuccessors() const { return 0; }
2871 // Methods for support type inquiry through isa, cast, and dyn_cast:
2872 static inline bool classof(const UnreachableInst *) { return true; }
2873 static inline bool classof(const Instruction *I) {
2874 return I->getOpcode() == Instruction::Unreachable;
2876 static inline bool classof(const Value *V) {
2877 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2880 virtual BasicBlock *getSuccessorV(unsigned idx) const;
2881 virtual unsigned getNumSuccessorsV() const;
2882 virtual void setSuccessorV(unsigned idx, BasicBlock *B);
2885 //===----------------------------------------------------------------------===//
2887 //===----------------------------------------------------------------------===//
2889 /// @brief This class represents a truncation of integer types.
2890 class TruncInst : public CastInst {
2892 /// @brief Clone an identical TruncInst
2893 virtual TruncInst *clone_impl() const;
2896 /// @brief Constructor with insert-before-instruction semantics
2898 Value *S, ///< The value to be truncated
2899 Type *Ty, ///< The (smaller) type to truncate to
2900 const Twine &NameStr = "", ///< A name for the new instruction
2901 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
2904 /// @brief Constructor with insert-at-end-of-block semantics
2906 Value *S, ///< The value to be truncated
2907 Type *Ty, ///< The (smaller) type to truncate to
2908 const Twine &NameStr, ///< A name for the new instruction
2909 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
2912 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
2913 static inline bool classof(const TruncInst *) { return true; }
2914 static inline bool classof(const Instruction *I) {
2915 return I->getOpcode() == Trunc;
2917 static inline bool classof(const Value *V) {
2918 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2922 //===----------------------------------------------------------------------===//
2924 //===----------------------------------------------------------------------===//
2926 /// @brief This class represents zero extension of integer types.
2927 class ZExtInst : public CastInst {
2929 /// @brief Clone an identical ZExtInst
2930 virtual ZExtInst *clone_impl() const;
2933 /// @brief Constructor with insert-before-instruction semantics
2935 Value *S, ///< The value to be zero extended
2936 Type *Ty, ///< The type to zero extend to
2937 const Twine &NameStr = "", ///< A name for the new instruction
2938 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
2941 /// @brief Constructor with insert-at-end semantics.
2943 Value *S, ///< The value to be zero extended
2944 Type *Ty, ///< The type to zero extend to
2945 const Twine &NameStr, ///< A name for the new instruction
2946 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
2949 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
2950 static inline bool classof(const ZExtInst *) { return true; }
2951 static inline bool classof(const Instruction *I) {
2952 return I->getOpcode() == ZExt;
2954 static inline bool classof(const Value *V) {
2955 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2959 //===----------------------------------------------------------------------===//
2961 //===----------------------------------------------------------------------===//
2963 /// @brief This class represents a sign extension of integer types.
2964 class SExtInst : public CastInst {
2966 /// @brief Clone an identical SExtInst
2967 virtual SExtInst *clone_impl() const;
2970 /// @brief Constructor with insert-before-instruction semantics
2972 Value *S, ///< The value to be sign extended
2973 Type *Ty, ///< The type to sign extend to
2974 const Twine &NameStr = "", ///< A name for the new instruction
2975 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
2978 /// @brief Constructor with insert-at-end-of-block semantics
2980 Value *S, ///< The value to be sign extended
2981 Type *Ty, ///< The type to sign extend to
2982 const Twine &NameStr, ///< A name for the new instruction
2983 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
2986 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
2987 static inline bool classof(const SExtInst *) { return true; }
2988 static inline bool classof(const Instruction *I) {
2989 return I->getOpcode() == SExt;
2991 static inline bool classof(const Value *V) {
2992 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2996 //===----------------------------------------------------------------------===//
2997 // FPTruncInst Class
2998 //===----------------------------------------------------------------------===//
3000 /// @brief This class represents a truncation of floating point types.
3001 class FPTruncInst : public CastInst {
3003 /// @brief Clone an identical FPTruncInst
3004 virtual FPTruncInst *clone_impl() const;
3007 /// @brief Constructor with insert-before-instruction semantics
3009 Value *S, ///< The value to be truncated
3010 Type *Ty, ///< The type to truncate to
3011 const Twine &NameStr = "", ///< A name for the new instruction
3012 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3015 /// @brief Constructor with insert-before-instruction semantics
3017 Value *S, ///< The value to be truncated
3018 Type *Ty, ///< The type to truncate to
3019 const Twine &NameStr, ///< A name for the new instruction
3020 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
3023 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
3024 static inline bool classof(const FPTruncInst *) { return true; }
3025 static inline bool classof(const Instruction *I) {
3026 return I->getOpcode() == FPTrunc;
3028 static inline bool classof(const Value *V) {
3029 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3033 //===----------------------------------------------------------------------===//
3035 //===----------------------------------------------------------------------===//
3037 /// @brief This class represents an extension of floating point types.
3038 class FPExtInst : public CastInst {
3040 /// @brief Clone an identical FPExtInst
3041 virtual FPExtInst *clone_impl() const;
3044 /// @brief Constructor with insert-before-instruction semantics
3046 Value *S, ///< The value to be extended
3047 Type *Ty, ///< The type to extend to
3048 const Twine &NameStr = "", ///< A name for the new instruction
3049 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3052 /// @brief Constructor with insert-at-end-of-block semantics
3054 Value *S, ///< The value to be extended
3055 Type *Ty, ///< The type to extend to
3056 const Twine &NameStr, ///< A name for the new instruction
3057 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
3060 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
3061 static inline bool classof(const FPExtInst *) { return true; }
3062 static inline bool classof(const Instruction *I) {
3063 return I->getOpcode() == FPExt;
3065 static inline bool classof(const Value *V) {
3066 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3070 //===----------------------------------------------------------------------===//
3072 //===----------------------------------------------------------------------===//
3074 /// @brief This class represents a cast unsigned integer to floating point.
3075 class UIToFPInst : public CastInst {
3077 /// @brief Clone an identical UIToFPInst
3078 virtual UIToFPInst *clone_impl() const;
3081 /// @brief Constructor with insert-before-instruction semantics
3083 Value *S, ///< The value to be converted
3084 Type *Ty, ///< The type to convert to
3085 const Twine &NameStr = "", ///< A name for the new instruction
3086 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3089 /// @brief Constructor with insert-at-end-of-block semantics
3091 Value *S, ///< The value to be converted
3092 Type *Ty, ///< The type to convert to
3093 const Twine &NameStr, ///< A name for the new instruction
3094 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
3097 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
3098 static inline bool classof(const UIToFPInst *) { return true; }
3099 static inline bool classof(const Instruction *I) {
3100 return I->getOpcode() == UIToFP;
3102 static inline bool classof(const Value *V) {
3103 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3107 //===----------------------------------------------------------------------===//
3109 //===----------------------------------------------------------------------===//
3111 /// @brief This class represents a cast from signed integer to floating point.
3112 class SIToFPInst : public CastInst {
3114 /// @brief Clone an identical SIToFPInst
3115 virtual SIToFPInst *clone_impl() const;
3118 /// @brief Constructor with insert-before-instruction semantics
3120 Value *S, ///< The value to be converted
3121 Type *Ty, ///< The type to convert to
3122 const Twine &NameStr = "", ///< A name for the new instruction
3123 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3126 /// @brief Constructor with insert-at-end-of-block semantics
3128 Value *S, ///< The value to be converted
3129 Type *Ty, ///< The type to convert to
3130 const Twine &NameStr, ///< A name for the new instruction
3131 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
3134 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
3135 static inline bool classof(const SIToFPInst *) { return true; }
3136 static inline bool classof(const Instruction *I) {
3137 return I->getOpcode() == SIToFP;
3139 static inline bool classof(const Value *V) {
3140 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3144 //===----------------------------------------------------------------------===//
3146 //===----------------------------------------------------------------------===//
3148 /// @brief This class represents a cast from floating point to unsigned integer
3149 class FPToUIInst : public CastInst {
3151 /// @brief Clone an identical FPToUIInst
3152 virtual FPToUIInst *clone_impl() const;
3155 /// @brief Constructor with insert-before-instruction semantics
3157 Value *S, ///< The value to be converted
3158 Type *Ty, ///< The type to convert to
3159 const Twine &NameStr = "", ///< A name for the new instruction
3160 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3163 /// @brief Constructor with insert-at-end-of-block semantics
3165 Value *S, ///< The value to be converted
3166 Type *Ty, ///< The type to convert to
3167 const Twine &NameStr, ///< A name for the new instruction
3168 BasicBlock *InsertAtEnd ///< Where to insert the new instruction
3171 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
3172 static inline bool classof(const FPToUIInst *) { return true; }
3173 static inline bool classof(const Instruction *I) {
3174 return I->getOpcode() == FPToUI;
3176 static inline bool classof(const Value *V) {
3177 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3181 //===----------------------------------------------------------------------===//
3183 //===----------------------------------------------------------------------===//
3185 /// @brief This class represents a cast from floating point to signed integer.
3186 class FPToSIInst : public CastInst {
3188 /// @brief Clone an identical FPToSIInst
3189 virtual FPToSIInst *clone_impl() const;
3192 /// @brief Constructor with insert-before-instruction semantics
3194 Value *S, ///< The value to be converted
3195 Type *Ty, ///< The type to convert to
3196 const Twine &NameStr = "", ///< A name for the new instruction
3197 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3200 /// @brief Constructor with insert-at-end-of-block semantics
3202 Value *S, ///< The value to be converted
3203 Type *Ty, ///< The type to convert to
3204 const Twine &NameStr, ///< A name for the new instruction
3205 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
3208 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
3209 static inline bool classof(const FPToSIInst *) { return true; }
3210 static inline bool classof(const Instruction *I) {
3211 return I->getOpcode() == FPToSI;
3213 static inline bool classof(const Value *V) {
3214 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3218 //===----------------------------------------------------------------------===//
3219 // IntToPtrInst Class
3220 //===----------------------------------------------------------------------===//
3222 /// @brief This class represents a cast from an integer to a pointer.
3223 class IntToPtrInst : public CastInst {
3225 /// @brief Constructor with insert-before-instruction semantics
3227 Value *S, ///< The value to be converted
3228 Type *Ty, ///< The type to convert to
3229 const Twine &NameStr = "", ///< A name for the new instruction
3230 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3233 /// @brief Constructor with insert-at-end-of-block semantics
3235 Value *S, ///< The value to be converted
3236 Type *Ty, ///< The type to convert to
3237 const Twine &NameStr, ///< A name for the new instruction
3238 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
3241 /// @brief Clone an identical IntToPtrInst
3242 virtual IntToPtrInst *clone_impl() const;
3244 // Methods for support type inquiry through isa, cast, and dyn_cast:
3245 static inline bool classof(const IntToPtrInst *) { return true; }
3246 static inline bool classof(const Instruction *I) {
3247 return I->getOpcode() == IntToPtr;
3249 static inline bool classof(const Value *V) {
3250 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3254 //===----------------------------------------------------------------------===//
3255 // PtrToIntInst Class
3256 //===----------------------------------------------------------------------===//
3258 /// @brief This class represents a cast from a pointer to an integer
3259 class PtrToIntInst : public CastInst {
3261 /// @brief Clone an identical PtrToIntInst
3262 virtual PtrToIntInst *clone_impl() const;
3265 /// @brief Constructor with insert-before-instruction semantics
3267 Value *S, ///< The value to be converted
3268 Type *Ty, ///< The type to convert to
3269 const Twine &NameStr = "", ///< A name for the new instruction
3270 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3273 /// @brief Constructor with insert-at-end-of-block semantics
3275 Value *S, ///< The value to be converted
3276 Type *Ty, ///< The type to convert to
3277 const Twine &NameStr, ///< A name for the new instruction
3278 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
3281 // Methods for support type inquiry through isa, cast, and dyn_cast:
3282 static inline bool classof(const PtrToIntInst *) { return true; }
3283 static inline bool classof(const Instruction *I) {
3284 return I->getOpcode() == PtrToInt;
3286 static inline bool classof(const Value *V) {
3287 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3291 //===----------------------------------------------------------------------===//
3292 // BitCastInst Class
3293 //===----------------------------------------------------------------------===//
3295 /// @brief This class represents a no-op cast from one type to another.
3296 class BitCastInst : public CastInst {
3298 /// @brief Clone an identical BitCastInst
3299 virtual BitCastInst *clone_impl() const;
3302 /// @brief Constructor with insert-before-instruction semantics
3304 Value *S, ///< The value to be casted
3305 Type *Ty, ///< The type to casted to
3306 const Twine &NameStr = "", ///< A name for the new instruction
3307 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
3310 /// @brief Constructor with insert-at-end-of-block semantics
3312 Value *S, ///< The value to be casted
3313 Type *Ty, ///< The type to casted to
3314 const Twine &NameStr, ///< A name for the new instruction
3315 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
3318 // Methods for support type inquiry through isa, cast, and dyn_cast:
3319 static inline bool classof(const BitCastInst *) { return true; }
3320 static inline bool classof(const Instruction *I) {
3321 return I->getOpcode() == BitCast;
3323 static inline bool classof(const Value *V) {
3324 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3328 } // End llvm namespace