Reword read error messages

Try to make errors more concise and consistent, and report
values were possible.

Author: philipc

src/read/dwarf.rs

@@ -1725,7 +1725,7 @@ mod tests {
             Err(e) => {
                 assert_eq!(
                     dwarf.format_error(e),
-                    "Hit the end of input before it was expected at .debug_str+0x1"
+                    "unexpected end of input at .debug_str+0x1"
                 );
             }
         }
@@ -1734,7 +1734,7 @@ mod tests {
             Err(e) => {
                 assert_eq!(
                     dwarf.format_error(e),
-                    "Hit the end of input before it was expected at .debug_str(sup)+0x1"
+                    "unexpected end of input at .debug_str(sup)+0x1"
                 );
             }
         }

src/read/mod.rs

@@ -414,261 +414,183 @@ pub enum Error {
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> ::core::result::Result<(), fmt::Error> {
         match *self {
-            Error::Io => write!(f, "An I/O error occurred while reading."),
+            Error::Io => write!(f, "I/O error"),
             Error::PcRelativePointerButSectionBaseIsUndefined => {
-                write!(
-                    f,
-                    "Found a PC relative pointer, but the section base is undefined."
-                )
+                write!(f, "undefined section base for PC relative pointer")
             }
             Error::TextRelativePointerButTextBaseIsUndefined => {
-                write!(
-                    f,
-                    "Found a `.text` relative pointer, but the `.text` base is undefined."
-                )
+                write!(f, "undefined text base for relative pointer")
             }
             Error::DataRelativePointerButDataBaseIsUndefined => {
-                write!(
-                    f,
-                    "Found a data relative pointer, but the data base is undefined."
-                )
+                write!(f, "undefined data base for relative pointer")
             }
             Error::FuncRelativePointerInBadContext => {
-                write!(
-                    f,
-                    "Found a function relative pointer in a context that does not have a function base."
-                )
+                write!(f, "undefined function base for relative pointer")
             }
             Error::CannotParseOmitPointerEncoding => {
-                write!(f, "Cannot parse a pointer with a `DW_EH_PE_omit` encoding.")
+                write!(f, "invalid pointer encoding: DW_EH_PE_omit")
             }
-            Error::BadUnsignedLeb128 => write!(f, "An error parsing an unsigned LEB128 value"),
-            Error::BadSignedLeb128 => write!(f, "An error parsing a signed LEB128 value"),
+            Error::BadUnsignedLeb128 => write!(f, "unsigned LEB128 overflow"),
+            Error::BadSignedLeb128 => write!(f, "signed LEB128 overflow"),
             Error::AbbreviationTagZero => {
-                write!(
-                    f,
-                    "An abbreviation declared that its tag is zero,
-                 but zero is reserved for null records"
-                )
+                write!(f, "invalid abbreviation tag: zero")
             }
             Error::AttributeNameZero => {
-                write!(
-                    f,
-                    "An attribute specification declared that its name is zero,
-                 but zero is reserved for null records"
-                )
+                write!(f, "invalid attribute name: zero")
             }
             Error::AttributeFormZero => {
-                write!(
-                    f,
-                    "An attribute specification declared that its form is zero,
-                 but zero is reserved for null records"
-                )
+                write!(f, "invalid attribute form: zero")
             }
             Error::BadHasChildren => {
-                write!(
-                    f,
-                    "The abbreviation's has-children byte was not one of
-                 `DW_CHILDREN_{{yes,no}}`"
-                )
+                write!(f, "invalid abbreviation children")
             }
-            Error::UnknownForm(_) => write!(f, "Found an unknown `DW_FORM_*` type"),
+            Error::UnknownForm(val) => write!(f, "unknown attribute form: 0x{:x}", val.0),
             Error::DuplicateAbbreviationCode => {
-                write!(f, "Found an abbreviation code that has already been used")
+                write!(f, "duplicate abbreviation code")
             }
-            Error::UnknownReservedLength => write!(f, "Found an unknown reserved length value"),
-            Error::UnknownVersion(_) => write!(f, "Found an unknown DWARF version"),
-            Error::UnknownAbbreviation(_) => {
-                write!(f, "Found a record with an unknown abbreviation code")
+            Error::UnknownReservedLength => write!(f, "unknown reserved initial length"),
+            Error::UnknownVersion(version) => write!(f, "unknown DWARF version: {version}"),
+            Error::UnknownAbbreviation(val) => {
+                write!(f, "invalid abbreviation code: 0x{val:x}")
             }
-            Error::UnexpectedEof(_) => write!(f, "Hit the end of input before it was expected"),
-            Error::UnknownLocListsEntry(_) => write!(f, "Found an unknown location lists entry"),
-            Error::UnknownRangeListsEntry(_) => write!(f, "Found an unknown range lists entry"),
-            Error::UnsupportedAddressSize(_) => {
-                write!(f, "The specified address size is not supported")
+            Error::UnexpectedEof(_) => write!(f, "unexpected end of input"),
+            Error::UnknownLocListsEntry(val) => {
+                write!(f, "unknown location lists entry: 0x{:x}", val.0)
             }
-            Error::UnsupportedOffsetSize(_) => {
-                write!(f, "The specified offset size is not supported")
+            Error::UnknownRangeListsEntry(val) => {
+                write!(f, "unknown range lists entry: 0x{:x}", val.0)
+            }
+            Error::UnsupportedAddressSize(val) => {
+                write!(f, "unsupported address size: {val}")
+            }
+            Error::UnsupportedOffsetSize(val) => {
+                write!(f, "unsupported offset size: {val}")
             }
             Error::MinimumInstructionLengthZero => {
-                write!(f, "The minimum instruction length must not be zero.")
+                write!(f, "invalid minimum line instruction length: zero")
             }
             Error::MaximumOperationsPerInstructionZero => {
-                write!(
-                    f,
-                    "The maximum operations per instruction must not be zero."
-                )
-            }
-            Error::LineRangeZero => write!(f, "The line range must not be zero."),
-            Error::OpcodeBaseZero => write!(f, "The opcode base must not be zero."),
-            Error::BadUtf8 => write!(f, "Found an invalid UTF-8 string."),
-            Error::NotCieId => write!(f, "Expected to find the CIE ID, but found something else."),
+                write!(f, "invalid maximum operations per line instruction: zero")
+            }
+            Error::LineRangeZero => write!(f, "invalid line range: zero"),
+            Error::OpcodeBaseZero => write!(f, "invalid line opcode base: zero"),
+            Error::BadUtf8 => write!(f, "invalid UTF-8"),
+            Error::NotCieId => write!(f, "no CIE at offset"),
             Error::NotFdePointer => {
-                write!(
-                    f,
-                    "Expected to find an FDE pointer, but found a CIE pointer instead."
-                )
+                write!(f, "no FDE at offset")
             }
-            Error::BadBranchTarget(_) => write!(f, "Invalid branch target in DWARF expression"),
+            Error::BadBranchTarget(_) => write!(f, "invalid expression branch target"),
             Error::InvalidPushObjectAddress => {
-                write!(
-                    f,
-                    "DW_OP_push_object_address used but no object address given"
-                )
+                write!(f, "undefined object address")
             }
             Error::NotEnoughStackItems => {
-                write!(f, "Not enough items on stack when evaluating expression")
+                write!(f, "expression stack underflow")
             }
             Error::TooManyIterations => {
-                write!(f, "Too many iterations to evaluate DWARF expression")
+                write!(f, "exceeded maximum expression iterations")
             }
-            Error::InvalidExpression(_) => write!(f, "Invalid opcode in DWARF expression"),
+            Error::InvalidExpression(val) => write!(f, "unknown expression opcode: 0x{:x}", val.0),
             Error::UnsupportedEvaluation => {
-                write!(f, "Unsupported operation when evaluating expression")
+                write!(f, "unsupported evaluation operation")
             }
             Error::InvalidPiece => {
-                write!(
-                    f,
-                    "DWARF expression has piece followed by non-piece expression at end"
-                )
+                write!(f, "missing expression piece terminator")
             }
             Error::InvalidExpressionTerminator(_) => {
-                write!(f, "Expected DW_OP_piece or DW_OP_bit_piece")
+                write!(f, "invalid expression piece terminator")
             }
             Error::DivisionByZero => {
-                write!(f, "Division or modulus by zero when evaluating expression")
+                write!(f, "division by zero")
             }
-            Error::TypeMismatch => write!(f, "Type mismatch when evaluating expression"),
+            Error::TypeMismatch => write!(f, "invalid operand type: mismatch"),
             Error::IntegralTypeRequired => {
-                write!(f, "Integral type expected when evaluating expression")
+                write!(f, "invalid operand type: integral required")
             }
             Error::UnsupportedTypeOperation => {
-                write!(
-                    f,
-                    "An expression operation used types that are not supported"
-                )
+                write!(f, "unsupported operand type")
             }
             Error::InvalidShiftExpression => {
-                write!(
-                    f,
-                    "The shift value in an expression must be a non-negative integer."
-                )
-            }
-            Error::InvalidDerefSize(_) => {
-                write!(
-                    f,
-                    "The size of a deref expression must not be larger than the size of an address."
-                )
-            }
-            Error::UnknownCallFrameInstruction(_) => write!(f, "An unknown DW_CFA_* instruction"),
+                write!(f, "invalid shift length")
+            }
+            Error::InvalidDerefSize(val) => {
+                write!(f, "invalid deref size: {val}")
+            }
+            Error::UnknownCallFrameInstruction(val) => {
+                write!(f, "unknown call frame instruction: 0x{:x}", val.0)
+            }
             Error::InvalidAddressRange => {
-                write!(
-                    f,
-                    "The end of an address range must not be before the beginning."
-                )
+                write!(f, "invalid call frame instruction address")
             }
-            Error::AddressOverflow => write!(f, "An address calculation overflowed."),
+            Error::AddressOverflow => write!(f, "address overflow"),
             Error::CfiInstructionInInvalidContext => {
-                write!(
-                    f,
-                    "Encountered a call frame instruction in a context in which it is not valid."
-                )
+                write!(f, "invalid context for call frame instruction")
             }
             Error::PopWithEmptyStack => {
-                write!(
-                    f,
-                    "When evaluating call frame instructions, found a `DW_CFA_restore_state` stack pop \
-                 instruction, but the stack was empty, and had nothing to pop."
-                )
+                write!(f, "call frame stack underflow")
             }
             Error::NoUnwindInfoForAddress => {
-                write!(f, "Do not have unwind info for the given address.")
+                write!(f, "no unwind info")
             }
             Error::UnsupportedOffset => {
-                write!(
-                    f,
-                    "An offset value was larger than the maximum supported value."
-                )
-            }
-            Error::UnknownPointerEncoding(_) => {
-                write!(
-                    f,
-                    "The given pointer encoding is either unknown or invalid."
-                )
-            }
-            Error::NoEntryAtGivenOffset => write!(f, "Did not find an entry at the given offset."),
-            Error::OffsetOutOfBounds => write!(f, "The given offset is out of bounds."),
-            Error::UnknownAugmentation => write!(f, "Found an unknown CFI augmentation."),
+                write!(f, "offset overflow")
+            }
+            Error::UnknownPointerEncoding(val) => {
+                write!(f, "unknown pointer encoding: 0x{:x}", val.0)
+            }
+            Error::NoEntryAtGivenOffset => write!(f, "no entry at offset"),
+            Error::OffsetOutOfBounds => write!(f, "invalid offset"),
+            Error::UnknownAugmentation => write!(f, "unknown CFI augmentation"),
             Error::UnsupportedPointerEncoding => {
-                write!(f, "We do not support the given pointer encoding yet.")
+                write!(f, "unsupported pointer encoding")
             }
-            Error::UnsupportedRegister(_) => {
-                write!(f, "Registers larger than `u16` are not supported.")
+            Error::UnsupportedRegister(val) => {
+                write!(f, "unsupported register: 0x{val:x}")
             }
             Error::TooManyRegisterRules => {
-                write!(
-                    f,
-                    "The CFI program defined more register rules than we have storage for."
-                )
+                write!(f, "too many CFI register rules")
             }
             Error::StackFull => {
-                write!(
-                    f,
-                    "Attempted to push onto the CFI stack, but it was already at full capacity."
-                )
+                write!(f, "CFI stack overflow")
             }
             Error::VariableLengthSearchTable => {
-                write!(
-                    f,
-                    "The `.eh_frame_hdr` binary search table claims to be variable-length encoded, \
-                 which makes binary search impossible."
-                )
+                write!(f, "invalid pointer encoding for search")
             }
             Error::UnsupportedUnitType => {
-                write!(f, "The `DW_UT_*` value for this unit is not supported yet")
+                write!(f, "unknown unit type")
             }
-            Error::UnsupportedSegmentSize => write!(f, "Nonzero segment size not supported yet"),
+            Error::UnsupportedSegmentSize => write!(f, "unsupported segment size"),
             Error::MissingUnitDie => {
-                write!(
-                    f,
-                    "A compilation unit or type unit is missing its top level DIE."
-                )
+                write!(f, "missing root DIE")
             }
             Error::MissingSplitUnit => {
-                write!(
-                    f,
-                    "A split DWARF section does not contain the split compilation unit."
-                )
+                write!(f, "missing split unit")
             }
             Error::UnsupportedAttributeForm => {
-                write!(f, "A DIE attribute used an unsupported form.")
+                write!(f, "unsupported attribute form")
             }
             Error::MissingFileEntryFormatPath => {
-                write!(f, "Missing DW_LNCT_path in file entry format.")
+                write!(f, "missing file entry format path")
             }
             Error::ExpectedStringAttributeValue => {
-                write!(f, "Expected an attribute value to be a string form.")
+                write!(f, "unsupported string attribute form")
             }
             Error::InvalidImplicitConst => {
-                write!(f, "DW_FORM_implicit_const used in an invalid context.")
+                write!(f, "invalid implicit const form")
             }
-            Error::InvalidIndexSectionCount => write!(f, "Invalid section count in `.dwp` index."),
-            Error::InvalidIndexSlotCount => write!(f, "Invalid slot count in `.dwp` index."),
-            Error::InvalidIndexRow => write!(f, "Invalid hash row in `.dwp` index."),
-            Error::UnknownIndexSection(_) => write!(f, "Unknown section type in `.dwp` index."),
-            Error::UnknownIndexSectionV2(_) => {
-                write!(f, "Unknown section type in version 2 `.dwp` index.")
+            Error::InvalidIndexSectionCount => write!(f, "unsupported DWP section count"),
+            Error::InvalidIndexSlotCount => write!(f, "invalid DWP slot count"),
+            Error::InvalidIndexRow => write!(f, "invalid DWP unit index"),
+            Error::UnknownIndexSection(val) => write!(f, "unknown DWP section type: 0x{:x}", val.0),
+            Error::UnknownIndexSectionV2(val) => {
+                write!(f, "unknown DWP v2 section type: 0x{:x}", val.0)
             }
-            Error::InvalidMacinfoType(_) => write!(f, "Invalid macinfo type in `.debug_macinfo`."),
-            Error::InvalidMacroType(_) => write!(f, "Invalid macro type in `.debug_macro`."),
+            Error::InvalidMacinfoType(val) => write!(f, "unknown macinfo type: 0x{:x}", val.0),
+            Error::InvalidMacroType(val) => write!(f, "unknown macro type: 0x{:x}", val.0),
             Error::UnsupportedOpcodeOperandsTable => {
-                write!(
-                    f,
-                    "The optional `opcode_operands_table` in `.debug_macro` is currently not supported."
-                )
+                write!(f, "unsupported macro opcode operands table")
             }
-            Error::InvalidNameAttributeIndex(_) => {
-                write!(f, "Invalid index in a `.debug_names` attribute value.")
+            Error::InvalidNameAttributeIndex(val) => {
+                write!(f, "invalid index in name attribute: 0x{val:x}")
             }
         }
     }