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