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)
52 : M(m), VMContext(M.getContext()), TempEnumTypes(nullptr),
53 TempRetainTypes(nullptr), TempSubprograms(nullptr), TempGVs(nullptr),
54 DeclareFn(nullptr), ValueFn(nullptr) {}
56 void DIBuilder::finalize() {
57 DIArray Enums = getOrCreateArray(AllEnumTypes);
58 DIType(TempEnumTypes).replaceAllUsesWith(Enums);
60 SmallVector<Value *, 16> RetainValues;
61 // Declarations and definitions of the same type may be retained. Some
62 // clients RAUW these pairs, leaving duplicates in the retained types
63 // list. Use a set to remove the duplicates while we transform the
64 // TrackingVHs back into Values.
65 SmallPtrSet<Value *, 16> RetainSet;
66 for (unsigned I = 0, E = AllRetainTypes.size(); I < E; I++)
67 if (RetainSet.insert(AllRetainTypes[I]))
68 RetainValues.push_back(AllRetainTypes[I]);
69 DIArray RetainTypes = getOrCreateArray(RetainValues);
70 DIType(TempRetainTypes).replaceAllUsesWith(RetainTypes);
72 DIArray SPs = getOrCreateArray(AllSubprograms);
73 DIType(TempSubprograms).replaceAllUsesWith(SPs);
74 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) {
75 DISubprogram SP(SPs.getElement(i));
76 if (MDNode *Temp = SP.getVariablesNodes()) {
77 SmallVector<Value *, 4> Variables;
78 for (Value *V : PreservedVariables.lookup(SP))
79 Variables.push_back(V);
80 DIArray AV = getOrCreateArray(Variables);
81 DIType(Temp).replaceAllUsesWith(AV);
85 DIArray GVs = getOrCreateArray(AllGVs);
86 DIType(TempGVs).replaceAllUsesWith(GVs);
88 SmallVector<Value *, 16> RetainValuesI;
89 for (unsigned I = 0, E = AllImportedModules.size(); I < E; I++)
90 RetainValuesI.push_back(AllImportedModules[I]);
91 DIArray IMs = getOrCreateArray(RetainValuesI);
92 DIType(TempImportedModules).replaceAllUsesWith(IMs);
95 /// If N is compile unit return NULL otherwise return N.
96 static MDNode *getNonCompileUnitScope(MDNode *N) {
97 if (DIDescriptor(N).isCompileUnit())
102 static MDNode *createFilePathPair(LLVMContext &VMContext, StringRef Filename,
103 StringRef Directory) {
104 assert(!Filename.empty() && "Unable to create file without name");
106 MDString::get(VMContext, Filename),
107 MDString::get(VMContext, Directory)
109 return MDNode::get(VMContext, Pair);
112 DICompileUnit DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename,
114 StringRef Producer, bool isOptimized,
115 StringRef Flags, unsigned RunTimeVer,
117 DebugEmissionKind Kind,
118 bool EmitDebugInfo) {
120 assert(((Lang <= dwarf::DW_LANG_OCaml && Lang >= dwarf::DW_LANG_C89) ||
121 (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) &&
122 "Invalid Language tag");
123 assert(!Filename.empty() &&
124 "Unable to create compile unit without filename");
125 Value *TElts[] = {HeaderBuilder::get(DW_TAG_base_type).get(VMContext)};
126 TempEnumTypes = MDNode::getTemporary(VMContext, TElts);
128 TempRetainTypes = MDNode::getTemporary(VMContext, TElts);
130 TempSubprograms = MDNode::getTemporary(VMContext, TElts);
132 TempGVs = MDNode::getTemporary(VMContext, TElts);
134 TempImportedModules = MDNode::getTemporary(VMContext, TElts);
136 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_compile_unit)
145 createFilePathPair(VMContext, Filename, Directory),
146 TempEnumTypes, TempRetainTypes, TempSubprograms, TempGVs,
147 TempImportedModules};
149 MDNode *CUNode = MDNode::get(VMContext, Elts);
151 // Create a named metadata so that it is easier to find cu in a module.
152 // Note that we only generate this when the caller wants to actually
153 // emit debug information. When we are only interested in tracking
154 // source line locations throughout the backend, we prevent codegen from
155 // emitting debug info in the final output by not generating llvm.dbg.cu.
157 NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
158 NMD->addOperand(CUNode);
161 return DICompileUnit(CUNode);
164 static DIImportedEntity
165 createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope Context,
166 Value *NS, unsigned Line, StringRef Name,
167 SmallVectorImpl<TrackingVH<MDNode>> &AllImportedModules) {
169 Value *Elts[] = {HeaderBuilder::get(Tag).concat(Line).concat(Name).get(C),
171 R = MDNode::get(C, Elts);
172 DIImportedEntity M(R);
173 assert(M.Verify() && "Imported module should be valid");
174 AllImportedModules.push_back(TrackingVH<MDNode>(M));
178 DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
181 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
182 Context, NS, Line, StringRef(), AllImportedModules);
185 DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
188 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
189 Context, NS, Line, StringRef(), AllImportedModules);
192 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
194 unsigned Line, StringRef Name) {
195 // Make sure to use the unique identifier based metadata reference for
196 // types that have one.
197 Value *V = Decl.isType() ? static_cast<Value*>(DIType(Decl).getRef()) : Decl;
198 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
199 Context, V, Line, Name,
203 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
204 DIImportedEntity Imp,
205 unsigned Line, StringRef Name) {
206 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
207 Context, Imp, Line, Name, AllImportedModules);
210 DIFile DIBuilder::createFile(StringRef Filename, StringRef Directory) {
211 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_file_type).get(VMContext),
212 createFilePathPair(VMContext, Filename, Directory)};
213 return DIFile(MDNode::get(VMContext, Elts));
216 DIEnumerator DIBuilder::createEnumerator(StringRef Name, int64_t Val) {
217 assert(!Name.empty() && "Unable to create enumerator without name");
219 HeaderBuilder::get(dwarf::DW_TAG_enumerator).concat(Name).concat(Val).get(
221 return DIEnumerator(MDNode::get(VMContext, Elts));
224 DIBasicType DIBuilder::createUnspecifiedType(StringRef Name) {
225 assert(!Name.empty() && "Unable to create type without name");
226 // Unspecified types are encoded in DIBasicType format. Line number, filename,
227 // size, alignment, offset and flags are always empty here.
229 HeaderBuilder::get(dwarf::DW_TAG_unspecified_type)
241 return DIBasicType(MDNode::get(VMContext, Elts));
244 DIBasicType DIBuilder::createNullPtrType() {
245 return createUnspecifiedType("decltype(nullptr)");
249 DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
250 uint64_t AlignInBits, unsigned Encoding) {
251 assert(!Name.empty() && "Unable to create type without name");
252 // Basic types are encoded in DIBasicType format. Line number, filename,
253 // offset and flags are always empty here.
255 HeaderBuilder::get(dwarf::DW_TAG_base_type)
267 return DIBasicType(MDNode::get(VMContext, Elts));
270 DIDerivedType DIBuilder::createQualifiedType(unsigned Tag, DIType FromTy) {
271 // Qualified types are encoded in DIDerivedType format.
272 Value *Elts[] = {HeaderBuilder::get(Tag)
273 .concat(StringRef()) // Name
283 return DIDerivedType(MDNode::get(VMContext, Elts));
287 DIBuilder::createPointerType(DIType PointeeTy, uint64_t SizeInBits,
288 uint64_t AlignInBits, StringRef Name) {
289 // Pointer types are encoded in DIDerivedType format.
290 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_pointer_type)
301 return DIDerivedType(MDNode::get(VMContext, Elts));
304 DIDerivedType DIBuilder::createMemberPointerType(DIType PointeeTy,
306 // Pointer types are encoded in DIDerivedType format.
307 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_ptr_to_member_type)
317 PointeeTy.getRef(), Base.getRef()};
318 return DIDerivedType(MDNode::get(VMContext, Elts));
321 DIDerivedType DIBuilder::createReferenceType(unsigned Tag, DIType RTy) {
322 assert(RTy.isType() && "Unable to create reference type");
323 // References are encoded in DIDerivedType format.
324 Value *Elts[] = {HeaderBuilder::get(Tag)
325 .concat(StringRef()) // Name
335 return DIDerivedType(MDNode::get(VMContext, Elts));
338 DIDerivedType DIBuilder::createTypedef(DIType Ty, StringRef Name, DIFile File,
339 unsigned LineNo, DIDescriptor Context) {
340 // typedefs are encoded in DIDerivedType format.
341 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_typedef)
350 DIScope(getNonCompileUnitScope(Context)).getRef(),
352 return DIDerivedType(MDNode::get(VMContext, Elts));
355 DIDerivedType DIBuilder::createFriend(DIType Ty, DIType FriendTy) {
356 // typedefs are encoded in DIDerivedType format.
357 assert(Ty.isType() && "Invalid type!");
358 assert(FriendTy.isType() && "Invalid friend type!");
359 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_friend)
360 .concat(StringRef()) // Name
367 nullptr, Ty.getRef(), FriendTy.getRef()};
368 return DIDerivedType(MDNode::get(VMContext, Elts));
371 DIDerivedType DIBuilder::createInheritance(DIType Ty, DIType BaseTy,
374 assert(Ty.isType() && "Unable to create inheritance");
375 // TAG_inheritance is encoded in DIDerivedType format.
376 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_inheritance)
377 .concat(StringRef()) // Name
384 nullptr, Ty.getRef(), BaseTy.getRef()};
385 return DIDerivedType(MDNode::get(VMContext, Elts));
388 DIDerivedType DIBuilder::createMemberType(DIDescriptor Scope, StringRef Name,
389 DIFile File, unsigned LineNumber,
391 uint64_t AlignInBits,
392 uint64_t OffsetInBits, unsigned Flags,
394 // TAG_member is encoded in DIDerivedType format.
395 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
400 .concat(OffsetInBits)
404 DIScope(getNonCompileUnitScope(Scope)).getRef(),
406 return DIDerivedType(MDNode::get(VMContext, Elts));
410 DIBuilder::createStaticMemberType(DIDescriptor Scope, StringRef Name,
411 DIFile File, unsigned LineNumber,
412 DIType Ty, unsigned Flags,
414 // TAG_member is encoded in DIDerivedType format.
415 Flags |= DIDescriptor::FlagStaticMember;
416 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
425 DIScope(getNonCompileUnitScope(Scope)).getRef(), Ty.getRef(),
427 return DIDerivedType(MDNode::get(VMContext, Elts));
430 DIDerivedType DIBuilder::createObjCIVar(StringRef Name, DIFile File,
433 uint64_t AlignInBits,
434 uint64_t OffsetInBits, unsigned Flags,
435 DIType Ty, MDNode *PropertyNode) {
436 // TAG_member is encoded in DIDerivedType format.
437 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
442 .concat(OffsetInBits)
445 File.getFileNode(), getNonCompileUnitScope(File), Ty,
447 return DIDerivedType(MDNode::get(VMContext, Elts));
451 DIBuilder::createObjCProperty(StringRef Name, DIFile File, unsigned LineNumber,
452 StringRef GetterName, StringRef SetterName,
453 unsigned PropertyAttributes, DIType Ty) {
454 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_APPLE_property)
459 .concat(PropertyAttributes)
462 return DIObjCProperty(MDNode::get(VMContext, Elts));
465 DITemplateTypeParameter
466 DIBuilder::createTemplateTypeParameter(DIDescriptor Context, StringRef Name,
467 DIType Ty, MDNode *File, unsigned LineNo,
469 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_template_type_parameter)
474 DIScope(getNonCompileUnitScope(Context)).getRef(),
476 return DITemplateTypeParameter(MDNode::get(VMContext, Elts));
479 DITemplateValueParameter
480 DIBuilder::createTemplateValueParameter(unsigned Tag, DIDescriptor Context,
481 StringRef Name, DIType Ty,
482 Value *Val, MDNode *File,
486 HeaderBuilder::get(Tag).concat(Name).concat(LineNo).concat(ColumnNo).get(
488 DIScope(getNonCompileUnitScope(Context)).getRef(), Ty.getRef(), Val,
490 return DITemplateValueParameter(MDNode::get(VMContext, Elts));
493 DITemplateValueParameter
494 DIBuilder::createTemplateValueParameter(DIDescriptor Context, StringRef Name,
495 DIType Ty, Value *Val,
496 MDNode *File, unsigned LineNo,
498 return createTemplateValueParameter(dwarf::DW_TAG_template_value_parameter,
499 Context, Name, Ty, Val, File, LineNo,
503 DITemplateValueParameter
504 DIBuilder::createTemplateTemplateParameter(DIDescriptor Context, StringRef Name,
505 DIType Ty, StringRef Val,
506 MDNode *File, unsigned LineNo,
508 return createTemplateValueParameter(
509 dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
510 MDString::get(VMContext, Val), File, LineNo, ColumnNo);
513 DITemplateValueParameter
514 DIBuilder::createTemplateParameterPack(DIDescriptor Context, StringRef Name,
515 DIType Ty, DIArray Val,
516 MDNode *File, unsigned LineNo,
518 return createTemplateValueParameter(dwarf::DW_TAG_GNU_template_parameter_pack,
519 Context, Name, Ty, Val, File, LineNo,
523 DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
524 DIFile File, unsigned LineNumber,
526 uint64_t AlignInBits,
527 uint64_t OffsetInBits,
528 unsigned Flags, DIType DerivedFrom,
531 MDNode *TemplateParams,
532 StringRef UniqueIdentifier) {
533 assert((!Context || Context.isScope() || Context.isType()) &&
534 "createClassType should be called with a valid Context");
535 // TAG_class_type is encoded in DICompositeType format.
537 HeaderBuilder::get(dwarf::DW_TAG_class_type)
542 .concat(OffsetInBits)
546 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
547 DerivedFrom.getRef(), Elements, VTableHolder.getRef(), TemplateParams,
548 UniqueIdentifier.empty() ? nullptr
549 : MDString::get(VMContext, UniqueIdentifier)};
550 DICompositeType R(MDNode::get(VMContext, Elts));
551 assert(R.isCompositeType() &&
552 "createClassType should return a DICompositeType");
553 if (!UniqueIdentifier.empty())
558 DICompositeType DIBuilder::createStructType(DIDescriptor Context,
559 StringRef Name, DIFile File,
562 uint64_t AlignInBits,
563 unsigned Flags, DIType DerivedFrom,
565 unsigned RunTimeLang,
567 StringRef UniqueIdentifier) {
568 // TAG_structure_type is encoded in DICompositeType format.
570 HeaderBuilder::get(dwarf::DW_TAG_structure_type)
579 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
580 DerivedFrom.getRef(), Elements, VTableHolder.getRef(), nullptr,
581 UniqueIdentifier.empty() ? nullptr
582 : MDString::get(VMContext, UniqueIdentifier)};
583 DICompositeType R(MDNode::get(VMContext, Elts));
584 assert(R.isCompositeType() &&
585 "createStructType should return a DICompositeType");
586 if (!UniqueIdentifier.empty())
591 DICompositeType DIBuilder::createUnionType(DIDescriptor Scope, StringRef Name,
592 DIFile File, unsigned LineNumber,
594 uint64_t AlignInBits, unsigned Flags,
596 unsigned RunTimeLang,
597 StringRef UniqueIdentifier) {
598 // TAG_union_type is encoded in DICompositeType format.
600 HeaderBuilder::get(dwarf::DW_TAG_union_type)
609 File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
610 nullptr, Elements, nullptr, nullptr,
611 UniqueIdentifier.empty() ? nullptr
612 : MDString::get(VMContext, UniqueIdentifier)};
613 DICompositeType R(MDNode::get(VMContext, Elts));
614 if (!UniqueIdentifier.empty())
619 DISubroutineType DIBuilder::createSubroutineType(DIFile File,
620 DITypeArray ParameterTypes,
622 // TAG_subroutine_type is encoded in DICompositeType format.
624 HeaderBuilder::get(dwarf::DW_TAG_subroutine_type)
630 .concat(Flags) // Flags
633 nullptr, nullptr, nullptr, ParameterTypes, nullptr, nullptr,
634 nullptr // Type Identifer
636 return DISubroutineType(MDNode::get(VMContext, Elts));
639 DICompositeType DIBuilder::createEnumerationType(
640 DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
641 uint64_t SizeInBits, uint64_t AlignInBits, DIArray Elements,
642 DIType UnderlyingType, StringRef UniqueIdentifier) {
643 // TAG_enumeration_type is encoded in DICompositeType format.
645 HeaderBuilder::get(dwarf::DW_TAG_enumeration_type)
654 File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
655 UnderlyingType.getRef(), Elements, nullptr, nullptr,
656 UniqueIdentifier.empty() ? nullptr
657 : MDString::get(VMContext, UniqueIdentifier)};
658 DICompositeType CTy(MDNode::get(VMContext, Elts));
659 AllEnumTypes.push_back(CTy);
660 if (!UniqueIdentifier.empty())
665 DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
666 DIType Ty, DIArray Subscripts) {
667 // TAG_array_type is encoded in DICompositeType format.
669 HeaderBuilder::get(dwarf::DW_TAG_array_type)
678 nullptr, // Filename/Directory,
680 Ty.getRef(), Subscripts, nullptr, nullptr,
681 nullptr // Type Identifer
683 return DICompositeType(MDNode::get(VMContext, Elts));
686 DICompositeType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
687 DIType Ty, DIArray Subscripts) {
688 // A vector is an array type with the FlagVector flag applied.
690 HeaderBuilder::get(dwarf::DW_TAG_array_type)
696 .concat(DIType::FlagVector)
699 nullptr, // Filename/Directory,
701 Ty.getRef(), Subscripts, nullptr, nullptr,
702 nullptr // Type Identifer
704 return DICompositeType(MDNode::get(VMContext, Elts));
707 static HeaderBuilder setTypeFlagsInHeader(StringRef Header,
708 unsigned FlagsToSet) {
709 DIHeaderFieldIterator I(Header);
713 if (I->getAsInteger(0, Flags))
717 return HeaderBuilder(Twine(I.getPrefix())).concat(Flags).concat(
721 static DIType createTypeWithFlags(LLVMContext &Context, DIType Ty,
722 unsigned FlagsToSet) {
723 SmallVector<Value *, 9> Elts;
725 assert(N && "Unexpected input DIType!");
726 // Update header field.
727 Elts.push_back(setTypeFlagsInHeader(Ty.getHeader(), FlagsToSet).get(Context));
728 for (unsigned I = 1, E = N->getNumOperands(); I != E; ++I)
729 Elts.push_back(N->getOperand(I));
731 return DIType(MDNode::get(Context, Elts));
734 DIType DIBuilder::createArtificialType(DIType Ty) {
735 if (Ty.isArtificial())
737 return createTypeWithFlags(VMContext, Ty, DIType::FlagArtificial);
740 DIType DIBuilder::createObjectPointerType(DIType Ty) {
741 if (Ty.isObjectPointer())
743 unsigned Flags = DIType::FlagObjectPointer | DIType::FlagArtificial;
744 return createTypeWithFlags(VMContext, Ty, Flags);
747 void DIBuilder::retainType(DIType T) {
748 AllRetainTypes.push_back(TrackingVH<MDNode>(T));
751 DIBasicType DIBuilder::createUnspecifiedParameter() {
752 return DIBasicType();
756 DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIDescriptor Scope,
757 DIFile F, unsigned Line, unsigned RuntimeLang,
758 uint64_t SizeInBits, uint64_t AlignInBits,
759 StringRef UniqueIdentifier) {
760 // Create a temporary MDNode.
762 HeaderBuilder::get(Tag)
768 .concat(DIDescriptor::FlagFwdDecl)
771 F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
773 nullptr, // TemplateParams
774 UniqueIdentifier.empty() ? nullptr
775 : MDString::get(VMContext, UniqueIdentifier)};
776 MDNode *Node = MDNode::get(VMContext, Elts);
777 DICompositeType RetTy(Node);
778 assert(RetTy.isCompositeType() &&
779 "createForwardDecl result should be a DIType");
780 if (!UniqueIdentifier.empty())
785 DICompositeType DIBuilder::createReplaceableForwardDecl(
786 unsigned Tag, StringRef Name, DIDescriptor Scope, DIFile F, unsigned Line,
787 unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
788 StringRef UniqueIdentifier) {
789 // Create a temporary MDNode.
791 HeaderBuilder::get(Tag)
797 .concat(DIDescriptor::FlagFwdDecl)
800 F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
802 nullptr, // TemplateParams
803 UniqueIdentifier.empty() ? nullptr
804 : MDString::get(VMContext, UniqueIdentifier)};
805 MDNode *Node = MDNode::getTemporary(VMContext, Elts);
806 DICompositeType RetTy(Node);
807 assert(RetTy.isCompositeType() &&
808 "createReplaceableForwardDecl result should be a DIType");
809 if (!UniqueIdentifier.empty())
814 DIArray DIBuilder::getOrCreateArray(ArrayRef<Value *> Elements) {
815 return DIArray(MDNode::get(VMContext, Elements));
818 DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Value *> Elements) {
819 SmallVector<llvm::Value *, 16> Elts;
820 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
821 if (Elements[i] && isa<MDNode>(Elements[i]))
822 Elts.push_back(DIType(cast<MDNode>(Elements[i])).getRef());
824 Elts.push_back(Elements[i]);
826 return DITypeArray(MDNode::get(VMContext, Elts));
829 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
830 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subrange_type)
835 return DISubrange(MDNode::get(VMContext, Elts));
838 static DIGlobalVariable
839 createGlobalVariableHelper(LLVMContext &VMContext, DIDescriptor Context,
840 StringRef Name, StringRef LinkageName, DIFile F,
841 unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit,
842 Value *Val, MDNode *Decl, bool isDefinition,
843 std::function<MDNode *(ArrayRef<Value *>)> CreateFunc) {
844 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_variable)
849 .concat(isLocalToUnit)
850 .concat(isDefinition)
852 getNonCompileUnitScope(Context), F, Ty, Val,
855 return DIGlobalVariable(CreateFunc(Elts));
858 DIGlobalVariable DIBuilder::createGlobalVariable(DIDescriptor Context,
860 StringRef LinkageName,
861 DIFile F, unsigned LineNumber,
864 Value *Val, MDNode *Decl) {
865 return createGlobalVariableHelper(VMContext, Context, Name, LinkageName, F,
866 LineNumber, Ty, isLocalToUnit, Val, Decl, true,
867 [&] (ArrayRef<Value *> Elts) -> MDNode * {
868 MDNode *Node = MDNode::get(VMContext, Elts);
869 AllGVs.push_back(Node);
875 DIBuilder::createTempGlobalVariableFwdDecl(DIDescriptor Context,
877 StringRef LinkageName,
878 DIFile F, unsigned LineNumber,
881 Value *Val, MDNode *Decl) {
882 return createGlobalVariableHelper(VMContext, Context, Name, LinkageName, F,
883 LineNumber, Ty, isLocalToUnit, Val, Decl, false,
884 [&] (ArrayRef<Value *> Elts) {
885 return MDNode::getTemporary(VMContext, Elts);
889 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
890 StringRef Name, DIFile File,
891 unsigned LineNo, DITypeRef Ty,
892 bool AlwaysPreserve, unsigned Flags,
894 DIDescriptor Context(getNonCompileUnitScope(Scope));
895 assert((!Context || Context.isScope()) &&
896 "createLocalVariable should be called with a valid Context");
897 Value *Elts[] = {HeaderBuilder::get(Tag)
899 .concat(LineNo | (ArgNo << 24))
902 getNonCompileUnitScope(Scope), File, Ty};
903 MDNode *Node = MDNode::get(VMContext, Elts);
904 if (AlwaysPreserve) {
905 // The optimizer may remove local variable. If there is an interest
906 // to preserve variable info in such situation then stash it in a
908 DISubprogram Fn(getDISubprogram(Scope));
909 assert(Fn && "Missing subprogram for local variable");
910 PreservedVariables[Fn].push_back(Node);
912 DIVariable RetVar(Node);
913 assert(RetVar.isVariable() &&
914 "createLocalVariable should return a valid DIVariable");
918 DIExpression DIBuilder::createExpression(ArrayRef<int64_t> Addr) {
919 auto Header = HeaderBuilder::get(DW_TAG_expression);
920 for (int64_t I : Addr)
922 Value *Elts[] = {Header.get(VMContext)};
923 return DIExpression(MDNode::get(VMContext, Elts));
926 DIExpression DIBuilder::createPieceExpression(unsigned OffsetInBytes,
927 unsigned SizeInBytes) {
928 int64_t Addr[] = {dwarf::DW_OP_piece, OffsetInBytes, SizeInBytes};
929 return createExpression(Addr);
932 DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
933 StringRef LinkageName, DIFile File,
934 unsigned LineNo, DICompositeType Ty,
935 bool isLocalToUnit, bool isDefinition,
936 unsigned ScopeLine, unsigned Flags,
937 bool isOptimized, Function *Fn,
938 MDNode *TParams, MDNode *Decl) {
939 // dragonegg does not generate identifier for types, so using an empty map
940 // to resolve the context should be fine.
941 DITypeIdentifierMap EmptyMap;
942 return createFunction(Context.resolve(EmptyMap), Name, LinkageName, File,
943 LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
944 Flags, isOptimized, Fn, TParams, Decl);
948 createFunctionHelper(LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
949 StringRef LinkageName, DIFile File, unsigned LineNo,
950 DICompositeType Ty, bool isLocalToUnit, bool isDefinition,
951 unsigned ScopeLine, unsigned Flags, bool isOptimized,
952 Function *Fn, MDNode *TParams, MDNode *Decl,
953 std::function<MDNode *(ArrayRef<Value *>)> CreateFunc) {
954 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
955 "function types should be subroutines");
956 Value *TElts[] = {HeaderBuilder::get(DW_TAG_base_type).get(VMContext)};
958 HeaderBuilder::get(dwarf::DW_TAG_subprogram)
963 .concat(isLocalToUnit)
964 .concat(isDefinition)
971 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(), Ty,
972 nullptr, Fn, TParams, Decl, MDNode::getTemporary(VMContext, TElts)};
974 DISubprogram S(CreateFunc(Elts));
975 assert(S.isSubprogram() &&
976 "createFunction should return a valid DISubprogram");
981 DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
982 StringRef LinkageName, DIFile File,
983 unsigned LineNo, DICompositeType Ty,
984 bool isLocalToUnit, bool isDefinition,
985 unsigned ScopeLine, unsigned Flags,
986 bool isOptimized, Function *Fn,
987 MDNode *TParams, MDNode *Decl) {
988 return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
989 LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
990 Flags, isOptimized, Fn, TParams, Decl,
991 [&] (ArrayRef<Value *> Elts) -> MDNode *{
992 MDNode *Node = MDNode::get(VMContext, Elts);
993 // Create a named metadata so that we
994 // do not lose this mdnode.
996 AllSubprograms.push_back(Node);
1002 DIBuilder::createTempFunctionFwdDecl(DIDescriptor Context, StringRef Name,
1003 StringRef LinkageName, DIFile File,
1004 unsigned LineNo, DICompositeType Ty,
1005 bool isLocalToUnit, bool isDefinition,
1006 unsigned ScopeLine, unsigned Flags,
1007 bool isOptimized, Function *Fn,
1008 MDNode *TParams, MDNode *Decl) {
1009 return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1010 LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
1011 Flags, isOptimized, Fn, TParams, Decl,
1012 [&] (ArrayRef<Value *> Elts) {
1013 return MDNode::getTemporary(VMContext, Elts);
1017 DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
1018 StringRef LinkageName, DIFile F,
1019 unsigned LineNo, DICompositeType Ty,
1020 bool isLocalToUnit, bool isDefinition,
1021 unsigned VK, unsigned VIndex,
1022 DIType VTableHolder, unsigned Flags,
1023 bool isOptimized, Function *Fn,
1025 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
1026 "function types should be subroutines");
1027 assert(getNonCompileUnitScope(Context) &&
1028 "Methods should have both a Context and a context that isn't "
1029 "the compile unit.");
1030 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
1033 .concat(LinkageName)
1035 .concat(isLocalToUnit)
1036 .concat(isDefinition)
1040 .concat(isOptimized)
1042 // FIXME: Do we want to use different scope/lines?
1044 F.getFileNode(), DIScope(Context).getRef(), Ty,
1045 VTableHolder.getRef(), Fn, TParam, nullptr, nullptr};
1046 MDNode *Node = MDNode::get(VMContext, Elts);
1048 AllSubprograms.push_back(Node);
1049 DISubprogram S(Node);
1050 assert(S.isSubprogram() && "createMethod should return a valid DISubprogram");
1054 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
1055 DIFile File, unsigned LineNo) {
1056 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_namespace)
1060 File.getFileNode(), getNonCompileUnitScope(Scope)};
1061 DINameSpace R(MDNode::get(VMContext, Elts));
1062 assert(R.Verify() &&
1063 "createNameSpace should return a verifiable DINameSpace");
1067 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
1069 unsigned Discriminator) {
1070 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1071 .concat(Discriminator)
1073 File.getFileNode(), Scope};
1074 DILexicalBlockFile R(MDNode::get(VMContext, Elts));
1077 "createLexicalBlockFile should return a verifiable DILexicalBlockFile");
1081 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
1082 unsigned Line, unsigned Col) {
1083 // FIXME: This isn't thread safe nor the right way to defeat MDNode uniquing.
1084 // I believe the right way is to have a self-referential element in the node.
1085 // Also: why do we bother with line/column - they're not used and the
1086 // documentation (SourceLevelDebugging.rst) claims the line/col are necessary
1087 // for uniquing, yet then we have this other solution (because line/col were
1088 // inadequate) anyway. Remove all 3 and replace them with a self-reference.
1090 // Defeat MDNode uniquing for lexical blocks by using unique id.
1091 static unsigned int unique_id = 0;
1092 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1095 .concat(unique_id++)
1097 File.getFileNode(), getNonCompileUnitScope(Scope)};
1098 DILexicalBlock R(MDNode::get(VMContext, Elts));
1099 assert(R.Verify() &&
1100 "createLexicalBlock should return a verifiable DILexicalBlock");
1104 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1106 Instruction *InsertBefore) {
1107 assert(Storage && "no storage passed to dbg.declare");
1108 assert(VarInfo.isVariable() &&
1109 "empty or invalid DIVariable passed to dbg.declare");
1111 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1113 Value *Args[] = {MDNode::get(Storage->getContext(), Storage), VarInfo, Expr};
1114 return CallInst::Create(DeclareFn, Args, "", InsertBefore);
1117 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1119 BasicBlock *InsertAtEnd) {
1120 assert(Storage && "no storage passed to dbg.declare");
1121 assert(VarInfo.isVariable() &&
1122 "empty or invalid DIVariable passed to dbg.declare");
1124 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1126 Value *Args[] = {MDNode::get(Storage->getContext(), Storage), VarInfo, Expr};
1128 // If this block already has a terminator then insert this intrinsic
1129 // before the terminator.
1130 if (TerminatorInst *T = InsertAtEnd->getTerminator())
1131 return CallInst::Create(DeclareFn, Args, "", T);
1133 return CallInst::Create(DeclareFn, Args, "", InsertAtEnd);
1136 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1139 Instruction *InsertBefore) {
1140 assert(V && "no value passed to dbg.value");
1141 assert(VarInfo.isVariable() &&
1142 "empty or invalid DIVariable passed to dbg.value");
1144 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1146 Value *Args[] = {MDNode::get(V->getContext(), V),
1147 ConstantInt::get(Type::getInt64Ty(V->getContext()), Offset),
1149 return CallInst::Create(ValueFn, Args, "", InsertBefore);
1152 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1155 BasicBlock *InsertAtEnd) {
1156 assert(V && "no value passed to dbg.value");
1157 assert(VarInfo.isVariable() &&
1158 "empty or invalid DIVariable passed to dbg.value");
1160 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1162 Value *Args[] = {MDNode::get(V->getContext(), V),
1163 ConstantInt::get(Type::getInt64Ty(V->getContext()), Offset),
1165 return CallInst::Create(ValueFn, Args, "", InsertAtEnd);