| //===- 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(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); |
| } |
