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