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