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 /// \brief Whether there are any fields yet.
30 /// Note that this is not equivalent to \c Chars.empty(), since \a concat()
31 /// may have been called already with an empty string.
33 SmallVector<char, 256> Chars;
36 HeaderBuilder() : IsEmpty(true) {}
37 HeaderBuilder(const HeaderBuilder &X) : IsEmpty(X.IsEmpty), Chars(X.Chars) {}
38 HeaderBuilder(HeaderBuilder &&X)
39 : IsEmpty(X.IsEmpty), Chars(std::move(X.Chars)) {}
41 template <class Twineable> HeaderBuilder &concat(Twineable &&X) {
46 Twine(X).toVector(Chars);
50 MDString *get(LLVMContext &Context) const {
51 return MDString::get(Context, StringRef(Chars.begin(), Chars.size()));
54 static HeaderBuilder get(unsigned Tag) {
55 return HeaderBuilder().concat("0x" + Twine::utohexstr(Tag));
60 DIBuilder::DIBuilder(Module &m, bool AllowUnresolvedNodes)
61 : M(m), VMContext(M.getContext()), TempEnumTypes(nullptr),
62 TempRetainTypes(nullptr), TempSubprograms(nullptr), TempGVs(nullptr),
63 DeclareFn(nullptr), ValueFn(nullptr),
64 AllowUnresolvedNodes(AllowUnresolvedNodes) {}
66 void DIBuilder::trackIfUnresolved(MDNode *N) {
72 assert(AllowUnresolvedNodes && "Cannot handle unresolved nodes");
73 UnresolvedNodes.emplace_back(N);
76 void DIBuilder::finalize() {
77 DIArray Enums = getOrCreateArray(AllEnumTypes);
78 DIType(TempEnumTypes).replaceAllUsesWith(Enums);
80 SmallVector<Metadata *, 16> RetainValues;
81 // Declarations and definitions of the same type may be retained. Some
82 // clients RAUW these pairs, leaving duplicates in the retained types
83 // list. Use a set to remove the duplicates while we transform the
84 // TrackingVHs back into Values.
85 SmallPtrSet<Metadata *, 16> RetainSet;
86 for (unsigned I = 0, E = AllRetainTypes.size(); I < E; I++)
87 if (RetainSet.insert(AllRetainTypes[I]).second)
88 RetainValues.push_back(AllRetainTypes[I]);
89 DIArray RetainTypes = getOrCreateArray(RetainValues);
90 DIType(TempRetainTypes).replaceAllUsesWith(RetainTypes);
92 DIArray SPs = getOrCreateArray(AllSubprograms);
93 DIType(TempSubprograms).replaceAllUsesWith(SPs);
94 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) {
95 DISubprogram SP(SPs.getElement(i));
96 if (MDNode *Temp = SP.getVariablesNodes()) {
97 SmallVector<Metadata *, 4> Variables;
98 for (Metadata *V : PreservedVariables.lookup(SP))
99 Variables.push_back(V);
100 DIArray AV = getOrCreateArray(Variables);
101 DIType(Temp).replaceAllUsesWith(AV);
105 DIArray GVs = getOrCreateArray(AllGVs);
106 DIType(TempGVs).replaceAllUsesWith(GVs);
108 SmallVector<Metadata *, 16> RetainValuesI;
109 for (unsigned I = 0, E = AllImportedModules.size(); I < E; I++)
110 RetainValuesI.push_back(AllImportedModules[I]);
111 DIArray IMs = getOrCreateArray(RetainValuesI);
112 DIType(TempImportedModules).replaceAllUsesWith(IMs);
114 // Now that all temp nodes have been replaced or deleted, resolve remaining
116 for (const auto &N : UnresolvedNodes)
117 if (N && !N->isResolved())
119 UnresolvedNodes.clear();
121 // Can't handle unresolved nodes anymore.
122 AllowUnresolvedNodes = false;
125 /// If N is compile unit return NULL otherwise return N.
126 static MDNode *getNonCompileUnitScope(MDNode *N) {
127 if (DIDescriptor(N).isCompileUnit())
132 static MDNode *createFilePathPair(LLVMContext &VMContext, StringRef Filename,
133 StringRef Directory) {
134 assert(!Filename.empty() && "Unable to create file without name");
135 Metadata *Pair[] = {MDString::get(VMContext, Filename),
136 MDString::get(VMContext, Directory)};
137 return MDNode::get(VMContext, Pair);
140 DICompileUnit DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename,
142 StringRef Producer, bool isOptimized,
143 StringRef Flags, unsigned RunTimeVer,
145 DebugEmissionKind Kind,
146 bool EmitDebugInfo) {
148 assert(((Lang <= dwarf::DW_LANG_OCaml && Lang >= dwarf::DW_LANG_C89) ||
149 (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) &&
150 "Invalid Language tag");
151 assert(!Filename.empty() &&
152 "Unable to create compile unit without filename");
153 Metadata *TElts[] = {HeaderBuilder::get(DW_TAG_base_type).get(VMContext)};
154 TempEnumTypes = MDNode::getTemporary(VMContext, TElts).release();
156 TempRetainTypes = MDNode::getTemporary(VMContext, TElts).release();
158 TempSubprograms = MDNode::getTemporary(VMContext, TElts).release();
160 TempGVs = MDNode::getTemporary(VMContext, TElts).release();
162 TempImportedModules = MDNode::getTemporary(VMContext, TElts).release();
164 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_compile_unit)
173 createFilePathPair(VMContext, Filename, Directory),
174 TempEnumTypes, TempRetainTypes, TempSubprograms, TempGVs,
175 TempImportedModules};
177 MDNode *CUNode = MDNode::get(VMContext, Elts);
179 // Create a named metadata so that it is easier to find cu in a module.
180 // Note that we only generate this when the caller wants to actually
181 // emit debug information. When we are only interested in tracking
182 // source line locations throughout the backend, we prevent codegen from
183 // emitting debug info in the final output by not generating llvm.dbg.cu.
185 NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
186 NMD->addOperand(CUNode);
189 trackIfUnresolved(CUNode);
190 return DICompileUnit(CUNode);
193 static DIImportedEntity
194 createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope Context,
195 Metadata *NS, unsigned Line, StringRef Name,
196 SmallVectorImpl<TrackingMDNodeRef> &AllImportedModules) {
198 Metadata *Elts[] = {HeaderBuilder::get(Tag).concat(Line).concat(Name).get(C),
200 R = MDNode::get(C, Elts);
201 DIImportedEntity M(R);
202 assert(M.Verify() && "Imported module should be valid");
203 AllImportedModules.emplace_back(M.get());
207 DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
210 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
211 Context, NS, Line, StringRef(), AllImportedModules);
214 DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
217 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
218 Context, NS, Line, StringRef(), AllImportedModules);
221 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
223 unsigned Line, StringRef Name) {
224 // Make sure to use the unique identifier based metadata reference for
225 // types that have one.
227 Decl.isType() ? static_cast<Metadata *>(DIType(Decl).getRef()) : Decl;
228 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
229 Context, V, Line, Name,
233 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
234 DIImportedEntity Imp,
235 unsigned Line, StringRef Name) {
236 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
237 Context, Imp, Line, Name, AllImportedModules);
240 DIFile DIBuilder::createFile(StringRef Filename, StringRef Directory) {
242 HeaderBuilder::get(dwarf::DW_TAG_file_type).get(VMContext),
243 createFilePathPair(VMContext, Filename, Directory)};
244 return DIFile(MDNode::get(VMContext, Elts));
247 DIEnumerator DIBuilder::createEnumerator(StringRef Name, int64_t Val) {
248 assert(!Name.empty() && "Unable to create enumerator without name");
249 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_enumerator)
253 return DIEnumerator(MDNode::get(VMContext, Elts));
256 DIBasicType DIBuilder::createUnspecifiedType(StringRef Name) {
257 assert(!Name.empty() && "Unable to create type without name");
258 // Unspecified types are encoded in DIBasicType format. Line number, filename,
259 // size, alignment, offset and flags are always empty here.
261 HeaderBuilder::get(dwarf::DW_TAG_unspecified_type)
273 return DIBasicType(MDNode::get(VMContext, Elts));
276 DIBasicType DIBuilder::createNullPtrType() {
277 return createUnspecifiedType("decltype(nullptr)");
281 DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
282 uint64_t AlignInBits, unsigned Encoding) {
283 assert(!Name.empty() && "Unable to create type without name");
284 // Basic types are encoded in DIBasicType format. Line number, filename,
285 // offset and flags are always empty here.
287 HeaderBuilder::get(dwarf::DW_TAG_base_type)
299 return DIBasicType(MDNode::get(VMContext, Elts));
302 DIDerivedType DIBuilder::createQualifiedType(unsigned Tag, DIType FromTy) {
303 // Qualified types are encoded in DIDerivedType format.
304 Metadata *Elts[] = {HeaderBuilder::get(Tag)
305 .concat(StringRef()) // Name
315 return DIDerivedType(MDNode::get(VMContext, Elts));
319 DIBuilder::createPointerType(DIType PointeeTy, uint64_t SizeInBits,
320 uint64_t AlignInBits, StringRef Name) {
321 // Pointer types are encoded in DIDerivedType format.
322 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_pointer_type)
333 return DIDerivedType(MDNode::get(VMContext, Elts));
337 DIBuilder::createMemberPointerType(DIType PointeeTy, DIType Base,
338 uint64_t SizeInBits, uint64_t AlignInBits) {
339 // Pointer types are encoded in DIDerivedType format.
340 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_ptr_to_member_type)
343 .concat(SizeInBits) // Size
344 .concat(AlignInBits) // Align
350 PointeeTy.getRef(), Base.getRef()};
351 return DIDerivedType(MDNode::get(VMContext, Elts));
354 DIDerivedType DIBuilder::createReferenceType(unsigned Tag, DIType RTy) {
355 assert(RTy.isType() && "Unable to create reference type");
356 // References are encoded in DIDerivedType format.
357 Metadata *Elts[] = {HeaderBuilder::get(Tag)
358 .concat(StringRef()) // Name
368 return DIDerivedType(MDNode::get(VMContext, Elts));
371 DIDerivedType DIBuilder::createTypedef(DIType Ty, StringRef Name, DIFile File,
372 unsigned LineNo, DIDescriptor Context) {
373 // typedefs are encoded in DIDerivedType format.
374 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_typedef)
383 DIScope(getNonCompileUnitScope(Context)).getRef(),
385 return DIDerivedType(MDNode::get(VMContext, Elts));
388 DIDerivedType DIBuilder::createFriend(DIType Ty, DIType FriendTy) {
389 // typedefs are encoded in DIDerivedType format.
390 assert(Ty.isType() && "Invalid type!");
391 assert(FriendTy.isType() && "Invalid friend type!");
392 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_friend)
393 .concat(StringRef()) // Name
400 nullptr, Ty.getRef(), FriendTy.getRef()};
401 return DIDerivedType(MDNode::get(VMContext, Elts));
404 DIDerivedType DIBuilder::createInheritance(DIType Ty, DIType BaseTy,
407 assert(Ty.isType() && "Unable to create inheritance");
408 // TAG_inheritance is encoded in DIDerivedType format.
409 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_inheritance)
410 .concat(StringRef()) // Name
417 nullptr, Ty.getRef(), BaseTy.getRef()};
418 return DIDerivedType(MDNode::get(VMContext, Elts));
421 DIDerivedType DIBuilder::createMemberType(DIDescriptor Scope, StringRef Name,
422 DIFile File, unsigned LineNumber,
424 uint64_t AlignInBits,
425 uint64_t OffsetInBits, unsigned Flags,
427 // TAG_member is encoded in DIDerivedType format.
428 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
433 .concat(OffsetInBits)
437 DIScope(getNonCompileUnitScope(Scope)).getRef(),
439 return DIDerivedType(MDNode::get(VMContext, Elts));
442 static Metadata *getConstantOrNull(Constant *C) {
444 return ConstantAsMetadata::get(C);
448 DIDerivedType DIBuilder::createStaticMemberType(DIDescriptor Scope,
449 StringRef Name, DIFile File,
450 unsigned LineNumber, DIType Ty,
452 llvm::Constant *Val) {
453 // TAG_member is encoded in DIDerivedType format.
454 Flags |= DIDescriptor::FlagStaticMember;
455 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
464 DIScope(getNonCompileUnitScope(Scope)).getRef(),
465 Ty.getRef(), getConstantOrNull(Val)};
466 return DIDerivedType(MDNode::get(VMContext, Elts));
469 DIDerivedType DIBuilder::createObjCIVar(StringRef Name, DIFile File,
472 uint64_t AlignInBits,
473 uint64_t OffsetInBits, unsigned Flags,
474 DIType Ty, MDNode *PropertyNode) {
475 // TAG_member is encoded in DIDerivedType format.
476 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
481 .concat(OffsetInBits)
484 File.getFileNode(), getNonCompileUnitScope(File), Ty,
486 return DIDerivedType(MDNode::get(VMContext, Elts));
490 DIBuilder::createObjCProperty(StringRef Name, DIFile File, unsigned LineNumber,
491 StringRef GetterName, StringRef SetterName,
492 unsigned PropertyAttributes, DIType Ty) {
493 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_APPLE_property)
498 .concat(PropertyAttributes)
501 return DIObjCProperty(MDNode::get(VMContext, Elts));
504 DITemplateTypeParameter
505 DIBuilder::createTemplateTypeParameter(DIDescriptor Context, StringRef Name,
506 DIType Ty, MDNode *File, unsigned LineNo,
508 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_template_type_parameter)
513 DIScope(getNonCompileUnitScope(Context)).getRef(),
515 return DITemplateTypeParameter(MDNode::get(VMContext, Elts));
518 static DITemplateValueParameter createTemplateValueParameterHelper(
519 LLVMContext &VMContext, unsigned Tag, DIDescriptor Context, StringRef Name,
520 DIType Ty, Metadata *MD, MDNode *File, unsigned LineNo, unsigned ColumnNo) {
522 HeaderBuilder::get(Tag).concat(Name).concat(LineNo).concat(ColumnNo).get(
524 DIScope(getNonCompileUnitScope(Context)).getRef(), Ty.getRef(), MD, File};
525 return DITemplateValueParameter(MDNode::get(VMContext, Elts));
528 DITemplateValueParameter
529 DIBuilder::createTemplateValueParameter(DIDescriptor Context, StringRef Name,
530 DIType Ty, Constant *Val, MDNode *File,
531 unsigned LineNo, unsigned ColumnNo) {
532 return createTemplateValueParameterHelper(
533 VMContext, dwarf::DW_TAG_template_value_parameter, Context, Name, Ty,
534 getConstantOrNull(Val), File, LineNo, ColumnNo);
537 DITemplateValueParameter
538 DIBuilder::createTemplateTemplateParameter(DIDescriptor Context, StringRef Name,
539 DIType Ty, StringRef Val,
540 MDNode *File, unsigned LineNo,
542 return createTemplateValueParameterHelper(
543 VMContext, dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
544 MDString::get(VMContext, Val), File, LineNo, ColumnNo);
547 DITemplateValueParameter
548 DIBuilder::createTemplateParameterPack(DIDescriptor Context, StringRef Name,
549 DIType Ty, DIArray Val,
550 MDNode *File, unsigned LineNo,
552 return createTemplateValueParameterHelper(
553 VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
554 Val, File, LineNo, ColumnNo);
557 DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
558 DIFile File, unsigned LineNumber,
560 uint64_t AlignInBits,
561 uint64_t OffsetInBits,
562 unsigned Flags, DIType DerivedFrom,
565 MDNode *TemplateParams,
566 StringRef UniqueIdentifier) {
567 assert((!Context || Context.isScope() || Context.isType()) &&
568 "createClassType should be called with a valid Context");
569 // TAG_class_type is encoded in DICompositeType format.
571 HeaderBuilder::get(dwarf::DW_TAG_class_type)
576 .concat(OffsetInBits)
580 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
581 DerivedFrom.getRef(), Elements, VTableHolder.getRef(), TemplateParams,
582 UniqueIdentifier.empty() ? nullptr
583 : MDString::get(VMContext, UniqueIdentifier)};
584 DICompositeType R(MDNode::get(VMContext, Elts));
585 assert(R.isCompositeType() &&
586 "createClassType should return a DICompositeType");
587 if (!UniqueIdentifier.empty())
592 DICompositeType DIBuilder::createStructType(DIDescriptor Context,
593 StringRef Name, DIFile File,
596 uint64_t AlignInBits,
597 unsigned Flags, DIType DerivedFrom,
599 unsigned RunTimeLang,
601 StringRef UniqueIdentifier) {
602 // TAG_structure_type is encoded in DICompositeType format.
604 HeaderBuilder::get(dwarf::DW_TAG_structure_type)
613 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
614 DerivedFrom.getRef(), Elements, VTableHolder.getRef(), nullptr,
615 UniqueIdentifier.empty() ? nullptr
616 : MDString::get(VMContext, UniqueIdentifier)};
617 DICompositeType R(MDNode::get(VMContext, Elts));
618 assert(R.isCompositeType() &&
619 "createStructType should return a DICompositeType");
620 if (!UniqueIdentifier.empty())
625 DICompositeType DIBuilder::createUnionType(DIDescriptor Scope, StringRef Name,
626 DIFile File, unsigned LineNumber,
628 uint64_t AlignInBits, unsigned Flags,
630 unsigned RunTimeLang,
631 StringRef UniqueIdentifier) {
632 // TAG_union_type is encoded in DICompositeType format.
634 HeaderBuilder::get(dwarf::DW_TAG_union_type)
643 File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
644 nullptr, Elements, nullptr, nullptr,
645 UniqueIdentifier.empty() ? nullptr
646 : MDString::get(VMContext, UniqueIdentifier)};
647 DICompositeType R(MDNode::get(VMContext, Elts));
648 if (!UniqueIdentifier.empty())
653 DISubroutineType DIBuilder::createSubroutineType(DIFile File,
654 DITypeArray ParameterTypes,
656 // TAG_subroutine_type is encoded in DICompositeType format.
658 HeaderBuilder::get(dwarf::DW_TAG_subroutine_type)
664 .concat(Flags) // Flags
667 nullptr, nullptr, nullptr, ParameterTypes, nullptr, nullptr,
668 nullptr // Type Identifer
670 return DISubroutineType(MDNode::get(VMContext, Elts));
673 DICompositeType DIBuilder::createEnumerationType(
674 DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
675 uint64_t SizeInBits, uint64_t AlignInBits, DIArray Elements,
676 DIType UnderlyingType, StringRef UniqueIdentifier) {
677 // TAG_enumeration_type is encoded in DICompositeType format.
679 HeaderBuilder::get(dwarf::DW_TAG_enumeration_type)
688 File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
689 UnderlyingType.getRef(), Elements, nullptr, nullptr,
690 UniqueIdentifier.empty() ? nullptr
691 : MDString::get(VMContext, UniqueIdentifier)};
692 DICompositeType CTy(MDNode::get(VMContext, Elts));
693 AllEnumTypes.push_back(CTy);
694 if (!UniqueIdentifier.empty())
699 DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
700 DIType Ty, DIArray Subscripts) {
701 // TAG_array_type is encoded in DICompositeType format.
703 HeaderBuilder::get(dwarf::DW_TAG_array_type)
712 nullptr, // Filename/Directory,
714 Ty.getRef(), Subscripts, nullptr, nullptr,
715 nullptr // Type Identifer
717 return DICompositeType(MDNode::get(VMContext, Elts));
720 DICompositeType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
721 DIType Ty, DIArray Subscripts) {
722 // A vector is an array type with the FlagVector flag applied.
724 HeaderBuilder::get(dwarf::DW_TAG_array_type)
730 .concat(DIType::FlagVector)
733 nullptr, // Filename/Directory,
735 Ty.getRef(), Subscripts, nullptr, nullptr,
736 nullptr // Type Identifer
738 return DICompositeType(MDNode::get(VMContext, Elts));
741 static HeaderBuilder setTypeFlagsInHeader(StringRef Header,
742 unsigned FlagsToSet) {
743 DIHeaderFieldIterator I(Header);
747 if (I->getAsInteger(0, Flags))
751 return HeaderBuilder()
752 .concat(I.getPrefix())
754 .concat(I.getSuffix());
757 static DIType createTypeWithFlags(LLVMContext &Context, DIType Ty,
758 unsigned FlagsToSet) {
759 SmallVector<Metadata *, 9> Elts;
761 assert(N && "Unexpected input DIType!");
762 // Update header field.
763 Elts.push_back(setTypeFlagsInHeader(Ty.getHeader(), FlagsToSet).get(Context));
764 for (unsigned I = 1, E = N->getNumOperands(); I != E; ++I)
765 Elts.push_back(N->getOperand(I));
767 return DIType(MDNode::get(Context, Elts));
770 DIType DIBuilder::createArtificialType(DIType Ty) {
771 if (Ty.isArtificial())
773 return createTypeWithFlags(VMContext, Ty, DIType::FlagArtificial);
776 DIType DIBuilder::createObjectPointerType(DIType Ty) {
777 if (Ty.isObjectPointer())
779 unsigned Flags = DIType::FlagObjectPointer | DIType::FlagArtificial;
780 return createTypeWithFlags(VMContext, Ty, Flags);
783 void DIBuilder::retainType(DIType T) { AllRetainTypes.emplace_back(T); }
785 DIBasicType DIBuilder::createUnspecifiedParameter() {
786 return DIBasicType();
790 DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIDescriptor Scope,
791 DIFile F, unsigned Line, unsigned RuntimeLang,
792 uint64_t SizeInBits, uint64_t AlignInBits,
793 StringRef UniqueIdentifier) {
794 // Create a temporary MDNode.
796 HeaderBuilder::get(Tag)
802 .concat(DIDescriptor::FlagFwdDecl)
805 F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
807 nullptr, // TemplateParams
808 UniqueIdentifier.empty() ? nullptr
809 : MDString::get(VMContext, UniqueIdentifier)};
810 MDNode *Node = MDNode::get(VMContext, Elts);
811 DICompositeType RetTy(Node);
812 assert(RetTy.isCompositeType() &&
813 "createForwardDecl result should be a DIType");
814 if (!UniqueIdentifier.empty())
819 DICompositeType DIBuilder::createReplaceableForwardDecl(
820 unsigned Tag, StringRef Name, DIDescriptor Scope, DIFile F, unsigned Line,
821 unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
822 StringRef UniqueIdentifier) {
823 // Create a temporary MDNode.
825 HeaderBuilder::get(Tag)
831 .concat(DIDescriptor::FlagFwdDecl)
834 F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
836 nullptr, // TemplateParams
837 UniqueIdentifier.empty() ? nullptr
838 : MDString::get(VMContext, UniqueIdentifier)};
839 DICompositeType RetTy(MDNode::getTemporary(VMContext, Elts).release());
840 assert(RetTy.isCompositeType() &&
841 "createReplaceableForwardDecl result should be a DIType");
842 if (!UniqueIdentifier.empty())
847 DIArray DIBuilder::getOrCreateArray(ArrayRef<Metadata *> Elements) {
848 return DIArray(MDNode::get(VMContext, Elements));
851 DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
852 SmallVector<llvm::Metadata *, 16> Elts;
853 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
854 if (Elements[i] && isa<MDNode>(Elements[i]))
855 Elts.push_back(DIType(cast<MDNode>(Elements[i])).getRef());
857 Elts.push_back(Elements[i]);
859 return DITypeArray(MDNode::get(VMContext, Elts));
862 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
863 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subrange_type)
868 return DISubrange(MDNode::get(VMContext, Elts));
871 static DIGlobalVariable createGlobalVariableHelper(
872 LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
873 StringRef LinkageName, DIFile F, unsigned LineNumber, DITypeRef Ty,
874 bool isLocalToUnit, Constant *Val, MDNode *Decl, bool isDefinition,
875 std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
877 MDNode *TheCtx = getNonCompileUnitScope(Context);
878 if (DIScope(TheCtx).isCompositeType()) {
879 assert(!DICompositeType(TheCtx).getIdentifier() &&
880 "Context of a global variable should not be a type with identifier");
883 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_variable)
888 .concat(isLocalToUnit)
889 .concat(isDefinition)
891 TheCtx, F, Ty, getConstantOrNull(Val),
894 return DIGlobalVariable(CreateFunc(Elts));
897 DIGlobalVariable DIBuilder::createGlobalVariable(
898 DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
899 unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
901 return createGlobalVariableHelper(
902 VMContext, Context, Name, LinkageName, F, LineNumber, Ty, isLocalToUnit,
903 Val, Decl, true, [&](ArrayRef<Metadata *> Elts) -> MDNode *{
904 MDNode *Node = MDNode::get(VMContext, Elts);
905 AllGVs.push_back(Node);
910 DIGlobalVariable DIBuilder::createTempGlobalVariableFwdDecl(
911 DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
912 unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
914 return createGlobalVariableHelper(VMContext, Context, Name, LinkageName, F,
915 LineNumber, Ty, isLocalToUnit, Val, Decl,
916 false, [&](ArrayRef<Metadata *> Elts) {
917 return MDNode::getTemporary(VMContext, Elts).release();
921 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
922 StringRef Name, DIFile File,
923 unsigned LineNo, DITypeRef Ty,
924 bool AlwaysPreserve, unsigned Flags,
926 DIDescriptor Context(getNonCompileUnitScope(Scope));
927 assert((!Context || Context.isScope()) &&
928 "createLocalVariable should be called with a valid Context");
929 Metadata *Elts[] = {HeaderBuilder::get(Tag)
931 .concat(LineNo | (ArgNo << 24))
934 getNonCompileUnitScope(Scope), File, Ty};
935 MDNode *Node = MDNode::get(VMContext, Elts);
936 if (AlwaysPreserve) {
937 // The optimizer may remove local variable. If there is an interest
938 // to preserve variable info in such situation then stash it in a
940 DISubprogram Fn(getDISubprogram(Scope));
941 assert(Fn && "Missing subprogram for local variable");
942 PreservedVariables[Fn].emplace_back(Node);
944 DIVariable RetVar(Node);
945 assert(RetVar.isVariable() &&
946 "createLocalVariable should return a valid DIVariable");
950 DIExpression DIBuilder::createExpression(ArrayRef<int64_t> Addr) {
951 auto Header = HeaderBuilder::get(DW_TAG_expression);
952 for (int64_t I : Addr)
954 Metadata *Elts[] = {Header.get(VMContext)};
955 return DIExpression(MDNode::get(VMContext, Elts));
958 DIExpression DIBuilder::createPieceExpression(unsigned OffsetInBytes,
959 unsigned SizeInBytes) {
960 int64_t Addr[] = {dwarf::DW_OP_piece, OffsetInBytes, SizeInBytes};
961 return createExpression(Addr);
964 DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
965 StringRef LinkageName, DIFile File,
966 unsigned LineNo, DICompositeType Ty,
967 bool isLocalToUnit, bool isDefinition,
968 unsigned ScopeLine, unsigned Flags,
969 bool isOptimized, Function *Fn,
970 MDNode *TParams, MDNode *Decl) {
971 // dragonegg does not generate identifier for types, so using an empty map
972 // to resolve the context should be fine.
973 DITypeIdentifierMap EmptyMap;
974 return createFunction(Context.resolve(EmptyMap), Name, LinkageName, File,
975 LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
976 Flags, isOptimized, Fn, TParams, Decl);
979 static DISubprogram createFunctionHelper(
980 LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
981 StringRef LinkageName, DIFile File, unsigned LineNo, DICompositeType Ty,
982 bool isLocalToUnit, bool isDefinition, unsigned ScopeLine, unsigned Flags,
983 bool isOptimized, Function *Fn, MDNode *TParams, MDNode *Decl, MDNode *Vars,
984 std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
985 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
986 "function types should be subroutines");
987 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
992 .concat(isLocalToUnit)
993 .concat(isDefinition)
1001 DIScope(getNonCompileUnitScope(Context)).getRef(), Ty,
1002 nullptr, getConstantOrNull(Fn), TParams, Decl, Vars};
1004 DISubprogram S(CreateFunc(Elts));
1005 assert(S.isSubprogram() &&
1006 "createFunction should return a valid DISubprogram");
1011 DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
1012 StringRef LinkageName, DIFile File,
1013 unsigned LineNo, DICompositeType Ty,
1014 bool isLocalToUnit, bool isDefinition,
1015 unsigned ScopeLine, unsigned Flags,
1016 bool isOptimized, Function *Fn,
1017 MDNode *TParams, MDNode *Decl) {
1018 return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1019 LineNo, Ty, isLocalToUnit, isDefinition,
1020 ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1021 MDNode::getTemporary(VMContext, None).release(),
1022 [&](ArrayRef<Metadata *> Elts) -> MDNode *{
1023 MDNode *Node = MDNode::get(VMContext, Elts);
1024 // Create a named metadata so that we
1025 // do not lose this mdnode.
1027 AllSubprograms.push_back(Node);
1033 DIBuilder::createTempFunctionFwdDecl(DIDescriptor Context, StringRef Name,
1034 StringRef LinkageName, DIFile File,
1035 unsigned LineNo, DICompositeType Ty,
1036 bool isLocalToUnit, bool isDefinition,
1037 unsigned ScopeLine, unsigned Flags,
1038 bool isOptimized, Function *Fn,
1039 MDNode *TParams, MDNode *Decl) {
1040 return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1041 LineNo, Ty, isLocalToUnit, isDefinition,
1042 ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1043 nullptr, [&](ArrayRef<Metadata *> Elts) {
1044 return MDNode::getTemporary(VMContext, Elts).release();
1048 DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
1049 StringRef LinkageName, DIFile F,
1050 unsigned LineNo, DICompositeType Ty,
1051 bool isLocalToUnit, bool isDefinition,
1052 unsigned VK, unsigned VIndex,
1053 DIType VTableHolder, unsigned Flags,
1054 bool isOptimized, Function *Fn,
1056 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
1057 "function types should be subroutines");
1058 assert(getNonCompileUnitScope(Context) &&
1059 "Methods should have both a Context and a context that isn't "
1060 "the compile unit.");
1061 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
1064 .concat(LinkageName)
1066 .concat(isLocalToUnit)
1067 .concat(isDefinition)
1071 .concat(isOptimized)
1073 // FIXME: Do we want to use different scope/lines?
1075 F.getFileNode(), DIScope(Context).getRef(), Ty,
1076 VTableHolder.getRef(), getConstantOrNull(Fn), TParam,
1078 MDNode *Node = MDNode::get(VMContext, Elts);
1080 AllSubprograms.push_back(Node);
1081 DISubprogram S(Node);
1082 assert(S.isSubprogram() && "createMethod should return a valid DISubprogram");
1086 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
1087 DIFile File, unsigned LineNo) {
1088 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_namespace)
1092 File.getFileNode(), getNonCompileUnitScope(Scope)};
1093 DINameSpace R(MDNode::get(VMContext, Elts));
1094 assert(R.Verify() &&
1095 "createNameSpace should return a verifiable DINameSpace");
1099 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
1101 unsigned Discriminator) {
1102 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1103 .concat(Discriminator)
1105 File.getFileNode(), Scope};
1106 DILexicalBlockFile R(MDNode::get(VMContext, Elts));
1109 "createLexicalBlockFile should return a verifiable DILexicalBlockFile");
1113 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
1114 unsigned Line, unsigned Col) {
1115 // FIXME: This isn't thread safe nor the right way to defeat MDNode uniquing.
1116 // I believe the right way is to have a self-referential element in the node.
1117 // Also: why do we bother with line/column - they're not used and the
1118 // documentation (SourceLevelDebugging.rst) claims the line/col are necessary
1119 // for uniquing, yet then we have this other solution (because line/col were
1120 // inadequate) anyway. Remove all 3 and replace them with a self-reference.
1122 // Defeat MDNode uniquing for lexical blocks by using unique id.
1123 static unsigned int unique_id = 0;
1124 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1127 .concat(unique_id++)
1129 File.getFileNode(), getNonCompileUnitScope(Scope)};
1130 DILexicalBlock R(MDNode::get(VMContext, Elts));
1131 assert(R.Verify() &&
1132 "createLexicalBlock should return a verifiable DILexicalBlock");
1136 static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) {
1137 assert(V && "no value passed to dbg intrinsic");
1138 return MetadataAsValue::get(VMContext, ValueAsMetadata::get(V));
1141 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1143 Instruction *InsertBefore) {
1144 assert(VarInfo.isVariable() &&
1145 "empty or invalid DIVariable passed to dbg.declare");
1147 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1149 trackIfUnresolved(VarInfo);
1150 trackIfUnresolved(Expr);
1151 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1152 MetadataAsValue::get(VMContext, VarInfo),
1153 MetadataAsValue::get(VMContext, Expr)};
1154 return CallInst::Create(DeclareFn, Args, "", InsertBefore);
1157 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1159 BasicBlock *InsertAtEnd) {
1160 assert(VarInfo.isVariable() &&
1161 "empty or invalid DIVariable passed to dbg.declare");
1163 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1165 trackIfUnresolved(VarInfo);
1166 trackIfUnresolved(Expr);
1167 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1168 MetadataAsValue::get(VMContext, VarInfo),
1169 MetadataAsValue::get(VMContext, Expr)};
1171 // If this block already has a terminator then insert this intrinsic
1172 // before the terminator.
1173 if (TerminatorInst *T = InsertAtEnd->getTerminator())
1174 return CallInst::Create(DeclareFn, Args, "", T);
1176 return CallInst::Create(DeclareFn, Args, "", InsertAtEnd);
1179 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1182 Instruction *InsertBefore) {
1183 assert(V && "no value passed to dbg.value");
1184 assert(VarInfo.isVariable() &&
1185 "empty or invalid DIVariable passed to dbg.value");
1187 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1189 trackIfUnresolved(VarInfo);
1190 trackIfUnresolved(Expr);
1191 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1192 ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1193 MetadataAsValue::get(VMContext, VarInfo),
1194 MetadataAsValue::get(VMContext, Expr)};
1195 return CallInst::Create(ValueFn, Args, "", InsertBefore);
1198 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1201 BasicBlock *InsertAtEnd) {
1202 assert(V && "no value passed to dbg.value");
1203 assert(VarInfo.isVariable() &&
1204 "empty or invalid DIVariable passed to dbg.value");
1206 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1208 trackIfUnresolved(VarInfo);
1209 trackIfUnresolved(Expr);
1210 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1211 ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1212 MetadataAsValue::get(VMContext, VarInfo),
1213 MetadataAsValue::get(VMContext, Expr)};
1214 return CallInst::Create(ValueFn, Args, "", InsertAtEnd);
1217 void DIBuilder::replaceVTableHolder(DICompositeType &T, DICompositeType VTableHolder) {
1218 T.setContainingType(VTableHolder);
1220 // If this didn't create a self-reference, just return.
1221 if (T != VTableHolder)
1224 // Look for unresolved operands. T has dropped RAUW support and is already
1225 // marked resolved, orphaning any cycles underneath it.
1226 assert(T->isResolved() && "Expected self-reference to be resolved");
1227 for (const MDOperand &O : T->operands())
1228 if (auto *N = dyn_cast_or_null<MDNode>(O))
1229 trackIfUnresolved(N);
1232 void DIBuilder::replaceArrays(DICompositeType &T, DIArray Elements,
1234 T.setArrays(Elements, TParams);
1236 // If T isn't resolved, there's no problem.
1237 if (!T->isResolved())
1240 // If "T" is resolved, it may be due to a self-reference cycle. Track the
1241 // arrays explicitly if they're unresolved, or else the cycles will be
1244 trackIfUnresolved(Elements);
1246 trackIfUnresolved(TParams);