/// TODO: refactor compile_units() to make this const.
uint8_t getCUAddrSize();
+ /// Dump Error as warning message to stderr.
+ static void dumpWarning(Error Warning);
+
private:
/// Return the compile unit which contains instruction with provided
/// address.
void clear();
/// Parse prologue and all rows.
- Error parse(DWARFDataExtractor &DebugLineData, uint32_t *OffsetPtr,
- const DWARFContext &Ctx, const DWARFUnit *U,
- std::function<void(Error)> RecoverableErrorCallback = warn,
- raw_ostream *OS = nullptr);
+ Error parse(
+ DWARFDataExtractor &DebugLineData, uint32_t *OffsetPtr,
+ const DWARFContext &Ctx, const DWARFUnit *U,
+ std::function<void(Error)> RecoverableErrorCallback,
+ raw_ostream *OS = nullptr);
using RowVector = std::vector<Row>;
using RowIter = RowVector::const_iterator;
Expected<const LineTable *> getOrParseLineTable(
DWARFDataExtractor &DebugLineData, uint32_t Offset,
const DWARFContext &Ctx, const DWARFUnit *U,
- std::function<void(Error)> RecoverableErrorCallback = warn);
+ std::function<void(Error)> RecoverableErrorCallback);
/// Helper to allow for parsing of an entire .debug_line section in sequence.
class SectionParser {
/// \param OS - if not null, the parser will print information about the
/// table as it parses it.
LineTable
- parseNext(function_ref<void(Error)> RecoverableErrorCallback = warn,
- function_ref<void(Error)> UnrecoverableErrorCallback = warn,
- raw_ostream *OS = nullptr);
+ parseNext(
+ function_ref<void(Error)> RecoverableErrorCallback,
+ function_ref<void(Error)> UnrecoverableErrorCallback,
+ raw_ostream *OS = nullptr);
/// Skip the current line table and go to the following line table (if
/// present) immediately.
///
/// \param ErrorCallback - report any prologue parsing issues via this
/// callback.
- void skip(function_ref<void(Error)> ErrorCallback = warn);
+ void skip(function_ref<void(Error)> ErrorCallback);
/// Indicates if the parser has parsed as much as possible.
///
bool Done = false;
};
- /// Helper function for DWARFDebugLine parse functions, to report issues
- /// identified during parsing.
- ///
- /// \param Err The Error to report.
- static void warn(Error Err);
-
private:
struct ParsingState {
ParsingState(struct LineTable *LT);
static void dumpAddrSection(raw_ostream &OS, DWARFDataExtractor &AddrData,
DIDumpOptions DumpOpts, uint16_t Version,
uint8_t AddrSize) {
- // TODO: Make this more general: add callback types to Error.h, create
- // implementation and make all DWARF classes use them.
- static auto WarnCallback = [](Error Warn) {
- handleAllErrors(std::move(Warn), [](ErrorInfoBase &Info) {
- WithColor::warning() << Info.message() << '\n';
- });
- };
uint32_t Offset = 0;
while (AddrData.isValidOffset(Offset)) {
DWARFDebugAddrTable AddrTable;
uint32_t TableOffset = Offset;
- if (Error Err = AddrTable.extract(AddrData, &Offset, Version,
- AddrSize, WarnCallback)) {
+ if (Error Err = AddrTable.extract(AddrData, &Offset, Version, AddrSize,
+ DWARFContext::dumpWarning)) {
WithColor::error() << toString(std::move(Err)) << '\n';
// Keep going after an error, if we can, assuming that the length field
// could be read. If it couldn't, stop reading the section.
DIDumpOptions DumpOpts) {
while (!Parser.done()) {
if (DumpOffset && Parser.getOffset() != *DumpOffset) {
- Parser.skip();
+ Parser.skip(dumpWarning);
continue;
}
OS << "debug_line[" << format("0x%8.8x", Parser.getOffset()) << "]\n";
if (DumpOpts.Verbose) {
- Parser.parseNext(DWARFDebugLine::warn, DWARFDebugLine::warn, &OS);
+ Parser.parseNext(dumpWarning, dumpWarning, &OS);
} else {
- DWARFDebugLine::LineTable LineTable = Parser.parseNext();
+ DWARFDebugLine::LineTable LineTable =
+ Parser.parseNext(dumpWarning, dumpWarning);
LineTable.dump(OS, DumpOpts);
}
}
const DWARFDebugLine::LineTable *
DWARFContext::getLineTableForUnit(DWARFUnit *U) {
Expected<const DWARFDebugLine::LineTable *> ExpectedLineTable =
- getLineTableForUnit(U, DWARFDebugLine::warn);
+ getLineTableForUnit(U, dumpWarning);
if (!ExpectedLineTable) {
- DWARFDebugLine::warn(ExpectedLineTable.takeError());
+ dumpWarning(ExpectedLineTable.takeError());
return nullptr;
}
return *ExpectedLineTable;
}
return Addr;
}
+
+void DWARFContext::dumpWarning(Error Warning) {
+ handleAllErrors(std::move(Warning), [](ErrorInfoBase &Info) {
+ WithColor::warning() << Info.message() << '\n';
+ });
+}
Done = true;
}
}
-
-void DWARFDebugLine::warn(Error Err) {
- handleAllErrors(std::move(Err), [](ErrorInfoBase &Info) {
- WithColor::warning() << Info.message() << '\n';
- });
-}
OrigDwarf.isLittleEndian(), Unit.getOrigUnit().getAddressByteSize());
Error Err = LineTable.parse(LineExtractor, &StmtOffset, OrigDwarf,
- &Unit.getOrigUnit());
- DWARFDebugLine::warn(std::move(Err));
+ &Unit.getOrigUnit(), DWARFContext::dumpWarning);
+ DWARFContext::dumpWarning(std::move(Err));
// This vector is the output line table.
std::vector<DWARFDebugLine::Row> NewRows;