1 //===- DWARFEmitter - Convert YAML to DWARF binary data -------------------===//
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 /// \file
10 /// The DWARF component of yaml2obj. Provided as library code for tests.
11 ///
12 //===----------------------------------------------------------------------===//
13
14 #include "llvm/ObjectYAML/DWARFEmitter.h"
15 #include "llvm/ADT/ArrayRef.h"
16 #include "llvm/ADT/StringMap.h"
17 #include "llvm/ADT/StringRef.h"
18 #include "llvm/ADT/StringSwitch.h"
19 #include "llvm/BinaryFormat/Dwarf.h"
20 #include "llvm/ObjectYAML/DWARFYAML.h"
21 #include "llvm/Support/Errc.h"
22 #include "llvm/Support/Error.h"
23 #include "llvm/Support/Host.h"
24 #include "llvm/Support/LEB128.h"
25 #include "llvm/Support/MathExtras.h"
26 #include "llvm/Support/MemoryBuffer.h"
27 #include "llvm/Support/SourceMgr.h"
28 #include "llvm/Support/SwapByteOrder.h"
29 #include "llvm/Support/YAMLTraits.h"
30 #include "llvm/Support/raw_ostream.h"
31 #include <algorithm>
32 #include <cassert>
33 #include <cstddef>
34 #include <cstdint>
35 #include <memory>
36 #include <string>
37 #include <vector>
38
39 using namespace llvm;
40
41 template <typename T>
writeInteger(T Integer,raw_ostream & OS,bool IsLittleEndian)42 static void writeInteger(T Integer, raw_ostream &OS, bool IsLittleEndian) {
43 if (IsLittleEndian != sys::IsLittleEndianHost)
44 sys::swapByteOrder(Integer);
45 OS.write(reinterpret_cast<char *>(&Integer), sizeof(T));
46 }
47
writeVariableSizedInteger(uint64_t Integer,size_t Size,raw_ostream & OS,bool IsLittleEndian)48 static Error writeVariableSizedInteger(uint64_t Integer, size_t Size,
49 raw_ostream &OS, bool IsLittleEndian) {
50 if (8 == Size)
51 writeInteger((uint64_t)Integer, OS, IsLittleEndian);
52 else if (4 == Size)
53 writeInteger((uint32_t)Integer, OS, IsLittleEndian);
54 else if (2 == Size)
55 writeInteger((uint16_t)Integer, OS, IsLittleEndian);
56 else if (1 == Size)
57 writeInteger((uint8_t)Integer, OS, IsLittleEndian);
58 else
59 return createStringError(errc::not_supported,
60 "invalid integer write size: %zu", Size);
61
62 return Error::success();
63 }
64
ZeroFillBytes(raw_ostream & OS,size_t Size)65 static void ZeroFillBytes(raw_ostream &OS, size_t Size) {
66 std::vector<uint8_t> FillData;
67 FillData.insert(FillData.begin(), Size, 0);
68 OS.write(reinterpret_cast<char *>(FillData.data()), Size);
69 }
70
writeInitialLength(const dwarf::DwarfFormat Format,const uint64_t Length,raw_ostream & OS,bool IsLittleEndian)71 static void writeInitialLength(const dwarf::DwarfFormat Format,
72 const uint64_t Length, raw_ostream &OS,
73 bool IsLittleEndian) {
74 bool IsDWARF64 = Format == dwarf::DWARF64;
75 if (IsDWARF64)
76 cantFail(writeVariableSizedInteger(dwarf::DW_LENGTH_DWARF64, 4, OS,
77 IsLittleEndian));
78 cantFail(
79 writeVariableSizedInteger(Length, IsDWARF64 ? 8 : 4, OS, IsLittleEndian));
80 }
81
writeDWARFOffset(uint64_t Offset,dwarf::DwarfFormat Format,raw_ostream & OS,bool IsLittleEndian)82 static void writeDWARFOffset(uint64_t Offset, dwarf::DwarfFormat Format,
83 raw_ostream &OS, bool IsLittleEndian) {
84 cantFail(writeVariableSizedInteger(Offset, Format == dwarf::DWARF64 ? 8 : 4,
85 OS, IsLittleEndian));
86 }
87
emitDebugStr(raw_ostream & OS,const DWARFYAML::Data & DI)88 Error DWARFYAML::emitDebugStr(raw_ostream &OS, const DWARFYAML::Data &DI) {
89 for (StringRef Str : *DI.DebugStrings) {
90 OS.write(Str.data(), Str.size());
91 OS.write('\0');
92 }
93
94 return Error::success();
95 }
96
getAbbrevTableContentByIndex(uint64_t Index) const97 StringRef DWARFYAML::Data::getAbbrevTableContentByIndex(uint64_t Index) const {
98 assert(Index < DebugAbbrev.size() &&
99 "Index should be less than the size of DebugAbbrev array");
100 auto It = AbbrevTableContents.find(Index);
101 if (It != AbbrevTableContents.cend())
102 return It->second;
103
104 std::string AbbrevTableBuffer;
105 raw_string_ostream OS(AbbrevTableBuffer);
106
107 uint64_t AbbrevCode = 0;
108 for (const DWARFYAML::Abbrev &AbbrevDecl : DebugAbbrev[Index].Table) {
109 AbbrevCode = AbbrevDecl.Code ? (uint64_t)*AbbrevDecl.Code : AbbrevCode + 1;
110 encodeULEB128(AbbrevCode, OS);
111 encodeULEB128(AbbrevDecl.Tag, OS);
112 OS.write(AbbrevDecl.Children);
113 for (const auto &Attr : AbbrevDecl.Attributes) {
114 encodeULEB128(Attr.Attribute, OS);
115 encodeULEB128(Attr.Form, OS);
116 if (Attr.Form == dwarf::DW_FORM_implicit_const)
117 encodeSLEB128(Attr.Value, OS);
118 }
119 encodeULEB128(0, OS);
120 encodeULEB128(0, OS);
121 }
122
123 // The abbreviations for a given compilation unit end with an entry
124 // consisting of a 0 byte for the abbreviation code.
125 OS.write_zeros(1);
126
127 AbbrevTableContents.insert({Index, AbbrevTableBuffer});
128
129 return AbbrevTableContents[Index];
130 }
131
emitDebugAbbrev(raw_ostream & OS,const DWARFYAML::Data & DI)132 Error DWARFYAML::emitDebugAbbrev(raw_ostream &OS, const DWARFYAML::Data &DI) {
133 for (uint64_t I = 0; I < DI.DebugAbbrev.size(); ++I) {
134 StringRef AbbrevTableContent = DI.getAbbrevTableContentByIndex(I);
135 OS.write(AbbrevTableContent.data(), AbbrevTableContent.size());
136 }
137
138 return Error::success();
139 }
140
emitDebugAranges(raw_ostream & OS,const DWARFYAML::Data & DI)141 Error DWARFYAML::emitDebugAranges(raw_ostream &OS, const DWARFYAML::Data &DI) {
142 assert(DI.DebugAranges && "unexpected emitDebugAranges() call");
143 for (const auto &Range : *DI.DebugAranges) {
144 uint8_t AddrSize;
145 if (Range.AddrSize)
146 AddrSize = *Range.AddrSize;
147 else
148 AddrSize = DI.Is64BitAddrSize ? 8 : 4;
149
150 uint64_t Length = 4; // sizeof(version) 2 + sizeof(address_size) 1 +
151 // sizeof(segment_selector_size) 1
152 Length +=
153 Range.Format == dwarf::DWARF64 ? 8 : 4; // sizeof(debug_info_offset)
154
155 const uint64_t HeaderLength =
156 Length + (Range.Format == dwarf::DWARF64
157 ? 12
158 : 4); // sizeof(unit_header) = 12 (DWARF64) or 4 (DWARF32)
159 const uint64_t PaddedHeaderLength = alignTo(HeaderLength, AddrSize * 2);
160
161 if (Range.Length) {
162 Length = *Range.Length;
163 } else {
164 Length += PaddedHeaderLength - HeaderLength;
165 Length += AddrSize * 2 * (Range.Descriptors.size() + 1);
166 }
167
168 writeInitialLength(Range.Format, Length, OS, DI.IsLittleEndian);
169 writeInteger((uint16_t)Range.Version, OS, DI.IsLittleEndian);
170 writeDWARFOffset(Range.CuOffset, Range.Format, OS, DI.IsLittleEndian);
171 writeInteger((uint8_t)AddrSize, OS, DI.IsLittleEndian);
172 writeInteger((uint8_t)Range.SegSize, OS, DI.IsLittleEndian);
173 ZeroFillBytes(OS, PaddedHeaderLength - HeaderLength);
174
175 for (const auto &Descriptor : Range.Descriptors) {
176 if (Error Err = writeVariableSizedInteger(Descriptor.Address, AddrSize,
177 OS, DI.IsLittleEndian))
178 return createStringError(errc::not_supported,
179 "unable to write debug_aranges address: %s",
180 toString(std::move(Err)).c_str());
181 cantFail(writeVariableSizedInteger(Descriptor.Length, AddrSize, OS,
182 DI.IsLittleEndian));
183 }
184 ZeroFillBytes(OS, AddrSize * 2);
185 }
186
187 return Error::success();
188 }
189
emitDebugRanges(raw_ostream & OS,const DWARFYAML::Data & DI)190 Error DWARFYAML::emitDebugRanges(raw_ostream &OS, const DWARFYAML::Data &DI) {
191 const size_t RangesOffset = OS.tell();
192 uint64_t EntryIndex = 0;
193 for (const auto &DebugRanges : *DI.DebugRanges) {
194 const size_t CurrOffset = OS.tell() - RangesOffset;
195 if (DebugRanges.Offset && (uint64_t)*DebugRanges.Offset < CurrOffset)
196 return createStringError(errc::invalid_argument,
197 "'Offset' for 'debug_ranges' with index " +
198 Twine(EntryIndex) +
199 " must be greater than or equal to the "
200 "number of bytes written already (0x" +
201 Twine::utohexstr(CurrOffset) + ")");
202 if (DebugRanges.Offset)
203 ZeroFillBytes(OS, *DebugRanges.Offset - CurrOffset);
204
205 uint8_t AddrSize;
206 if (DebugRanges.AddrSize)
207 AddrSize = *DebugRanges.AddrSize;
208 else
209 AddrSize = DI.Is64BitAddrSize ? 8 : 4;
210 for (const auto &Entry : DebugRanges.Entries) {
211 if (Error Err = writeVariableSizedInteger(Entry.LowOffset, AddrSize, OS,
212 DI.IsLittleEndian))
213 return createStringError(
214 errc::not_supported,
215 "unable to write debug_ranges address offset: %s",
216 toString(std::move(Err)).c_str());
217 cantFail(writeVariableSizedInteger(Entry.HighOffset, AddrSize, OS,
218 DI.IsLittleEndian));
219 }
220 ZeroFillBytes(OS, AddrSize * 2);
221 ++EntryIndex;
222 }
223
224 return Error::success();
225 }
226
emitPubSection(raw_ostream & OS,const DWARFYAML::PubSection & Sect,bool IsLittleEndian,bool IsGNUPubSec=false)227 static Error emitPubSection(raw_ostream &OS, const DWARFYAML::PubSection &Sect,
228 bool IsLittleEndian, bool IsGNUPubSec = false) {
229 writeInitialLength(Sect.Format, Sect.Length, OS, IsLittleEndian);
230 writeInteger((uint16_t)Sect.Version, OS, IsLittleEndian);
231 writeInteger((uint32_t)Sect.UnitOffset, OS, IsLittleEndian);
232 writeInteger((uint32_t)Sect.UnitSize, OS, IsLittleEndian);
233 for (const auto &Entry : Sect.Entries) {
234 writeInteger((uint32_t)Entry.DieOffset, OS, IsLittleEndian);
235 if (IsGNUPubSec)
236 writeInteger((uint8_t)Entry.Descriptor, OS, IsLittleEndian);
237 OS.write(Entry.Name.data(), Entry.Name.size());
238 OS.write('\0');
239 }
240 return Error::success();
241 }
242
emitDebugPubnames(raw_ostream & OS,const Data & DI)243 Error DWARFYAML::emitDebugPubnames(raw_ostream &OS, const Data &DI) {
244 assert(DI.PubNames && "unexpected emitDebugPubnames() call");
245 return emitPubSection(OS, *DI.PubNames, DI.IsLittleEndian);
246 }
247
emitDebugPubtypes(raw_ostream & OS,const Data & DI)248 Error DWARFYAML::emitDebugPubtypes(raw_ostream &OS, const Data &DI) {
249 assert(DI.PubTypes && "unexpected emitDebugPubtypes() call");
250 return emitPubSection(OS, *DI.PubTypes, DI.IsLittleEndian);
251 }
252
emitDebugGNUPubnames(raw_ostream & OS,const Data & DI)253 Error DWARFYAML::emitDebugGNUPubnames(raw_ostream &OS, const Data &DI) {
254 assert(DI.GNUPubNames && "unexpected emitDebugGNUPubnames() call");
255 return emitPubSection(OS, *DI.GNUPubNames, DI.IsLittleEndian,
256 /*IsGNUStyle=*/true);
257 }
258
emitDebugGNUPubtypes(raw_ostream & OS,const Data & DI)259 Error DWARFYAML::emitDebugGNUPubtypes(raw_ostream &OS, const Data &DI) {
260 assert(DI.GNUPubTypes && "unexpected emitDebugGNUPubtypes() call");
261 return emitPubSection(OS, *DI.GNUPubTypes, DI.IsLittleEndian,
262 /*IsGNUStyle=*/true);
263 }
264
writeDIE(const DWARFYAML::Data & DI,uint64_t CUIndex,uint64_t AbbrevTableID,const dwarf::FormParams & Params,const DWARFYAML::Entry & Entry,raw_ostream & OS,bool IsLittleEndian)265 static Expected<uint64_t> writeDIE(const DWARFYAML::Data &DI, uint64_t CUIndex,
266 uint64_t AbbrevTableID,
267 const dwarf::FormParams &Params,
268 const DWARFYAML::Entry &Entry,
269 raw_ostream &OS, bool IsLittleEndian) {
270 uint64_t EntryBegin = OS.tell();
271 encodeULEB128(Entry.AbbrCode, OS);
272 uint32_t AbbrCode = Entry.AbbrCode;
273 if (AbbrCode == 0 || Entry.Values.empty())
274 return OS.tell() - EntryBegin;
275
276 Expected<DWARFYAML::Data::AbbrevTableInfo> AbbrevTableInfoOrErr =
277 DI.getAbbrevTableInfoByID(AbbrevTableID);
278 if (!AbbrevTableInfoOrErr)
279 return createStringError(errc::invalid_argument,
280 toString(AbbrevTableInfoOrErr.takeError()) +
281 " for compilation unit with index " +
282 utostr(CUIndex));
283
284 ArrayRef<DWARFYAML::Abbrev> AbbrevDecls(
285 DI.DebugAbbrev[AbbrevTableInfoOrErr->Index].Table);
286
287 if (AbbrCode > AbbrevDecls.size())
288 return createStringError(
289 errc::invalid_argument,
290 "abbrev code must be less than or equal to the number of "
291 "entries in abbreviation table");
292 const DWARFYAML::Abbrev &Abbrev = AbbrevDecls[AbbrCode - 1];
293 auto FormVal = Entry.Values.begin();
294 auto AbbrForm = Abbrev.Attributes.begin();
295 for (; FormVal != Entry.Values.end() && AbbrForm != Abbrev.Attributes.end();
296 ++FormVal, ++AbbrForm) {
297 dwarf::Form Form = AbbrForm->Form;
298 bool Indirect;
299 do {
300 Indirect = false;
301 switch (Form) {
302 case dwarf::DW_FORM_addr:
303 // TODO: Test this error.
304 if (Error Err = writeVariableSizedInteger(
305 FormVal->Value, Params.AddrSize, OS, IsLittleEndian))
306 return std::move(Err);
307 break;
308 case dwarf::DW_FORM_ref_addr:
309 // TODO: Test this error.
310 if (Error Err = writeVariableSizedInteger(FormVal->Value,
311 Params.getRefAddrByteSize(),
312 OS, IsLittleEndian))
313 return std::move(Err);
314 break;
315 case dwarf::DW_FORM_exprloc:
316 case dwarf::DW_FORM_block:
317 encodeULEB128(FormVal->BlockData.size(), OS);
318 OS.write((const char *)FormVal->BlockData.data(),
319 FormVal->BlockData.size());
320 break;
321 case dwarf::DW_FORM_block1: {
322 writeInteger((uint8_t)FormVal->BlockData.size(), OS, IsLittleEndian);
323 OS.write((const char *)FormVal->BlockData.data(),
324 FormVal->BlockData.size());
325 break;
326 }
327 case dwarf::DW_FORM_block2: {
328 writeInteger((uint16_t)FormVal->BlockData.size(), OS, IsLittleEndian);
329 OS.write((const char *)FormVal->BlockData.data(),
330 FormVal->BlockData.size());
331 break;
332 }
333 case dwarf::DW_FORM_block4: {
334 writeInteger((uint32_t)FormVal->BlockData.size(), OS, IsLittleEndian);
335 OS.write((const char *)FormVal->BlockData.data(),
336 FormVal->BlockData.size());
337 break;
338 }
339 case dwarf::DW_FORM_strx:
340 case dwarf::DW_FORM_addrx:
341 case dwarf::DW_FORM_rnglistx:
342 case dwarf::DW_FORM_loclistx:
343 case dwarf::DW_FORM_udata:
344 case dwarf::DW_FORM_ref_udata:
345 case dwarf::DW_FORM_GNU_addr_index:
346 case dwarf::DW_FORM_GNU_str_index:
347 encodeULEB128(FormVal->Value, OS);
348 break;
349 case dwarf::DW_FORM_data1:
350 case dwarf::DW_FORM_ref1:
351 case dwarf::DW_FORM_flag:
352 case dwarf::DW_FORM_strx1:
353 case dwarf::DW_FORM_addrx1:
354 writeInteger((uint8_t)FormVal->Value, OS, IsLittleEndian);
355 break;
356 case dwarf::DW_FORM_data2:
357 case dwarf::DW_FORM_ref2:
358 case dwarf::DW_FORM_strx2:
359 case dwarf::DW_FORM_addrx2:
360 writeInteger((uint16_t)FormVal->Value, OS, IsLittleEndian);
361 break;
362 case dwarf::DW_FORM_data4:
363 case dwarf::DW_FORM_ref4:
364 case dwarf::DW_FORM_ref_sup4:
365 case dwarf::DW_FORM_strx4:
366 case dwarf::DW_FORM_addrx4:
367 writeInteger((uint32_t)FormVal->Value, OS, IsLittleEndian);
368 break;
369 case dwarf::DW_FORM_data8:
370 case dwarf::DW_FORM_ref8:
371 case dwarf::DW_FORM_ref_sup8:
372 case dwarf::DW_FORM_ref_sig8:
373 writeInteger((uint64_t)FormVal->Value, OS, IsLittleEndian);
374 break;
375 case dwarf::DW_FORM_sdata:
376 encodeSLEB128(FormVal->Value, OS);
377 break;
378 case dwarf::DW_FORM_string:
379 OS.write(FormVal->CStr.data(), FormVal->CStr.size());
380 OS.write('\0');
381 break;
382 case dwarf::DW_FORM_indirect:
383 encodeULEB128(FormVal->Value, OS);
384 Indirect = true;
385 Form = static_cast<dwarf::Form>((uint64_t)FormVal->Value);
386 ++FormVal;
387 break;
388 case dwarf::DW_FORM_strp:
389 case dwarf::DW_FORM_sec_offset:
390 case dwarf::DW_FORM_GNU_ref_alt:
391 case dwarf::DW_FORM_GNU_strp_alt:
392 case dwarf::DW_FORM_line_strp:
393 case dwarf::DW_FORM_strp_sup:
394 cantFail(writeVariableSizedInteger(FormVal->Value,
395 Params.getDwarfOffsetByteSize(), OS,
396 IsLittleEndian));
397 break;
398 default:
399 break;
400 }
401 } while (Indirect);
402 }
403
404 return OS.tell() - EntryBegin;
405 }
406
emitDebugInfo(raw_ostream & OS,const DWARFYAML::Data & DI)407 Error DWARFYAML::emitDebugInfo(raw_ostream &OS, const DWARFYAML::Data &DI) {
408 for (uint64_t I = 0; I < DI.CompileUnits.size(); ++I) {
409 const DWARFYAML::Unit &Unit = DI.CompileUnits[I];
410 uint8_t AddrSize;
411 if (Unit.AddrSize)
412 AddrSize = *Unit.AddrSize;
413 else
414 AddrSize = DI.Is64BitAddrSize ? 8 : 4;
415 dwarf::FormParams Params = {Unit.Version, AddrSize, Unit.Format};
416 uint64_t Length = 3; // sizeof(version) + sizeof(address_size)
417 Length += Unit.Version >= 5 ? 1 : 0; // sizeof(unit_type)
418 Length += Params.getDwarfOffsetByteSize(); // sizeof(debug_abbrev_offset)
419
420 // Since the length of the current compilation unit is undetermined yet, we
421 // firstly write the content of the compilation unit to a buffer to
422 // calculate it and then serialize the buffer content to the actual output
423 // stream.
424 std::string EntryBuffer;
425 raw_string_ostream EntryBufferOS(EntryBuffer);
426
427 uint64_t AbbrevTableID = Unit.AbbrevTableID.getValueOr(I);
428 for (const DWARFYAML::Entry &Entry : Unit.Entries) {
429 if (Expected<uint64_t> EntryLength =
430 writeDIE(DI, I, AbbrevTableID, Params, Entry, EntryBufferOS,
431 DI.IsLittleEndian))
432 Length += *EntryLength;
433 else
434 return EntryLength.takeError();
435 }
436
437 // If the length is specified in the YAML description, we use it instead of
438 // the actual length.
439 if (Unit.Length)
440 Length = *Unit.Length;
441
442 writeInitialLength(Unit.Format, Length, OS, DI.IsLittleEndian);
443 writeInteger((uint16_t)Unit.Version, OS, DI.IsLittleEndian);
444
445 uint64_t AbbrevTableOffset = 0;
446 if (Unit.AbbrOffset) {
447 AbbrevTableOffset = *Unit.AbbrOffset;
448 } else {
449 if (Expected<DWARFYAML::Data::AbbrevTableInfo> AbbrevTableInfoOrErr =
450 DI.getAbbrevTableInfoByID(AbbrevTableID)) {
451 AbbrevTableOffset = AbbrevTableInfoOrErr->Offset;
452 } else {
453 // The current compilation unit may not have DIEs and it will not be
454 // able to find the associated abbrev table. We consume the error and
455 // assign 0 to the debug_abbrev_offset in such circumstances.
456 consumeError(AbbrevTableInfoOrErr.takeError());
457 }
458 }
459
460 if (Unit.Version >= 5) {
461 writeInteger((uint8_t)Unit.Type, OS, DI.IsLittleEndian);
462 writeInteger((uint8_t)AddrSize, OS, DI.IsLittleEndian);
463 writeDWARFOffset(AbbrevTableOffset, Unit.Format, OS, DI.IsLittleEndian);
464 } else {
465 writeDWARFOffset(AbbrevTableOffset, Unit.Format, OS, DI.IsLittleEndian);
466 writeInteger((uint8_t)AddrSize, OS, DI.IsLittleEndian);
467 }
468
469 OS.write(EntryBuffer.data(), EntryBuffer.size());
470 }
471
472 return Error::success();
473 }
474
emitFileEntry(raw_ostream & OS,const DWARFYAML::File & File)475 static void emitFileEntry(raw_ostream &OS, const DWARFYAML::File &File) {
476 OS.write(File.Name.data(), File.Name.size());
477 OS.write('\0');
478 encodeULEB128(File.DirIdx, OS);
479 encodeULEB128(File.ModTime, OS);
480 encodeULEB128(File.Length, OS);
481 }
482
writeExtendedOpcode(const DWARFYAML::LineTableOpcode & Op,uint8_t AddrSize,bool IsLittleEndian,raw_ostream & OS)483 static void writeExtendedOpcode(const DWARFYAML::LineTableOpcode &Op,
484 uint8_t AddrSize, bool IsLittleEndian,
485 raw_ostream &OS) {
486 // The first byte of extended opcodes is a zero byte. The next bytes are an
487 // ULEB128 integer giving the number of bytes in the instruction itself (does
488 // not include the first zero byte or the size). We serialize the instruction
489 // itself into the OpBuffer and then write the size of the buffer and the
490 // buffer to the real output stream.
491 std::string OpBuffer;
492 raw_string_ostream OpBufferOS(OpBuffer);
493 writeInteger((uint8_t)Op.SubOpcode, OpBufferOS, IsLittleEndian);
494 switch (Op.SubOpcode) {
495 case dwarf::DW_LNE_set_address:
496 cantFail(writeVariableSizedInteger(Op.Data, AddrSize, OpBufferOS,
497 IsLittleEndian));
498 break;
499 case dwarf::DW_LNE_define_file:
500 emitFileEntry(OpBufferOS, Op.FileEntry);
501 break;
502 case dwarf::DW_LNE_set_discriminator:
503 encodeULEB128(Op.Data, OpBufferOS);
504 break;
505 case dwarf::DW_LNE_end_sequence:
506 break;
507 default:
508 for (auto OpByte : Op.UnknownOpcodeData)
509 writeInteger((uint8_t)OpByte, OpBufferOS, IsLittleEndian);
510 }
511 uint64_t ExtLen = Op.ExtLen.getValueOr(OpBuffer.size());
512 encodeULEB128(ExtLen, OS);
513 OS.write(OpBuffer.data(), OpBuffer.size());
514 }
515
writeLineTableOpcode(const DWARFYAML::LineTableOpcode & Op,uint8_t OpcodeBase,uint8_t AddrSize,raw_ostream & OS,bool IsLittleEndian)516 static void writeLineTableOpcode(const DWARFYAML::LineTableOpcode &Op,
517 uint8_t OpcodeBase, uint8_t AddrSize,
518 raw_ostream &OS, bool IsLittleEndian) {
519 writeInteger((uint8_t)Op.Opcode, OS, IsLittleEndian);
520 if (Op.Opcode == 0) {
521 writeExtendedOpcode(Op, AddrSize, IsLittleEndian, OS);
522 } else if (Op.Opcode < OpcodeBase) {
523 switch (Op.Opcode) {
524 case dwarf::DW_LNS_copy:
525 case dwarf::DW_LNS_negate_stmt:
526 case dwarf::DW_LNS_set_basic_block:
527 case dwarf::DW_LNS_const_add_pc:
528 case dwarf::DW_LNS_set_prologue_end:
529 case dwarf::DW_LNS_set_epilogue_begin:
530 break;
531
532 case dwarf::DW_LNS_advance_pc:
533 case dwarf::DW_LNS_set_file:
534 case dwarf::DW_LNS_set_column:
535 case dwarf::DW_LNS_set_isa:
536 encodeULEB128(Op.Data, OS);
537 break;
538
539 case dwarf::DW_LNS_advance_line:
540 encodeSLEB128(Op.SData, OS);
541 break;
542
543 case dwarf::DW_LNS_fixed_advance_pc:
544 writeInteger((uint16_t)Op.Data, OS, IsLittleEndian);
545 break;
546
547 default:
548 for (auto OpData : Op.StandardOpcodeData) {
549 encodeULEB128(OpData, OS);
550 }
551 }
552 }
553 }
554
555 static std::vector<uint8_t>
getStandardOpcodeLengths(uint16_t Version,Optional<uint8_t> OpcodeBase)556 getStandardOpcodeLengths(uint16_t Version, Optional<uint8_t> OpcodeBase) {
557 // If the opcode_base field isn't specified, we returns the
558 // standard_opcode_lengths array according to the version by default.
559 std::vector<uint8_t> StandardOpcodeLengths{0, 1, 1, 1, 1, 0,
560 0, 0, 1, 0, 0, 1};
561 if (Version == 2) {
562 // DWARF v2 uses the same first 9 standard opcodes as v3-5.
563 StandardOpcodeLengths.resize(9);
564 } else if (OpcodeBase) {
565 StandardOpcodeLengths.resize(*OpcodeBase > 0 ? *OpcodeBase - 1 : 0, 0);
566 }
567 return StandardOpcodeLengths;
568 }
569
emitDebugLine(raw_ostream & OS,const DWARFYAML::Data & DI)570 Error DWARFYAML::emitDebugLine(raw_ostream &OS, const DWARFYAML::Data &DI) {
571 for (const DWARFYAML::LineTable &LineTable : DI.DebugLines) {
572 // Buffer holds the bytes following the header_length (or prologue_length in
573 // DWARFv2) field to the end of the line number program itself.
574 std::string Buffer;
575 raw_string_ostream BufferOS(Buffer);
576
577 writeInteger(LineTable.MinInstLength, BufferOS, DI.IsLittleEndian);
578 // TODO: Add support for emitting DWARFv5 line table.
579 if (LineTable.Version >= 4)
580 writeInteger(LineTable.MaxOpsPerInst, BufferOS, DI.IsLittleEndian);
581 writeInteger(LineTable.DefaultIsStmt, BufferOS, DI.IsLittleEndian);
582 writeInteger(LineTable.LineBase, BufferOS, DI.IsLittleEndian);
583 writeInteger(LineTable.LineRange, BufferOS, DI.IsLittleEndian);
584
585 std::vector<uint8_t> StandardOpcodeLengths =
586 LineTable.StandardOpcodeLengths.getValueOr(
587 getStandardOpcodeLengths(LineTable.Version, LineTable.OpcodeBase));
588 uint8_t OpcodeBase = LineTable.OpcodeBase
589 ? *LineTable.OpcodeBase
590 : StandardOpcodeLengths.size() + 1;
591 writeInteger(OpcodeBase, BufferOS, DI.IsLittleEndian);
592 for (uint8_t OpcodeLength : StandardOpcodeLengths)
593 writeInteger(OpcodeLength, BufferOS, DI.IsLittleEndian);
594
595 for (StringRef IncludeDir : LineTable.IncludeDirs) {
596 BufferOS.write(IncludeDir.data(), IncludeDir.size());
597 BufferOS.write('\0');
598 }
599 BufferOS.write('\0');
600
601 for (const DWARFYAML::File &File : LineTable.Files)
602 emitFileEntry(BufferOS, File);
603 BufferOS.write('\0');
604
605 uint64_t HeaderLength =
606 LineTable.PrologueLength ? *LineTable.PrologueLength : Buffer.size();
607
608 for (const DWARFYAML::LineTableOpcode &Op : LineTable.Opcodes)
609 writeLineTableOpcode(Op, OpcodeBase, DI.Is64BitAddrSize ? 8 : 4, BufferOS,
610 DI.IsLittleEndian);
611
612 uint64_t Length;
613 if (LineTable.Length) {
614 Length = *LineTable.Length;
615 } else {
616 Length = 2; // sizeof(version)
617 Length +=
618 (LineTable.Format == dwarf::DWARF64 ? 8 : 4); // sizeof(header_length)
619 Length += Buffer.size();
620 }
621
622 writeInitialLength(LineTable.Format, Length, OS, DI.IsLittleEndian);
623 writeInteger(LineTable.Version, OS, DI.IsLittleEndian);
624 writeDWARFOffset(HeaderLength, LineTable.Format, OS, DI.IsLittleEndian);
625 OS.write(Buffer.data(), Buffer.size());
626 }
627
628 return Error::success();
629 }
630
emitDebugAddr(raw_ostream & OS,const Data & DI)631 Error DWARFYAML::emitDebugAddr(raw_ostream &OS, const Data &DI) {
632 for (const AddrTableEntry &TableEntry : *DI.DebugAddr) {
633 uint8_t AddrSize;
634 if (TableEntry.AddrSize)
635 AddrSize = *TableEntry.AddrSize;
636 else
637 AddrSize = DI.Is64BitAddrSize ? 8 : 4;
638
639 uint64_t Length;
640 if (TableEntry.Length)
641 Length = (uint64_t)*TableEntry.Length;
642 else
643 // 2 (version) + 1 (address_size) + 1 (segment_selector_size) = 4
644 Length = 4 + (AddrSize + TableEntry.SegSelectorSize) *
645 TableEntry.SegAddrPairs.size();
646
647 writeInitialLength(TableEntry.Format, Length, OS, DI.IsLittleEndian);
648 writeInteger((uint16_t)TableEntry.Version, OS, DI.IsLittleEndian);
649 writeInteger((uint8_t)AddrSize, OS, DI.IsLittleEndian);
650 writeInteger((uint8_t)TableEntry.SegSelectorSize, OS, DI.IsLittleEndian);
651
652 for (const SegAddrPair &Pair : TableEntry.SegAddrPairs) {
653 if (TableEntry.SegSelectorSize != 0)
654 if (Error Err = writeVariableSizedInteger(Pair.Segment,
655 TableEntry.SegSelectorSize,
656 OS, DI.IsLittleEndian))
657 return createStringError(errc::not_supported,
658 "unable to write debug_addr segment: %s",
659 toString(std::move(Err)).c_str());
660 if (AddrSize != 0)
661 if (Error Err = writeVariableSizedInteger(Pair.Address, AddrSize, OS,
662 DI.IsLittleEndian))
663 return createStringError(errc::not_supported,
664 "unable to write debug_addr address: %s",
665 toString(std::move(Err)).c_str());
666 }
667 }
668
669 return Error::success();
670 }
671
emitDebugStrOffsets(raw_ostream & OS,const Data & DI)672 Error DWARFYAML::emitDebugStrOffsets(raw_ostream &OS, const Data &DI) {
673 assert(DI.DebugStrOffsets && "unexpected emitDebugStrOffsets() call");
674 for (const DWARFYAML::StringOffsetsTable &Table : *DI.DebugStrOffsets) {
675 uint64_t Length;
676 if (Table.Length)
677 Length = *Table.Length;
678 else
679 // sizeof(version) + sizeof(padding) = 4
680 Length =
681 4 + Table.Offsets.size() * (Table.Format == dwarf::DWARF64 ? 8 : 4);
682
683 writeInitialLength(Table.Format, Length, OS, DI.IsLittleEndian);
684 writeInteger((uint16_t)Table.Version, OS, DI.IsLittleEndian);
685 writeInteger((uint16_t)Table.Padding, OS, DI.IsLittleEndian);
686
687 for (uint64_t Offset : Table.Offsets)
688 writeDWARFOffset(Offset, Table.Format, OS, DI.IsLittleEndian);
689 }
690
691 return Error::success();
692 }
693
checkOperandCount(StringRef EncodingString,ArrayRef<yaml::Hex64> Values,uint64_t ExpectedOperands)694 static Error checkOperandCount(StringRef EncodingString,
695 ArrayRef<yaml::Hex64> Values,
696 uint64_t ExpectedOperands) {
697 if (Values.size() != ExpectedOperands)
698 return createStringError(
699 errc::invalid_argument,
700 "invalid number (%zu) of operands for the operator: %s, %" PRIu64
701 " expected",
702 Values.size(), EncodingString.str().c_str(), ExpectedOperands);
703
704 return Error::success();
705 }
706
writeListEntryAddress(StringRef EncodingName,raw_ostream & OS,uint64_t Addr,uint8_t AddrSize,bool IsLittleEndian)707 static Error writeListEntryAddress(StringRef EncodingName, raw_ostream &OS,
708 uint64_t Addr, uint8_t AddrSize,
709 bool IsLittleEndian) {
710 if (Error Err = writeVariableSizedInteger(Addr, AddrSize, OS, IsLittleEndian))
711 return createStringError(errc::invalid_argument,
712 "unable to write address for the operator %s: %s",
713 EncodingName.str().c_str(),
714 toString(std::move(Err)).c_str());
715
716 return Error::success();
717 }
718
719 static Expected<uint64_t>
writeDWARFExpression(raw_ostream & OS,const DWARFYAML::DWARFOperation & Operation,uint8_t AddrSize,bool IsLittleEndian)720 writeDWARFExpression(raw_ostream &OS,
721 const DWARFYAML::DWARFOperation &Operation,
722 uint8_t AddrSize, bool IsLittleEndian) {
723 auto CheckOperands = [&](uint64_t ExpectedOperands) -> Error {
724 return checkOperandCount(dwarf::OperationEncodingString(Operation.Operator),
725 Operation.Values, ExpectedOperands);
726 };
727
728 uint64_t ExpressionBegin = OS.tell();
729 writeInteger((uint8_t)Operation.Operator, OS, IsLittleEndian);
730 switch (Operation.Operator) {
731 case dwarf::DW_OP_consts:
732 if (Error Err = CheckOperands(1))
733 return std::move(Err);
734 encodeSLEB128(Operation.Values[0], OS);
735 break;
736 case dwarf::DW_OP_stack_value:
737 if (Error Err = CheckOperands(0))
738 return std::move(Err);
739 break;
740 default:
741 StringRef EncodingStr = dwarf::OperationEncodingString(Operation.Operator);
742 return createStringError(errc::not_supported,
743 "DWARF expression: " +
744 (EncodingStr.empty()
745 ? "0x" + utohexstr(Operation.Operator)
746 : EncodingStr) +
747 " is not supported");
748 }
749 return OS.tell() - ExpressionBegin;
750 }
751
writeListEntry(raw_ostream & OS,const DWARFYAML::RnglistEntry & Entry,uint8_t AddrSize,bool IsLittleEndian)752 static Expected<uint64_t> writeListEntry(raw_ostream &OS,
753 const DWARFYAML::RnglistEntry &Entry,
754 uint8_t AddrSize,
755 bool IsLittleEndian) {
756 uint64_t BeginOffset = OS.tell();
757 writeInteger((uint8_t)Entry.Operator, OS, IsLittleEndian);
758
759 StringRef EncodingName = dwarf::RangeListEncodingString(Entry.Operator);
760
761 auto CheckOperands = [&](uint64_t ExpectedOperands) -> Error {
762 return checkOperandCount(EncodingName, Entry.Values, ExpectedOperands);
763 };
764
765 auto WriteAddress = [&](uint64_t Addr) -> Error {
766 return writeListEntryAddress(EncodingName, OS, Addr, AddrSize,
767 IsLittleEndian);
768 };
769
770 switch (Entry.Operator) {
771 case dwarf::DW_RLE_end_of_list:
772 if (Error Err = CheckOperands(0))
773 return std::move(Err);
774 break;
775 case dwarf::DW_RLE_base_addressx:
776 if (Error Err = CheckOperands(1))
777 return std::move(Err);
778 encodeULEB128(Entry.Values[0], OS);
779 break;
780 case dwarf::DW_RLE_startx_endx:
781 case dwarf::DW_RLE_startx_length:
782 case dwarf::DW_RLE_offset_pair:
783 if (Error Err = CheckOperands(2))
784 return std::move(Err);
785 encodeULEB128(Entry.Values[0], OS);
786 encodeULEB128(Entry.Values[1], OS);
787 break;
788 case dwarf::DW_RLE_base_address:
789 if (Error Err = CheckOperands(1))
790 return std::move(Err);
791 if (Error Err = WriteAddress(Entry.Values[0]))
792 return std::move(Err);
793 break;
794 case dwarf::DW_RLE_start_end:
795 if (Error Err = CheckOperands(2))
796 return std::move(Err);
797 if (Error Err = WriteAddress(Entry.Values[0]))
798 return std::move(Err);
799 cantFail(WriteAddress(Entry.Values[1]));
800 break;
801 case dwarf::DW_RLE_start_length:
802 if (Error Err = CheckOperands(2))
803 return std::move(Err);
804 if (Error Err = WriteAddress(Entry.Values[0]))
805 return std::move(Err);
806 encodeULEB128(Entry.Values[1], OS);
807 break;
808 }
809
810 return OS.tell() - BeginOffset;
811 }
812
writeListEntry(raw_ostream & OS,const DWARFYAML::LoclistEntry & Entry,uint8_t AddrSize,bool IsLittleEndian)813 static Expected<uint64_t> writeListEntry(raw_ostream &OS,
814 const DWARFYAML::LoclistEntry &Entry,
815 uint8_t AddrSize,
816 bool IsLittleEndian) {
817 uint64_t BeginOffset = OS.tell();
818 writeInteger((uint8_t)Entry.Operator, OS, IsLittleEndian);
819
820 StringRef EncodingName = dwarf::LocListEncodingString(Entry.Operator);
821
822 auto CheckOperands = [&](uint64_t ExpectedOperands) -> Error {
823 return checkOperandCount(EncodingName, Entry.Values, ExpectedOperands);
824 };
825
826 auto WriteAddress = [&](uint64_t Addr) -> Error {
827 return writeListEntryAddress(EncodingName, OS, Addr, AddrSize,
828 IsLittleEndian);
829 };
830
831 auto WriteDWARFOperations = [&]() -> Error {
832 std::string OpBuffer;
833 raw_string_ostream OpBufferOS(OpBuffer);
834 uint64_t DescriptionsLength = 0;
835
836 for (const DWARFYAML::DWARFOperation &Op : Entry.Descriptions) {
837 if (Expected<uint64_t> OpSize =
838 writeDWARFExpression(OpBufferOS, Op, AddrSize, IsLittleEndian))
839 DescriptionsLength += *OpSize;
840 else
841 return OpSize.takeError();
842 }
843
844 if (Entry.DescriptionsLength)
845 DescriptionsLength = *Entry.DescriptionsLength;
846 else
847 DescriptionsLength = OpBuffer.size();
848
849 encodeULEB128(DescriptionsLength, OS);
850 OS.write(OpBuffer.data(), OpBuffer.size());
851
852 return Error::success();
853 };
854
855 switch (Entry.Operator) {
856 case dwarf::DW_LLE_end_of_list:
857 if (Error Err = CheckOperands(0))
858 return std::move(Err);
859 break;
860 case dwarf::DW_LLE_base_addressx:
861 if (Error Err = CheckOperands(1))
862 return std::move(Err);
863 encodeULEB128(Entry.Values[0], OS);
864 break;
865 case dwarf::DW_LLE_startx_endx:
866 case dwarf::DW_LLE_startx_length:
867 case dwarf::DW_LLE_offset_pair:
868 if (Error Err = CheckOperands(2))
869 return std::move(Err);
870 encodeULEB128(Entry.Values[0], OS);
871 encodeULEB128(Entry.Values[1], OS);
872 if (Error Err = WriteDWARFOperations())
873 return std::move(Err);
874 break;
875 case dwarf::DW_LLE_default_location:
876 if (Error Err = CheckOperands(0))
877 return std::move(Err);
878 if (Error Err = WriteDWARFOperations())
879 return std::move(Err);
880 break;
881 case dwarf::DW_LLE_base_address:
882 if (Error Err = CheckOperands(1))
883 return std::move(Err);
884 if (Error Err = WriteAddress(Entry.Values[0]))
885 return std::move(Err);
886 break;
887 case dwarf::DW_LLE_start_end:
888 if (Error Err = CheckOperands(2))
889 return std::move(Err);
890 if (Error Err = WriteAddress(Entry.Values[0]))
891 return std::move(Err);
892 cantFail(WriteAddress(Entry.Values[1]));
893 if (Error Err = WriteDWARFOperations())
894 return std::move(Err);
895 break;
896 case dwarf::DW_LLE_start_length:
897 if (Error Err = CheckOperands(2))
898 return std::move(Err);
899 if (Error Err = WriteAddress(Entry.Values[0]))
900 return std::move(Err);
901 encodeULEB128(Entry.Values[1], OS);
902 if (Error Err = WriteDWARFOperations())
903 return std::move(Err);
904 break;
905 }
906
907 return OS.tell() - BeginOffset;
908 }
909
910 template <typename EntryType>
writeDWARFLists(raw_ostream & OS,ArrayRef<DWARFYAML::ListTable<EntryType>> Tables,bool IsLittleEndian,bool Is64BitAddrSize)911 static Error writeDWARFLists(raw_ostream &OS,
912 ArrayRef<DWARFYAML::ListTable<EntryType>> Tables,
913 bool IsLittleEndian, bool Is64BitAddrSize) {
914 for (const DWARFYAML::ListTable<EntryType> &Table : Tables) {
915 // sizeof(version) + sizeof(address_size) + sizeof(segment_selector_size) +
916 // sizeof(offset_entry_count) = 8
917 uint64_t Length = 8;
918
919 uint8_t AddrSize;
920 if (Table.AddrSize)
921 AddrSize = *Table.AddrSize;
922 else
923 AddrSize = Is64BitAddrSize ? 8 : 4;
924
925 // Since the length of the current range/location lists entry is
926 // undetermined yet, we firstly write the content of the range/location
927 // lists to a buffer to calculate the length and then serialize the buffer
928 // content to the actual output stream.
929 std::string ListBuffer;
930 raw_string_ostream ListBufferOS(ListBuffer);
931
932 // Offsets holds offsets for each range/location list. The i-th element is
933 // the offset from the beginning of the first range/location list to the
934 // location of the i-th range list.
935 std::vector<uint64_t> Offsets;
936
937 for (const DWARFYAML::ListEntries<EntryType> &List : Table.Lists) {
938 Offsets.push_back(ListBufferOS.tell());
939 if (List.Content) {
940 List.Content->writeAsBinary(ListBufferOS, UINT64_MAX);
941 Length += List.Content->binary_size();
942 } else if (List.Entries) {
943 for (const EntryType &Entry : *List.Entries) {
944 Expected<uint64_t> EntrySize =
945 writeListEntry(ListBufferOS, Entry, AddrSize, IsLittleEndian);
946 if (!EntrySize)
947 return EntrySize.takeError();
948 Length += *EntrySize;
949 }
950 }
951 }
952
953 // If the offset_entry_count field isn't specified, yaml2obj will infer it
954 // from the 'Offsets' field in the YAML description. If the 'Offsets' field
955 // isn't specified either, yaml2obj will infer it from the auto-generated
956 // offsets.
957 uint32_t OffsetEntryCount;
958 if (Table.OffsetEntryCount)
959 OffsetEntryCount = *Table.OffsetEntryCount;
960 else
961 OffsetEntryCount = Table.Offsets ? Table.Offsets->size() : Offsets.size();
962 uint64_t OffsetsSize =
963 OffsetEntryCount * (Table.Format == dwarf::DWARF64 ? 8 : 4);
964 Length += OffsetsSize;
965
966 // If the length is specified in the YAML description, we use it instead of
967 // the actual length.
968 if (Table.Length)
969 Length = *Table.Length;
970
971 writeInitialLength(Table.Format, Length, OS, IsLittleEndian);
972 writeInteger((uint16_t)Table.Version, OS, IsLittleEndian);
973 writeInteger((uint8_t)AddrSize, OS, IsLittleEndian);
974 writeInteger((uint8_t)Table.SegSelectorSize, OS, IsLittleEndian);
975 writeInteger((uint32_t)OffsetEntryCount, OS, IsLittleEndian);
976
977 auto EmitOffsets = [&](ArrayRef<uint64_t> Offsets, uint64_t OffsetsSize) {
978 for (uint64_t Offset : Offsets)
979 writeDWARFOffset(OffsetsSize + Offset, Table.Format, OS,
980 IsLittleEndian);
981 };
982
983 if (Table.Offsets)
984 EmitOffsets(ArrayRef<uint64_t>((const uint64_t *)Table.Offsets->data(),
985 Table.Offsets->size()),
986 0);
987 else if (OffsetEntryCount != 0)
988 EmitOffsets(Offsets, OffsetsSize);
989
990 OS.write(ListBuffer.data(), ListBuffer.size());
991 }
992
993 return Error::success();
994 }
995
emitDebugRnglists(raw_ostream & OS,const Data & DI)996 Error DWARFYAML::emitDebugRnglists(raw_ostream &OS, const Data &DI) {
997 assert(DI.DebugRnglists && "unexpected emitDebugRnglists() call");
998 return writeDWARFLists<DWARFYAML::RnglistEntry>(
999 OS, *DI.DebugRnglists, DI.IsLittleEndian, DI.Is64BitAddrSize);
1000 }
1001
emitDebugLoclists(raw_ostream & OS,const Data & DI)1002 Error DWARFYAML::emitDebugLoclists(raw_ostream &OS, const Data &DI) {
1003 assert(DI.DebugLoclists && "unexpected emitDebugRnglists() call");
1004 return writeDWARFLists<DWARFYAML::LoclistEntry>(
1005 OS, *DI.DebugLoclists, DI.IsLittleEndian, DI.Is64BitAddrSize);
1006 }
1007
1008 std::function<Error(raw_ostream &, const DWARFYAML::Data &)>
getDWARFEmitterByName(StringRef SecName)1009 DWARFYAML::getDWARFEmitterByName(StringRef SecName) {
1010 auto EmitFunc =
1011 StringSwitch<
1012 std::function<Error(raw_ostream &, const DWARFYAML::Data &)>>(SecName)
1013 .Case("debug_abbrev", DWARFYAML::emitDebugAbbrev)
1014 .Case("debug_addr", DWARFYAML::emitDebugAddr)
1015 .Case("debug_aranges", DWARFYAML::emitDebugAranges)
1016 .Case("debug_gnu_pubnames", DWARFYAML::emitDebugGNUPubnames)
1017 .Case("debug_gnu_pubtypes", DWARFYAML::emitDebugGNUPubtypes)
1018 .Case("debug_info", DWARFYAML::emitDebugInfo)
1019 .Case("debug_line", DWARFYAML::emitDebugLine)
1020 .Case("debug_loclists", DWARFYAML::emitDebugLoclists)
1021 .Case("debug_pubnames", DWARFYAML::emitDebugPubnames)
1022 .Case("debug_pubtypes", DWARFYAML::emitDebugPubtypes)
1023 .Case("debug_ranges", DWARFYAML::emitDebugRanges)
1024 .Case("debug_rnglists", DWARFYAML::emitDebugRnglists)
1025 .Case("debug_str", DWARFYAML::emitDebugStr)
1026 .Case("debug_str_offsets", DWARFYAML::emitDebugStrOffsets)
1027 .Default([&](raw_ostream &, const DWARFYAML::Data &) {
1028 return createStringError(errc::not_supported,
1029 SecName + " is not supported");
1030 });
1031
1032 return EmitFunc;
1033 }
1034
1035 static Error
emitDebugSectionImpl(const DWARFYAML::Data & DI,StringRef Sec,StringMap<std::unique_ptr<MemoryBuffer>> & OutputBuffers)1036 emitDebugSectionImpl(const DWARFYAML::Data &DI, StringRef Sec,
1037 StringMap<std::unique_ptr<MemoryBuffer>> &OutputBuffers) {
1038 std::string Data;
1039 raw_string_ostream DebugInfoStream(Data);
1040
1041 auto EmitFunc = DWARFYAML::getDWARFEmitterByName(Sec);
1042
1043 if (Error Err = EmitFunc(DebugInfoStream, DI))
1044 return Err;
1045 DebugInfoStream.flush();
1046 if (!Data.empty())
1047 OutputBuffers[Sec] = MemoryBuffer::getMemBufferCopy(Data);
1048
1049 return Error::success();
1050 }
1051
1052 Expected<StringMap<std::unique_ptr<MemoryBuffer>>>
emitDebugSections(StringRef YAMLString,bool IsLittleEndian,bool Is64BitAddrSize)1053 DWARFYAML::emitDebugSections(StringRef YAMLString, bool IsLittleEndian,
1054 bool Is64BitAddrSize) {
1055 auto CollectDiagnostic = [](const SMDiagnostic &Diag, void *DiagContext) {
1056 *static_cast<SMDiagnostic *>(DiagContext) = Diag;
1057 };
1058
1059 SMDiagnostic GeneratedDiag;
1060 yaml::Input YIn(YAMLString, /*Ctxt=*/nullptr, CollectDiagnostic,
1061 &GeneratedDiag);
1062
1063 DWARFYAML::Data DI;
1064 DI.IsLittleEndian = IsLittleEndian;
1065 DI.Is64BitAddrSize = Is64BitAddrSize;
1066
1067 YIn >> DI;
1068 if (YIn.error())
1069 return createStringError(YIn.error(), GeneratedDiag.getMessage());
1070
1071 StringMap<std::unique_ptr<MemoryBuffer>> DebugSections;
1072 Error Err = Error::success();
1073
1074 for (StringRef SecName : DI.getNonEmptySectionNames())
1075 Err = joinErrors(std::move(Err),
1076 emitDebugSectionImpl(DI, SecName, DebugSections));
1077
1078 if (Err)
1079 return std::move(Err);
1080 return std::move(DebugSections);
1081 }
1082