caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[NFC] Split portions of DWARFDataExtractor into new class (#140096)

Browse Source 
Currently, DWARFDataExtractor can extract data without performing
relocations, (eg, by checking if the section pointer is null) but is
coded such that it still depends on all the relocation machinery, like
DWARFSections and similar. All at build time.

Extract most functionality into a new class, DWARFDataExtractorBase, and 
have DWARFDataExtractor add the relocation dependent pieces via CRTP.  
Add a new class, DWARFDataExtractorSimple, which does no relocation at 
all. This will allow moving DWARFDataExtractorSimple into a new lower-level, 
lighter-weight library with fewer external build-time dependencies.

This is another in a series of refactoring changes to create a new
better-layered, low-level Dwarf library that can be called from
lower-level code without circular dependencies.
This commit is contained in:
Sterling-Augustine
2025-06-06 09:26:51 -07:00
committed by GitHub
parent cb3d77d107
commit c9c687d8d0
4 changed files with 229 additions and 191 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
llvm/include/llvm/DebugInfo/DWARF/DWARFDataExtractor.h
View File

@@ -10,81 +10,59 @@
#define LLVM_DEBUGINFO_DWARF_DWARFDATAEXTRACTOR_H
#include "llvm/BinaryFormat/Dwarf.h"
#include "llvm/DebugInfo/DWARF/DWARFDataExtractorSimple.h"
#include "llvm/DebugInfo/DWARF/DWARFObject.h"
#include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
#include "llvm/DebugInfo/DWARF/DWARFSection.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/DataExtractor.h"
namespace llvm {
class DWARFObject;
/// A DataExtractor (typically for an in-memory copy of an object-file section)
/// plus a relocation map for that section, if there is one.
class DWARFDataExtractor : public DataExtractor {
/// A DWARFDataExtractor (typically for an in-memory copy of an object-file
/// section) plus a relocation map for that section, if there is one.
class DWARFDataExtractor : public DWARFDataExtractorBase<DWARFDataExtractor> {
const DWARFObject *Obj = nullptr;
const DWARFSection *Section = nullptr;
public:
using DWARFDataExtractorBase::DWARFDataExtractorBase;
/// Constructor for the normal case of extracting data from a DWARF section.
/// The DWARFSection's lifetime must be at least as long as the extractor's.
DWARFDataExtractor(const DWARFObject &Obj, const DWARFSection &Section,
bool IsLittleEndian, uint8_t AddressSize)
: DataExtractor(Section.Data, IsLittleEndian, AddressSize), Obj(&Obj),
Section(&Section) {}
/// Constructor for cases when there are no relocations.
DWARFDataExtractor(StringRef Data, bool IsLittleEndian, uint8_t AddressSize)
: DataExtractor(Data, IsLittleEndian, AddressSize) {}
DWARFDataExtractor(ArrayRef<uint8_t> Data, bool IsLittleEndian,
uint8_t AddressSize)
: DataExtractor(
StringRef(reinterpret_cast<const char *>(Data.data()), Data.size()),
IsLittleEndian, AddressSize) {}
: DWARFDataExtractorBase(Section.Data, IsLittleEndian, AddressSize),
Obj(&Obj), Section(&Section) {}
/// Truncating constructor
DWARFDataExtractor(const DWARFDataExtractor &Other, size_t Length)
: DataExtractor(Other.getData().substr(0, Length), Other.isLittleEndian(),
Other.getAddressSize()),
: DWARFDataExtractorBase(Other.getData().substr(0, Length),
Other.isLittleEndian(), Other.getAddressSize()),
Obj(Other.Obj), Section(Other.Section) {}
/// Extracts the DWARF "initial length" field, which can either be a 32-bit
/// value smaller than 0xfffffff0, or the value 0xffffffff followed by a
/// 64-bit length. Returns the actual length, and the DWARF format which is
/// encoded in the field. In case of errors, it returns {0, DWARF32} and
/// leaves the offset unchanged.
LLVM_ABI std::pair<uint64_t, dwarf::DwarfFormat>
getInitialLength(uint64_t *Off, Error *Err = nullptr) const;
std::pair<uint64_t, dwarf::DwarfFormat> getInitialLength(Cursor &C) const {
return getInitialLength(&getOffset(C), &getError(C));
}
/// Extracts a value and applies a relocation to the result if
/// one exists for the given offset.
LLVM_ABI uint64_t getRelocatedValue(uint32_t Size, uint64_t *Off,
uint64_t *SectionIndex = nullptr,
Error *Err = nullptr) const;
uint64_t getRelocatedValue(Cursor &C, uint32_t Size,
uint64_t *SectionIndex = nullptr) const {
return getRelocatedValue(Size, &getOffset(C), SectionIndex, &getError(C));
}
LLVM_ABI uint64_t getRelocatedValueImpl(uint32_t Size, uint64_t *Off,
uint64_t *SecNdx, Error *Err) const {
if (SecNdx)
*SecNdx = object::SectionedAddress::UndefSection;
if (!Section)
return getUnsigned(Off, Size, Err);
ErrorAsOutParameter ErrAsOut(Err);
std::optional<RelocAddrEntry> E = Obj->find(*Section, *Off);
uint64_t LocData = getUnsigned(Off, Size, Err);
if (!E || (Err && *Err))
return LocData;
if (SecNdx)
*SecNdx = E->SectionIndex;
/// Extracts an address-sized value and applies a relocation to the result if
/// one exists for the given offset.
uint64_t getRelocatedAddress(uint64_t *Off, uint64_t *SecIx = nullptr) const {
return getRelocatedValue(getAddressSize(), Off, SecIx);
uint64_t R = object::resolveRelocation(E->Resolver, E->Reloc,
E->SymbolValue, LocData);
if (E->Reloc2)
R = object::resolveRelocation(E->Resolver, *E->Reloc2, E->SymbolValue2,
R);
return R;
}
uint64_t getRelocatedAddress(Cursor &C, uint64_t *SecIx = nullptr) const {
return getRelocatedValue(getAddressSize(), &getOffset(C), SecIx,
&getError(C));
}
/// Extracts a DWARF-encoded pointer in \p Offset using \p Encoding.
/// There is a DWARF encoding that uses a PC-relative adjustment.
/// For these values, \p AbsPosOffset is used to fix them, which should
/// reflect the absolute address of this pointer.
LLVM_ABI std::optional<uint64_t>
getEncodedPointer(uint64_t *Offset, uint8_t Encoding,
uint64_t AbsPosOffset = 0) const;
};
} // end namespace llvm

198
llvm/include/llvm/DebugInfo/DWARF/DWARFDataExtractorSimple.h Normal file
View File

@@ -0,0 +1,198 @@
//===- DWARFDataExtractorSimple.h -------------------------------*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_DWARF_DWARFDATAEXTRACTORSIMPLE_H
#define LLVM_DEBUGINFO_DWARF_DWARFDATAEXTRACTORSIMPLE_H
#include "llvm/BinaryFormat/Dwarf.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/DataExtractor.h"
#include "llvm/Support/Errc.h"
#include "llvm/Support/MathExtras.h"
namespace llvm {
/// A DataExtractor suitable use for parsing dwarf from memory. Clients use
/// Relocator::getRelocatedValueImpl to relocate values as appropriate.
template <typename Relocator>
class DWARFDataExtractorBase : public DataExtractor {
public:
DWARFDataExtractorBase(StringRef Data, bool IsLittleEndian,
uint8_t AddressSize)
: DataExtractor(Data, IsLittleEndian, AddressSize) {}
DWARFDataExtractorBase(ArrayRef<uint8_t> Data, bool IsLittleEndian,
uint8_t AddressSize)
: DataExtractor(
StringRef(reinterpret_cast<const char *>(Data.data()), Data.size()),
IsLittleEndian, AddressSize) {}
/// Truncating constructor
DWARFDataExtractorBase(const DWARFDataExtractorBase &Other, size_t Length)
: DataExtractor(Other.getData().substr(0, Length), Other.isLittleEndian(),
Other.getAddressSize()) {}
/// Extracts a value and returns it as adjusted by the Relocator
LLVM_ABI uint64_t getRelocatedValue(uint32_t Size, uint64_t *Off,
uint64_t *SectionIndex = nullptr,
Error *Err = nullptr) const {
return static_cast<const Relocator *>(this)->getRelocatedValueImpl(
Size, Off, SectionIndex, Err);
}
LLVM_ABI uint64_t getRelocatedValue(Cursor &C, uint32_t Size,
uint64_t *SectionIndex = nullptr) const {
return getRelocatedValue(Size, &getOffset(C), SectionIndex, &getError(C));
}
/// Extracts an address-sized value.
LLVM_ABI uint64_t getRelocatedAddress(uint64_t *Off,
uint64_t *SecIx = nullptr) const {
return getRelocatedValue(getAddressSize(), Off, SecIx);
}
LLVM_ABI uint64_t getRelocatedAddress(Cursor &C,
uint64_t *SecIx = nullptr) const {
return getRelocatedValue(getAddressSize(), &getOffset(C), SecIx,
&getError(C));
}
/// Extracts the DWARF "initial length" field, which can either be a 32-bit
/// value smaller than 0xfffffff0, or the value 0xffffffff followed by a
/// 64-bit length. Returns the actual length, and the DWARF format which is
/// encoded in the field. In case of errors, it returns {0, DWARF32} and
/// leaves the offset unchanged.
LLVM_ABI std::pair<uint64_t, dwarf::DwarfFormat>
getInitialLength(uint64_t *Off, Error *Err = nullptr) const {
ErrorAsOutParameter ErrAsOut(Err);
if (Err && *Err)
return {0, dwarf::DWARF32};
Cursor C(*Off);
uint64_t Length = getRelocatedValue(C, 4);
dwarf::DwarfFormat Format = dwarf::DWARF32;
if (Length == dwarf::DW_LENGTH_DWARF64) {
Length = getRelocatedValue(C, 8);
Format = dwarf::DWARF64;
} else if (Length >= dwarf::DW_LENGTH_lo_reserved) {
cantFail(C.takeError());
if (Err)
*Err = createStringError(
std::errc::invalid_argument,
"unsupported reserved unit length of value 0x%8.8" PRIx64, Length);
return {0, dwarf::DWARF32};
}
if (C) {
*Off = C.tell();
return {Length, Format};
}
if (Err)
*Err = C.takeError();
else
consumeError(C.takeError());
return {0, dwarf::DWARF32};
}
LLVM_ABI std::pair<uint64_t, dwarf::DwarfFormat>
getInitialLength(Cursor &C) const {
return getInitialLength(&getOffset(C), &getError(C));
}
/// Extracts a DWARF-encoded pointer in \p Offset using \p Encoding.
/// There is a DWARF encoding that uses a PC-relative adjustment.
/// For these values, \p AbsPosOffset is used to fix them, which should
/// reflect the absolute address of this pointer.
LLVM_ABI std::optional<uint64_t>
getEncodedPointer(uint64_t *Offset, uint8_t Encoding,
uint64_t PCRelOffset) const {
if (Encoding == dwarf::DW_EH_PE_omit)
return std::nullopt;
uint64_t Result = 0;
uint64_t OldOffset = *Offset;
// First get value
switch (Encoding & 0x0F) {
case dwarf::DW_EH_PE_absptr:
switch (getAddressSize()) {
case 2:
case 4:
case 8:
Result = getUnsigned(Offset, getAddressSize());
break;
default:
return std::nullopt;
}
break;
case dwarf::DW_EH_PE_uleb128:
Result = getULEB128(Offset);
break;
case dwarf::DW_EH_PE_sleb128:
Result = getSLEB128(Offset);
break;
case dwarf::DW_EH_PE_udata2:
Result = getUnsigned(Offset, 2);
break;
case dwarf::DW_EH_PE_udata4:
Result = getUnsigned(Offset, 4);
break;
case dwarf::DW_EH_PE_udata8:
Result = getUnsigned(Offset, 8);
break;
case dwarf::DW_EH_PE_sdata2:
Result = getSigned(Offset, 2);
break;
case dwarf::DW_EH_PE_sdata4:
Result = SignExtend64<32>(getRelocatedValue(4, Offset));
break;
case dwarf::DW_EH_PE_sdata8:
Result = getRelocatedValue(8, Offset);
break;
default:
return std::nullopt;
}
// Then add relative offset, if required
switch (Encoding & 0x70) {
case dwarf::DW_EH_PE_absptr:
// do nothing
break;
case dwarf::DW_EH_PE_pcrel:
Result += PCRelOffset;
break;
case dwarf::DW_EH_PE_datarel:
case dwarf::DW_EH_PE_textrel:
case dwarf::DW_EH_PE_funcrel:
case dwarf::DW_EH_PE_aligned:
default:
*Offset = OldOffset;
return std::nullopt;
}
return Result;
}
};
// Non relocating, low-level dwarf-data extractor. Suitable for use from
// libraries that cannot have build-time dependencies on relocation providers.
class DWARFDataExtractorSimple
: public DWARFDataExtractorBase<DWARFDataExtractorSimple> {
using DWARFDataExtractorBase::DWARFDataExtractorBase;
LLVM_ABI uint64_t getRelocatedValueImpl(uint32_t Size, uint64_t *Off,
uint64_t *SectionIndex = nullptr,
Error *Err = nullptr) const {
assert(SectionIndex == nullptr &&
"DWARFDATAExtractorSimple cannot take section indices.");
return getUnsigned(Off, Size, Err);
}
};
} // end namespace llvm
#endif // LLVM_DEBUGINFO_DWARF_DWARFDATAEXTRACTOR_H

1
llvm/lib/DebugInfo/DWARF/CMakeLists.txt
View File

@@ -5,7 +5,6 @@ add_llvm_component_library(LLVMDebugInfoDWARF
DWARFCFIProgram.cpp
DWARFCompileUnit.cpp
DWARFContext.cpp
DWARFDataExtractor.cpp
DWARFDebugAbbrev.cpp
DWARFDebugAddr.cpp
DWARFDebugArangeSet.cpp

137
llvm/lib/DebugInfo/DWARF/DWARFDataExtractor.cpp
View File

@@ -1,137 +0,0 @@
//===- DWARFDataExtractor.cpp ---------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
#include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
#include "llvm/DebugInfo/DWARF/DWARFObject.h"
#include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
#include "llvm/Support/Errc.h"
using namespace llvm;
std::pair<uint64_t, dwarf::DwarfFormat>
DWARFDataExtractor::getInitialLength(uint64_t *Off, Error *Err) const {
ErrorAsOutParameter ErrAsOut(Err);
if (Err && *Err)
return {0, dwarf::DWARF32};
Cursor C(*Off);
uint64_t Length = getRelocatedValue(C, 4);
dwarf::DwarfFormat Format = dwarf::DWARF32;
if (Length == dwarf::DW_LENGTH_DWARF64) {
Length = getRelocatedValue(C, 8);
Format = dwarf::DWARF64;
} else if (Length >= dwarf::DW_LENGTH_lo_reserved) {
cantFail(C.takeError());
if (Err)
*Err = createStringError(
errc::invalid_argument,
"unsupported reserved unit length of value 0x%8.8" PRIx64, Length);
return {0, dwarf::DWARF32};
}
if (C) {
*Off = C.tell();
return {Length, Format};
}
if (Err)
*Err = C.takeError();
else
consumeError(C.takeError());
return {0, dwarf::DWARF32};
}
uint64_t DWARFDataExtractor::getRelocatedValue(uint32_t Size, uint64_t *Off,
uint64_t *SecNdx,
Error *Err) const {
if (SecNdx)
*SecNdx = object::SectionedAddress::UndefSection;
if (!Section)
return getUnsigned(Off, Size, Err);
ErrorAsOutParameter ErrAsOut(Err);
std::optional<RelocAddrEntry> E = Obj->find(*Section, *Off);
uint64_t LocData = getUnsigned(Off, Size, Err);
if (!E || (Err && *Err))
return LocData;
if (SecNdx)
*SecNdx = E->SectionIndex;
uint64_t R =
object::resolveRelocation(E->Resolver, E->Reloc, E->SymbolValue, LocData);
if (E->Reloc2)
R = object::resolveRelocation(E->Resolver, *E->Reloc2, E->SymbolValue2, R);
return R;
}
std::optional<uint64_t>
DWARFDataExtractor::getEncodedPointer(uint64_t *Offset, uint8_t Encoding,
uint64_t PCRelOffset) const {
if (Encoding == dwarf::DW_EH_PE_omit)
return std::nullopt;
uint64_t Result = 0;
uint64_t OldOffset = *Offset;
// First get value
switch (Encoding & 0x0F) {
case dwarf::DW_EH_PE_absptr:
switch (getAddressSize()) {
case 2:
case 4:
case 8:
Result = getUnsigned(Offset, getAddressSize());
break;
default:
return std::nullopt;
}
break;
case dwarf::DW_EH_PE_uleb128:
Result = getULEB128(Offset);
break;
case dwarf::DW_EH_PE_sleb128:
Result = getSLEB128(Offset);
break;
case dwarf::DW_EH_PE_udata2:
Result = getUnsigned(Offset, 2);
break;
case dwarf::DW_EH_PE_udata4:
Result = getUnsigned(Offset, 4);
break;
case dwarf::DW_EH_PE_udata8:
Result = getUnsigned(Offset, 8);
break;
case dwarf::DW_EH_PE_sdata2:
Result = getSigned(Offset, 2);
break;
case dwarf::DW_EH_PE_sdata4:
Result = SignExtend64<32>(getRelocatedValue(4, Offset));
break;
case dwarf::DW_EH_PE_sdata8:
Result = getRelocatedValue(8, Offset);
break;
default:
return std::nullopt;
}
// Then add relative offset, if required
switch (Encoding & 0x70) {
case dwarf::DW_EH_PE_absptr:
// do nothing
break;
case dwarf::DW_EH_PE_pcrel:
Result += PCRelOffset;
break;
case dwarf::DW_EH_PE_datarel:
case dwarf::DW_EH_PE_textrel:
case dwarf::DW_EH_PE_funcrel:
case dwarf::DW_EH_PE_aligned:
default:
*Offset = OldOffset;
return std::nullopt;
}
return Result;
}