1 //===- llvm/CodeGen/DwarfCompileUnit.cpp - Dwarf Compile Units ------------===//
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
7 //===----------------------------------------------------------------------===//
9 // This file contains support for constructing a dwarf compile unit.
11 //===----------------------------------------------------------------------===//
13 #include "DwarfCompileUnit.h"
14 #include "AddressPool.h"
15 #include "DwarfDebug.h"
16 #include "DwarfExpression.h"
17 #include "DwarfUnit.h"
18 #include "llvm/ADT/None.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/SmallString.h"
21 #include "llvm/ADT/SmallVector.h"
22 #include "llvm/ADT/StringRef.h"
23 #include "llvm/BinaryFormat/Dwarf.h"
24 #include "llvm/CodeGen/AsmPrinter.h"
25 #include "llvm/CodeGen/DIE.h"
26 #include "llvm/CodeGen/LexicalScopes.h"
27 #include "llvm/CodeGen/MachineFunction.h"
28 #include "llvm/CodeGen/MachineInstr.h"
29 #include "llvm/CodeGen/MachineOperand.h"
30 #include "llvm/CodeGen/TargetFrameLowering.h"
31 #include "llvm/CodeGen/TargetRegisterInfo.h"
32 #include "llvm/CodeGen/TargetSubtargetInfo.h"
33 #include "llvm/IR/DataLayout.h"
34 #include "llvm/IR/DebugInfo.h"
35 #include "llvm/IR/DebugInfoMetadata.h"
36 #include "llvm/IR/GlobalVariable.h"
37 #include "llvm/MC/MCSection.h"
38 #include "llvm/MC/MCStreamer.h"
39 #include "llvm/MC/MCSymbol.h"
40 #include "llvm/MC/MachineLocation.h"
41 #include "llvm/Support/Casting.h"
42 #include "llvm/Target/TargetLoweringObjectFile.h"
43 #include "llvm/Target/TargetMachine.h"
44 #include "llvm/Target/TargetOptions.h"
55 static dwarf::Tag GetCompileUnitType(UnitKind Kind, DwarfDebug *DW) {
57 // According to DWARF Debugging Information Format Version 5,
58 // 3.1.2 Skeleton Compilation Unit Entries:
59 // "When generating a split DWARF object file (see Section 7.3.2
60 // on page 187), the compilation unit in the .debug_info section
61 // is a "skeleton" compilation unit with the tag DW_TAG_skeleton_unit"
62 if (DW->getDwarfVersion() >= 5 && Kind == UnitKind::Skeleton)
63 return dwarf::DW_TAG_skeleton_unit;
65 return dwarf::DW_TAG_compile_unit;
68 DwarfCompileUnit::DwarfCompileUnit(unsigned UID, const DICompileUnit *Node,
69 AsmPrinter *A, DwarfDebug *DW,
70 DwarfFile *DWU, UnitKind Kind)
71 : DwarfUnit(GetCompileUnitType(Kind, DW), Node, A, DW, DWU), UniqueID(UID) {
72 insertDIE(Node, &getUnitDie());
73 MacroLabelBegin = Asm->createTempSymbol("cu_macro_begin");
76 /// addLabelAddress - Add a dwarf label attribute data and value using
77 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
78 void DwarfCompileUnit::addLabelAddress(DIE &Die, dwarf::Attribute Attribute,
79 const MCSymbol *Label) {
80 // Don't use the address pool in non-fission or in the skeleton unit itself.
81 if ((!DD->useSplitDwarf() || !Skeleton) && DD->getDwarfVersion() < 5)
82 return addLocalLabelAddress(Die, Attribute, Label);
85 DD->addArangeLabel(SymbolCU(this, Label));
87 unsigned idx = DD->getAddressPool().getIndex(Label);
88 Die.addValue(DIEValueAllocator, Attribute,
89 DD->getDwarfVersion() >= 5 ? dwarf::DW_FORM_addrx
90 : dwarf::DW_FORM_GNU_addr_index,
94 void DwarfCompileUnit::addLocalLabelAddress(DIE &Die,
95 dwarf::Attribute Attribute,
96 const MCSymbol *Label) {
98 DD->addArangeLabel(SymbolCU(this, Label));
101 Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
104 Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
108 unsigned DwarfCompileUnit::getOrCreateSourceID(const DIFile *File) {
109 // If we print assembly, we can't separate .file entries according to
110 // compile units. Thus all files will belong to the default compile unit.
112 // FIXME: add a better feature test than hasRawTextSupport. Even better,
113 // extend .file to support this.
114 unsigned CUID = Asm->OutStreamer->hasRawTextSupport() ? 0 : getUniqueID();
116 return Asm->OutStreamer->EmitDwarfFileDirective(0, "", "", None, None, CUID);
117 return Asm->OutStreamer->EmitDwarfFileDirective(
118 0, File->getDirectory(), File->getFilename(), getMD5AsBytes(File),
119 File->getSource(), CUID);
122 DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE(
123 const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
124 // Check for pre-existence.
125 if (DIE *Die = getDIE(GV))
130 auto *GVContext = GV->getScope();
131 const DIType *GTy = GV->getType();
133 // Construct the context before querying for the existence of the DIE in
134 // case such construction creates the DIE.
135 auto *CB = GVContext ? dyn_cast<DICommonBlock>(GVContext) : nullptr;
136 DIE *ContextDIE = CB ? getOrCreateCommonBlock(CB, GlobalExprs)
137 : getOrCreateContextDIE(GVContext);
140 DIE *VariableDIE = &createAndAddDIE(GV->getTag(), *ContextDIE, GV);
141 DIScope *DeclContext;
142 if (auto *SDMDecl = GV->getStaticDataMemberDeclaration()) {
143 DeclContext = SDMDecl->getScope();
144 assert(SDMDecl->isStaticMember() && "Expected static member decl");
145 assert(GV->isDefinition());
146 // We need the declaration DIE that is in the static member's class.
147 DIE *VariableSpecDIE = getOrCreateStaticMemberDIE(SDMDecl);
148 addDIEEntry(*VariableDIE, dwarf::DW_AT_specification, *VariableSpecDIE);
149 // If the global variable's type is different from the one in the class
150 // member type, assume that it's more specific and also emit it.
151 if (GTy != SDMDecl->getBaseType())
152 addType(*VariableDIE, GTy);
154 DeclContext = GV->getScope();
155 // Add name and type.
156 addString(*VariableDIE, dwarf::DW_AT_name, GV->getDisplayName());
157 addType(*VariableDIE, GTy);
160 if (!GV->isLocalToUnit())
161 addFlag(*VariableDIE, dwarf::DW_AT_external);
163 // Add line number info.
164 addSourceLine(*VariableDIE, GV);
167 if (!GV->isDefinition())
168 addFlag(*VariableDIE, dwarf::DW_AT_declaration);
170 addGlobalName(GV->getName(), *VariableDIE, DeclContext);
172 if (uint32_t AlignInBytes = GV->getAlignInBytes())
173 addUInt(*VariableDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
176 if (MDTuple *TP = GV->getTemplateParams())
177 addTemplateParams(*VariableDIE, DINodeArray(TP));
180 addLocationAttribute(VariableDIE, GV, GlobalExprs);
185 void DwarfCompileUnit::addLocationAttribute(
186 DIE *VariableDIE, const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
187 bool addToAccelTable = false;
188 DIELoc *Loc = nullptr;
189 Optional<unsigned> NVPTXAddressSpace;
190 std::unique_ptr<DIEDwarfExpression> DwarfExpr;
191 for (const auto &GE : GlobalExprs) {
192 const GlobalVariable *Global = GE.Var;
193 const DIExpression *Expr = GE.Expr;
195 // For compatibility with DWARF 3 and earlier,
196 // DW_AT_location(DW_OP_constu, X, DW_OP_stack_value) becomes
197 // DW_AT_const_value(X).
198 if (GlobalExprs.size() == 1 && Expr && Expr->isConstant()) {
199 addToAccelTable = true;
200 addConstantValue(*VariableDIE, /*Unsigned=*/true, Expr->getElement(1));
204 // We cannot describe the location of dllimport'd variables: the
205 // computation of their address requires loads from the IAT.
206 if (Global && Global->hasDLLImportStorageClass())
209 // Nothing to describe without address or constant.
210 if (!Global && (!Expr || !Expr->isConstant()))
213 if (Global && Global->isThreadLocal() &&
214 !Asm->getObjFileLowering().supportDebugThreadLocalLocation())
218 addToAccelTable = true;
219 Loc = new (DIEValueAllocator) DIELoc;
220 DwarfExpr = std::make_unique<DIEDwarfExpression>(*Asm, *this, *Loc);
225 // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf
226 // cuda-gdb requires DW_AT_address_class for all variables to be able to
227 // correctly interpret address space of the variable address.
228 // Decode DW_OP_constu <DWARF Address Space> DW_OP_swap DW_OP_xderef
229 // sequence for the NVPTX + gdb target.
230 unsigned LocalNVPTXAddressSpace;
231 if (Asm->TM.getTargetTriple().isNVPTX() && DD->tuneForGDB()) {
232 const DIExpression *NewExpr =
233 DIExpression::extractAddressClass(Expr, LocalNVPTXAddressSpace);
234 if (NewExpr != Expr) {
236 NVPTXAddressSpace = LocalNVPTXAddressSpace;
239 DwarfExpr->addFragmentOffset(Expr);
243 const MCSymbol *Sym = Asm->getSymbol(Global);
244 if (Global->isThreadLocal()) {
245 if (Asm->TM.useEmulatedTLS()) {
246 // TODO: add debug info for emulated thread local mode.
248 // FIXME: Make this work with -gsplit-dwarf.
249 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
250 assert((PointerSize == 4 || PointerSize == 8) &&
251 "Add support for other sizes if necessary");
252 // Based on GCC's support for TLS:
253 if (!DD->useSplitDwarf()) {
254 // 1) Start with a constNu of the appropriate pointer size
255 addUInt(*Loc, dwarf::DW_FORM_data1,
256 PointerSize == 4 ? dwarf::DW_OP_const4u
257 : dwarf::DW_OP_const8u);
258 // 2) containing the (relocated) offset of the TLS variable
259 // within the module's TLS block.
260 addExpr(*Loc, dwarf::DW_FORM_udata,
261 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym));
263 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
264 addUInt(*Loc, dwarf::DW_FORM_udata,
265 DD->getAddressPool().getIndex(Sym, /* TLS */ true));
267 // 3) followed by an OP to make the debugger do a TLS lookup.
268 addUInt(*Loc, dwarf::DW_FORM_data1,
269 DD->useGNUTLSOpcode() ? dwarf::DW_OP_GNU_push_tls_address
270 : dwarf::DW_OP_form_tls_address);
273 DD->addArangeLabel(SymbolCU(this, Sym));
274 addOpAddress(*Loc, Sym);
277 // Global variables attached to symbols are memory locations.
278 // It would be better if this were unconditional, but malformed input that
279 // mixes non-fragments and fragments for the same variable is too expensive
280 // to detect in the verifier.
281 if (DwarfExpr->isUnknownLocation())
282 DwarfExpr->setMemoryLocationKind();
283 DwarfExpr->addExpression(Expr);
285 if (Asm->TM.getTargetTriple().isNVPTX() && DD->tuneForGDB()) {
287 // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf
288 // cuda-gdb requires DW_AT_address_class for all variables to be able to
289 // correctly interpret address space of the variable address.
290 const unsigned NVPTX_ADDR_global_space = 5;
291 addUInt(*VariableDIE, dwarf::DW_AT_address_class, dwarf::DW_FORM_data1,
292 NVPTXAddressSpace ? *NVPTXAddressSpace : NVPTX_ADDR_global_space);
295 addBlock(*VariableDIE, dwarf::DW_AT_location, DwarfExpr->finalize());
297 if (DD->useAllLinkageNames())
298 addLinkageName(*VariableDIE, GV->getLinkageName());
300 if (addToAccelTable) {
301 DD->addAccelName(*CUNode, GV->getName(), *VariableDIE);
303 // If the linkage name is different than the name, go ahead and output
304 // that as well into the name table.
305 if (GV->getLinkageName() != "" && GV->getName() != GV->getLinkageName() &&
306 DD->useAllLinkageNames())
307 DD->addAccelName(*CUNode, GV->getLinkageName(), *VariableDIE);
311 DIE *DwarfCompileUnit::getOrCreateCommonBlock(
312 const DICommonBlock *CB, ArrayRef<GlobalExpr> GlobalExprs) {
313 // Construct the context before querying for the existence of the DIE in case
314 // such construction creates the DIE.
315 DIE *ContextDIE = getOrCreateContextDIE(CB->getScope());
317 if (DIE *NDie = getDIE(CB))
319 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_common_block, *ContextDIE, CB);
320 StringRef Name = CB->getName().empty() ? "_BLNK_" : CB->getName();
321 addString(NDie, dwarf::DW_AT_name, Name);
322 addGlobalName(Name, NDie, CB->getScope());
324 addSourceLine(NDie, CB->getLineNo(), CB->getFile());
325 if (DIGlobalVariable *V = CB->getDecl())
326 getCU().addLocationAttribute(&NDie, V, GlobalExprs);
330 void DwarfCompileUnit::addRange(RangeSpan Range) {
331 bool SameAsPrevCU = this == DD->getPrevCU();
333 // If we have no current ranges just add the range and return, otherwise,
334 // check the current section and CU against the previous section and CU we
335 // emitted into and the subprogram was contained within. If these are the
336 // same then extend our current range, otherwise add this as a new range.
337 if (CURanges.empty() || !SameAsPrevCU ||
338 (&CURanges.back().End->getSection() !=
339 &Range.End->getSection())) {
340 CURanges.push_back(Range);
344 CURanges.back().End = Range.End;
347 void DwarfCompileUnit::initStmtList() {
348 if (CUNode->isDebugDirectivesOnly())
351 // Define start line table label for each Compile Unit.
352 MCSymbol *LineTableStartSym;
353 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
354 if (DD->useSectionsAsReferences()) {
355 LineTableStartSym = TLOF.getDwarfLineSection()->getBeginSymbol();
358 Asm->OutStreamer->getDwarfLineTableSymbol(getUniqueID());
361 // DW_AT_stmt_list is a offset of line number information for this
362 // compile unit in debug_line section. For split dwarf this is
363 // left in the skeleton CU and so not included.
364 // The line table entries are not always emitted in assembly, so it
365 // is not okay to use line_table_start here.
367 addSectionLabel(getUnitDie(), dwarf::DW_AT_stmt_list, LineTableStartSym,
368 TLOF.getDwarfLineSection()->getBeginSymbol());
371 void DwarfCompileUnit::applyStmtList(DIE &D) {
372 D.addValue(DIEValueAllocator, *StmtListValue);
375 void DwarfCompileUnit::attachLowHighPC(DIE &D, const MCSymbol *Begin,
376 const MCSymbol *End) {
377 assert(Begin && "Begin label should not be null!");
378 assert(End && "End label should not be null!");
379 assert(Begin->isDefined() && "Invalid starting label");
380 assert(End->isDefined() && "Invalid end label");
382 addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
383 if (DD->getDwarfVersion() < 4)
384 addLabelAddress(D, dwarf::DW_AT_high_pc, End);
386 addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
389 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
390 // and DW_AT_high_pc attributes. If there are global variables in this
391 // scope then create and insert DIEs for these variables.
392 DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP) {
393 DIE *SPDie = getOrCreateSubprogramDIE(SP, includeMinimalInlineScopes());
395 attachLowHighPC(*SPDie, Asm->getFunctionBegin(), Asm->getFunctionEnd());
396 if (DD->useAppleExtensionAttributes() &&
397 !DD->getCurrentFunction()->getTarget().Options.DisableFramePointerElim(
398 *DD->getCurrentFunction()))
399 addFlag(*SPDie, dwarf::DW_AT_APPLE_omit_frame_ptr);
401 // Only include DW_AT_frame_base in full debug info
402 if (!includeMinimalInlineScopes()) {
403 if (Asm->MF->getTarget().getTargetTriple().isNVPTX()) {
404 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
405 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_call_frame_cfa);
406 addBlock(*SPDie, dwarf::DW_AT_frame_base, Loc);
408 const TargetRegisterInfo *RI = Asm->MF->getSubtarget().getRegisterInfo();
409 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
410 if (Register::isPhysicalRegister(Location.getReg()))
411 addAddress(*SPDie, dwarf::DW_AT_frame_base, Location);
415 // Add name to the name table, we do this here because we're guaranteed
416 // to have concrete versions of our DW_TAG_subprogram nodes.
417 DD->addSubprogramNames(*CUNode, SP, *SPDie);
422 // Construct a DIE for this scope.
423 void DwarfCompileUnit::constructScopeDIE(
424 LexicalScope *Scope, SmallVectorImpl<DIE *> &FinalChildren) {
425 if (!Scope || !Scope->getScopeNode())
428 auto *DS = Scope->getScopeNode();
430 assert((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) &&
431 "Only handle inlined subprograms here, use "
432 "constructSubprogramScopeDIE for non-inlined "
435 SmallVector<DIE *, 8> Children;
437 // We try to create the scope DIE first, then the children DIEs. This will
438 // avoid creating un-used children then removing them later when we find out
439 // the scope DIE is null.
441 if (Scope->getParent() && isa<DISubprogram>(DS)) {
442 ScopeDIE = constructInlinedScopeDIE(Scope);
445 // We create children when the scope DIE is not null.
446 createScopeChildrenDIE(Scope, Children);
448 // Early exit when we know the scope DIE is going to be null.
449 if (DD->isLexicalScopeDIENull(Scope))
452 bool HasNonScopeChildren = false;
454 // We create children here when we know the scope DIE is not going to be
455 // null and the children will be added to the scope DIE.
456 createScopeChildrenDIE(Scope, Children, &HasNonScopeChildren);
458 // If there are only other scopes as children, put them directly in the
459 // parent instead, as this scope would serve no purpose.
460 if (!HasNonScopeChildren) {
461 FinalChildren.insert(FinalChildren.end(),
462 std::make_move_iterator(Children.begin()),
463 std::make_move_iterator(Children.end()));
466 ScopeDIE = constructLexicalScopeDIE(Scope);
467 assert(ScopeDIE && "Scope DIE should not be null.");
471 for (auto &I : Children)
472 ScopeDIE->addChild(std::move(I));
474 FinalChildren.push_back(std::move(ScopeDIE));
477 void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE,
478 SmallVector<RangeSpan, 2> Range) {
480 HasRangeLists = true;
482 // Add the range list to the set of ranges to be emitted.
484 (DD->getDwarfVersion() < 5 && Skeleton ? Skeleton->DU : DU)
485 ->addRange(*(Skeleton ? Skeleton : this), std::move(Range));
487 uint32_t Index = IndexAndList.first;
488 auto &List = *IndexAndList.second;
490 // Under fission, ranges are specified by constant offsets relative to the
491 // CU's DW_AT_GNU_ranges_base.
492 // FIXME: For DWARF v5, do not generate the DW_AT_ranges attribute under
493 // fission until we support the forms using the .debug_addr section
494 // (DW_RLE_startx_endx etc.).
495 if (DD->getDwarfVersion() >= 5)
496 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_rnglistx, Index);
498 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
499 const MCSymbol *RangeSectionSym =
500 TLOF.getDwarfRangesSection()->getBeginSymbol();
502 addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, List.Label,
505 addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges, List.Label,
510 void DwarfCompileUnit::attachRangesOrLowHighPC(
511 DIE &Die, SmallVector<RangeSpan, 2> Ranges) {
512 if (Ranges.size() == 1 || !DD->useRangesSection()) {
513 const RangeSpan &Front = Ranges.front();
514 const RangeSpan &Back = Ranges.back();
515 attachLowHighPC(Die, Front.Begin, Back.End);
517 addScopeRangeList(Die, std::move(Ranges));
520 void DwarfCompileUnit::attachRangesOrLowHighPC(
521 DIE &Die, const SmallVectorImpl<InsnRange> &Ranges) {
522 SmallVector<RangeSpan, 2> List;
523 List.reserve(Ranges.size());
524 for (const InsnRange &R : Ranges)
526 {DD->getLabelBeforeInsn(R.first), DD->getLabelAfterInsn(R.second)});
527 attachRangesOrLowHighPC(Die, std::move(List));
530 // This scope represents inlined body of a function. Construct DIE to
531 // represent this concrete inlined copy of the function.
532 DIE *DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope) {
533 assert(Scope->getScopeNode());
534 auto *DS = Scope->getScopeNode();
535 auto *InlinedSP = getDISubprogram(DS);
536 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
537 // was inlined from another compile unit.
538 DIE *OriginDIE = getAbstractSPDies()[InlinedSP];
539 assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.");
541 auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_inlined_subroutine);
542 addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE);
544 attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
546 // Add the call site information to the DIE.
547 const DILocation *IA = Scope->getInlinedAt();
548 addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None,
549 getOrCreateSourceID(IA->getFile()));
550 addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, IA->getLine());
552 addUInt(*ScopeDIE, dwarf::DW_AT_call_column, None, IA->getColumn());
553 if (IA->getDiscriminator() && DD->getDwarfVersion() >= 4)
554 addUInt(*ScopeDIE, dwarf::DW_AT_GNU_discriminator, None,
555 IA->getDiscriminator());
557 // Add name to the name table, we do this here because we're guaranteed
558 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
559 DD->addSubprogramNames(*CUNode, InlinedSP, *ScopeDIE);
564 // Construct new DW_TAG_lexical_block for this scope and attach
565 // DW_AT_low_pc/DW_AT_high_pc labels.
566 DIE *DwarfCompileUnit::constructLexicalScopeDIE(LexicalScope *Scope) {
567 if (DD->isLexicalScopeDIENull(Scope))
570 auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_lexical_block);
571 if (Scope->isAbstractScope())
574 attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
579 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
580 DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV, bool Abstract) {
581 auto D = constructVariableDIEImpl(DV, Abstract);
586 DIE *DwarfCompileUnit::constructLabelDIE(DbgLabel &DL,
587 const LexicalScope &Scope) {
588 auto LabelDie = DIE::get(DIEValueAllocator, DL.getTag());
589 insertDIE(DL.getLabel(), LabelDie);
590 DL.setDIE(*LabelDie);
592 if (Scope.isAbstractScope())
593 applyLabelAttributes(DL, *LabelDie);
598 DIE *DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV,
600 // Define variable debug information entry.
601 auto VariableDie = DIE::get(DIEValueAllocator, DV.getTag());
602 insertDIE(DV.getVariable(), VariableDie);
605 applyVariableAttributes(DV, *VariableDie);
609 // Add variable address.
611 unsigned Offset = DV.getDebugLocListIndex();
613 addLocationList(*VariableDie, dwarf::DW_AT_location, Offset);
614 auto TagOffset = DV.getDebugLocListTagOffset();
616 addUInt(*VariableDie, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1,
621 // Check if variable has a single location description.
622 if (auto *DVal = DV.getValueLoc()) {
623 if (DVal->isLocation())
624 addVariableAddress(DV, *VariableDie, DVal->getLoc());
625 else if (DVal->isInt()) {
626 auto *Expr = DV.getSingleExpression();
627 if (Expr && Expr->getNumElements()) {
628 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
629 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
630 // If there is an expression, emit raw unsigned bytes.
631 DwarfExpr.addFragmentOffset(Expr);
632 DwarfExpr.addUnsignedConstant(DVal->getInt());
633 DwarfExpr.addExpression(Expr);
634 addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
635 if (DwarfExpr.TagOffset)
636 addUInt(*VariableDie, dwarf::DW_AT_LLVM_tag_offset,
637 dwarf::DW_FORM_data1, *DwarfExpr.TagOffset);
640 addConstantValue(*VariableDie, DVal->getInt(), DV.getType());
641 } else if (DVal->isConstantFP()) {
642 addConstantFPValue(*VariableDie, DVal->getConstantFP());
643 } else if (DVal->isConstantInt()) {
644 addConstantValue(*VariableDie, DVal->getConstantInt(), DV.getType());
649 // .. else use frame index.
650 if (!DV.hasFrameIndexExprs())
653 Optional<unsigned> NVPTXAddressSpace;
654 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
655 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
656 for (auto &Fragment : DV.getFrameIndexExprs()) {
657 unsigned FrameReg = 0;
658 const DIExpression *Expr = Fragment.Expr;
659 const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering();
660 int Offset = TFI->getFrameIndexReference(*Asm->MF, Fragment.FI, FrameReg);
661 DwarfExpr.addFragmentOffset(Expr);
662 SmallVector<uint64_t, 8> Ops;
663 DIExpression::appendOffset(Ops, Offset);
665 // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf
666 // cuda-gdb requires DW_AT_address_class for all variables to be able to
667 // correctly interpret address space of the variable address.
668 // Decode DW_OP_constu <DWARF Address Space> DW_OP_swap DW_OP_xderef
669 // sequence for the NVPTX + gdb target.
670 unsigned LocalNVPTXAddressSpace;
671 if (Asm->TM.getTargetTriple().isNVPTX() && DD->tuneForGDB()) {
672 const DIExpression *NewExpr =
673 DIExpression::extractAddressClass(Expr, LocalNVPTXAddressSpace);
674 if (NewExpr != Expr) {
676 NVPTXAddressSpace = LocalNVPTXAddressSpace;
680 Ops.append(Expr->elements_begin(), Expr->elements_end());
681 DIExpressionCursor Cursor(Ops);
682 DwarfExpr.setMemoryLocationKind();
683 if (const MCSymbol *FrameSymbol = Asm->getFunctionFrameSymbol())
684 addOpAddress(*Loc, FrameSymbol);
686 DwarfExpr.addMachineRegExpression(
687 *Asm->MF->getSubtarget().getRegisterInfo(), Cursor, FrameReg);
688 DwarfExpr.addExpression(std::move(Cursor));
690 if (Asm->TM.getTargetTriple().isNVPTX() && DD->tuneForGDB()) {
692 // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf
693 // cuda-gdb requires DW_AT_address_class for all variables to be able to
694 // correctly interpret address space of the variable address.
695 const unsigned NVPTX_ADDR_local_space = 6;
696 addUInt(*VariableDie, dwarf::DW_AT_address_class, dwarf::DW_FORM_data1,
697 NVPTXAddressSpace ? *NVPTXAddressSpace : NVPTX_ADDR_local_space);
699 addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
700 if (DwarfExpr.TagOffset)
701 addUInt(*VariableDie, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1,
702 *DwarfExpr.TagOffset);
707 DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV,
708 const LexicalScope &Scope,
709 DIE *&ObjectPointer) {
710 auto Var = constructVariableDIE(DV, Scope.isAbstractScope());
711 if (DV.isObjectPointer())
716 /// Return all DIVariables that appear in count: expressions.
717 static SmallVector<const DIVariable *, 2> dependencies(DbgVariable *Var) {
718 SmallVector<const DIVariable *, 2> Result;
719 auto *Array = dyn_cast<DICompositeType>(Var->getType());
720 if (!Array || Array->getTag() != dwarf::DW_TAG_array_type)
722 for (auto *El : Array->getElements()) {
723 if (auto *Subrange = dyn_cast<DISubrange>(El)) {
724 auto Count = Subrange->getCount();
725 if (auto *Dependency = Count.dyn_cast<DIVariable *>())
726 Result.push_back(Dependency);
732 /// Sort local variables so that variables appearing inside of helper
733 /// expressions come first.
734 static SmallVector<DbgVariable *, 8>
735 sortLocalVars(SmallVectorImpl<DbgVariable *> &Input) {
736 SmallVector<DbgVariable *, 8> Result;
737 SmallVector<PointerIntPair<DbgVariable *, 1>, 8> WorkList;
738 // Map back from a DIVariable to its containing DbgVariable.
739 SmallDenseMap<const DILocalVariable *, DbgVariable *> DbgVar;
740 // Set of DbgVariables in Result.
741 SmallDenseSet<DbgVariable *, 8> Visited;
742 // For cycle detection.
743 SmallDenseSet<DbgVariable *, 8> Visiting;
745 // Initialize the worklist and the DIVariable lookup table.
746 for (auto Var : reverse(Input)) {
747 DbgVar.insert({Var->getVariable(), Var});
748 WorkList.push_back({Var, 0});
751 // Perform a stable topological sort by doing a DFS.
752 while (!WorkList.empty()) {
753 auto Item = WorkList.back();
754 DbgVariable *Var = Item.getPointer();
755 bool visitedAllDependencies = Item.getInt();
758 // Dependency is in a different lexical scope or a global.
763 if (Visited.count(Var))
766 // Add to Result if all dependencies are visited.
767 if (visitedAllDependencies) {
769 Result.push_back(Var);
774 auto Res = Visiting.insert(Var);
776 assert(false && "dependency cycle in local variables");
780 // Push dependencies and this node onto the worklist, so that this node is
781 // visited again after all of its dependencies are handled.
782 WorkList.push_back({Var, 1});
783 for (auto *Dependency : dependencies(Var)) {
784 auto Dep = dyn_cast_or_null<const DILocalVariable>(Dependency);
785 WorkList.push_back({DbgVar[Dep], 0});
791 DIE *DwarfCompileUnit::createScopeChildrenDIE(LexicalScope *Scope,
792 SmallVectorImpl<DIE *> &Children,
793 bool *HasNonScopeChildren) {
794 assert(Children.empty());
795 DIE *ObjectPointer = nullptr;
797 // Emit function arguments (order is significant).
798 auto Vars = DU->getScopeVariables().lookup(Scope);
799 for (auto &DV : Vars.Args)
800 Children.push_back(constructVariableDIE(*DV.second, *Scope, ObjectPointer));
802 // Emit local variables.
803 auto Locals = sortLocalVars(Vars.Locals);
804 for (DbgVariable *DV : Locals)
805 Children.push_back(constructVariableDIE(*DV, *Scope, ObjectPointer));
807 // Skip imported directives in gmlt-like data.
808 if (!includeMinimalInlineScopes()) {
809 // There is no need to emit empty lexical block DIE.
810 for (const auto *IE : ImportedEntities[Scope->getScopeNode()])
812 constructImportedEntityDIE(cast<DIImportedEntity>(IE)));
815 if (HasNonScopeChildren)
816 *HasNonScopeChildren = !Children.empty();
818 for (DbgLabel *DL : DU->getScopeLabels().lookup(Scope))
819 Children.push_back(constructLabelDIE(*DL, *Scope));
821 for (LexicalScope *LS : Scope->getChildren())
822 constructScopeDIE(LS, Children);
824 return ObjectPointer;
827 DIE &DwarfCompileUnit::constructSubprogramScopeDIE(const DISubprogram *Sub,
828 LexicalScope *Scope) {
829 DIE &ScopeDIE = updateSubprogramScopeDIE(Sub);
832 assert(!Scope->getInlinedAt());
833 assert(!Scope->isAbstractScope());
834 // Collect lexical scope children first.
835 // ObjectPointer might be a local (non-argument) local variable if it's a
836 // block's synthetic this pointer.
837 if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, ScopeDIE))
838 addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
841 // If this is a variadic function, add an unspecified parameter.
842 DITypeRefArray FnArgs = Sub->getType()->getTypeArray();
844 // If we have a single element of null, it is a function that returns void.
845 // If we have more than one elements and the last one is null, it is a
846 // variadic function.
847 if (FnArgs.size() > 1 && !FnArgs[FnArgs.size() - 1] &&
848 !includeMinimalInlineScopes())
850 DIE::get(DIEValueAllocator, dwarf::DW_TAG_unspecified_parameters));
855 DIE *DwarfCompileUnit::createAndAddScopeChildren(LexicalScope *Scope,
857 // We create children when the scope DIE is not null.
858 SmallVector<DIE *, 8> Children;
859 DIE *ObjectPointer = createScopeChildrenDIE(Scope, Children);
862 for (auto &I : Children)
863 ScopeDIE.addChild(std::move(I));
865 return ObjectPointer;
868 void DwarfCompileUnit::constructAbstractSubprogramScopeDIE(
869 LexicalScope *Scope) {
870 DIE *&AbsDef = getAbstractSPDies()[Scope->getScopeNode()];
874 auto *SP = cast<DISubprogram>(Scope->getScopeNode());
877 DwarfCompileUnit *ContextCU = this;
879 if (includeMinimalInlineScopes())
880 ContextDIE = &getUnitDie();
881 // Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with
882 // the important distinction that the debug node is not associated with the
883 // DIE (since the debug node will be associated with the concrete DIE, if
884 // any). It could be refactored to some common utility function.
885 else if (auto *SPDecl = SP->getDeclaration()) {
886 ContextDIE = &getUnitDie();
887 getOrCreateSubprogramDIE(SPDecl);
889 ContextDIE = getOrCreateContextDIE(SP->getScope());
890 // The scope may be shared with a subprogram that has already been
891 // constructed in another CU, in which case we need to construct this
892 // subprogram in the same CU.
893 ContextCU = DD->lookupCU(ContextDIE->getUnitDie());
896 // Passing null as the associated node because the abstract definition
897 // shouldn't be found by lookup.
898 AbsDef = &ContextCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, nullptr);
899 ContextCU->applySubprogramAttributesToDefinition(SP, *AbsDef);
901 if (!ContextCU->includeMinimalInlineScopes())
902 ContextCU->addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
903 if (DIE *ObjectPointer = ContextCU->createAndAddScopeChildren(Scope, *AbsDef))
904 ContextCU->addDIEEntry(*AbsDef, dwarf::DW_AT_object_pointer, *ObjectPointer);
907 /// Whether to use the GNU analog for a DWARF5 tag, attribute, or location atom.
908 static bool useGNUAnalogForDwarf5Feature(DwarfDebug *DD) {
909 return DD->getDwarfVersion() == 4 && DD->tuneForGDB();
912 dwarf::Tag DwarfCompileUnit::getDwarf5OrGNUTag(dwarf::Tag Tag) const {
913 if (!useGNUAnalogForDwarf5Feature(DD))
916 case dwarf::DW_TAG_call_site:
917 return dwarf::DW_TAG_GNU_call_site;
918 case dwarf::DW_TAG_call_site_parameter:
919 return dwarf::DW_TAG_GNU_call_site_parameter;
921 llvm_unreachable("DWARF5 tag with no GNU analog");
926 DwarfCompileUnit::getDwarf5OrGNUAttr(dwarf::Attribute Attr) const {
927 if (!useGNUAnalogForDwarf5Feature(DD))
930 case dwarf::DW_AT_call_all_calls:
931 return dwarf::DW_AT_GNU_all_call_sites;
932 case dwarf::DW_AT_call_target:
933 return dwarf::DW_AT_GNU_call_site_target;
934 case dwarf::DW_AT_call_origin:
935 return dwarf::DW_AT_abstract_origin;
936 case dwarf::DW_AT_call_pc:
937 return dwarf::DW_AT_low_pc;
938 case dwarf::DW_AT_call_value:
939 return dwarf::DW_AT_GNU_call_site_value;
940 case dwarf::DW_AT_call_tail_call:
941 return dwarf::DW_AT_GNU_tail_call;
943 llvm_unreachable("DWARF5 attribute with no GNU analog");
948 DwarfCompileUnit::getDwarf5OrGNULocationAtom(dwarf::LocationAtom Loc) const {
949 if (!useGNUAnalogForDwarf5Feature(DD))
952 case dwarf::DW_OP_entry_value:
953 return dwarf::DW_OP_GNU_entry_value;
955 llvm_unreachable("DWARF5 location atom with no GNU analog");
959 DIE &DwarfCompileUnit::constructCallSiteEntryDIE(
960 DIE &ScopeDIE, const DISubprogram *CalleeSP, bool IsTail,
961 const MCSymbol *PCAddr, const MCExpr *PCOffset, unsigned CallReg) {
962 // Insert a call site entry DIE within ScopeDIE.
963 DIE &CallSiteDIE = createAndAddDIE(getDwarf5OrGNUTag(dwarf::DW_TAG_call_site),
968 addAddress(CallSiteDIE, getDwarf5OrGNUAttr(dwarf::DW_AT_call_target),
969 MachineLocation(CallReg));
971 DIE *CalleeDIE = getOrCreateSubprogramDIE(CalleeSP);
972 assert(CalleeDIE && "Could not create DIE for call site entry origin");
973 addDIEEntry(CallSiteDIE, getDwarf5OrGNUAttr(dwarf::DW_AT_call_origin),
978 // Attach DW_AT_call_tail_call to tail calls for standards compliance.
979 addFlag(CallSiteDIE, getDwarf5OrGNUAttr(dwarf::DW_AT_call_tail_call));
981 // Attach the return PC to allow the debugger to disambiguate call paths
982 // from one function to another.
983 if (DD->getDwarfVersion() == 4 && DD->tuneForGDB()) {
984 assert(PCAddr && "Missing PC information for a call");
985 addLabelAddress(CallSiteDIE, dwarf::DW_AT_low_pc, PCAddr);
986 } else if (!IsTail || DD->tuneForGDB()) {
987 assert(PCOffset && "Missing return PC information for a call");
988 addAddressExpr(CallSiteDIE, dwarf::DW_AT_call_return_pc, PCOffset);
994 void DwarfCompileUnit::constructCallSiteParmEntryDIEs(
995 DIE &CallSiteDIE, SmallVector<DbgCallSiteParam, 4> &Params) {
996 for (const auto &Param : Params) {
997 unsigned Register = Param.getRegister();
998 auto CallSiteDieParam =
999 DIE::get(DIEValueAllocator,
1000 getDwarf5OrGNUTag(dwarf::DW_TAG_call_site_parameter));
1001 insertDIE(CallSiteDieParam);
1002 addAddress(*CallSiteDieParam, dwarf::DW_AT_location,
1003 MachineLocation(Register));
1005 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1006 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
1007 DwarfExpr.setCallSiteParamValueFlag();
1009 DwarfDebug::emitDebugLocValue(*Asm, nullptr, Param.getValue(), DwarfExpr);
1011 addBlock(*CallSiteDieParam, getDwarf5OrGNUAttr(dwarf::DW_AT_call_value),
1012 DwarfExpr.finalize());
1014 CallSiteDIE.addChild(CallSiteDieParam);
1018 DIE *DwarfCompileUnit::constructImportedEntityDIE(
1019 const DIImportedEntity *Module) {
1020 DIE *IMDie = DIE::get(DIEValueAllocator, (dwarf::Tag)Module->getTag());
1021 insertDIE(Module, IMDie);
1023 auto *Entity = Module->getEntity();
1024 if (auto *NS = dyn_cast<DINamespace>(Entity))
1025 EntityDie = getOrCreateNameSpace(NS);
1026 else if (auto *M = dyn_cast<DIModule>(Entity))
1027 EntityDie = getOrCreateModule(M);
1028 else if (auto *SP = dyn_cast<DISubprogram>(Entity))
1029 EntityDie = getOrCreateSubprogramDIE(SP);
1030 else if (auto *T = dyn_cast<DIType>(Entity))
1031 EntityDie = getOrCreateTypeDIE(T);
1032 else if (auto *GV = dyn_cast<DIGlobalVariable>(Entity))
1033 EntityDie = getOrCreateGlobalVariableDIE(GV, {});
1035 EntityDie = getDIE(Entity);
1037 addSourceLine(*IMDie, Module->getLine(), Module->getFile());
1038 addDIEEntry(*IMDie, dwarf::DW_AT_import, *EntityDie);
1039 StringRef Name = Module->getName();
1041 addString(*IMDie, dwarf::DW_AT_name, Name);
1046 void DwarfCompileUnit::finishSubprogramDefinition(const DISubprogram *SP) {
1047 DIE *D = getDIE(SP);
1048 if (DIE *AbsSPDIE = getAbstractSPDies().lookup(SP)) {
1050 // If this subprogram has an abstract definition, reference that
1051 addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE);
1053 assert(D || includeMinimalInlineScopes());
1055 // And attach the attributes
1056 applySubprogramAttributesToDefinition(SP, *D);
1060 void DwarfCompileUnit::finishEntityDefinition(const DbgEntity *Entity) {
1061 DbgEntity *AbsEntity = getExistingAbstractEntity(Entity->getEntity());
1063 auto *Die = Entity->getDIE();
1064 /// Label may be used to generate DW_AT_low_pc, so put it outside
1066 const DbgLabel *Label = nullptr;
1067 if (AbsEntity && AbsEntity->getDIE()) {
1068 addDIEEntry(*Die, dwarf::DW_AT_abstract_origin, *AbsEntity->getDIE());
1069 Label = dyn_cast<const DbgLabel>(Entity);
1071 if (const DbgVariable *Var = dyn_cast<const DbgVariable>(Entity))
1072 applyVariableAttributes(*Var, *Die);
1073 else if ((Label = dyn_cast<const DbgLabel>(Entity)))
1074 applyLabelAttributes(*Label, *Die);
1076 llvm_unreachable("DbgEntity must be DbgVariable or DbgLabel.");
1080 if (const auto *Sym = Label->getSymbol())
1081 addLabelAddress(*Die, dwarf::DW_AT_low_pc, Sym);
1084 DbgEntity *DwarfCompileUnit::getExistingAbstractEntity(const DINode *Node) {
1085 auto &AbstractEntities = getAbstractEntities();
1086 auto I = AbstractEntities.find(Node);
1087 if (I != AbstractEntities.end())
1088 return I->second.get();
1092 void DwarfCompileUnit::createAbstractEntity(const DINode *Node,
1093 LexicalScope *Scope) {
1094 assert(Scope && Scope->isAbstractScope());
1095 auto &Entity = getAbstractEntities()[Node];
1096 if (isa<const DILocalVariable>(Node)) {
1097 Entity = std::make_unique<DbgVariable>(
1098 cast<const DILocalVariable>(Node), nullptr /* IA */);;
1099 DU->addScopeVariable(Scope, cast<DbgVariable>(Entity.get()));
1100 } else if (isa<const DILabel>(Node)) {
1101 Entity = std::make_unique<DbgLabel>(
1102 cast<const DILabel>(Node), nullptr /* IA */);
1103 DU->addScopeLabel(Scope, cast<DbgLabel>(Entity.get()));
1107 void DwarfCompileUnit::emitHeader(bool UseOffsets) {
1108 // Don't bother labeling the .dwo unit, as its offset isn't used.
1109 if (!Skeleton && !DD->useSectionsAsReferences()) {
1110 LabelBegin = Asm->createTempSymbol("cu_begin");
1111 Asm->OutStreamer->EmitLabel(LabelBegin);
1114 dwarf::UnitType UT = Skeleton ? dwarf::DW_UT_split_compile
1115 : DD->useSplitDwarf() ? dwarf::DW_UT_skeleton
1116 : dwarf::DW_UT_compile;
1117 DwarfUnit::emitCommonHeader(UseOffsets, UT);
1118 if (DD->getDwarfVersion() >= 5 && UT != dwarf::DW_UT_compile)
1119 Asm->emitInt64(getDWOId());
1122 bool DwarfCompileUnit::hasDwarfPubSections() const {
1123 switch (CUNode->getNameTableKind()) {
1124 case DICompileUnit::DebugNameTableKind::None:
1126 // Opting in to GNU Pubnames/types overrides the default to ensure these are
1127 // generated for things like Gold's gdb_index generation.
1128 case DICompileUnit::DebugNameTableKind::GNU:
1130 case DICompileUnit::DebugNameTableKind::Default:
1131 return DD->tuneForGDB() && !includeMinimalInlineScopes() &&
1132 !CUNode->isDebugDirectivesOnly() &&
1133 DD->getAccelTableKind() != AccelTableKind::Apple &&
1134 DD->getDwarfVersion() < 5;
1136 llvm_unreachable("Unhandled DICompileUnit::DebugNameTableKind enum");
1139 /// addGlobalName - Add a new global name to the compile unit.
1140 void DwarfCompileUnit::addGlobalName(StringRef Name, const DIE &Die,
1141 const DIScope *Context) {
1142 if (!hasDwarfPubSections())
1144 std::string FullName = getParentContextString(Context) + Name.str();
1145 GlobalNames[FullName] = &Die;
1148 void DwarfCompileUnit::addGlobalNameForTypeUnit(StringRef Name,
1149 const DIScope *Context) {
1150 if (!hasDwarfPubSections())
1152 std::string FullName = getParentContextString(Context) + Name.str();
1153 // Insert, allowing the entry to remain as-is if it's already present
1154 // This way the CU-level type DIE is preferred over the "can't describe this
1155 // type as a unit offset because it's not really in the CU at all, it's only
1157 GlobalNames.insert(std::make_pair(std::move(FullName), &getUnitDie()));
1160 /// Add a new global type to the unit.
1161 void DwarfCompileUnit::addGlobalType(const DIType *Ty, const DIE &Die,
1162 const DIScope *Context) {
1163 if (!hasDwarfPubSections())
1165 std::string FullName = getParentContextString(Context) + Ty->getName().str();
1166 GlobalTypes[FullName] = &Die;
1169 void DwarfCompileUnit::addGlobalTypeUnitType(const DIType *Ty,
1170 const DIScope *Context) {
1171 if (!hasDwarfPubSections())
1173 std::string FullName = getParentContextString(Context) + Ty->getName().str();
1174 // Insert, allowing the entry to remain as-is if it's already present
1175 // This way the CU-level type DIE is preferred over the "can't describe this
1176 // type as a unit offset because it's not really in the CU at all, it's only
1178 GlobalTypes.insert(std::make_pair(std::move(FullName), &getUnitDie()));
1181 void DwarfCompileUnit::addVariableAddress(const DbgVariable &DV, DIE &Die,
1182 MachineLocation Location) {
1183 if (DV.hasComplexAddress())
1184 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
1186 addAddress(Die, dwarf::DW_AT_location, Location);
1189 /// Add an address attribute to a die based on the location provided.
1190 void DwarfCompileUnit::addAddress(DIE &Die, dwarf::Attribute Attribute,
1191 const MachineLocation &Location) {
1192 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1193 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
1194 if (Location.isIndirect())
1195 DwarfExpr.setMemoryLocationKind();
1197 DIExpressionCursor Cursor({});
1198 const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
1199 if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
1201 DwarfExpr.addExpression(std::move(Cursor));
1203 // Now attach the location information to the DIE.
1204 addBlock(Die, Attribute, DwarfExpr.finalize());
1206 if (DwarfExpr.TagOffset)
1207 addUInt(Die, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1,
1208 *DwarfExpr.TagOffset);
1211 /// Start with the address based on the location provided, and generate the
1212 /// DWARF information necessary to find the actual variable given the extra
1213 /// address information encoded in the DbgVariable, starting from the starting
1214 /// location. Add the DWARF information to the die.
1215 void DwarfCompileUnit::addComplexAddress(const DbgVariable &DV, DIE &Die,
1216 dwarf::Attribute Attribute,
1217 const MachineLocation &Location) {
1218 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1219 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
1220 const DIExpression *DIExpr = DV.getSingleExpression();
1221 DwarfExpr.addFragmentOffset(DIExpr);
1222 if (Location.isIndirect())
1223 DwarfExpr.setMemoryLocationKind();
1225 DIExpressionCursor Cursor(DIExpr);
1227 if (DIExpr->isEntryValue()) {
1228 DwarfExpr.setEntryValueFlag();
1229 DwarfExpr.beginEntryValueExpression(Cursor);
1232 const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
1233 if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
1235 DwarfExpr.addExpression(std::move(Cursor));
1237 // Now attach the location information to the DIE.
1238 addBlock(Die, Attribute, DwarfExpr.finalize());
1240 if (DwarfExpr.TagOffset)
1241 addUInt(Die, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1,
1242 *DwarfExpr.TagOffset);
1245 /// Add a Dwarf loclistptr attribute data and value.
1246 void DwarfCompileUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute,
1248 dwarf::Form Form = dwarf::DW_FORM_data4;
1249 if (DD->getDwarfVersion() == 4)
1250 Form =dwarf::DW_FORM_sec_offset;
1251 if (DD->getDwarfVersion() >= 5)
1252 Form =dwarf::DW_FORM_loclistx;
1253 Die.addValue(DIEValueAllocator, Attribute, Form, DIELocList(Index));
1256 void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var,
1258 StringRef Name = Var.getName();
1260 addString(VariableDie, dwarf::DW_AT_name, Name);
1261 const auto *DIVar = Var.getVariable();
1263 if (uint32_t AlignInBytes = DIVar->getAlignInBytes())
1264 addUInt(VariableDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1267 addSourceLine(VariableDie, DIVar);
1268 addType(VariableDie, Var.getType());
1269 if (Var.isArtificial())
1270 addFlag(VariableDie, dwarf::DW_AT_artificial);
1273 void DwarfCompileUnit::applyLabelAttributes(const DbgLabel &Label,
1275 StringRef Name = Label.getName();
1277 addString(LabelDie, dwarf::DW_AT_name, Name);
1278 const auto *DILabel = Label.getLabel();
1279 addSourceLine(LabelDie, DILabel);
1282 /// Add a Dwarf expression attribute data and value.
1283 void DwarfCompileUnit::addExpr(DIELoc &Die, dwarf::Form Form,
1284 const MCExpr *Expr) {
1285 Die.addValue(DIEValueAllocator, (dwarf::Attribute)0, Form, DIEExpr(Expr));
1288 void DwarfCompileUnit::addAddressExpr(DIE &Die, dwarf::Attribute Attribute,
1289 const MCExpr *Expr) {
1290 Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
1294 void DwarfCompileUnit::applySubprogramAttributesToDefinition(
1295 const DISubprogram *SP, DIE &SPDie) {
1296 auto *SPDecl = SP->getDeclaration();
1297 auto *Context = SPDecl ? SPDecl->getScope() : SP->getScope();
1298 applySubprogramAttributes(SP, SPDie, includeMinimalInlineScopes());
1299 addGlobalName(SP->getName(), SPDie, Context);
1302 bool DwarfCompileUnit::isDwoUnit() const {
1303 return DD->useSplitDwarf() && Skeleton;
1306 void DwarfCompileUnit::finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) {
1307 constructTypeDIE(D, CTy);
1310 bool DwarfCompileUnit::includeMinimalInlineScopes() const {
1311 return getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly ||
1312 (DD->useSplitDwarf() && !Skeleton);
1315 void DwarfCompileUnit::addAddrTableBase() {
1316 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1317 MCSymbol *Label = DD->getAddressPool().getLabel();
1318 addSectionLabel(getUnitDie(),
1319 getDwarfVersion() >= 5 ? dwarf::DW_AT_addr_base
1320 : dwarf::DW_AT_GNU_addr_base,
1321 Label, TLOF.getDwarfAddrSection()->getBeginSymbol());
1324 void DwarfCompileUnit::addBaseTypeRef(DIEValueList &Die, int64_t Idx) {
1325 Die.addValue(DIEValueAllocator, (dwarf::Attribute)0, dwarf::DW_FORM_udata,
1326 new (DIEValueAllocator) DIEBaseTypeRef(this, Idx));
1329 void DwarfCompileUnit::createBaseTypeDIEs() {
1330 // Insert the base_type DIEs directly after the CU so that their offsets will
1331 // fit in the fixed size ULEB128 used inside the location expressions.
1332 // Maintain order by iterating backwards and inserting to the front of CU
1334 for (auto &Btr : reverse(ExprRefedBaseTypes)) {
1335 DIE &Die = getUnitDie().addChildFront(
1336 DIE::get(DIEValueAllocator, dwarf::DW_TAG_base_type));
1337 SmallString<32> Str;
1338 addString(Die, dwarf::DW_AT_name,
1339 Twine(dwarf::AttributeEncodingString(Btr.Encoding) +
1340 "_" + Twine(Btr.BitSize)).toStringRef(Str));
1341 addUInt(Die, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, Btr.Encoding);
1342 addUInt(Die, dwarf::DW_AT_byte_size, None, Btr.BitSize / 8);