1 //===- llvm/Value.h - Definition of the Value class -------------*- C++ -*-===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 // This file declares the Value class.
11 //===----------------------------------------------------------------------===//
13 #ifndef LLVM_IR_VALUE_H
14 #define LLVM_IR_VALUE_H
16 #include "llvm-c/Types.h"
17 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/ADT/iterator_range.h"
19 #include "llvm/IR/Use.h"
20 #include "llvm/Support/Alignment.h"
21 #include "llvm/Support/CBindingWrapping.h"
22 #include "llvm/Support/Casting.h"
34 class ConstantAggregate
;
39 class GlobalIndirectSymbol
;
47 class ModuleSlotTracker
;
49 template<typename ValueTy
> class StringMapEntry
;
55 using ValueName
= StringMapEntry
<Value
*>;
57 //===----------------------------------------------------------------------===//
59 //===----------------------------------------------------------------------===//
61 /// LLVM Value Representation
63 /// This is a very important LLVM class. It is the base class of all values
64 /// computed by a program that may be used as operands to other values. Value is
65 /// the super class of other important classes such as Instruction and Function.
66 /// All Values have a Type. Type is not a subclass of Value. Some values can
67 /// have a name and they belong to some Module. Setting the name on the Value
68 /// automatically updates the module's symbol table.
70 /// Every value has a "use list" that keeps track of which other Values are
71 /// using this Value. A Value can also have an arbitrary number of ValueHandle
72 /// objects that watch it and listen to RAUW and Destroy events. See
73 /// llvm/IR/ValueHandle.h for details.
75 // The least-significant bit of the first word of Value *must* be zero:
76 // http://www.llvm.org/docs/ProgrammersManual.html#the-waymarking-algorithm
80 friend class ValueAsMetadata
; // Allow access to IsUsedByMD.
81 friend class ValueHandleBase
;
83 const unsigned char SubclassID
; // Subclass identifier (for isa/dyn_cast)
84 unsigned char HasValueHandle
: 1; // Has a ValueHandle pointing to this?
87 /// Hold subclass data that can be dropped.
89 /// This member is similar to SubclassData, however it is for holding
90 /// information which may be used to aid optimization, but which may be
91 /// cleared to zero without affecting conservative interpretation.
92 unsigned char SubclassOptionalData
: 7;
95 /// Hold arbitrary subclass data.
97 /// This member is defined by this class, but is not used for anything.
98 /// Subclasses can use it to hold whatever state they find useful. This
99 /// field is initialized to zero by the ctor.
100 unsigned short SubclassData
;
103 /// The number of operands in the subclass.
105 /// This member is defined by this class, but not used for anything.
106 /// Subclasses can use it to store their number of operands, if they have
109 /// This is stored here to save space in User on 64-bit hosts. Since most
110 /// instances of Value have operands, 32-bit hosts aren't significantly
113 /// Note, this should *NOT* be used directly by any class other than User.
114 /// User uses this value to find the Use list.
115 enum : unsigned { NumUserOperandsBits
= 28 };
116 unsigned NumUserOperands
: NumUserOperandsBits
;
118 // Use the same type as the bitfield above so that MSVC will pack them.
119 unsigned IsUsedByMD
: 1;
120 unsigned HasName
: 1;
121 unsigned HasHungOffUses
: 1;
122 unsigned HasDescriptor
: 1;
125 template <typename UseT
> // UseT == 'Use' or 'const Use'
126 class use_iterator_impl
127 : public std::iterator
<std::forward_iterator_tag
, UseT
*> {
132 explicit use_iterator_impl(UseT
*u
) : U(u
) {}
135 use_iterator_impl() : U() {}
137 bool operator==(const use_iterator_impl
&x
) const { return U
== x
.U
; }
138 bool operator!=(const use_iterator_impl
&x
) const { return !operator==(x
); }
140 use_iterator_impl
&operator++() { // Preincrement
141 assert(U
&& "Cannot increment end iterator!");
146 use_iterator_impl
operator++(int) { // Postincrement
152 UseT
&operator*() const {
153 assert(U
&& "Cannot dereference end iterator!");
157 UseT
*operator->() const { return &operator*(); }
159 operator use_iterator_impl
<const UseT
>() const {
160 return use_iterator_impl
<const UseT
>(U
);
164 template <typename UserTy
> // UserTy == 'User' or 'const User'
165 class user_iterator_impl
166 : public std::iterator
<std::forward_iterator_tag
, UserTy
*> {
167 use_iterator_impl
<Use
> UI
;
168 explicit user_iterator_impl(Use
*U
) : UI(U
) {}
172 user_iterator_impl() = default;
174 bool operator==(const user_iterator_impl
&x
) const { return UI
== x
.UI
; }
175 bool operator!=(const user_iterator_impl
&x
) const { return !operator==(x
); }
177 /// Returns true if this iterator is equal to user_end() on the value.
178 bool atEnd() const { return *this == user_iterator_impl(); }
180 user_iterator_impl
&operator++() { // Preincrement
185 user_iterator_impl
operator++(int) { // Postincrement
191 // Retrieve a pointer to the current User.
192 UserTy
*operator*() const {
193 return UI
->getUser();
196 UserTy
*operator->() const { return operator*(); }
198 operator user_iterator_impl
<const UserTy
>() const {
199 return user_iterator_impl
<const UserTy
>(*UI
);
202 Use
&getUse() const { return *UI
; }
206 Value(Type
*Ty
, unsigned scid
);
208 /// Value's destructor should be virtual by design, but that would require
209 /// that Value and all of its subclasses have a vtable that effectively
210 /// duplicates the information in the value ID. As a size optimization, the
211 /// destructor has been protected, and the caller should manually call
213 ~Value(); // Use deleteValue() to delete a generic Value.
216 Value(const Value
&) = delete;
217 Value
&operator=(const Value
&) = delete;
219 /// Delete a pointer to a generic Value.
222 /// Support for debugging, callable in GDB: V->dump()
225 /// Implement operator<< on Value.
227 void print(raw_ostream
&O
, bool IsForDebug
= false) const;
228 void print(raw_ostream
&O
, ModuleSlotTracker
&MST
,
229 bool IsForDebug
= false) const;
232 /// Print the name of this Value out to the specified raw_ostream.
234 /// This is useful when you just want to print 'int %reg126', not the
235 /// instruction that generated it. If you specify a Module for context, then
236 /// even constanst get pretty-printed; for example, the type of a null
237 /// pointer is printed symbolically.
239 void printAsOperand(raw_ostream
&O
, bool PrintType
= true,
240 const Module
*M
= nullptr) const;
241 void printAsOperand(raw_ostream
&O
, bool PrintType
,
242 ModuleSlotTracker
&MST
) const;
245 /// All values are typed, get the type of this value.
246 Type
*getType() const { return VTy
; }
248 /// All values hold a context through their type.
249 LLVMContext
&getContext() const;
251 // All values can potentially be named.
252 bool hasName() const { return HasName
; }
253 ValueName
*getValueName() const;
254 void setValueName(ValueName
*VN
);
257 void destroyValueName();
258 enum class ReplaceMetadataUses
{ No
, Yes
};
259 void doRAUW(Value
*New
, ReplaceMetadataUses
);
260 void setNameImpl(const Twine
&Name
);
263 /// Return a constant reference to the value's name.
265 /// This guaranteed to return the same reference as long as the value is not
266 /// modified. If the value has a name, this does a hashtable lookup, so it's
268 StringRef
getName() const;
270 /// Change the name of the value.
272 /// Choose a new unique name if the provided name is taken.
274 /// \param Name The new name; or "" if the value's name should be removed.
275 void setName(const Twine
&Name
);
277 /// Transfer the name from V to this value.
279 /// After taking V's name, sets V's name to empty.
281 /// \note It is an error to call V->takeName(V).
282 void takeName(Value
*V
);
284 /// Change all uses of this to point to a new Value.
286 /// Go through the uses list for this definition and make each use point to
287 /// "V" instead of "this". After this completes, 'this's use list is
288 /// guaranteed to be empty.
289 void replaceAllUsesWith(Value
*V
);
291 /// Change non-metadata uses of this to point to a new Value.
293 /// Go through the uses list for this definition and make each use point to
294 /// "V" instead of "this". This function skips metadata entries in the list.
295 void replaceNonMetadataUsesWith(Value
*V
);
297 /// Go through the uses list for this definition and make each use point
298 /// to "V" if the callback ShouldReplace returns true for the given Use.
299 /// Unlike replaceAllUsesWith() this function does not support basic block
300 /// values or constant users.
301 void replaceUsesWithIf(Value
*New
,
302 llvm::function_ref
<bool(Use
&U
)> ShouldReplace
) {
303 assert(New
&& "Value::replaceUsesWithIf(<null>) is invalid!");
304 assert(New
->getType() == getType() &&
305 "replaceUses of value with new value of different type!");
307 for (use_iterator UI
= use_begin(), E
= use_end(); UI
!= E
;) {
310 if (!ShouldReplace(U
))
316 /// replaceUsesOutsideBlock - Go through the uses list for this definition and
317 /// make each use point to "V" instead of "this" when the use is outside the
318 /// block. 'This's use list is expected to have at least one element.
319 /// Unlike replaceAllUsesWith() this function does not support basic block
320 /// values or constant users.
321 void replaceUsesOutsideBlock(Value
*V
, BasicBlock
*BB
);
323 //----------------------------------------------------------------------
324 // Methods for handling the chain of uses of this Value.
326 // Materializing a function can introduce new uses, so these methods come in
328 // The methods that start with materialized_ check the uses that are
329 // currently known given which functions are materialized. Be very careful
330 // when using them since you might not get all uses.
331 // The methods that don't start with materialized_ assert that modules is
332 // fully materialized.
333 void assertModuleIsMaterializedImpl() const;
334 // This indirection exists so we can keep assertModuleIsMaterializedImpl()
335 // around in release builds of Value.cpp to be linked with other code built
336 // in debug mode. But this avoids calling it in any of the release built code.
337 void assertModuleIsMaterialized() const {
339 assertModuleIsMaterializedImpl();
343 bool use_empty() const {
344 assertModuleIsMaterialized();
345 return UseList
== nullptr;
348 bool materialized_use_empty() const {
349 return UseList
== nullptr;
352 using use_iterator
= use_iterator_impl
<Use
>;
353 using const_use_iterator
= use_iterator_impl
<const Use
>;
355 use_iterator
materialized_use_begin() { return use_iterator(UseList
); }
356 const_use_iterator
materialized_use_begin() const {
357 return const_use_iterator(UseList
);
359 use_iterator
use_begin() {
360 assertModuleIsMaterialized();
361 return materialized_use_begin();
363 const_use_iterator
use_begin() const {
364 assertModuleIsMaterialized();
365 return materialized_use_begin();
367 use_iterator
use_end() { return use_iterator(); }
368 const_use_iterator
use_end() const { return const_use_iterator(); }
369 iterator_range
<use_iterator
> materialized_uses() {
370 return make_range(materialized_use_begin(), use_end());
372 iterator_range
<const_use_iterator
> materialized_uses() const {
373 return make_range(materialized_use_begin(), use_end());
375 iterator_range
<use_iterator
> uses() {
376 assertModuleIsMaterialized();
377 return materialized_uses();
379 iterator_range
<const_use_iterator
> uses() const {
380 assertModuleIsMaterialized();
381 return materialized_uses();
384 bool user_empty() const {
385 assertModuleIsMaterialized();
386 return UseList
== nullptr;
389 using user_iterator
= user_iterator_impl
<User
>;
390 using const_user_iterator
= user_iterator_impl
<const User
>;
392 user_iterator
materialized_user_begin() { return user_iterator(UseList
); }
393 const_user_iterator
materialized_user_begin() const {
394 return const_user_iterator(UseList
);
396 user_iterator
user_begin() {
397 assertModuleIsMaterialized();
398 return materialized_user_begin();
400 const_user_iterator
user_begin() const {
401 assertModuleIsMaterialized();
402 return materialized_user_begin();
404 user_iterator
user_end() { return user_iterator(); }
405 const_user_iterator
user_end() const { return const_user_iterator(); }
407 assertModuleIsMaterialized();
408 return *materialized_user_begin();
410 const User
*user_back() const {
411 assertModuleIsMaterialized();
412 return *materialized_user_begin();
414 iterator_range
<user_iterator
> materialized_users() {
415 return make_range(materialized_user_begin(), user_end());
417 iterator_range
<const_user_iterator
> materialized_users() const {
418 return make_range(materialized_user_begin(), user_end());
420 iterator_range
<user_iterator
> users() {
421 assertModuleIsMaterialized();
422 return materialized_users();
424 iterator_range
<const_user_iterator
> users() const {
425 assertModuleIsMaterialized();
426 return materialized_users();
429 /// Return true if there is exactly one user of this value.
431 /// This is specialized because it is a common request and does not require
432 /// traversing the whole use list.
433 bool hasOneUse() const {
434 const_use_iterator I
= use_begin(), E
= use_end();
435 if (I
== E
) return false;
439 /// Return true if this Value has exactly N users.
440 bool hasNUses(unsigned N
) const;
442 /// Return true if this value has N users or more.
444 /// This is logically equivalent to getNumUses() >= N.
445 bool hasNUsesOrMore(unsigned N
) const;
447 /// Check if this value is used in the specified basic block.
448 bool isUsedInBasicBlock(const BasicBlock
*BB
) const;
450 /// This method computes the number of uses of this Value.
452 /// This is a linear time operation. Use hasOneUse, hasNUses, or
453 /// hasNUsesOrMore to check for specific values.
454 unsigned getNumUses() const;
456 /// This method should only be used by the Use class.
457 void addUse(Use
&U
) { U
.addToList(&UseList
); }
459 /// Concrete subclass of this.
461 /// An enumeration for keeping track of the concrete subclass of Value that
462 /// is actually instantiated. Values of this enumeration are kept in the
463 /// Value classes SubclassID field. They are used for concrete type
466 #define HANDLE_VALUE(Name) Name##Val,
467 #include "llvm/IR/Value.def"
470 #define HANDLE_CONSTANT_MARKER(Marker, Constant) Marker = Constant##Val,
471 #include "llvm/IR/Value.def"
474 /// Return an ID for the concrete type of this object.
476 /// This is used to implement the classof checks. This should not be used
477 /// for any other purpose, as the values may change as LLVM evolves. Also,
478 /// note that for instructions, the Instruction's opcode is added to
479 /// InstructionVal. So this means three things:
480 /// # there is no value with code InstructionVal (no opcode==0).
481 /// # there are more possible values for the value type than in ValueTy enum.
482 /// # the InstructionVal enumerator must be the highest valued enumerator in
483 /// the ValueTy enum.
484 unsigned getValueID() const {
488 /// Return the raw optional flags value contained in this value.
490 /// This should only be used when testing two Values for equivalence.
491 unsigned getRawSubclassOptionalData() const {
492 return SubclassOptionalData
;
495 /// Clear the optional flags contained in this value.
496 void clearSubclassOptionalData() {
497 SubclassOptionalData
= 0;
500 /// Check the optional flags for equality.
501 bool hasSameSubclassOptionalData(const Value
*V
) const {
502 return SubclassOptionalData
== V
->SubclassOptionalData
;
505 /// Return true if there is a value handle associated with this value.
506 bool hasValueHandle() const { return HasValueHandle
; }
508 /// Return true if there is metadata referencing this value.
509 bool isUsedByMetadata() const { return IsUsedByMD
; }
511 /// Return true if this value is a swifterror value.
513 /// swifterror values can be either a function argument or an alloca with a
514 /// swifterror attribute.
515 bool isSwiftError() const;
517 /// Strip off pointer casts, all-zero GEPs and address space casts.
519 /// Returns the original uncasted value. If this is called on a non-pointer
520 /// value, it returns 'this'.
521 const Value
*stripPointerCasts() const;
522 Value
*stripPointerCasts() {
523 return const_cast<Value
*>(
524 static_cast<const Value
*>(this)->stripPointerCasts());
527 /// Strip off pointer casts, all-zero GEPs, address space casts, and aliases.
529 /// Returns the original uncasted value. If this is called on a non-pointer
530 /// value, it returns 'this'.
531 const Value
*stripPointerCastsAndAliases() const;
532 Value
*stripPointerCastsAndAliases() {
533 return const_cast<Value
*>(
534 static_cast<const Value
*>(this)->stripPointerCastsAndAliases());
537 /// Strip off pointer casts, all-zero GEPs and address space casts
538 /// but ensures the representation of the result stays the same.
540 /// Returns the original uncasted value with the same representation. If this
541 /// is called on a non-pointer value, it returns 'this'.
542 const Value
*stripPointerCastsSameRepresentation() const;
543 Value
*stripPointerCastsSameRepresentation() {
544 return const_cast<Value
*>(static_cast<const Value
*>(this)
545 ->stripPointerCastsSameRepresentation());
548 /// Strip off pointer casts, all-zero GEPs and invariant group info.
550 /// Returns the original uncasted value. If this is called on a non-pointer
551 /// value, it returns 'this'. This function should be used only in
553 const Value
*stripPointerCastsAndInvariantGroups() const;
554 Value
*stripPointerCastsAndInvariantGroups() {
555 return const_cast<Value
*>(static_cast<const Value
*>(this)
556 ->stripPointerCastsAndInvariantGroups());
559 /// Strip off pointer casts and all-constant inbounds GEPs.
561 /// Returns the original pointer value. If this is called on a non-pointer
562 /// value, it returns 'this'.
563 const Value
*stripInBoundsConstantOffsets() const;
564 Value
*stripInBoundsConstantOffsets() {
565 return const_cast<Value
*>(
566 static_cast<const Value
*>(this)->stripInBoundsConstantOffsets());
569 /// Accumulate the constant offset this value has compared to a base pointer.
570 /// Only 'getelementptr' instructions (GEPs) with constant indices are
571 /// accumulated but other instructions, e.g., casts, are stripped away as
572 /// well. The accumulated constant offset is added to \p Offset and the base
573 /// pointer is returned.
575 /// The APInt \p Offset has to have a bit-width equal to the IntPtr type for
576 /// the address space of 'this' pointer value, e.g., use
577 /// DataLayout::getIndexTypeSizeInBits(Ty).
579 /// If \p AllowNonInbounds is true, constant offsets in GEPs are stripped and
580 /// accumulated even if the GEP is not "inbounds".
582 /// If this is called on a non-pointer value, it returns 'this' and the
583 /// \p Offset is not modified.
585 /// Note that this function will never return a nullptr. It will also never
586 /// manipulate the \p Offset in a way that would not match the difference
587 /// between the underlying value and the returned one. Thus, if no constant
588 /// offset was found, the returned value is the underlying one and \p Offset
590 const Value
*stripAndAccumulateConstantOffsets(const DataLayout
&DL
,
592 bool AllowNonInbounds
) const;
593 Value
*stripAndAccumulateConstantOffsets(const DataLayout
&DL
, APInt
&Offset
,
594 bool AllowNonInbounds
) {
595 return const_cast<Value
*>(
596 static_cast<const Value
*>(this)->stripAndAccumulateConstantOffsets(
597 DL
, Offset
, AllowNonInbounds
));
600 /// This is a wrapper around stripAndAccumulateConstantOffsets with the
601 /// in-bounds requirement set to false.
602 const Value
*stripAndAccumulateInBoundsConstantOffsets(const DataLayout
&DL
,
603 APInt
&Offset
) const {
604 return stripAndAccumulateConstantOffsets(DL
, Offset
,
605 /* AllowNonInbounds */ false);
607 Value
*stripAndAccumulateInBoundsConstantOffsets(const DataLayout
&DL
,
609 return stripAndAccumulateConstantOffsets(DL
, Offset
,
610 /* AllowNonInbounds */ false);
613 /// Strip off pointer casts and inbounds GEPs.
615 /// Returns the original pointer value. If this is called on a non-pointer
616 /// value, it returns 'this'.
617 const Value
*stripInBoundsOffsets() const;
618 Value
*stripInBoundsOffsets() {
619 return const_cast<Value
*>(
620 static_cast<const Value
*>(this)->stripInBoundsOffsets());
623 /// Returns the number of bytes known to be dereferenceable for the
626 /// If CanBeNull is set by this function the pointer can either be null or be
627 /// dereferenceable up to the returned number of bytes.
628 uint64_t getPointerDereferenceableBytes(const DataLayout
&DL
,
629 bool &CanBeNull
) const;
631 /// Returns an alignment of the pointer value.
633 /// Returns an alignment which is either specified explicitly, e.g. via
634 /// align attribute of a function argument, or guaranteed by DataLayout.
635 MaybeAlign
getPointerAlignment(const DataLayout
&DL
) const;
637 /// Translate PHI node to its predecessor from the given basic block.
639 /// If this value is a PHI node with CurBB as its parent, return the value in
640 /// the PHI node corresponding to PredBB. If not, return ourself. This is
641 /// useful if you want to know the value something has in a predecessor
643 const Value
*DoPHITranslation(const BasicBlock
*CurBB
,
644 const BasicBlock
*PredBB
) const;
645 Value
*DoPHITranslation(const BasicBlock
*CurBB
, const BasicBlock
*PredBB
) {
646 return const_cast<Value
*>(
647 static_cast<const Value
*>(this)->DoPHITranslation(CurBB
, PredBB
));
650 /// The maximum alignment for instructions.
652 /// This is the greatest alignment value supported by load, store, and alloca
653 /// instructions, and global values.
654 static const unsigned MaxAlignmentExponent
= 29;
655 static const unsigned MaximumAlignment
= 1u << MaxAlignmentExponent
;
657 /// Mutate the type of this Value to be of the specified type.
659 /// Note that this is an extremely dangerous operation which can create
660 /// completely invalid IR very easily. It is strongly recommended that you
661 /// recreate IR objects with the right types instead of mutating them in
663 void mutateType(Type
*Ty
) {
667 /// Sort the use-list.
669 /// Sorts the Value's use-list by Cmp using a stable mergesort. Cmp is
670 /// expected to compare two \a Use references.
671 template <class Compare
> void sortUseList(Compare Cmp
);
673 /// Reverse the use-list.
674 void reverseUseList();
677 /// Merge two lists together.
679 /// Merges \c L and \c R using \c Cmp. To enable stable sorts, always pushes
680 /// "equal" items from L before items from R.
682 /// \return the first element in the list.
684 /// \note Completely ignores \a Use::Prev (doesn't read, doesn't update).
685 template <class Compare
>
686 static Use
*mergeUseLists(Use
*L
, Use
*R
, Compare Cmp
) {
688 Use
**Next
= &Merged
;
714 unsigned short getSubclassDataFromValue() const { return SubclassData
; }
715 void setValueSubclassData(unsigned short D
) { SubclassData
= D
; }
718 struct ValueDeleter
{ void operator()(Value
*V
) { V
->deleteValue(); } };
720 /// Use this instead of std::unique_ptr<Value> or std::unique_ptr<Instruction>.
721 /// Those don't work because Value and Instruction's destructors are protected,
722 /// aren't virtual, and won't destroy the complete object.
723 using unique_value
= std::unique_ptr
<Value
, ValueDeleter
>;
725 inline raw_ostream
&operator<<(raw_ostream
&OS
, const Value
&V
) {
730 void Use::set(Value
*V
) {
731 if (Val
) removeFromList();
733 if (V
) V
->addUse(*this);
736 Value
*Use::operator=(Value
*RHS
) {
741 const Use
&Use::operator=(const Use
&RHS
) {
746 template <class Compare
> void Value::sortUseList(Compare Cmp
) {
747 if (!UseList
|| !UseList
->Next
)
748 // No need to sort 0 or 1 uses.
751 // Note: this function completely ignores Prev pointers until the end when
752 // they're fixed en masse.
754 // Create a binomial vector of sorted lists, visiting uses one at a time and
755 // merging lists as necessary.
756 const unsigned MaxSlots
= 32;
757 Use
*Slots
[MaxSlots
];
759 // Collect the first use, turning it into a single-item list.
760 Use
*Next
= UseList
->Next
;
761 UseList
->Next
= nullptr;
762 unsigned NumSlots
= 1;
765 // Collect all but the last use.
768 Next
= Current
->Next
;
770 // Turn Current into a single-item list.
771 Current
->Next
= nullptr;
773 // Save Current in the first available slot, merging on collisions.
775 for (I
= 0; I
< NumSlots
; ++I
) {
779 // Merge two lists, doubling the size of Current and emptying slot I.
781 // Since the uses in Slots[I] originally preceded those in Current, send
782 // Slots[I] in as the left parameter to maintain a stable sort.
783 Current
= mergeUseLists(Slots
[I
], Current
, Cmp
);
786 // Check if this is a new slot.
789 assert(NumSlots
<= MaxSlots
&& "Use list bigger than 2^32");
792 // Found an open slot.
796 // Merge all the lists together.
797 assert(Next
&& "Expected one more Use");
798 assert(!Next
->Next
&& "Expected only one Use");
800 for (unsigned I
= 0; I
< NumSlots
; ++I
)
802 // Since the uses in Slots[I] originally preceded those in UseList, send
803 // Slots[I] in as the left parameter to maintain a stable sort.
804 UseList
= mergeUseLists(Slots
[I
], UseList
, Cmp
);
806 // Fix the Prev pointers.
807 for (Use
*I
= UseList
, **Prev
= &UseList
; I
; I
= I
->Next
) {
813 // isa - Provide some specializations of isa so that we don't have to include
814 // the subtype header files to test to see if the value is a subclass...
816 template <> struct isa_impl
<Constant
, Value
> {
817 static inline bool doit(const Value
&Val
) {
818 static_assert(Value::ConstantFirstVal
== 0, "Val.getValueID() >= Value::ConstantFirstVal");
819 return Val
.getValueID() <= Value::ConstantLastVal
;
823 template <> struct isa_impl
<ConstantData
, Value
> {
824 static inline bool doit(const Value
&Val
) {
825 return Val
.getValueID() >= Value::ConstantDataFirstVal
&&
826 Val
.getValueID() <= Value::ConstantDataLastVal
;
830 template <> struct isa_impl
<ConstantAggregate
, Value
> {
831 static inline bool doit(const Value
&Val
) {
832 return Val
.getValueID() >= Value::ConstantAggregateFirstVal
&&
833 Val
.getValueID() <= Value::ConstantAggregateLastVal
;
837 template <> struct isa_impl
<Argument
, Value
> {
838 static inline bool doit (const Value
&Val
) {
839 return Val
.getValueID() == Value::ArgumentVal
;
843 template <> struct isa_impl
<InlineAsm
, Value
> {
844 static inline bool doit(const Value
&Val
) {
845 return Val
.getValueID() == Value::InlineAsmVal
;
849 template <> struct isa_impl
<Instruction
, Value
> {
850 static inline bool doit(const Value
&Val
) {
851 return Val
.getValueID() >= Value::InstructionVal
;
855 template <> struct isa_impl
<BasicBlock
, Value
> {
856 static inline bool doit(const Value
&Val
) {
857 return Val
.getValueID() == Value::BasicBlockVal
;
861 template <> struct isa_impl
<Function
, Value
> {
862 static inline bool doit(const Value
&Val
) {
863 return Val
.getValueID() == Value::FunctionVal
;
867 template <> struct isa_impl
<GlobalVariable
, Value
> {
868 static inline bool doit(const Value
&Val
) {
869 return Val
.getValueID() == Value::GlobalVariableVal
;
873 template <> struct isa_impl
<GlobalAlias
, Value
> {
874 static inline bool doit(const Value
&Val
) {
875 return Val
.getValueID() == Value::GlobalAliasVal
;
879 template <> struct isa_impl
<GlobalIFunc
, Value
> {
880 static inline bool doit(const Value
&Val
) {
881 return Val
.getValueID() == Value::GlobalIFuncVal
;
885 template <> struct isa_impl
<GlobalIndirectSymbol
, Value
> {
886 static inline bool doit(const Value
&Val
) {
887 return isa
<GlobalAlias
>(Val
) || isa
<GlobalIFunc
>(Val
);
891 template <> struct isa_impl
<GlobalValue
, Value
> {
892 static inline bool doit(const Value
&Val
) {
893 return isa
<GlobalObject
>(Val
) || isa
<GlobalIndirectSymbol
>(Val
);
897 template <> struct isa_impl
<GlobalObject
, Value
> {
898 static inline bool doit(const Value
&Val
) {
899 return isa
<GlobalVariable
>(Val
) || isa
<Function
>(Val
);
903 // Create wrappers for C Binding types (see CBindingWrapping.h).
904 DEFINE_ISA_CONVERSION_FUNCTIONS(Value
, LLVMValueRef
)
906 // Specialized opaque value conversions.
907 inline Value
**unwrap(LLVMValueRef
*Vals
) {
908 return reinterpret_cast<Value
**>(Vals
);
912 inline T
**unwrap(LLVMValueRef
*Vals
, unsigned Length
) {
914 for (LLVMValueRef
*I
= Vals
, *E
= Vals
+ Length
; I
!= E
; ++I
)
915 unwrap
<T
>(*I
); // For side effect of calling assert on invalid usage.
918 return reinterpret_cast<T
**>(Vals
);
921 inline LLVMValueRef
*wrap(const Value
**Vals
) {
922 return reinterpret_cast<LLVMValueRef
*>(const_cast<Value
**>(Vals
));
925 } // end namespace llvm
927 #endif // LLVM_IR_VALUE_H