LCOV - code coverage report
Current view: top level - include/llvm/IR - Metadata.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 135 197 68.5 %
Date: 2018-10-20 13:21:21 Functions: 11 145 7.6 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13