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) LLVM_DELETED_FUNCTION;
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 static bool classof(const Metadata *MD) {
313 return MD->getMetadataID() == MDEnumeratorKind;
317 /// \brief Base class for scope-like contexts.
319 /// Base class for lexical scopes and types (which are also declaration
322 /// TODO: Separate the concepts of declaration contexts and lexical scopes.
323 class MDScope : public DebugNode {
325 MDScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
326 ArrayRef<Metadata *> Ops)
327 : DebugNode(C, ID, Storage, Tag, Ops) {}
331 Metadata *getFile() const { return getOperand(0); }
333 static bool classof(const Metadata *MD) {
334 switch (MD->getMetadataID()) {
337 case MDBasicTypeKind:
338 case MDDerivedTypeKind:
339 case MDCompositeTypeKind:
340 case MDSubroutineTypeKind:
342 case MDCompileUnitKind:
343 case MDSubprogramKind:
344 case MDLexicalBlockKind:
345 case MDLexicalBlockFileKind:
346 case MDNamespaceKind:
352 /// \brief Base class for types.
354 /// TODO: Remove the hardcoded name and context, since many types don't use
356 /// TODO: Split up flags.
357 class MDType : public MDScope {
360 unsigned AlignInBits;
361 unsigned OffsetInBits;
365 MDType(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
366 unsigned Line, unsigned SizeInBits, unsigned AlignInBits,
367 unsigned OffsetInBits, unsigned Flags, ArrayRef<Metadata *> Ops)
368 : MDScope(C, ID, Storage, Tag, Ops), Line(Line), SizeInBits(SizeInBits),
369 AlignInBits(AlignInBits), OffsetInBits(OffsetInBits), Flags(Flags) {}
373 unsigned getLine() const { return Line; }
374 unsigned getSizeInBits() const { return SizeInBits; }
375 unsigned getAlignInBits() const { return AlignInBits; }
376 unsigned getOffsetInBits() const { return OffsetInBits; }
377 unsigned getFlags() const { return Flags; }
379 Metadata *getScope() const { return getOperand(1); }
380 StringRef getName() const { return getStringOperand(2); }
382 static bool classof(const Metadata *MD) {
383 switch (MD->getMetadataID()) {
386 case MDBasicTypeKind:
387 case MDDerivedTypeKind:
388 case MDCompositeTypeKind:
389 case MDSubroutineTypeKind:
395 /// \brief Basic type.
397 /// TODO: Split out DW_TAG_unspecified_type.
398 /// TODO: Drop unused accessors.
399 class MDBasicType : public MDType {
400 friend class LLVMContextImpl;
405 MDBasicType(LLVMContext &C, StorageType Storage, unsigned Tag,
406 unsigned SizeInBits, unsigned AlignInBits, unsigned Encoding,
407 ArrayRef<Metadata *> Ops)
408 : MDType(C, MDBasicTypeKind, Storage, Tag, 0, SizeInBits, AlignInBits, 0,
410 Encoding(Encoding) {}
413 static MDBasicType *getImpl(LLVMContext &Context, unsigned Tag,
414 StringRef Name, unsigned SizeInBits,
415 unsigned AlignInBits, unsigned Encoding,
416 StorageType Storage, bool ShouldCreate = true) {
417 return getImpl(Context, Tag, getCanonicalMDString(Context, Name),
418 SizeInBits, AlignInBits, Encoding, Storage, ShouldCreate);
420 static MDBasicType *getImpl(LLVMContext &Context, unsigned Tag,
421 MDString *Name, unsigned SizeInBits,
422 unsigned AlignInBits, unsigned Encoding,
423 StorageType Storage, bool ShouldCreate = true);
425 TempMDBasicType cloneImpl() const {
426 return getTemporary(getContext(), getTag(), getName(), getSizeInBits(),
427 getAlignInBits(), getEncoding());
431 DEFINE_MDNODE_GET(MDBasicType,
432 (unsigned Tag, StringRef Name, unsigned SizeInBits,
433 unsigned AlignInBits, unsigned Encoding),
434 (Tag, Name, SizeInBits, AlignInBits, Encoding))
435 DEFINE_MDNODE_GET(MDBasicType,
436 (unsigned Tag, MDString *Name, unsigned SizeInBits,
437 unsigned AlignInBits, unsigned Encoding),
438 (Tag, Name, SizeInBits, AlignInBits, Encoding))
440 TempMDBasicType clone() const { return cloneImpl(); }
442 unsigned getEncoding() const { return Encoding; }
444 static bool classof(const Metadata *MD) {
445 return MD->getMetadataID() == MDBasicTypeKind;
449 /// \brief Base class for MDDerivedType and MDCompositeType.
451 /// TODO: Delete; they're not really related.
452 class MDDerivedTypeBase : public MDType {
454 MDDerivedTypeBase(LLVMContext &C, unsigned ID, StorageType Storage,
455 unsigned Tag, unsigned Line, unsigned SizeInBits,
456 unsigned AlignInBits, unsigned OffsetInBits, unsigned Flags,
457 ArrayRef<Metadata *> Ops)
458 : MDType(C, ID, Storage, Tag, Line, SizeInBits, AlignInBits, OffsetInBits,
460 ~MDDerivedTypeBase() {}
463 Metadata *getBaseType() const { return getOperand(3); }
465 static bool classof(const Metadata *MD) {
466 return MD->getMetadataID() == MDDerivedTypeKind ||
467 MD->getMetadataID() == MDCompositeTypeKind ||
468 MD->getMetadataID() == MDSubroutineTypeKind;
472 /// \brief Derived types.
474 /// This includes qualified types, pointers, references, friends, typedefs, and
477 /// TODO: Split out members (inheritance, fields, methods, etc.).
478 class MDDerivedType : public MDDerivedTypeBase {
479 friend class LLVMContextImpl;
482 MDDerivedType(LLVMContext &C, StorageType Storage, unsigned Tag,
483 unsigned Line, unsigned SizeInBits, unsigned AlignInBits,
484 unsigned OffsetInBits, unsigned Flags, ArrayRef<Metadata *> Ops)
485 : MDDerivedTypeBase(C, MDDerivedTypeKind, Storage, Tag, Line, SizeInBits,
486 AlignInBits, OffsetInBits, Flags, Ops) {}
489 static MDDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
490 StringRef Name, Metadata *File, unsigned Line,
491 Metadata *Scope, Metadata *BaseType,
492 unsigned SizeInBits, unsigned AlignInBits,
493 unsigned OffsetInBits, unsigned Flags,
494 Metadata *ExtraData, StorageType Storage,
495 bool ShouldCreate = true) {
496 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), File,
497 Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits,
498 Flags, ExtraData, Storage, ShouldCreate);
500 static MDDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
501 MDString *Name, Metadata *File, unsigned Line,
502 Metadata *Scope, Metadata *BaseType,
503 unsigned SizeInBits, unsigned AlignInBits,
504 unsigned OffsetInBits, unsigned Flags,
505 Metadata *ExtraData, StorageType Storage,
506 bool ShouldCreate = true);
508 TempMDDerivedType cloneImpl() const {
509 return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
510 getScope(), getBaseType(), getSizeInBits(),
511 getAlignInBits(), getOffsetInBits(), getFlags(),
516 DEFINE_MDNODE_GET(MDDerivedType,
517 (unsigned Tag, MDString *Name, Metadata *File,
518 unsigned Line, Metadata *Scope, Metadata *BaseType,
519 unsigned SizeInBits, unsigned AlignInBits,
520 unsigned OffsetInBits, unsigned Flags,
521 Metadata *ExtraData = nullptr),
522 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
523 AlignInBits, OffsetInBits, Flags, ExtraData))
524 DEFINE_MDNODE_GET(MDDerivedType,
525 (unsigned Tag, StringRef Name, Metadata *File,
526 unsigned Line, Metadata *Scope, Metadata *BaseType,
527 unsigned SizeInBits, unsigned AlignInBits,
528 unsigned OffsetInBits, unsigned Flags,
529 Metadata *ExtraData = nullptr),
530 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
531 AlignInBits, OffsetInBits, Flags, ExtraData))
533 TempMDDerivedType clone() const { return cloneImpl(); }
535 /// \brief Get extra data associated with this derived type.
537 /// Class type for pointer-to-members, objective-c property node for ivars,
538 /// or global constant wrapper for static members.
540 /// TODO: Separate out types that need this extra operand: pointer-to-member
541 /// types and member fields (static members and ivars).
542 Metadata *getExtraData() const { return getOperand(4); }
544 static bool classof(const Metadata *MD) {
545 return MD->getMetadataID() == MDDerivedTypeKind;
549 /// \brief Base class for MDCompositeType and MDSubroutineType.
551 /// TODO: Delete; they're not really related.
552 class MDCompositeTypeBase : public MDDerivedTypeBase {
553 unsigned RuntimeLang;
556 MDCompositeTypeBase(LLVMContext &C, unsigned ID, StorageType Storage,
557 unsigned Tag, unsigned Line, unsigned RuntimeLang,
558 unsigned SizeInBits, unsigned AlignInBits,
559 unsigned OffsetInBits, unsigned Flags,
560 ArrayRef<Metadata *> Ops)
561 : MDDerivedTypeBase(C, ID, Storage, Tag, Line, SizeInBits, AlignInBits,
562 OffsetInBits, Flags, Ops),
563 RuntimeLang(RuntimeLang) {}
564 ~MDCompositeTypeBase() {}
567 Metadata *getElements() const { return getOperand(4); }
568 Metadata *getVTableHolder() const { return getOperand(5); }
569 Metadata *getTemplateParams() const { return getOperand(6); }
570 StringRef getIdentifier() const { return getStringOperand(7); }
571 unsigned getRuntimeLang() const { return RuntimeLang; }
573 MDString *getRawIdentifier() const { return getOperandAs<MDString>(7); }
575 static bool classof(const Metadata *MD) {
576 return MD->getMetadataID() == MDCompositeTypeKind ||
577 MD->getMetadataID() == MDSubroutineTypeKind;
581 /// \brief Composite types.
583 /// TODO: Detach from DerivedTypeBase (split out MDEnumType?).
584 /// TODO: Create a custom, unrelated node for DW_TAG_array_type.
585 class MDCompositeType : public MDCompositeTypeBase {
586 friend class LLVMContextImpl;
589 MDCompositeType(LLVMContext &C, StorageType Storage, unsigned Tag,
590 unsigned Line, unsigned RuntimeLang, unsigned SizeInBits,
591 unsigned AlignInBits, unsigned OffsetInBits, unsigned Flags,
592 ArrayRef<Metadata *> Ops)
593 : MDCompositeTypeBase(C, MDCompositeTypeKind, Storage, Tag, Line,
594 RuntimeLang, SizeInBits, AlignInBits, OffsetInBits,
596 ~MDCompositeType() {}
598 static MDCompositeType *
599 getImpl(LLVMContext &Context, unsigned Tag, StringRef Name, Metadata *File,
600 unsigned Line, Metadata *Scope, Metadata *BaseType,
601 unsigned SizeInBits, unsigned AlignInBits, unsigned OffsetInBits,
602 unsigned Flags, Metadata *Elements, unsigned RuntimeLang,
603 Metadata *VTableHolder, Metadata *TemplateParams,
604 StringRef Identifier, StorageType Storage, bool ShouldCreate = true) {
605 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), File,
606 Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits,
607 Flags, Elements, RuntimeLang, VTableHolder, TemplateParams,
608 getCanonicalMDString(Context, Identifier), Storage,
611 static MDCompositeType *
612 getImpl(LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
613 unsigned Line, Metadata *Scope, Metadata *BaseType,
614 unsigned SizeInBits, unsigned AlignInBits, unsigned OffsetInBits,
615 unsigned Flags, Metadata *Elements, unsigned RuntimeLang,
616 Metadata *VTableHolder, Metadata *TemplateParams,
617 MDString *Identifier, StorageType Storage, bool ShouldCreate = true);
619 TempMDCompositeType cloneImpl() const {
620 return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
621 getScope(), getBaseType(), getSizeInBits(),
622 getAlignInBits(), getOffsetInBits(), getFlags(),
623 getElements(), getRuntimeLang(), getVTableHolder(),
624 getTemplateParams(), getIdentifier());
628 DEFINE_MDNODE_GET(MDCompositeType,
629 (unsigned Tag, StringRef Name, Metadata *File,
630 unsigned Line, Metadata *Scope, Metadata *BaseType,
631 unsigned SizeInBits, unsigned AlignInBits,
632 unsigned OffsetInBits, unsigned Flags, Metadata *Elements,
633 unsigned RuntimeLang, Metadata *VTableHolder,
634 Metadata *TemplateParams = nullptr,
635 StringRef Identifier = ""),
636 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
637 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
638 VTableHolder, TemplateParams, Identifier))
639 DEFINE_MDNODE_GET(MDCompositeType,
640 (unsigned Tag, MDString *Name, Metadata *File,
641 unsigned Line, Metadata *Scope, Metadata *BaseType,
642 unsigned SizeInBits, unsigned AlignInBits,
643 unsigned OffsetInBits, unsigned Flags, Metadata *Elements,
644 unsigned RuntimeLang, Metadata *VTableHolder,
645 Metadata *TemplateParams = nullptr,
646 MDString *Identifier = nullptr),
647 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
648 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
649 VTableHolder, TemplateParams, Identifier))
651 TempMDCompositeType clone() const { return cloneImpl(); }
653 static bool classof(const Metadata *MD) {
654 return MD->getMetadataID() == MDCompositeTypeKind;
658 /// \brief Type array for a subprogram.
660 /// TODO: Detach from CompositeType, and fold the array of types in directly
662 class MDSubroutineType : public MDCompositeTypeBase {
663 friend class LLVMContextImpl;
666 MDSubroutineType(LLVMContext &C, StorageType Storage, unsigned Flags,
667 ArrayRef<Metadata *> Ops)
668 : MDCompositeTypeBase(C, MDSubroutineTypeKind, Storage,
669 dwarf::DW_TAG_subroutine_type, 0, 0, 0, 0, 0, Flags,
671 ~MDSubroutineType() {}
673 static MDSubroutineType *getImpl(LLVMContext &Context, unsigned Flags,
674 Metadata *TypeArray, StorageType Storage,
675 bool ShouldCreate = true);
677 TempMDSubroutineType cloneImpl() const {
678 return getTemporary(getContext(), getFlags(), getTypeArray());
682 DEFINE_MDNODE_GET(MDSubroutineType, (unsigned Flags, Metadata *TypeArray),
685 TempMDSubroutineType clone() const { return cloneImpl(); }
687 Metadata *getTypeArray() const { return getElements(); }
689 static bool classof(const Metadata *MD) {
690 return MD->getMetadataID() == MDSubroutineTypeKind;
696 /// TODO: Merge with directory/file node (including users).
697 /// TODO: Canonicalize paths on creation.
698 class MDFile : public MDScope {
699 friend class LLVMContextImpl;
702 MDFile(LLVMContext &C, StorageType Storage, ArrayRef<Metadata *> Ops)
703 : MDScope(C, MDFileKind, Storage, dwarf::DW_TAG_file_type, Ops) {}
706 static MDFile *getImpl(LLVMContext &Context, StringRef Filename,
707 StringRef Directory, StorageType Storage,
708 bool ShouldCreate = true) {
709 return getImpl(Context, getCanonicalMDString(Context, Filename),
710 getCanonicalMDString(Context, Directory), Storage,
713 static MDFile *getImpl(LLVMContext &Context, MDString *Filename,
714 MDString *Directory, StorageType Storage,
715 bool ShouldCreate = true);
717 TempMDFile cloneImpl() const {
718 return getTemporary(getContext(), getFilename(), getDirectory());
722 DEFINE_MDNODE_GET(MDFile, (StringRef Filename, StringRef Directory),
723 (Filename, Directory))
724 DEFINE_MDNODE_GET(MDFile, (MDString * Filename, MDString *Directory),
725 (Filename, Directory))
727 TempMDFile clone() const { return cloneImpl(); }
729 MDTuple *getFileNode() const { return cast<MDTuple>(getOperand(0)); }
731 StringRef getFilename() const {
732 if (auto *S = cast_or_null<MDString>(getFileNode()->getOperand(0)))
733 return S->getString();
736 StringRef getDirectory() const {
737 if (auto *S = cast_or_null<MDString>(getFileNode()->getOperand(1)))
738 return S->getString();
742 static bool classof(const Metadata *MD) {
743 return MD->getMetadataID() == MDFileKind;
747 /// \brief Compile unit.
748 class MDCompileUnit : public MDScope {
749 friend class LLVMContextImpl;
752 unsigned SourceLanguage;
754 unsigned RuntimeVersion;
755 unsigned EmissionKind;
757 MDCompileUnit(LLVMContext &C, StorageType Storage, unsigned SourceLanguage,
758 bool IsOptimized, unsigned RuntimeVersion,
759 unsigned EmissionKind, ArrayRef<Metadata *> Ops)
760 : MDScope(C, MDCompileUnitKind, Storage, dwarf::DW_TAG_compile_unit, Ops),
761 SourceLanguage(SourceLanguage), IsOptimized(IsOptimized),
762 RuntimeVersion(RuntimeVersion), EmissionKind(EmissionKind) {}
765 static MDCompileUnit *
766 getImpl(LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
767 StringRef Producer, bool IsOptimized, StringRef Flags,
768 unsigned RuntimeVersion, StringRef SplitDebugFilename,
769 unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
770 Metadata *Subprograms, Metadata *GlobalVariables,
771 Metadata *ImportedEntities, StorageType Storage,
772 bool ShouldCreate = true) {
773 return getImpl(Context, SourceLanguage, File,
774 getCanonicalMDString(Context, Producer), IsOptimized,
775 getCanonicalMDString(Context, Flags), RuntimeVersion,
776 getCanonicalMDString(Context, SplitDebugFilename),
777 EmissionKind, EnumTypes, RetainedTypes, Subprograms,
778 GlobalVariables, ImportedEntities, Storage, ShouldCreate);
780 static MDCompileUnit *
781 getImpl(LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
782 MDString *Producer, bool IsOptimized, MDString *Flags,
783 unsigned RuntimeVersion, MDString *SplitDebugFilename,
784 unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
785 Metadata *Subprograms, Metadata *GlobalVariables,
786 Metadata *ImportedEntities, StorageType Storage,
787 bool ShouldCreate = true);
789 TempMDCompileUnit cloneImpl() const {
791 getContext(), getSourceLanguage(), getFile(), getProducer(),
792 isOptimized(), getFlags(), getRuntimeVersion(), getSplitDebugFilename(),
793 getEmissionKind(), getEnumTypes(), getRetainedTypes(), getSubprograms(),
794 getGlobalVariables(), getImportedEntities());
798 DEFINE_MDNODE_GET(MDCompileUnit,
799 (unsigned SourceLanguage, Metadata *File,
800 StringRef Producer, bool IsOptimized, StringRef Flags,
801 unsigned RuntimeVersion, StringRef SplitDebugFilename,
802 unsigned EmissionKind, Metadata *EnumTypes,
803 Metadata *RetainedTypes, Metadata *Subprograms,
804 Metadata *GlobalVariables, Metadata *ImportedEntities),
805 (SourceLanguage, File, Producer, IsOptimized, Flags,
806 RuntimeVersion, SplitDebugFilename, EmissionKind,
807 EnumTypes, RetainedTypes, Subprograms, GlobalVariables,
809 DEFINE_MDNODE_GET(MDCompileUnit,
810 (unsigned SourceLanguage, Metadata *File,
811 MDString *Producer, bool IsOptimized, MDString *Flags,
812 unsigned RuntimeVersion, MDString *SplitDebugFilename,
813 unsigned EmissionKind, Metadata *EnumTypes,
814 Metadata *RetainedTypes, Metadata *Subprograms,
815 Metadata *GlobalVariables, Metadata *ImportedEntities),
816 (SourceLanguage, File, Producer, IsOptimized, Flags,
817 RuntimeVersion, SplitDebugFilename, EmissionKind,
818 EnumTypes, RetainedTypes, Subprograms, GlobalVariables,
821 TempMDCompileUnit clone() const { return cloneImpl(); }
823 unsigned getSourceLanguage() const { return SourceLanguage; }
824 bool isOptimized() const { return IsOptimized; }
825 unsigned getRuntimeVersion() const { return RuntimeVersion; }
826 unsigned getEmissionKind() const { return EmissionKind; }
827 StringRef getProducer() const { return getStringOperand(1); }
828 StringRef getFlags() const { return getStringOperand(2); }
829 StringRef getSplitDebugFilename() const { return getStringOperand(3); }
830 Metadata *getEnumTypes() const { return getOperand(4); }
831 Metadata *getRetainedTypes() const { return getOperand(5); }
832 Metadata *getSubprograms() const { return getOperand(6); }
833 Metadata *getGlobalVariables() const { return getOperand(7); }
834 Metadata *getImportedEntities() const { return getOperand(8); }
836 static bool classof(const Metadata *MD) {
837 return MD->getMetadataID() == MDCompileUnitKind;
841 /// \brief Subprogram description.
843 /// TODO: Remove DisplayName. It's always equal to Name.
844 /// TODO: Split up flags.
845 class MDSubprogram : public MDScope {
846 friend class LLVMContextImpl;
852 unsigned VirtualIndex;
858 MDSubprogram(LLVMContext &C, StorageType Storage, unsigned Line,
859 unsigned ScopeLine, unsigned Virtuality, unsigned VirtualIndex,
860 unsigned Flags, bool IsLocalToUnit, bool IsDefinition,
861 bool IsOptimized, ArrayRef<Metadata *> Ops)
862 : MDScope(C, MDSubprogramKind, Storage, dwarf::DW_TAG_subprogram, Ops),
863 Line(Line), ScopeLine(ScopeLine), Virtuality(Virtuality),
864 VirtualIndex(VirtualIndex), Flags(Flags), IsLocalToUnit(IsLocalToUnit),
865 IsDefinition(IsDefinition), IsOptimized(IsOptimized) {}
868 static MDSubprogram *
869 getImpl(LLVMContext &Context, Metadata *Scope, StringRef Name,
870 StringRef LinkageName, Metadata *File, unsigned Line, Metadata *Type,
871 bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
872 Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex,
873 unsigned Flags, bool IsOptimized, Metadata *Function,
874 Metadata *TemplateParams, Metadata *Declaration, Metadata *Variables,
875 StorageType Storage, bool ShouldCreate = true) {
876 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
877 getCanonicalMDString(Context, LinkageName), File, Line, Type,
878 IsLocalToUnit, IsDefinition, ScopeLine, ContainingType,
879 Virtuality, VirtualIndex, Flags, IsOptimized, Function,
880 TemplateParams, Declaration, Variables, Storage,
883 static MDSubprogram *
884 getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
885 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
886 bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
887 Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex,
888 unsigned Flags, bool IsOptimized, Metadata *Function,
889 Metadata *TemplateParams, Metadata *Declaration, Metadata *Variables,
890 StorageType Storage, bool ShouldCreate = true);
892 TempMDSubprogram cloneImpl() const {
893 return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
894 getFile(), getLine(), getType(), isLocalToUnit(),
895 isDefinition(), getScopeLine(), getContainingType(),
896 getVirtuality(), getVirtualIndex(), getFlags(),
897 isOptimized(), getFunction(), getTemplateParams(),
898 getDeclaration(), getVariables());
904 (Metadata * Scope, StringRef Name, StringRef LinkageName, Metadata *File,
905 unsigned Line, Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
906 unsigned ScopeLine, Metadata *ContainingType, unsigned Virtuality,
907 unsigned VirtualIndex, unsigned Flags, bool IsOptimized,
908 Metadata *Function = nullptr, Metadata *TemplateParams = nullptr,
909 Metadata *Declaration = nullptr, Metadata *Variables = nullptr),
910 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition,
911 ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags, IsOptimized,
912 Function, TemplateParams, Declaration, Variables))
915 (Metadata * Scope, MDString *Name, MDString *LinkageName, Metadata *File,
916 unsigned Line, Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
917 unsigned ScopeLine, Metadata *ContainingType, unsigned Virtuality,
918 unsigned VirtualIndex, unsigned Flags, bool IsOptimized,
919 Metadata *Function = nullptr, Metadata *TemplateParams = nullptr,
920 Metadata *Declaration = nullptr, Metadata *Variables = nullptr),
921 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition,
922 ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags, IsOptimized,
923 Function, TemplateParams, Declaration, Variables))
925 TempMDSubprogram clone() const { return cloneImpl(); }
928 unsigned getLine() const { return Line; }
929 unsigned getVirtuality() const { return Virtuality; }
930 unsigned getVirtualIndex() const { return VirtualIndex; }
931 unsigned getScopeLine() const { return ScopeLine; }
932 unsigned getFlags() const { return Flags; }
933 bool isLocalToUnit() const { return IsLocalToUnit; }
934 bool isDefinition() const { return IsDefinition; }
935 bool isOptimized() const { return IsOptimized; }
937 Metadata *getScope() const { return getOperand(1); }
939 StringRef getName() const { return getStringOperand(2); }
940 StringRef getDisplayName() const { return getStringOperand(3); }
941 StringRef getLinkageName() const { return getStringOperand(4); }
943 Metadata *getType() const { return getOperand(5); }
944 Metadata *getContainingType() const { return getOperand(6); }
946 Metadata *getFunction() const { return getOperand(7); }
947 Metadata *getTemplateParams() const { return getOperand(8); }
948 Metadata *getDeclaration() const { return getOperand(9); }
949 Metadata *getVariables() const { return getOperand(10); }
951 static bool classof(const Metadata *MD) {
952 return MD->getMetadataID() == MDSubprogramKind;
956 class MDLexicalBlockBase : public MDScope {
958 MDLexicalBlockBase(LLVMContext &C, unsigned ID, StorageType Storage,
959 ArrayRef<Metadata *> Ops)
960 : MDScope(C, ID, Storage, dwarf::DW_TAG_lexical_block, Ops) {}
961 ~MDLexicalBlockBase() {}
964 Metadata *getScope() const { return getOperand(1); }
966 static bool classof(const Metadata *MD) {
967 return MD->getMetadataID() == MDLexicalBlockKind ||
968 MD->getMetadataID() == MDLexicalBlockFileKind;
972 class MDLexicalBlock : public MDLexicalBlockBase {
973 friend class LLVMContextImpl;
979 MDLexicalBlock(LLVMContext &C, StorageType Storage, unsigned Line,
980 unsigned Column, ArrayRef<Metadata *> Ops)
981 : MDLexicalBlockBase(C, MDLexicalBlockKind, Storage, Ops), Line(Line),
985 static MDLexicalBlock *getImpl(LLVMContext &Context, Metadata *Scope,
986 Metadata *File, unsigned Line, unsigned Column,
987 StorageType Storage, bool ShouldCreate = true);
989 TempMDLexicalBlock cloneImpl() const {
990 return getTemporary(getContext(), getScope(), getFile(), getLine(),
995 DEFINE_MDNODE_GET(MDLexicalBlock, (Metadata * Scope, Metadata *File,
996 unsigned Line, unsigned Column),
997 (Scope, File, Line, Column))
999 TempMDLexicalBlock clone() const { return cloneImpl(); }
1001 unsigned getLine() const { return Line; }
1002 unsigned getColumn() const { return Column; }
1004 static bool classof(const Metadata *MD) {
1005 return MD->getMetadataID() == MDLexicalBlockKind;
1009 class MDLexicalBlockFile : public MDLexicalBlockBase {
1010 friend class LLVMContextImpl;
1011 friend class MDNode;
1013 unsigned Discriminator;
1015 MDLexicalBlockFile(LLVMContext &C, StorageType Storage,
1016 unsigned Discriminator, ArrayRef<Metadata *> Ops)
1017 : MDLexicalBlockBase(C, MDLexicalBlockFileKind, Storage, Ops),
1018 Discriminator(Discriminator) {}
1019 ~MDLexicalBlockFile() {}
1021 static MDLexicalBlockFile *getImpl(LLVMContext &Context, Metadata *Scope,
1022 Metadata *File, unsigned Discriminator,
1023 StorageType Storage,
1024 bool ShouldCreate = true);
1026 TempMDLexicalBlockFile cloneImpl() const {
1027 return getTemporary(getContext(), getScope(), getFile(),
1028 getDiscriminator());
1032 DEFINE_MDNODE_GET(MDLexicalBlockFile,
1033 (Metadata * Scope, Metadata *File, unsigned Discriminator),
1034 (Scope, File, Discriminator))
1036 TempMDLexicalBlockFile clone() const { return cloneImpl(); }
1038 unsigned getDiscriminator() const { return Discriminator; }
1040 static bool classof(const Metadata *MD) {
1041 return MD->getMetadataID() == MDLexicalBlockFileKind;
1045 class MDNamespace : public MDScope {
1046 friend class LLVMContextImpl;
1047 friend class MDNode;
1051 MDNamespace(LLVMContext &Context, StorageType Storage, unsigned Line,
1052 ArrayRef<Metadata *> Ops)
1053 : MDScope(Context, MDNamespaceKind, Storage, dwarf::DW_TAG_namespace,
1058 static MDNamespace *getImpl(LLVMContext &Context, Metadata *Scope,
1059 Metadata *File, StringRef Name, unsigned Line,
1060 StorageType Storage, bool ShouldCreate = true) {
1061 return getImpl(Context, Scope, File, getCanonicalMDString(Context, Name),
1062 Line, Storage, ShouldCreate);
1064 static MDNamespace *getImpl(LLVMContext &Context, Metadata *Scope,
1065 Metadata *File, MDString *Name, unsigned Line,
1066 StorageType Storage, bool ShouldCreate = true);
1068 TempMDNamespace cloneImpl() const {
1069 return getTemporary(getContext(), getScope(), getFile(), getName(),
1074 DEFINE_MDNODE_GET(MDNamespace, (Metadata * Scope, Metadata *File,
1075 StringRef Name, unsigned Line),
1076 (Scope, File, Name, Line))
1077 DEFINE_MDNODE_GET(MDNamespace, (Metadata * Scope, Metadata *File,
1078 MDString *Name, unsigned Line),
1079 (Scope, File, Name, Line))
1081 TempMDNamespace clone() const { return cloneImpl(); }
1083 unsigned getLine() const { return Line; }
1084 Metadata *getScope() const { return getOperand(1); }
1085 StringRef getName() const { return getStringOperand(2); }
1087 static bool classof(const Metadata *MD) {
1088 return MD->getMetadataID() == MDNamespaceKind;
1092 /// \brief Base class for template parameters.
1094 /// TODO: Remove the scope. It's always the compile unit, and never
1096 /// TODO: Remove File, Line and Column. They're always 0 and never
1098 class MDTemplateParameter : public DebugNode {
1103 MDTemplateParameter(LLVMContext &Context, unsigned ID, StorageType Storage,
1104 unsigned Tag, unsigned Line, unsigned Column,
1105 ArrayRef<Metadata *> Ops)
1106 : DebugNode(Context, ID, Storage, Tag, Ops), Line(Line), Column(Column) {}
1107 ~MDTemplateParameter() {}
1110 unsigned getLine() const { return Line; }
1111 unsigned getColumn() const { return Column; }
1113 Metadata *getFile() const { return getOperand(0); }
1114 Metadata *getScope() const { return getOperand(1); }
1115 StringRef getName() const { return getStringOperand(2); }
1116 Metadata *getType() const { return getOperand(3); }
1118 static bool classof(const Metadata *MD) {
1119 return MD->getMetadataID() == MDTemplateTypeParameterKind ||
1120 MD->getMetadataID() == MDTemplateValueParameterKind;
1124 class MDTemplateTypeParameter : public MDTemplateParameter {
1125 friend class LLVMContextImpl;
1126 friend class MDNode;
1128 MDTemplateTypeParameter(LLVMContext &Context, StorageType Storage,
1129 unsigned Line, unsigned Column,
1130 ArrayRef<Metadata *> Ops)
1131 : MDTemplateParameter(Context, MDTemplateTypeParameterKind, Storage,
1132 dwarf::DW_TAG_template_type_parameter, Line, Column,
1134 ~MDTemplateTypeParameter() {}
1136 static MDTemplateTypeParameter *getImpl(LLVMContext &Context, Metadata *Scope,
1137 StringRef Name, Metadata *Type,
1138 Metadata *File, unsigned Line,
1139 unsigned Column, StorageType Storage,
1140 bool ShouldCreate = true) {
1141 return getImpl(Context, Scope, getCanonicalMDString(Context, Name), Type,
1142 File, Line, Column, Storage, ShouldCreate);
1144 static MDTemplateTypeParameter *getImpl(LLVMContext &Context, Metadata *Scope,
1145 MDString *Name, Metadata *Type,
1146 Metadata *File, unsigned Line,
1147 unsigned Column, StorageType Storage,
1148 bool ShouldCreate = true);
1150 TempMDTemplateTypeParameter cloneImpl() const {
1151 return getTemporary(getContext(), getScope(), getName(), getType(),
1152 getFile(), getLine(), getColumn());
1156 DEFINE_MDNODE_GET(MDTemplateTypeParameter,
1157 (Metadata * Scope, StringRef Name, Metadata *Type,
1158 Metadata *File = nullptr, unsigned Line = 0,
1159 unsigned Column = 0),
1160 (Scope, Name, Type, File, Line, Column))
1161 DEFINE_MDNODE_GET(MDTemplateTypeParameter,
1162 (Metadata * Scope, MDString *Name, Metadata *Type,
1163 Metadata *File = nullptr, unsigned Line = 0,
1164 unsigned Column = 0),
1165 (Scope, Name, Type, File, Line, Column))
1167 TempMDTemplateTypeParameter clone() const { return cloneImpl(); }
1169 static bool classof(const Metadata *MD) {
1170 return MD->getMetadataID() == MDTemplateTypeParameterKind;
1174 class MDTemplateValueParameter : public MDTemplateParameter {
1175 friend class LLVMContextImpl;
1176 friend class MDNode;
1178 MDTemplateValueParameter(LLVMContext &Context, StorageType Storage,
1179 unsigned Tag, unsigned Line, unsigned Column,
1180 ArrayRef<Metadata *> Ops)
1181 : MDTemplateParameter(Context, MDTemplateValueParameterKind, Storage, Tag,
1182 Line, Column, Ops) {}
1183 ~MDTemplateValueParameter() {}
1185 static MDTemplateValueParameter *
1186 getImpl(LLVMContext &Context, unsigned Tag, Metadata *Scope, StringRef Name,
1187 Metadata *Type, Metadata *Value, Metadata *File, unsigned Line,
1188 unsigned Column, StorageType Storage, bool ShouldCreate = true) {
1189 return getImpl(Context, Tag, Scope, getCanonicalMDString(Context, Name),
1190 Type, Value, File, Line, Column, Storage, ShouldCreate);
1192 static MDTemplateValueParameter *
1193 getImpl(LLVMContext &Context, unsigned Tag, Metadata *Scope, MDString *Name,
1194 Metadata *Type, Metadata *Value, Metadata *File, unsigned Line,
1195 unsigned Column, StorageType Storage, bool ShouldCreate = true);
1197 TempMDTemplateValueParameter cloneImpl() const {
1198 return getTemporary(getContext(), getTag(), getScope(), getName(),
1199 getType(), getValue(), getFile(), getLine(),
1204 DEFINE_MDNODE_GET(MDTemplateValueParameter,
1205 (unsigned Tag, Metadata *Scope, StringRef Name,
1206 Metadata *Type, Metadata *Value, Metadata *File = nullptr,
1207 unsigned Line = 0, unsigned Column = 0),
1208 (Tag, Scope, Name, Type, Value, File, Line, Column))
1209 DEFINE_MDNODE_GET(MDTemplateValueParameter,
1210 (unsigned Tag, Metadata *Scope, MDString *Name,
1211 Metadata *Type, Metadata *Value, Metadata *File = nullptr,
1212 unsigned Line = 0, unsigned Column = 0),
1213 (Tag, Scope, Name, Type, Value, File, Line, Column))
1215 Metadata *getValue() const { return getOperand(4); }
1217 static bool classof(const Metadata *MD) {
1218 return MD->getMetadataID() == MDTemplateValueParameterKind;
1222 /// \brief Base class for variables.
1224 /// TODO: Hardcode to DW_TAG_variable.
1225 class MDVariable : public DebugNode {
1229 MDVariable(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
1230 unsigned Line, ArrayRef<Metadata *> Ops)
1231 : DebugNode(C, ID, Storage, Tag, Ops), Line(Line) {}
1235 unsigned getLine() const { return Line; }
1236 Metadata *getScope() const { return getOperand(0); }
1237 StringRef getName() const { return getStringOperand(1); }
1238 Metadata *getFile() const { return getOperand(2); }
1239 Metadata *getType() const { return getOperand(3); }
1241 static bool classof(const Metadata *MD) {
1242 return MD->getMetadataID() == MDLocalVariableKind ||
1243 MD->getMetadataID() == MDGlobalVariableKind;
1247 /// \brief Global variables.
1249 /// TODO: Remove DisplayName. It's always equal to Name.
1250 class MDGlobalVariable : public MDVariable {
1251 friend class LLVMContextImpl;
1252 friend class MDNode;
1257 MDGlobalVariable(LLVMContext &C, StorageType Storage, unsigned Line,
1258 bool IsLocalToUnit, bool IsDefinition,
1259 ArrayRef<Metadata *> Ops)
1260 : MDVariable(C, MDGlobalVariableKind, Storage, dwarf::DW_TAG_variable,
1262 IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition) {}
1263 ~MDGlobalVariable() {}
1265 static MDGlobalVariable *
1266 getImpl(LLVMContext &Context, Metadata *Scope, StringRef Name,
1267 StringRef LinkageName, Metadata *File, unsigned Line, Metadata *Type,
1268 bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
1269 Metadata *StaticDataMemberDeclaration, StorageType Storage,
1270 bool ShouldCreate = true) {
1271 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
1272 getCanonicalMDString(Context, LinkageName), File, Line, Type,
1273 IsLocalToUnit, IsDefinition, Variable,
1274 StaticDataMemberDeclaration, Storage, ShouldCreate);
1276 static MDGlobalVariable *
1277 getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
1278 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
1279 bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
1280 Metadata *StaticDataMemberDeclaration, StorageType Storage,
1281 bool ShouldCreate = true);
1283 TempMDGlobalVariable cloneImpl() const {
1284 return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
1285 getFile(), getLine(), getType(), isLocalToUnit(),
1286 isDefinition(), getVariable(),
1287 getStaticDataMemberDeclaration());
1291 DEFINE_MDNODE_GET(MDGlobalVariable,
1292 (Metadata * Scope, StringRef Name, StringRef LinkageName,
1293 Metadata *File, unsigned Line, Metadata *Type,
1294 bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
1295 Metadata *StaticDataMemberDeclaration),
1296 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
1297 IsDefinition, Variable, StaticDataMemberDeclaration))
1298 DEFINE_MDNODE_GET(MDGlobalVariable,
1299 (Metadata * Scope, MDString *Name, MDString *LinkageName,
1300 Metadata *File, unsigned Line, Metadata *Type,
1301 bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
1302 Metadata *StaticDataMemberDeclaration),
1303 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
1304 IsDefinition, Variable, StaticDataMemberDeclaration))
1306 bool isLocalToUnit() const { return IsLocalToUnit; }
1307 bool isDefinition() const { return IsDefinition; }
1308 StringRef getDisplayName() const { return getStringOperand(4); }
1309 StringRef getLinkageName() const { return getStringOperand(5); }
1310 Metadata *getVariable() const { return getOperand(6); }
1311 Metadata *getStaticDataMemberDeclaration() const { return getOperand(7); }
1313 static bool classof(const Metadata *MD) {
1314 return MD->getMetadataID() == MDGlobalVariableKind;
1318 /// \brief Local variable.
1320 /// TODO: Split between arguments and otherwise.
1321 /// TODO: Use \c DW_TAG_variable instead of fake tags.
1322 /// TODO: Split up flags.
1323 class MDLocalVariable : public MDVariable {
1324 friend class LLVMContextImpl;
1325 friend class MDNode;
1330 MDLocalVariable(LLVMContext &C, StorageType Storage, unsigned Tag,
1331 unsigned Line, unsigned Arg, unsigned Flags,
1332 ArrayRef<Metadata *> Ops)
1333 : MDVariable(C, MDLocalVariableKind, Storage, Tag, Line, Ops), Arg(Arg),
1335 ~MDLocalVariable() {}
1337 static MDLocalVariable *getImpl(LLVMContext &Context, unsigned Tag,
1338 Metadata *Scope, StringRef Name,
1339 Metadata *File, unsigned Line, Metadata *Type,
1340 unsigned Arg, unsigned Flags,
1341 Metadata *InlinedAt, StorageType Storage,
1342 bool ShouldCreate = true) {
1343 return getImpl(Context, Tag, Scope, getCanonicalMDString(Context, Name),
1344 File, Line, Type, Arg, Flags, InlinedAt, Storage,
1347 static MDLocalVariable *getImpl(LLVMContext &Context, unsigned Tag,
1348 Metadata *Scope, MDString *Name,
1349 Metadata *File, unsigned Line, Metadata *Type,
1350 unsigned Arg, unsigned Flags,
1351 Metadata *InlinedAt, StorageType Storage,
1352 bool ShouldCreate = true);
1354 TempMDLocalVariable cloneImpl() const {
1355 return getTemporary(getContext(), getTag(), getScope(), getName(),
1356 getFile(), getLine(), getType(), getArg(), getFlags(),
1361 DEFINE_MDNODE_GET(MDLocalVariable,
1362 (unsigned Tag, Metadata *Scope, StringRef Name,
1363 Metadata *File, unsigned Line, Metadata *Type,
1364 unsigned Arg, unsigned Flags,
1365 Metadata *InlinedAt = nullptr),
1366 (Tag, Scope, Name, File, Line, Type, Arg, Flags, InlinedAt))
1367 DEFINE_MDNODE_GET(MDLocalVariable,
1368 (unsigned Tag, Metadata *Scope, MDString *Name,
1369 Metadata *File, unsigned Line, Metadata *Type,
1370 unsigned Arg, unsigned Flags,
1371 Metadata *InlinedAt = nullptr),
1372 (Tag, Scope, Name, File, Line, Type, Arg, Flags, InlinedAt))
1374 unsigned getArg() const { return Arg; }
1375 unsigned getFlags() const { return Flags; }
1376 Metadata *getInlinedAt() const { return getOperand(4); }
1378 static bool classof(const Metadata *MD) {
1379 return MD->getMetadataID() == MDLocalVariableKind;
1383 /// \brief DWARF expression.
1385 /// TODO: Co-allocate the expression elements.
1386 /// TODO: Drop fake DW_TAG_expression and separate from DebugNode.
1387 /// TODO: Separate from MDNode, or otherwise drop Distinct and Temporary
1389 class MDExpression : public DebugNode {
1390 friend class LLVMContextImpl;
1391 friend class MDNode;
1393 std::vector<uint64_t> Elements;
1395 MDExpression(LLVMContext &C, StorageType Storage, ArrayRef<uint64_t> Elements)
1396 : DebugNode(C, MDExpressionKind, Storage, dwarf::DW_TAG_expression, None),
1397 Elements(Elements.begin(), Elements.end()) {}
1400 static MDExpression *getImpl(LLVMContext &Context,
1401 ArrayRef<uint64_t> Elements, StorageType Storage,
1402 bool ShouldCreate = true);
1404 TempMDExpression cloneImpl() const {
1405 return getTemporary(getContext(), getElements());
1409 DEFINE_MDNODE_GET(MDExpression, (ArrayRef<uint64_t> Elements), (Elements))
1411 ArrayRef<uint64_t> getElements() const { return Elements; }
1413 unsigned getNumElements() const { return Elements.size(); }
1414 uint64_t getElement(unsigned I) const {
1415 assert(I < Elements.size() && "Index out of range");
1419 typedef ArrayRef<uint64_t>::iterator element_iterator;
1420 element_iterator elements_begin() const { return getElements().begin(); }
1421 element_iterator elements_end() const { return getElements().end(); }
1423 static bool classof(const Metadata *MD) {
1424 return MD->getMetadataID() == MDExpressionKind;
1428 class MDObjCProperty : public DebugNode {
1429 friend class LLVMContextImpl;
1430 friend class MDNode;
1433 unsigned Attributes;
1435 MDObjCProperty(LLVMContext &C, StorageType Storage, unsigned Line,
1436 unsigned Attributes, ArrayRef<Metadata *> Ops)
1437 : DebugNode(C, MDObjCPropertyKind, Storage, dwarf::DW_TAG_APPLE_property,
1439 Line(Line), Attributes(Attributes) {}
1440 ~MDObjCProperty() {}
1442 static MDObjCProperty *
1443 getImpl(LLVMContext &Context, StringRef Name, Metadata *File, unsigned Line,
1444 StringRef GetterName, StringRef SetterName, unsigned Attributes,
1445 Metadata *Type, StorageType Storage, bool ShouldCreate = true) {
1446 return getImpl(Context, getCanonicalMDString(Context, Name), File, Line,
1447 getCanonicalMDString(Context, GetterName),
1448 getCanonicalMDString(Context, SetterName), Attributes, Type,
1449 Storage, ShouldCreate);
1451 static MDObjCProperty *getImpl(LLVMContext &Context, MDString *Name,
1452 Metadata *File, unsigned Line,
1453 MDString *GetterName, MDString *SetterName,
1454 unsigned Attributes, Metadata *Type,
1455 StorageType Storage, bool ShouldCreate = true);
1457 TempMDObjCProperty cloneImpl() const {
1458 return getTemporary(getContext(), getName(), getFile(), getLine(),
1459 getGetterName(), getSetterName(), getAttributes(),
1464 DEFINE_MDNODE_GET(MDObjCProperty,
1465 (StringRef Name, Metadata *File, unsigned Line,
1466 StringRef GetterName, StringRef SetterName,
1467 unsigned Attributes, Metadata *Type),
1468 (Name, File, Line, GetterName, SetterName, Attributes,
1470 DEFINE_MDNODE_GET(MDObjCProperty,
1471 (MDString * Name, Metadata *File, unsigned Line,
1472 MDString *GetterName, MDString *SetterName,
1473 unsigned Attributes, Metadata *Type),
1474 (Name, File, Line, GetterName, SetterName, Attributes,
1477 unsigned getLine() const { return Line; }
1478 unsigned getAttributes() const { return Attributes; }
1479 StringRef getName() const { return getStringOperand(0); }
1480 Metadata *getFile() const { return getOperand(1); }
1481 StringRef getGetterName() const { return getStringOperand(2); }
1482 StringRef getSetterName() const { return getStringOperand(3); }
1483 Metadata *getType() const { return getOperand(4); }
1485 static bool classof(const Metadata *MD) {
1486 return MD->getMetadataID() == MDObjCPropertyKind;
1490 class MDImportedEntity : public DebugNode {
1491 friend class LLVMContextImpl;
1492 friend class MDNode;
1496 MDImportedEntity(LLVMContext &C, StorageType Storage, unsigned Tag,
1497 unsigned Line, ArrayRef<Metadata *> Ops)
1498 : DebugNode(C, MDImportedEntityKind, Storage, Tag, Ops), Line(Line) {}
1499 ~MDImportedEntity() {}
1501 static MDImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
1502 Metadata *Scope, Metadata *Entity,
1503 unsigned Line, StringRef Name,
1504 StorageType Storage,
1505 bool ShouldCreate = true) {
1506 return getImpl(Context, Tag, Scope, Entity, Line,
1507 getCanonicalMDString(Context, Name), Storage, ShouldCreate);
1509 static MDImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
1510 Metadata *Scope, Metadata *Entity,
1511 unsigned Line, MDString *Name,
1512 StorageType Storage,
1513 bool ShouldCreate = true);
1515 TempMDImportedEntity cloneImpl() const {
1516 return getTemporary(getContext(), getTag(), getScope(), getEntity(),
1517 getLine(), getName());
1521 DEFINE_MDNODE_GET(MDImportedEntity,
1522 (unsigned Tag, Metadata *Scope, Metadata *Entity,
1523 unsigned Line, StringRef Name = ""),
1524 (Tag, Scope, Entity, Line, Name))
1525 DEFINE_MDNODE_GET(MDImportedEntity,
1526 (unsigned Tag, Metadata *Scope, Metadata *Entity,
1527 unsigned Line, MDString *Name),
1528 (Tag, Scope, Entity, Line, Name))
1530 TempMDImportedEntity clone() const { return cloneImpl(); }
1532 unsigned getLine() const { return Line; }
1533 Metadata *getScope() const { return getOperand(0); }
1534 Metadata *getEntity() const { return getOperand(1); }
1535 StringRef getName() const { return getStringOperand(2); }
1537 static bool classof(const Metadata *MD) {
1538 return MD->getMetadataID() == MDImportedEntityKind;
1542 } // end namespace llvm
1544 #undef DEFINE_MDNODE_GET_UNPACK_IMPL
1545 #undef DEFINE_MDNODE_GET_UNPACK
1546 #undef DEFINE_MDNODE_GET