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 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 {
362 unsigned AlignInBits;
363 unsigned OffsetInBits;
367 MDType(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
368 unsigned Line, unsigned SizeInBits, unsigned AlignInBits,
369 unsigned OffsetInBits, unsigned Flags, ArrayRef<Metadata *> Ops)
370 : MDScope(C, ID, Storage, Tag, Ops), Line(Line), SizeInBits(SizeInBits),
371 AlignInBits(AlignInBits), OffsetInBits(OffsetInBits), Flags(Flags) {}
375 unsigned getLine() const { return Line; }
376 unsigned getSizeInBits() const { return SizeInBits; }
377 unsigned getAlignInBits() const { return AlignInBits; }
378 unsigned getOffsetInBits() const { return OffsetInBits; }
379 unsigned getFlags() const { return Flags; }
381 Metadata *getScope() const { return getOperand(1); }
382 StringRef getName() const { return getStringOperand(2); }
384 MDString *getRawName() const { return getOperandAs<MDString>(2); }
386 static bool classof(const Metadata *MD) {
387 switch (MD->getMetadataID()) {
390 case MDBasicTypeKind:
391 case MDDerivedTypeKind:
392 case MDCompositeTypeKind:
393 case MDSubroutineTypeKind:
399 /// \brief Basic type.
401 /// TODO: Split out DW_TAG_unspecified_type.
402 /// TODO: Drop unused accessors.
403 class MDBasicType : public MDType {
404 friend class LLVMContextImpl;
409 MDBasicType(LLVMContext &C, StorageType Storage, unsigned Tag,
410 unsigned SizeInBits, unsigned AlignInBits, unsigned Encoding,
411 ArrayRef<Metadata *> Ops)
412 : MDType(C, MDBasicTypeKind, Storage, Tag, 0, SizeInBits, AlignInBits, 0,
414 Encoding(Encoding) {}
417 static MDBasicType *getImpl(LLVMContext &Context, unsigned Tag,
418 StringRef Name, unsigned SizeInBits,
419 unsigned AlignInBits, unsigned Encoding,
420 StorageType Storage, bool ShouldCreate = true) {
421 return getImpl(Context, Tag, getCanonicalMDString(Context, Name),
422 SizeInBits, AlignInBits, Encoding, Storage, ShouldCreate);
424 static MDBasicType *getImpl(LLVMContext &Context, unsigned Tag,
425 MDString *Name, unsigned SizeInBits,
426 unsigned AlignInBits, unsigned Encoding,
427 StorageType Storage, bool ShouldCreate = true);
429 TempMDBasicType cloneImpl() const {
430 return getTemporary(getContext(), getTag(), getName(), getSizeInBits(),
431 getAlignInBits(), getEncoding());
435 DEFINE_MDNODE_GET(MDBasicType,
436 (unsigned Tag, StringRef Name, unsigned SizeInBits,
437 unsigned AlignInBits, unsigned Encoding),
438 (Tag, Name, SizeInBits, AlignInBits, Encoding))
439 DEFINE_MDNODE_GET(MDBasicType,
440 (unsigned Tag, MDString *Name, unsigned SizeInBits,
441 unsigned AlignInBits, unsigned Encoding),
442 (Tag, Name, SizeInBits, AlignInBits, Encoding))
444 TempMDBasicType clone() const { return cloneImpl(); }
446 unsigned getEncoding() const { return Encoding; }
448 static bool classof(const Metadata *MD) {
449 return MD->getMetadataID() == MDBasicTypeKind;
453 /// \brief Base class for MDDerivedType and MDCompositeType.
455 /// TODO: Delete; they're not really related.
456 class MDDerivedTypeBase : public MDType {
458 MDDerivedTypeBase(LLVMContext &C, unsigned ID, StorageType Storage,
459 unsigned Tag, unsigned Line, unsigned SizeInBits,
460 unsigned AlignInBits, unsigned OffsetInBits, unsigned Flags,
461 ArrayRef<Metadata *> Ops)
462 : MDType(C, ID, Storage, Tag, Line, SizeInBits, AlignInBits, OffsetInBits,
464 ~MDDerivedTypeBase() {}
467 Metadata *getBaseType() const { return getOperand(3); }
469 static bool classof(const Metadata *MD) {
470 return MD->getMetadataID() == MDDerivedTypeKind ||
471 MD->getMetadataID() == MDCompositeTypeKind ||
472 MD->getMetadataID() == MDSubroutineTypeKind;
476 /// \brief Derived types.
478 /// This includes qualified types, pointers, references, friends, typedefs, and
481 /// TODO: Split out members (inheritance, fields, methods, etc.).
482 class MDDerivedType : public MDDerivedTypeBase {
483 friend class LLVMContextImpl;
486 MDDerivedType(LLVMContext &C, StorageType Storage, unsigned Tag,
487 unsigned Line, unsigned SizeInBits, unsigned AlignInBits,
488 unsigned OffsetInBits, unsigned Flags, ArrayRef<Metadata *> Ops)
489 : MDDerivedTypeBase(C, MDDerivedTypeKind, Storage, Tag, Line, SizeInBits,
490 AlignInBits, OffsetInBits, Flags, Ops) {}
493 static MDDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
494 StringRef Name, Metadata *File, unsigned Line,
495 Metadata *Scope, Metadata *BaseType,
496 unsigned SizeInBits, unsigned AlignInBits,
497 unsigned OffsetInBits, unsigned Flags,
498 Metadata *ExtraData, StorageType Storage,
499 bool ShouldCreate = true) {
500 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), File,
501 Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits,
502 Flags, ExtraData, Storage, ShouldCreate);
504 static MDDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
505 MDString *Name, Metadata *File, unsigned Line,
506 Metadata *Scope, Metadata *BaseType,
507 unsigned SizeInBits, unsigned AlignInBits,
508 unsigned OffsetInBits, unsigned Flags,
509 Metadata *ExtraData, StorageType Storage,
510 bool ShouldCreate = true);
512 TempMDDerivedType cloneImpl() const {
513 return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
514 getScope(), getBaseType(), getSizeInBits(),
515 getAlignInBits(), getOffsetInBits(), getFlags(),
520 DEFINE_MDNODE_GET(MDDerivedType,
521 (unsigned Tag, MDString *Name, Metadata *File,
522 unsigned Line, Metadata *Scope, Metadata *BaseType,
523 unsigned SizeInBits, unsigned AlignInBits,
524 unsigned OffsetInBits, unsigned Flags,
525 Metadata *ExtraData = nullptr),
526 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
527 AlignInBits, OffsetInBits, Flags, ExtraData))
528 DEFINE_MDNODE_GET(MDDerivedType,
529 (unsigned Tag, StringRef Name, Metadata *File,
530 unsigned Line, Metadata *Scope, Metadata *BaseType,
531 unsigned SizeInBits, unsigned AlignInBits,
532 unsigned OffsetInBits, unsigned Flags,
533 Metadata *ExtraData = nullptr),
534 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
535 AlignInBits, OffsetInBits, Flags, ExtraData))
537 TempMDDerivedType clone() const { return cloneImpl(); }
539 /// \brief Get extra data associated with this derived type.
541 /// Class type for pointer-to-members, objective-c property node for ivars,
542 /// or global constant wrapper for static members.
544 /// TODO: Separate out types that need this extra operand: pointer-to-member
545 /// types and member fields (static members and ivars).
546 Metadata *getExtraData() const { return getOperand(4); }
548 static bool classof(const Metadata *MD) {
549 return MD->getMetadataID() == MDDerivedTypeKind;
553 /// \brief Base class for MDCompositeType and MDSubroutineType.
555 /// TODO: Delete; they're not really related.
556 class MDCompositeTypeBase : public MDDerivedTypeBase {
557 unsigned RuntimeLang;
560 MDCompositeTypeBase(LLVMContext &C, unsigned ID, StorageType Storage,
561 unsigned Tag, unsigned Line, unsigned RuntimeLang,
562 unsigned SizeInBits, unsigned AlignInBits,
563 unsigned OffsetInBits, unsigned Flags,
564 ArrayRef<Metadata *> Ops)
565 : MDDerivedTypeBase(C, ID, Storage, Tag, Line, SizeInBits, AlignInBits,
566 OffsetInBits, Flags, Ops),
567 RuntimeLang(RuntimeLang) {}
568 ~MDCompositeTypeBase() {}
571 Metadata *getElements() const { return getOperand(4); }
572 Metadata *getVTableHolder() const { return getOperand(5); }
573 Metadata *getTemplateParams() const { return getOperand(6); }
574 StringRef getIdentifier() const { return getStringOperand(7); }
575 unsigned getRuntimeLang() const { return RuntimeLang; }
577 MDString *getRawIdentifier() const { return getOperandAs<MDString>(7); }
579 static bool classof(const Metadata *MD) {
580 return MD->getMetadataID() == MDCompositeTypeKind ||
581 MD->getMetadataID() == MDSubroutineTypeKind;
585 /// \brief Composite types.
587 /// TODO: Detach from DerivedTypeBase (split out MDEnumType?).
588 /// TODO: Create a custom, unrelated node for DW_TAG_array_type.
589 class MDCompositeType : public MDCompositeTypeBase {
590 friend class LLVMContextImpl;
593 MDCompositeType(LLVMContext &C, StorageType Storage, unsigned Tag,
594 unsigned Line, unsigned RuntimeLang, unsigned SizeInBits,
595 unsigned AlignInBits, unsigned OffsetInBits, unsigned Flags,
596 ArrayRef<Metadata *> Ops)
597 : MDCompositeTypeBase(C, MDCompositeTypeKind, Storage, Tag, Line,
598 RuntimeLang, SizeInBits, AlignInBits, OffsetInBits,
600 ~MDCompositeType() {}
602 static MDCompositeType *
603 getImpl(LLVMContext &Context, unsigned Tag, StringRef Name, Metadata *File,
604 unsigned Line, Metadata *Scope, Metadata *BaseType,
605 unsigned SizeInBits, unsigned AlignInBits, unsigned OffsetInBits,
606 unsigned Flags, Metadata *Elements, unsigned RuntimeLang,
607 Metadata *VTableHolder, Metadata *TemplateParams,
608 StringRef Identifier, StorageType Storage, bool ShouldCreate = true) {
609 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), File,
610 Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits,
611 Flags, Elements, RuntimeLang, VTableHolder, TemplateParams,
612 getCanonicalMDString(Context, Identifier), Storage,
615 static MDCompositeType *
616 getImpl(LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
617 unsigned Line, Metadata *Scope, Metadata *BaseType,
618 unsigned SizeInBits, unsigned AlignInBits, unsigned OffsetInBits,
619 unsigned Flags, Metadata *Elements, unsigned RuntimeLang,
620 Metadata *VTableHolder, Metadata *TemplateParams,
621 MDString *Identifier, StorageType Storage, bool ShouldCreate = true);
623 TempMDCompositeType cloneImpl() const {
624 return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
625 getScope(), getBaseType(), getSizeInBits(),
626 getAlignInBits(), getOffsetInBits(), getFlags(),
627 getElements(), getRuntimeLang(), getVTableHolder(),
628 getTemplateParams(), getIdentifier());
632 DEFINE_MDNODE_GET(MDCompositeType,
633 (unsigned Tag, StringRef Name, Metadata *File,
634 unsigned Line, Metadata *Scope, Metadata *BaseType,
635 unsigned SizeInBits, unsigned AlignInBits,
636 unsigned OffsetInBits, unsigned Flags, Metadata *Elements,
637 unsigned RuntimeLang, Metadata *VTableHolder,
638 Metadata *TemplateParams = nullptr,
639 StringRef Identifier = ""),
640 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
641 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
642 VTableHolder, TemplateParams, Identifier))
643 DEFINE_MDNODE_GET(MDCompositeType,
644 (unsigned Tag, MDString *Name, Metadata *File,
645 unsigned Line, Metadata *Scope, Metadata *BaseType,
646 unsigned SizeInBits, unsigned AlignInBits,
647 unsigned OffsetInBits, unsigned Flags, Metadata *Elements,
648 unsigned RuntimeLang, Metadata *VTableHolder,
649 Metadata *TemplateParams = nullptr,
650 MDString *Identifier = nullptr),
651 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
652 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
653 VTableHolder, TemplateParams, Identifier))
655 TempMDCompositeType clone() const { return cloneImpl(); }
657 static bool classof(const Metadata *MD) {
658 return MD->getMetadataID() == MDCompositeTypeKind;
662 /// \brief Type array for a subprogram.
664 /// TODO: Detach from CompositeType, and fold the array of types in directly
666 class MDSubroutineType : public MDCompositeTypeBase {
667 friend class LLVMContextImpl;
670 MDSubroutineType(LLVMContext &C, StorageType Storage, unsigned Flags,
671 ArrayRef<Metadata *> Ops)
672 : MDCompositeTypeBase(C, MDSubroutineTypeKind, Storage,
673 dwarf::DW_TAG_subroutine_type, 0, 0, 0, 0, 0, Flags,
675 ~MDSubroutineType() {}
677 static MDSubroutineType *getImpl(LLVMContext &Context, unsigned Flags,
678 Metadata *TypeArray, StorageType Storage,
679 bool ShouldCreate = true);
681 TempMDSubroutineType cloneImpl() const {
682 return getTemporary(getContext(), getFlags(), getTypeArray());
686 DEFINE_MDNODE_GET(MDSubroutineType, (unsigned Flags, Metadata *TypeArray),
689 TempMDSubroutineType clone() const { return cloneImpl(); }
691 Metadata *getTypeArray() const { return getElements(); }
693 static bool classof(const Metadata *MD) {
694 return MD->getMetadataID() == MDSubroutineTypeKind;
700 /// TODO: Merge with directory/file node (including users).
701 /// TODO: Canonicalize paths on creation.
702 class MDFile : public MDScope {
703 friend class LLVMContextImpl;
706 MDFile(LLVMContext &C, StorageType Storage, ArrayRef<Metadata *> Ops)
707 : MDScope(C, MDFileKind, Storage, dwarf::DW_TAG_file_type, Ops) {}
710 static MDFile *getImpl(LLVMContext &Context, StringRef Filename,
711 StringRef Directory, StorageType Storage,
712 bool ShouldCreate = true) {
713 return getImpl(Context, getCanonicalMDString(Context, Filename),
714 getCanonicalMDString(Context, Directory), Storage,
717 static MDFile *getImpl(LLVMContext &Context, MDString *Filename,
718 MDString *Directory, StorageType Storage,
719 bool ShouldCreate = true);
721 TempMDFile cloneImpl() const {
722 return getTemporary(getContext(), getFilename(), getDirectory());
726 DEFINE_MDNODE_GET(MDFile, (StringRef Filename, StringRef Directory),
727 (Filename, Directory))
728 DEFINE_MDNODE_GET(MDFile, (MDString * Filename, MDString *Directory),
729 (Filename, Directory))
731 TempMDFile clone() const { return cloneImpl(); }
733 MDTuple *getFileNode() const { return cast<MDTuple>(getOperand(0)); }
735 StringRef getFilename() const {
736 if (auto *S = cast_or_null<MDString>(getFileNode()->getOperand(0)))
737 return S->getString();
740 StringRef getDirectory() const {
741 if (auto *S = cast_or_null<MDString>(getFileNode()->getOperand(1)))
742 return S->getString();
746 static bool classof(const Metadata *MD) {
747 return MD->getMetadataID() == MDFileKind;
751 /// \brief Compile unit.
752 class MDCompileUnit : public MDScope {
753 friend class LLVMContextImpl;
756 unsigned SourceLanguage;
758 unsigned RuntimeVersion;
759 unsigned EmissionKind;
761 MDCompileUnit(LLVMContext &C, StorageType Storage, unsigned SourceLanguage,
762 bool IsOptimized, unsigned RuntimeVersion,
763 unsigned EmissionKind, ArrayRef<Metadata *> Ops)
764 : MDScope(C, MDCompileUnitKind, Storage, dwarf::DW_TAG_compile_unit, Ops),
765 SourceLanguage(SourceLanguage), IsOptimized(IsOptimized),
766 RuntimeVersion(RuntimeVersion), EmissionKind(EmissionKind) {}
769 static MDCompileUnit *
770 getImpl(LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
771 StringRef Producer, bool IsOptimized, StringRef Flags,
772 unsigned RuntimeVersion, StringRef SplitDebugFilename,
773 unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
774 Metadata *Subprograms, Metadata *GlobalVariables,
775 Metadata *ImportedEntities, StorageType Storage,
776 bool ShouldCreate = true) {
777 return getImpl(Context, SourceLanguage, File,
778 getCanonicalMDString(Context, Producer), IsOptimized,
779 getCanonicalMDString(Context, Flags), RuntimeVersion,
780 getCanonicalMDString(Context, SplitDebugFilename),
781 EmissionKind, EnumTypes, RetainedTypes, Subprograms,
782 GlobalVariables, ImportedEntities, Storage, ShouldCreate);
784 static MDCompileUnit *
785 getImpl(LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
786 MDString *Producer, bool IsOptimized, MDString *Flags,
787 unsigned RuntimeVersion, MDString *SplitDebugFilename,
788 unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
789 Metadata *Subprograms, Metadata *GlobalVariables,
790 Metadata *ImportedEntities, StorageType Storage,
791 bool ShouldCreate = true);
793 TempMDCompileUnit cloneImpl() const {
795 getContext(), getSourceLanguage(), getFile(), getProducer(),
796 isOptimized(), getFlags(), getRuntimeVersion(), getSplitDebugFilename(),
797 getEmissionKind(), getEnumTypes(), getRetainedTypes(), getSubprograms(),
798 getGlobalVariables(), getImportedEntities());
802 DEFINE_MDNODE_GET(MDCompileUnit,
803 (unsigned SourceLanguage, Metadata *File,
804 StringRef Producer, bool IsOptimized, StringRef Flags,
805 unsigned RuntimeVersion, StringRef SplitDebugFilename,
806 unsigned EmissionKind, Metadata *EnumTypes,
807 Metadata *RetainedTypes, Metadata *Subprograms,
808 Metadata *GlobalVariables, Metadata *ImportedEntities),
809 (SourceLanguage, File, Producer, IsOptimized, Flags,
810 RuntimeVersion, SplitDebugFilename, EmissionKind,
811 EnumTypes, RetainedTypes, Subprograms, GlobalVariables,
813 DEFINE_MDNODE_GET(MDCompileUnit,
814 (unsigned SourceLanguage, Metadata *File,
815 MDString *Producer, bool IsOptimized, MDString *Flags,
816 unsigned RuntimeVersion, MDString *SplitDebugFilename,
817 unsigned EmissionKind, Metadata *EnumTypes,
818 Metadata *RetainedTypes, Metadata *Subprograms,
819 Metadata *GlobalVariables, Metadata *ImportedEntities),
820 (SourceLanguage, File, Producer, IsOptimized, Flags,
821 RuntimeVersion, SplitDebugFilename, EmissionKind,
822 EnumTypes, RetainedTypes, Subprograms, GlobalVariables,
825 TempMDCompileUnit clone() const { return cloneImpl(); }
827 unsigned getSourceLanguage() const { return SourceLanguage; }
828 bool isOptimized() const { return IsOptimized; }
829 unsigned getRuntimeVersion() const { return RuntimeVersion; }
830 unsigned getEmissionKind() const { return EmissionKind; }
831 StringRef getProducer() const { return getStringOperand(1); }
832 StringRef getFlags() const { return getStringOperand(2); }
833 StringRef getSplitDebugFilename() const { return getStringOperand(3); }
834 Metadata *getEnumTypes() const { return getOperand(4); }
835 Metadata *getRetainedTypes() const { return getOperand(5); }
836 Metadata *getSubprograms() const { return getOperand(6); }
837 Metadata *getGlobalVariables() const { return getOperand(7); }
838 Metadata *getImportedEntities() const { return getOperand(8); }
840 static bool classof(const Metadata *MD) {
841 return MD->getMetadataID() == MDCompileUnitKind;
845 /// \brief Subprogram description.
847 /// TODO: Remove DisplayName. It's always equal to Name.
848 /// TODO: Split up flags.
849 class MDSubprogram : public MDScope {
850 friend class LLVMContextImpl;
856 unsigned VirtualIndex;
862 MDSubprogram(LLVMContext &C, StorageType Storage, unsigned Line,
863 unsigned ScopeLine, unsigned Virtuality, unsigned VirtualIndex,
864 unsigned Flags, bool IsLocalToUnit, bool IsDefinition,
865 bool IsOptimized, ArrayRef<Metadata *> Ops)
866 : MDScope(C, MDSubprogramKind, Storage, dwarf::DW_TAG_subprogram, Ops),
867 Line(Line), ScopeLine(ScopeLine), Virtuality(Virtuality),
868 VirtualIndex(VirtualIndex), Flags(Flags), IsLocalToUnit(IsLocalToUnit),
869 IsDefinition(IsDefinition), IsOptimized(IsOptimized) {}
872 static MDSubprogram *
873 getImpl(LLVMContext &Context, Metadata *Scope, StringRef Name,
874 StringRef LinkageName, Metadata *File, unsigned Line, Metadata *Type,
875 bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
876 Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex,
877 unsigned Flags, bool IsOptimized, Metadata *Function,
878 Metadata *TemplateParams, Metadata *Declaration, Metadata *Variables,
879 StorageType Storage, bool ShouldCreate = true) {
880 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
881 getCanonicalMDString(Context, LinkageName), File, Line, Type,
882 IsLocalToUnit, IsDefinition, ScopeLine, ContainingType,
883 Virtuality, VirtualIndex, Flags, IsOptimized, Function,
884 TemplateParams, Declaration, Variables, Storage,
887 static MDSubprogram *
888 getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
889 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
890 bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
891 Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex,
892 unsigned Flags, bool IsOptimized, Metadata *Function,
893 Metadata *TemplateParams, Metadata *Declaration, Metadata *Variables,
894 StorageType Storage, bool ShouldCreate = true);
896 TempMDSubprogram cloneImpl() const {
897 return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
898 getFile(), getLine(), getType(), isLocalToUnit(),
899 isDefinition(), getScopeLine(), getContainingType(),
900 getVirtuality(), getVirtualIndex(), getFlags(),
901 isOptimized(), getFunction(), getTemplateParams(),
902 getDeclaration(), getVariables());
908 (Metadata * Scope, StringRef Name, StringRef LinkageName, Metadata *File,
909 unsigned Line, Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
910 unsigned ScopeLine, Metadata *ContainingType, unsigned Virtuality,
911 unsigned VirtualIndex, unsigned Flags, bool IsOptimized,
912 Metadata *Function = nullptr, Metadata *TemplateParams = nullptr,
913 Metadata *Declaration = nullptr, Metadata *Variables = nullptr),
914 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition,
915 ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags, IsOptimized,
916 Function, TemplateParams, Declaration, Variables))
919 (Metadata * Scope, MDString *Name, MDString *LinkageName, Metadata *File,
920 unsigned Line, Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
921 unsigned ScopeLine, Metadata *ContainingType, unsigned Virtuality,
922 unsigned VirtualIndex, unsigned Flags, bool IsOptimized,
923 Metadata *Function = nullptr, Metadata *TemplateParams = nullptr,
924 Metadata *Declaration = nullptr, Metadata *Variables = nullptr),
925 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition,
926 ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags, IsOptimized,
927 Function, TemplateParams, Declaration, Variables))
929 TempMDSubprogram clone() const { return cloneImpl(); }
932 unsigned getLine() const { return Line; }
933 unsigned getVirtuality() const { return Virtuality; }
934 unsigned getVirtualIndex() const { return VirtualIndex; }
935 unsigned getScopeLine() const { return ScopeLine; }
936 unsigned getFlags() const { return Flags; }
937 bool isLocalToUnit() const { return IsLocalToUnit; }
938 bool isDefinition() const { return IsDefinition; }
939 bool isOptimized() const { return IsOptimized; }
941 Metadata *getScope() const { return getOperand(1); }
943 StringRef getName() const { return getStringOperand(2); }
944 StringRef getDisplayName() const { return getStringOperand(3); }
945 StringRef getLinkageName() const { return getStringOperand(4); }
947 Metadata *getType() const { return getOperand(5); }
948 Metadata *getContainingType() const { return getOperand(6); }
950 Metadata *getFunction() const { return getOperand(7); }
951 Metadata *getTemplateParams() const { return getOperand(8); }
952 Metadata *getDeclaration() const { return getOperand(9); }
953 Metadata *getVariables() const { return getOperand(10); }
955 static bool classof(const Metadata *MD) {
956 return MD->getMetadataID() == MDSubprogramKind;
960 class MDLexicalBlockBase : public MDScope {
962 MDLexicalBlockBase(LLVMContext &C, unsigned ID, StorageType Storage,
963 ArrayRef<Metadata *> Ops)
964 : MDScope(C, ID, Storage, dwarf::DW_TAG_lexical_block, Ops) {}
965 ~MDLexicalBlockBase() {}
968 Metadata *getScope() const { return getOperand(1); }
970 static bool classof(const Metadata *MD) {
971 return MD->getMetadataID() == MDLexicalBlockKind ||
972 MD->getMetadataID() == MDLexicalBlockFileKind;
976 class MDLexicalBlock : public MDLexicalBlockBase {
977 friend class LLVMContextImpl;
983 MDLexicalBlock(LLVMContext &C, StorageType Storage, unsigned Line,
984 unsigned Column, ArrayRef<Metadata *> Ops)
985 : MDLexicalBlockBase(C, MDLexicalBlockKind, Storage, Ops), Line(Line),
989 static MDLexicalBlock *getImpl(LLVMContext &Context, Metadata *Scope,
990 Metadata *File, unsigned Line, unsigned Column,
991 StorageType Storage, bool ShouldCreate = true);
993 TempMDLexicalBlock cloneImpl() const {
994 return getTemporary(getContext(), getScope(), getFile(), getLine(),
999 DEFINE_MDNODE_GET(MDLexicalBlock, (Metadata * Scope, Metadata *File,
1000 unsigned Line, unsigned Column),
1001 (Scope, File, Line, Column))
1003 TempMDLexicalBlock clone() const { return cloneImpl(); }
1005 unsigned getLine() const { return Line; }
1006 unsigned getColumn() const { return Column; }
1008 static bool classof(const Metadata *MD) {
1009 return MD->getMetadataID() == MDLexicalBlockKind;
1013 class MDLexicalBlockFile : public MDLexicalBlockBase {
1014 friend class LLVMContextImpl;
1015 friend class MDNode;
1017 unsigned Discriminator;
1019 MDLexicalBlockFile(LLVMContext &C, StorageType Storage,
1020 unsigned Discriminator, ArrayRef<Metadata *> Ops)
1021 : MDLexicalBlockBase(C, MDLexicalBlockFileKind, Storage, Ops),
1022 Discriminator(Discriminator) {}
1023 ~MDLexicalBlockFile() {}
1025 static MDLexicalBlockFile *getImpl(LLVMContext &Context, Metadata *Scope,
1026 Metadata *File, unsigned Discriminator,
1027 StorageType Storage,
1028 bool ShouldCreate = true);
1030 TempMDLexicalBlockFile cloneImpl() const {
1031 return getTemporary(getContext(), getScope(), getFile(),
1032 getDiscriminator());
1036 DEFINE_MDNODE_GET(MDLexicalBlockFile,
1037 (Metadata * Scope, Metadata *File, unsigned Discriminator),
1038 (Scope, File, Discriminator))
1040 TempMDLexicalBlockFile clone() const { return cloneImpl(); }
1042 unsigned getDiscriminator() const { return Discriminator; }
1044 static bool classof(const Metadata *MD) {
1045 return MD->getMetadataID() == MDLexicalBlockFileKind;
1049 class MDNamespace : public MDScope {
1050 friend class LLVMContextImpl;
1051 friend class MDNode;
1055 MDNamespace(LLVMContext &Context, StorageType Storage, unsigned Line,
1056 ArrayRef<Metadata *> Ops)
1057 : MDScope(Context, MDNamespaceKind, Storage, dwarf::DW_TAG_namespace,
1062 static MDNamespace *getImpl(LLVMContext &Context, Metadata *Scope,
1063 Metadata *File, StringRef Name, unsigned Line,
1064 StorageType Storage, bool ShouldCreate = true) {
1065 return getImpl(Context, Scope, File, getCanonicalMDString(Context, Name),
1066 Line, Storage, ShouldCreate);
1068 static MDNamespace *getImpl(LLVMContext &Context, Metadata *Scope,
1069 Metadata *File, MDString *Name, unsigned Line,
1070 StorageType Storage, bool ShouldCreate = true);
1072 TempMDNamespace cloneImpl() const {
1073 return getTemporary(getContext(), getScope(), getFile(), getName(),
1078 DEFINE_MDNODE_GET(MDNamespace, (Metadata * Scope, Metadata *File,
1079 StringRef Name, unsigned Line),
1080 (Scope, File, Name, Line))
1081 DEFINE_MDNODE_GET(MDNamespace, (Metadata * Scope, Metadata *File,
1082 MDString *Name, unsigned Line),
1083 (Scope, File, Name, Line))
1085 TempMDNamespace clone() const { return cloneImpl(); }
1087 unsigned getLine() const { return Line; }
1088 Metadata *getScope() const { return getOperand(1); }
1089 StringRef getName() const { return getStringOperand(2); }
1091 static bool classof(const Metadata *MD) {
1092 return MD->getMetadataID() == MDNamespaceKind;
1096 /// \brief Base class for template parameters.
1098 /// TODO: Remove the scope. It's always the compile unit, and never
1100 /// TODO: Remove File, Line and Column. They're always 0 and never
1102 class MDTemplateParameter : public DebugNode {
1104 MDTemplateParameter(LLVMContext &Context, unsigned ID, StorageType Storage,
1105 unsigned Tag, ArrayRef<Metadata *> Ops)
1106 : DebugNode(Context, ID, Storage, Tag, Ops) {}
1107 ~MDTemplateParameter() {}
1110 Metadata *getScope() const { return getOperand(0); }
1111 StringRef getName() const { return getStringOperand(1); }
1112 Metadata *getType() const { return getOperand(2); }
1114 static bool classof(const Metadata *MD) {
1115 return MD->getMetadataID() == MDTemplateTypeParameterKind ||
1116 MD->getMetadataID() == MDTemplateValueParameterKind;
1120 class MDTemplateTypeParameter : public MDTemplateParameter {
1121 friend class LLVMContextImpl;
1122 friend class MDNode;
1124 MDTemplateTypeParameter(LLVMContext &Context, StorageType Storage,
1125 ArrayRef<Metadata *> Ops)
1126 : MDTemplateParameter(Context, MDTemplateTypeParameterKind, Storage,
1127 dwarf::DW_TAG_template_type_parameter, Ops) {}
1128 ~MDTemplateTypeParameter() {}
1130 static MDTemplateTypeParameter *getImpl(LLVMContext &Context, Metadata *Scope,
1131 StringRef Name, Metadata *Type,
1132 StorageType Storage,
1133 bool ShouldCreate = true) {
1134 return getImpl(Context, Scope, getCanonicalMDString(Context, Name), Type,
1135 Storage, ShouldCreate);
1137 static MDTemplateTypeParameter *getImpl(LLVMContext &Context, Metadata *Scope,
1138 MDString *Name, Metadata *Type,
1139 StorageType Storage,
1140 bool ShouldCreate = true);
1142 TempMDTemplateTypeParameter cloneImpl() const {
1143 return getTemporary(getContext(), getScope(), getName(), getType());
1147 DEFINE_MDNODE_GET(MDTemplateTypeParameter,
1148 (Metadata * Scope, StringRef Name, Metadata *Type),
1149 (Scope, Name, Type))
1150 DEFINE_MDNODE_GET(MDTemplateTypeParameter,
1151 (Metadata * Scope, MDString *Name, Metadata *Type),
1152 (Scope, Name, Type))
1154 TempMDTemplateTypeParameter clone() const { return cloneImpl(); }
1156 static bool classof(const Metadata *MD) {
1157 return MD->getMetadataID() == MDTemplateTypeParameterKind;
1161 class MDTemplateValueParameter : public MDTemplateParameter {
1162 friend class LLVMContextImpl;
1163 friend class MDNode;
1165 MDTemplateValueParameter(LLVMContext &Context, StorageType Storage,
1166 unsigned Tag, ArrayRef<Metadata *> Ops)
1167 : MDTemplateParameter(Context, MDTemplateValueParameterKind, Storage, Tag,
1169 ~MDTemplateValueParameter() {}
1171 static MDTemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
1172 Metadata *Scope, StringRef Name,
1173 Metadata *Type, Metadata *Value,
1174 StorageType Storage,
1175 bool ShouldCreate = true) {
1176 return getImpl(Context, Tag, Scope, getCanonicalMDString(Context, Name),
1177 Type, Value, Storage, ShouldCreate);
1179 static MDTemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
1180 Metadata *Scope, MDString *Name,
1181 Metadata *Type, Metadata *Value,
1182 StorageType Storage,
1183 bool ShouldCreate = true);
1185 TempMDTemplateValueParameter cloneImpl() const {
1186 return getTemporary(getContext(), getTag(), getScope(), getName(),
1187 getType(), getValue());
1191 DEFINE_MDNODE_GET(MDTemplateValueParameter,
1192 (unsigned Tag, Metadata *Scope, StringRef Name,
1193 Metadata *Type, Metadata *Value),
1194 (Tag, Scope, Name, Type, Value))
1195 DEFINE_MDNODE_GET(MDTemplateValueParameter,
1196 (unsigned Tag, Metadata *Scope, MDString *Name,
1197 Metadata *Type, Metadata *Value),
1198 (Tag, Scope, Name, Type, Value))
1200 Metadata *getValue() const { return getOperand(3); }
1202 static bool classof(const Metadata *MD) {
1203 return MD->getMetadataID() == MDTemplateValueParameterKind;
1207 /// \brief Base class for variables.
1209 /// TODO: Hardcode to DW_TAG_variable.
1210 class MDVariable : public DebugNode {
1214 MDVariable(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
1215 unsigned Line, ArrayRef<Metadata *> Ops)
1216 : DebugNode(C, ID, Storage, Tag, Ops), Line(Line) {}
1220 unsigned getLine() const { return Line; }
1221 Metadata *getScope() const { return getOperand(0); }
1222 StringRef getName() const { return getStringOperand(1); }
1223 Metadata *getFile() const { return getOperand(2); }
1224 Metadata *getType() const { return getOperand(3); }
1226 static bool classof(const Metadata *MD) {
1227 return MD->getMetadataID() == MDLocalVariableKind ||
1228 MD->getMetadataID() == MDGlobalVariableKind;
1232 /// \brief Global variables.
1234 /// TODO: Remove DisplayName. It's always equal to Name.
1235 class MDGlobalVariable : public MDVariable {
1236 friend class LLVMContextImpl;
1237 friend class MDNode;
1242 MDGlobalVariable(LLVMContext &C, StorageType Storage, unsigned Line,
1243 bool IsLocalToUnit, bool IsDefinition,
1244 ArrayRef<Metadata *> Ops)
1245 : MDVariable(C, MDGlobalVariableKind, Storage, dwarf::DW_TAG_variable,
1247 IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition) {}
1248 ~MDGlobalVariable() {}
1250 static MDGlobalVariable *
1251 getImpl(LLVMContext &Context, Metadata *Scope, StringRef Name,
1252 StringRef LinkageName, Metadata *File, unsigned Line, Metadata *Type,
1253 bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
1254 Metadata *StaticDataMemberDeclaration, StorageType Storage,
1255 bool ShouldCreate = true) {
1256 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
1257 getCanonicalMDString(Context, LinkageName), File, Line, Type,
1258 IsLocalToUnit, IsDefinition, Variable,
1259 StaticDataMemberDeclaration, Storage, ShouldCreate);
1261 static MDGlobalVariable *
1262 getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
1263 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
1264 bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
1265 Metadata *StaticDataMemberDeclaration, StorageType Storage,
1266 bool ShouldCreate = true);
1268 TempMDGlobalVariable cloneImpl() const {
1269 return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
1270 getFile(), getLine(), getType(), isLocalToUnit(),
1271 isDefinition(), getVariable(),
1272 getStaticDataMemberDeclaration());
1276 DEFINE_MDNODE_GET(MDGlobalVariable,
1277 (Metadata * Scope, StringRef Name, StringRef LinkageName,
1278 Metadata *File, unsigned Line, Metadata *Type,
1279 bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
1280 Metadata *StaticDataMemberDeclaration),
1281 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
1282 IsDefinition, Variable, StaticDataMemberDeclaration))
1283 DEFINE_MDNODE_GET(MDGlobalVariable,
1284 (Metadata * Scope, MDString *Name, MDString *LinkageName,
1285 Metadata *File, unsigned Line, Metadata *Type,
1286 bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
1287 Metadata *StaticDataMemberDeclaration),
1288 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
1289 IsDefinition, Variable, StaticDataMemberDeclaration))
1291 bool isLocalToUnit() const { return IsLocalToUnit; }
1292 bool isDefinition() const { return IsDefinition; }
1293 StringRef getDisplayName() const { return getStringOperand(4); }
1294 StringRef getLinkageName() const { return getStringOperand(5); }
1295 Metadata *getVariable() const { return getOperand(6); }
1296 Metadata *getStaticDataMemberDeclaration() const { return getOperand(7); }
1298 static bool classof(const Metadata *MD) {
1299 return MD->getMetadataID() == MDGlobalVariableKind;
1303 /// \brief Local variable.
1305 /// TODO: Split between arguments and otherwise.
1306 /// TODO: Use \c DW_TAG_variable instead of fake tags.
1307 /// TODO: Split up flags.
1308 class MDLocalVariable : public MDVariable {
1309 friend class LLVMContextImpl;
1310 friend class MDNode;
1315 MDLocalVariable(LLVMContext &C, StorageType Storage, unsigned Tag,
1316 unsigned Line, unsigned Arg, unsigned Flags,
1317 ArrayRef<Metadata *> Ops)
1318 : MDVariable(C, MDLocalVariableKind, Storage, Tag, Line, Ops), Arg(Arg),
1320 ~MDLocalVariable() {}
1322 static MDLocalVariable *getImpl(LLVMContext &Context, unsigned Tag,
1323 Metadata *Scope, StringRef Name,
1324 Metadata *File, unsigned Line, Metadata *Type,
1325 unsigned Arg, unsigned Flags,
1326 Metadata *InlinedAt, StorageType Storage,
1327 bool ShouldCreate = true) {
1328 return getImpl(Context, Tag, Scope, getCanonicalMDString(Context, Name),
1329 File, Line, Type, Arg, Flags, InlinedAt, Storage,
1332 static MDLocalVariable *getImpl(LLVMContext &Context, unsigned Tag,
1333 Metadata *Scope, MDString *Name,
1334 Metadata *File, unsigned Line, Metadata *Type,
1335 unsigned Arg, unsigned Flags,
1336 Metadata *InlinedAt, StorageType Storage,
1337 bool ShouldCreate = true);
1339 TempMDLocalVariable cloneImpl() const {
1340 return getTemporary(getContext(), getTag(), getScope(), getName(),
1341 getFile(), getLine(), getType(), getArg(), getFlags(),
1346 DEFINE_MDNODE_GET(MDLocalVariable,
1347 (unsigned Tag, Metadata *Scope, StringRef Name,
1348 Metadata *File, unsigned Line, Metadata *Type,
1349 unsigned Arg, unsigned Flags,
1350 Metadata *InlinedAt = nullptr),
1351 (Tag, Scope, Name, File, Line, Type, Arg, Flags, InlinedAt))
1352 DEFINE_MDNODE_GET(MDLocalVariable,
1353 (unsigned Tag, Metadata *Scope, MDString *Name,
1354 Metadata *File, unsigned Line, Metadata *Type,
1355 unsigned Arg, unsigned Flags,
1356 Metadata *InlinedAt = nullptr),
1357 (Tag, Scope, Name, File, Line, Type, Arg, Flags, InlinedAt))
1359 unsigned getArg() const { return Arg; }
1360 unsigned getFlags() const { return Flags; }
1361 Metadata *getInlinedAt() const { return getOperand(4); }
1363 static bool classof(const Metadata *MD) {
1364 return MD->getMetadataID() == MDLocalVariableKind;
1368 /// \brief DWARF expression.
1370 /// TODO: Co-allocate the expression elements.
1371 /// TODO: Drop fake DW_TAG_expression and separate from DebugNode.
1372 /// TODO: Separate from MDNode, or otherwise drop Distinct and Temporary
1374 class MDExpression : public DebugNode {
1375 friend class LLVMContextImpl;
1376 friend class MDNode;
1378 std::vector<uint64_t> Elements;
1380 MDExpression(LLVMContext &C, StorageType Storage, ArrayRef<uint64_t> Elements)
1381 : DebugNode(C, MDExpressionKind, Storage, dwarf::DW_TAG_expression, None),
1382 Elements(Elements.begin(), Elements.end()) {}
1385 static MDExpression *getImpl(LLVMContext &Context,
1386 ArrayRef<uint64_t> Elements, StorageType Storage,
1387 bool ShouldCreate = true);
1389 TempMDExpression cloneImpl() const {
1390 return getTemporary(getContext(), getElements());
1394 DEFINE_MDNODE_GET(MDExpression, (ArrayRef<uint64_t> Elements), (Elements))
1396 ArrayRef<uint64_t> getElements() const { return Elements; }
1398 unsigned getNumElements() const { return Elements.size(); }
1399 uint64_t getElement(unsigned I) const {
1400 assert(I < Elements.size() && "Index out of range");
1404 typedef ArrayRef<uint64_t>::iterator element_iterator;
1405 element_iterator elements_begin() const { return getElements().begin(); }
1406 element_iterator elements_end() const { return getElements().end(); }
1408 /// \brief A lightweight wrapper around an expression operand.
1410 /// TODO: Store arguments directly and change \a MDExpression to store a
1416 explicit ExprOperand(const uint64_t *Op) : Op(Op) {}
1418 const uint64_t *get() const { return Op; }
1420 /// \brief Get the operand code.
1421 uint64_t getOp() const { return *Op; }
1423 /// \brief Get an argument to the operand.
1425 /// Never returns the operand itself.
1426 uint64_t getArg(unsigned I) const { return Op[I + 1]; }
1428 unsigned getNumArgs() const { return getSize() - 1; }
1430 /// \brief Return the size of the operand.
1432 /// Return the number of elements in the operand (1 + args).
1433 unsigned getSize() const;
1436 /// \brief An iterator for expression operands.
1437 class expr_op_iterator
1438 : public std::iterator<std::input_iterator_tag, ExprOperand> {
1442 explicit expr_op_iterator(element_iterator I) : Op(I) {}
1444 element_iterator getBase() const { return Op.get(); }
1445 const ExprOperand &operator*() const { return Op; }
1446 const ExprOperand *operator->() const { return &Op; }
1448 expr_op_iterator &operator++() {
1452 expr_op_iterator operator++(int) {
1453 expr_op_iterator T(*this);
1458 bool operator==(const expr_op_iterator &X) const {
1459 return getBase() == X.getBase();
1461 bool operator!=(const expr_op_iterator &X) const {
1462 return getBase() != X.getBase();
1466 void increment() { Op = ExprOperand(getBase() + Op.getSize()); }
1469 /// \brief Visit the elements via ExprOperand wrappers.
1471 /// These range iterators visit elements through \a ExprOperand wrappers.
1472 /// This is not guaranteed to be a valid range unless \a isValid() gives \c
1475 /// \pre \a isValid() gives \c true.
1477 expr_op_iterator expr_op_begin() const {
1478 return expr_op_iterator(elements_begin());
1480 expr_op_iterator expr_op_end() const {
1481 return expr_op_iterator(elements_end());
1485 bool isValid() const;
1487 static bool classof(const Metadata *MD) {
1488 return MD->getMetadataID() == MDExpressionKind;
1492 class MDObjCProperty : public DebugNode {
1493 friend class LLVMContextImpl;
1494 friend class MDNode;
1497 unsigned Attributes;
1499 MDObjCProperty(LLVMContext &C, StorageType Storage, unsigned Line,
1500 unsigned Attributes, ArrayRef<Metadata *> Ops)
1501 : DebugNode(C, MDObjCPropertyKind, Storage, dwarf::DW_TAG_APPLE_property,
1503 Line(Line), Attributes(Attributes) {}
1504 ~MDObjCProperty() {}
1506 static MDObjCProperty *
1507 getImpl(LLVMContext &Context, StringRef Name, Metadata *File, unsigned Line,
1508 StringRef GetterName, StringRef SetterName, unsigned Attributes,
1509 Metadata *Type, StorageType Storage, bool ShouldCreate = true) {
1510 return getImpl(Context, getCanonicalMDString(Context, Name), File, Line,
1511 getCanonicalMDString(Context, GetterName),
1512 getCanonicalMDString(Context, SetterName), Attributes, Type,
1513 Storage, ShouldCreate);
1515 static MDObjCProperty *getImpl(LLVMContext &Context, MDString *Name,
1516 Metadata *File, unsigned Line,
1517 MDString *GetterName, MDString *SetterName,
1518 unsigned Attributes, Metadata *Type,
1519 StorageType Storage, bool ShouldCreate = true);
1521 TempMDObjCProperty cloneImpl() const {
1522 return getTemporary(getContext(), getName(), getFile(), getLine(),
1523 getGetterName(), getSetterName(), getAttributes(),
1528 DEFINE_MDNODE_GET(MDObjCProperty,
1529 (StringRef Name, Metadata *File, unsigned Line,
1530 StringRef GetterName, StringRef SetterName,
1531 unsigned Attributes, Metadata *Type),
1532 (Name, File, Line, GetterName, SetterName, Attributes,
1534 DEFINE_MDNODE_GET(MDObjCProperty,
1535 (MDString * Name, Metadata *File, unsigned Line,
1536 MDString *GetterName, MDString *SetterName,
1537 unsigned Attributes, Metadata *Type),
1538 (Name, File, Line, GetterName, SetterName, Attributes,
1541 unsigned getLine() const { return Line; }
1542 unsigned getAttributes() const { return Attributes; }
1543 StringRef getName() const { return getStringOperand(0); }
1544 Metadata *getFile() const { return getOperand(1); }
1545 StringRef getGetterName() const { return getStringOperand(2); }
1546 StringRef getSetterName() const { return getStringOperand(3); }
1547 Metadata *getType() const { return getOperand(4); }
1549 static bool classof(const Metadata *MD) {
1550 return MD->getMetadataID() == MDObjCPropertyKind;
1554 class MDImportedEntity : public DebugNode {
1555 friend class LLVMContextImpl;
1556 friend class MDNode;
1560 MDImportedEntity(LLVMContext &C, StorageType Storage, unsigned Tag,
1561 unsigned Line, ArrayRef<Metadata *> Ops)
1562 : DebugNode(C, MDImportedEntityKind, Storage, Tag, Ops), Line(Line) {}
1563 ~MDImportedEntity() {}
1565 static MDImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
1566 Metadata *Scope, Metadata *Entity,
1567 unsigned Line, StringRef Name,
1568 StorageType Storage,
1569 bool ShouldCreate = true) {
1570 return getImpl(Context, Tag, Scope, Entity, Line,
1571 getCanonicalMDString(Context, Name), Storage, ShouldCreate);
1573 static MDImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
1574 Metadata *Scope, Metadata *Entity,
1575 unsigned Line, MDString *Name,
1576 StorageType Storage,
1577 bool ShouldCreate = true);
1579 TempMDImportedEntity cloneImpl() const {
1580 return getTemporary(getContext(), getTag(), getScope(), getEntity(),
1581 getLine(), getName());
1585 DEFINE_MDNODE_GET(MDImportedEntity,
1586 (unsigned Tag, Metadata *Scope, Metadata *Entity,
1587 unsigned Line, StringRef Name = ""),
1588 (Tag, Scope, Entity, Line, Name))
1589 DEFINE_MDNODE_GET(MDImportedEntity,
1590 (unsigned Tag, Metadata *Scope, Metadata *Entity,
1591 unsigned Line, MDString *Name),
1592 (Tag, Scope, Entity, Line, Name))
1594 TempMDImportedEntity clone() const { return cloneImpl(); }
1596 unsigned getLine() const { return Line; }
1597 Metadata *getScope() const { return getOperand(0); }
1598 Metadata *getEntity() const { return getOperand(1); }
1599 StringRef getName() const { return getStringOperand(2); }
1601 static bool classof(const Metadata *MD) {
1602 return MD->getMetadataID() == MDImportedEntityKind;
1606 } // end namespace llvm
1608 #undef DEFINE_MDNODE_GET_UNPACK_IMPL
1609 #undef DEFINE_MDNODE_GET_UNPACK
1610 #undef DEFINE_MDNODE_GET