contrib/llvm/include/llvm/IR/Metadata.h

   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
  43 namespace llvm {
  44
  45 class Module;
  46 class ModuleSlotTracker;
  47
  48 enum 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.
  55 class Metadata {
  56   friend class ReplaceableMetadataImpl;
  57
  58   /// \brief RTTI.
  59   const unsigned char SubclassID;
  60
  61 protected:
  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
  72 public:
  73   enum MetadataKind {
  74 #define HANDLE_METADATA_LEAF(CLASS) CLASS##Kind,
  75 #include "llvm/IR/Metadata.def"
  76   };
  77
  78 protected:
  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
  94 public:
  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
 149 inline 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.
 161 class 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
 173 public:
 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
 182 private:
 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.
 195 class MetadataTracking {
 196 public:
 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
 252 private:
 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).
 264 class ReplaceableMetadataImpl {
 265   friend class MetadataTracking;
 266
 267 public:
 268   typedef MetadataTracking::OwnerTy OwnerTy;
 269
 270 private:
 271   LLVMContext &Context;
 272   uint64_t NextIndex;
 273   SmallDenseMap<void *, std::pair<OwnerTy, uint64_t>, 4> UseMap;
 274
 275 public:
 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
 297 private:
 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.
 325 class 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
 336 protected:
 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
 344 public:
 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
 368 protected:
 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
 378 public:
 379   static bool classof(const Metadata *MD) {
 380     return MD->getMetadataID() == LocalAsMetadataKind ||
 381            MD->getMetadataID() == ConstantAsMetadataKind;
 382   }
 383 };
 384
 385 class ConstantAsMetadata : public ValueAsMetadata {
 386   friend class ValueAsMetadata;
 387
 388   ConstantAsMetadata(Constant *C)
 389       : ValueAsMetadata(ConstantAsMetadataKind, C) {}
 390
 391 public:
 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
 409 class 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
 417 public:
 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.
 479 namespace mdconst {
 480
 481 namespace detail {
 482
 483 template <class T> T &make();
 484 template <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 };
 496 template <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 };
 500 template <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.
 511 template <class X, class Y>
 512 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, bool>::type
 513 hasa(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 }
 519 template <class X, class Y>
 520 inline
 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.
 529 template <class X, class Y>
 530 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
 531 extract(Y &&MD) {
 532   return cast<X>(cast<ConstantAsMetadata>(MD)->getValue());
 533 }
 534 template <class X, class Y>
 535 inline
 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.
 545 template <class X, class Y>
 546 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
 547 extract_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.
 558 template <class X, class Y>
 559 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
 560 dyn_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.
 571 template <class X, class Y>
 572 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
 573 dyn_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.
 586 class MDString : public Metadata {
 587   friend class StringMapEntry<MDString>;
 588
 589   StringMapEntry<MDString> *Entry;
 590   MDString() : Metadata(MDStringKind, Uniqued), Entry(nullptr) {}
 591
 592 public:
 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.
 625 struct 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.
 649 template<>
 650 struct 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.
 679 class MDOperand {
 680   Metadata *MD = nullptr;
 681
 682 public:
 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
 705 private:
 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
 722 template <> struct simplify_type<MDOperand> {
 723   typedef Metadata *SimpleType;
 724   static SimpleType getSimplifiedValue(MDOperand &MD) { return MD.get(); }
 725 };
 726
 727 template <> 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).
 736 class ContextAndReplaceableUses {
 737   PointerUnion<LLVMContext *, ReplaceableMetadataImpl *> Ptr;
 738
 739 public:
 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
 805 struct 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.
 830 class MDNode : public Metadata {
 831   friend class ReplaceableMetadataImpl;
 832   friend class LLVMContextImpl;
 833
 834   unsigned NumOperands;
 835   unsigned NumUnresolved;
 836
 837   ContextAndReplaceableUses Context;
 838
 839 protected:
 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
 867 public:
 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
 960 private:
 961   MDNode *replaceWithPermanentImpl();
 962   MDNode *replaceWithUniquedImpl();
 963   MDNode *replaceWithDistinctImpl();
 964
 965 protected:
 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
 976 private:
 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
1020 public:
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.
1072 class 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
1095 public:
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
1132 MDTuple *MDNode::get(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1133   return MDTuple::get(Context, MDs);
1134 }
1135
1136 MDTuple *MDNode::getIfExists(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1137   return MDTuple::getIfExists(Context, MDs);
1138 }
1139
1140 MDTuple *MDNode::getDistinct(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
1141   return MDTuple::getDistinct(Context, MDs);
1142 }
1143
1144 TempMDTuple MDNode::getTemporary(LLVMContext &Context,
1145                                  ArrayRef<Metadata *> MDs) {
1146   return MDTuple::getTemporary(Context, MDs);
1147 }
1148
1149 void 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.
1157 template <class T>
1158 class TypedMDOperandIterator
1159     : std::iterator<std::input_iterator_tag, T *, std::ptrdiff_t, void, T *> {
1160   MDNode::op_iterator I = nullptr;
1161
1162 public:
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.
1187 template <class T> class MDTupleTypedArrayWrapper {
1188   const MDTuple *N = nullptr;
1189
1190 public:
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.).
1244 class DistinctMDOperandPlaceholder : public Metadata {
1245   friend class MetadataTracking;
1246
1247   Metadata **Use = nullptr;
1248
1249 public:
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.
1282 class 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
1335 public:
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