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 Tagged DWARF-like metadata node.
46 /// A metadata node with a DWARF tag (i.e., a constant named \c DW_TAG_*,
47 /// defined in llvm/Support/Dwarf.h). Called \a DebugNode because it's
48 /// potentially used for non-DWARF output.
49 class DebugNode : public MDNode {
50 friend class LLVMContextImpl;
54 DebugNode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
55 ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None)
56 : MDNode(C, ID, Storage, Ops1, Ops2) {
57 assert(Tag < 1u << 16);
62 template <class Ty> Ty *getOperandAs(unsigned I) const {
63 return cast_or_null<Ty>(getOperand(I));
66 StringRef getStringOperand(unsigned I) const {
67 if (auto *S = getOperandAs<MDString>(I))
68 return S->getString();
72 static MDString *getCanonicalMDString(LLVMContext &Context, StringRef S) {
75 return MDString::get(Context, S);
79 unsigned getTag() const { return SubclassData16; }
81 static bool classof(const Metadata *MD) {
82 switch (MD->getMetadataID()) {
85 case GenericDebugNodeKind:
87 case MDEnumeratorKind:
89 case MDDerivedTypeKind:
90 case MDCompositeTypeKind:
91 case MDSubroutineTypeKind:
93 case MDCompileUnitKind:
94 case MDSubprogramKind:
95 case MDLexicalBlockKind:
96 case MDLexicalBlockFileKind:
98 case MDTemplateTypeParameterKind:
99 case MDTemplateValueParameterKind:
100 case MDGlobalVariableKind:
101 case MDLocalVariableKind:
102 case MDObjCPropertyKind:
103 case MDImportedEntityKind:
109 /// \brief Generic tagged DWARF-like metadata node.
111 /// An un-specialized DWARF-like metadata node. The first operand is a
112 /// (possibly empty) null-separated \a MDString header that contains arbitrary
113 /// fields. The remaining operands are \a dwarf_operands(), and are pointers
114 /// to other metadata.
115 class GenericDebugNode : public DebugNode {
116 friend class LLVMContextImpl;
119 GenericDebugNode(LLVMContext &C, StorageType Storage, unsigned Hash,
120 unsigned Tag, ArrayRef<Metadata *> Ops1,
121 ArrayRef<Metadata *> Ops2)
122 : DebugNode(C, GenericDebugNodeKind, Storage, Tag, Ops1, Ops2) {
125 ~GenericDebugNode() { dropAllReferences(); }
127 void setHash(unsigned Hash) { SubclassData32 = Hash; }
128 void recalculateHash();
130 static GenericDebugNode *getImpl(LLVMContext &Context, unsigned Tag,
132 ArrayRef<Metadata *> DwarfOps,
134 bool ShouldCreate = true) {
135 return getImpl(Context, Tag, getCanonicalMDString(Context, Header),
136 DwarfOps, Storage, ShouldCreate);
139 static GenericDebugNode *getImpl(LLVMContext &Context, unsigned Tag,
141 ArrayRef<Metadata *> DwarfOps,
143 bool ShouldCreate = true);
145 TempGenericDebugNode cloneImpl() const {
147 getContext(), getTag(), getHeader(),
148 SmallVector<Metadata *, 4>(dwarf_op_begin(), dwarf_op_end()));
152 unsigned getHash() const { return SubclassData32; }
154 DEFINE_MDNODE_GET(GenericDebugNode, (unsigned Tag, StringRef Header,
155 ArrayRef<Metadata *> DwarfOps),
156 (Tag, Header, DwarfOps))
157 DEFINE_MDNODE_GET(GenericDebugNode, (unsigned Tag, MDString *Header,
158 ArrayRef<Metadata *> DwarfOps),
159 (Tag, Header, DwarfOps))
161 /// \brief Return a (temporary) clone of this.
162 TempGenericDebugNode clone() const { return cloneImpl(); }
164 unsigned getTag() const { return SubclassData16; }
165 StringRef getHeader() const { return getStringOperand(0); }
167 op_iterator dwarf_op_begin() const { return op_begin() + 1; }
168 op_iterator dwarf_op_end() const { return op_end(); }
169 op_range dwarf_operands() const {
170 return op_range(dwarf_op_begin(), dwarf_op_end());
173 unsigned getNumDwarfOperands() const { return getNumOperands() - 1; }
174 const MDOperand &getDwarfOperand(unsigned I) const {
175 return getOperand(I + 1);
177 void replaceDwarfOperandWith(unsigned I, Metadata *New) {
178 replaceOperandWith(I + 1, New);
181 static bool classof(const Metadata *MD) {
182 return MD->getMetadataID() == GenericDebugNodeKind;
186 /// \brief Array subrange.
188 /// TODO: Merge into node for DW_TAG_array_type, which should have a custom
190 class MDSubrange : public DebugNode {
191 friend class LLVMContextImpl;
197 MDSubrange(LLVMContext &C, StorageType Storage, int64_t Count, int64_t Lo)
198 : DebugNode(C, MDSubrangeKind, Storage, dwarf::DW_TAG_subrange_type,
200 Count(Count), Lo(Lo) {}
203 static MDSubrange *getImpl(LLVMContext &Context, int64_t Count, int64_t Lo,
204 StorageType Storage, bool ShouldCreate = true);
206 TempMDSubrange cloneImpl() const {
207 return getTemporary(getContext(), getCount(), getLo());
211 DEFINE_MDNODE_GET(MDSubrange, (int64_t Count, int64_t Lo = 0), (Count, Lo))
213 TempMDSubrange clone() const { return cloneImpl(); }
215 int64_t getLo() const { return Lo; }
216 int64_t getCount() const { return Count; }
218 static bool classof(const Metadata *MD) {
219 return MD->getMetadataID() == MDSubrangeKind;
223 /// \brief Enumeration value.
225 /// TODO: Add a pointer to the context (DW_TAG_enumeration_type) once that no
226 /// longer creates a type cycle.
227 class MDEnumerator : public DebugNode {
228 friend class LLVMContextImpl;
233 MDEnumerator(LLVMContext &C, StorageType Storage, int64_t Value,
234 ArrayRef<Metadata *> Ops)
235 : DebugNode(C, MDEnumeratorKind, Storage, dwarf::DW_TAG_enumerator, Ops),
239 static MDEnumerator *getImpl(LLVMContext &Context, int64_t Value,
240 StringRef Name, StorageType Storage,
241 bool ShouldCreate = true) {
242 return getImpl(Context, Value, getCanonicalMDString(Context, Name), Storage,
245 static MDEnumerator *getImpl(LLVMContext &Context, int64_t Value,
246 MDString *Name, StorageType Storage,
247 bool ShouldCreate = true);
249 TempMDEnumerator cloneImpl() const {
250 return getTemporary(getContext(), getValue(), getName());
254 DEFINE_MDNODE_GET(MDEnumerator, (int64_t Value, StringRef Name),
256 DEFINE_MDNODE_GET(MDEnumerator, (int64_t Value, MDString *Name),
259 TempMDEnumerator clone() const { return cloneImpl(); }
261 int64_t getValue() const { return Value; }
262 StringRef getName() const { return getStringOperand(0); }
264 MDString *getRawName() const { return getOperandAs<MDString>(0); }
266 static bool classof(const Metadata *MD) {
267 return MD->getMetadataID() == MDEnumeratorKind;
271 /// \brief Base class for scope-like contexts.
273 /// Base class for lexical scopes and types (which are also declaration
276 /// TODO: Separate the concepts of declaration contexts and lexical scopes.
277 class MDScope : public DebugNode {
279 MDScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
280 ArrayRef<Metadata *> Ops)
281 : DebugNode(C, ID, Storage, Tag, Ops) {}
285 MDFile *getFile() const { return cast_or_null<MDFile>(getRawFile()); }
287 /// \brief Return the raw underlying file.
289 /// An \a MDFile is an \a MDScope, but it doesn't point at a separate file
290 /// (it\em is the file). If \c this is an \a MDFile, we need to return \c
291 /// this. Otherwise, return the first operand, which is where all other
292 /// subclasses store their file pointer.
293 Metadata *getRawFile() const {
294 return isa<MDFile>(this) ? const_cast<MDScope *>(this)
295 : static_cast<Metadata *>(getOperand(0));
298 static bool classof(const Metadata *MD) {
299 switch (MD->getMetadataID()) {
302 case MDBasicTypeKind:
303 case MDDerivedTypeKind:
304 case MDCompositeTypeKind:
305 case MDSubroutineTypeKind:
307 case MDCompileUnitKind:
308 case MDSubprogramKind:
309 case MDLexicalBlockKind:
310 case MDLexicalBlockFileKind:
311 case MDNamespaceKind:
319 /// TODO: Merge with directory/file node (including users).
320 /// TODO: Canonicalize paths on creation.
321 class MDFile : public MDScope {
322 friend class LLVMContextImpl;
325 MDFile(LLVMContext &C, StorageType Storage, ArrayRef<Metadata *> Ops)
326 : MDScope(C, MDFileKind, Storage, dwarf::DW_TAG_file_type, Ops) {}
329 static MDFile *getImpl(LLVMContext &Context, StringRef Filename,
330 StringRef Directory, StorageType Storage,
331 bool ShouldCreate = true) {
332 return getImpl(Context, getCanonicalMDString(Context, Filename),
333 getCanonicalMDString(Context, Directory), Storage,
336 static MDFile *getImpl(LLVMContext &Context, MDString *Filename,
337 MDString *Directory, StorageType Storage,
338 bool ShouldCreate = true);
340 TempMDFile cloneImpl() const {
341 return getTemporary(getContext(), getFilename(), getDirectory());
345 DEFINE_MDNODE_GET(MDFile, (StringRef Filename, StringRef Directory),
346 (Filename, Directory))
347 DEFINE_MDNODE_GET(MDFile, (MDString * Filename, MDString *Directory),
348 (Filename, Directory))
350 TempMDFile clone() const { return cloneImpl(); }
352 StringRef getFilename() const { return getStringOperand(0); }
353 StringRef getDirectory() const { return getStringOperand(1); }
355 MDString *getRawFilename() const { return getOperandAs<MDString>(0); }
356 MDString *getRawDirectory() const { return getOperandAs<MDString>(1); }
358 static bool classof(const Metadata *MD) {
359 return MD->getMetadataID() == MDFileKind;
363 /// \brief Base class for types.
365 /// TODO: Remove the hardcoded name and context, since many types don't use
367 /// TODO: Split up flags.
368 class MDType : public MDScope {
372 uint64_t AlignInBits;
373 uint64_t OffsetInBits;
376 MDType(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
377 unsigned Line, uint64_t SizeInBits, uint64_t AlignInBits,
378 uint64_t OffsetInBits, unsigned Flags, ArrayRef<Metadata *> Ops)
379 : MDScope(C, ID, Storage, Tag, Ops), Line(Line), Flags(Flags),
380 SizeInBits(SizeInBits), AlignInBits(AlignInBits),
381 OffsetInBits(OffsetInBits) {}
385 TempMDType clone() const {
386 return TempMDType(cast<MDType>(MDNode::clone().release()));
389 unsigned getLine() const { return Line; }
390 uint64_t getSizeInBits() const { return SizeInBits; }
391 uint64_t getAlignInBits() const { return AlignInBits; }
392 uint64_t getOffsetInBits() const { return OffsetInBits; }
393 unsigned getFlags() const { return Flags; }
395 Metadata *getScope() const { return getRawScope(); }
396 StringRef getName() const { return getStringOperand(2); }
399 Metadata *getRawScope() const { return getOperand(1); }
400 MDString *getRawName() const { return getOperandAs<MDString>(2); }
402 void setFlags(unsigned NewFlags) {
403 assert(!isUniqued() && "Cannot set flags on uniqued nodes");
407 static bool classof(const Metadata *MD) {
408 switch (MD->getMetadataID()) {
411 case MDBasicTypeKind:
412 case MDDerivedTypeKind:
413 case MDCompositeTypeKind:
414 case MDSubroutineTypeKind:
420 /// \brief Basic type.
422 /// TODO: Split out DW_TAG_unspecified_type.
423 /// TODO: Drop unused accessors.
424 class MDBasicType : public MDType {
425 friend class LLVMContextImpl;
430 MDBasicType(LLVMContext &C, StorageType Storage, unsigned Tag,
431 uint64_t SizeInBits, uint64_t AlignInBits, unsigned Encoding,
432 ArrayRef<Metadata *> Ops)
433 : MDType(C, MDBasicTypeKind, Storage, Tag, 0, SizeInBits, AlignInBits, 0,
435 Encoding(Encoding) {}
438 static MDBasicType *getImpl(LLVMContext &Context, unsigned Tag,
439 StringRef Name, uint64_t SizeInBits,
440 uint64_t AlignInBits, unsigned Encoding,
441 StorageType Storage, bool ShouldCreate = true) {
442 return getImpl(Context, Tag, getCanonicalMDString(Context, Name),
443 SizeInBits, AlignInBits, Encoding, Storage, ShouldCreate);
445 static MDBasicType *getImpl(LLVMContext &Context, unsigned Tag,
446 MDString *Name, uint64_t SizeInBits,
447 uint64_t AlignInBits, unsigned Encoding,
448 StorageType Storage, bool ShouldCreate = true);
450 TempMDBasicType cloneImpl() const {
451 return getTemporary(getContext(), getTag(), getName(), getSizeInBits(),
452 getAlignInBits(), getEncoding());
456 DEFINE_MDNODE_GET(MDBasicType, (unsigned Tag, StringRef Name),
457 (Tag, Name, 0, 0, 0))
458 DEFINE_MDNODE_GET(MDBasicType,
459 (unsigned Tag, StringRef Name, uint64_t SizeInBits,
460 uint64_t AlignInBits, unsigned Encoding),
461 (Tag, Name, SizeInBits, AlignInBits, Encoding))
462 DEFINE_MDNODE_GET(MDBasicType,
463 (unsigned Tag, MDString *Name, uint64_t SizeInBits,
464 uint64_t AlignInBits, unsigned Encoding),
465 (Tag, Name, SizeInBits, AlignInBits, Encoding))
467 TempMDBasicType clone() const { return cloneImpl(); }
469 unsigned getEncoding() const { return Encoding; }
471 static bool classof(const Metadata *MD) {
472 return MD->getMetadataID() == MDBasicTypeKind;
476 /// \brief Base class for MDDerivedType and MDCompositeType.
478 /// TODO: Delete; they're not really related.
479 class MDDerivedTypeBase : public MDType {
481 MDDerivedTypeBase(LLVMContext &C, unsigned ID, StorageType Storage,
482 unsigned Tag, unsigned Line, uint64_t SizeInBits,
483 uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
484 ArrayRef<Metadata *> Ops)
485 : MDType(C, ID, Storage, Tag, Line, SizeInBits, AlignInBits, OffsetInBits,
487 ~MDDerivedTypeBase() {}
490 Metadata *getBaseType() const { return getRawBaseType(); }
491 Metadata *getRawBaseType() const { return getOperand(3); }
493 static bool classof(const Metadata *MD) {
494 return MD->getMetadataID() == MDDerivedTypeKind ||
495 MD->getMetadataID() == MDCompositeTypeKind ||
496 MD->getMetadataID() == MDSubroutineTypeKind;
500 /// \brief Derived types.
502 /// This includes qualified types, pointers, references, friends, typedefs, and
505 /// TODO: Split out members (inheritance, fields, methods, etc.).
506 class MDDerivedType : public MDDerivedTypeBase {
507 friend class LLVMContextImpl;
510 MDDerivedType(LLVMContext &C, StorageType Storage, unsigned Tag,
511 unsigned Line, uint64_t SizeInBits, uint64_t AlignInBits,
512 uint64_t OffsetInBits, unsigned Flags, ArrayRef<Metadata *> Ops)
513 : MDDerivedTypeBase(C, MDDerivedTypeKind, Storage, Tag, Line, SizeInBits,
514 AlignInBits, OffsetInBits, Flags, Ops) {}
517 static MDDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
518 StringRef Name, MDFile *File, unsigned Line,
519 Metadata *Scope, Metadata *BaseType,
520 uint64_t SizeInBits, uint64_t AlignInBits,
521 uint64_t OffsetInBits, unsigned Flags,
522 Metadata *ExtraData, StorageType Storage,
523 bool ShouldCreate = true) {
524 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), File,
525 Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits,
526 Flags, ExtraData, Storage, ShouldCreate);
528 static MDDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
529 MDString *Name, Metadata *File, unsigned Line,
530 Metadata *Scope, Metadata *BaseType,
531 uint64_t SizeInBits, uint64_t AlignInBits,
532 uint64_t OffsetInBits, unsigned Flags,
533 Metadata *ExtraData, StorageType Storage,
534 bool ShouldCreate = true);
536 TempMDDerivedType cloneImpl() const {
537 return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
538 getScope(), getBaseType(), getSizeInBits(),
539 getAlignInBits(), getOffsetInBits(), getFlags(),
544 DEFINE_MDNODE_GET(MDDerivedType,
545 (unsigned Tag, MDString *Name, Metadata *File,
546 unsigned Line, Metadata *Scope, Metadata *BaseType,
547 uint64_t SizeInBits, uint64_t AlignInBits,
548 uint64_t OffsetInBits, unsigned Flags,
549 Metadata *ExtraData = nullptr),
550 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
551 AlignInBits, OffsetInBits, Flags, ExtraData))
552 DEFINE_MDNODE_GET(MDDerivedType,
553 (unsigned Tag, StringRef Name, MDFile *File,
554 unsigned Line, Metadata *Scope, Metadata *BaseType,
555 uint64_t SizeInBits, uint64_t AlignInBits,
556 uint64_t OffsetInBits, unsigned Flags,
557 Metadata *ExtraData = nullptr),
558 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
559 AlignInBits, OffsetInBits, Flags, ExtraData))
561 TempMDDerivedType clone() const { return cloneImpl(); }
563 /// \brief Get extra data associated with this derived type.
565 /// Class type for pointer-to-members, objective-c property node for ivars,
566 /// or global constant wrapper for static members.
568 /// TODO: Separate out types that need this extra operand: pointer-to-member
569 /// types and member fields (static members and ivars).
570 Metadata *getExtraData() const { return getRawExtraData(); }
571 Metadata *getRawExtraData() const { return getOperand(4); }
573 static bool classof(const Metadata *MD) {
574 return MD->getMetadataID() == MDDerivedTypeKind;
578 /// \brief Base class for MDCompositeType and MDSubroutineType.
580 /// TODO: Delete; they're not really related.
581 class MDCompositeTypeBase : public MDDerivedTypeBase {
582 unsigned RuntimeLang;
585 MDCompositeTypeBase(LLVMContext &C, unsigned ID, StorageType Storage,
586 unsigned Tag, unsigned Line, unsigned RuntimeLang,
587 uint64_t SizeInBits, uint64_t AlignInBits,
588 uint64_t OffsetInBits, unsigned Flags,
589 ArrayRef<Metadata *> Ops)
590 : MDDerivedTypeBase(C, ID, Storage, Tag, Line, SizeInBits, AlignInBits,
591 OffsetInBits, Flags, Ops),
592 RuntimeLang(RuntimeLang) {}
593 ~MDCompositeTypeBase() {}
596 MDTuple *getElements() const {
597 return cast_or_null<MDTuple>(getRawElements());
599 Metadata *getVTableHolder() const { return getRawVTableHolder(); }
600 MDTuple *getTemplateParams() const {
601 return cast_or_null<MDTuple>(getRawTemplateParams());
603 StringRef getIdentifier() const { return getStringOperand(7); }
604 unsigned getRuntimeLang() const { return RuntimeLang; }
606 Metadata *getRawElements() const { return getOperand(4); }
607 Metadata *getRawVTableHolder() const { return getOperand(5); }
608 Metadata *getRawTemplateParams() const { return getOperand(6); }
609 MDString *getRawIdentifier() const { return getOperandAs<MDString>(7); }
611 /// \brief Replace operands.
613 /// If this \a isUniqued() and not \a isResolved(), on a uniquing collision
614 /// this will be RAUW'ed and deleted. Use a \a TrackingMDRef to keep track
615 /// of its movement if necessary.
617 void replaceElements(MDTuple *Elements) {
619 if (auto *Old = cast_or_null<MDTuple>(getElements()))
620 for (const auto &Op : Old->operands())
621 assert(std::find(Elements->op_begin(), Elements->op_end(), Op) &&
622 "Lost a member during member list replacement");
624 replaceOperandWith(4, Elements);
626 void replaceVTableHolder(Metadata *VTableHolder) {
627 replaceOperandWith(5, VTableHolder);
629 void replaceTemplateParams(MDTuple *TemplateParams) {
630 replaceOperandWith(6, TemplateParams);
634 static bool classof(const Metadata *MD) {
635 return MD->getMetadataID() == MDCompositeTypeKind ||
636 MD->getMetadataID() == MDSubroutineTypeKind;
640 /// \brief Composite types.
642 /// TODO: Detach from DerivedTypeBase (split out MDEnumType?).
643 /// TODO: Create a custom, unrelated node for DW_TAG_array_type.
644 class MDCompositeType : public MDCompositeTypeBase {
645 friend class LLVMContextImpl;
648 MDCompositeType(LLVMContext &C, StorageType Storage, unsigned Tag,
649 unsigned Line, unsigned RuntimeLang, uint64_t SizeInBits,
650 uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
651 ArrayRef<Metadata *> Ops)
652 : MDCompositeTypeBase(C, MDCompositeTypeKind, Storage, Tag, Line,
653 RuntimeLang, SizeInBits, AlignInBits, OffsetInBits,
655 ~MDCompositeType() {}
657 static MDCompositeType *
658 getImpl(LLVMContext &Context, unsigned Tag, StringRef Name, Metadata *File,
659 unsigned Line, Metadata *Scope, Metadata *BaseType,
660 uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
661 uint64_t Flags, Metadata *Elements, unsigned RuntimeLang,
662 Metadata *VTableHolder, Metadata *TemplateParams,
663 StringRef Identifier, StorageType Storage, bool ShouldCreate = true) {
664 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), File,
665 Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits,
666 Flags, Elements, RuntimeLang, VTableHolder, TemplateParams,
667 getCanonicalMDString(Context, Identifier), Storage,
670 static MDCompositeType *
671 getImpl(LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
672 unsigned Line, Metadata *Scope, Metadata *BaseType,
673 uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
674 unsigned Flags, Metadata *Elements, unsigned RuntimeLang,
675 Metadata *VTableHolder, Metadata *TemplateParams,
676 MDString *Identifier, StorageType Storage, bool ShouldCreate = true);
678 TempMDCompositeType cloneImpl() const {
679 return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
680 getScope(), getBaseType(), getSizeInBits(),
681 getAlignInBits(), getOffsetInBits(), getFlags(),
682 getElements(), getRuntimeLang(), getVTableHolder(),
683 getTemplateParams(), getIdentifier());
687 DEFINE_MDNODE_GET(MDCompositeType,
688 (unsigned Tag, StringRef Name, Metadata *File,
689 unsigned Line, Metadata *Scope, Metadata *BaseType,
690 uint64_t SizeInBits, uint64_t AlignInBits,
691 uint64_t OffsetInBits, unsigned Flags, Metadata *Elements,
692 unsigned RuntimeLang, Metadata *VTableHolder,
693 Metadata *TemplateParams = nullptr,
694 StringRef Identifier = ""),
695 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
696 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
697 VTableHolder, TemplateParams, Identifier))
698 DEFINE_MDNODE_GET(MDCompositeType,
699 (unsigned Tag, MDString *Name, Metadata *File,
700 unsigned Line, Metadata *Scope, Metadata *BaseType,
701 uint64_t SizeInBits, uint64_t AlignInBits,
702 uint64_t OffsetInBits, unsigned Flags, Metadata *Elements,
703 unsigned RuntimeLang, Metadata *VTableHolder,
704 Metadata *TemplateParams = nullptr,
705 MDString *Identifier = nullptr),
706 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
707 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
708 VTableHolder, TemplateParams, Identifier))
710 TempMDCompositeType clone() const { return cloneImpl(); }
712 static bool classof(const Metadata *MD) {
713 return MD->getMetadataID() == MDCompositeTypeKind;
717 /// \brief Type array for a subprogram.
719 /// TODO: Detach from CompositeType, and fold the array of types in directly
721 class MDSubroutineType : public MDCompositeTypeBase {
722 friend class LLVMContextImpl;
725 MDSubroutineType(LLVMContext &C, StorageType Storage, unsigned Flags,
726 ArrayRef<Metadata *> Ops)
727 : MDCompositeTypeBase(C, MDSubroutineTypeKind, Storage,
728 dwarf::DW_TAG_subroutine_type, 0, 0, 0, 0, 0, Flags,
730 ~MDSubroutineType() {}
732 static MDSubroutineType *getImpl(LLVMContext &Context, unsigned Flags,
733 Metadata *TypeArray, StorageType Storage,
734 bool ShouldCreate = true);
736 TempMDSubroutineType cloneImpl() const {
737 return getTemporary(getContext(), getFlags(), getTypeArray());
741 DEFINE_MDNODE_GET(MDSubroutineType, (unsigned Flags, Metadata *TypeArray),
744 TempMDSubroutineType clone() const { return cloneImpl(); }
746 MDTuple *getTypeArray() const { return getElements(); }
747 Metadata *getRawTypeArray() const { return getRawElements(); }
749 static bool classof(const Metadata *MD) {
750 return MD->getMetadataID() == MDSubroutineTypeKind;
754 /// \brief Compile unit.
755 class MDCompileUnit : public MDScope {
756 friend class LLVMContextImpl;
759 unsigned SourceLanguage;
761 unsigned RuntimeVersion;
762 unsigned EmissionKind;
764 MDCompileUnit(LLVMContext &C, StorageType Storage, unsigned SourceLanguage,
765 bool IsOptimized, unsigned RuntimeVersion,
766 unsigned EmissionKind, ArrayRef<Metadata *> Ops)
767 : MDScope(C, MDCompileUnitKind, Storage, dwarf::DW_TAG_compile_unit, Ops),
768 SourceLanguage(SourceLanguage), IsOptimized(IsOptimized),
769 RuntimeVersion(RuntimeVersion), EmissionKind(EmissionKind) {}
772 static MDCompileUnit *
773 getImpl(LLVMContext &Context, unsigned SourceLanguage, MDFile *File,
774 StringRef Producer, bool IsOptimized, StringRef Flags,
775 unsigned RuntimeVersion, StringRef SplitDebugFilename,
776 unsigned EmissionKind, MDTuple *EnumTypes, MDTuple *RetainedTypes,
777 MDTuple *Subprograms, MDTuple *GlobalVariables,
778 MDTuple *ImportedEntities, StorageType Storage,
779 bool ShouldCreate = true) {
780 return getImpl(Context, SourceLanguage, File,
781 getCanonicalMDString(Context, Producer), IsOptimized,
782 getCanonicalMDString(Context, Flags), RuntimeVersion,
783 getCanonicalMDString(Context, SplitDebugFilename),
784 EmissionKind, EnumTypes, RetainedTypes, Subprograms,
785 GlobalVariables, ImportedEntities, Storage, ShouldCreate);
787 static MDCompileUnit *
788 getImpl(LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
789 MDString *Producer, bool IsOptimized, MDString *Flags,
790 unsigned RuntimeVersion, MDString *SplitDebugFilename,
791 unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
792 Metadata *Subprograms, Metadata *GlobalVariables,
793 Metadata *ImportedEntities, StorageType Storage,
794 bool ShouldCreate = true);
796 TempMDCompileUnit cloneImpl() const {
798 getContext(), getSourceLanguage(), getFile(), getProducer(),
799 isOptimized(), getFlags(), getRuntimeVersion(), getSplitDebugFilename(),
800 getEmissionKind(), getEnumTypes(), getRetainedTypes(), getSubprograms(),
801 getGlobalVariables(), getImportedEntities());
805 DEFINE_MDNODE_GET(MDCompileUnit,
806 (unsigned SourceLanguage, MDFile *File, StringRef Producer,
807 bool IsOptimized, StringRef Flags, unsigned RuntimeVersion,
808 StringRef SplitDebugFilename, unsigned EmissionKind,
809 MDTuple *EnumTypes, MDTuple *RetainedTypes,
810 MDTuple *Subprograms, MDTuple *GlobalVariables,
811 MDTuple *ImportedEntities),
812 (SourceLanguage, File, Producer, IsOptimized, Flags,
813 RuntimeVersion, SplitDebugFilename, EmissionKind,
814 EnumTypes, RetainedTypes, Subprograms, GlobalVariables,
816 DEFINE_MDNODE_GET(MDCompileUnit,
817 (unsigned SourceLanguage, Metadata *File,
818 MDString *Producer, bool IsOptimized, MDString *Flags,
819 unsigned RuntimeVersion, MDString *SplitDebugFilename,
820 unsigned EmissionKind, Metadata *EnumTypes,
821 Metadata *RetainedTypes, Metadata *Subprograms,
822 Metadata *GlobalVariables, Metadata *ImportedEntities),
823 (SourceLanguage, File, Producer, IsOptimized, Flags,
824 RuntimeVersion, SplitDebugFilename, EmissionKind,
825 EnumTypes, RetainedTypes, Subprograms, GlobalVariables,
828 TempMDCompileUnit clone() const { return cloneImpl(); }
830 unsigned getSourceLanguage() const { return SourceLanguage; }
831 bool isOptimized() const { return IsOptimized; }
832 unsigned getRuntimeVersion() const { return RuntimeVersion; }
833 unsigned getEmissionKind() const { return EmissionKind; }
834 StringRef getProducer() const { return getStringOperand(1); }
835 StringRef getFlags() const { return getStringOperand(2); }
836 StringRef getSplitDebugFilename() const { return getStringOperand(3); }
837 MDTuple *getEnumTypes() const {
838 return cast_or_null<MDTuple>(getRawEnumTypes());
840 MDTuple *getRetainedTypes() const {
841 return cast_or_null<MDTuple>(getRawRetainedTypes());
843 MDTuple *getSubprograms() const {
844 return cast_or_null<MDTuple>(getRawSubprograms());
846 MDTuple *getGlobalVariables() const {
847 return cast_or_null<MDTuple>(getRawGlobalVariables());
849 MDTuple *getImportedEntities() const {
850 return cast_or_null<MDTuple>(getRawImportedEntities());
853 MDString *getRawProducer() const { return getOperandAs<MDString>(1); }
854 MDString *getRawFlags() const { return getOperandAs<MDString>(2); }
855 MDString *getRawSplitDebugFilename() const {
856 return getOperandAs<MDString>(3);
858 Metadata *getRawEnumTypes() const { return getOperand(4); }
859 Metadata *getRawRetainedTypes() const { return getOperand(5); }
860 Metadata *getRawSubprograms() const { return getOperand(6); }
861 Metadata *getRawGlobalVariables() const { return getOperand(7); }
862 Metadata *getRawImportedEntities() const { return getOperand(8); }
864 /// \brief Replace arrays.
866 /// If this \a isUniqued() and not \a isResolved(), it will be RAUW'ed and
867 /// deleted on a uniquing collision. In practice, uniquing collisions on \a
868 /// MDCompileUnit should be fairly rare.
870 void replaceSubprograms(MDTuple *N) { replaceOperandWith(6, N); }
871 void replaceGlobalVariables(MDTuple *N) { replaceOperandWith(7, N); }
874 static bool classof(const Metadata *MD) {
875 return MD->getMetadataID() == MDCompileUnitKind;
879 /// \brief A scope for locals.
881 /// A legal scope for lexical blocks, local variables, and debug info
882 /// locations. Subclasses are \a MDSubprogram, \a MDLexicalBlock, and \a
883 /// MDLexicalBlockFile.
884 class MDLocalScope : public MDScope {
886 MDLocalScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
887 ArrayRef<Metadata *> Ops)
888 : MDScope(C, ID, Storage, Tag, Ops) {}
892 /// \brief Get the subprogram for this scope.
894 /// Return this if it's an \a MDSubprogram; otherwise, look up the scope
896 MDSubprogram *getSubprogram() const;
898 static bool classof(const Metadata *MD) {
899 return MD->getMetadataID() == MDSubprogramKind ||
900 MD->getMetadataID() == MDLexicalBlockKind ||
901 MD->getMetadataID() == MDLexicalBlockFileKind;
905 /// \brief Debug location.
907 /// A debug location in source code, used for debug info and otherwise.
908 class MDLocation : public MDNode {
909 friend class LLVMContextImpl;
912 MDLocation(LLVMContext &C, StorageType Storage, unsigned Line,
913 unsigned Column, ArrayRef<Metadata *> MDs);
914 ~MDLocation() { dropAllReferences(); }
916 static MDLocation *getImpl(LLVMContext &Context, unsigned Line,
917 unsigned Column, Metadata *Scope,
918 Metadata *InlinedAt, StorageType Storage,
919 bool ShouldCreate = true);
920 static MDLocation *getImpl(LLVMContext &Context, unsigned Line,
921 unsigned Column, MDLocalScope *Scope,
922 MDLocation *InlinedAt, StorageType Storage,
923 bool ShouldCreate = true) {
924 return getImpl(Context, Line, Column, static_cast<Metadata *>(Scope),
925 static_cast<Metadata *>(InlinedAt), Storage, ShouldCreate);
928 TempMDLocation cloneImpl() const {
929 return getTemporary(getContext(), getLine(), getColumn(), getScope(),
933 // Disallow replacing operands.
934 void replaceOperandWith(unsigned I, Metadata *New) = delete;
937 DEFINE_MDNODE_GET(MDLocation,
938 (unsigned Line, unsigned Column, Metadata *Scope,
939 Metadata *InlinedAt = nullptr),
940 (Line, Column, Scope, InlinedAt))
941 DEFINE_MDNODE_GET(MDLocation,
942 (unsigned Line, unsigned Column, MDLocalScope *Scope,
943 MDLocation *InlinedAt = nullptr),
944 (Line, Column, Scope, InlinedAt))
946 /// \brief Return a (temporary) clone of this.
947 TempMDLocation clone() const { return cloneImpl(); }
949 unsigned getLine() const { return SubclassData32; }
950 unsigned getColumn() const { return SubclassData16; }
951 MDLocalScope *getScope() const {
952 return cast_or_null<MDLocalScope>(getRawScope());
954 MDLocation *getInlinedAt() const {
955 return cast_or_null<MDLocation>(getRawInlinedAt());
958 /// \brief Get the scope where this is inlined.
960 /// Walk through \a getInlinedAt() and return \a getScope() from the deepest
962 MDLocalScope *getInlinedAtScope() const {
963 if (auto *IA = getInlinedAt())
964 return IA->getInlinedAtScope();
968 Metadata *getRawScope() const { return getOperand(0); }
969 Metadata *getRawInlinedAt() const {
970 if (getNumOperands() == 2)
971 return getOperand(1);
975 static bool classof(const Metadata *MD) {
976 return MD->getMetadataID() == MDLocationKind;
980 /// \brief Subprogram description.
982 /// TODO: Remove DisplayName. It's always equal to Name.
983 /// TODO: Split up flags.
984 class MDSubprogram : public MDLocalScope {
985 friend class LLVMContextImpl;
991 unsigned VirtualIndex;
997 MDSubprogram(LLVMContext &C, StorageType Storage, unsigned Line,
998 unsigned ScopeLine, unsigned Virtuality, unsigned VirtualIndex,
999 unsigned Flags, bool IsLocalToUnit, bool IsDefinition,
1000 bool IsOptimized, ArrayRef<Metadata *> Ops)
1001 : MDLocalScope(C, MDSubprogramKind, Storage, dwarf::DW_TAG_subprogram,
1003 Line(Line), ScopeLine(ScopeLine), Virtuality(Virtuality),
1004 VirtualIndex(VirtualIndex), Flags(Flags), IsLocalToUnit(IsLocalToUnit),
1005 IsDefinition(IsDefinition), IsOptimized(IsOptimized) {}
1008 static MDSubprogram *
1009 getImpl(LLVMContext &Context, Metadata *Scope, StringRef Name,
1010 StringRef LinkageName, MDFile *File, unsigned Line,
1011 MDSubroutineType *Type, bool IsLocalToUnit, bool IsDefinition,
1012 unsigned ScopeLine, Metadata *ContainingType, unsigned Virtuality,
1013 unsigned VirtualIndex, unsigned Flags, bool IsOptimized,
1014 ConstantAsMetadata *Function, MDTuple *TemplateParams,
1015 MDSubprogram *Declaration, MDTuple *Variables, StorageType Storage,
1016 bool ShouldCreate = true) {
1017 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
1018 getCanonicalMDString(Context, LinkageName), File, Line, Type,
1019 IsLocalToUnit, IsDefinition, ScopeLine, ContainingType,
1020 Virtuality, VirtualIndex, Flags, IsOptimized, Function,
1021 TemplateParams, Declaration, Variables, Storage,
1024 static MDSubprogram *
1025 getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
1026 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
1027 bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
1028 Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex,
1029 unsigned Flags, bool IsOptimized, Metadata *Function,
1030 Metadata *TemplateParams, Metadata *Declaration, Metadata *Variables,
1031 StorageType Storage, bool ShouldCreate = true);
1033 TempMDSubprogram cloneImpl() const {
1034 return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
1035 getFile(), getLine(), getType(), isLocalToUnit(),
1036 isDefinition(), getScopeLine(), getContainingType(),
1037 getVirtuality(), getVirtualIndex(), getFlags(),
1038 isOptimized(), getFunction(), getTemplateParams(),
1039 getDeclaration(), getVariables());
1045 (Metadata * Scope, StringRef Name, StringRef LinkageName, MDFile *File,
1046 unsigned Line, MDSubroutineType *Type, bool IsLocalToUnit,
1047 bool IsDefinition, unsigned ScopeLine, Metadata *ContainingType,
1048 unsigned Virtuality, unsigned VirtualIndex, unsigned Flags,
1049 bool IsOptimized, ConstantAsMetadata *Function = nullptr,
1050 MDTuple *TemplateParams = nullptr, MDSubprogram *Declaration = nullptr,
1051 MDTuple *Variables = nullptr),
1052 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition,
1053 ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags, IsOptimized,
1054 Function, TemplateParams, Declaration, Variables))
1057 (Metadata * Scope, MDString *Name, MDString *LinkageName, Metadata *File,
1058 unsigned Line, Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
1059 unsigned ScopeLine, Metadata *ContainingType, unsigned Virtuality,
1060 unsigned VirtualIndex, unsigned Flags, bool IsOptimized,
1061 Metadata *Function = nullptr, Metadata *TemplateParams = nullptr,
1062 Metadata *Declaration = nullptr, Metadata *Variables = nullptr),
1063 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition,
1064 ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags, IsOptimized,
1065 Function, TemplateParams, Declaration, Variables))
1067 TempMDSubprogram clone() const { return cloneImpl(); }
1070 unsigned getLine() const { return Line; }
1071 unsigned getVirtuality() const { return Virtuality; }
1072 unsigned getVirtualIndex() const { return VirtualIndex; }
1073 unsigned getScopeLine() const { return ScopeLine; }
1074 unsigned getFlags() const { return Flags; }
1075 bool isLocalToUnit() const { return IsLocalToUnit; }
1076 bool isDefinition() const { return IsDefinition; }
1077 bool isOptimized() const { return IsOptimized; }
1079 Metadata *getScope() const { return getRawScope(); }
1081 StringRef getName() const { return getStringOperand(2); }
1082 StringRef getDisplayName() const { return getStringOperand(3); }
1083 StringRef getLinkageName() const { return getStringOperand(4); }
1085 MDString *getRawName() const { return getOperandAs<MDString>(2); }
1086 MDString *getRawLinkageName() const { return getOperandAs<MDString>(4); }
1088 MDSubroutineType *getType() const {
1089 return cast_or_null<MDSubroutineType>(getRawType());
1091 Metadata *getContainingType() const { return getRawContainingType(); }
1093 ConstantAsMetadata *getFunction() const {
1094 return cast_or_null<ConstantAsMetadata>(getRawFunction());
1096 MDTuple *getTemplateParams() const {
1097 return cast_or_null<MDTuple>(getRawTemplateParams());
1099 MDSubprogram *getDeclaration() const {
1100 return cast_or_null<MDSubprogram>(getRawDeclaration());
1102 MDTuple *getVariables() const {
1103 return cast_or_null<MDTuple>(getRawVariables());
1106 Metadata *getRawScope() const { return getOperand(1); }
1107 Metadata *getRawType() const { return getOperand(5); }
1108 Metadata *getRawContainingType() const { return getOperand(6); }
1109 Metadata *getRawFunction() const { return getOperand(7); }
1110 Metadata *getRawTemplateParams() const { return getOperand(8); }
1111 Metadata *getRawDeclaration() const { return getOperand(9); }
1112 Metadata *getRawVariables() const { return getOperand(10); }
1114 /// \brief Replace the function.
1116 /// If \a isUniqued() and not \a isResolved(), this could node will be
1117 /// RAUW'ed and deleted out from under the caller. Use a \a TrackingMDRef if
1118 /// that's a problem.
1120 void replaceFunction(Function *F);
1121 void replaceFunction(ConstantAsMetadata *MD) { replaceOperandWith(7, MD); }
1122 void replaceFunction(std::nullptr_t) { replaceOperandWith(7, nullptr); }
1125 static bool classof(const Metadata *MD) {
1126 return MD->getMetadataID() == MDSubprogramKind;
1130 class MDLexicalBlockBase : public MDLocalScope {
1132 MDLexicalBlockBase(LLVMContext &C, unsigned ID, StorageType Storage,
1133 ArrayRef<Metadata *> Ops)
1134 : MDLocalScope(C, ID, Storage, dwarf::DW_TAG_lexical_block, Ops) {}
1135 ~MDLexicalBlockBase() {}
1138 MDLocalScope *getScope() const { return cast<MDLocalScope>(getRawScope()); }
1140 Metadata *getRawScope() const { return getOperand(1); }
1142 static bool classof(const Metadata *MD) {
1143 return MD->getMetadataID() == MDLexicalBlockKind ||
1144 MD->getMetadataID() == MDLexicalBlockFileKind;
1148 class MDLexicalBlock : public MDLexicalBlockBase {
1149 friend class LLVMContextImpl;
1150 friend class MDNode;
1155 MDLexicalBlock(LLVMContext &C, StorageType Storage, unsigned Line,
1156 unsigned Column, ArrayRef<Metadata *> Ops)
1157 : MDLexicalBlockBase(C, MDLexicalBlockKind, Storage, Ops), Line(Line),
1159 ~MDLexicalBlock() {}
1161 static MDLexicalBlock *getImpl(LLVMContext &Context, MDLocalScope *Scope,
1162 MDFile *File, unsigned Line, unsigned Column,
1163 StorageType Storage,
1164 bool ShouldCreate = true) {
1165 return getImpl(Context, static_cast<Metadata *>(Scope),
1166 static_cast<Metadata *>(File), Line, Column, Storage,
1170 static MDLexicalBlock *getImpl(LLVMContext &Context, Metadata *Scope,
1171 Metadata *File, unsigned Line, unsigned Column,
1172 StorageType Storage, bool ShouldCreate = true);
1174 TempMDLexicalBlock cloneImpl() const {
1175 return getTemporary(getContext(), getScope(), getFile(), getLine(),
1180 DEFINE_MDNODE_GET(MDLexicalBlock, (MDLocalScope * Scope, MDFile *File,
1181 unsigned Line, unsigned Column),
1182 (Scope, File, Line, Column))
1183 DEFINE_MDNODE_GET(MDLexicalBlock, (Metadata * Scope, Metadata *File,
1184 unsigned Line, unsigned Column),
1185 (Scope, File, Line, Column))
1187 TempMDLexicalBlock clone() const { return cloneImpl(); }
1189 unsigned getLine() const { return Line; }
1190 unsigned getColumn() const { return Column; }
1192 static bool classof(const Metadata *MD) {
1193 return MD->getMetadataID() == MDLexicalBlockKind;
1197 class MDLexicalBlockFile : public MDLexicalBlockBase {
1198 friend class LLVMContextImpl;
1199 friend class MDNode;
1201 unsigned Discriminator;
1203 MDLexicalBlockFile(LLVMContext &C, StorageType Storage,
1204 unsigned Discriminator, ArrayRef<Metadata *> Ops)
1205 : MDLexicalBlockBase(C, MDLexicalBlockFileKind, Storage, Ops),
1206 Discriminator(Discriminator) {}
1207 ~MDLexicalBlockFile() {}
1209 static MDLexicalBlockFile *getImpl(LLVMContext &Context, MDLocalScope *Scope,
1210 MDFile *File, unsigned Discriminator,
1211 StorageType Storage,
1212 bool ShouldCreate = true) {
1213 return getImpl(Context, static_cast<Metadata *>(Scope),
1214 static_cast<Metadata *>(File), Discriminator, Storage,
1218 static MDLexicalBlockFile *getImpl(LLVMContext &Context, Metadata *Scope,
1219 Metadata *File, unsigned Discriminator,
1220 StorageType Storage,
1221 bool ShouldCreate = true);
1223 TempMDLexicalBlockFile cloneImpl() const {
1224 return getTemporary(getContext(), getScope(), getFile(),
1225 getDiscriminator());
1229 DEFINE_MDNODE_GET(MDLexicalBlockFile, (MDLocalScope * Scope, MDFile *File,
1230 unsigned Discriminator),
1231 (Scope, File, Discriminator))
1232 DEFINE_MDNODE_GET(MDLexicalBlockFile,
1233 (Metadata * Scope, Metadata *File, unsigned Discriminator),
1234 (Scope, File, Discriminator))
1236 TempMDLexicalBlockFile clone() const { return cloneImpl(); }
1238 unsigned getDiscriminator() const { return Discriminator; }
1240 static bool classof(const Metadata *MD) {
1241 return MD->getMetadataID() == MDLexicalBlockFileKind;
1245 class MDNamespace : public MDScope {
1246 friend class LLVMContextImpl;
1247 friend class MDNode;
1251 MDNamespace(LLVMContext &Context, StorageType Storage, unsigned Line,
1252 ArrayRef<Metadata *> Ops)
1253 : MDScope(Context, MDNamespaceKind, Storage, dwarf::DW_TAG_namespace,
1258 static MDNamespace *getImpl(LLVMContext &Context, MDScope *Scope,
1259 MDFile *File, StringRef Name, unsigned Line,
1260 StorageType Storage, bool ShouldCreate = true) {
1261 return getImpl(Context, Scope, File, getCanonicalMDString(Context, Name),
1262 Line, Storage, ShouldCreate);
1264 static MDNamespace *getImpl(LLVMContext &Context, Metadata *Scope,
1265 Metadata *File, MDString *Name, unsigned Line,
1266 StorageType Storage, bool ShouldCreate = true);
1268 TempMDNamespace cloneImpl() const {
1269 return getTemporary(getContext(), getScope(), getFile(), getName(),
1274 DEFINE_MDNODE_GET(MDNamespace, (MDScope * Scope, MDFile *File, StringRef Name,
1276 (Scope, File, Name, Line))
1277 DEFINE_MDNODE_GET(MDNamespace, (Metadata * Scope, Metadata *File,
1278 MDString *Name, unsigned Line),
1279 (Scope, File, Name, Line))
1281 TempMDNamespace clone() const { return cloneImpl(); }
1283 unsigned getLine() const { return Line; }
1284 MDScope *getScope() const { return cast_or_null<MDScope>(getRawScope()); }
1285 StringRef getName() const { return getStringOperand(2); }
1287 Metadata *getRawScope() const { return getOperand(1); }
1288 MDString *getRawName() const { return getOperandAs<MDString>(2); }
1290 static bool classof(const Metadata *MD) {
1291 return MD->getMetadataID() == MDNamespaceKind;
1295 /// \brief Base class for template parameters.
1296 class MDTemplateParameter : public DebugNode {
1298 MDTemplateParameter(LLVMContext &Context, unsigned ID, StorageType Storage,
1299 unsigned Tag, ArrayRef<Metadata *> Ops)
1300 : DebugNode(Context, ID, Storage, Tag, Ops) {}
1301 ~MDTemplateParameter() {}
1304 StringRef getName() const { return getStringOperand(0); }
1305 Metadata *getType() const { return getOperand(1); }
1307 MDString *getRawName() const { return getOperandAs<MDString>(0); }
1309 static bool classof(const Metadata *MD) {
1310 return MD->getMetadataID() == MDTemplateTypeParameterKind ||
1311 MD->getMetadataID() == MDTemplateValueParameterKind;
1315 class MDTemplateTypeParameter : public MDTemplateParameter {
1316 friend class LLVMContextImpl;
1317 friend class MDNode;
1319 MDTemplateTypeParameter(LLVMContext &Context, StorageType Storage,
1320 ArrayRef<Metadata *> Ops)
1321 : MDTemplateParameter(Context, MDTemplateTypeParameterKind, Storage,
1322 dwarf::DW_TAG_template_type_parameter, Ops) {}
1323 ~MDTemplateTypeParameter() {}
1325 static MDTemplateTypeParameter *getImpl(LLVMContext &Context, StringRef Name,
1326 Metadata *Type, StorageType Storage,
1327 bool ShouldCreate = true) {
1328 return getImpl(Context, getCanonicalMDString(Context, Name), Type, Storage,
1331 static MDTemplateTypeParameter *getImpl(LLVMContext &Context, MDString *Name,
1332 Metadata *Type, StorageType Storage,
1333 bool ShouldCreate = true);
1335 TempMDTemplateTypeParameter cloneImpl() const {
1336 return getTemporary(getContext(), getName(), getType());
1340 DEFINE_MDNODE_GET(MDTemplateTypeParameter, (StringRef Name, Metadata *Type),
1342 DEFINE_MDNODE_GET(MDTemplateTypeParameter, (MDString * Name, Metadata *Type),
1345 TempMDTemplateTypeParameter clone() const { return cloneImpl(); }
1347 static bool classof(const Metadata *MD) {
1348 return MD->getMetadataID() == MDTemplateTypeParameterKind;
1352 class MDTemplateValueParameter : public MDTemplateParameter {
1353 friend class LLVMContextImpl;
1354 friend class MDNode;
1356 MDTemplateValueParameter(LLVMContext &Context, StorageType Storage,
1357 unsigned Tag, ArrayRef<Metadata *> Ops)
1358 : MDTemplateParameter(Context, MDTemplateValueParameterKind, Storage, Tag,
1360 ~MDTemplateValueParameter() {}
1362 static MDTemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
1363 StringRef Name, Metadata *Type,
1364 Metadata *Value, StorageType Storage,
1365 bool ShouldCreate = true) {
1366 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), Type,
1367 Value, Storage, ShouldCreate);
1369 static MDTemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
1370 MDString *Name, Metadata *Type,
1371 Metadata *Value, StorageType Storage,
1372 bool ShouldCreate = true);
1374 TempMDTemplateValueParameter cloneImpl() const {
1375 return getTemporary(getContext(), getTag(), getName(), getType(),
1380 DEFINE_MDNODE_GET(MDTemplateValueParameter, (unsigned Tag, StringRef Name,
1381 Metadata *Type, Metadata *Value),
1382 (Tag, Name, Type, Value))
1383 DEFINE_MDNODE_GET(MDTemplateValueParameter, (unsigned Tag, MDString *Name,
1384 Metadata *Type, Metadata *Value),
1385 (Tag, Name, Type, Value))
1387 TempMDTemplateValueParameter clone() const { return cloneImpl(); }
1389 Metadata *getValue() const { return getOperand(2); }
1391 static bool classof(const Metadata *MD) {
1392 return MD->getMetadataID() == MDTemplateValueParameterKind;
1396 /// \brief Base class for variables.
1398 /// TODO: Hardcode to DW_TAG_variable.
1399 class MDVariable : public DebugNode {
1403 MDVariable(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
1404 unsigned Line, ArrayRef<Metadata *> Ops)
1405 : DebugNode(C, ID, Storage, Tag, Ops), Line(Line) {}
1409 unsigned getLine() const { return Line; }
1410 MDScope *getScope() const { return cast_or_null<MDScope>(getRawScope()); }
1411 StringRef getName() const { return getStringOperand(1); }
1412 MDFile *getFile() const { return cast_or_null<MDFile>(getRawFile()); }
1413 Metadata *getType() const { return getRawType(); }
1415 Metadata *getRawScope() const { return getOperand(0); }
1416 MDString *getRawName() const { return getOperandAs<MDString>(1); }
1417 Metadata *getRawFile() const { return getOperand(2); }
1418 Metadata *getRawType() const { return getOperand(3); }
1420 static bool classof(const Metadata *MD) {
1421 return MD->getMetadataID() == MDLocalVariableKind ||
1422 MD->getMetadataID() == MDGlobalVariableKind;
1426 /// \brief Global variables.
1428 /// TODO: Remove DisplayName. It's always equal to Name.
1429 class MDGlobalVariable : public MDVariable {
1430 friend class LLVMContextImpl;
1431 friend class MDNode;
1436 MDGlobalVariable(LLVMContext &C, StorageType Storage, unsigned Line,
1437 bool IsLocalToUnit, bool IsDefinition,
1438 ArrayRef<Metadata *> Ops)
1439 : MDVariable(C, MDGlobalVariableKind, Storage, dwarf::DW_TAG_variable,
1441 IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition) {}
1442 ~MDGlobalVariable() {}
1444 static MDGlobalVariable *
1445 getImpl(LLVMContext &Context, MDScope *Scope, StringRef Name,
1446 StringRef LinkageName, MDFile *File, unsigned Line, Metadata *Type,
1447 bool IsLocalToUnit, bool IsDefinition, ConstantAsMetadata *Variable,
1448 MDDerivedType *StaticDataMemberDeclaration, StorageType Storage,
1449 bool ShouldCreate = true) {
1450 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
1451 getCanonicalMDString(Context, LinkageName), File, Line, Type,
1452 IsLocalToUnit, IsDefinition, Variable,
1453 StaticDataMemberDeclaration, Storage, ShouldCreate);
1455 static MDGlobalVariable *
1456 getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
1457 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
1458 bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
1459 Metadata *StaticDataMemberDeclaration, StorageType Storage,
1460 bool ShouldCreate = true);
1462 TempMDGlobalVariable cloneImpl() const {
1463 return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
1464 getFile(), getLine(), getType(), isLocalToUnit(),
1465 isDefinition(), getVariable(),
1466 getStaticDataMemberDeclaration());
1470 DEFINE_MDNODE_GET(MDGlobalVariable,
1471 (MDScope * Scope, StringRef Name, StringRef LinkageName,
1472 MDFile *File, unsigned Line, Metadata *Type,
1473 bool IsLocalToUnit, bool IsDefinition,
1474 ConstantAsMetadata *Variable,
1475 MDDerivedType *StaticDataMemberDeclaration),
1476 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
1477 IsDefinition, Variable, StaticDataMemberDeclaration))
1478 DEFINE_MDNODE_GET(MDGlobalVariable,
1479 (Metadata * Scope, MDString *Name, MDString *LinkageName,
1480 Metadata *File, unsigned Line, Metadata *Type,
1481 bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
1482 Metadata *StaticDataMemberDeclaration),
1483 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
1484 IsDefinition, Variable, StaticDataMemberDeclaration))
1486 TempMDGlobalVariable clone() const { return cloneImpl(); }
1488 bool isLocalToUnit() const { return IsLocalToUnit; }
1489 bool isDefinition() const { return IsDefinition; }
1490 StringRef getDisplayName() const { return getStringOperand(4); }
1491 StringRef getLinkageName() const { return getStringOperand(5); }
1492 ConstantAsMetadata *getVariable() const {
1493 return cast_or_null<ConstantAsMetadata>(getRawVariable());
1495 MDDerivedType *getStaticDataMemberDeclaration() const {
1496 return cast_or_null<MDDerivedType>(getRawStaticDataMemberDeclaration());
1499 MDString *getRawLinkageName() const { return getOperandAs<MDString>(5); }
1500 Metadata *getRawVariable() const { return getOperand(6); }
1501 Metadata *getRawStaticDataMemberDeclaration() const { return getOperand(7); }
1503 static bool classof(const Metadata *MD) {
1504 return MD->getMetadataID() == MDGlobalVariableKind;
1508 /// \brief Local variable.
1510 /// TODO: Split between arguments and otherwise.
1511 /// TODO: Use \c DW_TAG_variable instead of fake tags.
1512 /// TODO: Split up flags.
1513 class MDLocalVariable : public MDVariable {
1514 friend class LLVMContextImpl;
1515 friend class MDNode;
1520 MDLocalVariable(LLVMContext &C, StorageType Storage, unsigned Tag,
1521 unsigned Line, unsigned Arg, unsigned Flags,
1522 ArrayRef<Metadata *> Ops)
1523 : MDVariable(C, MDLocalVariableKind, Storage, Tag, Line, Ops), Arg(Arg),
1525 ~MDLocalVariable() {}
1527 static MDLocalVariable *getImpl(LLVMContext &Context, unsigned Tag,
1528 MDScope *Scope, StringRef Name, MDFile *File,
1529 unsigned Line, Metadata *Type, unsigned Arg,
1530 unsigned Flags, MDLocation *InlinedAt,
1531 StorageType Storage,
1532 bool ShouldCreate = true) {
1533 return getImpl(Context, Tag, Scope, getCanonicalMDString(Context, Name),
1534 File, Line, Type, Arg, Flags, InlinedAt, Storage,
1537 static MDLocalVariable *getImpl(LLVMContext &Context, unsigned Tag,
1538 Metadata *Scope, MDString *Name,
1539 Metadata *File, unsigned Line, Metadata *Type,
1540 unsigned Arg, unsigned Flags,
1541 Metadata *InlinedAt, StorageType Storage,
1542 bool ShouldCreate = true);
1544 TempMDLocalVariable cloneImpl() const {
1545 return getTemporary(getContext(), getTag(), getScope(), getName(),
1546 getFile(), getLine(), getType(), getArg(), getFlags(),
1551 DEFINE_MDNODE_GET(MDLocalVariable,
1552 (unsigned Tag, MDLocalScope *Scope, StringRef Name,
1553 MDFile *File, unsigned Line, Metadata *Type, unsigned Arg,
1554 unsigned Flags, MDLocation *InlinedAt = nullptr),
1555 (Tag, Scope, Name, File, Line, Type, Arg, Flags, InlinedAt))
1556 DEFINE_MDNODE_GET(MDLocalVariable,
1557 (unsigned Tag, Metadata *Scope, MDString *Name,
1558 Metadata *File, unsigned Line, Metadata *Type,
1559 unsigned Arg, unsigned Flags,
1560 Metadata *InlinedAt = nullptr),
1561 (Tag, Scope, Name, File, Line, Type, Arg, Flags, InlinedAt))
1563 TempMDLocalVariable clone() const { return cloneImpl(); }
1565 /// \brief Get the local scope for this variable.
1567 /// Variables must be defined in a local scope.
1568 MDLocalScope *getScope() const {
1569 return cast<MDLocalScope>(MDVariable::getScope());
1572 unsigned getArg() const { return Arg; }
1573 unsigned getFlags() const { return Flags; }
1574 MDLocation *getInlinedAt() const {
1575 return cast_or_null<MDLocation>(getRawInlinedAt());
1578 Metadata *getRawInlinedAt() const { return getOperand(4); }
1580 /// \brief Get an inlined version of this variable.
1582 /// Returns a version of this with \a getAlinedAt() set to \c InlinedAt.
1583 MDLocalVariable *withInline(MDLocation *InlinedAt) const {
1584 if (InlinedAt == getInlinedAt())
1585 return const_cast<MDLocalVariable *>(this);
1586 auto Temp = clone();
1587 Temp->replaceOperandWith(4, InlinedAt);
1588 return replaceWithUniqued(std::move(Temp));
1590 MDLocalVariable *withoutInline() const { return withInline(nullptr); }
1592 static bool classof(const Metadata *MD) {
1593 return MD->getMetadataID() == MDLocalVariableKind;
1597 /// \brief DWARF expression.
1599 /// TODO: Co-allocate the expression elements.
1600 /// TODO: Separate from MDNode, or otherwise drop Distinct and Temporary
1602 class MDExpression : public MDNode {
1603 friend class LLVMContextImpl;
1604 friend class MDNode;
1606 std::vector<uint64_t> Elements;
1608 MDExpression(LLVMContext &C, StorageType Storage, ArrayRef<uint64_t> Elements)
1609 : MDNode(C, MDExpressionKind, Storage, None),
1610 Elements(Elements.begin(), Elements.end()) {}
1613 static MDExpression *getImpl(LLVMContext &Context,
1614 ArrayRef<uint64_t> Elements, StorageType Storage,
1615 bool ShouldCreate = true);
1617 TempMDExpression cloneImpl() const {
1618 return getTemporary(getContext(), getElements());
1622 DEFINE_MDNODE_GET(MDExpression, (ArrayRef<uint64_t> Elements), (Elements))
1624 TempMDExpression clone() const { return cloneImpl(); }
1626 ArrayRef<uint64_t> getElements() const { return Elements; }
1628 unsigned getNumElements() const { return Elements.size(); }
1629 uint64_t getElement(unsigned I) const {
1630 assert(I < Elements.size() && "Index out of range");
1634 typedef ArrayRef<uint64_t>::iterator element_iterator;
1635 element_iterator elements_begin() const { return getElements().begin(); }
1636 element_iterator elements_end() const { return getElements().end(); }
1638 /// \brief A lightweight wrapper around an expression operand.
1640 /// TODO: Store arguments directly and change \a MDExpression to store a
1646 explicit ExprOperand(const uint64_t *Op) : Op(Op) {}
1648 const uint64_t *get() const { return Op; }
1650 /// \brief Get the operand code.
1651 uint64_t getOp() const { return *Op; }
1653 /// \brief Get an argument to the operand.
1655 /// Never returns the operand itself.
1656 uint64_t getArg(unsigned I) const { return Op[I + 1]; }
1658 unsigned getNumArgs() const { return getSize() - 1; }
1660 /// \brief Return the size of the operand.
1662 /// Return the number of elements in the operand (1 + args).
1663 unsigned getSize() const;
1666 /// \brief An iterator for expression operands.
1667 class expr_op_iterator
1668 : public std::iterator<std::input_iterator_tag, ExprOperand> {
1672 explicit expr_op_iterator(element_iterator I) : Op(I) {}
1674 element_iterator getBase() const { return Op.get(); }
1675 const ExprOperand &operator*() const { return Op; }
1676 const ExprOperand *operator->() const { return &Op; }
1678 expr_op_iterator &operator++() {
1682 expr_op_iterator operator++(int) {
1683 expr_op_iterator T(*this);
1688 bool operator==(const expr_op_iterator &X) const {
1689 return getBase() == X.getBase();
1691 bool operator!=(const expr_op_iterator &X) const {
1692 return getBase() != X.getBase();
1696 void increment() { Op = ExprOperand(getBase() + Op.getSize()); }
1699 /// \brief Visit the elements via ExprOperand wrappers.
1701 /// These range iterators visit elements through \a ExprOperand wrappers.
1702 /// This is not guaranteed to be a valid range unless \a isValid() gives \c
1705 /// \pre \a isValid() gives \c true.
1707 expr_op_iterator expr_op_begin() const {
1708 return expr_op_iterator(elements_begin());
1710 expr_op_iterator expr_op_end() const {
1711 return expr_op_iterator(elements_end());
1715 bool isValid() const;
1717 static bool classof(const Metadata *MD) {
1718 return MD->getMetadataID() == MDExpressionKind;
1722 class MDObjCProperty : public DebugNode {
1723 friend class LLVMContextImpl;
1724 friend class MDNode;
1727 unsigned Attributes;
1729 MDObjCProperty(LLVMContext &C, StorageType Storage, unsigned Line,
1730 unsigned Attributes, ArrayRef<Metadata *> Ops)
1731 : DebugNode(C, MDObjCPropertyKind, Storage, dwarf::DW_TAG_APPLE_property,
1733 Line(Line), Attributes(Attributes) {}
1734 ~MDObjCProperty() {}
1736 static MDObjCProperty *
1737 getImpl(LLVMContext &Context, StringRef Name, MDFile *File, unsigned Line,
1738 StringRef GetterName, StringRef SetterName, unsigned Attributes,
1739 MDType *Type, StorageType Storage, bool ShouldCreate = true) {
1740 return getImpl(Context, getCanonicalMDString(Context, Name), File, Line,
1741 getCanonicalMDString(Context, GetterName),
1742 getCanonicalMDString(Context, SetterName), Attributes, Type,
1743 Storage, ShouldCreate);
1745 static MDObjCProperty *getImpl(LLVMContext &Context, MDString *Name,
1746 Metadata *File, unsigned Line,
1747 MDString *GetterName, MDString *SetterName,
1748 unsigned Attributes, Metadata *Type,
1749 StorageType Storage, bool ShouldCreate = true);
1751 TempMDObjCProperty cloneImpl() const {
1752 return getTemporary(getContext(), getName(), getFile(), getLine(),
1753 getGetterName(), getSetterName(), getAttributes(),
1758 DEFINE_MDNODE_GET(MDObjCProperty,
1759 (StringRef Name, MDFile *File, unsigned Line,
1760 StringRef GetterName, StringRef SetterName,
1761 unsigned Attributes, MDType *Type),
1762 (Name, File, Line, GetterName, SetterName, Attributes,
1764 DEFINE_MDNODE_GET(MDObjCProperty,
1765 (MDString * Name, Metadata *File, unsigned Line,
1766 MDString *GetterName, MDString *SetterName,
1767 unsigned Attributes, Metadata *Type),
1768 (Name, File, Line, GetterName, SetterName, Attributes,
1771 TempMDObjCProperty clone() const { return cloneImpl(); }
1773 unsigned getLine() const { return Line; }
1774 unsigned getAttributes() const { return Attributes; }
1775 StringRef getName() const { return getStringOperand(0); }
1776 MDFile *getFile() const { return cast_or_null<MDFile>(getRawFile()); }
1777 StringRef getGetterName() const { return getStringOperand(2); }
1778 StringRef getSetterName() const { return getStringOperand(3); }
1779 MDType *getType() const { return cast_or_null<MDType>(getRawType()); }
1781 MDString *getRawName() const { return getOperandAs<MDString>(0); }
1782 Metadata *getRawFile() const { return getOperand(1); }
1783 MDString *getRawGetterName() const { return getOperandAs<MDString>(2); }
1784 MDString *getRawSetterName() const { return getOperandAs<MDString>(3); }
1785 Metadata *getRawType() const { return getOperand(4); }
1787 static bool classof(const Metadata *MD) {
1788 return MD->getMetadataID() == MDObjCPropertyKind;
1792 class MDImportedEntity : public DebugNode {
1793 friend class LLVMContextImpl;
1794 friend class MDNode;
1798 MDImportedEntity(LLVMContext &C, StorageType Storage, unsigned Tag,
1799 unsigned Line, ArrayRef<Metadata *> Ops)
1800 : DebugNode(C, MDImportedEntityKind, Storage, Tag, Ops), Line(Line) {}
1801 ~MDImportedEntity() {}
1803 static MDImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
1804 MDScope *Scope, Metadata *Entity,
1805 unsigned Line, StringRef Name,
1806 StorageType Storage,
1807 bool ShouldCreate = true) {
1808 return getImpl(Context, Tag, Scope, Entity, Line,
1809 getCanonicalMDString(Context, Name), Storage, ShouldCreate);
1811 static MDImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
1812 Metadata *Scope, Metadata *Entity,
1813 unsigned Line, MDString *Name,
1814 StorageType Storage,
1815 bool ShouldCreate = true);
1817 TempMDImportedEntity cloneImpl() const {
1818 return getTemporary(getContext(), getTag(), getScope(), getEntity(),
1819 getLine(), getName());
1823 DEFINE_MDNODE_GET(MDImportedEntity,
1824 (unsigned Tag, MDScope *Scope, Metadata *Entity,
1825 unsigned Line, StringRef Name = ""),
1826 (Tag, Scope, Entity, Line, Name))
1827 DEFINE_MDNODE_GET(MDImportedEntity,
1828 (unsigned Tag, Metadata *Scope, Metadata *Entity,
1829 unsigned Line, MDString *Name),
1830 (Tag, Scope, Entity, Line, Name))
1832 TempMDImportedEntity clone() const { return cloneImpl(); }
1834 unsigned getLine() const { return Line; }
1835 MDScope *getScope() const { return cast_or_null<MDScope>(getRawScope()); }
1836 Metadata *getEntity() const { return getRawEntity(); }
1837 StringRef getName() const { return getStringOperand(2); }
1839 Metadata *getRawScope() const { return getOperand(0); }
1840 Metadata *getRawEntity() const { return getOperand(1); }
1841 MDString *getRawName() const { return getOperandAs<MDString>(2); }
1843 static bool classof(const Metadata *MD) {
1844 return MD->getMetadataID() == MDImportedEntityKind;
1848 } // end namespace llvm
1850 #undef DEFINE_MDNODE_GET_UNPACK_IMPL
1851 #undef DEFINE_MDNODE_GET_UNPACK
1852 #undef DEFINE_MDNODE_GET