1 //===--- DIBuilder.cpp - Debug Information Builder ------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the DIBuilder.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/IR/DIBuilder.h"
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/IR/Constants.h"
17 #include "llvm/IR/DebugInfo.h"
18 #include "llvm/IR/IntrinsicInst.h"
19 #include "llvm/IR/Module.h"
20 #include "llvm/Support/Debug.h"
21 #include "llvm/Support/Dwarf.h"
24 using namespace llvm::dwarf;
28 /// \brief Whether there are any fields yet.
30 /// Note that this is not equivalent to \c Chars.empty(), since \a concat()
31 /// may have been called already with an empty string.
33 SmallVector<char, 256> Chars;
36 HeaderBuilder() : IsEmpty(true) {}
37 HeaderBuilder(const HeaderBuilder &X) : IsEmpty(X.IsEmpty), Chars(X.Chars) {}
38 HeaderBuilder(HeaderBuilder &&X)
39 : IsEmpty(X.IsEmpty), Chars(std::move(X.Chars)) {}
41 template <class Twineable> HeaderBuilder &concat(Twineable &&X) {
46 Twine(X).toVector(Chars);
50 MDString *get(LLVMContext &Context) const {
51 return MDString::get(Context, StringRef(Chars.begin(), Chars.size()));
54 static HeaderBuilder get(unsigned Tag) {
55 return HeaderBuilder().concat("0x" + Twine::utohexstr(Tag));
60 DIBuilder::DIBuilder(Module &m, bool AllowUnresolvedNodes)
61 : M(m), VMContext(M.getContext()), TempEnumTypes(nullptr),
62 TempRetainTypes(nullptr), TempSubprograms(nullptr), TempGVs(nullptr),
63 DeclareFn(nullptr), ValueFn(nullptr),
64 AllowUnresolvedNodes(AllowUnresolvedNodes) {}
66 void DIBuilder::trackIfUnresolved(MDNode *N) {
72 assert(AllowUnresolvedNodes && "Cannot handle unresolved nodes");
73 UnresolvedNodes.emplace_back(N);
76 void DIBuilder::finalize() {
77 DIArray Enums = getOrCreateArray(AllEnumTypes);
78 TempEnumTypes->replaceAllUsesWith(Enums.get());
80 SmallVector<Metadata *, 16> RetainValues;
81 // Declarations and definitions of the same type may be retained. Some
82 // clients RAUW these pairs, leaving duplicates in the retained types
83 // list. Use a set to remove the duplicates while we transform the
84 // TrackingVHs back into Values.
85 SmallPtrSet<Metadata *, 16> RetainSet;
86 for (unsigned I = 0, E = AllRetainTypes.size(); I < E; I++)
87 if (RetainSet.insert(AllRetainTypes[I]).second)
88 RetainValues.push_back(AllRetainTypes[I]);
89 DIArray RetainTypes = getOrCreateArray(RetainValues);
90 TempRetainTypes->replaceAllUsesWith(RetainTypes.get());
92 DIArray SPs = getOrCreateArray(AllSubprograms);
93 TempSubprograms->replaceAllUsesWith(SPs.get());
94 for (unsigned i = 0, e = SPs.size(); i != e; ++i) {
95 DISubprogram SP = cast<MDSubprogram>(SPs[i]);
96 if (MDTuple *Temp = SP.getVariables().get()) {
97 const auto &PV = PreservedVariables.lookup(SP);
98 SmallVector<Metadata *, 4> Variables(PV.begin(), PV.end());
99 DIArray AV = getOrCreateArray(Variables);
100 TempMDTuple(Temp)->replaceAllUsesWith(AV.get());
104 DIArray GVs = getOrCreateArray(AllGVs);
105 TempGVs->replaceAllUsesWith(GVs.get());
107 SmallVector<Metadata *, 16> RetainValuesI(AllImportedModules.begin(),
108 AllImportedModules.end());
109 DIArray IMs = getOrCreateArray(RetainValuesI);
110 TempImportedModules->replaceAllUsesWith(IMs.get());
112 // Now that all temp nodes have been replaced or deleted, resolve remaining
114 for (const auto &N : UnresolvedNodes)
115 if (N && !N->isResolved())
117 UnresolvedNodes.clear();
119 // Can't handle unresolved nodes anymore.
120 AllowUnresolvedNodes = false;
123 /// If N is compile unit return NULL otherwise return N.
124 static MDScope *getNonCompileUnitScope(MDNode *N) {
125 if (!N || isa<MDCompileUnit>(N))
127 return cast<MDScope>(N);
130 DICompileUnit DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename,
132 StringRef Producer, bool isOptimized,
133 StringRef Flags, unsigned RunTimeVer,
135 DebugEmissionKind Kind,
136 bool EmitDebugInfo) {
138 assert(((Lang <= dwarf::DW_LANG_Fortran08 && Lang >= dwarf::DW_LANG_C89) ||
139 (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) &&
140 "Invalid Language tag");
141 assert(!Filename.empty() &&
142 "Unable to create compile unit without filename");
144 // TODO: Once we make MDCompileUnit distinct, stop using temporaries here
145 // (just start with operands assigned to nullptr).
146 TempEnumTypes = MDTuple::getTemporary(VMContext, None);
147 TempRetainTypes = MDTuple::getTemporary(VMContext, None);
148 TempSubprograms = MDTuple::getTemporary(VMContext, None);
149 TempGVs = MDTuple::getTemporary(VMContext, None);
150 TempImportedModules = MDTuple::getTemporary(VMContext, None);
152 // TODO: Switch to getDistinct(). We never want to merge compile units based
154 MDCompileUnit *CUNode = MDCompileUnit::get(
155 VMContext, Lang, MDFile::get(VMContext, Filename, Directory), Producer,
156 isOptimized, Flags, RunTimeVer, SplitName, Kind, TempEnumTypes.get(),
157 TempRetainTypes.get(), TempSubprograms.get(), TempGVs.get(),
158 TempImportedModules.get());
160 // Create a named metadata so that it is easier to find cu in a module.
161 // Note that we only generate this when the caller wants to actually
162 // emit debug information. When we are only interested in tracking
163 // source line locations throughout the backend, we prevent codegen from
164 // emitting debug info in the final output by not generating llvm.dbg.cu.
166 NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
167 NMD->addOperand(CUNode);
170 trackIfUnresolved(CUNode);
174 static DIImportedEntity
175 createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope Context,
176 Metadata *NS, unsigned Line, StringRef Name,
177 SmallVectorImpl<TrackingMDNodeRef> &AllImportedModules) {
179 MDImportedEntity::get(C, Tag, Context, DebugNodeRef(NS), Line, Name);
180 AllImportedModules.emplace_back(M.get());
184 DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
187 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
188 Context, NS, Line, StringRef(), AllImportedModules);
191 DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
194 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
195 Context, NS, Line, StringRef(), AllImportedModules);
198 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
202 // Make sure to use the unique identifier based metadata reference for
203 // types that have one.
204 return ::createImportedModule(
205 VMContext, dwarf::DW_TAG_imported_declaration, Context,
206 DebugNodeRef::get(cast_or_null<DebugNode>(Decl.get())), Line, Name,
210 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
211 DIImportedEntity Imp,
212 unsigned Line, StringRef Name) {
213 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
214 Context, Imp, Line, Name, AllImportedModules);
217 DIFile DIBuilder::createFile(StringRef Filename, StringRef Directory) {
218 return MDFile::get(VMContext, Filename, Directory);
221 DIEnumerator DIBuilder::createEnumerator(StringRef Name, int64_t Val) {
222 assert(!Name.empty() && "Unable to create enumerator without name");
223 return MDEnumerator::get(VMContext, Val, Name);
226 DIBasicType DIBuilder::createUnspecifiedType(StringRef Name) {
227 assert(!Name.empty() && "Unable to create type without name");
228 return MDBasicType::get(VMContext, dwarf::DW_TAG_unspecified_type, Name);
231 DIBasicType DIBuilder::createNullPtrType() {
232 return createUnspecifiedType("decltype(nullptr)");
236 DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
237 uint64_t AlignInBits, unsigned Encoding) {
238 assert(!Name.empty() && "Unable to create type without name");
239 return MDBasicType::get(VMContext, dwarf::DW_TAG_base_type, Name, SizeInBits,
240 AlignInBits, Encoding);
243 DIDerivedType DIBuilder::createQualifiedType(unsigned Tag, DIType FromTy) {
244 return MDDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr,
245 MDTypeRef::get(FromTy), 0, 0, 0, 0);
249 DIBuilder::createPointerType(DIType PointeeTy, uint64_t SizeInBits,
250 uint64_t AlignInBits, StringRef Name) {
251 // FIXME: Why is there a name here?
252 return MDDerivedType::get(VMContext, dwarf::DW_TAG_pointer_type, Name,
253 nullptr, 0, nullptr, MDTypeRef::get(PointeeTy),
254 SizeInBits, AlignInBits, 0, 0);
258 DIBuilder::createMemberPointerType(DIType PointeeTy, DIType Base,
259 uint64_t SizeInBits, uint64_t AlignInBits) {
260 return MDDerivedType::get(VMContext, dwarf::DW_TAG_ptr_to_member_type, "",
261 nullptr, 0, nullptr, MDTypeRef::get(PointeeTy),
262 SizeInBits, AlignInBits, 0, 0, MDTypeRef::get(Base));
265 DIDerivedType DIBuilder::createReferenceType(unsigned Tag, DIType RTy) {
266 assert(RTy && "Unable to create reference type");
267 return MDDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr,
268 MDTypeRef::get(RTy), 0, 0, 0, 0);
271 DIDerivedType DIBuilder::createTypedef(DIType Ty, StringRef Name, DIFile File,
272 unsigned LineNo, DIDescriptor Context) {
273 return MDDerivedType::get(
274 VMContext, dwarf::DW_TAG_typedef, Name, File, LineNo,
275 MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))),
276 MDTypeRef::get(Ty), 0, 0, 0, 0);
279 DIDerivedType DIBuilder::createFriend(DIType Ty, DIType FriendTy) {
280 // typedefs are encoded in DIDerivedType format.
281 assert(Ty && "Invalid type!");
282 assert(FriendTy && "Invalid friend type!");
283 return MDDerivedType::get(VMContext, dwarf::DW_TAG_friend, "", nullptr, 0,
284 MDTypeRef::get(Ty), MDTypeRef::get(FriendTy), 0, 0,
288 DIDerivedType DIBuilder::createInheritance(DIType Ty, DIType BaseTy,
291 assert(Ty && "Unable to create inheritance");
292 return MDDerivedType::get(VMContext, dwarf::DW_TAG_inheritance, "", nullptr,
293 0, MDTypeRef::get(Ty), MDTypeRef::get(BaseTy), 0, 0,
297 DIDerivedType DIBuilder::createMemberType(DIDescriptor Scope, StringRef Name,
298 DIFile File, unsigned LineNumber,
300 uint64_t AlignInBits,
301 uint64_t OffsetInBits, unsigned Flags,
303 return MDDerivedType::get(
304 VMContext, dwarf::DW_TAG_member, Name, File, LineNumber,
305 MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))),
306 MDTypeRef::get(Ty), SizeInBits, AlignInBits, OffsetInBits, Flags);
309 static ConstantAsMetadata *getConstantOrNull(Constant *C) {
311 return ConstantAsMetadata::get(C);
315 DIDerivedType DIBuilder::createStaticMemberType(DIDescriptor Scope,
316 StringRef Name, DIFile File,
317 unsigned LineNumber, DIType Ty,
319 llvm::Constant *Val) {
320 // TAG_member is encoded in DIDerivedType format.
321 Flags |= DIDescriptor::FlagStaticMember;
322 return MDDerivedType::get(
323 VMContext, dwarf::DW_TAG_member, Name, File, LineNumber,
324 MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))),
325 MDTypeRef::get(Ty), 0, 0, 0, Flags, getConstantOrNull(Val));
328 DIDerivedType DIBuilder::createObjCIVar(StringRef Name, DIFile File,
331 uint64_t AlignInBits,
332 uint64_t OffsetInBits, unsigned Flags,
333 DIType Ty, MDNode *PropertyNode) {
334 return MDDerivedType::get(
335 VMContext, dwarf::DW_TAG_member, Name, File, LineNumber,
336 MDScopeRef::get(getNonCompileUnitScope(File)), MDTypeRef::get(Ty),
337 SizeInBits, AlignInBits, OffsetInBits, Flags, PropertyNode);
341 DIBuilder::createObjCProperty(StringRef Name, DIFile File, unsigned LineNumber,
342 StringRef GetterName, StringRef SetterName,
343 unsigned PropertyAttributes, DIType Ty) {
344 return MDObjCProperty::get(VMContext, Name, File, LineNumber, GetterName,
345 SetterName, PropertyAttributes, Ty);
348 DITemplateTypeParameter
349 DIBuilder::createTemplateTypeParameter(DIDescriptor Context, StringRef Name,
351 assert((!Context || isa<MDCompileUnit>(Context.get())) &&
352 "Expected compile unit");
353 return MDTemplateTypeParameter::get(VMContext, Name, MDTypeRef::get(Ty));
356 static DITemplateValueParameter
357 createTemplateValueParameterHelper(LLVMContext &VMContext, unsigned Tag,
358 DIDescriptor Context, StringRef Name,
359 DIType Ty, Metadata *MD) {
360 assert((!Context || isa<MDCompileUnit>(Context.get())) &&
361 "Expected compile unit");
362 return MDTemplateValueParameter::get(VMContext, Tag, Name, MDTypeRef::get(Ty),
366 DITemplateValueParameter
367 DIBuilder::createTemplateValueParameter(DIDescriptor Context, StringRef Name,
368 DIType Ty, Constant *Val) {
369 return createTemplateValueParameterHelper(
370 VMContext, dwarf::DW_TAG_template_value_parameter, Context, Name, Ty,
371 getConstantOrNull(Val));
374 DITemplateValueParameter
375 DIBuilder::createTemplateTemplateParameter(DIDescriptor Context, StringRef Name,
376 DIType Ty, StringRef Val) {
377 return createTemplateValueParameterHelper(
378 VMContext, dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
379 MDString::get(VMContext, Val));
382 DITemplateValueParameter
383 DIBuilder::createTemplateParameterPack(DIDescriptor Context, StringRef Name,
384 DIType Ty, DIArray Val) {
385 return createTemplateValueParameterHelper(
386 VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
390 DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
391 DIFile File, unsigned LineNumber,
393 uint64_t AlignInBits,
394 uint64_t OffsetInBits,
395 unsigned Flags, DIType DerivedFrom,
398 MDNode *TemplateParams,
399 StringRef UniqueIdentifier) {
400 assert((!Context || isa<MDScope>(Context)) &&
401 "createClassType should be called with a valid Context");
402 // TAG_class_type is encoded in DICompositeType format.
403 DICompositeType R = MDCompositeType::get(
404 VMContext, dwarf::DW_TAG_structure_type, Name, File, LineNumber,
405 MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))),
406 MDTypeRef::get(DerivedFrom), SizeInBits, AlignInBits, OffsetInBits, Flags,
407 Elements, 0, MDTypeRef::get(VTableHolder),
408 cast_or_null<MDTuple>(TemplateParams), UniqueIdentifier);
409 if (!UniqueIdentifier.empty())
411 trackIfUnresolved(R);
415 DICompositeType DIBuilder::createStructType(DIDescriptor Context,
416 StringRef Name, DIFile File,
419 uint64_t AlignInBits,
420 unsigned Flags, DIType DerivedFrom,
422 unsigned RunTimeLang,
424 StringRef UniqueIdentifier) {
425 DICompositeType R = MDCompositeType::get(
426 VMContext, dwarf::DW_TAG_structure_type, Name, File, LineNumber,
427 MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))),
428 MDTypeRef::get(DerivedFrom), SizeInBits, AlignInBits, 0, Flags, Elements,
429 RunTimeLang, MDTypeRef::get(VTableHolder), nullptr, UniqueIdentifier);
430 if (!UniqueIdentifier.empty())
432 trackIfUnresolved(R);
436 DICompositeType DIBuilder::createUnionType(DIDescriptor Scope, StringRef Name,
437 DIFile File, unsigned LineNumber,
439 uint64_t AlignInBits, unsigned Flags,
441 unsigned RunTimeLang,
442 StringRef UniqueIdentifier) {
443 DICompositeType R = MDCompositeType::get(
444 VMContext, dwarf::DW_TAG_union_type, Name, File, LineNumber,
445 MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))), nullptr,
446 SizeInBits, AlignInBits, 0, Flags, Elements, RunTimeLang, nullptr,
447 nullptr, UniqueIdentifier);
448 if (!UniqueIdentifier.empty())
450 trackIfUnresolved(R);
454 DISubroutineType DIBuilder::createSubroutineType(DIFile File,
455 DITypeArray ParameterTypes,
457 return MDSubroutineType::get(VMContext, Flags, ParameterTypes);
460 DICompositeType DIBuilder::createEnumerationType(
461 DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
462 uint64_t SizeInBits, uint64_t AlignInBits, DIArray Elements,
463 DIType UnderlyingType, StringRef UniqueIdentifier) {
464 DICompositeType CTy = MDCompositeType::get(
465 VMContext, dwarf::DW_TAG_enumeration_type, Name, File, LineNumber,
466 MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))),
467 MDTypeRef::get(UnderlyingType), SizeInBits, AlignInBits, 0, 0, Elements,
468 0, nullptr, nullptr, UniqueIdentifier);
469 AllEnumTypes.push_back(CTy);
470 if (!UniqueIdentifier.empty())
472 trackIfUnresolved(CTy);
476 DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
477 DIType Ty, DIArray Subscripts) {
478 auto *R = MDCompositeType::get(VMContext, dwarf::DW_TAG_array_type, "",
479 nullptr, 0, nullptr, MDTypeRef::get(Ty), Size,
480 AlignInBits, 0, 0, Subscripts, 0, nullptr);
481 trackIfUnresolved(R);
485 DICompositeType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
486 DIType Ty, DIArray Subscripts) {
488 MDCompositeType::get(VMContext, dwarf::DW_TAG_array_type, "", nullptr, 0,
489 nullptr, MDTypeRef::get(Ty), Size, AlignInBits, 0,
490 DIType::FlagVector, Subscripts, 0, nullptr);
491 trackIfUnresolved(R);
495 static DIType createTypeWithFlags(LLVMContext &Context, DIType Ty,
496 unsigned FlagsToSet) {
497 TempMDType NewTy = cast<MDType>(static_cast<MDNode *>(Ty))->clone();
498 NewTy->setFlags(NewTy->getFlags() | FlagsToSet);
499 return MDNode::replaceWithUniqued(std::move(NewTy));
502 DIType DIBuilder::createArtificialType(DIType Ty) {
503 // FIXME: Restrict this to the nodes where it's valid.
504 if (Ty.isArtificial())
506 return createTypeWithFlags(VMContext, Ty, DIType::FlagArtificial);
509 DIType DIBuilder::createObjectPointerType(DIType Ty) {
510 // FIXME: Restrict this to the nodes where it's valid.
511 if (Ty.isObjectPointer())
513 unsigned Flags = DIType::FlagObjectPointer | DIType::FlagArtificial;
514 return createTypeWithFlags(VMContext, Ty, Flags);
517 void DIBuilder::retainType(DIType T) {
518 assert(T.get() && "Expected non-null type");
519 AllRetainTypes.emplace_back(T);
522 DIBasicType DIBuilder::createUnspecifiedParameter() {
523 return DIBasicType();
527 DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIDescriptor Scope,
528 DIFile F, unsigned Line, unsigned RuntimeLang,
529 uint64_t SizeInBits, uint64_t AlignInBits,
530 StringRef UniqueIdentifier) {
531 // FIXME: Define in terms of createReplaceableForwardDecl() by calling
532 // replaceWithUniqued().
533 DICompositeType RetTy = MDCompositeType::get(
534 VMContext, Tag, Name, F, Line,
535 MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))), nullptr,
536 SizeInBits, AlignInBits, 0, DIDescriptor::FlagFwdDecl, nullptr,
537 RuntimeLang, nullptr, nullptr, UniqueIdentifier);
538 if (!UniqueIdentifier.empty())
540 trackIfUnresolved(RetTy);
544 DICompositeType DIBuilder::createReplaceableCompositeType(
545 unsigned Tag, StringRef Name, DIDescriptor Scope, DIFile F, unsigned Line,
546 unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
547 unsigned Flags, StringRef UniqueIdentifier) {
548 DICompositeType RetTy =
549 MDCompositeType::getTemporary(
550 VMContext, Tag, Name, F, Line,
551 MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))), nullptr,
552 SizeInBits, AlignInBits, 0, Flags, nullptr, RuntimeLang, nullptr,
553 nullptr, UniqueIdentifier)
555 if (!UniqueIdentifier.empty())
557 trackIfUnresolved(RetTy);
561 DIArray DIBuilder::getOrCreateArray(ArrayRef<Metadata *> Elements) {
562 return DIArray(MDNode::get(VMContext, Elements));
565 DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
566 SmallVector<llvm::Metadata *, 16> Elts;
567 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
568 if (Elements[i] && isa<MDNode>(Elements[i]))
569 Elts.push_back(MDTypeRef::get(cast<MDType>(Elements[i])));
571 Elts.push_back(Elements[i]);
573 return DITypeArray(MDNode::get(VMContext, Elts));
576 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
577 return MDSubrange::get(VMContext, Count, Lo);
580 static void checkGlobalVariableScope(DIDescriptor Context) {
582 if (DICompositeType CT =
583 dyn_cast_or_null<MDCompositeType>(getNonCompileUnitScope(Context)))
584 assert(!CT.getIdentifier() &&
585 "Context of a global variable should not be a type with identifier");
589 DIGlobalVariable DIBuilder::createGlobalVariable(
590 DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
591 unsigned LineNumber, DIType Ty, bool isLocalToUnit, Constant *Val,
593 checkGlobalVariableScope(Context);
595 auto *N = MDGlobalVariable::get(
596 VMContext, cast_or_null<MDScope>(Context.get()), Name, LinkageName, F,
597 LineNumber, MDTypeRef::get(Ty), isLocalToUnit, true, Val,
598 cast_or_null<MDDerivedType>(Decl));
603 DIGlobalVariable DIBuilder::createTempGlobalVariableFwdDecl(
604 DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
605 unsigned LineNumber, DIType Ty, bool isLocalToUnit, Constant *Val,
607 checkGlobalVariableScope(Context);
609 return MDGlobalVariable::getTemporary(
610 VMContext, cast_or_null<MDScope>(Context.get()), Name, LinkageName,
611 F, LineNumber, MDTypeRef::get(Ty), isLocalToUnit, false, Val,
612 cast_or_null<MDDerivedType>(Decl)).release();
615 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
616 StringRef Name, DIFile File,
617 unsigned LineNo, DIType Ty,
618 bool AlwaysPreserve, unsigned Flags,
620 // FIXME: Why getNonCompileUnitScope()?
621 // FIXME: Why is "!Context" okay here?
622 // FIXME: WHy doesn't this check for a subprogram or lexical block (AFAICT
623 // the only valid scopes)?
624 DIScope Context = getNonCompileUnitScope(Scope);
626 auto *Node = MDLocalVariable::get(
627 VMContext, Tag, cast_or_null<MDLocalScope>(Context.get()), Name, File,
628 LineNo, MDTypeRef::get(Ty), ArgNo, Flags);
629 if (AlwaysPreserve) {
630 // The optimizer may remove local variable. If there is an interest
631 // to preserve variable info in such situation then stash it in a
633 DISubprogram Fn(getDISubprogram(Scope));
634 assert(Fn && "Missing subprogram for local variable");
635 PreservedVariables[Fn].emplace_back(Node);
640 DIExpression DIBuilder::createExpression(ArrayRef<uint64_t> Addr) {
641 return MDExpression::get(VMContext, Addr);
644 DIExpression DIBuilder::createExpression(ArrayRef<int64_t> Signed) {
645 // TODO: Remove the callers of this signed version and delete.
646 SmallVector<uint64_t, 8> Addr(Signed.begin(), Signed.end());
647 return createExpression(Addr);
650 DIExpression DIBuilder::createBitPieceExpression(unsigned OffsetInBytes,
651 unsigned SizeInBytes) {
652 uint64_t Addr[] = {dwarf::DW_OP_bit_piece, OffsetInBytes, SizeInBytes};
653 return MDExpression::get(VMContext, Addr);
656 DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
657 StringRef LinkageName, DIFile File,
658 unsigned LineNo, DICompositeType Ty,
659 bool isLocalToUnit, bool isDefinition,
660 unsigned ScopeLine, unsigned Flags,
661 bool isOptimized, Function *Fn,
662 MDNode *TParams, MDNode *Decl) {
663 // dragonegg does not generate identifier for types, so using an empty map
664 // to resolve the context should be fine.
665 DITypeIdentifierMap EmptyMap;
666 return createFunction(Context.resolve(EmptyMap), Name, LinkageName, File,
667 LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
668 Flags, isOptimized, Fn, TParams, Decl);
671 DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
672 StringRef LinkageName, DIFile File,
673 unsigned LineNo, DICompositeType Ty,
674 bool isLocalToUnit, bool isDefinition,
675 unsigned ScopeLine, unsigned Flags,
676 bool isOptimized, Function *Fn,
677 MDNode *TParams, MDNode *Decl) {
678 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
679 "function types should be subroutines");
680 auto *Node = MDSubprogram::get(
681 VMContext, MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))),
682 Name, LinkageName, File.get(), LineNo,
683 cast_or_null<MDSubroutineType>(Ty.get()), isLocalToUnit, isDefinition,
684 ScopeLine, nullptr, 0, 0, Flags, isOptimized, Fn,
685 cast_or_null<MDTuple>(TParams), cast_or_null<MDSubprogram>(Decl),
686 MDTuple::getTemporary(VMContext, None).release());
689 AllSubprograms.push_back(Node);
690 trackIfUnresolved(Node);
695 DIBuilder::createTempFunctionFwdDecl(DIDescriptor Context, StringRef Name,
696 StringRef LinkageName, DIFile File,
697 unsigned LineNo, DICompositeType Ty,
698 bool isLocalToUnit, bool isDefinition,
699 unsigned ScopeLine, unsigned Flags,
700 bool isOptimized, Function *Fn,
701 MDNode *TParams, MDNode *Decl) {
702 return MDSubprogram::getTemporary(
704 MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))), Name,
705 LinkageName, File.get(), LineNo,
706 cast_or_null<MDSubroutineType>(Ty.get()), isLocalToUnit,
707 isDefinition, ScopeLine, nullptr, 0, 0, Flags, isOptimized, Fn,
708 cast_or_null<MDTuple>(TParams), cast_or_null<MDSubprogram>(Decl),
712 DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
713 StringRef LinkageName, DIFile F,
714 unsigned LineNo, DICompositeType Ty,
715 bool isLocalToUnit, bool isDefinition,
716 unsigned VK, unsigned VIndex,
717 DIType VTableHolder, unsigned Flags,
718 bool isOptimized, Function *Fn,
720 assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
721 "function types should be subroutines");
722 assert(getNonCompileUnitScope(Context) &&
723 "Methods should have both a Context and a context that isn't "
724 "the compile unit.");
725 // FIXME: Do we want to use different scope/lines?
726 auto *SP = MDSubprogram::get(
727 VMContext, MDScopeRef::get(cast<MDScope>(Context)), Name, LinkageName,
728 F.get(), LineNo, cast_or_null<MDSubroutineType>(Ty.get()), isLocalToUnit,
729 isDefinition, LineNo, MDTypeRef::get(VTableHolder), VK, VIndex, Flags,
730 isOptimized, Fn, cast_or_null<MDTuple>(TParam), nullptr, nullptr);
733 AllSubprograms.push_back(SP);
734 trackIfUnresolved(SP);
738 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
739 DIFile File, unsigned LineNo) {
740 return MDNamespace::get(VMContext, getNonCompileUnitScope(Scope), File, Name,
744 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
746 unsigned Discriminator) {
747 return MDLexicalBlockFile::get(VMContext, Scope, File.getFileNode(),
751 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
752 unsigned Line, unsigned Col) {
753 // Make these distinct, to avoid merging two lexical blocks on the same
755 return MDLexicalBlock::getDistinct(VMContext, getNonCompileUnitScope(Scope),
756 File.getFileNode(), Line, Col);
759 static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) {
760 assert(V && "no value passed to dbg intrinsic");
761 return MetadataAsValue::get(VMContext, ValueAsMetadata::get(V));
764 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
766 Instruction *InsertBefore) {
767 assert(VarInfo && "empty or invalid DIVariable passed to dbg.declare");
769 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
771 trackIfUnresolved(VarInfo);
772 trackIfUnresolved(Expr);
773 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
774 MetadataAsValue::get(VMContext, VarInfo),
775 MetadataAsValue::get(VMContext, Expr)};
776 return CallInst::Create(DeclareFn, Args, "", InsertBefore);
779 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
781 BasicBlock *InsertAtEnd) {
782 assert(VarInfo && "empty or invalid DIVariable passed to dbg.declare");
784 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
786 trackIfUnresolved(VarInfo);
787 trackIfUnresolved(Expr);
788 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
789 MetadataAsValue::get(VMContext, VarInfo),
790 MetadataAsValue::get(VMContext, Expr)};
792 // If this block already has a terminator then insert this intrinsic
793 // before the terminator.
794 if (TerminatorInst *T = InsertAtEnd->getTerminator())
795 return CallInst::Create(DeclareFn, Args, "", T);
797 return CallInst::Create(DeclareFn, Args, "", InsertAtEnd);
800 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
803 Instruction *InsertBefore) {
804 assert(V && "no value passed to dbg.value");
805 assert(VarInfo && "empty or invalid DIVariable passed to dbg.value");
807 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
809 trackIfUnresolved(VarInfo);
810 trackIfUnresolved(Expr);
811 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
812 ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
813 MetadataAsValue::get(VMContext, VarInfo),
814 MetadataAsValue::get(VMContext, Expr)};
815 return CallInst::Create(ValueFn, Args, "", InsertBefore);
818 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
821 BasicBlock *InsertAtEnd) {
822 assert(V && "no value passed to dbg.value");
823 assert(VarInfo && "empty or invalid DIVariable passed to dbg.value");
825 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
827 trackIfUnresolved(VarInfo);
828 trackIfUnresolved(Expr);
829 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
830 ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
831 MetadataAsValue::get(VMContext, VarInfo),
832 MetadataAsValue::get(VMContext, Expr)};
833 return CallInst::Create(ValueFn, Args, "", InsertAtEnd);
836 void DIBuilder::replaceVTableHolder(DICompositeType &T, DICompositeType VTableHolder) {
838 TypedTrackingMDRef<MDCompositeTypeBase> N(T);
839 N->replaceVTableHolder(MDTypeRef::get(VTableHolder));
843 // If this didn't create a self-reference, just return.
844 if (T != VTableHolder)
847 // Look for unresolved operands. T will drop RAUW support, orphaning any
848 // cycles underneath it.
850 for (const MDOperand &O : T->operands())
851 if (auto *N = dyn_cast_or_null<MDNode>(O))
852 trackIfUnresolved(N);
855 void DIBuilder::replaceArrays(DICompositeType &T, DIArray Elements,
858 TypedTrackingMDRef<MDCompositeTypeBase> N(T);
860 N->replaceElements(Elements);
862 N->replaceTemplateParams(MDTemplateParameterArray(TParams));
866 // If T isn't resolved, there's no problem.
867 if (!T->isResolved())
870 // If "T" is resolved, it may be due to a self-reference cycle. Track the
871 // arrays explicitly if they're unresolved, or else the cycles will be
874 trackIfUnresolved(Elements.get());
876 trackIfUnresolved(TParams.get());