1 //===- llvm/IR/Metadata.h - Metadata definitions ----------------*- C++ -*-===//
2 //
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
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 /// @file
10 /// This file contains the declarations for metadata subclasses.
11 /// They represent the different flavors of metadata that live in LLVM.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #ifndef LLVM_IR_METADATA_H
16 #define LLVM_IR_METADATA_H
17
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/StringMap.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
44 namespace llvm {
45
46 class Module;
47 class ModuleSlotTracker;
48 class raw_ostream;
49 class Type;
50
51 enum 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.
58 class Metadata {
59 friend class ReplaceableMetadataImpl;
60
61 /// RTTI.
62 const unsigned char SubclassID;
63
64 protected:
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
77 public:
78 enum MetadataKind {
79 #define HANDLE_METADATA_LEAF(CLASS) CLASS##Kind,
80 #include "llvm/IR/Metadata.def"
81 };
82
83 protected:
Metadata(unsigned ID,StorageType Storage)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.
handleChangedOperand(void *,Metadata *)95 void handleChangedOperand(void *, Metadata *) {
96 llvm_unreachable("Unimplemented in Metadata subclass");
97 }
98
99 public:
getMetadataID()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).
DEFINE_ISA_CONVERSION_FUNCTIONS(Metadata,LLVMMetadataRef)142 DEFINE_ISA_CONVERSION_FUNCTIONS(Metadata, LLVMMetadataRef)
143
144 // Specialized opaque metadata conversions.
145 inline 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
162 inline 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.
174 class 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).
dropUse()183 void dropUse() { MD = nullptr; }
184
185 public:
186 ~MetadataAsValue();
187
188 static MetadataAsValue *get(LLVMContext &Context, Metadata *MD);
189 static MetadataAsValue *getIfExists(LLVMContext &Context, Metadata *MD);
190
getMetadata()191 Metadata *getMetadata() const { return MD; }
192
classof(const Value * V)193 static bool classof(const Value *V) {
194 return V->getValueID() == MetadataAsValueVal;
195 }
196
197 private:
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.
210 class MetadataTracking {
211 public:
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.
track(Metadata * & 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.
track(void * Ref,Metadata & MD,Metadata & Owner)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.
track(void * Ref,Metadata & MD,MetadataAsValue & Owner)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.
untrack(Metadata * & 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.
retrack(Metadata * & MD,Metadata * & New)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
267 private:
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).
279 class ReplaceableMetadataImpl {
280 friend class MetadataTracking;
281
282 public:
283 using OwnerTy = MetadataTracking::OwnerTy;
284
285 private:
286 LLVMContext &Context;
287 uint64_t NextIndex = 0;
288 SmallDenseMap<void *, std::pair<OwnerTy, uint64_t>, 4> UseMap;
289
290 public:
ReplaceableMetadataImpl(LLVMContext & Context)291 ReplaceableMetadataImpl(LLVMContext &Context) : Context(Context) {}
292
~ReplaceableMetadataImpl()293 ~ReplaceableMetadataImpl() {
294 assert(UseMap.empty() && "Cannot destroy in-use replaceable metadata");
295 }
296
getContext()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
311 private:
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.
339 class ValueAsMetadata : public Metadata, ReplaceableMetadataImpl {
340 friend class ReplaceableMetadataImpl;
341 friend class LLVMContextImpl;
342
343 Value *V;
344
345 /// Drop users without RAUW (during teardown).
dropUsers()346 void dropUsers() {
347 ReplaceableMetadataImpl::resolveAllUses(/* ResolveUsers */ false);
348 }
349
350 protected:
ValueAsMetadata(unsigned ID,Value * V)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
358 public:
359 static ValueAsMetadata *get(Value *V);
360
getConstant(Value * C)361 static ConstantAsMetadata *getConstant(Value *C) {
362 return cast<ConstantAsMetadata>(get(C));
363 }
364
getLocal(Value * Local)365 static LocalAsMetadata *getLocal(Value *Local) {
366 return cast<LocalAsMetadata>(get(Local));
367 }
368
369 static ValueAsMetadata *getIfExists(Value *V);
370
getConstantIfExists(Value * C)371 static ConstantAsMetadata *getConstantIfExists(Value *C) {
372 return cast_or_null<ConstantAsMetadata>(getIfExists(C));
373 }
374
getLocalIfExists(Value * Local)375 static LocalAsMetadata *getLocalIfExists(Value *Local) {
376 return cast_or_null<LocalAsMetadata>(getIfExists(Local));
377 }
378
getValue()379 Value *getValue() const { return V; }
getType()380 Type *getType() const { return V->getType(); }
getContext()381 LLVMContext &getContext() const { return V->getContext(); }
382
383 static void handleDeletion(Value *V);
384 static void handleRAUW(Value *From, Value *To);
385
386 protected:
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.
replaceAllUsesWith(Metadata * MD)392 void replaceAllUsesWith(Metadata *MD) {
393 ReplaceableMetadataImpl::replaceAllUsesWith(MD);
394 }
395
396 public:
classof(const Metadata * MD)397 static bool classof(const Metadata *MD) {
398 return MD->getMetadataID() == LocalAsMetadataKind ||
399 MD->getMetadataID() == ConstantAsMetadataKind;
400 }
401 };
402
403 class ConstantAsMetadata : public ValueAsMetadata {
404 friend class ValueAsMetadata;
405
ConstantAsMetadata(Constant * C)406 ConstantAsMetadata(Constant *C)
407 : ValueAsMetadata(ConstantAsMetadataKind, C) {}
408
409 public:
get(Constant * C)410 static ConstantAsMetadata *get(Constant *C) {
411 return ValueAsMetadata::getConstant(C);
412 }
413
getIfExists(Constant * C)414 static ConstantAsMetadata *getIfExists(Constant *C) {
415 return ValueAsMetadata::getConstantIfExists(C);
416 }
417
getValue()418 Constant *getValue() const {
419 return cast<Constant>(ValueAsMetadata::getValue());
420 }
421
classof(const Metadata * MD)422 static bool classof(const Metadata *MD) {
423 return MD->getMetadataID() == ConstantAsMetadataKind;
424 }
425 };
426
427 class LocalAsMetadata : public ValueAsMetadata {
428 friend class ValueAsMetadata;
429
LocalAsMetadata(Value * Local)430 LocalAsMetadata(Value *Local)
431 : ValueAsMetadata(LocalAsMetadataKind, Local) {
432 assert(!isa<Constant>(Local) && "Expected local value");
433 }
434
435 public:
get(Value * Local)436 static LocalAsMetadata *get(Value *Local) {
437 return ValueAsMetadata::getLocal(Local);
438 }
439
getIfExists(Value * Local)440 static LocalAsMetadata *getIfExists(Value *Local) {
441 return ValueAsMetadata::getLocalIfExists(Local);
442 }
443
classof(const Metadata * MD)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.
497 namespace mdconst {
498
499 namespace detail {
500
501 template <class T> T &make();
502 template <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 };
514 template <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 };
518 template <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.
529 template <class X, class Y>
530 inline std::enable_if_t<detail::IsValidPointer<X, Y>::value, bool>
hasa(Y && MD)531 hasa(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 }
537 template <class X, class Y>
538 inline std::enable_if_t<detail::IsValidReference<X, Y &>::value, bool>
hasa(Y & MD)539 hasa(Y &MD) {
540 return hasa(&MD);
541 }
542
543 /// Extract a Value from Metadata.
544 ///
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 std::enable_if_t<detail::IsValidPointer<X, Y>::value, X *>
extract(Y && MD)548 extract(Y &&MD) {
549 return cast<X>(cast<ConstantAsMetadata>(MD)->getValue());
550 }
551 template <class X, class Y>
552 inline std::enable_if_t<detail::IsValidReference<X, Y &>::value, X *>
extract(Y & MD)553 extract(Y &MD) {
554 return extract(&MD);
555 }
556
557 /// Extract a Value from Metadata, allowing null.
558 ///
559 /// As an analogue to \a cast_or_null(), extract the \a Value subclass \c X
560 /// from \c MD, allowing \c MD to be null.
561 template <class X, class Y>
562 inline std::enable_if_t<detail::IsValidPointer<X, Y>::value, X *>
extract_or_null(Y && MD)563 extract_or_null(Y &&MD) {
564 if (auto *V = cast_or_null<ConstantAsMetadata>(MD))
565 return cast<X>(V->getValue());
566 return nullptr;
567 }
568
569 /// Extract a Value from Metadata, if any.
570 ///
571 /// As an analogue to \a dyn_cast_or_null(), extract the \a Value subclass \c X
572 /// from \c MD, return null if \c MD doesn't contain a \a Value or if the \a
573 /// Value it does contain is of the wrong subclass.
574 template <class X, class Y>
575 inline std::enable_if_t<detail::IsValidPointer<X, Y>::value, X *>
dyn_extract(Y && MD)576 dyn_extract(Y &&MD) {
577 if (auto *V = dyn_cast<ConstantAsMetadata>(MD))
578 return dyn_cast<X>(V->getValue());
579 return nullptr;
580 }
581
582 /// Extract a Value from Metadata, if any, allowing null.
583 ///
584 /// As an analogue to \a dyn_cast_or_null(), extract the \a Value subclass \c X
585 /// from \c MD, return null if \c MD doesn't contain a \a Value or if the \a
586 /// Value it does contain is of the wrong subclass, allowing \c MD to be null.
587 template <class X, class Y>
588 inline std::enable_if_t<detail::IsValidPointer<X, Y>::value, X *>
dyn_extract_or_null(Y && MD)589 dyn_extract_or_null(Y &&MD) {
590 if (auto *V = dyn_cast_or_null<ConstantAsMetadata>(MD))
591 return dyn_cast<X>(V->getValue());
592 return nullptr;
593 }
594
595 } // end namespace mdconst
596
597 //===----------------------------------------------------------------------===//
598 /// A single uniqued string.
599 ///
600 /// These are used to efficiently contain a byte sequence for metadata.
601 /// MDString is always unnamed.
602 class MDString : public Metadata {
603 friend class StringMapEntryStorage<MDString>;
604
605 StringMapEntry<MDString> *Entry = nullptr;
606
MDString()607 MDString() : Metadata(MDStringKind, Uniqued) {}
608
609 public:
610 MDString(const MDString &) = delete;
611 MDString &operator=(MDString &&) = delete;
612 MDString &operator=(const MDString &) = delete;
613
614 static MDString *get(LLVMContext &Context, StringRef Str);
get(LLVMContext & Context,const char * Str)615 static MDString *get(LLVMContext &Context, const char *Str) {
616 return get(Context, Str ? StringRef(Str) : StringRef());
617 }
618
619 StringRef getString() const;
620
getLength()621 unsigned getLength() const { return (unsigned)getString().size(); }
622
623 using iterator = StringRef::iterator;
624
625 /// Pointer to the first byte of the string.
begin()626 iterator begin() const { return getString().begin(); }
627
628 /// Pointer to one byte past the end of the string.
end()629 iterator end() const { return getString().end(); }
630
bytes_begin()631 const unsigned char *bytes_begin() const { return getString().bytes_begin(); }
bytes_end()632 const unsigned char *bytes_end() const { return getString().bytes_end(); }
633
634 /// Methods for support type inquiry through isa, cast, and dyn_cast.
classof(const Metadata * MD)635 static bool classof(const Metadata *MD) {
636 return MD->getMetadataID() == MDStringKind;
637 }
638 };
639
640 /// A collection of metadata nodes that might be associated with a
641 /// memory access used by the alias-analysis infrastructure.
642 struct AAMDNodes {
643 explicit AAMDNodes() = default;
AAMDNodesAAMDNodes644 explicit AAMDNodes(MDNode *T, MDNode *TS, MDNode *S, MDNode *N)
645 : TBAA(T), TBAAStruct(TS), Scope(S), NoAlias(N) {}
646
647 bool operator==(const AAMDNodes &A) const {
648 return TBAA == A.TBAA && TBAAStruct == A.TBAAStruct && Scope == A.Scope &&
649 NoAlias == A.NoAlias;
650 }
651
652 bool operator!=(const AAMDNodes &A) const { return !(*this == A); }
653
654 explicit operator bool() const {
655 return TBAA || TBAAStruct || Scope || NoAlias;
656 }
657
658 /// The tag for type-based alias analysis.
659 MDNode *TBAA = nullptr;
660
661 /// The tag for type-based alias analysis (tbaa struct).
662 MDNode *TBAAStruct = nullptr;
663
664 /// The tag for alias scope specification (used with noalias).
665 MDNode *Scope = nullptr;
666
667 /// The tag specifying the noalias scope.
668 MDNode *NoAlias = nullptr;
669
670 // Shift tbaa Metadata node to start off bytes later
671 static MDNode *ShiftTBAA(MDNode *M, size_t off);
672
673 // Shift tbaa.struct Metadata node to start off bytes later
674 static MDNode *ShiftTBAAStruct(MDNode *M, size_t off);
675
676 /// Given two sets of AAMDNodes that apply to the same pointer,
677 /// give the best AAMDNodes that are compatible with both (i.e. a set of
678 /// nodes whose allowable aliasing conclusions are a subset of those
679 /// allowable by both of the inputs). However, for efficiency
680 /// reasons, do not create any new MDNodes.
intersectAAMDNodes681 AAMDNodes intersect(const AAMDNodes &Other) {
682 AAMDNodes Result;
683 Result.TBAA = Other.TBAA == TBAA ? TBAA : nullptr;
684 Result.TBAAStruct = Other.TBAAStruct == TBAAStruct ? TBAAStruct : nullptr;
685 Result.Scope = Other.Scope == Scope ? Scope : nullptr;
686 Result.NoAlias = Other.NoAlias == NoAlias ? NoAlias : nullptr;
687 return Result;
688 }
689
690 /// Create a new AAMDNode that describes this AAMDNode after applying a
691 /// constant offset to the start of the pointer
shiftAAMDNodes692 AAMDNodes shift(size_t Offset) {
693 AAMDNodes Result;
694 Result.TBAA = TBAA ? ShiftTBAA(TBAA, Offset) : nullptr;
695 Result.TBAAStruct =
696 TBAAStruct ? ShiftTBAAStruct(TBAAStruct, Offset) : nullptr;
697 Result.Scope = Scope;
698 Result.NoAlias = NoAlias;
699 return Result;
700 }
701 };
702
703 // Specialize DenseMapInfo for AAMDNodes.
704 template<>
705 struct DenseMapInfo<AAMDNodes> {
706 static inline AAMDNodes getEmptyKey() {
707 return AAMDNodes(DenseMapInfo<MDNode *>::getEmptyKey(),
708 nullptr, nullptr, nullptr);
709 }
710
711 static inline AAMDNodes getTombstoneKey() {
712 return AAMDNodes(DenseMapInfo<MDNode *>::getTombstoneKey(),
713 nullptr, nullptr, nullptr);
714 }
715
716 static unsigned getHashValue(const AAMDNodes &Val) {
717 return DenseMapInfo<MDNode *>::getHashValue(Val.TBAA) ^
718 DenseMapInfo<MDNode *>::getHashValue(Val.TBAAStruct) ^
719 DenseMapInfo<MDNode *>::getHashValue(Val.Scope) ^
720 DenseMapInfo<MDNode *>::getHashValue(Val.NoAlias);
721 }
722
723 static bool isEqual(const AAMDNodes &LHS, const AAMDNodes &RHS) {
724 return LHS == RHS;
725 }
726 };
727
728 /// Tracking metadata reference owned by Metadata.
729 ///
730 /// Similar to \a TrackingMDRef, but it's expected to be owned by an instance
731 /// of \a Metadata, which has the option of registering itself for callbacks to
732 /// re-unique itself.
733 ///
734 /// In particular, this is used by \a MDNode.
735 class MDOperand {
736 Metadata *MD = nullptr;
737
738 public:
739 MDOperand() = default;
740 MDOperand(MDOperand &&) = delete;
741 MDOperand(const MDOperand &) = delete;
742 MDOperand &operator=(MDOperand &&) = delete;
743 MDOperand &operator=(const MDOperand &) = delete;
744 ~MDOperand() { untrack(); }
745
746 Metadata *get() const { return MD; }
747 operator Metadata *() const { return get(); }
748 Metadata *operator->() const { return get(); }
749 Metadata &operator*() const { return *get(); }
750
751 void reset() {
752 untrack();
753 MD = nullptr;
754 }
755 void reset(Metadata *MD, Metadata *Owner) {
756 untrack();
757 this->MD = MD;
758 track(Owner);
759 }
760
761 private:
762 void track(Metadata *Owner) {
763 if (MD) {
764 if (Owner)
765 MetadataTracking::track(this, *MD, *Owner);
766 else
767 MetadataTracking::track(MD);
768 }
769 }
770
771 void untrack() {
772 assert(static_cast<void *>(this) == &MD && "Expected same address");
773 if (MD)
774 MetadataTracking::untrack(MD);
775 }
776 };
777
778 template <> struct simplify_type<MDOperand> {
779 using SimpleType = Metadata *;
780
781 static SimpleType getSimplifiedValue(MDOperand &MD) { return MD.get(); }
782 };
783
784 template <> struct simplify_type<const MDOperand> {
785 using SimpleType = Metadata *;
786
787 static SimpleType getSimplifiedValue(const MDOperand &MD) { return MD.get(); }
788 };
789
790 /// Pointer to the context, with optional RAUW support.
791 ///
792 /// Either a raw (non-null) pointer to the \a LLVMContext, or an owned pointer
793 /// to \a ReplaceableMetadataImpl (which has a reference to \a LLVMContext).
794 class ContextAndReplaceableUses {
795 PointerUnion<LLVMContext *, ReplaceableMetadataImpl *> Ptr;
796
797 public:
798 ContextAndReplaceableUses(LLVMContext &Context) : Ptr(&Context) {}
799 ContextAndReplaceableUses(
800 std::unique_ptr<ReplaceableMetadataImpl> ReplaceableUses)
801 : Ptr(ReplaceableUses.release()) {
802 assert(getReplaceableUses() && "Expected non-null replaceable uses");
803 }
804 ContextAndReplaceableUses() = delete;
805 ContextAndReplaceableUses(ContextAndReplaceableUses &&) = delete;
806 ContextAndReplaceableUses(const ContextAndReplaceableUses &) = delete;
807 ContextAndReplaceableUses &operator=(ContextAndReplaceableUses &&) = delete;
808 ContextAndReplaceableUses &
809 operator=(const ContextAndReplaceableUses &) = delete;
810 ~ContextAndReplaceableUses() { delete getReplaceableUses(); }
811
812 operator LLVMContext &() { return getContext(); }
813
814 /// Whether this contains RAUW support.
815 bool hasReplaceableUses() const {
816 return Ptr.is<ReplaceableMetadataImpl *>();
817 }
818
819 LLVMContext &getContext() const {
820 if (hasReplaceableUses())
821 return getReplaceableUses()->getContext();
822 return *Ptr.get<LLVMContext *>();
823 }
824
825 ReplaceableMetadataImpl *getReplaceableUses() const {
826 if (hasReplaceableUses())
827 return Ptr.get<ReplaceableMetadataImpl *>();
828 return nullptr;
829 }
830
831 /// Ensure that this has RAUW support, and then return it.
832 ReplaceableMetadataImpl *getOrCreateReplaceableUses() {
833 if (!hasReplaceableUses())
834 makeReplaceable(std::make_unique<ReplaceableMetadataImpl>(getContext()));
835 return getReplaceableUses();
836 }
837
838 /// Assign RAUW support to this.
839 ///
840 /// Make this replaceable, taking ownership of \c ReplaceableUses (which must
841 /// not be null).
842 void
843 makeReplaceable(std::unique_ptr<ReplaceableMetadataImpl> ReplaceableUses) {
844 assert(ReplaceableUses && "Expected non-null replaceable uses");
845 assert(&ReplaceableUses->getContext() == &getContext() &&
846 "Expected same context");
847 delete getReplaceableUses();
848 Ptr = ReplaceableUses.release();
849 }
850
851 /// Drop RAUW support.
852 ///
853 /// Cede ownership of RAUW support, returning it.
854 std::unique_ptr<ReplaceableMetadataImpl> takeReplaceableUses() {
855 assert(hasReplaceableUses() && "Expected to own replaceable uses");
856 std::unique_ptr<ReplaceableMetadataImpl> ReplaceableUses(
857 getReplaceableUses());
858 Ptr = &ReplaceableUses->getContext();
859 return ReplaceableUses;
860 }
861 };
862
863 struct TempMDNodeDeleter {
864 inline void operator()(MDNode *Node) const;
865 };
866
867 #define HANDLE_MDNODE_LEAF(CLASS) \
868 using Temp##CLASS = std::unique_ptr<CLASS, TempMDNodeDeleter>;
869 #define HANDLE_MDNODE_BRANCH(CLASS) HANDLE_MDNODE_LEAF(CLASS)
870 #include "llvm/IR/Metadata.def"
871
872 /// Metadata node.
873 ///
874 /// Metadata nodes can be uniqued, like constants, or distinct. Temporary
875 /// metadata nodes (with full support for RAUW) can be used to delay uniquing
876 /// until forward references are known. The basic metadata node is an \a
877 /// MDTuple.
878 ///
879 /// There is limited support for RAUW at construction time. At construction
880 /// time, if any operand is a temporary node (or an unresolved uniqued node,
881 /// which indicates a transitive temporary operand), the node itself will be
882 /// unresolved. As soon as all operands become resolved, it will drop RAUW
883 /// support permanently.
884 ///
885 /// If an unresolved node is part of a cycle, \a resolveCycles() needs
886 /// to be called on some member of the cycle once all temporary nodes have been
887 /// replaced.
888 class MDNode : public Metadata {
889 friend class ReplaceableMetadataImpl;
890 friend class LLVMContextImpl;
891
892 unsigned NumOperands;
893 unsigned NumUnresolved;
894
895 ContextAndReplaceableUses Context;
896
897 protected:
898 MDNode(LLVMContext &Context, unsigned ID, StorageType Storage,
899 ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None);
900 ~MDNode() = default;
901
902 void *operator new(size_t Size, unsigned NumOps);
903 void operator delete(void *Mem);
904
905 /// Required by std, but never called.
906 void operator delete(void *, unsigned) {
907 llvm_unreachable("Constructor throws?");
908 }
909
910 /// Required by std, but never called.
911 void operator delete(void *, unsigned, bool) {
912 llvm_unreachable("Constructor throws?");
913 }
914
915 void dropAllReferences();
916
917 MDOperand *mutable_begin() { return mutable_end() - NumOperands; }
918 MDOperand *mutable_end() { return reinterpret_cast<MDOperand *>(this); }
919
920 using mutable_op_range = iterator_range<MDOperand *>;
921
922 mutable_op_range mutable_operands() {
923 return mutable_op_range(mutable_begin(), mutable_end());
924 }
925
926 public:
927 MDNode(const MDNode &) = delete;
928 void operator=(const MDNode &) = delete;
929 void *operator new(size_t) = delete;
930
931 static inline MDTuple *get(LLVMContext &Context, ArrayRef<Metadata *> MDs);
932 static inline MDTuple *getIfExists(LLVMContext &Context,
933 ArrayRef<Metadata *> MDs);
934 static inline MDTuple *getDistinct(LLVMContext &Context,
935 ArrayRef<Metadata *> MDs);
936 static inline TempMDTuple getTemporary(LLVMContext &Context,
937 ArrayRef<Metadata *> MDs);
938
939 /// Create a (temporary) clone of this.
940 TempMDNode clone() const;
941
942 /// Deallocate a node created by getTemporary.
943 ///
944 /// Calls \c replaceAllUsesWith(nullptr) before deleting, so any remaining
945 /// references will be reset.
946 static void deleteTemporary(MDNode *N);
947
948 LLVMContext &getContext() const { return Context.getContext(); }
949
950 /// Replace a specific operand.
951 void replaceOperandWith(unsigned I, Metadata *New);
952
953 /// Check if node is fully resolved.
954 ///
955 /// If \a isTemporary(), this always returns \c false; if \a isDistinct(),
956 /// this always returns \c true.
957 ///
958 /// If \a isUniqued(), returns \c true if this has already dropped RAUW
959 /// support (because all operands are resolved).
960 ///
961 /// As forward declarations are resolved, their containers should get
962 /// resolved automatically. However, if this (or one of its operands) is
963 /// involved in a cycle, \a resolveCycles() needs to be called explicitly.
964 bool isResolved() const { return !isTemporary() && !NumUnresolved; }
965
966 bool isUniqued() const { return Storage == Uniqued; }
967 bool isDistinct() const { return Storage == Distinct; }
968 bool isTemporary() const { return Storage == Temporary; }
969
970 /// RAUW a temporary.
971 ///
972 /// \pre \a isTemporary() must be \c true.
973 void replaceAllUsesWith(Metadata *MD) {
974 assert(isTemporary() && "Expected temporary node");
975 if (Context.hasReplaceableUses())
976 Context.getReplaceableUses()->replaceAllUsesWith(MD);
977 }
978
979 /// Resolve cycles.
980 ///
981 /// Once all forward declarations have been resolved, force cycles to be
982 /// resolved.
983 ///
984 /// \pre No operands (or operands' operands, etc.) have \a isTemporary().
985 void resolveCycles();
986
987 /// Resolve a unique, unresolved node.
988 void resolve();
989
990 /// Replace a temporary node with a permanent one.
991 ///
992 /// Try to create a uniqued version of \c N -- in place, if possible -- and
993 /// return it. If \c N cannot be uniqued, return a distinct node instead.
994 template <class T>
995 static std::enable_if_t<std::is_base_of<MDNode, T>::value, T *>
996 replaceWithPermanent(std::unique_ptr<T, TempMDNodeDeleter> N) {
997 return cast<T>(N.release()->replaceWithPermanentImpl());
998 }
999
1000 /// Replace a temporary node with a uniqued one.
1001 ///
1002 /// Create a uniqued version of \c N -- in place, if possible -- and return
1003 /// it. Takes ownership of the temporary node.
1004 ///
1005 /// \pre N does not self-reference.
1006 template <class T>
1007 static std::enable_if_t<std::is_base_of<MDNode, T>::value, T *>
1008 replaceWithUniqued(std::unique_ptr<T, TempMDNodeDeleter> N) {
1009 return cast<T>(N.release()->replaceWithUniquedImpl());
1010 }
1011
1012 /// Replace a temporary node with a distinct one.
1013 ///
1014 /// Create a distinct version of \c N -- in place, if possible -- and return
1015 /// it. Takes ownership of the temporary node.
1016 template <class T>
1017 static std::enable_if_t<std::is_base_of<MDNode, T>::value, T *>
1018 replaceWithDistinct(std::unique_ptr<T, TempMDNodeDeleter> N) {
1019 return cast<T>(N.release()->replaceWithDistinctImpl());
1020 }
1021
1022 private:
1023 MDNode *replaceWithPermanentImpl();
1024 MDNode *replaceWithUniquedImpl();
1025 MDNode *replaceWithDistinctImpl();
1026
1027 protected:
1028 /// Set an operand.
1029 ///
1030 /// Sets the operand directly, without worrying about uniquing.
1031 void setOperand(unsigned I, Metadata *New);
1032
1033 void storeDistinctInContext();
1034 template <class T, class StoreT>
1035 static T *storeImpl(T *N, StorageType Storage, StoreT &Store);
1036 template <class T> static T *storeImpl(T *N, StorageType Storage);
1037
1038 private:
1039 void handleChangedOperand(void *Ref, Metadata *New);
1040
1041 /// Drop RAUW support, if any.
1042 void dropReplaceableUses();
1043
1044 void resolveAfterOperandChange(Metadata *Old, Metadata *New);
1045 void decrementUnresolvedOperandCount();
1046 void countUnresolvedOperands();
1047
1048 /// Mutate this to be "uniqued".
1049 ///
1050 /// Mutate this so that \a isUniqued().
1051 /// \pre \a isTemporary().
1052 /// \pre already added to uniquing set.
1053 void makeUniqued();
1054
1055 /// Mutate this to be "distinct".
1056 ///
1057 /// Mutate this so that \a isDistinct().
1058 /// \pre \a isTemporary().
1059 void makeDistinct();
1060
1061 void deleteAsSubclass();
1062 MDNode *uniquify();
1063 void eraseFromStore();
1064
1065 template <class NodeTy> struct HasCachedHash;
1066 template <class NodeTy>
1067 static void dispatchRecalculateHash(NodeTy *N, std::true_type) {
1068 N->recalculateHash();
1069 }
1070 template <class NodeTy>
1071 static void dispatchRecalculateHash(NodeTy *, std::false_type) {}
1072 template <class NodeTy>
1073 static void dispatchResetHash(NodeTy *N, std::true_type) {
1074 N->setHash(0);
1075 }
1076 template <class NodeTy>
1077 static void dispatchResetHash(NodeTy *, std::false_type) {}
1078
1079 public:
1080 using op_iterator = const MDOperand *;
1081 using op_range = iterator_range<op_iterator>;
1082
1083 op_iterator op_begin() const {
1084 return const_cast<MDNode *>(this)->mutable_begin();
1085 }
1086
1087 op_iterator op_end() const {
1088 return const_cast<MDNode *>(this)->mutable_end();
1089 }
1090
1091 op_range operands() const { return op_range(op_begin(), op_end()); }
1092
1093 const MDOperand &getOperand(unsigned I) const {
1094 assert(I < NumOperands && "Out of range");
1095 return op_begin()[I];
1096 }
1097
1098 /// Return number of MDNode operands.
1099 unsigned getNumOperands() const { return NumOperands; }
1100
1101 /// Methods for support type inquiry through isa, cast, and dyn_cast:
1102 static bool classof(const Metadata *MD) {
1103 switch (MD->getMetadataID()) {
1104 default:
1105 return false;
1106 #define HANDLE_MDNODE_LEAF(CLASS) \
1107 case CLASS##Kind: \
1108 return true;
1109 #include "llvm/IR/Metadata.def"
1110 }
1111 }
1112
1113 /// Check whether MDNode is a vtable access.
1114 bool isTBAAVtableAccess() const;
1115
1116 /// Methods for metadata merging.
1117 static MDNode *concatenate(MDNode *A, MDNode *B);
1118 static MDNode *intersect(MDNode *A, MDNode *B);
1119 static MDNode *getMostGenericTBAA(MDNode *A, MDNode *B);
1120 static MDNode *getMostGenericFPMath(MDNode *A, MDNode *B);
1121 static MDNode *getMostGenericRange(MDNode *A, MDNode *B);
1122 static MDNode *getMostGenericAliasScope(MDNode *A, MDNode *B);
1123 static MDNode *getMostGenericAlignmentOrDereferenceable(MDNode *A, MDNode *B);
1124 };
1125
1126 /// Tuple of metadata.
1127 ///
1128 /// This is the simple \a MDNode arbitrary tuple. Nodes are uniqued by
1129 /// default based on their operands.
1130 class MDTuple : public MDNode {
1131 friend class LLVMContextImpl;
1132 friend class MDNode;
1133
1134 MDTuple(LLVMContext &C, StorageType Storage, unsigned Hash,
1135 ArrayRef<Metadata *> Vals)
1136 : MDNode(C, MDTupleKind, Storage, Vals) {
1137 setHash(Hash);
1138 }
1139
1140 ~MDTuple() { dropAllReferences(); }
1141
1142 void setHash(unsigned Hash) { SubclassData32 = Hash; }
1143 void recalculateHash();
1144
1145 static MDTuple *getImpl(LLVMContext &Context, ArrayRef<Metadata *> MDs,
1146 StorageType Storage, bool ShouldCreate = true);
1147
1148 TempMDTuple cloneImpl() const {
1149 return getTemporary(getContext(), SmallVector<Metadata *, 4>(operands()));
1150 }
1151
1152 public:
1153 /// Get the hash, if any.
1154 unsigned getHash() const { return SubclassData32; }
1155
1156 static MDTuple *get(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1157 return getImpl(Context, MDs, Uniqued);
1158 }
1159
1160 static MDTuple *getIfExists(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1161 return getImpl(Context, MDs, Uniqued, /* ShouldCreate */ false);
1162 }
1163
1164 /// Return a distinct node.
1165 ///
1166 /// Return a distinct node -- i.e., a node that is not uniqued.
1167 static MDTuple *getDistinct(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1168 return getImpl(Context, MDs, Distinct);
1169 }
1170
1171 /// Return a temporary node.
1172 ///
1173 /// For use in constructing cyclic MDNode structures. A temporary MDNode is
1174 /// not uniqued, may be RAUW'd, and must be manually deleted with
1175 /// deleteTemporary.
1176 static TempMDTuple getTemporary(LLVMContext &Context,
1177 ArrayRef<Metadata *> MDs) {
1178 return TempMDTuple(getImpl(Context, MDs, Temporary));
1179 }
1180
1181 /// Return a (temporary) clone of this.
1182 TempMDTuple clone() const { return cloneImpl(); }
1183
1184 static bool classof(const Metadata *MD) {
1185 return MD->getMetadataID() == MDTupleKind;
1186 }
1187 };
1188
1189 MDTuple *MDNode::get(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1190 return MDTuple::get(Context, MDs);
1191 }
1192
1193 MDTuple *MDNode::getIfExists(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1194 return MDTuple::getIfExists(Context, MDs);
1195 }
1196
1197 MDTuple *MDNode::getDistinct(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1198 return MDTuple::getDistinct(Context, MDs);
1199 }
1200
1201 TempMDTuple MDNode::getTemporary(LLVMContext &Context,
1202 ArrayRef<Metadata *> MDs) {
1203 return MDTuple::getTemporary(Context, MDs);
1204 }
1205
1206 void TempMDNodeDeleter::operator()(MDNode *Node) const {
1207 MDNode::deleteTemporary(Node);
1208 }
1209
1210 /// This is a simple wrapper around an MDNode which provides a higher-level
1211 /// interface by hiding the details of how alias analysis information is encoded
1212 /// in its operands.
1213 class AliasScopeNode {
1214 const MDNode *Node = nullptr;
1215
1216 public:
1217 AliasScopeNode() = default;
1218 explicit AliasScopeNode(const MDNode *N) : Node(N) {}
1219
1220 /// Get the MDNode for this AliasScopeNode.
1221 const MDNode *getNode() const { return Node; }
1222
1223 /// Get the MDNode for this AliasScopeNode's domain.
1224 const MDNode *getDomain() const {
1225 if (Node->getNumOperands() < 2)
1226 return nullptr;
1227 return dyn_cast_or_null<MDNode>(Node->getOperand(1));
1228 }
1229 StringRef getName() const {
1230 if (Node->getNumOperands() > 2)
1231 if (MDString *N = dyn_cast_or_null<MDString>(Node->getOperand(2)))
1232 return N->getString();
1233 return StringRef();
1234 }
1235 };
1236
1237 /// Typed iterator through MDNode operands.
1238 ///
1239 /// An iterator that transforms an \a MDNode::iterator into an iterator over a
1240 /// particular Metadata subclass.
1241 template <class T>
1242 class TypedMDOperandIterator
1243 : public std::iterator<std::input_iterator_tag, T *, std::ptrdiff_t, void,
1244 T *> {
1245 MDNode::op_iterator I = nullptr;
1246
1247 public:
1248 TypedMDOperandIterator() = default;
1249 explicit TypedMDOperandIterator(MDNode::op_iterator I) : I(I) {}
1250
1251 T *operator*() const { return cast_or_null<T>(*I); }
1252
1253 TypedMDOperandIterator &operator++() {
1254 ++I;
1255 return *this;
1256 }
1257
1258 TypedMDOperandIterator operator++(int) {
1259 TypedMDOperandIterator Temp(*this);
1260 ++I;
1261 return Temp;
1262 }
1263
1264 bool operator==(const TypedMDOperandIterator &X) const { return I == X.I; }
1265 bool operator!=(const TypedMDOperandIterator &X) const { return I != X.I; }
1266 };
1267
1268 /// Typed, array-like tuple of metadata.
1269 ///
1270 /// This is a wrapper for \a MDTuple that makes it act like an array holding a
1271 /// particular type of metadata.
1272 template <class T> class MDTupleTypedArrayWrapper {
1273 const MDTuple *N = nullptr;
1274
1275 public:
1276 MDTupleTypedArrayWrapper() = default;
1277 MDTupleTypedArrayWrapper(const MDTuple *N) : N(N) {}
1278
1279 template <class U>
1280 MDTupleTypedArrayWrapper(
1281 const MDTupleTypedArrayWrapper<U> &Other,
1282 std::enable_if_t<std::is_convertible<U *, T *>::value> * = nullptr)
1283 : N(Other.get()) {}
1284
1285 template <class U>
1286 explicit MDTupleTypedArrayWrapper(
1287 const MDTupleTypedArrayWrapper<U> &Other,
1288 std::enable_if_t<!std::is_convertible<U *, T *>::value> * = nullptr)
1289 : N(Other.get()) {}
1290
1291 explicit operator bool() const { return get(); }
1292 explicit operator MDTuple *() const { return get(); }
1293
1294 MDTuple *get() const { return const_cast<MDTuple *>(N); }
1295 MDTuple *operator->() const { return get(); }
1296 MDTuple &operator*() const { return *get(); }
1297
1298 // FIXME: Fix callers and remove condition on N.
1299 unsigned size() const { return N ? N->getNumOperands() : 0u; }
1300 bool empty() const { return N ? N->getNumOperands() == 0 : true; }
1301 T *operator[](unsigned I) const { return cast_or_null<T>(N->getOperand(I)); }
1302
1303 // FIXME: Fix callers and remove condition on N.
1304 using iterator = TypedMDOperandIterator<T>;
1305
1306 iterator begin() const { return N ? iterator(N->op_begin()) : iterator(); }
1307 iterator end() const { return N ? iterator(N->op_end()) : iterator(); }
1308 };
1309
1310 #define HANDLE_METADATA(CLASS) \
1311 using CLASS##Array = MDTupleTypedArrayWrapper<CLASS>;
1312 #include "llvm/IR/Metadata.def"
1313
1314 /// Placeholder metadata for operands of distinct MDNodes.
1315 ///
1316 /// This is a lightweight placeholder for an operand of a distinct node. It's
1317 /// purpose is to help track forward references when creating a distinct node.
1318 /// This allows distinct nodes involved in a cycle to be constructed before
1319 /// their operands without requiring a heavyweight temporary node with
1320 /// full-blown RAUW support.
1321 ///
1322 /// Each placeholder supports only a single MDNode user. Clients should pass
1323 /// an ID, retrieved via \a getID(), to indicate the "real" operand that this
1324 /// should be replaced with.
1325 ///
1326 /// While it would be possible to implement move operators, they would be
1327 /// fairly expensive. Leave them unimplemented to discourage their use
1328 /// (clients can use std::deque, std::list, BumpPtrAllocator, etc.).
1329 class DistinctMDOperandPlaceholder : public Metadata {
1330 friend class MetadataTracking;
1331
1332 Metadata **Use = nullptr;
1333
1334 public:
1335 explicit DistinctMDOperandPlaceholder(unsigned ID)
1336 : Metadata(DistinctMDOperandPlaceholderKind, Distinct) {
1337 SubclassData32 = ID;
1338 }
1339
1340 DistinctMDOperandPlaceholder() = delete;
1341 DistinctMDOperandPlaceholder(DistinctMDOperandPlaceholder &&) = delete;
1342 DistinctMDOperandPlaceholder(const DistinctMDOperandPlaceholder &) = delete;
1343
1344 ~DistinctMDOperandPlaceholder() {
1345 if (Use)
1346 *Use = nullptr;
1347 }
1348
1349 unsigned getID() const { return SubclassData32; }
1350
1351 /// Replace the use of this with MD.
1352 void replaceUseWith(Metadata *MD) {
1353 if (!Use)
1354 return;
1355 *Use = MD;
1356
1357 if (*Use)
1358 MetadataTracking::track(*Use);
1359
1360 Metadata *T = cast<Metadata>(this);
1361 MetadataTracking::untrack(T);
1362 assert(!Use && "Use is still being tracked despite being untracked!");
1363 }
1364 };
1365
1366 //===----------------------------------------------------------------------===//
1367 /// A tuple of MDNodes.
1368 ///
1369 /// Despite its name, a NamedMDNode isn't itself an MDNode.
1370 ///
1371 /// NamedMDNodes are named module-level entities that contain lists of MDNodes.
1372 ///
1373 /// It is illegal for a NamedMDNode to appear as an operand of an MDNode.
1374 class NamedMDNode : public ilist_node<NamedMDNode> {
1375 friend class LLVMContextImpl;
1376 friend class Module;
1377
1378 std::string Name;
1379 Module *Parent = nullptr;
1380 void *Operands; // SmallVector<TrackingMDRef, 4>
1381
1382 void setParent(Module *M) { Parent = M; }
1383
1384 explicit NamedMDNode(const Twine &N);
1385
1386 template<class T1, class T2>
1387 class op_iterator_impl :
1388 public std::iterator<std::bidirectional_iterator_tag, T2> {
1389 friend class NamedMDNode;
1390
1391 const NamedMDNode *Node = nullptr;
1392 unsigned Idx = 0;
1393
1394 op_iterator_impl(const NamedMDNode *N, unsigned i) : Node(N), Idx(i) {}
1395
1396 public:
1397 op_iterator_impl() = default;
1398
1399 bool operator==(const op_iterator_impl &o) const { return Idx == o.Idx; }
1400 bool operator!=(const op_iterator_impl &o) const { return Idx != o.Idx; }
1401
1402 op_iterator_impl &operator++() {
1403 ++Idx;
1404 return *this;
1405 }
1406
1407 op_iterator_impl operator++(int) {
1408 op_iterator_impl tmp(*this);
1409 operator++();
1410 return tmp;
1411 }
1412
1413 op_iterator_impl &operator--() {
1414 --Idx;
1415 return *this;
1416 }
1417
1418 op_iterator_impl operator--(int) {
1419 op_iterator_impl tmp(*this);
1420 operator--();
1421 return tmp;
1422 }
1423
1424 T1 operator*() const { return Node->getOperand(Idx); }
1425 };
1426
1427 public:
1428 NamedMDNode(const NamedMDNode &) = delete;
1429 ~NamedMDNode();
1430
1431 /// Drop all references and remove the node from parent module.
1432 void eraseFromParent();
1433
1434 /// Remove all uses and clear node vector.
1435 void dropAllReferences() { clearOperands(); }
1436 /// Drop all references to this node's operands.
1437 void clearOperands();
1438
1439 /// Get the module that holds this named metadata collection.
1440 inline Module *getParent() { return Parent; }
1441 inline const Module *getParent() const { return Parent; }
1442
1443 MDNode *getOperand(unsigned i) const;
1444 unsigned getNumOperands() const;
1445 void addOperand(MDNode *M);
1446 void setOperand(unsigned I, MDNode *New);
1447 StringRef getName() const;
1448 void print(raw_ostream &ROS, bool IsForDebug = false) const;
1449 void print(raw_ostream &ROS, ModuleSlotTracker &MST,
1450 bool IsForDebug = false) const;
1451 void dump() const;
1452
1453 // ---------------------------------------------------------------------------
1454 // Operand Iterator interface...
1455 //
1456 using op_iterator = op_iterator_impl<MDNode *, MDNode>;
1457
1458 op_iterator op_begin() { return op_iterator(this, 0); }
1459 op_iterator op_end() { return op_iterator(this, getNumOperands()); }
1460
1461 using const_op_iterator = op_iterator_impl<const MDNode *, MDNode>;
1462
1463 const_op_iterator op_begin() const { return const_op_iterator(this, 0); }
1464 const_op_iterator op_end() const { return const_op_iterator(this, getNumOperands()); }
1465
1466 inline iterator_range<op_iterator> operands() {
1467 return make_range(op_begin(), op_end());
1468 }
1469 inline iterator_range<const_op_iterator> operands() const {
1470 return make_range(op_begin(), op_end());
1471 }
1472 };
1473
1474 // Create wrappers for C Binding types (see CBindingWrapping.h).
1475 DEFINE_ISA_CONVERSION_FUNCTIONS(NamedMDNode, LLVMNamedMDNodeRef)
1476
1477 } // end namespace llvm
1478
1479 #endif // LLVM_IR_METADATA_H
1480