1 //===- llvm/IR/DebugInfoMetadata.h - Debug info metadata --------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Declarations for metadata specific to debug info.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_IR_DEBUGINFOMETADATA_H
15 #define LLVM_IR_DEBUGINFOMETADATA_H
17 #include "llvm/ADT/ArrayRef.h"
18 #include "llvm/ADT/BitmaskEnum.h"
19 #include "llvm/ADT/None.h"
20 #include "llvm/ADT/Optional.h"
21 #include "llvm/ADT/PointerUnion.h"
22 #include "llvm/ADT/STLExtras.h"
23 #include "llvm/ADT/SmallVector.h"
24 #include "llvm/ADT/StringRef.h"
25 #include "llvm/ADT/iterator_range.h"
26 #include "llvm/BinaryFormat/Dwarf.h"
27 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/Metadata.h"
29 #include "llvm/Support/Casting.h"
35 #include <type_traits>
38 // Helper macros for defining get() overrides.
39 #define DEFINE_MDNODE_GET_UNPACK_IMPL(...) __VA_ARGS__
40 #define DEFINE_MDNODE_GET_UNPACK(ARGS) DEFINE_MDNODE_GET_UNPACK_IMPL ARGS
41 #define DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(CLASS, FORMAL, ARGS) \
42 static CLASS *getDistinct(LLVMContext &Context, \
43 DEFINE_MDNODE_GET_UNPACK(FORMAL)) { \
44 return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Distinct); \
46 static Temp##CLASS getTemporary(LLVMContext &Context, \
47 DEFINE_MDNODE_GET_UNPACK(FORMAL)) { \
49 getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Temporary)); \
51 #define DEFINE_MDNODE_GET(CLASS, FORMAL, ARGS) \
52 static CLASS *get(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK(FORMAL)) { \
53 return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Uniqued); \
55 static CLASS *getIfExists(LLVMContext &Context, \
56 DEFINE_MDNODE_GET_UNPACK(FORMAL)) { \
57 return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Uniqued, \
58 /* ShouldCreate */ false); \
60 DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(CLASS, FORMAL, ARGS)
64 /// Holds a subclass of DINode.
66 /// FIXME: This class doesn't currently make much sense. Previously it was a
67 /// union beteen MDString (for ODR-uniqued types) and things like DIType. To
68 /// support CodeView work, it wasn't deleted outright when MDString-based type
69 /// references were deleted; we'll soon need a similar concept for CodeView
71 template <class T> class TypedDINodeRef {
72 const Metadata *MD = nullptr;
75 TypedDINodeRef() = default;
76 TypedDINodeRef(std::nullptr_t) {}
77 TypedDINodeRef(const T *MD) : MD(MD) {}
79 explicit TypedDINodeRef(const Metadata *MD) : MD(MD) {
80 assert((!MD || isa<T>(MD)) && "Expected valid type ref");
85 const TypedDINodeRef<U> &X,
86 typename std::enable_if<std::is_convertible<U *, T *>::value>::type * =
90 operator Metadata *() const { return const_cast<Metadata *>(MD); }
92 T *resolve() const { return const_cast<T *>(cast_or_null<T>(MD)); }
94 bool operator==(const TypedDINodeRef<T> &X) const { return MD == X.MD; }
95 bool operator!=(const TypedDINodeRef<T> &X) const { return MD != X.MD; }
98 using DINodeRef = TypedDINodeRef<DINode>;
99 using DIScopeRef = TypedDINodeRef<DIScope>;
100 using DITypeRef = TypedDINodeRef<DIType>;
102 class DITypeRefArray {
103 const MDTuple *N = nullptr;
106 DITypeRefArray() = default;
107 DITypeRefArray(const MDTuple *N) : N(N) {}
109 explicit operator bool() const { return get(); }
110 explicit operator MDTuple *() const { return get(); }
112 MDTuple *get() const { return const_cast<MDTuple *>(N); }
113 MDTuple *operator->() const { return get(); }
114 MDTuple &operator*() const { return *get(); }
116 // FIXME: Fix callers and remove condition on N.
117 unsigned size() const { return N ? N->getNumOperands() : 0u; }
118 DITypeRef operator[](unsigned I) const { return DITypeRef(N->getOperand(I)); }
120 class iterator : std::iterator<std::input_iterator_tag, DITypeRef,
121 std::ptrdiff_t, void, DITypeRef> {
122 MDNode::op_iterator I = nullptr;
125 iterator() = default;
126 explicit iterator(MDNode::op_iterator I) : I(I) {}
128 DITypeRef operator*() const { return DITypeRef(*I); }
130 iterator &operator++() {
135 iterator operator++(int) {
136 iterator Temp(*this);
141 bool operator==(const iterator &X) const { return I == X.I; }
142 bool operator!=(const iterator &X) const { return I != X.I; }
145 // FIXME: Fix callers and remove condition on N.
146 iterator begin() const { return N ? iterator(N->op_begin()) : iterator(); }
147 iterator end() const { return N ? iterator(N->op_end()) : iterator(); }
150 /// Tagged DWARF-like metadata node.
152 /// A metadata node with a DWARF tag (i.e., a constant named \c DW_TAG_*,
153 /// defined in llvm/BinaryFormat/Dwarf.h). Called \a DINode because it's
154 /// potentially used for non-DWARF output.
155 class DINode : public MDNode {
156 friend class LLVMContextImpl;
160 DINode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
161 ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None)
162 : MDNode(C, ID, Storage, Ops1, Ops2) {
163 assert(Tag < 1u << 16);
164 SubclassData16 = Tag;
168 template <class Ty> Ty *getOperandAs(unsigned I) const {
169 return cast_or_null<Ty>(getOperand(I));
172 StringRef getStringOperand(unsigned I) const {
173 if (auto *S = getOperandAs<MDString>(I))
174 return S->getString();
178 static MDString *getCanonicalMDString(LLVMContext &Context, StringRef S) {
181 return MDString::get(Context, S);
184 /// Allow subclasses to mutate the tag.
185 void setTag(unsigned Tag) { SubclassData16 = Tag; }
188 unsigned getTag() const { return SubclassData16; }
190 /// Debug info flags.
192 /// The three accessibility flags are mutually exclusive and rolled together
193 /// in the first two bits.
194 enum DIFlags : uint32_t {
195 #define HANDLE_DI_FLAG(ID, NAME) Flag##NAME = ID,
196 #define DI_FLAG_LARGEST_NEEDED
197 #include "llvm/IR/DebugInfoFlags.def"
198 FlagAccessibility = FlagPrivate | FlagProtected | FlagPublic,
199 FlagPtrToMemberRep = FlagSingleInheritance | FlagMultipleInheritance |
200 FlagVirtualInheritance,
201 LLVM_MARK_AS_BITMASK_ENUM(FlagLargest)
204 static DIFlags getFlag(StringRef Flag);
205 static StringRef getFlagString(DIFlags Flag);
207 /// Split up a flags bitfield.
209 /// Split \c Flags into \c SplitFlags, a vector of its components. Returns
210 /// any remaining (unrecognized) bits.
211 static DIFlags splitFlags(DIFlags Flags,
212 SmallVectorImpl<DIFlags> &SplitFlags);
214 static bool classof(const Metadata *MD) {
215 switch (MD->getMetadataID()) {
218 case GenericDINodeKind:
220 case DIEnumeratorKind:
221 case DIBasicTypeKind:
222 case DIDerivedTypeKind:
223 case DICompositeTypeKind:
224 case DISubroutineTypeKind:
226 case DICompileUnitKind:
227 case DISubprogramKind:
228 case DILexicalBlockKind:
229 case DILexicalBlockFileKind:
230 case DINamespaceKind:
231 case DITemplateTypeParameterKind:
232 case DITemplateValueParameterKind:
233 case DIGlobalVariableKind:
234 case DILocalVariableKind:
236 case DIObjCPropertyKind:
237 case DIImportedEntityKind:
244 template <class T> struct simplify_type<const TypedDINodeRef<T>> {
245 using SimpleType = Metadata *;
247 static SimpleType getSimplifiedValue(const TypedDINodeRef<T> &MD) {
253 struct simplify_type<TypedDINodeRef<T>>
254 : simplify_type<const TypedDINodeRef<T>> {};
256 /// Generic tagged DWARF-like metadata node.
258 /// An un-specialized DWARF-like metadata node. The first operand is a
259 /// (possibly empty) null-separated \a MDString header that contains arbitrary
260 /// fields. The remaining operands are \a dwarf_operands(), and are pointers
261 /// to other metadata.
262 class GenericDINode : public DINode {
263 friend class LLVMContextImpl;
266 GenericDINode(LLVMContext &C, StorageType Storage, unsigned Hash,
267 unsigned Tag, ArrayRef<Metadata *> Ops1,
268 ArrayRef<Metadata *> Ops2)
269 : DINode(C, GenericDINodeKind, Storage, Tag, Ops1, Ops2) {
272 ~GenericDINode() { dropAllReferences(); }
274 void setHash(unsigned Hash) { SubclassData32 = Hash; }
275 void recalculateHash();
277 static GenericDINode *getImpl(LLVMContext &Context, unsigned Tag,
278 StringRef Header, ArrayRef<Metadata *> DwarfOps,
279 StorageType Storage, bool ShouldCreate = true) {
280 return getImpl(Context, Tag, getCanonicalMDString(Context, Header),
281 DwarfOps, Storage, ShouldCreate);
284 static GenericDINode *getImpl(LLVMContext &Context, unsigned Tag,
285 MDString *Header, ArrayRef<Metadata *> DwarfOps,
286 StorageType Storage, bool ShouldCreate = true);
288 TempGenericDINode cloneImpl() const {
290 getContext(), getTag(), getHeader(),
291 SmallVector<Metadata *, 4>(dwarf_op_begin(), dwarf_op_end()));
295 unsigned getHash() const { return SubclassData32; }
297 DEFINE_MDNODE_GET(GenericDINode, (unsigned Tag, StringRef Header,
298 ArrayRef<Metadata *> DwarfOps),
299 (Tag, Header, DwarfOps))
300 DEFINE_MDNODE_GET(GenericDINode, (unsigned Tag, MDString *Header,
301 ArrayRef<Metadata *> DwarfOps),
302 (Tag, Header, DwarfOps))
304 /// Return a (temporary) clone of this.
305 TempGenericDINode clone() const { return cloneImpl(); }
307 unsigned getTag() const { return SubclassData16; }
308 StringRef getHeader() const { return getStringOperand(0); }
309 MDString *getRawHeader() const { return getOperandAs<MDString>(0); }
311 op_iterator dwarf_op_begin() const { return op_begin() + 1; }
312 op_iterator dwarf_op_end() const { return op_end(); }
313 op_range dwarf_operands() const {
314 return op_range(dwarf_op_begin(), dwarf_op_end());
317 unsigned getNumDwarfOperands() const { return getNumOperands() - 1; }
318 const MDOperand &getDwarfOperand(unsigned I) const {
319 return getOperand(I + 1);
321 void replaceDwarfOperandWith(unsigned I, Metadata *New) {
322 replaceOperandWith(I + 1, New);
325 static bool classof(const Metadata *MD) {
326 return MD->getMetadataID() == GenericDINodeKind;
332 /// TODO: Merge into node for DW_TAG_array_type, which should have a custom
334 class DISubrange : public DINode {
335 friend class LLVMContextImpl;
340 DISubrange(LLVMContext &C, StorageType Storage, Metadata *Node,
341 int64_t LowerBound, ArrayRef<Metadata *> Ops)
342 : DINode(C, DISubrangeKind, Storage, dwarf::DW_TAG_subrange_type, Ops),
343 LowerBound(LowerBound) {}
345 ~DISubrange() = default;
347 static DISubrange *getImpl(LLVMContext &Context, int64_t Count,
348 int64_t LowerBound, StorageType Storage,
349 bool ShouldCreate = true);
351 static DISubrange *getImpl(LLVMContext &Context, Metadata *CountNode,
352 int64_t LowerBound, StorageType Storage,
353 bool ShouldCreate = true);
355 TempDISubrange cloneImpl() const {
356 return getTemporary(getContext(), getRawCountNode(), getLowerBound());
360 DEFINE_MDNODE_GET(DISubrange, (int64_t Count, int64_t LowerBound = 0),
363 DEFINE_MDNODE_GET(DISubrange, (Metadata *CountNode, int64_t LowerBound = 0),
364 (CountNode, LowerBound))
366 TempDISubrange clone() const { return cloneImpl(); }
368 int64_t getLowerBound() const { return LowerBound; }
370 Metadata *getRawCountNode() const {
371 return getOperand(0).get();
374 typedef PointerUnion<ConstantInt*, DIVariable*> CountType;
376 CountType getCount() const {
377 if (auto *MD = dyn_cast<ConstantAsMetadata>(getRawCountNode()))
378 return CountType(cast<ConstantInt>(MD->getValue()));
380 if (auto *DV = dyn_cast<DIVariable>(getRawCountNode()))
381 return CountType(DV);
386 static bool classof(const Metadata *MD) {
387 return MD->getMetadataID() == DISubrangeKind;
391 /// Enumeration value.
393 /// TODO: Add a pointer to the context (DW_TAG_enumeration_type) once that no
394 /// longer creates a type cycle.
395 class DIEnumerator : public DINode {
396 friend class LLVMContextImpl;
400 DIEnumerator(LLVMContext &C, StorageType Storage, int64_t Value,
401 bool IsUnsigned, ArrayRef<Metadata *> Ops)
402 : DINode(C, DIEnumeratorKind, Storage, dwarf::DW_TAG_enumerator, Ops),
404 SubclassData32 = IsUnsigned;
406 ~DIEnumerator() = default;
408 static DIEnumerator *getImpl(LLVMContext &Context, int64_t Value,
409 bool IsUnsigned, StringRef Name,
410 StorageType Storage, bool ShouldCreate = true) {
411 return getImpl(Context, Value, IsUnsigned,
412 getCanonicalMDString(Context, Name), Storage, ShouldCreate);
414 static DIEnumerator *getImpl(LLVMContext &Context, int64_t Value,
415 bool IsUnsigned, MDString *Name,
416 StorageType Storage, bool ShouldCreate = true);
418 TempDIEnumerator cloneImpl() const {
419 return getTemporary(getContext(), getValue(), isUnsigned(), getName());
423 DEFINE_MDNODE_GET(DIEnumerator, (int64_t Value, bool IsUnsigned, StringRef Name),
424 (Value, IsUnsigned, Name))
425 DEFINE_MDNODE_GET(DIEnumerator, (int64_t Value, bool IsUnsigned, MDString *Name),
426 (Value, IsUnsigned, Name))
428 TempDIEnumerator clone() const { return cloneImpl(); }
430 int64_t getValue() const { return Value; }
431 bool isUnsigned() const { return SubclassData32; }
432 StringRef getName() const { return getStringOperand(0); }
434 MDString *getRawName() const { return getOperandAs<MDString>(0); }
436 static bool classof(const Metadata *MD) {
437 return MD->getMetadataID() == DIEnumeratorKind;
441 /// Base class for scope-like contexts.
443 /// Base class for lexical scopes and types (which are also declaration
446 /// TODO: Separate the concepts of declaration contexts and lexical scopes.
447 class DIScope : public DINode {
449 DIScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
450 ArrayRef<Metadata *> Ops)
451 : DINode(C, ID, Storage, Tag, Ops) {}
452 ~DIScope() = default;
455 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
457 inline StringRef getFilename() const;
458 inline StringRef getDirectory() const;
459 inline Optional<StringRef> getSource() const;
461 StringRef getName() const;
462 DIScopeRef getScope() const;
464 /// Return the raw underlying file.
466 /// A \a DIFile is a \a DIScope, but it doesn't point at a separate file (it
467 /// \em is the file). If \c this is an \a DIFile, we need to return \c this.
468 /// Otherwise, return the first operand, which is where all other subclasses
469 /// store their file pointer.
470 Metadata *getRawFile() const {
471 return isa<DIFile>(this) ? const_cast<DIScope *>(this)
472 : static_cast<Metadata *>(getOperand(0));
475 static bool classof(const Metadata *MD) {
476 switch (MD->getMetadataID()) {
479 case DIBasicTypeKind:
480 case DIDerivedTypeKind:
481 case DICompositeTypeKind:
482 case DISubroutineTypeKind:
484 case DICompileUnitKind:
485 case DISubprogramKind:
486 case DILexicalBlockKind:
487 case DILexicalBlockFileKind:
488 case DINamespaceKind:
497 /// TODO: Merge with directory/file node (including users).
498 /// TODO: Canonicalize paths on creation.
499 class DIFile : public DIScope {
500 friend class LLVMContextImpl;
504 /// Which algorithm (e.g. MD5) a checksum was generated with.
506 /// The encoding is explicit because it is used directly in Bitcode. The
507 /// value 0 is reserved to indicate the absence of a checksum in Bitcode.
509 // The first variant was originally CSK_None, encoded as 0. The new
510 // internal representation removes the need for this by wrapping the
511 // ChecksumInfo in an Optional, but to preserve Bitcode compatibility the 0
512 // encoding is reserved.
515 CSK_Last = CSK_SHA1 // Should be last enumeration.
518 /// A single checksum, represented by a \a Kind and a \a Value (a string).
519 template <typename T>
520 struct ChecksumInfo {
521 /// The kind of checksum which \a Value encodes.
523 /// The string value of the checksum.
526 ChecksumInfo(ChecksumKind Kind, T Value) : Kind(Kind), Value(Value) { }
527 ~ChecksumInfo() = default;
528 bool operator==(const ChecksumInfo<T> &X) const {
529 return Kind == X.Kind && Value == X.Value;
531 bool operator!=(const ChecksumInfo<T> &X) const { return !(*this == X); }
532 StringRef getKindAsString() const { return getChecksumKindAsString(Kind); }
536 Optional<ChecksumInfo<MDString *>> Checksum;
537 Optional<MDString *> Source;
539 DIFile(LLVMContext &C, StorageType Storage,
540 Optional<ChecksumInfo<MDString *>> CS, Optional<MDString *> Src,
541 ArrayRef<Metadata *> Ops)
542 : DIScope(C, DIFileKind, Storage, dwarf::DW_TAG_file_type, Ops),
543 Checksum(CS), Source(Src) {}
546 static DIFile *getImpl(LLVMContext &Context, StringRef Filename,
548 Optional<ChecksumInfo<StringRef>> CS,
549 Optional<StringRef> Source,
550 StorageType Storage, bool ShouldCreate = true) {
551 Optional<ChecksumInfo<MDString *>> MDChecksum;
553 MDChecksum.emplace(CS->Kind, getCanonicalMDString(Context, CS->Value));
554 return getImpl(Context, getCanonicalMDString(Context, Filename),
555 getCanonicalMDString(Context, Directory), MDChecksum,
556 Source ? Optional<MDString *>(getCanonicalMDString(Context, *Source)) : None,
557 Storage, ShouldCreate);
559 static DIFile *getImpl(LLVMContext &Context, MDString *Filename,
561 Optional<ChecksumInfo<MDString *>> CS,
562 Optional<MDString *> Source, StorageType Storage,
563 bool ShouldCreate = true);
565 TempDIFile cloneImpl() const {
566 return getTemporary(getContext(), getFilename(), getDirectory(),
567 getChecksum(), getSource());
571 DEFINE_MDNODE_GET(DIFile, (StringRef Filename, StringRef Directory,
572 Optional<ChecksumInfo<StringRef>> CS = None,
573 Optional<StringRef> Source = None),
574 (Filename, Directory, CS, Source))
575 DEFINE_MDNODE_GET(DIFile, (MDString * Filename, MDString *Directory,
576 Optional<ChecksumInfo<MDString *>> CS = None,
577 Optional<MDString *> Source = None),
578 (Filename, Directory, CS, Source))
580 TempDIFile clone() const { return cloneImpl(); }
582 StringRef getFilename() const { return getStringOperand(0); }
583 StringRef getDirectory() const { return getStringOperand(1); }
584 Optional<ChecksumInfo<StringRef>> getChecksum() const {
585 Optional<ChecksumInfo<StringRef>> StringRefChecksum;
587 StringRefChecksum.emplace(Checksum->Kind, Checksum->Value->getString());
588 return StringRefChecksum;
590 Optional<StringRef> getSource() const {
591 return Source ? Optional<StringRef>((*Source)->getString()) : None;
594 MDString *getRawFilename() const { return getOperandAs<MDString>(0); }
595 MDString *getRawDirectory() const { return getOperandAs<MDString>(1); }
596 Optional<ChecksumInfo<MDString *>> getRawChecksum() const { return Checksum; }
597 Optional<MDString *> getRawSource() const { return Source; }
599 static StringRef getChecksumKindAsString(ChecksumKind CSKind);
600 static Optional<ChecksumKind> getChecksumKind(StringRef CSKindStr);
602 static bool classof(const Metadata *MD) {
603 return MD->getMetadataID() == DIFileKind;
607 StringRef DIScope::getFilename() const {
608 if (auto *F = getFile())
609 return F->getFilename();
613 StringRef DIScope::getDirectory() const {
614 if (auto *F = getFile())
615 return F->getDirectory();
619 Optional<StringRef> DIScope::getSource() const {
620 if (auto *F = getFile())
621 return F->getSource();
625 /// Base class for types.
627 /// TODO: Remove the hardcoded name and context, since many types don't use
629 /// TODO: Split up flags.
630 class DIType : public DIScope {
634 uint64_t OffsetInBits;
635 uint32_t AlignInBits;
638 DIType(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
639 unsigned Line, uint64_t SizeInBits, uint32_t AlignInBits,
640 uint64_t OffsetInBits, DIFlags Flags, ArrayRef<Metadata *> Ops)
641 : DIScope(C, ID, Storage, Tag, Ops) {
642 init(Line, SizeInBits, AlignInBits, OffsetInBits, Flags);
646 void init(unsigned Line, uint64_t SizeInBits, uint32_t AlignInBits,
647 uint64_t OffsetInBits, DIFlags Flags) {
650 this->SizeInBits = SizeInBits;
651 this->AlignInBits = AlignInBits;
652 this->OffsetInBits = OffsetInBits;
655 /// Change fields in place.
656 void mutate(unsigned Tag, unsigned Line, uint64_t SizeInBits,
657 uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags) {
658 assert(isDistinct() && "Only distinct nodes can mutate");
660 init(Line, SizeInBits, AlignInBits, OffsetInBits, Flags);
664 TempDIType clone() const {
665 return TempDIType(cast<DIType>(MDNode::clone().release()));
668 unsigned getLine() const { return Line; }
669 uint64_t getSizeInBits() const { return SizeInBits; }
670 uint32_t getAlignInBits() const { return AlignInBits; }
671 uint32_t getAlignInBytes() const { return getAlignInBits() / CHAR_BIT; }
672 uint64_t getOffsetInBits() const { return OffsetInBits; }
673 DIFlags getFlags() const { return Flags; }
675 DIScopeRef getScope() const { return DIScopeRef(getRawScope()); }
676 StringRef getName() const { return getStringOperand(2); }
679 Metadata *getRawScope() const { return getOperand(1); }
680 MDString *getRawName() const { return getOperandAs<MDString>(2); }
682 /// Returns a new temporary DIType with updated Flags
683 TempDIType cloneWithFlags(DIFlags NewFlags) const {
684 auto NewTy = clone();
685 NewTy->Flags = NewFlags;
689 bool isPrivate() const {
690 return (getFlags() & FlagAccessibility) == FlagPrivate;
692 bool isProtected() const {
693 return (getFlags() & FlagAccessibility) == FlagProtected;
695 bool isPublic() const {
696 return (getFlags() & FlagAccessibility) == FlagPublic;
698 bool isForwardDecl() const { return getFlags() & FlagFwdDecl; }
699 bool isAppleBlockExtension() const { return getFlags() & FlagAppleBlock; }
700 bool isBlockByrefStruct() const { return getFlags() & FlagBlockByrefStruct; }
701 bool isVirtual() const { return getFlags() & FlagVirtual; }
702 bool isArtificial() const { return getFlags() & FlagArtificial; }
703 bool isObjectPointer() const { return getFlags() & FlagObjectPointer; }
704 bool isObjcClassComplete() const {
705 return getFlags() & FlagObjcClassComplete;
707 bool isVector() const { return getFlags() & FlagVector; }
708 bool isBitField() const { return getFlags() & FlagBitField; }
709 bool isStaticMember() const { return getFlags() & FlagStaticMember; }
710 bool isLValueReference() const { return getFlags() & FlagLValueReference; }
711 bool isRValueReference() const { return getFlags() & FlagRValueReference; }
712 bool isTypePassByValue() const { return getFlags() & FlagTypePassByValue; }
713 bool isTypePassByReference() const {
714 return getFlags() & FlagTypePassByReference;
717 static bool classof(const Metadata *MD) {
718 switch (MD->getMetadataID()) {
721 case DIBasicTypeKind:
722 case DIDerivedTypeKind:
723 case DICompositeTypeKind:
724 case DISubroutineTypeKind:
730 /// Basic type, like 'int' or 'float'.
732 /// TODO: Split out DW_TAG_unspecified_type.
733 /// TODO: Drop unused accessors.
734 class DIBasicType : public DIType {
735 friend class LLVMContextImpl;
740 DIBasicType(LLVMContext &C, StorageType Storage, unsigned Tag,
741 uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding,
742 ArrayRef<Metadata *> Ops)
743 : DIType(C, DIBasicTypeKind, Storage, Tag, 0, SizeInBits, AlignInBits, 0,
745 Encoding(Encoding) {}
746 ~DIBasicType() = default;
748 static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
749 StringRef Name, uint64_t SizeInBits,
750 uint32_t AlignInBits, unsigned Encoding,
751 StorageType Storage, bool ShouldCreate = true) {
752 return getImpl(Context, Tag, getCanonicalMDString(Context, Name),
753 SizeInBits, AlignInBits, Encoding, Storage, ShouldCreate);
755 static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
756 MDString *Name, uint64_t SizeInBits,
757 uint32_t AlignInBits, unsigned Encoding,
758 StorageType Storage, bool ShouldCreate = true);
760 TempDIBasicType cloneImpl() const {
761 return getTemporary(getContext(), getTag(), getName(), getSizeInBits(),
762 getAlignInBits(), getEncoding());
766 DEFINE_MDNODE_GET(DIBasicType, (unsigned Tag, StringRef Name),
767 (Tag, Name, 0, 0, 0))
768 DEFINE_MDNODE_GET(DIBasicType,
769 (unsigned Tag, StringRef Name, uint64_t SizeInBits,
770 uint32_t AlignInBits, unsigned Encoding),
771 (Tag, Name, SizeInBits, AlignInBits, Encoding))
772 DEFINE_MDNODE_GET(DIBasicType,
773 (unsigned Tag, MDString *Name, uint64_t SizeInBits,
774 uint32_t AlignInBits, unsigned Encoding),
775 (Tag, Name, SizeInBits, AlignInBits, Encoding))
777 TempDIBasicType clone() const { return cloneImpl(); }
779 unsigned getEncoding() const { return Encoding; }
781 enum class Signedness { Signed, Unsigned };
783 /// Return the signedness of this type, or None if this type is neither
784 /// signed nor unsigned.
785 Optional<Signedness> getSignedness() const;
787 static bool classof(const Metadata *MD) {
788 return MD->getMetadataID() == DIBasicTypeKind;
794 /// This includes qualified types, pointers, references, friends, typedefs, and
797 /// TODO: Split out members (inheritance, fields, methods, etc.).
798 class DIDerivedType : public DIType {
799 friend class LLVMContextImpl;
802 /// The DWARF address space of the memory pointed to or referenced by a
803 /// pointer or reference type respectively.
804 Optional<unsigned> DWARFAddressSpace;
806 DIDerivedType(LLVMContext &C, StorageType Storage, unsigned Tag,
807 unsigned Line, uint64_t SizeInBits, uint32_t AlignInBits,
808 uint64_t OffsetInBits, Optional<unsigned> DWARFAddressSpace,
809 DIFlags Flags, ArrayRef<Metadata *> Ops)
810 : DIType(C, DIDerivedTypeKind, Storage, Tag, Line, SizeInBits,
811 AlignInBits, OffsetInBits, Flags, Ops),
812 DWARFAddressSpace(DWARFAddressSpace) {}
813 ~DIDerivedType() = default;
815 static DIDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
816 StringRef Name, DIFile *File, unsigned Line,
817 DIScopeRef Scope, DITypeRef BaseType,
818 uint64_t SizeInBits, uint32_t AlignInBits,
819 uint64_t OffsetInBits,
820 Optional<unsigned> DWARFAddressSpace,
821 DIFlags Flags, Metadata *ExtraData,
822 StorageType Storage, bool ShouldCreate = true) {
823 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), File,
824 Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits,
825 DWARFAddressSpace, Flags, ExtraData, Storage, ShouldCreate);
827 static DIDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
828 MDString *Name, Metadata *File, unsigned Line,
829 Metadata *Scope, Metadata *BaseType,
830 uint64_t SizeInBits, uint32_t AlignInBits,
831 uint64_t OffsetInBits,
832 Optional<unsigned> DWARFAddressSpace,
833 DIFlags Flags, Metadata *ExtraData,
834 StorageType Storage, bool ShouldCreate = true);
836 TempDIDerivedType cloneImpl() const {
837 return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
838 getScope(), getBaseType(), getSizeInBits(),
839 getAlignInBits(), getOffsetInBits(),
840 getDWARFAddressSpace(), getFlags(), getExtraData());
844 DEFINE_MDNODE_GET(DIDerivedType,
845 (unsigned Tag, MDString *Name, Metadata *File,
846 unsigned Line, Metadata *Scope, Metadata *BaseType,
847 uint64_t SizeInBits, uint32_t AlignInBits,
848 uint64_t OffsetInBits,
849 Optional<unsigned> DWARFAddressSpace, DIFlags Flags,
850 Metadata *ExtraData = nullptr),
851 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
852 AlignInBits, OffsetInBits, DWARFAddressSpace, Flags,
854 DEFINE_MDNODE_GET(DIDerivedType,
855 (unsigned Tag, StringRef Name, DIFile *File, unsigned Line,
856 DIScopeRef Scope, DITypeRef BaseType, uint64_t SizeInBits,
857 uint32_t AlignInBits, uint64_t OffsetInBits,
858 Optional<unsigned> DWARFAddressSpace, DIFlags Flags,
859 Metadata *ExtraData = nullptr),
860 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
861 AlignInBits, OffsetInBits, DWARFAddressSpace, Flags,
864 TempDIDerivedType clone() const { return cloneImpl(); }
866 /// Get the base type this is derived from.
867 DITypeRef getBaseType() const { return DITypeRef(getRawBaseType()); }
868 Metadata *getRawBaseType() const { return getOperand(3); }
870 /// \returns The DWARF address space of the memory pointed to or referenced by
871 /// a pointer or reference type respectively.
872 Optional<unsigned> getDWARFAddressSpace() const { return DWARFAddressSpace; }
874 /// Get extra data associated with this derived type.
876 /// Class type for pointer-to-members, objective-c property node for ivars,
877 /// global constant wrapper for static members, or virtual base pointer offset
880 /// TODO: Separate out types that need this extra operand: pointer-to-member
881 /// types and member fields (static members and ivars).
882 Metadata *getExtraData() const { return getRawExtraData(); }
883 Metadata *getRawExtraData() const { return getOperand(4); }
885 /// Get casted version of extra data.
887 DITypeRef getClassType() const {
888 assert(getTag() == dwarf::DW_TAG_ptr_to_member_type);
889 return DITypeRef(getExtraData());
892 DIObjCProperty *getObjCProperty() const {
893 return dyn_cast_or_null<DIObjCProperty>(getExtraData());
896 uint32_t getVBPtrOffset() const {
897 assert(getTag() == dwarf::DW_TAG_inheritance);
898 if (auto *CM = cast_or_null<ConstantAsMetadata>(getExtraData()))
899 if (auto *CI = dyn_cast_or_null<ConstantInt>(CM->getValue()))
900 return static_cast<uint32_t>(CI->getZExtValue());
904 Constant *getStorageOffsetInBits() const {
905 assert(getTag() == dwarf::DW_TAG_member && isBitField());
906 if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
907 return C->getValue();
911 Constant *getConstant() const {
912 assert(getTag() == dwarf::DW_TAG_member && isStaticMember());
913 if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
914 return C->getValue();
917 Constant *getDiscriminantValue() const {
918 assert(getTag() == dwarf::DW_TAG_member && !isStaticMember());
919 if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
920 return C->getValue();
925 static bool classof(const Metadata *MD) {
926 return MD->getMetadataID() == DIDerivedTypeKind;
932 /// TODO: Detach from DerivedTypeBase (split out MDEnumType?).
933 /// TODO: Create a custom, unrelated node for DW_TAG_array_type.
934 class DICompositeType : public DIType {
935 friend class LLVMContextImpl;
938 unsigned RuntimeLang;
940 DICompositeType(LLVMContext &C, StorageType Storage, unsigned Tag,
941 unsigned Line, unsigned RuntimeLang, uint64_t SizeInBits,
942 uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
943 ArrayRef<Metadata *> Ops)
944 : DIType(C, DICompositeTypeKind, Storage, Tag, Line, SizeInBits,
945 AlignInBits, OffsetInBits, Flags, Ops),
946 RuntimeLang(RuntimeLang) {}
947 ~DICompositeType() = default;
949 /// Change fields in place.
950 void mutate(unsigned Tag, unsigned Line, unsigned RuntimeLang,
951 uint64_t SizeInBits, uint32_t AlignInBits,
952 uint64_t OffsetInBits, DIFlags Flags) {
953 assert(isDistinct() && "Only distinct nodes can mutate");
954 assert(getRawIdentifier() && "Only ODR-uniqued nodes should mutate");
955 this->RuntimeLang = RuntimeLang;
956 DIType::mutate(Tag, Line, SizeInBits, AlignInBits, OffsetInBits, Flags);
959 static DICompositeType *
960 getImpl(LLVMContext &Context, unsigned Tag, StringRef Name, Metadata *File,
961 unsigned Line, DIScopeRef Scope, DITypeRef BaseType,
962 uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
963 DIFlags Flags, DINodeArray Elements, unsigned RuntimeLang,
964 DITypeRef VTableHolder, DITemplateParameterArray TemplateParams,
965 StringRef Identifier, DIDerivedType *Discriminator,
966 StorageType Storage, bool ShouldCreate = true) {
968 Context, Tag, getCanonicalMDString(Context, Name), File, Line, Scope,
969 BaseType, SizeInBits, AlignInBits, OffsetInBits, Flags, Elements.get(),
970 RuntimeLang, VTableHolder, TemplateParams.get(),
971 getCanonicalMDString(Context, Identifier), Discriminator, Storage, ShouldCreate);
973 static DICompositeType *
974 getImpl(LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
975 unsigned Line, Metadata *Scope, Metadata *BaseType,
976 uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
977 DIFlags Flags, Metadata *Elements, unsigned RuntimeLang,
978 Metadata *VTableHolder, Metadata *TemplateParams,
979 MDString *Identifier, Metadata *Discriminator,
980 StorageType Storage, bool ShouldCreate = true);
982 TempDICompositeType cloneImpl() const {
983 return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
984 getScope(), getBaseType(), getSizeInBits(),
985 getAlignInBits(), getOffsetInBits(), getFlags(),
986 getElements(), getRuntimeLang(), getVTableHolder(),
987 getTemplateParams(), getIdentifier(), getDiscriminator());
991 DEFINE_MDNODE_GET(DICompositeType,
992 (unsigned Tag, StringRef Name, DIFile *File, unsigned Line,
993 DIScopeRef Scope, DITypeRef BaseType, uint64_t SizeInBits,
994 uint32_t AlignInBits, uint64_t OffsetInBits,
995 DIFlags Flags, DINodeArray Elements, unsigned RuntimeLang,
996 DITypeRef VTableHolder,
997 DITemplateParameterArray TemplateParams = nullptr,
998 StringRef Identifier = "", DIDerivedType *Discriminator = nullptr),
999 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
1000 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
1001 VTableHolder, TemplateParams, Identifier, Discriminator))
1002 DEFINE_MDNODE_GET(DICompositeType,
1003 (unsigned Tag, MDString *Name, Metadata *File,
1004 unsigned Line, Metadata *Scope, Metadata *BaseType,
1005 uint64_t SizeInBits, uint32_t AlignInBits,
1006 uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
1007 unsigned RuntimeLang, Metadata *VTableHolder,
1008 Metadata *TemplateParams = nullptr,
1009 MDString *Identifier = nullptr,
1010 Metadata *Discriminator = nullptr),
1011 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
1012 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
1013 VTableHolder, TemplateParams, Identifier, Discriminator))
1015 TempDICompositeType clone() const { return cloneImpl(); }
1017 /// Get a DICompositeType with the given ODR identifier.
1019 /// If \a LLVMContext::isODRUniquingDebugTypes(), gets the mapped
1020 /// DICompositeType for the given ODR \c Identifier. If none exists, creates
1023 /// Else, returns \c nullptr.
1024 static DICompositeType *
1025 getODRType(LLVMContext &Context, MDString &Identifier, unsigned Tag,
1026 MDString *Name, Metadata *File, unsigned Line, Metadata *Scope,
1027 Metadata *BaseType, uint64_t SizeInBits, uint32_t AlignInBits,
1028 uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
1029 unsigned RuntimeLang, Metadata *VTableHolder,
1030 Metadata *TemplateParams, Metadata *Discriminator);
1031 static DICompositeType *getODRTypeIfExists(LLVMContext &Context,
1032 MDString &Identifier);
1034 /// Build a DICompositeType with the given ODR identifier.
1036 /// Looks up the mapped DICompositeType for the given ODR \c Identifier. If
1037 /// it doesn't exist, creates a new one. If it does exist and \a
1038 /// isForwardDecl(), and the new arguments would be a definition, mutates the
1039 /// the type in place. In either case, returns the type.
1041 /// If not \a LLVMContext::isODRUniquingDebugTypes(), this function returns
1043 static DICompositeType *
1044 buildODRType(LLVMContext &Context, MDString &Identifier, unsigned Tag,
1045 MDString *Name, Metadata *File, unsigned Line, Metadata *Scope,
1046 Metadata *BaseType, uint64_t SizeInBits, uint32_t AlignInBits,
1047 uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
1048 unsigned RuntimeLang, Metadata *VTableHolder,
1049 Metadata *TemplateParams, Metadata *Discriminator);
1051 DITypeRef getBaseType() const { return DITypeRef(getRawBaseType()); }
1052 DINodeArray getElements() const {
1053 return cast_or_null<MDTuple>(getRawElements());
1055 DITypeRef getVTableHolder() const { return DITypeRef(getRawVTableHolder()); }
1056 DITemplateParameterArray getTemplateParams() const {
1057 return cast_or_null<MDTuple>(getRawTemplateParams());
1059 StringRef getIdentifier() const { return getStringOperand(7); }
1060 unsigned getRuntimeLang() const { return RuntimeLang; }
1062 Metadata *getRawBaseType() const { return getOperand(3); }
1063 Metadata *getRawElements() const { return getOperand(4); }
1064 Metadata *getRawVTableHolder() const { return getOperand(5); }
1065 Metadata *getRawTemplateParams() const { return getOperand(6); }
1066 MDString *getRawIdentifier() const { return getOperandAs<MDString>(7); }
1067 Metadata *getRawDiscriminator() const { return getOperand(8); }
1068 DIDerivedType *getDiscriminator() const { return getOperandAs<DIDerivedType>(8); }
1070 /// Replace operands.
1072 /// If this \a isUniqued() and not \a isResolved(), on a uniquing collision
1073 /// this will be RAUW'ed and deleted. Use a \a TrackingMDRef to keep track
1074 /// of its movement if necessary.
1076 void replaceElements(DINodeArray Elements) {
1078 for (DINode *Op : getElements())
1079 assert(is_contained(Elements->operands(), Op) &&
1080 "Lost a member during member list replacement");
1082 replaceOperandWith(4, Elements.get());
1085 void replaceVTableHolder(DITypeRef VTableHolder) {
1086 replaceOperandWith(5, VTableHolder);
1089 void replaceTemplateParams(DITemplateParameterArray TemplateParams) {
1090 replaceOperandWith(6, TemplateParams.get());
1094 static bool classof(const Metadata *MD) {
1095 return MD->getMetadataID() == DICompositeTypeKind;
1099 /// Type array for a subprogram.
1101 /// TODO: Fold the array of types in directly as operands.
1102 class DISubroutineType : public DIType {
1103 friend class LLVMContextImpl;
1104 friend class MDNode;
1106 /// The calling convention used with DW_AT_calling_convention. Actually of
1107 /// type dwarf::CallingConvention.
1110 DISubroutineType(LLVMContext &C, StorageType Storage, DIFlags Flags,
1111 uint8_t CC, ArrayRef<Metadata *> Ops)
1112 : DIType(C, DISubroutineTypeKind, Storage, dwarf::DW_TAG_subroutine_type,
1113 0, 0, 0, 0, Flags, Ops),
1115 ~DISubroutineType() = default;
1117 static DISubroutineType *getImpl(LLVMContext &Context, DIFlags Flags,
1118 uint8_t CC, DITypeRefArray TypeArray,
1119 StorageType Storage,
1120 bool ShouldCreate = true) {
1121 return getImpl(Context, Flags, CC, TypeArray.get(), Storage, ShouldCreate);
1123 static DISubroutineType *getImpl(LLVMContext &Context, DIFlags Flags,
1124 uint8_t CC, Metadata *TypeArray,
1125 StorageType Storage,
1126 bool ShouldCreate = true);
1128 TempDISubroutineType cloneImpl() const {
1129 return getTemporary(getContext(), getFlags(), getCC(), getTypeArray());
1133 DEFINE_MDNODE_GET(DISubroutineType,
1134 (DIFlags Flags, uint8_t CC, DITypeRefArray TypeArray),
1135 (Flags, CC, TypeArray))
1136 DEFINE_MDNODE_GET(DISubroutineType,
1137 (DIFlags Flags, uint8_t CC, Metadata *TypeArray),
1138 (Flags, CC, TypeArray))
1140 TempDISubroutineType clone() const { return cloneImpl(); }
1142 uint8_t getCC() const { return CC; }
1144 DITypeRefArray getTypeArray() const {
1145 return cast_or_null<MDTuple>(getRawTypeArray());
1148 Metadata *getRawTypeArray() const { return getOperand(3); }
1150 static bool classof(const Metadata *MD) {
1151 return MD->getMetadataID() == DISubroutineTypeKind;
1156 class DICompileUnit : public DIScope {
1157 friend class LLVMContextImpl;
1158 friend class MDNode;
1161 enum DebugEmissionKind : unsigned {
1165 LastEmissionKind = LineTablesOnly
1168 static Optional<DebugEmissionKind> getEmissionKind(StringRef Str);
1169 static const char *emissionKindString(DebugEmissionKind EK);
1172 unsigned SourceLanguage;
1174 unsigned RuntimeVersion;
1175 unsigned EmissionKind;
1177 bool SplitDebugInlining;
1178 bool DebugInfoForProfiling;
1181 DICompileUnit(LLVMContext &C, StorageType Storage, unsigned SourceLanguage,
1182 bool IsOptimized, unsigned RuntimeVersion,
1183 unsigned EmissionKind, uint64_t DWOId, bool SplitDebugInlining,
1184 bool DebugInfoForProfiling, bool GnuPubnames, ArrayRef<Metadata *> Ops)
1185 : DIScope(C, DICompileUnitKind, Storage, dwarf::DW_TAG_compile_unit, Ops),
1186 SourceLanguage(SourceLanguage), IsOptimized(IsOptimized),
1187 RuntimeVersion(RuntimeVersion), EmissionKind(EmissionKind),
1188 DWOId(DWOId), SplitDebugInlining(SplitDebugInlining),
1189 DebugInfoForProfiling(DebugInfoForProfiling), GnuPubnames(GnuPubnames) {
1190 assert(Storage != Uniqued);
1192 ~DICompileUnit() = default;
1194 static DICompileUnit *
1195 getImpl(LLVMContext &Context, unsigned SourceLanguage, DIFile *File,
1196 StringRef Producer, bool IsOptimized, StringRef Flags,
1197 unsigned RuntimeVersion, StringRef SplitDebugFilename,
1198 unsigned EmissionKind, DICompositeTypeArray EnumTypes,
1199 DIScopeArray RetainedTypes,
1200 DIGlobalVariableExpressionArray GlobalVariables,
1201 DIImportedEntityArray ImportedEntities, DIMacroNodeArray Macros,
1202 uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
1203 bool GnuPubnames, StorageType Storage, bool ShouldCreate = true) {
1205 Context, SourceLanguage, File, getCanonicalMDString(Context, Producer),
1206 IsOptimized, getCanonicalMDString(Context, Flags), RuntimeVersion,
1207 getCanonicalMDString(Context, SplitDebugFilename), EmissionKind,
1208 EnumTypes.get(), RetainedTypes.get(), GlobalVariables.get(),
1209 ImportedEntities.get(), Macros.get(), DWOId, SplitDebugInlining,
1210 DebugInfoForProfiling, GnuPubnames, Storage, ShouldCreate);
1212 static DICompileUnit *
1213 getImpl(LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
1214 MDString *Producer, bool IsOptimized, MDString *Flags,
1215 unsigned RuntimeVersion, MDString *SplitDebugFilename,
1216 unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
1217 Metadata *GlobalVariables, Metadata *ImportedEntities,
1218 Metadata *Macros, uint64_t DWOId, bool SplitDebugInlining,
1219 bool DebugInfoForProfiling, bool GnuPubnames, StorageType Storage,
1220 bool ShouldCreate = true);
1222 TempDICompileUnit cloneImpl() const {
1223 return getTemporary(getContext(), getSourceLanguage(), getFile(),
1224 getProducer(), isOptimized(), getFlags(),
1225 getRuntimeVersion(), getSplitDebugFilename(),
1226 getEmissionKind(), getEnumTypes(), getRetainedTypes(),
1227 getGlobalVariables(), getImportedEntities(),
1228 getMacros(), DWOId, getSplitDebugInlining(),
1229 getDebugInfoForProfiling(), getGnuPubnames());
1233 static void get() = delete;
1234 static void getIfExists() = delete;
1236 DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(
1238 (unsigned SourceLanguage, DIFile *File, StringRef Producer,
1239 bool IsOptimized, StringRef Flags, unsigned RuntimeVersion,
1240 StringRef SplitDebugFilename, DebugEmissionKind EmissionKind,
1241 DICompositeTypeArray EnumTypes, DIScopeArray RetainedTypes,
1242 DIGlobalVariableExpressionArray GlobalVariables,
1243 DIImportedEntityArray ImportedEntities, DIMacroNodeArray Macros,
1244 uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
1246 (SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion,
1247 SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
1248 GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining,
1249 DebugInfoForProfiling, GnuPubnames))
1250 DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(
1252 (unsigned SourceLanguage, Metadata *File, MDString *Producer,
1253 bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
1254 MDString *SplitDebugFilename, unsigned EmissionKind, Metadata *EnumTypes,
1255 Metadata *RetainedTypes, Metadata *GlobalVariables,
1256 Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId,
1257 bool SplitDebugInlining, bool DebugInfoForProfiling, bool GnuPubnames),
1258 (SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion,
1259 SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
1260 GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining,
1261 DebugInfoForProfiling, GnuPubnames))
1263 TempDICompileUnit clone() const { return cloneImpl(); }
1265 unsigned getSourceLanguage() const { return SourceLanguage; }
1266 bool isOptimized() const { return IsOptimized; }
1267 unsigned getRuntimeVersion() const { return RuntimeVersion; }
1268 DebugEmissionKind getEmissionKind() const {
1269 return (DebugEmissionKind)EmissionKind;
1271 bool getDebugInfoForProfiling() const { return DebugInfoForProfiling; }
1272 bool getGnuPubnames() const { return GnuPubnames; }
1273 StringRef getProducer() const { return getStringOperand(1); }
1274 StringRef getFlags() const { return getStringOperand(2); }
1275 StringRef getSplitDebugFilename() const { return getStringOperand(3); }
1276 DICompositeTypeArray getEnumTypes() const {
1277 return cast_or_null<MDTuple>(getRawEnumTypes());
1279 DIScopeArray getRetainedTypes() const {
1280 return cast_or_null<MDTuple>(getRawRetainedTypes());
1282 DIGlobalVariableExpressionArray getGlobalVariables() const {
1283 return cast_or_null<MDTuple>(getRawGlobalVariables());
1285 DIImportedEntityArray getImportedEntities() const {
1286 return cast_or_null<MDTuple>(getRawImportedEntities());
1288 DIMacroNodeArray getMacros() const {
1289 return cast_or_null<MDTuple>(getRawMacros());
1291 uint64_t getDWOId() const { return DWOId; }
1292 void setDWOId(uint64_t DwoId) { DWOId = DwoId; }
1293 bool getSplitDebugInlining() const { return SplitDebugInlining; }
1294 void setSplitDebugInlining(bool SplitDebugInlining) {
1295 this->SplitDebugInlining = SplitDebugInlining;
1298 MDString *getRawProducer() const { return getOperandAs<MDString>(1); }
1299 MDString *getRawFlags() const { return getOperandAs<MDString>(2); }
1300 MDString *getRawSplitDebugFilename() const {
1301 return getOperandAs<MDString>(3);
1303 Metadata *getRawEnumTypes() const { return getOperand(4); }
1304 Metadata *getRawRetainedTypes() const { return getOperand(5); }
1305 Metadata *getRawGlobalVariables() const { return getOperand(6); }
1306 Metadata *getRawImportedEntities() const { return getOperand(7); }
1307 Metadata *getRawMacros() const { return getOperand(8); }
1311 /// If this \a isUniqued() and not \a isResolved(), it will be RAUW'ed and
1312 /// deleted on a uniquing collision. In practice, uniquing collisions on \a
1313 /// DICompileUnit should be fairly rare.
1315 void replaceEnumTypes(DICompositeTypeArray N) {
1316 replaceOperandWith(4, N.get());
1318 void replaceRetainedTypes(DITypeArray N) {
1319 replaceOperandWith(5, N.get());
1321 void replaceGlobalVariables(DIGlobalVariableExpressionArray N) {
1322 replaceOperandWith(6, N.get());
1324 void replaceImportedEntities(DIImportedEntityArray N) {
1325 replaceOperandWith(7, N.get());
1327 void replaceMacros(DIMacroNodeArray N) { replaceOperandWith(8, N.get()); }
1330 static bool classof(const Metadata *MD) {
1331 return MD->getMetadataID() == DICompileUnitKind;
1335 /// A scope for locals.
1337 /// A legal scope for lexical blocks, local variables, and debug info
1338 /// locations. Subclasses are \a DISubprogram, \a DILexicalBlock, and \a
1339 /// DILexicalBlockFile.
1340 class DILocalScope : public DIScope {
1342 DILocalScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
1343 ArrayRef<Metadata *> Ops)
1344 : DIScope(C, ID, Storage, Tag, Ops) {}
1345 ~DILocalScope() = default;
1348 /// Get the subprogram for this scope.
1350 /// Return this if it's an \a DISubprogram; otherwise, look up the scope
1352 DISubprogram *getSubprogram() const;
1354 /// Get the first non DILexicalBlockFile scope of this scope.
1356 /// Return this if it's not a \a DILexicalBlockFIle; otherwise, look up the
1358 DILocalScope *getNonLexicalBlockFileScope() const;
1360 static bool classof(const Metadata *MD) {
1361 return MD->getMetadataID() == DISubprogramKind ||
1362 MD->getMetadataID() == DILexicalBlockKind ||
1363 MD->getMetadataID() == DILexicalBlockFileKind;
1369 /// A debug location in source code, used for debug info and otherwise.
1370 class DILocation : public MDNode {
1371 friend class LLVMContextImpl;
1372 friend class MDNode;
1374 DILocation(LLVMContext &C, StorageType Storage, unsigned Line,
1375 unsigned Column, ArrayRef<Metadata *> MDs);
1376 ~DILocation() { dropAllReferences(); }
1378 static DILocation *getImpl(LLVMContext &Context, unsigned Line,
1379 unsigned Column, Metadata *Scope,
1380 Metadata *InlinedAt, StorageType Storage,
1381 bool ShouldCreate = true);
1382 static DILocation *getImpl(LLVMContext &Context, unsigned Line,
1383 unsigned Column, DILocalScope *Scope,
1384 DILocation *InlinedAt, StorageType Storage,
1385 bool ShouldCreate = true) {
1386 return getImpl(Context, Line, Column, static_cast<Metadata *>(Scope),
1387 static_cast<Metadata *>(InlinedAt), Storage, ShouldCreate);
1390 /// With a given unsigned int \p U, use up to 13 bits to represent it.
1391 /// old_bit 1~5 --> new_bit 1~5
1392 /// old_bit 6~12 --> new_bit 7~13
1393 /// new_bit_6 is 0 if higher bits (7~13) are all 0
1394 static unsigned getPrefixEncodingFromUnsigned(unsigned U) {
1396 return U > 0x1f ? (((U & 0xfe0) << 1) | (U & 0x1f) | 0x20) : U;
1399 /// Reverse transformation as getPrefixEncodingFromUnsigned.
1400 static unsigned getUnsignedFromPrefixEncoding(unsigned U) {
1401 return (U & 0x20) ? (((U >> 1) & 0xfe0) | (U & 0x1f)) : (U & 0x1f);
1404 /// Returns the next component stored in discriminator.
1405 static unsigned getNextComponentInDiscriminator(unsigned D) {
1407 return D >> ((D & 0x40) ? 14 : 7);
1412 TempDILocation cloneImpl() const {
1413 // Get the raw scope/inlinedAt since it is possible to invoke this on
1414 // a DILocation containing temporary metadata.
1415 return getTemporary(getContext(), getLine(), getColumn(), getRawScope(),
1420 // Disallow replacing operands.
1421 void replaceOperandWith(unsigned I, Metadata *New) = delete;
1423 DEFINE_MDNODE_GET(DILocation,
1424 (unsigned Line, unsigned Column, Metadata *Scope,
1425 Metadata *InlinedAt = nullptr),
1426 (Line, Column, Scope, InlinedAt))
1427 DEFINE_MDNODE_GET(DILocation,
1428 (unsigned Line, unsigned Column, DILocalScope *Scope,
1429 DILocation *InlinedAt = nullptr),
1430 (Line, Column, Scope, InlinedAt))
1432 /// Return a (temporary) clone of this.
1433 TempDILocation clone() const { return cloneImpl(); }
1435 unsigned getLine() const { return SubclassData32; }
1436 unsigned getColumn() const { return SubclassData16; }
1437 DILocalScope *getScope() const { return cast<DILocalScope>(getRawScope()); }
1439 DILocation *getInlinedAt() const {
1440 return cast_or_null<DILocation>(getRawInlinedAt());
1443 DIFile *getFile() const { return getScope()->getFile(); }
1444 StringRef getFilename() const { return getScope()->getFilename(); }
1445 StringRef getDirectory() const { return getScope()->getDirectory(); }
1446 Optional<StringRef> getSource() const { return getScope()->getSource(); }
1448 /// Get the scope where this is inlined.
1450 /// Walk through \a getInlinedAt() and return \a getScope() from the deepest
1452 DILocalScope *getInlinedAtScope() const {
1453 if (auto *IA = getInlinedAt())
1454 return IA->getInlinedAtScope();
1458 /// Check whether this can be discriminated from another location.
1460 /// Check \c this can be discriminated from \c RHS in a linetable entry.
1461 /// Scope and inlined-at chains are not recorded in the linetable, so they
1462 /// cannot be used to distinguish basic blocks.
1463 bool canDiscriminate(const DILocation &RHS) const {
1464 return getLine() != RHS.getLine() ||
1465 getColumn() != RHS.getColumn() ||
1466 getDiscriminator() != RHS.getDiscriminator() ||
1467 getFilename() != RHS.getFilename() ||
1468 getDirectory() != RHS.getDirectory();
1471 /// Get the DWARF discriminator.
1473 /// DWARF discriminators distinguish identical file locations between
1474 /// instructions that are on different basic blocks.
1476 /// There are 3 components stored in discriminator, from lower bits:
1478 /// Base discriminator: assigned by AddDiscriminators pass to identify IRs
1479 /// that are defined by the same source line, but
1480 /// different basic blocks.
1481 /// Duplication factor: assigned by optimizations that will scale down
1482 /// the execution frequency of the original IR.
1483 /// Copy Identifier: assigned by optimizations that clones the IR.
1484 /// Each copy of the IR will be assigned an identifier.
1488 /// The above 3 components are encoded into a 32bit unsigned integer in
1489 /// order. If the lowest bit is 1, the current component is empty, and the
1490 /// next component will start in the next bit. Otherwise, the current
1491 /// component is non-empty, and its content starts in the next bit. The
1492 /// length of each components is either 5 bit or 12 bit: if the 7th bit
1493 /// is 0, the bit 2~6 (5 bits) are used to represent the component; if the
1494 /// 7th bit is 1, the bit 2~6 (5 bits) and 8~14 (7 bits) are combined to
1495 /// represent the component.
1497 inline unsigned getDiscriminator() const;
1499 /// Returns a new DILocation with updated \p Discriminator.
1500 inline const DILocation *cloneWithDiscriminator(unsigned Discriminator) const;
1502 /// Returns a new DILocation with updated base discriminator \p BD.
1503 inline const DILocation *setBaseDiscriminator(unsigned BD) const;
1505 /// Returns the duplication factor stored in the discriminator.
1506 inline unsigned getDuplicationFactor() const;
1508 /// Returns the copy identifier stored in the discriminator.
1509 inline unsigned getCopyIdentifier() const;
1511 /// Returns the base discriminator stored in the discriminator.
1512 inline unsigned getBaseDiscriminator() const;
1514 /// Returns a new DILocation with duplication factor \p DF encoded in the
1516 inline const DILocation *cloneWithDuplicationFactor(unsigned DF) const;
1518 enum { NoGeneratedLocation = false, WithGeneratedLocation = true };
1520 /// When two instructions are combined into a single instruction we also
1521 /// need to combine the original locations into a single location.
1523 /// When the locations are the same we can use either location. When they
1524 /// differ, we need a third location which is distinct from either. If they
1525 /// have the same file/line but have a different discriminator we could
1526 /// create a location with a new discriminator. If they are from different
1527 /// files/lines the location is ambiguous and can't be represented in a line
1528 /// entry. In this case, if \p GenerateLocation is true, we will set the
1529 /// merged debug location as line 0 of the nearest common scope where the two
1530 /// locations are inlined from.
1532 /// \p GenerateLocation: Whether the merged location can be generated when
1533 /// \p LocA and \p LocB differ.
1534 static const DILocation *
1535 getMergedLocation(const DILocation *LocA, const DILocation *LocB,
1536 bool GenerateLocation = NoGeneratedLocation);
1538 /// Returns the base discriminator for a given encoded discriminator \p D.
1539 static unsigned getBaseDiscriminatorFromDiscriminator(unsigned D) {
1541 return getUnsignedFromPrefixEncoding(D >> 1);
1546 /// Returns the duplication factor for a given encoded discriminator \p D.
1547 static unsigned getDuplicationFactorFromDiscriminator(unsigned D) {
1548 D = getNextComponentInDiscriminator(D);
1549 if (D == 0 || (D & 1))
1552 return getUnsignedFromPrefixEncoding(D >> 1);
1555 /// Returns the copy identifier for a given encoded discriminator \p D.
1556 static unsigned getCopyIdentifierFromDiscriminator(unsigned D) {
1557 return getUnsignedFromPrefixEncoding(getNextComponentInDiscriminator(
1558 getNextComponentInDiscriminator(D)));
1562 Metadata *getRawScope() const { return getOperand(0); }
1563 Metadata *getRawInlinedAt() const {
1564 if (getNumOperands() == 2)
1565 return getOperand(1);
1569 static bool classof(const Metadata *MD) {
1570 return MD->getMetadataID() == DILocationKind;
1574 /// Subprogram description.
1576 /// TODO: Remove DisplayName. It's always equal to Name.
1577 /// TODO: Split up flags.
1578 class DISubprogram : public DILocalScope {
1579 friend class LLVMContextImpl;
1580 friend class MDNode;
1584 unsigned VirtualIndex;
1586 /// In the MS ABI, the implicit 'this' parameter is adjusted in the prologue
1587 /// of method overrides from secondary bases by this amount. It may be
1591 // Virtuality can only assume three values, so we can pack
1592 // in 2 bits (none/pure/pure_virtual).
1593 unsigned Virtuality : 2;
1595 // These are boolean flags so one bit is enough.
1596 // MSVC starts a new container field every time the base
1597 // type changes so we can't use 'bool' to ensure these bits
1599 unsigned IsLocalToUnit : 1;
1600 unsigned IsDefinition : 1;
1601 unsigned IsOptimized : 1;
1603 unsigned Padding : 3;
1607 DISubprogram(LLVMContext &C, StorageType Storage, unsigned Line,
1608 unsigned ScopeLine, unsigned Virtuality, unsigned VirtualIndex,
1609 int ThisAdjustment, DIFlags Flags, bool IsLocalToUnit,
1610 bool IsDefinition, bool IsOptimized, ArrayRef<Metadata *> Ops)
1611 : DILocalScope(C, DISubprogramKind, Storage, dwarf::DW_TAG_subprogram,
1613 Line(Line), ScopeLine(ScopeLine), VirtualIndex(VirtualIndex),
1614 ThisAdjustment(ThisAdjustment), Virtuality(Virtuality),
1615 IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition),
1616 IsOptimized(IsOptimized), Flags(Flags) {
1617 static_assert(dwarf::DW_VIRTUALITY_max < 4, "Virtuality out of range");
1618 assert(Virtuality < 4 && "Virtuality out of range");
1620 ~DISubprogram() = default;
1622 static DISubprogram *
1623 getImpl(LLVMContext &Context, DIScopeRef Scope, StringRef Name,
1624 StringRef LinkageName, DIFile *File, unsigned Line,
1625 DISubroutineType *Type, bool IsLocalToUnit, bool IsDefinition,
1626 unsigned ScopeLine, DITypeRef ContainingType, unsigned Virtuality,
1627 unsigned VirtualIndex, int ThisAdjustment, DIFlags Flags,
1628 bool IsOptimized, DICompileUnit *Unit,
1629 DITemplateParameterArray TemplateParams, DISubprogram *Declaration,
1630 DINodeArray RetainedNodes, DITypeArray ThrownTypes,
1631 StorageType Storage, bool ShouldCreate = true) {
1632 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
1633 getCanonicalMDString(Context, LinkageName), File, Line, Type,
1634 IsLocalToUnit, IsDefinition, ScopeLine, ContainingType,
1635 Virtuality, VirtualIndex, ThisAdjustment, Flags, IsOptimized,
1636 Unit, TemplateParams.get(), Declaration, RetainedNodes.get(),
1637 ThrownTypes.get(), Storage, ShouldCreate);
1639 static DISubprogram *
1640 getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
1641 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
1642 bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
1643 Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex,
1644 int ThisAdjustment, DIFlags Flags, bool IsOptimized, Metadata *Unit,
1645 Metadata *TemplateParams, Metadata *Declaration, Metadata *RetainedNodes,
1646 Metadata *ThrownTypes, StorageType Storage, bool ShouldCreate = true);
1648 TempDISubprogram cloneImpl() const {
1649 return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
1650 getFile(), getLine(), getType(), isLocalToUnit(),
1651 isDefinition(), getScopeLine(), getContainingType(),
1652 getVirtuality(), getVirtualIndex(), getThisAdjustment(),
1653 getFlags(), isOptimized(), getUnit(),
1654 getTemplateParams(), getDeclaration(), getRetainedNodes(),
1659 DEFINE_MDNODE_GET(DISubprogram,
1660 (DIScopeRef Scope, StringRef Name, StringRef LinkageName,
1661 DIFile *File, unsigned Line, DISubroutineType *Type,
1662 bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
1663 DITypeRef ContainingType, unsigned Virtuality,
1664 unsigned VirtualIndex, int ThisAdjustment, DIFlags Flags,
1665 bool IsOptimized, DICompileUnit *Unit,
1666 DITemplateParameterArray TemplateParams = nullptr,
1667 DISubprogram *Declaration = nullptr,
1668 DINodeArray RetainedNodes = nullptr,
1669 DITypeArray ThrownTypes = nullptr),
1670 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
1671 IsDefinition, ScopeLine, ContainingType, Virtuality,
1672 VirtualIndex, ThisAdjustment, Flags, IsOptimized, Unit,
1673 TemplateParams, Declaration, RetainedNodes, ThrownTypes))
1676 (Metadata * Scope, MDString *Name, MDString *LinkageName, Metadata *File,
1677 unsigned Line, Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
1678 unsigned ScopeLine, Metadata *ContainingType, unsigned Virtuality,
1679 unsigned VirtualIndex, int ThisAdjustment, DIFlags Flags,
1680 bool IsOptimized, Metadata *Unit, Metadata *TemplateParams = nullptr,
1681 Metadata *Declaration = nullptr, Metadata *RetainedNodes = nullptr,
1682 Metadata *ThrownTypes = nullptr),
1683 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition,
1684 ScopeLine, ContainingType, Virtuality, VirtualIndex, ThisAdjustment,
1685 Flags, IsOptimized, Unit, TemplateParams, Declaration, RetainedNodes,
1688 TempDISubprogram clone() const { return cloneImpl(); }
1690 /// Returns a new temporary DISubprogram with updated Flags
1691 TempDISubprogram cloneWithFlags(DIFlags NewFlags) const {
1692 auto NewSP = clone();
1693 NewSP->Flags = NewFlags;
1698 unsigned getLine() const { return Line; }
1699 unsigned getVirtuality() const { return Virtuality; }
1700 unsigned getVirtualIndex() const { return VirtualIndex; }
1701 int getThisAdjustment() const { return ThisAdjustment; }
1702 unsigned getScopeLine() const { return ScopeLine; }
1703 DIFlags getFlags() const { return Flags; }
1704 bool isLocalToUnit() const { return IsLocalToUnit; }
1705 bool isDefinition() const { return IsDefinition; }
1706 bool isOptimized() const { return IsOptimized; }
1708 bool isArtificial() const { return getFlags() & FlagArtificial; }
1709 bool isPrivate() const {
1710 return (getFlags() & FlagAccessibility) == FlagPrivate;
1712 bool isProtected() const {
1713 return (getFlags() & FlagAccessibility) == FlagProtected;
1715 bool isPublic() const {
1716 return (getFlags() & FlagAccessibility) == FlagPublic;
1718 bool isExplicit() const { return getFlags() & FlagExplicit; }
1719 bool isPrototyped() const { return getFlags() & FlagPrototyped; }
1720 bool isMainSubprogram() const { return getFlags() & FlagMainSubprogram; }
1722 /// Check if this is reference-qualified.
1724 /// Return true if this subprogram is a C++11 reference-qualified non-static
1725 /// member function (void foo() &).
1726 bool isLValueReference() const { return getFlags() & FlagLValueReference; }
1728 /// Check if this is rvalue-reference-qualified.
1730 /// Return true if this subprogram is a C++11 rvalue-reference-qualified
1731 /// non-static member function (void foo() &&).
1732 bool isRValueReference() const { return getFlags() & FlagRValueReference; }
1734 /// Check if this is marked as noreturn.
1736 /// Return true if this subprogram is C++11 noreturn or C11 _Noreturn
1737 bool isNoReturn() const { return getFlags() & FlagNoReturn; }
1739 // Check if this routine is a compiler-generated thunk.
1741 // Returns true if this subprogram is a thunk generated by the compiler.
1742 bool isThunk() const { return getFlags() & FlagThunk; }
1744 DIScopeRef getScope() const { return DIScopeRef(getRawScope()); }
1746 StringRef getName() const { return getStringOperand(2); }
1747 StringRef getLinkageName() const { return getStringOperand(3); }
1749 DISubroutineType *getType() const {
1750 return cast_or_null<DISubroutineType>(getRawType());
1752 DITypeRef getContainingType() const {
1753 return DITypeRef(getRawContainingType());
1756 DICompileUnit *getUnit() const {
1757 return cast_or_null<DICompileUnit>(getRawUnit());
1759 void replaceUnit(DICompileUnit *CU) { replaceOperandWith(5, CU); }
1760 DITemplateParameterArray getTemplateParams() const {
1761 return cast_or_null<MDTuple>(getRawTemplateParams());
1763 DISubprogram *getDeclaration() const {
1764 return cast_or_null<DISubprogram>(getRawDeclaration());
1766 DINodeArray getRetainedNodes() const {
1767 return cast_or_null<MDTuple>(getRawRetainedNodes());
1769 DITypeArray getThrownTypes() const {
1770 return cast_or_null<MDTuple>(getRawThrownTypes());
1773 Metadata *getRawScope() const { return getOperand(1); }
1774 MDString *getRawName() const { return getOperandAs<MDString>(2); }
1775 MDString *getRawLinkageName() const { return getOperandAs<MDString>(3); }
1776 Metadata *getRawType() const { return getOperand(4); }
1777 Metadata *getRawUnit() const { return getOperand(5); }
1778 Metadata *getRawDeclaration() const { return getOperand(6); }
1779 Metadata *getRawRetainedNodes() const { return getOperand(7); }
1780 Metadata *getRawContainingType() const {
1781 return getNumOperands() > 8 ? getOperandAs<Metadata>(8) : nullptr;
1783 Metadata *getRawTemplateParams() const {
1784 return getNumOperands() > 9 ? getOperandAs<Metadata>(9) : nullptr;
1786 Metadata *getRawThrownTypes() const {
1787 return getNumOperands() > 10 ? getOperandAs<Metadata>(10) : nullptr;
1790 /// Check if this subprogram describes the given function.
1792 /// FIXME: Should this be looking through bitcasts?
1793 bool describes(const Function *F) const;
1795 static bool classof(const Metadata *MD) {
1796 return MD->getMetadataID() == DISubprogramKind;
1800 class DILexicalBlockBase : public DILocalScope {
1802 DILexicalBlockBase(LLVMContext &C, unsigned ID, StorageType Storage,
1803 ArrayRef<Metadata *> Ops)
1804 : DILocalScope(C, ID, Storage, dwarf::DW_TAG_lexical_block, Ops) {}
1805 ~DILexicalBlockBase() = default;
1808 DILocalScope *getScope() const { return cast<DILocalScope>(getRawScope()); }
1810 Metadata *getRawScope() const { return getOperand(1); }
1812 static bool classof(const Metadata *MD) {
1813 return MD->getMetadataID() == DILexicalBlockKind ||
1814 MD->getMetadataID() == DILexicalBlockFileKind;
1818 class DILexicalBlock : public DILexicalBlockBase {
1819 friend class LLVMContextImpl;
1820 friend class MDNode;
1825 DILexicalBlock(LLVMContext &C, StorageType Storage, unsigned Line,
1826 unsigned Column, ArrayRef<Metadata *> Ops)
1827 : DILexicalBlockBase(C, DILexicalBlockKind, Storage, Ops), Line(Line),
1829 assert(Column < (1u << 16) && "Expected 16-bit column");
1831 ~DILexicalBlock() = default;
1833 static DILexicalBlock *getImpl(LLVMContext &Context, DILocalScope *Scope,
1834 DIFile *File, unsigned Line, unsigned Column,
1835 StorageType Storage,
1836 bool ShouldCreate = true) {
1837 return getImpl(Context, static_cast<Metadata *>(Scope),
1838 static_cast<Metadata *>(File), Line, Column, Storage,
1842 static DILexicalBlock *getImpl(LLVMContext &Context, Metadata *Scope,
1843 Metadata *File, unsigned Line, unsigned Column,
1844 StorageType Storage, bool ShouldCreate = true);
1846 TempDILexicalBlock cloneImpl() const {
1847 return getTemporary(getContext(), getScope(), getFile(), getLine(),
1852 DEFINE_MDNODE_GET(DILexicalBlock, (DILocalScope * Scope, DIFile *File,
1853 unsigned Line, unsigned Column),
1854 (Scope, File, Line, Column))
1855 DEFINE_MDNODE_GET(DILexicalBlock, (Metadata * Scope, Metadata *File,
1856 unsigned Line, unsigned Column),
1857 (Scope, File, Line, Column))
1859 TempDILexicalBlock clone() const { return cloneImpl(); }
1861 unsigned getLine() const { return Line; }
1862 unsigned getColumn() const { return Column; }
1864 static bool classof(const Metadata *MD) {
1865 return MD->getMetadataID() == DILexicalBlockKind;
1869 class DILexicalBlockFile : public DILexicalBlockBase {
1870 friend class LLVMContextImpl;
1871 friend class MDNode;
1873 unsigned Discriminator;
1875 DILexicalBlockFile(LLVMContext &C, StorageType Storage,
1876 unsigned Discriminator, ArrayRef<Metadata *> Ops)
1877 : DILexicalBlockBase(C, DILexicalBlockFileKind, Storage, Ops),
1878 Discriminator(Discriminator) {}
1879 ~DILexicalBlockFile() = default;
1881 static DILexicalBlockFile *getImpl(LLVMContext &Context, DILocalScope *Scope,
1882 DIFile *File, unsigned Discriminator,
1883 StorageType Storage,
1884 bool ShouldCreate = true) {
1885 return getImpl(Context, static_cast<Metadata *>(Scope),
1886 static_cast<Metadata *>(File), Discriminator, Storage,
1890 static DILexicalBlockFile *getImpl(LLVMContext &Context, Metadata *Scope,
1891 Metadata *File, unsigned Discriminator,
1892 StorageType Storage,
1893 bool ShouldCreate = true);
1895 TempDILexicalBlockFile cloneImpl() const {
1896 return getTemporary(getContext(), getScope(), getFile(),
1897 getDiscriminator());
1901 DEFINE_MDNODE_GET(DILexicalBlockFile, (DILocalScope * Scope, DIFile *File,
1902 unsigned Discriminator),
1903 (Scope, File, Discriminator))
1904 DEFINE_MDNODE_GET(DILexicalBlockFile,
1905 (Metadata * Scope, Metadata *File, unsigned Discriminator),
1906 (Scope, File, Discriminator))
1908 TempDILexicalBlockFile clone() const { return cloneImpl(); }
1910 // TODO: Remove these once they're gone from DILexicalBlockBase.
1911 unsigned getLine() const = delete;
1912 unsigned getColumn() const = delete;
1914 unsigned getDiscriminator() const { return Discriminator; }
1916 static bool classof(const Metadata *MD) {
1917 return MD->getMetadataID() == DILexicalBlockFileKind;
1921 unsigned DILocation::getDiscriminator() const {
1922 if (auto *F = dyn_cast<DILexicalBlockFile>(getScope()))
1923 return F->getDiscriminator();
1928 DILocation::cloneWithDiscriminator(unsigned Discriminator) const {
1929 DIScope *Scope = getScope();
1930 // Skip all parent DILexicalBlockFile that already have a discriminator
1931 // assigned. We do not want to have nested DILexicalBlockFiles that have
1932 // mutliple discriminators because only the leaf DILexicalBlockFile's
1933 // dominator will be used.
1934 for (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope);
1935 LBF && LBF->getDiscriminator() != 0;
1936 LBF = dyn_cast<DILexicalBlockFile>(Scope))
1937 Scope = LBF->getScope();
1938 DILexicalBlockFile *NewScope =
1939 DILexicalBlockFile::get(getContext(), Scope, getFile(), Discriminator);
1940 return DILocation::get(getContext(), getLine(), getColumn(), NewScope,
1944 unsigned DILocation::getBaseDiscriminator() const {
1945 return getBaseDiscriminatorFromDiscriminator(getDiscriminator());
1948 unsigned DILocation::getDuplicationFactor() const {
1949 return getDuplicationFactorFromDiscriminator(getDiscriminator());
1952 unsigned DILocation::getCopyIdentifier() const {
1953 return getCopyIdentifierFromDiscriminator(getDiscriminator());
1956 const DILocation *DILocation::setBaseDiscriminator(unsigned D) const {
1960 return cloneWithDiscriminator(getPrefixEncodingFromUnsigned(D) << 1);
1963 const DILocation *DILocation::cloneWithDuplicationFactor(unsigned DF) const {
1964 DF *= getDuplicationFactor();
1968 unsigned BD = getBaseDiscriminator();
1969 unsigned CI = getCopyIdentifier() << (DF > 0x1f ? 14 : 7);
1970 unsigned D = CI | (getPrefixEncodingFromUnsigned(DF) << 1);
1975 D = (D << (BD > 0x1f ? 14 : 7)) | (getPrefixEncodingFromUnsigned(BD) << 1);
1977 return cloneWithDiscriminator(D);
1980 class DINamespace : public DIScope {
1981 friend class LLVMContextImpl;
1982 friend class MDNode;
1984 unsigned ExportSymbols : 1;
1986 DINamespace(LLVMContext &Context, StorageType Storage, bool ExportSymbols,
1987 ArrayRef<Metadata *> Ops)
1988 : DIScope(Context, DINamespaceKind, Storage, dwarf::DW_TAG_namespace,
1990 ExportSymbols(ExportSymbols) {}
1991 ~DINamespace() = default;
1993 static DINamespace *getImpl(LLVMContext &Context, DIScope *Scope,
1994 StringRef Name, bool ExportSymbols,
1995 StorageType Storage, bool ShouldCreate = true) {
1996 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
1997 ExportSymbols, Storage, ShouldCreate);
1999 static DINamespace *getImpl(LLVMContext &Context, Metadata *Scope,
2000 MDString *Name, bool ExportSymbols,
2001 StorageType Storage, bool ShouldCreate = true);
2003 TempDINamespace cloneImpl() const {
2004 return getTemporary(getContext(), getScope(), getName(),
2005 getExportSymbols());
2009 DEFINE_MDNODE_GET(DINamespace,
2010 (DIScope *Scope, StringRef Name, bool ExportSymbols),
2011 (Scope, Name, ExportSymbols))
2012 DEFINE_MDNODE_GET(DINamespace,
2013 (Metadata *Scope, MDString *Name, bool ExportSymbols),
2014 (Scope, Name, ExportSymbols))
2016 TempDINamespace clone() const { return cloneImpl(); }
2018 bool getExportSymbols() const { return ExportSymbols; }
2019 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
2020 StringRef getName() const { return getStringOperand(2); }
2022 Metadata *getRawScope() const { return getOperand(1); }
2023 MDString *getRawName() const { return getOperandAs<MDString>(2); }
2025 static bool classof(const Metadata *MD) {
2026 return MD->getMetadataID() == DINamespaceKind;
2030 /// A (clang) module that has been imported by the compile unit.
2032 class DIModule : public DIScope {
2033 friend class LLVMContextImpl;
2034 friend class MDNode;
2036 DIModule(LLVMContext &Context, StorageType Storage, ArrayRef<Metadata *> Ops)
2037 : DIScope(Context, DIModuleKind, Storage, dwarf::DW_TAG_module, Ops) {}
2038 ~DIModule() = default;
2040 static DIModule *getImpl(LLVMContext &Context, DIScope *Scope,
2041 StringRef Name, StringRef ConfigurationMacros,
2042 StringRef IncludePath, StringRef ISysRoot,
2043 StorageType Storage, bool ShouldCreate = true) {
2044 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
2045 getCanonicalMDString(Context, ConfigurationMacros),
2046 getCanonicalMDString(Context, IncludePath),
2047 getCanonicalMDString(Context, ISysRoot),
2048 Storage, ShouldCreate);
2050 static DIModule *getImpl(LLVMContext &Context, Metadata *Scope,
2051 MDString *Name, MDString *ConfigurationMacros,
2052 MDString *IncludePath, MDString *ISysRoot,
2053 StorageType Storage, bool ShouldCreate = true);
2055 TempDIModule cloneImpl() const {
2056 return getTemporary(getContext(), getScope(), getName(),
2057 getConfigurationMacros(), getIncludePath(),
2062 DEFINE_MDNODE_GET(DIModule, (DIScope *Scope, StringRef Name,
2063 StringRef ConfigurationMacros, StringRef IncludePath,
2064 StringRef ISysRoot),
2065 (Scope, Name, ConfigurationMacros, IncludePath, ISysRoot))
2066 DEFINE_MDNODE_GET(DIModule,
2067 (Metadata *Scope, MDString *Name, MDString *ConfigurationMacros,
2068 MDString *IncludePath, MDString *ISysRoot),
2069 (Scope, Name, ConfigurationMacros, IncludePath, ISysRoot))
2071 TempDIModule clone() const { return cloneImpl(); }
2073 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
2074 StringRef getName() const { return getStringOperand(1); }
2075 StringRef getConfigurationMacros() const { return getStringOperand(2); }
2076 StringRef getIncludePath() const { return getStringOperand(3); }
2077 StringRef getISysRoot() const { return getStringOperand(4); }
2079 Metadata *getRawScope() const { return getOperand(0); }
2080 MDString *getRawName() const { return getOperandAs<MDString>(1); }
2081 MDString *getRawConfigurationMacros() const { return getOperandAs<MDString>(2); }
2082 MDString *getRawIncludePath() const { return getOperandAs<MDString>(3); }
2083 MDString *getRawISysRoot() const { return getOperandAs<MDString>(4); }
2085 static bool classof(const Metadata *MD) {
2086 return MD->getMetadataID() == DIModuleKind;
2090 /// Base class for template parameters.
2091 class DITemplateParameter : public DINode {
2093 DITemplateParameter(LLVMContext &Context, unsigned ID, StorageType Storage,
2094 unsigned Tag, ArrayRef<Metadata *> Ops)
2095 : DINode(Context, ID, Storage, Tag, Ops) {}
2096 ~DITemplateParameter() = default;
2099 StringRef getName() const { return getStringOperand(0); }
2100 DITypeRef getType() const { return DITypeRef(getRawType()); }
2102 MDString *getRawName() const { return getOperandAs<MDString>(0); }
2103 Metadata *getRawType() const { return getOperand(1); }
2105 static bool classof(const Metadata *MD) {
2106 return MD->getMetadataID() == DITemplateTypeParameterKind ||
2107 MD->getMetadataID() == DITemplateValueParameterKind;
2111 class DITemplateTypeParameter : public DITemplateParameter {
2112 friend class LLVMContextImpl;
2113 friend class MDNode;
2115 DITemplateTypeParameter(LLVMContext &Context, StorageType Storage,
2116 ArrayRef<Metadata *> Ops)
2117 : DITemplateParameter(Context, DITemplateTypeParameterKind, Storage,
2118 dwarf::DW_TAG_template_type_parameter, Ops) {}
2119 ~DITemplateTypeParameter() = default;
2121 static DITemplateTypeParameter *getImpl(LLVMContext &Context, StringRef Name,
2122 DITypeRef Type, StorageType Storage,
2123 bool ShouldCreate = true) {
2124 return getImpl(Context, getCanonicalMDString(Context, Name), Type, Storage,
2127 static DITemplateTypeParameter *getImpl(LLVMContext &Context, MDString *Name,
2128 Metadata *Type, StorageType Storage,
2129 bool ShouldCreate = true);
2131 TempDITemplateTypeParameter cloneImpl() const {
2132 return getTemporary(getContext(), getName(), getType());
2136 DEFINE_MDNODE_GET(DITemplateTypeParameter, (StringRef Name, DITypeRef Type),
2138 DEFINE_MDNODE_GET(DITemplateTypeParameter, (MDString * Name, Metadata *Type),
2141 TempDITemplateTypeParameter clone() const { return cloneImpl(); }
2143 static bool classof(const Metadata *MD) {
2144 return MD->getMetadataID() == DITemplateTypeParameterKind;
2148 class DITemplateValueParameter : public DITemplateParameter {
2149 friend class LLVMContextImpl;
2150 friend class MDNode;
2152 DITemplateValueParameter(LLVMContext &Context, StorageType Storage,
2153 unsigned Tag, ArrayRef<Metadata *> Ops)
2154 : DITemplateParameter(Context, DITemplateValueParameterKind, Storage, Tag,
2156 ~DITemplateValueParameter() = default;
2158 static DITemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
2159 StringRef Name, DITypeRef Type,
2160 Metadata *Value, StorageType Storage,
2161 bool ShouldCreate = true) {
2162 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), Type,
2163 Value, Storage, ShouldCreate);
2165 static DITemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
2166 MDString *Name, Metadata *Type,
2167 Metadata *Value, StorageType Storage,
2168 bool ShouldCreate = true);
2170 TempDITemplateValueParameter cloneImpl() const {
2171 return getTemporary(getContext(), getTag(), getName(), getType(),
2176 DEFINE_MDNODE_GET(DITemplateValueParameter, (unsigned Tag, StringRef Name,
2177 DITypeRef Type, Metadata *Value),
2178 (Tag, Name, Type, Value))
2179 DEFINE_MDNODE_GET(DITemplateValueParameter, (unsigned Tag, MDString *Name,
2180 Metadata *Type, Metadata *Value),
2181 (Tag, Name, Type, Value))
2183 TempDITemplateValueParameter clone() const { return cloneImpl(); }
2185 Metadata *getValue() const { return getOperand(2); }
2187 static bool classof(const Metadata *MD) {
2188 return MD->getMetadataID() == DITemplateValueParameterKind;
2192 /// Base class for variables.
2193 class DIVariable : public DINode {
2195 uint32_t AlignInBits;
2198 DIVariable(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Line,
2199 ArrayRef<Metadata *> Ops, uint32_t AlignInBits = 0)
2200 : DINode(C, ID, Storage, dwarf::DW_TAG_variable, Ops), Line(Line),
2201 AlignInBits(AlignInBits) {}
2202 ~DIVariable() = default;
2205 unsigned getLine() const { return Line; }
2206 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
2207 StringRef getName() const { return getStringOperand(1); }
2208 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
2209 DITypeRef getType() const { return DITypeRef(getRawType()); }
2210 uint32_t getAlignInBits() const { return AlignInBits; }
2211 uint32_t getAlignInBytes() const { return getAlignInBits() / CHAR_BIT; }
2212 /// Determines the size of the variable's type.
2213 Optional<uint64_t> getSizeInBits() const;
2215 /// Return the signedness of this variable's type, or None if this type is
2216 /// neither signed nor unsigned.
2217 Optional<DIBasicType::Signedness> getSignedness() const {
2218 if (auto *BT = dyn_cast<DIBasicType>(getType().resolve()))
2219 return BT->getSignedness();
2223 StringRef getFilename() const {
2224 if (auto *F = getFile())
2225 return F->getFilename();
2229 StringRef getDirectory() const {
2230 if (auto *F = getFile())
2231 return F->getDirectory();
2235 Optional<StringRef> getSource() const {
2236 if (auto *F = getFile())
2237 return F->getSource();
2241 Metadata *getRawScope() const { return getOperand(0); }
2242 MDString *getRawName() const { return getOperandAs<MDString>(1); }
2243 Metadata *getRawFile() const { return getOperand(2); }
2244 Metadata *getRawType() const { return getOperand(3); }
2246 static bool classof(const Metadata *MD) {
2247 return MD->getMetadataID() == DILocalVariableKind ||
2248 MD->getMetadataID() == DIGlobalVariableKind;
2252 /// DWARF expression.
2254 /// This is (almost) a DWARF expression that modifies the location of a
2255 /// variable, or the location of a single piece of a variable, or (when using
2256 /// DW_OP_stack_value) is the constant variable value.
2258 /// TODO: Co-allocate the expression elements.
2259 /// TODO: Separate from MDNode, or otherwise drop Distinct and Temporary
2261 class DIExpression : public MDNode {
2262 friend class LLVMContextImpl;
2263 friend class MDNode;
2265 std::vector<uint64_t> Elements;
2267 DIExpression(LLVMContext &C, StorageType Storage, ArrayRef<uint64_t> Elements)
2268 : MDNode(C, DIExpressionKind, Storage, None),
2269 Elements(Elements.begin(), Elements.end()) {}
2270 ~DIExpression() = default;
2272 static DIExpression *getImpl(LLVMContext &Context,
2273 ArrayRef<uint64_t> Elements, StorageType Storage,
2274 bool ShouldCreate = true);
2276 TempDIExpression cloneImpl() const {
2277 return getTemporary(getContext(), getElements());
2281 DEFINE_MDNODE_GET(DIExpression, (ArrayRef<uint64_t> Elements), (Elements))
2283 TempDIExpression clone() const { return cloneImpl(); }
2285 ArrayRef<uint64_t> getElements() const { return Elements; }
2287 unsigned getNumElements() const { return Elements.size(); }
2289 uint64_t getElement(unsigned I) const {
2290 assert(I < Elements.size() && "Index out of range");
2294 /// Determine whether this represents a standalone constant value.
2295 bool isConstant() const;
2297 using element_iterator = ArrayRef<uint64_t>::iterator;
2299 element_iterator elements_begin() const { return getElements().begin(); }
2300 element_iterator elements_end() const { return getElements().end(); }
2302 /// A lightweight wrapper around an expression operand.
2304 /// TODO: Store arguments directly and change \a DIExpression to store a
2307 const uint64_t *Op = nullptr;
2310 ExprOperand() = default;
2311 explicit ExprOperand(const uint64_t *Op) : Op(Op) {}
2313 const uint64_t *get() const { return Op; }
2315 /// Get the operand code.
2316 uint64_t getOp() const { return *Op; }
2318 /// Get an argument to the operand.
2320 /// Never returns the operand itself.
2321 uint64_t getArg(unsigned I) const { return Op[I + 1]; }
2323 unsigned getNumArgs() const { return getSize() - 1; }
2325 /// Return the size of the operand.
2327 /// Return the number of elements in the operand (1 + args).
2328 unsigned getSize() const;
2330 /// Append the elements of this operand to \p V.
2331 void appendToVector(SmallVectorImpl<uint64_t> &V) const {
2332 V.append(get(), get() + getSize());
2336 /// An iterator for expression operands.
2337 class expr_op_iterator
2338 : public std::iterator<std::input_iterator_tag, ExprOperand> {
2342 expr_op_iterator() = default;
2343 explicit expr_op_iterator(element_iterator I) : Op(I) {}
2345 element_iterator getBase() const { return Op.get(); }
2346 const ExprOperand &operator*() const { return Op; }
2347 const ExprOperand *operator->() const { return &Op; }
2349 expr_op_iterator &operator++() {
2353 expr_op_iterator operator++(int) {
2354 expr_op_iterator T(*this);
2359 /// Get the next iterator.
2361 /// \a std::next() doesn't work because this is technically an
2362 /// input_iterator, but it's a perfectly valid operation. This is an
2363 /// accessor to provide the same functionality.
2364 expr_op_iterator getNext() const { return ++expr_op_iterator(*this); }
2366 bool operator==(const expr_op_iterator &X) const {
2367 return getBase() == X.getBase();
2369 bool operator!=(const expr_op_iterator &X) const {
2370 return getBase() != X.getBase();
2374 void increment() { Op = ExprOperand(getBase() + Op.getSize()); }
2377 /// Visit the elements via ExprOperand wrappers.
2379 /// These range iterators visit elements through \a ExprOperand wrappers.
2380 /// This is not guaranteed to be a valid range unless \a isValid() gives \c
2383 /// \pre \a isValid() gives \c true.
2385 expr_op_iterator expr_op_begin() const {
2386 return expr_op_iterator(elements_begin());
2388 expr_op_iterator expr_op_end() const {
2389 return expr_op_iterator(elements_end());
2391 iterator_range<expr_op_iterator> expr_ops() const {
2392 return {expr_op_begin(), expr_op_end()};
2396 bool isValid() const;
2398 static bool classof(const Metadata *MD) {
2399 return MD->getMetadataID() == DIExpressionKind;
2402 /// Return whether the first element a DW_OP_deref.
2403 bool startsWithDeref() const {
2404 return getNumElements() > 0 && getElement(0) == dwarf::DW_OP_deref;
2407 /// Holds the characteristics of one fragment of a larger variable.
2408 struct FragmentInfo {
2409 uint64_t SizeInBits;
2410 uint64_t OffsetInBits;
2413 /// Retrieve the details of this fragment expression.
2414 static Optional<FragmentInfo> getFragmentInfo(expr_op_iterator Start,
2415 expr_op_iterator End);
2417 /// Retrieve the details of this fragment expression.
2418 Optional<FragmentInfo> getFragmentInfo() const {
2419 return getFragmentInfo(expr_op_begin(), expr_op_end());
2422 /// Return whether this is a piece of an aggregate variable.
2423 bool isFragment() const { return getFragmentInfo().hasValue(); }
2425 /// Append \p Ops with operations to apply the \p Offset.
2426 static void appendOffset(SmallVectorImpl<uint64_t> &Ops, int64_t Offset);
2428 /// If this is a constant offset, extract it. If there is no expression,
2429 /// return true with an offset of zero.
2430 bool extractIfOffset(int64_t &Offset) const;
2432 /// Constants for DIExpression::prepend.
2433 enum { NoDeref = false, WithDeref = true, WithStackValue = true };
2435 /// Prepend \p DIExpr with a deref and offset operation and optionally turn it
2436 /// into a stack value.
2437 static DIExpression *prepend(const DIExpression *Expr, bool DerefBefore,
2438 int64_t Offset = 0, bool DerefAfter = false,
2439 bool StackValue = false);
2441 /// Prepend \p DIExpr with the given opcodes and optionally turn it into a
2443 static DIExpression *prependOpcodes(const DIExpression *Expr,
2444 SmallVectorImpl<uint64_t> &Ops,
2445 bool StackValue = false);
2447 /// Append the opcodes \p Ops to \p DIExpr. Unlike \ref appendToStack, the
2448 /// returned expression is a stack value only if \p DIExpr is a stack value.
2449 /// If \p DIExpr describes a fragment, the returned expression will describe
2450 /// the same fragment.
2451 static DIExpression *append(const DIExpression *Expr, ArrayRef<uint64_t> Ops);
2453 /// Convert \p DIExpr into a stack value if it isn't one already by appending
2454 /// DW_OP_deref if needed, and appending \p Ops to the resulting expression.
2455 /// If \p DIExpr describes a fragment, the returned expression will describe
2456 /// the same fragment.
2457 static DIExpression *appendToStack(const DIExpression *Expr,
2458 ArrayRef<uint64_t> Ops);
2460 /// Create a DIExpression to describe one part of an aggregate variable that
2461 /// is fragmented across multiple Values. The DW_OP_LLVM_fragment operation
2462 /// will be appended to the elements of \c Expr. If \c Expr already contains
2463 /// a \c DW_OP_LLVM_fragment \c OffsetInBits is interpreted as an offset
2464 /// into the existing fragment.
2466 /// \param OffsetInBits Offset of the piece in bits.
2467 /// \param SizeInBits Size of the piece in bits.
2468 /// \return Creating a fragment expression may fail if \c Expr
2469 /// contains arithmetic operations that would be truncated.
2470 static Optional<DIExpression *>
2471 createFragmentExpression(const DIExpression *Expr, unsigned OffsetInBits,
2472 unsigned SizeInBits);
2474 /// Determine the relative position of the fragments described by this
2475 /// DIExpression and \p Other.
2476 /// Returns -1 if this is entirely before Other, 0 if this and Other overlap,
2477 /// 1 if this is entirely after Other.
2478 int fragmentCmp(const DIExpression *Other) const {
2479 auto Fragment1 = *getFragmentInfo();
2480 auto Fragment2 = *Other->getFragmentInfo();
2481 unsigned l1 = Fragment1.OffsetInBits;
2482 unsigned l2 = Fragment2.OffsetInBits;
2483 unsigned r1 = l1 + Fragment1.SizeInBits;
2484 unsigned r2 = l2 + Fragment2.SizeInBits;
2493 /// Check if fragments overlap between this DIExpression and \p Other.
2494 bool fragmentsOverlap(const DIExpression *Other) const {
2495 if (!isFragment() || !Other->isFragment())
2497 return fragmentCmp(Other) == 0;
2501 /// Global variables.
2503 /// TODO: Remove DisplayName. It's always equal to Name.
2504 class DIGlobalVariable : public DIVariable {
2505 friend class LLVMContextImpl;
2506 friend class MDNode;
2511 DIGlobalVariable(LLVMContext &C, StorageType Storage, unsigned Line,
2512 bool IsLocalToUnit, bool IsDefinition, uint32_t AlignInBits,
2513 ArrayRef<Metadata *> Ops)
2514 : DIVariable(C, DIGlobalVariableKind, Storage, Line, Ops, AlignInBits),
2515 IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition) {}
2516 ~DIGlobalVariable() = default;
2518 static DIGlobalVariable *getImpl(LLVMContext &Context, DIScope *Scope,
2519 StringRef Name, StringRef LinkageName,
2520 DIFile *File, unsigned Line, DITypeRef Type,
2521 bool IsLocalToUnit, bool IsDefinition,
2522 DIDerivedType *StaticDataMemberDeclaration,
2523 uint32_t AlignInBits, StorageType Storage,
2524 bool ShouldCreate = true) {
2525 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
2526 getCanonicalMDString(Context, LinkageName), File, Line, Type,
2527 IsLocalToUnit, IsDefinition, StaticDataMemberDeclaration,
2528 AlignInBits, Storage, ShouldCreate);
2530 static DIGlobalVariable *
2531 getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
2532 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
2533 bool IsLocalToUnit, bool IsDefinition,
2534 Metadata *StaticDataMemberDeclaration, uint32_t AlignInBits,
2535 StorageType Storage, bool ShouldCreate = true);
2537 TempDIGlobalVariable cloneImpl() const {
2538 return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
2539 getFile(), getLine(), getType(), isLocalToUnit(),
2540 isDefinition(), getStaticDataMemberDeclaration(),
2545 DEFINE_MDNODE_GET(DIGlobalVariable,
2546 (DIScope * Scope, StringRef Name, StringRef LinkageName,
2547 DIFile *File, unsigned Line, DITypeRef Type,
2548 bool IsLocalToUnit, bool IsDefinition,
2549 DIDerivedType *StaticDataMemberDeclaration,
2550 uint32_t AlignInBits),
2551 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
2552 IsDefinition, StaticDataMemberDeclaration, AlignInBits))
2553 DEFINE_MDNODE_GET(DIGlobalVariable,
2554 (Metadata * Scope, MDString *Name, MDString *LinkageName,
2555 Metadata *File, unsigned Line, Metadata *Type,
2556 bool IsLocalToUnit, bool IsDefinition,
2557 Metadata *StaticDataMemberDeclaration,
2558 uint32_t AlignInBits),
2559 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
2560 IsDefinition, StaticDataMemberDeclaration, AlignInBits))
2562 TempDIGlobalVariable clone() const { return cloneImpl(); }
2564 bool isLocalToUnit() const { return IsLocalToUnit; }
2565 bool isDefinition() const { return IsDefinition; }
2566 StringRef getDisplayName() const { return getStringOperand(4); }
2567 StringRef getLinkageName() const { return getStringOperand(5); }
2568 DIDerivedType *getStaticDataMemberDeclaration() const {
2569 return cast_or_null<DIDerivedType>(getRawStaticDataMemberDeclaration());
2572 MDString *getRawLinkageName() const { return getOperandAs<MDString>(5); }
2573 Metadata *getRawStaticDataMemberDeclaration() const { return getOperand(6); }
2575 static bool classof(const Metadata *MD) {
2576 return MD->getMetadataID() == DIGlobalVariableKind;
2582 /// TODO: Split up flags.
2583 class DILocalVariable : public DIVariable {
2584 friend class LLVMContextImpl;
2585 friend class MDNode;
2590 DILocalVariable(LLVMContext &C, StorageType Storage, unsigned Line,
2591 unsigned Arg, DIFlags Flags, uint32_t AlignInBits,
2592 ArrayRef<Metadata *> Ops)
2593 : DIVariable(C, DILocalVariableKind, Storage, Line, Ops, AlignInBits),
2594 Arg(Arg), Flags(Flags) {
2595 assert(Arg < (1 << 16) && "DILocalVariable: Arg out of range");
2597 ~DILocalVariable() = default;
2599 static DILocalVariable *getImpl(LLVMContext &Context, DIScope *Scope,
2600 StringRef Name, DIFile *File, unsigned Line,
2601 DITypeRef Type, unsigned Arg, DIFlags Flags,
2602 uint32_t AlignInBits, StorageType Storage,
2603 bool ShouldCreate = true) {
2604 return getImpl(Context, Scope, getCanonicalMDString(Context, Name), File,
2605 Line, Type, Arg, Flags, AlignInBits, Storage, ShouldCreate);
2607 static DILocalVariable *getImpl(LLVMContext &Context, Metadata *Scope,
2608 MDString *Name, Metadata *File, unsigned Line,
2609 Metadata *Type, unsigned Arg, DIFlags Flags,
2610 uint32_t AlignInBits, StorageType Storage,
2611 bool ShouldCreate = true);
2613 TempDILocalVariable cloneImpl() const {
2614 return getTemporary(getContext(), getScope(), getName(), getFile(),
2615 getLine(), getType(), getArg(), getFlags(),
2620 DEFINE_MDNODE_GET(DILocalVariable,
2621 (DILocalScope * Scope, StringRef Name, DIFile *File,
2622 unsigned Line, DITypeRef Type, unsigned Arg,
2623 DIFlags Flags, uint32_t AlignInBits),
2624 (Scope, Name, File, Line, Type, Arg, Flags, AlignInBits))
2625 DEFINE_MDNODE_GET(DILocalVariable,
2626 (Metadata * Scope, MDString *Name, Metadata *File,
2627 unsigned Line, Metadata *Type, unsigned Arg,
2628 DIFlags Flags, uint32_t AlignInBits),
2629 (Scope, Name, File, Line, Type, Arg, Flags, AlignInBits))
2631 TempDILocalVariable clone() const { return cloneImpl(); }
2633 /// Get the local scope for this variable.
2635 /// Variables must be defined in a local scope.
2636 DILocalScope *getScope() const {
2637 return cast<DILocalScope>(DIVariable::getScope());
2640 bool isParameter() const { return Arg; }
2641 unsigned getArg() const { return Arg; }
2642 DIFlags getFlags() const { return Flags; }
2644 bool isArtificial() const { return getFlags() & FlagArtificial; }
2645 bool isObjectPointer() const { return getFlags() & FlagObjectPointer; }
2647 /// Check that a location is valid for this variable.
2649 /// Check that \c DL exists, is in the same subprogram, and has the same
2650 /// inlined-at location as \c this. (Otherwise, it's not a valid attachment
2651 /// to a \a DbgInfoIntrinsic.)
2652 bool isValidLocationForIntrinsic(const DILocation *DL) const {
2653 return DL && getScope()->getSubprogram() == DL->getScope()->getSubprogram();
2656 static bool classof(const Metadata *MD) {
2657 return MD->getMetadataID() == DILocalVariableKind;
2663 class DILabel : public DINode {
2664 friend class LLVMContextImpl;
2665 friend class MDNode;
2669 DILabel(LLVMContext &C, StorageType Storage, unsigned Line,
2670 ArrayRef<Metadata *> Ops)
2671 : DINode(C, DILabelKind, Storage, dwarf::DW_TAG_label, Ops), Line(Line) {}
2672 ~DILabel() = default;
2674 static DILabel *getImpl(LLVMContext &Context, DIScope *Scope,
2675 StringRef Name, DIFile *File, unsigned Line,
2676 StorageType Storage,
2677 bool ShouldCreate = true) {
2678 return getImpl(Context, Scope, getCanonicalMDString(Context, Name), File,
2679 Line, Storage, ShouldCreate);
2681 static DILabel *getImpl(LLVMContext &Context, Metadata *Scope,
2682 MDString *Name, Metadata *File, unsigned Line,
2683 StorageType Storage,
2684 bool ShouldCreate = true);
2686 TempDILabel cloneImpl() const {
2687 return getTemporary(getContext(), getScope(), getName(), getFile(),
2692 DEFINE_MDNODE_GET(DILabel,
2693 (DILocalScope * Scope, StringRef Name, DIFile *File,
2695 (Scope, Name, File, Line))
2696 DEFINE_MDNODE_GET(DILabel,
2697 (Metadata * Scope, MDString *Name, Metadata *File,
2699 (Scope, Name, File, Line))
2701 TempDILabel clone() const { return cloneImpl(); }
2703 /// Get the local scope for this label.
2705 /// Labels must be defined in a local scope.
2706 DILocalScope *getScope() const {
2707 return cast_or_null<DILocalScope>(getRawScope());
2709 unsigned getLine() const { return Line; }
2710 StringRef getName() const { return getStringOperand(1); }
2711 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
2713 Metadata *getRawScope() const { return getOperand(0); }
2714 MDString *getRawName() const { return getOperandAs<MDString>(1); }
2715 Metadata *getRawFile() const { return getOperand(2); }
2717 /// Check that a location is valid for this label.
2719 /// Check that \c DL exists, is in the same subprogram, and has the same
2720 /// inlined-at location as \c this. (Otherwise, it's not a valid attachment
2721 /// to a \a DbgInfoIntrinsic.)
2722 bool isValidLocationForIntrinsic(const DILocation *DL) const {
2723 return DL && getScope()->getSubprogram() == DL->getScope()->getSubprogram();
2726 static bool classof(const Metadata *MD) {
2727 return MD->getMetadataID() == DILabelKind;
2731 class DIObjCProperty : public DINode {
2732 friend class LLVMContextImpl;
2733 friend class MDNode;
2736 unsigned Attributes;
2738 DIObjCProperty(LLVMContext &C, StorageType Storage, unsigned Line,
2739 unsigned Attributes, ArrayRef<Metadata *> Ops)
2740 : DINode(C, DIObjCPropertyKind, Storage, dwarf::DW_TAG_APPLE_property,
2742 Line(Line), Attributes(Attributes) {}
2743 ~DIObjCProperty() = default;
2745 static DIObjCProperty *
2746 getImpl(LLVMContext &Context, StringRef Name, DIFile *File, unsigned Line,
2747 StringRef GetterName, StringRef SetterName, unsigned Attributes,
2748 DITypeRef Type, StorageType Storage, bool ShouldCreate = true) {
2749 return getImpl(Context, getCanonicalMDString(Context, Name), File, Line,
2750 getCanonicalMDString(Context, GetterName),
2751 getCanonicalMDString(Context, SetterName), Attributes, Type,
2752 Storage, ShouldCreate);
2754 static DIObjCProperty *getImpl(LLVMContext &Context, MDString *Name,
2755 Metadata *File, unsigned Line,
2756 MDString *GetterName, MDString *SetterName,
2757 unsigned Attributes, Metadata *Type,
2758 StorageType Storage, bool ShouldCreate = true);
2760 TempDIObjCProperty cloneImpl() const {
2761 return getTemporary(getContext(), getName(), getFile(), getLine(),
2762 getGetterName(), getSetterName(), getAttributes(),
2767 DEFINE_MDNODE_GET(DIObjCProperty,
2768 (StringRef Name, DIFile *File, unsigned Line,
2769 StringRef GetterName, StringRef SetterName,
2770 unsigned Attributes, DITypeRef Type),
2771 (Name, File, Line, GetterName, SetterName, Attributes,
2773 DEFINE_MDNODE_GET(DIObjCProperty,
2774 (MDString * Name, Metadata *File, unsigned Line,
2775 MDString *GetterName, MDString *SetterName,
2776 unsigned Attributes, Metadata *Type),
2777 (Name, File, Line, GetterName, SetterName, Attributes,
2780 TempDIObjCProperty clone() const { return cloneImpl(); }
2782 unsigned getLine() const { return Line; }
2783 unsigned getAttributes() const { return Attributes; }
2784 StringRef getName() const { return getStringOperand(0); }
2785 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
2786 StringRef getGetterName() const { return getStringOperand(2); }
2787 StringRef getSetterName() const { return getStringOperand(3); }
2788 DITypeRef getType() const { return DITypeRef(getRawType()); }
2790 StringRef getFilename() const {
2791 if (auto *F = getFile())
2792 return F->getFilename();
2796 StringRef getDirectory() const {
2797 if (auto *F = getFile())
2798 return F->getDirectory();
2802 Optional<StringRef> getSource() const {
2803 if (auto *F = getFile())
2804 return F->getSource();
2808 MDString *getRawName() const { return getOperandAs<MDString>(0); }
2809 Metadata *getRawFile() const { return getOperand(1); }
2810 MDString *getRawGetterName() const { return getOperandAs<MDString>(2); }
2811 MDString *getRawSetterName() const { return getOperandAs<MDString>(3); }
2812 Metadata *getRawType() const { return getOperand(4); }
2814 static bool classof(const Metadata *MD) {
2815 return MD->getMetadataID() == DIObjCPropertyKind;
2819 /// An imported module (C++ using directive or similar).
2820 class DIImportedEntity : public DINode {
2821 friend class LLVMContextImpl;
2822 friend class MDNode;
2826 DIImportedEntity(LLVMContext &C, StorageType Storage, unsigned Tag,
2827 unsigned Line, ArrayRef<Metadata *> Ops)
2828 : DINode(C, DIImportedEntityKind, Storage, Tag, Ops), Line(Line) {}
2829 ~DIImportedEntity() = default;
2831 static DIImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
2832 DIScope *Scope, DINodeRef Entity,
2833 DIFile *File, unsigned Line, StringRef Name,
2834 StorageType Storage,
2835 bool ShouldCreate = true) {
2836 return getImpl(Context, Tag, Scope, Entity, File, Line,
2837 getCanonicalMDString(Context, Name), Storage, ShouldCreate);
2839 static DIImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
2840 Metadata *Scope, Metadata *Entity,
2841 Metadata *File, unsigned Line,
2842 MDString *Name, StorageType Storage,
2843 bool ShouldCreate = true);
2845 TempDIImportedEntity cloneImpl() const {
2846 return getTemporary(getContext(), getTag(), getScope(), getEntity(),
2847 getFile(), getLine(), getName());
2851 DEFINE_MDNODE_GET(DIImportedEntity,
2852 (unsigned Tag, DIScope *Scope, DINodeRef Entity,
2853 DIFile *File, unsigned Line, StringRef Name = ""),
2854 (Tag, Scope, Entity, File, Line, Name))
2855 DEFINE_MDNODE_GET(DIImportedEntity,
2856 (unsigned Tag, Metadata *Scope, Metadata *Entity,
2857 Metadata *File, unsigned Line, MDString *Name),
2858 (Tag, Scope, Entity, File, Line, Name))
2860 TempDIImportedEntity clone() const { return cloneImpl(); }
2862 unsigned getLine() const { return Line; }
2863 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
2864 DINodeRef getEntity() const { return DINodeRef(getRawEntity()); }
2865 StringRef getName() const { return getStringOperand(2); }
2866 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
2868 Metadata *getRawScope() const { return getOperand(0); }
2869 Metadata *getRawEntity() const { return getOperand(1); }
2870 MDString *getRawName() const { return getOperandAs<MDString>(2); }
2871 Metadata *getRawFile() const { return getOperand(3); }
2873 static bool classof(const Metadata *MD) {
2874 return MD->getMetadataID() == DIImportedEntityKind;
2878 /// A pair of DIGlobalVariable and DIExpression.
2879 class DIGlobalVariableExpression : public MDNode {
2880 friend class LLVMContextImpl;
2881 friend class MDNode;
2883 DIGlobalVariableExpression(LLVMContext &C, StorageType Storage,
2884 ArrayRef<Metadata *> Ops)
2885 : MDNode(C, DIGlobalVariableExpressionKind, Storage, Ops) {}
2886 ~DIGlobalVariableExpression() = default;
2888 static DIGlobalVariableExpression *
2889 getImpl(LLVMContext &Context, Metadata *Variable, Metadata *Expression,
2890 StorageType Storage, bool ShouldCreate = true);
2892 TempDIGlobalVariableExpression cloneImpl() const {
2893 return getTemporary(getContext(), getVariable(), getExpression());
2897 DEFINE_MDNODE_GET(DIGlobalVariableExpression,
2898 (Metadata * Variable, Metadata *Expression),
2899 (Variable, Expression))
2901 TempDIGlobalVariableExpression clone() const { return cloneImpl(); }
2903 Metadata *getRawVariable() const { return getOperand(0); }
2905 DIGlobalVariable *getVariable() const {
2906 return cast_or_null<DIGlobalVariable>(getRawVariable());
2909 Metadata *getRawExpression() const { return getOperand(1); }
2911 DIExpression *getExpression() const {
2912 return cast<DIExpression>(getRawExpression());
2915 static bool classof(const Metadata *MD) {
2916 return MD->getMetadataID() == DIGlobalVariableExpressionKind;
2920 /// Macro Info DWARF-like metadata node.
2922 /// A metadata node with a DWARF macro info (i.e., a constant named
2923 /// \c DW_MACINFO_*, defined in llvm/BinaryFormat/Dwarf.h). Called \a
2925 /// because it's potentially used for non-DWARF output.
2926 class DIMacroNode : public MDNode {
2927 friend class LLVMContextImpl;
2928 friend class MDNode;
2931 DIMacroNode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned MIType,
2932 ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None)
2933 : MDNode(C, ID, Storage, Ops1, Ops2) {
2934 assert(MIType < 1u << 16);
2935 SubclassData16 = MIType;
2937 ~DIMacroNode() = default;
2939 template <class Ty> Ty *getOperandAs(unsigned I) const {
2940 return cast_or_null<Ty>(getOperand(I));
2943 StringRef getStringOperand(unsigned I) const {
2944 if (auto *S = getOperandAs<MDString>(I))
2945 return S->getString();
2949 static MDString *getCanonicalMDString(LLVMContext &Context, StringRef S) {
2952 return MDString::get(Context, S);
2956 unsigned getMacinfoType() const { return SubclassData16; }
2958 static bool classof(const Metadata *MD) {
2959 switch (MD->getMetadataID()) {
2963 case DIMacroFileKind:
2969 class DIMacro : public DIMacroNode {
2970 friend class LLVMContextImpl;
2971 friend class MDNode;
2975 DIMacro(LLVMContext &C, StorageType Storage, unsigned MIType, unsigned Line,
2976 ArrayRef<Metadata *> Ops)
2977 : DIMacroNode(C, DIMacroKind, Storage, MIType, Ops), Line(Line) {}
2978 ~DIMacro() = default;
2980 static DIMacro *getImpl(LLVMContext &Context, unsigned MIType, unsigned Line,
2981 StringRef Name, StringRef Value, StorageType Storage,
2982 bool ShouldCreate = true) {
2983 return getImpl(Context, MIType, Line, getCanonicalMDString(Context, Name),
2984 getCanonicalMDString(Context, Value), Storage, ShouldCreate);
2986 static DIMacro *getImpl(LLVMContext &Context, unsigned MIType, unsigned Line,
2987 MDString *Name, MDString *Value, StorageType Storage,
2988 bool ShouldCreate = true);
2990 TempDIMacro cloneImpl() const {
2991 return getTemporary(getContext(), getMacinfoType(), getLine(), getName(),
2996 DEFINE_MDNODE_GET(DIMacro, (unsigned MIType, unsigned Line, StringRef Name,
2997 StringRef Value = ""),
2998 (MIType, Line, Name, Value))
2999 DEFINE_MDNODE_GET(DIMacro, (unsigned MIType, unsigned Line, MDString *Name,
3001 (MIType, Line, Name, Value))
3003 TempDIMacro clone() const { return cloneImpl(); }
3005 unsigned getLine() const { return Line; }
3007 StringRef getName() const { return getStringOperand(0); }
3008 StringRef getValue() const { return getStringOperand(1); }
3010 MDString *getRawName() const { return getOperandAs<MDString>(0); }
3011 MDString *getRawValue() const { return getOperandAs<MDString>(1); }
3013 static bool classof(const Metadata *MD) {
3014 return MD->getMetadataID() == DIMacroKind;
3018 class DIMacroFile : public DIMacroNode {
3019 friend class LLVMContextImpl;
3020 friend class MDNode;
3024 DIMacroFile(LLVMContext &C, StorageType Storage, unsigned MIType,
3025 unsigned Line, ArrayRef<Metadata *> Ops)
3026 : DIMacroNode(C, DIMacroFileKind, Storage, MIType, Ops), Line(Line) {}
3027 ~DIMacroFile() = default;
3029 static DIMacroFile *getImpl(LLVMContext &Context, unsigned MIType,
3030 unsigned Line, DIFile *File,
3031 DIMacroNodeArray Elements, StorageType Storage,
3032 bool ShouldCreate = true) {
3033 return getImpl(Context, MIType, Line, static_cast<Metadata *>(File),
3034 Elements.get(), Storage, ShouldCreate);
3037 static DIMacroFile *getImpl(LLVMContext &Context, unsigned MIType,
3038 unsigned Line, Metadata *File, Metadata *Elements,
3039 StorageType Storage, bool ShouldCreate = true);
3041 TempDIMacroFile cloneImpl() const {
3042 return getTemporary(getContext(), getMacinfoType(), getLine(), getFile(),
3047 DEFINE_MDNODE_GET(DIMacroFile, (unsigned MIType, unsigned Line, DIFile *File,
3048 DIMacroNodeArray Elements),
3049 (MIType, Line, File, Elements))
3050 DEFINE_MDNODE_GET(DIMacroFile, (unsigned MIType, unsigned Line,
3051 Metadata *File, Metadata *Elements),
3052 (MIType, Line, File, Elements))
3054 TempDIMacroFile clone() const { return cloneImpl(); }
3056 void replaceElements(DIMacroNodeArray Elements) {
3058 for (DIMacroNode *Op : getElements())
3059 assert(is_contained(Elements->operands(), Op) &&
3060 "Lost a macro node during macro node list replacement");
3062 replaceOperandWith(1, Elements.get());
3065 unsigned getLine() const { return Line; }
3066 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
3068 DIMacroNodeArray getElements() const {
3069 return cast_or_null<MDTuple>(getRawElements());
3072 Metadata *getRawFile() const { return getOperand(0); }
3073 Metadata *getRawElements() const { return getOperand(1); }
3075 static bool classof(const Metadata *MD) {
3076 return MD->getMetadataID() == DIMacroFileKind;
3080 } // end namespace llvm
3082 #undef DEFINE_MDNODE_GET_UNPACK_IMPL
3083 #undef DEFINE_MDNODE_GET_UNPACK
3084 #undef DEFINE_MDNODE_GET
3086 #endif // LLVM_IR_DEBUGINFOMETADATA_H