1//===- llvm/CodeGen/DwarfFile.cpp - Dwarf Debug Framework -----------------===//
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#include "DwarfFile.h"
10#include "DwarfCompileUnit.h"
11#include "DwarfDebug.h"
12#include "DwarfUnit.h"
13#include "llvm/CodeGen/AsmPrinter.h"
14#include "llvm/IR/DebugInfoMetadata.h"
15#include "llvm/MC/MCStreamer.h"
16#include <cstdint>
17
18using namespace llvm;
19
20DwarfFile::DwarfFile(AsmPrinter *AP, StringRef Pref, BumpPtrAllocator &DA)
21 : Asm(AP), Abbrevs(AbbrevAllocator), StrPool(DA, *Asm, Pref) {}
22
23void DwarfFile::addUnit(std::unique_ptr<DwarfCompileUnit> U) {
24 CUs.push_back(Elt: std::move(U));
25}
26
27// Emit the various dwarf units to the unit section USection with
28// the abbreviations going into ASection.
29void DwarfFile::emitUnits(bool UseOffsets) {
30 for (const auto &TheU : CUs)
31 emitUnit(TheU: TheU.get(), UseOffsets);
32}
33
34void DwarfFile::emitUnit(DwarfUnit *TheU, bool UseOffsets) {
35 if (TheU->getCUNode()->isDebugDirectivesOnly())
36 return;
37
38 MCSection *S = TheU->getSection();
39
40 if (!S)
41 return;
42
43 // Skip CUs that ended up not being needed (split CUs that were abandoned
44 // because they added no information beyond the non-split CU)
45 if (TheU->getUnitDie().values().empty())
46 return;
47
48 Asm->OutStreamer->switchSection(Section: S);
49 TheU->emitHeader(UseOffsets);
50 Asm->emitDwarfDIE(Die: TheU->getUnitDie());
51
52 if (MCSymbol *EndLabel = TheU->getEndLabel())
53 Asm->OutStreamer->emitLabel(Symbol: EndLabel);
54}
55
56// Compute the size and offset for each DIE.
57void DwarfFile::computeSizeAndOffsets() {
58 // Offset from the first CU in the debug info section is 0 initially.
59 uint64_t SecOffset = 0;
60
61 // Iterate over each compile unit and set the size and offsets for each
62 // DIE within each compile unit. All offsets are CU relative.
63 for (const auto &TheU : CUs) {
64 if (TheU->getCUNode()->isDebugDirectivesOnly())
65 continue;
66
67 // Skip CUs that ended up not being needed (split CUs that were abandoned
68 // because they added no information beyond the non-split CU)
69 if (TheU->getUnitDie().values().empty())
70 return;
71
72 TheU->setDebugSectionOffset(SecOffset);
73 SecOffset += computeSizeAndOffsetsForUnit(TheU: TheU.get());
74 }
75 if (SecOffset > UINT32_MAX && !Asm->isDwarf64())
76 report_fatal_error(reason: "The generated debug information is too large "
77 "for the 32-bit DWARF format.");
78}
79
80unsigned DwarfFile::computeSizeAndOffsetsForUnit(DwarfUnit *TheU) {
81 // CU-relative offset is reset to 0 here.
82 unsigned Offset = Asm->getUnitLengthFieldByteSize() + // Length of Unit Info
83 TheU->getHeaderSize(); // Unit-specific headers
84
85 // The return value here is CU-relative, after laying out
86 // all of the CU DIE.
87 return computeSizeAndOffset(Die&: TheU->getUnitDie(), Offset);
88}
89
90// Compute the size and offset of a DIE. The offset is relative to start of the
91// CU. It returns the offset after laying out the DIE.
92unsigned DwarfFile::computeSizeAndOffset(DIE &Die, unsigned Offset) {
93 return Die.computeOffsetsAndAbbrevs(FormParams: Asm->getDwarfFormParams(), AbbrevSet&: Abbrevs,
94 CUOffset: Offset);
95}
96
97void DwarfFile::emitAbbrevs(MCSection *Section) { Abbrevs.Emit(AP: Asm, Section); }
98
99// Emit strings into a string section.
100void DwarfFile::emitStrings(MCSection *StrSection, MCSection *OffsetSection,
101 bool UseRelativeOffsets) {
102 StrPool.emit(Asm&: *Asm, StrSection, OffsetSection, UseRelativeOffsets);
103}
104
105void DwarfFile::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
106 auto &ScopeVars = ScopeVariables[LS];
107 const DILocalVariable *DV = Var->getVariable();
108 if (unsigned ArgNum = DV->getArg()) {
109 auto Ret = ScopeVars.Args.insert(x: {ArgNum, Var});
110 assert(Ret.second);
111 (void)Ret;
112 } else {
113 ScopeVars.Locals.push_back(Elt: Var);
114 }
115}
116
117void DwarfFile::addScopeLabel(LexicalScope *LS, DbgLabel *Label) {
118 SmallVectorImpl<DbgLabel *> &Labels = ScopeLabels[LS];
119 Labels.push_back(Elt: Label);
120}
121
122std::pair<uint32_t, RangeSpanList *>
123DwarfFile::addRange(const DwarfCompileUnit &CU, SmallVector<RangeSpan, 2> R) {
124 bool CanReuseLastRange = false;
125
126 if (!CURangeLists.empty()) {
127 auto Last = CURangeLists.back();
128 if (Last.CU == &CU && Last.Ranges == R) {
129 CanReuseLastRange = true;
130 }
131 }
132
133 if (!CanReuseLastRange) {
134 CURangeLists.push_back(Elt: RangeSpanList{.Label: Asm->createTempSymbol(Name: "debug_ranges"),
135 .CU: &CU, .Ranges: std::move(R)});
136 }
137
138 return std::make_pair(x: CURangeLists.size() - 1, y: &CURangeLists.back());
139}
140