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