1//===--- DIBuilder.cpp - Debug Information Builder ------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the DIBuilder.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/IR/DIBuilder.h"
14#include "LLVMContextImpl.h"
15#include "llvm/ADT/APInt.h"
16#include "llvm/ADT/APSInt.h"
17#include "llvm/BinaryFormat/Dwarf.h"
18#include "llvm/IR/Constants.h"
19#include "llvm/IR/DebugInfo.h"
20#include "llvm/IR/IRBuilder.h"
21#include "llvm/IR/Module.h"
22#include <optional>
23
24using namespace llvm;
25using namespace llvm::dwarf;
26
27DIBuilder::DIBuilder(Module &m, bool AllowUnresolvedNodes, DICompileUnit *CU)
28 : M(m), VMContext(M.getContext()), CUNode(CU),
29 AllowUnresolvedNodes(AllowUnresolvedNodes) {
30 if (CUNode) {
31 if (const auto &ETs = CUNode->getEnumTypes())
32 EnumTypes.assign(in_start: ETs.begin(), in_end: ETs.end());
33 if (const auto &RTs = CUNode->getRetainedTypes())
34 AllRetainTypes.assign(in_start: RTs.begin(), in_end: RTs.end());
35 if (const auto &GVs = CUNode->getGlobalVariables())
36 Globals.assign(in_start: GVs.begin(), in_end: GVs.end());
37 if (const auto &IMs = CUNode->getImportedEntities())
38 ImportedModules.assign(in_start: IMs.begin(), in_end: IMs.end());
39 if (const auto &MNs = CUNode->getMacros())
40 AllMacrosPerParent.insert(KV: {nullptr, {llvm::from_range, MNs}});
41 }
42}
43
44void DIBuilder::trackIfUnresolved(MDNode *N) {
45 if (!N)
46 return;
47 if (N->isResolved())
48 return;
49
50 assert(AllowUnresolvedNodes && "Cannot handle unresolved nodes");
51 UnresolvedNodes.emplace_back(Args&: N);
52}
53
54void DIBuilder::finalizeSubprogram(DISubprogram *SP) {
55 auto PN = SubprogramTrackedNodes.find(Val: SP);
56 if (PN == SubprogramTrackedNodes.end())
57 return;
58
59 SetVector<Metadata *> RetainedNodes;
60 for (MDNode *N : llvm::concat<MDNode *>(Ranges: SP->getRetainedNodes(), Ranges&: PN->second)) {
61 // If the tracked node N was temporary, and the DIBuilder user replaced it
62 // with a node that does not belong to SP or is non-local, do not add N to
63 // SP's retainedNodes list.
64 DILocalScope *Scope = dyn_cast_or_null<DILocalScope>(
65 Val: DISubprogram::getRawRetainedNodeScope(N));
66 if (Scope && Scope->getSubprogram() == SP)
67 RetainedNodes.insert(X: N);
68 }
69
70 SP->replaceRetainedNodes(
71 N: MDTuple::get(Context&: VMContext, MDs: RetainedNodes.getArrayRef()));
72}
73
74void DIBuilder::finalize() {
75 if (!CUNode) {
76 assert(!AllowUnresolvedNodes &&
77 "creating type nodes without a CU is not supported");
78 return;
79 }
80
81 if (!EnumTypes.empty())
82 CUNode->replaceEnumTypes(
83 N: MDTuple::get(Context&: VMContext, MDs: SmallVector<Metadata *, 16>(EnumTypes.begin(),
84 EnumTypes.end())));
85
86 SmallVector<Metadata *, 16> RetainValues;
87 // Declarations and definitions of the same type may be retained. Some
88 // clients RAUW these pairs, leaving duplicates in the retained types
89 // list. Use a set to remove the duplicates while we transform the
90 // TrackingVHs back into Values.
91 SmallPtrSet<Metadata *, 16> RetainSet;
92 for (const TrackingMDNodeRef &N : AllRetainTypes)
93 if (RetainSet.insert(Ptr: N).second)
94 RetainValues.push_back(Elt: N);
95
96 if (!RetainValues.empty())
97 CUNode->replaceRetainedTypes(N: MDTuple::get(Context&: VMContext, MDs: RetainValues));
98
99 for (auto *SP : AllSubprograms)
100 finalizeSubprogram(SP);
101 for (auto *N : RetainValues)
102 if (auto *SP = dyn_cast<DISubprogram>(Val: N))
103 finalizeSubprogram(SP);
104
105 if (!Globals.empty())
106 CUNode->replaceGlobalVariables(N: MDTuple::get(Context&: VMContext, MDs: Globals));
107
108 if (!ImportedModules.empty())
109 CUNode->replaceImportedEntities(N: MDTuple::get(
110 Context&: VMContext, MDs: SmallVector<Metadata *, 16>(ImportedModules.begin(),
111 ImportedModules.end())));
112
113 for (const auto &I : AllMacrosPerParent) {
114 // DIMacroNode's with nullptr parent are DICompileUnit direct children.
115 if (!I.first) {
116 CUNode->replaceMacros(N: MDTuple::get(Context&: VMContext, MDs: I.second.getArrayRef()));
117 continue;
118 }
119 // Otherwise, it must be a temporary DIMacroFile that need to be resolved.
120 auto *TMF = cast<DIMacroFile>(Val: I.first);
121 auto *MF = DIMacroFile::get(Context&: VMContext, MIType: dwarf::DW_MACINFO_start_file,
122 Line: TMF->getLine(), File: TMF->getFile(),
123 Elements: getOrCreateMacroArray(Elements: I.second.getArrayRef()));
124 replaceTemporary(N: llvm::TempDIMacroNode(TMF), Replacement: MF);
125 }
126
127 // Now that all temp nodes have been replaced or deleted, resolve remaining
128 // cycles.
129 for (const auto &N : UnresolvedNodes)
130 if (N && !N->isResolved())
131 N->resolveCycles();
132 UnresolvedNodes.clear();
133
134 // Can't handle unresolved nodes anymore.
135 AllowUnresolvedNodes = false;
136}
137
138/// If N is compile unit return NULL otherwise return N.
139static DIScope *getNonCompileUnitScope(DIScope *N) {
140 if (!N || isa<DICompileUnit>(Val: N))
141 return nullptr;
142 return cast<DIScope>(Val: N);
143}
144
145DICompileUnit *DIBuilder::createCompileUnit(
146 DISourceLanguageName Lang, DIFile *File, StringRef Producer,
147 bool isOptimized, StringRef Flags, unsigned RunTimeVer, StringRef SplitName,
148 DICompileUnit::DebugEmissionKind Kind, uint64_t DWOId,
149 bool SplitDebugInlining, bool DebugInfoForProfiling,
150 DICompileUnit::DebugNameTableKind NameTableKind, bool RangesBaseAddress,
151 StringRef SysRoot, StringRef SDK) {
152
153 assert(!CUNode && "Can only make one compile unit per DIBuilder instance");
154 CUNode = DICompileUnit::getDistinct(
155 Context&: VMContext, SourceLanguage: Lang, File, Producer, IsOptimized: isOptimized, Flags, RuntimeVersion: RunTimeVer,
156 SplitDebugFilename: SplitName, EmissionKind: Kind, EnumTypes: nullptr, RetainedTypes: nullptr, GlobalVariables: nullptr, ImportedEntities: nullptr, Macros: nullptr, DWOId,
157 SplitDebugInlining, DebugInfoForProfiling, NameTableKind,
158 RangesBaseAddress, SysRoot, SDK);
159
160 // Create a named metadata so that it is easier to find cu in a module.
161 NamedMDNode *NMD = M.getOrInsertNamedMetadata(Name: "llvm.dbg.cu");
162 NMD->addOperand(M: CUNode);
163 trackIfUnresolved(N: CUNode);
164 return CUNode;
165}
166
167static DIImportedEntity *
168createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope *Context,
169 Metadata *NS, DIFile *File, unsigned Line, StringRef Name,
170 DINodeArray Elements,
171 SmallVectorImpl<TrackingMDNodeRef> &ImportedModules) {
172 if (Line)
173 assert(File && "Source location has line number but no file");
174 unsigned EntitiesCount = C.pImpl->DIImportedEntitys.size();
175 auto *M = DIImportedEntity::get(Context&: C, Tag, Scope: Context, Entity: cast_or_null<DINode>(Val: NS),
176 File, Line, Name, Elements);
177 if (EntitiesCount < C.pImpl->DIImportedEntitys.size())
178 // A new Imported Entity was just added to the context.
179 // Add it to the Imported Modules list.
180 ImportedModules.emplace_back(Args&: M);
181 return M;
182}
183
184DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context,
185 DINamespace *NS, DIFile *File,
186 unsigned Line,
187 DINodeArray Elements) {
188 return ::createImportedModule(C&: VMContext, Tag: dwarf::DW_TAG_imported_module,
189 Context, NS, File, Line, Name: StringRef(), Elements,
190 ImportedModules&: getImportTrackingVector(S: Context));
191}
192
193DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context,
194 DIImportedEntity *NS,
195 DIFile *File, unsigned Line,
196 DINodeArray Elements) {
197 return ::createImportedModule(C&: VMContext, Tag: dwarf::DW_TAG_imported_module,
198 Context, NS, File, Line, Name: StringRef(), Elements,
199 ImportedModules&: getImportTrackingVector(S: Context));
200}
201
202DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context, DIModule *M,
203 DIFile *File, unsigned Line,
204 DINodeArray Elements) {
205 return ::createImportedModule(C&: VMContext, Tag: dwarf::DW_TAG_imported_module,
206 Context, NS: M, File, Line, Name: StringRef(), Elements,
207 ImportedModules&: getImportTrackingVector(S: Context));
208}
209
210DIImportedEntity *
211DIBuilder::createImportedDeclaration(DIScope *Context, DINode *Decl,
212 DIFile *File, unsigned Line,
213 StringRef Name, DINodeArray Elements) {
214 // Make sure to use the unique identifier based metadata reference for
215 // types that have one.
216 return ::createImportedModule(C&: VMContext, Tag: dwarf::DW_TAG_imported_declaration,
217 Context, NS: Decl, File, Line, Name, Elements,
218 ImportedModules&: getImportTrackingVector(S: Context));
219}
220
221DIFile *DIBuilder::createFile(StringRef Filename, StringRef Directory,
222 std::optional<DIFile::ChecksumInfo<StringRef>> CS,
223 std::optional<StringRef> Source) {
224 return DIFile::get(Context&: VMContext, Filename, Directory, CS, Source);
225}
226
227DIMacro *DIBuilder::createMacro(DIMacroFile *Parent, unsigned LineNumber,
228 unsigned MacroType, StringRef Name,
229 StringRef Value) {
230 assert(!Name.empty() && "Unable to create macro without name");
231 assert((MacroType == dwarf::DW_MACINFO_undef ||
232 MacroType == dwarf::DW_MACINFO_define) &&
233 "Unexpected macro type");
234 auto *M = DIMacro::get(Context&: VMContext, MIType: MacroType, Line: LineNumber, Name, Value);
235 AllMacrosPerParent[Parent].insert(X: M);
236 return M;
237}
238
239DIMacroFile *DIBuilder::createTempMacroFile(DIMacroFile *Parent,
240 unsigned LineNumber, DIFile *File) {
241 auto *MF = DIMacroFile::getTemporary(Context&: VMContext, MIType: dwarf::DW_MACINFO_start_file,
242 Line: LineNumber, File, Elements: DIMacroNodeArray())
243 .release();
244 AllMacrosPerParent[Parent].insert(X: MF);
245 // Add the new temporary DIMacroFile to the macro per parent map as a parent.
246 // This is needed to assure DIMacroFile with no children to have an entry in
247 // the map. Otherwise, it will not be resolved in DIBuilder::finalize().
248 AllMacrosPerParent.insert(KV: {MF, {}});
249 return MF;
250}
251
252DIEnumerator *DIBuilder::createEnumerator(StringRef Name, uint64_t Val,
253 bool IsUnsigned) {
254 assert(!Name.empty() && "Unable to create enumerator without name");
255 return DIEnumerator::get(Context&: VMContext, Value: APInt(64, Val, !IsUnsigned), IsUnsigned,
256 Name);
257}
258
259DIEnumerator *DIBuilder::createEnumerator(StringRef Name, const APSInt &Value) {
260 assert(!Name.empty() && "Unable to create enumerator without name");
261 return DIEnumerator::get(Context&: VMContext, Value: APInt(Value), IsUnsigned: Value.isUnsigned(), Name);
262}
263
264DIBasicType *DIBuilder::createUnspecifiedType(StringRef Name) {
265 assert(!Name.empty() && "Unable to create type without name");
266 return DIBasicType::get(Context&: VMContext, Tag: dwarf::DW_TAG_unspecified_type, Name);
267}
268
269DIBasicType *DIBuilder::createNullPtrType() {
270 return createUnspecifiedType(Name: "decltype(nullptr)");
271}
272
273DIBasicType *DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
274 unsigned Encoding,
275 DINode::DIFlags Flags,
276 uint32_t NumExtraInhabitants,
277 uint32_t DataSizeInBits) {
278 return DIBasicType::get(Context&: VMContext, Tag: dwarf::DW_TAG_base_type, Name, File: nullptr, LineNo: 0,
279 Scope: nullptr, SizeInBits, AlignInBits: 0, Encoding, NumExtraInhabitants,
280 DataSizeInBits, Flags);
281}
282
283DIBasicType *DIBuilder::createBasicType(StringRef Name, DIFile *File,
284 unsigned LineNo, DIScope *Context,
285 uint64_t SizeInBits, unsigned Encoding,
286 DINode::DIFlags Flags,
287 uint32_t NumExtraInhabitants,
288 uint32_t DataSizeInBits) {
289 auto *R = DIBasicType::get(Context&: VMContext, Tag: dwarf::DW_TAG_base_type, Name, File,
290 LineNo, Scope: Context, SizeInBits, AlignInBits: 0, Encoding,
291 NumExtraInhabitants, DataSizeInBits, Flags);
292 if (isa_and_nonnull<DILocalScope>(Val: Context))
293 getSubprogramNodesTrackingVector(S: Context).emplace_back(Args&: R);
294 trackIfUnresolved(N: R);
295 return R;
296}
297
298DIFixedPointType *DIBuilder::createBinaryFixedPointType(
299 StringRef Name, DIFile *File, unsigned LineNo, DIScope *Context,
300 uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding,
301 DINode::DIFlags Flags, int Factor) {
302 auto *R = DIFixedPointType::get(
303 Context&: VMContext, Tag: dwarf::DW_TAG_base_type, Name, File, LineNo, Scope: Context,
304 SizeInBits, AlignInBits, Encoding, Flags,
305 Kind: DIFixedPointType::FixedPointBinary, Factor, Numerator: APInt(), Denominator: APInt());
306 if (isa_and_nonnull<DILocalScope>(Val: Context))
307 getSubprogramNodesTrackingVector(S: Context).emplace_back(Args&: R);
308 trackIfUnresolved(N: R);
309 return R;
310}
311
312DIFixedPointType *DIBuilder::createDecimalFixedPointType(
313 StringRef Name, DIFile *File, unsigned LineNo, DIScope *Context,
314 uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding,
315 DINode::DIFlags Flags, int Factor) {
316 auto *R = DIFixedPointType::get(
317 Context&: VMContext, Tag: dwarf::DW_TAG_base_type, Name, File, LineNo, Scope: Context,
318 SizeInBits, AlignInBits, Encoding, Flags,
319 Kind: DIFixedPointType::FixedPointDecimal, Factor, Numerator: APInt(), Denominator: APInt());
320 if (isa_and_nonnull<DILocalScope>(Val: Context))
321 getSubprogramNodesTrackingVector(S: Context).emplace_back(Args&: R);
322 trackIfUnresolved(N: R);
323 return R;
324}
325
326DIFixedPointType *DIBuilder::createRationalFixedPointType(
327 StringRef Name, DIFile *File, unsigned LineNo, DIScope *Context,
328 uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding,
329 DINode::DIFlags Flags, APInt Numerator, APInt Denominator) {
330 auto *R = DIFixedPointType::get(
331 Context&: VMContext, Tag: dwarf::DW_TAG_base_type, Name, File, LineNo, Scope: Context,
332 SizeInBits, AlignInBits, Encoding, Flags,
333 Kind: DIFixedPointType::FixedPointRational, Factor: 0, Numerator, Denominator);
334 if (isa_and_nonnull<DILocalScope>(Val: Context))
335 getSubprogramNodesTrackingVector(S: Context).emplace_back(Args&: R);
336 trackIfUnresolved(N: R);
337 return R;
338}
339
340DIStringType *DIBuilder::createStringType(StringRef Name, uint64_t SizeInBits) {
341 assert(!Name.empty() && "Unable to create type without name");
342 return DIStringType::get(Context&: VMContext, Tag: dwarf::DW_TAG_string_type, Name,
343 SizeInBits, AlignInBits: 0);
344}
345
346DIStringType *DIBuilder::createStringType(StringRef Name,
347 DIVariable *StringLength,
348 DIExpression *StrLocationExp) {
349 assert(!Name.empty() && "Unable to create type without name");
350 return DIStringType::get(Context&: VMContext, Tag: dwarf::DW_TAG_string_type, Name,
351 StringLength, StringLengthExp: nullptr, StringLocationExp: StrLocationExp, SizeInBits: 0, AlignInBits: 0, Encoding: 0);
352}
353
354DIStringType *DIBuilder::createStringType(StringRef Name,
355 DIExpression *StringLengthExp,
356 DIExpression *StrLocationExp) {
357 assert(!Name.empty() && "Unable to create type without name");
358 return DIStringType::get(Context&: VMContext, Tag: dwarf::DW_TAG_string_type, Name, StringLength: nullptr,
359 StringLengthExp, StringLocationExp: StrLocationExp, SizeInBits: 0, AlignInBits: 0, Encoding: 0);
360}
361
362DIDerivedType *DIBuilder::createQualifiedType(unsigned Tag, DIType *FromTy) {
363 return DIDerivedType::get(Context&: VMContext, Tag, Name: "", File: nullptr, Line: 0, Scope: nullptr, BaseType: FromTy,
364 SizeInBits: (uint64_t)0, AlignInBits: 0, OffsetInBits: (uint64_t)0, DWARFAddressSpace: std::nullopt,
365 PtrAuthData: std::nullopt, Flags: DINode::FlagZero);
366}
367
368DIDerivedType *DIBuilder::createPtrAuthQualifiedType(
369 DIType *FromTy, unsigned Key, bool IsAddressDiscriminated,
370 unsigned ExtraDiscriminator, bool IsaPointer,
371 bool AuthenticatesNullValues) {
372 return DIDerivedType::get(
373 Context&: VMContext, Tag: dwarf::DW_TAG_LLVM_ptrauth_type, Name: "", File: nullptr, Line: 0, Scope: nullptr,
374 BaseType: FromTy, SizeInBits: (uint64_t)0, AlignInBits: 0, OffsetInBits: (uint64_t)0, DWARFAddressSpace: std::nullopt,
375 PtrAuthData: std::optional<DIDerivedType::PtrAuthData>(
376 std::in_place, Key, IsAddressDiscriminated, ExtraDiscriminator,
377 IsaPointer, AuthenticatesNullValues),
378 Flags: DINode::FlagZero);
379}
380
381DIDerivedType *
382DIBuilder::createPointerType(DIType *PointeeTy, uint64_t SizeInBits,
383 uint32_t AlignInBits,
384 std::optional<unsigned> DWARFAddressSpace,
385 StringRef Name, DINodeArray Annotations) {
386 // FIXME: Why is there a name here?
387 return DIDerivedType::get(Context&: VMContext, Tag: dwarf::DW_TAG_pointer_type, Name,
388 File: nullptr, Line: 0, Scope: nullptr, BaseType: PointeeTy, SizeInBits,
389 AlignInBits, OffsetInBits: 0, DWARFAddressSpace, PtrAuthData: std::nullopt,
390 Flags: DINode::FlagZero, ExtraData: nullptr, Annotations);
391}
392
393DIDerivedType *DIBuilder::createMemberPointerType(DIType *PointeeTy,
394 DIType *Base,
395 uint64_t SizeInBits,
396 uint32_t AlignInBits,
397 DINode::DIFlags Flags) {
398 return DIDerivedType::get(Context&: VMContext, Tag: dwarf::DW_TAG_ptr_to_member_type, Name: "",
399 File: nullptr, Line: 0, Scope: nullptr, BaseType: PointeeTy, SizeInBits,
400 AlignInBits, OffsetInBits: 0, DWARFAddressSpace: std::nullopt, PtrAuthData: std::nullopt, Flags,
401 ExtraData: Base);
402}
403
404DIDerivedType *
405DIBuilder::createReferenceType(unsigned Tag, DIType *RTy, uint64_t SizeInBits,
406 uint32_t AlignInBits,
407 std::optional<unsigned> DWARFAddressSpace) {
408 assert(RTy && "Unable to create reference type");
409 return DIDerivedType::get(Context&: VMContext, Tag, Name: "", File: nullptr, Line: 0, Scope: nullptr, BaseType: RTy,
410 SizeInBits, AlignInBits, OffsetInBits: 0, DWARFAddressSpace, PtrAuthData: {},
411 Flags: DINode::FlagZero);
412}
413
414DIDerivedType *DIBuilder::createTypedef(DIType *Ty, StringRef Name,
415 DIFile *File, unsigned LineNo,
416 DIScope *Context, uint32_t AlignInBits,
417 DINode::DIFlags Flags,
418 DINodeArray Annotations) {
419 auto *T = DIDerivedType::get(
420 Context&: VMContext, Tag: dwarf::DW_TAG_typedef, Name, File, Line: LineNo,
421 Scope: getNonCompileUnitScope(N: Context), BaseType: Ty, SizeInBits: (uint64_t)0, AlignInBits,
422 OffsetInBits: (uint64_t)0, DWARFAddressSpace: std::nullopt, PtrAuthData: std::nullopt, Flags, ExtraData: nullptr, Annotations);
423 if (isa_and_nonnull<DILocalScope>(Val: Context))
424 getSubprogramNodesTrackingVector(S: Context).emplace_back(Args&: T);
425 return T;
426}
427
428DIDerivedType *
429DIBuilder::createTemplateAlias(DIType *Ty, StringRef Name, DIFile *File,
430 unsigned LineNo, DIScope *Context,
431 DINodeArray TParams, uint32_t AlignInBits,
432 DINode::DIFlags Flags, DINodeArray Annotations) {
433 auto *T =
434 DIDerivedType::get(Context&: VMContext, Tag: dwarf::DW_TAG_template_alias, Name, File,
435 Line: LineNo, Scope: getNonCompileUnitScope(N: Context), BaseType: Ty,
436 SizeInBits: (uint64_t)0, AlignInBits, OffsetInBits: (uint64_t)0, DWARFAddressSpace: std::nullopt,
437 PtrAuthData: std::nullopt, Flags, ExtraData: TParams.get(), Annotations);
438 if (isa_and_nonnull<DILocalScope>(Val: Context))
439 getSubprogramNodesTrackingVector(S: Context).emplace_back(Args&: T);
440 return T;
441}
442
443DIDerivedType *DIBuilder::createFriend(DIType *Ty, DIType *FriendTy) {
444 assert(Ty && "Invalid type!");
445 assert(FriendTy && "Invalid friend type!");
446 return DIDerivedType::get(Context&: VMContext, Tag: dwarf::DW_TAG_friend, Name: "", File: nullptr, Line: 0, Scope: Ty,
447 BaseType: FriendTy, SizeInBits: (uint64_t)0, AlignInBits: 0, OffsetInBits: (uint64_t)0, DWARFAddressSpace: std::nullopt,
448 PtrAuthData: std::nullopt, Flags: DINode::FlagZero);
449}
450
451DIDerivedType *DIBuilder::createInheritance(DIType *Ty, DIType *BaseTy,
452 uint64_t BaseOffset,
453 uint32_t VBPtrOffset,
454 DINode::DIFlags Flags) {
455 assert(Ty && "Unable to create inheritance");
456 Metadata *ExtraData = ConstantAsMetadata::get(
457 C: ConstantInt::get(Ty: IntegerType::get(C&: VMContext, NumBits: 32), V: VBPtrOffset));
458 return DIDerivedType::get(Context&: VMContext, Tag: dwarf::DW_TAG_inheritance, Name: "", File: nullptr,
459 Line: 0, Scope: Ty, BaseType: BaseTy, SizeInBits: 0, AlignInBits: 0, OffsetInBits: BaseOffset, DWARFAddressSpace: std::nullopt,
460 PtrAuthData: std::nullopt, Flags, ExtraData);
461}
462
463DIDerivedType *DIBuilder::createMemberType(
464 DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
465 uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
466 DINode::DIFlags Flags, DIType *Ty, DINodeArray Annotations) {
467 return DIDerivedType::get(Context&: VMContext, Tag: dwarf::DW_TAG_member, Name, File,
468 Line: LineNumber, Scope: getNonCompileUnitScope(N: Scope), BaseType: Ty,
469 SizeInBits, AlignInBits, OffsetInBits, DWARFAddressSpace: std::nullopt,
470 PtrAuthData: std::nullopt, Flags, ExtraData: nullptr, Annotations);
471}
472
473DIDerivedType *DIBuilder::createMemberType(
474 DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
475 Metadata *SizeInBits, uint32_t AlignInBits, Metadata *OffsetInBits,
476 DINode::DIFlags Flags, DIType *Ty, DINodeArray Annotations) {
477 return DIDerivedType::get(Context&: VMContext, Tag: dwarf::DW_TAG_member, Name, File,
478 Line: LineNumber, Scope: getNonCompileUnitScope(N: Scope), BaseType: Ty,
479 SizeInBits, AlignInBits, OffsetInBits, DWARFAddressSpace: std::nullopt,
480 PtrAuthData: std::nullopt, Flags, ExtraData: nullptr, Annotations);
481}
482
483static ConstantAsMetadata *getConstantOrNull(Constant *C) {
484 if (C)
485 return ConstantAsMetadata::get(C);
486 return nullptr;
487}
488
489DIDerivedType *DIBuilder::createVariantMemberType(
490 DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
491 uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
492 Constant *Discriminant, DINode::DIFlags Flags, DIType *Ty) {
493 // "ExtraData" is overloaded for bit fields and for variants, so
494 // make sure to disallow this.
495 assert((Flags & DINode::FlagBitField) == 0);
496 return DIDerivedType::get(
497 Context&: VMContext, Tag: dwarf::DW_TAG_member, Name, File, Line: LineNumber,
498 Scope: getNonCompileUnitScope(N: Scope), BaseType: Ty, SizeInBits, AlignInBits, OffsetInBits,
499 DWARFAddressSpace: std::nullopt, PtrAuthData: std::nullopt, Flags, ExtraData: getConstantOrNull(C: Discriminant));
500}
501
502DIDerivedType *DIBuilder::createVariantMemberType(DIScope *Scope,
503 DINodeArray Elements,
504 Constant *Discriminant,
505 DIType *Ty) {
506 auto *V = DICompositeType::get(Context&: VMContext, Tag: dwarf::DW_TAG_variant, Name: {}, File: nullptr,
507 Line: 0, Scope: getNonCompileUnitScope(N: Scope), BaseType: {},
508 SizeInBits: (uint64_t)0, AlignInBits: 0, OffsetInBits: (uint64_t)0, Flags: DINode::FlagZero,
509 Elements, RuntimeLang: 0, EnumKind: {}, VTableHolder: nullptr);
510
511 trackIfUnresolved(N: V);
512 return createVariantMemberType(Scope, Name: {}, File: nullptr, LineNumber: 0, SizeInBits: 0, AlignInBits: 0, OffsetInBits: 0, Discriminant,
513 Flags: DINode::FlagZero, Ty: V);
514}
515
516DIDerivedType *DIBuilder::createBitFieldMemberType(
517 DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
518 Metadata *SizeInBits, Metadata *OffsetInBits, uint64_t StorageOffsetInBits,
519 DINode::DIFlags Flags, DIType *Ty, DINodeArray Annotations) {
520 Flags |= DINode::FlagBitField;
521 return DIDerivedType::get(
522 Context&: VMContext, Tag: dwarf::DW_TAG_member, Name, File, Line: LineNumber,
523 Scope: getNonCompileUnitScope(N: Scope), BaseType: Ty, SizeInBits, /*AlignInBits=*/0,
524 OffsetInBits, DWARFAddressSpace: std::nullopt, PtrAuthData: std::nullopt, Flags,
525 ExtraData: ConstantAsMetadata::get(C: ConstantInt::get(Ty: IntegerType::get(C&: VMContext, NumBits: 64),
526 V: StorageOffsetInBits)),
527 Annotations);
528}
529
530DIDerivedType *DIBuilder::createBitFieldMemberType(
531 DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
532 uint64_t SizeInBits, uint64_t OffsetInBits, uint64_t StorageOffsetInBits,
533 DINode::DIFlags Flags, DIType *Ty, DINodeArray Annotations) {
534 Flags |= DINode::FlagBitField;
535 return DIDerivedType::get(
536 Context&: VMContext, Tag: dwarf::DW_TAG_member, Name, File, Line: LineNumber,
537 Scope: getNonCompileUnitScope(N: Scope), BaseType: Ty, SizeInBits, /*AlignInBits=*/0,
538 OffsetInBits, DWARFAddressSpace: std::nullopt, PtrAuthData: std::nullopt, Flags,
539 ExtraData: ConstantAsMetadata::get(C: ConstantInt::get(Ty: IntegerType::get(C&: VMContext, NumBits: 64),
540 V: StorageOffsetInBits)),
541 Annotations);
542}
543
544DIDerivedType *
545DIBuilder::createStaticMemberType(DIScope *Scope, StringRef Name, DIFile *File,
546 unsigned LineNumber, DIType *Ty,
547 DINode::DIFlags Flags, llvm::Constant *Val,
548 unsigned Tag, uint32_t AlignInBits) {
549 Flags |= DINode::FlagStaticMember;
550 return DIDerivedType::get(Context&: VMContext, Tag, Name, File, Line: LineNumber,
551 Scope: getNonCompileUnitScope(N: Scope), BaseType: Ty, SizeInBits: (uint64_t)0,
552 AlignInBits, OffsetInBits: (uint64_t)0, DWARFAddressSpace: std::nullopt,
553 PtrAuthData: std::nullopt, Flags, ExtraData: getConstantOrNull(C: Val));
554}
555
556DIDerivedType *
557DIBuilder::createObjCIVar(StringRef Name, DIFile *File, unsigned LineNumber,
558 uint64_t SizeInBits, uint32_t AlignInBits,
559 uint64_t OffsetInBits, DINode::DIFlags Flags,
560 DIType *Ty, MDNode *PropertyNode) {
561 return DIDerivedType::get(Context&: VMContext, Tag: dwarf::DW_TAG_member, Name, File,
562 Line: LineNumber, Scope: getNonCompileUnitScope(N: File), BaseType: Ty,
563 SizeInBits, AlignInBits, OffsetInBits, DWARFAddressSpace: std::nullopt,
564 PtrAuthData: std::nullopt, Flags, ExtraData: PropertyNode);
565}
566
567DIObjCProperty *
568DIBuilder::createObjCProperty(StringRef Name, DIFile *File, unsigned LineNumber,
569 StringRef GetterName, StringRef SetterName,
570 unsigned PropertyAttributes, DIType *Ty) {
571 return DIObjCProperty::get(Context&: VMContext, Name, File, Line: LineNumber, GetterName,
572 SetterName, Attributes: PropertyAttributes, Type: Ty);
573}
574
575DITemplateTypeParameter *
576DIBuilder::createTemplateTypeParameter(DIScope *Context, StringRef Name,
577 DIType *Ty, bool isDefault) {
578 assert((!Context || isa<DICompileUnit>(Context)) && "Expected compile unit");
579 return DITemplateTypeParameter::get(Context&: VMContext, Name, Type: Ty, IsDefault: isDefault);
580}
581
582static DITemplateValueParameter *
583createTemplateValueParameterHelper(LLVMContext &VMContext, unsigned Tag,
584 DIScope *Context, StringRef Name, DIType *Ty,
585 bool IsDefault, Metadata *MD) {
586 assert((!Context || isa<DICompileUnit>(Context)) && "Expected compile unit");
587 return DITemplateValueParameter::get(Context&: VMContext, Tag, Name, Type: Ty, IsDefault, Value: MD);
588}
589
590DITemplateValueParameter *
591DIBuilder::createTemplateValueParameter(DIScope *Context, StringRef Name,
592 DIType *Ty, bool isDefault,
593 Constant *Val) {
594 return createTemplateValueParameterHelper(
595 VMContext, Tag: dwarf::DW_TAG_template_value_parameter, Context, Name, Ty,
596 IsDefault: isDefault, MD: getConstantOrNull(C: Val));
597}
598
599DITemplateValueParameter *
600DIBuilder::createTemplateTemplateParameter(DIScope *Context, StringRef Name,
601 DIType *Ty, StringRef Val,
602 bool IsDefault) {
603 return createTemplateValueParameterHelper(
604 VMContext, Tag: dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
605 IsDefault, MD: MDString::get(Context&: VMContext, Str: Val));
606}
607
608DITemplateValueParameter *
609DIBuilder::createTemplateParameterPack(DIScope *Context, StringRef Name,
610 DIType *Ty, DINodeArray Val) {
611 return createTemplateValueParameterHelper(
612 VMContext, Tag: dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
613 IsDefault: false, MD: Val.get());
614}
615
616DICompositeType *DIBuilder::createClassType(
617 DIScope *Context, StringRef Name, DIFile *File, unsigned LineNumber,
618 uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
619 DINode::DIFlags Flags, DIType *DerivedFrom, DINodeArray Elements,
620 unsigned RunTimeLang, DIType *VTableHolder, MDNode *TemplateParams,
621 StringRef UniqueIdentifier, DINodeArray Annotations) {
622 assert((!Context || isa<DIScope>(Context)) &&
623 "createClassType should be called with a valid Context");
624
625 auto *R = DICompositeType::get(
626 Context&: VMContext, Tag: dwarf::DW_TAG_class_type, Name, File, Line: LineNumber,
627 Scope: getNonCompileUnitScope(N: Context), BaseType: DerivedFrom, SizeInBits, AlignInBits,
628 OffsetInBits, Flags, Elements, RuntimeLang: RunTimeLang, /*EnumKind=*/std::nullopt,
629 VTableHolder, TemplateParams: cast_or_null<MDTuple>(Val: TemplateParams), Identifier: UniqueIdentifier,
630 Discriminator: nullptr, DataLocation: nullptr, Associated: nullptr, Allocated: nullptr, Rank: nullptr, Annotations);
631 trackIfUnresolved(N: R);
632 if (isa_and_nonnull<DILocalScope>(Val: Context))
633 getSubprogramNodesTrackingVector(S: Context).emplace_back(Args&: R);
634 return R;
635}
636
637DICompositeType *DIBuilder::createStructType(
638 DIScope *Context, StringRef Name, DIFile *File, unsigned LineNumber,
639 Metadata *SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags,
640 DIType *DerivedFrom, DINodeArray Elements, unsigned RunTimeLang,
641 DIType *VTableHolder, StringRef UniqueIdentifier, DIType *Specification,
642 uint32_t NumExtraInhabitants, DINodeArray Annotations) {
643 auto *R = DICompositeType::get(
644 Context&: VMContext, Tag: dwarf::DW_TAG_structure_type, Name, File, Line: LineNumber,
645 Scope: getNonCompileUnitScope(N: Context), BaseType: DerivedFrom, SizeInBits, AlignInBits, OffsetInBits: 0,
646 Flags, Elements, RuntimeLang: RunTimeLang, /*EnumKind=*/std::nullopt, VTableHolder,
647 TemplateParams: nullptr, Identifier: UniqueIdentifier, Discriminator: nullptr, DataLocation: nullptr, Associated: nullptr, Allocated: nullptr, Rank: nullptr,
648 Annotations, Specification, NumExtraInhabitants);
649 trackIfUnresolved(N: R);
650 if (isa_and_nonnull<DILocalScope>(Val: Context))
651 getSubprogramNodesTrackingVector(S: Context).emplace_back(Args&: R);
652 return R;
653}
654
655DICompositeType *DIBuilder::createStructType(
656 DIScope *Context, StringRef Name, DIFile *File, unsigned LineNumber,
657 uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags,
658 DIType *DerivedFrom, DINodeArray Elements, unsigned RunTimeLang,
659 DIType *VTableHolder, StringRef UniqueIdentifier, DIType *Specification,
660 uint32_t NumExtraInhabitants, DINodeArray Annotations) {
661 auto *R = DICompositeType::get(
662 Context&: VMContext, Tag: dwarf::DW_TAG_structure_type, Name, File, Line: LineNumber,
663 Scope: getNonCompileUnitScope(N: Context), BaseType: DerivedFrom, SizeInBits, AlignInBits, OffsetInBits: 0,
664 Flags, Elements, RuntimeLang: RunTimeLang, /*EnumKind=*/std::nullopt, VTableHolder,
665 TemplateParams: nullptr, Identifier: UniqueIdentifier, Discriminator: nullptr, DataLocation: nullptr, Associated: nullptr, Allocated: nullptr, Rank: nullptr,
666 Annotations, Specification, NumExtraInhabitants);
667 trackIfUnresolved(N: R);
668 if (isa_and_nonnull<DILocalScope>(Val: Context))
669 getSubprogramNodesTrackingVector(S: Context).emplace_back(Args&: R);
670 return R;
671}
672
673DICompositeType *DIBuilder::createUnionType(
674 DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
675 uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags,
676 DINodeArray Elements, unsigned RunTimeLang, StringRef UniqueIdentifier,
677 DINodeArray Annotations) {
678 auto *R = DICompositeType::get(
679 Context&: VMContext, Tag: dwarf::DW_TAG_union_type, Name, File, Line: LineNumber,
680 Scope: getNonCompileUnitScope(N: Scope), BaseType: nullptr, SizeInBits, AlignInBits, OffsetInBits: 0, Flags,
681 Elements, RuntimeLang: RunTimeLang, /*EnumKind=*/std::nullopt, VTableHolder: nullptr, TemplateParams: nullptr,
682 Identifier: UniqueIdentifier, Discriminator: nullptr, DataLocation: nullptr, Associated: nullptr, Allocated: nullptr, Rank: nullptr,
683 Annotations);
684 trackIfUnresolved(N: R);
685 if (isa_and_nonnull<DILocalScope>(Val: Scope))
686 getSubprogramNodesTrackingVector(S: Scope).emplace_back(Args&: R);
687 return R;
688}
689
690DICompositeType *
691DIBuilder::createVariantPart(DIScope *Scope, StringRef Name, DIFile *File,
692 unsigned LineNumber, uint64_t SizeInBits,
693 uint32_t AlignInBits, DINode::DIFlags Flags,
694 DIDerivedType *Discriminator, DINodeArray Elements,
695 StringRef UniqueIdentifier) {
696 auto *R = DICompositeType::get(
697 Context&: VMContext, Tag: dwarf::DW_TAG_variant_part, Name, File, Line: LineNumber,
698 Scope: getNonCompileUnitScope(N: Scope), BaseType: nullptr, SizeInBits, AlignInBits, OffsetInBits: 0, Flags,
699 Elements, RuntimeLang: 0, /*EnumKind=*/std::nullopt, VTableHolder: nullptr, TemplateParams: nullptr,
700 Identifier: UniqueIdentifier, Discriminator);
701 trackIfUnresolved(N: R);
702 return R;
703}
704
705DISubroutineType *DIBuilder::createSubroutineType(DITypeArray ParameterTypes,
706 DINode::DIFlags Flags,
707 unsigned CC) {
708 return DISubroutineType::get(Context&: VMContext, Flags, CC, TypeArray: ParameterTypes);
709}
710
711DICompositeType *DIBuilder::createEnumerationType(
712 DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
713 uint64_t SizeInBits, uint32_t AlignInBits, DINodeArray Elements,
714 DIType *UnderlyingType, unsigned RunTimeLang, StringRef UniqueIdentifier,
715 bool IsScoped, std::optional<uint32_t> EnumKind) {
716 auto *CTy = DICompositeType::get(
717 Context&: VMContext, Tag: dwarf::DW_TAG_enumeration_type, Name, File, Line: LineNumber,
718 Scope: getNonCompileUnitScope(N: Scope), BaseType: UnderlyingType, SizeInBits, AlignInBits, OffsetInBits: 0,
719 Flags: IsScoped ? DINode::FlagEnumClass : DINode::FlagZero, Elements,
720 RuntimeLang: RunTimeLang, EnumKind, VTableHolder: nullptr, TemplateParams: nullptr, Identifier: UniqueIdentifier);
721 if (isa_and_nonnull<DILocalScope>(Val: Scope))
722 getSubprogramNodesTrackingVector(S: Scope).emplace_back(Args&: CTy);
723 else
724 EnumTypes.emplace_back(Args&: CTy);
725 trackIfUnresolved(N: CTy);
726 return CTy;
727}
728
729DIDerivedType *DIBuilder::createSetType(DIScope *Scope, StringRef Name,
730 DIFile *File, unsigned LineNo,
731 uint64_t SizeInBits,
732 uint32_t AlignInBits, DIType *Ty) {
733 auto *R = DIDerivedType::get(Context&: VMContext, Tag: dwarf::DW_TAG_set_type, Name, File,
734 Line: LineNo, Scope: getNonCompileUnitScope(N: Scope), BaseType: Ty,
735 SizeInBits, AlignInBits, OffsetInBits: 0, DWARFAddressSpace: std::nullopt,
736 PtrAuthData: std::nullopt, Flags: DINode::FlagZero);
737 trackIfUnresolved(N: R);
738 if (isa_and_nonnull<DILocalScope>(Val: Scope))
739 getSubprogramNodesTrackingVector(S: Scope).emplace_back(Args&: R);
740 return R;
741}
742
743DICompositeType *
744DIBuilder::createArrayType(uint64_t Size, uint32_t AlignInBits, DIType *Ty,
745 DINodeArray Subscripts,
746 PointerUnion<DIExpression *, DIVariable *> DL,
747 PointerUnion<DIExpression *, DIVariable *> AS,
748 PointerUnion<DIExpression *, DIVariable *> AL,
749 PointerUnion<DIExpression *, DIVariable *> RK) {
750 return createArrayType(Scope: nullptr, Name: StringRef(), File: nullptr, LineNumber: 0, Size, AlignInBits,
751 Ty, Subscripts, DataLocation: DL, Associated: AS, Allocated: AL, Rank: RK);
752}
753
754DICompositeType *DIBuilder::createArrayType(
755 DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
756 uint64_t Size, uint32_t AlignInBits, DIType *Ty, DINodeArray Subscripts,
757 PointerUnion<DIExpression *, DIVariable *> DL,
758 PointerUnion<DIExpression *, DIVariable *> AS,
759 PointerUnion<DIExpression *, DIVariable *> AL,
760 PointerUnion<DIExpression *, DIVariable *> RK, Metadata *BitStride) {
761 auto *R = DICompositeType::get(
762 Context&: VMContext, Tag: dwarf::DW_TAG_array_type, Name, File, Line: LineNumber,
763 Scope: getNonCompileUnitScope(N: Scope), BaseType: Ty, SizeInBits: Size, AlignInBits, OffsetInBits: 0, Flags: DINode::FlagZero,
764 Elements: Subscripts, RuntimeLang: 0, /*EnumKind=*/std::nullopt, VTableHolder: nullptr, TemplateParams: nullptr, Identifier: "", Discriminator: nullptr,
765 DataLocation: isa<DIExpression *>(Val: DL) ? (Metadata *)cast<DIExpression *>(Val&: DL)
766 : (Metadata *)cast<DIVariable *>(Val&: DL),
767 Associated: isa<DIExpression *>(Val: AS) ? (Metadata *)cast<DIExpression *>(Val&: AS)
768 : (Metadata *)cast<DIVariable *>(Val&: AS),
769 Allocated: isa<DIExpression *>(Val: AL) ? (Metadata *)cast<DIExpression *>(Val&: AL)
770 : (Metadata *)cast<DIVariable *>(Val&: AL),
771 Rank: isa<DIExpression *>(Val: RK) ? (Metadata *)cast<DIExpression *>(Val&: RK)
772 : (Metadata *)cast<DIVariable *>(Val&: RK),
773 Annotations: nullptr, Specification: nullptr, NumExtraInhabitants: 0, BitStride);
774 trackIfUnresolved(N: R);
775 if (isa_and_nonnull<DILocalScope>(Val: Scope))
776 getSubprogramNodesTrackingVector(S: Scope).emplace_back(Args&: R);
777 return R;
778}
779
780DICompositeType *DIBuilder::createVectorType(uint64_t Size,
781 uint32_t AlignInBits, DIType *Ty,
782 DINodeArray Subscripts,
783 Metadata *BitStride) {
784 auto *R = DICompositeType::get(
785 Context&: VMContext, Tag: dwarf::DW_TAG_array_type, /*Name=*/"",
786 /*File=*/nullptr, /*Line=*/0, /*Scope=*/nullptr, /*BaseType=*/Ty,
787 /*SizeInBits=*/Size, /*AlignInBits=*/AlignInBits, /*OffsetInBits=*/0,
788 /*Flags=*/DINode::FlagVector, /*Elements=*/Subscripts,
789 /*RuntimeLang=*/0, /*EnumKind=*/std::nullopt, /*VTableHolder=*/nullptr,
790 /*TemplateParams=*/nullptr, /*Identifier=*/"",
791 /*Discriminator=*/nullptr, /*DataLocation=*/nullptr,
792 /*Associated=*/nullptr, /*Allocated=*/nullptr, /*Rank=*/nullptr,
793 /*Annotations=*/nullptr, /*Specification=*/nullptr,
794 /*NumExtraInhabitants=*/0,
795 /*BitStride=*/BitStride);
796 trackIfUnresolved(N: R);
797 return R;
798}
799
800DISubprogram *DIBuilder::createArtificialSubprogram(DISubprogram *SP) {
801 auto NewSP = SP->cloneWithFlags(NewFlags: SP->getFlags() | DINode::FlagArtificial);
802 return MDNode::replaceWithDistinct(N: std::move(NewSP));
803}
804
805static DIType *createTypeWithFlags(const DIType *Ty,
806 DINode::DIFlags FlagsToSet) {
807 auto NewTy = Ty->cloneWithFlags(NewFlags: Ty->getFlags() | FlagsToSet);
808 return MDNode::replaceWithUniqued(N: std::move(NewTy));
809}
810
811DIType *DIBuilder::createArtificialType(DIType *Ty) {
812 // FIXME: Restrict this to the nodes where it's valid.
813 if (Ty->isArtificial())
814 return Ty;
815 return createTypeWithFlags(Ty, FlagsToSet: DINode::FlagArtificial);
816}
817
818DIType *DIBuilder::createObjectPointerType(DIType *Ty, bool Implicit) {
819 // FIXME: Restrict this to the nodes where it's valid.
820 if (Ty->isObjectPointer())
821 return Ty;
822 DINode::DIFlags Flags = DINode::FlagObjectPointer;
823
824 if (Implicit)
825 Flags |= DINode::FlagArtificial;
826
827 return createTypeWithFlags(Ty, FlagsToSet: Flags);
828}
829
830void DIBuilder::retainType(DIScope *T) {
831 assert(T && "Expected non-null type");
832 assert((isa<DIType>(T) || (isa<DISubprogram>(T) &&
833 cast<DISubprogram>(T)->isDefinition() == false)) &&
834 "Expected type or subprogram declaration");
835 if (!isa_and_nonnull<DILocalScope>(Val: T->getScope()))
836 AllRetainTypes.emplace_back(Args&: T);
837}
838
839DIBasicType *DIBuilder::createUnspecifiedParameter() { return nullptr; }
840
841DICompositeType *DIBuilder::createForwardDecl(
842 unsigned Tag, StringRef Name, DIScope *Scope, DIFile *F, unsigned Line,
843 unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits,
844 StringRef UniqueIdentifier, std::optional<uint32_t> EnumKind) {
845 // FIXME: Define in terms of createReplaceableForwardDecl() by calling
846 // replaceWithUniqued().
847 auto *RetTy = DICompositeType::get(
848 Context&: VMContext, Tag, Name, File: F, Line, Scope: getNonCompileUnitScope(N: Scope), BaseType: nullptr,
849 SizeInBits, AlignInBits, OffsetInBits: 0, Flags: DINode::FlagFwdDecl, Elements: nullptr, RuntimeLang,
850 /*EnumKind=*/EnumKind, VTableHolder: nullptr, TemplateParams: nullptr, Identifier: UniqueIdentifier);
851 trackIfUnresolved(N: RetTy);
852 if (isa_and_nonnull<DILocalScope>(Val: Scope))
853 getSubprogramNodesTrackingVector(S: Scope).emplace_back(Args&: RetTy);
854 return RetTy;
855}
856
857DICompositeType *DIBuilder::createReplaceableCompositeType(
858 unsigned Tag, StringRef Name, DIScope *Scope, DIFile *F, unsigned Line,
859 unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits,
860 DINode::DIFlags Flags, StringRef UniqueIdentifier, DINodeArray Annotations,
861 std::optional<uint32_t> EnumKind) {
862 auto *RetTy =
863 DICompositeType::getTemporary(
864 Context&: VMContext, Tag, Name, File: F, Line, Scope: getNonCompileUnitScope(N: Scope), BaseType: nullptr,
865 SizeInBits, AlignInBits, OffsetInBits: 0, Flags, Elements: nullptr, RuntimeLang, EnumKind,
866 VTableHolder: nullptr, TemplateParams: nullptr, Identifier: UniqueIdentifier, Discriminator: nullptr, DataLocation: nullptr, Associated: nullptr,
867 Allocated: nullptr, Rank: nullptr, Annotations)
868 .release();
869 trackIfUnresolved(N: RetTy);
870 if (isa_and_nonnull<DILocalScope>(Val: Scope))
871 getSubprogramNodesTrackingVector(S: Scope).emplace_back(Args&: RetTy);
872 return RetTy;
873}
874
875DINodeArray DIBuilder::getOrCreateArray(ArrayRef<Metadata *> Elements) {
876 return MDTuple::get(Context&: VMContext, MDs: Elements);
877}
878
879DIMacroNodeArray
880DIBuilder::getOrCreateMacroArray(ArrayRef<Metadata *> Elements) {
881 return MDTuple::get(Context&: VMContext, MDs: Elements);
882}
883
884DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
885 SmallVector<llvm::Metadata *, 16> Elts;
886 for (Metadata *E : Elements) {
887 if (isa_and_nonnull<MDNode>(Val: E))
888 Elts.push_back(Elt: cast<DIType>(Val: E));
889 else
890 Elts.push_back(Elt: E);
891 }
892 return DITypeArray(MDNode::get(Context&: VMContext, MDs: Elts));
893}
894
895DISubrange *DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
896 auto *LB = ConstantAsMetadata::get(
897 C: ConstantInt::getSigned(Ty: Type::getInt64Ty(C&: VMContext), V: Lo));
898 auto *CountNode = ConstantAsMetadata::get(
899 C: ConstantInt::getSigned(Ty: Type::getInt64Ty(C&: VMContext), V: Count));
900 return DISubrange::get(Context&: VMContext, CountNode, LowerBound: LB, UpperBound: nullptr, Stride: nullptr);
901}
902
903DISubrange *DIBuilder::getOrCreateSubrange(int64_t Lo, Metadata *CountNode) {
904 auto *LB = ConstantAsMetadata::get(
905 C: ConstantInt::getSigned(Ty: Type::getInt64Ty(C&: VMContext), V: Lo));
906 return DISubrange::get(Context&: VMContext, CountNode, LowerBound: LB, UpperBound: nullptr, Stride: nullptr);
907}
908
909DISubrange *DIBuilder::getOrCreateSubrange(Metadata *CountNode, Metadata *LB,
910 Metadata *UB, Metadata *Stride) {
911 return DISubrange::get(Context&: VMContext, CountNode, LowerBound: LB, UpperBound: UB, Stride);
912}
913
914DIGenericSubrange *DIBuilder::getOrCreateGenericSubrange(
915 DIGenericSubrange::BoundType CountNode, DIGenericSubrange::BoundType LB,
916 DIGenericSubrange::BoundType UB, DIGenericSubrange::BoundType Stride) {
917 auto ConvToMetadata = [&](DIGenericSubrange::BoundType Bound) -> Metadata * {
918 return isa<DIExpression *>(Val: Bound) ? (Metadata *)cast<DIExpression *>(Val&: Bound)
919 : (Metadata *)cast<DIVariable *>(Val&: Bound);
920 };
921 return DIGenericSubrange::get(Context&: VMContext, CountNode: ConvToMetadata(CountNode),
922 LowerBound: ConvToMetadata(LB), UpperBound: ConvToMetadata(UB),
923 Stride: ConvToMetadata(Stride));
924}
925
926DISubrangeType *DIBuilder::createSubrangeType(
927 StringRef Name, DIFile *File, unsigned LineNo, DIScope *Scope,
928 uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags,
929 DIType *Ty, Metadata *LowerBound, Metadata *UpperBound, Metadata *Stride,
930 Metadata *Bias) {
931 auto *T = DISubrangeType::get(Context&: VMContext, Name, File, Line: LineNo, Scope,
932 SizeInBits, AlignInBits, Flags, BaseType: Ty, LowerBound,
933 UpperBound, Stride, Bias);
934 if (isa_and_nonnull<DILocalScope>(Val: Scope))
935 getSubprogramNodesTrackingVector(S: Scope).emplace_back(Args&: T);
936 return T;
937}
938
939static void checkGlobalVariableScope(DIScope *Context) {
940#ifndef NDEBUG
941 if (auto *CT =
942 dyn_cast_or_null<DICompositeType>(getNonCompileUnitScope(Context)))
943 assert(CT->getIdentifier().empty() &&
944 "Context of a global variable should not be a type with identifier");
945#endif
946}
947
948DIGlobalVariableExpression *DIBuilder::createGlobalVariableExpression(
949 DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F,
950 unsigned LineNumber, DIType *Ty, bool IsLocalToUnit, bool isDefined,
951 DIExpression *Expr, MDNode *Decl, MDTuple *TemplateParams,
952 uint32_t AlignInBits, DINodeArray Annotations) {
953 checkGlobalVariableScope(Context);
954
955 auto *GV = DIGlobalVariable::getDistinct(
956 Context&: VMContext, Scope: cast_or_null<DIScope>(Val: Context), Name, LinkageName, File: F,
957 Line: LineNumber, Type: Ty, IsLocalToUnit, IsDefinition: isDefined,
958 StaticDataMemberDeclaration: cast_or_null<DIDerivedType>(Val: Decl), TemplateParams, AlignInBits,
959 Annotations);
960 if (!Expr)
961 Expr = createExpression();
962 auto *N = DIGlobalVariableExpression::get(Context&: VMContext, Variable: GV, Expression: Expr);
963 if (isa_and_nonnull<DILocalScope>(Val: Context))
964 getSubprogramNodesTrackingVector(S: Context).emplace_back(Args&: N);
965 else
966 Globals.push_back(Elt: N);
967 return N;
968}
969
970DIGlobalVariable *DIBuilder::createTempGlobalVariableFwdDecl(
971 DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F,
972 unsigned LineNumber, DIType *Ty, bool IsLocalToUnit, MDNode *Decl,
973 MDTuple *TemplateParams, uint32_t AlignInBits) {
974 checkGlobalVariableScope(Context);
975
976 return DIGlobalVariable::getTemporary(
977 Context&: VMContext, Scope: cast_or_null<DIScope>(Val: Context), Name, LinkageName, File: F,
978 Line: LineNumber, Type: Ty, IsLocalToUnit, IsDefinition: false,
979 StaticDataMemberDeclaration: cast_or_null<DIDerivedType>(Val: Decl), TemplateParams, AlignInBits,
980 Annotations: nullptr)
981 .release();
982}
983
984static DILocalVariable *createLocalVariable(
985 LLVMContext &VMContext,
986 SmallVectorImpl<TrackingMDNodeRef> &PreservedNodes,
987 DIScope *Context, StringRef Name, unsigned ArgNo, DIFile *File,
988 unsigned LineNo, DIType *Ty, bool AlwaysPreserve, DINode::DIFlags Flags,
989 uint32_t AlignInBits, DINodeArray Annotations = nullptr) {
990 // FIXME: Why doesn't this check for a subprogram or lexical block (AFAICT
991 // the only valid scopes)?
992 auto *Scope = cast<DILocalScope>(Val: Context);
993 auto *Node = DILocalVariable::get(Context&: VMContext, Scope, Name, File, Line: LineNo, Type: Ty,
994 Arg: ArgNo, Flags, AlignInBits, Annotations);
995 if (AlwaysPreserve) {
996 // The optimizer may remove local variables. If there is an interest
997 // to preserve variable info in such situation then stash it in a
998 // named mdnode.
999 PreservedNodes.emplace_back(Args&: Node);
1000 }
1001 return Node;
1002}
1003
1004DILocalVariable *DIBuilder::createAutoVariable(DIScope *Scope, StringRef Name,
1005 DIFile *File, unsigned LineNo,
1006 DIType *Ty, bool AlwaysPreserve,
1007 DINode::DIFlags Flags,
1008 uint32_t AlignInBits) {
1009 assert(Scope && isa<DILocalScope>(Scope) &&
1010 "Unexpected scope for a local variable.");
1011 return createLocalVariable(
1012 VMContext, PreservedNodes&: getSubprogramNodesTrackingVector(S: Scope), Context: Scope, Name,
1013 /* ArgNo */ 0, File, LineNo, Ty, AlwaysPreserve, Flags, AlignInBits);
1014}
1015
1016DILocalVariable *DIBuilder::createParameterVariable(
1017 DIScope *Scope, StringRef Name, unsigned ArgNo, DIFile *File,
1018 unsigned LineNo, DIType *Ty, bool AlwaysPreserve, DINode::DIFlags Flags,
1019 DINodeArray Annotations) {
1020 assert(ArgNo && "Expected non-zero argument number for parameter");
1021 assert(Scope && isa<DILocalScope>(Scope) &&
1022 "Unexpected scope for a local variable.");
1023 return createLocalVariable(
1024 VMContext, PreservedNodes&: getSubprogramNodesTrackingVector(S: Scope), Context: Scope, Name, ArgNo,
1025 File, LineNo, Ty, AlwaysPreserve, Flags, /*AlignInBits=*/0, Annotations);
1026}
1027
1028DILabel *DIBuilder::createLabel(DIScope *Context, StringRef Name, DIFile *File,
1029 unsigned LineNo, unsigned Column,
1030 bool IsArtificial,
1031 std::optional<unsigned> CoroSuspendIdx,
1032 bool AlwaysPreserve) {
1033 auto *Scope = cast<DILocalScope>(Val: Context);
1034 auto *Node = DILabel::get(Context&: VMContext, Scope, Name, File, Line: LineNo, Column,
1035 IsArtificial, CoroSuspendIdx);
1036
1037 if (AlwaysPreserve) {
1038 /// The optimizer may remove labels. If there is an interest
1039 /// to preserve label info in such situation then append it to
1040 /// the list of retained nodes of the DISubprogram.
1041 getSubprogramNodesTrackingVector(S: Scope).emplace_back(Args&: Node);
1042 }
1043 return Node;
1044}
1045
1046DIExpression *DIBuilder::createExpression(ArrayRef<uint64_t> Addr) {
1047 return DIExpression::get(Context&: VMContext, Elements: Addr);
1048}
1049
1050template <class... Ts>
1051static DISubprogram *getSubprogram(bool IsDistinct, Ts &&...Args) {
1052 if (IsDistinct)
1053 return DISubprogram::getDistinct(std::forward<Ts>(Args)...);
1054 return DISubprogram::get(std::forward<Ts>(Args)...);
1055}
1056
1057DISubprogram *DIBuilder::createFunction(
1058 DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File,
1059 unsigned LineNo, DISubroutineType *Ty, unsigned ScopeLine,
1060 DINode::DIFlags Flags, DISubprogram::DISPFlags SPFlags,
1061 DITemplateParameterArray TParams, DISubprogram *Decl,
1062 DITypeArray ThrownTypes, DINodeArray Annotations, StringRef TargetFuncName,
1063 bool UseKeyInstructions) {
1064 bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
1065 auto *Node = getSubprogram(
1066 /*IsDistinct=*/IsDefinition, Args&: VMContext, Args: getNonCompileUnitScope(N: Context),
1067 Args&: Name, Args&: LinkageName, Args&: File, Args&: LineNo, Args&: Ty, Args&: ScopeLine, Args: nullptr, Args: 0, Args: 0, Args&: Flags,
1068 Args&: SPFlags, Args: IsDefinition ? CUNode : nullptr, Args&: TParams, Args&: Decl, Args: nullptr,
1069 Args&: ThrownTypes, Args&: Annotations, Args&: TargetFuncName, Args&: UseKeyInstructions);
1070
1071 AllSubprograms.push_back(Elt: Node);
1072 trackIfUnresolved(N: Node);
1073 return Node;
1074}
1075
1076DISubprogram *DIBuilder::createTempFunctionFwdDecl(
1077 DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File,
1078 unsigned LineNo, DISubroutineType *Ty, unsigned ScopeLine,
1079 DINode::DIFlags Flags, DISubprogram::DISPFlags SPFlags,
1080 DITemplateParameterArray TParams, DISubprogram *Decl,
1081 DITypeArray ThrownTypes) {
1082 bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
1083 return DISubprogram::getTemporary(Context&: VMContext, Scope: getNonCompileUnitScope(N: Context),
1084 Name, LinkageName, File, Line: LineNo, Type: Ty,
1085 ScopeLine, ContainingType: nullptr, VirtualIndex: 0, ThisAdjustment: 0, Flags, SPFlags,
1086 Unit: IsDefinition ? CUNode : nullptr, TemplateParams: TParams,
1087 Declaration: Decl, RetainedNodes: nullptr, ThrownTypes)
1088 .release();
1089}
1090
1091DISubprogram *DIBuilder::createMethod(
1092 DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F,
1093 unsigned LineNo, DISubroutineType *Ty, unsigned VIndex, int ThisAdjustment,
1094 DIType *VTableHolder, DINode::DIFlags Flags,
1095 DISubprogram::DISPFlags SPFlags, DITemplateParameterArray TParams,
1096 DITypeArray ThrownTypes, bool UseKeyInstructions) {
1097 assert(getNonCompileUnitScope(Context) &&
1098 "Methods should have both a Context and a context that isn't "
1099 "the compile unit.");
1100 // FIXME: Do we want to use different scope/lines?
1101 bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
1102 auto *SP = getSubprogram(
1103 /*IsDistinct=*/IsDefinition, Args&: VMContext, Args: cast<DIScope>(Val: Context), Args&: Name,
1104 Args&: LinkageName, Args&: F, Args&: LineNo, Args&: Ty, Args&: LineNo, Args&: VTableHolder, Args&: VIndex, Args&: ThisAdjustment,
1105 Args&: Flags, Args&: SPFlags, Args: IsDefinition ? CUNode : nullptr, Args&: TParams, Args: nullptr,
1106 Args: nullptr, Args&: ThrownTypes, Args: nullptr, Args: "", Args: IsDefinition && UseKeyInstructions);
1107
1108 AllSubprograms.push_back(Elt: SP);
1109 trackIfUnresolved(N: SP);
1110 return SP;
1111}
1112
1113DICommonBlock *DIBuilder::createCommonBlock(DIScope *Scope,
1114 DIGlobalVariable *Decl,
1115 StringRef Name, DIFile *File,
1116 unsigned LineNo) {
1117 return DICommonBlock::get(Context&: VMContext, Scope, Decl, Name, File, LineNo);
1118}
1119
1120DINamespace *DIBuilder::createNameSpace(DIScope *Scope, StringRef Name,
1121 bool ExportSymbols) {
1122
1123 // It is okay to *not* make anonymous top-level namespaces distinct, because
1124 // all nodes that have an anonymous namespace as their parent scope are
1125 // guaranteed to be unique and/or are linked to their containing
1126 // DICompileUnit. This decision is an explicit tradeoff of link time versus
1127 // memory usage versus code simplicity and may get revisited in the future.
1128 return DINamespace::get(Context&: VMContext, Scope: getNonCompileUnitScope(N: Scope), Name,
1129 ExportSymbols);
1130}
1131
1132DIModule *DIBuilder::createModule(DIScope *Scope, StringRef Name,
1133 StringRef ConfigurationMacros,
1134 StringRef IncludePath, StringRef APINotesFile,
1135 DIFile *File, unsigned LineNo, bool IsDecl) {
1136 return DIModule::get(Context&: VMContext, File, Scope: getNonCompileUnitScope(N: Scope), Name,
1137 ConfigurationMacros, IncludePath, APINotesFile, LineNo,
1138 IsDecl);
1139}
1140
1141DILexicalBlockFile *DIBuilder::createLexicalBlockFile(DIScope *Scope,
1142 DIFile *File,
1143 unsigned Discriminator) {
1144 return DILexicalBlockFile::get(Context&: VMContext, Scope, File, Discriminator);
1145}
1146
1147DILexicalBlock *DIBuilder::createLexicalBlock(DIScope *Scope, DIFile *File,
1148 unsigned Line, unsigned Col) {
1149 // Make these distinct, to avoid merging two lexical blocks on the same
1150 // file/line/column.
1151 return DILexicalBlock::getDistinct(Context&: VMContext, Scope: getNonCompileUnitScope(N: Scope),
1152 File, Line, Column: Col);
1153}
1154
1155DbgInstPtr DIBuilder::insertDeclare(Value *Storage, DILocalVariable *VarInfo,
1156 DIExpression *Expr, const DILocation *DL,
1157 BasicBlock *InsertAtEnd) {
1158 // If this block already has a terminator then insert this intrinsic before
1159 // the terminator. Otherwise, put it at the end of the block.
1160 Instruction *InsertBefore = InsertAtEnd->getTerminatorOrNull();
1161 return insertDeclare(Storage, VarInfo, Expr, DL,
1162 InsertPt: InsertBefore ? InsertBefore->getIterator()
1163 : InsertAtEnd->end());
1164}
1165
1166DbgInstPtr DIBuilder::insertDbgAssign(Instruction *LinkedInstr, Value *Val,
1167 DILocalVariable *SrcVar,
1168 DIExpression *ValExpr, Value *Addr,
1169 DIExpression *AddrExpr,
1170 const DILocation *DL) {
1171 auto *Link = cast_or_null<DIAssignID>(
1172 Val: LinkedInstr->getMetadata(KindID: LLVMContext::MD_DIAssignID));
1173 assert(Link && "Linked instruction must have DIAssign metadata attached");
1174
1175 DbgVariableRecord *DVR = DbgVariableRecord::createDVRAssign(
1176 Val, Variable: SrcVar, Expression: ValExpr, AssignID: Link, Address: Addr, AddressExpression: AddrExpr, DI: DL);
1177 // Insert after LinkedInstr.
1178 BasicBlock::iterator NextIt = std::next(x: LinkedInstr->getIterator());
1179 NextIt.setHeadBit(true);
1180 insertDbgVariableRecord(DVR, InsertPt: NextIt);
1181 return DVR;
1182}
1183
1184/// Initialize IRBuilder for inserting dbg.declare and dbg.value intrinsics.
1185/// This abstracts over the various ways to specify an insert position.
1186static void initIRBuilder(IRBuilder<> &Builder, const DILocation *DL,
1187 InsertPosition InsertPt) {
1188 Builder.SetInsertPoint(TheBB: InsertPt.getBasicBlock(), IP: InsertPt);
1189 Builder.SetCurrentDebugLocation(DL);
1190}
1191
1192static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) {
1193 assert(V && "no value passed to dbg intrinsic");
1194 return MetadataAsValue::get(Context&: VMContext, MD: ValueAsMetadata::get(V));
1195}
1196
1197DbgInstPtr DIBuilder::insertDbgValueIntrinsic(llvm::Value *Val,
1198 DILocalVariable *VarInfo,
1199 DIExpression *Expr,
1200 const DILocation *DL,
1201 InsertPosition InsertPt) {
1202 DbgVariableRecord *DVR =
1203 DbgVariableRecord::createDbgVariableRecord(Location: Val, DV: VarInfo, Expr, DI: DL);
1204 insertDbgVariableRecord(DVR, InsertPt);
1205 return DVR;
1206}
1207
1208DbgInstPtr DIBuilder::insertDeclare(Value *Storage, DILocalVariable *VarInfo,
1209 DIExpression *Expr, const DILocation *DL,
1210 InsertPosition InsertPt) {
1211 assert(VarInfo && "empty or invalid DILocalVariable* passed to dbg.declare");
1212 assert(DL && "Expected debug loc");
1213 assert(DL->getScope()->getSubprogram() ==
1214 VarInfo->getScope()->getSubprogram() &&
1215 "Expected matching subprograms");
1216
1217 DbgVariableRecord *DVR =
1218 DbgVariableRecord::createDVRDeclare(Address: Storage, DV: VarInfo, Expr, DI: DL);
1219 insertDbgVariableRecord(DVR, InsertPt);
1220 return DVR;
1221}
1222
1223DbgInstPtr DIBuilder::insertDeclareValue(Value *Storage,
1224 DILocalVariable *VarInfo,
1225 DIExpression *Expr,
1226 const DILocation *DL,
1227 InsertPosition InsertPt) {
1228 assert(VarInfo &&
1229 "empty or invalid DILocalVariable* passed to dbg.declare_value");
1230 assert(DL && "Expected debug loc");
1231 assert(DL->getScope()->getSubprogram() ==
1232 VarInfo->getScope()->getSubprogram() &&
1233 "Expected matching subprograms");
1234
1235 DbgVariableRecord *DVR =
1236 DbgVariableRecord::createDVRDeclareValue(Address: Storage, DV: VarInfo, Expr, DI: DL);
1237 insertDbgVariableRecord(DVR, InsertPt);
1238 return DVR;
1239}
1240
1241void DIBuilder::insertDbgVariableRecord(DbgVariableRecord *DVR,
1242 InsertPosition InsertPt) {
1243 assert(InsertPt.isValid());
1244 trackIfUnresolved(N: DVR->getVariable());
1245 trackIfUnresolved(N: DVR->getExpression());
1246 if (DVR->isDbgAssign())
1247 trackIfUnresolved(N: DVR->getAddressExpression());
1248
1249 auto *BB = InsertPt.getBasicBlock();
1250 BB->insertDbgRecordBefore(DR: DVR, Here: InsertPt);
1251}
1252
1253Instruction *DIBuilder::insertDbgIntrinsic(llvm::Function *IntrinsicFn,
1254 Value *V, DILocalVariable *VarInfo,
1255 DIExpression *Expr,
1256 const DILocation *DL,
1257 InsertPosition InsertPt) {
1258 assert(IntrinsicFn && "must pass a non-null intrinsic function");
1259 assert(V && "must pass a value to a dbg intrinsic");
1260 assert(VarInfo &&
1261 "empty or invalid DILocalVariable* passed to debug intrinsic");
1262 assert(DL && "Expected debug loc");
1263 assert(DL->getScope()->getSubprogram() ==
1264 VarInfo->getScope()->getSubprogram() &&
1265 "Expected matching subprograms");
1266
1267 trackIfUnresolved(N: VarInfo);
1268 trackIfUnresolved(N: Expr);
1269 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1270 MetadataAsValue::get(Context&: VMContext, MD: VarInfo),
1271 MetadataAsValue::get(Context&: VMContext, MD: Expr)};
1272
1273 IRBuilder<> B(DL->getContext());
1274 initIRBuilder(Builder&: B, DL, InsertPt);
1275 return B.CreateCall(Callee: IntrinsicFn, Args);
1276}
1277
1278DbgInstPtr DIBuilder::insertLabel(DILabel *LabelInfo, const DILocation *DL,
1279 InsertPosition InsertPt) {
1280 assert(LabelInfo && "empty or invalid DILabel* passed to dbg.label");
1281 assert(DL && "Expected debug loc");
1282 assert(DL->getScope()->getSubprogram() ==
1283 LabelInfo->getScope()->getSubprogram() &&
1284 "Expected matching subprograms");
1285
1286 trackIfUnresolved(N: LabelInfo);
1287 DbgLabelRecord *DLR = new DbgLabelRecord(LabelInfo, DL);
1288 if (InsertPt.isValid()) {
1289 auto *BB = InsertPt.getBasicBlock();
1290 BB->insertDbgRecordBefore(DR: DLR, Here: InsertPt);
1291 }
1292 return DLR;
1293}
1294
1295void DIBuilder::replaceVTableHolder(DICompositeType *&T, DIType *VTableHolder) {
1296 {
1297 TypedTrackingMDRef<DICompositeType> N(T);
1298 N->replaceVTableHolder(VTableHolder);
1299 T = N.get();
1300 }
1301
1302 // If this didn't create a self-reference, just return.
1303 if (T != VTableHolder)
1304 return;
1305
1306 // Look for unresolved operands. T will drop RAUW support, orphaning any
1307 // cycles underneath it.
1308 if (T->isResolved())
1309 for (const MDOperand &O : T->operands())
1310 if (auto *N = dyn_cast_or_null<MDNode>(Val: O))
1311 trackIfUnresolved(N);
1312}
1313
1314void DIBuilder::replaceArrays(DICompositeType *&T, DINodeArray Elements,
1315 DINodeArray TParams) {
1316 {
1317 TypedTrackingMDRef<DICompositeType> N(T);
1318 if (Elements)
1319 N->replaceElements(Elements);
1320 if (TParams)
1321 N->replaceTemplateParams(TemplateParams: DITemplateParameterArray(TParams));
1322 T = N.get();
1323 }
1324
1325 // If T isn't resolved, there's no problem.
1326 if (!T->isResolved())
1327 return;
1328
1329 // If T is resolved, it may be due to a self-reference cycle. Track the
1330 // arrays explicitly if they're unresolved, or else the cycles will be
1331 // orphaned.
1332 if (Elements)
1333 trackIfUnresolved(N: Elements.get());
1334 if (TParams)
1335 trackIfUnresolved(N: TParams.get());
1336}
1337