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/SmallVector.h"
33 //===----------------------------------------------------------------------===//
35 //===----------------------------------------------------------------------===//
37 /// AllocaInst - an instruction to allocate memory on the stack
39 class AllocaInst
: public UnaryInstruction
{
41 virtual AllocaInst
*clone_impl() const;
43 explicit AllocaInst(const Type
*Ty
, Value
*ArraySize
= 0,
44 const Twine
&Name
= "", Instruction
*InsertBefore
= 0);
45 AllocaInst(const Type
*Ty
, Value
*ArraySize
,
46 const Twine
&Name
, BasicBlock
*InsertAtEnd
);
48 AllocaInst(const Type
*Ty
, const Twine
&Name
, Instruction
*InsertBefore
= 0);
49 AllocaInst(const Type
*Ty
, const Twine
&Name
, BasicBlock
*InsertAtEnd
);
51 AllocaInst(const Type
*Ty
, Value
*ArraySize
, unsigned Align
,
52 const Twine
&Name
= "", Instruction
*InsertBefore
= 0);
53 AllocaInst(const Type
*Ty
, Value
*ArraySize
, unsigned Align
,
54 const Twine
&Name
, BasicBlock
*InsertAtEnd
);
56 // Out of line virtual method, so the vtable, etc. has a home.
57 virtual ~AllocaInst();
59 /// isArrayAllocation - Return true if there is an allocation size parameter
60 /// to the allocation instruction that is not 1.
62 bool isArrayAllocation() const;
64 /// getArraySize - Get the number of elements allocated. For a simple
65 /// allocation of a single element, this will return a constant 1 value.
67 const Value
*getArraySize() const { return getOperand(0); }
68 Value
*getArraySize() { return getOperand(0); }
70 /// getType - Overload to return most specific pointer type
72 const PointerType
*getType() const {
73 return reinterpret_cast<const PointerType
*>(Instruction::getType());
76 /// getAllocatedType - Return the type that is being allocated by the
79 Type
*getAllocatedType() const;
81 /// getAlignment - Return the alignment of the memory that is being allocated
82 /// by the instruction.
84 unsigned getAlignment() const {
85 return (1u << getSubclassDataFromInstruction()) >> 1;
87 void setAlignment(unsigned Align
);
89 /// isStaticAlloca - Return true if this alloca is in the entry block of the
90 /// function and is a constant size. If so, the code generator will fold it
91 /// into the prolog/epilog code, so it is basically free.
92 bool isStaticAlloca() const;
94 // Methods for support type inquiry through isa, cast, and dyn_cast:
95 static inline bool classof(const AllocaInst
*) { return true; }
96 static inline bool classof(const Instruction
*I
) {
97 return (I
->getOpcode() == Instruction::Alloca
);
99 static inline bool classof(const Value
*V
) {
100 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
103 // Shadow Instruction::setInstructionSubclassData with a private forwarding
104 // method so that subclasses cannot accidentally use it.
105 void setInstructionSubclassData(unsigned short D
) {
106 Instruction::setInstructionSubclassData(D
);
111 //===----------------------------------------------------------------------===//
113 //===----------------------------------------------------------------------===//
115 /// LoadInst - an instruction for reading from memory. This uses the
116 /// SubclassData field in Value to store whether or not the load is volatile.
118 class LoadInst
: public UnaryInstruction
{
121 virtual LoadInst
*clone_impl() const;
123 LoadInst(Value
*Ptr
, const Twine
&NameStr
, Instruction
*InsertBefore
);
124 LoadInst(Value
*Ptr
, const Twine
&NameStr
, BasicBlock
*InsertAtEnd
);
125 LoadInst(Value
*Ptr
, const Twine
&NameStr
, bool isVolatile
= false,
126 Instruction
*InsertBefore
= 0);
127 LoadInst(Value
*Ptr
, const Twine
&NameStr
, bool isVolatile
,
128 unsigned Align
, Instruction
*InsertBefore
= 0);
129 LoadInst(Value
*Ptr
, const Twine
&NameStr
, bool isVolatile
,
130 BasicBlock
*InsertAtEnd
);
131 LoadInst(Value
*Ptr
, const Twine
&NameStr
, bool isVolatile
,
132 unsigned Align
, BasicBlock
*InsertAtEnd
);
134 LoadInst(Value
*Ptr
, const char *NameStr
, Instruction
*InsertBefore
);
135 LoadInst(Value
*Ptr
, const char *NameStr
, BasicBlock
*InsertAtEnd
);
136 explicit LoadInst(Value
*Ptr
, const char *NameStr
= 0,
137 bool isVolatile
= false, Instruction
*InsertBefore
= 0);
138 LoadInst(Value
*Ptr
, const char *NameStr
, bool isVolatile
,
139 BasicBlock
*InsertAtEnd
);
141 /// isVolatile - Return true if this is a load from a volatile memory
144 bool isVolatile() const { return getSubclassDataFromInstruction() & 1; }
146 /// setVolatile - Specify whether this is a volatile load or not.
148 void setVolatile(bool V
) {
149 setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
153 /// getAlignment - Return the alignment of the access that is being performed
155 unsigned getAlignment() const {
156 return (1 << (getSubclassDataFromInstruction() >> 1)) >> 1;
159 void setAlignment(unsigned Align
);
161 Value
*getPointerOperand() { return getOperand(0); }
162 const Value
*getPointerOperand() const { return getOperand(0); }
163 static unsigned getPointerOperandIndex() { return 0U; }
165 unsigned getPointerAddressSpace() const {
166 return cast
<PointerType
>(getPointerOperand()->getType())->getAddressSpace();
170 // Methods for support type inquiry through isa, cast, and dyn_cast:
171 static inline bool classof(const LoadInst
*) { return true; }
172 static inline bool classof(const Instruction
*I
) {
173 return I
->getOpcode() == Instruction::Load
;
175 static inline bool classof(const Value
*V
) {
176 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
179 // Shadow Instruction::setInstructionSubclassData with a private forwarding
180 // method so that subclasses cannot accidentally use it.
181 void setInstructionSubclassData(unsigned short D
) {
182 Instruction::setInstructionSubclassData(D
);
187 //===----------------------------------------------------------------------===//
189 //===----------------------------------------------------------------------===//
191 /// StoreInst - an instruction for storing to memory
193 class StoreInst
: public Instruction
{
194 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
197 virtual StoreInst
*clone_impl() const;
199 // allocate space for exactly two operands
200 void *operator new(size_t s
) {
201 return User::operator new(s
, 2);
203 StoreInst(Value
*Val
, Value
*Ptr
, Instruction
*InsertBefore
);
204 StoreInst(Value
*Val
, Value
*Ptr
, BasicBlock
*InsertAtEnd
);
205 StoreInst(Value
*Val
, Value
*Ptr
, bool isVolatile
= false,
206 Instruction
*InsertBefore
= 0);
207 StoreInst(Value
*Val
, Value
*Ptr
, bool isVolatile
,
208 unsigned Align
, Instruction
*InsertBefore
= 0);
209 StoreInst(Value
*Val
, Value
*Ptr
, bool isVolatile
, BasicBlock
*InsertAtEnd
);
210 StoreInst(Value
*Val
, Value
*Ptr
, bool isVolatile
,
211 unsigned Align
, BasicBlock
*InsertAtEnd
);
214 /// isVolatile - Return true if this is a load from a volatile memory
217 bool isVolatile() const { return getSubclassDataFromInstruction() & 1; }
219 /// setVolatile - Specify whether this is a volatile load or not.
221 void setVolatile(bool V
) {
222 setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
226 /// Transparently provide more efficient getOperand methods.
227 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value
);
229 /// getAlignment - Return the alignment of the access that is being performed
231 unsigned getAlignment() const {
232 return (1 << (getSubclassDataFromInstruction() >> 1)) >> 1;
235 void setAlignment(unsigned Align
);
237 Value
*getValueOperand() { return getOperand(0); }
238 const Value
*getValueOperand() const { return getOperand(0); }
240 Value
*getPointerOperand() { return getOperand(1); }
241 const Value
*getPointerOperand() const { return getOperand(1); }
242 static unsigned getPointerOperandIndex() { return 1U; }
244 unsigned getPointerAddressSpace() const {
245 return cast
<PointerType
>(getPointerOperand()->getType())->getAddressSpace();
248 // Methods for support type inquiry through isa, cast, and dyn_cast:
249 static inline bool classof(const StoreInst
*) { return true; }
250 static inline bool classof(const Instruction
*I
) {
251 return I
->getOpcode() == Instruction::Store
;
253 static inline bool classof(const Value
*V
) {
254 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
257 // Shadow Instruction::setInstructionSubclassData with a private forwarding
258 // method so that subclasses cannot accidentally use it.
259 void setInstructionSubclassData(unsigned short D
) {
260 Instruction::setInstructionSubclassData(D
);
265 struct OperandTraits
<StoreInst
> : public FixedNumOperandTraits
<StoreInst
, 2> {
268 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(StoreInst
, Value
)
270 //===----------------------------------------------------------------------===//
271 // GetElementPtrInst Class
272 //===----------------------------------------------------------------------===//
274 // checkGEPType - Simple wrapper function to give a better assertion failure
275 // message on bad indexes for a gep instruction.
277 static inline const Type
*checkGEPType(const Type
*Ty
) {
278 assert(Ty
&& "Invalid GetElementPtrInst indices for type!");
282 /// GetElementPtrInst - an instruction for type-safe pointer arithmetic to
283 /// access elements of arrays and structs
285 class GetElementPtrInst
: public Instruction
{
286 GetElementPtrInst(const GetElementPtrInst
&GEPI
);
287 void init(Value
*Ptr
, Value
* const *Idx
, unsigned NumIdx
,
288 const Twine
&NameStr
);
289 void init(Value
*Ptr
, Value
*Idx
, const Twine
&NameStr
);
291 template<typename RandomAccessIterator
>
292 void init(Value
*Ptr
,
293 RandomAccessIterator IdxBegin
,
294 RandomAccessIterator IdxEnd
,
295 const Twine
&NameStr
,
296 // This argument ensures that we have an iterator we can
297 // do arithmetic on in constant time
298 std::random_access_iterator_tag
) {
299 unsigned NumIdx
= static_cast<unsigned>(std::distance(IdxBegin
, IdxEnd
));
302 // This requires that the iterator points to contiguous memory.
303 init(Ptr
, &*IdxBegin
, NumIdx
, NameStr
); // FIXME: for the general case
304 // we have to build an array here
307 init(Ptr
, 0, NumIdx
, NameStr
);
311 /// getIndexedType - Returns the type of the element that would be loaded with
312 /// a load instruction with the specified parameters.
314 /// Null is returned if the indices are invalid for the specified
317 template<typename RandomAccessIterator
>
318 static Type
*getIndexedType(const Type
*Ptr
,
319 RandomAccessIterator IdxBegin
,
320 RandomAccessIterator IdxEnd
,
321 // This argument ensures that we
322 // have an iterator we can do
323 // arithmetic on in constant time
324 std::random_access_iterator_tag
) {
325 unsigned NumIdx
= static_cast<unsigned>(std::distance(IdxBegin
, IdxEnd
));
328 // This requires that the iterator points to contiguous memory.
329 return getIndexedType(Ptr
, &*IdxBegin
, NumIdx
);
331 return getIndexedType(Ptr
, (Value
*const*)0, NumIdx
);
334 /// Constructors - Create a getelementptr instruction with a base pointer an
335 /// list of indices. The first ctor can optionally insert before an existing
336 /// instruction, the second appends the new instruction to the specified
338 template<typename RandomAccessIterator
>
339 inline GetElementPtrInst(Value
*Ptr
, RandomAccessIterator IdxBegin
,
340 RandomAccessIterator IdxEnd
,
342 const Twine
&NameStr
,
343 Instruction
*InsertBefore
);
344 template<typename RandomAccessIterator
>
345 inline GetElementPtrInst(Value
*Ptr
,
346 RandomAccessIterator IdxBegin
,
347 RandomAccessIterator IdxEnd
,
349 const Twine
&NameStr
, BasicBlock
*InsertAtEnd
);
351 /// Constructors - These two constructors are convenience methods because one
352 /// and two index getelementptr instructions are so common.
353 GetElementPtrInst(Value
*Ptr
, Value
*Idx
, const Twine
&NameStr
= "",
354 Instruction
*InsertBefore
= 0);
355 GetElementPtrInst(Value
*Ptr
, Value
*Idx
,
356 const Twine
&NameStr
, BasicBlock
*InsertAtEnd
);
358 virtual GetElementPtrInst
*clone_impl() const;
360 template<typename RandomAccessIterator
>
361 static GetElementPtrInst
*Create(Value
*Ptr
, RandomAccessIterator IdxBegin
,
362 RandomAccessIterator IdxEnd
,
363 const Twine
&NameStr
= "",
364 Instruction
*InsertBefore
= 0) {
365 typename
std::iterator_traits
<RandomAccessIterator
>::difference_type
366 Values
= 1 + std::distance(IdxBegin
, IdxEnd
);
368 GetElementPtrInst(Ptr
, IdxBegin
, IdxEnd
, Values
, NameStr
, InsertBefore
);
370 template<typename RandomAccessIterator
>
371 static GetElementPtrInst
*Create(Value
*Ptr
,
372 RandomAccessIterator IdxBegin
,
373 RandomAccessIterator IdxEnd
,
374 const Twine
&NameStr
,
375 BasicBlock
*InsertAtEnd
) {
376 typename
std::iterator_traits
<RandomAccessIterator
>::difference_type
377 Values
= 1 + std::distance(IdxBegin
, IdxEnd
);
379 GetElementPtrInst(Ptr
, IdxBegin
, IdxEnd
, Values
, NameStr
, InsertAtEnd
);
382 /// Constructors - These two creators are convenience methods because one
383 /// index getelementptr instructions are so common.
384 static GetElementPtrInst
*Create(Value
*Ptr
, Value
*Idx
,
385 const Twine
&NameStr
= "",
386 Instruction
*InsertBefore
= 0) {
387 return new(2) GetElementPtrInst(Ptr
, Idx
, NameStr
, InsertBefore
);
389 static GetElementPtrInst
*Create(Value
*Ptr
, Value
*Idx
,
390 const Twine
&NameStr
,
391 BasicBlock
*InsertAtEnd
) {
392 return new(2) GetElementPtrInst(Ptr
, Idx
, NameStr
, InsertAtEnd
);
395 /// Create an "inbounds" getelementptr. See the documentation for the
396 /// "inbounds" flag in LangRef.html for details.
397 template<typename RandomAccessIterator
>
398 static GetElementPtrInst
*CreateInBounds(Value
*Ptr
,
399 RandomAccessIterator IdxBegin
,
400 RandomAccessIterator IdxEnd
,
401 const Twine
&NameStr
= "",
402 Instruction
*InsertBefore
= 0) {
403 GetElementPtrInst
*GEP
= Create(Ptr
, IdxBegin
, IdxEnd
,
404 NameStr
, InsertBefore
);
405 GEP
->setIsInBounds(true);
408 template<typename RandomAccessIterator
>
409 static GetElementPtrInst
*CreateInBounds(Value
*Ptr
,
410 RandomAccessIterator IdxBegin
,
411 RandomAccessIterator IdxEnd
,
412 const Twine
&NameStr
,
413 BasicBlock
*InsertAtEnd
) {
414 GetElementPtrInst
*GEP
= Create(Ptr
, IdxBegin
, IdxEnd
,
415 NameStr
, InsertAtEnd
);
416 GEP
->setIsInBounds(true);
419 static GetElementPtrInst
*CreateInBounds(Value
*Ptr
, Value
*Idx
,
420 const Twine
&NameStr
= "",
421 Instruction
*InsertBefore
= 0) {
422 GetElementPtrInst
*GEP
= Create(Ptr
, Idx
, NameStr
, InsertBefore
);
423 GEP
->setIsInBounds(true);
426 static GetElementPtrInst
*CreateInBounds(Value
*Ptr
, Value
*Idx
,
427 const Twine
&NameStr
,
428 BasicBlock
*InsertAtEnd
) {
429 GetElementPtrInst
*GEP
= Create(Ptr
, Idx
, NameStr
, InsertAtEnd
);
430 GEP
->setIsInBounds(true);
434 /// Transparently provide more efficient getOperand methods.
435 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value
);
437 // getType - Overload to return most specific pointer type...
438 const PointerType
*getType() const {
439 return reinterpret_cast<const PointerType
*>(Instruction::getType());
442 /// getIndexedType - Returns the type of the element that would be loaded with
443 /// a load instruction with the specified parameters.
445 /// Null is returned if the indices are invalid for the specified
448 template<typename RandomAccessIterator
>
449 static Type
*getIndexedType(const Type
*Ptr
, RandomAccessIterator IdxBegin
,
450 RandomAccessIterator IdxEnd
) {
451 return getIndexedType(Ptr
, IdxBegin
, IdxEnd
,
452 typename
std::iterator_traits
<RandomAccessIterator
>::
453 iterator_category());
456 // FIXME: Use ArrayRef
457 static Type
*getIndexedType(const Type
*Ptr
,
458 Value
* const *Idx
, unsigned NumIdx
);
459 static Type
*getIndexedType(const Type
*Ptr
,
460 Constant
* const *Idx
, unsigned NumIdx
);
462 static Type
*getIndexedType(const Type
*Ptr
,
463 uint64_t const *Idx
, unsigned NumIdx
);
464 static Type
*getIndexedType(const Type
*Ptr
, Value
*Idx
);
466 inline op_iterator
idx_begin() { return op_begin()+1; }
467 inline const_op_iterator
idx_begin() const { return op_begin()+1; }
468 inline op_iterator
idx_end() { return op_end(); }
469 inline const_op_iterator
idx_end() const { return op_end(); }
471 Value
*getPointerOperand() {
472 return getOperand(0);
474 const Value
*getPointerOperand() const {
475 return getOperand(0);
477 static unsigned getPointerOperandIndex() {
478 return 0U; // get index for modifying correct operand
481 unsigned getPointerAddressSpace() const {
482 return cast
<PointerType
>(getType())->getAddressSpace();
485 /// getPointerOperandType - Method to return the pointer operand as a
487 const PointerType
*getPointerOperandType() const {
488 return reinterpret_cast<const PointerType
*>(getPointerOperand()->getType());
492 unsigned getNumIndices() const { // Note: always non-negative
493 return getNumOperands() - 1;
496 bool hasIndices() const {
497 return getNumOperands() > 1;
500 /// hasAllZeroIndices - Return true if all of the indices of this GEP are
501 /// zeros. If so, the result pointer and the first operand have the same
502 /// value, just potentially different types.
503 bool hasAllZeroIndices() const;
505 /// hasAllConstantIndices - Return true if all of the indices of this GEP are
506 /// constant integers. If so, the result pointer and the first operand have
507 /// a constant offset between them.
508 bool hasAllConstantIndices() const;
510 /// setIsInBounds - Set or clear the inbounds flag on this GEP instruction.
511 /// See LangRef.html for the meaning of inbounds on a getelementptr.
512 void setIsInBounds(bool b
= true);
514 /// isInBounds - Determine whether the GEP has the inbounds flag.
515 bool isInBounds() const;
517 // Methods for support type inquiry through isa, cast, and dyn_cast:
518 static inline bool classof(const GetElementPtrInst
*) { return true; }
519 static inline bool classof(const Instruction
*I
) {
520 return (I
->getOpcode() == Instruction::GetElementPtr
);
522 static inline bool classof(const Value
*V
) {
523 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
528 struct OperandTraits
<GetElementPtrInst
> :
529 public VariadicOperandTraits
<GetElementPtrInst
, 1> {
532 template<typename RandomAccessIterator
>
533 GetElementPtrInst::GetElementPtrInst(Value
*Ptr
,
534 RandomAccessIterator IdxBegin
,
535 RandomAccessIterator IdxEnd
,
537 const Twine
&NameStr
,
538 Instruction
*InsertBefore
)
539 : Instruction(PointerType::get(checkGEPType(
540 getIndexedType(Ptr
->getType(),
542 cast
<PointerType
>(Ptr
->getType())
543 ->getAddressSpace()),
545 OperandTraits
<GetElementPtrInst
>::op_end(this) - Values
,
546 Values
, InsertBefore
) {
547 init(Ptr
, IdxBegin
, IdxEnd
, NameStr
,
548 typename
std::iterator_traits
<RandomAccessIterator
>
549 ::iterator_category());
551 template<typename RandomAccessIterator
>
552 GetElementPtrInst::GetElementPtrInst(Value
*Ptr
,
553 RandomAccessIterator IdxBegin
,
554 RandomAccessIterator IdxEnd
,
556 const Twine
&NameStr
,
557 BasicBlock
*InsertAtEnd
)
558 : Instruction(PointerType::get(checkGEPType(
559 getIndexedType(Ptr
->getType(),
561 cast
<PointerType
>(Ptr
->getType())
562 ->getAddressSpace()),
564 OperandTraits
<GetElementPtrInst
>::op_end(this) - Values
,
565 Values
, InsertAtEnd
) {
566 init(Ptr
, IdxBegin
, IdxEnd
, NameStr
,
567 typename
std::iterator_traits
<RandomAccessIterator
>
568 ::iterator_category());
572 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GetElementPtrInst
, Value
)
575 //===----------------------------------------------------------------------===//
577 //===----------------------------------------------------------------------===//
579 /// This instruction compares its operands according to the predicate given
580 /// to the constructor. It only operates on integers or pointers. The operands
581 /// must be identical types.
582 /// @brief Represent an integer comparison operator.
583 class ICmpInst
: public CmpInst
{
585 /// @brief Clone an identical ICmpInst
586 virtual ICmpInst
*clone_impl() const;
588 /// @brief Constructor with insert-before-instruction semantics.
590 Instruction
*InsertBefore
, ///< Where to insert
591 Predicate pred
, ///< The predicate to use for the comparison
592 Value
*LHS
, ///< The left-hand-side of the expression
593 Value
*RHS
, ///< The right-hand-side of the expression
594 const Twine
&NameStr
= "" ///< Name of the instruction
595 ) : CmpInst(makeCmpResultType(LHS
->getType()),
596 Instruction::ICmp
, pred
, LHS
, RHS
, NameStr
,
598 assert(pred
>= CmpInst::FIRST_ICMP_PREDICATE
&&
599 pred
<= CmpInst::LAST_ICMP_PREDICATE
&&
600 "Invalid ICmp predicate value");
601 assert(getOperand(0)->getType() == getOperand(1)->getType() &&
602 "Both operands to ICmp instruction are not of the same type!");
603 // Check that the operands are the right type
604 assert((getOperand(0)->getType()->isIntOrIntVectorTy() ||
605 getOperand(0)->getType()->isPointerTy()) &&
606 "Invalid operand types for ICmp instruction");
609 /// @brief Constructor with insert-at-end semantics.
611 BasicBlock
&InsertAtEnd
, ///< Block to insert into.
612 Predicate pred
, ///< The predicate to use for the comparison
613 Value
*LHS
, ///< The left-hand-side of the expression
614 Value
*RHS
, ///< The right-hand-side of the expression
615 const Twine
&NameStr
= "" ///< Name of the instruction
616 ) : CmpInst(makeCmpResultType(LHS
->getType()),
617 Instruction::ICmp
, pred
, LHS
, RHS
, NameStr
,
619 assert(pred
>= CmpInst::FIRST_ICMP_PREDICATE
&&
620 pred
<= CmpInst::LAST_ICMP_PREDICATE
&&
621 "Invalid ICmp predicate value");
622 assert(getOperand(0)->getType() == getOperand(1)->getType() &&
623 "Both operands to ICmp instruction are not of the same type!");
624 // Check that the operands are the right type
625 assert((getOperand(0)->getType()->isIntOrIntVectorTy() ||
626 getOperand(0)->getType()->isPointerTy()) &&
627 "Invalid operand types for ICmp instruction");
630 /// @brief Constructor with no-insertion semantics
632 Predicate pred
, ///< The predicate to use for the comparison
633 Value
*LHS
, ///< The left-hand-side of the expression
634 Value
*RHS
, ///< The right-hand-side of the expression
635 const Twine
&NameStr
= "" ///< Name of the instruction
636 ) : CmpInst(makeCmpResultType(LHS
->getType()),
637 Instruction::ICmp
, pred
, LHS
, RHS
, NameStr
) {
638 assert(pred
>= CmpInst::FIRST_ICMP_PREDICATE
&&
639 pred
<= CmpInst::LAST_ICMP_PREDICATE
&&
640 "Invalid ICmp predicate value");
641 assert(getOperand(0)->getType() == getOperand(1)->getType() &&
642 "Both operands to ICmp instruction are not of the same type!");
643 // Check that the operands are the right type
644 assert((getOperand(0)->getType()->isIntOrIntVectorTy() ||
645 getOperand(0)->getType()->isPointerTy()) &&
646 "Invalid operand types for ICmp instruction");
649 /// For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.
650 /// @returns the predicate that would be the result if the operand were
651 /// regarded as signed.
652 /// @brief Return the signed version of the predicate
653 Predicate
getSignedPredicate() const {
654 return getSignedPredicate(getPredicate());
657 /// This is a static version that you can use without an instruction.
658 /// @brief Return the signed version of the predicate.
659 static Predicate
getSignedPredicate(Predicate pred
);
661 /// For example, EQ->EQ, SLE->ULE, UGT->UGT, etc.
662 /// @returns the predicate that would be the result if the operand were
663 /// regarded as unsigned.
664 /// @brief Return the unsigned version of the predicate
665 Predicate
getUnsignedPredicate() const {
666 return getUnsignedPredicate(getPredicate());
669 /// This is a static version that you can use without an instruction.
670 /// @brief Return the unsigned version of the predicate.
671 static Predicate
getUnsignedPredicate(Predicate pred
);
673 /// isEquality - Return true if this predicate is either EQ or NE. This also
674 /// tests for commutativity.
675 static bool isEquality(Predicate P
) {
676 return P
== ICMP_EQ
|| P
== ICMP_NE
;
679 /// isEquality - Return true if this predicate is either EQ or NE. This also
680 /// tests for commutativity.
681 bool isEquality() const {
682 return isEquality(getPredicate());
685 /// @returns true if the predicate of this ICmpInst is commutative
686 /// @brief Determine if this relation is commutative.
687 bool isCommutative() const { return isEquality(); }
689 /// isRelational - Return true if the predicate is relational (not EQ or NE).
691 bool isRelational() const {
692 return !isEquality();
695 /// isRelational - Return true if the predicate is relational (not EQ or NE).
697 static bool isRelational(Predicate P
) {
698 return !isEquality(P
);
701 /// Initialize a set of values that all satisfy the predicate with C.
702 /// @brief Make a ConstantRange for a relation with a constant value.
703 static ConstantRange
makeConstantRange(Predicate pred
, const APInt
&C
);
705 /// Exchange the two operands to this instruction in such a way that it does
706 /// not modify the semantics of the instruction. The predicate value may be
707 /// changed to retain the same result if the predicate is order dependent
709 /// @brief Swap operands and adjust predicate.
710 void swapOperands() {
711 setPredicate(getSwappedPredicate());
712 Op
<0>().swap(Op
<1>());
715 // Methods for support type inquiry through isa, cast, and dyn_cast:
716 static inline bool classof(const ICmpInst
*) { return true; }
717 static inline bool classof(const Instruction
*I
) {
718 return I
->getOpcode() == Instruction::ICmp
;
720 static inline bool classof(const Value
*V
) {
721 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
726 //===----------------------------------------------------------------------===//
728 //===----------------------------------------------------------------------===//
730 /// This instruction compares its operands according to the predicate given
731 /// to the constructor. It only operates on floating point values or packed
732 /// vectors of floating point values. The operands must be identical types.
733 /// @brief Represents a floating point comparison operator.
734 class FCmpInst
: public CmpInst
{
736 /// @brief Clone an identical FCmpInst
737 virtual FCmpInst
*clone_impl() const;
739 /// @brief Constructor with insert-before-instruction semantics.
741 Instruction
*InsertBefore
, ///< Where to insert
742 Predicate pred
, ///< The predicate to use for the comparison
743 Value
*LHS
, ///< The left-hand-side of the expression
744 Value
*RHS
, ///< The right-hand-side of the expression
745 const Twine
&NameStr
= "" ///< Name of the instruction
746 ) : CmpInst(makeCmpResultType(LHS
->getType()),
747 Instruction::FCmp
, pred
, LHS
, RHS
, NameStr
,
749 assert(pred
<= FCmpInst::LAST_FCMP_PREDICATE
&&
750 "Invalid FCmp predicate value");
751 assert(getOperand(0)->getType() == getOperand(1)->getType() &&
752 "Both operands to FCmp instruction are not of the same type!");
753 // Check that the operands are the right type
754 assert(getOperand(0)->getType()->isFPOrFPVectorTy() &&
755 "Invalid operand types for FCmp instruction");
758 /// @brief Constructor with insert-at-end semantics.
760 BasicBlock
&InsertAtEnd
, ///< Block to insert into.
761 Predicate pred
, ///< The predicate to use for the comparison
762 Value
*LHS
, ///< The left-hand-side of the expression
763 Value
*RHS
, ///< The right-hand-side of the expression
764 const Twine
&NameStr
= "" ///< Name of the instruction
765 ) : CmpInst(makeCmpResultType(LHS
->getType()),
766 Instruction::FCmp
, pred
, LHS
, RHS
, NameStr
,
768 assert(pred
<= FCmpInst::LAST_FCMP_PREDICATE
&&
769 "Invalid FCmp predicate value");
770 assert(getOperand(0)->getType() == getOperand(1)->getType() &&
771 "Both operands to FCmp instruction are not of the same type!");
772 // Check that the operands are the right type
773 assert(getOperand(0)->getType()->isFPOrFPVectorTy() &&
774 "Invalid operand types for FCmp instruction");
777 /// @brief Constructor with no-insertion semantics
779 Predicate pred
, ///< The predicate to use for the comparison
780 Value
*LHS
, ///< The left-hand-side of the expression
781 Value
*RHS
, ///< The right-hand-side of the expression
782 const Twine
&NameStr
= "" ///< Name of the instruction
783 ) : CmpInst(makeCmpResultType(LHS
->getType()),
784 Instruction::FCmp
, pred
, LHS
, RHS
, NameStr
) {
785 assert(pred
<= FCmpInst::LAST_FCMP_PREDICATE
&&
786 "Invalid FCmp predicate value");
787 assert(getOperand(0)->getType() == getOperand(1)->getType() &&
788 "Both operands to FCmp instruction are not of the same type!");
789 // Check that the operands are the right type
790 assert(getOperand(0)->getType()->isFPOrFPVectorTy() &&
791 "Invalid operand types for FCmp instruction");
794 /// @returns true if the predicate of this instruction is EQ or NE.
795 /// @brief Determine if this is an equality predicate.
796 bool isEquality() const {
797 return getPredicate() == FCMP_OEQ
|| getPredicate() == FCMP_ONE
||
798 getPredicate() == FCMP_UEQ
|| getPredicate() == FCMP_UNE
;
801 /// @returns true if the predicate of this instruction is commutative.
802 /// @brief Determine if this is a commutative predicate.
803 bool isCommutative() const {
804 return isEquality() ||
805 getPredicate() == FCMP_FALSE
||
806 getPredicate() == FCMP_TRUE
||
807 getPredicate() == FCMP_ORD
||
808 getPredicate() == FCMP_UNO
;
811 /// @returns true if the predicate is relational (not EQ or NE).
812 /// @brief Determine if this a relational predicate.
813 bool isRelational() const { return !isEquality(); }
815 /// Exchange the two operands to this instruction in such a way that it does
816 /// not modify the semantics of the instruction. The predicate value may be
817 /// changed to retain the same result if the predicate is order dependent
819 /// @brief Swap operands and adjust predicate.
820 void swapOperands() {
821 setPredicate(getSwappedPredicate());
822 Op
<0>().swap(Op
<1>());
825 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
826 static inline bool classof(const FCmpInst
*) { return true; }
827 static inline bool classof(const Instruction
*I
) {
828 return I
->getOpcode() == Instruction::FCmp
;
830 static inline bool classof(const Value
*V
) {
831 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
835 //===----------------------------------------------------------------------===//
836 /// CallInst - This class represents a function call, abstracting a target
837 /// machine's calling convention. This class uses low bit of the SubClassData
838 /// field to indicate whether or not this is a tail call. The rest of the bits
839 /// hold the calling convention of the call.
841 class CallInst
: public Instruction
{
842 AttrListPtr AttributeList
; ///< parameter attributes for call
843 CallInst(const CallInst
&CI
);
844 void init(Value
*Func
, Value
* const *Params
, unsigned NumParams
);
845 void init(Value
*Func
, Value
*Actual1
, Value
*Actual2
);
846 void init(Value
*Func
, Value
*Actual
);
847 void init(Value
*Func
);
849 template<typename RandomAccessIterator
>
850 void init(Value
*Func
,
851 RandomAccessIterator ArgBegin
,
852 RandomAccessIterator ArgEnd
,
853 const Twine
&NameStr
,
854 // This argument ensures that we have an iterator we can
855 // do arithmetic on in constant time
856 std::random_access_iterator_tag
) {
857 unsigned NumArgs
= (unsigned)std::distance(ArgBegin
, ArgEnd
);
859 // This requires that the iterator points to contiguous memory.
860 init(Func
, NumArgs
? &*ArgBegin
: 0, NumArgs
);
864 /// Construct a CallInst given a range of arguments. RandomAccessIterator
865 /// must be a random-access iterator pointing to contiguous storage
866 /// (e.g. a std::vector<>::iterator). Checks are made for
867 /// random-accessness but not for contiguous storage as that would
868 /// incur runtime overhead.
869 /// @brief Construct a CallInst from a range of arguments
870 template<typename RandomAccessIterator
>
871 CallInst(Value
*Func
,
872 RandomAccessIterator ArgBegin
, RandomAccessIterator ArgEnd
,
873 const Twine
&NameStr
, Instruction
*InsertBefore
);
875 /// Construct a CallInst given a range of arguments. RandomAccessIterator
876 /// must be a random-access iterator pointing to contiguous storage
877 /// (e.g. a std::vector<>::iterator). Checks are made for
878 /// random-accessness but not for contiguous storage as that would
879 /// incur runtime overhead.
880 /// @brief Construct a CallInst from a range of arguments
881 template<typename RandomAccessIterator
>
882 inline CallInst(Value
*Func
,
883 RandomAccessIterator ArgBegin
, RandomAccessIterator ArgEnd
,
884 const Twine
&NameStr
, BasicBlock
*InsertAtEnd
);
886 CallInst(Value
*F
, Value
*Actual
, const Twine
&NameStr
,
887 Instruction
*InsertBefore
);
888 CallInst(Value
*F
, Value
*Actual
, const Twine
&NameStr
,
889 BasicBlock
*InsertAtEnd
);
890 explicit CallInst(Value
*F
, const Twine
&NameStr
,
891 Instruction
*InsertBefore
);
892 CallInst(Value
*F
, const Twine
&NameStr
, BasicBlock
*InsertAtEnd
);
894 virtual CallInst
*clone_impl() const;
896 template<typename RandomAccessIterator
>
897 static CallInst
*Create(Value
*Func
,
898 RandomAccessIterator ArgBegin
,
899 RandomAccessIterator ArgEnd
,
900 const Twine
&NameStr
= "",
901 Instruction
*InsertBefore
= 0) {
902 return new(unsigned(ArgEnd
- ArgBegin
+ 1))
903 CallInst(Func
, ArgBegin
, ArgEnd
, NameStr
, InsertBefore
);
905 template<typename RandomAccessIterator
>
906 static CallInst
*Create(Value
*Func
,
907 RandomAccessIterator ArgBegin
,
908 RandomAccessIterator ArgEnd
,
909 const Twine
&NameStr
, BasicBlock
*InsertAtEnd
) {
910 return new(unsigned(ArgEnd
- ArgBegin
+ 1))
911 CallInst(Func
, ArgBegin
, ArgEnd
, NameStr
, InsertAtEnd
);
913 static CallInst
*Create(Value
*F
, Value
*Actual
,
914 const Twine
&NameStr
= "",
915 Instruction
*InsertBefore
= 0) {
916 return new(2) CallInst(F
, Actual
, NameStr
, InsertBefore
);
918 static CallInst
*Create(Value
*F
, Value
*Actual
, const Twine
&NameStr
,
919 BasicBlock
*InsertAtEnd
) {
920 return new(2) CallInst(F
, Actual
, NameStr
, InsertAtEnd
);
922 static CallInst
*Create(Value
*F
, const Twine
&NameStr
= "",
923 Instruction
*InsertBefore
= 0) {
924 return new(1) CallInst(F
, NameStr
, InsertBefore
);
926 static CallInst
*Create(Value
*F
, const Twine
&NameStr
,
927 BasicBlock
*InsertAtEnd
) {
928 return new(1) CallInst(F
, NameStr
, InsertAtEnd
);
930 /// CreateMalloc - Generate the IR for a call to malloc:
931 /// 1. Compute the malloc call's argument as the specified type's size,
932 /// possibly multiplied by the array size if the array size is not
934 /// 2. Call malloc with that argument.
935 /// 3. Bitcast the result of the malloc call to the specified type.
936 static Instruction
*CreateMalloc(Instruction
*InsertBefore
,
937 const Type
*IntPtrTy
, const Type
*AllocTy
,
938 Value
*AllocSize
, Value
*ArraySize
= 0,
939 Function
* MallocF
= 0,
940 const Twine
&Name
= "");
941 static Instruction
*CreateMalloc(BasicBlock
*InsertAtEnd
,
942 const Type
*IntPtrTy
, const Type
*AllocTy
,
943 Value
*AllocSize
, Value
*ArraySize
= 0,
944 Function
* MallocF
= 0,
945 const Twine
&Name
= "");
946 /// CreateFree - Generate the IR for a call to the builtin free function.
947 static Instruction
* CreateFree(Value
* Source
, Instruction
*InsertBefore
);
948 static Instruction
* CreateFree(Value
* Source
, BasicBlock
*InsertAtEnd
);
952 bool isTailCall() const { return getSubclassDataFromInstruction() & 1; }
953 void setTailCall(bool isTC
= true) {
954 setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
958 /// Provide fast operand accessors
959 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value
);
961 /// getNumArgOperands - Return the number of call arguments.
963 unsigned getNumArgOperands() const { return getNumOperands() - 1; }
965 /// getArgOperand/setArgOperand - Return/set the i-th call argument.
967 Value
*getArgOperand(unsigned i
) const { return getOperand(i
); }
968 void setArgOperand(unsigned i
, Value
*v
) { setOperand(i
, v
); }
970 /// getCallingConv/setCallingConv - Get or set the calling convention of this
972 CallingConv::ID
getCallingConv() const {
973 return static_cast<CallingConv::ID
>(getSubclassDataFromInstruction() >> 1);
975 void setCallingConv(CallingConv::ID CC
) {
976 setInstructionSubclassData((getSubclassDataFromInstruction() & 1) |
977 (static_cast<unsigned>(CC
) << 1));
980 /// getAttributes - Return the parameter attributes for this call.
982 const AttrListPtr
&getAttributes() const { return AttributeList
; }
984 /// setAttributes - Set the parameter attributes for this call.
986 void setAttributes(const AttrListPtr
&Attrs
) { AttributeList
= Attrs
; }
988 /// addAttribute - adds the attribute to the list of attributes.
989 void addAttribute(unsigned i
, Attributes attr
);
991 /// removeAttribute - removes the attribute from the list of attributes.
992 void removeAttribute(unsigned i
, Attributes attr
);
994 /// @brief Determine whether the call or the callee has the given attribute.
995 bool paramHasAttr(unsigned i
, Attributes attr
) const;
997 /// @brief Extract the alignment for a call or parameter (0=unknown).
998 unsigned getParamAlignment(unsigned i
) const {
999 return AttributeList
.getParamAlignment(i
);
1002 /// @brief Return true if the call should not be inlined.
1003 bool isNoInline() const { return paramHasAttr(~0, Attribute::NoInline
); }
1004 void setIsNoInline(bool Value
= true) {
1005 if (Value
) addAttribute(~0, Attribute::NoInline
);
1006 else removeAttribute(~0, Attribute::NoInline
);
1009 /// @brief Determine if the call does not access memory.
1010 bool doesNotAccessMemory() const {
1011 return paramHasAttr(~0, Attribute::ReadNone
);
1013 void setDoesNotAccessMemory(bool NotAccessMemory
= true) {
1014 if (NotAccessMemory
) addAttribute(~0, Attribute::ReadNone
);
1015 else removeAttribute(~0, Attribute::ReadNone
);
1018 /// @brief Determine if the call does not access or only reads memory.
1019 bool onlyReadsMemory() const {
1020 return doesNotAccessMemory() || paramHasAttr(~0, Attribute::ReadOnly
);
1022 void setOnlyReadsMemory(bool OnlyReadsMemory
= true) {
1023 if (OnlyReadsMemory
) addAttribute(~0, Attribute::ReadOnly
);
1024 else removeAttribute(~0, Attribute::ReadOnly
| Attribute::ReadNone
);
1027 /// @brief Determine if the call cannot return.
1028 bool doesNotReturn() const { return paramHasAttr(~0, Attribute::NoReturn
); }
1029 void setDoesNotReturn(bool DoesNotReturn
= true) {
1030 if (DoesNotReturn
) addAttribute(~0, Attribute::NoReturn
);
1031 else removeAttribute(~0, Attribute::NoReturn
);
1034 /// @brief Determine if the call cannot unwind.
1035 bool doesNotThrow() const { return paramHasAttr(~0, Attribute::NoUnwind
); }
1036 void setDoesNotThrow(bool DoesNotThrow
= true) {
1037 if (DoesNotThrow
) addAttribute(~0, Attribute::NoUnwind
);
1038 else removeAttribute(~0, Attribute::NoUnwind
);
1041 /// @brief Determine if the call returns a structure through first
1042 /// pointer argument.
1043 bool hasStructRetAttr() const {
1044 // Be friendly and also check the callee.
1045 return paramHasAttr(1, Attribute::StructRet
);
1048 /// @brief Determine if any call argument is an aggregate passed by value.
1049 bool hasByValArgument() const {
1050 return AttributeList
.hasAttrSomewhere(Attribute::ByVal
);
1053 /// getCalledFunction - Return the function called, or null if this is an
1054 /// indirect function invocation.
1056 Function
*getCalledFunction() const {
1057 return dyn_cast
<Function
>(Op
<-1>());
1060 /// getCalledValue - Get a pointer to the function that is invoked by this
1062 const Value
*getCalledValue() const { return Op
<-1>(); }
1063 Value
*getCalledValue() { return Op
<-1>(); }
1065 /// setCalledFunction - Set the function called.
1066 void setCalledFunction(Value
* Fn
) {
1070 /// isInlineAsm - Check if this call is an inline asm statement.
1071 bool isInlineAsm() const {
1072 return isa
<InlineAsm
>(Op
<-1>());
1075 // Methods for support type inquiry through isa, cast, and dyn_cast:
1076 static inline bool classof(const CallInst
*) { return true; }
1077 static inline bool classof(const Instruction
*I
) {
1078 return I
->getOpcode() == Instruction::Call
;
1080 static inline bool classof(const Value
*V
) {
1081 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
1084 // Shadow Instruction::setInstructionSubclassData with a private forwarding
1085 // method so that subclasses cannot accidentally use it.
1086 void setInstructionSubclassData(unsigned short D
) {
1087 Instruction::setInstructionSubclassData(D
);
1092 struct OperandTraits
<CallInst
> : public VariadicOperandTraits
<CallInst
, 1> {
1095 template<typename RandomAccessIterator
>
1096 CallInst::CallInst(Value
*Func
,
1097 RandomAccessIterator ArgBegin
, RandomAccessIterator ArgEnd
,
1098 const Twine
&NameStr
, BasicBlock
*InsertAtEnd
)
1099 : Instruction(cast
<FunctionType
>(cast
<PointerType
>(Func
->getType())
1100 ->getElementType())->getReturnType(),
1102 OperandTraits
<CallInst
>::op_end(this) - (ArgEnd
- ArgBegin
+ 1),
1103 unsigned(ArgEnd
- ArgBegin
+ 1), InsertAtEnd
) {
1104 init(Func
, ArgBegin
, ArgEnd
, NameStr
,
1105 typename
std::iterator_traits
<RandomAccessIterator
>
1106 ::iterator_category());
1109 template<typename RandomAccessIterator
>
1110 CallInst::CallInst(Value
*Func
,
1111 RandomAccessIterator ArgBegin
, RandomAccessIterator ArgEnd
,
1112 const Twine
&NameStr
, Instruction
*InsertBefore
)
1113 : Instruction(cast
<FunctionType
>(cast
<PointerType
>(Func
->getType())
1114 ->getElementType())->getReturnType(),
1116 OperandTraits
<CallInst
>::op_end(this) - (ArgEnd
- ArgBegin
+ 1),
1117 unsigned(ArgEnd
- ArgBegin
+ 1), InsertBefore
) {
1118 init(Func
, ArgBegin
, ArgEnd
, NameStr
,
1119 typename
std::iterator_traits
<RandomAccessIterator
>
1120 ::iterator_category());
1124 // Note: if you get compile errors about private methods then
1125 // please update your code to use the high-level operand
1126 // interfaces. See line 943 above.
1127 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CallInst
, Value
)
1129 //===----------------------------------------------------------------------===//
1131 //===----------------------------------------------------------------------===//
1133 /// SelectInst - This class represents the LLVM 'select' instruction.
1135 class SelectInst
: public Instruction
{
1136 void init(Value
*C
, Value
*S1
, Value
*S2
) {
1137 assert(!areInvalidOperands(C
, S1
, S2
) && "Invalid operands for select");
1143 SelectInst(Value
*C
, Value
*S1
, Value
*S2
, const Twine
&NameStr
,
1144 Instruction
*InsertBefore
)
1145 : Instruction(S1
->getType(), Instruction::Select
,
1146 &Op
<0>(), 3, InsertBefore
) {
1150 SelectInst(Value
*C
, Value
*S1
, Value
*S2
, const Twine
&NameStr
,
1151 BasicBlock
*InsertAtEnd
)
1152 : Instruction(S1
->getType(), Instruction::Select
,
1153 &Op
<0>(), 3, InsertAtEnd
) {
1158 virtual SelectInst
*clone_impl() const;
1160 static SelectInst
*Create(Value
*C
, Value
*S1
, Value
*S2
,
1161 const Twine
&NameStr
= "",
1162 Instruction
*InsertBefore
= 0) {
1163 return new(3) SelectInst(C
, S1
, S2
, NameStr
, InsertBefore
);
1165 static SelectInst
*Create(Value
*C
, Value
*S1
, Value
*S2
,
1166 const Twine
&NameStr
,
1167 BasicBlock
*InsertAtEnd
) {
1168 return new(3) SelectInst(C
, S1
, S2
, NameStr
, InsertAtEnd
);
1171 const Value
*getCondition() const { return Op
<0>(); }
1172 const Value
*getTrueValue() const { return Op
<1>(); }
1173 const Value
*getFalseValue() const { return Op
<2>(); }
1174 Value
*getCondition() { return Op
<0>(); }
1175 Value
*getTrueValue() { return Op
<1>(); }
1176 Value
*getFalseValue() { return Op
<2>(); }
1178 /// areInvalidOperands - Return a string if the specified operands are invalid
1179 /// for a select operation, otherwise return null.
1180 static const char *areInvalidOperands(Value
*Cond
, Value
*True
, Value
*False
);
1182 /// Transparently provide more efficient getOperand methods.
1183 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value
);
1185 OtherOps
getOpcode() const {
1186 return static_cast<OtherOps
>(Instruction::getOpcode());
1189 // Methods for support type inquiry through isa, cast, and dyn_cast:
1190 static inline bool classof(const SelectInst
*) { return true; }
1191 static inline bool classof(const Instruction
*I
) {
1192 return I
->getOpcode() == Instruction::Select
;
1194 static inline bool classof(const Value
*V
) {
1195 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
1200 struct OperandTraits
<SelectInst
> : public FixedNumOperandTraits
<SelectInst
, 3> {
1203 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(SelectInst
, Value
)
1205 //===----------------------------------------------------------------------===//
1207 //===----------------------------------------------------------------------===//
1209 /// VAArgInst - This class represents the va_arg llvm instruction, which returns
1210 /// an argument of the specified type given a va_list and increments that list
1212 class VAArgInst
: public UnaryInstruction
{
1214 virtual VAArgInst
*clone_impl() const;
1217 VAArgInst(Value
*List
, const Type
*Ty
, const Twine
&NameStr
= "",
1218 Instruction
*InsertBefore
= 0)
1219 : UnaryInstruction(Ty
, VAArg
, List
, InsertBefore
) {
1222 VAArgInst(Value
*List
, const Type
*Ty
, const Twine
&NameStr
,
1223 BasicBlock
*InsertAtEnd
)
1224 : UnaryInstruction(Ty
, VAArg
, List
, InsertAtEnd
) {
1228 Value
*getPointerOperand() { return getOperand(0); }
1229 const Value
*getPointerOperand() const { return getOperand(0); }
1230 static unsigned getPointerOperandIndex() { return 0U; }
1232 // Methods for support type inquiry through isa, cast, and dyn_cast:
1233 static inline bool classof(const VAArgInst
*) { return true; }
1234 static inline bool classof(const Instruction
*I
) {
1235 return I
->getOpcode() == VAArg
;
1237 static inline bool classof(const Value
*V
) {
1238 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
1242 //===----------------------------------------------------------------------===//
1243 // ExtractElementInst Class
1244 //===----------------------------------------------------------------------===//
1246 /// ExtractElementInst - This instruction extracts a single (scalar)
1247 /// element from a VectorType value
1249 class ExtractElementInst
: public Instruction
{
1250 ExtractElementInst(Value
*Vec
, Value
*Idx
, const Twine
&NameStr
= "",
1251 Instruction
*InsertBefore
= 0);
1252 ExtractElementInst(Value
*Vec
, Value
*Idx
, const Twine
&NameStr
,
1253 BasicBlock
*InsertAtEnd
);
1255 virtual ExtractElementInst
*clone_impl() const;
1258 static ExtractElementInst
*Create(Value
*Vec
, Value
*Idx
,
1259 const Twine
&NameStr
= "",
1260 Instruction
*InsertBefore
= 0) {
1261 return new(2) ExtractElementInst(Vec
, Idx
, NameStr
, InsertBefore
);
1263 static ExtractElementInst
*Create(Value
*Vec
, Value
*Idx
,
1264 const Twine
&NameStr
,
1265 BasicBlock
*InsertAtEnd
) {
1266 return new(2) ExtractElementInst(Vec
, Idx
, NameStr
, InsertAtEnd
);
1269 /// isValidOperands - Return true if an extractelement instruction can be
1270 /// formed with the specified operands.
1271 static bool isValidOperands(const Value
*Vec
, const Value
*Idx
);
1273 Value
*getVectorOperand() { return Op
<0>(); }
1274 Value
*getIndexOperand() { return Op
<1>(); }
1275 const Value
*getVectorOperand() const { return Op
<0>(); }
1276 const Value
*getIndexOperand() const { return Op
<1>(); }
1278 const VectorType
*getVectorOperandType() const {
1279 return reinterpret_cast<const VectorType
*>(getVectorOperand()->getType());
1283 /// Transparently provide more efficient getOperand methods.
1284 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value
);
1286 // Methods for support type inquiry through isa, cast, and dyn_cast:
1287 static inline bool classof(const ExtractElementInst
*) { return true; }
1288 static inline bool classof(const Instruction
*I
) {
1289 return I
->getOpcode() == Instruction::ExtractElement
;
1291 static inline bool classof(const Value
*V
) {
1292 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
1297 struct OperandTraits
<ExtractElementInst
> :
1298 public FixedNumOperandTraits
<ExtractElementInst
, 2> {
1301 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ExtractElementInst
, Value
)
1303 //===----------------------------------------------------------------------===//
1304 // InsertElementInst Class
1305 //===----------------------------------------------------------------------===//
1307 /// InsertElementInst - This instruction inserts a single (scalar)
1308 /// element into a VectorType value
1310 class InsertElementInst
: public Instruction
{
1311 InsertElementInst(Value
*Vec
, Value
*NewElt
, Value
*Idx
,
1312 const Twine
&NameStr
= "",
1313 Instruction
*InsertBefore
= 0);
1314 InsertElementInst(Value
*Vec
, Value
*NewElt
, Value
*Idx
,
1315 const Twine
&NameStr
, BasicBlock
*InsertAtEnd
);
1317 virtual InsertElementInst
*clone_impl() const;
1320 static InsertElementInst
*Create(Value
*Vec
, Value
*NewElt
, Value
*Idx
,
1321 const Twine
&NameStr
= "",
1322 Instruction
*InsertBefore
= 0) {
1323 return new(3) InsertElementInst(Vec
, NewElt
, Idx
, NameStr
, InsertBefore
);
1325 static InsertElementInst
*Create(Value
*Vec
, Value
*NewElt
, Value
*Idx
,
1326 const Twine
&NameStr
,
1327 BasicBlock
*InsertAtEnd
) {
1328 return new(3) InsertElementInst(Vec
, NewElt
, Idx
, NameStr
, InsertAtEnd
);
1331 /// isValidOperands - Return true if an insertelement instruction can be
1332 /// formed with the specified operands.
1333 static bool isValidOperands(const Value
*Vec
, const Value
*NewElt
,
1336 /// getType - Overload to return most specific vector type.
1338 const VectorType
*getType() const {
1339 return reinterpret_cast<const VectorType
*>(Instruction::getType());
1342 /// Transparently provide more efficient getOperand methods.
1343 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value
);
1345 // Methods for support type inquiry through isa, cast, and dyn_cast:
1346 static inline bool classof(const InsertElementInst
*) { return true; }
1347 static inline bool classof(const Instruction
*I
) {
1348 return I
->getOpcode() == Instruction::InsertElement
;
1350 static inline bool classof(const Value
*V
) {
1351 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
1356 struct OperandTraits
<InsertElementInst
> :
1357 public FixedNumOperandTraits
<InsertElementInst
, 3> {
1360 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertElementInst
, Value
)
1362 //===----------------------------------------------------------------------===//
1363 // ShuffleVectorInst Class
1364 //===----------------------------------------------------------------------===//
1366 /// ShuffleVectorInst - This instruction constructs a fixed permutation of two
1369 class ShuffleVectorInst
: public Instruction
{
1371 virtual ShuffleVectorInst
*clone_impl() const;
1374 // allocate space for exactly three operands
1375 void *operator new(size_t s
) {
1376 return User::operator new(s
, 3);
1378 ShuffleVectorInst(Value
*V1
, Value
*V2
, Value
*Mask
,
1379 const Twine
&NameStr
= "",
1380 Instruction
*InsertBefor
= 0);
1381 ShuffleVectorInst(Value
*V1
, Value
*V2
, Value
*Mask
,
1382 const Twine
&NameStr
, BasicBlock
*InsertAtEnd
);
1384 /// isValidOperands - Return true if a shufflevector instruction can be
1385 /// formed with the specified operands.
1386 static bool isValidOperands(const Value
*V1
, const Value
*V2
,
1389 /// getType - Overload to return most specific vector type.
1391 const VectorType
*getType() const {
1392 return reinterpret_cast<const VectorType
*>(Instruction::getType());
1395 /// Transparently provide more efficient getOperand methods.
1396 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value
);
1398 /// getMaskValue - Return the index from the shuffle mask for the specified
1399 /// output result. This is either -1 if the element is undef or a number less
1400 /// than 2*numelements.
1401 int getMaskValue(unsigned i
) const;
1403 // Methods for support type inquiry through isa, cast, and dyn_cast:
1404 static inline bool classof(const ShuffleVectorInst
*) { return true; }
1405 static inline bool classof(const Instruction
*I
) {
1406 return I
->getOpcode() == Instruction::ShuffleVector
;
1408 static inline bool classof(const Value
*V
) {
1409 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
1414 struct OperandTraits
<ShuffleVectorInst
> :
1415 public FixedNumOperandTraits
<ShuffleVectorInst
, 3> {
1418 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ShuffleVectorInst
, Value
)
1420 //===----------------------------------------------------------------------===//
1421 // ExtractValueInst Class
1422 //===----------------------------------------------------------------------===//
1424 /// ExtractValueInst - This instruction extracts a struct member or array
1425 /// element value from an aggregate value.
1427 class ExtractValueInst
: public UnaryInstruction
{
1428 SmallVector
<unsigned, 4> Indices
;
1430 ExtractValueInst(const ExtractValueInst
&EVI
);
1431 void init(const unsigned *Idx
, unsigned NumIdx
,
1432 const Twine
&NameStr
);
1433 void init(unsigned Idx
, const Twine
&NameStr
);
1435 template<typename RandomAccessIterator
>
1436 void init(RandomAccessIterator IdxBegin
,
1437 RandomAccessIterator IdxEnd
,
1438 const Twine
&NameStr
,
1439 // This argument ensures that we have an iterator we can
1440 // do arithmetic on in constant time
1441 std::random_access_iterator_tag
) {
1442 unsigned NumIdx
= static_cast<unsigned>(std::distance(IdxBegin
, IdxEnd
));
1444 // There's no fundamental reason why we require at least one index
1445 // (other than weirdness with &*IdxBegin being invalid; see
1446 // getelementptr's init routine for example). But there's no
1447 // present need to support it.
1448 assert(NumIdx
> 0 && "ExtractValueInst must have at least one index");
1450 // This requires that the iterator points to contiguous memory.
1451 init(&*IdxBegin
, NumIdx
, NameStr
); // FIXME: for the general case
1452 // we have to build an array here
1455 /// getIndexedType - Returns the type of the element that would be extracted
1456 /// with an extractvalue instruction with the specified parameters.
1458 /// Null is returned if the indices are invalid for the specified type.
1460 /// FIXME: Use ArrayRef
1461 static Type
*getIndexedType(const Type
*Agg
,
1462 const unsigned *Idx
, unsigned NumIdx
);
1464 template<typename RandomAccessIterator
>
1465 static Type
*getIndexedType(const Type
*Ptr
,
1466 RandomAccessIterator IdxBegin
,
1467 RandomAccessIterator IdxEnd
,
1468 // This argument ensures that we
1469 // have an iterator we can do
1470 // arithmetic on in constant time
1471 std::random_access_iterator_tag
) {
1472 unsigned NumIdx
= static_cast<unsigned>(std::distance(IdxBegin
, IdxEnd
));
1475 // This requires that the iterator points to contiguous memory.
1476 return getIndexedType(Ptr
, &*IdxBegin
, NumIdx
);
1478 return getIndexedType(Ptr
, (const unsigned *)0, NumIdx
);
1481 /// Constructors - Create a extractvalue instruction with a base aggregate
1482 /// value and a list of indices. The first ctor can optionally insert before
1483 /// an existing instruction, the second appends the new instruction to the
1484 /// specified BasicBlock.
1485 template<typename RandomAccessIterator
>
1486 inline ExtractValueInst(Value
*Agg
,
1487 RandomAccessIterator IdxBegin
,
1488 RandomAccessIterator IdxEnd
,
1489 const Twine
&NameStr
,
1490 Instruction
*InsertBefore
);
1491 template<typename RandomAccessIterator
>
1492 inline ExtractValueInst(Value
*Agg
,
1493 RandomAccessIterator IdxBegin
,
1494 RandomAccessIterator IdxEnd
,
1495 const Twine
&NameStr
, BasicBlock
*InsertAtEnd
);
1497 // allocate space for exactly one operand
1498 void *operator new(size_t s
) {
1499 return User::operator new(s
, 1);
1502 virtual ExtractValueInst
*clone_impl() const;
1505 template<typename RandomAccessIterator
>
1506 static ExtractValueInst
*Create(Value
*Agg
,
1507 RandomAccessIterator IdxBegin
,
1508 RandomAccessIterator IdxEnd
,
1509 const Twine
&NameStr
= "",
1510 Instruction
*InsertBefore
= 0) {
1512 ExtractValueInst(Agg
, IdxBegin
, IdxEnd
, NameStr
, InsertBefore
);
1514 template<typename RandomAccessIterator
>
1515 static ExtractValueInst
*Create(Value
*Agg
,
1516 RandomAccessIterator IdxBegin
,
1517 RandomAccessIterator IdxEnd
,
1518 const Twine
&NameStr
,
1519 BasicBlock
*InsertAtEnd
) {
1520 return new ExtractValueInst(Agg
, IdxBegin
, IdxEnd
, NameStr
, InsertAtEnd
);
1523 /// Constructors - These two creators are convenience methods because one
1524 /// index extractvalue instructions are much more common than those with
1526 static ExtractValueInst
*Create(Value
*Agg
, unsigned Idx
,
1527 const Twine
&NameStr
= "",
1528 Instruction
*InsertBefore
= 0) {
1529 unsigned Idxs
[1] = { Idx
};
1530 return new ExtractValueInst(Agg
, Idxs
, Idxs
+ 1, NameStr
, InsertBefore
);
1532 static ExtractValueInst
*Create(Value
*Agg
, unsigned Idx
,
1533 const Twine
&NameStr
,
1534 BasicBlock
*InsertAtEnd
) {
1535 unsigned Idxs
[1] = { Idx
};
1536 return new ExtractValueInst(Agg
, Idxs
, Idxs
+ 1, NameStr
, InsertAtEnd
);
1539 /// getIndexedType - Returns the type of the element that would be extracted
1540 /// with an extractvalue instruction with the specified parameters.
1542 /// Null is returned if the indices are invalid for the specified type.
1544 /// FIXME: Remove the templates and just use ArrayRef.
1545 template<typename RandomAccessIterator
>
1546 static Type
*getIndexedType(const Type
*Ptr
,
1547 RandomAccessIterator IdxBegin
,
1548 RandomAccessIterator IdxEnd
) {
1549 return getIndexedType(Ptr
, IdxBegin
, IdxEnd
,
1550 typename
std::iterator_traits
<RandomAccessIterator
>::
1551 iterator_category());
1553 static Type
*getIndexedType(const Type
*Ptr
, unsigned Idx
);
1555 typedef const unsigned* idx_iterator
;
1556 inline idx_iterator
idx_begin() const { return Indices
.begin(); }
1557 inline idx_iterator
idx_end() const { return Indices
.end(); }
1559 Value
*getAggregateOperand() {
1560 return getOperand(0);
1562 const Value
*getAggregateOperand() const {
1563 return getOperand(0);
1565 static unsigned getAggregateOperandIndex() {
1566 return 0U; // get index for modifying correct operand
1569 unsigned getNumIndices() const { // Note: always non-negative
1570 return (unsigned)Indices
.size();
1573 bool hasIndices() const {
1577 // Methods for support type inquiry through isa, cast, and dyn_cast:
1578 static inline bool classof(const ExtractValueInst
*) { return true; }
1579 static inline bool classof(const Instruction
*I
) {
1580 return I
->getOpcode() == Instruction::ExtractValue
;
1582 static inline bool classof(const Value
*V
) {
1583 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
1587 template<typename RandomAccessIterator
>
1588 ExtractValueInst::ExtractValueInst(Value
*Agg
,
1589 RandomAccessIterator IdxBegin
,
1590 RandomAccessIterator IdxEnd
,
1591 const Twine
&NameStr
,
1592 Instruction
*InsertBefore
)
1593 : UnaryInstruction(checkGEPType(getIndexedType(Agg
->getType(),
1595 ExtractValue
, Agg
, InsertBefore
) {
1596 init(IdxBegin
, IdxEnd
, NameStr
,
1597 typename
std::iterator_traits
<RandomAccessIterator
>
1598 ::iterator_category());
1600 template<typename RandomAccessIterator
>
1601 ExtractValueInst::ExtractValueInst(Value
*Agg
,
1602 RandomAccessIterator IdxBegin
,
1603 RandomAccessIterator IdxEnd
,
1604 const Twine
&NameStr
,
1605 BasicBlock
*InsertAtEnd
)
1606 : UnaryInstruction(checkGEPType(getIndexedType(Agg
->getType(),
1608 ExtractValue
, Agg
, InsertAtEnd
) {
1609 init(IdxBegin
, IdxEnd
, NameStr
,
1610 typename
std::iterator_traits
<RandomAccessIterator
>
1611 ::iterator_category());
1615 //===----------------------------------------------------------------------===//
1616 // InsertValueInst Class
1617 //===----------------------------------------------------------------------===//
1619 /// InsertValueInst - This instruction inserts a struct field of array element
1620 /// value into an aggregate value.
1622 class InsertValueInst
: public Instruction
{
1623 SmallVector
<unsigned, 4> Indices
;
1625 void *operator new(size_t, unsigned); // Do not implement
1626 InsertValueInst(const InsertValueInst
&IVI
);
1627 void init(Value
*Agg
, Value
*Val
, const unsigned *Idx
, unsigned NumIdx
,
1628 const Twine
&NameStr
);
1629 void init(Value
*Agg
, Value
*Val
, unsigned Idx
, const Twine
&NameStr
);
1631 template<typename RandomAccessIterator
>
1632 void init(Value
*Agg
, Value
*Val
,
1633 RandomAccessIterator IdxBegin
, RandomAccessIterator IdxEnd
,
1634 const Twine
&NameStr
,
1635 // This argument ensures that we have an iterator we can
1636 // do arithmetic on in constant time
1637 std::random_access_iterator_tag
) {
1638 unsigned NumIdx
= static_cast<unsigned>(std::distance(IdxBegin
, IdxEnd
));
1640 // There's no fundamental reason why we require at least one index
1641 // (other than weirdness with &*IdxBegin being invalid; see
1642 // getelementptr's init routine for example). But there's no
1643 // present need to support it.
1644 assert(NumIdx
> 0 && "InsertValueInst must have at least one index");
1646 // This requires that the iterator points to contiguous memory.
1647 init(Agg
, Val
, &*IdxBegin
, NumIdx
, NameStr
); // FIXME: for the general case
1648 // we have to build an array here
1651 /// Constructors - Create a insertvalue instruction with a base aggregate
1652 /// value, a value to insert, and a list of indices. The first ctor can
1653 /// optionally insert before an existing instruction, the second appends
1654 /// the new instruction to the specified BasicBlock.
1655 template<typename RandomAccessIterator
>
1656 inline InsertValueInst(Value
*Agg
, Value
*Val
,
1657 RandomAccessIterator IdxBegin
,
1658 RandomAccessIterator IdxEnd
,
1659 const Twine
&NameStr
,
1660 Instruction
*InsertBefore
);
1661 template<typename RandomAccessIterator
>
1662 inline InsertValueInst(Value
*Agg
, Value
*Val
,
1663 RandomAccessIterator IdxBegin
,
1664 RandomAccessIterator IdxEnd
,
1665 const Twine
&NameStr
, BasicBlock
*InsertAtEnd
);
1667 /// Constructors - These two constructors are convenience methods because one
1668 /// and two index insertvalue instructions are so common.
1669 InsertValueInst(Value
*Agg
, Value
*Val
,
1670 unsigned Idx
, const Twine
&NameStr
= "",
1671 Instruction
*InsertBefore
= 0);
1672 InsertValueInst(Value
*Agg
, Value
*Val
, unsigned Idx
,
1673 const Twine
&NameStr
, BasicBlock
*InsertAtEnd
);
1675 virtual InsertValueInst
*clone_impl() const;
1677 // allocate space for exactly two operands
1678 void *operator new(size_t s
) {
1679 return User::operator new(s
, 2);
1682 template<typename RandomAccessIterator
>
1683 static InsertValueInst
*Create(Value
*Agg
, Value
*Val
,
1684 RandomAccessIterator IdxBegin
,
1685 RandomAccessIterator IdxEnd
,
1686 const Twine
&NameStr
= "",
1687 Instruction
*InsertBefore
= 0) {
1688 return new InsertValueInst(Agg
, Val
, IdxBegin
, IdxEnd
,
1689 NameStr
, InsertBefore
);
1691 template<typename RandomAccessIterator
>
1692 static InsertValueInst
*Create(Value
*Agg
, Value
*Val
,
1693 RandomAccessIterator IdxBegin
,
1694 RandomAccessIterator IdxEnd
,
1695 const Twine
&NameStr
,
1696 BasicBlock
*InsertAtEnd
) {
1697 return new InsertValueInst(Agg
, Val
, IdxBegin
, IdxEnd
,
1698 NameStr
, InsertAtEnd
);
1701 /// Constructors - These two creators are convenience methods because one
1702 /// index insertvalue instructions are much more common than those with
1704 static InsertValueInst
*Create(Value
*Agg
, Value
*Val
, unsigned Idx
,
1705 const Twine
&NameStr
= "",
1706 Instruction
*InsertBefore
= 0) {
1707 return new InsertValueInst(Agg
, Val
, Idx
, NameStr
, InsertBefore
);
1709 static InsertValueInst
*Create(Value
*Agg
, Value
*Val
, unsigned Idx
,
1710 const Twine
&NameStr
,
1711 BasicBlock
*InsertAtEnd
) {
1712 return new InsertValueInst(Agg
, Val
, Idx
, NameStr
, InsertAtEnd
);
1715 /// Transparently provide more efficient getOperand methods.
1716 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value
);
1718 typedef const unsigned* idx_iterator
;
1719 inline idx_iterator
idx_begin() const { return Indices
.begin(); }
1720 inline idx_iterator
idx_end() const { return Indices
.end(); }
1722 Value
*getAggregateOperand() {
1723 return getOperand(0);
1725 const Value
*getAggregateOperand() const {
1726 return getOperand(0);
1728 static unsigned getAggregateOperandIndex() {
1729 return 0U; // get index for modifying correct operand
1732 Value
*getInsertedValueOperand() {
1733 return getOperand(1);
1735 const Value
*getInsertedValueOperand() const {
1736 return getOperand(1);
1738 static unsigned getInsertedValueOperandIndex() {
1739 return 1U; // get index for modifying correct operand
1742 unsigned getNumIndices() const { // Note: always non-negative
1743 return (unsigned)Indices
.size();
1746 bool hasIndices() const {
1750 // Methods for support type inquiry through isa, cast, and dyn_cast:
1751 static inline bool classof(const InsertValueInst
*) { return true; }
1752 static inline bool classof(const Instruction
*I
) {
1753 return I
->getOpcode() == Instruction::InsertValue
;
1755 static inline bool classof(const Value
*V
) {
1756 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
1761 struct OperandTraits
<InsertValueInst
> :
1762 public FixedNumOperandTraits
<InsertValueInst
, 2> {
1765 template<typename RandomAccessIterator
>
1766 InsertValueInst::InsertValueInst(Value
*Agg
,
1768 RandomAccessIterator IdxBegin
,
1769 RandomAccessIterator IdxEnd
,
1770 const Twine
&NameStr
,
1771 Instruction
*InsertBefore
)
1772 : Instruction(Agg
->getType(), InsertValue
,
1773 OperandTraits
<InsertValueInst
>::op_begin(this),
1775 init(Agg
, Val
, IdxBegin
, IdxEnd
, NameStr
,
1776 typename
std::iterator_traits
<RandomAccessIterator
>
1777 ::iterator_category());
1779 template<typename RandomAccessIterator
>
1780 InsertValueInst::InsertValueInst(Value
*Agg
,
1782 RandomAccessIterator IdxBegin
,
1783 RandomAccessIterator IdxEnd
,
1784 const Twine
&NameStr
,
1785 BasicBlock
*InsertAtEnd
)
1786 : Instruction(Agg
->getType(), InsertValue
,
1787 OperandTraits
<InsertValueInst
>::op_begin(this),
1789 init(Agg
, Val
, IdxBegin
, IdxEnd
, NameStr
,
1790 typename
std::iterator_traits
<RandomAccessIterator
>
1791 ::iterator_category());
1794 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertValueInst
, Value
)
1796 //===----------------------------------------------------------------------===//
1798 //===----------------------------------------------------------------------===//
1800 // PHINode - The PHINode class is used to represent the magical mystical PHI
1801 // node, that can not exist in nature, but can be synthesized in a computer
1802 // scientist's overactive imagination.
1804 class PHINode
: public Instruction
{
1805 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
1806 /// ReservedSpace - The number of operands actually allocated. NumOperands is
1807 /// the number actually in use.
1808 unsigned ReservedSpace
;
1809 PHINode(const PHINode
&PN
);
1810 // allocate space for exactly zero operands
1811 void *operator new(size_t s
) {
1812 return User::operator new(s
, 0);
1814 explicit PHINode(const Type
*Ty
, unsigned NumReservedValues
,
1815 const Twine
&NameStr
= "", Instruction
*InsertBefore
= 0)
1816 : Instruction(Ty
, Instruction::PHI
, 0, 0, InsertBefore
),
1817 ReservedSpace(NumReservedValues
) {
1819 OperandList
= allocHungoffUses(ReservedSpace
);
1822 PHINode(const Type
*Ty
, unsigned NumReservedValues
, const Twine
&NameStr
,
1823 BasicBlock
*InsertAtEnd
)
1824 : Instruction(Ty
, Instruction::PHI
, 0, 0, InsertAtEnd
),
1825 ReservedSpace(NumReservedValues
) {
1827 OperandList
= allocHungoffUses(ReservedSpace
);
1830 // allocHungoffUses - this is more complicated than the generic
1831 // User::allocHungoffUses, because we have to allocate Uses for the incoming
1832 // values and pointers to the incoming blocks, all in one allocation.
1833 Use
*allocHungoffUses(unsigned) const;
1835 virtual PHINode
*clone_impl() const;
1837 /// Constructors - NumReservedValues is a hint for the number of incoming
1838 /// edges that this phi node will have (use 0 if you really have no idea).
1839 static PHINode
*Create(const Type
*Ty
, unsigned NumReservedValues
,
1840 const Twine
&NameStr
= "",
1841 Instruction
*InsertBefore
= 0) {
1842 return new PHINode(Ty
, NumReservedValues
, NameStr
, InsertBefore
);
1844 static PHINode
*Create(const Type
*Ty
, unsigned NumReservedValues
,
1845 const Twine
&NameStr
, BasicBlock
*InsertAtEnd
) {
1846 return new PHINode(Ty
, NumReservedValues
, NameStr
, InsertAtEnd
);
1850 /// Provide fast operand accessors
1851 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value
);
1853 // Block iterator interface. This provides access to the list of incoming
1854 // basic blocks, which parallels the list of incoming values.
1856 typedef BasicBlock
**block_iterator
;
1857 typedef BasicBlock
* const *const_block_iterator
;
1859 block_iterator
block_begin() {
1861 reinterpret_cast<Use::UserRef
*>(op_begin() + ReservedSpace
);
1862 return reinterpret_cast<block_iterator
>(ref
+ 1);
1865 const_block_iterator
block_begin() const {
1866 const Use::UserRef
*ref
=
1867 reinterpret_cast<const Use::UserRef
*>(op_begin() + ReservedSpace
);
1868 return reinterpret_cast<const_block_iterator
>(ref
+ 1);
1871 block_iterator
block_end() {
1872 return block_begin() + getNumOperands();
1875 const_block_iterator
block_end() const {
1876 return block_begin() + getNumOperands();
1879 /// getNumIncomingValues - Return the number of incoming edges
1881 unsigned getNumIncomingValues() const { return getNumOperands(); }
1883 /// getIncomingValue - Return incoming value number x
1885 Value
*getIncomingValue(unsigned i
) const {
1886 return getOperand(i
);
1888 void setIncomingValue(unsigned i
, Value
*V
) {
1891 static unsigned getOperandNumForIncomingValue(unsigned i
) {
1894 static unsigned getIncomingValueNumForOperand(unsigned i
) {
1898 /// getIncomingBlock - Return incoming basic block number @p i.
1900 BasicBlock
*getIncomingBlock(unsigned i
) const {
1901 return block_begin()[i
];
1904 /// getIncomingBlock - Return incoming basic block corresponding
1905 /// to an operand of the PHI.
1907 BasicBlock
*getIncomingBlock(const Use
&U
) const {
1908 assert(this == U
.getUser() && "Iterator doesn't point to PHI's Uses?");
1909 return getIncomingBlock(unsigned(&U
- op_begin()));
1912 /// getIncomingBlock - Return incoming basic block corresponding
1913 /// to value use iterator.
1915 template <typename U
>
1916 BasicBlock
*getIncomingBlock(value_use_iterator
<U
> I
) const {
1917 return getIncomingBlock(I
.getUse());
1920 void setIncomingBlock(unsigned i
, BasicBlock
*BB
) {
1921 block_begin()[i
] = BB
;
1924 /// addIncoming - Add an incoming value to the end of the PHI list
1926 void addIncoming(Value
*V
, BasicBlock
*BB
) {
1927 assert(V
&& "PHI node got a null value!");
1928 assert(BB
&& "PHI node got a null basic block!");
1929 assert(getType() == V
->getType() &&
1930 "All operands to PHI node must be the same type as the PHI node!");
1931 if (NumOperands
== ReservedSpace
)
1932 growOperands(); // Get more space!
1933 // Initialize some new operands.
1935 setIncomingValue(NumOperands
- 1, V
);
1936 setIncomingBlock(NumOperands
- 1, BB
);
1939 /// removeIncomingValue - Remove an incoming value. This is useful if a
1940 /// predecessor basic block is deleted. The value removed is returned.
1942 /// If the last incoming value for a PHI node is removed (and DeletePHIIfEmpty
1943 /// is true), the PHI node is destroyed and any uses of it are replaced with
1944 /// dummy values. The only time there should be zero incoming values to a PHI
1945 /// node is when the block is dead, so this strategy is sound.
1947 Value
*removeIncomingValue(unsigned Idx
, bool DeletePHIIfEmpty
= true);
1949 Value
*removeIncomingValue(const BasicBlock
*BB
, bool DeletePHIIfEmpty
=true) {
1950 int Idx
= getBasicBlockIndex(BB
);
1951 assert(Idx
>= 0 && "Invalid basic block argument to remove!");
1952 return removeIncomingValue(Idx
, DeletePHIIfEmpty
);
1955 /// getBasicBlockIndex - Return the first index of the specified basic
1956 /// block in the value list for this PHI. Returns -1 if no instance.
1958 int getBasicBlockIndex(const BasicBlock
*BB
) const {
1959 for (unsigned i
= 0, e
= getNumOperands(); i
!= e
; ++i
)
1960 if (block_begin()[i
] == BB
)
1965 Value
*getIncomingValueForBlock(const BasicBlock
*BB
) const {
1966 int Idx
= getBasicBlockIndex(BB
);
1967 assert(Idx
>= 0 && "Invalid basic block argument!");
1968 return getIncomingValue(Idx
);
1971 /// hasConstantValue - If the specified PHI node always merges together the
1972 /// same value, return the value, otherwise return null.
1973 Value
*hasConstantValue() const;
1975 /// Methods for support type inquiry through isa, cast, and dyn_cast:
1976 static inline bool classof(const PHINode
*) { return true; }
1977 static inline bool classof(const Instruction
*I
) {
1978 return I
->getOpcode() == Instruction::PHI
;
1980 static inline bool classof(const Value
*V
) {
1981 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
1984 void growOperands();
1988 struct OperandTraits
<PHINode
> : public HungoffOperandTraits
<2> {
1991 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(PHINode
, Value
)
1994 //===----------------------------------------------------------------------===//
1996 //===----------------------------------------------------------------------===//
1998 //===---------------------------------------------------------------------------
1999 /// ReturnInst - Return a value (possibly void), from a function. Execution
2000 /// does not continue in this function any longer.
2002 class ReturnInst
: public TerminatorInst
{
2003 ReturnInst(const ReturnInst
&RI
);
2006 // ReturnInst constructors:
2007 // ReturnInst() - 'ret void' instruction
2008 // ReturnInst( null) - 'ret void' instruction
2009 // ReturnInst(Value* X) - 'ret X' instruction
2010 // ReturnInst( null, Inst *I) - 'ret void' instruction, insert before I
2011 // ReturnInst(Value* X, Inst *I) - 'ret X' instruction, insert before I
2012 // ReturnInst( null, BB *B) - 'ret void' instruction, insert @ end of B
2013 // ReturnInst(Value* X, BB *B) - 'ret X' instruction, insert @ end of B
2015 // NOTE: If the Value* passed is of type void then the constructor behaves as
2016 // if it was passed NULL.
2017 explicit ReturnInst(LLVMContext
&C
, Value
*retVal
= 0,
2018 Instruction
*InsertBefore
= 0);
2019 ReturnInst(LLVMContext
&C
, Value
*retVal
, BasicBlock
*InsertAtEnd
);
2020 explicit ReturnInst(LLVMContext
&C
, BasicBlock
*InsertAtEnd
);
2022 virtual ReturnInst
*clone_impl() const;
2024 static ReturnInst
* Create(LLVMContext
&C
, Value
*retVal
= 0,
2025 Instruction
*InsertBefore
= 0) {
2026 return new(!!retVal
) ReturnInst(C
, retVal
, InsertBefore
);
2028 static ReturnInst
* Create(LLVMContext
&C
, Value
*retVal
,
2029 BasicBlock
*InsertAtEnd
) {
2030 return new(!!retVal
) ReturnInst(C
, retVal
, InsertAtEnd
);
2032 static ReturnInst
* Create(LLVMContext
&C
, BasicBlock
*InsertAtEnd
) {
2033 return new(0) ReturnInst(C
, InsertAtEnd
);
2035 virtual ~ReturnInst();
2037 /// Provide fast operand accessors
2038 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value
);
2040 /// Convenience accessor. Returns null if there is no return value.
2041 Value
*getReturnValue() const {
2042 return getNumOperands() != 0 ? getOperand(0) : 0;
2045 unsigned getNumSuccessors() const { return 0; }
2047 // Methods for support type inquiry through isa, cast, and dyn_cast:
2048 static inline bool classof(const ReturnInst
*) { return true; }
2049 static inline bool classof(const Instruction
*I
) {
2050 return (I
->getOpcode() == Instruction::Ret
);
2052 static inline bool classof(const Value
*V
) {
2053 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
2056 virtual BasicBlock
*getSuccessorV(unsigned idx
) const;
2057 virtual unsigned getNumSuccessorsV() const;
2058 virtual void setSuccessorV(unsigned idx
, BasicBlock
*B
);
2062 struct OperandTraits
<ReturnInst
> : public VariadicOperandTraits
<ReturnInst
> {
2065 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ReturnInst
, Value
)
2067 //===----------------------------------------------------------------------===//
2069 //===----------------------------------------------------------------------===//
2071 //===---------------------------------------------------------------------------
2072 /// BranchInst - Conditional or Unconditional Branch instruction.
2074 class BranchInst
: public TerminatorInst
{
2075 /// Ops list - Branches are strange. The operands are ordered:
2076 /// [Cond, FalseDest,] TrueDest. This makes some accessors faster because
2077 /// they don't have to check for cond/uncond branchness. These are mostly
2078 /// accessed relative from op_end().
2079 BranchInst(const BranchInst
&BI
);
2081 // BranchInst constructors (where {B, T, F} are blocks, and C is a condition):
2082 // BranchInst(BB *B) - 'br B'
2083 // BranchInst(BB* T, BB *F, Value *C) - 'br C, T, F'
2084 // BranchInst(BB* B, Inst *I) - 'br B' insert before I
2085 // BranchInst(BB* T, BB *F, Value *C, Inst *I) - 'br C, T, F', insert before I
2086 // BranchInst(BB* B, BB *I) - 'br B' insert at end
2087 // BranchInst(BB* T, BB *F, Value *C, BB *I) - 'br C, T, F', insert at end
2088 explicit BranchInst(BasicBlock
*IfTrue
, Instruction
*InsertBefore
= 0);
2089 BranchInst(BasicBlock
*IfTrue
, BasicBlock
*IfFalse
, Value
*Cond
,
2090 Instruction
*InsertBefore
= 0);
2091 BranchInst(BasicBlock
*IfTrue
, BasicBlock
*InsertAtEnd
);
2092 BranchInst(BasicBlock
*IfTrue
, BasicBlock
*IfFalse
, Value
*Cond
,
2093 BasicBlock
*InsertAtEnd
);
2095 virtual BranchInst
*clone_impl() const;
2097 static BranchInst
*Create(BasicBlock
*IfTrue
, Instruction
*InsertBefore
= 0) {
2098 return new(1) BranchInst(IfTrue
, InsertBefore
);
2100 static BranchInst
*Create(BasicBlock
*IfTrue
, BasicBlock
*IfFalse
,
2101 Value
*Cond
, Instruction
*InsertBefore
= 0) {
2102 return new(3) BranchInst(IfTrue
, IfFalse
, Cond
, InsertBefore
);
2104 static BranchInst
*Create(BasicBlock
*IfTrue
, BasicBlock
*InsertAtEnd
) {
2105 return new(1) BranchInst(IfTrue
, InsertAtEnd
);
2107 static BranchInst
*Create(BasicBlock
*IfTrue
, BasicBlock
*IfFalse
,
2108 Value
*Cond
, BasicBlock
*InsertAtEnd
) {
2109 return new(3) BranchInst(IfTrue
, IfFalse
, Cond
, InsertAtEnd
);
2112 /// Transparently provide more efficient getOperand methods.
2113 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value
);
2115 bool isUnconditional() const { return getNumOperands() == 1; }
2116 bool isConditional() const { return getNumOperands() == 3; }
2118 Value
*getCondition() const {
2119 assert(isConditional() && "Cannot get condition of an uncond branch!");
2123 void setCondition(Value
*V
) {
2124 assert(isConditional() && "Cannot set condition of unconditional branch!");
2128 unsigned getNumSuccessors() const { return 1+isConditional(); }
2130 BasicBlock
*getSuccessor(unsigned i
) const {
2131 assert(i
< getNumSuccessors() && "Successor # out of range for Branch!");
2132 return cast_or_null
<BasicBlock
>((&Op
<-1>() - i
)->get());
2135 void setSuccessor(unsigned idx
, BasicBlock
*NewSucc
) {
2136 assert(idx
< getNumSuccessors() && "Successor # out of range for Branch!");
2137 *(&Op
<-1>() - idx
) = (Value
*)NewSucc
;
2140 // Methods for support type inquiry through isa, cast, and dyn_cast:
2141 static inline bool classof(const BranchInst
*) { return true; }
2142 static inline bool classof(const Instruction
*I
) {
2143 return (I
->getOpcode() == Instruction::Br
);
2145 static inline bool classof(const Value
*V
) {
2146 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
2149 virtual BasicBlock
*getSuccessorV(unsigned idx
) const;
2150 virtual unsigned getNumSuccessorsV() const;
2151 virtual void setSuccessorV(unsigned idx
, BasicBlock
*B
);
2155 struct OperandTraits
<BranchInst
> : public VariadicOperandTraits
<BranchInst
, 1> {
2158 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BranchInst
, Value
)
2160 //===----------------------------------------------------------------------===//
2162 //===----------------------------------------------------------------------===//
2164 //===---------------------------------------------------------------------------
2165 /// SwitchInst - Multiway switch
2167 class SwitchInst
: public TerminatorInst
{
2168 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
2169 unsigned ReservedSpace
;
2170 // Operand[0] = Value to switch on
2171 // Operand[1] = Default basic block destination
2172 // Operand[2n ] = Value to match
2173 // Operand[2n+1] = BasicBlock to go to on match
2174 SwitchInst(const SwitchInst
&SI
);
2175 void init(Value
*Value
, BasicBlock
*Default
, unsigned NumReserved
);
2176 void growOperands();
2177 // allocate space for exactly zero operands
2178 void *operator new(size_t s
) {
2179 return User::operator new(s
, 0);
2181 /// SwitchInst ctor - Create a new switch instruction, specifying a value to
2182 /// switch on and a default destination. The number of additional cases can
2183 /// be specified here to make memory allocation more efficient. This
2184 /// constructor can also autoinsert before another instruction.
2185 SwitchInst(Value
*Value
, BasicBlock
*Default
, unsigned NumCases
,
2186 Instruction
*InsertBefore
);
2188 /// SwitchInst ctor - Create a new switch instruction, specifying a value to
2189 /// switch on and a default destination. The number of additional cases can
2190 /// be specified here to make memory allocation more efficient. This
2191 /// constructor also autoinserts at the end of the specified BasicBlock.
2192 SwitchInst(Value
*Value
, BasicBlock
*Default
, unsigned NumCases
,
2193 BasicBlock
*InsertAtEnd
);
2195 virtual SwitchInst
*clone_impl() const;
2197 static SwitchInst
*Create(Value
*Value
, BasicBlock
*Default
,
2198 unsigned NumCases
, Instruction
*InsertBefore
= 0) {
2199 return new SwitchInst(Value
, Default
, NumCases
, InsertBefore
);
2201 static SwitchInst
*Create(Value
*Value
, BasicBlock
*Default
,
2202 unsigned NumCases
, BasicBlock
*InsertAtEnd
) {
2203 return new SwitchInst(Value
, Default
, NumCases
, InsertAtEnd
);
2207 /// Provide fast operand accessors
2208 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value
);
2210 // Accessor Methods for Switch stmt
2211 Value
*getCondition() const { return getOperand(0); }
2212 void setCondition(Value
*V
) { setOperand(0, V
); }
2214 BasicBlock
*getDefaultDest() const {
2215 return cast
<BasicBlock
>(getOperand(1));
2218 /// getNumCases - return the number of 'cases' in this switch instruction.
2219 /// Note that case #0 is always the default case.
2220 unsigned getNumCases() const {
2221 return getNumOperands()/2;
2224 /// getCaseValue - Return the specified case value. Note that case #0, the
2225 /// default destination, does not have a case value.
2226 ConstantInt
*getCaseValue(unsigned i
) {
2227 assert(i
&& i
< getNumCases() && "Illegal case value to get!");
2228 return getSuccessorValue(i
);
2231 /// getCaseValue - Return the specified case value. Note that case #0, the
2232 /// default destination, does not have a case value.
2233 const ConstantInt
*getCaseValue(unsigned i
) const {
2234 assert(i
&& i
< getNumCases() && "Illegal case value to get!");
2235 return getSuccessorValue(i
);
2238 /// findCaseValue - Search all of the case values for the specified constant.
2239 /// If it is explicitly handled, return the case number of it, otherwise
2240 /// return 0 to indicate that it is handled by the default handler.
2241 unsigned findCaseValue(const ConstantInt
*C
) const {
2242 for (unsigned i
= 1, e
= getNumCases(); i
!= e
; ++i
)
2243 if (getCaseValue(i
) == C
)
2248 /// findCaseDest - Finds the unique case value for a given successor. Returns
2249 /// null if the successor is not found, not unique, or is the default case.
2250 ConstantInt
*findCaseDest(BasicBlock
*BB
) {
2251 if (BB
== getDefaultDest()) return NULL
;
2253 ConstantInt
*CI
= NULL
;
2254 for (unsigned i
= 1, e
= getNumCases(); i
!= e
; ++i
) {
2255 if (getSuccessor(i
) == BB
) {
2256 if (CI
) return NULL
; // Multiple cases lead to BB.
2257 else CI
= getCaseValue(i
);
2263 /// addCase - Add an entry to the switch instruction...
2265 void addCase(ConstantInt
*OnVal
, BasicBlock
*Dest
);
2267 /// removeCase - This method removes the specified successor from the switch
2268 /// instruction. Note that this cannot be used to remove the default
2269 /// destination (successor #0). Also note that this operation may reorder the
2270 /// remaining cases at index idx and above.
2272 void removeCase(unsigned idx
);
2274 unsigned getNumSuccessors() const { return getNumOperands()/2; }
2275 BasicBlock
*getSuccessor(unsigned idx
) const {
2276 assert(idx
< getNumSuccessors() &&"Successor idx out of range for switch!");
2277 return cast
<BasicBlock
>(getOperand(idx
*2+1));
2279 void setSuccessor(unsigned idx
, BasicBlock
*NewSucc
) {
2280 assert(idx
< getNumSuccessors() && "Successor # out of range for switch!");
2281 setOperand(idx
*2+1, (Value
*)NewSucc
);
2284 // getSuccessorValue - Return the value associated with the specified
2286 ConstantInt
*getSuccessorValue(unsigned idx
) const {
2287 assert(idx
< getNumSuccessors() && "Successor # out of range!");
2288 return reinterpret_cast<ConstantInt
*>(getOperand(idx
*2));
2291 // Methods for support type inquiry through isa, cast, and dyn_cast:
2292 static inline bool classof(const SwitchInst
*) { return true; }
2293 static inline bool classof(const Instruction
*I
) {
2294 return I
->getOpcode() == Instruction::Switch
;
2296 static inline bool classof(const Value
*V
) {
2297 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
2300 virtual BasicBlock
*getSuccessorV(unsigned idx
) const;
2301 virtual unsigned getNumSuccessorsV() const;
2302 virtual void setSuccessorV(unsigned idx
, BasicBlock
*B
);
2306 struct OperandTraits
<SwitchInst
> : public HungoffOperandTraits
<2> {
2309 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(SwitchInst
, Value
)
2312 //===----------------------------------------------------------------------===//
2313 // IndirectBrInst Class
2314 //===----------------------------------------------------------------------===//
2316 //===---------------------------------------------------------------------------
2317 /// IndirectBrInst - Indirect Branch Instruction.
2319 class IndirectBrInst
: public TerminatorInst
{
2320 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
2321 unsigned ReservedSpace
;
2322 // Operand[0] = Value to switch on
2323 // Operand[1] = Default basic block destination
2324 // Operand[2n ] = Value to match
2325 // Operand[2n+1] = BasicBlock to go to on match
2326 IndirectBrInst(const IndirectBrInst
&IBI
);
2327 void init(Value
*Address
, unsigned NumDests
);
2328 void growOperands();
2329 // allocate space for exactly zero operands
2330 void *operator new(size_t s
) {
2331 return User::operator new(s
, 0);
2333 /// IndirectBrInst ctor - Create a new indirectbr instruction, specifying an
2334 /// Address to jump to. The number of expected destinations can be specified
2335 /// here to make memory allocation more efficient. This constructor can also
2336 /// autoinsert before another instruction.
2337 IndirectBrInst(Value
*Address
, unsigned NumDests
, Instruction
*InsertBefore
);
2339 /// IndirectBrInst ctor - Create a new indirectbr instruction, specifying an
2340 /// Address to jump to. The number of expected destinations can be specified
2341 /// here to make memory allocation more efficient. This constructor also
2342 /// autoinserts at the end of the specified BasicBlock.
2343 IndirectBrInst(Value
*Address
, unsigned NumDests
, BasicBlock
*InsertAtEnd
);
2345 virtual IndirectBrInst
*clone_impl() const;
2347 static IndirectBrInst
*Create(Value
*Address
, unsigned NumDests
,
2348 Instruction
*InsertBefore
= 0) {
2349 return new IndirectBrInst(Address
, NumDests
, InsertBefore
);
2351 static IndirectBrInst
*Create(Value
*Address
, unsigned NumDests
,
2352 BasicBlock
*InsertAtEnd
) {
2353 return new IndirectBrInst(Address
, NumDests
, InsertAtEnd
);
2357 /// Provide fast operand accessors.
2358 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value
);
2360 // Accessor Methods for IndirectBrInst instruction.
2361 Value
*getAddress() { return getOperand(0); }
2362 const Value
*getAddress() const { return getOperand(0); }
2363 void setAddress(Value
*V
) { setOperand(0, V
); }
2366 /// getNumDestinations - return the number of possible destinations in this
2367 /// indirectbr instruction.
2368 unsigned getNumDestinations() const { return getNumOperands()-1; }
2370 /// getDestination - Return the specified destination.
2371 BasicBlock
*getDestination(unsigned i
) { return getSuccessor(i
); }
2372 const BasicBlock
*getDestination(unsigned i
) const { return getSuccessor(i
); }
2374 /// addDestination - Add a destination.
2376 void addDestination(BasicBlock
*Dest
);
2378 /// removeDestination - This method removes the specified successor from the
2379 /// indirectbr instruction.
2380 void removeDestination(unsigned i
);
2382 unsigned getNumSuccessors() const { return getNumOperands()-1; }
2383 BasicBlock
*getSuccessor(unsigned i
) const {
2384 return cast
<BasicBlock
>(getOperand(i
+1));
2386 void setSuccessor(unsigned i
, BasicBlock
*NewSucc
) {
2387 setOperand(i
+1, (Value
*)NewSucc
);
2390 // Methods for support type inquiry through isa, cast, and dyn_cast:
2391 static inline bool classof(const IndirectBrInst
*) { return true; }
2392 static inline bool classof(const Instruction
*I
) {
2393 return I
->getOpcode() == Instruction::IndirectBr
;
2395 static inline bool classof(const Value
*V
) {
2396 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
2399 virtual BasicBlock
*getSuccessorV(unsigned idx
) const;
2400 virtual unsigned getNumSuccessorsV() const;
2401 virtual void setSuccessorV(unsigned idx
, BasicBlock
*B
);
2405 struct OperandTraits
<IndirectBrInst
> : public HungoffOperandTraits
<1> {
2408 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(IndirectBrInst
, Value
)
2411 //===----------------------------------------------------------------------===//
2413 //===----------------------------------------------------------------------===//
2415 /// InvokeInst - Invoke instruction. The SubclassData field is used to hold the
2416 /// calling convention of the call.
2418 class InvokeInst
: public TerminatorInst
{
2419 AttrListPtr AttributeList
;
2420 InvokeInst(const InvokeInst
&BI
);
2421 void init(Value
*Fn
, BasicBlock
*IfNormal
, BasicBlock
*IfException
,
2422 Value
* const *Args
, unsigned NumArgs
);
2424 template<typename RandomAccessIterator
>
2425 void init(Value
*Func
, BasicBlock
*IfNormal
, BasicBlock
*IfException
,
2426 RandomAccessIterator ArgBegin
, RandomAccessIterator ArgEnd
,
2427 const Twine
&NameStr
,
2428 // This argument ensures that we have an iterator we can
2429 // do arithmetic on in constant time
2430 std::random_access_iterator_tag
) {
2431 unsigned NumArgs
= (unsigned)std::distance(ArgBegin
, ArgEnd
);
2433 // This requires that the iterator points to contiguous memory.
2434 init(Func
, IfNormal
, IfException
, NumArgs
? &*ArgBegin
: 0, NumArgs
);
2438 /// Construct an InvokeInst given a range of arguments.
2439 /// RandomAccessIterator must be a random-access iterator pointing to
2440 /// contiguous storage (e.g. a std::vector<>::iterator). Checks are
2441 /// made for random-accessness but not for contiguous storage as
2442 /// that would incur runtime overhead.
2444 /// @brief Construct an InvokeInst from a range of arguments
2445 template<typename RandomAccessIterator
>
2446 inline InvokeInst(Value
*Func
, BasicBlock
*IfNormal
, BasicBlock
*IfException
,
2447 RandomAccessIterator ArgBegin
, RandomAccessIterator ArgEnd
,
2449 const Twine
&NameStr
, Instruction
*InsertBefore
);
2451 /// Construct an InvokeInst given a range of arguments.
2452 /// RandomAccessIterator must be a random-access iterator pointing to
2453 /// contiguous storage (e.g. a std::vector<>::iterator). Checks are
2454 /// made for random-accessness but not for contiguous storage as
2455 /// that would incur runtime overhead.
2457 /// @brief Construct an InvokeInst from a range of arguments
2458 template<typename RandomAccessIterator
>
2459 inline InvokeInst(Value
*Func
, BasicBlock
*IfNormal
, BasicBlock
*IfException
,
2460 RandomAccessIterator ArgBegin
, RandomAccessIterator ArgEnd
,
2462 const Twine
&NameStr
, BasicBlock
*InsertAtEnd
);
2464 virtual InvokeInst
*clone_impl() const;
2466 template<typename RandomAccessIterator
>
2467 static InvokeInst
*Create(Value
*Func
,
2468 BasicBlock
*IfNormal
, BasicBlock
*IfException
,
2469 RandomAccessIterator ArgBegin
,
2470 RandomAccessIterator ArgEnd
,
2471 const Twine
&NameStr
= "",
2472 Instruction
*InsertBefore
= 0) {
2473 unsigned Values(ArgEnd
- ArgBegin
+ 3);
2474 return new(Values
) InvokeInst(Func
, IfNormal
, IfException
, ArgBegin
, ArgEnd
,
2475 Values
, NameStr
, InsertBefore
);
2477 template<typename RandomAccessIterator
>
2478 static InvokeInst
*Create(Value
*Func
,
2479 BasicBlock
*IfNormal
, BasicBlock
*IfException
,
2480 RandomAccessIterator ArgBegin
,
2481 RandomAccessIterator ArgEnd
,
2482 const Twine
&NameStr
,
2483 BasicBlock
*InsertAtEnd
) {
2484 unsigned Values(ArgEnd
- ArgBegin
+ 3);
2485 return new(Values
) InvokeInst(Func
, IfNormal
, IfException
, ArgBegin
, ArgEnd
,
2486 Values
, NameStr
, InsertAtEnd
);
2489 /// Provide fast operand accessors
2490 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value
);
2492 /// getNumArgOperands - Return the number of invoke arguments.
2494 unsigned getNumArgOperands() const { return getNumOperands() - 3; }
2496 /// getArgOperand/setArgOperand - Return/set the i-th invoke argument.
2498 Value
*getArgOperand(unsigned i
) const { return getOperand(i
); }
2499 void setArgOperand(unsigned i
, Value
*v
) { setOperand(i
, v
); }
2501 /// getCallingConv/setCallingConv - Get or set the calling convention of this
2503 CallingConv::ID
getCallingConv() const {
2504 return static_cast<CallingConv::ID
>(getSubclassDataFromInstruction());
2506 void setCallingConv(CallingConv::ID CC
) {
2507 setInstructionSubclassData(static_cast<unsigned>(CC
));
2510 /// getAttributes - Return the parameter attributes for this invoke.
2512 const AttrListPtr
&getAttributes() const { return AttributeList
; }
2514 /// setAttributes - Set the parameter attributes for this invoke.
2516 void setAttributes(const AttrListPtr
&Attrs
) { AttributeList
= Attrs
; }
2518 /// addAttribute - adds the attribute to the list of attributes.
2519 void addAttribute(unsigned i
, Attributes attr
);
2521 /// removeAttribute - removes the attribute from the list of attributes.
2522 void removeAttribute(unsigned i
, Attributes attr
);
2524 /// @brief Determine whether the call or the callee has the given attribute.
2525 bool paramHasAttr(unsigned i
, Attributes attr
) const;
2527 /// @brief Extract the alignment for a call or parameter (0=unknown).
2528 unsigned getParamAlignment(unsigned i
) const {
2529 return AttributeList
.getParamAlignment(i
);
2532 /// @brief Return true if the call should not be inlined.
2533 bool isNoInline() const { return paramHasAttr(~0, Attribute::NoInline
); }
2534 void setIsNoInline(bool Value
= true) {
2535 if (Value
) addAttribute(~0, Attribute::NoInline
);
2536 else removeAttribute(~0, Attribute::NoInline
);
2539 /// @brief Determine if the call does not access memory.
2540 bool doesNotAccessMemory() const {
2541 return paramHasAttr(~0, Attribute::ReadNone
);
2543 void setDoesNotAccessMemory(bool NotAccessMemory
= true) {
2544 if (NotAccessMemory
) addAttribute(~0, Attribute::ReadNone
);
2545 else removeAttribute(~0, Attribute::ReadNone
);
2548 /// @brief Determine if the call does not access or only reads memory.
2549 bool onlyReadsMemory() const {
2550 return doesNotAccessMemory() || paramHasAttr(~0, Attribute::ReadOnly
);
2552 void setOnlyReadsMemory(bool OnlyReadsMemory
= true) {
2553 if (OnlyReadsMemory
) addAttribute(~0, Attribute::ReadOnly
);
2554 else removeAttribute(~0, Attribute::ReadOnly
| Attribute::ReadNone
);
2557 /// @brief Determine if the call cannot return.
2558 bool doesNotReturn() const { return paramHasAttr(~0, Attribute::NoReturn
); }
2559 void setDoesNotReturn(bool DoesNotReturn
= true) {
2560 if (DoesNotReturn
) addAttribute(~0, Attribute::NoReturn
);
2561 else removeAttribute(~0, Attribute::NoReturn
);
2564 /// @brief Determine if the call cannot unwind.
2565 bool doesNotThrow() const { return paramHasAttr(~0, Attribute::NoUnwind
); }
2566 void setDoesNotThrow(bool DoesNotThrow
= true) {
2567 if (DoesNotThrow
) addAttribute(~0, Attribute::NoUnwind
);
2568 else removeAttribute(~0, Attribute::NoUnwind
);
2571 /// @brief Determine if the call returns a structure through first
2572 /// pointer argument.
2573 bool hasStructRetAttr() const {
2574 // Be friendly and also check the callee.
2575 return paramHasAttr(1, Attribute::StructRet
);
2578 /// @brief Determine if any call argument is an aggregate passed by value.
2579 bool hasByValArgument() const {
2580 return AttributeList
.hasAttrSomewhere(Attribute::ByVal
);
2583 /// getCalledFunction - Return the function called, or null if this is an
2584 /// indirect function invocation.
2586 Function
*getCalledFunction() const {
2587 return dyn_cast
<Function
>(Op
<-3>());
2590 /// getCalledValue - Get a pointer to the function that is invoked by this
2592 const Value
*getCalledValue() const { return Op
<-3>(); }
2593 Value
*getCalledValue() { return Op
<-3>(); }
2595 /// setCalledFunction - Set the function called.
2596 void setCalledFunction(Value
* Fn
) {
2600 // get*Dest - Return the destination basic blocks...
2601 BasicBlock
*getNormalDest() const {
2602 return cast
<BasicBlock
>(Op
<-2>());
2604 BasicBlock
*getUnwindDest() const {
2605 return cast
<BasicBlock
>(Op
<-1>());
2607 void setNormalDest(BasicBlock
*B
) {
2608 Op
<-2>() = reinterpret_cast<Value
*>(B
);
2610 void setUnwindDest(BasicBlock
*B
) {
2611 Op
<-1>() = reinterpret_cast<Value
*>(B
);
2614 BasicBlock
*getSuccessor(unsigned i
) const {
2615 assert(i
< 2 && "Successor # out of range for invoke!");
2616 return i
== 0 ? getNormalDest() : getUnwindDest();
2619 void setSuccessor(unsigned idx
, BasicBlock
*NewSucc
) {
2620 assert(idx
< 2 && "Successor # out of range for invoke!");
2621 *(&Op
<-2>() + idx
) = reinterpret_cast<Value
*>(NewSucc
);
2624 unsigned getNumSuccessors() const { return 2; }
2626 // Methods for support type inquiry through isa, cast, and dyn_cast:
2627 static inline bool classof(const InvokeInst
*) { return true; }
2628 static inline bool classof(const Instruction
*I
) {
2629 return (I
->getOpcode() == Instruction::Invoke
);
2631 static inline bool classof(const Value
*V
) {
2632 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
2636 virtual BasicBlock
*getSuccessorV(unsigned idx
) const;
2637 virtual unsigned getNumSuccessorsV() const;
2638 virtual void setSuccessorV(unsigned idx
, BasicBlock
*B
);
2640 // Shadow Instruction::setInstructionSubclassData with a private forwarding
2641 // method so that subclasses cannot accidentally use it.
2642 void setInstructionSubclassData(unsigned short D
) {
2643 Instruction::setInstructionSubclassData(D
);
2648 struct OperandTraits
<InvokeInst
> : public VariadicOperandTraits
<InvokeInst
, 3> {
2651 template<typename RandomAccessIterator
>
2652 InvokeInst::InvokeInst(Value
*Func
,
2653 BasicBlock
*IfNormal
, BasicBlock
*IfException
,
2654 RandomAccessIterator ArgBegin
,
2655 RandomAccessIterator ArgEnd
,
2657 const Twine
&NameStr
, Instruction
*InsertBefore
)
2658 : TerminatorInst(cast
<FunctionType
>(cast
<PointerType
>(Func
->getType())
2659 ->getElementType())->getReturnType(),
2660 Instruction::Invoke
,
2661 OperandTraits
<InvokeInst
>::op_end(this) - Values
,
2662 Values
, InsertBefore
) {
2663 init(Func
, IfNormal
, IfException
, ArgBegin
, ArgEnd
, NameStr
,
2664 typename
std::iterator_traits
<RandomAccessIterator
>
2665 ::iterator_category());
2667 template<typename RandomAccessIterator
>
2668 InvokeInst::InvokeInst(Value
*Func
,
2669 BasicBlock
*IfNormal
, BasicBlock
*IfException
,
2670 RandomAccessIterator ArgBegin
,
2671 RandomAccessIterator ArgEnd
,
2673 const Twine
&NameStr
, BasicBlock
*InsertAtEnd
)
2674 : TerminatorInst(cast
<FunctionType
>(cast
<PointerType
>(Func
->getType())
2675 ->getElementType())->getReturnType(),
2676 Instruction::Invoke
,
2677 OperandTraits
<InvokeInst
>::op_end(this) - Values
,
2678 Values
, InsertAtEnd
) {
2679 init(Func
, IfNormal
, IfException
, ArgBegin
, ArgEnd
, NameStr
,
2680 typename
std::iterator_traits
<RandomAccessIterator
>
2681 ::iterator_category());
2684 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InvokeInst
, Value
)
2686 //===----------------------------------------------------------------------===//
2688 //===----------------------------------------------------------------------===//
2690 //===---------------------------------------------------------------------------
2691 /// UnwindInst - Immediately exit the current function, unwinding the stack
2692 /// until an invoke instruction is found.
2694 class UnwindInst
: public TerminatorInst
{
2695 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
2697 virtual UnwindInst
*clone_impl() const;
2699 // allocate space for exactly zero operands
2700 void *operator new(size_t s
) {
2701 return User::operator new(s
, 0);
2703 explicit UnwindInst(LLVMContext
&C
, Instruction
*InsertBefore
= 0);
2704 explicit UnwindInst(LLVMContext
&C
, BasicBlock
*InsertAtEnd
);
2706 unsigned getNumSuccessors() const { return 0; }
2708 // Methods for support type inquiry through isa, cast, and dyn_cast:
2709 static inline bool classof(const UnwindInst
*) { return true; }
2710 static inline bool classof(const Instruction
*I
) {
2711 return I
->getOpcode() == Instruction::Unwind
;
2713 static inline bool classof(const Value
*V
) {
2714 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
2717 virtual BasicBlock
*getSuccessorV(unsigned idx
) const;
2718 virtual unsigned getNumSuccessorsV() const;
2719 virtual void setSuccessorV(unsigned idx
, BasicBlock
*B
);
2722 //===----------------------------------------------------------------------===//
2723 // UnreachableInst Class
2724 //===----------------------------------------------------------------------===//
2726 //===---------------------------------------------------------------------------
2727 /// UnreachableInst - This function has undefined behavior. In particular, the
2728 /// presence of this instruction indicates some higher level knowledge that the
2729 /// end of the block cannot be reached.
2731 class UnreachableInst
: public TerminatorInst
{
2732 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
2734 virtual UnreachableInst
*clone_impl() const;
2737 // allocate space for exactly zero operands
2738 void *operator new(size_t s
) {
2739 return User::operator new(s
, 0);
2741 explicit UnreachableInst(LLVMContext
&C
, Instruction
*InsertBefore
= 0);
2742 explicit UnreachableInst(LLVMContext
&C
, BasicBlock
*InsertAtEnd
);
2744 unsigned getNumSuccessors() const { return 0; }
2746 // Methods for support type inquiry through isa, cast, and dyn_cast:
2747 static inline bool classof(const UnreachableInst
*) { return true; }
2748 static inline bool classof(const Instruction
*I
) {
2749 return I
->getOpcode() == Instruction::Unreachable
;
2751 static inline bool classof(const Value
*V
) {
2752 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
2755 virtual BasicBlock
*getSuccessorV(unsigned idx
) const;
2756 virtual unsigned getNumSuccessorsV() const;
2757 virtual void setSuccessorV(unsigned idx
, BasicBlock
*B
);
2760 //===----------------------------------------------------------------------===//
2762 //===----------------------------------------------------------------------===//
2764 /// @brief This class represents a truncation of integer types.
2765 class TruncInst
: public CastInst
{
2767 /// @brief Clone an identical TruncInst
2768 virtual TruncInst
*clone_impl() const;
2771 /// @brief Constructor with insert-before-instruction semantics
2773 Value
*S
, ///< The value to be truncated
2774 const Type
*Ty
, ///< The (smaller) type to truncate to
2775 const Twine
&NameStr
= "", ///< A name for the new instruction
2776 Instruction
*InsertBefore
= 0 ///< Where to insert the new instruction
2779 /// @brief Constructor with insert-at-end-of-block semantics
2781 Value
*S
, ///< The value to be truncated
2782 const Type
*Ty
, ///< The (smaller) type to truncate to
2783 const Twine
&NameStr
, ///< A name for the new instruction
2784 BasicBlock
*InsertAtEnd
///< The block to insert the instruction into
2787 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
2788 static inline bool classof(const TruncInst
*) { return true; }
2789 static inline bool classof(const Instruction
*I
) {
2790 return I
->getOpcode() == Trunc
;
2792 static inline bool classof(const Value
*V
) {
2793 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
2797 //===----------------------------------------------------------------------===//
2799 //===----------------------------------------------------------------------===//
2801 /// @brief This class represents zero extension of integer types.
2802 class ZExtInst
: public CastInst
{
2804 /// @brief Clone an identical ZExtInst
2805 virtual ZExtInst
*clone_impl() const;
2808 /// @brief Constructor with insert-before-instruction semantics
2810 Value
*S
, ///< The value to be zero extended
2811 const Type
*Ty
, ///< The type to zero extend to
2812 const Twine
&NameStr
= "", ///< A name for the new instruction
2813 Instruction
*InsertBefore
= 0 ///< Where to insert the new instruction
2816 /// @brief Constructor with insert-at-end semantics.
2818 Value
*S
, ///< The value to be zero extended
2819 const Type
*Ty
, ///< The type to zero extend to
2820 const Twine
&NameStr
, ///< A name for the new instruction
2821 BasicBlock
*InsertAtEnd
///< The block to insert the instruction into
2824 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
2825 static inline bool classof(const ZExtInst
*) { return true; }
2826 static inline bool classof(const Instruction
*I
) {
2827 return I
->getOpcode() == ZExt
;
2829 static inline bool classof(const Value
*V
) {
2830 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
2834 //===----------------------------------------------------------------------===//
2836 //===----------------------------------------------------------------------===//
2838 /// @brief This class represents a sign extension of integer types.
2839 class SExtInst
: public CastInst
{
2841 /// @brief Clone an identical SExtInst
2842 virtual SExtInst
*clone_impl() const;
2845 /// @brief Constructor with insert-before-instruction semantics
2847 Value
*S
, ///< The value to be sign extended
2848 const Type
*Ty
, ///< The type to sign extend to
2849 const Twine
&NameStr
= "", ///< A name for the new instruction
2850 Instruction
*InsertBefore
= 0 ///< Where to insert the new instruction
2853 /// @brief Constructor with insert-at-end-of-block semantics
2855 Value
*S
, ///< The value to be sign extended
2856 const Type
*Ty
, ///< The type to sign extend to
2857 const Twine
&NameStr
, ///< A name for the new instruction
2858 BasicBlock
*InsertAtEnd
///< The block to insert the instruction into
2861 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
2862 static inline bool classof(const SExtInst
*) { return true; }
2863 static inline bool classof(const Instruction
*I
) {
2864 return I
->getOpcode() == SExt
;
2866 static inline bool classof(const Value
*V
) {
2867 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
2871 //===----------------------------------------------------------------------===//
2872 // FPTruncInst Class
2873 //===----------------------------------------------------------------------===//
2875 /// @brief This class represents a truncation of floating point types.
2876 class FPTruncInst
: public CastInst
{
2878 /// @brief Clone an identical FPTruncInst
2879 virtual FPTruncInst
*clone_impl() const;
2882 /// @brief Constructor with insert-before-instruction semantics
2884 Value
*S
, ///< The value to be truncated
2885 const Type
*Ty
, ///< The type to truncate to
2886 const Twine
&NameStr
= "", ///< A name for the new instruction
2887 Instruction
*InsertBefore
= 0 ///< Where to insert the new instruction
2890 /// @brief Constructor with insert-before-instruction semantics
2892 Value
*S
, ///< The value to be truncated
2893 const Type
*Ty
, ///< The type to truncate to
2894 const Twine
&NameStr
, ///< A name for the new instruction
2895 BasicBlock
*InsertAtEnd
///< The block to insert the instruction into
2898 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
2899 static inline bool classof(const FPTruncInst
*) { return true; }
2900 static inline bool classof(const Instruction
*I
) {
2901 return I
->getOpcode() == FPTrunc
;
2903 static inline bool classof(const Value
*V
) {
2904 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
2908 //===----------------------------------------------------------------------===//
2910 //===----------------------------------------------------------------------===//
2912 /// @brief This class represents an extension of floating point types.
2913 class FPExtInst
: public CastInst
{
2915 /// @brief Clone an identical FPExtInst
2916 virtual FPExtInst
*clone_impl() const;
2919 /// @brief Constructor with insert-before-instruction semantics
2921 Value
*S
, ///< The value to be extended
2922 const Type
*Ty
, ///< The type to extend to
2923 const Twine
&NameStr
= "", ///< A name for the new instruction
2924 Instruction
*InsertBefore
= 0 ///< Where to insert the new instruction
2927 /// @brief Constructor with insert-at-end-of-block semantics
2929 Value
*S
, ///< The value to be extended
2930 const Type
*Ty
, ///< The type to extend to
2931 const Twine
&NameStr
, ///< A name for the new instruction
2932 BasicBlock
*InsertAtEnd
///< The block to insert the instruction into
2935 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
2936 static inline bool classof(const FPExtInst
*) { return true; }
2937 static inline bool classof(const Instruction
*I
) {
2938 return I
->getOpcode() == FPExt
;
2940 static inline bool classof(const Value
*V
) {
2941 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
2945 //===----------------------------------------------------------------------===//
2947 //===----------------------------------------------------------------------===//
2949 /// @brief This class represents a cast unsigned integer to floating point.
2950 class UIToFPInst
: public CastInst
{
2952 /// @brief Clone an identical UIToFPInst
2953 virtual UIToFPInst
*clone_impl() const;
2956 /// @brief Constructor with insert-before-instruction semantics
2958 Value
*S
, ///< The value to be converted
2959 const Type
*Ty
, ///< The type to convert to
2960 const Twine
&NameStr
= "", ///< A name for the new instruction
2961 Instruction
*InsertBefore
= 0 ///< Where to insert the new instruction
2964 /// @brief Constructor with insert-at-end-of-block semantics
2966 Value
*S
, ///< The value to be converted
2967 const Type
*Ty
, ///< The type to convert to
2968 const Twine
&NameStr
, ///< A name for the new instruction
2969 BasicBlock
*InsertAtEnd
///< The block to insert the instruction into
2972 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
2973 static inline bool classof(const UIToFPInst
*) { return true; }
2974 static inline bool classof(const Instruction
*I
) {
2975 return I
->getOpcode() == UIToFP
;
2977 static inline bool classof(const Value
*V
) {
2978 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
2982 //===----------------------------------------------------------------------===//
2984 //===----------------------------------------------------------------------===//
2986 /// @brief This class represents a cast from signed integer to floating point.
2987 class SIToFPInst
: public CastInst
{
2989 /// @brief Clone an identical SIToFPInst
2990 virtual SIToFPInst
*clone_impl() const;
2993 /// @brief Constructor with insert-before-instruction semantics
2995 Value
*S
, ///< The value to be converted
2996 const Type
*Ty
, ///< The type to convert to
2997 const Twine
&NameStr
= "", ///< A name for the new instruction
2998 Instruction
*InsertBefore
= 0 ///< Where to insert the new instruction
3001 /// @brief Constructor with insert-at-end-of-block semantics
3003 Value
*S
, ///< The value to be converted
3004 const Type
*Ty
, ///< The type to convert to
3005 const Twine
&NameStr
, ///< A name for the new instruction
3006 BasicBlock
*InsertAtEnd
///< The block to insert the instruction into
3009 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
3010 static inline bool classof(const SIToFPInst
*) { return true; }
3011 static inline bool classof(const Instruction
*I
) {
3012 return I
->getOpcode() == SIToFP
;
3014 static inline bool classof(const Value
*V
) {
3015 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
3019 //===----------------------------------------------------------------------===//
3021 //===----------------------------------------------------------------------===//
3023 /// @brief This class represents a cast from floating point to unsigned integer
3024 class FPToUIInst
: public CastInst
{
3026 /// @brief Clone an identical FPToUIInst
3027 virtual FPToUIInst
*clone_impl() const;
3030 /// @brief Constructor with insert-before-instruction semantics
3032 Value
*S
, ///< The value to be converted
3033 const Type
*Ty
, ///< The type to convert to
3034 const Twine
&NameStr
= "", ///< A name for the new instruction
3035 Instruction
*InsertBefore
= 0 ///< Where to insert the new instruction
3038 /// @brief Constructor with insert-at-end-of-block semantics
3040 Value
*S
, ///< The value to be converted
3041 const Type
*Ty
, ///< The type to convert to
3042 const Twine
&NameStr
, ///< A name for the new instruction
3043 BasicBlock
*InsertAtEnd
///< Where to insert the new instruction
3046 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
3047 static inline bool classof(const FPToUIInst
*) { return true; }
3048 static inline bool classof(const Instruction
*I
) {
3049 return I
->getOpcode() == FPToUI
;
3051 static inline bool classof(const Value
*V
) {
3052 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
3056 //===----------------------------------------------------------------------===//
3058 //===----------------------------------------------------------------------===//
3060 /// @brief This class represents a cast from floating point to signed integer.
3061 class FPToSIInst
: public CastInst
{
3063 /// @brief Clone an identical FPToSIInst
3064 virtual FPToSIInst
*clone_impl() const;
3067 /// @brief Constructor with insert-before-instruction semantics
3069 Value
*S
, ///< The value to be converted
3070 const Type
*Ty
, ///< The type to convert to
3071 const Twine
&NameStr
= "", ///< A name for the new instruction
3072 Instruction
*InsertBefore
= 0 ///< Where to insert the new instruction
3075 /// @brief Constructor with insert-at-end-of-block semantics
3077 Value
*S
, ///< The value to be converted
3078 const Type
*Ty
, ///< The type to convert to
3079 const Twine
&NameStr
, ///< A name for the new instruction
3080 BasicBlock
*InsertAtEnd
///< The block to insert the instruction into
3083 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
3084 static inline bool classof(const FPToSIInst
*) { return true; }
3085 static inline bool classof(const Instruction
*I
) {
3086 return I
->getOpcode() == FPToSI
;
3088 static inline bool classof(const Value
*V
) {
3089 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
3093 //===----------------------------------------------------------------------===//
3094 // IntToPtrInst Class
3095 //===----------------------------------------------------------------------===//
3097 /// @brief This class represents a cast from an integer to a pointer.
3098 class IntToPtrInst
: public CastInst
{
3100 /// @brief Constructor with insert-before-instruction semantics
3102 Value
*S
, ///< The value to be converted
3103 const Type
*Ty
, ///< The type to convert to
3104 const Twine
&NameStr
= "", ///< A name for the new instruction
3105 Instruction
*InsertBefore
= 0 ///< Where to insert the new instruction
3108 /// @brief Constructor with insert-at-end-of-block semantics
3110 Value
*S
, ///< The value to be converted
3111 const Type
*Ty
, ///< The type to convert to
3112 const Twine
&NameStr
, ///< A name for the new instruction
3113 BasicBlock
*InsertAtEnd
///< The block to insert the instruction into
3116 /// @brief Clone an identical IntToPtrInst
3117 virtual IntToPtrInst
*clone_impl() const;
3119 // Methods for support type inquiry through isa, cast, and dyn_cast:
3120 static inline bool classof(const IntToPtrInst
*) { return true; }
3121 static inline bool classof(const Instruction
*I
) {
3122 return I
->getOpcode() == IntToPtr
;
3124 static inline bool classof(const Value
*V
) {
3125 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
3129 //===----------------------------------------------------------------------===//
3130 // PtrToIntInst Class
3131 //===----------------------------------------------------------------------===//
3133 /// @brief This class represents a cast from a pointer to an integer
3134 class PtrToIntInst
: public CastInst
{
3136 /// @brief Clone an identical PtrToIntInst
3137 virtual PtrToIntInst
*clone_impl() const;
3140 /// @brief Constructor with insert-before-instruction semantics
3142 Value
*S
, ///< The value to be converted
3143 const Type
*Ty
, ///< The type to convert to
3144 const Twine
&NameStr
= "", ///< A name for the new instruction
3145 Instruction
*InsertBefore
= 0 ///< Where to insert the new instruction
3148 /// @brief Constructor with insert-at-end-of-block semantics
3150 Value
*S
, ///< The value to be converted
3151 const Type
*Ty
, ///< The type to convert to
3152 const Twine
&NameStr
, ///< A name for the new instruction
3153 BasicBlock
*InsertAtEnd
///< The block to insert the instruction into
3156 // Methods for support type inquiry through isa, cast, and dyn_cast:
3157 static inline bool classof(const PtrToIntInst
*) { return true; }
3158 static inline bool classof(const Instruction
*I
) {
3159 return I
->getOpcode() == PtrToInt
;
3161 static inline bool classof(const Value
*V
) {
3162 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
3166 //===----------------------------------------------------------------------===//
3167 // BitCastInst Class
3168 //===----------------------------------------------------------------------===//
3170 /// @brief This class represents a no-op cast from one type to another.
3171 class BitCastInst
: public CastInst
{
3173 /// @brief Clone an identical BitCastInst
3174 virtual BitCastInst
*clone_impl() const;
3177 /// @brief Constructor with insert-before-instruction semantics
3179 Value
*S
, ///< The value to be casted
3180 const Type
*Ty
, ///< The type to casted to
3181 const Twine
&NameStr
= "", ///< A name for the new instruction
3182 Instruction
*InsertBefore
= 0 ///< Where to insert the new instruction
3185 /// @brief Constructor with insert-at-end-of-block semantics
3187 Value
*S
, ///< The value to be casted
3188 const Type
*Ty
, ///< The type to casted to
3189 const Twine
&NameStr
, ///< A name for the new instruction
3190 BasicBlock
*InsertAtEnd
///< The block to insert the instruction into
3193 // Methods for support type inquiry through isa, cast, and dyn_cast:
3194 static inline bool classof(const BitCastInst
*) { return true; }
3195 static inline bool classof(const Instruction
*I
) {
3196 return I
->getOpcode() == BitCast
;
3198 static inline bool classof(const Value
*V
) {
3199 return isa
<Instruction
>(V
) && classof(cast
<Instruction
>(V
));
3203 } // End llvm namespace