forked from OSchip/llvm-project
1082 lines
40 KiB
C++
1082 lines
40 KiB
C++
//===- DWARFEmitter - Convert YAML to DWARF binary data -------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
///
|
|
/// \file
|
|
/// The DWARF component of yaml2obj. Provided as library code for tests.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/ObjectYAML/DWARFEmitter.h"
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
#include "llvm/ADT/StringMap.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/ADT/StringSwitch.h"
|
|
#include "llvm/BinaryFormat/Dwarf.h"
|
|
#include "llvm/ObjectYAML/DWARFYAML.h"
|
|
#include "llvm/Support/Errc.h"
|
|
#include "llvm/Support/Error.h"
|
|
#include "llvm/Support/Host.h"
|
|
#include "llvm/Support/LEB128.h"
|
|
#include "llvm/Support/MathExtras.h"
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
#include "llvm/Support/SourceMgr.h"
|
|
#include "llvm/Support/SwapByteOrder.h"
|
|
#include "llvm/Support/YAMLTraits.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include <algorithm>
|
|
#include <cassert>
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
using namespace llvm;
|
|
|
|
template <typename T>
|
|
static void writeInteger(T Integer, raw_ostream &OS, bool IsLittleEndian) {
|
|
if (IsLittleEndian != sys::IsLittleEndianHost)
|
|
sys::swapByteOrder(Integer);
|
|
OS.write(reinterpret_cast<char *>(&Integer), sizeof(T));
|
|
}
|
|
|
|
static Error writeVariableSizedInteger(uint64_t Integer, size_t Size,
|
|
raw_ostream &OS, bool IsLittleEndian) {
|
|
if (8 == Size)
|
|
writeInteger((uint64_t)Integer, OS, IsLittleEndian);
|
|
else if (4 == Size)
|
|
writeInteger((uint32_t)Integer, OS, IsLittleEndian);
|
|
else if (2 == Size)
|
|
writeInteger((uint16_t)Integer, OS, IsLittleEndian);
|
|
else if (1 == Size)
|
|
writeInteger((uint8_t)Integer, OS, IsLittleEndian);
|
|
else
|
|
return createStringError(errc::not_supported,
|
|
"invalid integer write size: %zu", Size);
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
static void ZeroFillBytes(raw_ostream &OS, size_t Size) {
|
|
std::vector<uint8_t> FillData;
|
|
FillData.insert(FillData.begin(), Size, 0);
|
|
OS.write(reinterpret_cast<char *>(FillData.data()), Size);
|
|
}
|
|
|
|
static void writeInitialLength(const dwarf::DwarfFormat Format,
|
|
const uint64_t Length, raw_ostream &OS,
|
|
bool IsLittleEndian) {
|
|
bool IsDWARF64 = Format == dwarf::DWARF64;
|
|
if (IsDWARF64)
|
|
cantFail(writeVariableSizedInteger(dwarf::DW_LENGTH_DWARF64, 4, OS,
|
|
IsLittleEndian));
|
|
cantFail(
|
|
writeVariableSizedInteger(Length, IsDWARF64 ? 8 : 4, OS, IsLittleEndian));
|
|
}
|
|
|
|
static void writeDWARFOffset(uint64_t Offset, dwarf::DwarfFormat Format,
|
|
raw_ostream &OS, bool IsLittleEndian) {
|
|
cantFail(writeVariableSizedInteger(Offset, Format == dwarf::DWARF64 ? 8 : 4,
|
|
OS, IsLittleEndian));
|
|
}
|
|
|
|
Error DWARFYAML::emitDebugStr(raw_ostream &OS, const DWARFYAML::Data &DI) {
|
|
for (StringRef Str : *DI.DebugStrings) {
|
|
OS.write(Str.data(), Str.size());
|
|
OS.write('\0');
|
|
}
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
StringRef DWARFYAML::Data::getAbbrevTableContentByIndex(uint64_t Index) const {
|
|
assert(Index < DebugAbbrev.size() &&
|
|
"Index should be less than the size of DebugAbbrev array");
|
|
auto It = AbbrevTableContents.find(Index);
|
|
if (It != AbbrevTableContents.cend())
|
|
return It->second;
|
|
|
|
std::string AbbrevTableBuffer;
|
|
raw_string_ostream OS(AbbrevTableBuffer);
|
|
|
|
uint64_t AbbrevCode = 0;
|
|
for (const DWARFYAML::Abbrev &AbbrevDecl : DebugAbbrev[Index].Table) {
|
|
AbbrevCode = AbbrevDecl.Code ? (uint64_t)*AbbrevDecl.Code : AbbrevCode + 1;
|
|
encodeULEB128(AbbrevCode, OS);
|
|
encodeULEB128(AbbrevDecl.Tag, OS);
|
|
OS.write(AbbrevDecl.Children);
|
|
for (const auto &Attr : AbbrevDecl.Attributes) {
|
|
encodeULEB128(Attr.Attribute, OS);
|
|
encodeULEB128(Attr.Form, OS);
|
|
if (Attr.Form == dwarf::DW_FORM_implicit_const)
|
|
encodeSLEB128(Attr.Value, OS);
|
|
}
|
|
encodeULEB128(0, OS);
|
|
encodeULEB128(0, OS);
|
|
}
|
|
|
|
// The abbreviations for a given compilation unit end with an entry
|
|
// consisting of a 0 byte for the abbreviation code.
|
|
OS.write_zeros(1);
|
|
|
|
AbbrevTableContents.insert({Index, AbbrevTableBuffer});
|
|
|
|
return AbbrevTableContents[Index];
|
|
}
|
|
|
|
Error DWARFYAML::emitDebugAbbrev(raw_ostream &OS, const DWARFYAML::Data &DI) {
|
|
for (uint64_t I = 0; I < DI.DebugAbbrev.size(); ++I) {
|
|
StringRef AbbrevTableContent = DI.getAbbrevTableContentByIndex(I);
|
|
OS.write(AbbrevTableContent.data(), AbbrevTableContent.size());
|
|
}
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
Error DWARFYAML::emitDebugAranges(raw_ostream &OS, const DWARFYAML::Data &DI) {
|
|
assert(DI.DebugAranges && "unexpected emitDebugAranges() call");
|
|
for (const auto &Range : *DI.DebugAranges) {
|
|
uint8_t AddrSize;
|
|
if (Range.AddrSize)
|
|
AddrSize = *Range.AddrSize;
|
|
else
|
|
AddrSize = DI.Is64BitAddrSize ? 8 : 4;
|
|
|
|
uint64_t Length = 4; // sizeof(version) 2 + sizeof(address_size) 1 +
|
|
// sizeof(segment_selector_size) 1
|
|
Length +=
|
|
Range.Format == dwarf::DWARF64 ? 8 : 4; // sizeof(debug_info_offset)
|
|
|
|
const uint64_t HeaderLength =
|
|
Length + (Range.Format == dwarf::DWARF64
|
|
? 12
|
|
: 4); // sizeof(unit_header) = 12 (DWARF64) or 4 (DWARF32)
|
|
const uint64_t PaddedHeaderLength = alignTo(HeaderLength, AddrSize * 2);
|
|
|
|
if (Range.Length) {
|
|
Length = *Range.Length;
|
|
} else {
|
|
Length += PaddedHeaderLength - HeaderLength;
|
|
Length += AddrSize * 2 * (Range.Descriptors.size() + 1);
|
|
}
|
|
|
|
writeInitialLength(Range.Format, Length, OS, DI.IsLittleEndian);
|
|
writeInteger((uint16_t)Range.Version, OS, DI.IsLittleEndian);
|
|
writeDWARFOffset(Range.CuOffset, Range.Format, OS, DI.IsLittleEndian);
|
|
writeInteger((uint8_t)AddrSize, OS, DI.IsLittleEndian);
|
|
writeInteger((uint8_t)Range.SegSize, OS, DI.IsLittleEndian);
|
|
ZeroFillBytes(OS, PaddedHeaderLength - HeaderLength);
|
|
|
|
for (const auto &Descriptor : Range.Descriptors) {
|
|
if (Error Err = writeVariableSizedInteger(Descriptor.Address, AddrSize,
|
|
OS, DI.IsLittleEndian))
|
|
return createStringError(errc::not_supported,
|
|
"unable to write debug_aranges address: %s",
|
|
toString(std::move(Err)).c_str());
|
|
cantFail(writeVariableSizedInteger(Descriptor.Length, AddrSize, OS,
|
|
DI.IsLittleEndian));
|
|
}
|
|
ZeroFillBytes(OS, AddrSize * 2);
|
|
}
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
Error DWARFYAML::emitDebugRanges(raw_ostream &OS, const DWARFYAML::Data &DI) {
|
|
const size_t RangesOffset = OS.tell();
|
|
uint64_t EntryIndex = 0;
|
|
for (const auto &DebugRanges : *DI.DebugRanges) {
|
|
const size_t CurrOffset = OS.tell() - RangesOffset;
|
|
if (DebugRanges.Offset && (uint64_t)*DebugRanges.Offset < CurrOffset)
|
|
return createStringError(errc::invalid_argument,
|
|
"'Offset' for 'debug_ranges' with index " +
|
|
Twine(EntryIndex) +
|
|
" must be greater than or equal to the "
|
|
"number of bytes written already (0x" +
|
|
Twine::utohexstr(CurrOffset) + ")");
|
|
if (DebugRanges.Offset)
|
|
ZeroFillBytes(OS, *DebugRanges.Offset - CurrOffset);
|
|
|
|
uint8_t AddrSize;
|
|
if (DebugRanges.AddrSize)
|
|
AddrSize = *DebugRanges.AddrSize;
|
|
else
|
|
AddrSize = DI.Is64BitAddrSize ? 8 : 4;
|
|
for (const auto &Entry : DebugRanges.Entries) {
|
|
if (Error Err = writeVariableSizedInteger(Entry.LowOffset, AddrSize, OS,
|
|
DI.IsLittleEndian))
|
|
return createStringError(
|
|
errc::not_supported,
|
|
"unable to write debug_ranges address offset: %s",
|
|
toString(std::move(Err)).c_str());
|
|
cantFail(writeVariableSizedInteger(Entry.HighOffset, AddrSize, OS,
|
|
DI.IsLittleEndian));
|
|
}
|
|
ZeroFillBytes(OS, AddrSize * 2);
|
|
++EntryIndex;
|
|
}
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
static Error emitPubSection(raw_ostream &OS, const DWARFYAML::PubSection &Sect,
|
|
bool IsLittleEndian, bool IsGNUPubSec = false) {
|
|
writeInitialLength(Sect.Format, Sect.Length, OS, IsLittleEndian);
|
|
writeInteger((uint16_t)Sect.Version, OS, IsLittleEndian);
|
|
writeInteger((uint32_t)Sect.UnitOffset, OS, IsLittleEndian);
|
|
writeInteger((uint32_t)Sect.UnitSize, OS, IsLittleEndian);
|
|
for (const auto &Entry : Sect.Entries) {
|
|
writeInteger((uint32_t)Entry.DieOffset, OS, IsLittleEndian);
|
|
if (IsGNUPubSec)
|
|
writeInteger((uint8_t)Entry.Descriptor, OS, IsLittleEndian);
|
|
OS.write(Entry.Name.data(), Entry.Name.size());
|
|
OS.write('\0');
|
|
}
|
|
return Error::success();
|
|
}
|
|
|
|
Error DWARFYAML::emitDebugPubnames(raw_ostream &OS, const Data &DI) {
|
|
assert(DI.PubNames && "unexpected emitDebugPubnames() call");
|
|
return emitPubSection(OS, *DI.PubNames, DI.IsLittleEndian);
|
|
}
|
|
|
|
Error DWARFYAML::emitDebugPubtypes(raw_ostream &OS, const Data &DI) {
|
|
assert(DI.PubTypes && "unexpected emitDebugPubtypes() call");
|
|
return emitPubSection(OS, *DI.PubTypes, DI.IsLittleEndian);
|
|
}
|
|
|
|
Error DWARFYAML::emitDebugGNUPubnames(raw_ostream &OS, const Data &DI) {
|
|
assert(DI.GNUPubNames && "unexpected emitDebugGNUPubnames() call");
|
|
return emitPubSection(OS, *DI.GNUPubNames, DI.IsLittleEndian,
|
|
/*IsGNUStyle=*/true);
|
|
}
|
|
|
|
Error DWARFYAML::emitDebugGNUPubtypes(raw_ostream &OS, const Data &DI) {
|
|
assert(DI.GNUPubTypes && "unexpected emitDebugGNUPubtypes() call");
|
|
return emitPubSection(OS, *DI.GNUPubTypes, DI.IsLittleEndian,
|
|
/*IsGNUStyle=*/true);
|
|
}
|
|
|
|
static Expected<uint64_t> writeDIE(const DWARFYAML::Data &DI, uint64_t CUIndex,
|
|
uint64_t AbbrevTableID,
|
|
const dwarf::FormParams &Params,
|
|
const DWARFYAML::Entry &Entry,
|
|
raw_ostream &OS, bool IsLittleEndian) {
|
|
uint64_t EntryBegin = OS.tell();
|
|
encodeULEB128(Entry.AbbrCode, OS);
|
|
uint32_t AbbrCode = Entry.AbbrCode;
|
|
if (AbbrCode == 0 || Entry.Values.empty())
|
|
return OS.tell() - EntryBegin;
|
|
|
|
Expected<DWARFYAML::Data::AbbrevTableInfo> AbbrevTableInfoOrErr =
|
|
DI.getAbbrevTableInfoByID(AbbrevTableID);
|
|
if (!AbbrevTableInfoOrErr)
|
|
return createStringError(errc::invalid_argument,
|
|
toString(AbbrevTableInfoOrErr.takeError()) +
|
|
" for compilation unit with index " +
|
|
utostr(CUIndex));
|
|
|
|
ArrayRef<DWARFYAML::Abbrev> AbbrevDecls(
|
|
DI.DebugAbbrev[AbbrevTableInfoOrErr->Index].Table);
|
|
|
|
if (AbbrCode > AbbrevDecls.size())
|
|
return createStringError(
|
|
errc::invalid_argument,
|
|
"abbrev code must be less than or equal to the number of "
|
|
"entries in abbreviation table");
|
|
const DWARFYAML::Abbrev &Abbrev = AbbrevDecls[AbbrCode - 1];
|
|
auto FormVal = Entry.Values.begin();
|
|
auto AbbrForm = Abbrev.Attributes.begin();
|
|
for (; FormVal != Entry.Values.end() && AbbrForm != Abbrev.Attributes.end();
|
|
++FormVal, ++AbbrForm) {
|
|
dwarf::Form Form = AbbrForm->Form;
|
|
bool Indirect;
|
|
do {
|
|
Indirect = false;
|
|
switch (Form) {
|
|
case dwarf::DW_FORM_addr:
|
|
// TODO: Test this error.
|
|
if (Error Err = writeVariableSizedInteger(
|
|
FormVal->Value, Params.AddrSize, OS, IsLittleEndian))
|
|
return std::move(Err);
|
|
break;
|
|
case dwarf::DW_FORM_ref_addr:
|
|
// TODO: Test this error.
|
|
if (Error Err = writeVariableSizedInteger(FormVal->Value,
|
|
Params.getRefAddrByteSize(),
|
|
OS, IsLittleEndian))
|
|
return std::move(Err);
|
|
break;
|
|
case dwarf::DW_FORM_exprloc:
|
|
case dwarf::DW_FORM_block:
|
|
encodeULEB128(FormVal->BlockData.size(), OS);
|
|
OS.write((const char *)FormVal->BlockData.data(),
|
|
FormVal->BlockData.size());
|
|
break;
|
|
case dwarf::DW_FORM_block1: {
|
|
writeInteger((uint8_t)FormVal->BlockData.size(), OS, IsLittleEndian);
|
|
OS.write((const char *)FormVal->BlockData.data(),
|
|
FormVal->BlockData.size());
|
|
break;
|
|
}
|
|
case dwarf::DW_FORM_block2: {
|
|
writeInteger((uint16_t)FormVal->BlockData.size(), OS, IsLittleEndian);
|
|
OS.write((const char *)FormVal->BlockData.data(),
|
|
FormVal->BlockData.size());
|
|
break;
|
|
}
|
|
case dwarf::DW_FORM_block4: {
|
|
writeInteger((uint32_t)FormVal->BlockData.size(), OS, IsLittleEndian);
|
|
OS.write((const char *)FormVal->BlockData.data(),
|
|
FormVal->BlockData.size());
|
|
break;
|
|
}
|
|
case dwarf::DW_FORM_strx:
|
|
case dwarf::DW_FORM_addrx:
|
|
case dwarf::DW_FORM_rnglistx:
|
|
case dwarf::DW_FORM_loclistx:
|
|
case dwarf::DW_FORM_udata:
|
|
case dwarf::DW_FORM_ref_udata:
|
|
case dwarf::DW_FORM_GNU_addr_index:
|
|
case dwarf::DW_FORM_GNU_str_index:
|
|
encodeULEB128(FormVal->Value, OS);
|
|
break;
|
|
case dwarf::DW_FORM_data1:
|
|
case dwarf::DW_FORM_ref1:
|
|
case dwarf::DW_FORM_flag:
|
|
case dwarf::DW_FORM_strx1:
|
|
case dwarf::DW_FORM_addrx1:
|
|
writeInteger((uint8_t)FormVal->Value, OS, IsLittleEndian);
|
|
break;
|
|
case dwarf::DW_FORM_data2:
|
|
case dwarf::DW_FORM_ref2:
|
|
case dwarf::DW_FORM_strx2:
|
|
case dwarf::DW_FORM_addrx2:
|
|
writeInteger((uint16_t)FormVal->Value, OS, IsLittleEndian);
|
|
break;
|
|
case dwarf::DW_FORM_data4:
|
|
case dwarf::DW_FORM_ref4:
|
|
case dwarf::DW_FORM_ref_sup4:
|
|
case dwarf::DW_FORM_strx4:
|
|
case dwarf::DW_FORM_addrx4:
|
|
writeInteger((uint32_t)FormVal->Value, OS, IsLittleEndian);
|
|
break;
|
|
case dwarf::DW_FORM_data8:
|
|
case dwarf::DW_FORM_ref8:
|
|
case dwarf::DW_FORM_ref_sup8:
|
|
case dwarf::DW_FORM_ref_sig8:
|
|
writeInteger((uint64_t)FormVal->Value, OS, IsLittleEndian);
|
|
break;
|
|
case dwarf::DW_FORM_sdata:
|
|
encodeSLEB128(FormVal->Value, OS);
|
|
break;
|
|
case dwarf::DW_FORM_string:
|
|
OS.write(FormVal->CStr.data(), FormVal->CStr.size());
|
|
OS.write('\0');
|
|
break;
|
|
case dwarf::DW_FORM_indirect:
|
|
encodeULEB128(FormVal->Value, OS);
|
|
Indirect = true;
|
|
Form = static_cast<dwarf::Form>((uint64_t)FormVal->Value);
|
|
++FormVal;
|
|
break;
|
|
case dwarf::DW_FORM_strp:
|
|
case dwarf::DW_FORM_sec_offset:
|
|
case dwarf::DW_FORM_GNU_ref_alt:
|
|
case dwarf::DW_FORM_GNU_strp_alt:
|
|
case dwarf::DW_FORM_line_strp:
|
|
case dwarf::DW_FORM_strp_sup:
|
|
cantFail(writeVariableSizedInteger(FormVal->Value,
|
|
Params.getDwarfOffsetByteSize(), OS,
|
|
IsLittleEndian));
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
} while (Indirect);
|
|
}
|
|
|
|
return OS.tell() - EntryBegin;
|
|
}
|
|
|
|
Error DWARFYAML::emitDebugInfo(raw_ostream &OS, const DWARFYAML::Data &DI) {
|
|
for (uint64_t I = 0; I < DI.CompileUnits.size(); ++I) {
|
|
const DWARFYAML::Unit &Unit = DI.CompileUnits[I];
|
|
uint8_t AddrSize;
|
|
if (Unit.AddrSize)
|
|
AddrSize = *Unit.AddrSize;
|
|
else
|
|
AddrSize = DI.Is64BitAddrSize ? 8 : 4;
|
|
dwarf::FormParams Params = {Unit.Version, AddrSize, Unit.Format};
|
|
uint64_t Length = 3; // sizeof(version) + sizeof(address_size)
|
|
Length += Unit.Version >= 5 ? 1 : 0; // sizeof(unit_type)
|
|
Length += Params.getDwarfOffsetByteSize(); // sizeof(debug_abbrev_offset)
|
|
|
|
// Since the length of the current compilation unit is undetermined yet, we
|
|
// firstly write the content of the compilation unit to a buffer to
|
|
// calculate it and then serialize the buffer content to the actual output
|
|
// stream.
|
|
std::string EntryBuffer;
|
|
raw_string_ostream EntryBufferOS(EntryBuffer);
|
|
|
|
uint64_t AbbrevTableID = Unit.AbbrevTableID.getValueOr(I);
|
|
for (const DWARFYAML::Entry &Entry : Unit.Entries) {
|
|
if (Expected<uint64_t> EntryLength =
|
|
writeDIE(DI, I, AbbrevTableID, Params, Entry, EntryBufferOS,
|
|
DI.IsLittleEndian))
|
|
Length += *EntryLength;
|
|
else
|
|
return EntryLength.takeError();
|
|
}
|
|
|
|
// If the length is specified in the YAML description, we use it instead of
|
|
// the actual length.
|
|
if (Unit.Length)
|
|
Length = *Unit.Length;
|
|
|
|
writeInitialLength(Unit.Format, Length, OS, DI.IsLittleEndian);
|
|
writeInteger((uint16_t)Unit.Version, OS, DI.IsLittleEndian);
|
|
|
|
uint64_t AbbrevTableOffset = 0;
|
|
if (Unit.AbbrOffset) {
|
|
AbbrevTableOffset = *Unit.AbbrOffset;
|
|
} else {
|
|
if (Expected<DWARFYAML::Data::AbbrevTableInfo> AbbrevTableInfoOrErr =
|
|
DI.getAbbrevTableInfoByID(AbbrevTableID)) {
|
|
AbbrevTableOffset = AbbrevTableInfoOrErr->Offset;
|
|
} else {
|
|
// The current compilation unit may not have DIEs and it will not be
|
|
// able to find the associated abbrev table. We consume the error and
|
|
// assign 0 to the debug_abbrev_offset in such circumstances.
|
|
consumeError(AbbrevTableInfoOrErr.takeError());
|
|
}
|
|
}
|
|
|
|
if (Unit.Version >= 5) {
|
|
writeInteger((uint8_t)Unit.Type, OS, DI.IsLittleEndian);
|
|
writeInteger((uint8_t)AddrSize, OS, DI.IsLittleEndian);
|
|
writeDWARFOffset(AbbrevTableOffset, Unit.Format, OS, DI.IsLittleEndian);
|
|
} else {
|
|
writeDWARFOffset(AbbrevTableOffset, Unit.Format, OS, DI.IsLittleEndian);
|
|
writeInteger((uint8_t)AddrSize, OS, DI.IsLittleEndian);
|
|
}
|
|
|
|
OS.write(EntryBuffer.data(), EntryBuffer.size());
|
|
}
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
static void emitFileEntry(raw_ostream &OS, const DWARFYAML::File &File) {
|
|
OS.write(File.Name.data(), File.Name.size());
|
|
OS.write('\0');
|
|
encodeULEB128(File.DirIdx, OS);
|
|
encodeULEB128(File.ModTime, OS);
|
|
encodeULEB128(File.Length, OS);
|
|
}
|
|
|
|
static void writeExtendedOpcode(const DWARFYAML::LineTableOpcode &Op,
|
|
uint8_t AddrSize, bool IsLittleEndian,
|
|
raw_ostream &OS) {
|
|
// The first byte of extended opcodes is a zero byte. The next bytes are an
|
|
// ULEB128 integer giving the number of bytes in the instruction itself (does
|
|
// not include the first zero byte or the size). We serialize the instruction
|
|
// itself into the OpBuffer and then write the size of the buffer and the
|
|
// buffer to the real output stream.
|
|
std::string OpBuffer;
|
|
raw_string_ostream OpBufferOS(OpBuffer);
|
|
writeInteger((uint8_t)Op.SubOpcode, OpBufferOS, IsLittleEndian);
|
|
switch (Op.SubOpcode) {
|
|
case dwarf::DW_LNE_set_address:
|
|
cantFail(writeVariableSizedInteger(Op.Data, AddrSize, OpBufferOS,
|
|
IsLittleEndian));
|
|
break;
|
|
case dwarf::DW_LNE_define_file:
|
|
emitFileEntry(OpBufferOS, Op.FileEntry);
|
|
break;
|
|
case dwarf::DW_LNE_set_discriminator:
|
|
encodeULEB128(Op.Data, OpBufferOS);
|
|
break;
|
|
case dwarf::DW_LNE_end_sequence:
|
|
break;
|
|
default:
|
|
for (auto OpByte : Op.UnknownOpcodeData)
|
|
writeInteger((uint8_t)OpByte, OpBufferOS, IsLittleEndian);
|
|
}
|
|
uint64_t ExtLen = Op.ExtLen.getValueOr(OpBuffer.size());
|
|
encodeULEB128(ExtLen, OS);
|
|
OS.write(OpBuffer.data(), OpBuffer.size());
|
|
}
|
|
|
|
static void writeLineTableOpcode(const DWARFYAML::LineTableOpcode &Op,
|
|
uint8_t OpcodeBase, uint8_t AddrSize,
|
|
raw_ostream &OS, bool IsLittleEndian) {
|
|
writeInteger((uint8_t)Op.Opcode, OS, IsLittleEndian);
|
|
if (Op.Opcode == 0) {
|
|
writeExtendedOpcode(Op, AddrSize, IsLittleEndian, OS);
|
|
} else if (Op.Opcode < OpcodeBase) {
|
|
switch (Op.Opcode) {
|
|
case dwarf::DW_LNS_copy:
|
|
case dwarf::DW_LNS_negate_stmt:
|
|
case dwarf::DW_LNS_set_basic_block:
|
|
case dwarf::DW_LNS_const_add_pc:
|
|
case dwarf::DW_LNS_set_prologue_end:
|
|
case dwarf::DW_LNS_set_epilogue_begin:
|
|
break;
|
|
|
|
case dwarf::DW_LNS_advance_pc:
|
|
case dwarf::DW_LNS_set_file:
|
|
case dwarf::DW_LNS_set_column:
|
|
case dwarf::DW_LNS_set_isa:
|
|
encodeULEB128(Op.Data, OS);
|
|
break;
|
|
|
|
case dwarf::DW_LNS_advance_line:
|
|
encodeSLEB128(Op.SData, OS);
|
|
break;
|
|
|
|
case dwarf::DW_LNS_fixed_advance_pc:
|
|
writeInteger((uint16_t)Op.Data, OS, IsLittleEndian);
|
|
break;
|
|
|
|
default:
|
|
for (auto OpData : Op.StandardOpcodeData) {
|
|
encodeULEB128(OpData, OS);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static std::vector<uint8_t>
|
|
getStandardOpcodeLengths(uint16_t Version, Optional<uint8_t> OpcodeBase) {
|
|
// If the opcode_base field isn't specified, we returns the
|
|
// standard_opcode_lengths array according to the version by default.
|
|
std::vector<uint8_t> StandardOpcodeLengths{0, 1, 1, 1, 1, 0,
|
|
0, 0, 1, 0, 0, 1};
|
|
if (Version == 2) {
|
|
// DWARF v2 uses the same first 9 standard opcodes as v3-5.
|
|
StandardOpcodeLengths.resize(9);
|
|
} else if (OpcodeBase) {
|
|
StandardOpcodeLengths.resize(*OpcodeBase > 0 ? *OpcodeBase - 1 : 0, 0);
|
|
}
|
|
return StandardOpcodeLengths;
|
|
}
|
|
|
|
Error DWARFYAML::emitDebugLine(raw_ostream &OS, const DWARFYAML::Data &DI) {
|
|
for (const DWARFYAML::LineTable &LineTable : DI.DebugLines) {
|
|
// Buffer holds the bytes following the header_length (or prologue_length in
|
|
// DWARFv2) field to the end of the line number program itself.
|
|
std::string Buffer;
|
|
raw_string_ostream BufferOS(Buffer);
|
|
|
|
writeInteger(LineTable.MinInstLength, BufferOS, DI.IsLittleEndian);
|
|
// TODO: Add support for emitting DWARFv5 line table.
|
|
if (LineTable.Version >= 4)
|
|
writeInteger(LineTable.MaxOpsPerInst, BufferOS, DI.IsLittleEndian);
|
|
writeInteger(LineTable.DefaultIsStmt, BufferOS, DI.IsLittleEndian);
|
|
writeInteger(LineTable.LineBase, BufferOS, DI.IsLittleEndian);
|
|
writeInteger(LineTable.LineRange, BufferOS, DI.IsLittleEndian);
|
|
|
|
std::vector<uint8_t> StandardOpcodeLengths =
|
|
LineTable.StandardOpcodeLengths.getValueOr(
|
|
getStandardOpcodeLengths(LineTable.Version, LineTable.OpcodeBase));
|
|
uint8_t OpcodeBase = LineTable.OpcodeBase
|
|
? *LineTable.OpcodeBase
|
|
: StandardOpcodeLengths.size() + 1;
|
|
writeInteger(OpcodeBase, BufferOS, DI.IsLittleEndian);
|
|
for (uint8_t OpcodeLength : StandardOpcodeLengths)
|
|
writeInteger(OpcodeLength, BufferOS, DI.IsLittleEndian);
|
|
|
|
for (StringRef IncludeDir : LineTable.IncludeDirs) {
|
|
BufferOS.write(IncludeDir.data(), IncludeDir.size());
|
|
BufferOS.write('\0');
|
|
}
|
|
BufferOS.write('\0');
|
|
|
|
for (const DWARFYAML::File &File : LineTable.Files)
|
|
emitFileEntry(BufferOS, File);
|
|
BufferOS.write('\0');
|
|
|
|
uint64_t HeaderLength =
|
|
LineTable.PrologueLength ? *LineTable.PrologueLength : Buffer.size();
|
|
|
|
for (const DWARFYAML::LineTableOpcode &Op : LineTable.Opcodes)
|
|
writeLineTableOpcode(Op, OpcodeBase, DI.Is64BitAddrSize ? 8 : 4, BufferOS,
|
|
DI.IsLittleEndian);
|
|
|
|
uint64_t Length;
|
|
if (LineTable.Length) {
|
|
Length = *LineTable.Length;
|
|
} else {
|
|
Length = 2; // sizeof(version)
|
|
Length +=
|
|
(LineTable.Format == dwarf::DWARF64 ? 8 : 4); // sizeof(header_length)
|
|
Length += Buffer.size();
|
|
}
|
|
|
|
writeInitialLength(LineTable.Format, Length, OS, DI.IsLittleEndian);
|
|
writeInteger(LineTable.Version, OS, DI.IsLittleEndian);
|
|
writeDWARFOffset(HeaderLength, LineTable.Format, OS, DI.IsLittleEndian);
|
|
OS.write(Buffer.data(), Buffer.size());
|
|
}
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
Error DWARFYAML::emitDebugAddr(raw_ostream &OS, const Data &DI) {
|
|
for (const AddrTableEntry &TableEntry : *DI.DebugAddr) {
|
|
uint8_t AddrSize;
|
|
if (TableEntry.AddrSize)
|
|
AddrSize = *TableEntry.AddrSize;
|
|
else
|
|
AddrSize = DI.Is64BitAddrSize ? 8 : 4;
|
|
|
|
uint64_t Length;
|
|
if (TableEntry.Length)
|
|
Length = (uint64_t)*TableEntry.Length;
|
|
else
|
|
// 2 (version) + 1 (address_size) + 1 (segment_selector_size) = 4
|
|
Length = 4 + (AddrSize + TableEntry.SegSelectorSize) *
|
|
TableEntry.SegAddrPairs.size();
|
|
|
|
writeInitialLength(TableEntry.Format, Length, OS, DI.IsLittleEndian);
|
|
writeInteger((uint16_t)TableEntry.Version, OS, DI.IsLittleEndian);
|
|
writeInteger((uint8_t)AddrSize, OS, DI.IsLittleEndian);
|
|
writeInteger((uint8_t)TableEntry.SegSelectorSize, OS, DI.IsLittleEndian);
|
|
|
|
for (const SegAddrPair &Pair : TableEntry.SegAddrPairs) {
|
|
if (TableEntry.SegSelectorSize != yaml::Hex8{0})
|
|
if (Error Err = writeVariableSizedInteger(Pair.Segment,
|
|
TableEntry.SegSelectorSize,
|
|
OS, DI.IsLittleEndian))
|
|
return createStringError(errc::not_supported,
|
|
"unable to write debug_addr segment: %s",
|
|
toString(std::move(Err)).c_str());
|
|
if (AddrSize != 0)
|
|
if (Error Err = writeVariableSizedInteger(Pair.Address, AddrSize, OS,
|
|
DI.IsLittleEndian))
|
|
return createStringError(errc::not_supported,
|
|
"unable to write debug_addr address: %s",
|
|
toString(std::move(Err)).c_str());
|
|
}
|
|
}
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
Error DWARFYAML::emitDebugStrOffsets(raw_ostream &OS, const Data &DI) {
|
|
assert(DI.DebugStrOffsets && "unexpected emitDebugStrOffsets() call");
|
|
for (const DWARFYAML::StringOffsetsTable &Table : *DI.DebugStrOffsets) {
|
|
uint64_t Length;
|
|
if (Table.Length)
|
|
Length = *Table.Length;
|
|
else
|
|
// sizeof(version) + sizeof(padding) = 4
|
|
Length =
|
|
4 + Table.Offsets.size() * (Table.Format == dwarf::DWARF64 ? 8 : 4);
|
|
|
|
writeInitialLength(Table.Format, Length, OS, DI.IsLittleEndian);
|
|
writeInteger((uint16_t)Table.Version, OS, DI.IsLittleEndian);
|
|
writeInteger((uint16_t)Table.Padding, OS, DI.IsLittleEndian);
|
|
|
|
for (uint64_t Offset : Table.Offsets)
|
|
writeDWARFOffset(Offset, Table.Format, OS, DI.IsLittleEndian);
|
|
}
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
static Error checkOperandCount(StringRef EncodingString,
|
|
ArrayRef<yaml::Hex64> Values,
|
|
uint64_t ExpectedOperands) {
|
|
if (Values.size() != ExpectedOperands)
|
|
return createStringError(
|
|
errc::invalid_argument,
|
|
"invalid number (%zu) of operands for the operator: %s, %" PRIu64
|
|
" expected",
|
|
Values.size(), EncodingString.str().c_str(), ExpectedOperands);
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
static Error writeListEntryAddress(StringRef EncodingName, raw_ostream &OS,
|
|
uint64_t Addr, uint8_t AddrSize,
|
|
bool IsLittleEndian) {
|
|
if (Error Err = writeVariableSizedInteger(Addr, AddrSize, OS, IsLittleEndian))
|
|
return createStringError(errc::invalid_argument,
|
|
"unable to write address for the operator %s: %s",
|
|
EncodingName.str().c_str(),
|
|
toString(std::move(Err)).c_str());
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
static Expected<uint64_t>
|
|
writeDWARFExpression(raw_ostream &OS,
|
|
const DWARFYAML::DWARFOperation &Operation,
|
|
uint8_t AddrSize, bool IsLittleEndian) {
|
|
auto CheckOperands = [&](uint64_t ExpectedOperands) -> Error {
|
|
return checkOperandCount(dwarf::OperationEncodingString(Operation.Operator),
|
|
Operation.Values, ExpectedOperands);
|
|
};
|
|
|
|
uint64_t ExpressionBegin = OS.tell();
|
|
writeInteger((uint8_t)Operation.Operator, OS, IsLittleEndian);
|
|
switch (Operation.Operator) {
|
|
case dwarf::DW_OP_consts:
|
|
if (Error Err = CheckOperands(1))
|
|
return std::move(Err);
|
|
encodeSLEB128(Operation.Values[0], OS);
|
|
break;
|
|
case dwarf::DW_OP_stack_value:
|
|
if (Error Err = CheckOperands(0))
|
|
return std::move(Err);
|
|
break;
|
|
default:
|
|
StringRef EncodingStr = dwarf::OperationEncodingString(Operation.Operator);
|
|
return createStringError(errc::not_supported,
|
|
"DWARF expression: " +
|
|
(EncodingStr.empty()
|
|
? "0x" + utohexstr(Operation.Operator)
|
|
: EncodingStr) +
|
|
" is not supported");
|
|
}
|
|
return OS.tell() - ExpressionBegin;
|
|
}
|
|
|
|
static Expected<uint64_t> writeListEntry(raw_ostream &OS,
|
|
const DWARFYAML::RnglistEntry &Entry,
|
|
uint8_t AddrSize,
|
|
bool IsLittleEndian) {
|
|
uint64_t BeginOffset = OS.tell();
|
|
writeInteger((uint8_t)Entry.Operator, OS, IsLittleEndian);
|
|
|
|
StringRef EncodingName = dwarf::RangeListEncodingString(Entry.Operator);
|
|
|
|
auto CheckOperands = [&](uint64_t ExpectedOperands) -> Error {
|
|
return checkOperandCount(EncodingName, Entry.Values, ExpectedOperands);
|
|
};
|
|
|
|
auto WriteAddress = [&](uint64_t Addr) -> Error {
|
|
return writeListEntryAddress(EncodingName, OS, Addr, AddrSize,
|
|
IsLittleEndian);
|
|
};
|
|
|
|
switch (Entry.Operator) {
|
|
case dwarf::DW_RLE_end_of_list:
|
|
if (Error Err = CheckOperands(0))
|
|
return std::move(Err);
|
|
break;
|
|
case dwarf::DW_RLE_base_addressx:
|
|
if (Error Err = CheckOperands(1))
|
|
return std::move(Err);
|
|
encodeULEB128(Entry.Values[0], OS);
|
|
break;
|
|
case dwarf::DW_RLE_startx_endx:
|
|
case dwarf::DW_RLE_startx_length:
|
|
case dwarf::DW_RLE_offset_pair:
|
|
if (Error Err = CheckOperands(2))
|
|
return std::move(Err);
|
|
encodeULEB128(Entry.Values[0], OS);
|
|
encodeULEB128(Entry.Values[1], OS);
|
|
break;
|
|
case dwarf::DW_RLE_base_address:
|
|
if (Error Err = CheckOperands(1))
|
|
return std::move(Err);
|
|
if (Error Err = WriteAddress(Entry.Values[0]))
|
|
return std::move(Err);
|
|
break;
|
|
case dwarf::DW_RLE_start_end:
|
|
if (Error Err = CheckOperands(2))
|
|
return std::move(Err);
|
|
if (Error Err = WriteAddress(Entry.Values[0]))
|
|
return std::move(Err);
|
|
cantFail(WriteAddress(Entry.Values[1]));
|
|
break;
|
|
case dwarf::DW_RLE_start_length:
|
|
if (Error Err = CheckOperands(2))
|
|
return std::move(Err);
|
|
if (Error Err = WriteAddress(Entry.Values[0]))
|
|
return std::move(Err);
|
|
encodeULEB128(Entry.Values[1], OS);
|
|
break;
|
|
}
|
|
|
|
return OS.tell() - BeginOffset;
|
|
}
|
|
|
|
static Expected<uint64_t> writeListEntry(raw_ostream &OS,
|
|
const DWARFYAML::LoclistEntry &Entry,
|
|
uint8_t AddrSize,
|
|
bool IsLittleEndian) {
|
|
uint64_t BeginOffset = OS.tell();
|
|
writeInteger((uint8_t)Entry.Operator, OS, IsLittleEndian);
|
|
|
|
StringRef EncodingName = dwarf::LocListEncodingString(Entry.Operator);
|
|
|
|
auto CheckOperands = [&](uint64_t ExpectedOperands) -> Error {
|
|
return checkOperandCount(EncodingName, Entry.Values, ExpectedOperands);
|
|
};
|
|
|
|
auto WriteAddress = [&](uint64_t Addr) -> Error {
|
|
return writeListEntryAddress(EncodingName, OS, Addr, AddrSize,
|
|
IsLittleEndian);
|
|
};
|
|
|
|
auto WriteDWARFOperations = [&]() -> Error {
|
|
std::string OpBuffer;
|
|
raw_string_ostream OpBufferOS(OpBuffer);
|
|
uint64_t DescriptionsLength = 0;
|
|
|
|
for (const DWARFYAML::DWARFOperation &Op : Entry.Descriptions) {
|
|
if (Expected<uint64_t> OpSize =
|
|
writeDWARFExpression(OpBufferOS, Op, AddrSize, IsLittleEndian))
|
|
DescriptionsLength += *OpSize;
|
|
else
|
|
return OpSize.takeError();
|
|
}
|
|
|
|
if (Entry.DescriptionsLength)
|
|
DescriptionsLength = *Entry.DescriptionsLength;
|
|
else
|
|
DescriptionsLength = OpBuffer.size();
|
|
|
|
encodeULEB128(DescriptionsLength, OS);
|
|
OS.write(OpBuffer.data(), OpBuffer.size());
|
|
|
|
return Error::success();
|
|
};
|
|
|
|
switch (Entry.Operator) {
|
|
case dwarf::DW_LLE_end_of_list:
|
|
if (Error Err = CheckOperands(0))
|
|
return std::move(Err);
|
|
break;
|
|
case dwarf::DW_LLE_base_addressx:
|
|
if (Error Err = CheckOperands(1))
|
|
return std::move(Err);
|
|
encodeULEB128(Entry.Values[0], OS);
|
|
break;
|
|
case dwarf::DW_LLE_startx_endx:
|
|
case dwarf::DW_LLE_startx_length:
|
|
case dwarf::DW_LLE_offset_pair:
|
|
if (Error Err = CheckOperands(2))
|
|
return std::move(Err);
|
|
encodeULEB128(Entry.Values[0], OS);
|
|
encodeULEB128(Entry.Values[1], OS);
|
|
if (Error Err = WriteDWARFOperations())
|
|
return std::move(Err);
|
|
break;
|
|
case dwarf::DW_LLE_default_location:
|
|
if (Error Err = CheckOperands(0))
|
|
return std::move(Err);
|
|
if (Error Err = WriteDWARFOperations())
|
|
return std::move(Err);
|
|
break;
|
|
case dwarf::DW_LLE_base_address:
|
|
if (Error Err = CheckOperands(1))
|
|
return std::move(Err);
|
|
if (Error Err = WriteAddress(Entry.Values[0]))
|
|
return std::move(Err);
|
|
break;
|
|
case dwarf::DW_LLE_start_end:
|
|
if (Error Err = CheckOperands(2))
|
|
return std::move(Err);
|
|
if (Error Err = WriteAddress(Entry.Values[0]))
|
|
return std::move(Err);
|
|
cantFail(WriteAddress(Entry.Values[1]));
|
|
if (Error Err = WriteDWARFOperations())
|
|
return std::move(Err);
|
|
break;
|
|
case dwarf::DW_LLE_start_length:
|
|
if (Error Err = CheckOperands(2))
|
|
return std::move(Err);
|
|
if (Error Err = WriteAddress(Entry.Values[0]))
|
|
return std::move(Err);
|
|
encodeULEB128(Entry.Values[1], OS);
|
|
if (Error Err = WriteDWARFOperations())
|
|
return std::move(Err);
|
|
break;
|
|
}
|
|
|
|
return OS.tell() - BeginOffset;
|
|
}
|
|
|
|
template <typename EntryType>
|
|
static Error writeDWARFLists(raw_ostream &OS,
|
|
ArrayRef<DWARFYAML::ListTable<EntryType>> Tables,
|
|
bool IsLittleEndian, bool Is64BitAddrSize) {
|
|
for (const DWARFYAML::ListTable<EntryType> &Table : Tables) {
|
|
// sizeof(version) + sizeof(address_size) + sizeof(segment_selector_size) +
|
|
// sizeof(offset_entry_count) = 8
|
|
uint64_t Length = 8;
|
|
|
|
uint8_t AddrSize;
|
|
if (Table.AddrSize)
|
|
AddrSize = *Table.AddrSize;
|
|
else
|
|
AddrSize = Is64BitAddrSize ? 8 : 4;
|
|
|
|
// Since the length of the current range/location lists entry is
|
|
// undetermined yet, we firstly write the content of the range/location
|
|
// lists to a buffer to calculate the length and then serialize the buffer
|
|
// content to the actual output stream.
|
|
std::string ListBuffer;
|
|
raw_string_ostream ListBufferOS(ListBuffer);
|
|
|
|
// Offsets holds offsets for each range/location list. The i-th element is
|
|
// the offset from the beginning of the first range/location list to the
|
|
// location of the i-th range list.
|
|
std::vector<uint64_t> Offsets;
|
|
|
|
for (const DWARFYAML::ListEntries<EntryType> &List : Table.Lists) {
|
|
Offsets.push_back(ListBufferOS.tell());
|
|
if (List.Content) {
|
|
List.Content->writeAsBinary(ListBufferOS, UINT64_MAX);
|
|
Length += List.Content->binary_size();
|
|
} else if (List.Entries) {
|
|
for (const EntryType &Entry : *List.Entries) {
|
|
Expected<uint64_t> EntrySize =
|
|
writeListEntry(ListBufferOS, Entry, AddrSize, IsLittleEndian);
|
|
if (!EntrySize)
|
|
return EntrySize.takeError();
|
|
Length += *EntrySize;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If the offset_entry_count field isn't specified, yaml2obj will infer it
|
|
// from the 'Offsets' field in the YAML description. If the 'Offsets' field
|
|
// isn't specified either, yaml2obj will infer it from the auto-generated
|
|
// offsets.
|
|
uint32_t OffsetEntryCount;
|
|
if (Table.OffsetEntryCount)
|
|
OffsetEntryCount = *Table.OffsetEntryCount;
|
|
else
|
|
OffsetEntryCount = Table.Offsets ? Table.Offsets->size() : Offsets.size();
|
|
uint64_t OffsetsSize =
|
|
OffsetEntryCount * (Table.Format == dwarf::DWARF64 ? 8 : 4);
|
|
Length += OffsetsSize;
|
|
|
|
// If the length is specified in the YAML description, we use it instead of
|
|
// the actual length.
|
|
if (Table.Length)
|
|
Length = *Table.Length;
|
|
|
|
writeInitialLength(Table.Format, Length, OS, IsLittleEndian);
|
|
writeInteger((uint16_t)Table.Version, OS, IsLittleEndian);
|
|
writeInteger((uint8_t)AddrSize, OS, IsLittleEndian);
|
|
writeInteger((uint8_t)Table.SegSelectorSize, OS, IsLittleEndian);
|
|
writeInteger((uint32_t)OffsetEntryCount, OS, IsLittleEndian);
|
|
|
|
auto EmitOffsets = [&](ArrayRef<uint64_t> Offsets, uint64_t OffsetsSize) {
|
|
for (uint64_t Offset : Offsets)
|
|
writeDWARFOffset(OffsetsSize + Offset, Table.Format, OS,
|
|
IsLittleEndian);
|
|
};
|
|
|
|
if (Table.Offsets)
|
|
EmitOffsets(ArrayRef<uint64_t>((const uint64_t *)Table.Offsets->data(),
|
|
Table.Offsets->size()),
|
|
0);
|
|
else if (OffsetEntryCount != 0)
|
|
EmitOffsets(Offsets, OffsetsSize);
|
|
|
|
OS.write(ListBuffer.data(), ListBuffer.size());
|
|
}
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
Error DWARFYAML::emitDebugRnglists(raw_ostream &OS, const Data &DI) {
|
|
assert(DI.DebugRnglists && "unexpected emitDebugRnglists() call");
|
|
return writeDWARFLists<DWARFYAML::RnglistEntry>(
|
|
OS, *DI.DebugRnglists, DI.IsLittleEndian, DI.Is64BitAddrSize);
|
|
}
|
|
|
|
Error DWARFYAML::emitDebugLoclists(raw_ostream &OS, const Data &DI) {
|
|
assert(DI.DebugLoclists && "unexpected emitDebugRnglists() call");
|
|
return writeDWARFLists<DWARFYAML::LoclistEntry>(
|
|
OS, *DI.DebugLoclists, DI.IsLittleEndian, DI.Is64BitAddrSize);
|
|
}
|
|
|
|
std::function<Error(raw_ostream &, const DWARFYAML::Data &)>
|
|
DWARFYAML::getDWARFEmitterByName(StringRef SecName) {
|
|
auto EmitFunc =
|
|
StringSwitch<
|
|
std::function<Error(raw_ostream &, const DWARFYAML::Data &)>>(SecName)
|
|
.Case("debug_abbrev", DWARFYAML::emitDebugAbbrev)
|
|
.Case("debug_addr", DWARFYAML::emitDebugAddr)
|
|
.Case("debug_aranges", DWARFYAML::emitDebugAranges)
|
|
.Case("debug_gnu_pubnames", DWARFYAML::emitDebugGNUPubnames)
|
|
.Case("debug_gnu_pubtypes", DWARFYAML::emitDebugGNUPubtypes)
|
|
.Case("debug_info", DWARFYAML::emitDebugInfo)
|
|
.Case("debug_line", DWARFYAML::emitDebugLine)
|
|
.Case("debug_loclists", DWARFYAML::emitDebugLoclists)
|
|
.Case("debug_pubnames", DWARFYAML::emitDebugPubnames)
|
|
.Case("debug_pubtypes", DWARFYAML::emitDebugPubtypes)
|
|
.Case("debug_ranges", DWARFYAML::emitDebugRanges)
|
|
.Case("debug_rnglists", DWARFYAML::emitDebugRnglists)
|
|
.Case("debug_str", DWARFYAML::emitDebugStr)
|
|
.Case("debug_str_offsets", DWARFYAML::emitDebugStrOffsets)
|
|
.Default([&](raw_ostream &, const DWARFYAML::Data &) {
|
|
return createStringError(errc::not_supported,
|
|
SecName + " is not supported");
|
|
});
|
|
|
|
return EmitFunc;
|
|
}
|
|
|
|
static Error
|
|
emitDebugSectionImpl(const DWARFYAML::Data &DI, StringRef Sec,
|
|
StringMap<std::unique_ptr<MemoryBuffer>> &OutputBuffers) {
|
|
std::string Data;
|
|
raw_string_ostream DebugInfoStream(Data);
|
|
|
|
auto EmitFunc = DWARFYAML::getDWARFEmitterByName(Sec);
|
|
|
|
if (Error Err = EmitFunc(DebugInfoStream, DI))
|
|
return Err;
|
|
DebugInfoStream.flush();
|
|
if (!Data.empty())
|
|
OutputBuffers[Sec] = MemoryBuffer::getMemBufferCopy(Data);
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
Expected<StringMap<std::unique_ptr<MemoryBuffer>>>
|
|
DWARFYAML::emitDebugSections(StringRef YAMLString, bool IsLittleEndian,
|
|
bool Is64BitAddrSize) {
|
|
auto CollectDiagnostic = [](const SMDiagnostic &Diag, void *DiagContext) {
|
|
*static_cast<SMDiagnostic *>(DiagContext) = Diag;
|
|
};
|
|
|
|
SMDiagnostic GeneratedDiag;
|
|
yaml::Input YIn(YAMLString, /*Ctxt=*/nullptr, CollectDiagnostic,
|
|
&GeneratedDiag);
|
|
|
|
DWARFYAML::Data DI;
|
|
DI.IsLittleEndian = IsLittleEndian;
|
|
DI.Is64BitAddrSize = Is64BitAddrSize;
|
|
|
|
YIn >> DI;
|
|
if (YIn.error())
|
|
return createStringError(YIn.error(), GeneratedDiag.getMessage());
|
|
|
|
StringMap<std::unique_ptr<MemoryBuffer>> DebugSections;
|
|
Error Err = Error::success();
|
|
|
|
for (StringRef SecName : DI.getNonEmptySectionNames())
|
|
Err = joinErrors(std::move(Err),
|
|
emitDebugSectionImpl(DI, SecName, DebugSections));
|
|
|
|
if (Err)
|
|
return std::move(Err);
|
|
return std::move(DebugSections);
|
|
}
|