1 //===- llvm/IR/Metadata.h - Metadata definitions ----------------*- 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 //===----------------------------------------------------------------------===//
10 /// This file contains the declarations for metadata subclasses.
11 /// They represent the different flavors of metadata that live in LLVM.
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_IR_METADATA_H
16 #define LLVM_IR_METADATA_H
18 #include "llvm/ADT/ArrayRef.h"
19 #include "llvm/ADT/DenseMap.h"
20 #include "llvm/ADT/DenseMapInfo.h"
21 #include "llvm/ADT/None.h"
22 #include "llvm/ADT/PointerUnion.h"
23 #include "llvm/ADT/STLExtras.h"
24 #include "llvm/ADT/SmallVector.h"
25 #include "llvm/ADT/StringRef.h"
26 #include "llvm/ADT/ilist_node.h"
27 #include "llvm/ADT/iterator_range.h"
28 #include "llvm/IR/Constant.h"
29 #include "llvm/IR/LLVMContext.h"
30 #include "llvm/IR/Value.h"
31 #include "llvm/Support/CBindingWrapping.h"
32 #include "llvm/Support/Casting.h"
33 #include "llvm/Support/ErrorHandling.h"
40 #include <type_traits>
46 class ModuleSlotTracker
;
50 enum LLVMConstants
: uint32_t {
51 DEBUG_METADATA_VERSION
= 3 // Current debug info version number.
54 /// Root of the metadata hierarchy.
56 /// This is a root class for typeless data in the IR.
58 friend class ReplaceableMetadataImpl
;
61 const unsigned char SubclassID
;
64 /// Active type of storage.
65 enum StorageType
{ Uniqued
, Distinct
, Temporary
};
67 /// Storage flag for non-uniqued, otherwise unowned, metadata.
68 unsigned char Storage
: 7;
69 // TODO: expose remaining bits to subclasses.
71 unsigned char ImplicitCode
: 1;
73 unsigned short SubclassData16
= 0;
74 unsigned SubclassData32
= 0;
78 #define HANDLE_METADATA_LEAF(CLASS) CLASS##Kind,
79 #include "llvm/IR/Metadata.def"
83 Metadata(unsigned ID
, StorageType Storage
)
84 : SubclassID(ID
), Storage(Storage
), ImplicitCode(false) {
85 static_assert(sizeof(*this) == 8, "Metadata fields poorly packed");
88 ~Metadata() = default;
90 /// Default handling of a changed operand, which asserts.
92 /// If subclasses pass themselves in as owners to a tracking node reference,
93 /// they must provide an implementation of this method.
94 void handleChangedOperand(void *, Metadata
*) {
95 llvm_unreachable("Unimplemented in Metadata subclass");
99 unsigned getMetadataID() const { return SubclassID
; }
101 /// User-friendly dump.
103 /// If \c M is provided, metadata nodes will be numbered canonically;
104 /// otherwise, pointer addresses are substituted.
106 /// Note: this uses an explicit overload instead of default arguments so that
107 /// the nullptr version is easy to call from a debugger.
111 void dump(const Module
*M
) const;
116 /// Prints definition of \c this.
118 /// If \c M is provided, metadata nodes will be numbered canonically;
119 /// otherwise, pointer addresses are substituted.
121 void print(raw_ostream
&OS
, const Module
*M
= nullptr,
122 bool IsForDebug
= false) const;
123 void print(raw_ostream
&OS
, ModuleSlotTracker
&MST
, const Module
*M
= nullptr,
124 bool IsForDebug
= false) const;
127 /// Print as operand.
129 /// Prints reference of \c this.
131 /// If \c M is provided, metadata nodes will be numbered canonically;
132 /// otherwise, pointer addresses are substituted.
134 void printAsOperand(raw_ostream
&OS
, const Module
*M
= nullptr) const;
135 void printAsOperand(raw_ostream
&OS
, ModuleSlotTracker
&MST
,
136 const Module
*M
= nullptr) const;
140 // Create wrappers for C Binding types (see CBindingWrapping.h).
141 DEFINE_ISA_CONVERSION_FUNCTIONS(Metadata
, LLVMMetadataRef
)
143 // Specialized opaque metadata conversions.
144 inline Metadata
**unwrap(LLVMMetadataRef
*MDs
) {
145 return reinterpret_cast<Metadata
**>(MDs
);
148 #define HANDLE_METADATA(CLASS) class CLASS;
149 #include "llvm/IR/Metadata.def"
151 // Provide specializations of isa so that we don't need definitions of
152 // subclasses to see if the metadata is a subclass.
153 #define HANDLE_METADATA_LEAF(CLASS) \
154 template <> struct isa_impl<CLASS, Metadata> { \
155 static inline bool doit(const Metadata &MD) { \
156 return MD.getMetadataID() == Metadata::CLASS##Kind; \
159 #include "llvm/IR/Metadata.def"
161 inline raw_ostream
&operator<<(raw_ostream
&OS
, const Metadata
&MD
) {
166 /// Metadata wrapper in the Value hierarchy.
168 /// A member of the \a Value hierarchy to represent a reference to metadata.
169 /// This allows, e.g., instrinsics to have metadata as operands.
171 /// Notably, this is the only thing in either hierarchy that is allowed to
172 /// reference \a LocalAsMetadata.
173 class MetadataAsValue
: public Value
{
174 friend class ReplaceableMetadataImpl
;
175 friend class LLVMContextImpl
;
179 MetadataAsValue(Type
*Ty
, Metadata
*MD
);
181 /// Drop use of metadata (during teardown).
182 void dropUse() { MD
= nullptr; }
187 static MetadataAsValue
*get(LLVMContext
&Context
, Metadata
*MD
);
188 static MetadataAsValue
*getIfExists(LLVMContext
&Context
, Metadata
*MD
);
190 Metadata
*getMetadata() const { return MD
; }
192 static bool classof(const Value
*V
) {
193 return V
->getValueID() == MetadataAsValueVal
;
197 void handleChangedMetadata(Metadata
*MD
);
202 /// API for tracking metadata references through RAUW and deletion.
204 /// Shared API for updating \a Metadata pointers in subclasses that support
207 /// This API is not meant to be used directly. See \a TrackingMDRef for a
208 /// user-friendly tracking reference.
209 class MetadataTracking
{
211 /// Track the reference to metadata.
213 /// Register \c MD with \c *MD, if the subclass supports tracking. If \c *MD
214 /// gets RAUW'ed, \c MD will be updated to the new address. If \c *MD gets
215 /// deleted, \c MD will be set to \c nullptr.
217 /// If tracking isn't supported, \c *MD will not change.
219 /// \return true iff tracking is supported by \c MD.
220 static bool track(Metadata
*&MD
) {
221 return track(&MD
, *MD
, static_cast<Metadata
*>(nullptr));
224 /// Track the reference to metadata for \a Metadata.
226 /// As \a track(Metadata*&), but with support for calling back to \c Owner to
227 /// tell it that its operand changed. This could trigger \c Owner being
229 static bool track(void *Ref
, Metadata
&MD
, Metadata
&Owner
) {
230 return track(Ref
, MD
, &Owner
);
233 /// Track the reference to metadata for \a MetadataAsValue.
235 /// As \a track(Metadata*&), but with support for calling back to \c Owner to
236 /// tell it that its operand changed. This could trigger \c Owner being
238 static bool track(void *Ref
, Metadata
&MD
, MetadataAsValue
&Owner
) {
239 return track(Ref
, MD
, &Owner
);
242 /// Stop tracking a reference to metadata.
244 /// Stops \c *MD from tracking \c MD.
245 static void untrack(Metadata
*&MD
) { untrack(&MD
, *MD
); }
246 static void untrack(void *Ref
, Metadata
&MD
);
248 /// Move tracking from one reference to another.
250 /// Semantically equivalent to \c untrack(MD) followed by \c track(New),
251 /// except that ownership callbacks are maintained.
253 /// Note: it is an error if \c *MD does not equal \c New.
255 /// \return true iff tracking is supported by \c MD.
256 static bool retrack(Metadata
*&MD
, Metadata
*&New
) {
257 return retrack(&MD
, *MD
, &New
);
259 static bool retrack(void *Ref
, Metadata
&MD
, void *New
);
261 /// Check whether metadata is replaceable.
262 static bool isReplaceable(const Metadata
&MD
);
264 using OwnerTy
= PointerUnion
<MetadataAsValue
*, Metadata
*>;
267 /// Track a reference to metadata for an owner.
269 /// Generalized version of tracking.
270 static bool track(void *Ref
, Metadata
&MD
, OwnerTy Owner
);
273 /// Shared implementation of use-lists for replaceable metadata.
275 /// Most metadata cannot be RAUW'ed. This is a shared implementation of
276 /// use-lists and associated API for the two that support it (\a ValueAsMetadata
277 /// and \a TempMDNode).
278 class ReplaceableMetadataImpl
{
279 friend class MetadataTracking
;
282 using OwnerTy
= MetadataTracking::OwnerTy
;
285 LLVMContext
&Context
;
286 uint64_t NextIndex
= 0;
287 SmallDenseMap
<void *, std::pair
<OwnerTy
, uint64_t>, 4> UseMap
;
290 ReplaceableMetadataImpl(LLVMContext
&Context
) : Context(Context
) {}
292 ~ReplaceableMetadataImpl() {
293 assert(UseMap
.empty() && "Cannot destroy in-use replaceable metadata");
296 LLVMContext
&getContext() const { return Context
; }
298 /// Replace all uses of this with MD.
300 /// Replace all uses of this with \c MD, which is allowed to be null.
301 void replaceAllUsesWith(Metadata
*MD
);
303 /// Resolve all uses of this.
305 /// Resolve all uses of this, turning off RAUW permanently. If \c
306 /// ResolveUsers, call \a MDNode::resolve() on any users whose last operand
308 void resolveAllUses(bool ResolveUsers
= true);
311 void addRef(void *Ref
, OwnerTy Owner
);
312 void dropRef(void *Ref
);
313 void moveRef(void *Ref
, void *New
, const Metadata
&MD
);
315 /// Lazily construct RAUW support on MD.
317 /// If this is an unresolved MDNode, RAUW support will be created on-demand.
318 /// ValueAsMetadata always has RAUW support.
319 static ReplaceableMetadataImpl
*getOrCreate(Metadata
&MD
);
321 /// Get RAUW support on MD, if it exists.
322 static ReplaceableMetadataImpl
*getIfExists(Metadata
&MD
);
324 /// Check whether this node will support RAUW.
326 /// Returns \c true unless getOrCreate() would return null.
327 static bool isReplaceable(const Metadata
&MD
);
330 /// Value wrapper in the Metadata hierarchy.
332 /// This is a custom value handle that allows other metadata to refer to
333 /// classes in the Value hierarchy.
335 /// Because of full uniquing support, each value is only wrapped by a single \a
336 /// ValueAsMetadata object, so the lookup maps are far more efficient than
337 /// those using ValueHandleBase.
338 class ValueAsMetadata
: public Metadata
, ReplaceableMetadataImpl
{
339 friend class ReplaceableMetadataImpl
;
340 friend class LLVMContextImpl
;
344 /// Drop users without RAUW (during teardown).
346 ReplaceableMetadataImpl::resolveAllUses(/* ResolveUsers */ false);
350 ValueAsMetadata(unsigned ID
, Value
*V
)
351 : Metadata(ID
, Uniqued
), ReplaceableMetadataImpl(V
->getContext()), V(V
) {
352 assert(V
&& "Expected valid value");
355 ~ValueAsMetadata() = default;
358 static ValueAsMetadata
*get(Value
*V
);
360 static ConstantAsMetadata
*getConstant(Value
*C
) {
361 return cast
<ConstantAsMetadata
>(get(C
));
364 static LocalAsMetadata
*getLocal(Value
*Local
) {
365 return cast
<LocalAsMetadata
>(get(Local
));
368 static ValueAsMetadata
*getIfExists(Value
*V
);
370 static ConstantAsMetadata
*getConstantIfExists(Value
*C
) {
371 return cast_or_null
<ConstantAsMetadata
>(getIfExists(C
));
374 static LocalAsMetadata
*getLocalIfExists(Value
*Local
) {
375 return cast_or_null
<LocalAsMetadata
>(getIfExists(Local
));
378 Value
*getValue() const { return V
; }
379 Type
*getType() const { return V
->getType(); }
380 LLVMContext
&getContext() const { return V
->getContext(); }
382 static void handleDeletion(Value
*V
);
383 static void handleRAUW(Value
*From
, Value
*To
);
386 /// Handle collisions after \a Value::replaceAllUsesWith().
388 /// RAUW isn't supported directly for \a ValueAsMetadata, but if the wrapped
389 /// \a Value gets RAUW'ed and the target already exists, this is used to
390 /// merge the two metadata nodes.
391 void replaceAllUsesWith(Metadata
*MD
) {
392 ReplaceableMetadataImpl::replaceAllUsesWith(MD
);
396 static bool classof(const Metadata
*MD
) {
397 return MD
->getMetadataID() == LocalAsMetadataKind
||
398 MD
->getMetadataID() == ConstantAsMetadataKind
;
402 class ConstantAsMetadata
: public ValueAsMetadata
{
403 friend class ValueAsMetadata
;
405 ConstantAsMetadata(Constant
*C
)
406 : ValueAsMetadata(ConstantAsMetadataKind
, C
) {}
409 static ConstantAsMetadata
*get(Constant
*C
) {
410 return ValueAsMetadata::getConstant(C
);
413 static ConstantAsMetadata
*getIfExists(Constant
*C
) {
414 return ValueAsMetadata::getConstantIfExists(C
);
417 Constant
*getValue() const {
418 return cast
<Constant
>(ValueAsMetadata::getValue());
421 static bool classof(const Metadata
*MD
) {
422 return MD
->getMetadataID() == ConstantAsMetadataKind
;
426 class LocalAsMetadata
: public ValueAsMetadata
{
427 friend class ValueAsMetadata
;
429 LocalAsMetadata(Value
*Local
)
430 : ValueAsMetadata(LocalAsMetadataKind
, Local
) {
431 assert(!isa
<Constant
>(Local
) && "Expected local value");
435 static LocalAsMetadata
*get(Value
*Local
) {
436 return ValueAsMetadata::getLocal(Local
);
439 static LocalAsMetadata
*getIfExists(Value
*Local
) {
440 return ValueAsMetadata::getLocalIfExists(Local
);
443 static bool classof(const Metadata
*MD
) {
444 return MD
->getMetadataID() == LocalAsMetadataKind
;
448 /// Transitional API for extracting constants from Metadata.
450 /// This namespace contains transitional functions for metadata that points to
453 /// In prehistory -- when metadata was a subclass of \a Value -- \a MDNode
454 /// operands could refer to any \a Value. There's was a lot of code like this:
458 /// auto *CI = dyn_cast<ConstantInt>(N->getOperand(2));
461 /// Now that \a Value and \a Metadata are in separate hierarchies, maintaining
462 /// the semantics for \a isa(), \a cast(), \a dyn_cast() (etc.) requires three
463 /// steps: cast in the \a Metadata hierarchy, extraction of the \a Value, and
464 /// cast in the \a Value hierarchy. Besides creating boiler-plate, this
465 /// requires subtle control flow changes.
467 /// The end-goal is to create a new type of metadata, called (e.g.) \a MDInt,
468 /// so that metadata can refer to numbers without traversing a bridge to the \a
469 /// Value hierarchy. In this final state, the code above would look like this:
473 /// auto *MI = dyn_cast<MDInt>(N->getOperand(2));
476 /// The API in this namespace supports the transition. \a MDInt doesn't exist
477 /// yet, and even once it does, changing each metadata schema to use it is its
478 /// own mini-project. In the meantime this API prevents us from introducing
479 /// complex and bug-prone control flow that will disappear in the end. In
480 /// particular, the above code looks like this:
484 /// auto *CI = mdconst::dyn_extract<ConstantInt>(N->getOperand(2));
487 /// The full set of provided functions includes:
489 /// mdconst::hasa <=> isa
490 /// mdconst::extract <=> cast
491 /// mdconst::extract_or_null <=> cast_or_null
492 /// mdconst::dyn_extract <=> dyn_cast
493 /// mdconst::dyn_extract_or_null <=> dyn_cast_or_null
495 /// The target of the cast must be a subclass of \a Constant.
500 template <class T
> T
&make();
501 template <class T
, class Result
> struct HasDereference
{
504 template <size_t N
> struct SFINAE
{};
506 template <class U
, class V
>
507 static Yes
&hasDereference(SFINAE
<sizeof(static_cast<V
>(*make
<U
>()))> * = 0);
508 template <class U
, class V
> static No
&hasDereference(...);
510 static const bool value
=
511 sizeof(hasDereference
<T
, Result
>(nullptr)) == sizeof(Yes
);
513 template <class V
, class M
> struct IsValidPointer
{
514 static const bool value
= std::is_base_of
<Constant
, V
>::value
&&
515 HasDereference
<M
, const Metadata
&>::value
;
517 template <class V
, class M
> struct IsValidReference
{
518 static const bool value
= std::is_base_of
<Constant
, V
>::value
&&
519 std::is_convertible
<M
, const Metadata
&>::value
;
522 } // end namespace detail
524 /// Check whether Metadata has a Value.
526 /// As an analogue to \a isa(), check whether \c MD has an \a Value inside of
528 template <class X
, class Y
>
529 inline typename
std::enable_if
<detail::IsValidPointer
<X
, Y
>::value
, bool>::type
531 assert(MD
&& "Null pointer sent into hasa");
532 if (auto *V
= dyn_cast
<ConstantAsMetadata
>(MD
))
533 return isa
<X
>(V
->getValue());
536 template <class X
, class Y
>
538 typename
std::enable_if
<detail::IsValidReference
<X
, Y
&>::value
, bool>::type
543 /// Extract a Value from Metadata.
545 /// As an analogue to \a cast(), extract the \a Value subclass \c X from \c MD.
546 template <class X
, class Y
>
547 inline typename
std::enable_if
<detail::IsValidPointer
<X
, Y
>::value
, X
*>::type
549 return cast
<X
>(cast
<ConstantAsMetadata
>(MD
)->getValue());
551 template <class X
, class Y
>
553 typename
std::enable_if
<detail::IsValidReference
<X
, Y
&>::value
, X
*>::type
558 /// Extract a Value from Metadata, allowing null.
560 /// As an analogue to \a cast_or_null(), extract the \a Value subclass \c X
561 /// from \c MD, allowing \c MD to be null.
562 template <class X
, class Y
>
563 inline typename
std::enable_if
<detail::IsValidPointer
<X
, Y
>::value
, X
*>::type
564 extract_or_null(Y
&&MD
) {
565 if (auto *V
= cast_or_null
<ConstantAsMetadata
>(MD
))
566 return cast
<X
>(V
->getValue());
570 /// Extract a Value from Metadata, if any.
572 /// As an analogue to \a dyn_cast_or_null(), extract the \a Value subclass \c X
573 /// from \c MD, return null if \c MD doesn't contain a \a Value or if the \a
574 /// Value it does contain is of the wrong subclass.
575 template <class X
, class Y
>
576 inline typename
std::enable_if
<detail::IsValidPointer
<X
, Y
>::value
, X
*>::type
577 dyn_extract(Y
&&MD
) {
578 if (auto *V
= dyn_cast
<ConstantAsMetadata
>(MD
))
579 return dyn_cast
<X
>(V
->getValue());
583 /// Extract a Value from Metadata, if any, allowing null.
585 /// As an analogue to \a dyn_cast_or_null(), extract the \a Value subclass \c X
586 /// from \c MD, return null if \c MD doesn't contain a \a Value or if the \a
587 /// Value it does contain is of the wrong subclass, allowing \c MD to be null.
588 template <class X
, class Y
>
589 inline typename
std::enable_if
<detail::IsValidPointer
<X
, Y
>::value
, X
*>::type
590 dyn_extract_or_null(Y
&&MD
) {
591 if (auto *V
= dyn_cast_or_null
<ConstantAsMetadata
>(MD
))
592 return dyn_cast
<X
>(V
->getValue());
596 } // end namespace mdconst
598 //===----------------------------------------------------------------------===//
599 /// A single uniqued string.
601 /// These are used to efficiently contain a byte sequence for metadata.
602 /// MDString is always unnamed.
603 class MDString
: public Metadata
{
604 friend class StringMapEntry
<MDString
>;
606 StringMapEntry
<MDString
> *Entry
= nullptr;
608 MDString() : Metadata(MDStringKind
, Uniqued
) {}
611 MDString(const MDString
&) = delete;
612 MDString
&operator=(MDString
&&) = delete;
613 MDString
&operator=(const MDString
&) = delete;
615 static MDString
*get(LLVMContext
&Context
, StringRef Str
);
616 static MDString
*get(LLVMContext
&Context
, const char *Str
) {
617 return get(Context
, Str
? StringRef(Str
) : StringRef());
620 StringRef
getString() const;
622 unsigned getLength() const { return (unsigned)getString().size(); }
624 using iterator
= StringRef::iterator
;
626 /// Pointer to the first byte of the string.
627 iterator
begin() const { return getString().begin(); }
629 /// Pointer to one byte past the end of the string.
630 iterator
end() const { return getString().end(); }
632 const unsigned char *bytes_begin() const { return getString().bytes_begin(); }
633 const unsigned char *bytes_end() const { return getString().bytes_end(); }
635 /// Methods for support type inquiry through isa, cast, and dyn_cast.
636 static bool classof(const Metadata
*MD
) {
637 return MD
->getMetadataID() == MDStringKind
;
641 /// A collection of metadata nodes that might be associated with a
642 /// memory access used by the alias-analysis infrastructure.
644 explicit AAMDNodes(MDNode
*T
= nullptr, MDNode
*S
= nullptr,
646 : TBAA(T
), Scope(S
), NoAlias(N
) {}
648 bool operator==(const AAMDNodes
&A
) const {
649 return TBAA
== A
.TBAA
&& Scope
== A
.Scope
&& NoAlias
== A
.NoAlias
;
652 bool operator!=(const AAMDNodes
&A
) const { return !(*this == A
); }
654 explicit operator bool() const { return TBAA
|| Scope
|| NoAlias
; }
656 /// The tag for type-based alias analysis.
659 /// The tag for alias scope specification (used with noalias).
662 /// The tag specifying the noalias scope.
665 /// Given two sets of AAMDNodes that apply to the same pointer,
666 /// give the best AAMDNodes that are compatible with both (i.e. a set of
667 /// nodes whose allowable aliasing conclusions are a subset of those
668 /// allowable by both of the inputs). However, for efficiency
669 /// reasons, do not create any new MDNodes.
670 AAMDNodes
intersect(const AAMDNodes
&Other
) {
672 Result
.TBAA
= Other
.TBAA
== TBAA
? TBAA
: nullptr;
673 Result
.Scope
= Other
.Scope
== Scope
? Scope
: nullptr;
674 Result
.NoAlias
= Other
.NoAlias
== NoAlias
? NoAlias
: nullptr;
679 // Specialize DenseMapInfo for AAMDNodes.
681 struct DenseMapInfo
<AAMDNodes
> {
682 static inline AAMDNodes
getEmptyKey() {
683 return AAMDNodes(DenseMapInfo
<MDNode
*>::getEmptyKey(),
687 static inline AAMDNodes
getTombstoneKey() {
688 return AAMDNodes(DenseMapInfo
<MDNode
*>::getTombstoneKey(),
692 static unsigned getHashValue(const AAMDNodes
&Val
) {
693 return DenseMapInfo
<MDNode
*>::getHashValue(Val
.TBAA
) ^
694 DenseMapInfo
<MDNode
*>::getHashValue(Val
.Scope
) ^
695 DenseMapInfo
<MDNode
*>::getHashValue(Val
.NoAlias
);
698 static bool isEqual(const AAMDNodes
&LHS
, const AAMDNodes
&RHS
) {
703 /// Tracking metadata reference owned by Metadata.
705 /// Similar to \a TrackingMDRef, but it's expected to be owned by an instance
706 /// of \a Metadata, which has the option of registering itself for callbacks to
707 /// re-unique itself.
709 /// In particular, this is used by \a MDNode.
711 Metadata
*MD
= nullptr;
714 MDOperand() = default;
715 MDOperand(MDOperand
&&) = delete;
716 MDOperand(const MDOperand
&) = delete;
717 MDOperand
&operator=(MDOperand
&&) = delete;
718 MDOperand
&operator=(const MDOperand
&) = delete;
719 ~MDOperand() { untrack(); }
721 Metadata
*get() const { return MD
; }
722 operator Metadata
*() const { return get(); }
723 Metadata
*operator->() const { return get(); }
724 Metadata
&operator*() const { return *get(); }
730 void reset(Metadata
*MD
, Metadata
*Owner
) {
737 void track(Metadata
*Owner
) {
740 MetadataTracking::track(this, *MD
, *Owner
);
742 MetadataTracking::track(MD
);
747 assert(static_cast<void *>(this) == &MD
&& "Expected same address");
749 MetadataTracking::untrack(MD
);
753 template <> struct simplify_type
<MDOperand
> {
754 using SimpleType
= Metadata
*;
756 static SimpleType
getSimplifiedValue(MDOperand
&MD
) { return MD
.get(); }
759 template <> struct simplify_type
<const MDOperand
> {
760 using SimpleType
= Metadata
*;
762 static SimpleType
getSimplifiedValue(const MDOperand
&MD
) { return MD
.get(); }
765 /// Pointer to the context, with optional RAUW support.
767 /// Either a raw (non-null) pointer to the \a LLVMContext, or an owned pointer
768 /// to \a ReplaceableMetadataImpl (which has a reference to \a LLVMContext).
769 class ContextAndReplaceableUses
{
770 PointerUnion
<LLVMContext
*, ReplaceableMetadataImpl
*> Ptr
;
773 ContextAndReplaceableUses(LLVMContext
&Context
) : Ptr(&Context
) {}
774 ContextAndReplaceableUses(
775 std::unique_ptr
<ReplaceableMetadataImpl
> ReplaceableUses
)
776 : Ptr(ReplaceableUses
.release()) {
777 assert(getReplaceableUses() && "Expected non-null replaceable uses");
779 ContextAndReplaceableUses() = delete;
780 ContextAndReplaceableUses(ContextAndReplaceableUses
&&) = delete;
781 ContextAndReplaceableUses(const ContextAndReplaceableUses
&) = delete;
782 ContextAndReplaceableUses
&operator=(ContextAndReplaceableUses
&&) = delete;
783 ContextAndReplaceableUses
&
784 operator=(const ContextAndReplaceableUses
&) = delete;
785 ~ContextAndReplaceableUses() { delete getReplaceableUses(); }
787 operator LLVMContext
&() { return getContext(); }
789 /// Whether this contains RAUW support.
790 bool hasReplaceableUses() const {
791 return Ptr
.is
<ReplaceableMetadataImpl
*>();
794 LLVMContext
&getContext() const {
795 if (hasReplaceableUses())
796 return getReplaceableUses()->getContext();
797 return *Ptr
.get
<LLVMContext
*>();
800 ReplaceableMetadataImpl
*getReplaceableUses() const {
801 if (hasReplaceableUses())
802 return Ptr
.get
<ReplaceableMetadataImpl
*>();
806 /// Ensure that this has RAUW support, and then return it.
807 ReplaceableMetadataImpl
*getOrCreateReplaceableUses() {
808 if (!hasReplaceableUses())
809 makeReplaceable(std::make_unique
<ReplaceableMetadataImpl
>(getContext()));
810 return getReplaceableUses();
813 /// Assign RAUW support to this.
815 /// Make this replaceable, taking ownership of \c ReplaceableUses (which must
818 makeReplaceable(std::unique_ptr
<ReplaceableMetadataImpl
> ReplaceableUses
) {
819 assert(ReplaceableUses
&& "Expected non-null replaceable uses");
820 assert(&ReplaceableUses
->getContext() == &getContext() &&
821 "Expected same context");
822 delete getReplaceableUses();
823 Ptr
= ReplaceableUses
.release();
826 /// Drop RAUW support.
828 /// Cede ownership of RAUW support, returning it.
829 std::unique_ptr
<ReplaceableMetadataImpl
> takeReplaceableUses() {
830 assert(hasReplaceableUses() && "Expected to own replaceable uses");
831 std::unique_ptr
<ReplaceableMetadataImpl
> ReplaceableUses(
832 getReplaceableUses());
833 Ptr
= &ReplaceableUses
->getContext();
834 return ReplaceableUses
;
838 struct TempMDNodeDeleter
{
839 inline void operator()(MDNode
*Node
) const;
842 #define HANDLE_MDNODE_LEAF(CLASS) \
843 using Temp##CLASS = std::unique_ptr<CLASS, TempMDNodeDeleter>;
844 #define HANDLE_MDNODE_BRANCH(CLASS) HANDLE_MDNODE_LEAF(CLASS)
845 #include "llvm/IR/Metadata.def"
849 /// Metadata nodes can be uniqued, like constants, or distinct. Temporary
850 /// metadata nodes (with full support for RAUW) can be used to delay uniquing
851 /// until forward references are known. The basic metadata node is an \a
854 /// There is limited support for RAUW at construction time. At construction
855 /// time, if any operand is a temporary node (or an unresolved uniqued node,
856 /// which indicates a transitive temporary operand), the node itself will be
857 /// unresolved. As soon as all operands become resolved, it will drop RAUW
858 /// support permanently.
860 /// If an unresolved node is part of a cycle, \a resolveCycles() needs
861 /// to be called on some member of the cycle once all temporary nodes have been
863 class MDNode
: public Metadata
{
864 friend class ReplaceableMetadataImpl
;
865 friend class LLVMContextImpl
;
867 unsigned NumOperands
;
868 unsigned NumUnresolved
;
870 ContextAndReplaceableUses Context
;
873 MDNode(LLVMContext
&Context
, unsigned ID
, StorageType Storage
,
874 ArrayRef
<Metadata
*> Ops1
, ArrayRef
<Metadata
*> Ops2
= None
);
877 void *operator new(size_t Size
, unsigned NumOps
);
878 void operator delete(void *Mem
);
880 /// Required by std, but never called.
881 void operator delete(void *, unsigned) {
882 llvm_unreachable("Constructor throws?");
885 /// Required by std, but never called.
886 void operator delete(void *, unsigned, bool) {
887 llvm_unreachable("Constructor throws?");
890 void dropAllReferences();
892 MDOperand
*mutable_begin() { return mutable_end() - NumOperands
; }
893 MDOperand
*mutable_end() { return reinterpret_cast<MDOperand
*>(this); }
895 using mutable_op_range
= iterator_range
<MDOperand
*>;
897 mutable_op_range
mutable_operands() {
898 return mutable_op_range(mutable_begin(), mutable_end());
902 MDNode(const MDNode
&) = delete;
903 void operator=(const MDNode
&) = delete;
904 void *operator new(size_t) = delete;
906 static inline MDTuple
*get(LLVMContext
&Context
, ArrayRef
<Metadata
*> MDs
);
907 static inline MDTuple
*getIfExists(LLVMContext
&Context
,
908 ArrayRef
<Metadata
*> MDs
);
909 static inline MDTuple
*getDistinct(LLVMContext
&Context
,
910 ArrayRef
<Metadata
*> MDs
);
911 static inline TempMDTuple
getTemporary(LLVMContext
&Context
,
912 ArrayRef
<Metadata
*> MDs
);
914 /// Create a (temporary) clone of this.
915 TempMDNode
clone() const;
917 /// Deallocate a node created by getTemporary.
919 /// Calls \c replaceAllUsesWith(nullptr) before deleting, so any remaining
920 /// references will be reset.
921 static void deleteTemporary(MDNode
*N
);
923 LLVMContext
&getContext() const { return Context
.getContext(); }
925 /// Replace a specific operand.
926 void replaceOperandWith(unsigned I
, Metadata
*New
);
928 /// Check if node is fully resolved.
930 /// If \a isTemporary(), this always returns \c false; if \a isDistinct(),
931 /// this always returns \c true.
933 /// If \a isUniqued(), returns \c true if this has already dropped RAUW
934 /// support (because all operands are resolved).
936 /// As forward declarations are resolved, their containers should get
937 /// resolved automatically. However, if this (or one of its operands) is
938 /// involved in a cycle, \a resolveCycles() needs to be called explicitly.
939 bool isResolved() const { return !isTemporary() && !NumUnresolved
; }
941 bool isUniqued() const { return Storage
== Uniqued
; }
942 bool isDistinct() const { return Storage
== Distinct
; }
943 bool isTemporary() const { return Storage
== Temporary
; }
945 /// RAUW a temporary.
947 /// \pre \a isTemporary() must be \c true.
948 void replaceAllUsesWith(Metadata
*MD
) {
949 assert(isTemporary() && "Expected temporary node");
950 if (Context
.hasReplaceableUses())
951 Context
.getReplaceableUses()->replaceAllUsesWith(MD
);
956 /// Once all forward declarations have been resolved, force cycles to be
959 /// \pre No operands (or operands' operands, etc.) have \a isTemporary().
960 void resolveCycles();
962 /// Resolve a unique, unresolved node.
965 /// Replace a temporary node with a permanent one.
967 /// Try to create a uniqued version of \c N -- in place, if possible -- and
968 /// return it. If \c N cannot be uniqued, return a distinct node instead.
970 static typename
std::enable_if
<std::is_base_of
<MDNode
, T
>::value
, T
*>::type
971 replaceWithPermanent(std::unique_ptr
<T
, TempMDNodeDeleter
> N
) {
972 return cast
<T
>(N
.release()->replaceWithPermanentImpl());
975 /// Replace a temporary node with a uniqued one.
977 /// Create a uniqued version of \c N -- in place, if possible -- and return
978 /// it. Takes ownership of the temporary node.
980 /// \pre N does not self-reference.
982 static typename
std::enable_if
<std::is_base_of
<MDNode
, T
>::value
, T
*>::type
983 replaceWithUniqued(std::unique_ptr
<T
, TempMDNodeDeleter
> N
) {
984 return cast
<T
>(N
.release()->replaceWithUniquedImpl());
987 /// Replace a temporary node with a distinct one.
989 /// Create a distinct version of \c N -- in place, if possible -- and return
990 /// it. Takes ownership of the temporary node.
992 static typename
std::enable_if
<std::is_base_of
<MDNode
, T
>::value
, T
*>::type
993 replaceWithDistinct(std::unique_ptr
<T
, TempMDNodeDeleter
> N
) {
994 return cast
<T
>(N
.release()->replaceWithDistinctImpl());
998 MDNode
*replaceWithPermanentImpl();
999 MDNode
*replaceWithUniquedImpl();
1000 MDNode
*replaceWithDistinctImpl();
1005 /// Sets the operand directly, without worrying about uniquing.
1006 void setOperand(unsigned I
, Metadata
*New
);
1008 void storeDistinctInContext();
1009 template <class T
, class StoreT
>
1010 static T
*storeImpl(T
*N
, StorageType Storage
, StoreT
&Store
);
1011 template <class T
> static T
*storeImpl(T
*N
, StorageType Storage
);
1014 void handleChangedOperand(void *Ref
, Metadata
*New
);
1016 /// Drop RAUW support, if any.
1017 void dropReplaceableUses();
1019 void resolveAfterOperandChange(Metadata
*Old
, Metadata
*New
);
1020 void decrementUnresolvedOperandCount();
1021 void countUnresolvedOperands();
1023 /// Mutate this to be "uniqued".
1025 /// Mutate this so that \a isUniqued().
1026 /// \pre \a isTemporary().
1027 /// \pre already added to uniquing set.
1030 /// Mutate this to be "distinct".
1032 /// Mutate this so that \a isDistinct().
1033 /// \pre \a isTemporary().
1034 void makeDistinct();
1036 void deleteAsSubclass();
1038 void eraseFromStore();
1040 template <class NodeTy
> struct HasCachedHash
;
1041 template <class NodeTy
>
1042 static void dispatchRecalculateHash(NodeTy
*N
, std::true_type
) {
1043 N
->recalculateHash();
1045 template <class NodeTy
>
1046 static void dispatchRecalculateHash(NodeTy
*, std::false_type
) {}
1047 template <class NodeTy
>
1048 static void dispatchResetHash(NodeTy
*N
, std::true_type
) {
1051 template <class NodeTy
>
1052 static void dispatchResetHash(NodeTy
*, std::false_type
) {}
1055 using op_iterator
= const MDOperand
*;
1056 using op_range
= iterator_range
<op_iterator
>;
1058 op_iterator
op_begin() const {
1059 return const_cast<MDNode
*>(this)->mutable_begin();
1062 op_iterator
op_end() const {
1063 return const_cast<MDNode
*>(this)->mutable_end();
1066 op_range
operands() const { return op_range(op_begin(), op_end()); }
1068 const MDOperand
&getOperand(unsigned I
) const {
1069 assert(I
< NumOperands
&& "Out of range");
1070 return op_begin()[I
];
1073 /// Return number of MDNode operands.
1074 unsigned getNumOperands() const { return NumOperands
; }
1076 /// Methods for support type inquiry through isa, cast, and dyn_cast:
1077 static bool classof(const Metadata
*MD
) {
1078 switch (MD
->getMetadataID()) {
1081 #define HANDLE_MDNODE_LEAF(CLASS) \
1084 #include "llvm/IR/Metadata.def"
1088 /// Check whether MDNode is a vtable access.
1089 bool isTBAAVtableAccess() const;
1091 /// Methods for metadata merging.
1092 static MDNode
*concatenate(MDNode
*A
, MDNode
*B
);
1093 static MDNode
*intersect(MDNode
*A
, MDNode
*B
);
1094 static MDNode
*getMostGenericTBAA(MDNode
*A
, MDNode
*B
);
1095 static MDNode
*getMostGenericFPMath(MDNode
*A
, MDNode
*B
);
1096 static MDNode
*getMostGenericRange(MDNode
*A
, MDNode
*B
);
1097 static MDNode
*getMostGenericAliasScope(MDNode
*A
, MDNode
*B
);
1098 static MDNode
*getMostGenericAlignmentOrDereferenceable(MDNode
*A
, MDNode
*B
);
1101 /// Tuple of metadata.
1103 /// This is the simple \a MDNode arbitrary tuple. Nodes are uniqued by
1104 /// default based on their operands.
1105 class MDTuple
: public MDNode
{
1106 friend class LLVMContextImpl
;
1107 friend class MDNode
;
1109 MDTuple(LLVMContext
&C
, StorageType Storage
, unsigned Hash
,
1110 ArrayRef
<Metadata
*> Vals
)
1111 : MDNode(C
, MDTupleKind
, Storage
, Vals
) {
1115 ~MDTuple() { dropAllReferences(); }
1117 void setHash(unsigned Hash
) { SubclassData32
= Hash
; }
1118 void recalculateHash();
1120 static MDTuple
*getImpl(LLVMContext
&Context
, ArrayRef
<Metadata
*> MDs
,
1121 StorageType Storage
, bool ShouldCreate
= true);
1123 TempMDTuple
cloneImpl() const {
1124 return getTemporary(getContext(),
1125 SmallVector
<Metadata
*, 4>(op_begin(), op_end()));
1129 /// Get the hash, if any.
1130 unsigned getHash() const { return SubclassData32
; }
1132 static MDTuple
*get(LLVMContext
&Context
, ArrayRef
<Metadata
*> MDs
) {
1133 return getImpl(Context
, MDs
, Uniqued
);
1136 static MDTuple
*getIfExists(LLVMContext
&Context
, ArrayRef
<Metadata
*> MDs
) {
1137 return getImpl(Context
, MDs
, Uniqued
, /* ShouldCreate */ false);
1140 /// Return a distinct node.
1142 /// Return a distinct node -- i.e., a node that is not uniqued.
1143 static MDTuple
*getDistinct(LLVMContext
&Context
, ArrayRef
<Metadata
*> MDs
) {
1144 return getImpl(Context
, MDs
, Distinct
);
1147 /// Return a temporary node.
1149 /// For use in constructing cyclic MDNode structures. A temporary MDNode is
1150 /// not uniqued, may be RAUW'd, and must be manually deleted with
1151 /// deleteTemporary.
1152 static TempMDTuple
getTemporary(LLVMContext
&Context
,
1153 ArrayRef
<Metadata
*> MDs
) {
1154 return TempMDTuple(getImpl(Context
, MDs
, Temporary
));
1157 /// Return a (temporary) clone of this.
1158 TempMDTuple
clone() const { return cloneImpl(); }
1160 static bool classof(const Metadata
*MD
) {
1161 return MD
->getMetadataID() == MDTupleKind
;
1165 MDTuple
*MDNode::get(LLVMContext
&Context
, ArrayRef
<Metadata
*> MDs
) {
1166 return MDTuple::get(Context
, MDs
);
1169 MDTuple
*MDNode::getIfExists(LLVMContext
&Context
, ArrayRef
<Metadata
*> MDs
) {
1170 return MDTuple::getIfExists(Context
, MDs
);
1173 MDTuple
*MDNode::getDistinct(LLVMContext
&Context
, ArrayRef
<Metadata
*> MDs
) {
1174 return MDTuple::getDistinct(Context
, MDs
);
1177 TempMDTuple
MDNode::getTemporary(LLVMContext
&Context
,
1178 ArrayRef
<Metadata
*> MDs
) {
1179 return MDTuple::getTemporary(Context
, MDs
);
1182 void TempMDNodeDeleter::operator()(MDNode
*Node
) const {
1183 MDNode::deleteTemporary(Node
);
1186 /// Typed iterator through MDNode operands.
1188 /// An iterator that transforms an \a MDNode::iterator into an iterator over a
1189 /// particular Metadata subclass.
1191 class TypedMDOperandIterator
1192 : public std::iterator
<std::input_iterator_tag
, T
*, std::ptrdiff_t, void,
1194 MDNode::op_iterator I
= nullptr;
1197 TypedMDOperandIterator() = default;
1198 explicit TypedMDOperandIterator(MDNode::op_iterator I
) : I(I
) {}
1200 T
*operator*() const { return cast_or_null
<T
>(*I
); }
1202 TypedMDOperandIterator
&operator++() {
1207 TypedMDOperandIterator
operator++(int) {
1208 TypedMDOperandIterator
Temp(*this);
1213 bool operator==(const TypedMDOperandIterator
&X
) const { return I
== X
.I
; }
1214 bool operator!=(const TypedMDOperandIterator
&X
) const { return I
!= X
.I
; }
1217 /// Typed, array-like tuple of metadata.
1219 /// This is a wrapper for \a MDTuple that makes it act like an array holding a
1220 /// particular type of metadata.
1221 template <class T
> class MDTupleTypedArrayWrapper
{
1222 const MDTuple
*N
= nullptr;
1225 MDTupleTypedArrayWrapper() = default;
1226 MDTupleTypedArrayWrapper(const MDTuple
*N
) : N(N
) {}
1229 MDTupleTypedArrayWrapper(
1230 const MDTupleTypedArrayWrapper
<U
> &Other
,
1231 typename
std::enable_if
<std::is_convertible
<U
*, T
*>::value
>::type
* =
1236 explicit MDTupleTypedArrayWrapper(
1237 const MDTupleTypedArrayWrapper
<U
> &Other
,
1238 typename
std::enable_if
<!std::is_convertible
<U
*, T
*>::value
>::type
* =
1242 explicit operator bool() const { return get(); }
1243 explicit operator MDTuple
*() const { return get(); }
1245 MDTuple
*get() const { return const_cast<MDTuple
*>(N
); }
1246 MDTuple
*operator->() const { return get(); }
1247 MDTuple
&operator*() const { return *get(); }
1249 // FIXME: Fix callers and remove condition on N.
1250 unsigned size() const { return N
? N
->getNumOperands() : 0u; }
1251 bool empty() const { return N
? N
->getNumOperands() == 0 : true; }
1252 T
*operator[](unsigned I
) const { return cast_or_null
<T
>(N
->getOperand(I
)); }
1254 // FIXME: Fix callers and remove condition on N.
1255 using iterator
= TypedMDOperandIterator
<T
>;
1257 iterator
begin() const { return N
? iterator(N
->op_begin()) : iterator(); }
1258 iterator
end() const { return N
? iterator(N
->op_end()) : iterator(); }
1261 #define HANDLE_METADATA(CLASS) \
1262 using CLASS##Array = MDTupleTypedArrayWrapper<CLASS>;
1263 #include "llvm/IR/Metadata.def"
1265 /// Placeholder metadata for operands of distinct MDNodes.
1267 /// This is a lightweight placeholder for an operand of a distinct node. It's
1268 /// purpose is to help track forward references when creating a distinct node.
1269 /// This allows distinct nodes involved in a cycle to be constructed before
1270 /// their operands without requiring a heavyweight temporary node with
1271 /// full-blown RAUW support.
1273 /// Each placeholder supports only a single MDNode user. Clients should pass
1274 /// an ID, retrieved via \a getID(), to indicate the "real" operand that this
1275 /// should be replaced with.
1277 /// While it would be possible to implement move operators, they would be
1278 /// fairly expensive. Leave them unimplemented to discourage their use
1279 /// (clients can use std::deque, std::list, BumpPtrAllocator, etc.).
1280 class DistinctMDOperandPlaceholder
: public Metadata
{
1281 friend class MetadataTracking
;
1283 Metadata
**Use
= nullptr;
1286 explicit DistinctMDOperandPlaceholder(unsigned ID
)
1287 : Metadata(DistinctMDOperandPlaceholderKind
, Distinct
) {
1288 SubclassData32
= ID
;
1291 DistinctMDOperandPlaceholder() = delete;
1292 DistinctMDOperandPlaceholder(DistinctMDOperandPlaceholder
&&) = delete;
1293 DistinctMDOperandPlaceholder(const DistinctMDOperandPlaceholder
&) = delete;
1295 ~DistinctMDOperandPlaceholder() {
1300 unsigned getID() const { return SubclassData32
; }
1302 /// Replace the use of this with MD.
1303 void replaceUseWith(Metadata
*MD
) {
1309 MetadataTracking::track(*Use
);
1311 Metadata
*T
= cast
<Metadata
>(this);
1312 MetadataTracking::untrack(T
);
1313 assert(!Use
&& "Use is still being tracked despite being untracked!");
1317 //===----------------------------------------------------------------------===//
1318 /// A tuple of MDNodes.
1320 /// Despite its name, a NamedMDNode isn't itself an MDNode.
1322 /// NamedMDNodes are named module-level entities that contain lists of MDNodes.
1324 /// It is illegal for a NamedMDNode to appear as an operand of an MDNode.
1325 class NamedMDNode
: public ilist_node
<NamedMDNode
> {
1326 friend class LLVMContextImpl
;
1327 friend class Module
;
1330 Module
*Parent
= nullptr;
1331 void *Operands
; // SmallVector<TrackingMDRef, 4>
1333 void setParent(Module
*M
) { Parent
= M
; }
1335 explicit NamedMDNode(const Twine
&N
);
1337 template<class T1
, class T2
>
1338 class op_iterator_impl
:
1339 public std::iterator
<std::bidirectional_iterator_tag
, T2
> {
1340 friend class NamedMDNode
;
1342 const NamedMDNode
*Node
= nullptr;
1345 op_iterator_impl(const NamedMDNode
*N
, unsigned i
) : Node(N
), Idx(i
) {}
1348 op_iterator_impl() = default;
1350 bool operator==(const op_iterator_impl
&o
) const { return Idx
== o
.Idx
; }
1351 bool operator!=(const op_iterator_impl
&o
) const { return Idx
!= o
.Idx
; }
1353 op_iterator_impl
&operator++() {
1358 op_iterator_impl
operator++(int) {
1359 op_iterator_impl
tmp(*this);
1364 op_iterator_impl
&operator--() {
1369 op_iterator_impl
operator--(int) {
1370 op_iterator_impl
tmp(*this);
1375 T1
operator*() const { return Node
->getOperand(Idx
); }
1379 NamedMDNode(const NamedMDNode
&) = delete;
1382 /// Drop all references and remove the node from parent module.
1383 void eraseFromParent();
1385 /// Remove all uses and clear node vector.
1386 void dropAllReferences() { clearOperands(); }
1387 /// Drop all references to this node's operands.
1388 void clearOperands();
1390 /// Get the module that holds this named metadata collection.
1391 inline Module
*getParent() { return Parent
; }
1392 inline const Module
*getParent() const { return Parent
; }
1394 MDNode
*getOperand(unsigned i
) const;
1395 unsigned getNumOperands() const;
1396 void addOperand(MDNode
*M
);
1397 void setOperand(unsigned I
, MDNode
*New
);
1398 StringRef
getName() const;
1399 void print(raw_ostream
&ROS
, bool IsForDebug
= false) const;
1400 void print(raw_ostream
&ROS
, ModuleSlotTracker
&MST
,
1401 bool IsForDebug
= false) const;
1404 // ---------------------------------------------------------------------------
1405 // Operand Iterator interface...
1407 using op_iterator
= op_iterator_impl
<MDNode
*, MDNode
>;
1409 op_iterator
op_begin() { return op_iterator(this, 0); }
1410 op_iterator
op_end() { return op_iterator(this, getNumOperands()); }
1412 using const_op_iterator
= op_iterator_impl
<const MDNode
*, MDNode
>;
1414 const_op_iterator
op_begin() const { return const_op_iterator(this, 0); }
1415 const_op_iterator
op_end() const { return const_op_iterator(this, getNumOperands()); }
1417 inline iterator_range
<op_iterator
> operands() {
1418 return make_range(op_begin(), op_end());
1420 inline iterator_range
<const_op_iterator
> operands() const {
1421 return make_range(op_begin(), op_end());
1425 // Create wrappers for C Binding types (see CBindingWrapping.h).
1426 DEFINE_ISA_CONVERSION_FUNCTIONS(NamedMDNode
, LLVMNamedMDNodeRef
)
1428 } // end namespace llvm
1430 #endif // LLVM_IR_METADATA_H