1//===- llvm/IR/Metadata.h - Metadata definitions ----------------*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10/// @file
11/// This file contains the declarations for metadata subclasses.
12/// They represent the different flavors of metadata that live in LLVM.
13//
14//===----------------------------------------------------------------------===//
15
16#ifndef LLVM_IR_METADATA_H
17#define LLVM_IR_METADATA_H
18
19#include "llvm/ADT/ArrayRef.h"
20#include "llvm/ADT/DenseMap.h"
21#include "llvm/ADT/DenseMapInfo.h"
22#include "llvm/ADT/None.h"
23#include "llvm/ADT/PointerUnion.h"
24#include "llvm/ADT/STLExtras.h"
25#include "llvm/ADT/SmallVector.h"
26#include "llvm/ADT/StringRef.h"
27#include "llvm/ADT/ilist_node.h"
28#include "llvm/ADT/iterator_range.h"
29#include "llvm/IR/Constant.h"
30#include "llvm/IR/LLVMContext.h"
31#include "llvm/IR/Value.h"
32#include "llvm/Support/CBindingWrapping.h"
33#include "llvm/Support/Casting.h"
34#include "llvm/Support/ErrorHandling.h"
35#include <cassert>
36#include <cstddef>
37#include <cstdint>
38#include <iterator>
39#include <memory>
40#include <string>
41#include <type_traits>
42#include <utility>
43
44namespace llvm {
45
46class Module;
47class ModuleSlotTracker;
48class raw_ostream;
49class Type;
50
51enum LLVMConstants : uint32_t {
52 DEBUG_METADATA_VERSION = 3 // Current debug info version number.
53};
54
55/// Root of the metadata hierarchy.
56///
57/// This is a root class for typeless data in the IR.
58class Metadata {
59 friend class ReplaceableMetadataImpl;
60
61 /// RTTI.
62 const unsigned char SubclassID;
63
64protected:
65 /// Active type of storage.
66 enum StorageType { Uniqued, Distinct, Temporary };
67
68 /// Storage flag for non-uniqued, otherwise unowned, metadata.
69 unsigned char Storage : 7;
70 // TODO: expose remaining bits to subclasses.
71
72 unsigned char ImplicitCode : 1;
73
74 unsigned short SubclassData16 = 0;
75 unsigned SubclassData32 = 0;
76
77public:
78 enum MetadataKind {
79#define HANDLE_METADATA_LEAF(CLASS) CLASS##Kind,
80#include "llvm/IR/Metadata.def"
81 };
82
83protected:
84 Metadata(unsigned ID, StorageType Storage)
85 : SubclassID(ID), Storage(Storage), ImplicitCode(false) {
86 static_assert(sizeof(*this) == 8, "Metadata fields poorly packed");
87 }
88
89 ~Metadata() = default;
90
91 /// Default handling of a changed operand, which asserts.
92 ///
93 /// If subclasses pass themselves in as owners to a tracking node reference,
94 /// they must provide an implementation of this method.
95 void handleChangedOperand(void *, Metadata *) {
96 llvm_unreachable("Unimplemented in Metadata subclass");
97 }
98
99public:
100 unsigned getMetadataID() const { return SubclassID; }
101
102 /// User-friendly dump.
103 ///
104 /// If \c M is provided, metadata nodes will be numbered canonically;
105 /// otherwise, pointer addresses are substituted.
106 ///
107 /// Note: this uses an explicit overload instead of default arguments so that
108 /// the nullptr version is easy to call from a debugger.
109 ///
110 /// @{
111 void dump() const;
112 void dump(const Module *M) const;
113 /// @}
114
115 /// Print.
116 ///
117 /// Prints definition of \c this.
118 ///
119 /// If \c M is provided, metadata nodes will be numbered canonically;
120 /// otherwise, pointer addresses are substituted.
121 /// @{
122 void print(raw_ostream &OS, const Module *M = nullptr,
123 bool IsForDebug = false) const;
124 void print(raw_ostream &OS, ModuleSlotTracker &MST, const Module *M = nullptr,
125 bool IsForDebug = false) const;
126 /// @}
127
128 /// Print as operand.
129 ///
130 /// Prints reference of \c this.
131 ///
132 /// If \c M is provided, metadata nodes will be numbered canonically;
133 /// otherwise, pointer addresses are substituted.
134 /// @{
135 void printAsOperand(raw_ostream &OS, const Module *M = nullptr) const;
136 void printAsOperand(raw_ostream &OS, ModuleSlotTracker &MST,
137 const Module *M = nullptr) const;
138 /// @}
139};
140
141// Create wrappers for C Binding types (see CBindingWrapping.h).
142DEFINE_ISA_CONVERSION_FUNCTIONS(Metadata, LLVMMetadataRef)
143
144// Specialized opaque metadata conversions.
145inline Metadata **unwrap(LLVMMetadataRef *MDs) {
146 return reinterpret_cast<Metadata**>(MDs);
147}
148
149#define HANDLE_METADATA(CLASS) class CLASS;
150#include "llvm/IR/Metadata.def"
151
152// Provide specializations of isa so that we don't need definitions of
153// subclasses to see if the metadata is a subclass.
154#define HANDLE_METADATA_LEAF(CLASS) \
155 template <> struct isa_impl<CLASS, Metadata> { \
156 static inline bool doit(const Metadata &MD) { \
157 return MD.getMetadataID() == Metadata::CLASS##Kind; \
158 } \
159 };
160#include "llvm/IR/Metadata.def"
161
162inline raw_ostream &operator<<(raw_ostream &OS, const Metadata &MD) {
163 MD.print(OS);
164 return OS;
165}
166
167/// Metadata wrapper in the Value hierarchy.
168///
169/// A member of the \a Value hierarchy to represent a reference to metadata.
170/// This allows, e.g., instrinsics to have metadata as operands.
171///
172/// Notably, this is the only thing in either hierarchy that is allowed to
173/// reference \a LocalAsMetadata.
174class MetadataAsValue : public Value {
175 friend class ReplaceableMetadataImpl;
176 friend class LLVMContextImpl;
177
178 Metadata *MD;
179
180 MetadataAsValue(Type *Ty, Metadata *MD);
181
182 /// Drop use of metadata (during teardown).
183 void dropUse() { MD = nullptr; }
184
185public:
186 ~MetadataAsValue();
187
188 static MetadataAsValue *get(LLVMContext &Context, Metadata *MD);
189 static MetadataAsValue *getIfExists(LLVMContext &Context, Metadata *MD);
190
191 Metadata *getMetadata() const { return MD; }
192
193 static bool classof(const Value *V) {
194 return V->getValueID() == MetadataAsValueVal;
195 }
196
197private:
198 void handleChangedMetadata(Metadata *MD);
199 void track();
200 void untrack();
201};
202
203/// API for tracking metadata references through RAUW and deletion.
204///
205/// Shared API for updating \a Metadata pointers in subclasses that support
206/// RAUW.
207///
208/// This API is not meant to be used directly. See \a TrackingMDRef for a
209/// user-friendly tracking reference.
210class MetadataTracking {
211public:
212 /// Track the reference to metadata.
213 ///
214 /// Register \c MD with \c *MD, if the subclass supports tracking. If \c *MD
215 /// gets RAUW'ed, \c MD will be updated to the new address. If \c *MD gets
216 /// deleted, \c MD will be set to \c nullptr.
217 ///
218 /// If tracking isn't supported, \c *MD will not change.
219 ///
220 /// \return true iff tracking is supported by \c MD.
221 static bool track(Metadata *&MD) {
222 return track(&MD, *MD, static_cast<Metadata *>(nullptr));
223 }
224
225 /// Track the reference to metadata for \a Metadata.
226 ///
227 /// As \a track(Metadata*&), but with support for calling back to \c Owner to
228 /// tell it that its operand changed. This could trigger \c Owner being
229 /// re-uniqued.
230 static bool track(void *Ref, Metadata &MD, Metadata &Owner) {
231 return track(Ref, MD, &Owner);
232 }
233
234 /// Track the reference to metadata for \a MetadataAsValue.
235 ///
236 /// As \a track(Metadata*&), but with support for calling back to \c Owner to
237 /// tell it that its operand changed. This could trigger \c Owner being
238 /// re-uniqued.
239 static bool track(void *Ref, Metadata &MD, MetadataAsValue &Owner) {
240 return track(Ref, MD, &Owner);
241 }
242
243 /// Stop tracking a reference to metadata.
244 ///
245 /// Stops \c *MD from tracking \c MD.
246 static void untrack(Metadata *&MD) { untrack(&MD, *MD); }
247 static void untrack(void *Ref, Metadata &MD);
248
249 /// Move tracking from one reference to another.
250 ///
251 /// Semantically equivalent to \c untrack(MD) followed by \c track(New),
252 /// except that ownership callbacks are maintained.
253 ///
254 /// Note: it is an error if \c *MD does not equal \c New.
255 ///
256 /// \return true iff tracking is supported by \c MD.
257 static bool retrack(Metadata *&MD, Metadata *&New) {
258 return retrack(&MD, *MD, &New);
259 }
260 static bool retrack(void *Ref, Metadata &MD, void *New);
261
262 /// Check whether metadata is replaceable.
263 static bool isReplaceable(const Metadata &MD);
264
265 using OwnerTy = PointerUnion<MetadataAsValue *, Metadata *>;
266
267private:
268 /// Track a reference to metadata for an owner.
269 ///
270 /// Generalized version of tracking.
271 static bool track(void *Ref, Metadata &MD, OwnerTy Owner);
272};
273
274/// Shared implementation of use-lists for replaceable metadata.
275///
276/// Most metadata cannot be RAUW'ed. This is a shared implementation of
277/// use-lists and associated API for the two that support it (\a ValueAsMetadata
278/// and \a TempMDNode).
279class ReplaceableMetadataImpl {
280 friend class MetadataTracking;
281
282public:
283 using OwnerTy = MetadataTracking::OwnerTy;
284
285private:
286 LLVMContext &Context;
287 uint64_t NextIndex = 0;
288 SmallDenseMap<void *, std::pair<OwnerTy, uint64_t>, 4> UseMap;
289
290public:
291 ReplaceableMetadataImpl(LLVMContext &Context) : Context(Context) {}
292
293 ~ReplaceableMetadataImpl() {
294 assert(UseMap.empty() && "Cannot destroy in-use replaceable metadata");
295 }
296
297 LLVMContext &getContext() const { return Context; }
298
299 /// Replace all uses of this with MD.
300 ///
301 /// Replace all uses of this with \c MD, which is allowed to be null.
302 void replaceAllUsesWith(Metadata *MD);
303
304 /// Resolve all uses of this.
305 ///
306 /// Resolve all uses of this, turning off RAUW permanently. If \c
307 /// ResolveUsers, call \a MDNode::resolve() on any users whose last operand
308 /// is resolved.
309 void resolveAllUses(bool ResolveUsers = true);
310
311private:
312 void addRef(void *Ref, OwnerTy Owner);
313 void dropRef(void *Ref);
314 void moveRef(void *Ref, void *New, const Metadata &MD);
315
316 /// Lazily construct RAUW support on MD.
317 ///
318 /// If this is an unresolved MDNode, RAUW support will be created on-demand.
319 /// ValueAsMetadata always has RAUW support.
320 static ReplaceableMetadataImpl *getOrCreate(Metadata &MD);
321
322 /// Get RAUW support on MD, if it exists.
323 static ReplaceableMetadataImpl *getIfExists(Metadata &MD);
324
325 /// Check whether this node will support RAUW.
326 ///
327 /// Returns \c true unless getOrCreate() would return null.
328 static bool isReplaceable(const Metadata &MD);
329};
330
331/// Value wrapper in the Metadata hierarchy.
332///
333/// This is a custom value handle that allows other metadata to refer to
334/// classes in the Value hierarchy.
335///
336/// Because of full uniquing support, each value is only wrapped by a single \a
337/// ValueAsMetadata object, so the lookup maps are far more efficient than
338/// those using ValueHandleBase.
339class ValueAsMetadata : public Metadata, ReplaceableMetadataImpl {
340 friend class ReplaceableMetadataImpl;
341 friend class LLVMContextImpl;
342
343 Value *V;
344
345 /// Drop users without RAUW (during teardown).
346 void dropUsers() {
347 ReplaceableMetadataImpl::resolveAllUses(/* ResolveUsers */ false);
348 }
349
350protected:
351 ValueAsMetadata(unsigned ID, Value *V)
352 : Metadata(ID, Uniqued), ReplaceableMetadataImpl(V->getContext()), V(V) {
353 assert(V && "Expected valid value");
354 }
355
356 ~ValueAsMetadata() = default;
357
358public:
359 static ValueAsMetadata *get(Value *V);
360
361 static ConstantAsMetadata *getConstant(Value *C) {
362 return cast<ConstantAsMetadata>(get(C));
363 }
364
365 static LocalAsMetadata *getLocal(Value *Local) {
366 return cast<LocalAsMetadata>(get(Local));
367 }
368
369 static ValueAsMetadata *getIfExists(Value *V);
370
371 static ConstantAsMetadata *getConstantIfExists(Value *C) {
372 return cast_or_null<ConstantAsMetadata>(getIfExists(C));
373 }
374
375 static LocalAsMetadata *getLocalIfExists(Value *Local) {
376 return cast_or_null<LocalAsMetadata>(getIfExists(Local));
377 }
378
379 Value *getValue() const { return V; }
380 Type *getType() const { return V->getType(); }
381 LLVMContext &getContext() const { return V->getContext(); }
382
383 static void handleDeletion(Value *V);
384 static void handleRAUW(Value *From, Value *To);
385
386protected:
387 /// Handle collisions after \a Value::replaceAllUsesWith().
388 ///
389 /// RAUW isn't supported directly for \a ValueAsMetadata, but if the wrapped
390 /// \a Value gets RAUW'ed and the target already exists, this is used to
391 /// merge the two metadata nodes.
392 void replaceAllUsesWith(Metadata *MD) {
393 ReplaceableMetadataImpl::replaceAllUsesWith(MD);
394 }
395
396public:
397 static bool classof(const Metadata *MD) {
398 return MD->getMetadataID() == LocalAsMetadataKind ||
399 MD->getMetadataID() == ConstantAsMetadataKind;
400 }
401};
402
403class ConstantAsMetadata : public ValueAsMetadata {
404 friend class ValueAsMetadata;
405
406 ConstantAsMetadata(Constant *C)
407 : ValueAsMetadata(ConstantAsMetadataKind, C) {}
408
409public:
410 static ConstantAsMetadata *get(Constant *C) {
411 return ValueAsMetadata::getConstant(C);
412 }
413
414 static ConstantAsMetadata *getIfExists(Constant *C) {
415 return ValueAsMetadata::getConstantIfExists(C);
416 }
417
418 Constant *getValue() const {
419 return cast<Constant>(ValueAsMetadata::getValue());
420 }
421
422 static bool classof(const Metadata *MD) {
423 return MD->getMetadataID() == ConstantAsMetadataKind;
424 }
425};
426
427class LocalAsMetadata : public ValueAsMetadata {
428 friend class ValueAsMetadata;
429
430 LocalAsMetadata(Value *Local)
431 : ValueAsMetadata(LocalAsMetadataKind, Local) {
432 assert(!isa<Constant>(Local) && "Expected local value");
433 }
434
435public:
436 static LocalAsMetadata *get(Value *Local) {
437 return ValueAsMetadata::getLocal(Local);
438 }
439
440 static LocalAsMetadata *getIfExists(Value *Local) {
441 return ValueAsMetadata::getLocalIfExists(Local);
442 }
443
444 static bool classof(const Metadata *MD) {
445 return MD->getMetadataID() == LocalAsMetadataKind;
446 }
447};
448
449/// Transitional API for extracting constants from Metadata.
450///
451/// This namespace contains transitional functions for metadata that points to
452/// \a Constants.
453///
454/// In prehistory -- when metadata was a subclass of \a Value -- \a MDNode
455/// operands could refer to any \a Value. There's was a lot of code like this:
456///
457/// \code
458/// MDNode *N = ...;
459/// auto *CI = dyn_cast<ConstantInt>(N->getOperand(2));
460/// \endcode
461///
462/// Now that \a Value and \a Metadata are in separate hierarchies, maintaining
463/// the semantics for \a isa(), \a cast(), \a dyn_cast() (etc.) requires three
464/// steps: cast in the \a Metadata hierarchy, extraction of the \a Value, and
465/// cast in the \a Value hierarchy. Besides creating boiler-plate, this
466/// requires subtle control flow changes.
467///
468/// The end-goal is to create a new type of metadata, called (e.g.) \a MDInt,
469/// so that metadata can refer to numbers without traversing a bridge to the \a
470/// Value hierarchy. In this final state, the code above would look like this:
471///
472/// \code
473/// MDNode *N = ...;
474/// auto *MI = dyn_cast<MDInt>(N->getOperand(2));
475/// \endcode
476///
477/// The API in this namespace supports the transition. \a MDInt doesn't exist
478/// yet, and even once it does, changing each metadata schema to use it is its
479/// own mini-project. In the meantime this API prevents us from introducing
480/// complex and bug-prone control flow that will disappear in the end. In
481/// particular, the above code looks like this:
482///
483/// \code
484/// MDNode *N = ...;
485/// auto *CI = mdconst::dyn_extract<ConstantInt>(N->getOperand(2));
486/// \endcode
487///
488/// The full set of provided functions includes:
489///
490/// mdconst::hasa <=> isa
491/// mdconst::extract <=> cast
492/// mdconst::extract_or_null <=> cast_or_null
493/// mdconst::dyn_extract <=> dyn_cast
494/// mdconst::dyn_extract_or_null <=> dyn_cast_or_null
495///
496/// The target of the cast must be a subclass of \a Constant.
497namespace mdconst {
498
499namespace detail {
500
501template <class T> T &make();
502template <class T, class Result> struct HasDereference {
503 using Yes = char[1];
504 using No = char[2];
505 template <size_t N> struct SFINAE {};
506
507 template <class U, class V>
508 static Yes &hasDereference(SFINAE<sizeof(static_cast<V>(*make<U>()))> * = 0);
509 template <class U, class V> static No &hasDereference(...);
510
511 static const bool value =
512 sizeof(hasDereference<T, Result>(nullptr)) == sizeof(Yes);
513};
514template <class V, class M> struct IsValidPointer {
515 static const bool value = std::is_base_of<Constant, V>::value &&
516 HasDereference<M, const Metadata &>::value;
517};
518template <class V, class M> struct IsValidReference {
519 static const bool value = std::is_base_of<Constant, V>::value &&
520 std::is_convertible<M, const Metadata &>::value;
521};
522
523} // end namespace detail
524
525/// Check whether Metadata has a Value.
526///
527/// As an analogue to \a isa(), check whether \c MD has an \a Value inside of
528/// type \c X.
529template <class X, class Y>
530inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, bool>::type
531hasa(Y &&MD) {
532 assert(MD && "Null pointer sent into hasa");
533 if (auto *V = dyn_cast<ConstantAsMetadata>(MD))
534 return isa<X>(V->getValue());
535 return false;
536}
537template <class X, class Y>
538inline
539 typename std::enable_if<detail::IsValidReference<X, Y &>::value, bool>::type
540 hasa(Y &MD) {
541 return hasa(&MD);
542}
543
544/// Extract a Value from Metadata.
545///
546/// As an analogue to \a cast(), extract the \a Value subclass \c X from \c MD.
547template <class X, class Y>
548inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
549extract(Y &&MD) {
550 return cast<X>(cast<ConstantAsMetadata>(MD)->getValue());
551}
552template <class X, class Y>
553inline
554 typename std::enable_if<detail::IsValidReference<X, Y &>::value, X *>::type
555 extract(Y &MD) {
556 return extract(&MD);
557}
558
559/// Extract a Value from Metadata, allowing null.
560///
561/// As an analogue to \a cast_or_null(), extract the \a Value subclass \c X
562/// from \c MD, allowing \c MD to be null.
563template <class X, class Y>
564inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
565extract_or_null(Y &&MD) {
566 if (auto *V = cast_or_null<ConstantAsMetadata>(MD))
567 return cast<X>(V->getValue());
568 return nullptr;
569}
570
571/// Extract a Value from Metadata, if any.
572///
573/// As an analogue to \a dyn_cast_or_null(), extract the \a Value subclass \c X
574/// from \c MD, return null if \c MD doesn't contain a \a Value or if the \a
575/// Value it does contain is of the wrong subclass.
576template <class X, class Y>
577inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
578dyn_extract(Y &&MD) {
579 if (auto *V = dyn_cast<ConstantAsMetadata>(MD))
580 return dyn_cast<X>(V->getValue());
581 return nullptr;
582}
583
584/// Extract a Value from Metadata, if any, allowing null.
585///
586/// As an analogue to \a dyn_cast_or_null(), extract the \a Value subclass \c X
587/// from \c MD, return null if \c MD doesn't contain a \a Value or if the \a
588/// Value it does contain is of the wrong subclass, allowing \c MD to be null.
589template <class X, class Y>
590inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
591dyn_extract_or_null(Y &&MD) {
592 if (auto *V = dyn_cast_or_null<ConstantAsMetadata>(MD))
593 return dyn_cast<X>(V->getValue());
594 return nullptr;
595}
596
597} // end namespace mdconst
598
599//===----------------------------------------------------------------------===//
600/// A single uniqued string.
601///
602/// These are used to efficiently contain a byte sequence for metadata.
603/// MDString is always unnamed.
604class MDString : public Metadata {
605 friend class StringMapEntry<MDString>;
606
607 StringMapEntry<MDString> *Entry = nullptr;
608
609 MDString() : Metadata(MDStringKind, Uniqued) {}
610
611public:
612 MDString(const MDString &) = delete;
613 MDString &operator=(MDString &&) = delete;
614 MDString &operator=(const MDString &) = delete;
615
616 static MDString *get(LLVMContext &Context, StringRef Str);
617 static MDString *get(LLVMContext &Context, const char *Str) {
618 return get(Context, Str ? StringRef(Str) : StringRef());
619 }
620
621 StringRef getString() const;
622
623 unsigned getLength() const { return (unsigned)getString().size(); }
624
625 using iterator = StringRef::iterator;
626
627 /// Pointer to the first byte of the string.
628 iterator begin() const { return getString().begin(); }
629
630 /// Pointer to one byte past the end of the string.
631 iterator end() const { return getString().end(); }
632
633 const unsigned char *bytes_begin() const { return getString().bytes_begin(); }
634 const unsigned char *bytes_end() const { return getString().bytes_end(); }
635
636 /// Methods for support type inquiry through isa, cast, and dyn_cast.
637 static bool classof(const Metadata *MD) {
638 return MD->getMetadataID() == MDStringKind;
639 }
640};
641
642/// A collection of metadata nodes that might be associated with a
643/// memory access used by the alias-analysis infrastructure.
644struct AAMDNodes {
645 explicit AAMDNodes(MDNode *T = nullptr, MDNode *S = nullptr,
646 MDNode *N = nullptr)
647 : TBAA(T), Scope(S), NoAlias(N) {}
648
649 bool operator==(const AAMDNodes &A) const {
650 return TBAA == A.TBAA && Scope == A.Scope && NoAlias == A.NoAlias;
651 }
652
653 bool operator!=(const AAMDNodes &A) const { return !(*this == A); }
654
655 explicit operator bool() const { return TBAA || Scope || NoAlias; }
656
657 /// The tag for type-based alias analysis.
658 MDNode *TBAA;
659
660 /// The tag for alias scope specification (used with noalias).
661 MDNode *Scope;
662
663 /// The tag specifying the noalias scope.
664 MDNode *NoAlias;
665
666 /// Given two sets of AAMDNodes that apply to the same pointer,
667 /// give the best AAMDNodes that are compatible with both (i.e. a set of
668 /// nodes whose allowable aliasing conclusions are a subset of those
669 /// allowable by both of the inputs). However, for efficiency
670 /// reasons, do not create any new MDNodes.
671 AAMDNodes intersect(const AAMDNodes &Other) {
672 AAMDNodes Result;
673 Result.TBAA = Other.TBAA == TBAA ? TBAA : nullptr;
674 Result.Scope = Other.Scope == Scope ? Scope : nullptr;
675 Result.NoAlias = Other.NoAlias == NoAlias ? NoAlias : nullptr;
676 return Result;
677 }
678};
679
680// Specialize DenseMapInfo for AAMDNodes.
681template<>
682struct DenseMapInfo<AAMDNodes> {
683 static inline AAMDNodes getEmptyKey() {
684 return AAMDNodes(DenseMapInfo<MDNode *>::getEmptyKey(),
685 nullptr, nullptr);
686 }
687
688 static inline AAMDNodes getTombstoneKey() {
689 return AAMDNodes(DenseMapInfo<MDNode *>::getTombstoneKey(),
690 nullptr, nullptr);
691 }
692
693 static unsigned getHashValue(const AAMDNodes &Val) {
694 return DenseMapInfo<MDNode *>::getHashValue(Val.TBAA) ^
695 DenseMapInfo<MDNode *>::getHashValue(Val.Scope) ^
696 DenseMapInfo<MDNode *>::getHashValue(Val.NoAlias);
697 }
698
699 static bool isEqual(const AAMDNodes &LHS, const AAMDNodes &RHS) {
700 return LHS == RHS;
701 }
702};
703
704/// Tracking metadata reference owned by Metadata.
705///
706/// Similar to \a TrackingMDRef, but it's expected to be owned by an instance
707/// of \a Metadata, which has the option of registering itself for callbacks to
708/// re-unique itself.
709///
710/// In particular, this is used by \a MDNode.
711class MDOperand {
712 Metadata *MD = nullptr;
713
714public:
715 MDOperand() = default;
716 MDOperand(MDOperand &&) = delete;
717 MDOperand(const MDOperand &) = delete;
718 MDOperand &operator=(MDOperand &&) = delete;
719 MDOperand &operator=(const MDOperand &) = delete;
720 ~MDOperand() { untrack(); }
721
722 Metadata *get() const { return MD; }
723 operator Metadata *() const { return get(); }
724 Metadata *operator->() const { return get(); }
725 Metadata &operator*() const { return *get(); }
726
727 void reset() {
728 untrack();
729 MD = nullptr;
730 }
731 void reset(Metadata *MD, Metadata *Owner) {
732 untrack();
733 this->MD = MD;
734 track(Owner);
735 }
736
737private:
738 void track(Metadata *Owner) {
739 if (MD) {
740 if (Owner)
741 MetadataTracking::track(this, *MD, *Owner);
742 else
743 MetadataTracking::track(MD);
744 }
745 }
746
747 void untrack() {
748 assert(static_cast<void *>(this) == &MD && "Expected same address");
749 if (MD)
750 MetadataTracking::untrack(MD);
751 }
752};
753
754template <> struct simplify_type<MDOperand> {
755 using SimpleType = Metadata *;
756
757 static SimpleType getSimplifiedValue(MDOperand &MD) { return MD.get(); }
758};
759
760template <> struct simplify_type<const MDOperand> {
761 using SimpleType = Metadata *;
762
763 static SimpleType getSimplifiedValue(const MDOperand &MD) { return MD.get(); }
764};
765
766/// Pointer to the context, with optional RAUW support.
767///
768/// Either a raw (non-null) pointer to the \a LLVMContext, or an owned pointer
769/// to \a ReplaceableMetadataImpl (which has a reference to \a LLVMContext).
770class ContextAndReplaceableUses {
771 PointerUnion<LLVMContext *, ReplaceableMetadataImpl *> Ptr;
772
773public:
774 ContextAndReplaceableUses(LLVMContext &Context) : Ptr(&Context) {}
775 ContextAndReplaceableUses(
776 std::unique_ptr<ReplaceableMetadataImpl> ReplaceableUses)
777 : Ptr(ReplaceableUses.release()) {
778 assert(getReplaceableUses() && "Expected non-null replaceable uses");
779 }
780 ContextAndReplaceableUses() = delete;
781 ContextAndReplaceableUses(ContextAndReplaceableUses &&) = delete;
782 ContextAndReplaceableUses(const ContextAndReplaceableUses &) = delete;
783 ContextAndReplaceableUses &operator=(ContextAndReplaceableUses &&) = delete;
784 ContextAndReplaceableUses &
785 operator=(const ContextAndReplaceableUses &) = delete;
786 ~ContextAndReplaceableUses() { delete getReplaceableUses(); }
787
788 operator LLVMContext &() { return getContext(); }
789
790 /// Whether this contains RAUW support.
791 bool hasReplaceableUses() const {
792 return Ptr.is<ReplaceableMetadataImpl *>();
793 }
794
795 LLVMContext &getContext() const {
796 if (hasReplaceableUses())
797 return getReplaceableUses()->getContext();
798 return *Ptr.get<LLVMContext *>();
799 }
800
801 ReplaceableMetadataImpl *getReplaceableUses() const {
802 if (hasReplaceableUses())
803 return Ptr.get<ReplaceableMetadataImpl *>();
804 return nullptr;
805 }
806
807 /// Ensure that this has RAUW support, and then return it.
808 ReplaceableMetadataImpl *getOrCreateReplaceableUses() {
809 if (!hasReplaceableUses())
810 makeReplaceable(llvm::make_unique<ReplaceableMetadataImpl>(getContext()));
811 return getReplaceableUses();
812 }
813
814 /// Assign RAUW support to this.
815 ///
816 /// Make this replaceable, taking ownership of \c ReplaceableUses (which must
817 /// not be null).
818 void
819 makeReplaceable(std::unique_ptr<ReplaceableMetadataImpl> ReplaceableUses) {
820 assert(ReplaceableUses && "Expected non-null replaceable uses");
821 assert(&ReplaceableUses->getContext() == &getContext() &&
822 "Expected same context");
823 delete getReplaceableUses();
824 Ptr = ReplaceableUses.release();
825 }
826
827 /// Drop RAUW support.
828 ///
829 /// Cede ownership of RAUW support, returning it.
830 std::unique_ptr<ReplaceableMetadataImpl> takeReplaceableUses() {
831 assert(hasReplaceableUses() && "Expected to own replaceable uses");
832 std::unique_ptr<ReplaceableMetadataImpl> ReplaceableUses(
833 getReplaceableUses());
834 Ptr = &ReplaceableUses->getContext();
835 return ReplaceableUses;
836 }
837};
838
839struct TempMDNodeDeleter {
840 inline void operator()(MDNode *Node) const;
841};
842
843#define HANDLE_MDNODE_LEAF(CLASS) \
844 using Temp##CLASS = std::unique_ptr<CLASS, TempMDNodeDeleter>;
845#define HANDLE_MDNODE_BRANCH(CLASS) HANDLE_MDNODE_LEAF(CLASS)
846#include "llvm/IR/Metadata.def"
847
848/// Metadata node.
849///
850/// Metadata nodes can be uniqued, like constants, or distinct. Temporary
851/// metadata nodes (with full support for RAUW) can be used to delay uniquing
852/// until forward references are known. The basic metadata node is an \a
853/// MDTuple.
854///
855/// There is limited support for RAUW at construction time. At construction
856/// time, if any operand is a temporary node (or an unresolved uniqued node,
857/// which indicates a transitive temporary operand), the node itself will be
858/// unresolved. As soon as all operands become resolved, it will drop RAUW
859/// support permanently.
860///
861/// If an unresolved node is part of a cycle, \a resolveCycles() needs
862/// to be called on some member of the cycle once all temporary nodes have been
863/// replaced.
864class MDNode : public Metadata {
865 friend class ReplaceableMetadataImpl;
866 friend class LLVMContextImpl;
867
868 unsigned NumOperands;
869 unsigned NumUnresolved;
870
871 ContextAndReplaceableUses Context;
872
873protected:
874 MDNode(LLVMContext &Context, unsigned ID, StorageType Storage,
875 ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None);
876 ~MDNode() = default;
877
878 void *operator new(size_t Size, unsigned NumOps);
879 void operator delete(void *Mem);
880
881 /// Required by std, but never called.
882 void operator delete(void *, unsigned) {
883 llvm_unreachable("Constructor throws?");
884 }
885
886 /// Required by std, but never called.
887 void operator delete(void *, unsigned, bool) {
888 llvm_unreachable("Constructor throws?");
889 }
890
891 void dropAllReferences();
892
893 MDOperand *mutable_begin() { return mutable_end() - NumOperands; }
894 MDOperand *mutable_end() { return reinterpret_cast<MDOperand *>(this); }
895
896 using mutable_op_range = iterator_range<MDOperand *>;
897
898 mutable_op_range mutable_operands() {
899 return mutable_op_range(mutable_begin(), mutable_end());
900 }
901
902public:
903 MDNode(const MDNode &) = delete;
904 void operator=(const MDNode &) = delete;
905 void *operator new(size_t) = delete;
906
907 static inline MDTuple *get(LLVMContext &Context, ArrayRef<Metadata *> MDs);
908 static inline MDTuple *getIfExists(LLVMContext &Context,
909 ArrayRef<Metadata *> MDs);
910 static inline MDTuple *getDistinct(LLVMContext &Context,
911 ArrayRef<Metadata *> MDs);
912 static inline TempMDTuple getTemporary(LLVMContext &Context,
913 ArrayRef<Metadata *> MDs);
914
915 /// Create a (temporary) clone of this.
916 TempMDNode clone() const;
917
918 /// Deallocate a node created by getTemporary.
919 ///
920 /// Calls \c replaceAllUsesWith(nullptr) before deleting, so any remaining
921 /// references will be reset.
922 static void deleteTemporary(MDNode *N);
923
924 LLVMContext &getContext() const { return Context.getContext(); }
925
926 /// Replace a specific operand.
927 void replaceOperandWith(unsigned I, Metadata *New);
928
929 /// Check if node is fully resolved.
930 ///
931 /// If \a isTemporary(), this always returns \c false; if \a isDistinct(),
932 /// this always returns \c true.
933 ///
934 /// If \a isUniqued(), returns \c true if this has already dropped RAUW
935 /// support (because all operands are resolved).
936 ///
937 /// As forward declarations are resolved, their containers should get
938 /// resolved automatically. However, if this (or one of its operands) is
939 /// involved in a cycle, \a resolveCycles() needs to be called explicitly.
940 bool isResolved() const { return !isTemporary() && !NumUnresolved; }
941
942 bool isUniqued() const { return Storage == Uniqued; }
943 bool isDistinct() const { return Storage == Distinct; }
944 bool isTemporary() const { return Storage == Temporary; }
945
946 /// RAUW a temporary.
947 ///
948 /// \pre \a isTemporary() must be \c true.
949 void replaceAllUsesWith(Metadata *MD) {
950 assert(isTemporary() && "Expected temporary node");
951 if (Context.hasReplaceableUses())
952 Context.getReplaceableUses()->replaceAllUsesWith(MD);
953 }
954
955 /// Resolve cycles.
956 ///
957 /// Once all forward declarations have been resolved, force cycles to be
958 /// resolved.
959 ///
960 /// \pre No operands (or operands' operands, etc.) have \a isTemporary().
961 void resolveCycles();
962
963 /// Resolve a unique, unresolved node.
964 void resolve();
965
966 /// Replace a temporary node with a permanent one.
967 ///
968 /// Try to create a uniqued version of \c N -- in place, if possible -- and
969 /// return it. If \c N cannot be uniqued, return a distinct node instead.
970 template <class T>
971 static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
972 replaceWithPermanent(std::unique_ptr<T, TempMDNodeDeleter> N) {
973 return cast<T>(N.release()->replaceWithPermanentImpl());
974 }
975
976 /// Replace a temporary node with a uniqued one.
977 ///
978 /// Create a uniqued version of \c N -- in place, if possible -- and return
979 /// it. Takes ownership of the temporary node.
980 ///
981 /// \pre N does not self-reference.
982 template <class T>
983 static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
984 replaceWithUniqued(std::unique_ptr<T, TempMDNodeDeleter> N) {
985 return cast<T>(N.release()->replaceWithUniquedImpl());
986 }
987
988 /// Replace a temporary node with a distinct one.
989 ///
990 /// Create a distinct version of \c N -- in place, if possible -- and return
991 /// it. Takes ownership of the temporary node.
992 template <class T>
993 static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
994 replaceWithDistinct(std::unique_ptr<T, TempMDNodeDeleter> N) {
995 return cast<T>(N.release()->replaceWithDistinctImpl());
996 }
997
998private:
999 MDNode *replaceWithPermanentImpl();
1000 MDNode *replaceWithUniquedImpl();
1001 MDNode *replaceWithDistinctImpl();
1002
1003protected:
1004 /// Set an operand.
1005 ///
1006 /// Sets the operand directly, without worrying about uniquing.
1007 void setOperand(unsigned I, Metadata *New);
1008
1009 void storeDistinctInContext();
1010 template <class T, class StoreT>
1011 static T *storeImpl(T *N, StorageType Storage, StoreT &Store);
1012 template <class T> static T *storeImpl(T *N, StorageType Storage);
1013
1014private:
1015 void handleChangedOperand(void *Ref, Metadata *New);
1016
1017 /// Drop RAUW support, if any.
1018 void dropReplaceableUses();
1019
1020 void resolveAfterOperandChange(Metadata *Old, Metadata *New);
1021 void decrementUnresolvedOperandCount();
1022 void countUnresolvedOperands();
1023
1024 /// Mutate this to be "uniqued".
1025 ///
1026 /// Mutate this so that \a isUniqued().
1027 /// \pre \a isTemporary().
1028 /// \pre already added to uniquing set.
1029 void makeUniqued();
1030
1031 /// Mutate this to be "distinct".
1032 ///
1033 /// Mutate this so that \a isDistinct().
1034 /// \pre \a isTemporary().
1035 void makeDistinct();
1036
1037 void deleteAsSubclass();
1038 MDNode *uniquify();
1039 void eraseFromStore();
1040
1041 template <class NodeTy> struct HasCachedHash;
1042 template <class NodeTy>
1043 static void dispatchRecalculateHash(NodeTy *N, std::true_type) {
1044 N->recalculateHash();
1045 }
1046 template <class NodeTy>
1047 static void dispatchRecalculateHash(NodeTy *, std::false_type) {}
1048 template <class NodeTy>
1049 static void dispatchResetHash(NodeTy *N, std::true_type) {
1050 N->setHash(0);
1051 }
1052 template <class NodeTy>
1053 static void dispatchResetHash(NodeTy *, std::false_type) {}
1054
1055public:
1056 using op_iterator = const MDOperand *;
1057 using op_range = iterator_range<op_iterator>;
1058
1059 op_iterator op_begin() const {
1060 return const_cast<MDNode *>(this)->mutable_begin();
1061 }
1062
1063 op_iterator op_end() const {
1064 return const_cast<MDNode *>(this)->mutable_end();
1065 }
1066
1067 op_range operands() const { return op_range(op_begin(), op_end()); }
1068
1069 const MDOperand &getOperand(unsigned I) const {
1070 assert(I < NumOperands && "Out of range");
1071 return op_begin()[I];
1072 }
1073
1074 /// Return number of MDNode operands.
1075 unsigned getNumOperands() const { return NumOperands; }
1076
1077 /// Methods for support type inquiry through isa, cast, and dyn_cast:
1078 static bool classof(const Metadata *MD) {
1079 switch (MD->getMetadataID()) {
1080 default:
1081 return false;
1082#define HANDLE_MDNODE_LEAF(CLASS) \
1083 case CLASS##Kind: \
1084 return true;
1085#include "llvm/IR/Metadata.def"
1086 }
1087 }
1088
1089 /// Check whether MDNode is a vtable access.
1090 bool isTBAAVtableAccess() const;
1091
1092 /// Methods for metadata merging.
1093 static MDNode *concatenate(MDNode *A, MDNode *B);
1094 static MDNode *intersect(MDNode *A, MDNode *B);
1095 static MDNode *getMostGenericTBAA(MDNode *A, MDNode *B);
1096 static MDNode *getMostGenericFPMath(MDNode *A, MDNode *B);
1097 static MDNode *getMostGenericRange(MDNode *A, MDNode *B);
1098 static MDNode *getMostGenericAliasScope(MDNode *A, MDNode *B);
1099 static MDNode *getMostGenericAlignmentOrDereferenceable(MDNode *A, MDNode *B);
1100};
1101
1102/// Tuple of metadata.
1103///
1104/// This is the simple \a MDNode arbitrary tuple. Nodes are uniqued by
1105/// default based on their operands.
1106class MDTuple : public MDNode {
1107 friend class LLVMContextImpl;
1108 friend class MDNode;
1109
1110 MDTuple(LLVMContext &C, StorageType Storage, unsigned Hash,
1111 ArrayRef<Metadata *> Vals)
1112 : MDNode(C, MDTupleKind, Storage, Vals) {
1113 setHash(Hash);
1114 }
1115
1116 ~MDTuple() { dropAllReferences(); }
1117
1118 void setHash(unsigned Hash) { SubclassData32 = Hash; }
1119 void recalculateHash();
1120
1121 static MDTuple *getImpl(LLVMContext &Context, ArrayRef<Metadata *> MDs,
1122 StorageType Storage, bool ShouldCreate = true);
1123
1124 TempMDTuple cloneImpl() const {
1125 return getTemporary(getContext(),
1126 SmallVector<Metadata *, 4>(op_begin(), op_end()));
1127 }
1128
1129public:
1130 /// Get the hash, if any.
1131 unsigned getHash() const { return SubclassData32; }
1132
1133 static MDTuple *get(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1134 return getImpl(Context, MDs, Uniqued);
1135 }
1136
1137 static MDTuple *getIfExists(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1138 return getImpl(Context, MDs, Uniqued, /* ShouldCreate */ false);
1139 }
1140
1141 /// Return a distinct node.
1142 ///
1143 /// Return a distinct node -- i.e., a node that is not uniqued.
1144 static MDTuple *getDistinct(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1145 return getImpl(Context, MDs, Distinct);
1146 }
1147
1148 /// Return a temporary node.
1149 ///
1150 /// For use in constructing cyclic MDNode structures. A temporary MDNode is
1151 /// not uniqued, may be RAUW'd, and must be manually deleted with
1152 /// deleteTemporary.
1153 static TempMDTuple getTemporary(LLVMContext &Context,
1154 ArrayRef<Metadata *> MDs) {
1155 return TempMDTuple(getImpl(Context, MDs, Temporary));
1156 }
1157
1158 /// Return a (temporary) clone of this.
1159 TempMDTuple clone() const { return cloneImpl(); }
1160
1161 static bool classof(const Metadata *MD) {
1162 return MD->getMetadataID() == MDTupleKind;
1163 }
1164};
1165
1166MDTuple *MDNode::get(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1167 return MDTuple::get(Context, MDs);
1168}
1169
1170MDTuple *MDNode::getIfExists(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1171 return MDTuple::getIfExists(Context, MDs);
1172}
1173
1174MDTuple *MDNode::getDistinct(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1175 return MDTuple::getDistinct(Context, MDs);
1176}
1177
1178TempMDTuple MDNode::getTemporary(LLVMContext &Context,
1179 ArrayRef<Metadata *> MDs) {
1180 return MDTuple::getTemporary(Context, MDs);
1181}
1182
1183void TempMDNodeDeleter::operator()(MDNode *Node) const {
1184 MDNode::deleteTemporary(Node);
1185}
1186
1187/// Typed iterator through MDNode operands.
1188///
1189/// An iterator that transforms an \a MDNode::iterator into an iterator over a
1190/// particular Metadata subclass.
1191template <class T>
1192class TypedMDOperandIterator
1193 : public std::iterator<std::input_iterator_tag, T *, std::ptrdiff_t, void,
1194 T *> {
1195 MDNode::op_iterator I = nullptr;
1196
1197public:
1198 TypedMDOperandIterator() = default;
1199 explicit TypedMDOperandIterator(MDNode::op_iterator I) : I(I) {}
1200
1201 T *operator*() const { return cast_or_null<T>(*I); }
1202
1203 TypedMDOperandIterator &operator++() {
1204 ++I;
1205 return *this;
1206 }
1207
1208 TypedMDOperandIterator operator++(int) {
1209 TypedMDOperandIterator Temp(*this);
1210 ++I;
1211 return Temp;
1212 }
1213
1214 bool operator==(const TypedMDOperandIterator &X) const { return I == X.I; }
1215 bool operator!=(const TypedMDOperandIterator &X) const { return I != X.I; }
1216};
1217
1218/// Typed, array-like tuple of metadata.
1219///
1220/// This is a wrapper for \a MDTuple that makes it act like an array holding a
1221/// particular type of metadata.
1222template <class T> class MDTupleTypedArrayWrapper {
1223 const MDTuple *N = nullptr;
1224
1225public:
1226 MDTupleTypedArrayWrapper() = default;
1227 MDTupleTypedArrayWrapper(const MDTuple *N) : N(N) {}
1228
1229 template <class U>
1230 MDTupleTypedArrayWrapper(
1231 const MDTupleTypedArrayWrapper<U> &Other,
1232 typename std::enable_if<std::is_convertible<U *, T *>::value>::type * =
1233 nullptr)
1234 : N(Other.get()) {}
1235
1236 template <class U>
1237 explicit MDTupleTypedArrayWrapper(
1238 const MDTupleTypedArrayWrapper<U> &Other,
1239 typename std::enable_if<!std::is_convertible<U *, T *>::value>::type * =
1240 nullptr)
1241 : N(Other.get()) {}
1242
1243 explicit operator bool() const { return get(); }
1244 explicit operator MDTuple *() const { return get(); }
1245
1246 MDTuple *get() const { return const_cast<MDTuple *>(N); }
1247 MDTuple *operator->() const { return get(); }
1248 MDTuple &operator*() const { return *get(); }
1249
1250 // FIXME: Fix callers and remove condition on N.
1251 unsigned size() const { return N ? N->getNumOperands() : 0u; }
1252 bool empty() const { return N ? N->getNumOperands() == 0 : true; }
1253 T *operator[](unsigned I) const { return cast_or_null<T>(N->getOperand(I)); }
1254
1255 // FIXME: Fix callers and remove condition on N.
1256 using iterator = TypedMDOperandIterator<T>;
1257
1258 iterator begin() const { return N ? iterator(N->op_begin()) : iterator(); }
1259 iterator end() const { return N ? iterator(N->op_end()) : iterator(); }
1260};
1261
1262#define HANDLE_METADATA(CLASS) \
1263 using CLASS##Array = MDTupleTypedArrayWrapper<CLASS>;
1264#include "llvm/IR/Metadata.def"
1265
1266/// Placeholder metadata for operands of distinct MDNodes.
1267///
1268/// This is a lightweight placeholder for an operand of a distinct node. It's
1269/// purpose is to help track forward references when creating a distinct node.
1270/// This allows distinct nodes involved in a cycle to be constructed before
1271/// their operands without requiring a heavyweight temporary node with
1272/// full-blown RAUW support.
1273///
1274/// Each placeholder supports only a single MDNode user. Clients should pass
1275/// an ID, retrieved via \a getID(), to indicate the "real" operand that this
1276/// should be replaced with.
1277///
1278/// While it would be possible to implement move operators, they would be
1279/// fairly expensive. Leave them unimplemented to discourage their use
1280/// (clients can use std::deque, std::list, BumpPtrAllocator, etc.).
1281class DistinctMDOperandPlaceholder : public Metadata {
1282 friend class MetadataTracking;
1283
1284 Metadata **Use = nullptr;
1285
1286public:
1287 explicit DistinctMDOperandPlaceholder(unsigned ID)
1288 : Metadata(DistinctMDOperandPlaceholderKind, Distinct) {
1289 SubclassData32 = ID;
1290 }
1291
1292 DistinctMDOperandPlaceholder() = delete;
1293 DistinctMDOperandPlaceholder(DistinctMDOperandPlaceholder &&) = delete;
1294 DistinctMDOperandPlaceholder(const DistinctMDOperandPlaceholder &) = delete;
1295
1296 ~DistinctMDOperandPlaceholder() {
1297 if (Use)
1298 *Use = nullptr;
1299 }
1300
1301 unsigned getID() const { return SubclassData32; }
1302
1303 /// Replace the use of this with MD.
1304 void replaceUseWith(Metadata *MD) {
1305 if (!Use)
1306 return;
1307 *Use = MD;
1308
1309 if (*Use)
1310 MetadataTracking::track(*Use);
1311
1312 Metadata *T = cast<Metadata>(this);
1313 MetadataTracking::untrack(T);
1314 assert(!Use && "Use is still being tracked despite being untracked!");
1315 }
1316};
1317
1318//===----------------------------------------------------------------------===//
1319/// A tuple of MDNodes.
1320///
1321/// Despite its name, a NamedMDNode isn't itself an MDNode.
1322///
1323/// NamedMDNodes are named module-level entities that contain lists of MDNodes.
1324///
1325/// It is illegal for a NamedMDNode to appear as an operand of an MDNode.
1326class NamedMDNode : public ilist_node<NamedMDNode> {
1327 friend class LLVMContextImpl;
1328 friend class Module;
1329
1330 std::string Name;
1331 Module *Parent = nullptr;
1332 void *Operands; // SmallVector<TrackingMDRef, 4>
1333
1334 void setParent(Module *M) { Parent = M; }
1335
1336 explicit NamedMDNode(const Twine &N);
1337
1338 template<class T1, class T2>
1339 class op_iterator_impl :
1340 public std::iterator<std::bidirectional_iterator_tag, T2> {
1341 friend class NamedMDNode;
1342
1343 const NamedMDNode *Node = nullptr;
1344 unsigned Idx = 0;
1345
1346 op_iterator_impl(const NamedMDNode *N, unsigned i) : Node(N), Idx(i) {}
1347
1348 public:
1349 op_iterator_impl() = default;
1350
1351 bool operator==(const op_iterator_impl &o) const { return Idx == o.Idx; }
1352 bool operator!=(const op_iterator_impl &o) const { return Idx != o.Idx; }
1353
1354 op_iterator_impl &operator++() {
1355 ++Idx;
1356 return *this;
1357 }
1358
1359 op_iterator_impl operator++(int) {
1360 op_iterator_impl tmp(*this);
1361 operator++();
1362 return tmp;
1363 }
1364
1365 op_iterator_impl &operator--() {
1366 --Idx;
1367 return *this;
1368 }
1369
1370 op_iterator_impl operator--(int) {
1371 op_iterator_impl tmp(*this);
1372 operator--();
1373 return tmp;
1374 }
1375
1376 T1 operator*() const { return Node->getOperand(Idx); }
1377 };
1378
1379public:
1380 NamedMDNode(const NamedMDNode &) = delete;
1381 ~NamedMDNode();
1382
1383 /// Drop all references and remove the node from parent module.
1384 void eraseFromParent();
1385
1386 /// Remove all uses and clear node vector.
1387 void dropAllReferences() { clearOperands(); }
1388 /// Drop all references to this node's operands.
1389 void clearOperands();
1390
1391 /// Get the module that holds this named metadata collection.
1392 inline Module *getParent() { return Parent; }
1393 inline const Module *getParent() const { return Parent; }
1394
1395 MDNode *getOperand(unsigned i) const;
1396 unsigned getNumOperands() const;
1397 void addOperand(MDNode *M);
1398 void setOperand(unsigned I, MDNode *New);
1399 StringRef getName() const;
1400 void print(raw_ostream &ROS, bool IsForDebug = false) const;
1401 void print(raw_ostream &ROS, ModuleSlotTracker &MST,
1402 bool IsForDebug = false) const;
1403 void dump() const;
1404
1405 // ---------------------------------------------------------------------------
1406 // Operand Iterator interface...
1407 //
1408 using op_iterator = op_iterator_impl<MDNode *, MDNode>;
1409
1410 op_iterator op_begin() { return op_iterator(this, 0); }
1411 op_iterator op_end() { return op_iterator(this, getNumOperands()); }
1412
1413 using const_op_iterator = op_iterator_impl<const MDNode *, MDNode>;
1414
1415 const_op_iterator op_begin() const { return const_op_iterator(this, 0); }
1416 const_op_iterator op_end() const { return const_op_iterator(this, getNumOperands()); }
1417
1418 inline iterator_range<op_iterator> operands() {
1419 return make_range(op_begin(), op_end());
1420 }
1421 inline iterator_range<const_op_iterator> operands() const {
1422 return make_range(op_begin(), op_end());
1423 }
1424};
1425
1426// Create wrappers for C Binding types (see CBindingWrapping.h).
1427DEFINE_ISA_CONVERSION_FUNCTIONS(NamedMDNode, LLVMNamedMDNodeRef)
1428
1429} // end namespace llvm
1430
1431#endif // LLVM_IR_METADATA_H
1432