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