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/IR/Metadata.h"
18#include "llvm/Support/Dwarf.h"
19
20// Helper macros for defining get() overrides.
21#define DEFINE_MDNODE_GET_UNPACK_IMPL(...) __VA_ARGS__
22#define DEFINE_MDNODE_GET_UNPACK(ARGS) DEFINE_MDNODE_GET_UNPACK_IMPL ARGS
23#define DEFINE_MDNODE_GET(CLASS, FORMAL, ARGS)                                 \
24  static CLASS *get(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK(FORMAL)) {  \
25    return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Uniqued);          \
26  }                                                                            \
27  static CLASS *getIfExists(LLVMContext &Context,                              \
28                            DEFINE_MDNODE_GET_UNPACK(FORMAL)) {                \
29    return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Uniqued,           \
30                   /* ShouldCreate */ false);                                  \
31  }                                                                            \
32  static CLASS *getDistinct(LLVMContext &Context,                              \
33                            DEFINE_MDNODE_GET_UNPACK(FORMAL)) {                \
34    return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Distinct);         \
35  }                                                                            \
36  static Temp##CLASS getTemporary(LLVMContext &Context,                        \
37                                  DEFINE_MDNODE_GET_UNPACK(FORMAL)) {          \
38    return Temp##CLASS(                                                        \
39        getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Temporary));          \
40  }
41
42namespace llvm {
43
44/// \brief Pointer union between a subclass of DebugNode and MDString.
45///
46/// \a MDCompositeType can be referenced via an \a MDString unique identifier.
47/// This class allows some type safety in the face of that, requiring either a
48/// node of a particular type or an \a MDString.
49template <class T> class TypedDebugNodeRef {
50  const Metadata *MD = nullptr;
51
52public:
53  TypedDebugNodeRef() = default;
54  TypedDebugNodeRef(std::nullptr_t) {}
55
56  /// \brief Construct from a raw pointer.
57  explicit TypedDebugNodeRef(const Metadata *MD) : MD(MD) {
58    assert((!MD || isa<MDString>(MD) || isa<T>(MD)) && "Expected valid ref");
59  }
60
61  template <class U>
62  TypedDebugNodeRef(
63      const TypedDebugNodeRef<U> &X,
64      typename std::enable_if<std::is_convertible<U *, T *>::value>::type * =
65          nullptr)
66      : MD(X) {}
67
68  operator Metadata *() const { return const_cast<Metadata *>(MD); }
69
70  bool operator==(const TypedDebugNodeRef<T> &X) const { return MD == X.MD; };
71  bool operator!=(const TypedDebugNodeRef<T> &X) const { return MD != X.MD; };
72
73  /// \brief Create a reference.
74  ///
75  /// Get a reference to \c N, using an \a MDString reference if available.
76  static TypedDebugNodeRef get(const T *N);
77
78  template <class MapTy> T *resolve(const MapTy &Map) const {
79    if (!MD)
80      return nullptr;
81
82    if (auto *Typed = dyn_cast<T>(MD))
83      return const_cast<T *>(Typed);
84
85    auto *S = cast<MDString>(MD);
86    auto I = Map.find(S);
87    assert(I != Map.end() && "Missing identifier in type map");
88    return cast<T>(I->second);
89  }
90};
91
92typedef TypedDebugNodeRef<DebugNode> DebugNodeRef;
93typedef TypedDebugNodeRef<MDScope> MDScopeRef;
94typedef TypedDebugNodeRef<MDType> MDTypeRef;
95
96class MDTypeRefArray {
97  const MDTuple *N = nullptr;
98
99public:
100  MDTypeRefArray(const MDTuple *N) : N(N) {}
101
102  explicit operator bool() const { return get(); }
103  explicit operator MDTuple *() const { return get(); }
104
105  MDTuple *get() const { return const_cast<MDTuple *>(N); }
106  MDTuple *operator->() const { return get(); }
107  MDTuple &operator*() const { return *get(); }
108
109  // FIXME: Fix callers and remove condition on N.
110  unsigned size() const { return N ? N->getNumOperands() : 0u; }
111  MDTypeRef operator[](unsigned I) const { return MDTypeRef(N->getOperand(I)); }
112
113  class iterator : std::iterator<std::input_iterator_tag, MDTypeRef,
114                                 std::ptrdiff_t, void, MDTypeRef> {
115    MDNode::op_iterator I = nullptr;
116
117  public:
118    iterator() = default;
119    explicit iterator(MDNode::op_iterator I) : I(I) {}
120    MDTypeRef operator*() const { return MDTypeRef(*I); }
121    iterator &operator++() {
122      ++I;
123      return *this;
124    }
125    iterator operator++(int) {
126      iterator Temp(*this);
127      ++I;
128      return Temp;
129    }
130    bool operator==(const iterator &X) const { return I == X.I; }
131    bool operator!=(const iterator &X) const { return I != X.I; }
132  };
133
134  // FIXME: Fix callers and remove condition on N.
135  iterator begin() const { return N ? iterator(N->op_begin()) : iterator(); }
136  iterator end() const { return N ? iterator(N->op_end()) : iterator(); }
137};
138
139/// \brief Tagged DWARF-like metadata node.
140///
141/// A metadata node with a DWARF tag (i.e., a constant named \c DW_TAG_*,
142/// defined in llvm/Support/Dwarf.h).  Called \a DebugNode because it's
143/// potentially used for non-DWARF output.
144class DebugNode : public MDNode {
145  friend class LLVMContextImpl;
146  friend class MDNode;
147
148protected:
149  DebugNode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
150            ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None)
151      : MDNode(C, ID, Storage, Ops1, Ops2) {
152    assert(Tag < 1u << 16);
153    SubclassData16 = Tag;
154  }
155  ~DebugNode() = default;
156
157  template <class Ty> Ty *getOperandAs(unsigned I) const {
158    return cast_or_null<Ty>(getOperand(I));
159  }
160
161  StringRef getStringOperand(unsigned I) const {
162    if (auto *S = getOperandAs<MDString>(I))
163      return S->getString();
164    return StringRef();
165  }
166
167  static MDString *getCanonicalMDString(LLVMContext &Context, StringRef S) {
168    if (S.empty())
169      return nullptr;
170    return MDString::get(Context, S);
171  }
172
173public:
174  unsigned getTag() const { return SubclassData16; }
175
176  /// \brief Debug info flags.
177  ///
178  /// The three accessibility flags are mutually exclusive and rolled together
179  /// in the first two bits.
180  enum DIFlags {
181#define HANDLE_DI_FLAG(ID, NAME) Flag##NAME = ID,
182#include "llvm/IR/DebugInfoFlags.def"
183    FlagAccessibility = FlagPrivate | FlagProtected | FlagPublic
184  };
185
186  static unsigned getFlag(StringRef Flag);
187  static const char *getFlagString(unsigned Flag);
188
189  /// \brief Split up a flags bitfield.
190  ///
191  /// Split \c Flags into \c SplitFlags, a vector of its components.  Returns
192  /// any remaining (unrecognized) bits.
193  static unsigned splitFlags(unsigned Flags,
194                             SmallVectorImpl<unsigned> &SplitFlags);
195
196  DebugNodeRef getRef() const { return DebugNodeRef::get(this); }
197
198  static bool classof(const Metadata *MD) {
199    switch (MD->getMetadataID()) {
200    default:
201      return false;
202    case GenericDebugNodeKind:
203    case MDSubrangeKind:
204    case MDEnumeratorKind:
205    case MDBasicTypeKind:
206    case MDDerivedTypeKind:
207    case MDCompositeTypeKind:
208    case MDSubroutineTypeKind:
209    case MDFileKind:
210    case MDCompileUnitKind:
211    case MDSubprogramKind:
212    case MDLexicalBlockKind:
213    case MDLexicalBlockFileKind:
214    case MDNamespaceKind:
215    case MDTemplateTypeParameterKind:
216    case MDTemplateValueParameterKind:
217    case MDGlobalVariableKind:
218    case MDLocalVariableKind:
219    case MDObjCPropertyKind:
220    case MDImportedEntityKind:
221      return true;
222    }
223  }
224};
225
226template <class T>
227struct simplify_type<const TypedDebugNodeRef<T>> {
228  typedef Metadata *SimpleType;
229  static SimpleType getSimplifiedValue(const TypedDebugNodeRef<T> &MD) {
230    return MD;
231  }
232};
233
234template <class T>
235struct simplify_type<TypedDebugNodeRef<T>>
236    : simplify_type<const TypedDebugNodeRef<T>> {};
237
238/// \brief Generic tagged DWARF-like metadata node.
239///
240/// An un-specialized DWARF-like metadata node.  The first operand is a
241/// (possibly empty) null-separated \a MDString header that contains arbitrary
242/// fields.  The remaining operands are \a dwarf_operands(), and are pointers
243/// to other metadata.
244class GenericDebugNode : public DebugNode {
245  friend class LLVMContextImpl;
246  friend class MDNode;
247
248  GenericDebugNode(LLVMContext &C, StorageType Storage, unsigned Hash,
249                   unsigned Tag, ArrayRef<Metadata *> Ops1,
250                   ArrayRef<Metadata *> Ops2)
251      : DebugNode(C, GenericDebugNodeKind, Storage, Tag, Ops1, Ops2) {
252    setHash(Hash);
253  }
254  ~GenericDebugNode() { dropAllReferences(); }
255
256  void setHash(unsigned Hash) { SubclassData32 = Hash; }
257  void recalculateHash();
258
259  static GenericDebugNode *getImpl(LLVMContext &Context, unsigned Tag,
260                                   StringRef Header,
261                                   ArrayRef<Metadata *> DwarfOps,
262                                   StorageType Storage,
263                                   bool ShouldCreate = true) {
264    return getImpl(Context, Tag, getCanonicalMDString(Context, Header),
265                   DwarfOps, Storage, ShouldCreate);
266  }
267
268  static GenericDebugNode *getImpl(LLVMContext &Context, unsigned Tag,
269                                   MDString *Header,
270                                   ArrayRef<Metadata *> DwarfOps,
271                                   StorageType Storage,
272                                   bool ShouldCreate = true);
273
274  TempGenericDebugNode cloneImpl() const {
275    return getTemporary(
276        getContext(), getTag(), getHeader(),
277        SmallVector<Metadata *, 4>(dwarf_op_begin(), dwarf_op_end()));
278  }
279
280public:
281  unsigned getHash() const { return SubclassData32; }
282
283  DEFINE_MDNODE_GET(GenericDebugNode, (unsigned Tag, StringRef Header,
284                                       ArrayRef<Metadata *> DwarfOps),
285                    (Tag, Header, DwarfOps))
286  DEFINE_MDNODE_GET(GenericDebugNode, (unsigned Tag, MDString *Header,
287                                       ArrayRef<Metadata *> DwarfOps),
288                    (Tag, Header, DwarfOps))
289
290  /// \brief Return a (temporary) clone of this.
291  TempGenericDebugNode clone() const { return cloneImpl(); }
292
293  unsigned getTag() const { return SubclassData16; }
294  StringRef getHeader() const { return getStringOperand(0); }
295
296  op_iterator dwarf_op_begin() const { return op_begin() + 1; }
297  op_iterator dwarf_op_end() const { return op_end(); }
298  op_range dwarf_operands() const {
299    return op_range(dwarf_op_begin(), dwarf_op_end());
300  }
301
302  unsigned getNumDwarfOperands() const { return getNumOperands() - 1; }
303  const MDOperand &getDwarfOperand(unsigned I) const {
304    return getOperand(I + 1);
305  }
306  void replaceDwarfOperandWith(unsigned I, Metadata *New) {
307    replaceOperandWith(I + 1, New);
308  }
309
310  static bool classof(const Metadata *MD) {
311    return MD->getMetadataID() == GenericDebugNodeKind;
312  }
313};
314
315/// \brief Array subrange.
316///
317/// TODO: Merge into node for DW_TAG_array_type, which should have a custom
318/// type.
319class MDSubrange : public DebugNode {
320  friend class LLVMContextImpl;
321  friend class MDNode;
322
323  int64_t Count;
324  int64_t LowerBound;
325
326  MDSubrange(LLVMContext &C, StorageType Storage, int64_t Count,
327             int64_t LowerBound)
328      : DebugNode(C, MDSubrangeKind, Storage, dwarf::DW_TAG_subrange_type,
329                  None),
330        Count(Count), LowerBound(LowerBound) {}
331  ~MDSubrange() = default;
332
333  static MDSubrange *getImpl(LLVMContext &Context, int64_t Count,
334                             int64_t LowerBound, StorageType Storage,
335                             bool ShouldCreate = true);
336
337  TempMDSubrange cloneImpl() const {
338    return getTemporary(getContext(), getCount(), getLowerBound());
339  }
340
341public:
342  DEFINE_MDNODE_GET(MDSubrange, (int64_t Count, int64_t LowerBound = 0),
343                    (Count, LowerBound))
344
345  TempMDSubrange clone() const { return cloneImpl(); }
346
347  int64_t getLowerBound() const { return LowerBound; }
348  int64_t getCount() const { return Count; }
349
350  static bool classof(const Metadata *MD) {
351    return MD->getMetadataID() == MDSubrangeKind;
352  }
353};
354
355/// \brief Enumeration value.
356///
357/// TODO: Add a pointer to the context (DW_TAG_enumeration_type) once that no
358/// longer creates a type cycle.
359class MDEnumerator : public DebugNode {
360  friend class LLVMContextImpl;
361  friend class MDNode;
362
363  int64_t Value;
364
365  MDEnumerator(LLVMContext &C, StorageType Storage, int64_t Value,
366               ArrayRef<Metadata *> Ops)
367      : DebugNode(C, MDEnumeratorKind, Storage, dwarf::DW_TAG_enumerator, Ops),
368        Value(Value) {}
369  ~MDEnumerator() = default;
370
371  static MDEnumerator *getImpl(LLVMContext &Context, int64_t Value,
372                               StringRef Name, StorageType Storage,
373                               bool ShouldCreate = true) {
374    return getImpl(Context, Value, getCanonicalMDString(Context, Name), Storage,
375                   ShouldCreate);
376  }
377  static MDEnumerator *getImpl(LLVMContext &Context, int64_t Value,
378                               MDString *Name, StorageType Storage,
379                               bool ShouldCreate = true);
380
381  TempMDEnumerator cloneImpl() const {
382    return getTemporary(getContext(), getValue(), getName());
383  }
384
385public:
386  DEFINE_MDNODE_GET(MDEnumerator, (int64_t Value, StringRef Name),
387                    (Value, Name))
388  DEFINE_MDNODE_GET(MDEnumerator, (int64_t Value, MDString *Name),
389                    (Value, Name))
390
391  TempMDEnumerator clone() const { return cloneImpl(); }
392
393  int64_t getValue() const { return Value; }
394  StringRef getName() const { return getStringOperand(0); }
395
396  MDString *getRawName() const { return getOperandAs<MDString>(0); }
397
398  static bool classof(const Metadata *MD) {
399    return MD->getMetadataID() == MDEnumeratorKind;
400  }
401};
402
403/// \brief Base class for scope-like contexts.
404///
405/// Base class for lexical scopes and types (which are also declaration
406/// contexts).
407///
408/// TODO: Separate the concepts of declaration contexts and lexical scopes.
409class MDScope : public DebugNode {
410protected:
411  MDScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
412          ArrayRef<Metadata *> Ops)
413      : DebugNode(C, ID, Storage, Tag, Ops) {}
414  ~MDScope() = default;
415
416public:
417  MDFile *getFile() const { return cast_or_null<MDFile>(getRawFile()); }
418
419  inline StringRef getFilename() const;
420  inline StringRef getDirectory() const;
421
422  StringRef getName() const;
423  MDScopeRef getScope() const;
424
425  /// \brief Return the raw underlying file.
426  ///
427  /// An \a MDFile is an \a MDScope, but it doesn't point at a separate file
428  /// (it\em is the file).  If \c this is an \a MDFile, we need to return \c
429  /// this.  Otherwise, return the first operand, which is where all other
430  /// subclasses store their file pointer.
431  Metadata *getRawFile() const {
432    return isa<MDFile>(this) ? const_cast<MDScope *>(this)
433                             : static_cast<Metadata *>(getOperand(0));
434  }
435
436  MDScopeRef getRef() const { return MDScopeRef::get(this); }
437
438  static bool classof(const Metadata *MD) {
439    switch (MD->getMetadataID()) {
440    default:
441      return false;
442    case MDBasicTypeKind:
443    case MDDerivedTypeKind:
444    case MDCompositeTypeKind:
445    case MDSubroutineTypeKind:
446    case MDFileKind:
447    case MDCompileUnitKind:
448    case MDSubprogramKind:
449    case MDLexicalBlockKind:
450    case MDLexicalBlockFileKind:
451    case MDNamespaceKind:
452      return true;
453    }
454  }
455};
456
457/// \brief File.
458///
459/// TODO: Merge with directory/file node (including users).
460/// TODO: Canonicalize paths on creation.
461class MDFile : public MDScope {
462  friend class LLVMContextImpl;
463  friend class MDNode;
464
465  MDFile(LLVMContext &C, StorageType Storage, ArrayRef<Metadata *> Ops)
466      : MDScope(C, MDFileKind, Storage, dwarf::DW_TAG_file_type, Ops) {}
467  ~MDFile() = default;
468
469  static MDFile *getImpl(LLVMContext &Context, StringRef Filename,
470                         StringRef Directory, StorageType Storage,
471                         bool ShouldCreate = true) {
472    return getImpl(Context, getCanonicalMDString(Context, Filename),
473                   getCanonicalMDString(Context, Directory), Storage,
474                   ShouldCreate);
475  }
476  static MDFile *getImpl(LLVMContext &Context, MDString *Filename,
477                         MDString *Directory, StorageType Storage,
478                         bool ShouldCreate = true);
479
480  TempMDFile cloneImpl() const {
481    return getTemporary(getContext(), getFilename(), getDirectory());
482  }
483
484public:
485  DEFINE_MDNODE_GET(MDFile, (StringRef Filename, StringRef Directory),
486                    (Filename, Directory))
487  DEFINE_MDNODE_GET(MDFile, (MDString * Filename, MDString *Directory),
488                    (Filename, Directory))
489
490  TempMDFile clone() const { return cloneImpl(); }
491
492  StringRef getFilename() const { return getStringOperand(0); }
493  StringRef getDirectory() const { return getStringOperand(1); }
494
495  MDString *getRawFilename() const { return getOperandAs<MDString>(0); }
496  MDString *getRawDirectory() const { return getOperandAs<MDString>(1); }
497
498  static bool classof(const Metadata *MD) {
499    return MD->getMetadataID() == MDFileKind;
500  }
501};
502
503StringRef MDScope::getFilename() const {
504  if (auto *F = getFile())
505    return F->getFilename();
506  return "";
507}
508
509StringRef MDScope::getDirectory() const {
510  if (auto *F = getFile())
511    return F->getDirectory();
512  return "";
513}
514
515/// \brief Base class for types.
516///
517/// TODO: Remove the hardcoded name and context, since many types don't use
518/// them.
519/// TODO: Split up flags.
520class MDType : public MDScope {
521  unsigned Line;
522  unsigned Flags;
523  uint64_t SizeInBits;
524  uint64_t AlignInBits;
525  uint64_t OffsetInBits;
526
527protected:
528  MDType(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
529         unsigned Line, uint64_t SizeInBits, uint64_t AlignInBits,
530         uint64_t OffsetInBits, unsigned Flags, ArrayRef<Metadata *> Ops)
531      : MDScope(C, ID, Storage, Tag, Ops), Line(Line), Flags(Flags),
532        SizeInBits(SizeInBits), AlignInBits(AlignInBits),
533        OffsetInBits(OffsetInBits) {}
534  ~MDType() = default;
535
536public:
537  TempMDType clone() const {
538    return TempMDType(cast<MDType>(MDNode::clone().release()));
539  }
540
541  unsigned getLine() const { return Line; }
542  uint64_t getSizeInBits() const { return SizeInBits; }
543  uint64_t getAlignInBits() const { return AlignInBits; }
544  uint64_t getOffsetInBits() const { return OffsetInBits; }
545  unsigned getFlags() const { return Flags; }
546
547  MDScopeRef getScope() const { return MDScopeRef(getRawScope()); }
548  StringRef getName() const { return getStringOperand(2); }
549
550
551  Metadata *getRawScope() const { return getOperand(1); }
552  MDString *getRawName() const { return getOperandAs<MDString>(2); }
553
554  void setFlags(unsigned NewFlags) {
555    assert(!isUniqued() && "Cannot set flags on uniqued nodes");
556    Flags = NewFlags;
557  }
558
559  bool isPrivate() const {
560    return (getFlags() & FlagAccessibility) == FlagPrivate;
561  }
562  bool isProtected() const {
563    return (getFlags() & FlagAccessibility) == FlagProtected;
564  }
565  bool isPublic() const {
566    return (getFlags() & FlagAccessibility) == FlagPublic;
567  }
568  bool isForwardDecl() const { return getFlags() & FlagFwdDecl; }
569  bool isAppleBlockExtension() const { return getFlags() & FlagAppleBlock; }
570  bool isBlockByrefStruct() const { return getFlags() & FlagBlockByrefStruct; }
571  bool isVirtual() const { return getFlags() & FlagVirtual; }
572  bool isArtificial() const { return getFlags() & FlagArtificial; }
573  bool isObjectPointer() const { return getFlags() & FlagObjectPointer; }
574  bool isObjcClassComplete() const {
575    return getFlags() & FlagObjcClassComplete;
576  }
577  bool isVector() const { return getFlags() & FlagVector; }
578  bool isStaticMember() const { return getFlags() & FlagStaticMember; }
579  bool isLValueReference() const { return getFlags() & FlagLValueReference; }
580  bool isRValueReference() const { return getFlags() & FlagRValueReference; }
581
582  MDTypeRef getRef() const { return MDTypeRef::get(this); }
583
584  static bool classof(const Metadata *MD) {
585    switch (MD->getMetadataID()) {
586    default:
587      return false;
588    case MDBasicTypeKind:
589    case MDDerivedTypeKind:
590    case MDCompositeTypeKind:
591    case MDSubroutineTypeKind:
592      return true;
593    }
594  }
595};
596
597/// \brief Basic type, like 'int' or 'float'.
598///
599/// TODO: Split out DW_TAG_unspecified_type.
600/// TODO: Drop unused accessors.
601class MDBasicType : public MDType {
602  friend class LLVMContextImpl;
603  friend class MDNode;
604
605  unsigned Encoding;
606
607  MDBasicType(LLVMContext &C, StorageType Storage, unsigned Tag,
608              uint64_t SizeInBits, uint64_t AlignInBits, unsigned Encoding,
609              ArrayRef<Metadata *> Ops)
610      : MDType(C, MDBasicTypeKind, Storage, Tag, 0, SizeInBits, AlignInBits, 0,
611               0, Ops),
612        Encoding(Encoding) {}
613  ~MDBasicType() = default;
614
615  static MDBasicType *getImpl(LLVMContext &Context, unsigned Tag,
616                              StringRef Name, uint64_t SizeInBits,
617                              uint64_t AlignInBits, unsigned Encoding,
618                              StorageType Storage, bool ShouldCreate = true) {
619    return getImpl(Context, Tag, getCanonicalMDString(Context, Name),
620                   SizeInBits, AlignInBits, Encoding, Storage, ShouldCreate);
621  }
622  static MDBasicType *getImpl(LLVMContext &Context, unsigned Tag,
623                              MDString *Name, uint64_t SizeInBits,
624                              uint64_t AlignInBits, unsigned Encoding,
625                              StorageType Storage, bool ShouldCreate = true);
626
627  TempMDBasicType cloneImpl() const {
628    return getTemporary(getContext(), getTag(), getName(), getSizeInBits(),
629                        getAlignInBits(), getEncoding());
630  }
631
632public:
633  DEFINE_MDNODE_GET(MDBasicType, (unsigned Tag, StringRef Name),
634                    (Tag, Name, 0, 0, 0))
635  DEFINE_MDNODE_GET(MDBasicType,
636                    (unsigned Tag, StringRef Name, uint64_t SizeInBits,
637                     uint64_t AlignInBits, unsigned Encoding),
638                    (Tag, Name, SizeInBits, AlignInBits, Encoding))
639  DEFINE_MDNODE_GET(MDBasicType,
640                    (unsigned Tag, MDString *Name, uint64_t SizeInBits,
641                     uint64_t AlignInBits, unsigned Encoding),
642                    (Tag, Name, SizeInBits, AlignInBits, Encoding))
643
644  TempMDBasicType clone() const { return cloneImpl(); }
645
646  unsigned getEncoding() const { return Encoding; }
647
648  static bool classof(const Metadata *MD) {
649    return MD->getMetadataID() == MDBasicTypeKind;
650  }
651};
652
653/// \brief Base class for MDDerivedType and MDCompositeType.
654///
655/// TODO: Delete; they're not really related.
656class MDDerivedTypeBase : public MDType {
657protected:
658  MDDerivedTypeBase(LLVMContext &C, unsigned ID, StorageType Storage,
659                    unsigned Tag, unsigned Line, uint64_t SizeInBits,
660                    uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
661                    ArrayRef<Metadata *> Ops)
662      : MDType(C, ID, Storage, Tag, Line, SizeInBits, AlignInBits, OffsetInBits,
663               Flags, Ops) {}
664  ~MDDerivedTypeBase() = default;
665
666public:
667  MDTypeRef getBaseType() const { return MDTypeRef(getRawBaseType()); }
668  Metadata *getRawBaseType() const { return getOperand(3); }
669
670  static bool classof(const Metadata *MD) {
671    return MD->getMetadataID() == MDDerivedTypeKind ||
672           MD->getMetadataID() == MDCompositeTypeKind ||
673           MD->getMetadataID() == MDSubroutineTypeKind;
674  }
675};
676
677/// \brief Derived types.
678///
679/// This includes qualified types, pointers, references, friends, typedefs, and
680/// class members.
681///
682/// TODO: Split out members (inheritance, fields, methods, etc.).
683class MDDerivedType : public MDDerivedTypeBase {
684  friend class LLVMContextImpl;
685  friend class MDNode;
686
687  MDDerivedType(LLVMContext &C, StorageType Storage, unsigned Tag,
688                unsigned Line, uint64_t SizeInBits, uint64_t AlignInBits,
689                uint64_t OffsetInBits, unsigned Flags, ArrayRef<Metadata *> Ops)
690      : MDDerivedTypeBase(C, MDDerivedTypeKind, Storage, Tag, Line, SizeInBits,
691                          AlignInBits, OffsetInBits, Flags, Ops) {}
692  ~MDDerivedType() = default;
693
694  static MDDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
695                                StringRef Name, MDFile *File, unsigned Line,
696                                MDScopeRef Scope, MDTypeRef BaseType,
697                                uint64_t SizeInBits, uint64_t AlignInBits,
698                                uint64_t OffsetInBits, unsigned Flags,
699                                Metadata *ExtraData, StorageType Storage,
700                                bool ShouldCreate = true) {
701    return getImpl(Context, Tag, getCanonicalMDString(Context, Name), File,
702                   Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits,
703                   Flags, ExtraData, Storage, ShouldCreate);
704  }
705  static MDDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
706                                MDString *Name, Metadata *File, unsigned Line,
707                                Metadata *Scope, Metadata *BaseType,
708                                uint64_t SizeInBits, uint64_t AlignInBits,
709                                uint64_t OffsetInBits, unsigned Flags,
710                                Metadata *ExtraData, StorageType Storage,
711                                bool ShouldCreate = true);
712
713  TempMDDerivedType cloneImpl() const {
714    return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
715                        getScope(), getBaseType(), getSizeInBits(),
716                        getAlignInBits(), getOffsetInBits(), getFlags(),
717                        getExtraData());
718  }
719
720public:
721  DEFINE_MDNODE_GET(MDDerivedType,
722                    (unsigned Tag, MDString *Name, Metadata *File,
723                     unsigned Line, Metadata *Scope, Metadata *BaseType,
724                     uint64_t SizeInBits, uint64_t AlignInBits,
725                     uint64_t OffsetInBits, unsigned Flags,
726                     Metadata *ExtraData = nullptr),
727                    (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
728                     AlignInBits, OffsetInBits, Flags, ExtraData))
729  DEFINE_MDNODE_GET(MDDerivedType,
730                    (unsigned Tag, StringRef Name, MDFile *File, unsigned Line,
731                     MDScopeRef Scope, MDTypeRef BaseType, uint64_t SizeInBits,
732                     uint64_t AlignInBits, uint64_t OffsetInBits,
733                     unsigned Flags, Metadata *ExtraData = nullptr),
734                    (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
735                     AlignInBits, OffsetInBits, Flags, ExtraData))
736
737  TempMDDerivedType clone() const { return cloneImpl(); }
738
739  /// \brief Get extra data associated with this derived type.
740  ///
741  /// Class type for pointer-to-members, objective-c property node for ivars,
742  /// or global constant wrapper for static members.
743  ///
744  /// TODO: Separate out types that need this extra operand: pointer-to-member
745  /// types and member fields (static members and ivars).
746  Metadata *getExtraData() const { return getRawExtraData(); }
747  Metadata *getRawExtraData() const { return getOperand(4); }
748
749  /// \brief Get casted version of extra data.
750  /// @{
751  MDTypeRef getClassType() const {
752    assert(getTag() == dwarf::DW_TAG_ptr_to_member_type);
753    return MDTypeRef(getExtraData());
754  }
755  MDObjCProperty *getObjCProperty() const {
756    return dyn_cast_or_null<MDObjCProperty>(getExtraData());
757  }
758  Constant *getConstant() const {
759    assert(getTag() == dwarf::DW_TAG_member && isStaticMember());
760    if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
761      return C->getValue();
762    return nullptr;
763  }
764  /// @}
765
766  static bool classof(const Metadata *MD) {
767    return MD->getMetadataID() == MDDerivedTypeKind;
768  }
769};
770
771/// \brief Base class for MDCompositeType and MDSubroutineType.
772///
773/// TODO: Delete; they're not really related.
774class MDCompositeTypeBase : public MDDerivedTypeBase {
775  unsigned RuntimeLang;
776
777protected:
778  MDCompositeTypeBase(LLVMContext &C, unsigned ID, StorageType Storage,
779                      unsigned Tag, unsigned Line, unsigned RuntimeLang,
780                      uint64_t SizeInBits, uint64_t AlignInBits,
781                      uint64_t OffsetInBits, unsigned Flags,
782                      ArrayRef<Metadata *> Ops)
783      : MDDerivedTypeBase(C, ID, Storage, Tag, Line, SizeInBits, AlignInBits,
784                          OffsetInBits, Flags, Ops),
785        RuntimeLang(RuntimeLang) {}
786  ~MDCompositeTypeBase() = default;
787
788public:
789  /// \brief Get the elements of the composite type.
790  ///
791  /// \note Calling this is only valid for \a MDCompositeType.  This assertion
792  /// can be removed once \a MDSubroutineType has been separated from
793  /// "composite types".
794  DebugNodeArray getElements() const {
795    assert(!isa<MDSubroutineType>(this) && "no elements for DISubroutineType");
796    return cast_or_null<MDTuple>(getRawElements());
797  }
798  MDTypeRef getVTableHolder() const { return MDTypeRef(getRawVTableHolder()); }
799  MDTemplateParameterArray getTemplateParams() const {
800    return cast_or_null<MDTuple>(getRawTemplateParams());
801  }
802  StringRef getIdentifier() const { return getStringOperand(7); }
803  unsigned getRuntimeLang() const { return RuntimeLang; }
804
805  Metadata *getRawElements() const { return getOperand(4); }
806  Metadata *getRawVTableHolder() const { return getOperand(5); }
807  Metadata *getRawTemplateParams() const { return getOperand(6); }
808  MDString *getRawIdentifier() const { return getOperandAs<MDString>(7); }
809
810  /// \brief Replace operands.
811  ///
812  /// If this \a isUniqued() and not \a isResolved(), on a uniquing collision
813  /// this will be RAUW'ed and deleted.  Use a \a TrackingMDRef to keep track
814  /// of its movement if necessary.
815  /// @{
816  void replaceElements(DebugNodeArray Elements) {
817#ifndef NDEBUG
818    for (DebugNode *Op : getElements())
819      assert(std::find(Elements->op_begin(), Elements->op_end(), Op) &&
820             "Lost a member during member list replacement");
821#endif
822    replaceOperandWith(4, Elements.get());
823  }
824  void replaceVTableHolder(MDTypeRef VTableHolder) {
825    replaceOperandWith(5, VTableHolder);
826  }
827  void replaceTemplateParams(MDTemplateParameterArray TemplateParams) {
828    replaceOperandWith(6, TemplateParams.get());
829  }
830  /// @}
831
832  static bool classof(const Metadata *MD) {
833    return MD->getMetadataID() == MDCompositeTypeKind ||
834           MD->getMetadataID() == MDSubroutineTypeKind;
835  }
836};
837
838/// \brief Composite types.
839///
840/// TODO: Detach from DerivedTypeBase (split out MDEnumType?).
841/// TODO: Create a custom, unrelated node for DW_TAG_array_type.
842class MDCompositeType : public MDCompositeTypeBase {
843  friend class LLVMContextImpl;
844  friend class MDNode;
845
846  MDCompositeType(LLVMContext &C, StorageType Storage, unsigned Tag,
847                  unsigned Line, unsigned RuntimeLang, uint64_t SizeInBits,
848                  uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
849                  ArrayRef<Metadata *> Ops)
850      : MDCompositeTypeBase(C, MDCompositeTypeKind, Storage, Tag, Line,
851                            RuntimeLang, SizeInBits, AlignInBits, OffsetInBits,
852                            Flags, Ops) {}
853  ~MDCompositeType() = default;
854
855  static MDCompositeType *
856  getImpl(LLVMContext &Context, unsigned Tag, StringRef Name, Metadata *File,
857          unsigned Line, MDScopeRef Scope, MDTypeRef BaseType,
858          uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
859          uint64_t Flags, DebugNodeArray Elements, unsigned RuntimeLang,
860          MDTypeRef VTableHolder, MDTemplateParameterArray TemplateParams,
861          StringRef Identifier, StorageType Storage, bool ShouldCreate = true) {
862    return getImpl(
863        Context, Tag, getCanonicalMDString(Context, Name), File, Line, Scope,
864        BaseType, SizeInBits, AlignInBits, OffsetInBits, Flags, Elements.get(),
865        RuntimeLang, VTableHolder, TemplateParams.get(),
866        getCanonicalMDString(Context, Identifier), Storage, ShouldCreate);
867  }
868  static MDCompositeType *
869  getImpl(LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
870          unsigned Line, Metadata *Scope, Metadata *BaseType,
871          uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
872          unsigned Flags, Metadata *Elements, unsigned RuntimeLang,
873          Metadata *VTableHolder, Metadata *TemplateParams,
874          MDString *Identifier, StorageType Storage, bool ShouldCreate = true);
875
876  TempMDCompositeType cloneImpl() const {
877    return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
878                        getScope(), getBaseType(), getSizeInBits(),
879                        getAlignInBits(), getOffsetInBits(), getFlags(),
880                        getElements(), getRuntimeLang(), getVTableHolder(),
881                        getTemplateParams(), getIdentifier());
882  }
883
884public:
885  DEFINE_MDNODE_GET(MDCompositeType,
886                    (unsigned Tag, StringRef Name, MDFile *File, unsigned Line,
887                     MDScopeRef Scope, MDTypeRef BaseType, uint64_t SizeInBits,
888                     uint64_t AlignInBits, uint64_t OffsetInBits,
889                     unsigned Flags, DebugNodeArray Elements,
890                     unsigned RuntimeLang, MDTypeRef VTableHolder,
891                     MDTemplateParameterArray TemplateParams = nullptr,
892                     StringRef Identifier = ""),
893                    (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
894                     AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
895                     VTableHolder, TemplateParams, Identifier))
896  DEFINE_MDNODE_GET(MDCompositeType,
897                    (unsigned Tag, MDString *Name, Metadata *File,
898                     unsigned Line, Metadata *Scope, Metadata *BaseType,
899                     uint64_t SizeInBits, uint64_t AlignInBits,
900                     uint64_t OffsetInBits, unsigned Flags, Metadata *Elements,
901                     unsigned RuntimeLang, Metadata *VTableHolder,
902                     Metadata *TemplateParams = nullptr,
903                     MDString *Identifier = nullptr),
904                    (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
905                     AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
906                     VTableHolder, TemplateParams, Identifier))
907
908  TempMDCompositeType clone() const { return cloneImpl(); }
909
910  static bool classof(const Metadata *MD) {
911    return MD->getMetadataID() == MDCompositeTypeKind;
912  }
913};
914
915template <class T> TypedDebugNodeRef<T> TypedDebugNodeRef<T>::get(const T *N) {
916  if (N)
917    if (auto *Composite = dyn_cast<MDCompositeType>(N))
918      if (auto *S = Composite->getRawIdentifier())
919        return TypedDebugNodeRef<T>(S);
920  return TypedDebugNodeRef<T>(N);
921}
922
923/// \brief Type array for a subprogram.
924///
925/// TODO: Detach from CompositeType, and fold the array of types in directly
926/// as operands.
927class MDSubroutineType : public MDCompositeTypeBase {
928  friend class LLVMContextImpl;
929  friend class MDNode;
930
931  MDSubroutineType(LLVMContext &C, StorageType Storage, unsigned Flags,
932                   ArrayRef<Metadata *> Ops)
933      : MDCompositeTypeBase(C, MDSubroutineTypeKind, Storage,
934                            dwarf::DW_TAG_subroutine_type, 0, 0, 0, 0, 0, Flags,
935                            Ops) {}
936  ~MDSubroutineType() = default;
937
938  static MDSubroutineType *getImpl(LLVMContext &Context, unsigned Flags,
939                                   MDTypeRefArray TypeArray,
940                                   StorageType Storage,
941                                   bool ShouldCreate = true) {
942    return getImpl(Context, Flags, TypeArray.get(), Storage, ShouldCreate);
943  }
944  static MDSubroutineType *getImpl(LLVMContext &Context, unsigned Flags,
945                                   Metadata *TypeArray, StorageType Storage,
946                                   bool ShouldCreate = true);
947
948  TempMDSubroutineType cloneImpl() const {
949    return getTemporary(getContext(), getFlags(), getTypeArray());
950  }
951
952public:
953  DEFINE_MDNODE_GET(MDSubroutineType,
954                    (unsigned Flags, MDTypeRefArray TypeArray),
955                    (Flags, TypeArray))
956  DEFINE_MDNODE_GET(MDSubroutineType, (unsigned Flags, Metadata *TypeArray),
957                    (Flags, TypeArray))
958
959  TempMDSubroutineType clone() const { return cloneImpl(); }
960
961  MDTypeRefArray getTypeArray() const {
962    return cast_or_null<MDTuple>(getRawTypeArray());
963  }
964  Metadata *getRawTypeArray() const { return getRawElements(); }
965
966  static bool classof(const Metadata *MD) {
967    return MD->getMetadataID() == MDSubroutineTypeKind;
968  }
969};
970
971/// \brief Compile unit.
972class MDCompileUnit : public MDScope {
973  friend class LLVMContextImpl;
974  friend class MDNode;
975
976  unsigned SourceLanguage;
977  bool IsOptimized;
978  unsigned RuntimeVersion;
979  unsigned EmissionKind;
980
981  MDCompileUnit(LLVMContext &C, StorageType Storage, unsigned SourceLanguage,
982                bool IsOptimized, unsigned RuntimeVersion,
983                unsigned EmissionKind, ArrayRef<Metadata *> Ops)
984      : MDScope(C, MDCompileUnitKind, Storage, dwarf::DW_TAG_compile_unit, Ops),
985        SourceLanguage(SourceLanguage), IsOptimized(IsOptimized),
986        RuntimeVersion(RuntimeVersion), EmissionKind(EmissionKind) {}
987  ~MDCompileUnit() = default;
988
989  static MDCompileUnit *
990  getImpl(LLVMContext &Context, unsigned SourceLanguage, MDFile *File,
991          StringRef Producer, bool IsOptimized, StringRef Flags,
992          unsigned RuntimeVersion, StringRef SplitDebugFilename,
993          unsigned EmissionKind, MDCompositeTypeArray EnumTypes,
994          MDTypeArray RetainedTypes, MDSubprogramArray Subprograms,
995          MDGlobalVariableArray GlobalVariables,
996          MDImportedEntityArray ImportedEntities, StorageType Storage,
997          bool ShouldCreate = true) {
998    return getImpl(
999        Context, SourceLanguage, File, getCanonicalMDString(Context, Producer),
1000        IsOptimized, getCanonicalMDString(Context, Flags), RuntimeVersion,
1001        getCanonicalMDString(Context, SplitDebugFilename), EmissionKind,
1002        EnumTypes.get(), RetainedTypes.get(), Subprograms.get(),
1003        GlobalVariables.get(), ImportedEntities.get(), Storage, ShouldCreate);
1004  }
1005  static MDCompileUnit *
1006  getImpl(LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
1007          MDString *Producer, bool IsOptimized, MDString *Flags,
1008          unsigned RuntimeVersion, MDString *SplitDebugFilename,
1009          unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
1010          Metadata *Subprograms, Metadata *GlobalVariables,
1011          Metadata *ImportedEntities, StorageType Storage,
1012          bool ShouldCreate = true);
1013
1014  TempMDCompileUnit cloneImpl() const {
1015    return getTemporary(
1016        getContext(), getSourceLanguage(), getFile(), getProducer(),
1017        isOptimized(), getFlags(), getRuntimeVersion(), getSplitDebugFilename(),
1018        getEmissionKind(), getEnumTypes(), getRetainedTypes(), getSubprograms(),
1019        getGlobalVariables(), getImportedEntities());
1020  }
1021
1022public:
1023  DEFINE_MDNODE_GET(MDCompileUnit,
1024                    (unsigned SourceLanguage, MDFile *File, StringRef Producer,
1025                     bool IsOptimized, StringRef Flags, unsigned RuntimeVersion,
1026                     StringRef SplitDebugFilename, unsigned EmissionKind,
1027                     MDCompositeTypeArray EnumTypes, MDTypeArray RetainedTypes,
1028                     MDSubprogramArray Subprograms,
1029                     MDGlobalVariableArray GlobalVariables,
1030                     MDImportedEntityArray ImportedEntities),
1031                    (SourceLanguage, File, Producer, IsOptimized, Flags,
1032                     RuntimeVersion, SplitDebugFilename, EmissionKind,
1033                     EnumTypes, RetainedTypes, Subprograms, GlobalVariables,
1034                     ImportedEntities))
1035  DEFINE_MDNODE_GET(MDCompileUnit,
1036                    (unsigned SourceLanguage, Metadata *File,
1037                     MDString *Producer, bool IsOptimized, MDString *Flags,
1038                     unsigned RuntimeVersion, MDString *SplitDebugFilename,
1039                     unsigned EmissionKind, Metadata *EnumTypes,
1040                     Metadata *RetainedTypes, Metadata *Subprograms,
1041                     Metadata *GlobalVariables, Metadata *ImportedEntities),
1042                    (SourceLanguage, File, Producer, IsOptimized, Flags,
1043                     RuntimeVersion, SplitDebugFilename, EmissionKind,
1044                     EnumTypes, RetainedTypes, Subprograms, GlobalVariables,
1045                     ImportedEntities))
1046
1047  TempMDCompileUnit clone() const { return cloneImpl(); }
1048
1049  unsigned getSourceLanguage() const { return SourceLanguage; }
1050  bool isOptimized() const { return IsOptimized; }
1051  unsigned getRuntimeVersion() const { return RuntimeVersion; }
1052  unsigned getEmissionKind() const { return EmissionKind; }
1053  StringRef getProducer() const { return getStringOperand(1); }
1054  StringRef getFlags() const { return getStringOperand(2); }
1055  StringRef getSplitDebugFilename() const { return getStringOperand(3); }
1056  MDCompositeTypeArray getEnumTypes() const {
1057    return cast_or_null<MDTuple>(getRawEnumTypes());
1058  }
1059  MDTypeArray getRetainedTypes() const {
1060    return cast_or_null<MDTuple>(getRawRetainedTypes());
1061  }
1062  MDSubprogramArray getSubprograms() const {
1063    return cast_or_null<MDTuple>(getRawSubprograms());
1064  }
1065  MDGlobalVariableArray getGlobalVariables() const {
1066    return cast_or_null<MDTuple>(getRawGlobalVariables());
1067  }
1068  MDImportedEntityArray getImportedEntities() const {
1069    return cast_or_null<MDTuple>(getRawImportedEntities());
1070  }
1071
1072  MDString *getRawProducer() const { return getOperandAs<MDString>(1); }
1073  MDString *getRawFlags() const { return getOperandAs<MDString>(2); }
1074  MDString *getRawSplitDebugFilename() const {
1075    return getOperandAs<MDString>(3);
1076  }
1077  Metadata *getRawEnumTypes() const { return getOperand(4); }
1078  Metadata *getRawRetainedTypes() const { return getOperand(5); }
1079  Metadata *getRawSubprograms() const { return getOperand(6); }
1080  Metadata *getRawGlobalVariables() const { return getOperand(7); }
1081  Metadata *getRawImportedEntities() const { return getOperand(8); }
1082
1083  /// \brief Replace arrays.
1084  ///
1085  /// If this \a isUniqued() and not \a isResolved(), it will be RAUW'ed and
1086  /// deleted on a uniquing collision.  In practice, uniquing collisions on \a
1087  /// MDCompileUnit should be fairly rare.
1088  /// @{
1089  void replaceSubprograms(MDSubprogramArray N) {
1090    replaceOperandWith(6, N.get());
1091  }
1092  void replaceGlobalVariables(MDGlobalVariableArray N) {
1093    replaceOperandWith(7, N.get());
1094  }
1095  /// @}
1096
1097  static bool classof(const Metadata *MD) {
1098    return MD->getMetadataID() == MDCompileUnitKind;
1099  }
1100};
1101
1102/// \brief A scope for locals.
1103///
1104/// A legal scope for lexical blocks, local variables, and debug info
1105/// locations.  Subclasses are \a MDSubprogram, \a MDLexicalBlock, and \a
1106/// MDLexicalBlockFile.
1107class MDLocalScope : public MDScope {
1108protected:
1109  MDLocalScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
1110               ArrayRef<Metadata *> Ops)
1111      : MDScope(C, ID, Storage, Tag, Ops) {}
1112  ~MDLocalScope() = default;
1113
1114public:
1115  /// \brief Get the subprogram for this scope.
1116  ///
1117  /// Return this if it's an \a MDSubprogram; otherwise, look up the scope
1118  /// chain.
1119  MDSubprogram *getSubprogram() const;
1120
1121  static bool classof(const Metadata *MD) {
1122    return MD->getMetadataID() == MDSubprogramKind ||
1123           MD->getMetadataID() == MDLexicalBlockKind ||
1124           MD->getMetadataID() == MDLexicalBlockFileKind;
1125  }
1126};
1127
1128/// \brief Debug location.
1129///
1130/// A debug location in source code, used for debug info and otherwise.
1131class MDLocation : public MDNode {
1132  friend class LLVMContextImpl;
1133  friend class MDNode;
1134
1135  MDLocation(LLVMContext &C, StorageType Storage, unsigned Line,
1136             unsigned Column, ArrayRef<Metadata *> MDs);
1137  ~MDLocation() { dropAllReferences(); }
1138
1139  static MDLocation *getImpl(LLVMContext &Context, unsigned Line,
1140                             unsigned Column, Metadata *Scope,
1141                             Metadata *InlinedAt, StorageType Storage,
1142                             bool ShouldCreate = true);
1143  static MDLocation *getImpl(LLVMContext &Context, unsigned Line,
1144                             unsigned Column, MDLocalScope *Scope,
1145                             MDLocation *InlinedAt, StorageType Storage,
1146                             bool ShouldCreate = true) {
1147    return getImpl(Context, Line, Column, static_cast<Metadata *>(Scope),
1148                   static_cast<Metadata *>(InlinedAt), Storage, ShouldCreate);
1149  }
1150
1151  TempMDLocation cloneImpl() const {
1152    return getTemporary(getContext(), getLine(), getColumn(), getScope(),
1153                        getInlinedAt());
1154  }
1155
1156  // Disallow replacing operands.
1157  void replaceOperandWith(unsigned I, Metadata *New) = delete;
1158
1159public:
1160  DEFINE_MDNODE_GET(MDLocation,
1161                    (unsigned Line, unsigned Column, Metadata *Scope,
1162                     Metadata *InlinedAt = nullptr),
1163                    (Line, Column, Scope, InlinedAt))
1164  DEFINE_MDNODE_GET(MDLocation,
1165                    (unsigned Line, unsigned Column, MDLocalScope *Scope,
1166                     MDLocation *InlinedAt = nullptr),
1167                    (Line, Column, Scope, InlinedAt))
1168
1169  /// \brief Return a (temporary) clone of this.
1170  TempMDLocation clone() const { return cloneImpl(); }
1171
1172  unsigned getLine() const { return SubclassData32; }
1173  unsigned getColumn() const { return SubclassData16; }
1174  MDLocalScope *getScope() const {
1175    return cast<MDLocalScope>(getRawScope());
1176  }
1177  MDLocation *getInlinedAt() const {
1178    return cast_or_null<MDLocation>(getRawInlinedAt());
1179  }
1180
1181  MDFile *getFile() const { return getScope()->getFile(); }
1182  StringRef getFilename() const { return getScope()->getFilename(); }
1183  StringRef getDirectory() const { return getScope()->getDirectory(); }
1184
1185  /// \brief Get the scope where this is inlined.
1186  ///
1187  /// Walk through \a getInlinedAt() and return \a getScope() from the deepest
1188  /// location.
1189  MDLocalScope *getInlinedAtScope() const {
1190    if (auto *IA = getInlinedAt())
1191      return IA->getInlinedAtScope();
1192    return getScope();
1193  }
1194
1195  /// \brief Check whether this can be discriminated from another location.
1196  ///
1197  /// Check \c this can be discriminated from \c RHS in a linetable entry.
1198  /// Scope and inlined-at chains are not recorded in the linetable, so they
1199  /// cannot be used to distinguish basic blocks.
1200  ///
1201  /// The current implementation is weaker than it should be, since it just
1202  /// checks filename and line.
1203  ///
1204  /// FIXME: Add a check for getDiscriminator().
1205  /// FIXME: Add a check for getColumn().
1206  /// FIXME: Change the getFilename() check to getFile() (or add one for
1207  /// getDirectory()).
1208  bool canDiscriminate(const MDLocation &RHS) const {
1209    return getFilename() != RHS.getFilename() || getLine() != RHS.getLine();
1210  }
1211
1212  /// \brief Get the DWARF discriminator.
1213  ///
1214  /// DWARF discriminators distinguish identical file locations between
1215  /// instructions that are on different basic blocks.
1216  inline unsigned getDiscriminator() const;
1217
1218  /// \brief Compute new discriminator in the given context.
1219  ///
1220  /// This modifies the \a LLVMContext that \c this is in to increment the next
1221  /// discriminator for \c this's line/filename combination.
1222  ///
1223  /// FIXME: Delete this.  See comments in implementation and at the only call
1224  /// site in \a AddDiscriminators::runOnFunction().
1225  unsigned computeNewDiscriminator() const;
1226
1227  Metadata *getRawScope() const { return getOperand(0); }
1228  Metadata *getRawInlinedAt() const {
1229    if (getNumOperands() == 2)
1230      return getOperand(1);
1231    return nullptr;
1232  }
1233
1234  static bool classof(const Metadata *MD) {
1235    return MD->getMetadataID() == MDLocationKind;
1236  }
1237};
1238
1239/// \brief Subprogram description.
1240///
1241/// TODO: Remove DisplayName.  It's always equal to Name.
1242/// TODO: Split up flags.
1243class MDSubprogram : public MDLocalScope {
1244  friend class LLVMContextImpl;
1245  friend class MDNode;
1246
1247  unsigned Line;
1248  unsigned ScopeLine;
1249  unsigned Virtuality;
1250  unsigned VirtualIndex;
1251  unsigned Flags;
1252  bool IsLocalToUnit;
1253  bool IsDefinition;
1254  bool IsOptimized;
1255
1256  MDSubprogram(LLVMContext &C, StorageType Storage, unsigned Line,
1257               unsigned ScopeLine, unsigned Virtuality, unsigned VirtualIndex,
1258               unsigned Flags, bool IsLocalToUnit, bool IsDefinition,
1259               bool IsOptimized, ArrayRef<Metadata *> Ops)
1260      : MDLocalScope(C, MDSubprogramKind, Storage, dwarf::DW_TAG_subprogram,
1261                     Ops),
1262        Line(Line), ScopeLine(ScopeLine), Virtuality(Virtuality),
1263        VirtualIndex(VirtualIndex), Flags(Flags), IsLocalToUnit(IsLocalToUnit),
1264        IsDefinition(IsDefinition), IsOptimized(IsOptimized) {}
1265  ~MDSubprogram() = default;
1266
1267  static MDSubprogram *
1268  getImpl(LLVMContext &Context, MDScopeRef Scope, StringRef Name,
1269          StringRef LinkageName, MDFile *File, unsigned Line,
1270          MDSubroutineType *Type, bool IsLocalToUnit, bool IsDefinition,
1271          unsigned ScopeLine, MDTypeRef ContainingType, unsigned Virtuality,
1272          unsigned VirtualIndex, unsigned Flags, bool IsOptimized,
1273          Constant *Function, MDTemplateParameterArray TemplateParams,
1274          MDSubprogram *Declaration, MDLocalVariableArray Variables,
1275          StorageType Storage, bool ShouldCreate = true) {
1276    return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
1277                   getCanonicalMDString(Context, LinkageName), File, Line, Type,
1278                   IsLocalToUnit, IsDefinition, ScopeLine, ContainingType,
1279                   Virtuality, VirtualIndex, Flags, IsOptimized,
1280                   Function ? ConstantAsMetadata::get(Function) : nullptr,
1281                   TemplateParams.get(), Declaration, Variables.get(), Storage,
1282                   ShouldCreate);
1283  }
1284  static MDSubprogram *
1285  getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
1286          MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
1287          bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
1288          Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex,
1289          unsigned Flags, bool IsOptimized, Metadata *Function,
1290          Metadata *TemplateParams, Metadata *Declaration, Metadata *Variables,
1291          StorageType Storage, bool ShouldCreate = true);
1292
1293  TempMDSubprogram cloneImpl() const {
1294    return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
1295                        getFile(), getLine(), getType(), isLocalToUnit(),
1296                        isDefinition(), getScopeLine(), getContainingType(),
1297                        getVirtuality(), getVirtualIndex(), getFlags(),
1298                        isOptimized(), getFunctionConstant(),
1299                        getTemplateParams(), getDeclaration(), getVariables());
1300  }
1301
1302public:
1303  DEFINE_MDNODE_GET(MDSubprogram,
1304                    (MDScopeRef Scope, StringRef Name, StringRef LinkageName,
1305                     MDFile *File, unsigned Line, MDSubroutineType *Type,
1306                     bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
1307                     MDTypeRef ContainingType, unsigned Virtuality,
1308                     unsigned VirtualIndex, unsigned Flags, bool IsOptimized,
1309                     Constant *Function = nullptr,
1310                     MDTemplateParameterArray TemplateParams = nullptr,
1311                     MDSubprogram *Declaration = nullptr,
1312                     MDLocalVariableArray Variables = nullptr),
1313                    (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
1314                     IsDefinition, ScopeLine, ContainingType, Virtuality,
1315                     VirtualIndex, Flags, IsOptimized, Function, TemplateParams,
1316                     Declaration, Variables))
1317  DEFINE_MDNODE_GET(
1318      MDSubprogram,
1319      (Metadata * Scope, MDString *Name, MDString *LinkageName, Metadata *File,
1320       unsigned Line, Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
1321       unsigned ScopeLine, Metadata *ContainingType, unsigned Virtuality,
1322       unsigned VirtualIndex, unsigned Flags, bool IsOptimized,
1323       Metadata *Function = nullptr, Metadata *TemplateParams = nullptr,
1324       Metadata *Declaration = nullptr, Metadata *Variables = nullptr),
1325      (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition,
1326       ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags, IsOptimized,
1327       Function, TemplateParams, Declaration, Variables))
1328
1329  TempMDSubprogram clone() const { return cloneImpl(); }
1330
1331public:
1332  unsigned getLine() const { return Line; }
1333  unsigned getVirtuality() const { return Virtuality; }
1334  unsigned getVirtualIndex() const { return VirtualIndex; }
1335  unsigned getScopeLine() const { return ScopeLine; }
1336  unsigned getFlags() const { return Flags; }
1337  bool isLocalToUnit() const { return IsLocalToUnit; }
1338  bool isDefinition() const { return IsDefinition; }
1339  bool isOptimized() const { return IsOptimized; }
1340
1341  unsigned isArtificial() const { return getFlags() & FlagArtificial; }
1342  bool isPrivate() const {
1343    return (getFlags() & FlagAccessibility) == FlagPrivate;
1344  }
1345  bool isProtected() const {
1346    return (getFlags() & FlagAccessibility) == FlagProtected;
1347  }
1348  bool isPublic() const {
1349    return (getFlags() & FlagAccessibility) == FlagPublic;
1350  }
1351  bool isExplicit() const { return getFlags() & FlagExplicit; }
1352  bool isPrototyped() const { return getFlags() & FlagPrototyped; }
1353
1354  /// \brief Check if this is reference-qualified.
1355  ///
1356  /// Return true if this subprogram is a C++11 reference-qualified non-static
1357  /// member function (void foo() &).
1358  unsigned isLValueReference() const {
1359    return getFlags() & FlagLValueReference;
1360  }
1361
1362  /// \brief Check if this is rvalue-reference-qualified.
1363  ///
1364  /// Return true if this subprogram is a C++11 rvalue-reference-qualified
1365  /// non-static member function (void foo() &&).
1366  unsigned isRValueReference() const {
1367    return getFlags() & FlagRValueReference;
1368  }
1369
1370  MDScopeRef getScope() const { return MDScopeRef(getRawScope()); }
1371
1372  StringRef getName() const { return getStringOperand(2); }
1373  StringRef getDisplayName() const { return getStringOperand(3); }
1374  StringRef getLinkageName() const { return getStringOperand(4); }
1375
1376  MDString *getRawName() const { return getOperandAs<MDString>(2); }
1377  MDString *getRawLinkageName() const { return getOperandAs<MDString>(4); }
1378
1379  MDSubroutineType *getType() const {
1380    return cast_or_null<MDSubroutineType>(getRawType());
1381  }
1382  MDTypeRef getContainingType() const {
1383    return MDTypeRef(getRawContainingType());
1384  }
1385
1386  Constant *getFunctionConstant() const {
1387    if (auto *C = cast_or_null<ConstantAsMetadata>(getRawFunction()))
1388      return C->getValue();
1389    return nullptr;
1390  }
1391  MDTemplateParameterArray getTemplateParams() const {
1392    return cast_or_null<MDTuple>(getRawTemplateParams());
1393  }
1394  MDSubprogram *getDeclaration() const {
1395    return cast_or_null<MDSubprogram>(getRawDeclaration());
1396  }
1397  MDLocalVariableArray getVariables() const {
1398    return cast_or_null<MDTuple>(getRawVariables());
1399  }
1400
1401  Metadata *getRawScope() const { return getOperand(1); }
1402  Metadata *getRawType() const { return getOperand(5); }
1403  Metadata *getRawContainingType() const { return getOperand(6); }
1404  Metadata *getRawFunction() const { return getOperand(7); }
1405  Metadata *getRawTemplateParams() const { return getOperand(8); }
1406  Metadata *getRawDeclaration() const { return getOperand(9); }
1407  Metadata *getRawVariables() const { return getOperand(10); }
1408
1409  /// \brief Get a pointer to the function this subprogram describes.
1410  ///
1411  /// This dyn_casts \a getFunctionConstant() to \a Function.
1412  ///
1413  /// FIXME: Should this be looking through bitcasts?
1414  Function *getFunction() const;
1415
1416  /// \brief Replace the function.
1417  ///
1418  /// If \a isUniqued() and not \a isResolved(), this could node will be
1419  /// RAUW'ed and deleted out from under the caller.  Use a \a TrackingMDRef if
1420  /// that's a problem.
1421  /// @{
1422  void replaceFunction(Function *F);
1423  void replaceFunction(ConstantAsMetadata *MD) { replaceOperandWith(7, MD); }
1424  void replaceFunction(std::nullptr_t) { replaceOperandWith(7, nullptr); }
1425  /// @}
1426
1427  /// \brief Check if this subprogram decribes the given function.
1428  ///
1429  /// FIXME: Should this be looking through bitcasts?
1430  bool describes(const Function *F) const;
1431
1432  static bool classof(const Metadata *MD) {
1433    return MD->getMetadataID() == MDSubprogramKind;
1434  }
1435};
1436
1437class MDLexicalBlockBase : public MDLocalScope {
1438protected:
1439  MDLexicalBlockBase(LLVMContext &C, unsigned ID, StorageType Storage,
1440                     ArrayRef<Metadata *> Ops)
1441      : MDLocalScope(C, ID, Storage, dwarf::DW_TAG_lexical_block, Ops) {}
1442  ~MDLexicalBlockBase() = default;
1443
1444public:
1445  MDLocalScope *getScope() const { return cast<MDLocalScope>(getRawScope()); }
1446
1447  Metadata *getRawScope() const { return getOperand(1); }
1448
1449  /// \brief Forwarding accessors to LexicalBlock.
1450  ///
1451  /// TODO: Remove these and update code to use \a MDLexicalBlock directly.
1452  /// @{
1453  inline unsigned getLine() const;
1454  inline unsigned getColumn() const;
1455  /// @}
1456  static bool classof(const Metadata *MD) {
1457    return MD->getMetadataID() == MDLexicalBlockKind ||
1458           MD->getMetadataID() == MDLexicalBlockFileKind;
1459  }
1460};
1461
1462class MDLexicalBlock : public MDLexicalBlockBase {
1463  friend class LLVMContextImpl;
1464  friend class MDNode;
1465
1466  unsigned Line;
1467  unsigned Column;
1468
1469  MDLexicalBlock(LLVMContext &C, StorageType Storage, unsigned Line,
1470                 unsigned Column, ArrayRef<Metadata *> Ops)
1471      : MDLexicalBlockBase(C, MDLexicalBlockKind, Storage, Ops), Line(Line),
1472        Column(Column) {}
1473  ~MDLexicalBlock() = default;
1474
1475  static MDLexicalBlock *getImpl(LLVMContext &Context, MDLocalScope *Scope,
1476                                 MDFile *File, unsigned Line, unsigned Column,
1477                                 StorageType Storage,
1478                                 bool ShouldCreate = true) {
1479    return getImpl(Context, static_cast<Metadata *>(Scope),
1480                   static_cast<Metadata *>(File), Line, Column, Storage,
1481                   ShouldCreate);
1482  }
1483
1484  static MDLexicalBlock *getImpl(LLVMContext &Context, Metadata *Scope,
1485                                 Metadata *File, unsigned Line, unsigned Column,
1486                                 StorageType Storage, bool ShouldCreate = true);
1487
1488  TempMDLexicalBlock cloneImpl() const {
1489    return getTemporary(getContext(), getScope(), getFile(), getLine(),
1490                        getColumn());
1491  }
1492
1493public:
1494  DEFINE_MDNODE_GET(MDLexicalBlock, (MDLocalScope * Scope, MDFile *File,
1495                                     unsigned Line, unsigned Column),
1496                    (Scope, File, Line, Column))
1497  DEFINE_MDNODE_GET(MDLexicalBlock, (Metadata * Scope, Metadata *File,
1498                                     unsigned Line, unsigned Column),
1499                    (Scope, File, Line, Column))
1500
1501  TempMDLexicalBlock clone() const { return cloneImpl(); }
1502
1503  unsigned getLine() const { return Line; }
1504  unsigned getColumn() const { return Column; }
1505
1506  static bool classof(const Metadata *MD) {
1507    return MD->getMetadataID() == MDLexicalBlockKind;
1508  }
1509};
1510
1511unsigned MDLexicalBlockBase::getLine() const {
1512  if (auto *N = dyn_cast<MDLexicalBlock>(this))
1513    return N->getLine();
1514  return 0;
1515}
1516
1517unsigned MDLexicalBlockBase::getColumn() const {
1518  if (auto *N = dyn_cast<MDLexicalBlock>(this))
1519    return N->getColumn();
1520  return 0;
1521}
1522
1523class MDLexicalBlockFile : public MDLexicalBlockBase {
1524  friend class LLVMContextImpl;
1525  friend class MDNode;
1526
1527  unsigned Discriminator;
1528
1529  MDLexicalBlockFile(LLVMContext &C, StorageType Storage,
1530                     unsigned Discriminator, ArrayRef<Metadata *> Ops)
1531      : MDLexicalBlockBase(C, MDLexicalBlockFileKind, Storage, Ops),
1532        Discriminator(Discriminator) {}
1533  ~MDLexicalBlockFile() = default;
1534
1535  static MDLexicalBlockFile *getImpl(LLVMContext &Context, MDLocalScope *Scope,
1536                                     MDFile *File, unsigned Discriminator,
1537                                     StorageType Storage,
1538                                     bool ShouldCreate = true) {
1539    return getImpl(Context, static_cast<Metadata *>(Scope),
1540                   static_cast<Metadata *>(File), Discriminator, Storage,
1541                   ShouldCreate);
1542  }
1543
1544  static MDLexicalBlockFile *getImpl(LLVMContext &Context, Metadata *Scope,
1545                                     Metadata *File, unsigned Discriminator,
1546                                     StorageType Storage,
1547                                     bool ShouldCreate = true);
1548
1549  TempMDLexicalBlockFile cloneImpl() const {
1550    return getTemporary(getContext(), getScope(), getFile(),
1551                        getDiscriminator());
1552  }
1553
1554public:
1555  DEFINE_MDNODE_GET(MDLexicalBlockFile, (MDLocalScope * Scope, MDFile *File,
1556                                         unsigned Discriminator),
1557                    (Scope, File, Discriminator))
1558  DEFINE_MDNODE_GET(MDLexicalBlockFile,
1559                    (Metadata * Scope, Metadata *File, unsigned Discriminator),
1560                    (Scope, File, Discriminator))
1561
1562  TempMDLexicalBlockFile clone() const { return cloneImpl(); }
1563
1564  // TODO: Remove these once they're gone from MDLexicalBlockBase.
1565  unsigned getLine() const = delete;
1566  unsigned getColumn() const = delete;
1567
1568  unsigned getDiscriminator() const { return Discriminator; }
1569
1570  static bool classof(const Metadata *MD) {
1571    return MD->getMetadataID() == MDLexicalBlockFileKind;
1572  }
1573};
1574
1575unsigned MDLocation::getDiscriminator() const {
1576  if (auto *F = dyn_cast<MDLexicalBlockFile>(getScope()))
1577    return F->getDiscriminator();
1578  return 0;
1579}
1580
1581class MDNamespace : public MDScope {
1582  friend class LLVMContextImpl;
1583  friend class MDNode;
1584
1585  unsigned Line;
1586
1587  MDNamespace(LLVMContext &Context, StorageType Storage, unsigned Line,
1588              ArrayRef<Metadata *> Ops)
1589      : MDScope(Context, MDNamespaceKind, Storage, dwarf::DW_TAG_namespace,
1590                Ops),
1591        Line(Line) {}
1592  ~MDNamespace() = default;
1593
1594  static MDNamespace *getImpl(LLVMContext &Context, MDScope *Scope,
1595                              MDFile *File, StringRef Name, unsigned Line,
1596                              StorageType Storage, bool ShouldCreate = true) {
1597    return getImpl(Context, Scope, File, getCanonicalMDString(Context, Name),
1598                   Line, Storage, ShouldCreate);
1599  }
1600  static MDNamespace *getImpl(LLVMContext &Context, Metadata *Scope,
1601                              Metadata *File, MDString *Name, unsigned Line,
1602                              StorageType Storage, bool ShouldCreate = true);
1603
1604  TempMDNamespace cloneImpl() const {
1605    return getTemporary(getContext(), getScope(), getFile(), getName(),
1606                        getLine());
1607  }
1608
1609public:
1610  DEFINE_MDNODE_GET(MDNamespace, (MDScope * Scope, MDFile *File, StringRef Name,
1611                                  unsigned Line),
1612                    (Scope, File, Name, Line))
1613  DEFINE_MDNODE_GET(MDNamespace, (Metadata * Scope, Metadata *File,
1614                                  MDString *Name, unsigned Line),
1615                    (Scope, File, Name, Line))
1616
1617  TempMDNamespace clone() const { return cloneImpl(); }
1618
1619  unsigned getLine() const { return Line; }
1620  MDScope *getScope() const { return cast_or_null<MDScope>(getRawScope()); }
1621  StringRef getName() const { return getStringOperand(2); }
1622
1623  Metadata *getRawScope() const { return getOperand(1); }
1624  MDString *getRawName() const { return getOperandAs<MDString>(2); }
1625
1626  static bool classof(const Metadata *MD) {
1627    return MD->getMetadataID() == MDNamespaceKind;
1628  }
1629};
1630
1631/// \brief Base class for template parameters.
1632class MDTemplateParameter : public DebugNode {
1633protected:
1634  MDTemplateParameter(LLVMContext &Context, unsigned ID, StorageType Storage,
1635                      unsigned Tag, ArrayRef<Metadata *> Ops)
1636      : DebugNode(Context, ID, Storage, Tag, Ops) {}
1637  ~MDTemplateParameter() = default;
1638
1639public:
1640  StringRef getName() const { return getStringOperand(0); }
1641  MDTypeRef getType() const { return MDTypeRef(getRawType()); }
1642
1643  MDString *getRawName() const { return getOperandAs<MDString>(0); }
1644  Metadata *getRawType() const { return getOperand(1); }
1645
1646  static bool classof(const Metadata *MD) {
1647    return MD->getMetadataID() == MDTemplateTypeParameterKind ||
1648           MD->getMetadataID() == MDTemplateValueParameterKind;
1649  }
1650};
1651
1652class MDTemplateTypeParameter : public MDTemplateParameter {
1653  friend class LLVMContextImpl;
1654  friend class MDNode;
1655
1656  MDTemplateTypeParameter(LLVMContext &Context, StorageType Storage,
1657                          ArrayRef<Metadata *> Ops)
1658      : MDTemplateParameter(Context, MDTemplateTypeParameterKind, Storage,
1659                            dwarf::DW_TAG_template_type_parameter, Ops) {}
1660  ~MDTemplateTypeParameter() = default;
1661
1662  static MDTemplateTypeParameter *getImpl(LLVMContext &Context, StringRef Name,
1663                                          MDTypeRef Type, StorageType Storage,
1664                                          bool ShouldCreate = true) {
1665    return getImpl(Context, getCanonicalMDString(Context, Name), Type, Storage,
1666                   ShouldCreate);
1667  }
1668  static MDTemplateTypeParameter *getImpl(LLVMContext &Context, MDString *Name,
1669                                          Metadata *Type, StorageType Storage,
1670                                          bool ShouldCreate = true);
1671
1672  TempMDTemplateTypeParameter cloneImpl() const {
1673    return getTemporary(getContext(), getName(), getType());
1674  }
1675
1676public:
1677  DEFINE_MDNODE_GET(MDTemplateTypeParameter, (StringRef Name, MDTypeRef Type),
1678                    (Name, Type))
1679  DEFINE_MDNODE_GET(MDTemplateTypeParameter, (MDString * Name, Metadata *Type),
1680                    (Name, Type))
1681
1682  TempMDTemplateTypeParameter clone() const { return cloneImpl(); }
1683
1684  static bool classof(const Metadata *MD) {
1685    return MD->getMetadataID() == MDTemplateTypeParameterKind;
1686  }
1687};
1688
1689class MDTemplateValueParameter : public MDTemplateParameter {
1690  friend class LLVMContextImpl;
1691  friend class MDNode;
1692
1693  MDTemplateValueParameter(LLVMContext &Context, StorageType Storage,
1694                           unsigned Tag, ArrayRef<Metadata *> Ops)
1695      : MDTemplateParameter(Context, MDTemplateValueParameterKind, Storage, Tag,
1696                            Ops) {}
1697  ~MDTemplateValueParameter() = default;
1698
1699  static MDTemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
1700                                           StringRef Name, MDTypeRef Type,
1701                                           Metadata *Value, StorageType Storage,
1702                                           bool ShouldCreate = true) {
1703    return getImpl(Context, Tag, getCanonicalMDString(Context, Name), Type,
1704                   Value, Storage, ShouldCreate);
1705  }
1706  static MDTemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
1707                                           MDString *Name, Metadata *Type,
1708                                           Metadata *Value, StorageType Storage,
1709                                           bool ShouldCreate = true);
1710
1711  TempMDTemplateValueParameter cloneImpl() const {
1712    return getTemporary(getContext(), getTag(), getName(), getType(),
1713                        getValue());
1714  }
1715
1716public:
1717  DEFINE_MDNODE_GET(MDTemplateValueParameter, (unsigned Tag, StringRef Name,
1718                                               MDTypeRef Type, Metadata *Value),
1719                    (Tag, Name, Type, Value))
1720  DEFINE_MDNODE_GET(MDTemplateValueParameter, (unsigned Tag, MDString *Name,
1721                                               Metadata *Type, Metadata *Value),
1722                    (Tag, Name, Type, Value))
1723
1724  TempMDTemplateValueParameter clone() const { return cloneImpl(); }
1725
1726  Metadata *getValue() const { return getOperand(2); }
1727
1728  static bool classof(const Metadata *MD) {
1729    return MD->getMetadataID() == MDTemplateValueParameterKind;
1730  }
1731};
1732
1733/// \brief Base class for variables.
1734///
1735/// TODO: Hardcode to DW_TAG_variable.
1736class MDVariable : public DebugNode {
1737  unsigned Line;
1738
1739protected:
1740  MDVariable(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
1741             unsigned Line, ArrayRef<Metadata *> Ops)
1742      : DebugNode(C, ID, Storage, Tag, Ops), Line(Line) {}
1743  ~MDVariable() = default;
1744
1745public:
1746  unsigned getLine() const { return Line; }
1747  MDScope *getScope() const { return cast_or_null<MDScope>(getRawScope()); }
1748  StringRef getName() const { return getStringOperand(1); }
1749  MDFile *getFile() const { return cast_or_null<MDFile>(getRawFile()); }
1750  MDTypeRef getType() const { return MDTypeRef(getRawType()); }
1751
1752  StringRef getFilename() const {
1753    if (auto *F = getFile())
1754      return F->getFilename();
1755    return "";
1756  }
1757  StringRef getDirectory() const {
1758    if (auto *F = getFile())
1759      return F->getDirectory();
1760    return "";
1761  }
1762
1763  Metadata *getRawScope() const { return getOperand(0); }
1764  MDString *getRawName() const { return getOperandAs<MDString>(1); }
1765  Metadata *getRawFile() const { return getOperand(2); }
1766  Metadata *getRawType() const { return getOperand(3); }
1767
1768  static bool classof(const Metadata *MD) {
1769    return MD->getMetadataID() == MDLocalVariableKind ||
1770           MD->getMetadataID() == MDGlobalVariableKind;
1771  }
1772};
1773
1774/// \brief Global variables.
1775///
1776/// TODO: Remove DisplayName.  It's always equal to Name.
1777class MDGlobalVariable : public MDVariable {
1778  friend class LLVMContextImpl;
1779  friend class MDNode;
1780
1781  bool IsLocalToUnit;
1782  bool IsDefinition;
1783
1784  MDGlobalVariable(LLVMContext &C, StorageType Storage, unsigned Line,
1785                   bool IsLocalToUnit, bool IsDefinition,
1786                   ArrayRef<Metadata *> Ops)
1787      : MDVariable(C, MDGlobalVariableKind, Storage, dwarf::DW_TAG_variable,
1788                   Line, Ops),
1789        IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition) {}
1790  ~MDGlobalVariable() = default;
1791
1792  static MDGlobalVariable *
1793  getImpl(LLVMContext &Context, MDScope *Scope, StringRef Name,
1794          StringRef LinkageName, MDFile *File, unsigned Line, MDTypeRef Type,
1795          bool IsLocalToUnit, bool IsDefinition, Constant *Variable,
1796          MDDerivedType *StaticDataMemberDeclaration, StorageType Storage,
1797          bool ShouldCreate = true) {
1798    return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
1799                   getCanonicalMDString(Context, LinkageName), File, Line, Type,
1800                   IsLocalToUnit, IsDefinition,
1801                   Variable ? ConstantAsMetadata::get(Variable) : nullptr,
1802                   StaticDataMemberDeclaration, Storage, ShouldCreate);
1803  }
1804  static MDGlobalVariable *
1805  getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
1806          MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
1807          bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
1808          Metadata *StaticDataMemberDeclaration, StorageType Storage,
1809          bool ShouldCreate = true);
1810
1811  TempMDGlobalVariable cloneImpl() const {
1812    return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
1813                        getFile(), getLine(), getType(), isLocalToUnit(),
1814                        isDefinition(), getVariable(),
1815                        getStaticDataMemberDeclaration());
1816  }
1817
1818public:
1819  DEFINE_MDNODE_GET(MDGlobalVariable,
1820                    (MDScope * Scope, StringRef Name, StringRef LinkageName,
1821                     MDFile *File, unsigned Line, MDTypeRef Type,
1822                     bool IsLocalToUnit, bool IsDefinition, Constant *Variable,
1823                     MDDerivedType *StaticDataMemberDeclaration),
1824                    (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
1825                     IsDefinition, Variable, StaticDataMemberDeclaration))
1826  DEFINE_MDNODE_GET(MDGlobalVariable,
1827                    (Metadata * Scope, MDString *Name, MDString *LinkageName,
1828                     Metadata *File, unsigned Line, Metadata *Type,
1829                     bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
1830                     Metadata *StaticDataMemberDeclaration),
1831                    (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
1832                     IsDefinition, Variable, StaticDataMemberDeclaration))
1833
1834  TempMDGlobalVariable clone() const { return cloneImpl(); }
1835
1836  bool isLocalToUnit() const { return IsLocalToUnit; }
1837  bool isDefinition() const { return IsDefinition; }
1838  StringRef getDisplayName() const { return getStringOperand(4); }
1839  StringRef getLinkageName() const { return getStringOperand(5); }
1840  Constant *getVariable() const {
1841    if (auto *C = cast_or_null<ConstantAsMetadata>(getRawVariable()))
1842      return dyn_cast<Constant>(C->getValue());
1843    return nullptr;
1844  }
1845  MDDerivedType *getStaticDataMemberDeclaration() const {
1846    return cast_or_null<MDDerivedType>(getRawStaticDataMemberDeclaration());
1847  }
1848
1849  MDString *getRawLinkageName() const { return getOperandAs<MDString>(5); }
1850  Metadata *getRawVariable() const { return getOperand(6); }
1851  Metadata *getRawStaticDataMemberDeclaration() const { return getOperand(7); }
1852
1853  static bool classof(const Metadata *MD) {
1854    return MD->getMetadataID() == MDGlobalVariableKind;
1855  }
1856};
1857
1858/// \brief Local variable.
1859///
1860/// TODO: Split between arguments and otherwise.
1861/// TODO: Use \c DW_TAG_variable instead of fake tags.
1862/// TODO: Split up flags.
1863class MDLocalVariable : public MDVariable {
1864  friend class LLVMContextImpl;
1865  friend class MDNode;
1866
1867  unsigned Arg;
1868  unsigned Flags;
1869
1870  MDLocalVariable(LLVMContext &C, StorageType Storage, unsigned Tag,
1871                  unsigned Line, unsigned Arg, unsigned Flags,
1872                  ArrayRef<Metadata *> Ops)
1873      : MDVariable(C, MDLocalVariableKind, Storage, Tag, Line, Ops), Arg(Arg),
1874        Flags(Flags) {}
1875  ~MDLocalVariable() = default;
1876
1877  static MDLocalVariable *getImpl(LLVMContext &Context, unsigned Tag,
1878                                  MDScope *Scope, StringRef Name, MDFile *File,
1879                                  unsigned Line, MDTypeRef Type, unsigned Arg,
1880                                  unsigned Flags, StorageType Storage,
1881                                  bool ShouldCreate = true) {
1882    return getImpl(Context, Tag, Scope, getCanonicalMDString(Context, Name),
1883                   File, Line, Type, Arg, Flags, Storage, ShouldCreate);
1884  }
1885  static MDLocalVariable *
1886  getImpl(LLVMContext &Context, unsigned Tag, Metadata *Scope, MDString *Name,
1887          Metadata *File, unsigned Line, Metadata *Type, unsigned Arg,
1888          unsigned Flags, StorageType Storage, bool ShouldCreate = true);
1889
1890  TempMDLocalVariable cloneImpl() const {
1891    return getTemporary(getContext(), getTag(), getScope(), getName(),
1892                        getFile(), getLine(), getType(), getArg(), getFlags());
1893  }
1894
1895public:
1896  DEFINE_MDNODE_GET(MDLocalVariable,
1897                    (unsigned Tag, MDLocalScope *Scope, StringRef Name,
1898                     MDFile *File, unsigned Line, MDTypeRef Type, unsigned Arg,
1899                     unsigned Flags),
1900                    (Tag, Scope, Name, File, Line, Type, Arg, Flags))
1901  DEFINE_MDNODE_GET(MDLocalVariable,
1902                    (unsigned Tag, Metadata *Scope, MDString *Name,
1903                     Metadata *File, unsigned Line, Metadata *Type,
1904                     unsigned Arg, unsigned Flags),
1905                    (Tag, Scope, Name, File, Line, Type, Arg, Flags))
1906
1907  TempMDLocalVariable clone() const { return cloneImpl(); }
1908
1909  /// \brief Get the local scope for this variable.
1910  ///
1911  /// Variables must be defined in a local scope.
1912  MDLocalScope *getScope() const {
1913    return cast<MDLocalScope>(MDVariable::getScope());
1914  }
1915
1916  unsigned getArg() const { return Arg; }
1917  unsigned getFlags() const { return Flags; }
1918
1919  bool isArtificial() const { return getFlags() & FlagArtificial; }
1920  bool isObjectPointer() const { return getFlags() & FlagObjectPointer; }
1921
1922  /// \brief Check that a location is valid for this variable.
1923  ///
1924  /// Check that \c DL exists, is in the same subprogram, and has the same
1925  /// inlined-at location as \c this.  (Otherwise, it's not a valid attachemnt
1926  /// to a \a DbgInfoIntrinsic.)
1927  bool isValidLocationForIntrinsic(const MDLocation *DL) const {
1928    return DL && getScope()->getSubprogram() == DL->getScope()->getSubprogram();
1929  }
1930
1931  static bool classof(const Metadata *MD) {
1932    return MD->getMetadataID() == MDLocalVariableKind;
1933  }
1934};
1935
1936/// \brief DWARF expression.
1937///
1938/// This is (almost) a DWARF expression that modifies the location of a
1939/// variable or (or the location of a single piece of a variable).
1940///
1941/// FIXME: Instead of DW_OP_plus taking an argument, this should use DW_OP_const
1942/// and have DW_OP_plus consume the topmost elements on the stack.
1943///
1944/// TODO: Co-allocate the expression elements.
1945/// TODO: Separate from MDNode, or otherwise drop Distinct and Temporary
1946/// storage types.
1947class MDExpression : public MDNode {
1948  friend class LLVMContextImpl;
1949  friend class MDNode;
1950
1951  std::vector<uint64_t> Elements;
1952
1953  MDExpression(LLVMContext &C, StorageType Storage, ArrayRef<uint64_t> Elements)
1954      : MDNode(C, MDExpressionKind, Storage, None),
1955        Elements(Elements.begin(), Elements.end()) {}
1956  ~MDExpression() = default;
1957
1958  static MDExpression *getImpl(LLVMContext &Context,
1959                               ArrayRef<uint64_t> Elements, StorageType Storage,
1960                               bool ShouldCreate = true);
1961
1962  TempMDExpression cloneImpl() const {
1963    return getTemporary(getContext(), getElements());
1964  }
1965
1966public:
1967  DEFINE_MDNODE_GET(MDExpression, (ArrayRef<uint64_t> Elements), (Elements))
1968
1969  TempMDExpression clone() const { return cloneImpl(); }
1970
1971  ArrayRef<uint64_t> getElements() const { return Elements; }
1972
1973  unsigned getNumElements() const { return Elements.size(); }
1974  uint64_t getElement(unsigned I) const {
1975    assert(I < Elements.size() && "Index out of range");
1976    return Elements[I];
1977  }
1978
1979  /// \brief Return whether this is a piece of an aggregate variable.
1980  bool isBitPiece() const;
1981
1982  /// \brief Return the offset of this piece in bits.
1983  uint64_t getBitPieceOffset() const;
1984
1985  /// \brief Return the size of this piece in bits.
1986  uint64_t getBitPieceSize() const;
1987
1988  typedef ArrayRef<uint64_t>::iterator element_iterator;
1989  element_iterator elements_begin() const { return getElements().begin(); }
1990  element_iterator elements_end() const { return getElements().end(); }
1991
1992  /// \brief A lightweight wrapper around an expression operand.
1993  ///
1994  /// TODO: Store arguments directly and change \a MDExpression to store a
1995  /// range of these.
1996  class ExprOperand {
1997    const uint64_t *Op;
1998
1999  public:
2000    explicit ExprOperand(const uint64_t *Op) : Op(Op) {}
2001
2002    const uint64_t *get() const { return Op; }
2003
2004    /// \brief Get the operand code.
2005    uint64_t getOp() const { return *Op; }
2006
2007    /// \brief Get an argument to the operand.
2008    ///
2009    /// Never returns the operand itself.
2010    uint64_t getArg(unsigned I) const { return Op[I + 1]; }
2011
2012    unsigned getNumArgs() const { return getSize() - 1; }
2013
2014    /// \brief Return the size of the operand.
2015    ///
2016    /// Return the number of elements in the operand (1 + args).
2017    unsigned getSize() const;
2018  };
2019
2020  /// \brief An iterator for expression operands.
2021  class expr_op_iterator
2022      : public std::iterator<std::input_iterator_tag, ExprOperand> {
2023    ExprOperand Op;
2024
2025  public:
2026    explicit expr_op_iterator(element_iterator I) : Op(I) {}
2027
2028    element_iterator getBase() const { return Op.get(); }
2029    const ExprOperand &operator*() const { return Op; }
2030    const ExprOperand *operator->() const { return &Op; }
2031
2032    expr_op_iterator &operator++() {
2033      increment();
2034      return *this;
2035    }
2036    expr_op_iterator operator++(int) {
2037      expr_op_iterator T(*this);
2038      increment();
2039      return T;
2040    }
2041
2042    /// \brief Get the next iterator.
2043    ///
2044    /// \a std::next() doesn't work because this is technically an
2045    /// input_iterator, but it's a perfectly valid operation.  This is an
2046    /// accessor to provide the same functionality.
2047    expr_op_iterator getNext() const { return ++expr_op_iterator(*this); }
2048
2049    bool operator==(const expr_op_iterator &X) const {
2050      return getBase() == X.getBase();
2051    }
2052    bool operator!=(const expr_op_iterator &X) const {
2053      return getBase() != X.getBase();
2054    }
2055
2056  private:
2057    void increment() { Op = ExprOperand(getBase() + Op.getSize()); }
2058  };
2059
2060  /// \brief Visit the elements via ExprOperand wrappers.
2061  ///
2062  /// These range iterators visit elements through \a ExprOperand wrappers.
2063  /// This is not guaranteed to be a valid range unless \a isValid() gives \c
2064  /// true.
2065  ///
2066  /// \pre \a isValid() gives \c true.
2067  /// @{
2068  expr_op_iterator expr_op_begin() const {
2069    return expr_op_iterator(elements_begin());
2070  }
2071  expr_op_iterator expr_op_end() const {
2072    return expr_op_iterator(elements_end());
2073  }
2074  /// @}
2075
2076  bool isValid() const;
2077
2078  static bool classof(const Metadata *MD) {
2079    return MD->getMetadataID() == MDExpressionKind;
2080  }
2081};
2082
2083class MDObjCProperty : public DebugNode {
2084  friend class LLVMContextImpl;
2085  friend class MDNode;
2086
2087  unsigned Line;
2088  unsigned Attributes;
2089
2090  MDObjCProperty(LLVMContext &C, StorageType Storage, unsigned Line,
2091                 unsigned Attributes, ArrayRef<Metadata *> Ops)
2092      : DebugNode(C, MDObjCPropertyKind, Storage, dwarf::DW_TAG_APPLE_property,
2093                  Ops),
2094        Line(Line), Attributes(Attributes) {}
2095  ~MDObjCProperty() = default;
2096
2097  static MDObjCProperty *
2098  getImpl(LLVMContext &Context, StringRef Name, MDFile *File, unsigned Line,
2099          StringRef GetterName, StringRef SetterName, unsigned Attributes,
2100          MDType *Type, StorageType Storage, bool ShouldCreate = true) {
2101    return getImpl(Context, getCanonicalMDString(Context, Name), File, Line,
2102                   getCanonicalMDString(Context, GetterName),
2103                   getCanonicalMDString(Context, SetterName), Attributes, Type,
2104                   Storage, ShouldCreate);
2105  }
2106  static MDObjCProperty *getImpl(LLVMContext &Context, MDString *Name,
2107                                 Metadata *File, unsigned Line,
2108                                 MDString *GetterName, MDString *SetterName,
2109                                 unsigned Attributes, Metadata *Type,
2110                                 StorageType Storage, bool ShouldCreate = true);
2111
2112  TempMDObjCProperty cloneImpl() const {
2113    return getTemporary(getContext(), getName(), getFile(), getLine(),
2114                        getGetterName(), getSetterName(), getAttributes(),
2115                        getType());
2116  }
2117
2118public:
2119  DEFINE_MDNODE_GET(MDObjCProperty,
2120                    (StringRef Name, MDFile *File, unsigned Line,
2121                     StringRef GetterName, StringRef SetterName,
2122                     unsigned Attributes, MDType *Type),
2123                    (Name, File, Line, GetterName, SetterName, Attributes,
2124                     Type))
2125  DEFINE_MDNODE_GET(MDObjCProperty,
2126                    (MDString * Name, Metadata *File, unsigned Line,
2127                     MDString *GetterName, MDString *SetterName,
2128                     unsigned Attributes, Metadata *Type),
2129                    (Name, File, Line, GetterName, SetterName, Attributes,
2130                     Type))
2131
2132  TempMDObjCProperty clone() const { return cloneImpl(); }
2133
2134  unsigned getLine() const { return Line; }
2135  unsigned getAttributes() const { return Attributes; }
2136  StringRef getName() const { return getStringOperand(0); }
2137  MDFile *getFile() const { return cast_or_null<MDFile>(getRawFile()); }
2138  StringRef getGetterName() const { return getStringOperand(2); }
2139  StringRef getSetterName() const { return getStringOperand(3); }
2140
2141  /// \brief Get the type.
2142  ///
2143  /// \note Objective-C doesn't have an ODR, so there is no benefit in storing
2144  /// the type as a DITypeRef here.
2145  MDType *getType() const { return cast_or_null<MDType>(getRawType()); }
2146
2147  StringRef getFilename() const {
2148    if (auto *F = getFile())
2149      return F->getFilename();
2150    return "";
2151  }
2152  StringRef getDirectory() const {
2153    if (auto *F = getFile())
2154      return F->getDirectory();
2155    return "";
2156  }
2157
2158  MDString *getRawName() const { return getOperandAs<MDString>(0); }
2159  Metadata *getRawFile() const { return getOperand(1); }
2160  MDString *getRawGetterName() const { return getOperandAs<MDString>(2); }
2161  MDString *getRawSetterName() const { return getOperandAs<MDString>(3); }
2162  Metadata *getRawType() const { return getOperand(4); }
2163
2164  static bool classof(const Metadata *MD) {
2165    return MD->getMetadataID() == MDObjCPropertyKind;
2166  }
2167};
2168
2169/// \brief An imported module (C++ using directive or similar).
2170class MDImportedEntity : public DebugNode {
2171  friend class LLVMContextImpl;
2172  friend class MDNode;
2173
2174  unsigned Line;
2175
2176  MDImportedEntity(LLVMContext &C, StorageType Storage, unsigned Tag,
2177                   unsigned Line, ArrayRef<Metadata *> Ops)
2178      : DebugNode(C, MDImportedEntityKind, Storage, Tag, Ops), Line(Line) {}
2179  ~MDImportedEntity() = default;
2180
2181  static MDImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
2182                                   MDScope *Scope, DebugNodeRef Entity,
2183                                   unsigned Line, StringRef Name,
2184                                   StorageType Storage,
2185                                   bool ShouldCreate = true) {
2186    return getImpl(Context, Tag, Scope, Entity, Line,
2187                   getCanonicalMDString(Context, Name), Storage, ShouldCreate);
2188  }
2189  static MDImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
2190                                   Metadata *Scope, Metadata *Entity,
2191                                   unsigned Line, MDString *Name,
2192                                   StorageType Storage,
2193                                   bool ShouldCreate = true);
2194
2195  TempMDImportedEntity cloneImpl() const {
2196    return getTemporary(getContext(), getTag(), getScope(), getEntity(),
2197                        getLine(), getName());
2198  }
2199
2200public:
2201  DEFINE_MDNODE_GET(MDImportedEntity,
2202                    (unsigned Tag, MDScope *Scope, DebugNodeRef Entity,
2203                     unsigned Line, StringRef Name = ""),
2204                    (Tag, Scope, Entity, Line, Name))
2205  DEFINE_MDNODE_GET(MDImportedEntity,
2206                    (unsigned Tag, Metadata *Scope, Metadata *Entity,
2207                     unsigned Line, MDString *Name),
2208                    (Tag, Scope, Entity, Line, Name))
2209
2210  TempMDImportedEntity clone() const { return cloneImpl(); }
2211
2212  unsigned getLine() const { return Line; }
2213  MDScope *getScope() const { return cast_or_null<MDScope>(getRawScope()); }
2214  DebugNodeRef getEntity() const { return DebugNodeRef(getRawEntity()); }
2215  StringRef getName() const { return getStringOperand(2); }
2216
2217  Metadata *getRawScope() const { return getOperand(0); }
2218  Metadata *getRawEntity() const { return getOperand(1); }
2219  MDString *getRawName() const { return getOperandAs<MDString>(2); }
2220
2221  static bool classof(const Metadata *MD) {
2222    return MD->getMetadataID() == MDImportedEntityKind;
2223  }
2224};
2225
2226} // end namespace llvm
2227
2228#undef DEFINE_MDNODE_GET_UNPACK_IMPL
2229#undef DEFINE_MDNODE_GET_UNPACK
2230#undef DEFINE_MDNODE_GET
2231
2232#endif
2233