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