LCOV - code coverage report
Current view: top level - include/llvm/IR - DebugInfoMetadata.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 530 546 97.1 %
Date: 2018-07-13 00:08:38 Functions: 73 78 93.6 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- llvm/IR/DebugInfoMetadata.h - Debug info metadata --------*- 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             : // Declarations for metadata specific to debug info.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #ifndef LLVM_IR_DEBUGINFOMETADATA_H
      15             : #define LLVM_IR_DEBUGINFOMETADATA_H
      16             : 
      17             : #include "llvm/ADT/ArrayRef.h"
      18             : #include "llvm/ADT/BitmaskEnum.h"
      19             : #include "llvm/ADT/None.h"
      20             : #include "llvm/ADT/Optional.h"
      21             : #include "llvm/ADT/PointerUnion.h"
      22             : #include "llvm/ADT/STLExtras.h"
      23             : #include "llvm/ADT/SmallVector.h"
      24             : #include "llvm/ADT/StringRef.h"
      25             : #include "llvm/ADT/iterator_range.h"
      26             : #include "llvm/BinaryFormat/Dwarf.h"
      27             : #include "llvm/IR/Constants.h"
      28             : #include "llvm/IR/Metadata.h"
      29             : #include "llvm/Support/Casting.h"
      30             : #include <cassert>
      31             : #include <climits>
      32             : #include <cstddef>
      33             : #include <cstdint>
      34             : #include <iterator>
      35             : #include <type_traits>
      36             : #include <vector>
      37             : 
      38             : // Helper macros for defining get() overrides.
      39             : #define DEFINE_MDNODE_GET_UNPACK_IMPL(...) __VA_ARGS__
      40             : #define DEFINE_MDNODE_GET_UNPACK(ARGS) DEFINE_MDNODE_GET_UNPACK_IMPL ARGS
      41             : #define DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(CLASS, FORMAL, ARGS)              \
      42             :   static CLASS *getDistinct(LLVMContext &Context,                              \
      43             :                             DEFINE_MDNODE_GET_UNPACK(FORMAL)) {                \
      44             :     return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Distinct);         \
      45             :   }                                                                            \
      46             :   static Temp##CLASS getTemporary(LLVMContext &Context,                        \
      47             :                                   DEFINE_MDNODE_GET_UNPACK(FORMAL)) {          \
      48             :     return Temp##CLASS(                                                        \
      49             :         getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Temporary));          \
      50             :   }
      51             : #define DEFINE_MDNODE_GET(CLASS, FORMAL, ARGS)                                 \
      52             :   static CLASS *get(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK(FORMAL)) {  \
      53             :     return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Uniqued);          \
      54             :   }                                                                            \
      55             :   static CLASS *getIfExists(LLVMContext &Context,                              \
      56             :                             DEFINE_MDNODE_GET_UNPACK(FORMAL)) {                \
      57             :     return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Uniqued,           \
      58             :                    /* ShouldCreate */ false);                                  \
      59             :   }                                                                            \
      60             :   DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(CLASS, FORMAL, ARGS)
      61             : 
      62             : namespace llvm {
      63             : 
      64             : /// Holds a subclass of DINode.
      65             : ///
      66             : /// FIXME: This class doesn't currently make much sense.  Previously it was a
      67             : /// union beteen MDString (for ODR-uniqued types) and things like DIType.  To
      68             : /// support CodeView work, it wasn't deleted outright when MDString-based type
      69             : /// references were deleted; we'll soon need a similar concept for CodeView
      70             : /// DITypeIndex.
      71             : template <class T> class TypedDINodeRef {
      72             :   const Metadata *MD = nullptr;
      73             : 
      74             : public:
      75             :   TypedDINodeRef() = default;
      76             :   TypedDINodeRef(std::nullptr_t) {}
      77      118774 :   TypedDINodeRef(const T *MD) : MD(MD) {}
      78             : 
      79           8 :   explicit TypedDINodeRef(const Metadata *MD) : MD(MD) {
      80             :     assert((!MD || isa<T>(MD)) && "Expected valid type ref");
      81             :   }
      82             : 
      83             :   template <class U>
      84             :   TypedDINodeRef(
      85             :       const TypedDINodeRef<U> &X,
      86             :       typename std::enable_if<std::is_convertible<U *, T *>::value>::type * =
      87             :           nullptr)
      88             :       : MD(X) {}
      89             : 
      90     1607688 :   operator Metadata *() const { return const_cast<Metadata *>(MD); }
      91             : 
      92      121854 :   T *resolve() const { return const_cast<T *>(cast_or_null<T>(MD)); }
      93             : 
      94             :   bool operator==(const TypedDINodeRef<T> &X) const { return MD == X.MD; }
      95             :   bool operator!=(const TypedDINodeRef<T> &X) const { return MD != X.MD; }
      96             : };
      97             : 
      98             : using DINodeRef = TypedDINodeRef<DINode>;
      99             : using DIScopeRef = TypedDINodeRef<DIScope>;
     100             : using DITypeRef = TypedDINodeRef<DIType>;
     101             : 
     102             : class DITypeRefArray {
     103             :   const MDTuple *N = nullptr;
     104             : 
     105             : public:
     106             :   DITypeRefArray() = default;
     107             :   DITypeRefArray(const MDTuple *N) : N(N) {}
     108             : 
     109             :   explicit operator bool() const { return get(); }
     110             :   explicit operator MDTuple *() const { return get(); }
     111             : 
     112           0 :   MDTuple *get() const { return const_cast<MDTuple *>(N); }
     113             :   MDTuple *operator->() const { return get(); }
     114             :   MDTuple &operator*() const { return *get(); }
     115             : 
     116             :   // FIXME: Fix callers and remove condition on N.
     117      719733 :   unsigned size() const { return N ? N->getNumOperands() : 0u; }
     118      918820 :   DITypeRef operator[](unsigned I) const { return DITypeRef(N->getOperand(I)); }
     119             : 
     120             :   class iterator : std::iterator<std::input_iterator_tag, DITypeRef,
     121             :                                  std::ptrdiff_t, void, DITypeRef> {
     122             :     MDNode::op_iterator I = nullptr;
     123             : 
     124             :   public:
     125             :     iterator() = default;
     126             :     explicit iterator(MDNode::op_iterator I) : I(I) {}
     127             : 
     128             :     DITypeRef operator*() const { return DITypeRef(*I); }
     129             : 
     130             :     iterator &operator++() {
     131         501 :       ++I;
     132             :       return *this;
     133             :     }
     134             : 
     135             :     iterator operator++(int) {
     136             :       iterator Temp(*this);
     137             :       ++I;
     138             :       return Temp;
     139             :     }
     140             : 
     141             :     bool operator==(const iterator &X) const { return I == X.I; }
     142             :     bool operator!=(const iterator &X) const { return I != X.I; }
     143             :   };
     144             : 
     145             :   // FIXME: Fix callers and remove condition on N.
     146         302 :   iterator begin() const { return N ? iterator(N->op_begin()) : iterator(); }
     147         302 :   iterator end() const { return N ? iterator(N->op_end()) : iterator(); }
     148             : };
     149             : 
     150             : /// Tagged DWARF-like metadata node.
     151             : ///
     152             : /// A metadata node with a DWARF tag (i.e., a constant named \c DW_TAG_*,
     153             : /// defined in llvm/BinaryFormat/Dwarf.h).  Called \a DINode because it's
     154             : /// potentially used for non-DWARF output.
     155             : class DINode : public MDNode {
     156             :   friend class LLVMContextImpl;
     157             :   friend class MDNode;
     158             : 
     159             : protected:
     160             :   DINode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
     161             :          ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None)
     162     1351817 :       : MDNode(C, ID, Storage, Ops1, Ops2) {
     163             :     assert(Tag < 1u << 16);
     164     1351817 :     SubclassData16 = Tag;
     165             :   }
     166             :   ~DINode() = default;
     167             : 
     168             :   template <class Ty> Ty *getOperandAs(unsigned I) const {
     169    13868758 :     return cast_or_null<Ty>(getOperand(I));
     170             :   }
     171             : 
     172     8921439 :   StringRef getStringOperand(unsigned I) const {
     173             :     if (auto *S = getOperandAs<MDString>(I))
     174     8217013 :       return S->getString();
     175      704426 :     return StringRef();
     176             :   }
     177             : 
     178             :   static MDString *getCanonicalMDString(LLVMContext &Context, StringRef S) {
     179     1664711 :     if (S.empty())
     180             :       return nullptr;
     181      959691 :     return MDString::get(Context, S);
     182             :   }
     183             : 
     184             :   /// Allow subclasses to mutate the tag.
     185           5 :   void setTag(unsigned Tag) { SubclassData16 = Tag; }
     186             : 
     187             : public:
     188     3574060 :   unsigned getTag() const { return SubclassData16; }
     189             : 
     190             :   /// Debug info flags.
     191             :   ///
     192             :   /// The three accessibility flags are mutually exclusive and rolled together
     193             :   /// in the first two bits.
     194             :   enum DIFlags : uint32_t {
     195             : #define HANDLE_DI_FLAG(ID, NAME) Flag##NAME = ID,
     196             : #define DI_FLAG_LARGEST_NEEDED
     197             : #include "llvm/IR/DebugInfoFlags.def"
     198             :     FlagAccessibility = FlagPrivate | FlagProtected | FlagPublic,
     199             :     FlagPtrToMemberRep = FlagSingleInheritance | FlagMultipleInheritance |
     200             :                          FlagVirtualInheritance,
     201             :     LLVM_MARK_AS_BITMASK_ENUM(FlagLargest)
     202             :   };
     203             : 
     204             :   static DIFlags getFlag(StringRef Flag);
     205             :   static StringRef getFlagString(DIFlags Flag);
     206             : 
     207             :   /// Split up a flags bitfield.
     208             :   ///
     209             :   /// Split \c Flags into \c SplitFlags, a vector of its components.  Returns
     210             :   /// any remaining (unrecognized) bits.
     211             :   static DIFlags splitFlags(DIFlags Flags,
     212             :                             SmallVectorImpl<DIFlags> &SplitFlags);
     213             : 
     214             :   static bool classof(const Metadata *MD) {
     215        1147 :     switch (MD->getMetadataID()) {
     216             :     default:
     217             :       return false;
     218             :     case GenericDINodeKind:
     219             :     case DISubrangeKind:
     220             :     case DIEnumeratorKind:
     221             :     case DIBasicTypeKind:
     222             :     case DIDerivedTypeKind:
     223             :     case DICompositeTypeKind:
     224             :     case DISubroutineTypeKind:
     225             :     case DIFileKind:
     226             :     case DICompileUnitKind:
     227             :     case DISubprogramKind:
     228             :     case DILexicalBlockKind:
     229             :     case DILexicalBlockFileKind:
     230             :     case DINamespaceKind:
     231             :     case DITemplateTypeParameterKind:
     232             :     case DITemplateValueParameterKind:
     233             :     case DIGlobalVariableKind:
     234             :     case DILocalVariableKind:
     235             :     case DILabelKind:
     236             :     case DIObjCPropertyKind:
     237             :     case DIImportedEntityKind:
     238             :     case DIModuleKind:
     239             :       return true;
     240             :     }
     241             :   }
     242             : };
     243             : 
     244             : template <class T> struct simplify_type<const TypedDINodeRef<T>> {
     245             :   using SimpleType = Metadata *;
     246             : 
     247             :   static SimpleType getSimplifiedValue(const TypedDINodeRef<T> &MD) {
     248             :     return MD;
     249             :   }
     250             : };
     251             : 
     252             : template <class T>
     253             : struct simplify_type<TypedDINodeRef<T>>
     254             :     : simplify_type<const TypedDINodeRef<T>> {};
     255             : 
     256             : /// Generic tagged DWARF-like metadata node.
     257             : ///
     258             : /// An un-specialized DWARF-like metadata node.  The first operand is a
     259             : /// (possibly empty) null-separated \a MDString header that contains arbitrary
     260             : /// fields.  The remaining operands are \a dwarf_operands(), and are pointers
     261             : /// to other metadata.
     262             : class GenericDINode : public DINode {
     263             :   friend class LLVMContextImpl;
     264             :   friend class MDNode;
     265             : 
     266             :   GenericDINode(LLVMContext &C, StorageType Storage, unsigned Hash,
     267             :                 unsigned Tag, ArrayRef<Metadata *> Ops1,
     268             :                 ArrayRef<Metadata *> Ops2)
     269             :       : DINode(C, GenericDINodeKind, Storage, Tag, Ops1, Ops2) {
     270             :     setHash(Hash);
     271             :   }
     272          96 :   ~GenericDINode() { dropAllReferences(); }
     273             : 
     274          74 :   void setHash(unsigned Hash) { SubclassData32 = Hash; }
     275             :   void recalculateHash();
     276             : 
     277           6 :   static GenericDINode *getImpl(LLVMContext &Context, unsigned Tag,
     278             :                                 StringRef Header, ArrayRef<Metadata *> DwarfOps,
     279             :                                 StorageType Storage, bool ShouldCreate = true) {
     280           6 :     return getImpl(Context, Tag, getCanonicalMDString(Context, Header),
     281           6 :                    DwarfOps, Storage, ShouldCreate);
     282             :   }
     283             : 
     284             :   static GenericDINode *getImpl(LLVMContext &Context, unsigned Tag,
     285             :                                 MDString *Header, ArrayRef<Metadata *> DwarfOps,
     286             :                                 StorageType Storage, bool ShouldCreate = true);
     287             : 
     288           1 :   TempGenericDINode cloneImpl() const {
     289             :     return getTemporary(
     290             :         getContext(), getTag(), getHeader(),
     291           2 :         SmallVector<Metadata *, 4>(dwarf_op_begin(), dwarf_op_end()));
     292             :   }
     293             : 
     294             : public:
     295             :   unsigned getHash() const { return SubclassData32; }
     296             : 
     297           6 :   DEFINE_MDNODE_GET(GenericDINode, (unsigned Tag, StringRef Header,
     298             :                                     ArrayRef<Metadata *> DwarfOps),
     299             :                     (Tag, Header, DwarfOps))
     300          55 :   DEFINE_MDNODE_GET(GenericDINode, (unsigned Tag, MDString *Header,
     301             :                                     ArrayRef<Metadata *> DwarfOps),
     302             :                     (Tag, Header, DwarfOps))
     303             : 
     304             :   /// Return a (temporary) clone of this.
     305           1 :   TempGenericDINode clone() const { return cloneImpl(); }
     306             : 
     307          98 :   unsigned getTag() const { return SubclassData16; }
     308          25 :   StringRef getHeader() const { return getStringOperand(0); }
     309             :   MDString *getRawHeader() const { return getOperandAs<MDString>(0); }
     310             : 
     311           6 :   op_iterator dwarf_op_begin() const { return op_begin() + 1; }
     312           6 :   op_iterator dwarf_op_end() const { return op_end(); }
     313             :   op_range dwarf_operands() const {
     314             :     return op_range(dwarf_op_begin(), dwarf_op_end());
     315             :   }
     316             : 
     317          21 :   unsigned getNumDwarfOperands() const { return getNumOperands() - 1; }
     318             :   const MDOperand &getDwarfOperand(unsigned I) const {
     319           3 :     return getOperand(I + 1);
     320             :   }
     321             :   void replaceDwarfOperandWith(unsigned I, Metadata *New) {
     322           1 :     replaceOperandWith(I + 1, New);
     323             :   }
     324             : 
     325             :   static bool classof(const Metadata *MD) {
     326             :     return MD->getMetadataID() == GenericDINodeKind;
     327             :   }
     328             : };
     329             : 
     330             : /// Array subrange.
     331             : ///
     332             : /// TODO: Merge into node for DW_TAG_array_type, which should have a custom
     333             : /// type.
     334             : class DISubrange : public DINode {
     335             :   friend class LLVMContextImpl;
     336             :   friend class MDNode;
     337             : 
     338             :   int64_t LowerBound;
     339             : 
     340             :   DISubrange(LLVMContext &C, StorageType Storage, Metadata *Node,
     341             :              int64_t LowerBound, ArrayRef<Metadata *> Ops)
     342        3100 :       : DINode(C, DISubrangeKind, Storage, dwarf::DW_TAG_subrange_type, Ops),
     343        3100 :         LowerBound(LowerBound) {}
     344             : 
     345         438 :   ~DISubrange() = default;
     346             : 
     347             :   static DISubrange *getImpl(LLVMContext &Context, int64_t Count,
     348             :                              int64_t LowerBound, StorageType Storage,
     349             :                              bool ShouldCreate = true);
     350             : 
     351             :   static DISubrange *getImpl(LLVMContext &Context, Metadata *CountNode,
     352             :                              int64_t LowerBound, StorageType Storage,
     353             :                              bool ShouldCreate = true);
     354             : 
     355           1 :   TempDISubrange cloneImpl() const {
     356           2 :     return getTemporary(getContext(), getRawCountNode(), getLowerBound());
     357             :   }
     358             : 
     359             : public:
     360        3551 :   DEFINE_MDNODE_GET(DISubrange, (int64_t Count, int64_t LowerBound = 0),
     361             :                     (Count, LowerBound))
     362             : 
     363          80 :   DEFINE_MDNODE_GET(DISubrange, (Metadata *CountNode, int64_t LowerBound = 0),
     364             :                     (CountNode, LowerBound))
     365             : 
     366           1 :   TempDISubrange clone() const { return cloneImpl(); }
     367             : 
     368             :   int64_t getLowerBound() const { return LowerBound; }
     369             : 
     370             :   Metadata *getRawCountNode() const {
     371       12237 :     return getOperand(0).get();
     372             :   }
     373             : 
     374             :   typedef PointerUnion<ConstantInt*, DIVariable*> CountType;
     375             : 
     376        8787 :   CountType getCount() const {
     377             :     if (auto *MD = dyn_cast<ConstantAsMetadata>(getRawCountNode()))
     378        8623 :       return CountType(cast<ConstantInt>(MD->getValue()));
     379             : 
     380             :     if (auto *DV = dyn_cast<DIVariable>(getRawCountNode()))
     381         161 :       return CountType(DV);
     382             : 
     383           3 :     return CountType();
     384             :   }
     385             : 
     386             :   static bool classof(const Metadata *MD) {
     387         632 :     return MD->getMetadataID() == DISubrangeKind;
     388             :   }
     389             : };
     390             : 
     391             : /// Enumeration value.
     392             : ///
     393             : /// TODO: Add a pointer to the context (DW_TAG_enumeration_type) once that no
     394             : /// longer creates a type cycle.
     395             : class DIEnumerator : public DINode {
     396             :   friend class LLVMContextImpl;
     397             :   friend class MDNode;
     398             : 
     399             :   int64_t Value;
     400             :   DIEnumerator(LLVMContext &C, StorageType Storage, int64_t Value,
     401             :                bool IsUnsigned, ArrayRef<Metadata *> Ops)
     402       17789 :       : DINode(C, DIEnumeratorKind, Storage, dwarf::DW_TAG_enumerator, Ops),
     403       17789 :         Value(Value) {
     404       17789 :     SubclassData32 = IsUnsigned;
     405             :   }
     406        6250 :   ~DIEnumerator() = default;
     407             : 
     408       11613 :   static DIEnumerator *getImpl(LLVMContext &Context, int64_t Value,
     409             :                                bool IsUnsigned, StringRef Name,
     410             :                                StorageType Storage, bool ShouldCreate = true) {
     411       23226 :     return getImpl(Context, Value, IsUnsigned,
     412       11613 :                    getCanonicalMDString(Context, Name), Storage, ShouldCreate);
     413             :   }
     414             :   static DIEnumerator *getImpl(LLVMContext &Context, int64_t Value,
     415             :                                bool IsUnsigned, MDString *Name,
     416             :                                StorageType Storage, bool ShouldCreate = true);
     417             : 
     418           1 :   TempDIEnumerator cloneImpl() const {
     419           3 :     return getTemporary(getContext(), getValue(), isUnsigned(), getName());
     420             :   }
     421             : 
     422             : public:
     423       11613 :   DEFINE_MDNODE_GET(DIEnumerator, (int64_t Value, bool IsUnsigned, StringRef Name),
     424             :                     (Value, IsUnsigned, Name))
     425        6187 :   DEFINE_MDNODE_GET(DIEnumerator, (int64_t Value, bool IsUnsigned, MDString *Name),
     426             :                     (Value, IsUnsigned, Name))
     427             : 
     428           1 :   TempDIEnumerator clone() const { return cloneImpl(); }
     429             : 
     430             :   int64_t getValue() const { return Value; }
     431       35415 :   bool isUnsigned() const { return SubclassData32; }
     432       17754 :   StringRef getName() const { return getStringOperand(0); }
     433             : 
     434             :   MDString *getRawName() const { return getOperandAs<MDString>(0); }
     435             : 
     436             :   static bool classof(const Metadata *MD) {
     437       17664 :     return MD->getMetadataID() == DIEnumeratorKind;
     438             :   }
     439             : };
     440             : 
     441             : /// Base class for scope-like contexts.
     442             : ///
     443             : /// Base class for lexical scopes and types (which are also declaration
     444             : /// contexts).
     445             : ///
     446             : /// TODO: Separate the concepts of declaration contexts and lexical scopes.
     447             : class DIScope : public DINode {
     448             : protected:
     449             :   DIScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
     450             :           ArrayRef<Metadata *> Ops)
     451             :       : DINode(C, ID, Storage, Tag, Ops) {}
     452             :   ~DIScope() = default;
     453             : 
     454             : public:
     455             :   DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
     456             : 
     457             :   inline StringRef getFilename() const;
     458             :   inline StringRef getDirectory() const;
     459             :   inline Optional<StringRef> getSource() const;
     460             : 
     461             :   StringRef getName() const;
     462             :   DIScopeRef getScope() const;
     463             : 
     464             :   /// Return the raw underlying file.
     465             :   ///
     466             :   /// A \a DIFile is a \a DIScope, but it doesn't point at a separate file (it
     467             :   /// \em is the file).  If \c this is an \a DIFile, we need to return \c this.
     468             :   /// Otherwise, return the first operand, which is where all other subclasses
     469             :   /// store their file pointer.
     470             :   Metadata *getRawFile() const {
     471     6348924 :     return isa<DIFile>(this) ? const_cast<DIScope *>(this)
     472     6348923 :                              : static_cast<Metadata *>(getOperand(0));
     473             :   }
     474             : 
     475             :   static bool classof(const Metadata *MD) {
     476      110174 :     switch (MD->getMetadataID()) {
     477             :     default:
     478             :       return false;
     479             :     case DIBasicTypeKind:
     480             :     case DIDerivedTypeKind:
     481             :     case DICompositeTypeKind:
     482             :     case DISubroutineTypeKind:
     483             :     case DIFileKind:
     484             :     case DICompileUnitKind:
     485             :     case DISubprogramKind:
     486             :     case DILexicalBlockKind:
     487             :     case DILexicalBlockFileKind:
     488             :     case DINamespaceKind:
     489             :     case DIModuleKind:
     490             :       return true;
     491             :     }
     492             :   }
     493             : };
     494             : 
     495             : /// File.
     496             : ///
     497             : /// TODO: Merge with directory/file node (including users).
     498             : /// TODO: Canonicalize paths on creation.
     499             : class DIFile : public DIScope {
     500             :   friend class LLVMContextImpl;
     501             :   friend class MDNode;
     502             : 
     503             : public:
     504             :   /// Which algorithm (e.g. MD5) a checksum was generated with.
     505             :   ///
     506             :   /// The encoding is explicit because it is used directly in Bitcode. The
     507             :   /// value 0 is reserved to indicate the absence of a checksum in Bitcode.
     508             :   enum ChecksumKind {
     509             :     // The first variant was originally CSK_None, encoded as 0. The new
     510             :     // internal representation removes the need for this by wrapping the
     511             :     // ChecksumInfo in an Optional, but to preserve Bitcode compatibility the 0
     512             :     // encoding is reserved.
     513             :     CSK_MD5 = 1,
     514             :     CSK_SHA1 = 2,
     515             :     CSK_Last = CSK_SHA1 // Should be last enumeration.
     516             :   };
     517             : 
     518             :   /// A single checksum, represented by a \a Kind and a \a Value (a string).
     519             :   template <typename T>
     520             :   struct ChecksumInfo {
     521             :     /// The kind of checksum which \a Value encodes.
     522             :     ChecksumKind Kind;
     523             :     /// The string value of the checksum.
     524             :     T Value;
     525             : 
     526         788 :     ChecksumInfo(ChecksumKind Kind, T Value) : Kind(Kind), Value(Value) { }
     527             :     ~ChecksumInfo() = default;
     528           1 :     bool operator==(const ChecksumInfo<T> &X) const {
     529         122 :       return Kind == X.Kind && Value == X.Value;
     530             :     }
     531             :     bool operator!=(const ChecksumInfo<T> &X) const { return !(*this == X); }
     532          70 :     StringRef getKindAsString() const { return getChecksumKindAsString(Kind); }
     533             :   };
     534             : 
     535             : private:
     536             :   Optional<ChecksumInfo<MDString *>> Checksum;
     537             :   Optional<MDString *> Source;
     538             : 
     539       27782 :   DIFile(LLVMContext &C, StorageType Storage,
     540             :          Optional<ChecksumInfo<MDString *>> CS, Optional<MDString *> Src,
     541             :          ArrayRef<Metadata *> Ops)
     542       27782 :       : DIScope(C, DIFileKind, Storage, dwarf::DW_TAG_file_type, Ops),
     543       27782 :         Checksum(CS), Source(Src) {}
     544        3667 :   ~DIFile() = default;
     545             : 
     546       49202 :   static DIFile *getImpl(LLVMContext &Context, StringRef Filename,
     547             :                          StringRef Directory,
     548             :                          Optional<ChecksumInfo<StringRef>> CS,
     549             :                          Optional<StringRef> Source,
     550             :                          StorageType Storage, bool ShouldCreate = true) {
     551             :     Optional<ChecksumInfo<MDString *>> MDChecksum;
     552       49202 :     if (CS)
     553             :       MDChecksum.emplace(CS->Kind, getCanonicalMDString(Context, CS->Value));
     554       98404 :     return getImpl(Context, getCanonicalMDString(Context, Filename),
     555             :                    getCanonicalMDString(Context, Directory), MDChecksum,
     556       98404 :                    Source ? Optional<MDString *>(getCanonicalMDString(Context, *Source)) : None,
     557       98404 :                    Storage, ShouldCreate);
     558             :   }
     559             :   static DIFile *getImpl(LLVMContext &Context, MDString *Filename,
     560             :                          MDString *Directory,
     561             :                          Optional<ChecksumInfo<MDString *>> CS,
     562             :                          Optional<MDString *> Source, StorageType Storage,
     563             :                          bool ShouldCreate = true);
     564             : 
     565           1 :   TempDIFile cloneImpl() const {
     566             :     return getTemporary(getContext(), getFilename(), getDirectory(),
     567           1 :                         getChecksum(), getSource());
     568             :   }
     569             : 
     570             : public:
     571       98405 :   DEFINE_MDNODE_GET(DIFile, (StringRef Filename, StringRef Directory,
     572             :                              Optional<ChecksumInfo<StringRef>> CS = None,
     573             :                              Optional<StringRef> Source = None),
     574             :                     (Filename, Directory, CS, Source))
     575        6090 :   DEFINE_MDNODE_GET(DIFile, (MDString * Filename, MDString *Directory,
     576             :                              Optional<ChecksumInfo<MDString *>> CS = None,
     577             :                              Optional<MDString *> Source = None),
     578             :                     (Filename, Directory, CS, Source))
     579             : 
     580           1 :   TempDIFile clone() const { return cloneImpl(); }
     581             : 
     582     4119166 :   StringRef getFilename() const { return getStringOperand(0); }
     583     1463213 :   StringRef getDirectory() const { return getStringOperand(1); }
     584             :   Optional<ChecksumInfo<StringRef>> getChecksum() const {
     585             :     Optional<ChecksumInfo<StringRef>> StringRefChecksum;
     586       32819 :     if (Checksum)
     587        1815 :       StringRefChecksum.emplace(Checksum->Kind, Checksum->Value->getString());
     588             :     return StringRefChecksum;
     589             :   }
     590             :   Optional<StringRef> getSource() const {
     591     2694878 :     return Source ? Optional<StringRef>((*Source)->getString()) : None;
     592             :   }
     593             : 
     594             :   MDString *getRawFilename() const { return getOperandAs<MDString>(0); }
     595             :   MDString *getRawDirectory() const { return getOperandAs<MDString>(1); }
     596             :   Optional<ChecksumInfo<MDString *>> getRawChecksum() const { return Checksum; }
     597             :   Optional<MDString *> getRawSource() const { return Source; }
     598             : 
     599             :   static StringRef getChecksumKindAsString(ChecksumKind CSKind);
     600             :   static Optional<ChecksumKind> getChecksumKind(StringRef CSKindStr);
     601             : 
     602             :   static bool classof(const Metadata *MD) {
     603     7368234 :     return MD->getMetadataID() == DIFileKind;
     604             :   }
     605             : };
     606             : 
     607     2764811 : StringRef DIScope::getFilename() const {
     608             :   if (auto *F = getFile())
     609             :     return F->getFilename();
     610          55 :   return "";
     611             : }
     612             : 
     613      118233 : StringRef DIScope::getDirectory() const {
     614             :   if (auto *F = getFile())
     615             :     return F->getDirectory();
     616           4 :   return "";
     617             : }
     618             : 
     619        2585 : Optional<StringRef> DIScope::getSource() const {
     620             :   if (auto *F = getFile())
     621             :     return F->getSource();
     622             :   return None;
     623             : }
     624             : 
     625             : /// Base class for types.
     626             : ///
     627             : /// TODO: Remove the hardcoded name and context, since many types don't use
     628             : /// them.
     629             : /// TODO: Split up flags.
     630             : class DIType : public DIScope {
     631             :   unsigned Line;
     632             :   DIFlags Flags;
     633             :   uint64_t SizeInBits;
     634             :   uint64_t OffsetInBits;
     635             :   uint32_t AlignInBits;
     636             : 
     637             : protected:
     638             :   DIType(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
     639             :          unsigned Line, uint64_t SizeInBits, uint32_t AlignInBits,
     640             :          uint64_t OffsetInBits, DIFlags Flags, ArrayRef<Metadata *> Ops)
     641      749596 :       : DIScope(C, ID, Storage, Tag, Ops) {
     642             :     init(Line, SizeInBits, AlignInBits, OffsetInBits, Flags);
     643             :   }
     644             :   ~DIType() = default;
     645             : 
     646             :   void init(unsigned Line, uint64_t SizeInBits, uint32_t AlignInBits,
     647             :             uint64_t OffsetInBits, DIFlags Flags) {
     648      749601 :     this->Line = Line;
     649      749601 :     this->Flags = Flags;
     650      749601 :     this->SizeInBits = SizeInBits;
     651      749601 :     this->AlignInBits = AlignInBits;
     652      749601 :     this->OffsetInBits = OffsetInBits;
     653             :   }
     654             : 
     655             :   /// Change fields in place.
     656             :   void mutate(unsigned Tag, unsigned Line, uint64_t SizeInBits,
     657             :               uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags) {
     658             :     assert(isDistinct() && "Only distinct nodes can mutate");
     659             :     setTag(Tag);
     660             :     init(Line, SizeInBits, AlignInBits, OffsetInBits, Flags);
     661             :   }
     662             : 
     663             : public:
     664             :   TempDIType clone() const {
     665      355254 :     return TempDIType(cast<DIType>(MDNode::clone().release()));
     666             :   }
     667             : 
     668             :   unsigned getLine() const { return Line; }
     669             :   uint64_t getSizeInBits() const { return SizeInBits; }
     670             :   uint32_t getAlignInBits() const { return AlignInBits; }
     671       98539 :   uint32_t getAlignInBytes() const { return getAlignInBits() / CHAR_BIT; }
     672             :   uint64_t getOffsetInBits() const { return OffsetInBits; }
     673             :   DIFlags getFlags() const { return Flags; }
     674             : 
     675             :   DIScopeRef getScope() const { return DIScopeRef(getRawScope()); }
     676      875496 :   StringRef getName() const { return getStringOperand(2); }
     677             : 
     678             : 
     679     3241688 :   Metadata *getRawScope() const { return getOperand(1); }
     680             :   MDString *getRawName() const { return getOperandAs<MDString>(2); }
     681             : 
     682             :   /// Returns a new temporary DIType with updated Flags
     683             :   TempDIType cloneWithFlags(DIFlags NewFlags) const {
     684             :     auto NewTy = clone();
     685      177626 :     NewTy->Flags = NewFlags;
     686             :     return NewTy;
     687             :   }
     688             : 
     689             :   bool isPrivate() const {
     690             :     return (getFlags() & FlagAccessibility) == FlagPrivate;
     691             :   }
     692             :   bool isProtected() const {
     693       61777 :     return (getFlags() & FlagAccessibility) == FlagProtected;
     694             :   }
     695             :   bool isPublic() const {
     696             :     return (getFlags() & FlagAccessibility) == FlagPublic;
     697             :   }
     698      353946 :   bool isForwardDecl() const { return getFlags() & FlagFwdDecl; }
     699       35437 :   bool isAppleBlockExtension() const { return getFlags() & FlagAppleBlock; }
     700      185478 :   bool isBlockByrefStruct() const { return getFlags() & FlagBlockByrefStruct; }
     701       64216 :   bool isVirtual() const { return getFlags() & FlagVirtual; }
     702      551827 :   bool isArtificial() const { return getFlags() & FlagArtificial; }
     703      236190 :   bool isObjectPointer() const { return getFlags() & FlagObjectPointer; }
     704             :   bool isObjcClassComplete() const {
     705       35437 :     return getFlags() & FlagObjcClassComplete;
     706             :   }
     707        3110 :   bool isVector() const { return getFlags() & FlagVector; }
     708         102 :   bool isBitField() const { return getFlags() & FlagBitField; }
     709       61776 :   bool isStaticMember() const { return getFlags() & FlagStaticMember; }
     710        1705 :   bool isLValueReference() const { return getFlags() & FlagLValueReference; }
     711        1705 :   bool isRValueReference() const { return getFlags() & FlagRValueReference; }
     712       35437 :   bool isTypePassByValue() const { return getFlags() & FlagTypePassByValue; }
     713             :   bool isTypePassByReference() const {
     714             :     return getFlags() & FlagTypePassByReference;
     715             :   }
     716             : 
     717             :   static bool classof(const Metadata *MD) {
     718     3652596 :     switch (MD->getMetadataID()) {
     719             :     default:
     720             :       return false;
     721             :     case DIBasicTypeKind:
     722             :     case DIDerivedTypeKind:
     723             :     case DICompositeTypeKind:
     724             :     case DISubroutineTypeKind:
     725             :       return true;
     726             :     }
     727             :   }
     728             : };
     729             : 
     730             : /// Basic type, like 'int' or 'float'.
     731             : ///
     732             : /// TODO: Split out DW_TAG_unspecified_type.
     733             : /// TODO: Drop unused accessors.
     734             : class DIBasicType : public DIType {
     735             :   friend class LLVMContextImpl;
     736             :   friend class MDNode;
     737             : 
     738             :   unsigned Encoding;
     739             : 
     740             :   DIBasicType(LLVMContext &C, StorageType Storage, unsigned Tag,
     741             :               uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding,
     742             :               ArrayRef<Metadata *> Ops)
     743       11852 :       : DIType(C, DIBasicTypeKind, Storage, Tag, 0, SizeInBits, AlignInBits, 0,
     744             :                FlagZero, Ops),
     745       11852 :         Encoding(Encoding) {}
     746        2370 :   ~DIBasicType() = default;
     747             : 
     748       10573 :   static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
     749             :                               StringRef Name, uint64_t SizeInBits,
     750             :                               uint32_t AlignInBits, unsigned Encoding,
     751             :                               StorageType Storage, bool ShouldCreate = true) {
     752       10573 :     return getImpl(Context, Tag, getCanonicalMDString(Context, Name),
     753       10573 :                    SizeInBits, AlignInBits, Encoding, Storage, ShouldCreate);
     754             :   }
     755             :   static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
     756             :                               MDString *Name, uint64_t SizeInBits,
     757             :                               uint32_t AlignInBits, unsigned Encoding,
     758             :                               StorageType Storage, bool ShouldCreate = true);
     759             : 
     760           2 :   TempDIBasicType cloneImpl() const {
     761             :     return getTemporary(getContext(), getTag(), getName(), getSizeInBits(),
     762           6 :                         getAlignInBits(), getEncoding());
     763             :   }
     764             : 
     765             : public:
     766         387 :   DEFINE_MDNODE_GET(DIBasicType, (unsigned Tag, StringRef Name),
     767             :                     (Tag, Name, 0, 0, 0))
     768       10186 :   DEFINE_MDNODE_GET(DIBasicType,
     769             :                     (unsigned Tag, StringRef Name, uint64_t SizeInBits,
     770             :                      uint32_t AlignInBits, unsigned Encoding),
     771             :                     (Tag, Name, SizeInBits, AlignInBits, Encoding))
     772        1665 :   DEFINE_MDNODE_GET(DIBasicType,
     773             :                     (unsigned Tag, MDString *Name, uint64_t SizeInBits,
     774             :                      uint32_t AlignInBits, unsigned Encoding),
     775             :                     (Tag, Name, SizeInBits, AlignInBits, Encoding))
     776             : 
     777           1 :   TempDIBasicType clone() const { return cloneImpl(); }
     778             : 
     779             :   unsigned getEncoding() const { return Encoding; }
     780             : 
     781             :   enum class Signedness { Signed, Unsigned };
     782             : 
     783             :   /// Return the signedness of this type, or None if this type is neither
     784             :   /// signed nor unsigned.
     785             :   Optional<Signedness> getSignedness() const;
     786             : 
     787             :   static bool classof(const Metadata *MD) {
     788      226038 :     return MD->getMetadataID() == DIBasicTypeKind;
     789             :   }
     790             : };
     791             : 
     792             : /// Derived types.
     793             : ///
     794             : /// This includes qualified types, pointers, references, friends, typedefs, and
     795             : /// class members.
     796             : ///
     797             : /// TODO: Split out members (inheritance, fields, methods, etc.).
     798             : class DIDerivedType : public DIType {
     799             :   friend class LLVMContextImpl;
     800             :   friend class MDNode;
     801             : 
     802             :   /// The DWARF address space of the memory pointed to or referenced by a
     803             :   /// pointer or reference type respectively.
     804             :   Optional<unsigned> DWARFAddressSpace;
     805             : 
     806             :   DIDerivedType(LLVMContext &C, StorageType Storage, unsigned Tag,
     807             :                 unsigned Line, uint64_t SizeInBits, uint32_t AlignInBits,
     808             :                 uint64_t OffsetInBits, Optional<unsigned> DWARFAddressSpace,
     809             :                 DIFlags Flags, ArrayRef<Metadata *> Ops)
     810      410341 :       : DIType(C, DIDerivedTypeKind, Storage, Tag, Line, SizeInBits,
     811             :                AlignInBits, OffsetInBits, Flags, Ops),
     812             :         DWARFAddressSpace(DWARFAddressSpace) {}
     813      162195 :   ~DIDerivedType() = default;
     814             : 
     815      549626 :   static DIDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
     816             :                                 StringRef Name, DIFile *File, unsigned Line,
     817             :                                 DIScopeRef Scope, DITypeRef BaseType,
     818             :                                 uint64_t SizeInBits, uint32_t AlignInBits,
     819             :                                 uint64_t OffsetInBits,
     820             :                                 Optional<unsigned> DWARFAddressSpace,
     821             :                                 DIFlags Flags, Metadata *ExtraData,
     822             :                                 StorageType Storage, bool ShouldCreate = true) {
     823     1099252 :     return getImpl(Context, Tag, getCanonicalMDString(Context, Name), File,
     824             :                    Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits,
     825     1099252 :                    DWARFAddressSpace, Flags, ExtraData, Storage, ShouldCreate);
     826             :   }
     827             :   static DIDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
     828             :                                 MDString *Name, Metadata *File, unsigned Line,
     829             :                                 Metadata *Scope, Metadata *BaseType,
     830             :                                 uint64_t SizeInBits, uint32_t AlignInBits,
     831             :                                 uint64_t OffsetInBits,
     832             :                                 Optional<unsigned> DWARFAddressSpace,
     833             :                                 DIFlags Flags, Metadata *ExtraData,
     834             :                                 StorageType Storage, bool ShouldCreate = true);
     835             : 
     836      177627 :   TempDIDerivedType cloneImpl() const {
     837             :     return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
     838             :                         getScope(), getBaseType(), getSizeInBits(),
     839             :                         getAlignInBits(), getOffsetInBits(),
     840      888135 :                         getDWARFAddressSpace(), getFlags(), getExtraData());
     841             :   }
     842             : 
     843             : public:
     844        2249 :   DEFINE_MDNODE_GET(DIDerivedType,
     845             :                     (unsigned Tag, MDString *Name, Metadata *File,
     846             :                      unsigned Line, Metadata *Scope, Metadata *BaseType,
     847             :                      uint64_t SizeInBits, uint32_t AlignInBits,
     848             :                      uint64_t OffsetInBits,
     849             :                      Optional<unsigned> DWARFAddressSpace, DIFlags Flags,
     850             :                      Metadata *ExtraData = nullptr),
     851             :                     (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
     852             :                      AlignInBits, OffsetInBits, DWARFAddressSpace, Flags,
     853             :                      ExtraData))
     854      904880 :   DEFINE_MDNODE_GET(DIDerivedType,
     855             :                     (unsigned Tag, StringRef Name, DIFile *File, unsigned Line,
     856             :                      DIScopeRef Scope, DITypeRef BaseType, uint64_t SizeInBits,
     857             :                      uint32_t AlignInBits, uint64_t OffsetInBits,
     858             :                      Optional<unsigned> DWARFAddressSpace, DIFlags Flags,
     859             :                      Metadata *ExtraData = nullptr),
     860             :                     (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
     861             :                      AlignInBits, OffsetInBits, DWARFAddressSpace, Flags,
     862             :                      ExtraData))
     863             : 
     864           1 :   TempDIDerivedType clone() const { return cloneImpl(); }
     865             : 
     866             :   /// Get the base type this is derived from.
     867             :   DITypeRef getBaseType() const { return DITypeRef(getRawBaseType()); }
     868     1517396 :   Metadata *getRawBaseType() const { return getOperand(3); }
     869             : 
     870             :   /// \returns The DWARF address space of the memory pointed to or referenced by
     871             :   /// a pointer or reference type respectively.
     872             :   Optional<unsigned> getDWARFAddressSpace() const { return DWARFAddressSpace; }
     873             : 
     874             :   /// Get extra data associated with this derived type.
     875             :   ///
     876             :   /// Class type for pointer-to-members, objective-c property node for ivars,
     877             :   /// global constant wrapper for static members, or virtual base pointer offset
     878             :   /// for inheritance.
     879             :   ///
     880             :   /// TODO: Separate out types that need this extra operand: pointer-to-member
     881             :   /// types and member fields (static members and ivars).
     882             :   Metadata *getExtraData() const { return getRawExtraData(); }
     883      177809 :   Metadata *getRawExtraData() const { return getOperand(4); }
     884             : 
     885             :   /// Get casted version of extra data.
     886             :   /// @{
     887             :   DITypeRef getClassType() const {
     888             :     assert(getTag() == dwarf::DW_TAG_ptr_to_member_type);
     889             :     return DITypeRef(getExtraData());
     890             :   }
     891             : 
     892             :   DIObjCProperty *getObjCProperty() const {
     893             :     return dyn_cast_or_null<DIObjCProperty>(getExtraData());
     894             :   }
     895             : 
     896           9 :   uint32_t getVBPtrOffset() const {
     897             :     assert(getTag() == dwarf::DW_TAG_inheritance);
     898             :     if (auto *CM = cast_or_null<ConstantAsMetadata>(getExtraData()))
     899             :       if (auto *CI = dyn_cast_or_null<ConstantInt>(CM->getValue()))
     900           3 :         return static_cast<uint32_t>(CI->getZExtValue());
     901             :     return 0;
     902             :   }
     903             : 
     904             :   Constant *getStorageOffsetInBits() const {
     905             :     assert(getTag() == dwarf::DW_TAG_member && isBitField());
     906             :     if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
     907             :       return C->getValue();
     908             :     return nullptr;
     909             :   }
     910             : 
     911             :   Constant *getConstant() const {
     912             :     assert(getTag() == dwarf::DW_TAG_member && isStaticMember());
     913             :     if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
     914             :       return C->getValue();
     915             :     return nullptr;
     916             :   }
     917             :   Constant *getDiscriminantValue() const {
     918             :     assert(getTag() == dwarf::DW_TAG_member && !isStaticMember());
     919             :     if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
     920             :       return C->getValue();
     921             :     return nullptr;
     922             :   }
     923             :   /// @}
     924             : 
     925             :   static bool classof(const Metadata *MD) {
     926      117968 :     return MD->getMetadataID() == DIDerivedTypeKind;
     927             :   }
     928             : };
     929             : 
     930             : /// Composite types.
     931             : ///
     932             : /// TODO: Detach from DerivedTypeBase (split out MDEnumType?).
     933             : /// TODO: Create a custom, unrelated node for DW_TAG_array_type.
     934             : class DICompositeType : public DIType {
     935             :   friend class LLVMContextImpl;
     936             :   friend class MDNode;
     937             : 
     938             :   unsigned RuntimeLang;
     939             : 
     940             :   DICompositeType(LLVMContext &C, StorageType Storage, unsigned Tag,
     941             :                   unsigned Line, unsigned RuntimeLang, uint64_t SizeInBits,
     942             :                   uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
     943             :                   ArrayRef<Metadata *> Ops)
     944       43528 :       : DIType(C, DICompositeTypeKind, Storage, Tag, Line, SizeInBits,
     945             :                AlignInBits, OffsetInBits, Flags, Ops),
     946       43528 :         RuntimeLang(RuntimeLang) {}
     947        3916 :   ~DICompositeType() = default;
     948             : 
     949             :   /// Change fields in place.
     950             :   void mutate(unsigned Tag, unsigned Line, unsigned RuntimeLang,
     951             :               uint64_t SizeInBits, uint32_t AlignInBits,
     952             :               uint64_t OffsetInBits, DIFlags Flags) {
     953             :     assert(isDistinct() && "Only distinct nodes can mutate");
     954             :     assert(getRawIdentifier() && "Only ODR-uniqued nodes should mutate");
     955           5 :     this->RuntimeLang = RuntimeLang;
     956             :     DIType::mutate(Tag, Line, SizeInBits, AlignInBits, OffsetInBits, Flags);
     957             :   }
     958             : 
     959             :   static DICompositeType *
     960       42451 :   getImpl(LLVMContext &Context, unsigned Tag, StringRef Name, Metadata *File,
     961             :           unsigned Line, DIScopeRef Scope, DITypeRef BaseType,
     962             :           uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
     963             :           DIFlags Flags, DINodeArray Elements, unsigned RuntimeLang,
     964             :           DITypeRef VTableHolder, DITemplateParameterArray TemplateParams,
     965             :           StringRef Identifier, DIDerivedType *Discriminator,
     966             :           StorageType Storage, bool ShouldCreate = true) {
     967       42451 :     return getImpl(
     968             :         Context, Tag, getCanonicalMDString(Context, Name), File, Line, Scope,
     969             :         BaseType, SizeInBits, AlignInBits, OffsetInBits, Flags, Elements.get(),
     970             :         RuntimeLang, VTableHolder, TemplateParams.get(),
     971       42451 :         getCanonicalMDString(Context, Identifier), Discriminator, Storage, ShouldCreate);
     972             :   }
     973             :   static DICompositeType *
     974             :   getImpl(LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
     975             :           unsigned Line, Metadata *Scope, Metadata *BaseType,
     976             :           uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
     977             :           DIFlags Flags, Metadata *Elements, unsigned RuntimeLang,
     978             :           Metadata *VTableHolder, Metadata *TemplateParams,
     979             :           MDString *Identifier, Metadata *Discriminator,
     980             :           StorageType Storage, bool ShouldCreate = true);
     981             : 
     982           3 :   TempDICompositeType cloneImpl() const {
     983             :     return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
     984             :                         getScope(), getBaseType(), getSizeInBits(),
     985             :                         getAlignInBits(), getOffsetInBits(), getFlags(),
     986             :                         getElements(), getRuntimeLang(), getVTableHolder(),
     987          15 :                         getTemplateParams(), getIdentifier(), getDiscriminator());
     988             :   }
     989             : 
     990             : public:
     991       42451 :   DEFINE_MDNODE_GET(DICompositeType,
     992             :                     (unsigned Tag, StringRef Name, DIFile *File, unsigned Line,
     993             :                      DIScopeRef Scope, DITypeRef BaseType, uint64_t SizeInBits,
     994             :                      uint32_t AlignInBits, uint64_t OffsetInBits,
     995             :                      DIFlags Flags, DINodeArray Elements, unsigned RuntimeLang,
     996             :                      DITypeRef VTableHolder,
     997             :                      DITemplateParameterArray TemplateParams = nullptr,
     998             :                      StringRef Identifier = "", DIDerivedType *Discriminator = nullptr),
     999             :                     (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
    1000             :                      AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
    1001             :                      VTableHolder, TemplateParams, Identifier, Discriminator))
    1002        1178 :   DEFINE_MDNODE_GET(DICompositeType,
    1003             :                     (unsigned Tag, MDString *Name, Metadata *File,
    1004             :                      unsigned Line, Metadata *Scope, Metadata *BaseType,
    1005             :                      uint64_t SizeInBits, uint32_t AlignInBits,
    1006             :                      uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
    1007             :                      unsigned RuntimeLang, Metadata *VTableHolder,
    1008             :                      Metadata *TemplateParams = nullptr,
    1009             :                      MDString *Identifier = nullptr,
    1010             :                      Metadata *Discriminator = nullptr),
    1011             :                     (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
    1012             :                      AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
    1013             :                      VTableHolder, TemplateParams, Identifier, Discriminator))
    1014             : 
    1015           1 :   TempDICompositeType clone() const { return cloneImpl(); }
    1016             : 
    1017             :   /// Get a DICompositeType with the given ODR identifier.
    1018             :   ///
    1019             :   /// If \a LLVMContext::isODRUniquingDebugTypes(), gets the mapped
    1020             :   /// DICompositeType for the given ODR \c Identifier.  If none exists, creates
    1021             :   /// a new node.
    1022             :   ///
    1023             :   /// Else, returns \c nullptr.
    1024             :   static DICompositeType *
    1025             :   getODRType(LLVMContext &Context, MDString &Identifier, unsigned Tag,
    1026             :              MDString *Name, Metadata *File, unsigned Line, Metadata *Scope,
    1027             :              Metadata *BaseType, uint64_t SizeInBits, uint32_t AlignInBits,
    1028             :              uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
    1029             :              unsigned RuntimeLang, Metadata *VTableHolder,
    1030             :              Metadata *TemplateParams, Metadata *Discriminator);
    1031             :   static DICompositeType *getODRTypeIfExists(LLVMContext &Context,
    1032             :                                              MDString &Identifier);
    1033             : 
    1034             :   /// Build a DICompositeType with the given ODR identifier.
    1035             :   ///
    1036             :   /// Looks up the mapped DICompositeType for the given ODR \c Identifier.  If
    1037             :   /// it doesn't exist, creates a new one.  If it does exist and \a
    1038             :   /// isForwardDecl(), and the new arguments would be a definition, mutates the
    1039             :   /// the type in place.  In either case, returns the type.
    1040             :   ///
    1041             :   /// If not \a LLVMContext::isODRUniquingDebugTypes(), this function returns
    1042             :   /// nullptr.
    1043             :   static DICompositeType *
    1044             :   buildODRType(LLVMContext &Context, MDString &Identifier, unsigned Tag,
    1045             :                MDString *Name, Metadata *File, unsigned Line, Metadata *Scope,
    1046             :                Metadata *BaseType, uint64_t SizeInBits, uint32_t AlignInBits,
    1047             :                uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
    1048             :                unsigned RuntimeLang, Metadata *VTableHolder,
    1049             :                Metadata *TemplateParams, Metadata *Discriminator);
    1050             : 
    1051             :   DITypeRef getBaseType() const { return DITypeRef(getRawBaseType()); }
    1052             :   DINodeArray getElements() const {
    1053             :     return cast_or_null<MDTuple>(getRawElements());
    1054             :   }
    1055             :   DITypeRef getVTableHolder() const { return DITypeRef(getRawVTableHolder()); }
    1056             :   DITemplateParameterArray getTemplateParams() const {
    1057             :     return cast_or_null<MDTuple>(getRawTemplateParams());
    1058             :   }
    1059        2039 :   StringRef getIdentifier() const { return getStringOperand(7); }
    1060             :   unsigned getRuntimeLang() const { return RuntimeLang; }
    1061             : 
    1062       34948 :   Metadata *getRawBaseType() const { return getOperand(3); }
    1063       37042 :   Metadata *getRawElements() const { return getOperand(4); }
    1064           1 :   Metadata *getRawVTableHolder() const { return getOperand(5); }
    1065           4 :   Metadata *getRawTemplateParams() const { return getOperand(6); }
    1066             :   MDString *getRawIdentifier() const { return getOperandAs<MDString>(7); }
    1067             :   Metadata *getRawDiscriminator() const { return getOperand(8); }
    1068             :   DIDerivedType *getDiscriminator() const { return getOperandAs<DIDerivedType>(8); }
    1069             : 
    1070             :   /// Replace operands.
    1071             :   ///
    1072             :   /// If this \a isUniqued() and not \a isResolved(), on a uniquing collision
    1073             :   /// this will be RAUW'ed and deleted.  Use a \a TrackingMDRef to keep track
    1074             :   /// of its movement if necessary.
    1075             :   /// @{
    1076             :   void replaceElements(DINodeArray Elements) {
    1077             : #ifndef NDEBUG
    1078             :     for (DINode *Op : getElements())
    1079             :       assert(is_contained(Elements->operands(), Op) &&
    1080             :              "Lost a member during member list replacement");
    1081             : #endif
    1082       31942 :     replaceOperandWith(4, Elements.get());
    1083             :   }
    1084             : 
    1085             :   void replaceVTableHolder(DITypeRef VTableHolder) {
    1086       31273 :     replaceOperandWith(5, VTableHolder);
    1087             :   }
    1088             : 
    1089             :   void replaceTemplateParams(DITemplateParameterArray TemplateParams) {
    1090       19511 :     replaceOperandWith(6, TemplateParams.get());
    1091             :   }
    1092             :   /// @}
    1093             : 
    1094             :   static bool classof(const Metadata *MD) {
    1095      135553 :     return MD->getMetadataID() == DICompositeTypeKind;
    1096             :   }
    1097             : };
    1098             : 
    1099             : /// Type array for a subprogram.
    1100             : ///
    1101             : /// TODO: Fold the array of types in directly as operands.
    1102             : class DISubroutineType : public DIType {
    1103             :   friend class LLVMContextImpl;
    1104             :   friend class MDNode;
    1105             : 
    1106             :   /// The calling convention used with DW_AT_calling_convention. Actually of
    1107             :   /// type dwarf::CallingConvention.
    1108             :   uint8_t CC;
    1109             : 
    1110      283875 :   DISubroutineType(LLVMContext &C, StorageType Storage, DIFlags Flags,
    1111             :                    uint8_t CC, ArrayRef<Metadata *> Ops)
    1112      283875 :       : DIType(C, DISubroutineTypeKind, Storage, dwarf::DW_TAG_subroutine_type,
    1113             :                0, 0, 0, 0, Flags, Ops),
    1114      283875 :         CC(CC) {}
    1115        3971 :   ~DISubroutineType() = default;
    1116             : 
    1117             :   static DISubroutineType *getImpl(LLVMContext &Context, DIFlags Flags,
    1118             :                                    uint8_t CC, DITypeRefArray TypeArray,
    1119             :                                    StorageType Storage,
    1120             :                                    bool ShouldCreate = true) {
    1121      380799 :     return getImpl(Context, Flags, CC, TypeArray.get(), Storage, ShouldCreate);
    1122             :   }
    1123             :   static DISubroutineType *getImpl(LLVMContext &Context, DIFlags Flags,
    1124             :                                    uint8_t CC, Metadata *TypeArray,
    1125             :                                    StorageType Storage,
    1126             :                                    bool ShouldCreate = true);
    1127             : 
    1128           5 :   TempDISubroutineType cloneImpl() const {
    1129          10 :     return getTemporary(getContext(), getFlags(), getCC(), getTypeArray());
    1130             :   }
    1131             : 
    1132             : public:
    1133             :   DEFINE_MDNODE_GET(DISubroutineType,
    1134             :                     (DIFlags Flags, uint8_t CC, DITypeRefArray TypeArray),
    1135             :                     (Flags, CC, TypeArray))
    1136        2163 :   DEFINE_MDNODE_GET(DISubroutineType,
    1137             :                     (DIFlags Flags, uint8_t CC, Metadata *TypeArray),
    1138             :                     (Flags, CC, TypeArray))
    1139             : 
    1140           1 :   TempDISubroutineType clone() const { return cloneImpl(); }
    1141             : 
    1142             :   uint8_t getCC() const { return CC; }
    1143             : 
    1144             :   DITypeRefArray getTypeArray() const {
    1145             :     return cast_or_null<MDTuple>(getRawTypeArray());
    1146             :   }
    1147             : 
    1148     1790513 :   Metadata *getRawTypeArray() const { return getOperand(3); }
    1149             : 
    1150             :   static bool classof(const Metadata *MD) {
    1151         141 :     return MD->getMetadataID() == DISubroutineTypeKind;
    1152             :   }
    1153             : };
    1154             : 
    1155             : /// Compile unit.
    1156             : class DICompileUnit : public DIScope {
    1157             :   friend class LLVMContextImpl;
    1158             :   friend class MDNode;
    1159             : 
    1160             : public:
    1161             :   enum DebugEmissionKind : unsigned {
    1162             :     NoDebug = 0,
    1163             :     FullDebug,
    1164             :     LineTablesOnly,
    1165             :     LastEmissionKind = LineTablesOnly
    1166             :   };
    1167             : 
    1168             :   static Optional<DebugEmissionKind> getEmissionKind(StringRef Str);
    1169             :   static const char *emissionKindString(DebugEmissionKind EK);
    1170             : 
    1171             : private:
    1172             :   unsigned SourceLanguage;
    1173             :   bool IsOptimized;
    1174             :   unsigned RuntimeVersion;
    1175             :   unsigned EmissionKind;
    1176             :   uint64_t DWOId;
    1177             :   bool SplitDebugInlining;
    1178             :   bool DebugInfoForProfiling;
    1179             :   bool GnuPubnames;
    1180             : 
    1181             :   DICompileUnit(LLVMContext &C, StorageType Storage, unsigned SourceLanguage,
    1182             :                 bool IsOptimized, unsigned RuntimeVersion,
    1183             :                 unsigned EmissionKind, uint64_t DWOId, bool SplitDebugInlining,
    1184             :                 bool DebugInfoForProfiling, bool GnuPubnames, ArrayRef<Metadata *> Ops)
    1185        5277 :       : DIScope(C, DICompileUnitKind, Storage, dwarf::DW_TAG_compile_unit, Ops),
    1186             :         SourceLanguage(SourceLanguage), IsOptimized(IsOptimized),
    1187             :         RuntimeVersion(RuntimeVersion), EmissionKind(EmissionKind),
    1188             :         DWOId(DWOId), SplitDebugInlining(SplitDebugInlining),
    1189        5277 :         DebugInfoForProfiling(DebugInfoForProfiling), GnuPubnames(GnuPubnames) {
    1190             :     assert(Storage != Uniqued);
    1191             :   }
    1192        3672 :   ~DICompileUnit() = default;
    1193             : 
    1194             :   static DICompileUnit *
    1195        2931 :   getImpl(LLVMContext &Context, unsigned SourceLanguage, DIFile *File,
    1196             :           StringRef Producer, bool IsOptimized, StringRef Flags,
    1197             :           unsigned RuntimeVersion, StringRef SplitDebugFilename,
    1198             :           unsigned EmissionKind, DICompositeTypeArray EnumTypes,
    1199             :           DIScopeArray RetainedTypes,
    1200             :           DIGlobalVariableExpressionArray GlobalVariables,
    1201             :           DIImportedEntityArray ImportedEntities, DIMacroNodeArray Macros,
    1202             :           uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
    1203             :           bool GnuPubnames, StorageType Storage, bool ShouldCreate = true) {
    1204        5862 :     return getImpl(
    1205             :         Context, SourceLanguage, File, getCanonicalMDString(Context, Producer),
    1206             :         IsOptimized, getCanonicalMDString(Context, Flags), RuntimeVersion,
    1207             :         getCanonicalMDString(Context, SplitDebugFilename), EmissionKind,
    1208             :         EnumTypes.get(), RetainedTypes.get(), GlobalVariables.get(),
    1209             :         ImportedEntities.get(), Macros.get(), DWOId, SplitDebugInlining,
    1210        2931 :         DebugInfoForProfiling, GnuPubnames, Storage, ShouldCreate);
    1211             :   }
    1212             :   static DICompileUnit *
    1213             :   getImpl(LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
    1214             :           MDString *Producer, bool IsOptimized, MDString *Flags,
    1215             :           unsigned RuntimeVersion, MDString *SplitDebugFilename,
    1216             :           unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
    1217             :           Metadata *GlobalVariables, Metadata *ImportedEntities,
    1218             :           Metadata *Macros, uint64_t DWOId, bool SplitDebugInlining,
    1219             :           bool DebugInfoForProfiling, bool GnuPubnames, StorageType Storage,
    1220             :           bool ShouldCreate = true);
    1221             : 
    1222         117 :   TempDICompileUnit cloneImpl() const {
    1223             :     return getTemporary(getContext(), getSourceLanguage(), getFile(),
    1224         117 :                         getProducer(), isOptimized(), getFlags(),
    1225             :                         getRuntimeVersion(), getSplitDebugFilename(),
    1226             :                         getEmissionKind(), getEnumTypes(), getRetainedTypes(),
    1227             :                         getGlobalVariables(), getImportedEntities(),
    1228         234 :                         getMacros(), DWOId, getSplitDebugInlining(),
    1229         819 :                         getDebugInfoForProfiling(), getGnuPubnames());
    1230             :   }
    1231             : 
    1232             : public:
    1233             :   static void get() = delete;
    1234             :   static void getIfExists() = delete;
    1235             : 
    1236        2931 :   DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(
    1237             :       DICompileUnit,
    1238             :       (unsigned SourceLanguage, DIFile *File, StringRef Producer,
    1239             :        bool IsOptimized, StringRef Flags, unsigned RuntimeVersion,
    1240             :        StringRef SplitDebugFilename, DebugEmissionKind EmissionKind,
    1241             :        DICompositeTypeArray EnumTypes, DIScopeArray RetainedTypes,
    1242             :        DIGlobalVariableExpressionArray GlobalVariables,
    1243             :        DIImportedEntityArray ImportedEntities, DIMacroNodeArray Macros,
    1244             :        uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
    1245             :        bool GnuPubnames),
    1246             :       (SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion,
    1247             :        SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
    1248             :        GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining,
    1249             :        DebugInfoForProfiling, GnuPubnames))
    1250        2346 :   DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(
    1251             :       DICompileUnit,
    1252             :       (unsigned SourceLanguage, Metadata *File, MDString *Producer,
    1253             :        bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
    1254             :        MDString *SplitDebugFilename, unsigned EmissionKind, Metadata *EnumTypes,
    1255             :        Metadata *RetainedTypes, Metadata *GlobalVariables,
    1256             :        Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId,
    1257             :        bool SplitDebugInlining, bool DebugInfoForProfiling, bool GnuPubnames),
    1258             :       (SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion,
    1259             :        SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
    1260             :        GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining,
    1261             :        DebugInfoForProfiling, GnuPubnames))
    1262             : 
    1263           1 :   TempDICompileUnit clone() const { return cloneImpl(); }
    1264             : 
    1265             :   unsigned getSourceLanguage() const { return SourceLanguage; }
    1266             :   bool isOptimized() const { return IsOptimized; }
    1267             :   unsigned getRuntimeVersion() const { return RuntimeVersion; }
    1268             :   DebugEmissionKind getEmissionKind() const {
    1269             :     return (DebugEmissionKind)EmissionKind;
    1270             :   }
    1271             :   bool getDebugInfoForProfiling() const { return DebugInfoForProfiling; }
    1272             :   bool getGnuPubnames() const { return GnuPubnames; }
    1273        3973 :   StringRef getProducer() const { return getStringOperand(1); }
    1274        4050 :   StringRef getFlags() const { return getStringOperand(2); }
    1275        1281 :   StringRef getSplitDebugFilename() const { return getStringOperand(3); }
    1276             :   DICompositeTypeArray getEnumTypes() const {
    1277             :     return cast_or_null<MDTuple>(getRawEnumTypes());
    1278             :   }
    1279             :   DIScopeArray getRetainedTypes() const {
    1280             :     return cast_or_null<MDTuple>(getRawRetainedTypes());
    1281             :   }
    1282             :   DIGlobalVariableExpressionArray getGlobalVariables() const {
    1283             :     return cast_or_null<MDTuple>(getRawGlobalVariables());
    1284             :   }
    1285             :   DIImportedEntityArray getImportedEntities() const {
    1286             :     return cast_or_null<MDTuple>(getRawImportedEntities());
    1287             :   }
    1288             :   DIMacroNodeArray getMacros() const {
    1289             :     return cast_or_null<MDTuple>(getRawMacros());
    1290             :   }
    1291             :   uint64_t getDWOId() const { return DWOId; }
    1292          23 :   void setDWOId(uint64_t DwoId) { DWOId = DwoId; }
    1293             :   bool getSplitDebugInlining() const { return SplitDebugInlining; }
    1294             :   void setSplitDebugInlining(bool SplitDebugInlining) {
    1295             :     this->SplitDebugInlining = SplitDebugInlining;
    1296             :   }
    1297             : 
    1298             :   MDString *getRawProducer() const { return getOperandAs<MDString>(1); }
    1299             :   MDString *getRawFlags() const { return getOperandAs<MDString>(2); }
    1300             :   MDString *getRawSplitDebugFilename() const {
    1301             :     return getOperandAs<MDString>(3);
    1302             :   }
    1303       10219 :   Metadata *getRawEnumTypes() const { return getOperand(4); }
    1304         124 :   Metadata *getRawRetainedTypes() const { return getOperand(5); }
    1305         216 :   Metadata *getRawGlobalVariables() const { return getOperand(6); }
    1306        5215 :   Metadata *getRawImportedEntities() const { return getOperand(7); }
    1307        5295 :   Metadata *getRawMacros() const { return getOperand(8); }
    1308             : 
    1309             :   /// Replace arrays.
    1310             :   ///
    1311             :   /// If this \a isUniqued() and not \a isResolved(), it will be RAUW'ed and
    1312             :   /// deleted on a uniquing collision.  In practice, uniquing collisions on \a
    1313             :   /// DICompileUnit should be fairly rare.
    1314             :   /// @{
    1315             :   void replaceEnumTypes(DICompositeTypeArray N) {
    1316        2796 :     replaceOperandWith(4, N.get());
    1317             :   }
    1318             :   void replaceRetainedTypes(DITypeArray N) {
    1319         472 :     replaceOperandWith(5, N.get());
    1320             :   }
    1321             :   void replaceGlobalVariables(DIGlobalVariableExpressionArray N) {
    1322         758 :     replaceOperandWith(6, N.get());
    1323             :   }
    1324             :   void replaceImportedEntities(DIImportedEntityArray N) {
    1325         606 :     replaceOperandWith(7, N.get());
    1326             :   }
    1327           7 :   void replaceMacros(DIMacroNodeArray N) { replaceOperandWith(8, N.get()); }
    1328             :   /// @}
    1329             : 
    1330             :   static bool classof(const Metadata *MD) {
    1331      551595 :     return MD->getMetadataID() == DICompileUnitKind;
    1332             :   }
    1333             : };
    1334             : 
    1335             : /// A scope for locals.
    1336             : ///
    1337             : /// A legal scope for lexical blocks, local variables, and debug info
    1338             : /// locations.  Subclasses are \a DISubprogram, \a DILexicalBlock, and \a
    1339             : /// DILexicalBlockFile.
    1340             : class DILocalScope : public DIScope {
    1341             : protected:
    1342             :   DILocalScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
    1343             :                ArrayRef<Metadata *> Ops)
    1344             :       : DIScope(C, ID, Storage, Tag, Ops) {}
    1345             :   ~DILocalScope() = default;
    1346             : 
    1347             : public:
    1348             :   /// Get the subprogram for this scope.
    1349             :   ///
    1350             :   /// Return this if it's an \a DISubprogram; otherwise, look up the scope
    1351             :   /// chain.
    1352             :   DISubprogram *getSubprogram() const;
    1353             : 
    1354             :   /// Get the first non DILexicalBlockFile scope of this scope.
    1355             :   ///
    1356             :   /// Return this if it's not a \a DILexicalBlockFIle; otherwise, look up the
    1357             :   /// scope chain.
    1358             :   DILocalScope *getNonLexicalBlockFileScope() const;
    1359             : 
    1360             :   static bool classof(const Metadata *MD) {
    1361      763649 :     return MD->getMetadataID() == DISubprogramKind ||
    1362      749128 :            MD->getMetadataID() == DILexicalBlockKind ||
    1363             :            MD->getMetadataID() == DILexicalBlockFileKind;
    1364             :   }
    1365             : };
    1366             : 
    1367             : /// Debug location.
    1368             : ///
    1369             : /// A debug location in source code, used for debug info and otherwise.
    1370             : class DILocation : public MDNode {
    1371             :   friend class LLVMContextImpl;
    1372             :   friend class MDNode;
    1373             : 
    1374             :   DILocation(LLVMContext &C, StorageType Storage, unsigned Line,
    1375             :              unsigned Column, ArrayRef<Metadata *> MDs);
    1376       50200 :   ~DILocation() { dropAllReferences(); }
    1377             : 
    1378             :   static DILocation *getImpl(LLVMContext &Context, unsigned Line,
    1379             :                              unsigned Column, Metadata *Scope,
    1380             :                              Metadata *InlinedAt, StorageType Storage,
    1381             :                              bool ShouldCreate = true);
    1382             :   static DILocation *getImpl(LLVMContext &Context, unsigned Line,
    1383             :                              unsigned Column, DILocalScope *Scope,
    1384             :                              DILocation *InlinedAt, StorageType Storage,
    1385             :                              bool ShouldCreate = true) {
    1386             :     return getImpl(Context, Line, Column, static_cast<Metadata *>(Scope),
    1387      172398 :                    static_cast<Metadata *>(InlinedAt), Storage, ShouldCreate);
    1388             :   }
    1389             : 
    1390             :   /// With a given unsigned int \p U, use up to 13 bits to represent it.
    1391             :   /// old_bit 1~5  --> new_bit 1~5
    1392             :   /// old_bit 6~12 --> new_bit 7~13
    1393             :   /// new_bit_6 is 0 if higher bits (7~13) are all 0
    1394             :   static unsigned getPrefixEncodingFromUnsigned(unsigned U) {
    1395         298 :     U &= 0xfff;
    1396         298 :     return U > 0x1f ? (((U & 0xfe0) << 1) | (U & 0x1f) | 0x20) : U;
    1397             :   }
    1398             : 
    1399             :   /// Reverse transformation as getPrefixEncodingFromUnsigned.
    1400             :   static unsigned getUnsignedFromPrefixEncoding(unsigned U) {
    1401        1480 :     return (U & 0x20) ? (((U >> 1) & 0xfe0) | (U & 0x1f)) : (U & 0x1f);
    1402             :   }
    1403             : 
    1404             :   /// Returns the next component stored in discriminator.
    1405             :   static unsigned getNextComponentInDiscriminator(unsigned D) {
    1406         330 :     if ((D & 1) == 0)
    1407         214 :       return D >> ((D & 0x40) ? 14 : 7);
    1408             :     else
    1409         116 :       return D >> 1;
    1410             :   }
    1411             : 
    1412         195 :   TempDILocation cloneImpl() const {
    1413             :     // Get the raw scope/inlinedAt since it is possible to invoke this on
    1414             :     // a DILocation containing temporary metadata.
    1415             :     return getTemporary(getContext(), getLine(), getColumn(), getRawScope(),
    1416         585 :                         getRawInlinedAt());
    1417             :   }
    1418             : 
    1419             : public:
    1420             :   // Disallow replacing operands.
    1421             :   void replaceOperandWith(unsigned I, Metadata *New) = delete;
    1422             : 
    1423     3113723 :   DEFINE_MDNODE_GET(DILocation,
    1424             :                     (unsigned Line, unsigned Column, Metadata *Scope,
    1425             :                      Metadata *InlinedAt = nullptr),
    1426             :                     (Line, Column, Scope, InlinedAt))
    1427             :   DEFINE_MDNODE_GET(DILocation,
    1428             :                     (unsigned Line, unsigned Column, DILocalScope *Scope,
    1429             :                      DILocation *InlinedAt = nullptr),
    1430             :                     (Line, Column, Scope, InlinedAt))
    1431             : 
    1432             :   /// Return a (temporary) clone of this.
    1433           1 :   TempDILocation clone() const { return cloneImpl(); }
    1434             : 
    1435             :   unsigned getLine() const { return SubclassData32; }
    1436     7130609 :   unsigned getColumn() const { return SubclassData16; }
    1437             :   DILocalScope *getScope() const { return cast<DILocalScope>(getRawScope()); }
    1438             : 
    1439             :   DILocation *getInlinedAt() const {
    1440             :     return cast_or_null<DILocation>(getRawInlinedAt());
    1441             :   }
    1442             : 
    1443             :   DIFile *getFile() const { return getScope()->getFile(); }
    1444      186288 :   StringRef getFilename() const { return getScope()->getFilename(); }
    1445       93816 :   StringRef getDirectory() const { return getScope()->getDirectory(); }
    1446             :   Optional<StringRef> getSource() const { return getScope()->getSource(); }
    1447             : 
    1448             :   /// Get the scope where this is inlined.
    1449             :   ///
    1450             :   /// Walk through \a getInlinedAt() and return \a getScope() from the deepest
    1451             :   /// location.
    1452             :   DILocalScope *getInlinedAtScope() const {
    1453             :     if (auto *IA = getInlinedAt())
    1454             :       return IA->getInlinedAtScope();
    1455             :     return getScope();
    1456             :   }
    1457             : 
    1458             :   /// Check whether this can be discriminated from another location.
    1459             :   ///
    1460             :   /// Check \c this can be discriminated from \c RHS in a linetable entry.
    1461             :   /// Scope and inlined-at chains are not recorded in the linetable, so they
    1462             :   /// cannot be used to distinguish basic blocks.
    1463       60163 :   bool canDiscriminate(const DILocation &RHS) const {
    1464      110422 :     return getLine() != RHS.getLine() ||
    1465       97182 :            getColumn() != RHS.getColumn() ||
    1466             :            getDiscriminator() != RHS.getDiscriminator() ||
    1467       60163 :            getFilename() != RHS.getFilename() ||
    1468       60163 :            getDirectory() != RHS.getDirectory();
    1469             :   }
    1470             : 
    1471             :   /// Get the DWARF discriminator.
    1472             :   ///
    1473             :   /// DWARF discriminators distinguish identical file locations between
    1474             :   /// instructions that are on different basic blocks.
    1475             :   ///
    1476             :   /// There are 3 components stored in discriminator, from lower bits:
    1477             :   ///
    1478             :   /// Base discriminator: assigned by AddDiscriminators pass to identify IRs
    1479             :   ///                     that are defined by the same source line, but
    1480             :   ///                     different basic blocks.
    1481             :   /// Duplication factor: assigned by optimizations that will scale down
    1482             :   ///                     the execution frequency of the original IR.
    1483             :   /// Copy Identifier: assigned by optimizations that clones the IR.
    1484             :   ///                  Each copy of the IR will be assigned an identifier.
    1485             :   ///
    1486             :   /// Encoding:
    1487             :   ///
    1488             :   /// The above 3 components are encoded into a 32bit unsigned integer in
    1489             :   /// order. If the lowest bit is 1, the current component is empty, and the
    1490             :   /// next component will start in the next bit. Otherwise, the current
    1491             :   /// component is non-empty, and its content starts in the next bit. The
    1492             :   /// length of each components is either 5 bit or 12 bit: if the 7th bit
    1493             :   /// is 0, the bit 2~6 (5 bits) are used to represent the component; if the
    1494             :   /// 7th bit is 1, the bit 2~6 (5 bits) and 8~14 (7 bits) are combined to
    1495             :   /// represent the component.
    1496             : 
    1497             :   inline unsigned getDiscriminator() const;
    1498             : 
    1499             :   /// Returns a new DILocation with updated \p Discriminator.
    1500             :   inline const DILocation *cloneWithDiscriminator(unsigned Discriminator) const;
    1501             : 
    1502             :   /// Returns a new DILocation with updated base discriminator \p BD.
    1503             :   inline const DILocation *setBaseDiscriminator(unsigned BD) const;
    1504             : 
    1505             :   /// Returns the duplication factor stored in the discriminator.
    1506             :   inline unsigned getDuplicationFactor() const;
    1507             : 
    1508             :   /// Returns the copy identifier stored in the discriminator.
    1509             :   inline unsigned getCopyIdentifier() const;
    1510             : 
    1511             :   /// Returns the base discriminator stored in the discriminator.
    1512             :   inline unsigned getBaseDiscriminator() const;
    1513             : 
    1514             :   /// Returns a new DILocation with duplication factor \p DF encoded in the
    1515             :   /// discriminator.
    1516             :   inline const DILocation *cloneWithDuplicationFactor(unsigned DF) const;
    1517             : 
    1518             :   enum { NoGeneratedLocation = false, WithGeneratedLocation = true };
    1519             : 
    1520             :   /// When two instructions are combined into a single instruction we also
    1521             :   /// need to combine the original locations into a single location.
    1522             :   ///
    1523             :   /// When the locations are the same we can use either location. When they
    1524             :   /// differ, we need a third location which is distinct from either. If they
    1525             :   /// have the same file/line but have a different discriminator we could
    1526             :   /// create a location with a new discriminator. If they are from different
    1527             :   /// files/lines the location is ambiguous and can't be represented in a line
    1528             :   /// entry. In this case, if \p GenerateLocation is true, we will set the
    1529             :   /// merged debug location as line 0 of the nearest common scope where the two
    1530             :   /// locations are inlined from.
    1531             :   ///
    1532             :   /// \p GenerateLocation: Whether the merged location can be generated when
    1533             :   /// \p LocA and \p LocB differ.
    1534             :   static const DILocation *
    1535             :   getMergedLocation(const DILocation *LocA, const DILocation *LocB,
    1536             :                     bool GenerateLocation = NoGeneratedLocation);
    1537             : 
    1538             :   /// Returns the base discriminator for a given encoded discriminator \p D.
    1539             :   static unsigned getBaseDiscriminatorFromDiscriminator(unsigned D) {
    1540        1378 :     if ((D & 1) == 0)
    1541        1312 :       return getUnsignedFromPrefixEncoding(D >> 1);
    1542             :     else
    1543             :       return 0;
    1544             :   }
    1545             : 
    1546             :   /// Returns the duplication factor for a given encoded discriminator \p D.
    1547         110 :   static unsigned getDuplicationFactorFromDiscriminator(unsigned D) {
    1548             :     D = getNextComponentInDiscriminator(D);
    1549         110 :     if (D == 0 || (D & 1))
    1550             :       return 1;
    1551             :     else
    1552          58 :       return getUnsignedFromPrefixEncoding(D >> 1);
    1553             :   }
    1554             : 
    1555             :   /// Returns the copy identifier for a given encoded discriminator \p D.
    1556         110 :   static unsigned getCopyIdentifierFromDiscriminator(unsigned D) {
    1557             :     return getUnsignedFromPrefixEncoding(getNextComponentInDiscriminator(
    1558         110 :         getNextComponentInDiscriminator(D)));
    1559             :   }
    1560             : 
    1561             : 
    1562    10532804 :   Metadata *getRawScope() const { return getOperand(0); }
    1563             :   Metadata *getRawInlinedAt() const {
    1564     9745697 :     if (getNumOperands() == 2)
    1565             :       return getOperand(1);
    1566             :     return nullptr;
    1567             :   }
    1568             : 
    1569             :   static bool classof(const Metadata *MD) {
    1570      200581 :     return MD->getMetadataID() == DILocationKind;
    1571             :   }
    1572             : };
    1573             : 
    1574             : /// Subprogram description.
    1575             : ///
    1576             : /// TODO: Remove DisplayName.  It's always equal to Name.
    1577             : /// TODO: Split up flags.
    1578             : class DISubprogram : public DILocalScope {
    1579             :   friend class LLVMContextImpl;
    1580             :   friend class MDNode;
    1581             : 
    1582             :   unsigned Line;
    1583             :   unsigned ScopeLine;
    1584             :   unsigned VirtualIndex;
    1585             : 
    1586             :   /// In the MS ABI, the implicit 'this' parameter is adjusted in the prologue
    1587             :   /// of method overrides from secondary bases by this amount. It may be
    1588             :   /// negative.
    1589             :   int ThisAdjustment;
    1590             : 
    1591             :   // Virtuality can only assume three values, so we can pack
    1592             :   // in 2 bits (none/pure/pure_virtual).
    1593             :   unsigned Virtuality : 2;
    1594             : 
    1595             :   // These are boolean flags so one bit is enough.
    1596             :   // MSVC starts a new container field every time the base
    1597             :   // type changes so we can't use 'bool' to ensure these bits
    1598             :   // are packed.
    1599             :   unsigned IsLocalToUnit : 1;
    1600             :   unsigned IsDefinition : 1;
    1601             :   unsigned IsOptimized : 1;
    1602             : 
    1603             :   unsigned Padding : 3;
    1604             : 
    1605             :   DIFlags Flags;
    1606             : 
    1607             :   DISubprogram(LLVMContext &C, StorageType Storage, unsigned Line,
    1608             :                unsigned ScopeLine, unsigned Virtuality, unsigned VirtualIndex,
    1609             :                int ThisAdjustment, DIFlags Flags, bool IsLocalToUnit,
    1610             :                bool IsDefinition, bool IsOptimized, ArrayRef<Metadata *> Ops)
    1611      321107 :       : DILocalScope(C, DISubprogramKind, Storage, dwarf::DW_TAG_subprogram,
    1612             :                      Ops),
    1613             :         Line(Line), ScopeLine(ScopeLine), VirtualIndex(VirtualIndex),
    1614             :         ThisAdjustment(ThisAdjustment), Virtuality(Virtuality),
    1615             :         IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition),
    1616      321107 :         IsOptimized(IsOptimized), Flags(Flags) {
    1617             :     static_assert(dwarf::DW_VIRTUALITY_max < 4, "Virtuality out of range");
    1618             :     assert(Virtuality < 4 && "Virtuality out of range");
    1619             :   }
    1620       17580 :   ~DISubprogram() = default;
    1621             : 
    1622             :   static DISubprogram *
    1623      317874 :   getImpl(LLVMContext &Context, DIScopeRef Scope, StringRef Name,
    1624             :           StringRef LinkageName, DIFile *File, unsigned Line,
    1625             :           DISubroutineType *Type, bool IsLocalToUnit, bool IsDefinition,
    1626             :           unsigned ScopeLine, DITypeRef ContainingType, unsigned Virtuality,
    1627             :           unsigned VirtualIndex, int ThisAdjustment, DIFlags Flags,
    1628             :           bool IsOptimized, DICompileUnit *Unit,
    1629             :           DITemplateParameterArray TemplateParams, DISubprogram *Declaration,
    1630             :           DINodeArray RetainedNodes, DITypeArray ThrownTypes,
    1631             :           StorageType Storage, bool ShouldCreate = true) {
    1632      953622 :     return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
    1633             :                    getCanonicalMDString(Context, LinkageName), File, Line, Type,
    1634             :                    IsLocalToUnit, IsDefinition, ScopeLine, ContainingType,
    1635             :                    Virtuality, VirtualIndex, ThisAdjustment, Flags, IsOptimized,
    1636             :                    Unit, TemplateParams.get(), Declaration, RetainedNodes.get(),
    1637      317874 :                    ThrownTypes.get(), Storage, ShouldCreate);
    1638             :   }
    1639             :   static DISubprogram *
    1640             :   getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
    1641             :           MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
    1642             :           bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
    1643             :           Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex,
    1644             :           int ThisAdjustment, DIFlags Flags, bool IsOptimized, Metadata *Unit,
    1645             :           Metadata *TemplateParams, Metadata *Declaration, Metadata *RetainedNodes,
    1646             :           Metadata *ThrownTypes, StorageType Storage, bool ShouldCreate = true);
    1647             : 
    1648          34 :   TempDISubprogram cloneImpl() const {
    1649             :     return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
    1650             :                         getFile(), getLine(), getType(), isLocalToUnit(),
    1651             :                         isDefinition(), getScopeLine(), getContainingType(),
    1652             :                         getVirtuality(), getVirtualIndex(), getThisAdjustment(),
    1653             :                         getFlags(), isOptimized(), getUnit(),
    1654             :                         getTemplateParams(), getDeclaration(), getRetainedNodes(),
    1655         204 :                         getThrownTypes());
    1656             :   }
    1657             : 
    1658             : public:
    1659      317874 :   DEFINE_MDNODE_GET(DISubprogram,
    1660             :                     (DIScopeRef Scope, StringRef Name, StringRef LinkageName,
    1661             :                      DIFile *File, unsigned Line, DISubroutineType *Type,
    1662             :                      bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
    1663             :                      DITypeRef ContainingType, unsigned Virtuality,
    1664             :                      unsigned VirtualIndex, int ThisAdjustment, DIFlags Flags,
    1665             :                      bool IsOptimized, DICompileUnit *Unit,
    1666             :                      DITemplateParameterArray TemplateParams = nullptr,
    1667             :                      DISubprogram *Declaration = nullptr,
    1668             :                      DINodeArray RetainedNodes = nullptr,
    1669             :                      DITypeArray ThrownTypes = nullptr),
    1670             :                     (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
    1671             :                      IsDefinition, ScopeLine, ContainingType, Virtuality,
    1672             :                      VirtualIndex, ThisAdjustment, Flags, IsOptimized, Unit,
    1673             :                      TemplateParams, Declaration, RetainedNodes, ThrownTypes))
    1674        3241 :   DEFINE_MDNODE_GET(
    1675             :       DISubprogram,
    1676             :       (Metadata * Scope, MDString *Name, MDString *LinkageName, Metadata *File,
    1677             :        unsigned Line, Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
    1678             :        unsigned ScopeLine, Metadata *ContainingType, unsigned Virtuality,
    1679             :        unsigned VirtualIndex, int ThisAdjustment, DIFlags Flags,
    1680             :        bool IsOptimized, Metadata *Unit, Metadata *TemplateParams = nullptr,
    1681             :        Metadata *Declaration = nullptr, Metadata *RetainedNodes = nullptr,
    1682             :        Metadata *ThrownTypes = nullptr),
    1683             :       (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition,
    1684             :        ScopeLine, ContainingType, Virtuality, VirtualIndex, ThisAdjustment,
    1685             :        Flags, IsOptimized, Unit, TemplateParams, Declaration, RetainedNodes,
    1686             :        ThrownTypes))
    1687             : 
    1688           3 :   TempDISubprogram clone() const { return cloneImpl(); }
    1689             : 
    1690             :   /// Returns a new temporary DISubprogram with updated Flags
    1691             :   TempDISubprogram cloneWithFlags(DIFlags NewFlags) const {
    1692             :     auto NewSP = clone();
    1693           1 :     NewSP->Flags = NewFlags;
    1694             :     return NewSP;
    1695             :   }
    1696             : 
    1697             : public:
    1698             :   unsigned getLine() const { return Line; }
    1699      929887 :   unsigned getVirtuality() const { return Virtuality; }
    1700             :   unsigned getVirtualIndex() const { return VirtualIndex; }
    1701             :   int getThisAdjustment() const { return ThisAdjustment; }
    1702             :   unsigned getScopeLine() const { return ScopeLine; }
    1703             :   DIFlags getFlags() const { return Flags; }
    1704      925898 :   bool isLocalToUnit() const { return IsLocalToUnit; }
    1705     2812537 :   bool isDefinition() const { return IsDefinition; }
    1706      668894 :   bool isOptimized() const { return IsOptimized; }
    1707             : 
    1708      257348 :   bool isArtificial() const { return getFlags() & FlagArtificial; }
    1709             :   bool isPrivate() const {
    1710             :     return (getFlags() & FlagAccessibility) == FlagPrivate;
    1711             :   }
    1712             :   bool isProtected() const {
    1713      257284 :     return (getFlags() & FlagAccessibility) == FlagProtected;
    1714             :   }
    1715             :   bool isPublic() const {
    1716             :     return (getFlags() & FlagAccessibility) == FlagPublic;
    1717             :   }
    1718      257284 :   bool isExplicit() const { return getFlags() & FlagExplicit; }
    1719      257284 :   bool isPrototyped() const { return getFlags() & FlagPrototyped; }
    1720      257284 :   bool isMainSubprogram() const { return getFlags() & FlagMainSubprogram; }
    1721             : 
    1722             :   /// Check if this is reference-qualified.
    1723             :   ///
    1724             :   /// Return true if this subprogram is a C++11 reference-qualified non-static
    1725             :   /// member function (void foo() &).
    1726      257284 :   bool isLValueReference() const { return getFlags() & FlagLValueReference; }
    1727             : 
    1728             :   /// Check if this is rvalue-reference-qualified.
    1729             :   ///
    1730             :   /// Return true if this subprogram is a C++11 rvalue-reference-qualified
    1731             :   /// non-static member function (void foo() &&).
    1732      257284 :   bool isRValueReference() const { return getFlags() & FlagRValueReference; }
    1733             : 
    1734             :   /// Check if this is marked as noreturn.
    1735             :   ///
    1736             :   /// Return true if this subprogram is C++11 noreturn or C11 _Noreturn
    1737      257284 :   bool isNoReturn() const { return getFlags() & FlagNoReturn; }
    1738             : 
    1739             :   // Check if this routine is a compiler-generated thunk.
    1740             :   //
    1741             :   // Returns true if this subprogram is a thunk generated by the compiler.
    1742         209 :   bool isThunk() const { return getFlags() & FlagThunk; }
    1743             : 
    1744             :   DIScopeRef getScope() const { return DIScopeRef(getRawScope()); }
    1745             : 
    1746     1139628 :   StringRef getName() const { return getStringOperand(2); }
    1747      902296 :   StringRef getLinkageName() const { return getStringOperand(3); }
    1748             : 
    1749             :   DISubroutineType *getType() const {
    1750             :     return cast_or_null<DISubroutineType>(getRawType());
    1751             :   }
    1752             :   DITypeRef getContainingType() const {
    1753             :     return DITypeRef(getRawContainingType());
    1754             :   }
    1755             : 
    1756             :   DICompileUnit *getUnit() const {
    1757             :     return cast_or_null<DICompileUnit>(getRawUnit());
    1758             :   }
    1759           4 :   void replaceUnit(DICompileUnit *CU) { replaceOperandWith(5, CU); }
    1760             :   DITemplateParameterArray getTemplateParams() const {
    1761             :     return cast_or_null<MDTuple>(getRawTemplateParams());
    1762             :   }
    1763             :   DISubprogram *getDeclaration() const {
    1764             :     return cast_or_null<DISubprogram>(getRawDeclaration());
    1765             :   }
    1766             :   DINodeArray getRetainedNodes() const {
    1767             :     return cast_or_null<MDTuple>(getRawRetainedNodes());
    1768             :   }
    1769             :   DITypeArray getThrownTypes() const {
    1770             :     return cast_or_null<MDTuple>(getRawThrownTypes());
    1771             :   }
    1772             : 
    1773     2252409 :   Metadata *getRawScope() const { return getOperand(1); }
    1774             :   MDString *getRawName() const { return getOperandAs<MDString>(2); }
    1775             :   MDString *getRawLinkageName() const { return getOperandAs<MDString>(3); }
    1776      292362 :   Metadata *getRawType() const { return getOperand(4); }
    1777     3759297 :   Metadata *getRawUnit() const { return getOperand(5); }
    1778      613384 :   Metadata *getRawDeclaration() const { return getOperand(6); }
    1779      201816 :   Metadata *getRawRetainedNodes() const { return getOperand(7); }
    1780             :   Metadata *getRawContainingType() const {
    1781      685456 :     return getNumOperands() > 8 ? getOperandAs<Metadata>(8) : nullptr;
    1782             :   }
    1783             :   Metadata *getRawTemplateParams() const {
    1784     1408626 :     return getNumOperands() > 9 ? getOperandAs<Metadata>(9) : nullptr;
    1785             :   }
    1786             :   Metadata *getRawThrownTypes() const {
    1787      939757 :     return getNumOperands() > 10 ? getOperandAs<Metadata>(10) : nullptr;
    1788             :   }
    1789             : 
    1790             :   /// Check if this subprogram describes the given function.
    1791             :   ///
    1792             :   /// FIXME: Should this be looking through bitcasts?
    1793             :   bool describes(const Function *F) const;
    1794             : 
    1795             :   static bool classof(const Metadata *MD) {
    1796      620923 :     return MD->getMetadataID() == DISubprogramKind;
    1797             :   }
    1798             : };
    1799             : 
    1800             : class DILexicalBlockBase : public DILocalScope {
    1801             : protected:
    1802             :   DILexicalBlockBase(LLVMContext &C, unsigned ID, StorageType Storage,
    1803             :                      ArrayRef<Metadata *> Ops)
    1804             :       : DILocalScope(C, ID, Storage, dwarf::DW_TAG_lexical_block, Ops) {}
    1805             :   ~DILexicalBlockBase() = default;
    1806             : 
    1807             : public:
    1808             :   DILocalScope *getScope() const { return cast<DILocalScope>(getRawScope()); }
    1809             : 
    1810      184037 :   Metadata *getRawScope() const { return getOperand(1); }
    1811             : 
    1812             :   static bool classof(const Metadata *MD) {
    1813     4558680 :     return MD->getMetadataID() == DILexicalBlockKind ||
    1814             :            MD->getMetadataID() == DILexicalBlockFileKind;
    1815             :   }
    1816             : };
    1817             : 
    1818             : class DILexicalBlock : public DILexicalBlockBase {
    1819             :   friend class LLVMContextImpl;
    1820             :   friend class MDNode;
    1821             : 
    1822             :   unsigned Line;
    1823             :   uint16_t Column;
    1824             : 
    1825             :   DILexicalBlock(LLVMContext &C, StorageType Storage, unsigned Line,
    1826             :                  unsigned Column, ArrayRef<Metadata *> Ops)
    1827       24466 :       : DILexicalBlockBase(C, DILexicalBlockKind, Storage, Ops), Line(Line),
    1828       24466 :         Column(Column) {
    1829             :     assert(Column < (1u << 16) && "Expected 16-bit column");
    1830             :   }
    1831        1967 :   ~DILexicalBlock() = default;
    1832             : 
    1833             :   static DILexicalBlock *getImpl(LLVMContext &Context, DILocalScope *Scope,
    1834             :                                  DIFile *File, unsigned Line, unsigned Column,
    1835             :                                  StorageType Storage,
    1836             :                                  bool ShouldCreate = true) {
    1837             :     return getImpl(Context, static_cast<Metadata *>(Scope),
    1838             :                    static_cast<Metadata *>(File), Line, Column, Storage,
    1839          36 :                    ShouldCreate);
    1840             :   }
    1841             : 
    1842             :   static DILexicalBlock *getImpl(LLVMContext &Context, Metadata *Scope,
    1843             :                                  Metadata *File, unsigned Line, unsigned Column,
    1844             :                                  StorageType Storage, bool ShouldCreate = true);
    1845             : 
    1846          26 :   TempDILexicalBlock cloneImpl() const {
    1847             :     return getTemporary(getContext(), getScope(), getFile(), getLine(),
    1848          78 :                         getColumn());
    1849             :   }
    1850             : 
    1851             : public:
    1852             :   DEFINE_MDNODE_GET(DILexicalBlock, (DILocalScope * Scope, DIFile *File,
    1853             :                                      unsigned Line, unsigned Column),
    1854             :                     (Scope, File, Line, Column))
    1855       24434 :   DEFINE_MDNODE_GET(DILexicalBlock, (Metadata * Scope, Metadata *File,
    1856             :                                      unsigned Line, unsigned Column),
    1857             :                     (Scope, File, Line, Column))
    1858             : 
    1859           1 :   TempDILexicalBlock clone() const { return cloneImpl(); }
    1860             : 
    1861             :   unsigned getLine() const { return Line; }
    1862         899 :   unsigned getColumn() const { return Column; }
    1863             : 
    1864             :   static bool classof(const Metadata *MD) {
    1865         148 :     return MD->getMetadataID() == DILexicalBlockKind;
    1866             :   }
    1867             : };
    1868             : 
    1869             : class DILexicalBlockFile : public DILexicalBlockBase {
    1870             :   friend class LLVMContextImpl;
    1871             :   friend class MDNode;
    1872             : 
    1873             :   unsigned Discriminator;
    1874             : 
    1875             :   DILexicalBlockFile(LLVMContext &C, StorageType Storage,
    1876             :                      unsigned Discriminator, ArrayRef<Metadata *> Ops)
    1877         465 :       : DILexicalBlockBase(C, DILexicalBlockFileKind, Storage, Ops),
    1878         465 :         Discriminator(Discriminator) {}
    1879         455 :   ~DILexicalBlockFile() = default;
    1880             : 
    1881             :   static DILexicalBlockFile *getImpl(LLVMContext &Context, DILocalScope *Scope,
    1882             :                                      DIFile *File, unsigned Discriminator,
    1883             :                                      StorageType Storage,
    1884             :                                      bool ShouldCreate = true) {
    1885             :     return getImpl(Context, static_cast<Metadata *>(Scope),
    1886             :                    static_cast<Metadata *>(File), Discriminator, Storage,
    1887           6 :                    ShouldCreate);
    1888             :   }
    1889             : 
    1890             :   static DILexicalBlockFile *getImpl(LLVMContext &Context, Metadata *Scope,
    1891             :                                      Metadata *File, unsigned Discriminator,
    1892             :                                      StorageType Storage,
    1893             :                                      bool ShouldCreate = true);
    1894             : 
    1895           1 :   TempDILexicalBlockFile cloneImpl() const {
    1896             :     return getTemporary(getContext(), getScope(), getFile(),
    1897           2 :                         getDiscriminator());
    1898             :   }
    1899             : 
    1900             : public:
    1901             :   DEFINE_MDNODE_GET(DILexicalBlockFile, (DILocalScope * Scope, DIFile *File,
    1902             :                                          unsigned Discriminator),
    1903             :                     (Scope, File, Discriminator))
    1904         921 :   DEFINE_MDNODE_GET(DILexicalBlockFile,
    1905             :                     (Metadata * Scope, Metadata *File, unsigned Discriminator),
    1906             :                     (Scope, File, Discriminator))
    1907             : 
    1908           1 :   TempDILexicalBlockFile clone() const { return cloneImpl(); }
    1909             : 
    1910             :   // TODO: Remove these once they're gone from DILexicalBlockBase.
    1911             :   unsigned getLine() const = delete;
    1912             :   unsigned getColumn() const = delete;
    1913             : 
    1914             :   unsigned getDiscriminator() const { return Discriminator; }
    1915             : 
    1916             :   static bool classof(const Metadata *MD) {
    1917     4385356 :     return MD->getMetadataID() == DILexicalBlockFileKind;
    1918             :   }
    1919             : };
    1920             : 
    1921             : unsigned DILocation::getDiscriminator() const {
    1922             :   if (auto *F = dyn_cast<DILexicalBlockFile>(getScope()))
    1923         470 :     return F->getDiscriminator();
    1924             :   return 0;
    1925             : }
    1926             : 
    1927             : const DILocation *
    1928         298 : DILocation::cloneWithDiscriminator(unsigned Discriminator) const {
    1929             :   DIScope *Scope = getScope();
    1930             :   // Skip all parent DILexicalBlockFile that already have a discriminator
    1931             :   // assigned. We do not want to have nested DILexicalBlockFiles that have
    1932             :   // mutliple discriminators because only the leaf DILexicalBlockFile's
    1933             :   // dominator will be used.
    1934             :   for (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope);
    1935         357 :        LBF && LBF->getDiscriminator() != 0;
    1936             :        LBF = dyn_cast<DILexicalBlockFile>(Scope))
    1937             :     Scope = LBF->getScope();
    1938             :   DILexicalBlockFile *NewScope =
    1939             :       DILexicalBlockFile::get(getContext(), Scope, getFile(), Discriminator);
    1940         596 :   return DILocation::get(getContext(), getLine(), getColumn(), NewScope,
    1941         298 :                          getInlinedAt());
    1942             : }
    1943             : 
    1944        1378 : unsigned DILocation::getBaseDiscriminator() const {
    1945        1378 :   return getBaseDiscriminatorFromDiscriminator(getDiscriminator());
    1946             : }
    1947             : 
    1948         110 : unsigned DILocation::getDuplicationFactor() const {
    1949         110 :   return getDuplicationFactorFromDiscriminator(getDiscriminator());
    1950             : }
    1951             : 
    1952         110 : unsigned DILocation::getCopyIdentifier() const {
    1953         110 :   return getCopyIdentifierFromDiscriminator(getDiscriminator());
    1954             : }
    1955             : 
    1956         188 : const DILocation *DILocation::setBaseDiscriminator(unsigned D) const {
    1957         188 :   if (D == 0)
    1958             :     return this;
    1959             :   else
    1960         188 :     return cloneWithDiscriminator(getPrefixEncodingFromUnsigned(D) << 1);
    1961             : }
    1962             : 
    1963         110 : const DILocation *DILocation::cloneWithDuplicationFactor(unsigned DF) const {
    1964         110 :   DF *= getDuplicationFactor();
    1965         110 :   if (DF <= 1)
    1966             :     return this;
    1967             : 
    1968         110 :   unsigned BD = getBaseDiscriminator();
    1969         110 :   unsigned CI = getCopyIdentifier() << (DF > 0x1f ? 14 : 7);
    1970         110 :   unsigned D = CI | (getPrefixEncodingFromUnsigned(DF) << 1);
    1971             : 
    1972         110 :   if (BD == 0)
    1973         110 :     D = (D << 1) | 1;
    1974             :   else
    1975           0 :     D = (D << (BD > 0x1f ? 14 : 7)) | (getPrefixEncodingFromUnsigned(BD) << 1);
    1976             : 
    1977         110 :   return cloneWithDiscriminator(D);
    1978             : }
    1979             : 
    1980             : class DINamespace : public DIScope {
    1981             :   friend class LLVMContextImpl;
    1982             :   friend class MDNode;
    1983             : 
    1984             :   unsigned ExportSymbols : 1;
    1985             : 
    1986             :   DINamespace(LLVMContext &Context, StorageType Storage, bool ExportSymbols,
    1987             :               ArrayRef<Metadata *> Ops)
    1988        3452 :       : DIScope(Context, DINamespaceKind, Storage, dwarf::DW_TAG_namespace,
    1989             :                 Ops),
    1990        3452 :         ExportSymbols(ExportSymbols) {}
    1991         274 :   ~DINamespace() = default;
    1992             : 
    1993       17130 :   static DINamespace *getImpl(LLVMContext &Context, DIScope *Scope,
    1994             :                               StringRef Name, bool ExportSymbols,
    1995             :                               StorageType Storage, bool ShouldCreate = true) {
    1996       17130 :     return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
    1997       17130 :                    ExportSymbols, Storage, ShouldCreate);
    1998             :   }
    1999             :   static DINamespace *getImpl(LLVMContext &Context, Metadata *Scope,
    2000             :                               MDString *Name, bool ExportSymbols,
    2001             :                               StorageType Storage, bool ShouldCreate = true);
    2002             : 
    2003           1 :   TempDINamespace cloneImpl() const {
    2004             :     return getTemporary(getContext(), getScope(), getName(),
    2005           2 :                         getExportSymbols());
    2006             :   }
    2007             : 
    2008             : public:
    2009       17130 :   DEFINE_MDNODE_GET(DINamespace,
    2010             :                     (DIScope *Scope, StringRef Name, bool ExportSymbols),
    2011             :                     (Scope, Name, ExportSymbols))
    2012         140 :   DEFINE_MDNODE_GET(DINamespace,
    2013             :                     (Metadata *Scope, MDString *Name, bool ExportSymbols),
    2014             :                     (Scope, Name, ExportSymbols))
    2015             : 
    2016           1 :   TempDINamespace clone() const { return cloneImpl(); }
    2017             : 
    2018       20736 :   bool getExportSymbols() const { return ExportSymbols; }
    2019             :   DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
    2020       65132 :   StringRef getName() const { return getStringOperand(2); }
    2021             : 
    2022      686546 :   Metadata *getRawScope() const { return getOperand(1); }
    2023             :   MDString *getRawName() const { return getOperandAs<MDString>(2); }
    2024             : 
    2025             :   static bool classof(const Metadata *MD) {
    2026       99106 :     return MD->getMetadataID() == DINamespaceKind;
    2027             :   }
    2028             : };
    2029             : 
    2030             : /// A (clang) module that has been imported by the compile unit.
    2031             : ///
    2032             : class DIModule : public DIScope {
    2033             :   friend class LLVMContextImpl;
    2034             :   friend class MDNode;
    2035             : 
    2036             :   DIModule(LLVMContext &Context, StorageType Storage, ArrayRef<Metadata *> Ops)
    2037             :       : DIScope(Context, DIModuleKind, Storage, dwarf::DW_TAG_module, Ops) {}
    2038          88 :   ~DIModule() = default;
    2039             : 
    2040          64 :   static DIModule *getImpl(LLVMContext &Context, DIScope *Scope,
    2041             :                            StringRef Name, StringRef ConfigurationMacros,
    2042             :                            StringRef IncludePath, StringRef ISysRoot,
    2043             :                            StorageType Storage, bool ShouldCreate = true) {
    2044          64 :     return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
    2045             :                    getCanonicalMDString(Context, ConfigurationMacros),
    2046             :                    getCanonicalMDString(Context, IncludePath),
    2047             :                    getCanonicalMDString(Context, ISysRoot),
    2048          64 :                    Storage, ShouldCreate);
    2049             :   }
    2050             :   static DIModule *getImpl(LLVMContext &Context, Metadata *Scope,
    2051             :                            MDString *Name, MDString *ConfigurationMacros,
    2052             :                            MDString *IncludePath, MDString *ISysRoot,
    2053             :                            StorageType Storage, bool ShouldCreate = true);
    2054             : 
    2055           1 :   TempDIModule cloneImpl() const {
    2056             :     return getTemporary(getContext(), getScope(), getName(),
    2057             :                         getConfigurationMacros(), getIncludePath(),
    2058           1 :                         getISysRoot());
    2059             :   }
    2060             : 
    2061             : public:
    2062          64 :   DEFINE_MDNODE_GET(DIModule, (DIScope *Scope, StringRef Name,
    2063             :                                StringRef ConfigurationMacros, StringRef IncludePath,
    2064             :                                StringRef ISysRoot),
    2065             :                     (Scope, Name, ConfigurationMacros, IncludePath, ISysRoot))
    2066          33 :   DEFINE_MDNODE_GET(DIModule,
    2067             :                     (Metadata *Scope, MDString *Name, MDString *ConfigurationMacros,
    2068             :                      MDString *IncludePath, MDString *ISysRoot),
    2069             :                     (Scope, Name, ConfigurationMacros, IncludePath, ISysRoot))
    2070             : 
    2071           1 :   TempDIModule clone() const { return cloneImpl(); }
    2072             : 
    2073             :   DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
    2074         299 :   StringRef getName() const { return getStringOperand(1); }
    2075          77 :   StringRef getConfigurationMacros() const { return getStringOperand(2); }
    2076          91 :   StringRef getIncludePath() const { return getStringOperand(3); }
    2077          97 :   StringRef getISysRoot() const { return getStringOperand(4); }
    2078             : 
    2079         402 :   Metadata *getRawScope() const { return getOperand(0); }
    2080             :   MDString *getRawName() const { return getOperandAs<MDString>(1); }
    2081             :   MDString *getRawConfigurationMacros() const { return getOperandAs<MDString>(2); }
    2082             :   MDString *getRawIncludePath() const { return getOperandAs<MDString>(3); }
    2083             :   MDString *getRawISysRoot() const { return getOperandAs<MDString>(4); }
    2084             : 
    2085             :   static bool classof(const Metadata *MD) {
    2086             :     return MD->getMetadataID() == DIModuleKind;
    2087             :   }
    2088             : };
    2089             : 
    2090             : /// Base class for template parameters.
    2091             : class DITemplateParameter : public DINode {
    2092             : protected:
    2093             :   DITemplateParameter(LLVMContext &Context, unsigned ID, StorageType Storage,
    2094             :                       unsigned Tag, ArrayRef<Metadata *> Ops)
    2095             :       : DINode(Context, ID, Storage, Tag, Ops) {}
    2096             :   ~DITemplateParameter() = default;
    2097             : 
    2098             : public:
    2099      129095 :   StringRef getName() const { return getStringOperand(0); }
    2100             :   DITypeRef getType() const { return DITypeRef(getRawType()); }
    2101             : 
    2102             :   MDString *getRawName() const { return getOperandAs<MDString>(0); }
    2103      176243 :   Metadata *getRawType() const { return getOperand(1); }
    2104             : 
    2105             :   static bool classof(const Metadata *MD) {
    2106        2154 :     return MD->getMetadataID() == DITemplateTypeParameterKind ||
    2107             :            MD->getMetadataID() == DITemplateValueParameterKind;
    2108             :   }
    2109             : };
    2110             : 
    2111             : class DITemplateTypeParameter : public DITemplateParameter {
    2112             :   friend class LLVMContextImpl;
    2113             :   friend class MDNode;
    2114             : 
    2115             :   DITemplateTypeParameter(LLVMContext &Context, StorageType Storage,
    2116             :                           ArrayRef<Metadata *> Ops)
    2117             :       : DITemplateParameter(Context, DITemplateTypeParameterKind, Storage,
    2118             :                             dwarf::DW_TAG_template_type_parameter, Ops) {}
    2119         336 :   ~DITemplateTypeParameter() = default;
    2120             : 
    2121       53442 :   static DITemplateTypeParameter *getImpl(LLVMContext &Context, StringRef Name,
    2122             :                                           DITypeRef Type, StorageType Storage,
    2123             :                                           bool ShouldCreate = true) {
    2124       53442 :     return getImpl(Context, getCanonicalMDString(Context, Name), Type, Storage,
    2125       53442 :                    ShouldCreate);
    2126             :   }
    2127             :   static DITemplateTypeParameter *getImpl(LLVMContext &Context, MDString *Name,
    2128             :                                           Metadata *Type, StorageType Storage,
    2129             :                                           bool ShouldCreate = true);
    2130             : 
    2131           2 :   TempDITemplateTypeParameter cloneImpl() const {
    2132           2 :     return getTemporary(getContext(), getName(), getType());
    2133             :   }
    2134             : 
    2135             : public:
    2136       53442 :   DEFINE_MDNODE_GET(DITemplateTypeParameter, (StringRef Name, DITypeRef Type),
    2137             :                     (Name, Type))
    2138          81 :   DEFINE_MDNODE_GET(DITemplateTypeParameter, (MDString * Name, Metadata *Type),
    2139             :                     (Name, Type))
    2140             : 
    2141           1 :   TempDITemplateTypeParameter clone() const { return cloneImpl(); }
    2142             : 
    2143             :   static bool classof(const Metadata *MD) {
    2144       71948 :     return MD->getMetadataID() == DITemplateTypeParameterKind;
    2145             :   }
    2146             : };
    2147             : 
    2148             : class DITemplateValueParameter : public DITemplateParameter {
    2149             :   friend class LLVMContextImpl;
    2150             :   friend class MDNode;
    2151             : 
    2152             :   DITemplateValueParameter(LLVMContext &Context, StorageType Storage,
    2153             :                            unsigned Tag, ArrayRef<Metadata *> Ops)
    2154             :       : DITemplateParameter(Context, DITemplateValueParameterKind, Storage, Tag,
    2155             :                             Ops) {}
    2156         351 :   ~DITemplateValueParameter() = default;
    2157             : 
    2158       21097 :   static DITemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
    2159             :                                            StringRef Name, DITypeRef Type,
    2160             :                                            Metadata *Value, StorageType Storage,
    2161             :                                            bool ShouldCreate = true) {
    2162       21097 :     return getImpl(Context, Tag, getCanonicalMDString(Context, Name), Type,
    2163       21097 :                    Value, Storage, ShouldCreate);
    2164             :   }
    2165             :   static DITemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
    2166             :                                            MDString *Name, Metadata *Type,
    2167             :                                            Metadata *Value, StorageType Storage,
    2168             :                                            bool ShouldCreate = true);
    2169             : 
    2170           3 :   TempDITemplateValueParameter cloneImpl() const {
    2171             :     return getTemporary(getContext(), getTag(), getName(), getType(),
    2172           6 :                         getValue());
    2173             :   }
    2174             : 
    2175             : public:
    2176       21097 :   DEFINE_MDNODE_GET(DITemplateValueParameter, (unsigned Tag, StringRef Name,
    2177             :                                                DITypeRef Type, Metadata *Value),
    2178             :                     (Tag, Name, Type, Value))
    2179          90 :   DEFINE_MDNODE_GET(DITemplateValueParameter, (unsigned Tag, MDString *Name,
    2180             :                                                Metadata *Type, Metadata *Value),
    2181             :                     (Tag, Name, Type, Value))
    2182             : 
    2183           1 :   TempDITemplateValueParameter clone() const { return cloneImpl(); }
    2184             : 
    2185       45629 :   Metadata *getValue() const { return getOperand(2); }
    2186             : 
    2187             :   static bool classof(const Metadata *MD) {
    2188             :     return MD->getMetadataID() == DITemplateValueParameterKind;
    2189             :   }
    2190             : };
    2191             : 
    2192             : /// Base class for variables.
    2193             : class DIVariable : public DINode {
    2194             :   unsigned Line;
    2195             :   uint32_t AlignInBits;
    2196             : 
    2197             : protected:
    2198             :   DIVariable(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Line,
    2199             :              ArrayRef<Metadata *> Ops, uint32_t AlignInBits = 0)
    2200       77125 :       : DINode(C, ID, Storage, dwarf::DW_TAG_variable, Ops), Line(Line),
    2201       77125 :         AlignInBits(AlignInBits) {}
    2202             :   ~DIVariable() = default;
    2203             : 
    2204             : public:
    2205             :   unsigned getLine() const { return Line; }
    2206             :   DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
    2207       88782 :   StringRef getName() const { return getStringOperand(1); }
    2208             :   DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
    2209             :   DITypeRef getType() const { return DITypeRef(getRawType()); }
    2210             :   uint32_t getAlignInBits() const { return AlignInBits; }
    2211       66350 :   uint32_t getAlignInBytes() const { return getAlignInBits() / CHAR_BIT; }
    2212             :   /// Determines the size of the variable's type.
    2213             :   Optional<uint64_t> getSizeInBits() const;
    2214             : 
    2215             :   /// Return the signedness of this variable's type, or None if this type is
    2216             :   /// neither signed nor unsigned.
    2217         387 :   Optional<DIBasicType::Signedness> getSignedness() const {
    2218             :     if (auto *BT = dyn_cast<DIBasicType>(getType().resolve()))
    2219         387 :       return BT->getSignedness();
    2220             :     return None;
    2221             :   }
    2222             : 
    2223           2 :   StringRef getFilename() const {
    2224             :     if (auto *F = getFile())
    2225             :       return F->getFilename();
    2226           0 :     return "";
    2227             :   }
    2228             : 
    2229           2 :   StringRef getDirectory() const {
    2230             :     if (auto *F = getFile())
    2231             :       return F->getDirectory();
    2232           0 :     return "";
    2233             :   }
    2234             : 
    2235             :   Optional<StringRef> getSource() const {
    2236             :     if (auto *F = getFile())
    2237             :       return F->getSource();
    2238             :     return None;
    2239             :   }
    2240             : 
    2241      334842 :   Metadata *getRawScope() const { return getOperand(0); }
    2242             :   MDString *getRawName() const { return getOperandAs<MDString>(1); }
    2243       66303 :   Metadata *getRawFile() const { return getOperand(2); }
    2244      247588 :   Metadata *getRawType() const { return getOperand(3); }
    2245             : 
    2246             :   static bool classof(const Metadata *MD) {
    2247         166 :     return MD->getMetadataID() == DILocalVariableKind ||
    2248             :            MD->getMetadataID() == DIGlobalVariableKind;
    2249             :   }
    2250             : };
    2251             : 
    2252             : /// DWARF expression.
    2253             : ///
    2254             : /// This is (almost) a DWARF expression that modifies the location of a
    2255             : /// variable, or the location of a single piece of a variable, or (when using
    2256             : /// DW_OP_stack_value) is the constant variable value.
    2257             : ///
    2258             : /// TODO: Co-allocate the expression elements.
    2259             : /// TODO: Separate from MDNode, or otherwise drop Distinct and Temporary
    2260             : /// storage types.
    2261             : class DIExpression : public MDNode {
    2262             :   friend class LLVMContextImpl;
    2263             :   friend class MDNode;
    2264             : 
    2265             :   std::vector<uint64_t> Elements;
    2266             : 
    2267        4279 :   DIExpression(LLVMContext &C, StorageType Storage, ArrayRef<uint64_t> Elements)
    2268        4279 :       : MDNode(C, DIExpressionKind, Storage, None),
    2269       12837 :         Elements(Elements.begin(), Elements.end()) {}
    2270        3922 :   ~DIExpression() = default;
    2271             : 
    2272             :   static DIExpression *getImpl(LLVMContext &Context,
    2273             :                                ArrayRef<uint64_t> Elements, StorageType Storage,
    2274             :                                bool ShouldCreate = true);
    2275             : 
    2276           1 :   TempDIExpression cloneImpl() const {
    2277           1 :     return getTemporary(getContext(), getElements());
    2278             :   }
    2279             : 
    2280             : public:
    2281       83507 :   DEFINE_MDNODE_GET(DIExpression, (ArrayRef<uint64_t> Elements), (Elements))
    2282             : 
    2283           1 :   TempDIExpression clone() const { return cloneImpl(); }
    2284             : 
    2285             :   ArrayRef<uint64_t> getElements() const { return Elements; }
    2286             : 
    2287       56900 :   unsigned getNumElements() const { return Elements.size(); }
    2288             : 
    2289             :   uint64_t getElement(unsigned I) const {
    2290             :     assert(I < Elements.size() && "Index out of range");
    2291          74 :     return Elements[I];
    2292             :   }
    2293             : 
    2294             :   /// Determine whether this represents a standalone constant value.
    2295             :   bool isConstant() const;
    2296             : 
    2297             :   using element_iterator = ArrayRef<uint64_t>::iterator;
    2298             : 
    2299             :   element_iterator elements_begin() const { return getElements().begin(); }
    2300             :   element_iterator elements_end() const { return getElements().end(); }
    2301             : 
    2302             :   /// A lightweight wrapper around an expression operand.
    2303             :   ///
    2304             :   /// TODO: Store arguments directly and change \a DIExpression to store a
    2305             :   /// range of these.
    2306             :   class ExprOperand {
    2307             :     const uint64_t *Op = nullptr;
    2308             : 
    2309             :   public:
    2310       87948 :     ExprOperand() = default;
    2311      107744 :     explicit ExprOperand(const uint64_t *Op) : Op(Op) {}
    2312             : 
    2313      916012 :     const uint64_t *get() const { return Op; }
    2314             : 
    2315             :     /// Get the operand code.
    2316      533460 :     uint64_t getOp() const { return *Op; }
    2317             : 
    2318             :     /// Get an argument to the operand.
    2319             :     ///
    2320             :     /// Never returns the operand itself.
    2321       69118 :     uint64_t getArg(unsigned I) const { return Op[I + 1]; }
    2322             : 
    2323        1240 :     unsigned getNumArgs() const { return getSize() - 1; }
    2324             : 
    2325             :     /// Return the size of the operand.
    2326             :     ///
    2327             :     /// Return the number of elements in the operand (1 + args).
    2328             :     unsigned getSize() const;
    2329             : 
    2330             :     /// Append the elements of this operand to \p V.
    2331        2025 :     void appendToVector(SmallVectorImpl<uint64_t> &V) const {
    2332        4050 :       V.append(get(), get() + getSize());
    2333        2025 :     }
    2334             :   };
    2335             : 
    2336             :   /// An iterator for expression operands.
    2337             :   class expr_op_iterator
    2338             :       : public std::iterator<std::input_iterator_tag, ExprOperand> {
    2339             :     ExprOperand Op;
    2340             : 
    2341             :   public:
    2342             :     expr_op_iterator() = default;
    2343             :     explicit expr_op_iterator(element_iterator I) : Op(I) {}
    2344             : 
    2345             :     element_iterator getBase() const { return Op.get(); }
    2346             :     const ExprOperand &operator*() const { return Op; }
    2347             :     const ExprOperand *operator->() const { return &Op; }
    2348             : 
    2349             :     expr_op_iterator &operator++() {
    2350             :       increment();
    2351             :       return *this;
    2352             :     }
    2353             :     expr_op_iterator operator++(int) {
    2354             :       expr_op_iterator T(*this);
    2355             :       increment();
    2356             :       return T;
    2357             :     }
    2358             : 
    2359             :     /// Get the next iterator.
    2360             :     ///
    2361             :     /// \a std::next() doesn't work because this is technically an
    2362             :     /// input_iterator, but it's a perfectly valid operation.  This is an
    2363             :     /// accessor to provide the same functionality.
    2364         452 :     expr_op_iterator getNext() const { return ++expr_op_iterator(*this); }
    2365             : 
    2366             :     bool operator==(const expr_op_iterator &X) const {
    2367             :       return getBase() == X.getBase();
    2368             :     }
    2369             :     bool operator!=(const expr_op_iterator &X) const {
    2370             :       return getBase() != X.getBase();
    2371             :     }
    2372             : 
    2373             :   private:
    2374      199852 :     void increment() { Op = ExprOperand(getBase() + Op.getSize()); }
    2375             :   };
    2376             : 
    2377             :   /// Visit the elements via ExprOperand wrappers.
    2378             :   ///
    2379             :   /// These range iterators visit elements through \a ExprOperand wrappers.
    2380             :   /// This is not guaranteed to be a valid range unless \a isValid() gives \c
    2381             :   /// true.
    2382             :   ///
    2383             :   /// \pre \a isValid() gives \c true.
    2384             :   /// @{
    2385             :   expr_op_iterator expr_op_begin() const {
    2386             :     return expr_op_iterator(elements_begin());
    2387             :   }
    2388             :   expr_op_iterator expr_op_end() const {
    2389             :     return expr_op_iterator(elements_end());
    2390             :   }
    2391             :   iterator_range<expr_op_iterator> expr_ops() const {
    2392             :     return {expr_op_begin(), expr_op_end()};
    2393             :   }
    2394             :   /// @}
    2395             : 
    2396             :   bool isValid() const;
    2397             : 
    2398             :   static bool classof(const Metadata *MD) {
    2399      389580 :     return MD->getMetadataID() == DIExpressionKind;
    2400             :   }
    2401             : 
    2402             :   /// Return whether the first element a DW_OP_deref.
    2403             :   bool startsWithDeref() const {
    2404           8 :     return getNumElements() > 0 && getElement(0) == dwarf::DW_OP_deref;
    2405             :   }
    2406             : 
    2407             :   /// Holds the characteristics of one fragment of a larger variable.
    2408             :   struct FragmentInfo {
    2409             :     uint64_t SizeInBits;
    2410             :     uint64_t OffsetInBits;
    2411             :   };
    2412             : 
    2413             :   /// Retrieve the details of this fragment expression.
    2414             :   static Optional<FragmentInfo> getFragmentInfo(expr_op_iterator Start,
    2415             :                                                 expr_op_iterator End);
    2416             : 
    2417             :   /// Retrieve the details of this fragment expression.
    2418             :   Optional<FragmentInfo> getFragmentInfo() const {
    2419      208689 :     return getFragmentInfo(expr_op_begin(), expr_op_end());
    2420             :   }
    2421             : 
    2422             :   /// Return whether this is a piece of an aggregate variable.
    2423      171317 :   bool isFragment() const { return getFragmentInfo().hasValue(); }
    2424             : 
    2425             :   /// Append \p Ops with operations to apply the \p Offset.
    2426             :   static void appendOffset(SmallVectorImpl<uint64_t> &Ops, int64_t Offset);
    2427             : 
    2428             :   /// If this is a constant offset, extract it. If there is no expression,
    2429             :   /// return true with an offset of zero.
    2430             :   bool extractIfOffset(int64_t &Offset) const;
    2431             : 
    2432             :   /// Constants for DIExpression::prepend.
    2433             :   enum { NoDeref = false, WithDeref = true, WithStackValue = true };
    2434             : 
    2435             :   /// Prepend \p DIExpr with a deref and offset operation and optionally turn it
    2436             :   /// into a stack value.
    2437             :   static DIExpression *prepend(const DIExpression *Expr, bool DerefBefore,
    2438             :                                int64_t Offset = 0, bool DerefAfter = false,
    2439             :                                bool StackValue = false);
    2440             : 
    2441             :   /// Prepend \p DIExpr with the given opcodes and optionally turn it into a
    2442             :   /// stack value.
    2443             :   static DIExpression *prependOpcodes(const DIExpression *Expr,
    2444             :                                       SmallVectorImpl<uint64_t> &Ops,
    2445             :                                       bool StackValue = false);
    2446             : 
    2447             :   /// Convert \p DIExpr into a stack value if it isn't one already by appending
    2448             :   /// DW_OP_deref if needed, and applying \p Ops to the resulting expression.
    2449             :   /// If \p DIExpr is a fragment, the returned expression will contain the same
    2450             :   /// fragment.
    2451             :   static DIExpression *appendToStack(const DIExpression *Expr,
    2452             :                                      ArrayRef<uint64_t> Ops);
    2453             : 
    2454             :   /// Create a DIExpression to describe one part of an aggregate variable that
    2455             :   /// is fragmented across multiple Values. The DW_OP_LLVM_fragment operation
    2456             :   /// will be appended to the elements of \c Expr. If \c Expr already contains
    2457             :   /// a \c DW_OP_LLVM_fragment \c OffsetInBits is interpreted as an offset
    2458             :   /// into the existing fragment.
    2459             :   ///
    2460             :   /// \param OffsetInBits Offset of the piece in bits.
    2461             :   /// \param SizeInBits   Size of the piece in bits.
    2462             :   /// \return             Creating a fragment expression may fail if \c Expr
    2463             :   ///                     contains arithmetic operations that would be truncated.
    2464             :   static Optional<DIExpression *>
    2465             :   createFragmentExpression(const DIExpression *Expr, unsigned OffsetInBits,
    2466             :                            unsigned SizeInBits);
    2467             : 
    2468             :   /// Determine the relative position of the fragments described by this
    2469             :   /// DIExpression and \p Other.
    2470             :   /// Returns -1 if this is entirely before Other, 0 if this and Other overlap,
    2471             :   /// 1 if this is entirely after Other.
    2472         388 :   int fragmentCmp(const DIExpression *Other) const {
    2473         388 :     auto Fragment1 = *getFragmentInfo();
    2474         388 :     auto Fragment2 = *Other->getFragmentInfo();
    2475         388 :     unsigned l1 = Fragment1.OffsetInBits;
    2476         388 :     unsigned l2 = Fragment2.OffsetInBits;
    2477         388 :     unsigned r1 = l1 + Fragment1.SizeInBits;
    2478         388 :     unsigned r2 = l2 + Fragment2.SizeInBits;
    2479         388 :     if (r1 <= l2)
    2480             :       return -1;
    2481         278 :     else if (r2 <= l1)
    2482             :       return 1;
    2483             :     else
    2484         166 :       return 0;
    2485             :   }
    2486             : 
    2487             :   /// Check if fragments overlap between this DIExpression and \p Other.
    2488        1209 :   bool fragmentsOverlap(const DIExpression *Other) const {
    2489        1555 :     if (!isFragment() || !Other->isFragment())
    2490             :       return true;
    2491         346 :     return fragmentCmp(Other) == 0;
    2492             :   }
    2493             : };
    2494             : 
    2495             : /// Global variables.
    2496             : ///
    2497             : /// TODO: Remove DisplayName.  It's always equal to Name.
    2498             : class DIGlobalVariable : public DIVariable {
    2499             :   friend class LLVMContextImpl;
    2500             :   friend class MDNode;
    2501             : 
    2502             :   bool IsLocalToUnit;
    2503             :   bool IsDefinition;
    2504             : 
    2505             :   DIGlobalVariable(LLVMContext &C, StorageType Storage, unsigned Line,
    2506             :                    bool IsLocalToUnit, bool IsDefinition, uint32_t AlignInBits,
    2507             :                    ArrayRef<Metadata *> Ops)
    2508        4834 :       : DIVariable(C, DIGlobalVariableKind, Storage, Line, Ops, AlignInBits),
    2509        4834 :         IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition) {}
    2510        1451 :   ~DIGlobalVariable() = default;
    2511             : 
    2512        3808 :   static DIGlobalVariable *getImpl(LLVMContext &Context, DIScope *Scope,
    2513             :                                    StringRef Name, StringRef LinkageName,
    2514             :                                    DIFile *File, unsigned Line, DITypeRef Type,
    2515             :                                    bool IsLocalToUnit, bool IsDefinition,
    2516             :                                    DIDerivedType *StaticDataMemberDeclaration,
    2517             :                                    uint32_t AlignInBits, StorageType Storage,
    2518             :                                    bool ShouldCreate = true) {
    2519        3808 :     return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
    2520             :                    getCanonicalMDString(Context, LinkageName), File, Line, Type,
    2521             :                    IsLocalToUnit, IsDefinition, StaticDataMemberDeclaration,
    2522        3808 :                    AlignInBits, Storage, ShouldCreate);
    2523             :   }
    2524             :   static DIGlobalVariable *
    2525             :   getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
    2526             :           MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
    2527             :           bool IsLocalToUnit, bool IsDefinition,
    2528             :           Metadata *StaticDataMemberDeclaration, uint32_t AlignInBits,
    2529             :           StorageType Storage, bool ShouldCreate = true);
    2530             : 
    2531           2 :   TempDIGlobalVariable cloneImpl() const {
    2532             :     return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
    2533           2 :                         getFile(), getLine(), getType(), isLocalToUnit(),
    2534           2 :                         isDefinition(), getStaticDataMemberDeclaration(),
    2535          10 :                         getAlignInBits());
    2536             :   }
    2537             : 
    2538             : public:
    2539        3808 :   DEFINE_MDNODE_GET(DIGlobalVariable,
    2540             :                     (DIScope * Scope, StringRef Name, StringRef LinkageName,
    2541             :                      DIFile *File, unsigned Line, DITypeRef Type,
    2542             :                      bool IsLocalToUnit, bool IsDefinition,
    2543             :                      DIDerivedType *StaticDataMemberDeclaration,
    2544             :                      uint32_t AlignInBits),
    2545             :                     (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
    2546             :                      IsDefinition, StaticDataMemberDeclaration, AlignInBits))
    2547        1027 :   DEFINE_MDNODE_GET(DIGlobalVariable,
    2548             :                     (Metadata * Scope, MDString *Name, MDString *LinkageName,
    2549             :                      Metadata *File, unsigned Line, Metadata *Type,
    2550             :                      bool IsLocalToUnit, bool IsDefinition,
    2551             :                      Metadata *StaticDataMemberDeclaration,
    2552             :                      uint32_t AlignInBits),
    2553             :                     (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
    2554             :                      IsDefinition, StaticDataMemberDeclaration, AlignInBits))
    2555             : 
    2556           1 :   TempDIGlobalVariable clone() const { return cloneImpl(); }
    2557             : 
    2558             :   bool isLocalToUnit() const { return IsLocalToUnit; }
    2559             :   bool isDefinition() const { return IsDefinition; }
    2560        3938 :   StringRef getDisplayName() const { return getStringOperand(4); }
    2561        9302 :   StringRef getLinkageName() const { return getStringOperand(5); }
    2562             :   DIDerivedType *getStaticDataMemberDeclaration() const {
    2563             :     return cast_or_null<DIDerivedType>(getRawStaticDataMemberDeclaration());
    2564             :   }
    2565             : 
    2566             :   MDString *getRawLinkageName() const { return getOperandAs<MDString>(5); }
    2567       19187 :   Metadata *getRawStaticDataMemberDeclaration() const { return getOperand(6); }
    2568             : 
    2569             :   static bool classof(const Metadata *MD) {
    2570          17 :     return MD->getMetadataID() == DIGlobalVariableKind;
    2571             :   }
    2572             : };
    2573             : 
    2574             : /// Local variable.
    2575             : ///
    2576             : /// TODO: Split up flags.
    2577             : class DILocalVariable : public DIVariable {
    2578             :   friend class LLVMContextImpl;
    2579             :   friend class MDNode;
    2580             : 
    2581             :   unsigned Arg : 16;
    2582             :   DIFlags Flags;
    2583             : 
    2584             :   DILocalVariable(LLVMContext &C, StorageType Storage, unsigned Line,
    2585             :                   unsigned Arg, DIFlags Flags, uint32_t AlignInBits,
    2586             :                   ArrayRef<Metadata *> Ops)
    2587       72291 :       : DIVariable(C, DILocalVariableKind, Storage, Line, Ops, AlignInBits),
    2588       72291 :         Arg(Arg), Flags(Flags) {
    2589             :     assert(Arg < (1 << 16) && "DILocalVariable: Arg out of range");
    2590             :   }
    2591        7811 :   ~DILocalVariable() = default;
    2592             : 
    2593       69886 :   static DILocalVariable *getImpl(LLVMContext &Context, DIScope *Scope,
    2594             :                                   StringRef Name, DIFile *File, unsigned Line,
    2595             :                                   DITypeRef Type, unsigned Arg, DIFlags Flags,
    2596             :                                   uint32_t AlignInBits, StorageType Storage,
    2597             :                                   bool ShouldCreate = true) {
    2598       69886 :     return getImpl(Context, Scope, getCanonicalMDString(Context, Name), File,
    2599       69886 :                    Line, Type, Arg, Flags, AlignInBits, Storage, ShouldCreate);
    2600             :   }
    2601             :   static DILocalVariable *getImpl(LLVMContext &Context, Metadata *Scope,
    2602             :                                   MDString *Name, Metadata *File, unsigned Line,
    2603             :                                   Metadata *Type, unsigned Arg, DIFlags Flags,
    2604             :                                   uint32_t AlignInBits, StorageType Storage,
    2605             :                                   bool ShouldCreate = true);
    2606             : 
    2607          24 :   TempDILocalVariable cloneImpl() const {
    2608             :     return getTemporary(getContext(), getScope(), getName(), getFile(),
    2609             :                         getLine(), getType(), getArg(), getFlags(),
    2610          72 :                         getAlignInBits());
    2611             :   }
    2612             : 
    2613             : public:
    2614       69886 :   DEFINE_MDNODE_GET(DILocalVariable,
    2615             :                     (DILocalScope * Scope, StringRef Name, DIFile *File,
    2616             :                      unsigned Line, DITypeRef Type, unsigned Arg,
    2617             :                      DIFlags Flags, uint32_t AlignInBits),
    2618             :                     (Scope, Name, File, Line, Type, Arg, Flags, AlignInBits))
    2619        2530 :   DEFINE_MDNODE_GET(DILocalVariable,
    2620             :                     (Metadata * Scope, MDString *Name, Metadata *File,
    2621             :                      unsigned Line, Metadata *Type, unsigned Arg,
    2622             :                      DIFlags Flags, uint32_t AlignInBits),
    2623             :                     (Scope, Name, File, Line, Type, Arg, Flags, AlignInBits))
    2624             : 
    2625           1 :   TempDILocalVariable clone() const { return cloneImpl(); }
    2626             : 
    2627             :   /// Get the local scope for this variable.
    2628             :   ///
    2629             :   /// Variables must be defined in a local scope.
    2630             :   DILocalScope *getScope() const {
    2631             :     return cast<DILocalScope>(DIVariable::getScope());
    2632             :   }
    2633             : 
    2634      114360 :   bool isParameter() const { return Arg; }
    2635      243815 :   unsigned getArg() const { return Arg; }
    2636             :   DIFlags getFlags() const { return Flags; }
    2637             : 
    2638       62751 :   bool isArtificial() const { return getFlags() & FlagArtificial; }
    2639       81558 :   bool isObjectPointer() const { return getFlags() & FlagObjectPointer; }
    2640             : 
    2641             :   /// Check that a location is valid for this variable.
    2642             :   ///
    2643             :   /// Check that \c DL exists, is in the same subprogram, and has the same
    2644             :   /// inlined-at location as \c this.  (Otherwise, it's not a valid attachment
    2645             :   /// to a \a DbgInfoIntrinsic.)
    2646             :   bool isValidLocationForIntrinsic(const DILocation *DL) const {
    2647             :     return DL && getScope()->getSubprogram() == DL->getScope()->getSubprogram();
    2648             :   }
    2649             : 
    2650             :   static bool classof(const Metadata *MD) {
    2651       16244 :     return MD->getMetadataID() == DILocalVariableKind;
    2652             :   }
    2653             : };
    2654             : 
    2655             : /// Label.
    2656             : ///
    2657             : class DILabel : public DINode {
    2658             :   friend class LLVMContextImpl;
    2659             :   friend class MDNode;
    2660             : 
    2661             :   unsigned Line;
    2662             : 
    2663             :   DILabel(LLVMContext &C, StorageType Storage, unsigned Line,
    2664             :           ArrayRef<Metadata *> Ops)
    2665          54 :       : DINode(C, DILabelKind, Storage, dwarf::DW_TAG_label, Ops), Line(Line) {}
    2666          27 :   ~DILabel() = default;
    2667             : 
    2668           0 :   static DILabel *getImpl(LLVMContext &Context, DIScope *Scope,
    2669             :                           StringRef Name, DIFile *File, unsigned Line,
    2670             :                           StorageType Storage,
    2671             :                           bool ShouldCreate = true) {
    2672           0 :     return getImpl(Context, Scope, getCanonicalMDString(Context, Name), File,
    2673           0 :                    Line, Storage, ShouldCreate);
    2674             :   }
    2675             :   static DILabel *getImpl(LLVMContext &Context, Metadata *Scope,
    2676             :                           MDString *Name, Metadata *File, unsigned Line,
    2677             :                           StorageType Storage,
    2678             :                           bool ShouldCreate = true);
    2679             : 
    2680           0 :   TempDILabel cloneImpl() const {
    2681             :     return getTemporary(getContext(), getScope(), getName(), getFile(),
    2682           0 :                         getLine());
    2683             :   }
    2684             : 
    2685             : public:
    2686           0 :   DEFINE_MDNODE_GET(DILabel,
    2687             :                     (DILocalScope * Scope, StringRef Name, DIFile *File,
    2688             :                      unsigned Line),
    2689             :                     (Scope, Name, File, Line))
    2690          27 :   DEFINE_MDNODE_GET(DILabel,
    2691             :                     (Metadata * Scope, MDString *Name, Metadata *File,
    2692             :                      unsigned Line),
    2693             :                     (Scope, Name, File, Line))
    2694             : 
    2695             :   TempDILabel clone() const { return cloneImpl(); }
    2696             : 
    2697             :   /// Get the local scope for this label.
    2698             :   ///
    2699             :   /// Labels must be defined in a local scope.
    2700             :   DILocalScope *getScope() const {
    2701             :     return cast_or_null<DILocalScope>(getRawScope());
    2702             :   }
    2703             :   unsigned getLine() const { return Line; }
    2704          13 :   StringRef getName() const { return getStringOperand(1); }
    2705             :   DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
    2706             : 
    2707         169 :   Metadata *getRawScope() const { return getOperand(0); }
    2708             :   MDString *getRawName() const { return getOperandAs<MDString>(1); }
    2709           0 :   Metadata *getRawFile() const { return getOperand(2); }
    2710             : 
    2711             :   /// Check that a location is valid for this label.
    2712             :   ///
    2713             :   /// Check that \c DL exists, is in the same subprogram, and has the same
    2714             :   /// inlined-at location as \c this.  (Otherwise, it's not a valid attachment
    2715             :   /// to a \a DbgInfoIntrinsic.)
    2716             :   bool isValidLocationForIntrinsic(const DILocation *DL) const {
    2717             :     return DL && getScope()->getSubprogram() == DL->getScope()->getSubprogram();
    2718             :   }
    2719             : 
    2720             :   static bool classof(const Metadata *MD) {
    2721           0 :     return MD->getMetadataID() == DILabelKind;
    2722             :   }
    2723             : };
    2724             : 
    2725             : class DIObjCProperty : public DINode {
    2726             :   friend class LLVMContextImpl;
    2727             :   friend class MDNode;
    2728             : 
    2729             :   unsigned Line;
    2730             :   unsigned Attributes;
    2731             : 
    2732             :   DIObjCProperty(LLVMContext &C, StorageType Storage, unsigned Line,
    2733             :                  unsigned Attributes, ArrayRef<Metadata *> Ops)
    2734          91 :       : DINode(C, DIObjCPropertyKind, Storage, dwarf::DW_TAG_APPLE_property,
    2735             :                Ops),
    2736          91 :         Line(Line), Attributes(Attributes) {}
    2737          90 :   ~DIObjCProperty() = default;
    2738             : 
    2739             :   static DIObjCProperty *
    2740          84 :   getImpl(LLVMContext &Context, StringRef Name, DIFile *File, unsigned Line,
    2741             :           StringRef GetterName, StringRef SetterName, unsigned Attributes,
    2742             :           DITypeRef Type, StorageType Storage, bool ShouldCreate = true) {
    2743          84 :     return getImpl(Context, getCanonicalMDString(Context, Name), File, Line,
    2744             :                    getCanonicalMDString(Context, GetterName),
    2745             :                    getCanonicalMDString(Context, SetterName), Attributes, Type,
    2746          84 :                    Storage, ShouldCreate);
    2747             :   }
    2748             :   static DIObjCProperty *getImpl(LLVMContext &Context, MDString *Name,
    2749             :                                  Metadata *File, unsigned Line,
    2750             :                                  MDString *GetterName, MDString *SetterName,
    2751             :                                  unsigned Attributes, Metadata *Type,
    2752             :                                  StorageType Storage, bool ShouldCreate = true);
    2753             : 
    2754           1 :   TempDIObjCProperty cloneImpl() const {
    2755             :     return getTemporary(getContext(), getName(), getFile(), getLine(),
    2756             :                         getGetterName(), getSetterName(), getAttributes(),
    2757           3 :                         getType());
    2758             :   }
    2759             : 
    2760             : public:
    2761          84 :   DEFINE_MDNODE_GET(DIObjCProperty,
    2762             :                     (StringRef Name, DIFile *File, unsigned Line,
    2763             :                      StringRef GetterName, StringRef SetterName,
    2764             :                      unsigned Attributes, DITypeRef Type),
    2765             :                     (Name, File, Line, GetterName, SetterName, Attributes,
    2766             :                      Type))
    2767          39 :   DEFINE_MDNODE_GET(DIObjCProperty,
    2768             :                     (MDString * Name, Metadata *File, unsigned Line,
    2769             :                      MDString *GetterName, MDString *SetterName,
    2770             :                      unsigned Attributes, Metadata *Type),
    2771             :                     (Name, File, Line, GetterName, SetterName, Attributes,
    2772             :                      Type))
    2773             : 
    2774           1 :   TempDIObjCProperty clone() const { return cloneImpl(); }
    2775             : 
    2776             :   unsigned getLine() const { return Line; }
    2777             :   unsigned getAttributes() const { return Attributes; }
    2778          64 :   StringRef getName() const { return getStringOperand(0); }
    2779             :   DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
    2780          64 :   StringRef getGetterName() const { return getStringOperand(2); }
    2781          64 :   StringRef getSetterName() const { return getStringOperand(3); }
    2782             :   DITypeRef getType() const { return DITypeRef(getRawType()); }
    2783             : 
    2784             :   StringRef getFilename() const {
    2785             :     if (auto *F = getFile())
    2786             :       return F->getFilename();
    2787             :     return "";
    2788             :   }
    2789             : 
    2790             :   StringRef getDirectory() const {
    2791             :     if (auto *F = getFile())
    2792             :       return F->getDirectory();
    2793             :     return "";
    2794             :   }
    2795             : 
    2796             :   Optional<StringRef> getSource() const {
    2797             :     if (auto *F = getFile())
    2798             :       return F->getSource();
    2799             :     return None;
    2800             :   }
    2801             : 
    2802             :   MDString *getRawName() const { return getOperandAs<MDString>(0); }
    2803         203 :   Metadata *getRawFile() const { return getOperand(1); }
    2804             :   MDString *getRawGetterName() const { return getOperandAs<MDString>(2); }
    2805             :   MDString *getRawSetterName() const { return getOperandAs<MDString>(3); }
    2806         118 :   Metadata *getRawType() const { return getOperand(4); }
    2807             : 
    2808             :   static bool classof(const Metadata *MD) {
    2809             :     return MD->getMetadataID() == DIObjCPropertyKind;
    2810             :   }
    2811             : };
    2812             : 
    2813             : /// An imported module (C++ using directive or similar).
    2814             : class DIImportedEntity : public DINode {
    2815             :   friend class LLVMContextImpl;
    2816             :   friend class MDNode;
    2817             : 
    2818             :   unsigned Line;
    2819             : 
    2820             :   DIImportedEntity(LLVMContext &C, StorageType Storage, unsigned Tag,
    2821             :                    unsigned Line, ArrayRef<Metadata *> Ops)
    2822      191076 :       : DINode(C, DIImportedEntityKind, Storage, Tag, Ops), Line(Line) {}
    2823         352 :   ~DIImportedEntity() = default;
    2824             : 
    2825       95251 :   static DIImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
    2826             :                                    DIScope *Scope, DINodeRef Entity,
    2827             :                                    DIFile *File, unsigned Line, StringRef Name,
    2828             :                                    StorageType Storage,
    2829             :                                    bool ShouldCreate = true) {
    2830       95251 :     return getImpl(Context, Tag, Scope, Entity, File, Line,
    2831       95251 :                    getCanonicalMDString(Context, Name), Storage, ShouldCreate);
    2832             :   }
    2833             :   static DIImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
    2834             :                                    Metadata *Scope, Metadata *Entity,
    2835             :                                    Metadata *File, unsigned Line,
    2836             :                                    MDString *Name, StorageType Storage,
    2837             :                                    bool ShouldCreate = true);
    2838             : 
    2839           1 :   TempDIImportedEntity cloneImpl() const {
    2840             :     return getTemporary(getContext(), getTag(), getScope(), getEntity(),
    2841           3 :                         getFile(), getLine(), getName());
    2842             :   }
    2843             : 
    2844             : public:
    2845       95251 :   DEFINE_MDNODE_GET(DIImportedEntity,
    2846             :                     (unsigned Tag, DIScope *Scope, DINodeRef Entity,
    2847             :                      DIFile *File, unsigned Line, StringRef Name = ""),
    2848             :                     (Tag, Scope, Entity, File, Line, Name))
    2849         293 :   DEFINE_MDNODE_GET(DIImportedEntity,
    2850             :                     (unsigned Tag, Metadata *Scope, Metadata *Entity,
    2851             :                      Metadata *File, unsigned Line, MDString *Name),
    2852             :                     (Tag, Scope, Entity, File, Line, Name))
    2853             : 
    2854           1 :   TempDIImportedEntity clone() const { return cloneImpl(); }
    2855             : 
    2856             :   unsigned getLine() const { return Line; }
    2857             :   DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
    2858             :   DINodeRef getEntity() const { return DINodeRef(getRawEntity()); }
    2859       95500 :   StringRef getName() const { return getStringOperand(2); }
    2860             :   DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
    2861             : 
    2862      580010 :   Metadata *getRawScope() const { return getOperand(0); }
    2863       95424 :   Metadata *getRawEntity() const { return getOperand(1); }
    2864             :   MDString *getRawName() const { return getOperandAs<MDString>(2); }
    2865           2 :   Metadata *getRawFile() const { return getOperand(3); }
    2866             : 
    2867             :   static bool classof(const Metadata *MD) {
    2868             :     return MD->getMetadataID() == DIImportedEntityKind;
    2869             :   }
    2870             : };
    2871             : 
    2872             : /// A pair of DIGlobalVariable and DIExpression.
    2873             : class DIGlobalVariableExpression : public MDNode {
    2874             :   friend class LLVMContextImpl;
    2875             :   friend class MDNode;
    2876             : 
    2877             :   DIGlobalVariableExpression(LLVMContext &C, StorageType Storage,
    2878             :                              ArrayRef<Metadata *> Ops)
    2879        9216 :       : MDNode(C, DIGlobalVariableExpressionKind, Storage, Ops) {}
    2880        1436 :   ~DIGlobalVariableExpression() = default;
    2881             : 
    2882             :   static DIGlobalVariableExpression *
    2883             :   getImpl(LLVMContext &Context, Metadata *Variable, Metadata *Expression,
    2884             :           StorageType Storage, bool ShouldCreate = true);
    2885             : 
    2886           2 :   TempDIGlobalVariableExpression cloneImpl() const {
    2887           2 :     return getTemporary(getContext(), getVariable(), getExpression());
    2888             :   }
    2889             : 
    2890             : public:
    2891        4611 :   DEFINE_MDNODE_GET(DIGlobalVariableExpression,
    2892             :                     (Metadata * Variable, Metadata *Expression),
    2893             :                     (Variable, Expression))
    2894             : 
    2895           1 :   TempDIGlobalVariableExpression clone() const { return cloneImpl(); }
    2896             : 
    2897       28319 :   Metadata *getRawVariable() const { return getOperand(0); }
    2898             : 
    2899             :   DIGlobalVariable *getVariable() const {
    2900             :     return cast_or_null<DIGlobalVariable>(getRawVariable());
    2901             :   }
    2902             : 
    2903           7 :   Metadata *getRawExpression() const { return getOperand(1); }
    2904             : 
    2905             :   DIExpression *getExpression() const {
    2906             :     return cast<DIExpression>(getRawExpression());
    2907             :   }
    2908             : 
    2909             :   static bool classof(const Metadata *MD) {
    2910        3400 :     return MD->getMetadataID() == DIGlobalVariableExpressionKind;
    2911             :   }
    2912             : };
    2913             : 
    2914             : /// Macro Info DWARF-like metadata node.
    2915             : ///
    2916             : /// A metadata node with a DWARF macro info (i.e., a constant named
    2917             : /// \c DW_MACINFO_*, defined in llvm/BinaryFormat/Dwarf.h).  Called \a
    2918             : /// DIMacroNode
    2919             : /// because it's potentially used for non-DWARF output.
    2920             : class DIMacroNode : public MDNode {
    2921             :   friend class LLVMContextImpl;
    2922             :   friend class MDNode;
    2923             : 
    2924             : protected:
    2925             :   DIMacroNode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned MIType,
    2926             :               ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None)
    2927        1179 :       : MDNode(C, ID, Storage, Ops1, Ops2) {
    2928             :     assert(MIType < 1u << 16);
    2929        1179 :     SubclassData16 = MIType;
    2930             :   }
    2931             :   ~DIMacroNode() = default;
    2932             : 
    2933             :   template <class Ty> Ty *getOperandAs(unsigned I) const {
    2934        7986 :     return cast_or_null<Ty>(getOperand(I));
    2935             :   }
    2936             : 
    2937        4418 :   StringRef getStringOperand(unsigned I) const {
    2938             :     if (auto *S = getOperandAs<MDString>(I))
    2939        4331 :       return S->getString();
    2940          87 :     return StringRef();
    2941             :   }
    2942             : 
    2943             :   static MDString *getCanonicalMDString(LLVMContext &Context, StringRef S) {
    2944        2144 :     if (S.empty())
    2945             :       return nullptr;
    2946        2097 :     return MDString::get(Context, S);
    2947             :   }
    2948             : 
    2949             : public:
    2950        5975 :   unsigned getMacinfoType() const { return SubclassData16; }
    2951             : 
    2952             :   static bool classof(const Metadata *MD) {
    2953        1205 :     switch (MD->getMetadataID()) {
    2954             :     default:
    2955             :       return false;
    2956             :     case DIMacroKind:
    2957             :     case DIMacroFileKind:
    2958             :       return true;
    2959             :     }
    2960             :   }
    2961             : };
    2962             : 
    2963             : class DIMacro : public DIMacroNode {
    2964             :   friend class LLVMContextImpl;
    2965             :   friend class MDNode;
    2966             : 
    2967             :   unsigned Line;
    2968             : 
    2969             :   DIMacro(LLVMContext &C, StorageType Storage, unsigned MIType, unsigned Line,
    2970             :           ArrayRef<Metadata *> Ops)
    2971        2194 :       : DIMacroNode(C, DIMacroKind, Storage, MIType, Ops), Line(Line) {}
    2972        1097 :   ~DIMacro() = default;
    2973             : 
    2974        1072 :   static DIMacro *getImpl(LLVMContext &Context, unsigned MIType, unsigned Line,
    2975             :                           StringRef Name, StringRef Value, StorageType Storage,
    2976             :                           bool ShouldCreate = true) {
    2977        1072 :     return getImpl(Context, MIType, Line, getCanonicalMDString(Context, Name),
    2978        1072 :                    getCanonicalMDString(Context, Value), Storage, ShouldCreate);
    2979             :   }
    2980             :   static DIMacro *getImpl(LLVMContext &Context, unsigned MIType, unsigned Line,
    2981             :                           MDString *Name, MDString *Value, StorageType Storage,
    2982             :                           bool ShouldCreate = true);
    2983             : 
    2984           0 :   TempDIMacro cloneImpl() const {
    2985             :     return getTemporary(getContext(), getMacinfoType(), getLine(), getName(),
    2986           0 :                         getValue());
    2987             :   }
    2988             : 
    2989             : public:
    2990        1072 :   DEFINE_MDNODE_GET(DIMacro, (unsigned MIType, unsigned Line, StringRef Name,
    2991             :                               StringRef Value = ""),
    2992             :                     (MIType, Line, Name, Value))
    2993          34 :   DEFINE_MDNODE_GET(DIMacro, (unsigned MIType, unsigned Line, MDString *Name,
    2994             :                               MDString *Value),
    2995             :                     (MIType, Line, Name, Value))
    2996             : 
    2997             :   TempDIMacro clone() const { return cloneImpl(); }
    2998             : 
    2999             :   unsigned getLine() const { return Line; }
    3000             : 
    3001        2209 :   StringRef getName() const { return getStringOperand(0); }
    3002        2209 :   StringRef getValue() const { return getStringOperand(1); }
    3003             : 
    3004             :   MDString *getRawName() const { return getOperandAs<MDString>(0); }
    3005             :   MDString *getRawValue() const { return getOperandAs<MDString>(1); }
    3006             : 
    3007             :   static bool classof(const Metadata *MD) {
    3008           7 :     return MD->getMetadataID() == DIMacroKind;
    3009             :   }
    3010             : };
    3011             : 
    3012             : class DIMacroFile : public DIMacroNode {
    3013             :   friend class LLVMContextImpl;
    3014             :   friend class MDNode;
    3015             : 
    3016             :   unsigned Line;
    3017             : 
    3018             :   DIMacroFile(LLVMContext &C, StorageType Storage, unsigned MIType,
    3019             :               unsigned Line, ArrayRef<Metadata *> Ops)
    3020         164 :       : DIMacroNode(C, DIMacroFileKind, Storage, MIType, Ops), Line(Line) {}
    3021          82 :   ~DIMacroFile() = default;
    3022             : 
    3023             :   static DIMacroFile *getImpl(LLVMContext &Context, unsigned MIType,
    3024             :                               unsigned Line, DIFile *File,
    3025             :                               DIMacroNodeArray Elements, StorageType Storage,
    3026             :                               bool ShouldCreate = true) {
    3027             :     return getImpl(Context, MIType, Line, static_cast<Metadata *>(File),
    3028          38 :                    Elements.get(), Storage, ShouldCreate);
    3029             :   }
    3030             : 
    3031             :   static DIMacroFile *getImpl(LLVMContext &Context, unsigned MIType,
    3032             :                               unsigned Line, Metadata *File, Metadata *Elements,
    3033             :                               StorageType Storage, bool ShouldCreate = true);
    3034             : 
    3035           0 :   TempDIMacroFile cloneImpl() const {
    3036             :     return getTemporary(getContext(), getMacinfoType(), getLine(), getFile(),
    3037           0 :                         getElements());
    3038             :   }
    3039             : 
    3040             : public:
    3041             :   DEFINE_MDNODE_GET(DIMacroFile, (unsigned MIType, unsigned Line, DIFile *File,
    3042             :                                   DIMacroNodeArray Elements),
    3043             :                     (MIType, Line, File, Elements))
    3044          46 :   DEFINE_MDNODE_GET(DIMacroFile, (unsigned MIType, unsigned Line,
    3045             :                                   Metadata *File, Metadata *Elements),
    3046             :                     (MIType, Line, File, Elements))
    3047             : 
    3048             :   TempDIMacroFile clone() const { return cloneImpl(); }
    3049             : 
    3050             :   void replaceElements(DIMacroNodeArray Elements) {
    3051             : #ifndef NDEBUG
    3052             :     for (DIMacroNode *Op : getElements())
    3053             :       assert(is_contained(Elements->operands(), Op) &&
    3054             :              "Lost a macro node during macro node list replacement");
    3055             : #endif
    3056             :     replaceOperandWith(1, Elements.get());
    3057             :   }
    3058             : 
    3059             :   unsigned getLine() const { return Line; }
    3060             :   DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
    3061             : 
    3062             :   DIMacroNodeArray getElements() const {
    3063             :     return cast_or_null<MDTuple>(getRawElements());
    3064             :   }
    3065             : 
    3066         278 :   Metadata *getRawFile() const { return getOperand(0); }
    3067           2 :   Metadata *getRawElements() const { return getOperand(1); }
    3068             : 
    3069             :   static bool classof(const Metadata *MD) {
    3070             :     return MD->getMetadataID() == DIMacroFileKind;
    3071             :   }
    3072             : };
    3073             : 
    3074             : } // end namespace llvm
    3075             : 
    3076             : #undef DEFINE_MDNODE_GET_UNPACK_IMPL
    3077             : #undef DEFINE_MDNODE_GET_UNPACK
    3078             : #undef DEFINE_MDNODE_GET
    3079             : 
    3080             : #endif // LLVM_IR_DEBUGINFOMETADATA_H

Generated by: LCOV version 1.13