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/IR/Metadata.h"
18 #include "llvm/Support/Dwarf.h"
20 // Helper macros for defining get() overrides.
21 #define DEFINE_MDNODE_GET_UNPACK_IMPL(...) __VA_ARGS__
22 #define DEFINE_MDNODE_GET_UNPACK(ARGS) DEFINE_MDNODE_GET_UNPACK_IMPL ARGS
23 #define DEFINE_MDNODE_GET(CLASS, FORMAL, ARGS) \
24 static CLASS *get(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK(FORMAL)) { \
25 return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Uniqued); \
27 static CLASS *getIfExists(LLVMContext &Context, \
28 DEFINE_MDNODE_GET_UNPACK(FORMAL)) { \
29 return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Uniqued, \
30 /* ShouldCreate */ false); \
32 static CLASS *getDistinct(LLVMContext &Context, \
33 DEFINE_MDNODE_GET_UNPACK(FORMAL)) { \
34 return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Distinct); \
36 static Temp##CLASS getTemporary(LLVMContext &Context, \
37 DEFINE_MDNODE_GET_UNPACK(FORMAL)) { \
39 getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Temporary)); \
44 /// \brief Debug location.
46 /// A debug location in source code, used for debug info and otherwise.
47 class MDLocation : public MDNode {
48 friend class LLVMContextImpl;
51 MDLocation(LLVMContext &C, StorageType Storage, unsigned Line,
52 unsigned Column, ArrayRef<Metadata *> MDs);
53 ~MDLocation() { dropAllReferences(); }
55 static MDLocation *getImpl(LLVMContext &Context, unsigned Line,
56 unsigned Column, Metadata *Scope,
57 Metadata *InlinedAt, StorageType Storage,
58 bool ShouldCreate = true);
60 TempMDLocation cloneImpl() const {
61 return getTemporary(getContext(), getLine(), getColumn(), getScope(),
65 // Disallow replacing operands.
66 void replaceOperandWith(unsigned I, Metadata *New) = delete;
69 DEFINE_MDNODE_GET(MDLocation,
70 (unsigned Line, unsigned Column, Metadata *Scope,
71 Metadata *InlinedAt = nullptr),
72 (Line, Column, Scope, InlinedAt))
74 /// \brief Return a (temporary) clone of this.
75 TempMDLocation clone() const { return cloneImpl(); }
77 unsigned getLine() const { return SubclassData32; }
78 unsigned getColumn() const { return SubclassData16; }
79 Metadata *getScope() const { return getOperand(0); }
80 Metadata *getInlinedAt() const {
81 if (getNumOperands() == 2)
86 static bool classof(const Metadata *MD) {
87 return MD->getMetadataID() == MDLocationKind;
91 /// \brief Tagged DWARF-like metadata node.
93 /// A metadata node with a DWARF tag (i.e., a constant named \c DW_TAG_*,
94 /// defined in llvm/Support/Dwarf.h). Called \a DebugNode because it's
95 /// potentially used for non-DWARF output.
96 class DebugNode : public MDNode {
97 friend class LLVMContextImpl;
101 DebugNode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
102 ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None)
103 : MDNode(C, ID, Storage, Ops1, Ops2) {
104 assert(Tag < 1u << 16);
105 SubclassData16 = Tag;
109 template <class Ty> Ty *getOperandAs(unsigned I) const {
110 return cast_or_null<Ty>(getOperand(I));
113 StringRef getStringOperand(unsigned I) const {
114 if (auto *S = getOperandAs<MDString>(I))
115 return S->getString();
119 static MDString *getCanonicalMDString(LLVMContext &Context, StringRef S) {
122 return MDString::get(Context, S);
126 unsigned getTag() const { return SubclassData16; }
128 static bool classof(const Metadata *MD) {
129 switch (MD->getMetadataID()) {
132 case GenericDebugNodeKind:
134 case MDEnumeratorKind:
135 case MDBasicTypeKind:
136 case MDDerivedTypeKind:
137 case MDCompositeTypeKind:
138 case MDSubroutineTypeKind:
140 case MDCompileUnitKind:
141 case MDSubprogramKind:
142 case MDLexicalBlockKind:
143 case MDLexicalBlockFileKind:
144 case MDNamespaceKind:
145 case MDTemplateTypeParameterKind:
146 case MDTemplateValueParameterKind:
147 case MDGlobalVariableKind:
148 case MDLocalVariableKind:
149 case MDExpressionKind:
150 case MDObjCPropertyKind:
151 case MDImportedEntityKind:
157 /// \brief Generic tagged DWARF-like metadata node.
159 /// An un-specialized DWARF-like metadata node. The first operand is a
160 /// (possibly empty) null-separated \a MDString header that contains arbitrary
161 /// fields. The remaining operands are \a dwarf_operands(), and are pointers
162 /// to other metadata.
163 class GenericDebugNode : public DebugNode {
164 friend class LLVMContextImpl;
167 GenericDebugNode(LLVMContext &C, StorageType Storage, unsigned Hash,
168 unsigned Tag, ArrayRef<Metadata *> Ops1,
169 ArrayRef<Metadata *> Ops2)
170 : DebugNode(C, GenericDebugNodeKind, Storage, Tag, Ops1, Ops2) {
173 ~GenericDebugNode() { dropAllReferences(); }
175 void setHash(unsigned Hash) { SubclassData32 = Hash; }
176 void recalculateHash();
178 static GenericDebugNode *getImpl(LLVMContext &Context, unsigned Tag,
180 ArrayRef<Metadata *> DwarfOps,
182 bool ShouldCreate = true) {
183 return getImpl(Context, Tag, getCanonicalMDString(Context, Header),
184 DwarfOps, Storage, ShouldCreate);
187 static GenericDebugNode *getImpl(LLVMContext &Context, unsigned Tag,
189 ArrayRef<Metadata *> DwarfOps,
191 bool ShouldCreate = true);
193 TempGenericDebugNode cloneImpl() const {
195 getContext(), getTag(), getHeader(),
196 SmallVector<Metadata *, 4>(dwarf_op_begin(), dwarf_op_end()));
200 unsigned getHash() const { return SubclassData32; }
202 DEFINE_MDNODE_GET(GenericDebugNode, (unsigned Tag, StringRef Header,
203 ArrayRef<Metadata *> DwarfOps),
204 (Tag, Header, DwarfOps))
205 DEFINE_MDNODE_GET(GenericDebugNode, (unsigned Tag, MDString *Header,
206 ArrayRef<Metadata *> DwarfOps),
207 (Tag, Header, DwarfOps))
209 /// \brief Return a (temporary) clone of this.
210 TempGenericDebugNode clone() const { return cloneImpl(); }
212 unsigned getTag() const { return SubclassData16; }
213 StringRef getHeader() const { return getStringOperand(0); }
215 op_iterator dwarf_op_begin() const { return op_begin() + 1; }
216 op_iterator dwarf_op_end() const { return op_end(); }
217 op_range dwarf_operands() const {
218 return op_range(dwarf_op_begin(), dwarf_op_end());
221 unsigned getNumDwarfOperands() const { return getNumOperands() - 1; }
222 const MDOperand &getDwarfOperand(unsigned I) const {
223 return getOperand(I + 1);
225 void replaceDwarfOperandWith(unsigned I, Metadata *New) {
226 replaceOperandWith(I + 1, New);
229 static bool classof(const Metadata *MD) {
230 return MD->getMetadataID() == GenericDebugNodeKind;
234 /// \brief Array subrange.
236 /// TODO: Merge into node for DW_TAG_array_type, which should have a custom
238 class MDSubrange : public DebugNode {
239 friend class LLVMContextImpl;
245 MDSubrange(LLVMContext &C, StorageType Storage, int64_t Count, int64_t Lo)
246 : DebugNode(C, MDSubrangeKind, Storage, dwarf::DW_TAG_subrange_type,
248 Count(Count), Lo(Lo) {}
251 static MDSubrange *getImpl(LLVMContext &Context, int64_t Count, int64_t Lo,
252 StorageType Storage, bool ShouldCreate = true);
254 TempMDSubrange cloneImpl() const {
255 return getTemporary(getContext(), getCount(), getLo());
259 DEFINE_MDNODE_GET(MDSubrange, (int64_t Count, int64_t Lo = 0), (Count, Lo))
261 TempMDSubrange clone() const { return cloneImpl(); }
263 int64_t getLo() const { return Lo; }
264 int64_t getCount() const { return Count; }
266 static bool classof(const Metadata *MD) {
267 return MD->getMetadataID() == MDSubrangeKind;
271 /// \brief Enumeration value.
273 /// TODO: Add a pointer to the context (DW_TAG_enumeration_type) once that no
274 /// longer creates a type cycle.
275 class MDEnumerator : public DebugNode {
276 friend class LLVMContextImpl;
281 MDEnumerator(LLVMContext &C, StorageType Storage, int64_t Value,
282 ArrayRef<Metadata *> Ops)
283 : DebugNode(C, MDEnumeratorKind, Storage, dwarf::DW_TAG_enumerator, Ops),
287 static MDEnumerator *getImpl(LLVMContext &Context, int64_t Value,
288 StringRef Name, StorageType Storage,
289 bool ShouldCreate = true) {
290 return getImpl(Context, Value, getCanonicalMDString(Context, Name), Storage,
293 static MDEnumerator *getImpl(LLVMContext &Context, int64_t Value,
294 MDString *Name, StorageType Storage,
295 bool ShouldCreate = true);
297 TempMDEnumerator cloneImpl() const {
298 return getTemporary(getContext(), getValue(), getName());
302 DEFINE_MDNODE_GET(MDEnumerator, (int64_t Value, StringRef Name),
304 DEFINE_MDNODE_GET(MDEnumerator, (int64_t Value, MDString *Name),
307 TempMDEnumerator clone() const { return cloneImpl(); }
309 int64_t getValue() const { return Value; }
310 StringRef getName() const { return getStringOperand(0); }
312 MDString *getRawName() const { return getOperandAs<MDString>(0); }
314 static bool classof(const Metadata *MD) {
315 return MD->getMetadataID() == MDEnumeratorKind;
319 /// \brief Base class for scope-like contexts.
321 /// Base class for lexical scopes and types (which are also declaration
324 /// TODO: Separate the concepts of declaration contexts and lexical scopes.
325 class MDScope : public DebugNode {
327 MDScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
328 ArrayRef<Metadata *> Ops)
329 : DebugNode(C, ID, Storage, Tag, Ops) {}
333 Metadata *getFile() const { return getOperand(0); }
335 static bool classof(const Metadata *MD) {
336 switch (MD->getMetadataID()) {
339 case MDBasicTypeKind:
340 case MDDerivedTypeKind:
341 case MDCompositeTypeKind:
342 case MDSubroutineTypeKind:
344 case MDCompileUnitKind:
345 case MDSubprogramKind:
346 case MDLexicalBlockKind:
347 case MDLexicalBlockFileKind:
348 case MDNamespaceKind:
354 /// \brief Base class for types.
356 /// TODO: Remove the hardcoded name and context, since many types don't use
358 /// TODO: Split up flags.
359 class MDType : public MDScope {
363 uint64_t AlignInBits;
364 uint64_t OffsetInBits;
367 MDType(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
368 unsigned Line, uint64_t SizeInBits, uint64_t AlignInBits,
369 uint64_t OffsetInBits, unsigned Flags, ArrayRef<Metadata *> Ops)
370 : MDScope(C, ID, Storage, Tag, Ops), Line(Line), Flags(Flags),
371 SizeInBits(SizeInBits), AlignInBits(AlignInBits),
372 OffsetInBits(OffsetInBits) {}
376 unsigned getLine() const { return Line; }
377 uint64_t getSizeInBits() const { return SizeInBits; }
378 uint64_t getAlignInBits() const { return AlignInBits; }
379 uint64_t getOffsetInBits() const { return OffsetInBits; }
380 unsigned getFlags() const { return Flags; }
382 Metadata *getScope() const { return getOperand(1); }
383 StringRef getName() const { return getStringOperand(2); }
385 MDString *getRawName() const { return getOperandAs<MDString>(2); }
387 static bool classof(const Metadata *MD) {
388 switch (MD->getMetadataID()) {
391 case MDBasicTypeKind:
392 case MDDerivedTypeKind:
393 case MDCompositeTypeKind:
394 case MDSubroutineTypeKind:
400 /// \brief Basic type.
402 /// TODO: Split out DW_TAG_unspecified_type.
403 /// TODO: Drop unused accessors.
404 class MDBasicType : public MDType {
405 friend class LLVMContextImpl;
410 MDBasicType(LLVMContext &C, StorageType Storage, unsigned Tag,
411 uint64_t SizeInBits, uint64_t AlignInBits, unsigned Encoding,
412 ArrayRef<Metadata *> Ops)
413 : MDType(C, MDBasicTypeKind, Storage, Tag, 0, SizeInBits, AlignInBits, 0,
415 Encoding(Encoding) {}
418 static MDBasicType *getImpl(LLVMContext &Context, unsigned Tag,
419 StringRef Name, uint64_t SizeInBits,
420 uint64_t AlignInBits, unsigned Encoding,
421 StorageType Storage, bool ShouldCreate = true) {
422 return getImpl(Context, Tag, getCanonicalMDString(Context, Name),
423 SizeInBits, AlignInBits, Encoding, Storage, ShouldCreate);
425 static MDBasicType *getImpl(LLVMContext &Context, unsigned Tag,
426 MDString *Name, uint64_t SizeInBits,
427 uint64_t AlignInBits, unsigned Encoding,
428 StorageType Storage, bool ShouldCreate = true);
430 TempMDBasicType cloneImpl() const {
431 return getTemporary(getContext(), getTag(), getName(), getSizeInBits(),
432 getAlignInBits(), getEncoding());
436 DEFINE_MDNODE_GET(MDBasicType,
437 (unsigned Tag, StringRef Name, uint64_t SizeInBits,
438 uint64_t AlignInBits, unsigned Encoding),
439 (Tag, Name, SizeInBits, AlignInBits, Encoding))
440 DEFINE_MDNODE_GET(MDBasicType,
441 (unsigned Tag, MDString *Name, uint64_t SizeInBits,
442 uint64_t AlignInBits, unsigned Encoding),
443 (Tag, Name, SizeInBits, AlignInBits, Encoding))
445 TempMDBasicType clone() const { return cloneImpl(); }
447 unsigned getEncoding() const { return Encoding; }
449 static bool classof(const Metadata *MD) {
450 return MD->getMetadataID() == MDBasicTypeKind;
454 /// \brief Base class for MDDerivedType and MDCompositeType.
456 /// TODO: Delete; they're not really related.
457 class MDDerivedTypeBase : public MDType {
459 MDDerivedTypeBase(LLVMContext &C, unsigned ID, StorageType Storage,
460 unsigned Tag, unsigned Line, uint64_t SizeInBits,
461 uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
462 ArrayRef<Metadata *> Ops)
463 : MDType(C, ID, Storage, Tag, Line, SizeInBits, AlignInBits, OffsetInBits,
465 ~MDDerivedTypeBase() {}
468 Metadata *getBaseType() const { return getOperand(3); }
470 static bool classof(const Metadata *MD) {
471 return MD->getMetadataID() == MDDerivedTypeKind ||
472 MD->getMetadataID() == MDCompositeTypeKind ||
473 MD->getMetadataID() == MDSubroutineTypeKind;
477 /// \brief Derived types.
479 /// This includes qualified types, pointers, references, friends, typedefs, and
482 /// TODO: Split out members (inheritance, fields, methods, etc.).
483 class MDDerivedType : public MDDerivedTypeBase {
484 friend class LLVMContextImpl;
487 MDDerivedType(LLVMContext &C, StorageType Storage, unsigned Tag,
488 unsigned Line, uint64_t SizeInBits, uint64_t AlignInBits,
489 uint64_t OffsetInBits, unsigned Flags, ArrayRef<Metadata *> Ops)
490 : MDDerivedTypeBase(C, MDDerivedTypeKind, Storage, Tag, Line, SizeInBits,
491 AlignInBits, OffsetInBits, Flags, Ops) {}
494 static MDDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
495 StringRef Name, Metadata *File, unsigned Line,
496 Metadata *Scope, Metadata *BaseType,
497 uint64_t SizeInBits, uint64_t AlignInBits,
498 uint64_t OffsetInBits, unsigned Flags,
499 Metadata *ExtraData, StorageType Storage,
500 bool ShouldCreate = true) {
501 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), File,
502 Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits,
503 Flags, ExtraData, Storage, ShouldCreate);
505 static MDDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
506 MDString *Name, Metadata *File, unsigned Line,
507 Metadata *Scope, Metadata *BaseType,
508 uint64_t SizeInBits, uint64_t AlignInBits,
509 uint64_t OffsetInBits, unsigned Flags,
510 Metadata *ExtraData, StorageType Storage,
511 bool ShouldCreate = true);
513 TempMDDerivedType cloneImpl() const {
514 return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
515 getScope(), getBaseType(), getSizeInBits(),
516 getAlignInBits(), getOffsetInBits(), getFlags(),
521 DEFINE_MDNODE_GET(MDDerivedType,
522 (unsigned Tag, MDString *Name, Metadata *File,
523 unsigned Line, Metadata *Scope, Metadata *BaseType,
524 uint64_t SizeInBits, uint64_t AlignInBits,
525 uint64_t OffsetInBits, unsigned Flags,
526 Metadata *ExtraData = nullptr),
527 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
528 AlignInBits, OffsetInBits, Flags, ExtraData))
529 DEFINE_MDNODE_GET(MDDerivedType,
530 (unsigned Tag, StringRef Name, Metadata *File,
531 unsigned Line, Metadata *Scope, Metadata *BaseType,
532 uint64_t SizeInBits, uint64_t AlignInBits,
533 uint64_t OffsetInBits, unsigned Flags,
534 Metadata *ExtraData = nullptr),
535 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
536 AlignInBits, OffsetInBits, Flags, ExtraData))
538 TempMDDerivedType clone() const { return cloneImpl(); }
540 /// \brief Get extra data associated with this derived type.
542 /// Class type for pointer-to-members, objective-c property node for ivars,
543 /// or global constant wrapper for static members.
545 /// TODO: Separate out types that need this extra operand: pointer-to-member
546 /// types and member fields (static members and ivars).
547 Metadata *getExtraData() const { return getOperand(4); }
549 static bool classof(const Metadata *MD) {
550 return MD->getMetadataID() == MDDerivedTypeKind;
554 /// \brief Base class for MDCompositeType and MDSubroutineType.
556 /// TODO: Delete; they're not really related.
557 class MDCompositeTypeBase : public MDDerivedTypeBase {
558 unsigned RuntimeLang;
561 MDCompositeTypeBase(LLVMContext &C, unsigned ID, StorageType Storage,
562 unsigned Tag, unsigned Line, unsigned RuntimeLang,
563 uint64_t SizeInBits, uint64_t AlignInBits,
564 uint64_t OffsetInBits, unsigned Flags,
565 ArrayRef<Metadata *> Ops)
566 : MDDerivedTypeBase(C, ID, Storage, Tag, Line, SizeInBits, AlignInBits,
567 OffsetInBits, Flags, Ops),
568 RuntimeLang(RuntimeLang) {}
569 ~MDCompositeTypeBase() {}
572 Metadata *getElements() const { return getOperand(4); }
573 Metadata *getVTableHolder() const { return getOperand(5); }
574 Metadata *getTemplateParams() const { return getOperand(6); }
575 StringRef getIdentifier() const { return getStringOperand(7); }
576 unsigned getRuntimeLang() const { return RuntimeLang; }
578 MDString *getRawIdentifier() const { return getOperandAs<MDString>(7); }
580 /// \brief Replace operands.
582 /// If this \a isUniqued() and not \a isResolved(), on a uniquing collision
583 /// this will be RAUW'ed and deleted. Use a \a TrackingMDRef to keep track
584 /// of its movement if necessary.
586 void replaceElements(MDTuple *Elements) {
588 if (auto *Old = cast_or_null<MDTuple>(getElements()))
589 for (const auto &Op : Old->operands())
590 assert(std::find(Elements->op_begin(), Elements->op_end(), Op) &&
591 "Lost a member during member list replacement");
593 replaceOperandWith(4, Elements);
595 void replaceVTableHolder(Metadata *VTableHolder) {
596 replaceOperandWith(5, VTableHolder);
598 void replaceTemplateParams(MDTuple *TemplateParams) {
599 replaceOperandWith(6, TemplateParams);
603 static bool classof(const Metadata *MD) {
604 return MD->getMetadataID() == MDCompositeTypeKind ||
605 MD->getMetadataID() == MDSubroutineTypeKind;
609 /// \brief Composite types.
611 /// TODO: Detach from DerivedTypeBase (split out MDEnumType?).
612 /// TODO: Create a custom, unrelated node for DW_TAG_array_type.
613 class MDCompositeType : public MDCompositeTypeBase {
614 friend class LLVMContextImpl;
617 MDCompositeType(LLVMContext &C, StorageType Storage, unsigned Tag,
618 unsigned Line, unsigned RuntimeLang, uint64_t SizeInBits,
619 uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
620 ArrayRef<Metadata *> Ops)
621 : MDCompositeTypeBase(C, MDCompositeTypeKind, Storage, Tag, Line,
622 RuntimeLang, SizeInBits, AlignInBits, OffsetInBits,
624 ~MDCompositeType() {}
626 static MDCompositeType *
627 getImpl(LLVMContext &Context, unsigned Tag, StringRef Name, Metadata *File,
628 unsigned Line, Metadata *Scope, Metadata *BaseType,
629 uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
630 uint64_t Flags, Metadata *Elements, unsigned RuntimeLang,
631 Metadata *VTableHolder, Metadata *TemplateParams,
632 StringRef Identifier, StorageType Storage, bool ShouldCreate = true) {
633 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), File,
634 Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits,
635 Flags, Elements, RuntimeLang, VTableHolder, TemplateParams,
636 getCanonicalMDString(Context, Identifier), Storage,
639 static MDCompositeType *
640 getImpl(LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
641 unsigned Line, Metadata *Scope, Metadata *BaseType,
642 uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
643 unsigned Flags, Metadata *Elements, unsigned RuntimeLang,
644 Metadata *VTableHolder, Metadata *TemplateParams,
645 MDString *Identifier, StorageType Storage, bool ShouldCreate = true);
647 TempMDCompositeType cloneImpl() const {
648 return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
649 getScope(), getBaseType(), getSizeInBits(),
650 getAlignInBits(), getOffsetInBits(), getFlags(),
651 getElements(), getRuntimeLang(), getVTableHolder(),
652 getTemplateParams(), getIdentifier());
656 DEFINE_MDNODE_GET(MDCompositeType,
657 (unsigned Tag, StringRef Name, Metadata *File,
658 unsigned Line, Metadata *Scope, Metadata *BaseType,
659 uint64_t SizeInBits, uint64_t AlignInBits,
660 uint64_t OffsetInBits, unsigned Flags, Metadata *Elements,
661 unsigned RuntimeLang, Metadata *VTableHolder,
662 Metadata *TemplateParams = nullptr,
663 StringRef Identifier = ""),
664 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
665 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
666 VTableHolder, TemplateParams, Identifier))
667 DEFINE_MDNODE_GET(MDCompositeType,
668 (unsigned Tag, MDString *Name, Metadata *File,
669 unsigned Line, Metadata *Scope, Metadata *BaseType,
670 uint64_t SizeInBits, uint64_t AlignInBits,
671 uint64_t OffsetInBits, unsigned Flags, Metadata *Elements,
672 unsigned RuntimeLang, Metadata *VTableHolder,
673 Metadata *TemplateParams = nullptr,
674 MDString *Identifier = nullptr),
675 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
676 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
677 VTableHolder, TemplateParams, Identifier))
679 TempMDCompositeType clone() const { return cloneImpl(); }
681 static bool classof(const Metadata *MD) {
682 return MD->getMetadataID() == MDCompositeTypeKind;
686 /// \brief Type array for a subprogram.
688 /// TODO: Detach from CompositeType, and fold the array of types in directly
690 class MDSubroutineType : public MDCompositeTypeBase {
691 friend class LLVMContextImpl;
694 MDSubroutineType(LLVMContext &C, StorageType Storage, unsigned Flags,
695 ArrayRef<Metadata *> Ops)
696 : MDCompositeTypeBase(C, MDSubroutineTypeKind, Storage,
697 dwarf::DW_TAG_subroutine_type, 0, 0, 0, 0, 0, Flags,
699 ~MDSubroutineType() {}
701 static MDSubroutineType *getImpl(LLVMContext &Context, unsigned Flags,
702 Metadata *TypeArray, StorageType Storage,
703 bool ShouldCreate = true);
705 TempMDSubroutineType cloneImpl() const {
706 return getTemporary(getContext(), getFlags(), getTypeArray());
710 DEFINE_MDNODE_GET(MDSubroutineType, (unsigned Flags, Metadata *TypeArray),
713 TempMDSubroutineType clone() const { return cloneImpl(); }
715 Metadata *getTypeArray() const { return getElements(); }
717 static bool classof(const Metadata *MD) {
718 return MD->getMetadataID() == MDSubroutineTypeKind;
724 /// TODO: Merge with directory/file node (including users).
725 /// TODO: Canonicalize paths on creation.
726 class MDFile : public MDScope {
727 friend class LLVMContextImpl;
730 MDFile(LLVMContext &C, StorageType Storage, ArrayRef<Metadata *> Ops)
731 : MDScope(C, MDFileKind, Storage, dwarf::DW_TAG_file_type, Ops) {}
734 static MDFile *getImpl(LLVMContext &Context, StringRef Filename,
735 StringRef Directory, StorageType Storage,
736 bool ShouldCreate = true) {
737 return getImpl(Context, getCanonicalMDString(Context, Filename),
738 getCanonicalMDString(Context, Directory), Storage,
741 static MDFile *getImpl(LLVMContext &Context, MDString *Filename,
742 MDString *Directory, StorageType Storage,
743 bool ShouldCreate = true);
745 TempMDFile cloneImpl() const {
746 return getTemporary(getContext(), getFilename(), getDirectory());
750 DEFINE_MDNODE_GET(MDFile, (StringRef Filename, StringRef Directory),
751 (Filename, Directory))
752 DEFINE_MDNODE_GET(MDFile, (MDString * Filename, MDString *Directory),
753 (Filename, Directory))
755 TempMDFile clone() const { return cloneImpl(); }
757 MDTuple *getFileNode() const { return cast<MDTuple>(getOperand(0)); }
759 StringRef getFilename() const {
760 if (auto *S = getRawFilename())
761 return S->getString();
764 StringRef getDirectory() const {
765 if (auto *S = getRawDirectory())
766 return S->getString();
770 MDString *getRawFilename() const {
771 return cast_or_null<MDString>(getFileNode()->getOperand(0));
773 MDString *getRawDirectory() const {
774 return cast_or_null<MDString>(getFileNode()->getOperand(1));
777 static bool classof(const Metadata *MD) {
778 return MD->getMetadataID() == MDFileKind;
782 /// \brief Compile unit.
783 class MDCompileUnit : public MDScope {
784 friend class LLVMContextImpl;
787 unsigned SourceLanguage;
789 unsigned RuntimeVersion;
790 unsigned EmissionKind;
792 MDCompileUnit(LLVMContext &C, StorageType Storage, unsigned SourceLanguage,
793 bool IsOptimized, unsigned RuntimeVersion,
794 unsigned EmissionKind, ArrayRef<Metadata *> Ops)
795 : MDScope(C, MDCompileUnitKind, Storage, dwarf::DW_TAG_compile_unit, Ops),
796 SourceLanguage(SourceLanguage), IsOptimized(IsOptimized),
797 RuntimeVersion(RuntimeVersion), EmissionKind(EmissionKind) {}
800 static MDCompileUnit *
801 getImpl(LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
802 StringRef Producer, bool IsOptimized, StringRef Flags,
803 unsigned RuntimeVersion, StringRef SplitDebugFilename,
804 unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
805 Metadata *Subprograms, Metadata *GlobalVariables,
806 Metadata *ImportedEntities, StorageType Storage,
807 bool ShouldCreate = true) {
808 return getImpl(Context, SourceLanguage, File,
809 getCanonicalMDString(Context, Producer), IsOptimized,
810 getCanonicalMDString(Context, Flags), RuntimeVersion,
811 getCanonicalMDString(Context, SplitDebugFilename),
812 EmissionKind, EnumTypes, RetainedTypes, Subprograms,
813 GlobalVariables, ImportedEntities, Storage, ShouldCreate);
815 static MDCompileUnit *
816 getImpl(LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
817 MDString *Producer, bool IsOptimized, MDString *Flags,
818 unsigned RuntimeVersion, MDString *SplitDebugFilename,
819 unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
820 Metadata *Subprograms, Metadata *GlobalVariables,
821 Metadata *ImportedEntities, StorageType Storage,
822 bool ShouldCreate = true);
824 TempMDCompileUnit cloneImpl() const {
826 getContext(), getSourceLanguage(), getFile(), getProducer(),
827 isOptimized(), getFlags(), getRuntimeVersion(), getSplitDebugFilename(),
828 getEmissionKind(), getEnumTypes(), getRetainedTypes(), getSubprograms(),
829 getGlobalVariables(), getImportedEntities());
833 DEFINE_MDNODE_GET(MDCompileUnit,
834 (unsigned SourceLanguage, Metadata *File,
835 StringRef Producer, bool IsOptimized, StringRef Flags,
836 unsigned RuntimeVersion, StringRef SplitDebugFilename,
837 unsigned EmissionKind, Metadata *EnumTypes,
838 Metadata *RetainedTypes, Metadata *Subprograms,
839 Metadata *GlobalVariables, Metadata *ImportedEntities),
840 (SourceLanguage, File, Producer, IsOptimized, Flags,
841 RuntimeVersion, SplitDebugFilename, EmissionKind,
842 EnumTypes, RetainedTypes, Subprograms, GlobalVariables,
844 DEFINE_MDNODE_GET(MDCompileUnit,
845 (unsigned SourceLanguage, Metadata *File,
846 MDString *Producer, bool IsOptimized, MDString *Flags,
847 unsigned RuntimeVersion, MDString *SplitDebugFilename,
848 unsigned EmissionKind, Metadata *EnumTypes,
849 Metadata *RetainedTypes, Metadata *Subprograms,
850 Metadata *GlobalVariables, Metadata *ImportedEntities),
851 (SourceLanguage, File, Producer, IsOptimized, Flags,
852 RuntimeVersion, SplitDebugFilename, EmissionKind,
853 EnumTypes, RetainedTypes, Subprograms, GlobalVariables,
856 TempMDCompileUnit clone() const { return cloneImpl(); }
858 unsigned getSourceLanguage() const { return SourceLanguage; }
859 bool isOptimized() const { return IsOptimized; }
860 unsigned getRuntimeVersion() const { return RuntimeVersion; }
861 unsigned getEmissionKind() const { return EmissionKind; }
862 StringRef getProducer() const { return getStringOperand(1); }
863 StringRef getFlags() const { return getStringOperand(2); }
864 StringRef getSplitDebugFilename() const { return getStringOperand(3); }
865 Metadata *getEnumTypes() const { return getOperand(4); }
866 Metadata *getRetainedTypes() const { return getOperand(5); }
867 Metadata *getSubprograms() const { return getOperand(6); }
868 Metadata *getGlobalVariables() const { return getOperand(7); }
869 Metadata *getImportedEntities() const { return getOperand(8); }
871 MDString *getRawProducer() const { return getOperandAs<MDString>(1); }
872 MDString *getRawFlags() const { return getOperandAs<MDString>(2); }
873 MDString *getRawSplitDebugFilename() const {
874 return getOperandAs<MDString>(3);
877 /// \brief Replace arrays.
879 /// If this \a isUniqued() and not \a isResolved(), it will be RAUW'ed and
880 /// deleted on a uniquing collision. In practice, uniquing collisions on \a
881 /// MDCompileUnit should be fairly rare.
883 void replaceSubprograms(MDTuple *N) { replaceOperandWith(6, N); }
884 void replaceGlobalVariables(MDTuple *N) { replaceOperandWith(7, N); }
887 static bool classof(const Metadata *MD) {
888 return MD->getMetadataID() == MDCompileUnitKind;
892 /// \brief Subprogram description.
894 /// TODO: Remove DisplayName. It's always equal to Name.
895 /// TODO: Split up flags.
896 class MDSubprogram : public MDScope {
897 friend class LLVMContextImpl;
903 unsigned VirtualIndex;
909 MDSubprogram(LLVMContext &C, StorageType Storage, unsigned Line,
910 unsigned ScopeLine, unsigned Virtuality, unsigned VirtualIndex,
911 unsigned Flags, bool IsLocalToUnit, bool IsDefinition,
912 bool IsOptimized, ArrayRef<Metadata *> Ops)
913 : MDScope(C, MDSubprogramKind, Storage, dwarf::DW_TAG_subprogram, Ops),
914 Line(Line), ScopeLine(ScopeLine), Virtuality(Virtuality),
915 VirtualIndex(VirtualIndex), Flags(Flags), IsLocalToUnit(IsLocalToUnit),
916 IsDefinition(IsDefinition), IsOptimized(IsOptimized) {}
919 static MDSubprogram *
920 getImpl(LLVMContext &Context, Metadata *Scope, StringRef Name,
921 StringRef LinkageName, Metadata *File, unsigned Line, Metadata *Type,
922 bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
923 Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex,
924 unsigned Flags, bool IsOptimized, Metadata *Function,
925 Metadata *TemplateParams, Metadata *Declaration, Metadata *Variables,
926 StorageType Storage, bool ShouldCreate = true) {
927 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
928 getCanonicalMDString(Context, LinkageName), File, Line, Type,
929 IsLocalToUnit, IsDefinition, ScopeLine, ContainingType,
930 Virtuality, VirtualIndex, Flags, IsOptimized, Function,
931 TemplateParams, Declaration, Variables, Storage,
934 static MDSubprogram *
935 getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
936 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
937 bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
938 Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex,
939 unsigned Flags, bool IsOptimized, Metadata *Function,
940 Metadata *TemplateParams, Metadata *Declaration, Metadata *Variables,
941 StorageType Storage, bool ShouldCreate = true);
943 TempMDSubprogram cloneImpl() const {
944 return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
945 getFile(), getLine(), getType(), isLocalToUnit(),
946 isDefinition(), getScopeLine(), getContainingType(),
947 getVirtuality(), getVirtualIndex(), getFlags(),
948 isOptimized(), getFunction(), getTemplateParams(),
949 getDeclaration(), getVariables());
955 (Metadata * Scope, StringRef Name, StringRef LinkageName, Metadata *File,
956 unsigned Line, Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
957 unsigned ScopeLine, Metadata *ContainingType, unsigned Virtuality,
958 unsigned VirtualIndex, unsigned Flags, bool IsOptimized,
959 Metadata *Function = nullptr, Metadata *TemplateParams = nullptr,
960 Metadata *Declaration = nullptr, Metadata *Variables = nullptr),
961 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition,
962 ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags, IsOptimized,
963 Function, TemplateParams, Declaration, Variables))
966 (Metadata * Scope, MDString *Name, MDString *LinkageName, Metadata *File,
967 unsigned Line, Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
968 unsigned ScopeLine, Metadata *ContainingType, unsigned Virtuality,
969 unsigned VirtualIndex, unsigned Flags, bool IsOptimized,
970 Metadata *Function = nullptr, Metadata *TemplateParams = nullptr,
971 Metadata *Declaration = nullptr, Metadata *Variables = nullptr),
972 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition,
973 ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags, IsOptimized,
974 Function, TemplateParams, Declaration, Variables))
976 TempMDSubprogram clone() const { return cloneImpl(); }
979 unsigned getLine() const { return Line; }
980 unsigned getVirtuality() const { return Virtuality; }
981 unsigned getVirtualIndex() const { return VirtualIndex; }
982 unsigned getScopeLine() const { return ScopeLine; }
983 unsigned getFlags() const { return Flags; }
984 bool isLocalToUnit() const { return IsLocalToUnit; }
985 bool isDefinition() const { return IsDefinition; }
986 bool isOptimized() const { return IsOptimized; }
988 Metadata *getScope() const { return getOperand(1); }
990 StringRef getName() const { return getStringOperand(2); }
991 StringRef getDisplayName() const { return getStringOperand(3); }
992 StringRef getLinkageName() const { return getStringOperand(4); }
994 MDString *getRawName() const { return getOperandAs<MDString>(2); }
995 MDString *getRawLinkageName() const { return getOperandAs<MDString>(4); }
997 Metadata *getType() const { return getOperand(5); }
998 Metadata *getContainingType() const { return getOperand(6); }
1000 Metadata *getFunction() const { return getOperand(7); }
1001 Metadata *getTemplateParams() const { return getOperand(8); }
1002 Metadata *getDeclaration() const { return getOperand(9); }
1003 Metadata *getVariables() const { return getOperand(10); }
1005 /// \brief Replace the function.
1007 /// If \a isUniqued() and not \a isResolved(), this could node will be
1008 /// RAUW'ed and deleted out from under the caller. Use a \a TrackingMDRef if
1009 /// that's a problem.
1011 void replaceFunction(Function *F);
1012 void replaceFunction(ConstantAsMetadata *MD) { replaceOperandWith(7, MD); }
1013 void replaceFunction(std::nullptr_t) { replaceOperandWith(7, nullptr); }
1016 static bool classof(const Metadata *MD) {
1017 return MD->getMetadataID() == MDSubprogramKind;
1021 class MDLexicalBlockBase : public MDScope {
1023 MDLexicalBlockBase(LLVMContext &C, unsigned ID, StorageType Storage,
1024 ArrayRef<Metadata *> Ops)
1025 : MDScope(C, ID, Storage, dwarf::DW_TAG_lexical_block, Ops) {}
1026 ~MDLexicalBlockBase() {}
1029 Metadata *getScope() const { return getOperand(1); }
1031 static bool classof(const Metadata *MD) {
1032 return MD->getMetadataID() == MDLexicalBlockKind ||
1033 MD->getMetadataID() == MDLexicalBlockFileKind;
1037 class MDLexicalBlock : public MDLexicalBlockBase {
1038 friend class LLVMContextImpl;
1039 friend class MDNode;
1044 MDLexicalBlock(LLVMContext &C, StorageType Storage, unsigned Line,
1045 unsigned Column, ArrayRef<Metadata *> Ops)
1046 : MDLexicalBlockBase(C, MDLexicalBlockKind, Storage, Ops), Line(Line),
1048 ~MDLexicalBlock() {}
1050 static MDLexicalBlock *getImpl(LLVMContext &Context, Metadata *Scope,
1051 Metadata *File, unsigned Line, unsigned Column,
1052 StorageType Storage, bool ShouldCreate = true);
1054 TempMDLexicalBlock cloneImpl() const {
1055 return getTemporary(getContext(), getScope(), getFile(), getLine(),
1060 DEFINE_MDNODE_GET(MDLexicalBlock, (Metadata * Scope, Metadata *File,
1061 unsigned Line, unsigned Column),
1062 (Scope, File, Line, Column))
1064 TempMDLexicalBlock clone() const { return cloneImpl(); }
1066 unsigned getLine() const { return Line; }
1067 unsigned getColumn() const { return Column; }
1069 static bool classof(const Metadata *MD) {
1070 return MD->getMetadataID() == MDLexicalBlockKind;
1074 class MDLexicalBlockFile : public MDLexicalBlockBase {
1075 friend class LLVMContextImpl;
1076 friend class MDNode;
1078 unsigned Discriminator;
1080 MDLexicalBlockFile(LLVMContext &C, StorageType Storage,
1081 unsigned Discriminator, ArrayRef<Metadata *> Ops)
1082 : MDLexicalBlockBase(C, MDLexicalBlockFileKind, Storage, Ops),
1083 Discriminator(Discriminator) {}
1084 ~MDLexicalBlockFile() {}
1086 static MDLexicalBlockFile *getImpl(LLVMContext &Context, Metadata *Scope,
1087 Metadata *File, unsigned Discriminator,
1088 StorageType Storage,
1089 bool ShouldCreate = true);
1091 TempMDLexicalBlockFile cloneImpl() const {
1092 return getTemporary(getContext(), getScope(), getFile(),
1093 getDiscriminator());
1097 DEFINE_MDNODE_GET(MDLexicalBlockFile,
1098 (Metadata * Scope, Metadata *File, unsigned Discriminator),
1099 (Scope, File, Discriminator))
1101 TempMDLexicalBlockFile clone() const { return cloneImpl(); }
1103 unsigned getDiscriminator() const { return Discriminator; }
1105 static bool classof(const Metadata *MD) {
1106 return MD->getMetadataID() == MDLexicalBlockFileKind;
1110 class MDNamespace : public MDScope {
1111 friend class LLVMContextImpl;
1112 friend class MDNode;
1116 MDNamespace(LLVMContext &Context, StorageType Storage, unsigned Line,
1117 ArrayRef<Metadata *> Ops)
1118 : MDScope(Context, MDNamespaceKind, Storage, dwarf::DW_TAG_namespace,
1123 static MDNamespace *getImpl(LLVMContext &Context, Metadata *Scope,
1124 Metadata *File, StringRef Name, unsigned Line,
1125 StorageType Storage, bool ShouldCreate = true) {
1126 return getImpl(Context, Scope, File, getCanonicalMDString(Context, Name),
1127 Line, Storage, ShouldCreate);
1129 static MDNamespace *getImpl(LLVMContext &Context, Metadata *Scope,
1130 Metadata *File, MDString *Name, unsigned Line,
1131 StorageType Storage, bool ShouldCreate = true);
1133 TempMDNamespace cloneImpl() const {
1134 return getTemporary(getContext(), getScope(), getFile(), getName(),
1139 DEFINE_MDNODE_GET(MDNamespace, (Metadata * Scope, Metadata *File,
1140 StringRef Name, unsigned Line),
1141 (Scope, File, Name, Line))
1142 DEFINE_MDNODE_GET(MDNamespace, (Metadata * Scope, Metadata *File,
1143 MDString *Name, unsigned Line),
1144 (Scope, File, Name, Line))
1146 TempMDNamespace clone() const { return cloneImpl(); }
1148 unsigned getLine() const { return Line; }
1149 Metadata *getScope() const { return getOperand(1); }
1150 StringRef getName() const { return getStringOperand(2); }
1152 MDString *getRawName() const { return getOperandAs<MDString>(2); }
1154 static bool classof(const Metadata *MD) {
1155 return MD->getMetadataID() == MDNamespaceKind;
1159 /// \brief Base class for template parameters.
1160 class MDTemplateParameter : public DebugNode {
1162 MDTemplateParameter(LLVMContext &Context, unsigned ID, StorageType Storage,
1163 unsigned Tag, ArrayRef<Metadata *> Ops)
1164 : DebugNode(Context, ID, Storage, Tag, Ops) {}
1165 ~MDTemplateParameter() {}
1168 StringRef getName() const { return getStringOperand(0); }
1169 Metadata *getType() const { return getOperand(1); }
1171 MDString *getRawName() const { return getOperandAs<MDString>(0); }
1173 static bool classof(const Metadata *MD) {
1174 return MD->getMetadataID() == MDTemplateTypeParameterKind ||
1175 MD->getMetadataID() == MDTemplateValueParameterKind;
1179 class MDTemplateTypeParameter : public MDTemplateParameter {
1180 friend class LLVMContextImpl;
1181 friend class MDNode;
1183 MDTemplateTypeParameter(LLVMContext &Context, StorageType Storage,
1184 ArrayRef<Metadata *> Ops)
1185 : MDTemplateParameter(Context, MDTemplateTypeParameterKind, Storage,
1186 dwarf::DW_TAG_template_type_parameter, Ops) {}
1187 ~MDTemplateTypeParameter() {}
1189 static MDTemplateTypeParameter *getImpl(LLVMContext &Context, StringRef Name,
1190 Metadata *Type, StorageType Storage,
1191 bool ShouldCreate = true) {
1192 return getImpl(Context, getCanonicalMDString(Context, Name), Type, Storage,
1195 static MDTemplateTypeParameter *getImpl(LLVMContext &Context, MDString *Name,
1196 Metadata *Type, StorageType Storage,
1197 bool ShouldCreate = true);
1199 TempMDTemplateTypeParameter cloneImpl() const {
1200 return getTemporary(getContext(), getName(), getType());
1204 DEFINE_MDNODE_GET(MDTemplateTypeParameter, (StringRef Name, Metadata *Type),
1206 DEFINE_MDNODE_GET(MDTemplateTypeParameter, (MDString * Name, Metadata *Type),
1209 TempMDTemplateTypeParameter clone() const { return cloneImpl(); }
1211 static bool classof(const Metadata *MD) {
1212 return MD->getMetadataID() == MDTemplateTypeParameterKind;
1216 class MDTemplateValueParameter : public MDTemplateParameter {
1217 friend class LLVMContextImpl;
1218 friend class MDNode;
1220 MDTemplateValueParameter(LLVMContext &Context, StorageType Storage,
1221 unsigned Tag, ArrayRef<Metadata *> Ops)
1222 : MDTemplateParameter(Context, MDTemplateValueParameterKind, Storage, Tag,
1224 ~MDTemplateValueParameter() {}
1226 static MDTemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
1227 StringRef Name, Metadata *Type,
1228 Metadata *Value, StorageType Storage,
1229 bool ShouldCreate = true) {
1230 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), Type,
1231 Value, Storage, ShouldCreate);
1233 static MDTemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
1234 MDString *Name, Metadata *Type,
1235 Metadata *Value, StorageType Storage,
1236 bool ShouldCreate = true);
1238 TempMDTemplateValueParameter cloneImpl() const {
1239 return getTemporary(getContext(), getTag(), getName(), getType(),
1244 DEFINE_MDNODE_GET(MDTemplateValueParameter, (unsigned Tag, StringRef Name,
1245 Metadata *Type, Metadata *Value),
1246 (Tag, Name, Type, Value))
1247 DEFINE_MDNODE_GET(MDTemplateValueParameter, (unsigned Tag, MDString *Name,
1248 Metadata *Type, Metadata *Value),
1249 (Tag, Name, Type, Value))
1251 TempMDTemplateValueParameter clone() const { return cloneImpl(); }
1253 Metadata *getValue() const { return getOperand(2); }
1255 static bool classof(const Metadata *MD) {
1256 return MD->getMetadataID() == MDTemplateValueParameterKind;
1260 /// \brief Base class for variables.
1262 /// TODO: Hardcode to DW_TAG_variable.
1263 class MDVariable : public DebugNode {
1267 MDVariable(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
1268 unsigned Line, ArrayRef<Metadata *> Ops)
1269 : DebugNode(C, ID, Storage, Tag, Ops), Line(Line) {}
1273 unsigned getLine() const { return Line; }
1274 Metadata *getScope() const { return getOperand(0); }
1275 StringRef getName() const { return getStringOperand(1); }
1276 Metadata *getFile() const { return getOperand(2); }
1277 Metadata *getType() const { return getOperand(3); }
1279 MDString *getRawName() const { return getOperandAs<MDString>(1); }
1281 static bool classof(const Metadata *MD) {
1282 return MD->getMetadataID() == MDLocalVariableKind ||
1283 MD->getMetadataID() == MDGlobalVariableKind;
1287 /// \brief Global variables.
1289 /// TODO: Remove DisplayName. It's always equal to Name.
1290 class MDGlobalVariable : public MDVariable {
1291 friend class LLVMContextImpl;
1292 friend class MDNode;
1297 MDGlobalVariable(LLVMContext &C, StorageType Storage, unsigned Line,
1298 bool IsLocalToUnit, bool IsDefinition,
1299 ArrayRef<Metadata *> Ops)
1300 : MDVariable(C, MDGlobalVariableKind, Storage, dwarf::DW_TAG_variable,
1302 IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition) {}
1303 ~MDGlobalVariable() {}
1305 static MDGlobalVariable *
1306 getImpl(LLVMContext &Context, Metadata *Scope, StringRef Name,
1307 StringRef LinkageName, Metadata *File, unsigned Line, Metadata *Type,
1308 bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
1309 Metadata *StaticDataMemberDeclaration, StorageType Storage,
1310 bool ShouldCreate = true) {
1311 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
1312 getCanonicalMDString(Context, LinkageName), File, Line, Type,
1313 IsLocalToUnit, IsDefinition, Variable,
1314 StaticDataMemberDeclaration, Storage, ShouldCreate);
1316 static MDGlobalVariable *
1317 getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
1318 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
1319 bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
1320 Metadata *StaticDataMemberDeclaration, StorageType Storage,
1321 bool ShouldCreate = true);
1323 TempMDGlobalVariable cloneImpl() const {
1324 return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
1325 getFile(), getLine(), getType(), isLocalToUnit(),
1326 isDefinition(), getVariable(),
1327 getStaticDataMemberDeclaration());
1331 DEFINE_MDNODE_GET(MDGlobalVariable,
1332 (Metadata * Scope, StringRef Name, StringRef LinkageName,
1333 Metadata *File, unsigned Line, Metadata *Type,
1334 bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
1335 Metadata *StaticDataMemberDeclaration),
1336 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
1337 IsDefinition, Variable, StaticDataMemberDeclaration))
1338 DEFINE_MDNODE_GET(MDGlobalVariable,
1339 (Metadata * Scope, MDString *Name, MDString *LinkageName,
1340 Metadata *File, unsigned Line, Metadata *Type,
1341 bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
1342 Metadata *StaticDataMemberDeclaration),
1343 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
1344 IsDefinition, Variable, StaticDataMemberDeclaration))
1346 TempMDGlobalVariable clone() const { return cloneImpl(); }
1348 bool isLocalToUnit() const { return IsLocalToUnit; }
1349 bool isDefinition() const { return IsDefinition; }
1350 StringRef getDisplayName() const { return getStringOperand(4); }
1351 StringRef getLinkageName() const { return getStringOperand(5); }
1352 Metadata *getVariable() const { return getOperand(6); }
1353 Metadata *getStaticDataMemberDeclaration() const { return getOperand(7); }
1355 MDString *getRawLinkageName() const { return getOperandAs<MDString>(5); }
1357 static bool classof(const Metadata *MD) {
1358 return MD->getMetadataID() == MDGlobalVariableKind;
1362 /// \brief Local variable.
1364 /// TODO: Split between arguments and otherwise.
1365 /// TODO: Use \c DW_TAG_variable instead of fake tags.
1366 /// TODO: Split up flags.
1367 class MDLocalVariable : public MDVariable {
1368 friend class LLVMContextImpl;
1369 friend class MDNode;
1374 MDLocalVariable(LLVMContext &C, StorageType Storage, unsigned Tag,
1375 unsigned Line, unsigned Arg, unsigned Flags,
1376 ArrayRef<Metadata *> Ops)
1377 : MDVariable(C, MDLocalVariableKind, Storage, Tag, Line, Ops), Arg(Arg),
1379 ~MDLocalVariable() {}
1381 static MDLocalVariable *getImpl(LLVMContext &Context, unsigned Tag,
1382 Metadata *Scope, StringRef Name,
1383 Metadata *File, unsigned Line, Metadata *Type,
1384 unsigned Arg, unsigned Flags,
1385 Metadata *InlinedAt, StorageType Storage,
1386 bool ShouldCreate = true) {
1387 return getImpl(Context, Tag, Scope, getCanonicalMDString(Context, Name),
1388 File, Line, Type, Arg, Flags, InlinedAt, Storage,
1391 static MDLocalVariable *getImpl(LLVMContext &Context, unsigned Tag,
1392 Metadata *Scope, MDString *Name,
1393 Metadata *File, unsigned Line, Metadata *Type,
1394 unsigned Arg, unsigned Flags,
1395 Metadata *InlinedAt, StorageType Storage,
1396 bool ShouldCreate = true);
1398 TempMDLocalVariable cloneImpl() const {
1399 return getTemporary(getContext(), getTag(), getScope(), getName(),
1400 getFile(), getLine(), getType(), getArg(), getFlags(),
1405 DEFINE_MDNODE_GET(MDLocalVariable,
1406 (unsigned Tag, Metadata *Scope, StringRef Name,
1407 Metadata *File, unsigned Line, Metadata *Type,
1408 unsigned Arg, unsigned Flags,
1409 Metadata *InlinedAt = nullptr),
1410 (Tag, Scope, Name, File, Line, Type, Arg, Flags, InlinedAt))
1411 DEFINE_MDNODE_GET(MDLocalVariable,
1412 (unsigned Tag, Metadata *Scope, MDString *Name,
1413 Metadata *File, unsigned Line, Metadata *Type,
1414 unsigned Arg, unsigned Flags,
1415 Metadata *InlinedAt = nullptr),
1416 (Tag, Scope, Name, File, Line, Type, Arg, Flags, InlinedAt))
1418 TempMDLocalVariable clone() const { return cloneImpl(); }
1420 unsigned getArg() const { return Arg; }
1421 unsigned getFlags() const { return Flags; }
1422 Metadata *getInlinedAt() const { return getOperand(4); }
1424 static bool classof(const Metadata *MD) {
1425 return MD->getMetadataID() == MDLocalVariableKind;
1429 /// \brief DWARF expression.
1431 /// TODO: Co-allocate the expression elements.
1432 /// TODO: Drop fake DW_TAG_expression and separate from DebugNode.
1433 /// TODO: Separate from MDNode, or otherwise drop Distinct and Temporary
1435 class MDExpression : public DebugNode {
1436 friend class LLVMContextImpl;
1437 friend class MDNode;
1439 std::vector<uint64_t> Elements;
1441 MDExpression(LLVMContext &C, StorageType Storage, ArrayRef<uint64_t> Elements)
1442 : DebugNode(C, MDExpressionKind, Storage, dwarf::DW_TAG_expression, None),
1443 Elements(Elements.begin(), Elements.end()) {}
1446 static MDExpression *getImpl(LLVMContext &Context,
1447 ArrayRef<uint64_t> Elements, StorageType Storage,
1448 bool ShouldCreate = true);
1450 TempMDExpression cloneImpl() const {
1451 return getTemporary(getContext(), getElements());
1455 DEFINE_MDNODE_GET(MDExpression, (ArrayRef<uint64_t> Elements), (Elements))
1457 TempMDExpression clone() const { return cloneImpl(); }
1459 ArrayRef<uint64_t> getElements() const { return Elements; }
1461 unsigned getNumElements() const { return Elements.size(); }
1462 uint64_t getElement(unsigned I) const {
1463 assert(I < Elements.size() && "Index out of range");
1467 typedef ArrayRef<uint64_t>::iterator element_iterator;
1468 element_iterator elements_begin() const { return getElements().begin(); }
1469 element_iterator elements_end() const { return getElements().end(); }
1471 /// \brief A lightweight wrapper around an expression operand.
1473 /// TODO: Store arguments directly and change \a MDExpression to store a
1479 explicit ExprOperand(const uint64_t *Op) : Op(Op) {}
1481 const uint64_t *get() const { return Op; }
1483 /// \brief Get the operand code.
1484 uint64_t getOp() const { return *Op; }
1486 /// \brief Get an argument to the operand.
1488 /// Never returns the operand itself.
1489 uint64_t getArg(unsigned I) const { return Op[I + 1]; }
1491 unsigned getNumArgs() const { return getSize() - 1; }
1493 /// \brief Return the size of the operand.
1495 /// Return the number of elements in the operand (1 + args).
1496 unsigned getSize() const;
1499 /// \brief An iterator for expression operands.
1500 class expr_op_iterator
1501 : public std::iterator<std::input_iterator_tag, ExprOperand> {
1505 explicit expr_op_iterator(element_iterator I) : Op(I) {}
1507 element_iterator getBase() const { return Op.get(); }
1508 const ExprOperand &operator*() const { return Op; }
1509 const ExprOperand *operator->() const { return &Op; }
1511 expr_op_iterator &operator++() {
1515 expr_op_iterator operator++(int) {
1516 expr_op_iterator T(*this);
1521 bool operator==(const expr_op_iterator &X) const {
1522 return getBase() == X.getBase();
1524 bool operator!=(const expr_op_iterator &X) const {
1525 return getBase() != X.getBase();
1529 void increment() { Op = ExprOperand(getBase() + Op.getSize()); }
1532 /// \brief Visit the elements via ExprOperand wrappers.
1534 /// These range iterators visit elements through \a ExprOperand wrappers.
1535 /// This is not guaranteed to be a valid range unless \a isValid() gives \c
1538 /// \pre \a isValid() gives \c true.
1540 expr_op_iterator expr_op_begin() const {
1541 return expr_op_iterator(elements_begin());
1543 expr_op_iterator expr_op_end() const {
1544 return expr_op_iterator(elements_end());
1548 bool isValid() const;
1550 static bool classof(const Metadata *MD) {
1551 return MD->getMetadataID() == MDExpressionKind;
1555 class MDObjCProperty : public DebugNode {
1556 friend class LLVMContextImpl;
1557 friend class MDNode;
1560 unsigned Attributes;
1562 MDObjCProperty(LLVMContext &C, StorageType Storage, unsigned Line,
1563 unsigned Attributes, ArrayRef<Metadata *> Ops)
1564 : DebugNode(C, MDObjCPropertyKind, Storage, dwarf::DW_TAG_APPLE_property,
1566 Line(Line), Attributes(Attributes) {}
1567 ~MDObjCProperty() {}
1569 static MDObjCProperty *
1570 getImpl(LLVMContext &Context, StringRef Name, Metadata *File, unsigned Line,
1571 StringRef GetterName, StringRef SetterName, unsigned Attributes,
1572 Metadata *Type, StorageType Storage, bool ShouldCreate = true) {
1573 return getImpl(Context, getCanonicalMDString(Context, Name), File, Line,
1574 getCanonicalMDString(Context, GetterName),
1575 getCanonicalMDString(Context, SetterName), Attributes, Type,
1576 Storage, ShouldCreate);
1578 static MDObjCProperty *getImpl(LLVMContext &Context, MDString *Name,
1579 Metadata *File, unsigned Line,
1580 MDString *GetterName, MDString *SetterName,
1581 unsigned Attributes, Metadata *Type,
1582 StorageType Storage, bool ShouldCreate = true);
1584 TempMDObjCProperty cloneImpl() const {
1585 return getTemporary(getContext(), getName(), getFile(), getLine(),
1586 getGetterName(), getSetterName(), getAttributes(),
1591 DEFINE_MDNODE_GET(MDObjCProperty,
1592 (StringRef Name, Metadata *File, unsigned Line,
1593 StringRef GetterName, StringRef SetterName,
1594 unsigned Attributes, Metadata *Type),
1595 (Name, File, Line, GetterName, SetterName, Attributes,
1597 DEFINE_MDNODE_GET(MDObjCProperty,
1598 (MDString * Name, Metadata *File, unsigned Line,
1599 MDString *GetterName, MDString *SetterName,
1600 unsigned Attributes, Metadata *Type),
1601 (Name, File, Line, GetterName, SetterName, Attributes,
1604 TempMDObjCProperty clone() const { return cloneImpl(); }
1606 unsigned getLine() const { return Line; }
1607 unsigned getAttributes() const { return Attributes; }
1608 StringRef getName() const { return getStringOperand(0); }
1609 Metadata *getFile() const { return getOperand(1); }
1610 StringRef getGetterName() const { return getStringOperand(2); }
1611 StringRef getSetterName() const { return getStringOperand(3); }
1612 Metadata *getType() const { return getOperand(4); }
1614 MDString *getRawName() const { return getOperandAs<MDString>(0); }
1615 MDString *getRawGetterName() const { return getOperandAs<MDString>(2); }
1616 MDString *getRawSetterName() const { return getOperandAs<MDString>(3); }
1618 static bool classof(const Metadata *MD) {
1619 return MD->getMetadataID() == MDObjCPropertyKind;
1623 class MDImportedEntity : public DebugNode {
1624 friend class LLVMContextImpl;
1625 friend class MDNode;
1629 MDImportedEntity(LLVMContext &C, StorageType Storage, unsigned Tag,
1630 unsigned Line, ArrayRef<Metadata *> Ops)
1631 : DebugNode(C, MDImportedEntityKind, Storage, Tag, Ops), Line(Line) {}
1632 ~MDImportedEntity() {}
1634 static MDImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
1635 Metadata *Scope, Metadata *Entity,
1636 unsigned Line, StringRef Name,
1637 StorageType Storage,
1638 bool ShouldCreate = true) {
1639 return getImpl(Context, Tag, Scope, Entity, Line,
1640 getCanonicalMDString(Context, Name), Storage, ShouldCreate);
1642 static MDImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
1643 Metadata *Scope, Metadata *Entity,
1644 unsigned Line, MDString *Name,
1645 StorageType Storage,
1646 bool ShouldCreate = true);
1648 TempMDImportedEntity cloneImpl() const {
1649 return getTemporary(getContext(), getTag(), getScope(), getEntity(),
1650 getLine(), getName());
1654 DEFINE_MDNODE_GET(MDImportedEntity,
1655 (unsigned Tag, Metadata *Scope, Metadata *Entity,
1656 unsigned Line, StringRef Name = ""),
1657 (Tag, Scope, Entity, Line, Name))
1658 DEFINE_MDNODE_GET(MDImportedEntity,
1659 (unsigned Tag, Metadata *Scope, Metadata *Entity,
1660 unsigned Line, MDString *Name),
1661 (Tag, Scope, Entity, Line, Name))
1663 TempMDImportedEntity clone() const { return cloneImpl(); }
1665 unsigned getLine() const { return Line; }
1666 Metadata *getScope() const { return getOperand(0); }
1667 Metadata *getEntity() const { return getOperand(1); }
1668 StringRef getName() const { return getStringOperand(2); }
1670 MDString *getRawName() const { return getOperandAs<MDString>(2); }
1672 static bool classof(const Metadata *MD) {
1673 return MD->getMetadataID() == MDImportedEntityKind;
1677 } // end namespace llvm
1679 #undef DEFINE_MDNODE_GET_UNPACK_IMPL
1680 #undef DEFINE_MDNODE_GET_UNPACK
1681 #undef DEFINE_MDNODE_GET