]>
git.proxmox.com Git - rustc.git/blob - src/llvm/include/llvm/IR/Value.h
1 //===-- llvm/Value.h - Definition of the Value class ------------*- 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 declares the Value class.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_IR_VALUE_H
15 #define LLVM_IR_VALUE_H
17 #include "llvm-c/Core.h"
18 #include "llvm/ADT/iterator_range.h"
19 #include "llvm/IR/Use.h"
20 #include "llvm/Support/CBindingWrapping.h"
21 #include "llvm/Support/Casting.h"
22 #include "llvm/Support/Compiler.h"
28 class AssemblyAnnotationWriter
;
44 class ValueHandleBase
;
45 class ValueSymbolTable
;
48 template<typename ValueTy
> class StringMapEntry
;
49 typedef StringMapEntry
<Value
*> ValueName
;
51 //===----------------------------------------------------------------------===//
53 //===----------------------------------------------------------------------===//
55 /// \brief LLVM Value Representation
57 /// This is a very important LLVM class. It is the base class of all values
58 /// computed by a program that may be used as operands to other values. Value is
59 /// the super class of other important classes such as Instruction and Function.
60 /// All Values have a Type. Type is not a subclass of Value. Some values can
61 /// have a name and they belong to some Module. Setting the name on the Value
62 /// automatically updates the module's symbol table.
64 /// Every value has a "use list" that keeps track of which other Values are
65 /// using this Value. A Value can also have an arbitrary number of ValueHandle
66 /// objects that watch it and listen to RAUW and Destroy events. See
67 /// llvm/IR/ValueHandle.h for details.
72 friend class ValueAsMetadata
; // Allow access to NameAndIsUsedByMD.
73 friend class ValueHandleBase
;
74 PointerIntPair
<ValueName
*, 1> NameAndIsUsedByMD
;
76 const unsigned char SubclassID
; // Subclass identifier (for isa/dyn_cast)
77 unsigned char HasValueHandle
: 1; // Has a ValueHandle pointing to this?
79 /// \brief Hold subclass data that can be dropped.
81 /// This member is similar to SubclassData, however it is for holding
82 /// information which may be used to aid optimization, but which may be
83 /// cleared to zero without affecting conservative interpretation.
84 unsigned char SubclassOptionalData
: 7;
87 /// \brief Hold arbitrary subclass data.
89 /// This member is defined by this class, but is not used for anything.
90 /// Subclasses can use it to hold whatever state they find useful. This
91 /// field is initialized to zero by the ctor.
92 unsigned short SubclassData
;
95 /// \brief The number of operands in the subclass.
97 /// This member is defined by this class, but not used for anything.
98 /// Subclasses can use it to store their number of operands, if they have
101 /// This is stored here to save space in User on 64-bit hosts. Since most
102 /// instances of Value have operands, 32-bit hosts aren't significantly
104 unsigned NumOperands
;
107 template <typename UseT
> // UseT == 'Use' or 'const Use'
108 class use_iterator_impl
109 : public std::iterator
<std::forward_iterator_tag
, UseT
*, ptrdiff_t> {
110 typedef std::iterator
<std::forward_iterator_tag
, UseT
*, ptrdiff_t> super
;
113 explicit use_iterator_impl(UseT
*u
) : U(u
) {}
117 typedef typename
super::reference reference
;
118 typedef typename
super::pointer pointer
;
120 use_iterator_impl() : U() {}
122 bool operator==(const use_iterator_impl
&x
) const { return U
== x
.U
; }
123 bool operator!=(const use_iterator_impl
&x
) const { return !operator==(x
); }
125 use_iterator_impl
&operator++() { // Preincrement
126 assert(U
&& "Cannot increment end iterator!");
130 use_iterator_impl
operator++(int) { // Postincrement
136 UseT
&operator*() const {
137 assert(U
&& "Cannot dereference end iterator!");
141 UseT
*operator->() const { return &operator*(); }
143 operator use_iterator_impl
<const UseT
>() const {
144 return use_iterator_impl
<const UseT
>(U
);
148 template <typename UserTy
> // UserTy == 'User' or 'const User'
149 class user_iterator_impl
150 : public std::iterator
<std::forward_iterator_tag
, UserTy
*, ptrdiff_t> {
151 typedef std::iterator
<std::forward_iterator_tag
, UserTy
*, ptrdiff_t> super
;
153 use_iterator_impl
<Use
> UI
;
154 explicit user_iterator_impl(Use
*U
) : UI(U
) {}
158 typedef typename
super::reference reference
;
159 typedef typename
super::pointer pointer
;
161 user_iterator_impl() {}
163 bool operator==(const user_iterator_impl
&x
) const { return UI
== x
.UI
; }
164 bool operator!=(const user_iterator_impl
&x
) const { return !operator==(x
); }
166 /// \brief Returns true if this iterator is equal to user_end() on the value.
167 bool atEnd() const { return *this == user_iterator_impl(); }
169 user_iterator_impl
&operator++() { // Preincrement
173 user_iterator_impl
operator++(int) { // Postincrement
179 // Retrieve a pointer to the current User.
180 UserTy
*operator*() const {
181 return UI
->getUser();
184 UserTy
*operator->() const { return operator*(); }
186 operator user_iterator_impl
<const UserTy
>() const {
187 return user_iterator_impl
<const UserTy
>(*UI
);
190 Use
&getUse() const { return *UI
; }
192 /// \brief Return the operand # of this use in its User.
194 /// FIXME: Replace all callers with a direct call to Use::getOperandNo.
195 unsigned getOperandNo() const { return UI
->getOperandNo(); }
198 void operator=(const Value
&) LLVM_DELETED_FUNCTION
;
199 Value(const Value
&) LLVM_DELETED_FUNCTION
;
202 Value(Type
*Ty
, unsigned scid
);
206 /// \brief Support for debugging, callable in GDB: V->dump()
209 /// \brief Implement operator<< on Value.
210 void print(raw_ostream
&O
) const;
212 /// \brief Print the name of this Value out to the specified raw_ostream.
214 /// This is useful when you just want to print 'int %reg126', not the
215 /// instruction that generated it. If you specify a Module for context, then
216 /// even constanst get pretty-printed; for example, the type of a null
217 /// pointer is printed symbolically.
218 void printAsOperand(raw_ostream
&O
, bool PrintType
= true,
219 const Module
*M
= nullptr) const;
221 /// \brief All values are typed, get the type of this value.
222 Type
*getType() const { return VTy
; }
224 /// \brief All values hold a context through their type.
225 LLVMContext
&getContext() const;
227 // \brief All values can potentially be named.
228 bool hasName() const { return getValueName() != nullptr; }
229 ValueName
*getValueName() const { return NameAndIsUsedByMD
.getPointer(); }
230 void setValueName(ValueName
*VN
) { NameAndIsUsedByMD
.setPointer(VN
); }
233 void destroyValueName();
236 /// \brief Return a constant reference to the value's name.
238 /// This is cheap and guaranteed to return the same reference as long as the
239 /// value is not modified.
240 StringRef
getName() const;
242 /// \brief Change the name of the value.
244 /// Choose a new unique name if the provided name is taken.
246 /// \param Name The new name; or "" if the value's name should be removed.
247 void setName(const Twine
&Name
);
250 /// \brief Transfer the name from V to this value.
252 /// After taking V's name, sets V's name to empty.
254 /// \note It is an error to call V->takeName(V).
255 void takeName(Value
*V
);
257 /// \brief Change all uses of this to point to a new Value.
259 /// Go through the uses list for this definition and make each use point to
260 /// "V" instead of "this". After this completes, 'this's use list is
261 /// guaranteed to be empty.
262 void replaceAllUsesWith(Value
*V
);
264 /// replaceUsesOutsideBlock - Go through the uses list for this definition and
265 /// make each use point to "V" instead of "this" when the use is outside the
266 /// block. 'This's use list is expected to have at least one element.
267 /// Unlike replaceAllUsesWith this function does not support basic block
268 /// values or constant users.
269 void replaceUsesOutsideBlock(Value
*V
, BasicBlock
*BB
);
271 //----------------------------------------------------------------------
272 // Methods for handling the chain of uses of this Value.
274 bool use_empty() const { return UseList
== nullptr; }
276 typedef use_iterator_impl
<Use
> use_iterator
;
277 typedef use_iterator_impl
<const Use
> const_use_iterator
;
278 use_iterator
use_begin() { return use_iterator(UseList
); }
279 const_use_iterator
use_begin() const { return const_use_iterator(UseList
); }
280 use_iterator
use_end() { return use_iterator(); }
281 const_use_iterator
use_end() const { return const_use_iterator(); }
282 iterator_range
<use_iterator
> uses() {
283 return iterator_range
<use_iterator
>(use_begin(), use_end());
285 iterator_range
<const_use_iterator
> uses() const {
286 return iterator_range
<const_use_iterator
>(use_begin(), use_end());
289 bool user_empty() const { return UseList
== nullptr; }
291 typedef user_iterator_impl
<User
> user_iterator
;
292 typedef user_iterator_impl
<const User
> const_user_iterator
;
293 user_iterator
user_begin() { return user_iterator(UseList
); }
294 const_user_iterator
user_begin() const { return const_user_iterator(UseList
); }
295 user_iterator
user_end() { return user_iterator(); }
296 const_user_iterator
user_end() const { return const_user_iterator(); }
297 User
*user_back() { return *user_begin(); }
298 const User
*user_back() const { return *user_begin(); }
299 iterator_range
<user_iterator
> users() {
300 return iterator_range
<user_iterator
>(user_begin(), user_end());
302 iterator_range
<const_user_iterator
> users() const {
303 return iterator_range
<const_user_iterator
>(user_begin(), user_end());
306 /// \brief Return true if there is exactly one user of this value.
308 /// This is specialized because it is a common request and does not require
309 /// traversing the whole use list.
310 bool hasOneUse() const {
311 const_use_iterator I
= use_begin(), E
= use_end();
312 if (I
== E
) return false;
316 /// \brief Return true if this Value has exactly N users.
317 bool hasNUses(unsigned N
) const;
319 /// \brief Return true if this value has N users or more.
321 /// This is logically equivalent to getNumUses() >= N.
322 bool hasNUsesOrMore(unsigned N
) const;
324 /// \brief Check if this value is used in the specified basic block.
325 bool isUsedInBasicBlock(const BasicBlock
*BB
) const;
327 /// \brief This method computes the number of uses of this Value.
329 /// This is a linear time operation. Use hasOneUse, hasNUses, or
330 /// hasNUsesOrMore to check for specific values.
331 unsigned getNumUses() const;
333 /// \brief This method should only be used by the Use class.
334 void addUse(Use
&U
) { U
.addToList(&UseList
); }
336 /// \brief Concrete subclass of this.
338 /// An enumeration for keeping track of the concrete subclass of Value that
339 /// is actually instantiated. Values of this enumeration are kept in the
340 /// Value classes SubclassID field. They are used for concrete type
343 ArgumentVal
, // This is an instance of Argument
344 BasicBlockVal
, // This is an instance of BasicBlock
345 FunctionVal
, // This is an instance of Function
346 GlobalAliasVal
, // This is an instance of GlobalAlias
347 GlobalVariableVal
, // This is an instance of GlobalVariable
348 UndefValueVal
, // This is an instance of UndefValue
349 BlockAddressVal
, // This is an instance of BlockAddress
350 ConstantExprVal
, // This is an instance of ConstantExpr
351 ConstantAggregateZeroVal
, // This is an instance of ConstantAggregateZero
352 ConstantDataArrayVal
, // This is an instance of ConstantDataArray
353 ConstantDataVectorVal
, // This is an instance of ConstantDataVector
354 ConstantIntVal
, // This is an instance of ConstantInt
355 ConstantFPVal
, // This is an instance of ConstantFP
356 ConstantArrayVal
, // This is an instance of ConstantArray
357 ConstantStructVal
, // This is an instance of ConstantStruct
358 ConstantVectorVal
, // This is an instance of ConstantVector
359 ConstantPointerNullVal
, // This is an instance of ConstantPointerNull
360 MetadataAsValueVal
, // This is an instance of MetadataAsValue
361 InlineAsmVal
, // This is an instance of InlineAsm
362 InstructionVal
, // This is an instance of Instruction
363 // Enum values starting at InstructionVal are used for Instructions;
364 // don't add new values here!
367 ConstantFirstVal
= FunctionVal
,
368 ConstantLastVal
= ConstantPointerNullVal
371 /// \brief Return an ID for the concrete type of this object.
373 /// This is used to implement the classof checks. This should not be used
374 /// for any other purpose, as the values may change as LLVM evolves. Also,
375 /// note that for instructions, the Instruction's opcode is added to
376 /// InstructionVal. So this means three things:
377 /// # there is no value with code InstructionVal (no opcode==0).
378 /// # there are more possible values for the value type than in ValueTy enum.
379 /// # the InstructionVal enumerator must be the highest valued enumerator in
380 /// the ValueTy enum.
381 unsigned getValueID() const {
385 /// \brief Return the raw optional flags value contained in this value.
387 /// This should only be used when testing two Values for equivalence.
388 unsigned getRawSubclassOptionalData() const {
389 return SubclassOptionalData
;
392 /// \brief Clear the optional flags contained in this value.
393 void clearSubclassOptionalData() {
394 SubclassOptionalData
= 0;
397 /// \brief Check the optional flags for equality.
398 bool hasSameSubclassOptionalData(const Value
*V
) const {
399 return SubclassOptionalData
== V
->SubclassOptionalData
;
402 /// \brief Clear any optional flags not set in the given Value.
403 void intersectOptionalDataWith(const Value
*V
) {
404 SubclassOptionalData
&= V
->SubclassOptionalData
;
407 /// \brief Return true if there is a value handle associated with this value.
408 bool hasValueHandle() const { return HasValueHandle
; }
410 /// \brief Return true if there is metadata referencing this value.
411 bool isUsedByMetadata() const { return NameAndIsUsedByMD
.getInt(); }
413 /// \brief Strip off pointer casts, all-zero GEPs, and aliases.
415 /// Returns the original uncasted value. If this is called on a non-pointer
416 /// value, it returns 'this'.
417 Value
*stripPointerCasts();
418 const Value
*stripPointerCasts() const {
419 return const_cast<Value
*>(this)->stripPointerCasts();
422 /// \brief Strip off pointer casts and all-zero GEPs.
424 /// Returns the original uncasted value. If this is called on a non-pointer
425 /// value, it returns 'this'.
426 Value
*stripPointerCastsNoFollowAliases();
427 const Value
*stripPointerCastsNoFollowAliases() const {
428 return const_cast<Value
*>(this)->stripPointerCastsNoFollowAliases();
431 /// \brief Strip off pointer casts and all-constant inbounds GEPs.
433 /// Returns the original pointer value. If this is called on a non-pointer
434 /// value, it returns 'this'.
435 Value
*stripInBoundsConstantOffsets();
436 const Value
*stripInBoundsConstantOffsets() const {
437 return const_cast<Value
*>(this)->stripInBoundsConstantOffsets();
440 /// \brief Accumulate offsets from \a stripInBoundsConstantOffsets().
442 /// Stores the resulting constant offset stripped into the APInt provided.
443 /// The provided APInt will be extended or truncated as needed to be the
444 /// correct bitwidth for an offset of this pointer type.
446 /// If this is called on a non-pointer value, it returns 'this'.
447 Value
*stripAndAccumulateInBoundsConstantOffsets(const DataLayout
&DL
,
449 const Value
*stripAndAccumulateInBoundsConstantOffsets(const DataLayout
&DL
,
450 APInt
&Offset
) const {
451 return const_cast<Value
*>(this)
452 ->stripAndAccumulateInBoundsConstantOffsets(DL
, Offset
);
455 /// \brief Strip off pointer casts and inbounds GEPs.
457 /// Returns the original pointer value. If this is called on a non-pointer
458 /// value, it returns 'this'.
459 Value
*stripInBoundsOffsets();
460 const Value
*stripInBoundsOffsets() const {
461 return const_cast<Value
*>(this)->stripInBoundsOffsets();
464 /// \brief Check if this is always a dereferenceable pointer.
466 /// Test if this value is always a pointer to allocated and suitably aligned
467 /// memory for a simple load or store.
468 bool isDereferenceablePointer(const DataLayout
*DL
= nullptr) const;
470 /// \brief Translate PHI node to its predecessor from the given basic block.
472 /// If this value is a PHI node with CurBB as its parent, return the value in
473 /// the PHI node corresponding to PredBB. If not, return ourself. This is
474 /// useful if you want to know the value something has in a predecessor
476 Value
*DoPHITranslation(const BasicBlock
*CurBB
, const BasicBlock
*PredBB
);
478 const Value
*DoPHITranslation(const BasicBlock
*CurBB
,
479 const BasicBlock
*PredBB
) const{
480 return const_cast<Value
*>(this)->DoPHITranslation(CurBB
, PredBB
);
483 /// \brief The maximum alignment for instructions.
485 /// This is the greatest alignment value supported by load, store, and alloca
486 /// instructions, and global values.
487 static const unsigned MaximumAlignment
= 1u << 29;
489 /// \brief Mutate the type of this Value to be of the specified type.
491 /// Note that this is an extremely dangerous operation which can create
492 /// completely invalid IR very easily. It is strongly recommended that you
493 /// recreate IR objects with the right types instead of mutating them in
495 void mutateType(Type
*Ty
) {
499 /// \brief Sort the use-list.
501 /// Sorts the Value's use-list by Cmp using a stable mergesort. Cmp is
502 /// expected to compare two \a Use references.
503 template <class Compare
> void sortUseList(Compare Cmp
);
505 /// \brief Reverse the use-list.
506 void reverseUseList();
509 /// \brief Merge two lists together.
511 /// Merges \c L and \c R using \c Cmp. To enable stable sorts, always pushes
512 /// "equal" items from L before items from R.
514 /// \return the first element in the list.
516 /// \note Completely ignores \a Use::Prev (doesn't read, doesn't update).
517 template <class Compare
>
518 static Use
*mergeUseLists(Use
*L
, Use
*R
, Compare Cmp
) {
520 mergeUseListsImpl(L
, R
, &Merged
, Cmp
);
524 /// \brief Tail-recursive helper for \a mergeUseLists().
526 /// \param[out] Next the first element in the list.
527 template <class Compare
>
528 static void mergeUseListsImpl(Use
*L
, Use
*R
, Use
**Next
, Compare Cmp
);
531 unsigned short getSubclassDataFromValue() const { return SubclassData
; }
532 void setValueSubclassData(unsigned short D
) { SubclassData
= D
; }
535 inline raw_ostream
&operator<<(raw_ostream
&OS
, const Value
&V
) {
540 void Use::set(Value
*V
) {
541 if (Val
) removeFromList();
543 if (V
) V
->addUse(*this);
546 template <class Compare
> void Value::sortUseList(Compare Cmp
) {
547 if (!UseList
|| !UseList
->Next
)
548 // No need to sort 0 or 1 uses.
551 // Note: this function completely ignores Prev pointers until the end when
552 // they're fixed en masse.
554 // Create a binomial vector of sorted lists, visiting uses one at a time and
555 // merging lists as necessary.
556 const unsigned MaxSlots
= 32;
557 Use
*Slots
[MaxSlots
];
559 // Collect the first use, turning it into a single-item list.
560 Use
*Next
= UseList
->Next
;
561 UseList
->Next
= nullptr;
562 unsigned NumSlots
= 1;
565 // Collect all but the last use.
568 Next
= Current
->Next
;
570 // Turn Current into a single-item list.
571 Current
->Next
= nullptr;
573 // Save Current in the first available slot, merging on collisions.
575 for (I
= 0; I
< NumSlots
; ++I
) {
579 // Merge two lists, doubling the size of Current and emptying slot I.
581 // Since the uses in Slots[I] originally preceded those in Current, send
582 // Slots[I] in as the left parameter to maintain a stable sort.
583 Current
= mergeUseLists(Slots
[I
], Current
, Cmp
);
586 // Check if this is a new slot.
589 assert(NumSlots
<= MaxSlots
&& "Use list bigger than 2^32");
592 // Found an open slot.
596 // Merge all the lists together.
597 assert(Next
&& "Expected one more Use");
598 assert(!Next
->Next
&& "Expected only one Use");
600 for (unsigned I
= 0; I
< NumSlots
; ++I
)
602 // Since the uses in Slots[I] originally preceded those in UseList, send
603 // Slots[I] in as the left parameter to maintain a stable sort.
604 UseList
= mergeUseLists(Slots
[I
], UseList
, Cmp
);
606 // Fix the Prev pointers.
607 for (Use
*I
= UseList
, **Prev
= &UseList
; I
; I
= I
->Next
) {
613 template <class Compare
>
614 void Value::mergeUseListsImpl(Use
*L
, Use
*R
, Use
**Next
, Compare Cmp
) {
625 mergeUseListsImpl(L
, R
->Next
, &R
->Next
, Cmp
);
629 mergeUseListsImpl(L
->Next
, R
, &L
->Next
, Cmp
);
632 // isa - Provide some specializations of isa so that we don't have to include
633 // the subtype header files to test to see if the value is a subclass...
635 template <> struct isa_impl
<Constant
, Value
> {
636 static inline bool doit(const Value
&Val
) {
637 return Val
.getValueID() >= Value::ConstantFirstVal
&&
638 Val
.getValueID() <= Value::ConstantLastVal
;
642 template <> struct isa_impl
<Argument
, Value
> {
643 static inline bool doit (const Value
&Val
) {
644 return Val
.getValueID() == Value::ArgumentVal
;
648 template <> struct isa_impl
<InlineAsm
, Value
> {
649 static inline bool doit(const Value
&Val
) {
650 return Val
.getValueID() == Value::InlineAsmVal
;
654 template <> struct isa_impl
<Instruction
, Value
> {
655 static inline bool doit(const Value
&Val
) {
656 return Val
.getValueID() >= Value::InstructionVal
;
660 template <> struct isa_impl
<BasicBlock
, Value
> {
661 static inline bool doit(const Value
&Val
) {
662 return Val
.getValueID() == Value::BasicBlockVal
;
666 template <> struct isa_impl
<Function
, Value
> {
667 static inline bool doit(const Value
&Val
) {
668 return Val
.getValueID() == Value::FunctionVal
;
672 template <> struct isa_impl
<GlobalVariable
, Value
> {
673 static inline bool doit(const Value
&Val
) {
674 return Val
.getValueID() == Value::GlobalVariableVal
;
678 template <> struct isa_impl
<GlobalAlias
, Value
> {
679 static inline bool doit(const Value
&Val
) {
680 return Val
.getValueID() == Value::GlobalAliasVal
;
684 template <> struct isa_impl
<GlobalValue
, Value
> {
685 static inline bool doit(const Value
&Val
) {
686 return isa
<GlobalObject
>(Val
) || isa
<GlobalAlias
>(Val
);
690 template <> struct isa_impl
<GlobalObject
, Value
> {
691 static inline bool doit(const Value
&Val
) {
692 return isa
<GlobalVariable
>(Val
) || isa
<Function
>(Val
);
696 // Value* is only 4-byte aligned.
698 class PointerLikeTypeTraits
<Value
*> {
701 static inline void *getAsVoidPointer(PT P
) { return P
; }
702 static inline PT
getFromVoidPointer(void *P
) {
703 return static_cast<PT
>(P
);
705 enum { NumLowBitsAvailable
= 2 };
708 // Create wrappers for C Binding types (see CBindingWrapping.h).
709 DEFINE_ISA_CONVERSION_FUNCTIONS(Value
, LLVMValueRef
)
711 /* Specialized opaque value conversions.
713 inline Value
**unwrap(LLVMValueRef
*Vals
) {
714 return reinterpret_cast<Value
**>(Vals
);
718 inline T
**unwrap(LLVMValueRef
*Vals
, unsigned Length
) {
720 for (LLVMValueRef
*I
= Vals
, *E
= Vals
+ Length
; I
!= E
; ++I
)
724 return reinterpret_cast<T
**>(Vals
);
727 inline LLVMValueRef
*wrap(const Value
**Vals
) {
728 return reinterpret_cast<LLVMValueRef
*>(const_cast<Value
**>(Vals
));
731 } // End llvm namespace