Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- llvm/IR/Metadata.h - Metadata definitions ----------------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

/// @file

/// This file contains the declarations for metadata subclasses.

/// They represent the different flavors of metadata that live in LLVM.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_IR_METADATA_H

#define LLVM_IR_METADATA_H

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/DenseMap.h"

#include "llvm/ADT/DenseMapInfo.h"

#include "llvm/ADT/PointerUnion.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/ADT/ilist_node.h"

#include "llvm/ADT/iterator_range.h"

#include "llvm/IR/Constant.h"

#include "llvm/IR/LLVMContext.h"

#include "llvm/IR/Value.h"

#include "llvm/Support/CBindingWrapping.h"

#include "llvm/Support/Casting.h"

#include "llvm/Support/ErrorHandling.h"

#include <cassert>

#include <cstddef>

#include <cstdint>

#include <iterator>

#include <memory>

#include <string>

#include <type_traits>

#include <utility>

namespace llvm {

class Module;

class ModuleSlotTracker;

class raw_ostream;

template <typename T> class StringMapEntry;

template <typename ValueTy> class StringMapEntryStorage;

class Type;

enum LLVMConstants : uint32_t {

  DEBUG_METADATA_VERSION = 3 // Current debug info version number.

};

/// Magic number in the value profile metadata showing a target has been

/// promoted for the instruction and shouldn't be promoted again.

const uint64_t NOMORE_ICP_MAGICNUM = -1;

/// Root of the metadata hierarchy.

///

/// This is a root class for typeless data in the IR.

class Metadata {

  friend class ReplaceableMetadataImpl;

  /// RTTI.

  const unsigned char SubclassID;

protected:

  /// Active type of storage.

  enum StorageType { Uniqued, Distinct, Temporary };

  /// Storage flag for non-uniqued, otherwise unowned, metadata.

  unsigned char Storage : 7;

  unsigned char SubclassData1 : 1;

  unsigned short SubclassData16 = 0;

  unsigned SubclassData32 = 0;

public:

  enum MetadataKind {

#define HANDLE_METADATA_LEAF(CLASS) CLASS##Kind,

#include "llvm/IR/Metadata.def"

  };

protected:

  Metadata(unsigned ID, StorageType Storage)

      : SubclassID(ID), Storage(Storage), SubclassData1(false) {

    static_assert(sizeof(*this) == 8, "Metadata fields poorly packed");

  }

  ~Metadata() = default;

  /// Default handling of a changed operand, which asserts.

  ///

  /// If subclasses pass themselves in as owners to a tracking node reference,

  /// they must provide an implementation of this method.

  void handleChangedOperand(void *, Metadata *) {

    llvm_unreachable("Unimplemented in Metadata subclass");

  }

public:

  unsigned getMetadataID() const { return SubclassID; }

  /// User-friendly dump.

  ///

  /// If \c M is provided, metadata nodes will be numbered canonically;

  /// otherwise, pointer addresses are substituted.

  ///

  /// Note: this uses an explicit overload instead of default arguments so that

  /// the nullptr version is easy to call from a debugger.

  ///

  /// @{

  void dump() const;

  void dump(const Module *M) const;

  /// @}

  /// Print.

  ///

  /// Prints definition of \c this.

  ///

  /// If \c M is provided, metadata nodes will be numbered canonically;

  /// otherwise, pointer addresses are substituted.

  /// @{

  void print(raw_ostream &OS, const Module *M = nullptr,

             bool IsForDebug = false) const;

  void print(raw_ostream &OS, ModuleSlotTracker &MST, const Module *M = nullptr,

             bool IsForDebug = false) const;

  /// @}

  /// Print as operand.

  ///

  /// Prints reference of \c this.

  ///

  /// If \c M is provided, metadata nodes will be numbered canonically;

  /// otherwise, pointer addresses are substituted.

  /// @{

  void printAsOperand(raw_ostream &OS, const Module *M = nullptr) const;

  void printAsOperand(raw_ostream &OS, ModuleSlotTracker &MST,

                      const Module *M = nullptr) const;

  /// @}

};

// Create wrappers for C Binding types (see CBindingWrapping.h).

DEFINE_ISA_CONVERSION_FUNCTIONS(Metadata, LLVMMetadataRef)

// Specialized opaque metadata conversions.

inline Metadata **unwrap(LLVMMetadataRef *MDs) {

  return reinterpret_cast<Metadata**>(MDs);

}

#define HANDLE_METADATA(CLASS) class CLASS;

#include "llvm/IR/Metadata.def"

// Provide specializations of isa so that we don't need definitions of

// subclasses to see if the metadata is a subclass.

#define HANDLE_METADATA_LEAF(CLASS)                                            \

  template <> struct isa_impl<CLASS, Metadata> {                               \

    static inline bool doit(const Metadata &MD) {                              \

      return MD.getMetadataID() == Metadata::CLASS##Kind;                      \

    }                                                                          \

  };

#include "llvm/IR/Metadata.def"

inline raw_ostream &operator<<(raw_ostream &OS, const Metadata &MD) {

  MD.print(OS);

  return OS;

}

/// Metadata wrapper in the Value hierarchy.

///

/// A member of the \a Value hierarchy to represent a reference to metadata.

/// This allows, e.g., intrinsics to have metadata as operands.

///

/// Notably, this is the only thing in either hierarchy that is allowed to

/// reference \a LocalAsMetadata.

class MetadataAsValue : public Value {

  friend class ReplaceableMetadataImpl;

  friend class LLVMContextImpl;

  Metadata *MD;

  MetadataAsValue(Type *Ty, Metadata *MD);

  /// Drop use of metadata (during teardown).

  void dropUse() { MD = nullptr; }

public:

  ~MetadataAsValue();

  static MetadataAsValue *get(LLVMContext &Context, Metadata *MD);

  static MetadataAsValue *getIfExists(LLVMContext &Context, Metadata *MD);

  Metadata *getMetadata() const { return MD; }

  static bool classof(const Value *V) {

    return V->getValueID() == MetadataAsValueVal;

  }

private:

  void handleChangedMetadata(Metadata *MD);

  void track();

  void untrack();

};

/// API for tracking metadata references through RAUW and deletion.

///

/// Shared API for updating \a Metadata pointers in subclasses that support

/// RAUW.

///

/// This API is not meant to be used directly.  See \a TrackingMDRef for a

/// user-friendly tracking reference.

class MetadataTracking {

public:

  /// Track the reference to metadata.

  ///

  /// Register \c MD with \c *MD, if the subclass supports tracking.  If \c *MD

  /// gets RAUW'ed, \c MD will be updated to the new address.  If \c *MD gets

  /// deleted, \c MD will be set to \c nullptr.

  ///

  /// If tracking isn't supported, \c *MD will not change.

  ///

  /// \return true iff tracking is supported by \c MD.

  static bool track(Metadata *&MD) {

    return track(&MD, *MD, static_cast<Metadata *>(nullptr));

  }

  /// Track the reference to metadata for \a Metadata.

  ///

  /// As \a track(Metadata*&), but with support for calling back to \c Owner to

  /// tell it that its operand changed.  This could trigger \c Owner being

  /// re-uniqued.

  static bool track(void *Ref, Metadata &MD, Metadata &Owner) {

    return track(Ref, MD, &Owner);

  }

  /// Track the reference to metadata for \a MetadataAsValue.

  ///

  /// As \a track(Metadata*&), but with support for calling back to \c Owner to

  /// tell it that its operand changed.  This could trigger \c Owner being

  /// re-uniqued.

  static bool track(void *Ref, Metadata &MD, MetadataAsValue &Owner) {

    return track(Ref, MD, &Owner);

  }

  /// Stop tracking a reference to metadata.

  ///

  /// Stops \c *MD from tracking \c MD.

  static void untrack(Metadata *&MD) { untrack(&MD, *MD); }

  static void untrack(void *Ref, Metadata &MD);

  /// Move tracking from one reference to another.

  ///

  /// Semantically equivalent to \c untrack(MD) followed by \c track(New),

  /// except that ownership callbacks are maintained.

  ///

  /// Note: it is an error if \c *MD does not equal \c New.

  ///

  /// \return true iff tracking is supported by \c MD.

  static bool retrack(Metadata *&MD, Metadata *&New) {

    return retrack(&MD, *MD, &New);

  }

  static bool retrack(void *Ref, Metadata &MD, void *New);

  /// Check whether metadata is replaceable.

  static bool isReplaceable(const Metadata &MD);

  using OwnerTy = PointerUnion<MetadataAsValue *, Metadata *>;

private:

  /// Track a reference to metadata for an owner.

  ///

  /// Generalized version of tracking.

  static bool track(void *Ref, Metadata &MD, OwnerTy Owner);

};

/// Shared implementation of use-lists for replaceable metadata.

///

/// Most metadata cannot be RAUW'ed.  This is a shared implementation of

/// use-lists and associated API for the two that support it (\a ValueAsMetadata

/// and \a TempMDNode).

class ReplaceableMetadataImpl {

  friend class MetadataTracking;

public:

  using OwnerTy = MetadataTracking::OwnerTy;

private:

  LLVMContext &Context;

  uint64_t NextIndex = 0;

  SmallDenseMap<void *, std::pair<OwnerTy, uint64_t>, 4> UseMap;

public:

  ReplaceableMetadataImpl(LLVMContext &Context) : Context(Context) {}

  ~ReplaceableMetadataImpl() {

    assert(UseMap.empty() && "Cannot destroy in-use replaceable metadata");

  }

  LLVMContext &getContext() const { return Context; }

  /// Replace all uses of this with MD.

  ///

  /// Replace all uses of this with \c MD, which is allowed to be null.

  void replaceAllUsesWith(Metadata *MD);

   /// Replace all uses of the constant with Undef in debug info metadata

  static void SalvageDebugInfo(const Constant &C);

  /// Returns the list of all DIArgList users of this.

  SmallVector<Metadata *> getAllArgListUsers();

  /// Resolve all uses of this.

  ///

  /// Resolve all uses of this, turning off RAUW permanently.  If \c

  /// ResolveUsers, call \a MDNode::resolve() on any users whose last operand

  /// is resolved.

  void resolveAllUses(bool ResolveUsers = true);

private:

  void addRef(void *Ref, OwnerTy Owner);

  void dropRef(void *Ref);

  void moveRef(void *Ref, void *New, const Metadata &MD);

  /// Lazily construct RAUW support on MD.

  ///

  /// If this is an unresolved MDNode, RAUW support will be created on-demand.

  /// ValueAsMetadata always has RAUW support.

  static ReplaceableMetadataImpl *getOrCreate(Metadata &MD);

  /// Get RAUW support on MD, if it exists.

  static ReplaceableMetadataImpl *getIfExists(Metadata &MD);

  /// Check whether this node will support RAUW.

  ///

  /// Returns \c true unless getOrCreate() would return null.

  static bool isReplaceable(const Metadata &MD);

};

/// Value wrapper in the Metadata hierarchy.

///

/// This is a custom value handle that allows other metadata to refer to

/// classes in the Value hierarchy.

///

/// Because of full uniquing support, each value is only wrapped by a single \a

/// ValueAsMetadata object, so the lookup maps are far more efficient than

/// those using ValueHandleBase.

class ValueAsMetadata : public Metadata, ReplaceableMetadataImpl {

  friend class ReplaceableMetadataImpl;

  friend class LLVMContextImpl;

  Value *V;

  /// Drop users without RAUW (during teardown).

  void dropUsers() {

    ReplaceableMetadataImpl::resolveAllUses(/* ResolveUsers */ false);

  }

protected:

  ValueAsMetadata(unsigned ID, Value *V)

      : Metadata(ID, Uniqued), ReplaceableMetadataImpl(V->getContext()), V(V) {

    assert(V && "Expected valid value");

  }

  ~ValueAsMetadata() = default;

public:

  static ValueAsMetadata *get(Value *V);

  static ConstantAsMetadata *getConstant(Value *C) {

    return cast<ConstantAsMetadata>(get(C));

  }

  static LocalAsMetadata *getLocal(Value *Local) {

    return cast<LocalAsMetadata>(get(Local));

  }

  static ValueAsMetadata *getIfExists(Value *V);

  static ConstantAsMetadata *getConstantIfExists(Value *C) {

    return cast_or_null<ConstantAsMetadata>(getIfExists(C));

  }

  static LocalAsMetadata *getLocalIfExists(Value *Local) {

    return cast_or_null<LocalAsMetadata>(getIfExists(Local));

  }

  Value *getValue() const { return V; }

  Type *getType() const { return V->getType(); }

  LLVMContext &getContext() const { return V->getContext(); }

  SmallVector<Metadata *> getAllArgListUsers() {

    return ReplaceableMetadataImpl::getAllArgListUsers();

  }

  static void handleDeletion(Value *V);

  static void handleRAUW(Value *From, Value *To);

protected:

  /// Handle collisions after \a Value::replaceAllUsesWith().

  ///

  /// RAUW isn't supported directly for \a ValueAsMetadata, but if the wrapped

  /// \a Value gets RAUW'ed and the target already exists, this is used to

  /// merge the two metadata nodes.

  void replaceAllUsesWith(Metadata *MD) {

    ReplaceableMetadataImpl::replaceAllUsesWith(MD);

  }

public:

  static bool classof(const Metadata *MD) {

    return MD->getMetadataID() == LocalAsMetadataKind ||

           MD->getMetadataID() == ConstantAsMetadataKind;

  }

};

class ConstantAsMetadata : public ValueAsMetadata {

  friend class ValueAsMetadata;

  ConstantAsMetadata(Constant *C)

      : ValueAsMetadata(ConstantAsMetadataKind, C) {}

public:

  static ConstantAsMetadata *get(Constant *C) {

    return ValueAsMetadata::getConstant(C);

  }

  static ConstantAsMetadata *getIfExists(Constant *C) {

    return ValueAsMetadata::getConstantIfExists(C);

  }

  Constant *getValue() const {

    return cast<Constant>(ValueAsMetadata::getValue());

  }

  static bool classof(const Metadata *MD) {

    return MD->getMetadataID() == ConstantAsMetadataKind;

  }

};

class LocalAsMetadata : public ValueAsMetadata {

  friend class ValueAsMetadata;

  LocalAsMetadata(Value *Local)

      : ValueAsMetadata(LocalAsMetadataKind, Local) {

    assert(!isa<Constant>(Local) && "Expected local value");

  }

public:

  static LocalAsMetadata *get(Value *Local) {

    return ValueAsMetadata::getLocal(Local);

  }

  static LocalAsMetadata *getIfExists(Value *Local) {

    return ValueAsMetadata::getLocalIfExists(Local);

  }

  static bool classof(const Metadata *MD) {

    return MD->getMetadataID() == LocalAsMetadataKind;

  }

};

/// Transitional API for extracting constants from Metadata.

///

/// This namespace contains transitional functions for metadata that points to

/// \a Constants.

///

/// In prehistory -- when metadata was a subclass of \a Value -- \a MDNode

/// operands could refer to any \a Value.  There's was a lot of code like this:

///

/// \code

///     MDNode *N = ...;

///     auto *CI = dyn_cast<ConstantInt>(N->getOperand(2));

/// \endcode

///

/// Now that \a Value and \a Metadata are in separate hierarchies, maintaining

/// the semantics for \a isa(), \a cast(), \a dyn_cast() (etc.) requires three

/// steps: cast in the \a Metadata hierarchy, extraction of the \a Value, and

/// cast in the \a Value hierarchy.  Besides creating boiler-plate, this

/// requires subtle control flow changes.

///

/// The end-goal is to create a new type of metadata, called (e.g.) \a MDInt,

/// so that metadata can refer to numbers without traversing a bridge to the \a

/// Value hierarchy.  In this final state, the code above would look like this:

///

/// \code

///     MDNode *N = ...;

///     auto *MI = dyn_cast<MDInt>(N->getOperand(2));

/// \endcode

///

/// The API in this namespace supports the transition.  \a MDInt doesn't exist

/// yet, and even once it does, changing each metadata schema to use it is its

/// own mini-project.  In the meantime this API prevents us from introducing

/// complex and bug-prone control flow that will disappear in the end.  In

/// particular, the above code looks like this:

///

/// \code

///     MDNode *N = ...;

///     auto *CI = mdconst::dyn_extract<ConstantInt>(N->getOperand(2));

/// \endcode

///

/// The full set of provided functions includes:

///

///   mdconst::hasa                <=> isa

///   mdconst::extract             <=> cast

///   mdconst::extract_or_null     <=> cast_or_null

///   mdconst::dyn_extract         <=> dyn_cast

///   mdconst::dyn_extract_or_null <=> dyn_cast_or_null

///

/// The target of the cast must be a subclass of \a Constant.

namespace mdconst {

namespace detail {

template <class T> T &make();

template <class T, class Result> struct HasDereference {

  using Yes = char[1];

  using No = char[2];

  template <size_t N> struct SFINAE {};

  template <class U, class V>

  static Yes &hasDereference(SFINAE<sizeof(static_cast<V>(*make<U>()))> * = 0);

  template <class U, class V> static No &hasDereference(...);

  static const bool value =

      sizeof(hasDereference<T, Result>(nullptr)) == sizeof(Yes);

};

template <class V, class M> struct IsValidPointer {

  static const bool value = std::is_base_of<Constant, V>::value &&

                            HasDereference<M, const Metadata &>::value;

};

template <class V, class M> struct IsValidReference {

  static const bool value = std::is_base_of<Constant, V>::value &&

                            std::is_convertible<M, const Metadata &>::value;

};

} // end namespace detail

/// Check whether Metadata has a Value.

///

/// As an analogue to \a isa(), check whether \c MD has an \a Value inside of

/// type \c X.

template <class X, class Y>

inline std::enable_if_t<detail::IsValidPointer<X, Y>::value, bool>

hasa(Y &&MD) {

  assert(MD && "Null pointer sent into hasa");

  if (auto *V = dyn_cast<ConstantAsMetadata>(MD))

    return isa<X>(V->getValue());

  return false;

}

template <class X, class Y>

inline std::enable_if_t<detail::IsValidReference<X, Y &>::value, bool>

hasa(Y &MD) {

  return hasa(&MD);

}

/// Extract a Value from Metadata.

///

/// As an analogue to \a cast(), extract the \a Value subclass \c X from \c MD.

template <class X, class Y>

inline std::enable_if_t<detail::IsValidPointer<X, Y>::value, X *>

extract(Y &&MD) {

  return cast<X>(cast<ConstantAsMetadata>(MD)->getValue());

}

template <class X, class Y>

inline std::enable_if_t<detail::IsValidReference<X, Y &>::value, X *>

extract(Y &MD) {

  return extract(&MD);

}

/// Extract a Value from Metadata, allowing null.

///

/// As an analogue to \a cast_or_null(), extract the \a Value subclass \c X

/// from \c MD, allowing \c MD to be null.

template <class X, class Y>

inline std::enable_if_t<detail::IsValidPointer<X, Y>::value, X *>

extract_or_null(Y &&MD) {

  if (auto *V = cast_or_null<ConstantAsMetadata>(MD))

    return cast<X>(V->getValue());

  return nullptr;

}

/// Extract a Value from Metadata, if any.

///

/// As an analogue to \a dyn_cast_or_null(), extract the \a Value subclass \c X

/// from \c MD, return null if \c MD doesn't contain a \a Value or if the \a

/// Value it does contain is of the wrong subclass.

template <class X, class Y>

inline std::enable_if_t<detail::IsValidPointer<X, Y>::value, X *>

dyn_extract(Y &&MD) {

  if (auto *V = dyn_cast<ConstantAsMetadata>(MD))

    return dyn_cast<X>(V->getValue());

  return nullptr;

}

/// Extract a Value from Metadata, if any, allowing null.

///

/// As an analogue to \a dyn_cast_or_null(), extract the \a Value subclass \c X

/// from \c MD, return null if \c MD doesn't contain a \a Value or if the \a

/// Value it does contain is of the wrong subclass, allowing \c MD to be null.

template <class X, class Y>

inline std::enable_if_t<detail::IsValidPointer<X, Y>::value, X *>

dyn_extract_or_null(Y &&MD) {

  if (auto *V = dyn_cast_or_null<ConstantAsMetadata>(MD))

    return dyn_cast<X>(V->getValue());

  return nullptr;

}

} // end namespace mdconst

//===----------------------------------------------------------------------===//

/// A single uniqued string.

///

/// These are used to efficiently contain a byte sequence for metadata.

/// MDString is always unnamed.

class MDString : public Metadata {

  friend class StringMapEntryStorage<MDString>;

  StringMapEntry<MDString> *Entry = nullptr;

  MDString() : Metadata(MDStringKind, Uniqued) {}

public:

  MDString(const MDString &) = delete;

  MDString &operator=(MDString &&) = delete;

  MDString &operator=(const MDString &) = delete;

  static MDString *get(LLVMContext &Context, StringRef Str);

  static MDString *get(LLVMContext &Context, const char *Str) {

    return get(Context, Str ? StringRef(Str) : StringRef());

  }

  StringRef getString() const;

  unsigned getLength() const { return (unsigned)getString().size(); }

  using iterator = StringRef::iterator;

  /// Pointer to the first byte of the string.

  iterator begin() const { return getString().begin(); }

  /// Pointer to one byte past the end of the string.

  iterator end() const { return getString().end(); }

  const unsigned char *bytes_begin() const { return getString().bytes_begin(); }

  const unsigned char *bytes_end() const { return getString().bytes_end(); }

  /// Methods for support type inquiry through isa, cast, and dyn_cast.

  static bool classof(const Metadata *MD) {

    return MD->getMetadataID() == MDStringKind;

  }

};

/// A collection of metadata nodes that might be associated with a

/// memory access used by the alias-analysis infrastructure.

struct AAMDNodes {

  explicit AAMDNodes() = default;

  explicit AAMDNodes(MDNode *T, MDNode *TS, MDNode *S, MDNode *N)

      : TBAA(T), TBAAStruct(TS), Scope(S), NoAlias(N) {}

  bool operator==(const AAMDNodes &A) const {

    return TBAA == A.TBAA && TBAAStruct == A.TBAAStruct && Scope == A.Scope &&

           NoAlias == A.NoAlias;

  }

  bool operator!=(const AAMDNodes &A) const { return !(*this == A); }

  explicit operator bool() const {

    return TBAA || TBAAStruct || Scope || NoAlias;

  }

  /// The tag for type-based alias analysis.

  MDNode *TBAA = nullptr;

  /// The tag for type-based alias analysis (tbaa struct).

  MDNode *TBAAStruct = nullptr;

  /// The tag for alias scope specification (used with noalias).

  MDNode *Scope = nullptr;

  /// The tag specifying the noalias scope.

  MDNode *NoAlias = nullptr;

  // Shift tbaa Metadata node to start off bytes later

  static MDNode *shiftTBAA(MDNode *M, size_t off);

  // Shift tbaa.struct Metadata node to start off bytes later

  static MDNode *shiftTBAAStruct(MDNode *M, size_t off);

  // Extend tbaa Metadata node to apply to a series of bytes of length len.

  // A size of -1 denotes an unknown size.

  static MDNode *extendToTBAA(MDNode *TBAA, ssize_t len);

  /// Given two sets of AAMDNodes that apply to the same pointer,

  /// give the best AAMDNodes that are compatible with both (i.e. a set of

  /// nodes whose allowable aliasing conclusions are a subset of those

  /// allowable by both of the inputs). However, for efficiency

  /// reasons, do not create any new MDNodes.

  AAMDNodes intersect(const AAMDNodes &Other) const {

    AAMDNodes Result;

    Result.TBAA = Other.TBAA == TBAA ? TBAA : nullptr;

    Result.TBAAStruct = Other.TBAAStruct == TBAAStruct ? TBAAStruct : nullptr;

    Result.Scope = Other.Scope == Scope ? Scope : nullptr;

    Result.NoAlias = Other.NoAlias == NoAlias ? NoAlias : nullptr;

    return Result;

  }

  /// Create a new AAMDNode that describes this AAMDNode after applying a

  /// constant offset to the start of the pointer.

  AAMDNodes shift(size_t Offset) const {

    AAMDNodes Result;

    Result.TBAA = TBAA ? shiftTBAA(TBAA, Offset) : nullptr;

    Result.TBAAStruct =

        TBAAStruct ? shiftTBAAStruct(TBAAStruct, Offset) : nullptr;

    Result.Scope = Scope;

    Result.NoAlias = NoAlias;

    return Result;

  }

  /// Create a new AAMDNode that describes this AAMDNode after extending it to

  /// apply to a series of bytes of length Len. A size of -1 denotes an unknown

  /// size.

  AAMDNodes extendTo(ssize_t Len) const {

    AAMDNodes Result;

    Result.TBAA = TBAA ? extendToTBAA(TBAA, Len) : nullptr;

    // tbaa.struct contains (offset, size, type) triples. Extending the length

    // of the tbaa.struct doesn't require changing this (though more information

    // could be provided by adding more triples at subsequent lengths).

    Result.TBAAStruct = TBAAStruct;

    Result.Scope = Scope;

    Result.NoAlias = NoAlias;

    return Result;

  }

  /// Given two sets of AAMDNodes applying to potentially different locations,

  /// determine the best AAMDNodes that apply to both.

  AAMDNodes merge(const AAMDNodes &Other) const;

  /// Determine the best AAMDNodes after concatenating two different locations

  /// together. Different from `merge`, where different locations should

  /// overlap each other, `concat` puts non-overlapping locations together.

  AAMDNodes concat(const AAMDNodes &Other) const;

};

// Specialize DenseMapInfo for AAMDNodes.

template<>

struct DenseMapInfo<AAMDNodes> {

  static inline AAMDNodes getEmptyKey() {

    return AAMDNodes(DenseMapInfo<MDNode *>::getEmptyKey(),

                     nullptr, nullptr, nullptr);

  }

  static inline AAMDNodes getTombstoneKey() {

    return AAMDNodes(DenseMapInfo<MDNode *>::getTombstoneKey(),

                     nullptr, nullptr, nullptr);

  }

  static unsigned getHashValue(const AAMDNodes &Val) {

    return DenseMapInfo<MDNode *>::getHashValue(Val.TBAA) ^

           DenseMapInfo<MDNode *>::getHashValue(Val.TBAAStruct) ^

           DenseMapInfo<MDNode *>::getHashValue(Val.Scope) ^

           DenseMapInfo<MDNode *>::getHashValue(Val.NoAlias);

  }

  static bool isEqual(const AAMDNodes &LHS, const AAMDNodes &RHS) {

    return LHS == RHS;

  }

};

/// Tracking metadata reference owned by Metadata.

///

/// Similar to \a TrackingMDRef, but it's expected to be owned by an instance

/// of \a Metadata, which has the option of registering itself for callbacks to

/// re-unique itself.

///

/// In particular, this is used by \a MDNode.

class MDOperand {

  Metadata *MD = nullptr;

public:

  MDOperand() = default;

  MDOperand(const MDOperand &) = delete;

  MDOperand(MDOperand &&Op) {

    MD = Op.MD;

    if (MD)

      (void)MetadataTracking::retrack(Op.MD, MD);

    Op.MD = nullptr;

  }

  MDOperand &operator=(const MDOperand &) = delete;

  MDOperand &operator=(MDOperand &&Op) {

    MD = Op.MD;

    if (MD)

      (void)MetadataTracking::retrack(Op.MD, MD);

    Op.MD = nullptr;

    return *this;

  }

  ~MDOperand() { untrack(); }

  Metadata *get() const { return MD; }

  operator Metadata *() const { return get(); }

  Metadata *operator->() const { return get(); }

  Metadata &operator*() const { return *get(); }

  void reset() {

    untrack();