Include more values in validation errors

Author: philipc

src/read/abbrev.rs

@@ -267,8 +267,9 @@ impl Abbreviations {
         let mut abbrevs = Abbreviations::empty();
 
         while let Some(abbrev) = Abbreviation::parse(input)? {
+            let code = abbrev.code;
             if abbrevs.insert(abbrev).is_err() {
-                return Err(Error::DuplicateAbbreviationCode);
+                return Err(Error::DuplicateAbbreviationCode(code));
             }
         }
 
@@ -348,7 +349,7 @@ impl Abbreviation {
         if val == constants::DW_CHILDREN_no || val == constants::DW_CHILDREN_yes {
             Ok(val)
         } else {
-            Err(Error::BadHasChildren)
+            Err(Error::InvalidAbbreviationChildren(val))
         }
     }
 
@@ -894,7 +895,7 @@ pub(crate) mod tests {
         let buf = &mut EndianSlice::new(&buf, LittleEndian);
 
         match Abbreviations::parse(buf) {
-            Err(Error::DuplicateAbbreviationCode) => {}
+            Err(Error::DuplicateAbbreviationCode(1)) => {}
             otherwise => panic!("Unexpected result: {:?}", otherwise),
         };
     }
@@ -927,7 +928,7 @@ pub(crate) mod tests {
         let val = Abbreviation::parse_has_children(rest).expect("Should parse children");
         assert_eq!(val, constants::DW_CHILDREN_yes);
         match Abbreviation::parse_has_children(rest) {
-            Err(Error::BadHasChildren) => {}
+            Err(Error::InvalidAbbreviationChildren(_)) => {}
             otherwise => panic!("Unexpected result: {:?}", otherwise),
         };
     }

src/read/addr.rs

@@ -156,7 +156,7 @@ where
         let address_size = rest.read_address_size()?;
         let segment_size = rest.read_u8()?;
         if segment_size != 0 {
-            return Err(Error::UnsupportedSegmentSize);
+            return Err(Error::UnsupportedSegmentSize(segment_size));
         }
 
         // unit_length + version + address_size + segment_size

src/read/aranges.rs

@@ -170,7 +170,7 @@ where
         let address_size = rest.read_address_size()?;
         let segment_size = rest.read_u8()?;
         if segment_size != 0 {
-            return Err(Error::UnsupportedSegmentSize);
+            return Err(Error::UnsupportedSegmentSize(segment_size));
         }
 
         // unit_length + version + offset + address_size + segment_size

src/read/cfi.rs

@@ -656,7 +656,7 @@ pub trait UnwindSection<R: Reader>: Clone + Debug + _UnwindSectionPrivate<R> {
         let offset = UnwindOffset::into(offset);
         let input = &mut self.section().clone();
         input.skip(offset)?;
-        CommonInformationEntry::parse(bases, self, input)
+        CommonInformationEntry::parse(bases, self, input, offset)
     }
 
     /// Parse the `PartialFrameDescriptionEntry` at the given offset.
@@ -668,7 +668,7 @@ pub trait UnwindSection<R: Reader>: Clone + Debug + _UnwindSectionPrivate<R> {
         let offset = UnwindOffset::into(offset);
         let input = &mut self.section().clone();
         input.skip(offset)?;
-        PartialFrameDescriptionEntry::parse_partial(self, bases, input)
+        PartialFrameDescriptionEntry::parse_partial(self, bases, input, offset)
     }
 
     /// Parse the `FrameDescriptionEntry` at the given offset.
@@ -1103,7 +1103,7 @@ where
     } else {
         let cie_offset = R::Offset::from_u64(cie_id_or_offset)?;
         let cie_offset = match section.resolve_cie_offset(cie_offset_base, cie_offset) {
-            None => return Err(Error::OffsetOutOfBounds),
+            None => return Err(Error::OffsetOutOfBounds(cie_id_or_offset)),
             Some(cie_offset) => cie_offset,
         };
 
@@ -1316,11 +1316,12 @@ impl<R: Reader> CommonInformationEntry<R> {
         bases: &BaseAddresses,
         section: &Section,
         input: &mut R,
+        offset: R::Offset,
     ) -> Result<CommonInformationEntry<R>> {
         match parse_cfi_entry(bases, section, input)? {
             Some(CieOrFde::Cie(cie)) => Ok(cie),
-            Some(CieOrFde::Fde(_)) => Err(Error::NotCieId),
-            None => Err(Error::NoEntryAtGivenOffset),
+            Some(CieOrFde::Fde(_)) => Err(Error::NotCieId(offset.into_u64())),
+            None => Err(Error::NoEntryAtGivenOffset(offset.into_u64())),
         }
     }
 
@@ -1348,7 +1349,7 @@ impl<R: Reader> CommonInformationEntry<R> {
             let address_size = rest.read_address_size()?;
             let segment_size = rest.read_u8()?;
             if segment_size != 0 {
-                return Err(Error::UnsupportedSegmentSize);
+                return Err(Error::UnsupportedSegmentSize(segment_size));
             }
             address_size
         } else {
@@ -1543,11 +1544,12 @@ where
         section: &Section,
         bases: &'bases BaseAddresses,
         input: &mut R,
+        offset: R::Offset,
     ) -> Result<PartialFrameDescriptionEntry<'bases, Section, R>> {
         match parse_cfi_entry(bases, section, input)? {
-            Some(CieOrFde::Cie(_)) => Err(Error::NotFdePointer),
+            Some(CieOrFde::Cie(_)) => Err(Error::NotFdePointer(offset.into_u64())),
             Some(CieOrFde::Fde(partial)) => Ok(partial),
-            None => Err(Error::NoEntryAtGivenOffset),
+            None => Err(Error::NoEntryAtGivenOffset(offset.into_u64())),
         }
     }
 
@@ -3780,7 +3782,7 @@ mod tests {
         let bases = Default::default();
         match parse_cfi_entry(&bases, &section, input) {
             Ok(Some(CieOrFde::Fde(partial))) => partial.parse(get_cie),
-            Ok(_) => Err(Error::NoEntryAtGivenOffset),
+            Ok(_) => Err(Error::NoEntryAtGivenOffset(0)),
             Err(e) => Err(e),
         }
     }
@@ -3984,7 +3986,7 @@ mod tests {
         debug_frame.set_address_size(address_size);
         let input = &mut EndianSlice::new(&section, E::default());
         let bases = Default::default();
-        let result = CommonInformationEntry::parse(&bases, &debug_frame, input);
+        let result = CommonInformationEntry::parse(&bases, &debug_frame, input, 0);
         let result = result.map(|cie| (*input, cie)).map_eof(&section);
         assert_eq!(result, expected);
     }
@@ -4038,7 +4040,7 @@ mod tests {
             .B32(4)
             // Not the CIE Id.
             .B32(0xbad1_bad2);
-        assert_parse_cie(kind, section, 8, Err(Error::NotCieId));
+        assert_parse_cie(kind, section, 8, Err(Error::NotCieId(0)));
     }
 
     #[test]
@@ -4179,7 +4181,8 @@ mod tests {
             CommonInformationEntry::parse(
                 &bases,
                 &debug_frame,
-                &mut EndianSlice::new(&contents, LittleEndian)
+                &mut EndianSlice::new(&contents, LittleEndian),
+                0,
             )
             .map_eof(&contents),
             Err(Error::UnexpectedEof(ReaderOffsetId(4)))
@@ -6691,7 +6694,7 @@ mod tests {
 
         assert_eq!(
             eh_frame.cie_from_offset(&bases, EhFrameOffset(0)),
-            Err(Error::NoEntryAtGivenOffset)
+            Err(Error::NoEntryAtGivenOffset(0))
         );
     }
 
@@ -6713,7 +6716,7 @@ mod tests {
 
         assert_eq!(
             debug_frame.cie_from_offset(&bases, DebugFrameOffset(0)),
-            Err(Error::NoEntryAtGivenOffset)
+            Err(Error::NoEntryAtGivenOffset(0))
         );
     }
 
@@ -6763,7 +6766,7 @@ mod tests {
         let buf = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
         assert_eq!(
             resolve_cie_offset(&buf, buf.len() + 4 + 2),
-            Err(Error::OffsetOutOfBounds)
+            Err(Error::OffsetOutOfBounds(buf.len() as u64 + 4 + 2))
         );
     }
 
@@ -6772,7 +6775,7 @@ mod tests {
         let buf = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
         assert_eq!(
             resolve_cie_offset(&buf, usize::MAX),
-            Err(Error::OffsetOutOfBounds)
+            Err(Error::OffsetOutOfBounds(u32::MAX as u64))
         );
     }
 
@@ -6853,7 +6856,7 @@ mod tests {
         let section = Section::with_endian(kind.endian())
             .cie(kind, None, &mut cie)
             .mark(&end_of_cie)
-            .fde(kind, 99_999_999_999_999, &mut fde);
+            .fde(kind, 99_999_999, &mut fde);
 
         section.start().set_const(0);
         let section = section.get_contents().unwrap();
@@ -6865,7 +6868,7 @@ mod tests {
             &mut section.range_from(end_of_cie.value().unwrap() as usize..),
             UnwindSection::cie_from_offset,
         );
-        assert_eq!(result, Err(Error::OffsetOutOfBounds));
+        assert_eq!(result, Err(Error::OffsetOutOfBounds(99_999_999)));
     }
 
     #[test]

src/read/index.rs

@@ -167,15 +167,15 @@ impl<R: Reader> UnitIndex<R> {
         let unit_count = input.read_u32()?;
         let slot_count = input.read_u32()?;
         if slot_count != 0 && (slot_count & (slot_count - 1) != 0 || slot_count <= unit_count) {
-            return Err(Error::InvalidIndexSlotCount);
+            return Err(Error::InvalidIndexSlotCount(slot_count));
         }
 
         let hash_ids = input.split(R::Offset::from_u64(u64::from(slot_count) * 8)?)?;
         let hash_rows = input.split(R::Offset::from_u64(u64::from(slot_count) * 4)?)?;
 
         let mut sections = [IndexSectionId::DebugAbbrev; SECTION_COUNT_MAX as usize];
         if section_count > SECTION_COUNT_MAX.into() {
-            return Err(Error::InvalidIndexSectionCount);
+            return Err(Error::UnsupportedIndexSectionCount(section_count));
         }
         for i in 0..section_count {
             let section = input.read_u32()?;
@@ -258,11 +258,11 @@ impl<R: Reader> UnitIndex<R> {
     /// Return the section offsets and sizes for the given row index.
     pub fn sections(&self, mut row: u32) -> Result<UnitIndexSectionIterator<'_, R>> {
         if row == 0 {
-            return Err(Error::InvalidIndexRow);
+            return Err(Error::InvalidIndexRow(row));
         }
         row -= 1;
         if row >= self.unit_count {
-            return Err(Error::InvalidIndexRow);
+            return Err(Error::InvalidIndexRow(row));
         }
         let mut offsets = self.offsets.clone();
         offsets.skip(R::Offset::from_u64(

src/read/line.rs

@@ -1246,7 +1246,7 @@ where
             address_size = rest.read_address_size()?;
             let segment_selector_size = rest.read_u8()?;
             if segment_selector_size != 0 {
-                return Err(Error::UnsupportedSegmentSize);
+                return Err(Error::UnsupportedSegmentSize(segment_selector_size));
             }
         }
 

src/read/lists.rs

@@ -52,7 +52,7 @@ fn parse_header<R: Reader>(input: &mut R) -> Result<ListsHeader> {
     let address_size = input.read_address_size()?;
     let segment_selector_size = input.read_u8()?;
     if segment_selector_size != 0 {
-        return Err(Error::UnsupportedSegmentSize);
+        return Err(Error::UnsupportedSegmentSize(segment_selector_size));
     }
     let offset_entry_count = input.read_u32()?;