1//===- llvm/CodeGen/DwarfCompileUnit.cpp - Dwarf Compile Units ------------===//
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 contains support for constructing a dwarf compile unit.
10//
11//===----------------------------------------------------------------------===//
12
13#include "DwarfCompileUnit.h"
14#include "AddressPool.h"
15#include "DwarfExpression.h"
16#include "llvm/ADT/STLExtras.h"
17#include "llvm/ADT/SmallString.h"
18#include "llvm/BinaryFormat/Dwarf.h"
19#include "llvm/CodeGen/AsmPrinter.h"
20#include "llvm/CodeGen/DIE.h"
21#include "llvm/CodeGen/MachineFunction.h"
22#include "llvm/CodeGen/MachineInstr.h"
23#include "llvm/CodeGen/TargetFrameLowering.h"
24#include "llvm/CodeGen/TargetRegisterInfo.h"
25#include "llvm/CodeGen/TargetSubtargetInfo.h"
26#include "llvm/IR/DataLayout.h"
27#include "llvm/IR/DebugInfo.h"
28#include "llvm/IR/GlobalVariable.h"
29#include "llvm/MC/MCAsmInfo.h"
30#include "llvm/MC/MCSection.h"
31#include "llvm/MC/MCStreamer.h"
32#include "llvm/MC/MCSymbol.h"
33#include "llvm/MC/MCSymbolWasm.h"
34#include "llvm/MC/MachineLocation.h"
35#include "llvm/Support/CommandLine.h"
36#include "llvm/Target/TargetLoweringObjectFile.h"
37#include "llvm/Target/TargetMachine.h"
38#include <optional>
39#include <string>
40#include <utility>
41
42using namespace llvm;
43
44/// Query value using AddLinkageNamesToDeclCallOriginsForTuning.
45static cl::opt<cl::boolOrDefault> AddLinkageNamesToDeclCallOrigins(
46 "add-linkage-names-to-declaration-call-origins", cl::Hidden,
47 cl::desc("Add DW_AT_linkage_name to function declaration DIEs "
48 "referenced by DW_AT_call_origin attributes. Enabled by default "
49 "for -gsce debugger tuning."));
50
51static cl::opt<bool> EmitFuncLineTableOffsetsOption(
52 "emit-func-debug-line-table-offsets", cl::Hidden,
53 cl::desc("Include line table offset in function's debug info and emit end "
54 "sequence after each function's line data."),
55 cl::init(Val: false));
56
57static bool AddLinkageNamesToDeclCallOriginsForTuning(const DwarfDebug *DD) {
58 bool EnabledByDefault = DD->tuneForSCE();
59 if (EnabledByDefault)
60 return AddLinkageNamesToDeclCallOrigins != cl::boolOrDefault::BOU_FALSE;
61 return AddLinkageNamesToDeclCallOrigins == cl::boolOrDefault::BOU_TRUE;
62}
63
64static dwarf::Tag GetCompileUnitType(UnitKind Kind, DwarfDebug *DW) {
65
66 // According to DWARF Debugging Information Format Version 5,
67 // 3.1.2 Skeleton Compilation Unit Entries:
68 // "When generating a split DWARF object file (see Section 7.3.2
69 // on page 187), the compilation unit in the .debug_info section
70 // is a "skeleton" compilation unit with the tag DW_TAG_skeleton_unit"
71 if (DW->getDwarfVersion() >= 5 && Kind == UnitKind::Skeleton)
72 return dwarf::DW_TAG_skeleton_unit;
73
74 return dwarf::DW_TAG_compile_unit;
75}
76
77DwarfCompileUnit::DwarfCompileUnit(unsigned UID, const DICompileUnit *Node,
78 AsmPrinter *A, DwarfDebug *DW,
79 DwarfFile *DWU, UnitKind Kind)
80 : DwarfUnit(GetCompileUnitType(Kind, DW), Node, A, DW, DWU, UID) {
81 insertDIE(Desc: Node, D: &getUnitDie());
82 MacroLabelBegin = Asm->createTempSymbol(Name: "cu_macro_begin");
83 assert(CUNode);
84 for (auto *GVE : CUNode->getGlobalVariables())
85 if (auto *GV = GVE->getVariable())
86 GlobalVarScopes.insert(Ptr: GV->getScope());
87}
88
89/// addLabelAddress - Add a dwarf label attribute data and value using
90/// DW_FORM_addr or DW_FORM_GNU_addr_index.
91void DwarfCompileUnit::addLabelAddress(DIE &Die, dwarf::Attribute Attribute,
92 const MCSymbol *Label) {
93 if ((Skeleton || !DD->useSplitDwarf()) && Label)
94 DD->addArangeLabel(SCU: SymbolCU(this, Label));
95
96 // Don't use the address pool in non-fission or in the skeleton unit itself.
97 if ((!DD->useSplitDwarf() || !Skeleton) && DD->getDwarfVersion() < 5)
98 return addLocalLabelAddress(Die, Attribute, Label);
99
100 bool UseAddrOffsetFormOrExpressions =
101 DD->useAddrOffsetForm() || DD->useAddrOffsetExpressions();
102
103 const MCSymbol *Base = nullptr;
104 if (Label->isInSection() && UseAddrOffsetFormOrExpressions)
105 Base = DD->getSectionLabel(S: &Label->getSection());
106
107 if (!Base || Base == Label) {
108 unsigned idx = DD->getAddressPool().getIndex(Sym: Label);
109 addAttribute(Die, Attribute,
110 Form: DD->getDwarfVersion() >= 5 ? dwarf::DW_FORM_addrx
111 : dwarf::DW_FORM_GNU_addr_index,
112 Value: DIEInteger(idx));
113 return;
114 }
115
116 // Could be extended to work with DWARFv4 Split DWARF if that's important for
117 // someone. In that case DW_FORM_data would be used.
118 assert(DD->getDwarfVersion() >= 5 &&
119 "Addr+offset expressions are only valuable when using debug_addr (to "
120 "reduce relocations) available in DWARFv5 or higher");
121 if (DD->useAddrOffsetExpressions()) {
122 auto *Loc = new (DIEValueAllocator) DIEBlock();
123 addPoolOpAddress(Die&: *Loc, Label);
124 addBlock(Die, Attribute, Form: dwarf::DW_FORM_exprloc, Block: Loc);
125 } else
126 addAttribute(Die, Attribute, Form: dwarf::DW_FORM_LLVM_addrx_offset,
127 Value: new (DIEValueAllocator) DIEAddrOffset(
128 DD->getAddressPool().getIndex(Sym: Base), Label, Base));
129}
130
131void DwarfCompileUnit::addLocalLabelAddress(DIE &Die,
132 dwarf::Attribute Attribute,
133 const MCSymbol *Label) {
134 if (Label)
135 addAttribute(Die, Attribute, Form: dwarf::DW_FORM_addr, Value: DIELabel(Label));
136 else
137 addAttribute(Die, Attribute, Form: dwarf::DW_FORM_addr, Value: DIEInteger(0));
138}
139
140unsigned DwarfCompileUnit::getOrCreateSourceID(const DIFile *File) {
141 // If we print assembly, we can't separate .file entries according to
142 // compile units. Thus all files will belong to the default compile unit.
143
144 // FIXME: add a better feature test than hasRawTextSupport. Even better,
145 // extend .file to support this.
146 unsigned CUID = Asm->OutStreamer->hasRawTextSupport() ? 0 : getUniqueID();
147 if (!File)
148 return Asm->OutStreamer->emitDwarfFileDirective(FileNo: 0, Directory: "", Filename: "", Checksum: std::nullopt,
149 Source: std::nullopt, CUID);
150
151 if (LastFile != File) {
152 LastFile = File;
153 LastFileID = Asm->OutStreamer->emitDwarfFileDirective(
154 FileNo: 0, Directory: File->getDirectory(), Filename: File->getFilename(), Checksum: DD->getMD5AsBytes(File),
155 Source: File->getSource(), CUID);
156 }
157 return LastFileID;
158}
159
160DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE(
161 const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
162 // Check for pre-existence.
163 if (DIE *Die = getDIE(D: GV))
164 return Die;
165
166 assert(GV);
167
168 auto *GVContext = GV->getScope();
169 const DIType *GTy = GV->getType();
170
171 auto *CB = GVContext ? dyn_cast<DICommonBlock>(Val: GVContext) : nullptr;
172 DIE *ContextDIE = CB ? getOrCreateCommonBlock(CB, GlobalExprs)
173 : getOrCreateContextDIE(Ty: GVContext);
174
175 // Add to map.
176 DIE *VariableDIE = &createAndAddDIE(Tag: GV->getTag(), Parent&: *ContextDIE, N: GV);
177 DIScope *DeclContext;
178 if (auto *SDMDecl = GV->getStaticDataMemberDeclaration()) {
179 DeclContext = SDMDecl->getScope();
180 assert(SDMDecl->isStaticMember() && "Expected static member decl");
181 assert(GV->isDefinition());
182 // We need the declaration DIE that is in the static member's class.
183 DIE *VariableSpecDIE = getOrCreateStaticMemberDIE(DT: SDMDecl);
184 addDIEEntry(Die&: *VariableDIE, Attribute: dwarf::DW_AT_specification, Entry&: *VariableSpecDIE);
185 // If the global variable's type is different from the one in the class
186 // member type, assume that it's more specific and also emit it.
187 if (GTy != SDMDecl->getBaseType())
188 addType(Entity&: *VariableDIE, Ty: GTy);
189 } else {
190 DeclContext = GV->getScope();
191 // Add name and type.
192 StringRef DisplayName = GV->getDisplayName();
193 if (!DisplayName.empty())
194 addString(Die&: *VariableDIE, Attribute: dwarf::DW_AT_name, Str: GV->getDisplayName());
195 if (GTy)
196 addType(Entity&: *VariableDIE, Ty: GTy);
197
198 // Add scoping info.
199 if (!GV->isLocalToUnit())
200 addFlag(Die&: *VariableDIE, Attribute: dwarf::DW_AT_external);
201
202 // Add line number info.
203 addSourceLine(Die&: *VariableDIE, G: GV);
204 }
205
206 if (!GV->isDefinition())
207 addFlag(Die&: *VariableDIE, Attribute: dwarf::DW_AT_declaration);
208 else
209 addGlobalName(Name: GV->getName(), Die: *VariableDIE, Context: DeclContext);
210
211 addAnnotation(Buffer&: *VariableDIE, Annotations: GV->getAnnotations());
212
213 if (uint32_t AlignInBytes = GV->getAlignInBytes())
214 addUInt(Die&: *VariableDIE, Attribute: dwarf::DW_AT_alignment, Form: dwarf::DW_FORM_udata,
215 Integer: AlignInBytes);
216
217 if (MDTuple *TP = GV->getTemplateParams())
218 addTemplateParams(Buffer&: *VariableDIE, TParams: DINodeArray(TP));
219
220 // Add location.
221 addLocationAttribute(ToDIE: VariableDIE, GV, GlobalExprs);
222
223 return VariableDIE;
224}
225
226void DwarfCompileUnit::addLocationAttribute(
227 DIE *VariableDIE, const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
228 bool addToAccelTable = false;
229 DIELoc *Loc = nullptr;
230 std::optional<unsigned> TargetAddrSpace;
231 std::unique_ptr<DIEDwarfExpression> DwarfExpr;
232 const GlobalVariable *LastGlobal = nullptr;
233 for (const auto &GE : GlobalExprs) {
234 const GlobalVariable *Global = GE.Var;
235 const DIExpression *Expr = GE.Expr;
236
237 // For compatibility with DWARF 3 and earlier,
238 // DW_AT_location(DW_OP_constu, X, DW_OP_stack_value) or
239 // DW_AT_location(DW_OP_consts, X, DW_OP_stack_value) becomes
240 // DW_AT_const_value(X).
241 if (GlobalExprs.size() == 1 && Expr && Expr->isConstant()) {
242 addToAccelTable = true;
243 addConstantValue(
244 Die&: *VariableDIE,
245 Unsigned: DIExpression::SignedOrUnsignedConstant::UnsignedConstant ==
246 *Expr->isConstant(),
247 Val: Expr->getElement(I: 1));
248 break;
249 }
250
251 // We cannot describe the location of dllimport'd variables: the
252 // computation of their address requires loads from the IAT.
253 if (Global && Global->hasDLLImportStorageClass())
254 continue;
255
256 // Nothing to describe without address or constant.
257 if (!Global && (!Expr || !Expr->isConstant()))
258 continue;
259
260 if (Global && Global->isThreadLocal() &&
261 !Asm->getObjFileLowering().supportDebugThreadLocalLocation())
262 continue;
263
264 if (!Loc) {
265 addToAccelTable = true;
266 Loc = new (DIEValueAllocator) DIELoc;
267 DwarfExpr = std::make_unique<DIEDwarfExpression>(args&: *Asm, args&: *this, args&: *Loc);
268 }
269
270 if (Expr) {
271 Expr = DD->adjustExpressionForTarget(Expr, TargetAddrSpace);
272 DwarfExpr->addFragmentOffset(Expr);
273 }
274
275 if (Global) {
276 const MCSymbol *Sym = Asm->getSymbol(GV: Global);
277 // 16-bit platforms like MSP430 and AVR take this path, so sink this
278 // assert to platforms that use it.
279 auto GetPointerSizedFormAndOp = [this]() {
280 unsigned PointerSize = Asm->MAI.getCodePointerSize();
281 assert((PointerSize == 4 || PointerSize == 8) &&
282 "Add support for other sizes if necessary");
283 struct FormAndOp {
284 dwarf::Form Form;
285 dwarf::LocationAtom Op;
286 };
287 return PointerSize == 4
288 ? FormAndOp{.Form: dwarf::DW_FORM_data4, .Op: dwarf::DW_OP_const4u}
289 : FormAndOp{.Form: dwarf::DW_FORM_data8, .Op: dwarf::DW_OP_const8u};
290 };
291 if (Global->isThreadLocal()) {
292 if (Asm->TM.getTargetTriple().isWasm()) {
293 // FIXME This is not guaranteed, but in practice, in static linking,
294 // if present, __tls_base's index is 1. This doesn't hold for dynamic
295 // linking, so TLS variables used in dynamic linking won't have
296 // correct debug info for now. See
297 // https://github.com/llvm/llvm-project/blob/19afbfe33156d211fa959dadeea46cd17b9c723c/lld/wasm/Driver.cpp#L786-L823
298 addWasmRelocBaseGlobal(Loc, GlobalName: "__tls_base", GlobalIndex: 1);
299 addOpAddress(Die&: *Loc, Sym);
300 addUInt(Block&: *Loc, Form: dwarf::DW_FORM_data1, Integer: dwarf::DW_OP_plus);
301 } else if (Asm->TM.useEmulatedTLS()) {
302 // TODO: add debug info for emulated thread local mode.
303 } else {
304 // FIXME: Make this work with -gsplit-dwarf.
305 // Based on GCC's support for TLS:
306 if (!DD->useSplitDwarf()) {
307 auto FormAndOp = GetPointerSizedFormAndOp();
308 // 1) Start with a constNu of the appropriate pointer size
309 addUInt(Block&: *Loc, Form: dwarf::DW_FORM_data1, Integer: FormAndOp.Op);
310 // 2) containing the (relocated) offset of the TLS variable
311 // within the module's TLS block.
312 addExpr(Die&: *Loc, Form: FormAndOp.Form,
313 Expr: Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym));
314 } else {
315 addUInt(Block&: *Loc, Form: dwarf::DW_FORM_data1, Integer: dwarf::DW_OP_GNU_const_index);
316 addUInt(Block&: *Loc, Form: dwarf::DW_FORM_udata,
317 Integer: DD->getAddressPool().getIndex(Sym, /* TLS */ true));
318 }
319 // 3) followed by an OP to make the debugger do a TLS lookup.
320 addUInt(Block&: *Loc, Form: dwarf::DW_FORM_data1,
321 Integer: DD->useGNUTLSOpcode() ? dwarf::DW_OP_GNU_push_tls_address
322 : dwarf::DW_OP_form_tls_address);
323 }
324 } else if (Asm->TM.getTargetTriple().isWasm() &&
325 Asm->TM.getRelocationModel() == Reloc::PIC_) {
326 // FIXME This is not guaranteed, but in practice, if present,
327 // __memory_base's index is 1. See
328 // https://github.com/llvm/llvm-project/blob/19afbfe33156d211fa959dadeea46cd17b9c723c/lld/wasm/Driver.cpp#L786-L823
329 addWasmRelocBaseGlobal(Loc, GlobalName: "__memory_base", GlobalIndex: 1);
330 addOpAddress(Die&: *Loc, Sym);
331 addUInt(Block&: *Loc, Form: dwarf::DW_FORM_data1, Integer: dwarf::DW_OP_plus);
332 } else if ((Asm->TM.getRelocationModel() == Reloc::RWPI ||
333 Asm->TM.getRelocationModel() == Reloc::ROPI_RWPI) &&
334 !Asm->getObjFileLowering()
335 .getKindForGlobal(GO: Global, TM: Asm->TM)
336 .isReadOnly()) {
337 auto FormAndOp = GetPointerSizedFormAndOp();
338 // Constant
339 addUInt(Block&: *Loc, Form: dwarf::DW_FORM_data1, Integer: FormAndOp.Op);
340 // Relocation offset
341 addExpr(Die&: *Loc, Form: FormAndOp.Form,
342 Expr: Asm->getObjFileLowering().getIndirectSymViaRWPI(Sym));
343 // Base register
344 Register BaseReg = Asm->getObjFileLowering().getStaticBase();
345 unsigned DwarfBaseReg =
346 Asm->TM.getMCRegisterInfo().getDwarfRegNum(Reg: BaseReg, isEH: false);
347 addUInt(Block&: *Loc, Form: dwarf::DW_FORM_data1, Integer: dwarf::DW_OP_breg0 + DwarfBaseReg);
348 // Offset from base register
349 addSInt(Die&: *Loc, Form: dwarf::DW_FORM_sdata, Integer: 0);
350 // Operation
351 addUInt(Block&: *Loc, Form: dwarf::DW_FORM_data1, Integer: dwarf::DW_OP_plus);
352 } else {
353 DD->addArangeLabel(SCU: SymbolCU(this, Sym));
354 addOpAddress(Die&: *Loc, Sym);
355 }
356 LastGlobal = Global;
357 }
358 // Global variables attached to symbols are memory locations.
359 // It would be better if this were unconditional, but malformed input that
360 // mixes non-fragments and fragments for the same variable is too expensive
361 // to detect in the verifier.
362 if (DwarfExpr->isUnknownLocation())
363 DwarfExpr->setMemoryLocationKind();
364 DwarfExpr->addExpression(Expr);
365 }
366 DD->addTargetVariableAttributes(CU&: *this, Die&: *VariableDIE, TargetAddrSpace,
367 VarLocKind: DwarfDebug::VariableLocationKind::Global,
368 GV: LastGlobal);
369 if (Loc)
370 addBlock(Die&: *VariableDIE, Attribute: dwarf::DW_AT_location, Loc: DwarfExpr->finalize());
371
372 if (DD->useAllLinkageNames())
373 addLinkageName(Die&: *VariableDIE, LinkageName: GV->getLinkageName());
374
375 if (addToAccelTable) {
376 DD->addAccelName(Unit: *this, NameTableKind: CUNode->getNameTableKind(), Name: GV->getName(),
377 Die: *VariableDIE);
378
379 // If the linkage name is different than the name, go ahead and output
380 // that as well into the name table.
381 if (GV->getLinkageName() != "" && GV->getName() != GV->getLinkageName() &&
382 DD->useAllLinkageNames())
383 DD->addAccelName(Unit: *this, NameTableKind: CUNode->getNameTableKind(), Name: GV->getLinkageName(),
384 Die: *VariableDIE);
385 }
386}
387
388DIE *DwarfCompileUnit::getOrCreateCommonBlock(
389 const DICommonBlock *CB, ArrayRef<GlobalExpr> GlobalExprs) {
390 // Check for pre-existence.
391 if (DIE *NDie = getDIE(D: CB))
392 return NDie;
393 DIE *ContextDIE = getOrCreateContextDIE(Ty: CB->getScope());
394 DIE &NDie = createAndAddDIE(Tag: dwarf::DW_TAG_common_block, Parent&: *ContextDIE, N: CB);
395 StringRef Name = CB->getName().empty() ? "_BLNK_" : CB->getName();
396 addString(Die&: NDie, Attribute: dwarf::DW_AT_name, Str: Name);
397 addGlobalName(Name, Die: NDie, Context: CB->getScope());
398 if (CB->getFile())
399 addSourceLine(Die&: NDie, Line: CB->getLineNo(), /*Column*/ 0, File: CB->getFile());
400 if (DIGlobalVariable *V = CB->getDecl())
401 getCU().addLocationAttribute(VariableDIE: &NDie, GV: V, GlobalExprs);
402 return &NDie;
403}
404
405void DwarfCompileUnit::addRange(RangeSpan Range) {
406 DD->insertSectionLabel(S: Range.Begin);
407
408 auto *PrevCU = DD->getPrevCU();
409 bool SameAsPrevCU = this == PrevCU;
410 DD->setPrevCU(this);
411 // If we have no current ranges just add the range and return, otherwise,
412 // check the current section and CU against the previous section and CU we
413 // emitted into and the subprogram was contained within. If these are the
414 // same then extend our current range, otherwise add this as a new range.
415 if (CURanges.empty() || !SameAsPrevCU ||
416 (&CURanges.back().End->getSection() !=
417 &Range.End->getSection())) {
418 // Before a new range is added, always terminate the prior line table.
419 if (PrevCU)
420 DD->terminateLineTable(CU: PrevCU);
421 CURanges.push_back(Elt: Range);
422 return;
423 }
424
425 CURanges.back().End = Range.End;
426}
427
428void DwarfCompileUnit::initStmtList() {
429 if (CUNode->isDebugDirectivesOnly())
430 return;
431
432 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
433 if (DD->useSectionsAsReferences()) {
434 LineTableStartSym = TLOF.getDwarfLineSection()->getBeginSymbol();
435 } else {
436 LineTableStartSym =
437 Asm->OutStreamer->getDwarfLineTableSymbol(CUID: getUniqueID());
438 }
439
440 // DW_AT_stmt_list is a offset of line number information for this
441 // compile unit in debug_line section. For split dwarf this is
442 // left in the skeleton CU and so not included.
443 // The line table entries are not always emitted in assembly, so it
444 // is not okay to use line_table_start here.
445 addSectionLabel(Die&: getUnitDie(), Attribute: dwarf::DW_AT_stmt_list, Label: LineTableStartSym,
446 Sec: TLOF.getDwarfLineSection()->getBeginSymbol());
447}
448
449void DwarfCompileUnit::applyStmtList(DIE &D) {
450 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
451 addSectionLabel(Die&: D, Attribute: dwarf::DW_AT_stmt_list, Label: LineTableStartSym,
452 Sec: TLOF.getDwarfLineSection()->getBeginSymbol());
453}
454
455void DwarfCompileUnit::attachLowHighPC(DIE &D, const MCSymbol *Begin,
456 const MCSymbol *End) {
457 assert(Begin && "Begin label should not be null!");
458 assert(End && "End label should not be null!");
459 assert(Begin->isDefined() && "Invalid starting label");
460 assert(End->isDefined() && "Invalid end label");
461
462 addLabelAddress(Die&: D, Attribute: dwarf::DW_AT_low_pc, Label: Begin);
463 if (DD->getDwarfVersion() >= 4 &&
464 (!isDwoUnit() || !llvm::isRangeRelaxable(Begin, End))) {
465 addLabelDelta(Die&: D, Attribute: dwarf::DW_AT_high_pc, Hi: End, Lo: Begin);
466 return;
467 }
468 addLabelAddress(Die&: D, Attribute: dwarf::DW_AT_high_pc, Label: End);
469}
470
471// Add info for Wasm-global-based relocation.
472// 'GlobalIndex' is used for split dwarf, which currently relies on a few
473// assumptions that are not guaranteed in a formal way but work in practice.
474void DwarfCompileUnit::addWasmRelocBaseGlobal(DIELoc *Loc, StringRef GlobalName,
475 uint64_t GlobalIndex) {
476 // FIXME: duplicated from Target/WebAssembly/WebAssembly.h
477 // don't want to depend on target specific headers in this code?
478 const unsigned TI_GLOBAL_RELOC = 3;
479 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
480 auto *Sym =
481 static_cast<MCSymbolWasm *>(Asm->GetExternalSymbolSymbol(Sym: GlobalName));
482 // FIXME: this repeats what WebAssemblyMCInstLower::
483 // GetExternalSymbolSymbol does, since if there's no code that
484 // refers to this symbol, we have to set it here.
485 Sym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
486 Sym->setGlobalType(wasm::WasmGlobalType{
487 .Type: static_cast<uint8_t>(PointerSize == 4 ? wasm::WASM_TYPE_I32
488 : wasm::WASM_TYPE_I64),
489 .Mutable: true});
490 addUInt(Block&: *Loc, Form: dwarf::DW_FORM_data1, Integer: dwarf::DW_OP_WASM_location);
491 addSInt(Die&: *Loc, Form: dwarf::DW_FORM_sdata, Integer: TI_GLOBAL_RELOC);
492 if (!isDwoUnit()) {
493 addLabel(Die&: *Loc, Form: dwarf::DW_FORM_data4, Label: Sym);
494 } else {
495 // FIXME: when writing dwo, we need to avoid relocations. Probably
496 // the "right" solution is to treat globals the way func and data
497 // symbols are (with entries in .debug_addr).
498 // For now we hardcode the indices in the callsites. Global indices are not
499 // fixed, but in practice a few are fixed; for example, __stack_pointer is
500 // always index 0.
501 addUInt(Block&: *Loc, Form: dwarf::DW_FORM_data4, Integer: GlobalIndex);
502 }
503}
504
505// Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
506// and DW_AT_high_pc attributes. If there are global variables in this
507// scope then create and insert DIEs for these variables.
508DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP,
509 const Function &F,
510 MCSymbol *LineTableSym) {
511 DIE *SPDie = getOrCreateSubprogramDIE(SP, F: &F, Minimal: includeMinimalInlineScopes());
512 SmallVector<RangeSpan, 2> BB_List;
513 // If basic block sections are on, ranges for each basic block section has
514 // to be emitted separately.
515 for (const auto &R : Asm->MBBSectionRanges)
516 BB_List.push_back(Elt: {.Begin: R.second.BeginLabel, .End: R.second.EndLabel});
517
518 attachRangesOrLowHighPC(D&: *SPDie, Ranges: BB_List);
519
520 if (DD->useAppleExtensionAttributes() &&
521 !DD->getCurrentFunction()->disableFramePointerElim())
522 addFlag(Die&: *SPDie, Attribute: dwarf::DW_AT_APPLE_omit_frame_ptr);
523
524 if (emitFuncLineTableOffsets() && LineTableSym) {
525 MCSymbol *Symbol =
526 Asm->getObjFileLowering().getDwarfLineSection()->getBeginSymbol();
527 addSectionLabel(Die&: *SPDie, Attribute: dwarf::DW_AT_LLVM_stmt_sequence, Label: LineTableSym,
528 Sec: Symbol);
529 }
530
531 // Only include DW_AT_frame_base in full debug info
532 if (!includeMinimalInlineScopes()) {
533 const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering();
534 TargetFrameLowering::DwarfFrameBase FrameBase =
535 TFI->getDwarfFrameBase(MF: *Asm->MF);
536 switch (FrameBase.Kind) {
537 case TargetFrameLowering::DwarfFrameBase::Register: {
538 if (Register::isPhysicalRegister(Reg: FrameBase.Location.Reg)) {
539 MachineLocation Location(FrameBase.Location.Reg);
540 addAddress(Die&: *SPDie, Attribute: dwarf::DW_AT_frame_base, Location);
541 }
542 break;
543 }
544 case TargetFrameLowering::DwarfFrameBase::CFA: {
545 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
546 addUInt(Block&: *Loc, Form: dwarf::DW_FORM_data1, Integer: dwarf::DW_OP_call_frame_cfa);
547 if (FrameBase.Location.Offset != 0) {
548 addUInt(Block&: *Loc, Form: dwarf::DW_FORM_data1, Integer: dwarf::DW_OP_consts);
549 addSInt(Die&: *Loc, Form: dwarf::DW_FORM_sdata, Integer: FrameBase.Location.Offset);
550 addUInt(Block&: *Loc, Form: dwarf::DW_FORM_data1, Integer: dwarf::DW_OP_plus);
551 }
552 addBlock(Die&: *SPDie, Attribute: dwarf::DW_AT_frame_base, Loc);
553 break;
554 }
555 case TargetFrameLowering::DwarfFrameBase::WasmFrameBase: {
556 // FIXME: duplicated from Target/WebAssembly/WebAssembly.h
557 const unsigned TI_GLOBAL_RELOC = 3;
558 if (FrameBase.Location.WasmLoc.Kind == TI_GLOBAL_RELOC) {
559 // These need to be relocatable.
560 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
561 assert(FrameBase.Location.WasmLoc.Index == 0); // Only SP so far.
562 // For now, since we only ever use index 0, this should work as-is.
563 addWasmRelocBaseGlobal(Loc, GlobalName: "__stack_pointer",
564 GlobalIndex: FrameBase.Location.WasmLoc.Index);
565 addUInt(Block&: *Loc, Form: dwarf::DW_FORM_data1, Integer: dwarf::DW_OP_stack_value);
566 addBlock(Die&: *SPDie, Attribute: dwarf::DW_AT_frame_base, Loc);
567 } else {
568 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
569 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
570 DIExpressionCursor Cursor({});
571 DwarfExpr.addWasmLocation(Index: FrameBase.Location.WasmLoc.Kind,
572 Offset: FrameBase.Location.WasmLoc.Index);
573 DwarfExpr.addExpression(Expr: std::move(Cursor));
574 addBlock(Die&: *SPDie, Attribute: dwarf::DW_AT_frame_base, Loc: DwarfExpr.finalize());
575 }
576 break;
577 }
578 }
579 }
580
581 // Add name to the name table, we do this here because we're guaranteed
582 // to have concrete versions of our DW_TAG_subprogram nodes.
583 DD->addSubprogramNames(Unit: *this, NameTableKind: CUNode->getNameTableKind(), SP, Die&: *SPDie);
584
585 return *SPDie;
586}
587
588// Construct a DIE for this scope.
589void DwarfCompileUnit::constructScopeDIE(LexicalScope *Scope,
590 DIE &ParentScopeDIE) {
591 if (!Scope || !Scope->getScopeNode())
592 return;
593
594 auto *DS = Scope->getScopeNode();
595
596 assert((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) &&
597 "Only handle inlined subprograms here, use "
598 "constructSubprogramScopeDIE for non-inlined "
599 "subprograms");
600
601 // Emit inlined subprograms.
602 if (Scope->getParent() && isa<DISubprogram>(Val: DS)) {
603 DIE *ScopeDIE = constructInlinedScopeDIE(Scope, ParentScopeDIE);
604 assert(ScopeDIE && "Scope DIE should not be null.");
605 createAndAddScopeChildren(Scope, ScopeDIE&: *ScopeDIE);
606 return;
607 }
608
609 // Early exit when we know the scope DIE is going to be null.
610 if (DD->isLexicalScopeDIENull(Scope))
611 return;
612
613 // Emit lexical blocks.
614 DIE *ScopeDIE = getOrCreateLexicalBlockDIE(Scope, ParentDIE&: ParentScopeDIE);
615 assert(ScopeDIE && "Scope DIE should not be null.");
616
617 createAndAddScopeChildren(Scope, ScopeDIE&: *ScopeDIE);
618}
619
620void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE,
621 SmallVector<RangeSpan, 2> Range) {
622
623 HasRangeLists = true;
624
625 // Add the range list to the set of ranges to be emitted.
626 auto IndexAndList =
627 (DD->getDwarfVersion() < 5 && Skeleton ? Skeleton->DU : DU)
628 ->addRange(CU: *(Skeleton ? Skeleton : this), R: std::move(Range));
629
630 uint32_t Index = IndexAndList.first;
631 auto &List = *IndexAndList.second;
632
633 // Under fission, ranges are specified by constant offsets relative to the
634 // CU's DW_AT_GNU_ranges_base.
635 // FIXME: For DWARF v5, do not generate the DW_AT_ranges attribute under
636 // fission until we support the forms using the .debug_addr section
637 // (DW_RLE_startx_endx etc.).
638 if (DD->getDwarfVersion() >= 5)
639 addUInt(Die&: ScopeDIE, Attribute: dwarf::DW_AT_ranges, Form: dwarf::DW_FORM_rnglistx, Integer: Index);
640 else {
641 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
642 const MCSymbol *RangeSectionSym =
643 TLOF.getDwarfRangesSection()->getBeginSymbol();
644 addSectionLabel(Die&: ScopeDIE, Attribute: dwarf::DW_AT_ranges, Label: List.Label, Sec: RangeSectionSym);
645 }
646}
647
648void DwarfCompileUnit::attachRangesOrLowHighPC(
649 DIE &Die, SmallVector<RangeSpan, 2> Ranges) {
650 assert(!Ranges.empty());
651 if (!DD->useRangesSection() ||
652 (Ranges.size() == 1 &&
653 (!DD->alwaysUseRanges(*this) ||
654 DD->getSectionLabel(S: &Ranges.front().Begin->getSection()) ==
655 Ranges.front().Begin))) {
656 const RangeSpan &Front = Ranges.front();
657 const RangeSpan &Back = Ranges.back();
658 attachLowHighPC(D&: Die, Begin: Front.Begin, End: Back.End);
659 } else
660 addScopeRangeList(ScopeDIE&: Die, Range: std::move(Ranges));
661}
662
663void DwarfCompileUnit::attachRangesOrLowHighPC(
664 DIE &Die, const SmallVectorImpl<InsnRange> &Ranges) {
665 SmallVector<RangeSpan, 2> List;
666 List.reserve(N: Ranges.size());
667 for (const InsnRange &R : Ranges) {
668 auto *BeginLabel = DD->getLabelBeforeInsn(MI: R.first);
669 auto *EndLabel = DD->getLabelAfterInsn(MI: R.second);
670
671 const auto *BeginMBB = R.first->getParent();
672 const auto *EndMBB = R.second->getParent();
673
674 const auto *MBB = BeginMBB;
675 // Basic block sections allows basic block subsets to be placed in unique
676 // sections. For each section, the begin and end label must be added to the
677 // list. If there is more than one range, debug ranges must be used.
678 // Otherwise, low/high PC can be used.
679 // FIXME: Debug Info Emission depends on block order and this assumes that
680 // the order of blocks will be frozen beyond this point.
681 do {
682 if (MBB->sameSection(MBB: EndMBB) || MBB->isEndSection()) {
683 auto MBBSectionRange = Asm->MBBSectionRanges[MBB->getSectionID()];
684 List.push_back(
685 Elt: {.Begin: MBB->sameSection(MBB: BeginMBB) ? BeginLabel
686 : MBBSectionRange.BeginLabel,
687 .End: MBB->sameSection(MBB: EndMBB) ? EndLabel : MBBSectionRange.EndLabel});
688 }
689 if (MBB->sameSection(MBB: EndMBB))
690 break;
691 MBB = MBB->getNextNode();
692 } while (true);
693 }
694 attachRangesOrLowHighPC(Die, Ranges: std::move(List));
695}
696
697DIE *DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope,
698 DIE &ParentScopeDIE) {
699 assert(Scope->getScopeNode());
700 auto *DS = Scope->getScopeNode();
701 auto *InlinedSP = getDISubprogram(Scope: DS);
702 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
703 // was inlined from another compile unit.
704 DIE *OriginDIE = getAbstractScopeDIEs()[InlinedSP];
705 assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.");
706
707 auto ScopeDIE = DIE::get(Alloc&: DIEValueAllocator, Tag: dwarf::DW_TAG_inlined_subroutine);
708 ParentScopeDIE.addChild(Child: ScopeDIE);
709 addDIEEntry(Die&: *ScopeDIE, Attribute: dwarf::DW_AT_abstract_origin, Entry&: *OriginDIE);
710
711 attachRangesOrLowHighPC(Die&: *ScopeDIE, Ranges: Scope->getRanges());
712
713 // Add the call site information to the DIE.
714 const DILocation *IA = Scope->getInlinedAt();
715 addUInt(Die&: *ScopeDIE, Attribute: dwarf::DW_AT_call_file, Form: std::nullopt,
716 Integer: getOrCreateSourceID(File: IA->getFile()));
717 addUInt(Die&: *ScopeDIE, Attribute: dwarf::DW_AT_call_line, Form: std::nullopt, Integer: IA->getLine());
718 if (IA->getColumn())
719 addUInt(Die&: *ScopeDIE, Attribute: dwarf::DW_AT_call_column, Form: std::nullopt, Integer: IA->getColumn());
720 if (IA->getDiscriminator() && DD->getDwarfVersion() >= 4)
721 addUInt(Die&: *ScopeDIE, Attribute: dwarf::DW_AT_GNU_discriminator, Form: std::nullopt,
722 Integer: IA->getDiscriminator());
723
724 // Add name to the name table, we do this here because we're guaranteed
725 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
726 DD->addSubprogramNames(Unit: *this, NameTableKind: CUNode->getNameTableKind(), SP: InlinedSP,
727 Die&: *ScopeDIE);
728
729 return ScopeDIE;
730}
731
732DIE *DwarfCompileUnit::getOrCreateLexicalBlockDIE(LexicalScope *Scope,
733 DIE &ParentScopeDIE) {
734 if (DD->isLexicalScopeDIENull(Scope))
735 return nullptr;
736 const auto *DS = Scope->getScopeNode();
737
738 auto ScopeDIE = DIE::get(Alloc&: DIEValueAllocator, Tag: dwarf::DW_TAG_lexical_block);
739 ParentScopeDIE.addChild(Child: ScopeDIE);
740
741 if (Scope->isAbstractScope()) {
742 assert(!getAbstractScopeDIEs().count(DS) &&
743 "Abstract DIE for this scope exists!");
744 getAbstractScopeDIEs()[DS] = ScopeDIE;
745 return ScopeDIE;
746 }
747 if (!Scope->getInlinedAt()) {
748 assert(!LexicalBlockDIEs.count(DS) &&
749 "Concrete out-of-line DIE for this scope exists!");
750 LexicalBlockDIEs[DS] = ScopeDIE;
751 } else {
752 InlinedLocalScopeDIEs[DS].push_back(Elt: ScopeDIE);
753 }
754
755 attachRangesOrLowHighPC(Die&: *ScopeDIE, Ranges: Scope->getRanges());
756
757 return ScopeDIE;
758}
759
760DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV, bool Abstract) {
761 auto *VariableDie = DIE::get(Alloc&: DIEValueAllocator, Tag: DV.getTag());
762 insertDIE(Desc: DV.getVariable(), D: VariableDie);
763 DV.setDIE(*VariableDie);
764 // Abstract variables don't get common attributes later, so apply them now.
765 if (Abstract) {
766 applyCommonDbgVariableAttributes(Var: DV, VariableDie&: *VariableDie);
767 } else {
768 std::visit(
769 visitor: [&](const auto &V) {
770 applyConcreteDbgVariableAttributes(V, DV, *VariableDie);
771 },
772 variants&: DV.asVariant());
773 }
774 return VariableDie;
775}
776
777static const DIType *resolveTypeQualifiers(const DIType *Ty) {
778 while (const auto *DT = dyn_cast_or_null<DIDerivedType>(Val: Ty)) {
779 switch (DT->getTag()) {
780 case dwarf::DW_TAG_typedef:
781 case dwarf::DW_TAG_const_type:
782 case dwarf::DW_TAG_volatile_type:
783 case dwarf::DW_TAG_restrict_type:
784 case dwarf::DW_TAG_atomic_type:
785 Ty = DT->getBaseType();
786 continue;
787 default:
788 return Ty;
789 }
790 }
791 return Ty;
792}
793
794bool DwarfCompileUnit::emitImplicitPointerLocation(const Loc::Single &Single,
795 const DbgVariable &DV,
796 DIE &VariableDie) {
797 const DIExpression *Expr = Single.getExpr();
798 if (!Expr)
799 return false;
800
801 // Only handle the simple case where DW_OP_LLVM_implicit_pointer is the
802 // sole operation (or followed only by DW_OP_LLVM_fragment).
803 //
804 // Multi-level implicit pointers (e.g., int **pp where both levels are
805 // optimized away) would require stacking multiple implicit_pointer ops
806 // in one expression and unwinding them into a chain of artificial DIEs.
807 // This is left for future work.
808 //
809 // Location list support (Loc::Multi) is not yet handled.
810 auto ExprOps = Expr->expr_ops();
811 auto FirstOp = ExprOps.begin();
812 if (FirstOp == ExprOps.end() ||
813 FirstOp->getOp() != dwarf::DW_OP_LLVM_implicit_pointer)
814 return false;
815
816 if (DD->getDwarfVersion() < 4)
817 return false;
818
819 const DbgValueLoc &DVal = Single.getValueLoc();
820 if (DVal.isVariadic())
821 return false;
822
823 assert(!DVal.getLocEntries().empty() &&
824 "Non-variadic value must have one entry");
825 const DbgValueLocEntry &Entry = DVal.getLocEntries()[0];
826
827 // Resolve the variable's type, stripping qualifiers and typedefs,
828 // to find the pointer or reference type underneath.
829 // The verifier rejects cyclic type references, so this loop terminates.
830 const DIDerivedType *PtrTy =
831 dyn_cast_or_null<DIDerivedType>(Val: resolveTypeQualifiers(Ty: DV.getType()));
832 if (!PtrTy)
833 return false;
834
835 if (PtrTy->getTag() != dwarf::DW_TAG_pointer_type &&
836 PtrTy->getTag() != dwarf::DW_TAG_reference_type &&
837 PtrTy->getTag() != dwarf::DW_TAG_rvalue_reference_type)
838 return false;
839
840 const DIType *PointeeTy = PtrTy->getBaseType();
841
842 // Try to reuse an existing artificial DIE for constant integer values.
843 // This avoids duplicate DIEs when multiple pointer variables reference
844 // the same constant (e.g., after ArgumentPromotion promotes the same
845 // struct member for two different pointer parameters).
846 DIE *ArtificialDIEPtr = nullptr;
847 if (Entry.isInt() && PointeeTy) {
848 auto It = ImplicitPointerDIEs.find(Val: {PointeeTy, Entry.getInt()});
849 if (It != ImplicitPointerDIEs.end())
850 ArtificialDIEPtr = It->second;
851 }
852
853 if (!ArtificialDIEPtr) {
854 // Check that the value can be described before creating a DIE for it.
855 if (!Entry.isLocation() && !Entry.isInt() && !Entry.isConstantFP())
856 return false;
857
858 DIE &ProcDIE = createAndAddDIE(Tag: dwarf::DW_TAG_dwarf_procedure, Parent&: getUnitDie());
859
860 if (Entry.isLocation()) {
861 addAddress(Die&: ProcDIE, Attribute: dwarf::DW_AT_location, Location: Entry.getLoc());
862 } else if (Entry.isInt()) {
863 if (PointeeTy)
864 addConstantValue(Die&: ProcDIE, Val: Entry.getInt(), Ty: PointeeTy);
865 } else {
866 addConstantFPValue(Die&: ProcDIE, CFP: Entry.getConstantFP());
867 }
868
869 ArtificialDIEPtr = &ProcDIE;
870
871 // Cache constant entries for de-duplication.
872 if (Entry.isInt() && PointeeTy)
873 ImplicitPointerDIEs.insert(
874 KV: {{PointeeTy, Entry.getInt()}, ArtificialDIEPtr});
875 }
876
877 auto *Loc = new (DIEValueAllocator) DIELoc;
878
879 const unsigned ImplicitPtrOp = DD->getDwarfVersion() >= 5
880 ? dwarf::DW_OP_implicit_pointer
881 : dwarf::DW_OP_GNU_implicit_pointer;
882 addUInt(Block&: *Loc, Form: dwarf::DW_FORM_data1, Integer: ImplicitPtrOp);
883
884 Loc->addValue(Alloc&: DIEValueAllocator, Attribute: static_cast<dwarf::Attribute>(0),
885 Form: dwarf::DW_FORM_ref_addr, Value: DIEEntry(*ArtificialDIEPtr));
886
887 addSInt(Die&: *Loc, Form: dwarf::DW_FORM_sdata, Integer: 0);
888
889 addBlock(Die&: VariableDie, Attribute: dwarf::DW_AT_location, Loc);
890 return true;
891}
892
893void DwarfCompileUnit::applyConcreteDbgVariableAttributes(
894 const Loc::Single &Single, const DbgVariable &DV, DIE &VariableDie) {
895 // Handle DW_OP_LLVM_implicit_pointer before normal location emission.
896 if (emitImplicitPointerLocation(Single, DV, VariableDie))
897 return;
898
899 const DbgValueLoc *DVal = &Single.getValueLoc();
900 if (!Single.getExpr())
901 DD->addTargetVariableAttributes(CU&: *this, Die&: VariableDie, TargetAddrSpace: std::nullopt,
902 VarLocKind: DwarfDebug::VariableLocationKind::Register);
903 if (!DVal->isVariadic()) {
904 const DbgValueLocEntry *Entry = DVal->getLocEntries().begin();
905 if (Entry->isLocation()) {
906 addVariableAddress(DV, Die&: VariableDie, Location: Entry->getLoc());
907 } else if (Entry->isInt()) {
908 auto *Expr = Single.getExpr();
909 if (Expr && Expr->getNumElements()) {
910 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
911 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
912 // If there is an expression, emit raw unsigned bytes.
913 DwarfExpr.addFragmentOffset(Expr);
914 DwarfExpr.addUnsignedConstant(Value: Entry->getInt());
915 DwarfExpr.addExpression(Expr);
916 addBlock(Die&: VariableDie, Attribute: dwarf::DW_AT_location, Loc: DwarfExpr.finalize());
917 if (DwarfExpr.TagOffset)
918 addUInt(Die&: VariableDie, Attribute: dwarf::DW_AT_LLVM_tag_offset,
919 Form: dwarf::DW_FORM_data1, Integer: *DwarfExpr.TagOffset);
920 } else
921 addConstantValue(Die&: VariableDie, Val: Entry->getInt(), Ty: DV.getType());
922 } else if (Entry->isConstantFP()) {
923 addConstantFPValue(Die&: VariableDie, CFP: Entry->getConstantFP());
924 } else if (Entry->isConstantInt()) {
925 addConstantValue(Die&: VariableDie, CI: Entry->getConstantInt(), Ty: DV.getType());
926 } else if (Entry->isGlobalAddress()) {
927 auto *Expr = Single.getExpr();
928 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
929 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
930 DwarfExpr.addFragmentOffset(Expr);
931 if (!DwarfExpr.addGlobalAddress(GV: Entry->getGlobalAddress(),
932 Offset: Entry->getGlobalOffset()))
933 return;
934 // A rejected operation leaves the expression built so far in Loc, which
935 // describes some other location rather than none. Drop it instead.
936 if (!DwarfExpr.addExpression(Expr))
937 return;
938 addBlock(Die&: VariableDie, Attribute: dwarf::DW_AT_location, Loc: DwarfExpr.finalize());
939 if (DwarfExpr.TagOffset)
940 addUInt(Die&: VariableDie, Attribute: dwarf::DW_AT_LLVM_tag_offset, Form: dwarf::DW_FORM_data1,
941 Integer: *DwarfExpr.TagOffset);
942 } else if (Entry->isTargetIndexLocation()) {
943 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
944 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
945 const DIBasicType *BT = dyn_cast<DIBasicType>(
946 Val: static_cast<const Metadata *>(DV.getVariable()->getType()));
947 DwarfDebug::emitDebugLocValue(AP: *Asm, BT, Value: *DVal, DwarfExpr);
948 addBlock(Die&: VariableDie, Attribute: dwarf::DW_AT_location, Loc: DwarfExpr.finalize());
949 }
950 return;
951 }
952 // If any of the location entries are registers with the value 0,
953 // then the location is undefined.
954 if (any_of(Range: DVal->getLocEntries(), P: [](const DbgValueLocEntry &Entry) {
955 return Entry.isLocation() && !Entry.getLoc().getReg();
956 }))
957 return;
958 const DIExpression *Expr = Single.getExpr();
959 assert(Expr && "Variadic Debug Value must have an Expression.");
960 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
961 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
962 DwarfExpr.addFragmentOffset(Expr);
963 DIExpressionCursor Cursor(Expr);
964 const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
965
966 auto AddEntry = [&](const DbgValueLocEntry &Entry,
967 DIExpressionCursor &Cursor) {
968 if (Entry.isLocation()) {
969 if (!DwarfExpr.addMachineRegExpression(TRI, Expr&: Cursor,
970 MachineReg: Entry.getLoc().getReg()))
971 return false;
972 } else if (Entry.isInt()) {
973 // If there is an expression, emit raw unsigned bytes.
974 DwarfExpr.addUnsignedConstant(Value: Entry.getInt());
975 } else if (Entry.isConstantFP()) {
976 // DwarfExpression does not support arguments wider than 64 bits
977 // (see PR52584).
978 // TODO: Consider chunking expressions containing overly wide
979 // arguments into separate pointer-sized fragment expressions.
980 APInt RawBytes = Entry.getConstantFP()->getValueAPF().bitcastToAPInt();
981 if (RawBytes.getBitWidth() > 64)
982 return false;
983 DwarfExpr.addUnsignedConstant(Value: RawBytes.getZExtValue());
984 } else if (Entry.isConstantInt()) {
985 APInt RawBytes = Entry.getConstantInt()->getValue();
986 if (RawBytes.getBitWidth() > 64)
987 return false;
988 DwarfExpr.addUnsignedConstant(Value: RawBytes.getZExtValue());
989 } else if (Entry.isTargetIndexLocation()) {
990 TargetIndexLocation Loc = Entry.getTargetIndexLocation();
991 // TODO TargetIndexLocation is a target-independent. Currently
992 // only the WebAssembly-specific encoding is supported.
993 assert(Asm->TM.getTargetTriple().isWasm());
994 DwarfExpr.addWasmLocation(Index: Loc.Index, Offset: static_cast<uint64_t>(Loc.Offset));
995 } else if (Entry.isGlobalAddress()) {
996 if (!DwarfExpr.addGlobalAddress(GV: Entry.getGlobalAddress(),
997 Offset: Entry.getGlobalOffset()))
998 return false;
999 } else {
1000 llvm_unreachable("Unsupported Entry type.");
1001 }
1002 return true;
1003 };
1004
1005 if (!DwarfExpr.addExpression(
1006 Expr: std::move(Cursor),
1007 InsertArg: [&](unsigned Idx, DIExpressionCursor &Cursor) -> bool {
1008 return AddEntry(DVal->getLocEntries()[Idx], Cursor);
1009 }))
1010 return;
1011
1012 // Now attach the location information to the DIE.
1013 addBlock(Die&: VariableDie, Attribute: dwarf::DW_AT_location, Loc: DwarfExpr.finalize());
1014 if (DwarfExpr.TagOffset)
1015 addUInt(Die&: VariableDie, Attribute: dwarf::DW_AT_LLVM_tag_offset, Form: dwarf::DW_FORM_data1,
1016 Integer: *DwarfExpr.TagOffset);
1017}
1018
1019void DwarfCompileUnit::applyConcreteDbgVariableAttributes(
1020 const Loc::Multi &Multi, const DbgVariable &DV, DIE &VariableDie) {
1021 addLocationList(Die&: VariableDie, Attribute: dwarf::DW_AT_location,
1022 Index: Multi.getDebugLocListIndex());
1023 auto TagOffset = Multi.getDebugLocListTagOffset();
1024 if (TagOffset)
1025 addUInt(Die&: VariableDie, Attribute: dwarf::DW_AT_LLVM_tag_offset, Form: dwarf::DW_FORM_data1,
1026 Integer: *TagOffset);
1027}
1028
1029void DwarfCompileUnit::applyConcreteDbgVariableAttributes(const Loc::MMI &MMI,
1030 const DbgVariable &DV,
1031 DIE &VariableDie) {
1032 std::optional<unsigned> TargetAddrSpace;
1033 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1034 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
1035 for (const auto &Fragment : MMI.getFrameIndexExprs()) {
1036 Register FrameReg;
1037 const DIExpression *Expr = Fragment.Expr;
1038 const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering();
1039 StackOffset Offset =
1040 TFI->getFrameIndexReference(MF: *Asm->MF, FI: Fragment.FI, FrameReg);
1041 DwarfExpr.addFragmentOffset(Expr);
1042
1043 auto *TRI = Asm->MF->getSubtarget().getRegisterInfo();
1044 SmallVector<uint64_t, 8> Ops;
1045 TRI->getOffsetOpcodes(Offset, Ops);
1046
1047 Expr = DD->adjustExpressionForTarget(Expr, TargetAddrSpace);
1048 if (Expr)
1049 Ops.append(in_start: Expr->elements_begin(), in_end: Expr->elements_end());
1050 DIExpressionCursor Cursor(Ops);
1051 DwarfExpr.setMemoryLocationKind();
1052 if (const MCSymbol *FrameSymbol = Asm->getFunctionFrameSymbol())
1053 addOpAddress(Die&: *Loc, Sym: FrameSymbol);
1054 else
1055 DwarfExpr.addMachineRegExpression(
1056 TRI: *Asm->MF->getSubtarget().getRegisterInfo(), Expr&: Cursor, MachineReg: FrameReg);
1057 DwarfExpr.addExpression(Expr: std::move(Cursor));
1058 }
1059 DD->addTargetVariableAttributes(CU&: *this, Die&: VariableDie, TargetAddrSpace,
1060 VarLocKind: DwarfDebug::VariableLocationKind::FrameIndex);
1061 addBlock(Die&: VariableDie, Attribute: dwarf::DW_AT_location, Loc: DwarfExpr.finalize());
1062 if (DwarfExpr.TagOffset)
1063 addUInt(Die&: VariableDie, Attribute: dwarf::DW_AT_LLVM_tag_offset, Form: dwarf::DW_FORM_data1,
1064 Integer: *DwarfExpr.TagOffset);
1065}
1066
1067void DwarfCompileUnit::applyConcreteDbgVariableAttributes(
1068 const Loc::EntryValue &EntryValue, const DbgVariable &DV,
1069 DIE &VariableDie) {
1070 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1071 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
1072 // Emit each expression as: EntryValue(Register) <other ops> <Fragment>.
1073 for (auto [Register, Expr] : EntryValue.EntryValues) {
1074 DwarfExpr.addFragmentOffset(Expr: &Expr);
1075 DIExpressionCursor Cursor(Expr.getElements());
1076 DwarfExpr.beginEntryValueExpression(ExprCursor&: Cursor);
1077 DwarfExpr.addMachineRegExpression(
1078 TRI: *Asm->MF->getSubtarget().getRegisterInfo(), Expr&: Cursor, MachineReg: Register);
1079 DwarfExpr.addExpression(Expr: std::move(Cursor));
1080 }
1081 addBlock(Die&: VariableDie, Attribute: dwarf::DW_AT_location, Loc: DwarfExpr.finalize());
1082}
1083
1084void DwarfCompileUnit::applyConcreteDbgVariableAttributes(
1085 const std::monostate &, const DbgVariable &DV, DIE &VariableDie) {}
1086
1087DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV,
1088 const LexicalScope &Scope,
1089 DIE *&ObjectPointer) {
1090 auto Var = constructVariableDIE(DV, Abstract: Scope.isAbstractScope());
1091 if (DV.isObjectPointer())
1092 ObjectPointer = Var;
1093 return Var;
1094}
1095
1096DIE *DwarfCompileUnit::constructLabelDIE(DbgLabel &DL,
1097 const LexicalScope &Scope) {
1098 auto LabelDie = DIE::get(Alloc&: DIEValueAllocator, Tag: DL.getTag());
1099 insertDIE(Desc: DL.getLabel(), D: LabelDie);
1100 DL.setDIE(*LabelDie);
1101
1102 if (Scope.isAbstractScope())
1103 applyLabelAttributes(Label: DL, LabelDie&: *LabelDie);
1104
1105 return LabelDie;
1106}
1107
1108/// Return all DIVariables that appear in count: expressions.
1109static SmallVector<const DIVariable *, 2> dependencies(DbgVariable *Var) {
1110 SmallVector<const DIVariable *, 2> Result;
1111 auto *Array = dyn_cast<DICompositeType>(Val: Var->getType());
1112 if (!Array || Array->getTag() != dwarf::DW_TAG_array_type)
1113 return Result;
1114 if (auto *DLVar = Array->getDataLocation())
1115 Result.push_back(Elt: DLVar);
1116 if (auto *AsVar = Array->getAssociated())
1117 Result.push_back(Elt: AsVar);
1118 if (auto *AlVar = Array->getAllocated())
1119 Result.push_back(Elt: AlVar);
1120 for (auto *El : Array->getElements()) {
1121 if (auto *Subrange = dyn_cast<DISubrange>(Val: El)) {
1122 if (auto Count = Subrange->getCount())
1123 if (auto *Dependency = dyn_cast_if_present<DIVariable *>(Val&: Count))
1124 Result.push_back(Elt: Dependency);
1125 if (auto LB = Subrange->getLowerBound())
1126 if (auto *Dependency = dyn_cast_if_present<DIVariable *>(Val&: LB))
1127 Result.push_back(Elt: Dependency);
1128 if (auto UB = Subrange->getUpperBound())
1129 if (auto *Dependency = dyn_cast_if_present<DIVariable *>(Val&: UB))
1130 Result.push_back(Elt: Dependency);
1131 if (auto ST = Subrange->getStride())
1132 if (auto *Dependency = dyn_cast_if_present<DIVariable *>(Val&: ST))
1133 Result.push_back(Elt: Dependency);
1134 } else if (auto *GenericSubrange = dyn_cast<DIGenericSubrange>(Val: El)) {
1135 if (auto Count = GenericSubrange->getCount())
1136 if (auto *Dependency = dyn_cast_if_present<DIVariable *>(Val&: Count))
1137 Result.push_back(Elt: Dependency);
1138 if (auto LB = GenericSubrange->getLowerBound())
1139 if (auto *Dependency = dyn_cast_if_present<DIVariable *>(Val&: LB))
1140 Result.push_back(Elt: Dependency);
1141 if (auto UB = GenericSubrange->getUpperBound())
1142 if (auto *Dependency = dyn_cast_if_present<DIVariable *>(Val&: UB))
1143 Result.push_back(Elt: Dependency);
1144 if (auto ST = GenericSubrange->getStride())
1145 if (auto *Dependency = dyn_cast_if_present<DIVariable *>(Val&: ST))
1146 Result.push_back(Elt: Dependency);
1147 }
1148 }
1149 return Result;
1150}
1151
1152/// Sort local variables so that variables appearing inside of helper
1153/// expressions come first.
1154static SmallVector<DbgVariable *, 8>
1155sortLocalVars(SmallVectorImpl<DbgVariable *> &Input) {
1156 SmallVector<DbgVariable *, 8> Result;
1157 SmallVector<PointerIntPair<DbgVariable *, 1>, 8> WorkList;
1158 // Map back from a DIVariable to its containing DbgVariable.
1159 SmallDenseMap<const DILocalVariable *, DbgVariable *> DbgVar;
1160 // Set of DbgVariables in Result.
1161 SmallDenseSet<DbgVariable *, 8> Visited;
1162 // For cycle detection.
1163 SmallDenseSet<DbgVariable *, 8> Visiting;
1164
1165 // Initialize the worklist and the DIVariable lookup table.
1166 for (auto *Var : reverse(C&: Input)) {
1167 DbgVar.insert(KV: {Var->getVariable(), Var});
1168 WorkList.push_back(Elt: {Var, 0});
1169 }
1170
1171 // Perform a stable topological sort by doing a DFS.
1172 while (!WorkList.empty()) {
1173 auto Item = WorkList.back();
1174 DbgVariable *Var = Item.getPointer();
1175 bool visitedAllDependencies = Item.getInt();
1176 WorkList.pop_back();
1177
1178 assert(Var);
1179
1180 // Already handled.
1181 if (Visited.count(V: Var))
1182 continue;
1183
1184 // Add to Result if all dependencies are visited.
1185 if (visitedAllDependencies) {
1186 Visited.insert(V: Var);
1187 Result.push_back(Elt: Var);
1188 continue;
1189 }
1190
1191 // Detect cycles.
1192 auto Res = Visiting.insert(V: Var);
1193 if (!Res.second) {
1194 assert(false && "dependency cycle in local variables");
1195 return Result;
1196 }
1197
1198 // Push dependencies and this node onto the worklist, so that this node is
1199 // visited again after all of its dependencies are handled.
1200 WorkList.push_back(Elt: {Var, 1});
1201 for (const auto *Dependency : dependencies(Var)) {
1202 // Don't add dependency if it is in a different lexical scope or a global.
1203 if (const auto *Dep = dyn_cast<const DILocalVariable>(Val: Dependency))
1204 if (DbgVariable *Var = DbgVar.lookup(Val: Dep))
1205 WorkList.push_back(Elt: {Var, 0});
1206 }
1207 }
1208 return Result;
1209}
1210
1211DIE &DwarfCompileUnit::constructSubprogramScopeDIE(const DISubprogram *Sub,
1212 const Function &F,
1213 LexicalScope *Scope,
1214 MCSymbol *LineTableSym) {
1215 DIE &ScopeDIE = updateSubprogramScopeDIE(SP: Sub, F, LineTableSym);
1216
1217 if (Scope) {
1218 assert(!Scope->getInlinedAt());
1219 assert(!Scope->isAbstractScope());
1220 // Collect lexical scope children first.
1221 // ObjectPointer might be a local (non-argument) local variable if it's a
1222 // block's synthetic this pointer.
1223 if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, ScopeDIE))
1224 addDIEEntry(Die&: ScopeDIE, Attribute: dwarf::DW_AT_object_pointer, Entry&: *ObjectPointer);
1225 }
1226
1227 // If this is a variadic function, add an unspecified parameter.
1228 auto *SPTy = Sub->getType();
1229 if (!SPTy)
1230 return ScopeDIE;
1231
1232 DITypeArray FnArgs = SPTy->getTypeArray();
1233
1234 // If we have a single element of null, it is a function that returns void.
1235 // If we have more than one elements and the last one is null, it is a
1236 // variadic function.
1237 if (FnArgs.size() > 1 && !FnArgs[FnArgs.size() - 1] &&
1238 !includeMinimalInlineScopes())
1239 ScopeDIE.addChild(
1240 Child: DIE::get(Alloc&: DIEValueAllocator, Tag: dwarf::DW_TAG_unspecified_parameters));
1241
1242 return ScopeDIE;
1243}
1244
1245bool DwarfCompileUnit::hasGlobalVariableInScope(const DILocalScope *ScopeNode) {
1246 return GlobalVarScopes.contains(Ptr: ScopeNode);
1247}
1248
1249DIE *DwarfCompileUnit::createAndAddScopeChildren(LexicalScope *Scope,
1250 DIE &ScopeDIE) {
1251 DIE *ObjectPointer = nullptr;
1252
1253 // Emit function arguments (order is significant).
1254 auto Vars = DU->getScopeVariables().lookup(Val: Scope);
1255 for (auto &DV : Vars.Args)
1256 ScopeDIE.addChild(Child: constructVariableDIE(DV&: *DV.second, Scope: *Scope, ObjectPointer));
1257
1258 // Emit local variables.
1259 auto Locals = sortLocalVars(Input&: Vars.Locals);
1260 for (DbgVariable *DV : Locals)
1261 ScopeDIE.addChild(Child: constructVariableDIE(DV&: *DV, Scope: *Scope, ObjectPointer));
1262
1263 // Emit labels.
1264 for (DbgLabel *DL : DU->getScopeLabels().lookup(Val: Scope))
1265 ScopeDIE.addChild(Child: constructLabelDIE(DL&: *DL, Scope: *Scope));
1266
1267 // Track other local entities (skipped in gmlt-like data).
1268 // This creates mapping between CU and a set of local declarations that
1269 // should be emitted for subprograms in this CU.
1270 if (!includeMinimalInlineScopes() && !Scope->getInlinedAt()) {
1271 auto &LocalDecls = DD->getLocalDeclsForScope(S: Scope->getScopeNode());
1272 DeferredLocalDecls.insert_range(R&: LocalDecls);
1273 }
1274
1275 // Emit inner lexical scopes.
1276 auto skipLexicalScope = [this](LexicalScope *S) -> bool {
1277 const DILocalScope *DS = S->getScopeNode();
1278 if (isa<DISubprogram>(Val: DS))
1279 return false;
1280 // Don't skip abstract lexical blocks that are scope targets for global
1281 // variables (e.g., function-scope statics). Those globals are emitted
1282 // later in endModule() and need to find the block via
1283 // getOrCreateContextDIE().
1284 if (S->isAbstractScope() && hasGlobalVariableInScope(ScopeNode: DS))
1285 return false;
1286 // Create a concrete lexical block for a scope with an abstract lexical
1287 // block to ensure visibility of scope-local types and static variables
1288 // within the scope range.
1289 if (getAbstractScopeDIEs().lookup(Val: DS))
1290 return false;
1291 auto Vars = DU->getScopeVariables().lookup(Val: S);
1292 if (!Vars.Args.empty() || !Vars.Locals.empty())
1293 return false;
1294 return includeMinimalInlineScopes() ||
1295 DD->getLocalDeclsForScope(S: DS).empty();
1296 };
1297 for (LexicalScope *LS : Scope->getChildren()) {
1298 // If the lexical block doesn't have non-scope children or global
1299 // variables scoped to it, skip its emission and put its children directly
1300 // to the parent scope.
1301 if (skipLexicalScope(LS))
1302 createAndAddScopeChildren(Scope: LS, ScopeDIE);
1303 else
1304 constructScopeDIE(Scope: LS, ParentScopeDIE&: ScopeDIE);
1305 }
1306
1307 return ObjectPointer;
1308}
1309
1310DIE &DwarfCompileUnit::getOrCreateAbstractSubprogramDIE(
1311 const DISubprogram *SP) {
1312 if (auto *AbsDef = getAbstractScopeDIEs().lookup(Val: SP))
1313 return *AbsDef;
1314
1315 auto [ContextDIE, ContextCU] = getOrCreateAbstractSubprogramContextDIE(SP);
1316 return createAbstractSubprogramDIE(SP, ContextDIE, ContextCU);
1317}
1318
1319DIE &DwarfCompileUnit::createAbstractSubprogramDIE(
1320 const DISubprogram *SP, DIE *ContextDIE, DwarfCompileUnit *ContextCU) {
1321 // Passing null as the associated node because the abstract definition
1322 // shouldn't be found by lookup.
1323 DIE &AbsDef = ContextCU->createAndAddDIE(Tag: dwarf::DW_TAG_subprogram,
1324 Parent&: *ContextDIE, N: nullptr);
1325
1326 // Store the DIE before creating children.
1327 ContextCU->getAbstractScopeDIEs()[SP] = &AbsDef;
1328
1329 ContextCU->applySubprogramAttributesToDefinition(SP, SPDie&: AbsDef);
1330 ContextCU->addSInt(Die&: AbsDef, Attribute: dwarf::DW_AT_inline,
1331 Form: DD->getDwarfVersion() <= 4 ? std::optional<dwarf::Form>()
1332 : dwarf::DW_FORM_implicit_const,
1333 Integer: dwarf::DW_INL_inlined);
1334
1335 return AbsDef;
1336}
1337
1338std::pair<DIE *, DwarfCompileUnit *>
1339DwarfCompileUnit::getOrCreateAbstractSubprogramContextDIE(
1340 const DISubprogram *SP) {
1341 bool Minimal = includeMinimalInlineScopes();
1342 bool IgnoreScope = shouldPlaceInUnitDIE(SP, Minimal);
1343 DIE *ContextDIE = getOrCreateSubprogramContextDIE(SP, IgnoreScope);
1344
1345 if (auto *SPDecl = SP->getDeclaration())
1346 if (!Minimal)
1347 getOrCreateSubprogramDIE(SP: SPDecl, F: nullptr);
1348
1349 // The scope may be shared with a subprogram that has already been
1350 // constructed in another CU, in which case we need to construct this
1351 // subprogram in the same CU.
1352 auto *ContextCU = IgnoreScope ? this : DD->lookupCU(Die: ContextDIE->getUnitDie());
1353
1354 return std::make_pair(x&: ContextDIE, y&: ContextCU);
1355}
1356
1357void DwarfCompileUnit::constructAbstractSubprogramScopeDIE(
1358 LexicalScope *Scope) {
1359 auto *SP = cast<DISubprogram>(Val: Scope->getScopeNode());
1360
1361 // Populate subprogram DIE only once.
1362 if (!getFinalizedAbstractSubprograms().insert(Ptr: SP).second)
1363 return;
1364
1365 auto [ContextDIE, ContextCU] = getOrCreateAbstractSubprogramContextDIE(SP);
1366 DIE *AbsDef = getAbstractScopeDIEs().lookup(Val: SP);
1367 if (!AbsDef)
1368 AbsDef = &createAbstractSubprogramDIE(SP, ContextDIE, ContextCU);
1369
1370 if (DIE *ObjectPointer = ContextCU->createAndAddScopeChildren(Scope, ScopeDIE&: *AbsDef))
1371 ContextCU->addDIEEntry(Die&: *AbsDef, Attribute: dwarf::DW_AT_object_pointer,
1372 Entry&: *ObjectPointer);
1373}
1374
1375bool DwarfCompileUnit::useGNUAnalogForDwarf5Feature() const {
1376 return DD->getDwarfVersion() <= 4 && !DD->tuneForLLDB();
1377}
1378
1379dwarf::Tag DwarfCompileUnit::getDwarf5OrGNUTag(dwarf::Tag Tag) const {
1380 if (!useGNUAnalogForDwarf5Feature())
1381 return Tag;
1382 switch (Tag) {
1383 case dwarf::DW_TAG_call_site:
1384 return dwarf::DW_TAG_GNU_call_site;
1385 case dwarf::DW_TAG_call_site_parameter:
1386 return dwarf::DW_TAG_GNU_call_site_parameter;
1387 default:
1388 llvm_unreachable("DWARF5 tag with no GNU analog");
1389 }
1390}
1391
1392dwarf::Attribute
1393DwarfCompileUnit::getDwarf5OrGNUAttr(dwarf::Attribute Attr) const {
1394 if (!useGNUAnalogForDwarf5Feature())
1395 return Attr;
1396 switch (Attr) {
1397 case dwarf::DW_AT_call_all_calls:
1398 return dwarf::DW_AT_GNU_all_call_sites;
1399 case dwarf::DW_AT_call_target:
1400 return dwarf::DW_AT_GNU_call_site_target;
1401 case dwarf::DW_AT_call_target_clobbered:
1402 return dwarf::DW_AT_GNU_call_site_target_clobbered;
1403 case dwarf::DW_AT_call_origin:
1404 return dwarf::DW_AT_abstract_origin;
1405 case dwarf::DW_AT_call_return_pc:
1406 return dwarf::DW_AT_low_pc;
1407 case dwarf::DW_AT_call_value:
1408 return dwarf::DW_AT_GNU_call_site_value;
1409 case dwarf::DW_AT_call_tail_call:
1410 return dwarf::DW_AT_GNU_tail_call;
1411 default:
1412 llvm_unreachable("DWARF5 attribute with no GNU analog");
1413 }
1414}
1415
1416dwarf::LocationAtom
1417DwarfCompileUnit::getDwarf5OrGNULocationAtom(dwarf::LocationAtom Loc) const {
1418 if (!useGNUAnalogForDwarf5Feature())
1419 return Loc;
1420 switch (Loc) {
1421 case dwarf::DW_OP_entry_value:
1422 return dwarf::DW_OP_GNU_entry_value;
1423 default:
1424 llvm_unreachable("DWARF5 location atom with no GNU analog");
1425 }
1426}
1427
1428DIE &DwarfCompileUnit::constructCallSiteEntryDIE(
1429 DIE &ScopeDIE, const DISubprogram *CalleeSP, const Function *CalleeF,
1430 bool IsTail, const MCSymbol *PCAddr, const MCSymbol *CallAddr,
1431 MachineLocation CallTarget, int64_t Offset, DIType *AllocSiteTy) {
1432 // Insert a call site entry DIE within ScopeDIE.
1433 DIE &CallSiteDIE = createAndAddDIE(Tag: getDwarf5OrGNUTag(Tag: dwarf::DW_TAG_call_site),
1434 Parent&: ScopeDIE, N: nullptr);
1435
1436 // A valid register in CallTarget indicates an indirect call.
1437 if (CallTarget.getReg()) {
1438 // Add a DW_AT_call_target location expression describing the location of
1439 // the address of the target function. If any register in the expression
1440 // (i.e., the single register we currently handle) is volatile we must use
1441 // DW_AT_call_target_clobbered instead.
1442 const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
1443 dwarf::Attribute Attribute = getDwarf5OrGNUAttr(
1444 Attr: TRI.isCalleeSavedPhysReg(PhysReg: CallTarget.getReg(), MF: *Asm->MF)
1445 ? dwarf::DW_AT_call_target
1446 : dwarf::DW_AT_call_target_clobbered);
1447
1448 // CallTarget is the location of the address of an indirect call. The
1449 // location may be indirect, modified by Offset.
1450 if (CallTarget.isIndirect())
1451 addMemoryLocation(Die&: CallSiteDIE, Attribute, Location: CallTarget, Offset);
1452 else
1453 addAddress(Die&: CallSiteDIE, Attribute, Location: CallTarget);
1454 } else if (CalleeSP) {
1455 DIE *CalleeDIE = getOrCreateSubprogramDIE(SP: CalleeSP, F: CalleeF);
1456 assert(CalleeDIE && "Could not create DIE for call site entry origin");
1457 addLinkageNamesToDeclarations(DD: *DD, CalleeSP: *CalleeSP, CalleeDIE&: *CalleeDIE);
1458
1459 addDIEEntry(Die&: CallSiteDIE, Attribute: getDwarf5OrGNUAttr(Attr: dwarf::DW_AT_call_origin),
1460 Entry&: *CalleeDIE);
1461 }
1462
1463 if (IsTail) {
1464 // Attach DW_AT_call_tail_call to tail calls for standards compliance.
1465 addFlag(Die&: CallSiteDIE, Attribute: getDwarf5OrGNUAttr(Attr: dwarf::DW_AT_call_tail_call));
1466
1467 // Attach the address of the branch instruction to allow the debugger to
1468 // show where the tail call occurred. This attribute has no GNU analog.
1469 //
1470 // GDB works backwards from non-standard usage of DW_AT_low_pc (in DWARF4
1471 // mode -- equivalently, in DWARF5 mode, DW_AT_call_return_pc) at tail-call
1472 // site entries to figure out the PC of tail-calling branch instructions.
1473 // This means it doesn't need the compiler to emit DW_AT_call_pc, so we
1474 // don't emit it here.
1475 //
1476 // There's no need to tie non-GDB debuggers to this non-standardness, as it
1477 // adds unnecessary complexity to the debugger. For non-GDB debuggers, emit
1478 // the standard DW_AT_call_pc info.
1479 if (!useGNUAnalogForDwarf5Feature())
1480 addLabelAddress(Die&: CallSiteDIE, Attribute: dwarf::DW_AT_call_pc, Label: CallAddr);
1481 }
1482
1483 // Attach the return PC to allow the debugger to disambiguate call paths
1484 // from one function to another.
1485 //
1486 // The return PC is only really needed when the call /isn't/ a tail call, but
1487 // GDB expects it in DWARF4 mode, even for tail calls (see the comment above
1488 // the DW_AT_call_pc emission logic for an explanation).
1489 if (!IsTail || useGNUAnalogForDwarf5Feature()) {
1490 assert(PCAddr && "Missing return PC information for a call");
1491 addLabelAddress(Die&: CallSiteDIE,
1492 Attribute: getDwarf5OrGNUAttr(Attr: dwarf::DW_AT_call_return_pc), Label: PCAddr);
1493 }
1494
1495 if (AllocSiteTy)
1496 addType(Entity&: CallSiteDIE, Ty: AllocSiteTy, Attribute: dwarf::DW_AT_LLVM_alloc_type);
1497
1498 return CallSiteDIE;
1499}
1500
1501void DwarfCompileUnit::constructCallSiteParmEntryDIEs(
1502 DIE &CallSiteDIE, SmallVector<DbgCallSiteParam, 4> &Params) {
1503 for (const auto &Param : Params) {
1504 unsigned Register = Param.getRegister();
1505 auto CallSiteDieParam =
1506 DIE::get(Alloc&: DIEValueAllocator,
1507 Tag: getDwarf5OrGNUTag(Tag: dwarf::DW_TAG_call_site_parameter));
1508 insertDIE(D: CallSiteDieParam);
1509 addAddress(Die&: *CallSiteDieParam, Attribute: dwarf::DW_AT_location,
1510 Location: MachineLocation(Register));
1511
1512 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1513 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
1514 DwarfExpr.setCallSiteParamValueFlag();
1515
1516 DwarfDebug::emitDebugLocValue(AP: *Asm, BT: nullptr, Value: Param.getValue(), DwarfExpr);
1517
1518 addBlock(Die&: *CallSiteDieParam, Attribute: getDwarf5OrGNUAttr(Attr: dwarf::DW_AT_call_value),
1519 Loc: DwarfExpr.finalize());
1520
1521 CallSiteDIE.addChild(Child: CallSiteDieParam);
1522 }
1523}
1524
1525DIE *DwarfCompileUnit::constructImportedEntityDIE(
1526 const DIImportedEntity *Module) {
1527 DIE *IMDie = DIE::get(Alloc&: DIEValueAllocator, Tag: Module->getTag());
1528 insertDIE(Desc: Module, D: IMDie);
1529 DIE *EntityDie;
1530 auto *Entity = Module->getEntity();
1531 if (auto *NS = dyn_cast<DINamespace>(Val: Entity))
1532 EntityDie = getOrCreateNameSpace(NS);
1533 else if (auto *M = dyn_cast<DIModule>(Val: Entity))
1534 EntityDie = getOrCreateModule(M);
1535 else if (auto *SP = dyn_cast<DISubprogram>(Val: Entity)) {
1536 // If there is an abstract subprogram, refer to it. Note that this assumes
1537 // that all the abstract subprograms have been already created (which is
1538 // correct until imported entities get emitted in DwarfDebug::endModule()).
1539 if (auto *AbsSPDie = getAbstractScopeDIEs().lookup(Val: SP))
1540 EntityDie = AbsSPDie;
1541 else
1542 EntityDie = getOrCreateSubprogramDIE(SP, F: nullptr);
1543 } else if (auto *T = dyn_cast<DIType>(Val: Entity))
1544 EntityDie = getOrCreateTypeDIE(TyNode: T);
1545 else if (auto *GV = dyn_cast<DIGlobalVariable>(Val: Entity))
1546 EntityDie = getOrCreateGlobalVariableDIE(GV, GlobalExprs: {});
1547 else if (auto *IE = dyn_cast<DIImportedEntity>(Val: Entity))
1548 EntityDie = getOrCreateImportedEntityDIE(IE);
1549 else
1550 EntityDie = getDIE(D: Entity);
1551 assert(EntityDie);
1552 addSourceLine(Die&: *IMDie, Line: Module->getLine(), /*Column*/ 0, File: Module->getFile());
1553 addDIEEntry(Die&: *IMDie, Attribute: dwarf::DW_AT_import, Entry&: *EntityDie);
1554 StringRef Name = Module->getName();
1555 if (!Name.empty()) {
1556 addString(Die&: *IMDie, Attribute: dwarf::DW_AT_name, Str: Name);
1557
1558 // FIXME: if consumers ever start caring about handling
1559 // unnamed import declarations such as `using ::nullptr_t`
1560 // or `using namespace std::ranges`, we could add the
1561 // import declaration into the accelerator table with the
1562 // name being the one of the entity being imported.
1563 DD->addAccelNamespace(Unit: *this, NameTableKind: CUNode->getNameTableKind(), Name, Die: *IMDie);
1564 }
1565
1566 // This is for imported module with renamed entities (such as variables and
1567 // subprograms).
1568 DINodeArray Elements = Module->getElements();
1569 for (const auto *Element : Elements) {
1570 if (!Element)
1571 continue;
1572 IMDie->addChild(
1573 Child: constructImportedEntityDIE(Module: cast<DIImportedEntity>(Val: Element)));
1574 }
1575
1576 return IMDie;
1577}
1578
1579DIE *DwarfCompileUnit::getOrCreateImportedEntityDIE(
1580 const DIImportedEntity *IE) {
1581
1582 // Check for pre-existence.
1583 if (DIE *Die = getDIE(D: IE))
1584 return Die;
1585
1586 DIE *ContextDIE = getOrCreateContextDIE(Ty: IE->getScope());
1587 assert(ContextDIE && "Empty scope for the imported entity!");
1588
1589 DIE *IMDie = constructImportedEntityDIE(Module: IE);
1590 ContextDIE->addChild(Child: IMDie);
1591 return IMDie;
1592}
1593
1594void DwarfCompileUnit::finishSubprogramDefinition(const DISubprogram *SP) {
1595 DIE *D = getDIE(D: SP);
1596 if (DIE *AbsSPDIE = getAbstractScopeDIEs().lookup(Val: SP)) {
1597 if (D)
1598 // If this subprogram has an abstract definition, reference that
1599 addDIEEntry(Die&: *D, Attribute: dwarf::DW_AT_abstract_origin, Entry&: *AbsSPDIE);
1600 } else {
1601 assert(D || includeMinimalInlineScopes());
1602 if (D)
1603 // And attach the attributes
1604 applySubprogramAttributesToDefinition(SP, SPDie&: *D);
1605 }
1606}
1607
1608void DwarfCompileUnit::finishEntityDefinition(const DbgEntity *Entity) {
1609 DbgEntity *AbsEntity = getExistingAbstractEntity(Node: Entity->getEntity());
1610
1611 auto *Die = Entity->getDIE();
1612 /// Label may be used to generate DW_AT_low_pc, so put it outside
1613 /// if/else block.
1614 const DbgLabel *Label = nullptr;
1615 if (AbsEntity && AbsEntity->getDIE()) {
1616 addDIEEntry(Die&: *Die, Attribute: dwarf::DW_AT_abstract_origin, Entry&: *AbsEntity->getDIE());
1617 Label = dyn_cast<const DbgLabel>(Val: Entity);
1618 } else {
1619 if (const DbgVariable *Var = dyn_cast<const DbgVariable>(Val: Entity))
1620 applyCommonDbgVariableAttributes(Var: *Var, VariableDie&: *Die);
1621 else if ((Label = dyn_cast<const DbgLabel>(Val: Entity)))
1622 applyLabelAttributes(Label: *Label, LabelDie&: *Die);
1623 else
1624 llvm_unreachable("DbgEntity must be DbgVariable or DbgLabel.");
1625 }
1626
1627 if (!Label)
1628 return;
1629
1630 const auto *Sym = Label->getSymbol();
1631 if (!Sym)
1632 return;
1633
1634 addLabelAddress(Die&: *Die, Attribute: dwarf::DW_AT_low_pc, Label: Sym);
1635
1636 // A TAG_label with a name and an AT_low_pc must be placed in debug_names.
1637 if (StringRef Name = Label->getName(); !Name.empty())
1638 getDwarfDebug().addAccelName(Unit: *this, NameTableKind: CUNode->getNameTableKind(), Name, Die: *Die);
1639}
1640
1641void DwarfCompileUnit::attachLexicalScopesAbstractOrigins() {
1642 auto AttachAO = [&](const DILocalScope *LS, DIE *ScopeDIE) {
1643 if (auto *AbsLSDie = getAbstractScopeDIEs().lookup(Val: LS))
1644 addDIEEntry(Die&: *ScopeDIE, Attribute: dwarf::DW_AT_abstract_origin, Entry&: *AbsLSDie);
1645 };
1646
1647 for (auto [LScope, ScopeDIE] : LexicalBlockDIEs)
1648 AttachAO(LScope, ScopeDIE);
1649 for (auto &[LScope, ScopeDIEs] : InlinedLocalScopeDIEs)
1650 for (auto *ScopeDIE : ScopeDIEs)
1651 AttachAO(LScope, ScopeDIE);
1652}
1653
1654DbgEntity *DwarfCompileUnit::getExistingAbstractEntity(const DINode *Node) {
1655 auto &AbstractEntities = getAbstractEntities();
1656 auto I = AbstractEntities.find(Val: Node);
1657 if (I != AbstractEntities.end())
1658 return I->second.get();
1659 return nullptr;
1660}
1661
1662void DwarfCompileUnit::createAbstractEntity(const DINode *Node,
1663 LexicalScope *Scope) {
1664 assert(Scope && Scope->isAbstractScope());
1665 auto &Entity = getAbstractEntities()[Node];
1666 if (isa<const DILocalVariable>(Val: Node)) {
1667 Entity = std::make_unique<DbgVariable>(args: cast<const DILocalVariable>(Val: Node),
1668 args: nullptr /* IA */);
1669 DU->addScopeVariable(LS: Scope, Var: cast<DbgVariable>(Val: Entity.get()));
1670 } else if (isa<const DILabel>(Val: Node)) {
1671 Entity = std::make_unique<DbgLabel>(
1672 args: cast<const DILabel>(Val: Node), args: nullptr /* IA */);
1673 DU->addScopeLabel(LS: Scope, Label: cast<DbgLabel>(Val: Entity.get()));
1674 }
1675}
1676
1677void DwarfCompileUnit::emitHeader(bool UseOffsets) {
1678 // Don't bother labeling the .dwo unit, as its offset isn't used.
1679 if (!Skeleton && !DD->useSectionsAsReferences()) {
1680 LabelBegin = Asm->createTempSymbol(Name: "cu_begin");
1681 Asm->OutStreamer->emitLabel(Symbol: LabelBegin);
1682 }
1683
1684 dwarf::UnitType UT = Skeleton ? dwarf::DW_UT_split_compile
1685 : DD->useSplitDwarf() ? dwarf::DW_UT_skeleton
1686 : dwarf::DW_UT_compile;
1687 DwarfUnit::emitCommonHeader(UseOffsets, UT);
1688 if (DD->getDwarfVersion() >= 5 && UT != dwarf::DW_UT_compile)
1689 Asm->emitInt64(Value: getDWOId());
1690}
1691
1692bool DwarfCompileUnit::hasDwarfPubSections() const {
1693 if (!DD->shouldEmitDwarfPubSections())
1694 return false;
1695
1696 switch (CUNode->getNameTableKind()) {
1697 case DICompileUnit::DebugNameTableKind::None:
1698 return false;
1699 // Opting in to GNU Pubnames/types overrides the default to ensure these are
1700 // generated for things like Gold's gdb_index generation.
1701 case DICompileUnit::DebugNameTableKind::GNU:
1702 return true;
1703 case DICompileUnit::DebugNameTableKind::Apple:
1704 return false;
1705 case DICompileUnit::DebugNameTableKind::Default:
1706 return DD->tuneForGDB() && !includeMinimalInlineScopes() &&
1707 !CUNode->isDebugDirectivesOnly() &&
1708 DD->getAccelTableKind() != AccelTableKind::Apple &&
1709 DD->getDwarfVersion() < 5;
1710 }
1711 llvm_unreachable("Unhandled DICompileUnit::DebugNameTableKind enum");
1712}
1713
1714/// addGlobalName - Add a new global name to the compile unit.
1715void DwarfCompileUnit::addGlobalName(StringRef Name, const DIE &Die,
1716 const DIScope *Context) {
1717 if (!hasDwarfPubSections())
1718 return;
1719 std::string FullName = getParentContextString(Context) + Name.str();
1720 GlobalNames[FullName] = &Die;
1721}
1722
1723void DwarfCompileUnit::addGlobalNameForTypeUnit(StringRef Name,
1724 const DIScope *Context) {
1725 if (!hasDwarfPubSections())
1726 return;
1727 std::string FullName = getParentContextString(Context) + Name.str();
1728 // Insert, allowing the entry to remain as-is if it's already present
1729 // This way the CU-level type DIE is preferred over the "can't describe this
1730 // type as a unit offset because it's not really in the CU at all, it's only
1731 // in a type unit"
1732 GlobalNames.insert(KV: std::make_pair(x: std::move(FullName), y: &getUnitDie()));
1733}
1734
1735/// Add a new global type to the unit.
1736void DwarfCompileUnit::addGlobalTypeImpl(const DIType *Ty, const DIE &Die,
1737 const DIScope *Context) {
1738 if (!hasDwarfPubSections())
1739 return;
1740 std::string FullName = getParentContextString(Context) + Ty->getName().str();
1741 GlobalTypes[FullName] = &Die;
1742}
1743
1744void DwarfCompileUnit::addGlobalTypeUnitType(const DIType *Ty,
1745 const DIScope *Context) {
1746 if (!hasDwarfPubSections())
1747 return;
1748 std::string FullName = getParentContextString(Context) + Ty->getName().str();
1749 // Insert, allowing the entry to remain as-is if it's already present
1750 // This way the CU-level type DIE is preferred over the "can't describe this
1751 // type as a unit offset because it's not really in the CU at all, it's only
1752 // in a type unit"
1753 GlobalTypes.insert(KV: std::make_pair(x: std::move(FullName), y: &getUnitDie()));
1754}
1755
1756void DwarfCompileUnit::addVariableAddress(const DbgVariable &DV, DIE &Die,
1757 MachineLocation Location) {
1758 auto *Single = std::get_if<Loc::Single>(ptr: &DV);
1759 if (Single && Single->getExpr())
1760 addComplexAddress(DIExpr: Single->getExpr(), Die, Attribute: dwarf::DW_AT_location, Location);
1761 else
1762 addAddress(Die, Attribute: dwarf::DW_AT_location, Location);
1763}
1764
1765void DwarfCompileUnit::addLocationWithExpr(DIE &Die, dwarf::Attribute Attribute,
1766 const MachineLocation &Location,
1767 ArrayRef<uint64_t> Expr) {
1768 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1769 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
1770 if (Location.isIndirect())
1771 DwarfExpr.setMemoryLocationKind();
1772
1773 DIExpressionCursor Cursor(Expr);
1774 const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
1775 if (!DwarfExpr.addMachineRegExpression(TRI, Expr&: Cursor, MachineReg: Location.getReg()))
1776 return;
1777 DwarfExpr.addExpression(Expr: std::move(Cursor));
1778
1779 // Now attach the location information to the DIE.
1780 addBlock(Die, Attribute, Loc: DwarfExpr.finalize());
1781
1782 if (DwarfExpr.TagOffset)
1783 addUInt(Die, Attribute: dwarf::DW_AT_LLVM_tag_offset, Form: dwarf::DW_FORM_data1,
1784 Integer: *DwarfExpr.TagOffset);
1785}
1786
1787/// Add an address attribute to a die based on the location provided.
1788void DwarfCompileUnit::addAddress(DIE &Die, dwarf::Attribute Attribute,
1789 const MachineLocation &Location) {
1790 addLocationWithExpr(Die, Attribute, Location, Expr: {});
1791}
1792
1793/// Add a memory location exprloc to \p DIE with attribute \p Attribute
1794/// at \p Location + \p Offset.
1795void DwarfCompileUnit::addMemoryLocation(DIE &Die, dwarf::Attribute Attribute,
1796 const MachineLocation &Location,
1797 int64_t Offset) {
1798 assert(Location.isIndirect() && "Memory loc should be indirect");
1799 SmallVector<uint64_t, 3> Ops;
1800 DIExpression::appendOffset(Ops, Offset);
1801 addLocationWithExpr(Die, Attribute, Location, Expr: Ops);
1802}
1803
1804/// Start with the address based on the location provided, and generate the
1805/// DWARF information necessary to find the actual variable given the extra
1806/// address information encoded in the DbgVariable, starting from the starting
1807/// location. Add the DWARF information to the die.
1808void DwarfCompileUnit::addComplexAddress(const DIExpression *DIExpr, DIE &Die,
1809 dwarf::Attribute Attribute,
1810 const MachineLocation &Location) {
1811 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1812 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
1813 DwarfExpr.addFragmentOffset(Expr: DIExpr);
1814 DwarfExpr.setLocation(Loc: Location, DIExpr);
1815
1816 DIExpressionCursor Cursor(DIExpr);
1817
1818 if (DIExpr->isEntryValue())
1819 DwarfExpr.beginEntryValueExpression(ExprCursor&: Cursor);
1820
1821 const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
1822 if (!DwarfExpr.addMachineRegExpression(TRI, Expr&: Cursor, MachineReg: Location.getReg()))
1823 return;
1824 DwarfExpr.addExpression(Expr: std::move(Cursor));
1825
1826 // Now attach the location information to the DIE.
1827 addBlock(Die, Attribute, Loc: DwarfExpr.finalize());
1828
1829 if (DwarfExpr.TagOffset)
1830 addUInt(Die, Attribute: dwarf::DW_AT_LLVM_tag_offset, Form: dwarf::DW_FORM_data1,
1831 Integer: *DwarfExpr.TagOffset);
1832}
1833
1834/// Add a Dwarf loclistptr attribute data and value.
1835void DwarfCompileUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute,
1836 unsigned Index) {
1837 dwarf::Form Form = (DD->getDwarfVersion() >= 5)
1838 ? dwarf::DW_FORM_loclistx
1839 : DD->getDwarfSectionOffsetForm();
1840 addAttribute(Die, Attribute, Form, Value: DIELocList(Index));
1841}
1842
1843void DwarfCompileUnit::applyCommonDbgVariableAttributes(const DbgVariable &Var,
1844 DIE &VariableDie) {
1845 StringRef Name = Var.getName();
1846 if (!Name.empty())
1847 addString(Die&: VariableDie, Attribute: dwarf::DW_AT_name, Str: Name);
1848 const auto *DIVar = Var.getVariable();
1849 if (DIVar) {
1850 if (uint32_t AlignInBytes = DIVar->getAlignInBytes())
1851 addUInt(Die&: VariableDie, Attribute: dwarf::DW_AT_alignment, Form: dwarf::DW_FORM_udata,
1852 Integer: AlignInBytes);
1853 addAnnotation(Buffer&: VariableDie, Annotations: DIVar->getAnnotations());
1854 }
1855
1856 addSourceLine(Die&: VariableDie, V: DIVar);
1857 addType(Entity&: VariableDie, Ty: Var.getType());
1858 if (Var.isArtificial())
1859 addFlag(Die&: VariableDie, Attribute: dwarf::DW_AT_artificial);
1860}
1861
1862void DwarfCompileUnit::applyLabelAttributes(const DbgLabel &Label,
1863 DIE &LabelDie) {
1864 StringRef Name = Label.getName();
1865 if (!Name.empty())
1866 addString(Die&: LabelDie, Attribute: dwarf::DW_AT_name, Str: Name);
1867 const auto *DILabel = Label.getLabel();
1868 addSourceLine(Die&: LabelDie, L: DILabel);
1869 if (DILabel->isArtificial())
1870 addFlag(Die&: LabelDie, Attribute: dwarf::DW_AT_artificial);
1871 if (DILabel->getCoroSuspendIdx())
1872 addUInt(Die&: LabelDie, Attribute: dwarf::DW_AT_LLVM_coro_suspend_idx, Form: std::nullopt,
1873 Integer: *DILabel->getCoroSuspendIdx());
1874}
1875
1876/// Add a Dwarf expression attribute data and value.
1877void DwarfCompileUnit::addExpr(DIELoc &Die, dwarf::Form Form,
1878 const MCExpr *Expr) {
1879 addAttribute(Die, Attribute: (dwarf::Attribute)0, Form, Value: DIEExpr(Expr));
1880}
1881
1882void DwarfCompileUnit::applySubprogramAttributesToDefinition(
1883 const DISubprogram *SP, DIE &SPDie) {
1884 auto *SPDecl = SP->getDeclaration();
1885 auto *Context = SPDecl ? SPDecl->getScope() : SP->getScope();
1886 applySubprogramAttributes(SP, SPDie, SkipSPAttributes: includeMinimalInlineScopes());
1887 addGlobalName(Name: SP->getName(), Die: SPDie, Context);
1888}
1889
1890bool DwarfCompileUnit::isDwoUnit() const {
1891 return DD->useSplitDwarf() && Skeleton;
1892}
1893
1894void DwarfCompileUnit::finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) {
1895 constructTypeDIE(Buffer&: D, CTy);
1896}
1897
1898bool DwarfCompileUnit::includeMinimalInlineScopes() const {
1899 return getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly ||
1900 (DD->useSplitDwarf() && !Skeleton);
1901}
1902
1903bool DwarfCompileUnit::emitFuncLineTableOffsets() const {
1904 return EmitFuncLineTableOffsetsOption;
1905}
1906
1907void DwarfCompileUnit::addAddrTableBase() {
1908 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1909 MCSymbol *Label = DD->getAddressPool().getLabel();
1910 addSectionLabel(Die&: getUnitDie(),
1911 Attribute: DD->getDwarfVersion() >= 5 ? dwarf::DW_AT_addr_base
1912 : dwarf::DW_AT_GNU_addr_base,
1913 Label, Sec: TLOF.getDwarfAddrSection()->getBeginSymbol());
1914}
1915
1916void DwarfCompileUnit::addBaseTypeRef(DIEValueList &Die, int64_t Idx) {
1917 addAttribute(Die, Attribute: (dwarf::Attribute)0, Form: dwarf::DW_FORM_udata,
1918 Value: new (DIEValueAllocator) DIEBaseTypeRef(this, Idx));
1919}
1920
1921void DwarfCompileUnit::createBaseTypeDIEs() {
1922 // Insert the base_type DIEs directly after the CU so that their offsets will
1923 // fit in the fixed size ULEB128 used inside the location expressions.
1924 // Maintain order by iterating backwards and inserting to the front of CU
1925 // child list.
1926 for (auto &Btr : reverse(C&: ExprRefedBaseTypes)) {
1927 DIE &Die = getUnitDie().addChildFront(
1928 Child: DIE::get(Alloc&: DIEValueAllocator, Tag: dwarf::DW_TAG_base_type));
1929 SmallString<32> Str;
1930 addString(Die, Attribute: dwarf::DW_AT_name,
1931 Str: Twine(dwarf::AttributeEncodingString(Encoding: Btr.Encoding) +
1932 "_" + Twine(Btr.BitSize)).toStringRef(Out&: Str));
1933 addUInt(Die, Attribute: dwarf::DW_AT_encoding, Form: dwarf::DW_FORM_data1, Integer: Btr.Encoding);
1934 // Round up to smallest number of bytes that contains this number of bits.
1935 // ExprRefedBaseTypes is populated with types referenced by
1936 // DW_OP_LLVM_convert operations in location expressions. These are often
1937 // byte-sized, but one common counter-example is 1-bit sized conversions
1938 // from `i1` types. TODO: Should these use DW_AT_bit_size? See
1939 // DwarfUnit::constructTypeDIE.
1940 addUInt(Die, Attribute: dwarf::DW_AT_byte_size, Form: std::nullopt,
1941 Integer: divideCeil(Numerator: Btr.BitSize, Denominator: 8));
1942 Btr.Die = &Die;
1943 }
1944}
1945
1946DIE *DwarfCompileUnit::getLocalContextDIE(const DILexicalBlock *LB) {
1947 // Assume if there is an abstract tree all the DIEs are already emitted.
1948 bool isAbstract = getAbstractScopeDIEs().count(Val: LB->getSubprogram());
1949 if (isAbstract) {
1950 auto &DIEs = getAbstractScopeDIEs();
1951 if (auto It = DIEs.find(Val: LB); It != DIEs.end())
1952 return It->second;
1953 }
1954 assert(!isAbstract && "Missed lexical block DIE in abstract tree!");
1955
1956 // Check if we have a concrete DIE.
1957 if (auto It = LexicalBlockDIEs.find(Val: LB); It != LexicalBlockDIEs.end())
1958 return It->second;
1959
1960 // If nothing available found, we cannot just create a new lexical block,
1961 // because it isn't known where to put it into the DIE tree.
1962 // So, we may only try to find the most close avaiable parent DIE.
1963 return getOrCreateContextDIE(Ty: LB->getScope()->getNonLexicalBlockFileScope());
1964}
1965
1966DIE *DwarfCompileUnit::getOrCreateContextDIE(const DIScope *Context) {
1967 if (isa_and_nonnull<DILocalScope>(Val: Context)) {
1968 if (auto *LFScope = dyn_cast<DILexicalBlockFile>(Val: Context))
1969 Context = LFScope->getNonLexicalBlockFileScope();
1970 if (auto *LScope = dyn_cast<DILexicalBlock>(Val: Context))
1971 return getLocalContextDIE(LB: LScope);
1972
1973 // Otherwise the context must be a DISubprogram.
1974 auto *SPScope = cast<DISubprogram>(Val: Context);
1975 const auto &DIEs = getAbstractScopeDIEs();
1976 if (auto It = DIEs.find(Val: SPScope); It != DIEs.end())
1977 return It->second;
1978 }
1979 return DwarfUnit::getOrCreateContextDIE(Context);
1980}
1981
1982DIE *DwarfCompileUnit::getOrCreateSubprogramDIE(const DISubprogram *SP,
1983 const Function *F,
1984 bool Minimal) {
1985 if (!F && SP->isDefinition()) {
1986 F = DD->getLexicalScopes().getFunction(SP);
1987
1988 if (!F) {
1989 // SP may belong to another CU. Determine the CU similarly
1990 // to DwarfDebug::constructAbstractSubprogramScopeDIE.
1991 return &DD->getOrCreateAbstractSubprogramCU(SP, SrcCU&: *this)
1992 .getOrCreateAbstractSubprogramDIE(SP);
1993 }
1994 }
1995
1996 return DwarfUnit::getOrCreateSubprogramDIE(SP, FnHint: F, Minimal);
1997}
1998
1999void DwarfCompileUnit::addLinkageNamesToDeclarations(
2000 const DwarfDebug &DD, const DISubprogram &CalleeSP, DIE &CalleeDIE) {
2001 if (AddLinkageNamesToDeclCallOriginsForTuning(DD: &DD) &&
2002 !CalleeSP.isDefinition() &&
2003 !CalleeDIE.findAttribute(Attribute: dwarf::DW_AT_linkage_name)) {
2004 addLinkageName(Die&: CalleeDIE, LinkageName: CalleeSP.getLinkageName());
2005 }
2006}
2007