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