1 //===------ dwarf2yaml.cpp - obj2yaml conversion tool -----------*- C++ -*-===//
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 "llvm/BinaryFormat/Dwarf.h"
10 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
11 #include "llvm/DebugInfo/DWARF/DWARFDebugAddr.h"
12 #include "llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h"
13 #include "llvm/DebugInfo/DWARF/DWARFDebugPubTable.h"
14 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
15 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
16 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
17 #include "llvm/ObjectYAML/DWARFYAML.h"
18 
19 #include <algorithm>
20 
21 using namespace llvm;
22 
23 void dumpDebugAbbrev(DWARFContext &DCtx, DWARFYAML::Data &Y) {
24   auto AbbrevSetPtr = DCtx.getDebugAbbrev();
25   if (AbbrevSetPtr) {
26     uint64_t AbbrevTableID = 0;
27     for (auto AbbrvDeclSet : *AbbrevSetPtr) {
28       Y.DebugAbbrev.emplace_back();
29       Y.DebugAbbrev.back().ID = AbbrevTableID++;
30       for (auto AbbrvDecl : AbbrvDeclSet.second) {
31         DWARFYAML::Abbrev Abbrv;
32         Abbrv.Code = AbbrvDecl.getCode();
33         Abbrv.Tag = AbbrvDecl.getTag();
34         Abbrv.Children = AbbrvDecl.hasChildren() ? dwarf::DW_CHILDREN_yes
35                                                  : dwarf::DW_CHILDREN_no;
36         for (auto Attribute : AbbrvDecl.attributes()) {
37           DWARFYAML::AttributeAbbrev AttAbrv;
38           AttAbrv.Attribute = Attribute.Attr;
39           AttAbrv.Form = Attribute.Form;
40           if (AttAbrv.Form == dwarf::DW_FORM_implicit_const)
41             AttAbrv.Value = Attribute.getImplicitConstValue();
42           Abbrv.Attributes.push_back(AttAbrv);
43         }
44         Y.DebugAbbrev.back().Table.push_back(Abbrv);
45       }
46     }
47   }
48 }
49 
50 Error dumpDebugAddr(DWARFContext &DCtx, DWARFYAML::Data &Y) {
51   DWARFDebugAddrTable AddrTable;
52   DWARFDataExtractor AddrData(DCtx.getDWARFObj(),
53                               DCtx.getDWARFObj().getAddrSection(),
54                               DCtx.isLittleEndian(), /*AddrSize=*/0);
55   std::vector<DWARFYAML::AddrTableEntry> AddrTables;
56   uint64_t Offset = 0;
57   while (AddrData.isValidOffset(Offset)) {
58     // We ignore any errors that don't prevent parsing the section, since we can
59     // still represent such sections.
60     if (Error Err = AddrTable.extractV5(AddrData, &Offset, /*CUAddrSize=*/0,
61                                         consumeError))
62       return Err;
63     AddrTables.emplace_back();
64     for (uint64_t Addr : AddrTable.getAddressEntries()) {
65       // Currently, the parser doesn't support parsing an address table with non
66       // linear addresses (segment_selector_size != 0). The segment selectors
67       // are specified to be zero.
68       AddrTables.back().SegAddrPairs.push_back(
69           {/*SegmentSelector=*/0, /*Address=*/Addr});
70     }
71 
72     AddrTables.back().Format = AddrTable.getFormat();
73     AddrTables.back().Length = AddrTable.getLength();
74     AddrTables.back().Version = AddrTable.getVersion();
75     AddrTables.back().AddrSize = AddrTable.getAddressSize();
76     AddrTables.back().SegSelectorSize = AddrTable.getSegmentSelectorSize();
77   }
78   Y.DebugAddr = std::move(AddrTables);
79   return Error::success();
80 }
81 
82 Error dumpDebugStrings(DWARFContext &DCtx, DWARFYAML::Data &Y) {
83   DataExtractor StrData = DCtx.getStringExtractor();
84   uint64_t Offset = 0;
85   std::vector<StringRef> DebugStr;
86   Error Err = Error::success();
87   while (StrData.isValidOffset(Offset)) {
88     const char *CStr = StrData.getCStr(&Offset, &Err);
89     if (Err)
90       return Err;
91     DebugStr.push_back(CStr);
92   }
93 
94   Y.DebugStrings = DebugStr;
95   return Err;
96 }
97 
98 Error dumpDebugARanges(DWARFContext &DCtx, DWARFYAML::Data &Y) {
99   DWARFDataExtractor ArangesData(DCtx.getDWARFObj().getArangesSection(),
100                                  DCtx.isLittleEndian(), 0);
101   uint64_t Offset = 0;
102   DWARFDebugArangeSet Set;
103   std::vector<DWARFYAML::ARange> DebugAranges;
104 
105   // We ignore any errors that don't prevent parsing the section, since we can
106   // still represent such sections. These errors are recorded via the
107   // WarningHandler parameter of Set.extract().
108   auto DiscardError = [](Error Err) { consumeError(std::move(Err)); };
109 
110   while (ArangesData.isValidOffset(Offset)) {
111     if (Error E = Set.extract(ArangesData, &Offset, DiscardError))
112       return E;
113     DWARFYAML::ARange Range;
114     Range.Format = Set.getHeader().Format;
115     Range.Length = Set.getHeader().Length;
116     Range.Version = Set.getHeader().Version;
117     Range.CuOffset = Set.getHeader().CuOffset;
118     Range.AddrSize = Set.getHeader().AddrSize;
119     Range.SegSize = Set.getHeader().SegSize;
120     for (auto Descriptor : Set.descriptors()) {
121       DWARFYAML::ARangeDescriptor Desc;
122       Desc.Address = Descriptor.Address;
123       Desc.Length = Descriptor.Length;
124       Range.Descriptors.push_back(Desc);
125     }
126     DebugAranges.push_back(Range);
127   }
128 
129   Y.DebugAranges = DebugAranges;
130   return ErrorSuccess();
131 }
132 
133 Error dumpDebugRanges(DWARFContext &DCtx, DWARFYAML::Data &Y) {
134   // We are assuming all address byte sizes will be consistent across all
135   // compile units.
136   uint8_t AddrSize = 0;
137   for (const auto &CU : DCtx.compile_units()) {
138     const uint8_t CUAddrSize = CU->getAddressByteSize();
139     if (AddrSize == 0)
140       AddrSize = CUAddrSize;
141     else if (CUAddrSize != AddrSize)
142       return createStringError(std::errc::invalid_argument,
143                                "address sizes vary in different compile units");
144   }
145 
146   DWARFDataExtractor Data(DCtx.getDWARFObj().getRangesSection().Data,
147                           DCtx.isLittleEndian(), AddrSize);
148   uint64_t Offset = 0;
149   DWARFDebugRangeList DwarfRanges;
150   std::vector<DWARFYAML::Ranges> DebugRanges;
151 
152   while (Data.isValidOffset(Offset)) {
153     DWARFYAML::Ranges YamlRanges;
154     YamlRanges.Offset = Offset;
155     YamlRanges.AddrSize = AddrSize;
156     if (Error E = DwarfRanges.extract(Data, &Offset))
157       return E;
158     for (const auto &RLE : DwarfRanges.getEntries())
159       YamlRanges.Entries.push_back({RLE.StartAddress, RLE.EndAddress});
160     DebugRanges.push_back(std::move(YamlRanges));
161   }
162 
163   Y.DebugRanges = DebugRanges;
164   return ErrorSuccess();
165 }
166 
167 static Optional<DWARFYAML::PubSection>
168 dumpPubSection(const DWARFContext &DCtx, const DWARFSection &Section,
169                bool IsGNUStyle) {
170   DWARFYAML::PubSection Y;
171   DWARFDataExtractor PubSectionData(DCtx.getDWARFObj(), Section,
172                                     DCtx.isLittleEndian(), 0);
173   DWARFDebugPubTable Table;
174   // We ignore any errors that don't prevent parsing the section, since we can
175   // still represent such sections.
176   Table.extract(PubSectionData, IsGNUStyle,
177                 [](Error Err) { consumeError(std::move(Err)); });
178   ArrayRef<DWARFDebugPubTable::Set> Sets = Table.getData();
179   if (Sets.empty())
180     return None;
181 
182   // FIXME: Currently, obj2yaml only supports dumping the first pubtable.
183   Y.Format = Sets[0].Format;
184   Y.Length = Sets[0].Length;
185   Y.Version = Sets[0].Version;
186   Y.UnitOffset = Sets[0].Offset;
187   Y.UnitSize = Sets[0].Size;
188 
189   for (const DWARFDebugPubTable::Entry &E : Sets[0].Entries)
190     Y.Entries.push_back(DWARFYAML::PubEntry{(uint32_t)E.SecOffset,
191                                             E.Descriptor.toBits(), E.Name});
192 
193   return Y;
194 }
195 
196 void dumpDebugPubSections(DWARFContext &DCtx, DWARFYAML::Data &Y) {
197   const DWARFObject &D = DCtx.getDWARFObj();
198 
199   Y.PubNames =
200       dumpPubSection(DCtx, D.getPubnamesSection(), /*IsGNUStyle=*/false);
201   Y.PubTypes =
202       dumpPubSection(DCtx, D.getPubtypesSection(), /*IsGNUStyle=*/false);
203   // TODO: Test dumping .debug_gnu_pubnames section.
204   Y.GNUPubNames =
205       dumpPubSection(DCtx, D.getGnuPubnamesSection(), /*IsGNUStyle=*/true);
206   // TODO: Test dumping .debug_gnu_pubtypes section.
207   Y.GNUPubTypes =
208       dumpPubSection(DCtx, D.getGnuPubtypesSection(), /*IsGNUStyle=*/true);
209 }
210 
211 void dumpDebugInfo(DWARFContext &DCtx, DWARFYAML::Data &Y) {
212   for (const auto &CU : DCtx.compile_units()) {
213     DWARFYAML::Unit NewUnit;
214     NewUnit.Format = CU->getFormat();
215     NewUnit.Length = CU->getLength();
216     NewUnit.Version = CU->getVersion();
217     if (NewUnit.Version >= 5)
218       NewUnit.Type = (dwarf::UnitType)CU->getUnitType();
219     const DWARFDebugAbbrev *DebugAbbrev = DCtx.getDebugAbbrev();
220     NewUnit.AbbrevTableID = std::distance(
221         DebugAbbrev->begin(),
222         llvm::find_if(
223             *DebugAbbrev,
224             [&](const std::pair<uint64_t, DWARFAbbreviationDeclarationSet> &P) {
225               return P.first == CU->getAbbreviations()->getOffset();
226             }));
227     NewUnit.AbbrOffset = CU->getAbbreviations()->getOffset();
228     NewUnit.AddrSize = CU->getAddressByteSize();
229     for (auto DIE : CU->dies()) {
230       DWARFYAML::Entry NewEntry;
231       DataExtractor EntryData = CU->getDebugInfoExtractor();
232       uint64_t offset = DIE.getOffset();
233 
234       assert(EntryData.isValidOffset(offset) && "Invalid DIE Offset");
235       if (!EntryData.isValidOffset(offset))
236         continue;
237 
238       NewEntry.AbbrCode = EntryData.getULEB128(&offset);
239 
240       auto AbbrevDecl = DIE.getAbbreviationDeclarationPtr();
241       if (AbbrevDecl) {
242         for (const auto &AttrSpec : AbbrevDecl->attributes()) {
243           DWARFYAML::FormValue NewValue;
244           NewValue.Value = 0xDEADBEEFDEADBEEF;
245           DWARFDie DIEWrapper(CU.get(), &DIE);
246           auto FormValue = DIEWrapper.find(AttrSpec.Attr);
247           if (!FormValue)
248             return;
249           auto Form = FormValue.getValue().getForm();
250           bool indirect = false;
251           do {
252             indirect = false;
253             switch (Form) {
254             case dwarf::DW_FORM_addr:
255             case dwarf::DW_FORM_GNU_addr_index:
256               if (auto Val = FormValue.getValue().getAsAddress())
257                 NewValue.Value = Val.getValue();
258               break;
259             case dwarf::DW_FORM_ref_addr:
260             case dwarf::DW_FORM_ref1:
261             case dwarf::DW_FORM_ref2:
262             case dwarf::DW_FORM_ref4:
263             case dwarf::DW_FORM_ref8:
264             case dwarf::DW_FORM_ref_udata:
265             case dwarf::DW_FORM_ref_sig8:
266               if (auto Val = FormValue.getValue().getAsReferenceUVal())
267                 NewValue.Value = Val.getValue();
268               break;
269             case dwarf::DW_FORM_exprloc:
270             case dwarf::DW_FORM_block:
271             case dwarf::DW_FORM_block1:
272             case dwarf::DW_FORM_block2:
273             case dwarf::DW_FORM_block4:
274               if (auto Val = FormValue.getValue().getAsBlock()) {
275                 auto BlockData = Val.getValue();
276                 std::copy(BlockData.begin(), BlockData.end(),
277                           std::back_inserter(NewValue.BlockData));
278               }
279               NewValue.Value = NewValue.BlockData.size();
280               break;
281             case dwarf::DW_FORM_data1:
282             case dwarf::DW_FORM_flag:
283             case dwarf::DW_FORM_data2:
284             case dwarf::DW_FORM_data4:
285             case dwarf::DW_FORM_data8:
286             case dwarf::DW_FORM_sdata:
287             case dwarf::DW_FORM_udata:
288             case dwarf::DW_FORM_ref_sup4:
289             case dwarf::DW_FORM_ref_sup8:
290               if (auto Val = FormValue.getValue().getAsUnsignedConstant())
291                 NewValue.Value = Val.getValue();
292               break;
293             case dwarf::DW_FORM_string:
294               if (auto Val = FormValue.getValue().getAsCString())
295                 NewValue.CStr = Val.getValue();
296               break;
297             case dwarf::DW_FORM_indirect:
298               indirect = true;
299               if (auto Val = FormValue.getValue().getAsUnsignedConstant()) {
300                 NewValue.Value = Val.getValue();
301                 NewEntry.Values.push_back(NewValue);
302                 Form = static_cast<dwarf::Form>(Val.getValue());
303               }
304               break;
305             case dwarf::DW_FORM_strp:
306             case dwarf::DW_FORM_sec_offset:
307             case dwarf::DW_FORM_GNU_ref_alt:
308             case dwarf::DW_FORM_GNU_strp_alt:
309             case dwarf::DW_FORM_line_strp:
310             case dwarf::DW_FORM_strp_sup:
311             case dwarf::DW_FORM_GNU_str_index:
312             case dwarf::DW_FORM_strx:
313               if (auto Val = FormValue.getValue().getAsCStringOffset())
314                 NewValue.Value = Val.getValue();
315               break;
316             case dwarf::DW_FORM_flag_present:
317               NewValue.Value = 1;
318               break;
319             default:
320               break;
321             }
322           } while (indirect);
323           NewEntry.Values.push_back(NewValue);
324         }
325       }
326 
327       NewUnit.Entries.push_back(NewEntry);
328     }
329     Y.CompileUnits.push_back(NewUnit);
330   }
331 }
332 
333 bool dumpFileEntry(DataExtractor &Data, uint64_t &Offset,
334                    DWARFYAML::File &File) {
335   File.Name = Data.getCStr(&Offset);
336   if (File.Name.empty())
337     return false;
338   File.DirIdx = Data.getULEB128(&Offset);
339   File.ModTime = Data.getULEB128(&Offset);
340   File.Length = Data.getULEB128(&Offset);
341   return true;
342 }
343 
344 void dumpDebugLines(DWARFContext &DCtx, DWARFYAML::Data &Y) {
345   for (const auto &CU : DCtx.compile_units()) {
346     auto CUDIE = CU->getUnitDIE();
347     if (!CUDIE)
348       continue;
349     if (auto StmtOffset =
350             dwarf::toSectionOffset(CUDIE.find(dwarf::DW_AT_stmt_list))) {
351       DWARFYAML::LineTable DebugLines;
352       DataExtractor LineData(DCtx.getDWARFObj().getLineSection().Data,
353                              DCtx.isLittleEndian(), CU->getAddressByteSize());
354       uint64_t Offset = *StmtOffset;
355       uint64_t LengthOrDWARF64Prefix = LineData.getU32(&Offset);
356       if (LengthOrDWARF64Prefix == dwarf::DW_LENGTH_DWARF64) {
357         DebugLines.Format = dwarf::DWARF64;
358         DebugLines.Length = LineData.getU64(&Offset);
359       } else {
360         DebugLines.Format = dwarf::DWARF32;
361         DebugLines.Length = LengthOrDWARF64Prefix;
362       }
363       assert(DebugLines.Length);
364       uint64_t LineTableLength = *DebugLines.Length;
365       uint64_t SizeOfPrologueLength =
366           DebugLines.Format == dwarf::DWARF64 ? 8 : 4;
367       DebugLines.Version = LineData.getU16(&Offset);
368       DebugLines.PrologueLength =
369           LineData.getUnsigned(&Offset, SizeOfPrologueLength);
370       assert(DebugLines.PrologueLength);
371       const uint64_t EndPrologue = *DebugLines.PrologueLength + Offset;
372 
373       DebugLines.MinInstLength = LineData.getU8(&Offset);
374       if (DebugLines.Version >= 4)
375         DebugLines.MaxOpsPerInst = LineData.getU8(&Offset);
376       DebugLines.DefaultIsStmt = LineData.getU8(&Offset);
377       DebugLines.LineBase = LineData.getU8(&Offset);
378       DebugLines.LineRange = LineData.getU8(&Offset);
379       DebugLines.OpcodeBase = LineData.getU8(&Offset);
380 
381       DebugLines.StandardOpcodeLengths.emplace();
382       for (uint8_t i = 1; i < DebugLines.OpcodeBase; ++i)
383         DebugLines.StandardOpcodeLengths->push_back(LineData.getU8(&Offset));
384 
385       while (Offset < EndPrologue) {
386         StringRef Dir = LineData.getCStr(&Offset);
387         if (!Dir.empty())
388           DebugLines.IncludeDirs.push_back(Dir);
389         else
390           break;
391       }
392 
393       while (Offset < EndPrologue) {
394         DWARFYAML::File TmpFile;
395         if (dumpFileEntry(LineData, Offset, TmpFile))
396           DebugLines.Files.push_back(TmpFile);
397         else
398           break;
399       }
400 
401       const uint64_t LineEnd =
402           LineTableLength + *StmtOffset + SizeOfPrologueLength;
403       while (Offset < LineEnd) {
404         DWARFYAML::LineTableOpcode NewOp = {};
405         NewOp.Opcode = (dwarf::LineNumberOps)LineData.getU8(&Offset);
406         if (NewOp.Opcode == 0) {
407           auto StartExt = Offset;
408           NewOp.ExtLen = LineData.getULEB128(&Offset);
409           NewOp.SubOpcode =
410               (dwarf::LineNumberExtendedOps)LineData.getU8(&Offset);
411           switch (NewOp.SubOpcode) {
412           case dwarf::DW_LNE_set_address:
413           case dwarf::DW_LNE_set_discriminator:
414             NewOp.Data = LineData.getAddress(&Offset);
415             break;
416           case dwarf::DW_LNE_define_file:
417             dumpFileEntry(LineData, Offset, NewOp.FileEntry);
418             break;
419           case dwarf::DW_LNE_end_sequence:
420             break;
421           default:
422             while (Offset < StartExt + *NewOp.ExtLen)
423               NewOp.UnknownOpcodeData.push_back(LineData.getU8(&Offset));
424           }
425         } else if (NewOp.Opcode < *DebugLines.OpcodeBase) {
426           switch (NewOp.Opcode) {
427           case dwarf::DW_LNS_copy:
428           case dwarf::DW_LNS_negate_stmt:
429           case dwarf::DW_LNS_set_basic_block:
430           case dwarf::DW_LNS_const_add_pc:
431           case dwarf::DW_LNS_set_prologue_end:
432           case dwarf::DW_LNS_set_epilogue_begin:
433             break;
434 
435           case dwarf::DW_LNS_advance_pc:
436           case dwarf::DW_LNS_set_file:
437           case dwarf::DW_LNS_set_column:
438           case dwarf::DW_LNS_set_isa:
439             NewOp.Data = LineData.getULEB128(&Offset);
440             break;
441 
442           case dwarf::DW_LNS_advance_line:
443             NewOp.SData = LineData.getSLEB128(&Offset);
444             break;
445 
446           case dwarf::DW_LNS_fixed_advance_pc:
447             NewOp.Data = LineData.getU16(&Offset);
448             break;
449 
450           default:
451             for (uint8_t i = 0;
452                  i <
453                  DebugLines.StandardOpcodeLengths.getValue()[NewOp.Opcode - 1];
454                  ++i)
455               NewOp.StandardOpcodeData.push_back(LineData.getULEB128(&Offset));
456           }
457         }
458         DebugLines.Opcodes.push_back(NewOp);
459       }
460       Y.DebugLines.push_back(DebugLines);
461     }
462   }
463 }
464