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