llvm/lib/ObjectYAML/DWARFEmitter.cpp

   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/LEB128.h"
  24 #include "llvm/Support/MathExtras.h"
  25 #include "llvm/Support/MemoryBuffer.h"
  26 #include "llvm/Support/SourceMgr.h"
  27 #include "llvm/Support/SwapByteOrder.h"
  28 #include "llvm/Support/YAMLTraits.h"
  29 #include "llvm/Support/raw_ostream.h"
  30 #include "llvm/TargetParser/Host.h"
  31 #include <algorithm>
  32 #include <cassert>
  33 #include <cstddef>
  34 #include <cstdint>
  35 #include <memory>
  36 #include <optional>
  37 #include <string>
  38 #include <vector>
  39
  40 using namespace llvm;
  41
  42 template <typename T>
  43 static void writeInteger(T Integer, raw_ostream &OS, bool IsLittleEndian) {
  44   if (IsLittleEndian != sys::IsLittleEndianHost)
  45     sys::swapByteOrder(Integer);
  46   OS.write(reinterpret_cast<char *>(&Integer), sizeof(T));
  47 }
  48
  49 static Error writeVariableSizedInteger(uint64_t Integer, size_t Size,
  50                                        raw_ostream &OS, bool IsLittleEndian) {
  51   if (8 == Size)
  52     writeInteger((uint64_t)Integer, OS, IsLittleEndian);
  53   else if (4 == Size)
  54     writeInteger((uint32_t)Integer, OS, IsLittleEndian);
  55   else if (2 == Size)
  56     writeInteger((uint16_t)Integer, OS, IsLittleEndian);
  57   else if (1 == Size)
  58     writeInteger((uint8_t)Integer, OS, IsLittleEndian);
  59   else
  60     return createStringError(errc::not_supported,
  61                              "invalid integer write size: %zu", Size);
  62
  63   return Error::success();
  64 }
  65
  66 static void ZeroFillBytes(raw_ostream &OS, size_t Size) {
  67   std::vector<uint8_t> FillData(Size, 0);
  68   OS.write(reinterpret_cast<char *>(FillData.data()), Size);
  69 }
  70
  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
  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
  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
  97 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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.value_or(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
 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
 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.value_or(OpBuffer.size());
 512   encodeULEB128(ExtLen, OS);
 513   OS.write(OpBuffer.data(), OpBuffer.size());
 514 }
 515
 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>
 556 getStandardOpcodeLengths(uint16_t Version, std::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
 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.value_or(
 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
 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 != yaml::Hex8{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
 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
 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
 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>
 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
 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
 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>
 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
 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
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 &)>
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
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>>>
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 }