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 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
196 Context, Decl.getRef(), Line, Name,
200 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
201 DIImportedEntity Imp,
202 unsigned Line, StringRef Name) {
203 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
204 Context, Imp, Line, Name, AllImportedModules);
207 DIFile DIBuilder::createFile(StringRef Filename, StringRef Directory) {
208 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_file_type).get(VMContext),
209 createFilePathPair(VMContext, Filename, Directory)};
210 return DIFile(MDNode::get(VMContext, Elts));
213 DIEnumerator DIBuilder::createEnumerator(StringRef Name, int64_t Val) {
214 assert(!Name.empty() && "Unable to create enumerator without name");
216 HeaderBuilder::get(dwarf::DW_TAG_enumerator).concat(Name).concat(Val).get(
218 return DIEnumerator(MDNode::get(VMContext, Elts));
221 DIBasicType DIBuilder::createUnspecifiedType(StringRef Name) {
222 assert(!Name.empty() && "Unable to create type without name");
223 // Unspecified types are encoded in DIBasicType format. Line number, filename,
224 // size, alignment, offset and flags are always empty here.
226 HeaderBuilder::get(dwarf::DW_TAG_unspecified_type)
238 return DIBasicType(MDNode::get(VMContext, Elts));
241 DIBasicType DIBuilder::createNullPtrType() {
242 return createUnspecifiedType("decltype(nullptr)");
246 DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
247 uint64_t AlignInBits, unsigned Encoding) {
248 assert(!Name.empty() && "Unable to create type without name");
249 // Basic types are encoded in DIBasicType format. Line number, filename,
250 // offset and flags are always empty here.
252 HeaderBuilder::get(dwarf::DW_TAG_base_type)
264 return DIBasicType(MDNode::get(VMContext, Elts));
267 DIDerivedType DIBuilder::createQualifiedType(unsigned Tag, DIType FromTy) {
268 // Qualified types are encoded in DIDerivedType format.
269 Value *Elts[] = {HeaderBuilder::get(Tag)
270 .concat(StringRef()) // Name
280 return DIDerivedType(MDNode::get(VMContext, Elts));
284 DIBuilder::createPointerType(DIType PointeeTy, uint64_t SizeInBits,
285 uint64_t AlignInBits, StringRef Name) {
286 // Pointer types are encoded in DIDerivedType format.
287 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_pointer_type)
298 return DIDerivedType(MDNode::get(VMContext, Elts));
301 DIDerivedType DIBuilder::createMemberPointerType(DIType PointeeTy,
303 // Pointer types are encoded in DIDerivedType format.
304 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_ptr_to_member_type)
314 PointeeTy.getRef(), Base.getRef()};
315 return DIDerivedType(MDNode::get(VMContext, Elts));
318 DIDerivedType DIBuilder::createReferenceType(unsigned Tag, DIType RTy) {
319 assert(RTy.isType() && "Unable to create reference type");
320 // References are encoded in DIDerivedType format.
321 Value *Elts[] = {HeaderBuilder::get(Tag)
322 .concat(StringRef()) // Name
332 return DIDerivedType(MDNode::get(VMContext, Elts));
335 DIDerivedType DIBuilder::createTypedef(DIType Ty, StringRef Name, DIFile File,
336 unsigned LineNo, DIDescriptor Context) {
337 // typedefs are encoded in DIDerivedType format.
338 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_typedef)
347 DIScope(getNonCompileUnitScope(Context)).getRef(),
349 return DIDerivedType(MDNode::get(VMContext, Elts));
352 DIDerivedType DIBuilder::createFriend(DIType Ty, DIType FriendTy) {
353 // typedefs are encoded in DIDerivedType format.
354 assert(Ty.isType() && "Invalid type!");
355 assert(FriendTy.isType() && "Invalid friend type!");
356 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_friend)
357 .concat(StringRef()) // Name
364 nullptr, Ty.getRef(), FriendTy.getRef()};
365 return DIDerivedType(MDNode::get(VMContext, Elts));
368 DIDerivedType DIBuilder::createInheritance(DIType Ty, DIType BaseTy,
371 assert(Ty.isType() && "Unable to create inheritance");
372 // TAG_inheritance is encoded in DIDerivedType format.
373 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_inheritance)
374 .concat(StringRef()) // Name
381 nullptr, Ty.getRef(), BaseTy.getRef()};
382 return DIDerivedType(MDNode::get(VMContext, Elts));
385 DIDerivedType DIBuilder::createMemberType(DIDescriptor Scope, StringRef Name,
386 DIFile File, unsigned LineNumber,
388 uint64_t AlignInBits,
389 uint64_t OffsetInBits, unsigned Flags,
391 // TAG_member is encoded in DIDerivedType format.
392 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
397 .concat(OffsetInBits)
401 DIScope(getNonCompileUnitScope(Scope)).getRef(),
403 return DIDerivedType(MDNode::get(VMContext, Elts));
407 DIBuilder::createStaticMemberType(DIDescriptor Scope, StringRef Name,
408 DIFile File, unsigned LineNumber,
409 DIType Ty, unsigned Flags,
411 // TAG_member is encoded in DIDerivedType format.
412 Flags |= DIDescriptor::FlagStaticMember;
413 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
422 DIScope(getNonCompileUnitScope(Scope)).getRef(), Ty.getRef(),
424 return DIDerivedType(MDNode::get(VMContext, Elts));
427 DIDerivedType DIBuilder::createObjCIVar(StringRef Name, DIFile File,
430 uint64_t AlignInBits,
431 uint64_t OffsetInBits, unsigned Flags,
432 DIType Ty, MDNode *PropertyNode) {
433 // TAG_member is encoded in DIDerivedType format.
434 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
439 .concat(OffsetInBits)
442 File.getFileNode(), getNonCompileUnitScope(File), Ty,
444 return DIDerivedType(MDNode::get(VMContext, Elts));
448 DIBuilder::createObjCProperty(StringRef Name, DIFile File, unsigned LineNumber,
449 StringRef GetterName, StringRef SetterName,
450 unsigned PropertyAttributes, DIType Ty) {
451 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_APPLE_property)
456 .concat(PropertyAttributes)
459 return DIObjCProperty(MDNode::get(VMContext, Elts));
462 DITemplateTypeParameter
463 DIBuilder::createTemplateTypeParameter(DIDescriptor Context, StringRef Name,
464 DIType Ty, MDNode *File, unsigned LineNo,
466 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_template_type_parameter)
471 DIScope(getNonCompileUnitScope(Context)).getRef(),
473 return DITemplateTypeParameter(MDNode::get(VMContext, Elts));
476 DITemplateValueParameter
477 DIBuilder::createTemplateValueParameter(unsigned Tag, DIDescriptor Context,
478 StringRef Name, DIType Ty,
479 Value *Val, MDNode *File,
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, Value *Val,
493 MDNode *File, unsigned LineNo,
495 return createTemplateValueParameter(dwarf::DW_TAG_template_value_parameter,
496 Context, Name, Ty, Val, File, LineNo,
500 DITemplateValueParameter
501 DIBuilder::createTemplateTemplateParameter(DIDescriptor Context, StringRef Name,
502 DIType Ty, StringRef Val,
503 MDNode *File, unsigned LineNo,
505 return createTemplateValueParameter(
506 dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
507 MDString::get(VMContext, Val), File, LineNo, ColumnNo);
510 DITemplateValueParameter
511 DIBuilder::createTemplateParameterPack(DIDescriptor Context, StringRef Name,
512 DIType Ty, DIArray Val,
513 MDNode *File, unsigned LineNo,
515 return createTemplateValueParameter(dwarf::DW_TAG_GNU_template_parameter_pack,
516 Context, Name, Ty, Val, File, LineNo,
520 DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
521 DIFile File, unsigned LineNumber,
523 uint64_t AlignInBits,
524 uint64_t OffsetInBits,
525 unsigned Flags, DIType DerivedFrom,
528 MDNode *TemplateParams,
529 StringRef UniqueIdentifier) {
530 assert((!Context || Context.isScope() || Context.isType()) &&
531 "createClassType should be called with a valid Context");
532 // TAG_class_type is encoded in DICompositeType format.
534 HeaderBuilder::get(dwarf::DW_TAG_class_type)
539 .concat(OffsetInBits)
543 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
544 DerivedFrom.getRef(), Elements, VTableHolder.getRef(), TemplateParams,
545 UniqueIdentifier.empty() ? nullptr
546 : MDString::get(VMContext, UniqueIdentifier)};
547 DICompositeType R(MDNode::get(VMContext, Elts));
548 assert(R.isCompositeType() &&
549 "createClassType should return a DICompositeType");
550 if (!UniqueIdentifier.empty())
555 DICompositeType DIBuilder::createStructType(DIDescriptor Context,
556 StringRef Name, DIFile File,
559 uint64_t AlignInBits,
560 unsigned Flags, DIType DerivedFrom,
562 unsigned RunTimeLang,
564 StringRef UniqueIdentifier) {
565 // TAG_structure_type is encoded in DICompositeType format.
567 HeaderBuilder::get(dwarf::DW_TAG_structure_type)
576 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
577 DerivedFrom.getRef(), Elements, VTableHolder.getRef(), nullptr,
578 UniqueIdentifier.empty() ? nullptr
579 : MDString::get(VMContext, UniqueIdentifier)};
580 DICompositeType R(MDNode::get(VMContext, Elts));
581 assert(R.isCompositeType() &&
582 "createStructType should return a DICompositeType");
583 if (!UniqueIdentifier.empty())
588 DICompositeType DIBuilder::createUnionType(DIDescriptor Scope, StringRef Name,
589 DIFile File, unsigned LineNumber,
591 uint64_t AlignInBits, unsigned Flags,
593 unsigned RunTimeLang,
594 StringRef UniqueIdentifier) {
595 // TAG_union_type is encoded in DICompositeType format.
597 HeaderBuilder::get(dwarf::DW_TAG_union_type)
606 File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
607 nullptr, Elements, nullptr, nullptr,
608 UniqueIdentifier.empty() ? nullptr
609 : MDString::get(VMContext, UniqueIdentifier)};
610 DICompositeType R(MDNode::get(VMContext, Elts));
611 if (!UniqueIdentifier.empty())
616 DISubroutineType DIBuilder::createSubroutineType(DIFile File,
617 DITypeArray ParameterTypes,
619 // TAG_subroutine_type is encoded in DICompositeType format.
621 HeaderBuilder::get(dwarf::DW_TAG_subroutine_type)
627 .concat(Flags) // Flags
630 nullptr, nullptr, nullptr, ParameterTypes, nullptr, nullptr,
631 nullptr // Type Identifer
633 return DISubroutineType(MDNode::get(VMContext, Elts));
636 DICompositeType DIBuilder::createEnumerationType(
637 DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
638 uint64_t SizeInBits, uint64_t AlignInBits, DIArray Elements,
639 DIType UnderlyingType, StringRef UniqueIdentifier) {
640 // TAG_enumeration_type is encoded in DICompositeType format.
642 HeaderBuilder::get(dwarf::DW_TAG_enumeration_type)
651 File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
652 UnderlyingType.getRef(), Elements, nullptr, nullptr,
653 UniqueIdentifier.empty() ? nullptr
654 : MDString::get(VMContext, UniqueIdentifier)};
655 DICompositeType CTy(MDNode::get(VMContext, Elts));
656 AllEnumTypes.push_back(CTy);
657 if (!UniqueIdentifier.empty())
662 DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
663 DIType Ty, DIArray Subscripts) {
664 // TAG_array_type is encoded in DICompositeType format.
666 HeaderBuilder::get(dwarf::DW_TAG_array_type)
675 nullptr, // Filename/Directory,
677 Ty.getRef(), Subscripts, nullptr, nullptr,
678 nullptr // Type Identifer
680 return DICompositeType(MDNode::get(VMContext, Elts));
683 DICompositeType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
684 DIType Ty, DIArray Subscripts) {
685 // A vector is an array type with the FlagVector flag applied.
687 HeaderBuilder::get(dwarf::DW_TAG_array_type)
693 .concat(DIType::FlagVector)
696 nullptr, // Filename/Directory,
698 Ty.getRef(), Subscripts, nullptr, nullptr,
699 nullptr // Type Identifer
701 return DICompositeType(MDNode::get(VMContext, Elts));
704 static HeaderBuilder setTypeFlagsInHeader(StringRef Header,
705 unsigned FlagsToSet) {
706 DIHeaderFieldIterator I(Header);
710 if (I->getAsInteger(0, Flags))
714 return HeaderBuilder(Twine(I.getPrefix())).concat(Flags).concat(
718 static DIType createTypeWithFlags(LLVMContext &Context, DIType Ty,
719 unsigned FlagsToSet) {
720 SmallVector<Value *, 9> Elts;
722 assert(N && "Unexpected input DIType!");
723 // Update header field.
724 Elts.push_back(setTypeFlagsInHeader(Ty.getHeader(), FlagsToSet).get(Context));
725 for (unsigned I = 1, E = N->getNumOperands(); I != E; ++I)
726 Elts.push_back(N->getOperand(I));
728 return DIType(MDNode::get(Context, Elts));
731 DIType DIBuilder::createArtificialType(DIType Ty) {
732 if (Ty.isArtificial())
734 return createTypeWithFlags(VMContext, Ty, DIType::FlagArtificial);
737 DIType DIBuilder::createObjectPointerType(DIType Ty) {
738 if (Ty.isObjectPointer())
740 unsigned Flags = DIType::FlagObjectPointer | DIType::FlagArtificial;
741 return createTypeWithFlags(VMContext, Ty, Flags);
744 void DIBuilder::retainType(DIType T) {
745 AllRetainTypes.push_back(TrackingVH<MDNode>(T));
748 DIBasicType DIBuilder::createUnspecifiedParameter() {
749 return DIBasicType();
753 DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIDescriptor Scope,
754 DIFile F, unsigned Line, unsigned RuntimeLang,
755 uint64_t SizeInBits, uint64_t AlignInBits,
756 StringRef UniqueIdentifier) {
757 // Create a temporary MDNode.
759 HeaderBuilder::get(Tag)
765 .concat(DIDescriptor::FlagFwdDecl)
768 F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
770 nullptr, // TemplateParams
771 UniqueIdentifier.empty() ? nullptr
772 : MDString::get(VMContext, UniqueIdentifier)};
773 MDNode *Node = MDNode::get(VMContext, Elts);
774 DICompositeType RetTy(Node);
775 assert(RetTy.isCompositeType() &&
776 "createForwardDecl result should be a DIType");
777 if (!UniqueIdentifier.empty())
782 DICompositeType DIBuilder::createReplaceableForwardDecl(
783 unsigned Tag, StringRef Name, DIDescriptor Scope, DIFile F, unsigned Line,
784 unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
785 StringRef UniqueIdentifier) {
786 // Create a temporary MDNode.
788 HeaderBuilder::get(Tag)
794 .concat(DIDescriptor::FlagFwdDecl)
797 F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
799 nullptr, // TemplateParams
800 UniqueIdentifier.empty() ? nullptr
801 : MDString::get(VMContext, UniqueIdentifier)};
802 MDNode *Node = MDNode::getTemporary(VMContext, Elts);
803 DICompositeType RetTy(Node);
804 assert(RetTy.isCompositeType() &&
805 "createReplaceableForwardDecl result should be a DIType");
806 if (!UniqueIdentifier.empty())
811 DIArray DIBuilder::getOrCreateArray(ArrayRef<Value *> Elements) {
812 return DIArray(MDNode::get(VMContext, Elements));
815 DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Value *> Elements) {
816 SmallVector<llvm::Value *, 16> Elts;
817 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
818 if (Elements[i] && isa<MDNode>(Elements[i]))
819 Elts.push_back(DIType(cast<MDNode>(Elements[i])).getRef());
821 Elts.push_back(Elements[i]);
823 return DITypeArray(MDNode::get(VMContext, Elts));
826 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
827 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subrange_type)
832 return DISubrange(MDNode::get(VMContext, Elts));
835 static DIGlobalVariable
836 createGlobalVariableHelper(LLVMContext &VMContext, DIDescriptor Context,
837 StringRef Name, StringRef LinkageName, DIFile F,
838 unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit,
839 Value *Val, MDNode *Decl, bool isDefinition,
840 std::function<MDNode *(ArrayRef<Value *>)> CreateFunc) {
841 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_variable)
846 .concat(isLocalToUnit)
847 .concat(isDefinition)
849 getNonCompileUnitScope(Context), F, Ty, Val,
852 return DIGlobalVariable(CreateFunc(Elts));
855 DIGlobalVariable DIBuilder::createGlobalVariable(DIDescriptor Context,
857 StringRef LinkageName,
858 DIFile F, unsigned LineNumber,
861 Value *Val, MDNode *Decl) {
862 return createGlobalVariableHelper(VMContext, Context, Name, LinkageName, F,
863 LineNumber, Ty, isLocalToUnit, Val, Decl, true,
864 [&] (ArrayRef<Value *> Elts) -> MDNode * {
865 MDNode *Node = MDNode::get(VMContext, Elts);
866 AllGVs.push_back(Node);
872 DIBuilder::createTempGlobalVariableFwdDecl(DIDescriptor Context,
874 StringRef LinkageName,
875 DIFile F, unsigned LineNumber,
878 Value *Val, MDNode *Decl) {
879 return createGlobalVariableHelper(VMContext, Context, Name, LinkageName, F,
880 LineNumber, Ty, isLocalToUnit, Val, Decl, false,
881 [&] (ArrayRef<Value *> Elts) {
882 return MDNode::getTemporary(VMContext, Elts);
886 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
887 StringRef Name, DIFile File,
888 unsigned LineNo, DITypeRef Ty,
889 bool AlwaysPreserve, unsigned Flags,
891 DIDescriptor Context(getNonCompileUnitScope(Scope));
892 assert((!Context || Context.isScope()) &&
893 "createLocalVariable should be called with a valid Context");
894 Value *Elts[] = {HeaderBuilder::get(Tag)
896 .concat(LineNo | (ArgNo << 24))
899 getNonCompileUnitScope(Scope), File, Ty};
900 MDNode *Node = MDNode::get(VMContext, Elts);
901 if (AlwaysPreserve) {
902 // The optimizer may remove local variable. If there is an interest
903 // to preserve variable info in such situation then stash it in a
905 DISubprogram Fn(getDISubprogram(Scope));
906 assert(Fn && "Missing subprogram for local variable");
907 PreservedVariables[Fn].push_back(Node);
909 DIVariable RetVar(Node);
910 assert(RetVar.isVariable() &&
911 "createLocalVariable should return a valid DIVariable");
915 DIExpression DIBuilder::createExpression(ArrayRef<int64_t> Addr) {
916 auto Header = HeaderBuilder::get(DW_TAG_expression);
917 for (int64_t I : Addr)
919 Value *Elts[] = {Header.get(VMContext)};
920 return DIExpression(MDNode::get(VMContext, Elts));
923 DIExpression DIBuilder::createPieceExpression(unsigned OffsetInBytes,
924 unsigned SizeInBytes) {
925 int64_t Addr[] = {dwarf::DW_OP_piece, OffsetInBytes, SizeInBytes};
926 return createExpression(Addr);
929 DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
930 StringRef LinkageName, DIFile File,
931 unsigned LineNo, DICompositeType Ty,
932 bool isLocalToUnit, bool isDefinition,
933 unsigned ScopeLine, unsigned Flags,
934 bool isOptimized, Function *Fn,
935 MDNode *TParams, MDNode *Decl) {
936 // dragonegg does not generate identifier for types, so using an empty map
937 // to resolve the context should be fine.
938 DITypeIdentifierMap EmptyMap;
939 return createFunction(Context.resolve(EmptyMap), Name, LinkageName, File,
940 LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
941 Flags, isOptimized, Fn, TParams, Decl);
945 createFunctionHelper(LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
946 StringRef LinkageName, DIFile File, unsigned LineNo,
947 DICompositeType Ty, bool isLocalToUnit, bool isDefinition,
948 unsigned ScopeLine, unsigned Flags, bool isOptimized,
949 Function *Fn, MDNode *TParams, MDNode *Decl,
950 std::function<MDNode *(ArrayRef<Value *>)> CreateFunc) {
951 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
952 "function types should be subroutines");
953 Value *TElts[] = {HeaderBuilder::get(DW_TAG_base_type).get(VMContext)};
955 HeaderBuilder::get(dwarf::DW_TAG_subprogram)
960 .concat(isLocalToUnit)
961 .concat(isDefinition)
968 File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(), Ty,
969 nullptr, Fn, TParams, Decl, MDNode::getTemporary(VMContext, TElts)};
971 DISubprogram S(CreateFunc(Elts));
972 assert(S.isSubprogram() &&
973 "createFunction should return a valid DISubprogram");
978 DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
979 StringRef LinkageName, DIFile File,
980 unsigned LineNo, DICompositeType Ty,
981 bool isLocalToUnit, bool isDefinition,
982 unsigned ScopeLine, unsigned Flags,
983 bool isOptimized, Function *Fn,
984 MDNode *TParams, MDNode *Decl) {
985 return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
986 LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
987 Flags, isOptimized, Fn, TParams, Decl,
988 [&] (ArrayRef<Value *> Elts) -> MDNode *{
989 MDNode *Node = MDNode::get(VMContext, Elts);
990 // Create a named metadata so that we
991 // do not lose this mdnode.
993 AllSubprograms.push_back(Node);
999 DIBuilder::createTempFunctionFwdDecl(DIDescriptor Context, StringRef Name,
1000 StringRef LinkageName, DIFile File,
1001 unsigned LineNo, DICompositeType Ty,
1002 bool isLocalToUnit, bool isDefinition,
1003 unsigned ScopeLine, unsigned Flags,
1004 bool isOptimized, Function *Fn,
1005 MDNode *TParams, MDNode *Decl) {
1006 return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1007 LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
1008 Flags, isOptimized, Fn, TParams, Decl,
1009 [&] (ArrayRef<Value *> Elts) {
1010 return MDNode::getTemporary(VMContext, Elts);
1014 DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
1015 StringRef LinkageName, DIFile F,
1016 unsigned LineNo, DICompositeType Ty,
1017 bool isLocalToUnit, bool isDefinition,
1018 unsigned VK, unsigned VIndex,
1019 DIType VTableHolder, unsigned Flags,
1020 bool isOptimized, Function *Fn,
1022 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
1023 "function types should be subroutines");
1024 assert(getNonCompileUnitScope(Context) &&
1025 "Methods should have both a Context and a context that isn't "
1026 "the compile unit.");
1027 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
1030 .concat(LinkageName)
1032 .concat(isLocalToUnit)
1033 .concat(isDefinition)
1037 .concat(isOptimized)
1039 // FIXME: Do we want to use different scope/lines?
1041 F.getFileNode(), DIScope(Context).getRef(), Ty,
1042 VTableHolder.getRef(), Fn, TParam, nullptr, nullptr};
1043 MDNode *Node = MDNode::get(VMContext, Elts);
1045 AllSubprograms.push_back(Node);
1046 DISubprogram S(Node);
1047 assert(S.isSubprogram() && "createMethod should return a valid DISubprogram");
1051 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
1052 DIFile File, unsigned LineNo) {
1053 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_namespace)
1057 File.getFileNode(), getNonCompileUnitScope(Scope)};
1058 DINameSpace R(MDNode::get(VMContext, Elts));
1059 assert(R.Verify() &&
1060 "createNameSpace should return a verifiable DINameSpace");
1064 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
1066 unsigned Discriminator) {
1067 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1068 .concat(Discriminator)
1070 File.getFileNode(), Scope};
1071 DILexicalBlockFile R(MDNode::get(VMContext, Elts));
1074 "createLexicalBlockFile should return a verifiable DILexicalBlockFile");
1078 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
1079 unsigned Line, unsigned Col) {
1080 // FIXME: This isn't thread safe nor the right way to defeat MDNode uniquing.
1081 // I believe the right way is to have a self-referential element in the node.
1082 // Also: why do we bother with line/column - they're not used and the
1083 // documentation (SourceLevelDebugging.rst) claims the line/col are necessary
1084 // for uniquing, yet then we have this other solution (because line/col were
1085 // inadequate) anyway. Remove all 3 and replace them with a self-reference.
1087 // Defeat MDNode uniquing for lexical blocks by using unique id.
1088 static unsigned int unique_id = 0;
1089 Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1092 .concat(unique_id++)
1094 File.getFileNode(), getNonCompileUnitScope(Scope)};
1095 DILexicalBlock R(MDNode::get(VMContext, Elts));
1096 assert(R.Verify() &&
1097 "createLexicalBlock should return a verifiable DILexicalBlock");
1101 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1103 Instruction *InsertBefore) {
1104 assert(Storage && "no storage passed to dbg.declare");
1105 assert(VarInfo.isVariable() &&
1106 "empty or invalid DIVariable passed to dbg.declare");
1108 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1110 Value *Args[] = {MDNode::get(Storage->getContext(), Storage), VarInfo, Expr};
1111 return CallInst::Create(DeclareFn, Args, "", InsertBefore);
1114 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1116 BasicBlock *InsertAtEnd) {
1117 assert(Storage && "no storage passed to dbg.declare");
1118 assert(VarInfo.isVariable() &&
1119 "empty or invalid DIVariable passed to dbg.declare");
1121 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1123 Value *Args[] = {MDNode::get(Storage->getContext(), Storage), VarInfo, Expr};
1125 // If this block already has a terminator then insert this intrinsic
1126 // before the terminator.
1127 if (TerminatorInst *T = InsertAtEnd->getTerminator())
1128 return CallInst::Create(DeclareFn, Args, "", T);
1130 return CallInst::Create(DeclareFn, Args, "", InsertAtEnd);
1133 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1136 Instruction *InsertBefore) {
1137 assert(V && "no value passed to dbg.value");
1138 assert(VarInfo.isVariable() &&
1139 "empty or invalid DIVariable passed to dbg.value");
1141 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1143 Value *Args[] = {MDNode::get(V->getContext(), V),
1144 ConstantInt::get(Type::getInt64Ty(V->getContext()), Offset),
1146 return CallInst::Create(ValueFn, Args, "", InsertBefore);
1149 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1152 BasicBlock *InsertAtEnd) {
1153 assert(V && "no value passed to dbg.value");
1154 assert(VarInfo.isVariable() &&
1155 "empty or invalid DIVariable passed to dbg.value");
1157 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1159 Value *Args[] = {MDNode::get(V->getContext(), V),
1160 ConstantInt::get(Type::getInt64Ty(V->getContext()), Offset),
1162 return CallInst::Create(ValueFn, Args, "", InsertAtEnd);