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 const auto &PV = PreservedVariables.lookup(SP);
98 SmallVector<Metadata *, 4> Variables(PV.begin(), PV.end());
99 DIArray AV = getOrCreateArray(Variables);
100 DIType(Temp).replaceAllUsesWith(AV);
104 DIArray GVs = getOrCreateArray(AllGVs);
105 DIType(TempGVs).replaceAllUsesWith(GVs);
107 SmallVector<Metadata *, 16> RetainValuesI(AllImportedModules.begin(),
108 AllImportedModules.end());
109 DIArray IMs = getOrCreateArray(RetainValuesI);
110 DIType(TempImportedModules).replaceAllUsesWith(IMs);
112 // Now that all temp nodes have been replaced or deleted, resolve remaining
114 for (const auto &N : UnresolvedNodes)
115 if (N && !N->isResolved())
117 UnresolvedNodes.clear();
119 // Can't handle unresolved nodes anymore.
120 AllowUnresolvedNodes = false;
123 /// If N is compile unit return NULL otherwise return N.
124 static MDNode *getNonCompileUnitScope(MDNode *N) {
125 if (DIDescriptor(N).isCompileUnit())
130 static MDNode *createFilePathPair(LLVMContext &VMContext, StringRef Filename,
131 StringRef Directory) {
132 assert(!Filename.empty() && "Unable to create file without name");
133 Metadata *Pair[] = {MDString::get(VMContext, Filename),
134 MDString::get(VMContext, Directory)};
135 return MDNode::get(VMContext, Pair);
138 DICompileUnit DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename,
140 StringRef Producer, bool isOptimized,
141 StringRef Flags, unsigned RunTimeVer,
143 DebugEmissionKind Kind,
144 bool EmitDebugInfo) {
146 assert(((Lang <= dwarf::DW_LANG_Fortran08 && Lang >= dwarf::DW_LANG_C89) ||
147 (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) &&
148 "Invalid Language tag");
149 assert(!Filename.empty() &&
150 "Unable to create compile unit without filename");
152 // TODO: Once we make MDCompileUnit distinct, stop using temporaries here
153 // (just start with operands assigned to nullptr).
154 TempEnumTypes = MDTuple::getTemporary(VMContext, None).release();
155 TempRetainTypes = MDTuple::getTemporary(VMContext, None).release();
156 TempSubprograms = MDTuple::getTemporary(VMContext, None).release();
157 TempGVs = MDTuple::getTemporary(VMContext, None).release();
158 TempImportedModules = MDTuple::getTemporary(VMContext, None).release();
160 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_compile_unit)
169 createFilePathPair(VMContext, Filename, Directory),
170 TempEnumTypes, TempRetainTypes, TempSubprograms, TempGVs,
171 TempImportedModules};
173 // TODO: Switch to getDistinct(). We never want to merge compile units based
175 MDNode *CUNode = MDNode::get(VMContext, Elts);
177 // Create a named metadata so that it is easier to find cu in a module.
178 // Note that we only generate this when the caller wants to actually
179 // emit debug information. When we are only interested in tracking
180 // source line locations throughout the backend, we prevent codegen from
181 // emitting debug info in the final output by not generating llvm.dbg.cu.
183 NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
184 NMD->addOperand(CUNode);
187 trackIfUnresolved(CUNode);
188 return DICompileUnit(CUNode);
191 static DIImportedEntity
192 createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope Context,
193 Metadata *NS, unsigned Line, StringRef Name,
194 SmallVectorImpl<TrackingMDNodeRef> &AllImportedModules) {
196 Metadata *Elts[] = {HeaderBuilder::get(Tag).concat(Line).concat(Name).get(C),
198 R = MDNode::get(C, Elts);
199 DIImportedEntity M(R);
200 assert(M.Verify() && "Imported module should be valid");
201 AllImportedModules.emplace_back(M.get());
205 DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
208 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
209 Context, NS, Line, StringRef(), AllImportedModules);
212 DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
215 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
216 Context, NS, Line, StringRef(), AllImportedModules);
219 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
221 unsigned Line, StringRef Name) {
222 // Make sure to use the unique identifier based metadata reference for
223 // types that have one.
225 Decl.isType() ? static_cast<Metadata *>(DIType(Decl).getRef()) : Decl;
226 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
227 Context, V, Line, Name,
231 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
232 DIImportedEntity Imp,
233 unsigned Line, StringRef Name) {
234 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
235 Context, Imp, Line, Name, AllImportedModules);
238 DIFile DIBuilder::createFile(StringRef Filename, StringRef Directory) {
240 HeaderBuilder::get(dwarf::DW_TAG_file_type).get(VMContext),
241 createFilePathPair(VMContext, Filename, Directory)};
242 return DIFile(MDNode::get(VMContext, Elts));
245 DIEnumerator DIBuilder::createEnumerator(StringRef Name, int64_t Val) {
246 assert(!Name.empty() && "Unable to create enumerator without name");
247 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_enumerator)
251 return DIEnumerator(MDNode::get(VMContext, Elts));
254 DIBasicType DIBuilder::createUnspecifiedType(StringRef Name) {
255 assert(!Name.empty() && "Unable to create type without name");
256 // Unspecified types are encoded in DIBasicType format. Line number, filename,
257 // size, alignment, offset and flags are always empty here.
259 HeaderBuilder::get(dwarf::DW_TAG_unspecified_type)
271 return DIBasicType(MDNode::get(VMContext, Elts));
274 DIBasicType DIBuilder::createNullPtrType() {
275 return createUnspecifiedType("decltype(nullptr)");
279 DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
280 uint64_t AlignInBits, unsigned Encoding) {
281 assert(!Name.empty() && "Unable to create type without name");
282 // Basic types are encoded in DIBasicType format. Line number, filename,
283 // offset and flags are always empty here.
285 HeaderBuilder::get(dwarf::DW_TAG_base_type)
297 return DIBasicType(MDNode::get(VMContext, Elts));
300 DIDerivedType DIBuilder::createQualifiedType(unsigned Tag, DIType FromTy) {
301 // Qualified types are encoded in DIDerivedType format.
302 Metadata *Elts[] = {HeaderBuilder::get(Tag)
303 .concat(StringRef()) // Name
313 return DIDerivedType(MDNode::get(VMContext, Elts));
317 DIBuilder::createPointerType(DIType PointeeTy, uint64_t SizeInBits,
318 uint64_t AlignInBits, StringRef Name) {
319 // Pointer types are encoded in DIDerivedType format.
320 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_pointer_type)
331 return DIDerivedType(MDNode::get(VMContext, Elts));
335 DIBuilder::createMemberPointerType(DIType PointeeTy, DIType Base,
336 uint64_t SizeInBits, uint64_t AlignInBits) {
337 // Pointer types are encoded in DIDerivedType format.
338 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_ptr_to_member_type)
341 .concat(SizeInBits) // Size
342 .concat(AlignInBits) // Align
348 PointeeTy.getRef(), Base.getRef()};
349 return DIDerivedType(MDNode::get(VMContext, Elts));
352 DIDerivedType DIBuilder::createReferenceType(unsigned Tag, DIType RTy) {
353 assert(RTy.isType() && "Unable to create reference type");
354 // References are encoded in DIDerivedType format.
355 Metadata *Elts[] = {HeaderBuilder::get(Tag)
356 .concat(StringRef()) // Name
366 return DIDerivedType(MDNode::get(VMContext, Elts));
369 DIDerivedType DIBuilder::createTypedef(DIType Ty, StringRef Name, DIFile File,
370 unsigned LineNo, DIDescriptor Context) {
371 // typedefs are encoded in DIDerivedType format.
372 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_typedef)
381 DIScope(getNonCompileUnitScope(Context)).getRef(),
383 return DIDerivedType(MDNode::get(VMContext, Elts));
386 DIDerivedType DIBuilder::createFriend(DIType Ty, DIType FriendTy) {
387 // typedefs are encoded in DIDerivedType format.
388 assert(Ty.isType() && "Invalid type!");
389 assert(FriendTy.isType() && "Invalid friend type!");
390 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_friend)
391 .concat(StringRef()) // Name
398 nullptr, Ty.getRef(), FriendTy.getRef()};
399 return DIDerivedType(MDNode::get(VMContext, Elts));
402 DIDerivedType DIBuilder::createInheritance(DIType Ty, DIType BaseTy,
405 assert(Ty.isType() && "Unable to create inheritance");
406 // TAG_inheritance is encoded in DIDerivedType format.
407 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_inheritance)
408 .concat(StringRef()) // Name
415 nullptr, Ty.getRef(), BaseTy.getRef()};
416 auto R = DIDerivedType(MDNode::get(VMContext, Elts));
420 DIDerivedType DIBuilder::createMemberType(DIDescriptor Scope, StringRef Name,
421 DIFile File, unsigned LineNumber,
423 uint64_t AlignInBits,
424 uint64_t OffsetInBits, unsigned Flags,
426 // TAG_member is encoded in DIDerivedType format.
427 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
432 .concat(OffsetInBits)
436 DIScope(getNonCompileUnitScope(Scope)).getRef(),
438 return DIDerivedType(MDNode::get(VMContext, Elts));
441 static Metadata *getConstantOrNull(Constant *C) {
443 return ConstantAsMetadata::get(C);
447 DIDerivedType DIBuilder::createStaticMemberType(DIDescriptor Scope,
448 StringRef Name, DIFile File,
449 unsigned LineNumber, DIType Ty,
451 llvm::Constant *Val) {
452 // TAG_member is encoded in DIDerivedType format.
453 Flags |= DIDescriptor::FlagStaticMember;
454 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
463 DIScope(getNonCompileUnitScope(Scope)).getRef(),
464 Ty.getRef(), getConstantOrNull(Val)};
465 return DIDerivedType(MDNode::get(VMContext, Elts));
468 DIDerivedType DIBuilder::createObjCIVar(StringRef Name, DIFile File,
471 uint64_t AlignInBits,
472 uint64_t OffsetInBits, unsigned Flags,
473 DIType Ty, MDNode *PropertyNode) {
474 // TAG_member is encoded in DIDerivedType format.
475 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
480 .concat(OffsetInBits)
483 File.getFileNode(), getNonCompileUnitScope(File), Ty,
485 return DIDerivedType(MDNode::get(VMContext, Elts));
489 DIBuilder::createObjCProperty(StringRef Name, DIFile File, unsigned LineNumber,
490 StringRef GetterName, StringRef SetterName,
491 unsigned PropertyAttributes, DIType Ty) {
492 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_APPLE_property)
497 .concat(PropertyAttributes)
500 return DIObjCProperty(MDNode::get(VMContext, Elts));
503 DITemplateTypeParameter
504 DIBuilder::createTemplateTypeParameter(DIDescriptor Context, StringRef Name,
506 assert(!DIScope(getNonCompileUnitScope(Context)).getRef() &&
507 "Expected compile unit");
508 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_template_type_parameter)
513 nullptr, Ty.getRef(), nullptr};
514 return DITemplateTypeParameter(MDNode::get(VMContext, Elts));
517 static DITemplateValueParameter
518 createTemplateValueParameterHelper(LLVMContext &VMContext, unsigned Tag,
519 DIDescriptor Context, StringRef Name,
520 DIType Ty, Metadata *MD) {
521 assert(!DIScope(getNonCompileUnitScope(Context)).getRef() &&
522 "Expected compile unit");
524 HeaderBuilder::get(Tag).concat(Name).concat(0).concat(0).get(VMContext),
525 nullptr, Ty.getRef(), MD, nullptr};
526 return DITemplateValueParameter(MDNode::get(VMContext, Elts));
529 DITemplateValueParameter
530 DIBuilder::createTemplateValueParameter(DIDescriptor Context, StringRef Name,
531 DIType Ty, Constant *Val) {
532 return createTemplateValueParameterHelper(
533 VMContext, dwarf::DW_TAG_template_value_parameter, Context, Name, Ty,
534 getConstantOrNull(Val));
537 DITemplateValueParameter
538 DIBuilder::createTemplateTemplateParameter(DIDescriptor Context, StringRef Name,
539 DIType Ty, StringRef Val) {
540 return createTemplateValueParameterHelper(
541 VMContext, dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
542 MDString::get(VMContext, Val));
545 DITemplateValueParameter
546 DIBuilder::createTemplateParameterPack(DIDescriptor Context, StringRef Name,
547 DIType Ty, DIArray Val) {
548 return createTemplateValueParameterHelper(
549 VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
553 DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
554 DIFile File, unsigned LineNumber,
556 uint64_t AlignInBits,
557 uint64_t OffsetInBits,
558 unsigned Flags, DIType DerivedFrom,
561 MDNode *TemplateParams,
562 StringRef UniqueIdentifier) {
563 assert((!Context || Context.isScope() || Context.isType()) &&
564 "createClassType should be called with a valid Context");
565 // TAG_class_type is encoded in DICompositeType format.
567 HeaderBuilder::get(dwarf::DW_TAG_class_type)
572 .concat(OffsetInBits)
576 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
577 DerivedFrom.getRef(), Elements, VTableHolder.getRef(), TemplateParams,
578 UniqueIdentifier.empty() ? nullptr
579 : MDString::get(VMContext, UniqueIdentifier)};
580 DICompositeType R(MDNode::get(VMContext, Elts));
581 assert(R.isCompositeType() &&
582 "createClassType should return a DICompositeType");
583 if (!UniqueIdentifier.empty())
585 trackIfUnresolved(R);
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())
619 trackIfUnresolved(R);
623 DICompositeType DIBuilder::createUnionType(DIDescriptor Scope, StringRef Name,
624 DIFile File, unsigned LineNumber,
626 uint64_t AlignInBits, unsigned Flags,
628 unsigned RunTimeLang,
629 StringRef UniqueIdentifier) {
630 // TAG_union_type is encoded in DICompositeType format.
632 HeaderBuilder::get(dwarf::DW_TAG_union_type)
641 File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
642 nullptr, Elements, nullptr, nullptr,
643 UniqueIdentifier.empty() ? nullptr
644 : MDString::get(VMContext, UniqueIdentifier)};
645 DICompositeType R(MDNode::get(VMContext, Elts));
646 if (!UniqueIdentifier.empty())
648 trackIfUnresolved(R);
652 DISubroutineType DIBuilder::createSubroutineType(DIFile File,
653 DITypeArray ParameterTypes,
655 // TAG_subroutine_type is encoded in DICompositeType format.
657 HeaderBuilder::get(dwarf::DW_TAG_subroutine_type)
663 .concat(Flags) // Flags
666 nullptr, nullptr, nullptr, ParameterTypes, nullptr, nullptr,
667 nullptr // Type Identifer
669 return DISubroutineType(MDNode::get(VMContext, Elts));
672 DICompositeType DIBuilder::createEnumerationType(
673 DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
674 uint64_t SizeInBits, uint64_t AlignInBits, DIArray Elements,
675 DIType UnderlyingType, StringRef UniqueIdentifier) {
676 // TAG_enumeration_type is encoded in DICompositeType format.
678 HeaderBuilder::get(dwarf::DW_TAG_enumeration_type)
687 File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
688 UnderlyingType.getRef(), Elements, nullptr, nullptr,
689 UniqueIdentifier.empty() ? nullptr
690 : MDString::get(VMContext, UniqueIdentifier)};
691 DICompositeType CTy(MDNode::get(VMContext, Elts));
692 AllEnumTypes.push_back(CTy);
693 if (!UniqueIdentifier.empty())
695 trackIfUnresolved(CTy);
699 DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
700 DIType Ty, DIArray Subscripts) {
701 // TAG_array_type is encoded in DICompositeType format.
703 HeaderBuilder::get(dwarf::DW_TAG_array_type)
712 nullptr, // Filename/Directory,
714 Ty.getRef(), Subscripts, nullptr, nullptr,
715 nullptr // Type Identifer
717 DICompositeType R(MDNode::get(VMContext, Elts));
718 trackIfUnresolved(R);
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 DICompositeType R(MDNode::get(VMContext, Elts));
741 trackIfUnresolved(R);
745 static HeaderBuilder setTypeFlagsInHeader(StringRef Header,
746 unsigned FlagsToSet) {
747 DIHeaderFieldIterator I(Header);
751 if (I->getAsInteger(0, Flags))
755 return HeaderBuilder()
756 .concat(I.getPrefix())
758 .concat(I.getSuffix());
761 static DIType createTypeWithFlags(LLVMContext &Context, DIType Ty,
762 unsigned FlagsToSet) {
763 SmallVector<Metadata *, 9> Elts;
765 assert(N && "Unexpected input DIType!");
766 // Update header field.
767 Elts.push_back(setTypeFlagsInHeader(Ty.getHeader(), FlagsToSet).get(Context));
768 Elts.append(N->op_begin() + 1, N->op_end());
770 return DIType(MDNode::get(Context, Elts));
773 DIType DIBuilder::createArtificialType(DIType Ty) {
774 if (Ty.isArtificial())
776 return createTypeWithFlags(VMContext, Ty, DIType::FlagArtificial);
779 DIType DIBuilder::createObjectPointerType(DIType Ty) {
780 if (Ty.isObjectPointer())
782 unsigned Flags = DIType::FlagObjectPointer | DIType::FlagArtificial;
783 return createTypeWithFlags(VMContext, Ty, Flags);
786 void DIBuilder::retainType(DIType T) { AllRetainTypes.emplace_back(T); }
788 DIBasicType DIBuilder::createUnspecifiedParameter() {
789 return DIBasicType();
793 DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIDescriptor Scope,
794 DIFile F, unsigned Line, unsigned RuntimeLang,
795 uint64_t SizeInBits, uint64_t AlignInBits,
796 StringRef UniqueIdentifier) {
797 // Create a temporary MDNode.
799 HeaderBuilder::get(Tag)
805 .concat(DIDescriptor::FlagFwdDecl)
808 F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
810 nullptr, // TemplateParams
811 UniqueIdentifier.empty() ? nullptr
812 : MDString::get(VMContext, UniqueIdentifier)};
813 MDNode *Node = MDNode::get(VMContext, Elts);
814 DICompositeType RetTy(Node);
815 assert(RetTy.isCompositeType() &&
816 "createForwardDecl result should be a DIType");
817 if (!UniqueIdentifier.empty())
819 trackIfUnresolved(RetTy);
823 DICompositeType DIBuilder::createReplaceableCompositeType(
824 unsigned Tag, StringRef Name, DIDescriptor Scope, DIFile F, unsigned Line,
825 unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
826 unsigned Flags, StringRef UniqueIdentifier) {
827 // Create a temporary MDNode.
829 HeaderBuilder::get(Tag)
838 F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
840 nullptr, // TemplateParams
841 UniqueIdentifier.empty() ? nullptr
842 : MDString::get(VMContext, UniqueIdentifier)};
843 DICompositeType RetTy(MDNode::getTemporary(VMContext, Elts).release());
844 assert(RetTy.isCompositeType() &&
845 "createReplaceableForwardDecl result should be a DIType");
846 if (!UniqueIdentifier.empty())
848 trackIfUnresolved(RetTy);
852 DIArray DIBuilder::getOrCreateArray(ArrayRef<Metadata *> Elements) {
853 return DIArray(MDNode::get(VMContext, Elements));
856 DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
857 SmallVector<llvm::Metadata *, 16> Elts;
858 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
859 if (Elements[i] && isa<MDNode>(Elements[i]))
860 Elts.push_back(DIType(cast<MDNode>(Elements[i])).getRef());
862 Elts.push_back(Elements[i]);
864 return DITypeArray(MDNode::get(VMContext, Elts));
867 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
868 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subrange_type)
873 return DISubrange(MDNode::get(VMContext, Elts));
876 static DIGlobalVariable createGlobalVariableHelper(
877 LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
878 StringRef LinkageName, DIFile F, unsigned LineNumber, DITypeRef Ty,
879 bool isLocalToUnit, Constant *Val, MDNode *Decl, bool isDefinition,
880 std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
882 MDNode *TheCtx = getNonCompileUnitScope(Context);
883 if (DIScope(TheCtx).isCompositeType()) {
884 assert(!DICompositeType(TheCtx).getIdentifier() &&
885 "Context of a global variable should not be a type with identifier");
888 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_variable)
893 .concat(isLocalToUnit)
894 .concat(isDefinition)
896 TheCtx, F, Ty, getConstantOrNull(Val),
899 return DIGlobalVariable(CreateFunc(Elts));
902 DIGlobalVariable DIBuilder::createGlobalVariable(
903 DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
904 unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
906 return createGlobalVariableHelper(
907 VMContext, Context, Name, LinkageName, F, LineNumber, Ty, isLocalToUnit,
908 Val, Decl, true, [&](ArrayRef<Metadata *> Elts) -> MDNode *{
909 MDNode *Node = MDNode::get(VMContext, Elts);
910 AllGVs.push_back(Node);
915 DIGlobalVariable DIBuilder::createTempGlobalVariableFwdDecl(
916 DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
917 unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
919 return createGlobalVariableHelper(VMContext, Context, Name, LinkageName, F,
920 LineNumber, Ty, isLocalToUnit, Val, Decl,
921 false, [&](ArrayRef<Metadata *> Elts) {
922 return MDNode::getTemporary(VMContext, Elts).release();
926 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
927 StringRef Name, DIFile File,
928 unsigned LineNo, DITypeRef Ty,
929 bool AlwaysPreserve, unsigned Flags,
931 DIDescriptor Context(getNonCompileUnitScope(Scope));
932 assert((!Context || Context.isScope()) &&
933 "createLocalVariable should be called with a valid Context");
934 Metadata *Elts[] = {HeaderBuilder::get(Tag)
936 .concat(LineNo | (ArgNo << 24))
939 getNonCompileUnitScope(Scope), File, Ty};
940 MDNode *Node = MDNode::get(VMContext, Elts);
941 if (AlwaysPreserve) {
942 // The optimizer may remove local variable. If there is an interest
943 // to preserve variable info in such situation then stash it in a
945 DISubprogram Fn(getDISubprogram(Scope));
946 assert(Fn && "Missing subprogram for local variable");
947 PreservedVariables[Fn].emplace_back(Node);
949 DIVariable RetVar(Node);
950 assert(RetVar.isVariable() &&
951 "createLocalVariable should return a valid DIVariable");
955 DIExpression DIBuilder::createExpression(ArrayRef<uint64_t> Addr) {
956 auto Header = HeaderBuilder::get(DW_TAG_expression);
957 for (uint64_t I : Addr)
959 Metadata *Elts[] = {Header.get(VMContext)};
960 return DIExpression(MDNode::get(VMContext, Elts));
963 DIExpression DIBuilder::createExpression(ArrayRef<int64_t> Signed) {
964 // TODO: Remove the callers of this signed version and delete.
965 SmallVector<uint64_t, 8> Addr(Signed.begin(), Signed.end());
966 return createExpression(Addr);
969 DIExpression DIBuilder::createBitPieceExpression(unsigned OffsetInBits,
970 unsigned SizeInBits) {
971 int64_t Addr[] = {dwarf::DW_OP_bit_piece, OffsetInBits, SizeInBits};
972 return createExpression(Addr);
975 DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
976 StringRef LinkageName, DIFile File,
977 unsigned LineNo, DICompositeType Ty,
978 bool isLocalToUnit, bool isDefinition,
979 unsigned ScopeLine, unsigned Flags,
980 bool isOptimized, Function *Fn,
981 MDNode *TParams, MDNode *Decl) {
982 // dragonegg does not generate identifier for types, so using an empty map
983 // to resolve the context should be fine.
984 DITypeIdentifierMap EmptyMap;
985 return createFunction(Context.resolve(EmptyMap), Name, LinkageName, File,
986 LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
987 Flags, isOptimized, Fn, TParams, Decl);
990 static DISubprogram createFunctionHelper(
991 LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
992 StringRef LinkageName, DIFile File, unsigned LineNo, DICompositeType Ty,
993 bool isLocalToUnit, bool isDefinition, unsigned ScopeLine, unsigned Flags,
994 bool isOptimized, Function *Fn, MDNode *TParams, MDNode *Decl, MDNode *Vars,
995 std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
996 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
997 "function types should be subroutines");
998 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
1001 .concat(LinkageName)
1003 .concat(isLocalToUnit)
1004 .concat(isDefinition)
1008 .concat(isOptimized)
1012 DIScope(getNonCompileUnitScope(Context)).getRef(), Ty,
1013 nullptr, getConstantOrNull(Fn), TParams, Decl, Vars};
1015 DISubprogram S(CreateFunc(Elts));
1016 assert(S.isSubprogram() &&
1017 "createFunction should return a valid DISubprogram");
1022 DISubprogram DIBuilder::createFunction(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 MDNode::getTemporary(VMContext, None).release(),
1033 [&](ArrayRef<Metadata *> Elts) -> MDNode *{
1034 MDNode *Node = MDNode::get(VMContext, Elts);
1035 // Create a named metadata so that we
1036 // do not lose this mdnode.
1038 AllSubprograms.push_back(Node);
1039 trackIfUnresolved(Node);
1045 DIBuilder::createTempFunctionFwdDecl(DIDescriptor Context, StringRef Name,
1046 StringRef LinkageName, DIFile File,
1047 unsigned LineNo, DICompositeType Ty,
1048 bool isLocalToUnit, bool isDefinition,
1049 unsigned ScopeLine, unsigned Flags,
1050 bool isOptimized, Function *Fn,
1051 MDNode *TParams, MDNode *Decl) {
1052 return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1053 LineNo, Ty, isLocalToUnit, isDefinition,
1054 ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1055 nullptr, [&](ArrayRef<Metadata *> Elts) {
1056 return MDNode::getTemporary(VMContext, Elts).release();
1060 DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
1061 StringRef LinkageName, DIFile F,
1062 unsigned LineNo, DICompositeType Ty,
1063 bool isLocalToUnit, bool isDefinition,
1064 unsigned VK, unsigned VIndex,
1065 DIType VTableHolder, unsigned Flags,
1066 bool isOptimized, Function *Fn,
1068 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
1069 "function types should be subroutines");
1070 assert(getNonCompileUnitScope(Context) &&
1071 "Methods should have both a Context and a context that isn't "
1072 "the compile unit.");
1073 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
1076 .concat(LinkageName)
1078 .concat(isLocalToUnit)
1079 .concat(isDefinition)
1083 .concat(isOptimized)
1085 // FIXME: Do we want to use different scope/lines?
1087 F.getFileNode(), DIScope(Context).getRef(), Ty,
1088 VTableHolder.getRef(), getConstantOrNull(Fn), TParam,
1090 MDNode *Node = MDNode::get(VMContext, Elts);
1092 AllSubprograms.push_back(Node);
1093 DISubprogram S(Node);
1094 assert(S.isSubprogram() && "createMethod should return a valid DISubprogram");
1095 trackIfUnresolved(S);
1099 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
1100 DIFile File, unsigned LineNo) {
1101 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_namespace)
1105 File.getFileNode(), getNonCompileUnitScope(Scope)};
1106 DINameSpace R(MDNode::get(VMContext, Elts));
1107 assert(R.Verify() &&
1108 "createNameSpace should return a verifiable DINameSpace");
1112 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
1114 unsigned Discriminator) {
1115 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1116 .concat(Discriminator)
1118 File.getFileNode(), Scope};
1119 DILexicalBlockFile R(MDNode::get(VMContext, Elts));
1122 "createLexicalBlockFile should return a verifiable DILexicalBlockFile");
1126 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
1127 unsigned Line, unsigned Col) {
1128 // FIXME: This isn't thread safe nor the right way to defeat MDNode uniquing.
1129 // I believe the right way is to have a self-referential element in the node.
1130 // Also: why do we bother with line/column - they're not used and the
1131 // documentation (SourceLevelDebugging.rst) claims the line/col are necessary
1132 // for uniquing, yet then we have this other solution (because line/col were
1133 // inadequate) anyway. Remove all 3 and replace them with a self-reference.
1135 // Defeat MDNode uniquing for lexical blocks by using unique id.
1136 static unsigned int unique_id = 0;
1137 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1140 .concat(unique_id++)
1142 File.getFileNode(), getNonCompileUnitScope(Scope)};
1143 DILexicalBlock R(MDNode::get(VMContext, Elts));
1144 assert(R.Verify() &&
1145 "createLexicalBlock should return a verifiable DILexicalBlock");
1149 static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) {
1150 assert(V && "no value passed to dbg intrinsic");
1151 return MetadataAsValue::get(VMContext, ValueAsMetadata::get(V));
1154 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1156 Instruction *InsertBefore) {
1157 assert(VarInfo.isVariable() &&
1158 "empty or invalid DIVariable passed to dbg.declare");
1160 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1162 trackIfUnresolved(VarInfo);
1163 trackIfUnresolved(Expr);
1164 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1165 MetadataAsValue::get(VMContext, VarInfo),
1166 MetadataAsValue::get(VMContext, Expr)};
1167 return CallInst::Create(DeclareFn, Args, "", InsertBefore);
1170 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1172 BasicBlock *InsertAtEnd) {
1173 assert(VarInfo.isVariable() &&
1174 "empty or invalid DIVariable passed to dbg.declare");
1176 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1178 trackIfUnresolved(VarInfo);
1179 trackIfUnresolved(Expr);
1180 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1181 MetadataAsValue::get(VMContext, VarInfo),
1182 MetadataAsValue::get(VMContext, Expr)};
1184 // If this block already has a terminator then insert this intrinsic
1185 // before the terminator.
1186 if (TerminatorInst *T = InsertAtEnd->getTerminator())
1187 return CallInst::Create(DeclareFn, Args, "", T);
1189 return CallInst::Create(DeclareFn, Args, "", InsertAtEnd);
1192 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1195 Instruction *InsertBefore) {
1196 assert(V && "no value passed to dbg.value");
1197 assert(VarInfo.isVariable() &&
1198 "empty or invalid DIVariable passed to dbg.value");
1200 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1202 trackIfUnresolved(VarInfo);
1203 trackIfUnresolved(Expr);
1204 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1205 ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1206 MetadataAsValue::get(VMContext, VarInfo),
1207 MetadataAsValue::get(VMContext, Expr)};
1208 return CallInst::Create(ValueFn, Args, "", InsertBefore);
1211 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1214 BasicBlock *InsertAtEnd) {
1215 assert(V && "no value passed to dbg.value");
1216 assert(VarInfo.isVariable() &&
1217 "empty or invalid DIVariable passed to dbg.value");
1219 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1221 trackIfUnresolved(VarInfo);
1222 trackIfUnresolved(Expr);
1223 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1224 ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1225 MetadataAsValue::get(VMContext, VarInfo),
1226 MetadataAsValue::get(VMContext, Expr)};
1227 return CallInst::Create(ValueFn, Args, "", InsertAtEnd);
1230 void DIBuilder::replaceVTableHolder(DICompositeType &T, DICompositeType VTableHolder) {
1231 T.setContainingType(VTableHolder);
1233 // If this didn't create a self-reference, just return.
1234 if (T != VTableHolder)
1237 // Look for unresolved operands. T will drop RAUW support, orphaning any
1238 // cycles underneath it.
1239 if (T->isResolved())
1240 for (const MDOperand &O : T->operands())
1241 if (auto *N = dyn_cast_or_null<MDNode>(O))
1242 trackIfUnresolved(N);
1245 void DIBuilder::replaceArrays(DICompositeType &T, DIArray Elements,
1247 T.setArrays(Elements, TParams);
1249 // If T isn't resolved, there's no problem.
1250 if (!T->isResolved())
1253 // If "T" is resolved, it may be due to a self-reference cycle. Track the
1254 // arrays explicitly if they're unresolved, or else the cycles will be
1257 trackIfUnresolved(Elements);
1259 trackIfUnresolved(TParams);