1 //===--- DIBuilder.cpp - Debug Information Builder ------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the DIBuilder.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/IR/DIBuilder.h"
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/IR/Constants.h"
17 #include "llvm/IR/DebugInfo.h"
18 #include "llvm/IR/IntrinsicInst.h"
19 #include "llvm/IR/Module.h"
20 #include "llvm/Support/Debug.h"
21 #include "llvm/Support/Dwarf.h"
24 using namespace llvm::dwarf;
28 SmallVector<char, 256> Chars;
31 explicit HeaderBuilder(Twine T) { T.toVector(Chars); }
32 HeaderBuilder(const HeaderBuilder &X) : Chars(X.Chars) {}
33 HeaderBuilder(HeaderBuilder &&X) : Chars(std::move(X.Chars)) {}
35 template <class Twineable> HeaderBuilder &concat(Twineable &&X) {
37 Twine(X).toVector(Chars);
41 MDString *get(LLVMContext &Context) const {
42 return MDString::get(Context, StringRef(Chars.begin(), Chars.size()));
45 static HeaderBuilder get(unsigned Tag) {
46 return HeaderBuilder("0x" + Twine::utohexstr(Tag));
51 DIBuilder::DIBuilder(Module &m, bool AllowUnresolvedNodes)
52 : M(m), VMContext(M.getContext()), TempEnumTypes(nullptr),
53 TempRetainTypes(nullptr), TempSubprograms(nullptr), TempGVs(nullptr),
54 DeclareFn(nullptr), ValueFn(nullptr),
55 AllowUnresolvedNodes(AllowUnresolvedNodes) {}
57 void DIBuilder::trackIfUnresolved(MDNode *N) {
63 assert(AllowUnresolvedNodes && "Cannot handle unresolved nodes");
64 UnresolvedNodes.emplace_back(N);
67 void DIBuilder::finalize() {
68 DIArray Enums = getOrCreateArray(AllEnumTypes);
69 DIType(TempEnumTypes).replaceAllUsesWith(Enums);
71 SmallVector<Metadata *, 16> RetainValues;
72 // Declarations and definitions of the same type may be retained. Some
73 // clients RAUW these pairs, leaving duplicates in the retained types
74 // list. Use a set to remove the duplicates while we transform the
75 // TrackingVHs back into Values.
76 SmallPtrSet<Metadata *, 16> RetainSet;
77 for (unsigned I = 0, E = AllRetainTypes.size(); I < E; I++)
78 if (RetainSet.insert(AllRetainTypes[I]).second)
79 RetainValues.push_back(AllRetainTypes[I]);
80 DIArray RetainTypes = getOrCreateArray(RetainValues);
81 DIType(TempRetainTypes).replaceAllUsesWith(RetainTypes);
83 DIArray SPs = getOrCreateArray(AllSubprograms);
84 DIType(TempSubprograms).replaceAllUsesWith(SPs);
85 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) {
86 DISubprogram SP(SPs.getElement(i));
87 if (MDNode *Temp = SP.getVariablesNodes()) {
88 SmallVector<Metadata *, 4> Variables;
89 for (Metadata *V : PreservedVariables.lookup(SP))
90 Variables.push_back(V);
91 DIArray AV = getOrCreateArray(Variables);
92 DIType(Temp).replaceAllUsesWith(AV);
96 DIArray GVs = getOrCreateArray(AllGVs);
97 DIType(TempGVs).replaceAllUsesWith(GVs);
99 SmallVector<Metadata *, 16> RetainValuesI;
100 for (unsigned I = 0, E = AllImportedModules.size(); I < E; I++)
101 RetainValuesI.push_back(AllImportedModules[I]);
102 DIArray IMs = getOrCreateArray(RetainValuesI);
103 DIType(TempImportedModules).replaceAllUsesWith(IMs);
105 // Now that all temp nodes have been replaced or deleted, resolve remaining
107 for (const auto &N : UnresolvedNodes)
109 cast<UniquableMDNode>(N)->resolveCycles();
110 UnresolvedNodes.clear();
112 // Can't handle unresolved nodes anymore.
113 AllowUnresolvedNodes = false;
116 /// If N is compile unit return NULL otherwise return N.
117 static MDNode *getNonCompileUnitScope(MDNode *N) {
118 if (DIDescriptor(N).isCompileUnit())
123 static MDNode *createFilePathPair(LLVMContext &VMContext, StringRef Filename,
124 StringRef Directory) {
125 assert(!Filename.empty() && "Unable to create file without name");
126 Metadata *Pair[] = {MDString::get(VMContext, Filename),
127 MDString::get(VMContext, Directory)};
128 return MDNode::get(VMContext, Pair);
131 DICompileUnit DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename,
133 StringRef Producer, bool isOptimized,
134 StringRef Flags, unsigned RunTimeVer,
136 DebugEmissionKind Kind,
137 bool EmitDebugInfo) {
139 assert(((Lang <= dwarf::DW_LANG_OCaml && Lang >= dwarf::DW_LANG_C89) ||
140 (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) &&
141 "Invalid Language tag");
142 assert(!Filename.empty() &&
143 "Unable to create compile unit without filename");
144 Metadata *TElts[] = {HeaderBuilder::get(DW_TAG_base_type).get(VMContext)};
145 TempEnumTypes = MDNode::getTemporary(VMContext, TElts);
147 TempRetainTypes = MDNode::getTemporary(VMContext, TElts);
149 TempSubprograms = MDNode::getTemporary(VMContext, TElts);
151 TempGVs = MDNode::getTemporary(VMContext, TElts);
153 TempImportedModules = MDNode::getTemporary(VMContext, TElts);
155 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_compile_unit)
164 createFilePathPair(VMContext, Filename, Directory),
165 TempEnumTypes, TempRetainTypes, TempSubprograms, TempGVs,
166 TempImportedModules};
168 MDNode *CUNode = MDNode::get(VMContext, Elts);
170 // Create a named metadata so that it is easier to find cu in a module.
171 // Note that we only generate this when the caller wants to actually
172 // emit debug information. When we are only interested in tracking
173 // source line locations throughout the backend, we prevent codegen from
174 // emitting debug info in the final output by not generating llvm.dbg.cu.
176 NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
177 NMD->addOperand(CUNode);
180 trackIfUnresolved(CUNode);
181 return DICompileUnit(CUNode);
184 static DIImportedEntity
185 createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope Context,
186 Metadata *NS, unsigned Line, StringRef Name,
187 SmallVectorImpl<TrackingMDNodeRef> &AllImportedModules) {
189 Metadata *Elts[] = {HeaderBuilder::get(Tag).concat(Line).concat(Name).get(C),
191 R = MDNode::get(C, Elts);
192 DIImportedEntity M(R);
193 assert(M.Verify() && "Imported module should be valid");
194 AllImportedModules.emplace_back(M.get());
198 DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
201 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
202 Context, NS, Line, StringRef(), AllImportedModules);
205 DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
208 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
209 Context, NS, Line, StringRef(), AllImportedModules);
212 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
214 unsigned Line, StringRef Name) {
215 // Make sure to use the unique identifier based metadata reference for
216 // types that have one.
218 Decl.isType() ? static_cast<Metadata *>(DIType(Decl).getRef()) : Decl;
219 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
220 Context, V, Line, Name,
224 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
225 DIImportedEntity Imp,
226 unsigned Line, StringRef Name) {
227 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
228 Context, Imp, Line, Name, AllImportedModules);
231 DIFile DIBuilder::createFile(StringRef Filename, StringRef Directory) {
233 HeaderBuilder::get(dwarf::DW_TAG_file_type).get(VMContext),
234 createFilePathPair(VMContext, Filename, Directory)};
235 return DIFile(MDNode::get(VMContext, Elts));
238 DIEnumerator DIBuilder::createEnumerator(StringRef Name, int64_t Val) {
239 assert(!Name.empty() && "Unable to create enumerator without name");
240 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_enumerator)
244 return DIEnumerator(MDNode::get(VMContext, Elts));
247 DIBasicType DIBuilder::createUnspecifiedType(StringRef Name) {
248 assert(!Name.empty() && "Unable to create type without name");
249 // Unspecified types are encoded in DIBasicType format. Line number, filename,
250 // size, alignment, offset and flags are always empty here.
252 HeaderBuilder::get(dwarf::DW_TAG_unspecified_type)
264 return DIBasicType(MDNode::get(VMContext, Elts));
267 DIBasicType DIBuilder::createNullPtrType() {
268 return createUnspecifiedType("decltype(nullptr)");
272 DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
273 uint64_t AlignInBits, unsigned Encoding) {
274 assert(!Name.empty() && "Unable to create type without name");
275 // Basic types are encoded in DIBasicType format. Line number, filename,
276 // offset and flags are always empty here.
278 HeaderBuilder::get(dwarf::DW_TAG_base_type)
290 return DIBasicType(MDNode::get(VMContext, Elts));
293 DIDerivedType DIBuilder::createQualifiedType(unsigned Tag, DIType FromTy) {
294 // Qualified types are encoded in DIDerivedType format.
295 Metadata *Elts[] = {HeaderBuilder::get(Tag)
296 .concat(StringRef()) // Name
306 return DIDerivedType(MDNode::get(VMContext, Elts));
310 DIBuilder::createPointerType(DIType PointeeTy, uint64_t SizeInBits,
311 uint64_t AlignInBits, StringRef Name) {
312 // Pointer types are encoded in DIDerivedType format.
313 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_pointer_type)
324 return DIDerivedType(MDNode::get(VMContext, Elts));
328 DIBuilder::createMemberPointerType(DIType PointeeTy, DIType Base,
329 uint64_t SizeInBits, uint64_t AlignInBits) {
330 // Pointer types are encoded in DIDerivedType format.
331 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_ptr_to_member_type)
334 .concat(SizeInBits) // Size
335 .concat(AlignInBits) // Align
341 PointeeTy.getRef(), Base.getRef()};
342 return DIDerivedType(MDNode::get(VMContext, Elts));
345 DIDerivedType DIBuilder::createReferenceType(unsigned Tag, DIType RTy) {
346 assert(RTy.isType() && "Unable to create reference type");
347 // References are encoded in DIDerivedType format.
348 Metadata *Elts[] = {HeaderBuilder::get(Tag)
349 .concat(StringRef()) // Name
359 return DIDerivedType(MDNode::get(VMContext, Elts));
362 DIDerivedType DIBuilder::createTypedef(DIType Ty, StringRef Name, DIFile File,
363 unsigned LineNo, DIDescriptor Context) {
364 // typedefs are encoded in DIDerivedType format.
365 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_typedef)
374 DIScope(getNonCompileUnitScope(Context)).getRef(),
376 return DIDerivedType(MDNode::get(VMContext, Elts));
379 DIDerivedType DIBuilder::createFriend(DIType Ty, DIType FriendTy) {
380 // typedefs are encoded in DIDerivedType format.
381 assert(Ty.isType() && "Invalid type!");
382 assert(FriendTy.isType() && "Invalid friend type!");
383 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_friend)
384 .concat(StringRef()) // Name
391 nullptr, Ty.getRef(), FriendTy.getRef()};
392 return DIDerivedType(MDNode::get(VMContext, Elts));
395 DIDerivedType DIBuilder::createInheritance(DIType Ty, DIType BaseTy,
398 assert(Ty.isType() && "Unable to create inheritance");
399 // TAG_inheritance is encoded in DIDerivedType format.
400 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_inheritance)
401 .concat(StringRef()) // Name
408 nullptr, Ty.getRef(), BaseTy.getRef()};
409 return DIDerivedType(MDNode::get(VMContext, Elts));
412 DIDerivedType DIBuilder::createMemberType(DIDescriptor Scope, StringRef Name,
413 DIFile File, unsigned LineNumber,
415 uint64_t AlignInBits,
416 uint64_t OffsetInBits, unsigned Flags,
418 // TAG_member is encoded in DIDerivedType format.
419 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
424 .concat(OffsetInBits)
428 DIScope(getNonCompileUnitScope(Scope)).getRef(),
430 return DIDerivedType(MDNode::get(VMContext, Elts));
433 static Metadata *getConstantOrNull(Constant *C) {
435 return ConstantAsMetadata::get(C);
439 DIDerivedType DIBuilder::createStaticMemberType(DIDescriptor Scope,
440 StringRef Name, DIFile File,
441 unsigned LineNumber, DIType Ty,
443 llvm::Constant *Val) {
444 // TAG_member is encoded in DIDerivedType format.
445 Flags |= DIDescriptor::FlagStaticMember;
446 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
455 DIScope(getNonCompileUnitScope(Scope)).getRef(),
456 Ty.getRef(), getConstantOrNull(Val)};
457 return DIDerivedType(MDNode::get(VMContext, Elts));
460 DIDerivedType DIBuilder::createObjCIVar(StringRef Name, DIFile File,
463 uint64_t AlignInBits,
464 uint64_t OffsetInBits, unsigned Flags,
465 DIType Ty, MDNode *PropertyNode) {
466 // TAG_member is encoded in DIDerivedType format.
467 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
472 .concat(OffsetInBits)
475 File.getFileNode(), getNonCompileUnitScope(File), Ty,
477 return DIDerivedType(MDNode::get(VMContext, Elts));
481 DIBuilder::createObjCProperty(StringRef Name, DIFile File, unsigned LineNumber,
482 StringRef GetterName, StringRef SetterName,
483 unsigned PropertyAttributes, DIType Ty) {
484 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_APPLE_property)
489 .concat(PropertyAttributes)
492 return DIObjCProperty(MDNode::get(VMContext, Elts));
495 DITemplateTypeParameter
496 DIBuilder::createTemplateTypeParameter(DIDescriptor Context, StringRef Name,
497 DIType Ty, MDNode *File, unsigned LineNo,
499 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_template_type_parameter)
504 DIScope(getNonCompileUnitScope(Context)).getRef(),
506 return DITemplateTypeParameter(MDNode::get(VMContext, Elts));
509 static DITemplateValueParameter createTemplateValueParameterHelper(
510 LLVMContext &VMContext, unsigned Tag, DIDescriptor Context, StringRef Name,
511 DIType Ty, Metadata *MD, MDNode *File, unsigned LineNo, unsigned ColumnNo) {
513 HeaderBuilder::get(Tag).concat(Name).concat(LineNo).concat(ColumnNo).get(
515 DIScope(getNonCompileUnitScope(Context)).getRef(), Ty.getRef(), MD, File};
516 return DITemplateValueParameter(MDNode::get(VMContext, Elts));
519 DITemplateValueParameter
520 DIBuilder::createTemplateValueParameter(DIDescriptor Context, StringRef Name,
521 DIType Ty, Constant *Val, MDNode *File,
522 unsigned LineNo, unsigned ColumnNo) {
523 return createTemplateValueParameterHelper(
524 VMContext, dwarf::DW_TAG_template_value_parameter, Context, Name, Ty,
525 getConstantOrNull(Val), File, LineNo, ColumnNo);
528 DITemplateValueParameter
529 DIBuilder::createTemplateTemplateParameter(DIDescriptor Context, StringRef Name,
530 DIType Ty, StringRef Val,
531 MDNode *File, unsigned LineNo,
533 return createTemplateValueParameterHelper(
534 VMContext, dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
535 MDString::get(VMContext, Val), File, LineNo, ColumnNo);
538 DITemplateValueParameter
539 DIBuilder::createTemplateParameterPack(DIDescriptor Context, StringRef Name,
540 DIType Ty, DIArray Val,
541 MDNode *File, unsigned LineNo,
543 return createTemplateValueParameterHelper(
544 VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
545 Val, File, LineNo, ColumnNo);
548 DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
549 DIFile File, unsigned LineNumber,
551 uint64_t AlignInBits,
552 uint64_t OffsetInBits,
553 unsigned Flags, DIType DerivedFrom,
556 MDNode *TemplateParams,
557 StringRef UniqueIdentifier) {
558 assert((!Context || Context.isScope() || Context.isType()) &&
559 "createClassType should be called with a valid Context");
560 // TAG_class_type is encoded in DICompositeType format.
562 HeaderBuilder::get(dwarf::DW_TAG_class_type)
567 .concat(OffsetInBits)
571 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
572 DerivedFrom.getRef(), Elements, VTableHolder.getRef(), TemplateParams,
573 UniqueIdentifier.empty() ? nullptr
574 : MDString::get(VMContext, UniqueIdentifier)};
575 DICompositeType R(MDNode::get(VMContext, Elts));
576 assert(R.isCompositeType() &&
577 "createClassType should return a DICompositeType");
578 if (!UniqueIdentifier.empty())
583 DICompositeType DIBuilder::createStructType(DIDescriptor Context,
584 StringRef Name, DIFile File,
587 uint64_t AlignInBits,
588 unsigned Flags, DIType DerivedFrom,
590 unsigned RunTimeLang,
592 StringRef UniqueIdentifier) {
593 // TAG_structure_type is encoded in DICompositeType format.
595 HeaderBuilder::get(dwarf::DW_TAG_structure_type)
604 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
605 DerivedFrom.getRef(), Elements, VTableHolder.getRef(), nullptr,
606 UniqueIdentifier.empty() ? nullptr
607 : MDString::get(VMContext, UniqueIdentifier)};
608 DICompositeType R(MDNode::get(VMContext, Elts));
609 assert(R.isCompositeType() &&
610 "createStructType should return a DICompositeType");
611 if (!UniqueIdentifier.empty())
616 DICompositeType DIBuilder::createUnionType(DIDescriptor Scope, StringRef Name,
617 DIFile File, unsigned LineNumber,
619 uint64_t AlignInBits, unsigned Flags,
621 unsigned RunTimeLang,
622 StringRef UniqueIdentifier) {
623 // TAG_union_type is encoded in DICompositeType format.
625 HeaderBuilder::get(dwarf::DW_TAG_union_type)
634 File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
635 nullptr, Elements, nullptr, nullptr,
636 UniqueIdentifier.empty() ? nullptr
637 : MDString::get(VMContext, UniqueIdentifier)};
638 DICompositeType R(MDNode::get(VMContext, Elts));
639 if (!UniqueIdentifier.empty())
644 DISubroutineType DIBuilder::createSubroutineType(DIFile File,
645 DITypeArray ParameterTypes,
647 // TAG_subroutine_type is encoded in DICompositeType format.
649 HeaderBuilder::get(dwarf::DW_TAG_subroutine_type)
655 .concat(Flags) // Flags
658 nullptr, nullptr, nullptr, ParameterTypes, nullptr, nullptr,
659 nullptr // Type Identifer
661 return DISubroutineType(MDNode::get(VMContext, Elts));
664 DICompositeType DIBuilder::createEnumerationType(
665 DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
666 uint64_t SizeInBits, uint64_t AlignInBits, DIArray Elements,
667 DIType UnderlyingType, StringRef UniqueIdentifier) {
668 // TAG_enumeration_type is encoded in DICompositeType format.
670 HeaderBuilder::get(dwarf::DW_TAG_enumeration_type)
679 File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
680 UnderlyingType.getRef(), Elements, nullptr, nullptr,
681 UniqueIdentifier.empty() ? nullptr
682 : MDString::get(VMContext, UniqueIdentifier)};
683 DICompositeType CTy(MDNode::get(VMContext, Elts));
684 AllEnumTypes.push_back(CTy);
685 if (!UniqueIdentifier.empty())
690 DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
691 DIType Ty, DIArray Subscripts) {
692 // TAG_array_type is encoded in DICompositeType format.
694 HeaderBuilder::get(dwarf::DW_TAG_array_type)
703 nullptr, // Filename/Directory,
705 Ty.getRef(), Subscripts, nullptr, nullptr,
706 nullptr // Type Identifer
708 return DICompositeType(MDNode::get(VMContext, Elts));
711 DICompositeType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
712 DIType Ty, DIArray Subscripts) {
713 // A vector is an array type with the FlagVector flag applied.
715 HeaderBuilder::get(dwarf::DW_TAG_array_type)
721 .concat(DIType::FlagVector)
724 nullptr, // Filename/Directory,
726 Ty.getRef(), Subscripts, nullptr, nullptr,
727 nullptr // Type Identifer
729 return DICompositeType(MDNode::get(VMContext, Elts));
732 static HeaderBuilder setTypeFlagsInHeader(StringRef Header,
733 unsigned FlagsToSet) {
734 DIHeaderFieldIterator I(Header);
738 if (I->getAsInteger(0, Flags))
742 return HeaderBuilder(Twine(I.getPrefix())).concat(Flags).concat(
746 static DIType createTypeWithFlags(LLVMContext &Context, DIType Ty,
747 unsigned FlagsToSet) {
748 SmallVector<Metadata *, 9> Elts;
750 assert(N && "Unexpected input DIType!");
751 // Update header field.
752 Elts.push_back(setTypeFlagsInHeader(Ty.getHeader(), FlagsToSet).get(Context));
753 for (unsigned I = 1, E = N->getNumOperands(); I != E; ++I)
754 Elts.push_back(N->getOperand(I));
756 return DIType(MDNode::get(Context, Elts));
759 DIType DIBuilder::createArtificialType(DIType Ty) {
760 if (Ty.isArtificial())
762 return createTypeWithFlags(VMContext, Ty, DIType::FlagArtificial);
765 DIType DIBuilder::createObjectPointerType(DIType Ty) {
766 if (Ty.isObjectPointer())
768 unsigned Flags = DIType::FlagObjectPointer | DIType::FlagArtificial;
769 return createTypeWithFlags(VMContext, Ty, Flags);
772 void DIBuilder::retainType(DIType T) { AllRetainTypes.emplace_back(T); }
774 DIBasicType DIBuilder::createUnspecifiedParameter() {
775 return DIBasicType();
779 DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIDescriptor Scope,
780 DIFile F, unsigned Line, unsigned RuntimeLang,
781 uint64_t SizeInBits, uint64_t AlignInBits,
782 StringRef UniqueIdentifier) {
783 // Create a temporary MDNode.
785 HeaderBuilder::get(Tag)
791 .concat(DIDescriptor::FlagFwdDecl)
794 F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
796 nullptr, // TemplateParams
797 UniqueIdentifier.empty() ? nullptr
798 : MDString::get(VMContext, UniqueIdentifier)};
799 MDNode *Node = MDNode::get(VMContext, Elts);
800 DICompositeType RetTy(Node);
801 assert(RetTy.isCompositeType() &&
802 "createForwardDecl result should be a DIType");
803 if (!UniqueIdentifier.empty())
808 DICompositeType DIBuilder::createReplaceableForwardDecl(
809 unsigned Tag, StringRef Name, DIDescriptor Scope, DIFile F, unsigned Line,
810 unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
811 StringRef UniqueIdentifier) {
812 // Create a temporary MDNode.
814 HeaderBuilder::get(Tag)
820 .concat(DIDescriptor::FlagFwdDecl)
823 F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
825 nullptr, // TemplateParams
826 UniqueIdentifier.empty() ? nullptr
827 : MDString::get(VMContext, UniqueIdentifier)};
828 DICompositeType RetTy(MDNode::getTemporary(VMContext, Elts));
829 assert(RetTy.isCompositeType() &&
830 "createReplaceableForwardDecl result should be a DIType");
831 if (!UniqueIdentifier.empty())
836 DIArray DIBuilder::getOrCreateArray(ArrayRef<Metadata *> Elements) {
837 return DIArray(MDNode::get(VMContext, Elements));
840 DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
841 SmallVector<llvm::Metadata *, 16> Elts;
842 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
843 if (Elements[i] && isa<MDNode>(Elements[i]))
844 Elts.push_back(DIType(cast<MDNode>(Elements[i])).getRef());
846 Elts.push_back(Elements[i]);
848 return DITypeArray(MDNode::get(VMContext, Elts));
851 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
852 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subrange_type)
857 return DISubrange(MDNode::get(VMContext, Elts));
860 static DIGlobalVariable createGlobalVariableHelper(
861 LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
862 StringRef LinkageName, DIFile F, unsigned LineNumber, DITypeRef Ty,
863 bool isLocalToUnit, Constant *Val, MDNode *Decl, bool isDefinition,
864 std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
866 MDNode *TheCtx = getNonCompileUnitScope(Context);
867 if (DIScope(TheCtx).isCompositeType()) {
868 assert(!DICompositeType(TheCtx).getIdentifier() &&
869 "Context of a global variable should not be a type with identifier");
872 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_variable)
877 .concat(isLocalToUnit)
878 .concat(isDefinition)
880 TheCtx, F, Ty, getConstantOrNull(Val),
883 return DIGlobalVariable(CreateFunc(Elts));
886 DIGlobalVariable DIBuilder::createGlobalVariable(
887 DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
888 unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
890 return createGlobalVariableHelper(
891 VMContext, Context, Name, LinkageName, F, LineNumber, Ty, isLocalToUnit,
892 Val, Decl, true, [&](ArrayRef<Metadata *> Elts) -> MDNode *{
893 MDNode *Node = MDNode::get(VMContext, Elts);
894 AllGVs.push_back(Node);
899 DIGlobalVariable DIBuilder::createTempGlobalVariableFwdDecl(
900 DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
901 unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
903 return createGlobalVariableHelper(VMContext, Context, Name, LinkageName, F,
904 LineNumber, Ty, isLocalToUnit, Val, Decl,
905 false, [&](ArrayRef<Metadata *> Elts) {
906 return MDNode::getTemporary(VMContext, Elts);
910 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
911 StringRef Name, DIFile File,
912 unsigned LineNo, DITypeRef Ty,
913 bool AlwaysPreserve, unsigned Flags,
915 DIDescriptor Context(getNonCompileUnitScope(Scope));
916 assert((!Context || Context.isScope()) &&
917 "createLocalVariable should be called with a valid Context");
918 Metadata *Elts[] = {HeaderBuilder::get(Tag)
920 .concat(LineNo | (ArgNo << 24))
923 getNonCompileUnitScope(Scope), File, Ty};
924 MDNode *Node = MDNode::get(VMContext, Elts);
925 if (AlwaysPreserve) {
926 // The optimizer may remove local variable. If there is an interest
927 // to preserve variable info in such situation then stash it in a
929 DISubprogram Fn(getDISubprogram(Scope));
930 assert(Fn && "Missing subprogram for local variable");
931 PreservedVariables[Fn].emplace_back(Node);
933 DIVariable RetVar(Node);
934 assert(RetVar.isVariable() &&
935 "createLocalVariable should return a valid DIVariable");
939 DIExpression DIBuilder::createExpression(ArrayRef<int64_t> Addr) {
940 auto Header = HeaderBuilder::get(DW_TAG_expression);
941 for (int64_t I : Addr)
943 Metadata *Elts[] = {Header.get(VMContext)};
944 return DIExpression(MDNode::get(VMContext, Elts));
947 DIExpression DIBuilder::createPieceExpression(unsigned OffsetInBytes,
948 unsigned SizeInBytes) {
949 int64_t Addr[] = {dwarf::DW_OP_piece, OffsetInBytes, SizeInBytes};
950 return createExpression(Addr);
953 DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
954 StringRef LinkageName, DIFile File,
955 unsigned LineNo, DICompositeType Ty,
956 bool isLocalToUnit, bool isDefinition,
957 unsigned ScopeLine, unsigned Flags,
958 bool isOptimized, Function *Fn,
959 MDNode *TParams, MDNode *Decl) {
960 // dragonegg does not generate identifier for types, so using an empty map
961 // to resolve the context should be fine.
962 DITypeIdentifierMap EmptyMap;
963 return createFunction(Context.resolve(EmptyMap), Name, LinkageName, File,
964 LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
965 Flags, isOptimized, Fn, TParams, Decl);
968 static DISubprogram createFunctionHelper(
969 LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
970 StringRef LinkageName, DIFile File, unsigned LineNo, DICompositeType Ty,
971 bool isLocalToUnit, bool isDefinition, unsigned ScopeLine, unsigned Flags,
972 bool isOptimized, Function *Fn, MDNode *TParams, MDNode *Decl, MDNode *Vars,
973 std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
974 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
975 "function types should be subroutines");
976 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
981 .concat(isLocalToUnit)
982 .concat(isDefinition)
990 DIScope(getNonCompileUnitScope(Context)).getRef(), Ty,
991 nullptr, getConstantOrNull(Fn), TParams, Decl, Vars};
993 DISubprogram S(CreateFunc(Elts));
994 assert(S.isSubprogram() &&
995 "createFunction should return a valid DISubprogram");
1000 DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
1001 StringRef LinkageName, DIFile File,
1002 unsigned LineNo, DICompositeType Ty,
1003 bool isLocalToUnit, bool isDefinition,
1004 unsigned ScopeLine, unsigned Flags,
1005 bool isOptimized, Function *Fn,
1006 MDNode *TParams, MDNode *Decl) {
1007 return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1008 LineNo, Ty, isLocalToUnit, isDefinition,
1009 ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1010 MDNode::getTemporary(VMContext, None),
1011 [&](ArrayRef<Metadata *> Elts) -> MDNode *{
1012 MDNode *Node = MDNode::get(VMContext, Elts);
1013 // Create a named metadata so that we
1014 // do not lose this mdnode.
1016 AllSubprograms.push_back(Node);
1022 DIBuilder::createTempFunctionFwdDecl(DIDescriptor Context, StringRef Name,
1023 StringRef LinkageName, DIFile File,
1024 unsigned LineNo, DICompositeType Ty,
1025 bool isLocalToUnit, bool isDefinition,
1026 unsigned ScopeLine, unsigned Flags,
1027 bool isOptimized, Function *Fn,
1028 MDNode *TParams, MDNode *Decl) {
1029 return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1030 LineNo, Ty, isLocalToUnit, isDefinition,
1031 ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1032 nullptr, [&](ArrayRef<Metadata *> Elts) {
1033 return MDNode::getTemporary(VMContext, Elts);
1037 DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
1038 StringRef LinkageName, DIFile F,
1039 unsigned LineNo, DICompositeType Ty,
1040 bool isLocalToUnit, bool isDefinition,
1041 unsigned VK, unsigned VIndex,
1042 DIType VTableHolder, unsigned Flags,
1043 bool isOptimized, Function *Fn,
1045 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
1046 "function types should be subroutines");
1047 assert(getNonCompileUnitScope(Context) &&
1048 "Methods should have both a Context and a context that isn't "
1049 "the compile unit.");
1050 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
1053 .concat(LinkageName)
1055 .concat(isLocalToUnit)
1056 .concat(isDefinition)
1060 .concat(isOptimized)
1062 // FIXME: Do we want to use different scope/lines?
1064 F.getFileNode(), DIScope(Context).getRef(), Ty,
1065 VTableHolder.getRef(), getConstantOrNull(Fn), TParam,
1067 MDNode *Node = MDNode::get(VMContext, Elts);
1069 AllSubprograms.push_back(Node);
1070 DISubprogram S(Node);
1071 assert(S.isSubprogram() && "createMethod should return a valid DISubprogram");
1075 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
1076 DIFile File, unsigned LineNo) {
1077 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_namespace)
1081 File.getFileNode(), getNonCompileUnitScope(Scope)};
1082 DINameSpace R(MDNode::get(VMContext, Elts));
1083 assert(R.Verify() &&
1084 "createNameSpace should return a verifiable DINameSpace");
1088 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
1090 unsigned Discriminator) {
1091 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1092 .concat(Discriminator)
1094 File.getFileNode(), Scope};
1095 DILexicalBlockFile R(MDNode::get(VMContext, Elts));
1098 "createLexicalBlockFile should return a verifiable DILexicalBlockFile");
1102 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
1103 unsigned Line, unsigned Col) {
1104 // FIXME: This isn't thread safe nor the right way to defeat MDNode uniquing.
1105 // I believe the right way is to have a self-referential element in the node.
1106 // Also: why do we bother with line/column - they're not used and the
1107 // documentation (SourceLevelDebugging.rst) claims the line/col are necessary
1108 // for uniquing, yet then we have this other solution (because line/col were
1109 // inadequate) anyway. Remove all 3 and replace them with a self-reference.
1111 // Defeat MDNode uniquing for lexical blocks by using unique id.
1112 static unsigned int unique_id = 0;
1113 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1116 .concat(unique_id++)
1118 File.getFileNode(), getNonCompileUnitScope(Scope)};
1119 DILexicalBlock R(MDNode::get(VMContext, Elts));
1120 assert(R.Verify() &&
1121 "createLexicalBlock should return a verifiable DILexicalBlock");
1125 static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) {
1126 assert(V && "no value passed to dbg intrinsic");
1127 return MetadataAsValue::get(VMContext, ValueAsMetadata::get(V));
1130 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1132 Instruction *InsertBefore) {
1133 assert(VarInfo.isVariable() &&
1134 "empty or invalid DIVariable passed to dbg.declare");
1136 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1138 trackIfUnresolved(VarInfo);
1139 trackIfUnresolved(Expr);
1140 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1141 MetadataAsValue::get(VMContext, VarInfo),
1142 MetadataAsValue::get(VMContext, Expr)};
1143 return CallInst::Create(DeclareFn, Args, "", InsertBefore);
1146 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1148 BasicBlock *InsertAtEnd) {
1149 assert(VarInfo.isVariable() &&
1150 "empty or invalid DIVariable passed to dbg.declare");
1152 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1154 trackIfUnresolved(VarInfo);
1155 trackIfUnresolved(Expr);
1156 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1157 MetadataAsValue::get(VMContext, VarInfo),
1158 MetadataAsValue::get(VMContext, Expr)};
1160 // If this block already has a terminator then insert this intrinsic
1161 // before the terminator.
1162 if (TerminatorInst *T = InsertAtEnd->getTerminator())
1163 return CallInst::Create(DeclareFn, Args, "", T);
1165 return CallInst::Create(DeclareFn, Args, "", InsertAtEnd);
1168 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1171 Instruction *InsertBefore) {
1172 assert(V && "no value passed to dbg.value");
1173 assert(VarInfo.isVariable() &&
1174 "empty or invalid DIVariable passed to dbg.value");
1176 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1178 trackIfUnresolved(VarInfo);
1179 trackIfUnresolved(Expr);
1180 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1181 ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1182 MetadataAsValue::get(VMContext, VarInfo),
1183 MetadataAsValue::get(VMContext, Expr)};
1184 return CallInst::Create(ValueFn, Args, "", InsertBefore);
1187 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1190 BasicBlock *InsertAtEnd) {
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, "", InsertAtEnd);
1206 void DIBuilder::replaceVTableHolder(DICompositeType &T, DICompositeType VTableHolder) {
1207 T.setContainingType(VTableHolder);
1209 // If this didn't create a self-reference, just return.
1210 if (T != VTableHolder)
1213 // Look for unresolved operands. T has dropped RAUW support and is already
1214 // marked resolved, orphaning any cycles underneath it.
1215 assert(T->isResolved() && "Expected self-reference to be resolved");
1216 for (const MDOperand &O : T->operands())
1217 if (auto *N = dyn_cast_or_null<MDNode>(O))
1218 trackIfUnresolved(N);
1221 void DIBuilder::replaceArrays(DICompositeType &T, DIArray Elements,
1223 T.setArrays(Elements, TParams);
1225 // If T isn't resolved, there's no problem.
1226 if (!T->isResolved())
1229 // If "T" is resolved, it may be due to a self-reference cycle. Track the
1230 // arrays explicitly if they're unresolved, or else the cycles will be
1233 trackIfUnresolved(Elements);
1235 trackIfUnresolved(TParams);