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);
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)), 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 |= DebugNode::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)) && "Expected compile unit");
352 return MDTemplateTypeParameter::get(VMContext, Name, MDTypeRef::get(Ty));
355 static DITemplateValueParameter
356 createTemplateValueParameterHelper(LLVMContext &VMContext, unsigned Tag,
357 DIDescriptor Context, StringRef Name,
358 DIType Ty, Metadata *MD) {
359 assert((!Context || isa<MDCompileUnit>(Context)) && "Expected compile unit");
360 return MDTemplateValueParameter::get(VMContext, Tag, Name, MDTypeRef::get(Ty),
364 DITemplateValueParameter
365 DIBuilder::createTemplateValueParameter(DIDescriptor Context, StringRef Name,
366 DIType Ty, Constant *Val) {
367 return createTemplateValueParameterHelper(
368 VMContext, dwarf::DW_TAG_template_value_parameter, Context, Name, Ty,
369 getConstantOrNull(Val));
372 DITemplateValueParameter
373 DIBuilder::createTemplateTemplateParameter(DIDescriptor Context, StringRef Name,
374 DIType Ty, StringRef Val) {
375 return createTemplateValueParameterHelper(
376 VMContext, dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
377 MDString::get(VMContext, Val));
380 DITemplateValueParameter
381 DIBuilder::createTemplateParameterPack(DIDescriptor Context, StringRef Name,
382 DIType Ty, DIArray Val) {
383 return createTemplateValueParameterHelper(
384 VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
388 DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
389 DIFile File, unsigned LineNumber,
391 uint64_t AlignInBits,
392 uint64_t OffsetInBits,
393 unsigned Flags, DIType DerivedFrom,
396 MDNode *TemplateParams,
397 StringRef UniqueIdentifier) {
398 assert((!Context || isa<MDScope>(Context)) &&
399 "createClassType should be called with a valid Context");
400 // TAG_class_type is encoded in DICompositeType format.
401 DICompositeType R = MDCompositeType::get(
402 VMContext, dwarf::DW_TAG_structure_type, Name, File, LineNumber,
403 MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))),
404 MDTypeRef::get(DerivedFrom), SizeInBits, AlignInBits, OffsetInBits, Flags,
405 Elements, 0, MDTypeRef::get(VTableHolder),
406 cast_or_null<MDTuple>(TemplateParams), UniqueIdentifier);
407 if (!UniqueIdentifier.empty())
409 trackIfUnresolved(R);
413 DICompositeType DIBuilder::createStructType(DIDescriptor Context,
414 StringRef Name, DIFile File,
417 uint64_t AlignInBits,
418 unsigned Flags, DIType DerivedFrom,
420 unsigned RunTimeLang,
422 StringRef UniqueIdentifier) {
423 DICompositeType R = MDCompositeType::get(
424 VMContext, dwarf::DW_TAG_structure_type, Name, File, LineNumber,
425 MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))),
426 MDTypeRef::get(DerivedFrom), SizeInBits, AlignInBits, 0, Flags, Elements,
427 RunTimeLang, MDTypeRef::get(VTableHolder), nullptr, UniqueIdentifier);
428 if (!UniqueIdentifier.empty())
430 trackIfUnresolved(R);
434 DICompositeType DIBuilder::createUnionType(DIDescriptor Scope, StringRef Name,
435 DIFile File, unsigned LineNumber,
437 uint64_t AlignInBits, unsigned Flags,
439 unsigned RunTimeLang,
440 StringRef UniqueIdentifier) {
441 DICompositeType R = MDCompositeType::get(
442 VMContext, dwarf::DW_TAG_union_type, Name, File, LineNumber,
443 MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))), nullptr,
444 SizeInBits, AlignInBits, 0, Flags, Elements, RunTimeLang, nullptr,
445 nullptr, UniqueIdentifier);
446 if (!UniqueIdentifier.empty())
448 trackIfUnresolved(R);
452 DISubroutineType DIBuilder::createSubroutineType(DIFile File,
453 DITypeArray ParameterTypes,
455 return MDSubroutineType::get(VMContext, Flags, ParameterTypes);
458 DICompositeType DIBuilder::createEnumerationType(
459 DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
460 uint64_t SizeInBits, uint64_t AlignInBits, DIArray Elements,
461 DIType UnderlyingType, StringRef UniqueIdentifier) {
462 DICompositeType CTy = MDCompositeType::get(
463 VMContext, dwarf::DW_TAG_enumeration_type, Name, File, LineNumber,
464 MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))),
465 MDTypeRef::get(UnderlyingType), SizeInBits, AlignInBits, 0, 0, Elements,
466 0, nullptr, nullptr, UniqueIdentifier);
467 AllEnumTypes.push_back(CTy);
468 if (!UniqueIdentifier.empty())
470 trackIfUnresolved(CTy);
474 DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
475 DIType Ty, DIArray Subscripts) {
476 auto *R = MDCompositeType::get(VMContext, dwarf::DW_TAG_array_type, "",
477 nullptr, 0, nullptr, MDTypeRef::get(Ty), Size,
478 AlignInBits, 0, 0, Subscripts, 0, nullptr);
479 trackIfUnresolved(R);
483 DICompositeType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
484 DIType Ty, DIArray Subscripts) {
486 MDCompositeType::get(VMContext, dwarf::DW_TAG_array_type, "", nullptr, 0,
487 nullptr, MDTypeRef::get(Ty), Size, AlignInBits, 0,
488 DebugNode::FlagVector, Subscripts, 0, nullptr);
489 trackIfUnresolved(R);
493 static DIType createTypeWithFlags(LLVMContext &Context, DIType Ty,
494 unsigned FlagsToSet) {
495 TempMDType NewTy = cast<MDType>(static_cast<MDNode *>(Ty))->clone();
496 NewTy->setFlags(NewTy->getFlags() | FlagsToSet);
497 return MDNode::replaceWithUniqued(std::move(NewTy));
500 DIType DIBuilder::createArtificialType(DIType Ty) {
501 // FIXME: Restrict this to the nodes where it's valid.
502 if (Ty->isArtificial())
504 return createTypeWithFlags(VMContext, Ty, DebugNode::FlagArtificial);
507 DIType DIBuilder::createObjectPointerType(DIType Ty) {
508 // FIXME: Restrict this to the nodes where it's valid.
509 if (Ty->isObjectPointer())
511 unsigned Flags = DebugNode::FlagObjectPointer | DebugNode::FlagArtificial;
512 return createTypeWithFlags(VMContext, Ty, Flags);
515 void DIBuilder::retainType(DIType T) {
516 assert(T && "Expected non-null type");
517 AllRetainTypes.emplace_back(T);
520 DIBasicType DIBuilder::createUnspecifiedParameter() { return nullptr; }
523 DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIDescriptor Scope,
524 DIFile F, unsigned Line, unsigned RuntimeLang,
525 uint64_t SizeInBits, uint64_t AlignInBits,
526 StringRef UniqueIdentifier) {
527 // FIXME: Define in terms of createReplaceableForwardDecl() by calling
528 // replaceWithUniqued().
529 DICompositeType RetTy = MDCompositeType::get(
530 VMContext, Tag, Name, F, Line,
531 MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))), nullptr,
532 SizeInBits, AlignInBits, 0, DebugNode::FlagFwdDecl, nullptr, RuntimeLang,
533 nullptr, nullptr, UniqueIdentifier);
534 if (!UniqueIdentifier.empty())
536 trackIfUnresolved(RetTy);
540 DICompositeType DIBuilder::createReplaceableCompositeType(
541 unsigned Tag, StringRef Name, DIDescriptor Scope, DIFile F, unsigned Line,
542 unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
543 unsigned Flags, StringRef UniqueIdentifier) {
544 DICompositeType RetTy =
545 MDCompositeType::getTemporary(
546 VMContext, Tag, Name, F, Line,
547 MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))), nullptr,
548 SizeInBits, AlignInBits, 0, Flags, nullptr, RuntimeLang, nullptr,
549 nullptr, UniqueIdentifier)
551 if (!UniqueIdentifier.empty())
553 trackIfUnresolved(RetTy);
557 DIArray DIBuilder::getOrCreateArray(ArrayRef<Metadata *> Elements) {
558 return DIArray(MDNode::get(VMContext, Elements));
561 DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
562 SmallVector<llvm::Metadata *, 16> Elts;
563 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
564 if (Elements[i] && isa<MDNode>(Elements[i]))
565 Elts.push_back(MDTypeRef::get(cast<MDType>(Elements[i])));
567 Elts.push_back(Elements[i]);
569 return DITypeArray(MDNode::get(VMContext, Elts));
572 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
573 return MDSubrange::get(VMContext, Count, Lo);
576 static void checkGlobalVariableScope(DIDescriptor Context) {
579 dyn_cast_or_null<MDCompositeType>(getNonCompileUnitScope(Context)))
580 assert(CT->getIdentifier().empty() &&
581 "Context of a global variable should not be a type with identifier");
585 DIGlobalVariable DIBuilder::createGlobalVariable(
586 DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
587 unsigned LineNumber, DIType Ty, bool isLocalToUnit, Constant *Val,
589 checkGlobalVariableScope(Context);
591 auto *N = MDGlobalVariable::get(VMContext, cast_or_null<MDScope>(Context),
592 Name, LinkageName, F, LineNumber,
593 MDTypeRef::get(Ty), isLocalToUnit, true, Val,
594 cast_or_null<MDDerivedType>(Decl));
599 DIGlobalVariable DIBuilder::createTempGlobalVariableFwdDecl(
600 DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
601 unsigned LineNumber, DIType Ty, bool isLocalToUnit, Constant *Val,
603 checkGlobalVariableScope(Context);
605 return MDGlobalVariable::getTemporary(
606 VMContext, cast_or_null<MDScope>(Context), Name, LinkageName, F,
607 LineNumber, MDTypeRef::get(Ty), isLocalToUnit, false, Val,
608 cast_or_null<MDDerivedType>(Decl))
612 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
613 StringRef Name, DIFile File,
614 unsigned LineNo, DIType Ty,
615 bool AlwaysPreserve, unsigned Flags,
617 // FIXME: Why getNonCompileUnitScope()?
618 // FIXME: Why is "!Context" okay here?
619 // FIXME: WHy doesn't this check for a subprogram or lexical block (AFAICT
620 // the only valid scopes)?
621 DIScope Context = getNonCompileUnitScope(Scope);
623 auto *Node = MDLocalVariable::get(
624 VMContext, Tag, cast_or_null<MDLocalScope>(Context), Name, File, LineNo,
625 MDTypeRef::get(Ty), ArgNo, Flags);
626 if (AlwaysPreserve) {
627 // The optimizer may remove local variable. If there is an interest
628 // to preserve variable info in such situation then stash it in a
630 DISubprogram Fn(getDISubprogram(Scope));
631 assert(Fn && "Missing subprogram for local variable");
632 PreservedVariables[Fn].emplace_back(Node);
637 DIExpression DIBuilder::createExpression(ArrayRef<uint64_t> Addr) {
638 return MDExpression::get(VMContext, Addr);
641 DIExpression DIBuilder::createExpression(ArrayRef<int64_t> Signed) {
642 // TODO: Remove the callers of this signed version and delete.
643 SmallVector<uint64_t, 8> Addr(Signed.begin(), Signed.end());
644 return createExpression(Addr);
647 DIExpression DIBuilder::createBitPieceExpression(unsigned OffsetInBytes,
648 unsigned SizeInBytes) {
649 uint64_t Addr[] = {dwarf::DW_OP_bit_piece, OffsetInBytes, SizeInBytes};
650 return MDExpression::get(VMContext, Addr);
653 DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
654 StringRef LinkageName, DIFile File,
655 unsigned LineNo, DICompositeType Ty,
656 bool isLocalToUnit, bool isDefinition,
657 unsigned ScopeLine, unsigned Flags,
658 bool isOptimized, Function *Fn,
659 MDNode *TParams, MDNode *Decl) {
660 // dragonegg does not generate identifier for types, so using an empty map
661 // to resolve the context should be fine.
662 DITypeIdentifierMap EmptyMap;
663 return createFunction(Context.resolve(EmptyMap), Name, LinkageName, File,
664 LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
665 Flags, isOptimized, Fn, TParams, Decl);
668 DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
669 StringRef LinkageName, DIFile File,
670 unsigned LineNo, DICompositeType Ty,
671 bool isLocalToUnit, bool isDefinition,
672 unsigned ScopeLine, unsigned Flags,
673 bool isOptimized, Function *Fn,
674 MDNode *TParams, MDNode *Decl) {
675 assert(Ty->getTag() == dwarf::DW_TAG_subroutine_type &&
676 "function types should be subroutines");
677 auto *Node = MDSubprogram::get(
678 VMContext, MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))),
679 Name, LinkageName, File, LineNo, cast_or_null<MDSubroutineType>(Ty),
680 isLocalToUnit, isDefinition, ScopeLine, nullptr, 0, 0, Flags, isOptimized,
681 Fn, cast_or_null<MDTuple>(TParams), cast_or_null<MDSubprogram>(Decl),
682 MDTuple::getTemporary(VMContext, None).release());
685 AllSubprograms.push_back(Node);
686 trackIfUnresolved(Node);
691 DIBuilder::createTempFunctionFwdDecl(DIDescriptor Context, StringRef Name,
692 StringRef LinkageName, DIFile File,
693 unsigned LineNo, DICompositeType Ty,
694 bool isLocalToUnit, bool isDefinition,
695 unsigned ScopeLine, unsigned Flags,
696 bool isOptimized, Function *Fn,
697 MDNode *TParams, MDNode *Decl) {
698 return MDSubprogram::getTemporary(
700 MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))), Name,
701 LinkageName, File, LineNo, cast_or_null<MDSubroutineType>(Ty),
702 isLocalToUnit, isDefinition, ScopeLine, nullptr, 0, 0, Flags,
703 isOptimized, Fn, cast_or_null<MDTuple>(TParams),
704 cast_or_null<MDSubprogram>(Decl), nullptr)
708 DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
709 StringRef LinkageName, DIFile F,
710 unsigned LineNo, DICompositeType Ty,
711 bool isLocalToUnit, bool isDefinition,
712 unsigned VK, unsigned VIndex,
713 DIType VTableHolder, unsigned Flags,
714 bool isOptimized, Function *Fn,
716 assert(Ty->getTag() == dwarf::DW_TAG_subroutine_type &&
717 "function types should be subroutines");
718 assert(getNonCompileUnitScope(Context) &&
719 "Methods should have both a Context and a context that isn't "
720 "the compile unit.");
721 // FIXME: Do we want to use different scope/lines?
722 auto *SP = MDSubprogram::get(
723 VMContext, MDScopeRef::get(cast<MDScope>(Context)), Name, LinkageName, F,
724 LineNo, cast_or_null<MDSubroutineType>(Ty), isLocalToUnit, isDefinition,
725 LineNo, MDTypeRef::get(VTableHolder), VK, VIndex, Flags, isOptimized, Fn,
726 cast_or_null<MDTuple>(TParam), nullptr, nullptr);
729 AllSubprograms.push_back(SP);
730 trackIfUnresolved(SP);
734 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
735 DIFile File, unsigned LineNo) {
736 return MDNamespace::get(VMContext, getNonCompileUnitScope(Scope), File, Name,
740 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
742 unsigned Discriminator) {
743 return MDLexicalBlockFile::get(VMContext, Scope, File, Discriminator);
746 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
747 unsigned Line, unsigned Col) {
748 // Make these distinct, to avoid merging two lexical blocks on the same
750 return MDLexicalBlock::getDistinct(VMContext, getNonCompileUnitScope(Scope),
754 static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) {
755 assert(V && "no value passed to dbg intrinsic");
756 return MetadataAsValue::get(VMContext, ValueAsMetadata::get(V));
759 static Instruction *withDebugLoc(Instruction *I, const MDLocation *DL) {
760 I->setDebugLoc(const_cast<MDLocation *>(DL));
764 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
765 DIExpression Expr, const MDLocation *DL,
766 Instruction *InsertBefore) {
767 assert(VarInfo && "empty or invalid DIVariable passed to dbg.declare");
768 assert(DL && "Expected debug loc");
769 assert(DL->getScope()->getSubprogram() ==
770 VarInfo->getScope()->getSubprogram() &&
771 "Expected matching subprograms");
773 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
775 trackIfUnresolved(VarInfo);
776 trackIfUnresolved(Expr);
777 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
778 MetadataAsValue::get(VMContext, VarInfo),
779 MetadataAsValue::get(VMContext, Expr)};
780 return withDebugLoc(CallInst::Create(DeclareFn, Args, "", InsertBefore), DL);
783 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
784 DIExpression Expr, const MDLocation *DL,
785 BasicBlock *InsertAtEnd) {
786 assert(VarInfo && "empty or invalid DIVariable passed to dbg.declare");
787 assert(DL && "Expected debug loc");
788 assert(DL->getScope()->getSubprogram() ==
789 VarInfo->getScope()->getSubprogram() &&
790 "Expected matching subprograms");
792 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
794 trackIfUnresolved(VarInfo);
795 trackIfUnresolved(Expr);
796 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
797 MetadataAsValue::get(VMContext, VarInfo),
798 MetadataAsValue::get(VMContext, Expr)};
800 // If this block already has a terminator then insert this intrinsic
801 // before the terminator.
802 if (TerminatorInst *T = InsertAtEnd->getTerminator())
803 return withDebugLoc(CallInst::Create(DeclareFn, Args, "", T), DL);
804 return withDebugLoc(CallInst::Create(DeclareFn, Args, "", InsertAtEnd), DL);
807 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
810 const MDLocation *DL,
811 Instruction *InsertBefore) {
812 assert(V && "no value passed to dbg.value");
813 assert(VarInfo && "empty or invalid DIVariable passed to dbg.value");
814 assert(DL && "Expected debug loc");
815 assert(DL->getScope()->getSubprogram() ==
816 VarInfo->getScope()->getSubprogram() &&
817 "Expected matching subprograms");
819 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
821 trackIfUnresolved(VarInfo);
822 trackIfUnresolved(Expr);
823 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
824 ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
825 MetadataAsValue::get(VMContext, VarInfo),
826 MetadataAsValue::get(VMContext, Expr)};
827 return withDebugLoc(CallInst::Create(ValueFn, Args, "", InsertBefore), DL);
830 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
833 const MDLocation *DL,
834 BasicBlock *InsertAtEnd) {
835 assert(V && "no value passed to dbg.value");
836 assert(VarInfo && "empty or invalid DIVariable passed to dbg.value");
837 assert(DL && "Expected debug loc");
838 assert(DL->getScope()->getSubprogram() ==
839 VarInfo->getScope()->getSubprogram() &&
840 "Expected matching subprograms");
842 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
844 trackIfUnresolved(VarInfo);
845 trackIfUnresolved(Expr);
846 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
847 ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
848 MetadataAsValue::get(VMContext, VarInfo),
849 MetadataAsValue::get(VMContext, Expr)};
851 return withDebugLoc(CallInst::Create(ValueFn, Args, "", InsertAtEnd), DL);
854 void DIBuilder::replaceVTableHolder(DICompositeType &T, DICompositeType VTableHolder) {
856 TypedTrackingMDRef<MDCompositeTypeBase> N(T);
857 N->replaceVTableHolder(MDTypeRef::get(VTableHolder));
861 // If this didn't create a self-reference, just return.
862 if (T != VTableHolder)
865 // Look for unresolved operands. T will drop RAUW support, orphaning any
866 // cycles underneath it.
868 for (const MDOperand &O : T->operands())
869 if (auto *N = dyn_cast_or_null<MDNode>(O))
870 trackIfUnresolved(N);
873 void DIBuilder::replaceArrays(DICompositeType &T, DIArray Elements,
876 TypedTrackingMDRef<MDCompositeTypeBase> N(T);
878 N->replaceElements(Elements);
880 N->replaceTemplateParams(MDTemplateParameterArray(TParams));
884 // If T isn't resolved, there's no problem.
885 if (!T->isResolved())
888 // If "T" is resolved, it may be due to a self-reference cycle. Track the
889 // arrays explicitly if they're unresolved, or else the cycles will be
892 trackIfUnresolved(Elements.get());
894 trackIfUnresolved(TParams.get());