Line data Source code
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 :
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:
84 : Metadata(unsigned ID, StorageType Storage)
85 2284143 : : 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 0 : void handleChangedOperand(void *, Metadata *) {
96 0 : llvm_unreachable("Unimplemented in Metadata subclass");
97 : }
98 :
99 : public:
100 18501495 : 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).
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 4 : 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).
183 12081 : 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 :
191 0 : Metadata *getMetadata() const { return MD; }
192 :
193 : static bool classof(const Value *V) {
194 4747926 : 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.
221 : static bool track(Metadata *&MD) {
222 138998947 : 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 3427056 : 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 171608 : return track(Ref, MD, &Owner);
241 : }
242 :
243 : /// Stop tracking a reference to metadata.
244 : ///
245 : /// Stops \c *MD from tracking \c MD.
246 124254956 : 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 90595441 : 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:
291 542552 : ReplaceableMetadataImpl(LLVMContext &Context) : Context(Context) {}
292 :
293 1423 : ~ReplaceableMetadataImpl() {
294 : assert(UseMap.empty() && "Cannot destroy in-use replaceable metadata");
295 : }
296 :
297 0 : 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).
346 : void dropUsers() {
347 67285 : ReplaceableMetadataImpl::resolveAllUses(/* ResolveUsers */ false);
348 : }
349 :
350 : protected:
351 212729 : ValueAsMetadata(unsigned ID, Value *V)
352 212729 : : Metadata(ID, Uniqued), ReplaceableMetadataImpl(V->getContext()), V(V) {
353 : assert(V && "Expected valid value");
354 212729 : }
355 :
356 162764 : ~ValueAsMetadata() = default;
357 :
358 : public:
359 : static ValueAsMetadata *get(Value *V);
360 :
361 : static ConstantAsMetadata *getConstant(Value *C) {
362 156955 : return cast<ConstantAsMetadata>(get(C));
363 : }
364 :
365 : static LocalAsMetadata *getLocal(Value *Local) {
366 598 : 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 114407 : return cast_or_null<LocalAsMetadata>(getIfExists(Local));
377 : }
378 :
379 0 : Value *getValue() const { return V; }
380 82 : 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 :
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.
392 : void replaceAllUsesWith(Metadata *MD) {
393 162764 : ReplaceableMetadataImpl::replaceAllUsesWith(MD);
394 : }
395 :
396 : public:
397 : static bool classof(const Metadata *MD) {
398 4672039 : return MD->getMetadataID() == LocalAsMetadataKind ||
399 : MD->getMetadataID() == ConstantAsMetadataKind;
400 : }
401 : };
402 :
403 : class ConstantAsMetadata : public ValueAsMetadata {
404 : friend class ValueAsMetadata;
405 :
406 : ConstantAsMetadata(Constant *C)
407 89790 : : ValueAsMetadata(ConstantAsMetadataKind, C) {}
408 :
409 : public:
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 8638005 : return cast<Constant>(ValueAsMetadata::getValue());
420 : }
421 :
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 :
430 : LocalAsMetadata(Value *Local)
431 122939 : : ValueAsMetadata(LocalAsMetadataKind, Local) {
432 : assert(!isa<Constant>(Local) && "Expected local value");
433 : }
434 :
435 : public:
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 158429 : 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 typename std::enable_if<detail::IsValidPointer<X, Y>::value, bool>::type
531 0 : hasa(Y &&MD) {
532 : assert(MD && "Null pointer sent into hasa");
533 0 : 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
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.
547 : template <class X, class Y>
548 : inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
549 0 : extract(Y &&MD) {
550 0 : return cast<X>(cast<ConstantAsMetadata>(MD)->getValue());
551 : }
552 : template <class X, class Y>
553 : inline
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.
563 : template <class X, class Y>
564 : inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
565 0 : extract_or_null(Y &&MD) {
566 0 : if (auto *V = cast_or_null<ConstantAsMetadata>(MD))
567 0 : 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.
576 : template <class X, class Y>
577 : inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
578 0 : dyn_extract(Y &&MD) {
579 0 : if (auto *V = dyn_cast<ConstantAsMetadata>(MD))
580 : return dyn_cast<X>(V->getValue());
581 : return nullptr;
582 : }
583 0 :
584 0 : /// 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 0 : /// Value it does contain is of the wrong subclass, allowing \c MD to be null.
589 0 : template <class X, class Y>
590 : inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
591 0 : dyn_extract_or_null(Y &&MD) {
592 0 : 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.
604 : class MDString : public Metadata {
605 : friend class StringMapEntry<MDString>;
606 :
607 : StringMapEntry<MDString> *Entry = nullptr;
608 :
609 250282 : MDString() : Metadata(MDStringKind, Uniqued) {}
610 :
611 : public:
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 11820 : static MDString *get(LLVMContext &Context, const char *Str) {
618 11820 : return get(Context, Str ? StringRef(Str) : StringRef());
619 : }
620 :
621 : StringRef getString() const;
622 :
623 8110 : 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.
644 : struct AAMDNodes {
645 : explicit AAMDNodes(MDNode *T = nullptr, MDNode *S = nullptr,
646 : MDNode *N = nullptr)
647 61973294 : : TBAA(T), Scope(S), NoAlias(N) {}
648 :
649 : bool operator==(const AAMDNodes &A) const {
650 201023371 : return TBAA == A.TBAA && Scope == A.Scope && NoAlias == A.NoAlias;
651 : }
652 :
653 : bool operator!=(const AAMDNodes &A) const { return !(*this == A); }
654 :
655 964095 : 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 670845 : Result.TBAA = Other.TBAA == TBAA ? TBAA : nullptr;
674 670845 : Result.Scope = Other.Scope == Scope ? Scope : nullptr;
675 670845 : Result.NoAlias = Other.NoAlias == NoAlias ? NoAlias : nullptr;
676 : return Result;
677 : }
678 : };
679 :
680 : // Specialize DenseMapInfo for AAMDNodes.
681 : template<>
682 : struct 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 310175412 : return DenseMapInfo<MDNode *>::getHashValue(Val.TBAA) ^
695 155087706 : DenseMapInfo<MDNode *>::getHashValue(Val.Scope) ^
696 310175412 : 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.
711 : class MDOperand {
712 : Metadata *MD = nullptr;
713 :
714 : public:
715 4900706 : MDOperand() = default;
716 : MDOperand(MDOperand &&) = delete;
717 : MDOperand(const MDOperand &) = delete;
718 : MDOperand &operator=(MDOperand &&) = delete;
719 : MDOperand &operator=(const MDOperand &) = delete;
720 730324 : ~MDOperand() { untrack(); }
721 :
722 0 : Metadata *get() const { return MD; }
723 41935003 : operator Metadata *() const { return get(); }
724 : Metadata *operator->() const { return get(); }
725 4 : Metadata &operator*() const { return *get(); }
726 :
727 : void reset() {
728 : untrack();
729 : MD = nullptr;
730 : }
731 6046278 : void reset(Metadata *MD, Metadata *Owner) {
732 0 : untrack();
733 6093070 : this->MD = MD;
734 6046278 : track(Owner);
735 6046276 : }
736 :
737 : private:
738 6046275 : void track(Metadata *Owner) {
739 6046275 : if (MD) {
740 4350412 : if (Owner)
741 : MetadataTracking::track(this, *MD, *Owner);
742 : else
743 923356 : MetadataTracking::track(MD);
744 : }
745 6046275 : }
746 :
747 : void untrack() {
748 : assert(static_cast<void *>(this) == &MD && "Expected same address");
749 6776601 : if (MD)
750 667984 : MetadataTracking::untrack(MD);
751 : }
752 : };
753 :
754 : template <> struct simplify_type<MDOperand> {
755 : using SimpleType = Metadata *;
756 :
757 : static SimpleType getSimplifiedValue(MDOperand &MD) { return MD.get(); }
758 : };
759 :
760 : template <> struct simplify_type<const MDOperand> {
761 : using SimpleType = Metadata *;
762 :
763 4332397 : 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).
770 : class ContextAndReplaceableUses {
771 : PointerUnion<LLVMContext *, ReplaceableMetadataImpl *> Ptr;
772 :
773 : public:
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 382511 : ~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 4537114 : if (hasReplaceableUses())
797 114568 : return getReplaceableUses()->getContext();
798 : return *Ptr.get<LLVMContext *>();
799 : }
800 :
801 : ReplaceableMetadataImpl *getReplaceableUses() const {
802 1757526 : if (hasReplaceableUses())
803 : return Ptr.get<ReplaceableMetadataImpl *>();
804 : return nullptr;
805 : }
806 :
807 : /// Ensure that this has RAUW support, and then return it.
808 630798 : ReplaceableMetadataImpl *getOrCreateReplaceableUses() {
809 630798 : if (!hasReplaceableUses())
810 659640 : makeReplaceable(llvm::make_unique<ReplaceableMetadataImpl>(getContext()));
811 630798 : 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 329821 : makeReplaceable(std::unique_ptr<ReplaceableMetadataImpl> ReplaceableUses) {
820 : assert(ReplaceableUses && "Expected non-null replaceable uses");
821 : assert(&ReplaceableUses->getContext() == &getContext() &&
822 : "Expected same context");
823 0 : delete getReplaceableUses();
824 : Ptr = ReplaceableUses.release();
825 329821 : }
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 328398 : Ptr = &ReplaceableUses->getContext();
835 : return ReplaceableUses;
836 : }
837 : };
838 :
839 : struct 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.
864 : class MDNode : public Metadata {
865 : friend class ReplaceableMetadataImpl;
866 : friend class LLVMContextImpl;
867 :
868 : unsigned NumOperands;
869 : unsigned NumUnresolved;
870 :
871 : ContextAndReplaceableUses Context;
872 :
873 : protected:
874 : MDNode(LLVMContext &Context, unsigned ID, StorageType Storage,
875 : ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None);
876 381083 : ~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 51415707 : 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 :
902 : public:
903 1269761 : 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 372834403 : bool isResolved() const { return !isTemporary() && !NumUnresolved; }
941 :
942 8368941 : bool isUniqued() const { return Storage == Uniqued; }
943 146804 : bool isDistinct() const { return Storage == Distinct; }
944 373810457 : 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 314833 : if (Context.hasReplaceableUses())
952 286034 : 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 4 : 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 33057 : 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 6185 : return cast<T>(N.release()->replaceWithDistinctImpl());
996 : }
997 :
998 : private:
999 : MDNode *replaceWithPermanentImpl();
1000 : MDNode *replaceWithUniquedImpl();
1001 : MDNode *replaceWithDistinctImpl();
1002 :
1003 : protected:
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 :
1014 : private:
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 0 : static void dispatchRecalculateHash(NodeTy *N, std::true_type) {
1044 27098 : N->recalculateHash();
1045 0 : }
1046 0 : template <class NodeTy>
1047 0 : static void dispatchRecalculateHash(NodeTy *, std::false_type) {}
1048 0 : template <class NodeTy>
1049 0 : static void dispatchResetHash(NodeTy *N, std::true_type) {
1050 0 : N->setHash(0);
1051 0 : }
1052 : template <class NodeTy>
1053 0 : static void dispatchResetHash(NodeTy *, std::false_type) {}
1054 :
1055 0 : public:
1056 : using op_iterator = const MDOperand *;
1057 0 : using op_range = iterator_range<op_iterator>;
1058 0 :
1059 : op_iterator op_begin() const {
1060 0 : return const_cast<MDNode *>(this)->mutable_begin();
1061 0 : }
1062 :
1063 0 : op_iterator op_end() const {
1064 : return const_cast<MDNode *>(this)->mutable_end();
1065 0 : }
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 60309025 : return op_begin()[I];
1072 : }
1073 :
1074 : /// Return number of MDNode operands.
1075 0 : 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 6260305 : switch (MD->getMetadataID()) {
1080 : default:
1081 1215634 : return false;
1082 : #define HANDLE_MDNODE_LEAF(CLASS) \
1083 515345 : case CLASS##Kind: \
1084 : return true;
1085 0 : #include "llvm/IR/Metadata.def"
1086 : }
1087 0 : }
1088 :
1089 : /// Check whether MDNode is a vtable access.
1090 : bool isTBAAVtableAccess() const;
1091 375056300 :
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.
1106 : class 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 167036 : ~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 869064 : TempMDTuple cloneImpl() const {
1125 : return getTemporary(getContext(),
1126 : SmallVector<Metadata *, 4>(op_begin(), op_end()));
1127 : }
1128 367514 :
1129 : public:
1130 501628 : /// Get the hash, if any.
1131 : unsigned getHash() const { return SubclassData32; }
1132 :
1133 20256 : static MDTuple *get(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1134 770173 : return getImpl(Context, MDs, Uniqued);
1135 : }
1136 50 :
1137 : static MDTuple *getIfExists(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1138 101 : return getImpl(Context, MDs, Uniqued, /* ShouldCreate */ false);
1139 : }
1140 :
1141 : /// Return a distinct node.
1142 : ///
1143 0 : /// Return a distinct node -- i.e., a node that is not uniqued.
1144 638 : static MDTuple *getDistinct(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1145 2703 : return getImpl(Context, MDs, Distinct);
1146 182727 : }
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 164895 : 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 23 : return MD->getMetadataID() == MDTupleKind;
1163 : }
1164 : };
1165 :
1166 : MDTuple *MDNode::get(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1167 659728 : return MDTuple::get(Context, MDs);
1168 : }
1169 :
1170 : MDTuple *MDNode::getIfExists(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1171 1 : return MDTuple::getIfExists(Context, MDs);
1172 : }
1173 :
1174 : MDTuple *MDNode::getDistinct(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1175 2028 : return MDTuple::getDistinct(Context, MDs);
1176 : }
1177 :
1178 : TempMDTuple MDNode::getTemporary(LLVMContext &Context,
1179 182285 : ArrayRef<Metadata *> MDs) {
1180 45874 : return MDTuple::getTemporary(Context, MDs);
1181 : }
1182 :
1183 0 : void TempMDNodeDeleter::operator()(MDNode *Node) const {
1184 109285 : MDNode::deleteTemporary(Node);
1185 0 : }
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.
1191 : template <class T>
1192 : class TypedMDOperandIterator
1193 : : public std::iterator<std::input_iterator_tag, T *, std::ptrdiff_t, void,
1194 : T *> {
1195 0 : MDNode::op_iterator I = nullptr;
1196 0 :
1197 0 : public:
1198 : TypedMDOperandIterator() = default;
1199 0 : explicit TypedMDOperandIterator(MDNode::op_iterator I) : I(I) {}
1200 :
1201 0 : T *operator*() const { return cast_or_null<T>(*I); }
1202 :
1203 : TypedMDOperandIterator &operator++() {
1204 140310 : ++I;
1205 : return *this;
1206 : }
1207 :
1208 : TypedMDOperandIterator operator++(int) {
1209 0 : TypedMDOperandIterator Temp(*this);
1210 : ++I;
1211 0 : return Temp;
1212 : }
1213 :
1214 46792 : bool operator==(const TypedMDOperandIterator &X) const { return I == X.I; }
1215 0 : 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.
1222 : template <class T> class MDTupleTypedArrayWrapper {
1223 : const MDTuple *N = nullptr;
1224 :
1225 0 : public:
1226 : MDTupleTypedArrayWrapper() = default;
1227 107457 : 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 1225 : explicit MDTupleTypedArrayWrapper(
1238 : const MDTupleTypedArrayWrapper<U> &Other,
1239 : typename std::enable_if<!std::is_convertible<U *, T *>::value>::type * =
1240 94097 : nullptr)
1241 : : N(Other.get()) {}
1242 :
1243 : explicit operator bool() const { return get(); }
1244 94097 : explicit operator MDTuple *() const { return get(); }
1245 :
1246 0 : 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 63 : unsigned size() const { return N ? N->getNumOperands() : 0u; }
1252 5733 : bool empty() const { return N ? N->getNumOperands() == 0 : true; }
1253 86 : T *operator[](unsigned I) const { return cast_or_null<T>(N->getOperand(I)); }
1254 :
1255 : // FIXME: Fix callers and remove condition on N.
1256 0 : using iterator = TypedMDOperandIterator<T>;
1257 :
1258 79066 : iterator begin() const { return N ? iterator(N->op_begin()) : iterator(); }
1259 79066 : iterator end() const { return N ? iterator(N->op_end()) : iterator(); }
1260 : };
1261 820 :
1262 : #define HANDLE_METADATA(CLASS) \
1263 2374 : using CLASS##Array = MDTupleTypedArrayWrapper<CLASS>;
1264 : #include "llvm/IR/Metadata.def"
1265 :
1266 : /// Placeholder metadata for operands of distinct MDNodes.
1267 : ///
1268 101361 : /// This is a lightweight placeholder for an operand of a distinct node. It's
1269 101361 : /// 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.).
1281 : class DistinctMDOperandPlaceholder : public Metadata {
1282 : friend class MetadataTracking;
1283 :
1284 : Metadata **Use = nullptr;
1285 :
1286 : public:
1287 : explicit DistinctMDOperandPlaceholder(unsigned ID)
1288 6062 : : Metadata(DistinctMDOperandPlaceholderKind, Distinct) {
1289 3029 : SubclassData32 = ID;
1290 : }
1291 :
1292 : DistinctMDOperandPlaceholder() = delete;
1293 : DistinctMDOperandPlaceholder(DistinctMDOperandPlaceholder &&) = delete;
1294 : DistinctMDOperandPlaceholder(const DistinctMDOperandPlaceholder &) = delete;
1295 :
1296 3029 : ~DistinctMDOperandPlaceholder() {
1297 3029 : if (Use)
1298 0 : *Use = nullptr;
1299 : }
1300 :
1301 0 : unsigned getID() const { return SubclassData32; }
1302 :
1303 : /// Replace the use of this with MD.
1304 3031 : void replaceUseWith(Metadata *MD) {
1305 3031 : if (!Use)
1306 10 : return;
1307 3021 : *Use = MD;
1308 :
1309 3021 : if (*Use)
1310 : MetadataTracking::track(*Use);
1311 :
1312 3021 : 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.
1326 : class 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 42174 : 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 0 : bool operator!=(const op_iterator_impl &o) const { return Idx != o.Idx; }
1353 :
1354 : op_iterator_impl &operator++() {
1355 7802189 : ++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 7802462 : T1 operator*() const { return Node->getOperand(Idx); }
1377 : };
1378 :
1379 : public:
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 0 : inline Module *getParent() { return Parent; }
1393 0 : 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 29094 : 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 0 :
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 6546 : 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 2805474 : 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).
1427 : DEFINE_ISA_CONVERSION_FUNCTIONS(NamedMDNode, LLVMNamedMDNodeRef)
1428 :
1429 : } // end namespace llvm
1430 :
1431 : #endif // LLVM_IR_METADATA_H
|
