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