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]).second)
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));
409 DIDerivedType DIBuilder::createStaticMemberType(DIDescriptor Scope,
410 StringRef Name, DIFile File,
411 unsigned LineNumber, DIType Ty,
413 llvm::Constant *Val) {
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 static DITemplateValueParameter createTemplateValueParameterHelper(
480 LLVMContext &VMContext, unsigned Tag, DIDescriptor Context, StringRef Name,
481 DIType Ty, Value *Val, MDNode *File, unsigned LineNo, unsigned ColumnNo) {
483 HeaderBuilder::get(Tag).concat(Name).concat(LineNo).concat(ColumnNo).get(
485 DIScope(getNonCompileUnitScope(Context)).getRef(), Ty.getRef(), Val,
487 return DITemplateValueParameter(MDNode::get(VMContext, Elts));
490 DITemplateValueParameter
491 DIBuilder::createTemplateValueParameter(DIDescriptor Context, StringRef Name,
492 DIType Ty, Constant *Val, MDNode *File,
493 unsigned LineNo, unsigned ColumnNo) {
494 return createTemplateValueParameterHelper(
495 VMContext, dwarf::DW_TAG_template_value_parameter, Context, Name, Ty, Val,
496 File, LineNo, ColumnNo);
499 DITemplateValueParameter
500 DIBuilder::createTemplateTemplateParameter(DIDescriptor Context, StringRef Name,
501 DIType Ty, StringRef Val,
502 MDNode *File, unsigned LineNo,
504 return createTemplateValueParameterHelper(
505 VMContext, dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
506 MDString::get(VMContext, Val), File, LineNo, ColumnNo);
509 DITemplateValueParameter
510 DIBuilder::createTemplateParameterPack(DIDescriptor Context, StringRef Name,
511 DIType Ty, DIArray Val,
512 MDNode *File, unsigned LineNo,
514 return createTemplateValueParameterHelper(
515 VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
516 Val, File, LineNo, ColumnNo);
519 DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
520 DIFile File, unsigned LineNumber,
522 uint64_t AlignInBits,
523 uint64_t OffsetInBits,
524 unsigned Flags, DIType DerivedFrom,
527 MDNode *TemplateParams,
528 StringRef UniqueIdentifier) {
529 assert((!Context || Context.isScope() || Context.isType()) &&
530 "createClassType should be called with a valid Context");
531 // TAG_class_type is encoded in DICompositeType format.
533 HeaderBuilder::get(dwarf::DW_TAG_class_type)
538 .concat(OffsetInBits)
542 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
543 DerivedFrom.getRef(), Elements, VTableHolder.getRef(), TemplateParams,
544 UniqueIdentifier.empty() ? nullptr
545 : MDString::get(VMContext, UniqueIdentifier)};
546 DICompositeType R(MDNode::get(VMContext, Elts));
547 assert(R.isCompositeType() &&
548 "createClassType should return a DICompositeType");
549 if (!UniqueIdentifier.empty())
554 DICompositeType DIBuilder::createStructType(DIDescriptor Context,
555 StringRef Name, DIFile File,
558 uint64_t AlignInBits,
559 unsigned Flags, DIType DerivedFrom,
561 unsigned RunTimeLang,
563 StringRef UniqueIdentifier) {
564 // TAG_structure_type is encoded in DICompositeType format.
566 HeaderBuilder::get(dwarf::DW_TAG_structure_type)
575 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
576 DerivedFrom.getRef(), Elements, VTableHolder.getRef(), nullptr,
577 UniqueIdentifier.empty() ? nullptr
578 : MDString::get(VMContext, UniqueIdentifier)};
579 DICompositeType R(MDNode::get(VMContext, Elts));
580 assert(R.isCompositeType() &&
581 "createStructType should return a DICompositeType");
582 if (!UniqueIdentifier.empty())
587 DICompositeType DIBuilder::createUnionType(DIDescriptor Scope, StringRef Name,
588 DIFile File, unsigned LineNumber,
590 uint64_t AlignInBits, unsigned Flags,
592 unsigned RunTimeLang,
593 StringRef UniqueIdentifier) {
594 // TAG_union_type is encoded in DICompositeType format.
596 HeaderBuilder::get(dwarf::DW_TAG_union_type)
605 File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
606 nullptr, Elements, nullptr, nullptr,
607 UniqueIdentifier.empty() ? nullptr
608 : MDString::get(VMContext, UniqueIdentifier)};
609 DICompositeType R(MDNode::get(VMContext, Elts));
610 if (!UniqueIdentifier.empty())
615 DISubroutineType DIBuilder::createSubroutineType(DIFile File,
616 DITypeArray ParameterTypes,
618 // TAG_subroutine_type is encoded in DICompositeType format.
620 HeaderBuilder::get(dwarf::DW_TAG_subroutine_type)
626 .concat(Flags) // Flags
629 nullptr, nullptr, nullptr, ParameterTypes, nullptr, nullptr,
630 nullptr // Type Identifer
632 return DISubroutineType(MDNode::get(VMContext, Elts));
635 DICompositeType DIBuilder::createEnumerationType(
636 DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
637 uint64_t SizeInBits, uint64_t AlignInBits, DIArray Elements,
638 DIType UnderlyingType, StringRef UniqueIdentifier) {
639 // TAG_enumeration_type is encoded in DICompositeType format.
641 HeaderBuilder::get(dwarf::DW_TAG_enumeration_type)
650 File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
651 UnderlyingType.getRef(), Elements, nullptr, nullptr,
652 UniqueIdentifier.empty() ? nullptr
653 : MDString::get(VMContext, UniqueIdentifier)};
654 DICompositeType CTy(MDNode::get(VMContext, Elts));
655 AllEnumTypes.push_back(CTy);
656 if (!UniqueIdentifier.empty())
661 DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
662 DIType Ty, DIArray Subscripts) {
663 // TAG_array_type is encoded in DICompositeType format.
665 HeaderBuilder::get(dwarf::DW_TAG_array_type)
674 nullptr, // Filename/Directory,
676 Ty.getRef(), Subscripts, nullptr, nullptr,
677 nullptr // Type Identifer
679 return DICompositeType(MDNode::get(VMContext, Elts));
682 DICompositeType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
683 DIType Ty, DIArray Subscripts) {
684 // A vector is an array type with the FlagVector flag applied.
686 HeaderBuilder::get(dwarf::DW_TAG_array_type)
692 .concat(DIType::FlagVector)
695 nullptr, // Filename/Directory,
697 Ty.getRef(), Subscripts, nullptr, nullptr,
698 nullptr // Type Identifer
700 return DICompositeType(MDNode::get(VMContext, Elts));
703 static HeaderBuilder setTypeFlagsInHeader(StringRef Header,
704 unsigned FlagsToSet) {
705 DIHeaderFieldIterator I(Header);
709 if (I->getAsInteger(0, Flags))
713 return HeaderBuilder(Twine(I.getPrefix())).concat(Flags).concat(
717 static DIType createTypeWithFlags(LLVMContext &Context, DIType Ty,
718 unsigned FlagsToSet) {
719 SmallVector<Value *, 9> Elts;
721 assert(N && "Unexpected input DIType!");
722 // Update header field.
723 Elts.push_back(setTypeFlagsInHeader(Ty.getHeader(), FlagsToSet).get(Context));
724 for (unsigned I = 1, E = N->getNumOperands(); I != E; ++I)
725 Elts.push_back(N->getOperand(I));
727 return DIType(MDNode::get(Context, Elts));
730 DIType DIBuilder::createArtificialType(DIType Ty) {
731 if (Ty.isArtificial())
733 return createTypeWithFlags(VMContext, Ty, DIType::FlagArtificial);
736 DIType DIBuilder::createObjectPointerType(DIType Ty) {
737 if (Ty.isObjectPointer())
739 unsigned Flags = DIType::FlagObjectPointer | DIType::FlagArtificial;
740 return createTypeWithFlags(VMContext, Ty, Flags);
743 void DIBuilder::retainType(DIType T) {
744 AllRetainTypes.push_back(TrackingVH<MDNode>(T));
747 DIBasicType DIBuilder::createUnspecifiedParameter() {
748 return DIBasicType();
752 DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIDescriptor Scope,
753 DIFile F, unsigned Line, unsigned RuntimeLang,
754 uint64_t SizeInBits, uint64_t AlignInBits,
755 StringRef UniqueIdentifier) {
756 // Create a temporary MDNode.
758 HeaderBuilder::get(Tag)
764 .concat(DIDescriptor::FlagFwdDecl)
767 F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
769 nullptr, // TemplateParams
770 UniqueIdentifier.empty() ? nullptr
771 : MDString::get(VMContext, UniqueIdentifier)};
772 MDNode *Node = MDNode::get(VMContext, Elts);
773 DICompositeType RetTy(Node);
774 assert(RetTy.isCompositeType() &&
775 "createForwardDecl result should be a DIType");
776 if (!UniqueIdentifier.empty())
781 DICompositeType DIBuilder::createReplaceableForwardDecl(
782 unsigned Tag, StringRef Name, DIDescriptor Scope, DIFile F, unsigned Line,
783 unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
784 StringRef UniqueIdentifier) {
785 // Create a temporary MDNode.
787 HeaderBuilder::get(Tag)
793 .concat(DIDescriptor::FlagFwdDecl)
796 F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
798 nullptr, // TemplateParams
799 UniqueIdentifier.empty() ? nullptr
800 : MDString::get(VMContext, UniqueIdentifier)};
801 MDNode *Node = MDNode::getTemporary(VMContext, Elts);
802 DICompositeType RetTy(Node);
803 assert(RetTy.isCompositeType() &&
804 "createReplaceableForwardDecl result should be a DIType");
805 if (!UniqueIdentifier.empty())
810 DIArray DIBuilder::getOrCreateArray(ArrayRef<Value *> Elements) {
811 return DIArray(MDNode::get(VMContext, Elements));
814 DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Value *> Elements) {
815 SmallVector<llvm::Value *, 16> Elts;
816 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
817 if (Elements[i] && isa<MDNode>(Elements[i]))
818 Elts.push_back(DIType(cast<MDNode>(Elements[i])).getRef());
820 Elts.push_back(Elements[i]);
822 return DITypeArray(MDNode::get(VMContext, Elts));
825 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
826 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subrange_type)
831 return DISubrange(MDNode::get(VMContext, Elts));
834 static DIGlobalVariable createGlobalVariableHelper(
835 LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
836 StringRef LinkageName, DIFile F, unsigned LineNumber, DITypeRef Ty,
837 bool isLocalToUnit, Constant *Val, MDNode *Decl, bool isDefinition,
838 std::function<MDNode *(ArrayRef<Value *>)> CreateFunc) {
839 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_variable)
844 .concat(isLocalToUnit)
845 .concat(isDefinition)
847 DIScope(getNonCompileUnitScope(Context)).getRef(), F, Ty, Val,
850 return DIGlobalVariable(CreateFunc(Elts));
853 DIGlobalVariable DIBuilder::createGlobalVariable(
854 DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
855 unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
857 return createGlobalVariableHelper(VMContext, Context, Name, LinkageName, F,
858 LineNumber, Ty, isLocalToUnit, Val, Decl, true,
859 [&] (ArrayRef<Value *> Elts) -> MDNode * {
860 MDNode *Node = MDNode::get(VMContext, Elts);
861 AllGVs.push_back(Node);
866 DIGlobalVariable DIBuilder::createTempGlobalVariableFwdDecl(
867 DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
868 unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
870 return createGlobalVariableHelper(VMContext, Context, Name, LinkageName, F,
871 LineNumber, Ty, isLocalToUnit, Val, Decl, false,
872 [&] (ArrayRef<Value *> Elts) {
873 return MDNode::getTemporary(VMContext, Elts);
877 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
878 StringRef Name, DIFile File,
879 unsigned LineNo, DITypeRef Ty,
880 bool AlwaysPreserve, unsigned Flags,
882 DIDescriptor Context(getNonCompileUnitScope(Scope));
883 assert((!Context || Context.isScope()) &&
884 "createLocalVariable should be called with a valid Context");
885 Value *Elts[] = {HeaderBuilder::get(Tag)
887 .concat(LineNo | (ArgNo << 24))
890 getNonCompileUnitScope(Scope), File, Ty};
891 MDNode *Node = MDNode::get(VMContext, Elts);
892 if (AlwaysPreserve) {
893 // The optimizer may remove local variable. If there is an interest
894 // to preserve variable info in such situation then stash it in a
896 DISubprogram Fn(getDISubprogram(Scope));
897 assert(Fn && "Missing subprogram for local variable");
898 PreservedVariables[Fn].push_back(Node);
900 DIVariable RetVar(Node);
901 assert(RetVar.isVariable() &&
902 "createLocalVariable should return a valid DIVariable");
906 DIExpression DIBuilder::createExpression(ArrayRef<int64_t> Addr) {
907 auto Header = HeaderBuilder::get(DW_TAG_expression);
908 for (int64_t I : Addr)
910 Value *Elts[] = {Header.get(VMContext)};
911 return DIExpression(MDNode::get(VMContext, Elts));
914 DIExpression DIBuilder::createPieceExpression(unsigned OffsetInBytes,
915 unsigned SizeInBytes) {
916 int64_t Addr[] = {dwarf::DW_OP_piece, OffsetInBytes, SizeInBytes};
917 return createExpression(Addr);
920 DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
921 StringRef LinkageName, DIFile File,
922 unsigned LineNo, DICompositeType Ty,
923 bool isLocalToUnit, bool isDefinition,
924 unsigned ScopeLine, unsigned Flags,
925 bool isOptimized, Function *Fn,
926 MDNode *TParams, MDNode *Decl) {
927 // dragonegg does not generate identifier for types, so using an empty map
928 // to resolve the context should be fine.
929 DITypeIdentifierMap EmptyMap;
930 return createFunction(Context.resolve(EmptyMap), Name, LinkageName, File,
931 LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
932 Flags, isOptimized, Fn, TParams, Decl);
936 createFunctionHelper(LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
937 StringRef LinkageName, DIFile File, unsigned LineNo,
938 DICompositeType Ty, bool isLocalToUnit, bool isDefinition,
939 unsigned ScopeLine, unsigned Flags, bool isOptimized,
940 Function *Fn, MDNode *TParams, MDNode *Decl, MDNode *Vars,
941 std::function<MDNode *(ArrayRef<Value *>)> CreateFunc) {
942 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
943 "function types should be subroutines");
945 HeaderBuilder::get(dwarf::DW_TAG_subprogram)
950 .concat(isLocalToUnit)
951 .concat(isDefinition)
958 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(), Ty,
959 nullptr, Fn, TParams, Decl, Vars};
961 DISubprogram S(CreateFunc(Elts));
962 assert(S.isSubprogram() &&
963 "createFunction should return a valid DISubprogram");
968 DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
969 StringRef LinkageName, DIFile File,
970 unsigned LineNo, DICompositeType Ty,
971 bool isLocalToUnit, bool isDefinition,
972 unsigned ScopeLine, unsigned Flags,
973 bool isOptimized, Function *Fn,
974 MDNode *TParams, MDNode *Decl) {
975 return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
976 LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
977 Flags, isOptimized, Fn, TParams, Decl,
978 MDNode::getTemporary(VMContext, None),
979 [&] (ArrayRef<Value *> Elts) -> MDNode *{
980 MDNode *Node = MDNode::get(VMContext, Elts);
981 // Create a named metadata so that we
982 // do not lose this mdnode.
984 AllSubprograms.push_back(Node);
990 DIBuilder::createTempFunctionFwdDecl(DIDescriptor Context, StringRef Name,
991 StringRef LinkageName, DIFile File,
992 unsigned LineNo, DICompositeType Ty,
993 bool isLocalToUnit, bool isDefinition,
994 unsigned ScopeLine, unsigned Flags,
995 bool isOptimized, Function *Fn,
996 MDNode *TParams, MDNode *Decl) {
997 return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
998 LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
999 Flags, isOptimized, Fn, TParams, Decl, nullptr,
1000 [&] (ArrayRef<Value *> Elts) {
1001 return MDNode::getTemporary(VMContext, Elts);
1005 DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
1006 StringRef LinkageName, DIFile F,
1007 unsigned LineNo, DICompositeType Ty,
1008 bool isLocalToUnit, bool isDefinition,
1009 unsigned VK, unsigned VIndex,
1010 DIType VTableHolder, unsigned Flags,
1011 bool isOptimized, Function *Fn,
1013 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
1014 "function types should be subroutines");
1015 assert(getNonCompileUnitScope(Context) &&
1016 "Methods should have both a Context and a context that isn't "
1017 "the compile unit.");
1018 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
1021 .concat(LinkageName)
1023 .concat(isLocalToUnit)
1024 .concat(isDefinition)
1028 .concat(isOptimized)
1030 // FIXME: Do we want to use different scope/lines?
1032 F.getFileNode(), DIScope(Context).getRef(), Ty,
1033 VTableHolder.getRef(), Fn, TParam, nullptr, nullptr};
1034 MDNode *Node = MDNode::get(VMContext, Elts);
1036 AllSubprograms.push_back(Node);
1037 DISubprogram S(Node);
1038 assert(S.isSubprogram() && "createMethod should return a valid DISubprogram");
1042 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
1043 DIFile File, unsigned LineNo) {
1044 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_namespace)
1048 File.getFileNode(), getNonCompileUnitScope(Scope)};
1049 DINameSpace R(MDNode::get(VMContext, Elts));
1050 assert(R.Verify() &&
1051 "createNameSpace should return a verifiable DINameSpace");
1055 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
1057 unsigned Discriminator) {
1058 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1059 .concat(Discriminator)
1061 File.getFileNode(), Scope};
1062 DILexicalBlockFile R(MDNode::get(VMContext, Elts));
1065 "createLexicalBlockFile should return a verifiable DILexicalBlockFile");
1069 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
1070 unsigned Line, unsigned Col) {
1071 // FIXME: This isn't thread safe nor the right way to defeat MDNode uniquing.
1072 // I believe the right way is to have a self-referential element in the node.
1073 // Also: why do we bother with line/column - they're not used and the
1074 // documentation (SourceLevelDebugging.rst) claims the line/col are necessary
1075 // for uniquing, yet then we have this other solution (because line/col were
1076 // inadequate) anyway. Remove all 3 and replace them with a self-reference.
1078 // Defeat MDNode uniquing for lexical blocks by using unique id.
1079 static unsigned int unique_id = 0;
1080 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1083 .concat(unique_id++)
1085 File.getFileNode(), getNonCompileUnitScope(Scope)};
1086 DILexicalBlock R(MDNode::get(VMContext, Elts));
1087 assert(R.Verify() &&
1088 "createLexicalBlock should return a verifiable DILexicalBlock");
1092 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1094 Instruction *InsertBefore) {
1095 assert(Storage && "no storage passed to dbg.declare");
1096 assert(VarInfo.isVariable() &&
1097 "empty or invalid DIVariable passed to dbg.declare");
1099 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1101 Value *Args[] = {MDNode::get(Storage->getContext(), Storage), VarInfo, Expr};
1102 return CallInst::Create(DeclareFn, Args, "", InsertBefore);
1105 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1107 BasicBlock *InsertAtEnd) {
1108 assert(Storage && "no storage passed to dbg.declare");
1109 assert(VarInfo.isVariable() &&
1110 "empty or invalid DIVariable passed to dbg.declare");
1112 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1114 Value *Args[] = {MDNode::get(Storage->getContext(), Storage), VarInfo, Expr};
1116 // If this block already has a terminator then insert this intrinsic
1117 // before the terminator.
1118 if (TerminatorInst *T = InsertAtEnd->getTerminator())
1119 return CallInst::Create(DeclareFn, Args, "", T);
1121 return CallInst::Create(DeclareFn, Args, "", InsertAtEnd);
1124 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1127 Instruction *InsertBefore) {
1128 assert(V && "no value passed to dbg.value");
1129 assert(VarInfo.isVariable() &&
1130 "empty or invalid DIVariable passed to dbg.value");
1132 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1134 Value *Args[] = {MDNode::get(V->getContext(), V),
1135 ConstantInt::get(Type::getInt64Ty(V->getContext()), Offset),
1137 return CallInst::Create(ValueFn, Args, "", InsertBefore);
1140 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1143 BasicBlock *InsertAtEnd) {
1144 assert(V && "no value passed to dbg.value");
1145 assert(VarInfo.isVariable() &&
1146 "empty or invalid DIVariable passed to dbg.value");
1148 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1150 Value *Args[] = {MDNode::get(V->getContext(), V),
1151 ConstantInt::get(Type::getInt64Ty(V->getContext()), Offset),
1153 return CallInst::Create(ValueFn, Args, "", InsertAtEnd);