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