1 //===--- DIBuilder.cpp - Debug Information Builder ------------------------===//
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 // This file implements the DIBuilder.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/IR/DIBuilder.h"
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/IR/Constants.h"
17 #include "llvm/IR/DebugInfo.h"
18 #include "llvm/IR/IntrinsicInst.h"
19 #include "llvm/IR/Module.h"
20 #include "llvm/Support/Debug.h"
21 #include "llvm/Support/Dwarf.h"
24 using namespace llvm::dwarf;
28 SmallVector<char, 256> Chars;
31 explicit HeaderBuilder(Twine T) { T.toVector(Chars); }
32 HeaderBuilder(const HeaderBuilder &X) : Chars(X.Chars) {}
33 HeaderBuilder(HeaderBuilder &&X) : Chars(std::move(X.Chars)) {}
35 template <class Twineable> HeaderBuilder &concat(Twineable &&X) {
37 Twine(X).toVector(Chars);
41 MDString *get(LLVMContext &Context) const {
42 return MDString::get(Context, StringRef(Chars.begin(), Chars.size()));
45 static HeaderBuilder get(unsigned Tag) {
46 return HeaderBuilder("0x" + Twine::utohexstr(Tag));
51 DIBuilder::DIBuilder(Module &m, bool AllowUnresolvedNodes)
52 : M(m), VMContext(M.getContext()), TempEnumTypes(nullptr),
53 TempRetainTypes(nullptr), TempSubprograms(nullptr), TempGVs(nullptr),
54 DeclareFn(nullptr), ValueFn(nullptr),
55 AllowUnresolvedNodes(AllowUnresolvedNodes) {}
57 static bool isUnresolved(MDNode *N) { return N && !N->isResolved(); }
59 void DIBuilder::trackIfUnresolved(MDNode *N) {
60 if (!AllowUnresolvedNodes) {
61 assert(!isUnresolved(N) && "Cannot handle unresolved nodes");
65 UnresolvedNodes.emplace_back(N);
69 void DIBuilder::finalize() {
70 DIArray Enums = getOrCreateArray(AllEnumTypes);
71 DIType(TempEnumTypes).replaceAllUsesWith(Enums);
73 SmallVector<Metadata *, 16> RetainValues;
74 // Declarations and definitions of the same type may be retained. Some
75 // clients RAUW these pairs, leaving duplicates in the retained types
76 // list. Use a set to remove the duplicates while we transform the
77 // TrackingVHs back into Values.
78 SmallPtrSet<Metadata *, 16> RetainSet;
79 for (unsigned I = 0, E = AllRetainTypes.size(); I < E; I++)
80 if (RetainSet.insert(AllRetainTypes[I]).second)
81 RetainValues.push_back(AllRetainTypes[I]);
82 DIArray RetainTypes = getOrCreateArray(RetainValues);
83 DIType(TempRetainTypes).replaceAllUsesWith(RetainTypes);
85 DIArray SPs = getOrCreateArray(AllSubprograms);
86 DIType(TempSubprograms).replaceAllUsesWith(SPs);
87 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) {
88 DISubprogram SP(SPs.getElement(i));
89 if (MDNode *Temp = SP.getVariablesNodes()) {
90 SmallVector<Metadata *, 4> Variables;
91 for (Metadata *V : PreservedVariables.lookup(SP))
92 Variables.push_back(V);
93 DIArray AV = getOrCreateArray(Variables);
94 DIType(Temp).replaceAllUsesWith(AV);
98 DIArray GVs = getOrCreateArray(AllGVs);
99 DIType(TempGVs).replaceAllUsesWith(GVs);
101 SmallVector<Metadata *, 16> RetainValuesI;
102 for (unsigned I = 0, E = AllImportedModules.size(); I < E; I++)
103 RetainValuesI.push_back(AllImportedModules[I]);
104 DIArray IMs = getOrCreateArray(RetainValuesI);
105 DIType(TempImportedModules).replaceAllUsesWith(IMs);
107 // Now that all temp nodes have been replaced or deleted, resolve remaining
109 for (const auto &N : UnresolvedNodes)
111 cast<UniquableMDNode>(N)->resolveCycles();
112 UnresolvedNodes.clear();
114 // Can't handle unresolved nodes anymore.
115 AllowUnresolvedNodes = false;
118 /// If N is compile unit return NULL otherwise return N.
119 static MDNode *getNonCompileUnitScope(MDNode *N) {
120 if (DIDescriptor(N).isCompileUnit())
125 static MDNode *createFilePathPair(LLVMContext &VMContext, StringRef Filename,
126 StringRef Directory) {
127 assert(!Filename.empty() && "Unable to create file without name");
128 Metadata *Pair[] = {MDString::get(VMContext, Filename),
129 MDString::get(VMContext, Directory)};
130 return MDNode::get(VMContext, Pair);
133 DICompileUnit DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename,
135 StringRef Producer, bool isOptimized,
136 StringRef Flags, unsigned RunTimeVer,
138 DebugEmissionKind Kind,
139 bool EmitDebugInfo) {
141 assert(((Lang <= dwarf::DW_LANG_OCaml && Lang >= dwarf::DW_LANG_C89) ||
142 (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) &&
143 "Invalid Language tag");
144 assert(!Filename.empty() &&
145 "Unable to create compile unit without filename");
146 Metadata *TElts[] = {HeaderBuilder::get(DW_TAG_base_type).get(VMContext)};
147 TempEnumTypes = MDNode::getTemporary(VMContext, TElts);
149 TempRetainTypes = MDNode::getTemporary(VMContext, TElts);
151 TempSubprograms = MDNode::getTemporary(VMContext, TElts);
153 TempGVs = MDNode::getTemporary(VMContext, TElts);
155 TempImportedModules = MDNode::getTemporary(VMContext, TElts);
157 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_compile_unit)
166 createFilePathPair(VMContext, Filename, Directory),
167 TempEnumTypes, TempRetainTypes, TempSubprograms, TempGVs,
168 TempImportedModules};
170 MDNode *CUNode = MDNode::get(VMContext, Elts);
172 // Create a named metadata so that it is easier to find cu in a module.
173 // Note that we only generate this when the caller wants to actually
174 // emit debug information. When we are only interested in tracking
175 // source line locations throughout the backend, we prevent codegen from
176 // emitting debug info in the final output by not generating llvm.dbg.cu.
178 NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
179 NMD->addOperand(CUNode);
182 trackIfUnresolved(CUNode);
183 return DICompileUnit(CUNode);
186 static DIImportedEntity
187 createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope Context,
188 Metadata *NS, unsigned Line, StringRef Name,
189 SmallVectorImpl<TrackingMDNodeRef> &AllImportedModules) {
191 Metadata *Elts[] = {HeaderBuilder::get(Tag).concat(Line).concat(Name).get(C),
193 R = MDNode::get(C, Elts);
194 DIImportedEntity M(R);
195 assert(M.Verify() && "Imported module should be valid");
196 AllImportedModules.emplace_back(M.get());
200 DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
203 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
204 Context, NS, Line, StringRef(), AllImportedModules);
207 DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
210 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
211 Context, NS, Line, StringRef(), AllImportedModules);
214 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
216 unsigned Line, StringRef Name) {
217 // Make sure to use the unique identifier based metadata reference for
218 // types that have one.
220 Decl.isType() ? static_cast<Metadata *>(DIType(Decl).getRef()) : Decl;
221 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
222 Context, V, Line, Name,
226 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
227 DIImportedEntity Imp,
228 unsigned Line, StringRef Name) {
229 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
230 Context, Imp, Line, Name, AllImportedModules);
233 DIFile DIBuilder::createFile(StringRef Filename, StringRef Directory) {
235 HeaderBuilder::get(dwarf::DW_TAG_file_type).get(VMContext),
236 createFilePathPair(VMContext, Filename, Directory)};
237 return DIFile(MDNode::get(VMContext, Elts));
240 DIEnumerator DIBuilder::createEnumerator(StringRef Name, int64_t Val) {
241 assert(!Name.empty() && "Unable to create enumerator without name");
242 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_enumerator)
246 return DIEnumerator(MDNode::get(VMContext, Elts));
249 DIBasicType DIBuilder::createUnspecifiedType(StringRef Name) {
250 assert(!Name.empty() && "Unable to create type without name");
251 // Unspecified types are encoded in DIBasicType format. Line number, filename,
252 // size, alignment, offset and flags are always empty here.
254 HeaderBuilder::get(dwarf::DW_TAG_unspecified_type)
266 return DIBasicType(MDNode::get(VMContext, Elts));
269 DIBasicType DIBuilder::createNullPtrType() {
270 return createUnspecifiedType("decltype(nullptr)");
274 DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
275 uint64_t AlignInBits, unsigned Encoding) {
276 assert(!Name.empty() && "Unable to create type without name");
277 // Basic types are encoded in DIBasicType format. Line number, filename,
278 // offset and flags are always empty here.
280 HeaderBuilder::get(dwarf::DW_TAG_base_type)
292 return DIBasicType(MDNode::get(VMContext, Elts));
295 DIDerivedType DIBuilder::createQualifiedType(unsigned Tag, DIType FromTy) {
296 // Qualified types are encoded in DIDerivedType format.
297 Metadata *Elts[] = {HeaderBuilder::get(Tag)
298 .concat(StringRef()) // Name
308 return DIDerivedType(MDNode::get(VMContext, Elts));
312 DIBuilder::createPointerType(DIType PointeeTy, uint64_t SizeInBits,
313 uint64_t AlignInBits, StringRef Name) {
314 // Pointer types are encoded in DIDerivedType format.
315 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_pointer_type)
326 return DIDerivedType(MDNode::get(VMContext, Elts));
330 DIBuilder::createMemberPointerType(DIType PointeeTy, DIType Base,
331 uint64_t SizeInBits, uint64_t AlignInBits) {
332 // Pointer types are encoded in DIDerivedType format.
333 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_ptr_to_member_type)
336 .concat(SizeInBits) // Size
337 .concat(AlignInBits) // Align
343 PointeeTy.getRef(), Base.getRef()};
344 return DIDerivedType(MDNode::get(VMContext, Elts));
347 DIDerivedType DIBuilder::createReferenceType(unsigned Tag, DIType RTy) {
348 assert(RTy.isType() && "Unable to create reference type");
349 // References are encoded in DIDerivedType format.
350 Metadata *Elts[] = {HeaderBuilder::get(Tag)
351 .concat(StringRef()) // Name
361 return DIDerivedType(MDNode::get(VMContext, Elts));
364 DIDerivedType DIBuilder::createTypedef(DIType Ty, StringRef Name, DIFile File,
365 unsigned LineNo, DIDescriptor Context) {
366 // typedefs are encoded in DIDerivedType format.
367 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_typedef)
376 DIScope(getNonCompileUnitScope(Context)).getRef(),
378 return DIDerivedType(MDNode::get(VMContext, Elts));
381 DIDerivedType DIBuilder::createFriend(DIType Ty, DIType FriendTy) {
382 // typedefs are encoded in DIDerivedType format.
383 assert(Ty.isType() && "Invalid type!");
384 assert(FriendTy.isType() && "Invalid friend type!");
385 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_friend)
386 .concat(StringRef()) // Name
393 nullptr, Ty.getRef(), FriendTy.getRef()};
394 return DIDerivedType(MDNode::get(VMContext, Elts));
397 DIDerivedType DIBuilder::createInheritance(DIType Ty, DIType BaseTy,
400 assert(Ty.isType() && "Unable to create inheritance");
401 // TAG_inheritance is encoded in DIDerivedType format.
402 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_inheritance)
403 .concat(StringRef()) // Name
410 nullptr, Ty.getRef(), BaseTy.getRef()};
411 return DIDerivedType(MDNode::get(VMContext, Elts));
414 DIDerivedType DIBuilder::createMemberType(DIDescriptor Scope, StringRef Name,
415 DIFile File, unsigned LineNumber,
417 uint64_t AlignInBits,
418 uint64_t OffsetInBits, unsigned Flags,
420 // TAG_member is encoded in DIDerivedType format.
421 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
426 .concat(OffsetInBits)
430 DIScope(getNonCompileUnitScope(Scope)).getRef(),
432 return DIDerivedType(MDNode::get(VMContext, Elts));
435 static Metadata *getConstantOrNull(Constant *C) {
437 return ConstantAsMetadata::get(C);
441 DIDerivedType DIBuilder::createStaticMemberType(DIDescriptor Scope,
442 StringRef Name, DIFile File,
443 unsigned LineNumber, DIType Ty,
445 llvm::Constant *Val) {
446 // TAG_member is encoded in DIDerivedType format.
447 Flags |= DIDescriptor::FlagStaticMember;
448 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
457 DIScope(getNonCompileUnitScope(Scope)).getRef(),
458 Ty.getRef(), getConstantOrNull(Val)};
459 return DIDerivedType(MDNode::get(VMContext, Elts));
462 DIDerivedType DIBuilder::createObjCIVar(StringRef Name, DIFile File,
465 uint64_t AlignInBits,
466 uint64_t OffsetInBits, unsigned Flags,
467 DIType Ty, MDNode *PropertyNode) {
468 // TAG_member is encoded in DIDerivedType format.
469 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
474 .concat(OffsetInBits)
477 File.getFileNode(), getNonCompileUnitScope(File), Ty,
479 return DIDerivedType(MDNode::get(VMContext, Elts));
483 DIBuilder::createObjCProperty(StringRef Name, DIFile File, unsigned LineNumber,
484 StringRef GetterName, StringRef SetterName,
485 unsigned PropertyAttributes, DIType Ty) {
486 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_APPLE_property)
491 .concat(PropertyAttributes)
494 return DIObjCProperty(MDNode::get(VMContext, Elts));
497 DITemplateTypeParameter
498 DIBuilder::createTemplateTypeParameter(DIDescriptor Context, StringRef Name,
499 DIType Ty, MDNode *File, unsigned LineNo,
501 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_template_type_parameter)
506 DIScope(getNonCompileUnitScope(Context)).getRef(),
508 return DITemplateTypeParameter(MDNode::get(VMContext, Elts));
511 static DITemplateValueParameter createTemplateValueParameterHelper(
512 LLVMContext &VMContext, unsigned Tag, DIDescriptor Context, StringRef Name,
513 DIType Ty, Metadata *MD, MDNode *File, unsigned LineNo, unsigned ColumnNo) {
515 HeaderBuilder::get(Tag).concat(Name).concat(LineNo).concat(ColumnNo).get(
517 DIScope(getNonCompileUnitScope(Context)).getRef(), Ty.getRef(), MD, File};
518 return DITemplateValueParameter(MDNode::get(VMContext, Elts));
521 DITemplateValueParameter
522 DIBuilder::createTemplateValueParameter(DIDescriptor Context, StringRef Name,
523 DIType Ty, Constant *Val, MDNode *File,
524 unsigned LineNo, unsigned ColumnNo) {
525 return createTemplateValueParameterHelper(
526 VMContext, dwarf::DW_TAG_template_value_parameter, Context, Name, Ty,
527 getConstantOrNull(Val), File, LineNo, ColumnNo);
530 DITemplateValueParameter
531 DIBuilder::createTemplateTemplateParameter(DIDescriptor Context, StringRef Name,
532 DIType Ty, StringRef Val,
533 MDNode *File, unsigned LineNo,
535 return createTemplateValueParameterHelper(
536 VMContext, dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
537 MDString::get(VMContext, Val), File, LineNo, ColumnNo);
540 DITemplateValueParameter
541 DIBuilder::createTemplateParameterPack(DIDescriptor Context, StringRef Name,
542 DIType Ty, DIArray Val,
543 MDNode *File, unsigned LineNo,
545 return createTemplateValueParameterHelper(
546 VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
547 Val, File, LineNo, ColumnNo);
550 DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
551 DIFile File, unsigned LineNumber,
553 uint64_t AlignInBits,
554 uint64_t OffsetInBits,
555 unsigned Flags, DIType DerivedFrom,
558 MDNode *TemplateParams,
559 StringRef UniqueIdentifier) {
560 assert((!Context || Context.isScope() || Context.isType()) &&
561 "createClassType should be called with a valid Context");
562 // TAG_class_type is encoded in DICompositeType format.
564 HeaderBuilder::get(dwarf::DW_TAG_class_type)
569 .concat(OffsetInBits)
573 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
574 DerivedFrom.getRef(), Elements, VTableHolder.getRef(), TemplateParams,
575 UniqueIdentifier.empty() ? nullptr
576 : MDString::get(VMContext, UniqueIdentifier)};
577 DICompositeType R(MDNode::get(VMContext, Elts));
578 assert(R.isCompositeType() &&
579 "createClassType should return a DICompositeType");
580 if (!UniqueIdentifier.empty())
585 DICompositeType DIBuilder::createStructType(DIDescriptor Context,
586 StringRef Name, DIFile File,
589 uint64_t AlignInBits,
590 unsigned Flags, DIType DerivedFrom,
592 unsigned RunTimeLang,
594 StringRef UniqueIdentifier) {
595 // TAG_structure_type is encoded in DICompositeType format.
597 HeaderBuilder::get(dwarf::DW_TAG_structure_type)
606 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
607 DerivedFrom.getRef(), Elements, VTableHolder.getRef(), nullptr,
608 UniqueIdentifier.empty() ? nullptr
609 : MDString::get(VMContext, UniqueIdentifier)};
610 DICompositeType R(MDNode::get(VMContext, Elts));
611 assert(R.isCompositeType() &&
612 "createStructType should return a DICompositeType");
613 if (!UniqueIdentifier.empty())
618 DICompositeType DIBuilder::createUnionType(DIDescriptor Scope, StringRef Name,
619 DIFile File, unsigned LineNumber,
621 uint64_t AlignInBits, unsigned Flags,
623 unsigned RunTimeLang,
624 StringRef UniqueIdentifier) {
625 // TAG_union_type is encoded in DICompositeType format.
627 HeaderBuilder::get(dwarf::DW_TAG_union_type)
636 File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
637 nullptr, Elements, nullptr, nullptr,
638 UniqueIdentifier.empty() ? nullptr
639 : MDString::get(VMContext, UniqueIdentifier)};
640 DICompositeType R(MDNode::get(VMContext, Elts));
641 if (!UniqueIdentifier.empty())
646 DISubroutineType DIBuilder::createSubroutineType(DIFile File,
647 DITypeArray ParameterTypes,
649 // TAG_subroutine_type is encoded in DICompositeType format.
651 HeaderBuilder::get(dwarf::DW_TAG_subroutine_type)
657 .concat(Flags) // Flags
660 nullptr, nullptr, nullptr, ParameterTypes, nullptr, nullptr,
661 nullptr // Type Identifer
663 return DISubroutineType(MDNode::get(VMContext, Elts));
666 DICompositeType DIBuilder::createEnumerationType(
667 DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
668 uint64_t SizeInBits, uint64_t AlignInBits, DIArray Elements,
669 DIType UnderlyingType, StringRef UniqueIdentifier) {
670 // TAG_enumeration_type is encoded in DICompositeType format.
672 HeaderBuilder::get(dwarf::DW_TAG_enumeration_type)
681 File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
682 UnderlyingType.getRef(), Elements, nullptr, nullptr,
683 UniqueIdentifier.empty() ? nullptr
684 : MDString::get(VMContext, UniqueIdentifier)};
685 DICompositeType CTy(MDNode::get(VMContext, Elts));
686 AllEnumTypes.push_back(CTy);
687 if (!UniqueIdentifier.empty())
692 DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
693 DIType Ty, DIArray Subscripts) {
694 // TAG_array_type is encoded in DICompositeType format.
696 HeaderBuilder::get(dwarf::DW_TAG_array_type)
705 nullptr, // Filename/Directory,
707 Ty.getRef(), Subscripts, nullptr, nullptr,
708 nullptr // Type Identifer
710 return DICompositeType(MDNode::get(VMContext, Elts));
713 DICompositeType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
714 DIType Ty, DIArray Subscripts) {
715 // A vector is an array type with the FlagVector flag applied.
717 HeaderBuilder::get(dwarf::DW_TAG_array_type)
723 .concat(DIType::FlagVector)
726 nullptr, // Filename/Directory,
728 Ty.getRef(), Subscripts, nullptr, nullptr,
729 nullptr // Type Identifer
731 return DICompositeType(MDNode::get(VMContext, Elts));
734 static HeaderBuilder setTypeFlagsInHeader(StringRef Header,
735 unsigned FlagsToSet) {
736 DIHeaderFieldIterator I(Header);
740 if (I->getAsInteger(0, Flags))
744 return HeaderBuilder(Twine(I.getPrefix())).concat(Flags).concat(
748 static DIType createTypeWithFlags(LLVMContext &Context, DIType Ty,
749 unsigned FlagsToSet) {
750 SmallVector<Metadata *, 9> Elts;
752 assert(N && "Unexpected input DIType!");
753 // Update header field.
754 Elts.push_back(setTypeFlagsInHeader(Ty.getHeader(), FlagsToSet).get(Context));
755 for (unsigned I = 1, E = N->getNumOperands(); I != E; ++I)
756 Elts.push_back(N->getOperand(I));
758 return DIType(MDNode::get(Context, Elts));
761 DIType DIBuilder::createArtificialType(DIType Ty) {
762 if (Ty.isArtificial())
764 return createTypeWithFlags(VMContext, Ty, DIType::FlagArtificial);
767 DIType DIBuilder::createObjectPointerType(DIType Ty) {
768 if (Ty.isObjectPointer())
770 unsigned Flags = DIType::FlagObjectPointer | DIType::FlagArtificial;
771 return createTypeWithFlags(VMContext, Ty, Flags);
774 void DIBuilder::retainType(DIType T) { AllRetainTypes.emplace_back(T); }
776 DIBasicType DIBuilder::createUnspecifiedParameter() {
777 return DIBasicType();
781 DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIDescriptor Scope,
782 DIFile F, unsigned Line, unsigned RuntimeLang,
783 uint64_t SizeInBits, uint64_t AlignInBits,
784 StringRef UniqueIdentifier) {
785 // Create a temporary MDNode.
787 HeaderBuilder::get(Tag)
793 .concat(DIDescriptor::FlagFwdDecl)
796 F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
798 nullptr, // TemplateParams
799 UniqueIdentifier.empty() ? nullptr
800 : MDString::get(VMContext, UniqueIdentifier)};
801 MDNode *Node = MDNode::get(VMContext, Elts);
802 DICompositeType RetTy(Node);
803 assert(RetTy.isCompositeType() &&
804 "createForwardDecl result should be a DIType");
805 if (!UniqueIdentifier.empty())
810 DICompositeType DIBuilder::createReplaceableForwardDecl(
811 unsigned Tag, StringRef Name, DIDescriptor Scope, DIFile F, unsigned Line,
812 unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
813 StringRef UniqueIdentifier) {
814 // Create a temporary MDNode.
816 HeaderBuilder::get(Tag)
822 .concat(DIDescriptor::FlagFwdDecl)
825 F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
827 nullptr, // TemplateParams
828 UniqueIdentifier.empty() ? nullptr
829 : MDString::get(VMContext, UniqueIdentifier)};
830 DICompositeType RetTy(MDNode::getTemporary(VMContext, Elts));
831 assert(RetTy.isCompositeType() &&
832 "createReplaceableForwardDecl result should be a DIType");
833 if (!UniqueIdentifier.empty())
838 DIArray DIBuilder::getOrCreateArray(ArrayRef<Metadata *> Elements) {
839 return DIArray(MDNode::get(VMContext, Elements));
842 DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
843 SmallVector<llvm::Metadata *, 16> Elts;
844 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
845 if (Elements[i] && isa<MDNode>(Elements[i]))
846 Elts.push_back(DIType(cast<MDNode>(Elements[i])).getRef());
848 Elts.push_back(Elements[i]);
850 return DITypeArray(MDNode::get(VMContext, Elts));
853 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
854 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subrange_type)
859 return DISubrange(MDNode::get(VMContext, Elts));
862 static DIGlobalVariable createGlobalVariableHelper(
863 LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
864 StringRef LinkageName, DIFile F, unsigned LineNumber, DITypeRef Ty,
865 bool isLocalToUnit, Constant *Val, MDNode *Decl, bool isDefinition,
866 std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
868 MDNode *TheCtx = getNonCompileUnitScope(Context);
869 if (DIScope(TheCtx).isCompositeType()) {
870 assert(!DICompositeType(TheCtx).getIdentifier() &&
871 "Context of a global variable should not be a type with identifier");
874 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_variable)
879 .concat(isLocalToUnit)
880 .concat(isDefinition)
882 TheCtx, F, Ty, getConstantOrNull(Val),
885 return DIGlobalVariable(CreateFunc(Elts));
888 DIGlobalVariable DIBuilder::createGlobalVariable(
889 DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
890 unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
892 return createGlobalVariableHelper(
893 VMContext, Context, Name, LinkageName, F, LineNumber, Ty, isLocalToUnit,
894 Val, Decl, true, [&](ArrayRef<Metadata *> Elts) -> MDNode *{
895 MDNode *Node = MDNode::get(VMContext, Elts);
896 AllGVs.push_back(Node);
901 DIGlobalVariable DIBuilder::createTempGlobalVariableFwdDecl(
902 DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
903 unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
905 return createGlobalVariableHelper(VMContext, Context, Name, LinkageName, F,
906 LineNumber, Ty, isLocalToUnit, Val, Decl,
907 false, [&](ArrayRef<Metadata *> Elts) {
908 return MDNode::getTemporary(VMContext, Elts);
912 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
913 StringRef Name, DIFile File,
914 unsigned LineNo, DITypeRef Ty,
915 bool AlwaysPreserve, unsigned Flags,
917 DIDescriptor Context(getNonCompileUnitScope(Scope));
918 assert((!Context || Context.isScope()) &&
919 "createLocalVariable should be called with a valid Context");
920 Metadata *Elts[] = {HeaderBuilder::get(Tag)
922 .concat(LineNo | (ArgNo << 24))
925 getNonCompileUnitScope(Scope), File, Ty};
926 MDNode *Node = MDNode::get(VMContext, Elts);
927 if (AlwaysPreserve) {
928 // The optimizer may remove local variable. If there is an interest
929 // to preserve variable info in such situation then stash it in a
931 DISubprogram Fn(getDISubprogram(Scope));
932 assert(Fn && "Missing subprogram for local variable");
933 PreservedVariables[Fn].emplace_back(Node);
935 DIVariable RetVar(Node);
936 assert(RetVar.isVariable() &&
937 "createLocalVariable should return a valid DIVariable");
941 DIExpression DIBuilder::createExpression(ArrayRef<int64_t> Addr) {
942 auto Header = HeaderBuilder::get(DW_TAG_expression);
943 for (int64_t I : Addr)
945 Metadata *Elts[] = {Header.get(VMContext)};
946 return DIExpression(MDNode::get(VMContext, Elts));
949 DIExpression DIBuilder::createPieceExpression(unsigned OffsetInBytes,
950 unsigned SizeInBytes) {
951 int64_t Addr[] = {dwarf::DW_OP_piece, OffsetInBytes, SizeInBytes};
952 return createExpression(Addr);
955 DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
956 StringRef LinkageName, DIFile File,
957 unsigned LineNo, DICompositeType Ty,
958 bool isLocalToUnit, bool isDefinition,
959 unsigned ScopeLine, unsigned Flags,
960 bool isOptimized, Function *Fn,
961 MDNode *TParams, MDNode *Decl) {
962 // dragonegg does not generate identifier for types, so using an empty map
963 // to resolve the context should be fine.
964 DITypeIdentifierMap EmptyMap;
965 return createFunction(Context.resolve(EmptyMap), Name, LinkageName, File,
966 LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
967 Flags, isOptimized, Fn, TParams, Decl);
970 static DISubprogram createFunctionHelper(
971 LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
972 StringRef LinkageName, DIFile File, unsigned LineNo, DICompositeType Ty,
973 bool isLocalToUnit, bool isDefinition, unsigned ScopeLine, unsigned Flags,
974 bool isOptimized, Function *Fn, MDNode *TParams, MDNode *Decl, MDNode *Vars,
975 std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
976 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
977 "function types should be subroutines");
978 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
983 .concat(isLocalToUnit)
984 .concat(isDefinition)
992 DIScope(getNonCompileUnitScope(Context)).getRef(), Ty,
993 nullptr, getConstantOrNull(Fn), TParams, Decl, Vars};
995 DISubprogram S(CreateFunc(Elts));
996 assert(S.isSubprogram() &&
997 "createFunction should return a valid DISubprogram");
1002 DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
1003 StringRef LinkageName, DIFile File,
1004 unsigned LineNo, DICompositeType Ty,
1005 bool isLocalToUnit, bool isDefinition,
1006 unsigned ScopeLine, unsigned Flags,
1007 bool isOptimized, Function *Fn,
1008 MDNode *TParams, MDNode *Decl) {
1009 return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1010 LineNo, Ty, isLocalToUnit, isDefinition,
1011 ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1012 MDNode::getTemporary(VMContext, None),
1013 [&](ArrayRef<Metadata *> Elts) -> MDNode *{
1014 MDNode *Node = MDNode::get(VMContext, Elts);
1015 // Create a named metadata so that we
1016 // do not lose this mdnode.
1018 AllSubprograms.push_back(Node);
1024 DIBuilder::createTempFunctionFwdDecl(DIDescriptor Context, StringRef Name,
1025 StringRef LinkageName, DIFile File,
1026 unsigned LineNo, DICompositeType Ty,
1027 bool isLocalToUnit, bool isDefinition,
1028 unsigned ScopeLine, unsigned Flags,
1029 bool isOptimized, Function *Fn,
1030 MDNode *TParams, MDNode *Decl) {
1031 return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1032 LineNo, Ty, isLocalToUnit, isDefinition,
1033 ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1034 nullptr, [&](ArrayRef<Metadata *> Elts) {
1035 return MDNode::getTemporary(VMContext, Elts);
1039 DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
1040 StringRef LinkageName, DIFile F,
1041 unsigned LineNo, DICompositeType Ty,
1042 bool isLocalToUnit, bool isDefinition,
1043 unsigned VK, unsigned VIndex,
1044 DIType VTableHolder, unsigned Flags,
1045 bool isOptimized, Function *Fn,
1047 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
1048 "function types should be subroutines");
1049 assert(getNonCompileUnitScope(Context) &&
1050 "Methods should have both a Context and a context that isn't "
1051 "the compile unit.");
1052 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
1055 .concat(LinkageName)
1057 .concat(isLocalToUnit)
1058 .concat(isDefinition)
1062 .concat(isOptimized)
1064 // FIXME: Do we want to use different scope/lines?
1066 F.getFileNode(), DIScope(Context).getRef(), Ty,
1067 VTableHolder.getRef(), getConstantOrNull(Fn), TParam,
1069 MDNode *Node = MDNode::get(VMContext, Elts);
1071 AllSubprograms.push_back(Node);
1072 DISubprogram S(Node);
1073 assert(S.isSubprogram() && "createMethod should return a valid DISubprogram");
1077 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
1078 DIFile File, unsigned LineNo) {
1079 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_namespace)
1083 File.getFileNode(), getNonCompileUnitScope(Scope)};
1084 DINameSpace R(MDNode::get(VMContext, Elts));
1085 assert(R.Verify() &&
1086 "createNameSpace should return a verifiable DINameSpace");
1090 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
1092 unsigned Discriminator) {
1093 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1094 .concat(Discriminator)
1096 File.getFileNode(), Scope};
1097 DILexicalBlockFile R(MDNode::get(VMContext, Elts));
1100 "createLexicalBlockFile should return a verifiable DILexicalBlockFile");
1104 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
1105 unsigned Line, unsigned Col) {
1106 // FIXME: This isn't thread safe nor the right way to defeat MDNode uniquing.
1107 // I believe the right way is to have a self-referential element in the node.
1108 // Also: why do we bother with line/column - they're not used and the
1109 // documentation (SourceLevelDebugging.rst) claims the line/col are necessary
1110 // for uniquing, yet then we have this other solution (because line/col were
1111 // inadequate) anyway. Remove all 3 and replace them with a self-reference.
1113 // Defeat MDNode uniquing for lexical blocks by using unique id.
1114 static unsigned int unique_id = 0;
1115 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1118 .concat(unique_id++)
1120 File.getFileNode(), getNonCompileUnitScope(Scope)};
1121 DILexicalBlock R(MDNode::get(VMContext, Elts));
1122 assert(R.Verify() &&
1123 "createLexicalBlock should return a verifiable DILexicalBlock");
1127 static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) {
1128 assert(V && "no value passed to dbg intrinsic");
1129 return MetadataAsValue::get(VMContext, ValueAsMetadata::get(V));
1132 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1134 Instruction *InsertBefore) {
1135 assert(VarInfo.isVariable() &&
1136 "empty or invalid DIVariable passed to dbg.declare");
1138 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1140 trackIfUnresolved(VarInfo);
1141 trackIfUnresolved(Expr);
1142 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1143 MetadataAsValue::get(VMContext, VarInfo),
1144 MetadataAsValue::get(VMContext, Expr)};
1145 return CallInst::Create(DeclareFn, Args, "", InsertBefore);
1148 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1150 BasicBlock *InsertAtEnd) {
1151 assert(VarInfo.isVariable() &&
1152 "empty or invalid DIVariable passed to dbg.declare");
1154 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1156 trackIfUnresolved(VarInfo);
1157 trackIfUnresolved(Expr);
1158 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1159 MetadataAsValue::get(VMContext, VarInfo),
1160 MetadataAsValue::get(VMContext, Expr)};
1162 // If this block already has a terminator then insert this intrinsic
1163 // before the terminator.
1164 if (TerminatorInst *T = InsertAtEnd->getTerminator())
1165 return CallInst::Create(DeclareFn, Args, "", T);
1167 return CallInst::Create(DeclareFn, Args, "", InsertAtEnd);
1170 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1173 Instruction *InsertBefore) {
1174 assert(V && "no value passed to dbg.value");
1175 assert(VarInfo.isVariable() &&
1176 "empty or invalid DIVariable passed to dbg.value");
1178 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1180 trackIfUnresolved(VarInfo);
1181 trackIfUnresolved(Expr);
1182 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1183 ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1184 MetadataAsValue::get(VMContext, VarInfo),
1185 MetadataAsValue::get(VMContext, Expr)};
1186 return CallInst::Create(ValueFn, Args, "", InsertBefore);
1189 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1192 BasicBlock *InsertAtEnd) {
1193 assert(V && "no value passed to dbg.value");
1194 assert(VarInfo.isVariable() &&
1195 "empty or invalid DIVariable passed to dbg.value");
1197 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1199 trackIfUnresolved(VarInfo);
1200 trackIfUnresolved(Expr);
1201 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1202 ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1203 MetadataAsValue::get(VMContext, VarInfo),
1204 MetadataAsValue::get(VMContext, Expr)};
1205 return CallInst::Create(ValueFn, Args, "", InsertAtEnd);
1208 void DIBuilder::replaceVTableHolder(DICompositeType &T, DICompositeType VTableHolder) {
1209 T.setContainingType(VTableHolder);
1211 // If this didn't create a self-reference, just return.
1212 if (T != VTableHolder)
1215 // Look for unresolved operands. T has dropped RAUW support and is already
1216 // marked resolved, orphaning any cycles underneath it.
1217 assert(T->isResolved() && "Expected self-reference to be resolved");
1218 for (const MDOperand &O : T->operands())
1219 if (auto *N = dyn_cast_or_null<MDNode>(O))
1220 trackIfUnresolved(N);
1223 void DIBuilder::replaceArrays(DICompositeType &T, DIArray Elements,
1225 T.setArrays(Elements, TParams);
1227 // If T isn't resolved, there's no problem.
1228 if (!T->isResolved())
1231 // If "T" is resolved, it may be due to a self-reference cycle. Track the
1232 // arrays explicitly if they're unresolved, or else the cycles will be
1235 trackIfUnresolved(Elements);
1237 trackIfUnresolved(TParams);