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_Fortran08 && 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");
154 // TODO: Once we make MDCompileUnit distinct, stop using temporaries here
155 // (just start with operands assigned to nullptr).
156 TempEnumTypes = MDTuple::getTemporary(VMContext, None).release();
157 TempRetainTypes = MDTuple::getTemporary(VMContext, None).release();
158 TempSubprograms = MDTuple::getTemporary(VMContext, None).release();
159 TempGVs = MDTuple::getTemporary(VMContext, None).release();
160 TempImportedModules = MDTuple::getTemporary(VMContext, None).release();
162 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_compile_unit)
171 createFilePathPair(VMContext, Filename, Directory),
172 TempEnumTypes, TempRetainTypes, TempSubprograms, TempGVs,
173 TempImportedModules};
175 // TODO: Switch to getDistinct(). We never want to merge compile units based
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 auto R = DIDerivedType(MDNode::get(VMContext, Elts));
419 trackIfUnresolved(R);
423 DIDerivedType DIBuilder::createMemberType(DIDescriptor Scope, StringRef Name,
424 DIFile File, unsigned LineNumber,
426 uint64_t AlignInBits,
427 uint64_t OffsetInBits, unsigned Flags,
429 // TAG_member is encoded in DIDerivedType format.
430 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
435 .concat(OffsetInBits)
439 DIScope(getNonCompileUnitScope(Scope)).getRef(),
441 return DIDerivedType(MDNode::get(VMContext, Elts));
444 static Metadata *getConstantOrNull(Constant *C) {
446 return ConstantAsMetadata::get(C);
450 DIDerivedType DIBuilder::createStaticMemberType(DIDescriptor Scope,
451 StringRef Name, DIFile File,
452 unsigned LineNumber, DIType Ty,
454 llvm::Constant *Val) {
455 // TAG_member is encoded in DIDerivedType format.
456 Flags |= DIDescriptor::FlagStaticMember;
457 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
466 DIScope(getNonCompileUnitScope(Scope)).getRef(),
467 Ty.getRef(), getConstantOrNull(Val)};
468 return DIDerivedType(MDNode::get(VMContext, Elts));
471 DIDerivedType DIBuilder::createObjCIVar(StringRef Name, DIFile File,
474 uint64_t AlignInBits,
475 uint64_t OffsetInBits, unsigned Flags,
476 DIType Ty, MDNode *PropertyNode) {
477 // TAG_member is encoded in DIDerivedType format.
478 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
483 .concat(OffsetInBits)
486 File.getFileNode(), getNonCompileUnitScope(File), Ty,
488 return DIDerivedType(MDNode::get(VMContext, Elts));
492 DIBuilder::createObjCProperty(StringRef Name, DIFile File, unsigned LineNumber,
493 StringRef GetterName, StringRef SetterName,
494 unsigned PropertyAttributes, DIType Ty) {
495 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_APPLE_property)
500 .concat(PropertyAttributes)
503 return DIObjCProperty(MDNode::get(VMContext, Elts));
506 DITemplateTypeParameter
507 DIBuilder::createTemplateTypeParameter(DIDescriptor Context, StringRef Name,
509 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_template_type_parameter)
514 DIScope(getNonCompileUnitScope(Context)).getRef(),
515 Ty.getRef(), nullptr};
516 return DITemplateTypeParameter(MDNode::get(VMContext, Elts));
519 static DITemplateValueParameter
520 createTemplateValueParameterHelper(LLVMContext &VMContext, unsigned Tag,
521 DIDescriptor Context, StringRef Name,
522 DIType Ty, Metadata *MD) {
524 HeaderBuilder::get(Tag).concat(Name).concat(0).concat(0).get(VMContext),
525 DIScope(getNonCompileUnitScope(Context)).getRef(), Ty.getRef(), MD,
527 return DITemplateValueParameter(MDNode::get(VMContext, Elts));
530 DITemplateValueParameter
531 DIBuilder::createTemplateValueParameter(DIDescriptor Context, StringRef Name,
532 DIType Ty, Constant *Val) {
533 return createTemplateValueParameterHelper(
534 VMContext, dwarf::DW_TAG_template_value_parameter, Context, Name, Ty,
535 getConstantOrNull(Val));
538 DITemplateValueParameter
539 DIBuilder::createTemplateTemplateParameter(DIDescriptor Context, StringRef Name,
540 DIType Ty, StringRef Val) {
541 return createTemplateValueParameterHelper(
542 VMContext, dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
543 MDString::get(VMContext, Val));
546 DITemplateValueParameter
547 DIBuilder::createTemplateParameterPack(DIDescriptor Context, StringRef Name,
548 DIType Ty, DIArray Val) {
549 return createTemplateValueParameterHelper(
550 VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
554 DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
555 DIFile File, unsigned LineNumber,
557 uint64_t AlignInBits,
558 uint64_t OffsetInBits,
559 unsigned Flags, DIType DerivedFrom,
562 MDNode *TemplateParams,
563 StringRef UniqueIdentifier) {
564 assert((!Context || Context.isScope() || Context.isType()) &&
565 "createClassType should be called with a valid Context");
566 // TAG_class_type is encoded in DICompositeType format.
568 HeaderBuilder::get(dwarf::DW_TAG_class_type)
573 .concat(OffsetInBits)
577 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
578 DerivedFrom.getRef(), Elements, VTableHolder.getRef(), TemplateParams,
579 UniqueIdentifier.empty() ? nullptr
580 : MDString::get(VMContext, UniqueIdentifier)};
581 DICompositeType R(MDNode::get(VMContext, Elts));
582 assert(R.isCompositeType() &&
583 "createClassType should return a DICompositeType");
584 if (!UniqueIdentifier.empty())
589 DICompositeType DIBuilder::createStructType(DIDescriptor Context,
590 StringRef Name, DIFile File,
593 uint64_t AlignInBits,
594 unsigned Flags, DIType DerivedFrom,
596 unsigned RunTimeLang,
598 StringRef UniqueIdentifier) {
599 // TAG_structure_type is encoded in DICompositeType format.
601 HeaderBuilder::get(dwarf::DW_TAG_structure_type)
610 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
611 DerivedFrom.getRef(), Elements, VTableHolder.getRef(), nullptr,
612 UniqueIdentifier.empty() ? nullptr
613 : MDString::get(VMContext, UniqueIdentifier)};
614 DICompositeType R(MDNode::get(VMContext, Elts));
615 assert(R.isCompositeType() &&
616 "createStructType should return a DICompositeType");
617 if (!UniqueIdentifier.empty())
622 DICompositeType DIBuilder::createUnionType(DIDescriptor Scope, StringRef Name,
623 DIFile File, unsigned LineNumber,
625 uint64_t AlignInBits, unsigned Flags,
627 unsigned RunTimeLang,
628 StringRef UniqueIdentifier) {
629 // TAG_union_type is encoded in DICompositeType format.
631 HeaderBuilder::get(dwarf::DW_TAG_union_type)
640 File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
641 nullptr, Elements, nullptr, nullptr,
642 UniqueIdentifier.empty() ? nullptr
643 : MDString::get(VMContext, UniqueIdentifier)};
644 DICompositeType R(MDNode::get(VMContext, Elts));
645 if (!UniqueIdentifier.empty())
650 DISubroutineType DIBuilder::createSubroutineType(DIFile File,
651 DITypeArray ParameterTypes,
653 // TAG_subroutine_type is encoded in DICompositeType format.
655 HeaderBuilder::get(dwarf::DW_TAG_subroutine_type)
661 .concat(Flags) // Flags
664 nullptr, nullptr, nullptr, ParameterTypes, nullptr, nullptr,
665 nullptr // Type Identifer
667 return DISubroutineType(MDNode::get(VMContext, Elts));
670 DICompositeType DIBuilder::createEnumerationType(
671 DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
672 uint64_t SizeInBits, uint64_t AlignInBits, DIArray Elements,
673 DIType UnderlyingType, StringRef UniqueIdentifier) {
674 // TAG_enumeration_type is encoded in DICompositeType format.
676 HeaderBuilder::get(dwarf::DW_TAG_enumeration_type)
685 File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
686 UnderlyingType.getRef(), Elements, nullptr, nullptr,
687 UniqueIdentifier.empty() ? nullptr
688 : MDString::get(VMContext, UniqueIdentifier)};
689 DICompositeType CTy(MDNode::get(VMContext, Elts));
690 AllEnumTypes.push_back(CTy);
691 if (!UniqueIdentifier.empty())
696 DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
697 DIType Ty, DIArray Subscripts) {
698 // TAG_array_type is encoded in DICompositeType format.
700 HeaderBuilder::get(dwarf::DW_TAG_array_type)
709 nullptr, // Filename/Directory,
711 Ty.getRef(), Subscripts, nullptr, nullptr,
712 nullptr // Type Identifer
714 return DICompositeType(MDNode::get(VMContext, Elts));
717 DICompositeType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
718 DIType Ty, DIArray Subscripts) {
719 // A vector is an array type with the FlagVector flag applied.
721 HeaderBuilder::get(dwarf::DW_TAG_array_type)
727 .concat(DIType::FlagVector)
730 nullptr, // Filename/Directory,
732 Ty.getRef(), Subscripts, nullptr, nullptr,
733 nullptr // Type Identifer
735 return DICompositeType(MDNode::get(VMContext, Elts));
738 static HeaderBuilder setTypeFlagsInHeader(StringRef Header,
739 unsigned FlagsToSet) {
740 DIHeaderFieldIterator I(Header);
744 if (I->getAsInteger(0, Flags))
748 return HeaderBuilder()
749 .concat(I.getPrefix())
751 .concat(I.getSuffix());
754 static DIType createTypeWithFlags(LLVMContext &Context, DIType Ty,
755 unsigned FlagsToSet) {
756 SmallVector<Metadata *, 9> Elts;
758 assert(N && "Unexpected input DIType!");
759 // Update header field.
760 Elts.push_back(setTypeFlagsInHeader(Ty.getHeader(), FlagsToSet).get(Context));
761 for (unsigned I = 1, E = N->getNumOperands(); I != E; ++I)
762 Elts.push_back(N->getOperand(I));
764 return DIType(MDNode::get(Context, Elts));
767 DIType DIBuilder::createArtificialType(DIType Ty) {
768 if (Ty.isArtificial())
770 return createTypeWithFlags(VMContext, Ty, DIType::FlagArtificial);
773 DIType DIBuilder::createObjectPointerType(DIType Ty) {
774 if (Ty.isObjectPointer())
776 unsigned Flags = DIType::FlagObjectPointer | DIType::FlagArtificial;
777 return createTypeWithFlags(VMContext, Ty, Flags);
780 void DIBuilder::retainType(DIType T) { AllRetainTypes.emplace_back(T); }
782 DIBasicType DIBuilder::createUnspecifiedParameter() {
783 return DIBasicType();
787 DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIDescriptor Scope,
788 DIFile F, unsigned Line, unsigned RuntimeLang,
789 uint64_t SizeInBits, uint64_t AlignInBits,
790 StringRef UniqueIdentifier) {
791 // Create a temporary MDNode.
793 HeaderBuilder::get(Tag)
799 .concat(DIDescriptor::FlagFwdDecl)
802 F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
804 nullptr, // TemplateParams
805 UniqueIdentifier.empty() ? nullptr
806 : MDString::get(VMContext, UniqueIdentifier)};
807 MDNode *Node = MDNode::get(VMContext, Elts);
808 DICompositeType RetTy(Node);
809 assert(RetTy.isCompositeType() &&
810 "createForwardDecl result should be a DIType");
811 if (!UniqueIdentifier.empty())
816 DICompositeType DIBuilder::createReplaceableCompositeType(
817 unsigned Tag, StringRef Name, DIDescriptor Scope, DIFile F, unsigned Line,
818 unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
819 unsigned Flags, StringRef UniqueIdentifier) {
820 // Create a temporary MDNode.
822 HeaderBuilder::get(Tag)
831 F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
833 nullptr, // TemplateParams
834 UniqueIdentifier.empty() ? nullptr
835 : MDString::get(VMContext, UniqueIdentifier)};
836 DICompositeType RetTy(MDNode::getTemporary(VMContext, Elts).release());
837 assert(RetTy.isCompositeType() &&
838 "createReplaceableForwardDecl result should be a DIType");
839 if (!UniqueIdentifier.empty())
844 DIArray DIBuilder::getOrCreateArray(ArrayRef<Metadata *> Elements) {
845 return DIArray(MDNode::get(VMContext, Elements));
848 DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
849 SmallVector<llvm::Metadata *, 16> Elts;
850 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
851 if (Elements[i] && isa<MDNode>(Elements[i]))
852 Elts.push_back(DIType(cast<MDNode>(Elements[i])).getRef());
854 Elts.push_back(Elements[i]);
856 return DITypeArray(MDNode::get(VMContext, Elts));
859 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
860 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subrange_type)
865 return DISubrange(MDNode::get(VMContext, Elts));
868 static DIGlobalVariable createGlobalVariableHelper(
869 LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
870 StringRef LinkageName, DIFile F, unsigned LineNumber, DITypeRef Ty,
871 bool isLocalToUnit, Constant *Val, MDNode *Decl, bool isDefinition,
872 std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
874 MDNode *TheCtx = getNonCompileUnitScope(Context);
875 if (DIScope(TheCtx).isCompositeType()) {
876 assert(!DICompositeType(TheCtx).getIdentifier() &&
877 "Context of a global variable should not be a type with identifier");
880 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_variable)
885 .concat(isLocalToUnit)
886 .concat(isDefinition)
888 TheCtx, F, Ty, getConstantOrNull(Val),
891 return DIGlobalVariable(CreateFunc(Elts));
894 DIGlobalVariable DIBuilder::createGlobalVariable(
895 DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
896 unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
898 return createGlobalVariableHelper(
899 VMContext, Context, Name, LinkageName, F, LineNumber, Ty, isLocalToUnit,
900 Val, Decl, true, [&](ArrayRef<Metadata *> Elts) -> MDNode *{
901 MDNode *Node = MDNode::get(VMContext, Elts);
902 AllGVs.push_back(Node);
907 DIGlobalVariable DIBuilder::createTempGlobalVariableFwdDecl(
908 DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
909 unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
911 return createGlobalVariableHelper(VMContext, Context, Name, LinkageName, F,
912 LineNumber, Ty, isLocalToUnit, Val, Decl,
913 false, [&](ArrayRef<Metadata *> Elts) {
914 return MDNode::getTemporary(VMContext, Elts).release();
918 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
919 StringRef Name, DIFile File,
920 unsigned LineNo, DITypeRef Ty,
921 bool AlwaysPreserve, unsigned Flags,
923 DIDescriptor Context(getNonCompileUnitScope(Scope));
924 assert((!Context || Context.isScope()) &&
925 "createLocalVariable should be called with a valid Context");
926 Metadata *Elts[] = {HeaderBuilder::get(Tag)
928 .concat(LineNo | (ArgNo << 24))
931 getNonCompileUnitScope(Scope), File, Ty};
932 MDNode *Node = MDNode::get(VMContext, Elts);
933 if (AlwaysPreserve) {
934 // The optimizer may remove local variable. If there is an interest
935 // to preserve variable info in such situation then stash it in a
937 DISubprogram Fn(getDISubprogram(Scope));
938 assert(Fn && "Missing subprogram for local variable");
939 PreservedVariables[Fn].emplace_back(Node);
941 DIVariable RetVar(Node);
942 assert(RetVar.isVariable() &&
943 "createLocalVariable should return a valid DIVariable");
947 DIExpression DIBuilder::createExpression(ArrayRef<uint64_t> Addr) {
948 auto Header = HeaderBuilder::get(DW_TAG_expression);
949 for (uint64_t I : Addr)
951 Metadata *Elts[] = {Header.get(VMContext)};
952 return DIExpression(MDNode::get(VMContext, Elts));
955 DIExpression DIBuilder::createExpression(ArrayRef<int64_t> Signed) {
956 // TODO: Remove the callers of this signed version and delete.
957 SmallVector<uint64_t, 8> Addr(Signed.begin(), Signed.end());
958 return createExpression(Addr);
961 DIExpression DIBuilder::createBitPieceExpression(unsigned OffsetInBits,
962 unsigned SizeInBits) {
963 int64_t Addr[] = {dwarf::DW_OP_bit_piece, OffsetInBits, SizeInBits};
964 return createExpression(Addr);
967 DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
968 StringRef LinkageName, DIFile File,
969 unsigned LineNo, DICompositeType Ty,
970 bool isLocalToUnit, bool isDefinition,
971 unsigned ScopeLine, unsigned Flags,
972 bool isOptimized, Function *Fn,
973 MDNode *TParams, MDNode *Decl) {
974 // dragonegg does not generate identifier for types, so using an empty map
975 // to resolve the context should be fine.
976 DITypeIdentifierMap EmptyMap;
977 return createFunction(Context.resolve(EmptyMap), Name, LinkageName, File,
978 LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
979 Flags, isOptimized, Fn, TParams, Decl);
982 static DISubprogram createFunctionHelper(
983 LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
984 StringRef LinkageName, DIFile File, unsigned LineNo, DICompositeType Ty,
985 bool isLocalToUnit, bool isDefinition, unsigned ScopeLine, unsigned Flags,
986 bool isOptimized, Function *Fn, MDNode *TParams, MDNode *Decl, MDNode *Vars,
987 std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
988 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
989 "function types should be subroutines");
990 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
995 .concat(isLocalToUnit)
996 .concat(isDefinition)
1000 .concat(isOptimized)
1004 DIScope(getNonCompileUnitScope(Context)).getRef(), Ty,
1005 nullptr, getConstantOrNull(Fn), TParams, Decl, Vars};
1007 DISubprogram S(CreateFunc(Elts));
1008 assert(S.isSubprogram() &&
1009 "createFunction should return a valid DISubprogram");
1014 DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
1015 StringRef LinkageName, DIFile File,
1016 unsigned LineNo, DICompositeType Ty,
1017 bool isLocalToUnit, bool isDefinition,
1018 unsigned ScopeLine, unsigned Flags,
1019 bool isOptimized, Function *Fn,
1020 MDNode *TParams, MDNode *Decl) {
1021 return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1022 LineNo, Ty, isLocalToUnit, isDefinition,
1023 ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1024 MDNode::getTemporary(VMContext, None).release(),
1025 [&](ArrayRef<Metadata *> Elts) -> MDNode *{
1026 MDNode *Node = MDNode::get(VMContext, Elts);
1027 // Create a named metadata so that we
1028 // do not lose this mdnode.
1030 AllSubprograms.push_back(Node);
1036 DIBuilder::createTempFunctionFwdDecl(DIDescriptor Context, StringRef Name,
1037 StringRef LinkageName, DIFile File,
1038 unsigned LineNo, DICompositeType Ty,
1039 bool isLocalToUnit, bool isDefinition,
1040 unsigned ScopeLine, unsigned Flags,
1041 bool isOptimized, Function *Fn,
1042 MDNode *TParams, MDNode *Decl) {
1043 return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1044 LineNo, Ty, isLocalToUnit, isDefinition,
1045 ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1046 nullptr, [&](ArrayRef<Metadata *> Elts) {
1047 return MDNode::getTemporary(VMContext, Elts).release();
1051 DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
1052 StringRef LinkageName, DIFile F,
1053 unsigned LineNo, DICompositeType Ty,
1054 bool isLocalToUnit, bool isDefinition,
1055 unsigned VK, unsigned VIndex,
1056 DIType VTableHolder, unsigned Flags,
1057 bool isOptimized, Function *Fn,
1059 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
1060 "function types should be subroutines");
1061 assert(getNonCompileUnitScope(Context) &&
1062 "Methods should have both a Context and a context that isn't "
1063 "the compile unit.");
1064 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
1067 .concat(LinkageName)
1069 .concat(isLocalToUnit)
1070 .concat(isDefinition)
1074 .concat(isOptimized)
1076 // FIXME: Do we want to use different scope/lines?
1078 F.getFileNode(), DIScope(Context).getRef(), Ty,
1079 VTableHolder.getRef(), getConstantOrNull(Fn), TParam,
1081 MDNode *Node = MDNode::get(VMContext, Elts);
1083 AllSubprograms.push_back(Node);
1084 DISubprogram S(Node);
1085 assert(S.isSubprogram() && "createMethod should return a valid DISubprogram");
1089 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
1090 DIFile File, unsigned LineNo) {
1091 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_namespace)
1095 File.getFileNode(), getNonCompileUnitScope(Scope)};
1096 DINameSpace R(MDNode::get(VMContext, Elts));
1097 assert(R.Verify() &&
1098 "createNameSpace should return a verifiable DINameSpace");
1102 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
1104 unsigned Discriminator) {
1105 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1106 .concat(Discriminator)
1108 File.getFileNode(), Scope};
1109 DILexicalBlockFile R(MDNode::get(VMContext, Elts));
1112 "createLexicalBlockFile should return a verifiable DILexicalBlockFile");
1116 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
1117 unsigned Line, unsigned Col) {
1118 // FIXME: This isn't thread safe nor the right way to defeat MDNode uniquing.
1119 // I believe the right way is to have a self-referential element in the node.
1120 // Also: why do we bother with line/column - they're not used and the
1121 // documentation (SourceLevelDebugging.rst) claims the line/col are necessary
1122 // for uniquing, yet then we have this other solution (because line/col were
1123 // inadequate) anyway. Remove all 3 and replace them with a self-reference.
1125 // Defeat MDNode uniquing for lexical blocks by using unique id.
1126 static unsigned int unique_id = 0;
1127 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1130 .concat(unique_id++)
1132 File.getFileNode(), getNonCompileUnitScope(Scope)};
1133 DILexicalBlock R(MDNode::get(VMContext, Elts));
1134 assert(R.Verify() &&
1135 "createLexicalBlock should return a verifiable DILexicalBlock");
1139 static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) {
1140 assert(V && "no value passed to dbg intrinsic");
1141 return MetadataAsValue::get(VMContext, ValueAsMetadata::get(V));
1144 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1146 Instruction *InsertBefore) {
1147 assert(VarInfo.isVariable() &&
1148 "empty or invalid DIVariable passed to dbg.declare");
1150 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1152 trackIfUnresolved(VarInfo);
1153 trackIfUnresolved(Expr);
1154 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1155 MetadataAsValue::get(VMContext, VarInfo),
1156 MetadataAsValue::get(VMContext, Expr)};
1157 return CallInst::Create(DeclareFn, Args, "", InsertBefore);
1160 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1162 BasicBlock *InsertAtEnd) {
1163 assert(VarInfo.isVariable() &&
1164 "empty or invalid DIVariable passed to dbg.declare");
1166 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1168 trackIfUnresolved(VarInfo);
1169 trackIfUnresolved(Expr);
1170 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1171 MetadataAsValue::get(VMContext, VarInfo),
1172 MetadataAsValue::get(VMContext, Expr)};
1174 // If this block already has a terminator then insert this intrinsic
1175 // before the terminator.
1176 if (TerminatorInst *T = InsertAtEnd->getTerminator())
1177 return CallInst::Create(DeclareFn, Args, "", T);
1179 return CallInst::Create(DeclareFn, Args, "", InsertAtEnd);
1182 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1185 Instruction *InsertBefore) {
1186 assert(V && "no value passed to dbg.value");
1187 assert(VarInfo.isVariable() &&
1188 "empty or invalid DIVariable passed to dbg.value");
1190 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1192 trackIfUnresolved(VarInfo);
1193 trackIfUnresolved(Expr);
1194 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1195 ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1196 MetadataAsValue::get(VMContext, VarInfo),
1197 MetadataAsValue::get(VMContext, Expr)};
1198 return CallInst::Create(ValueFn, Args, "", InsertBefore);
1201 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1204 BasicBlock *InsertAtEnd) {
1205 assert(V && "no value passed to dbg.value");
1206 assert(VarInfo.isVariable() &&
1207 "empty or invalid DIVariable passed to dbg.value");
1209 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1211 trackIfUnresolved(VarInfo);
1212 trackIfUnresolved(Expr);
1213 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1214 ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1215 MetadataAsValue::get(VMContext, VarInfo),
1216 MetadataAsValue::get(VMContext, Expr)};
1217 return CallInst::Create(ValueFn, Args, "", InsertAtEnd);
1220 void DIBuilder::replaceVTableHolder(DICompositeType &T, DICompositeType VTableHolder) {
1221 T.setContainingType(VTableHolder);
1223 // If this didn't create a self-reference, just return.
1224 if (T != VTableHolder)
1227 // Look for unresolved operands. T will drop RAUW support, orphaning any
1228 // cycles underneath it.
1229 if (T->isResolved())
1230 for (const MDOperand &O : T->operands())
1231 if (auto *N = dyn_cast_or_null<MDNode>(O))
1232 trackIfUnresolved(N);
1235 void DIBuilder::replaceArrays(DICompositeType &T, DIArray Elements,
1237 T.setArrays(Elements, TParams);
1239 // If T isn't resolved, there's no problem.
1240 if (!T->isResolved())
1243 // If "T" is resolved, it may be due to a self-reference cycle. Track the
1244 // arrays explicitly if they're unresolved, or else the cycles will be
1247 trackIfUnresolved(Elements);
1249 trackIfUnresolved(TParams);