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,
508 DIType Ty, MDNode *File, unsigned LineNo,
510 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_template_type_parameter)
515 DIScope(getNonCompileUnitScope(Context)).getRef(),
517 return DITemplateTypeParameter(MDNode::get(VMContext, Elts));
520 static DITemplateValueParameter createTemplateValueParameterHelper(
521 LLVMContext &VMContext, unsigned Tag, DIDescriptor Context, StringRef Name,
522 DIType Ty, Metadata *MD, MDNode *File, unsigned LineNo, unsigned ColumnNo) {
524 HeaderBuilder::get(Tag).concat(Name).concat(LineNo).concat(ColumnNo).get(
526 DIScope(getNonCompileUnitScope(Context)).getRef(), Ty.getRef(), MD, File};
527 return DITemplateValueParameter(MDNode::get(VMContext, Elts));
530 DITemplateValueParameter
531 DIBuilder::createTemplateValueParameter(DIDescriptor Context, StringRef Name,
532 DIType Ty, Constant *Val, MDNode *File,
533 unsigned LineNo, unsigned ColumnNo) {
534 return createTemplateValueParameterHelper(
535 VMContext, dwarf::DW_TAG_template_value_parameter, Context, Name, Ty,
536 getConstantOrNull(Val), File, LineNo, ColumnNo);
539 DITemplateValueParameter
540 DIBuilder::createTemplateTemplateParameter(DIDescriptor Context, StringRef Name,
541 DIType Ty, StringRef Val,
542 MDNode *File, unsigned LineNo,
544 return createTemplateValueParameterHelper(
545 VMContext, dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
546 MDString::get(VMContext, Val), File, LineNo, ColumnNo);
549 DITemplateValueParameter
550 DIBuilder::createTemplateParameterPack(DIDescriptor Context, StringRef Name,
551 DIType Ty, DIArray Val,
552 MDNode *File, unsigned LineNo,
554 return createTemplateValueParameterHelper(
555 VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
556 Val, File, LineNo, ColumnNo);
559 DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
560 DIFile File, unsigned LineNumber,
562 uint64_t AlignInBits,
563 uint64_t OffsetInBits,
564 unsigned Flags, DIType DerivedFrom,
567 MDNode *TemplateParams,
568 StringRef UniqueIdentifier) {
569 assert((!Context || Context.isScope() || Context.isType()) &&
570 "createClassType should be called with a valid Context");
571 // TAG_class_type is encoded in DICompositeType format.
573 HeaderBuilder::get(dwarf::DW_TAG_class_type)
578 .concat(OffsetInBits)
582 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
583 DerivedFrom.getRef(), Elements, VTableHolder.getRef(), TemplateParams,
584 UniqueIdentifier.empty() ? nullptr
585 : MDString::get(VMContext, UniqueIdentifier)};
586 DICompositeType R(MDNode::get(VMContext, Elts));
587 assert(R.isCompositeType() &&
588 "createClassType should return a DICompositeType");
589 if (!UniqueIdentifier.empty())
594 DICompositeType DIBuilder::createStructType(DIDescriptor Context,
595 StringRef Name, DIFile File,
598 uint64_t AlignInBits,
599 unsigned Flags, DIType DerivedFrom,
601 unsigned RunTimeLang,
603 StringRef UniqueIdentifier) {
604 // TAG_structure_type is encoded in DICompositeType format.
606 HeaderBuilder::get(dwarf::DW_TAG_structure_type)
615 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
616 DerivedFrom.getRef(), Elements, VTableHolder.getRef(), nullptr,
617 UniqueIdentifier.empty() ? nullptr
618 : MDString::get(VMContext, UniqueIdentifier)};
619 DICompositeType R(MDNode::get(VMContext, Elts));
620 assert(R.isCompositeType() &&
621 "createStructType should return a DICompositeType");
622 if (!UniqueIdentifier.empty())
627 DICompositeType DIBuilder::createUnionType(DIDescriptor Scope, StringRef Name,
628 DIFile File, unsigned LineNumber,
630 uint64_t AlignInBits, unsigned Flags,
632 unsigned RunTimeLang,
633 StringRef UniqueIdentifier) {
634 // TAG_union_type is encoded in DICompositeType format.
636 HeaderBuilder::get(dwarf::DW_TAG_union_type)
645 File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
646 nullptr, Elements, nullptr, nullptr,
647 UniqueIdentifier.empty() ? nullptr
648 : MDString::get(VMContext, UniqueIdentifier)};
649 DICompositeType R(MDNode::get(VMContext, Elts));
650 if (!UniqueIdentifier.empty())
655 DISubroutineType DIBuilder::createSubroutineType(DIFile File,
656 DITypeArray ParameterTypes,
658 // TAG_subroutine_type is encoded in DICompositeType format.
660 HeaderBuilder::get(dwarf::DW_TAG_subroutine_type)
666 .concat(Flags) // Flags
669 nullptr, nullptr, nullptr, ParameterTypes, nullptr, nullptr,
670 nullptr // Type Identifer
672 return DISubroutineType(MDNode::get(VMContext, Elts));
675 DICompositeType DIBuilder::createEnumerationType(
676 DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
677 uint64_t SizeInBits, uint64_t AlignInBits, DIArray Elements,
678 DIType UnderlyingType, StringRef UniqueIdentifier) {
679 // TAG_enumeration_type is encoded in DICompositeType format.
681 HeaderBuilder::get(dwarf::DW_TAG_enumeration_type)
690 File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
691 UnderlyingType.getRef(), Elements, nullptr, nullptr,
692 UniqueIdentifier.empty() ? nullptr
693 : MDString::get(VMContext, UniqueIdentifier)};
694 DICompositeType CTy(MDNode::get(VMContext, Elts));
695 AllEnumTypes.push_back(CTy);
696 if (!UniqueIdentifier.empty())
701 DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
702 DIType Ty, DIArray Subscripts) {
703 // TAG_array_type is encoded in DICompositeType format.
705 HeaderBuilder::get(dwarf::DW_TAG_array_type)
714 nullptr, // Filename/Directory,
716 Ty.getRef(), Subscripts, nullptr, nullptr,
717 nullptr // Type Identifer
719 return DICompositeType(MDNode::get(VMContext, Elts));
722 DICompositeType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
723 DIType Ty, DIArray Subscripts) {
724 // A vector is an array type with the FlagVector flag applied.
726 HeaderBuilder::get(dwarf::DW_TAG_array_type)
732 .concat(DIType::FlagVector)
735 nullptr, // Filename/Directory,
737 Ty.getRef(), Subscripts, nullptr, nullptr,
738 nullptr // Type Identifer
740 return DICompositeType(MDNode::get(VMContext, Elts));
743 static HeaderBuilder setTypeFlagsInHeader(StringRef Header,
744 unsigned FlagsToSet) {
745 DIHeaderFieldIterator I(Header);
749 if (I->getAsInteger(0, Flags))
753 return HeaderBuilder()
754 .concat(I.getPrefix())
756 .concat(I.getSuffix());
759 static DIType createTypeWithFlags(LLVMContext &Context, DIType Ty,
760 unsigned FlagsToSet) {
761 SmallVector<Metadata *, 9> Elts;
763 assert(N && "Unexpected input DIType!");
764 // Update header field.
765 Elts.push_back(setTypeFlagsInHeader(Ty.getHeader(), FlagsToSet).get(Context));
766 for (unsigned I = 1, E = N->getNumOperands(); I != E; ++I)
767 Elts.push_back(N->getOperand(I));
769 return DIType(MDNode::get(Context, Elts));
772 DIType DIBuilder::createArtificialType(DIType Ty) {
773 if (Ty.isArtificial())
775 return createTypeWithFlags(VMContext, Ty, DIType::FlagArtificial);
778 DIType DIBuilder::createObjectPointerType(DIType Ty) {
779 if (Ty.isObjectPointer())
781 unsigned Flags = DIType::FlagObjectPointer | DIType::FlagArtificial;
782 return createTypeWithFlags(VMContext, Ty, Flags);
785 void DIBuilder::retainType(DIType T) { AllRetainTypes.emplace_back(T); }
787 DIBasicType DIBuilder::createUnspecifiedParameter() {
788 return DIBasicType();
792 DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIDescriptor Scope,
793 DIFile F, unsigned Line, unsigned RuntimeLang,
794 uint64_t SizeInBits, uint64_t AlignInBits,
795 StringRef UniqueIdentifier) {
796 // Create a temporary MDNode.
798 HeaderBuilder::get(Tag)
804 .concat(DIDescriptor::FlagFwdDecl)
807 F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
809 nullptr, // TemplateParams
810 UniqueIdentifier.empty() ? nullptr
811 : MDString::get(VMContext, UniqueIdentifier)};
812 MDNode *Node = MDNode::get(VMContext, Elts);
813 DICompositeType RetTy(Node);
814 assert(RetTy.isCompositeType() &&
815 "createForwardDecl result should be a DIType");
816 if (!UniqueIdentifier.empty())
821 DICompositeType DIBuilder::createReplaceableCompositeType(
822 unsigned Tag, StringRef Name, DIDescriptor Scope, DIFile F, unsigned Line,
823 unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
824 unsigned Flags, StringRef UniqueIdentifier) {
825 // Create a temporary MDNode.
827 HeaderBuilder::get(Tag)
836 F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
838 nullptr, // TemplateParams
839 UniqueIdentifier.empty() ? nullptr
840 : MDString::get(VMContext, UniqueIdentifier)};
841 DICompositeType RetTy(MDNode::getTemporary(VMContext, Elts).release());
842 assert(RetTy.isCompositeType() &&
843 "createReplaceableForwardDecl result should be a DIType");
844 if (!UniqueIdentifier.empty())
849 DIArray DIBuilder::getOrCreateArray(ArrayRef<Metadata *> Elements) {
850 return DIArray(MDNode::get(VMContext, Elements));
853 DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
854 SmallVector<llvm::Metadata *, 16> Elts;
855 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
856 if (Elements[i] && isa<MDNode>(Elements[i]))
857 Elts.push_back(DIType(cast<MDNode>(Elements[i])).getRef());
859 Elts.push_back(Elements[i]);
861 return DITypeArray(MDNode::get(VMContext, Elts));
864 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
865 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subrange_type)
870 return DISubrange(MDNode::get(VMContext, Elts));
873 static DIGlobalVariable createGlobalVariableHelper(
874 LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
875 StringRef LinkageName, DIFile F, unsigned LineNumber, DITypeRef Ty,
876 bool isLocalToUnit, Constant *Val, MDNode *Decl, bool isDefinition,
877 std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
879 MDNode *TheCtx = getNonCompileUnitScope(Context);
880 if (DIScope(TheCtx).isCompositeType()) {
881 assert(!DICompositeType(TheCtx).getIdentifier() &&
882 "Context of a global variable should not be a type with identifier");
885 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_variable)
890 .concat(isLocalToUnit)
891 .concat(isDefinition)
893 TheCtx, F, Ty, getConstantOrNull(Val),
896 return DIGlobalVariable(CreateFunc(Elts));
899 DIGlobalVariable DIBuilder::createGlobalVariable(
900 DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
901 unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
903 return createGlobalVariableHelper(
904 VMContext, Context, Name, LinkageName, F, LineNumber, Ty, isLocalToUnit,
905 Val, Decl, true, [&](ArrayRef<Metadata *> Elts) -> MDNode *{
906 MDNode *Node = MDNode::get(VMContext, Elts);
907 AllGVs.push_back(Node);
912 DIGlobalVariable DIBuilder::createTempGlobalVariableFwdDecl(
913 DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
914 unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
916 return createGlobalVariableHelper(VMContext, Context, Name, LinkageName, F,
917 LineNumber, Ty, isLocalToUnit, Val, Decl,
918 false, [&](ArrayRef<Metadata *> Elts) {
919 return MDNode::getTemporary(VMContext, Elts).release();
923 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
924 StringRef Name, DIFile File,
925 unsigned LineNo, DITypeRef Ty,
926 bool AlwaysPreserve, unsigned Flags,
928 DIDescriptor Context(getNonCompileUnitScope(Scope));
929 assert((!Context || Context.isScope()) &&
930 "createLocalVariable should be called with a valid Context");
931 Metadata *Elts[] = {HeaderBuilder::get(Tag)
933 .concat(LineNo | (ArgNo << 24))
936 getNonCompileUnitScope(Scope), File, Ty};
937 MDNode *Node = MDNode::get(VMContext, Elts);
938 if (AlwaysPreserve) {
939 // The optimizer may remove local variable. If there is an interest
940 // to preserve variable info in such situation then stash it in a
942 DISubprogram Fn(getDISubprogram(Scope));
943 assert(Fn && "Missing subprogram for local variable");
944 PreservedVariables[Fn].emplace_back(Node);
946 DIVariable RetVar(Node);
947 assert(RetVar.isVariable() &&
948 "createLocalVariable should return a valid DIVariable");
952 DIExpression DIBuilder::createExpression(ArrayRef<uint64_t> Addr) {
953 auto Header = HeaderBuilder::get(DW_TAG_expression);
954 for (uint64_t I : Addr)
956 Metadata *Elts[] = {Header.get(VMContext)};
957 return DIExpression(MDNode::get(VMContext, Elts));
960 DIExpression DIBuilder::createExpression(ArrayRef<int64_t> Signed) {
961 // TODO: Remove the callers of this signed version and delete.
962 SmallVector<uint64_t, 8> Addr(Signed.begin(), Signed.end());
963 return createExpression(Addr);
966 DIExpression DIBuilder::createBitPieceExpression(unsigned OffsetInBits,
967 unsigned SizeInBits) {
968 int64_t Addr[] = {dwarf::DW_OP_bit_piece, OffsetInBits, SizeInBits};
969 return createExpression(Addr);
972 DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
973 StringRef LinkageName, DIFile File,
974 unsigned LineNo, DICompositeType Ty,
975 bool isLocalToUnit, bool isDefinition,
976 unsigned ScopeLine, unsigned Flags,
977 bool isOptimized, Function *Fn,
978 MDNode *TParams, MDNode *Decl) {
979 // dragonegg does not generate identifier for types, so using an empty map
980 // to resolve the context should be fine.
981 DITypeIdentifierMap EmptyMap;
982 return createFunction(Context.resolve(EmptyMap), Name, LinkageName, File,
983 LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
984 Flags, isOptimized, Fn, TParams, Decl);
987 static DISubprogram createFunctionHelper(
988 LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
989 StringRef LinkageName, DIFile File, unsigned LineNo, DICompositeType Ty,
990 bool isLocalToUnit, bool isDefinition, unsigned ScopeLine, unsigned Flags,
991 bool isOptimized, Function *Fn, MDNode *TParams, MDNode *Decl, MDNode *Vars,
992 std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
993 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
994 "function types should be subroutines");
995 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
1000 .concat(isLocalToUnit)
1001 .concat(isDefinition)
1005 .concat(isOptimized)
1009 DIScope(getNonCompileUnitScope(Context)).getRef(), Ty,
1010 nullptr, getConstantOrNull(Fn), TParams, Decl, Vars};
1012 DISubprogram S(CreateFunc(Elts));
1013 assert(S.isSubprogram() &&
1014 "createFunction should return a valid DISubprogram");
1019 DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
1020 StringRef LinkageName, DIFile File,
1021 unsigned LineNo, DICompositeType Ty,
1022 bool isLocalToUnit, bool isDefinition,
1023 unsigned ScopeLine, unsigned Flags,
1024 bool isOptimized, Function *Fn,
1025 MDNode *TParams, MDNode *Decl) {
1026 return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1027 LineNo, Ty, isLocalToUnit, isDefinition,
1028 ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1029 MDNode::getTemporary(VMContext, None).release(),
1030 [&](ArrayRef<Metadata *> Elts) -> MDNode *{
1031 MDNode *Node = MDNode::get(VMContext, Elts);
1032 // Create a named metadata so that we
1033 // do not lose this mdnode.
1035 AllSubprograms.push_back(Node);
1041 DIBuilder::createTempFunctionFwdDecl(DIDescriptor Context, StringRef Name,
1042 StringRef LinkageName, DIFile File,
1043 unsigned LineNo, DICompositeType Ty,
1044 bool isLocalToUnit, bool isDefinition,
1045 unsigned ScopeLine, unsigned Flags,
1046 bool isOptimized, Function *Fn,
1047 MDNode *TParams, MDNode *Decl) {
1048 return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1049 LineNo, Ty, isLocalToUnit, isDefinition,
1050 ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1051 nullptr, [&](ArrayRef<Metadata *> Elts) {
1052 return MDNode::getTemporary(VMContext, Elts).release();
1056 DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
1057 StringRef LinkageName, DIFile F,
1058 unsigned LineNo, DICompositeType Ty,
1059 bool isLocalToUnit, bool isDefinition,
1060 unsigned VK, unsigned VIndex,
1061 DIType VTableHolder, unsigned Flags,
1062 bool isOptimized, Function *Fn,
1064 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
1065 "function types should be subroutines");
1066 assert(getNonCompileUnitScope(Context) &&
1067 "Methods should have both a Context and a context that isn't "
1068 "the compile unit.");
1069 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
1072 .concat(LinkageName)
1074 .concat(isLocalToUnit)
1075 .concat(isDefinition)
1079 .concat(isOptimized)
1081 // FIXME: Do we want to use different scope/lines?
1083 F.getFileNode(), DIScope(Context).getRef(), Ty,
1084 VTableHolder.getRef(), getConstantOrNull(Fn), TParam,
1086 MDNode *Node = MDNode::get(VMContext, Elts);
1088 AllSubprograms.push_back(Node);
1089 DISubprogram S(Node);
1090 assert(S.isSubprogram() && "createMethod should return a valid DISubprogram");
1094 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
1095 DIFile File, unsigned LineNo) {
1096 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_namespace)
1100 File.getFileNode(), getNonCompileUnitScope(Scope)};
1101 DINameSpace R(MDNode::get(VMContext, Elts));
1102 assert(R.Verify() &&
1103 "createNameSpace should return a verifiable DINameSpace");
1107 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
1109 unsigned Discriminator) {
1110 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1111 .concat(Discriminator)
1113 File.getFileNode(), Scope};
1114 DILexicalBlockFile R(MDNode::get(VMContext, Elts));
1117 "createLexicalBlockFile should return a verifiable DILexicalBlockFile");
1121 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
1122 unsigned Line, unsigned Col) {
1123 // FIXME: This isn't thread safe nor the right way to defeat MDNode uniquing.
1124 // I believe the right way is to have a self-referential element in the node.
1125 // Also: why do we bother with line/column - they're not used and the
1126 // documentation (SourceLevelDebugging.rst) claims the line/col are necessary
1127 // for uniquing, yet then we have this other solution (because line/col were
1128 // inadequate) anyway. Remove all 3 and replace them with a self-reference.
1130 // Defeat MDNode uniquing for lexical blocks by using unique id.
1131 static unsigned int unique_id = 0;
1132 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1135 .concat(unique_id++)
1137 File.getFileNode(), getNonCompileUnitScope(Scope)};
1138 DILexicalBlock R(MDNode::get(VMContext, Elts));
1139 assert(R.Verify() &&
1140 "createLexicalBlock should return a verifiable DILexicalBlock");
1144 static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) {
1145 assert(V && "no value passed to dbg intrinsic");
1146 return MetadataAsValue::get(VMContext, ValueAsMetadata::get(V));
1149 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1151 Instruction *InsertBefore) {
1152 assert(VarInfo.isVariable() &&
1153 "empty or invalid DIVariable passed to dbg.declare");
1155 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1157 trackIfUnresolved(VarInfo);
1158 trackIfUnresolved(Expr);
1159 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1160 MetadataAsValue::get(VMContext, VarInfo),
1161 MetadataAsValue::get(VMContext, Expr)};
1162 return CallInst::Create(DeclareFn, Args, "", InsertBefore);
1165 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1167 BasicBlock *InsertAtEnd) {
1168 assert(VarInfo.isVariable() &&
1169 "empty or invalid DIVariable passed to dbg.declare");
1171 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1173 trackIfUnresolved(VarInfo);
1174 trackIfUnresolved(Expr);
1175 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1176 MetadataAsValue::get(VMContext, VarInfo),
1177 MetadataAsValue::get(VMContext, Expr)};
1179 // If this block already has a terminator then insert this intrinsic
1180 // before the terminator.
1181 if (TerminatorInst *T = InsertAtEnd->getTerminator())
1182 return CallInst::Create(DeclareFn, Args, "", T);
1184 return CallInst::Create(DeclareFn, Args, "", InsertAtEnd);
1187 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1190 Instruction *InsertBefore) {
1191 assert(V && "no value passed to dbg.value");
1192 assert(VarInfo.isVariable() &&
1193 "empty or invalid DIVariable passed to dbg.value");
1195 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1197 trackIfUnresolved(VarInfo);
1198 trackIfUnresolved(Expr);
1199 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1200 ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1201 MetadataAsValue::get(VMContext, VarInfo),
1202 MetadataAsValue::get(VMContext, Expr)};
1203 return CallInst::Create(ValueFn, Args, "", InsertBefore);
1206 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1209 BasicBlock *InsertAtEnd) {
1210 assert(V && "no value passed to dbg.value");
1211 assert(VarInfo.isVariable() &&
1212 "empty or invalid DIVariable passed to dbg.value");
1214 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1216 trackIfUnresolved(VarInfo);
1217 trackIfUnresolved(Expr);
1218 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1219 ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1220 MetadataAsValue::get(VMContext, VarInfo),
1221 MetadataAsValue::get(VMContext, Expr)};
1222 return CallInst::Create(ValueFn, Args, "", InsertAtEnd);
1225 void DIBuilder::replaceVTableHolder(DICompositeType &T, DICompositeType VTableHolder) {
1226 T.setContainingType(VTableHolder);
1228 // If this didn't create a self-reference, just return.
1229 if (T != VTableHolder)
1232 // Look for unresolved operands. T will drop RAUW support, orphaning any
1233 // cycles underneath it.
1234 if (T->isResolved())
1235 for (const MDOperand &O : T->operands())
1236 if (auto *N = dyn_cast_or_null<MDNode>(O))
1237 trackIfUnresolved(N);
1240 void DIBuilder::replaceArrays(DICompositeType &T, DIArray Elements,
1242 T.setArrays(Elements, TParams);
1244 // If T isn't resolved, there's no problem.
1245 if (!T->isResolved())
1248 // If "T" is resolved, it may be due to a self-reference cycle. Track the
1249 // arrays explicitly if they're unresolved, or else the cycles will be
1252 trackIfUnresolved(Elements);
1254 trackIfUnresolved(TParams);