[NFC] Split portions of DWARFDataExtractor into new class #140096
Merged
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
…ple. Currently, DWARFDataExtractor can extract data without performing relocations, but is coded such that it still depends on all the relocation machinery, like DWARFSections and similar. Extract most functionality into a new base class, DWARFDataExtractorSimple, and have DWARFDataExtractor add the relocation dependent pieces as overrides. This will allow moving DWARFDataExtractorSimple into a new lower-level, lighter-weight library with fewer external dependencies. This is another in a series of refactoring changes to create a new better-layered, lo-level Dwarf library that can be called from lower-level code without circular dependencies.
Member
|
@llvm/pr-subscribers-debuginfo Author: None (Sterling-Augustine) ChangesCurrently, 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. Extract most functionality into a new base class, DWARFDataExtractorSimple, and have DWARFDataExtractor add the relocation dependent pieces as overrides. This will allow moving DWARFDataExtractorSimple into a new lower-level, lighter-weight library with fewer external dependencies. This is another in a series of refactoring changes to create a new better-layered, lo-level Dwarf library that can be called from lower-level code without circular dependencies. Although there is no change in functionality, this one is not mechanical like the others, so it is worth a closer look by the reviewers. Full diff: https://github.com/llvm/llvm-project/pull/140096.diff 5 Files Affected:
diff --git a/llvm/include/llvm/DebugInfo/DWARF/DWARFDataExtractor.h b/llvm/include/llvm/DebugInfo/DWARF/DWARFDataExtractor.h
index e94fa7bf5590f..4394e46806d84 100644
--- a/llvm/include/llvm/DebugInfo/DWARF/DWARFDataExtractor.h
+++ b/llvm/include/llvm/DebugInfo/DWARF/DWARFDataExtractor.h
@@ -10,79 +10,46 @@
#define LLVM_DEBUGINFO_DWARF_DWARFDATAEXTRACTOR_H
#include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/DebugInfo/DWARF/DWARFDataExtractorSimple.h"
#include "llvm/DebugInfo/DWARF/DWARFSection.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 DWARFDataExtractorSimple (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 DWARFDataExtractorSimple {
const DWARFObject *Obj = nullptr;
const DWARFSection *Section = nullptr;
public:
+ using DWARFDataExtractorSimple::DWARFDataExtractorSimple;
+
/// 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) {}
+ : DWARFDataExtractorSimple(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()),
+ : DWARFDataExtractorSimple(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.
- 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.
uint64_t getRelocatedValue(uint32_t Size, uint64_t *Off,
uint64_t *SectionIndex = nullptr,
- Error *Err = nullptr) const;
+ Error *Err = nullptr) const override;
+
uint64_t getRelocatedValue(Cursor &C, uint32_t Size,
- uint64_t *SectionIndex = nullptr) const {
+ uint64_t *SectionIndex = nullptr) const override {
return getRelocatedValue(Size, &getOffset(C), SectionIndex, &getError(C));
}
-
- /// 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 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.
- std::optional<uint64_t> getEncodedPointer(uint64_t *Offset, uint8_t Encoding,
- uint64_t AbsPosOffset = 0) const;
};
} // end namespace llvm
diff --git a/llvm/include/llvm/DebugInfo/DWARF/DWARFDataExtractorSimple.h b/llvm/include/llvm/DebugInfo/DWARF/DWARFDataExtractorSimple.h
new file mode 100644
index 0000000000000..b6f1c081f83e8
--- /dev/null
+++ b/llvm/include/llvm/DebugInfo/DWARF/DWARFDataExtractorSimple.h
@@ -0,0 +1,88 @@
+//===- 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
+//
+//===----------------------------------------------------------------------===//
+
+// Non relocating, low-level dwarf-data extractor. Suitable for use from
+// libraries that cannot have build-time dependencies on relocation providers.
+
+#ifndef LLVM_DEBUGINFO_DWARF_DWARFDATAEXTRACTORSIMPLE_H
+#define LLVM_DEBUGINFO_DWARF_DWARFDATAEXTRACTORSIMPLE_H
+
+#include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/Support/DataExtractor.h"
+
+namespace llvm {
+
+/// A DataExtractor suitable use for parsing dwarf from memory with minimal
+/// dwarf context--no sections and no objects. getRelocated* functions
+/// return raw values.
+
+class DWARFDataExtractorSimple : public DataExtractor {
+
+public:
+ DWARFDataExtractorSimple(StringRef Data, bool IsLittleEndian,
+ uint8_t AddressSize)
+ : DataExtractor(Data, IsLittleEndian, AddressSize) {}
+ DWARFDataExtractorSimple(ArrayRef<uint8_t> Data, bool IsLittleEndian,
+ uint8_t AddressSize)
+ : DataExtractor(
+ StringRef(reinterpret_cast<const char *>(Data.data()), Data.size()),
+ IsLittleEndian, AddressSize) {}
+
+ /// Truncating constructor
+ DWARFDataExtractorSimple(const DWARFDataExtractorSimple &Other, size_t Length)
+ : DataExtractor(Other.getData().substr(0, Length), Other.isLittleEndian(),
+ Other.getAddressSize()) {}
+
+ virtual ~DWARFDataExtractorSimple() = default;
+
+ /// 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.
+ 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 returns it unrelocated. Named such to implement the
+ /// required interface.
+ virtual uint64_t getRelocatedValue(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);
+ }
+ virtual 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.
+ uint64_t getRelocatedAddress(uint64_t *Off, uint64_t *SecIx = nullptr) const {
+ return getRelocatedValue(getAddressSize(), Off, SecIx);
+ }
+ 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.
+ std::optional<uint64_t> getEncodedPointer(uint64_t *Offset, uint8_t Encoding,
+ uint64_t AbsPosOffset = 0) const;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_DWARF_DWARFDATAEXTRACTOR_H
diff --git a/llvm/lib/DebugInfo/DWARF/CMakeLists.txt b/llvm/lib/DebugInfo/DWARF/CMakeLists.txt
index e565821cf2942..2dbe7f66446b4 100644
--- a/llvm/lib/DebugInfo/DWARF/CMakeLists.txt
+++ b/llvm/lib/DebugInfo/DWARF/CMakeLists.txt
@@ -5,6 +5,7 @@ add_llvm_component_library(LLVMDebugInfoDWARF
DWARFCompileUnit.cpp
DWARFContext.cpp
DWARFDataExtractor.cpp
+ DWARFDataExtractorSimple.cpp
DWARFDebugAbbrev.cpp
DWARFDebugAddr.cpp
DWARFDebugArangeSet.cpp
diff --git a/llvm/lib/DebugInfo/DWARF/DWARFDataExtractor.cpp b/llvm/lib/DebugInfo/DWARF/DWARFDataExtractor.cpp
index 97434b3cfab82..5b4ae615ae565 100644
--- a/llvm/lib/DebugInfo/DWARF/DWARFDataExtractor.cpp
+++ b/llvm/lib/DebugInfo/DWARF/DWARFDataExtractor.cpp
@@ -13,38 +13,6 @@
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 {
@@ -67,71 +35,3 @@ uint64_t DWARFDataExtractor::getRelocatedValue(uint32_t Size, uint64_t *Off,
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;
-}
diff --git a/llvm/lib/DebugInfo/DWARF/DWARFDataExtractorSimple.cpp b/llvm/lib/DebugInfo/DWARF/DWARFDataExtractorSimple.cpp
new file mode 100644
index 0000000000000..382d234d996f0
--- /dev/null
+++ b/llvm/lib/DebugInfo/DWARF/DWARFDataExtractorSimple.cpp
@@ -0,0 +1,113 @@
+//===- DWARFDataExtractorSimple.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/DWARFDataExtractorSimple.h"
+#include "llvm/Support/Errc.h"
+#include "llvm/Support/MathExtras.h"
+
+using namespace llvm;
+
+std::pair<uint64_t, dwarf::DwarfFormat>
+DWARFDataExtractorSimple::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};
+}
+
+std::optional<uint64_t>
+DWARFDataExtractorSimple::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;
+}
|
ilovepi
approved these changes
Jun 4, 2025
Contributor
ilovepi
left a comment
ilovepi
left a comment
There was a problem hiding this comment.
LGTM, since this is a straightforward refactoring. You may want to give code owners a chance to chime in before landing though.
Collaborator
|
A more detailed description of the restructuring might be helpful for high level review (though hopefully most of that could be covered on an/the RFC thread, rather than in code review) - specifically the description doesn't mention the addition of virtual dispatch, which seems like a pretty significant change to the way things work. Alternatively this could use some kind of CRTP instead? (& virtual dispatch, plus potentially polymorphic ownership (virtual dtor - by default I'd expect non-polymorphic ownership, using a protected non-virtual dtor, and final derived classes, unless there's an expectation/need for polymorphic ownership, which I'd be a bit surprised by)) |
dwblaikie
approved these changes
Jun 5, 2025
Collaborator
dwblaikie
left a comment
dwblaikie
left a comment
There was a problem hiding this comment.
(I guess one other alternative would be to have a "Resolver" member that's a std::function, then there's only one DWARFDataExtractor and a null resolver V a non-null resolver, perhaps - but I don't know that that's objectively better, and the resolver-builder would have to live in a different header so it didn't introduce the compile-time depnedence you're trying to avoid, which feels a bit awkward, etc)
| Other.getAddressSize()) {} | ||
|
|
||
| virtual ~DWARFDataExtractorSimple() = default; | ||
| ~DWARFDataExtractorBase() {} |
Collaborator
There was a problem hiding this comment.
Remove this since it's the default, probably?
| /// Relocator::getRelocatedValueImpl to relocate values as appropriate. | ||
|
|
||
| class DWARFDataExtractorSimple : public DataExtractor { | ||
| template <class Relocator> class DWARFDataExtractorBase : public DataExtractor { |
Collaborator
There was a problem hiding this comment.
Don't think we have a documented convention, but at least in llvm/include, there's more use of typename in template argument lists than class (at a very dodgy grepping, at least... ) - I'd tend to favor that.
tomtor
pushed a commit
to tomtor/llvm-project
that referenced
this pull request
Jun 14, 2025
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.
llvm-sync bot
pushed a commit
to arm/arm-toolchain
that referenced
this pull request
Jun 24, 2025
This PR is in the direction of separating Unwind table from FDE, and CIE that depends on llvm/Object. To separate, first the runtime dependencies have to be removed, which this commit does that. This is similar to [1](llvm/llvm-project#140096), [2](llvm/llvm-project#139175), and [3](llvm/llvm-project#139326).
DrSergei
pushed a commit
to DrSergei/llvm-project
that referenced
this pull request
Jun 24, 2025
This PR is in the direction of separating Unwind table from FDE, and CIE that depends on llvm/Object. To separate, first the runtime dependencies have to be removed, which this commit does that. This is similar to [1](llvm#140096), [2](llvm#139175), and [3](llvm#139326).
anthonyhatran
pushed a commit
to anthonyhatran/llvm-project
that referenced
this pull request
Jun 26, 2025
This PR is in the direction of separating Unwind table from FDE, and CIE that depends on llvm/Object. To separate, first the runtime dependencies have to be removed, which this commit does that. This is similar to [1](llvm#140096), [2](llvm#139175), and [3](llvm#139326).
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
4 participants
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
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.
Extract most functionality into a new base class, DWARFDataExtractorSimple, and have DWARFDataExtractor add the relocation dependent pieces as overrides. This will allow moving DWARFDataExtractorSimple into a new lower-level, lighter-weight library with fewer external 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.
Although there is no change in functionality, this one is not mechanical like the others, so it is worth a closer look by the reviewers.