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 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_template_type_parameter)
511 DIScope(getNonCompileUnitScope(Context)).getRef(),
512 Ty.getRef(), nullptr};
513 return DITemplateTypeParameter(MDNode::get(VMContext, Elts));
516 static DITemplateValueParameter
517 createTemplateValueParameterHelper(LLVMContext &VMContext, unsigned Tag,
518 DIDescriptor Context, StringRef Name,
519 DIType Ty, Metadata *MD) {
521 HeaderBuilder::get(Tag).concat(Name).concat(0).concat(0).get(VMContext),
522 DIScope(getNonCompileUnitScope(Context)).getRef(), Ty.getRef(), MD,
524 return DITemplateValueParameter(MDNode::get(VMContext, Elts));
527 DITemplateValueParameter
528 DIBuilder::createTemplateValueParameter(DIDescriptor Context, StringRef Name,
529 DIType Ty, Constant *Val) {
530 return createTemplateValueParameterHelper(
531 VMContext, dwarf::DW_TAG_template_value_parameter, Context, Name, Ty,
532 getConstantOrNull(Val));
535 DITemplateValueParameter
536 DIBuilder::createTemplateTemplateParameter(DIDescriptor Context, StringRef Name,
537 DIType Ty, StringRef Val) {
538 return createTemplateValueParameterHelper(
539 VMContext, dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
540 MDString::get(VMContext, Val));
543 DITemplateValueParameter
544 DIBuilder::createTemplateParameterPack(DIDescriptor Context, StringRef Name,
545 DIType Ty, DIArray Val) {
546 return createTemplateValueParameterHelper(
547 VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
551 DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
552 DIFile File, unsigned LineNumber,
554 uint64_t AlignInBits,
555 uint64_t OffsetInBits,
556 unsigned Flags, DIType DerivedFrom,
559 MDNode *TemplateParams,
560 StringRef UniqueIdentifier) {
561 assert((!Context || Context.isScope() || Context.isType()) &&
562 "createClassType should be called with a valid Context");
563 // TAG_class_type is encoded in DICompositeType format.
565 HeaderBuilder::get(dwarf::DW_TAG_class_type)
570 .concat(OffsetInBits)
574 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
575 DerivedFrom.getRef(), Elements, VTableHolder.getRef(), TemplateParams,
576 UniqueIdentifier.empty() ? nullptr
577 : MDString::get(VMContext, UniqueIdentifier)};
578 DICompositeType R(MDNode::get(VMContext, Elts));
579 assert(R.isCompositeType() &&
580 "createClassType should return a DICompositeType");
581 if (!UniqueIdentifier.empty())
583 trackIfUnresolved(R);
587 DICompositeType DIBuilder::createStructType(DIDescriptor Context,
588 StringRef Name, DIFile File,
591 uint64_t AlignInBits,
592 unsigned Flags, DIType DerivedFrom,
594 unsigned RunTimeLang,
596 StringRef UniqueIdentifier) {
597 // TAG_structure_type is encoded in DICompositeType format.
599 HeaderBuilder::get(dwarf::DW_TAG_structure_type)
608 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
609 DerivedFrom.getRef(), Elements, VTableHolder.getRef(), nullptr,
610 UniqueIdentifier.empty() ? nullptr
611 : MDString::get(VMContext, UniqueIdentifier)};
612 DICompositeType R(MDNode::get(VMContext, Elts));
613 assert(R.isCompositeType() &&
614 "createStructType should return a DICompositeType");
615 if (!UniqueIdentifier.empty())
617 trackIfUnresolved(R);
621 DICompositeType DIBuilder::createUnionType(DIDescriptor Scope, StringRef Name,
622 DIFile File, unsigned LineNumber,
624 uint64_t AlignInBits, unsigned Flags,
626 unsigned RunTimeLang,
627 StringRef UniqueIdentifier) {
628 // TAG_union_type is encoded in DICompositeType format.
630 HeaderBuilder::get(dwarf::DW_TAG_union_type)
639 File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
640 nullptr, Elements, nullptr, nullptr,
641 UniqueIdentifier.empty() ? nullptr
642 : MDString::get(VMContext, UniqueIdentifier)};
643 DICompositeType R(MDNode::get(VMContext, Elts));
644 if (!UniqueIdentifier.empty())
646 trackIfUnresolved(R);
650 DISubroutineType DIBuilder::createSubroutineType(DIFile File,
651 DITypeArray ParameterTypes,
653 // TAG_subroutine_type is encoded in DICompositeType format.
655 HeaderBuilder::get(dwarf::DW_TAG_subroutine_type)
661 .concat(Flags) // Flags
664 nullptr, nullptr, nullptr, ParameterTypes, nullptr, nullptr,
665 nullptr // Type Identifer
667 return DISubroutineType(MDNode::get(VMContext, Elts));
670 DICompositeType DIBuilder::createEnumerationType(
671 DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
672 uint64_t SizeInBits, uint64_t AlignInBits, DIArray Elements,
673 DIType UnderlyingType, StringRef UniqueIdentifier) {
674 // TAG_enumeration_type is encoded in DICompositeType format.
676 HeaderBuilder::get(dwarf::DW_TAG_enumeration_type)
685 File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
686 UnderlyingType.getRef(), Elements, nullptr, nullptr,
687 UniqueIdentifier.empty() ? nullptr
688 : MDString::get(VMContext, UniqueIdentifier)};
689 DICompositeType CTy(MDNode::get(VMContext, Elts));
690 AllEnumTypes.push_back(CTy);
691 if (!UniqueIdentifier.empty())
693 trackIfUnresolved(CTy);
697 DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
698 DIType Ty, DIArray Subscripts) {
699 // TAG_array_type is encoded in DICompositeType format.
701 HeaderBuilder::get(dwarf::DW_TAG_array_type)
710 nullptr, // Filename/Directory,
712 Ty.getRef(), Subscripts, nullptr, nullptr,
713 nullptr // Type Identifer
715 DICompositeType R(MDNode::get(VMContext, Elts));
716 trackIfUnresolved(R);
720 DICompositeType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
721 DIType Ty, DIArray Subscripts) {
722 // A vector is an array type with the FlagVector flag applied.
724 HeaderBuilder::get(dwarf::DW_TAG_array_type)
730 .concat(DIType::FlagVector)
733 nullptr, // Filename/Directory,
735 Ty.getRef(), Subscripts, nullptr, nullptr,
736 nullptr // Type Identifer
738 DICompositeType R(MDNode::get(VMContext, Elts));
739 trackIfUnresolved(R);
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 Elts.append(N->op_begin() + 1, N->op_end());
768 return DIType(MDNode::get(Context, Elts));
771 DIType DIBuilder::createArtificialType(DIType Ty) {
772 if (Ty.isArtificial())
774 return createTypeWithFlags(VMContext, Ty, DIType::FlagArtificial);
777 DIType DIBuilder::createObjectPointerType(DIType Ty) {
778 if (Ty.isObjectPointer())
780 unsigned Flags = DIType::FlagObjectPointer | DIType::FlagArtificial;
781 return createTypeWithFlags(VMContext, Ty, Flags);
784 void DIBuilder::retainType(DIType T) { AllRetainTypes.emplace_back(T); }
786 DIBasicType DIBuilder::createUnspecifiedParameter() {
787 return DIBasicType();
791 DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIDescriptor Scope,
792 DIFile F, unsigned Line, unsigned RuntimeLang,
793 uint64_t SizeInBits, uint64_t AlignInBits,
794 StringRef UniqueIdentifier) {
795 // Create a temporary MDNode.
797 HeaderBuilder::get(Tag)
803 .concat(DIDescriptor::FlagFwdDecl)
806 F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
808 nullptr, // TemplateParams
809 UniqueIdentifier.empty() ? nullptr
810 : MDString::get(VMContext, UniqueIdentifier)};
811 MDNode *Node = MDNode::get(VMContext, Elts);
812 DICompositeType RetTy(Node);
813 assert(RetTy.isCompositeType() &&
814 "createForwardDecl result should be a DIType");
815 if (!UniqueIdentifier.empty())
817 trackIfUnresolved(RetTy);
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())
846 trackIfUnresolved(RetTy);
850 DIArray DIBuilder::getOrCreateArray(ArrayRef<Metadata *> Elements) {
851 return DIArray(MDNode::get(VMContext, Elements));
854 DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
855 SmallVector<llvm::Metadata *, 16> Elts;
856 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
857 if (Elements[i] && isa<MDNode>(Elements[i]))
858 Elts.push_back(DIType(cast<MDNode>(Elements[i])).getRef());
860 Elts.push_back(Elements[i]);
862 return DITypeArray(MDNode::get(VMContext, Elts));
865 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
866 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subrange_type)
871 return DISubrange(MDNode::get(VMContext, Elts));
874 static DIGlobalVariable createGlobalVariableHelper(
875 LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
876 StringRef LinkageName, DIFile F, unsigned LineNumber, DITypeRef Ty,
877 bool isLocalToUnit, Constant *Val, MDNode *Decl, bool isDefinition,
878 std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
880 MDNode *TheCtx = getNonCompileUnitScope(Context);
881 if (DIScope(TheCtx).isCompositeType()) {
882 assert(!DICompositeType(TheCtx).getIdentifier() &&
883 "Context of a global variable should not be a type with identifier");
886 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_variable)
891 .concat(isLocalToUnit)
892 .concat(isDefinition)
894 TheCtx, F, Ty, getConstantOrNull(Val),
897 return DIGlobalVariable(CreateFunc(Elts));
900 DIGlobalVariable DIBuilder::createGlobalVariable(
901 DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
902 unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
904 return createGlobalVariableHelper(
905 VMContext, Context, Name, LinkageName, F, LineNumber, Ty, isLocalToUnit,
906 Val, Decl, true, [&](ArrayRef<Metadata *> Elts) -> MDNode *{
907 MDNode *Node = MDNode::get(VMContext, Elts);
908 AllGVs.push_back(Node);
913 DIGlobalVariable DIBuilder::createTempGlobalVariableFwdDecl(
914 DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
915 unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
917 return createGlobalVariableHelper(VMContext, Context, Name, LinkageName, F,
918 LineNumber, Ty, isLocalToUnit, Val, Decl,
919 false, [&](ArrayRef<Metadata *> Elts) {
920 return MDNode::getTemporary(VMContext, Elts).release();
924 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
925 StringRef Name, DIFile File,
926 unsigned LineNo, DITypeRef Ty,
927 bool AlwaysPreserve, unsigned Flags,
929 DIDescriptor Context(getNonCompileUnitScope(Scope));
930 assert((!Context || Context.isScope()) &&
931 "createLocalVariable should be called with a valid Context");
932 Metadata *Elts[] = {HeaderBuilder::get(Tag)
934 .concat(LineNo | (ArgNo << 24))
937 getNonCompileUnitScope(Scope), File, Ty};
938 MDNode *Node = MDNode::get(VMContext, Elts);
939 if (AlwaysPreserve) {
940 // The optimizer may remove local variable. If there is an interest
941 // to preserve variable info in such situation then stash it in a
943 DISubprogram Fn(getDISubprogram(Scope));
944 assert(Fn && "Missing subprogram for local variable");
945 PreservedVariables[Fn].emplace_back(Node);
947 DIVariable RetVar(Node);
948 assert(RetVar.isVariable() &&
949 "createLocalVariable should return a valid DIVariable");
953 DIExpression DIBuilder::createExpression(ArrayRef<uint64_t> Addr) {
954 auto Header = HeaderBuilder::get(DW_TAG_expression);
955 for (uint64_t I : Addr)
957 Metadata *Elts[] = {Header.get(VMContext)};
958 return DIExpression(MDNode::get(VMContext, Elts));
961 DIExpression DIBuilder::createExpression(ArrayRef<int64_t> Signed) {
962 // TODO: Remove the callers of this signed version and delete.
963 SmallVector<uint64_t, 8> Addr(Signed.begin(), Signed.end());
964 return createExpression(Addr);
967 DIExpression DIBuilder::createBitPieceExpression(unsigned OffsetInBits,
968 unsigned SizeInBits) {
969 int64_t Addr[] = {dwarf::DW_OP_bit_piece, OffsetInBits, SizeInBits};
970 return createExpression(Addr);
973 DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
974 StringRef LinkageName, DIFile File,
975 unsigned LineNo, DICompositeType Ty,
976 bool isLocalToUnit, bool isDefinition,
977 unsigned ScopeLine, unsigned Flags,
978 bool isOptimized, Function *Fn,
979 MDNode *TParams, MDNode *Decl) {
980 // dragonegg does not generate identifier for types, so using an empty map
981 // to resolve the context should be fine.
982 DITypeIdentifierMap EmptyMap;
983 return createFunction(Context.resolve(EmptyMap), Name, LinkageName, File,
984 LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
985 Flags, isOptimized, Fn, TParams, Decl);
988 static DISubprogram createFunctionHelper(
989 LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
990 StringRef LinkageName, DIFile File, unsigned LineNo, DICompositeType Ty,
991 bool isLocalToUnit, bool isDefinition, unsigned ScopeLine, unsigned Flags,
992 bool isOptimized, Function *Fn, MDNode *TParams, MDNode *Decl, MDNode *Vars,
993 std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
994 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
995 "function types should be subroutines");
996 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
1001 .concat(isLocalToUnit)
1002 .concat(isDefinition)
1006 .concat(isOptimized)
1010 DIScope(getNonCompileUnitScope(Context)).getRef(), Ty,
1011 nullptr, getConstantOrNull(Fn), TParams, Decl, Vars};
1013 DISubprogram S(CreateFunc(Elts));
1014 assert(S.isSubprogram() &&
1015 "createFunction should return a valid DISubprogram");
1020 DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
1021 StringRef LinkageName, DIFile File,
1022 unsigned LineNo, DICompositeType Ty,
1023 bool isLocalToUnit, bool isDefinition,
1024 unsigned ScopeLine, unsigned Flags,
1025 bool isOptimized, Function *Fn,
1026 MDNode *TParams, MDNode *Decl) {
1027 return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1028 LineNo, Ty, isLocalToUnit, isDefinition,
1029 ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1030 MDNode::getTemporary(VMContext, None).release(),
1031 [&](ArrayRef<Metadata *> Elts) -> MDNode *{
1032 MDNode *Node = MDNode::get(VMContext, Elts);
1033 // Create a named metadata so that we
1034 // do not lose this mdnode.
1036 AllSubprograms.push_back(Node);
1037 trackIfUnresolved(Node);
1043 DIBuilder::createTempFunctionFwdDecl(DIDescriptor Context, StringRef Name,
1044 StringRef LinkageName, DIFile File,
1045 unsigned LineNo, DICompositeType Ty,
1046 bool isLocalToUnit, bool isDefinition,
1047 unsigned ScopeLine, unsigned Flags,
1048 bool isOptimized, Function *Fn,
1049 MDNode *TParams, MDNode *Decl) {
1050 return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1051 LineNo, Ty, isLocalToUnit, isDefinition,
1052 ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1053 nullptr, [&](ArrayRef<Metadata *> Elts) {
1054 return MDNode::getTemporary(VMContext, Elts).release();
1058 DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
1059 StringRef LinkageName, DIFile F,
1060 unsigned LineNo, DICompositeType Ty,
1061 bool isLocalToUnit, bool isDefinition,
1062 unsigned VK, unsigned VIndex,
1063 DIType VTableHolder, unsigned Flags,
1064 bool isOptimized, Function *Fn,
1066 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
1067 "function types should be subroutines");
1068 assert(getNonCompileUnitScope(Context) &&
1069 "Methods should have both a Context and a context that isn't "
1070 "the compile unit.");
1071 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
1074 .concat(LinkageName)
1076 .concat(isLocalToUnit)
1077 .concat(isDefinition)
1081 .concat(isOptimized)
1083 // FIXME: Do we want to use different scope/lines?
1085 F.getFileNode(), DIScope(Context).getRef(), Ty,
1086 VTableHolder.getRef(), getConstantOrNull(Fn), TParam,
1088 MDNode *Node = MDNode::get(VMContext, Elts);
1090 AllSubprograms.push_back(Node);
1091 DISubprogram S(Node);
1092 assert(S.isSubprogram() && "createMethod should return a valid DISubprogram");
1093 trackIfUnresolved(S);
1097 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
1098 DIFile File, unsigned LineNo) {
1099 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_namespace)
1103 File.getFileNode(), getNonCompileUnitScope(Scope)};
1104 DINameSpace R(MDNode::get(VMContext, Elts));
1105 assert(R.Verify() &&
1106 "createNameSpace should return a verifiable DINameSpace");
1110 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
1112 unsigned Discriminator) {
1113 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1114 .concat(Discriminator)
1116 File.getFileNode(), Scope};
1117 DILexicalBlockFile R(MDNode::get(VMContext, Elts));
1120 "createLexicalBlockFile should return a verifiable DILexicalBlockFile");
1124 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
1125 unsigned Line, unsigned Col) {
1126 // FIXME: This isn't thread safe nor the right way to defeat MDNode uniquing.
1127 // I believe the right way is to have a self-referential element in the node.
1128 // Also: why do we bother with line/column - they're not used and the
1129 // documentation (SourceLevelDebugging.rst) claims the line/col are necessary
1130 // for uniquing, yet then we have this other solution (because line/col were
1131 // inadequate) anyway. Remove all 3 and replace them with a self-reference.
1133 // Defeat MDNode uniquing for lexical blocks by using unique id.
1134 static unsigned int unique_id = 0;
1135 Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1138 .concat(unique_id++)
1140 File.getFileNode(), getNonCompileUnitScope(Scope)};
1141 DILexicalBlock R(MDNode::get(VMContext, Elts));
1142 assert(R.Verify() &&
1143 "createLexicalBlock should return a verifiable DILexicalBlock");
1147 static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) {
1148 assert(V && "no value passed to dbg intrinsic");
1149 return MetadataAsValue::get(VMContext, ValueAsMetadata::get(V));
1152 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1154 Instruction *InsertBefore) {
1155 assert(VarInfo.isVariable() &&
1156 "empty or invalid DIVariable passed to dbg.declare");
1158 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1160 trackIfUnresolved(VarInfo);
1161 trackIfUnresolved(Expr);
1162 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1163 MetadataAsValue::get(VMContext, VarInfo),
1164 MetadataAsValue::get(VMContext, Expr)};
1165 return CallInst::Create(DeclareFn, Args, "", InsertBefore);
1168 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1170 BasicBlock *InsertAtEnd) {
1171 assert(VarInfo.isVariable() &&
1172 "empty or invalid DIVariable passed to dbg.declare");
1174 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1176 trackIfUnresolved(VarInfo);
1177 trackIfUnresolved(Expr);
1178 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1179 MetadataAsValue::get(VMContext, VarInfo),
1180 MetadataAsValue::get(VMContext, Expr)};
1182 // If this block already has a terminator then insert this intrinsic
1183 // before the terminator.
1184 if (TerminatorInst *T = InsertAtEnd->getTerminator())
1185 return CallInst::Create(DeclareFn, Args, "", T);
1187 return CallInst::Create(DeclareFn, Args, "", InsertAtEnd);
1190 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1193 Instruction *InsertBefore) {
1194 assert(V && "no value passed to dbg.value");
1195 assert(VarInfo.isVariable() &&
1196 "empty or invalid DIVariable passed to dbg.value");
1198 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1200 trackIfUnresolved(VarInfo);
1201 trackIfUnresolved(Expr);
1202 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1203 ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1204 MetadataAsValue::get(VMContext, VarInfo),
1205 MetadataAsValue::get(VMContext, Expr)};
1206 return CallInst::Create(ValueFn, Args, "", InsertBefore);
1209 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1212 BasicBlock *InsertAtEnd) {
1213 assert(V && "no value passed to dbg.value");
1214 assert(VarInfo.isVariable() &&
1215 "empty or invalid DIVariable passed to dbg.value");
1217 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1219 trackIfUnresolved(VarInfo);
1220 trackIfUnresolved(Expr);
1221 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1222 ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1223 MetadataAsValue::get(VMContext, VarInfo),
1224 MetadataAsValue::get(VMContext, Expr)};
1225 return CallInst::Create(ValueFn, Args, "", InsertAtEnd);
1228 void DIBuilder::replaceVTableHolder(DICompositeType &T, DICompositeType VTableHolder) {
1229 T.setContainingType(VTableHolder);
1231 // If this didn't create a self-reference, just return.
1232 if (T != VTableHolder)
1235 // Look for unresolved operands. T will drop RAUW support, orphaning any
1236 // cycles underneath it.
1237 if (T->isResolved())
1238 for (const MDOperand &O : T->operands())
1239 if (auto *N = dyn_cast_or_null<MDNode>(O))
1240 trackIfUnresolved(N);
1243 void DIBuilder::replaceArrays(DICompositeType &T, DIArray Elements,
1245 T.setArrays(Elements, TParams);
1247 // If T isn't resolved, there's no problem.
1248 if (!T->isResolved())
1251 // If "T" is resolved, it may be due to a self-reference cycle. Track the
1252 // arrays explicitly if they're unresolved, or else the cycles will be
1255 trackIfUnresolved(Elements);
1257 trackIfUnresolved(TParams);