Implement indexed values for DWARF 5

examples/dwarfdump.rs

@@ -324,11 +324,8 @@ impl<'a, R: gimli::Reader<Offset = usize>> gimli::Reader for Relocate<'a, R> {
     }
 
     #[inline]
-    fn read_u8_array<A>(&mut self) -> gimli::Result<A>
-    where
-        A: Sized + Default + AsMut<[u8]>,
-    {
-        self.reader.read_u8_array()
+    fn read_slice(&mut self, buf: &mut [u8]) -> gimli::Result<()> {
+        self.reader.read_slice(buf)
     }
 }
 

src/endianity.rs

@@ -57,6 +57,20 @@ pub trait Endianity: Debug + Default + Clone + Copy + PartialEq + Eq {
         }
     }
 
+    /// Read an unsigned n-bytes integer u64.
+    ///
+    /// # Panics
+    ///
+    /// Panics when `buf.len() < 1` or `buf.len() > 8`.
+    #[inline]
+    fn read_uint(&mut self, buf: &[u8]) -> u64 {
+        if self.is_big_endian() {
+            byteorder::BigEndian::read_uint(buf, buf.len())
+        } else {
+            byteorder::LittleEndian::read_uint(buf, buf.len())
+        }
+    }
+
     /// Reads a signed 16 bit integer from `buf`.
     ///
     /// # Panics

src/read/endian_reader.rs

@@ -4,7 +4,6 @@ use borrow::Cow;
 use rc::Rc;
 use stable_deref_trait::CloneStableDeref;
 use std::fmt::Debug;
-use std::mem;
 use std::ops::{Deref, Index, Range, RangeFrom, RangeTo};
 use std::slice;
 use std::str;
@@ -441,15 +440,10 @@ where
     }
 
     #[inline]
-    fn read_u8_array<A>(&mut self) -> Result<A>
-    where
-        A: Sized + Default + AsMut<[u8]>,
-    {
-        let len = mem::size_of::<A>();
-        let slice = self.range.read_slice(len)?;
-        let mut val = Default::default();
-        <A as AsMut<[u8]>>::as_mut(&mut val).clone_from_slice(slice);
-        Ok(val)
+    fn read_slice(&mut self, buf: &mut [u8]) -> Result<()> {
+        let slice = self.range.read_slice(buf.len())?;
+        buf.clone_from_slice(slice);
+        Ok(())
     }
 }
 

src/read/endian_slice.rs

@@ -1,7 +1,6 @@
 //! Working with byte slices that have an associated endianity.
 
 use borrow::Cow;
-use std::mem;
 use std::ops::{Deref, Index, Range, RangeFrom, RangeTo};
 use std::str;
 use string::String;
@@ -286,15 +285,10 @@ where
     }
 
     #[inline]
-    fn read_u8_array<A>(&mut self) -> Result<A>
-    where
-        A: Sized + Default + AsMut<[u8]>,
-    {
-        let len = mem::size_of::<A>();
-        let slice = self.read_slice(len)?;
-        let mut val = Default::default();
-        <A as AsMut<[u8]>>::as_mut(&mut val).clone_from_slice(slice);
-        Ok(val)
+    fn read_slice(&mut self, buf: &mut [u8]) -> Result<()> {
+        let slice = self.read_slice(buf.len())?;
+        buf.clone_from_slice(slice);
+        Ok(())
     }
 }
 

src/read/reader.rs

@@ -261,10 +261,19 @@ pub trait Reader: Debug + Clone {
     /// Does not advance the reader.
     fn to_string_lossy(&self) -> Result<Cow<str>>;
 
+    /// Read a u8 slice.
+    fn read_slice(&mut self, buf: &mut [u8]) -> Result<()>;
+
     /// Read a u8 array.
+    #[inline]
     fn read_u8_array<A>(&mut self) -> Result<A>
     where
-        A: Sized + Default + AsMut<[u8]>;
+        A: Sized + Default + AsMut<[u8]>,
+    {
+        let mut val = Default::default();
+        self.read_slice(<A as AsMut<[u8]>>::as_mut(&mut val))?;
+        Ok(val)
+    }
 
     /// Return true if the number of bytes remaining is zero.
     #[inline]
@@ -342,6 +351,18 @@ pub trait Reader: Debug + Clone {
         Ok(self.endian().read_f64(&a))
     }
 
+    /// Read an unsigned n-bytes integer u64.
+    ///
+    /// # Panics
+    ///
+    /// Panics when nbytes < 1 or nbytes > 8
+    #[inline]
+    fn read_uint(&mut self, n: usize) -> Result<u64> {
+        let mut buf = [0; 8];
+        self.read_slice(&mut buf[..n])?;
+        Ok(self.endian().read_uint(&buf[..n]))
+    }
+
     /// Read a null-terminated slice, and return it (excluding the null).
     fn read_null_terminated_slice(&mut self) -> Result<Self> {
         let idx = self.find(0)?;