read/elf: small fixes to low level API (#685)

Implement Default for SectionTable and RelocationSections.
Return a SectionIndex from SectionTable::section_by_name.
Add some helpers to Sym trait.

Author: philipc

src/read/elf/file.rs

@@ -147,7 +147,7 @@ where
             .section_by_name(self.endian, section_name)
             .map(|(index, section)| ElfSection {
                 file: self,
-                index: SectionIndex(index),
+                index,
                 section,
             })
     }

src/read/elf/relocation.rs

@@ -14,7 +14,7 @@ use crate::read::{
 use super::{ElfFile, FileHeader, SectionHeader, SectionTable};
 
 /// A mapping from section index to associated relocation sections.
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct RelocationSections {
     relocations: Vec<usize>,
 }

src/read/elf/section.rs

@@ -20,7 +20,7 @@ use super::{
 /// Also includes the string table used for the section names.
 ///
 /// Returned by [`FileHeader::sections`].
-#[derive(Debug, Default, Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub struct SectionTable<'data, Elf: FileHeader, R = &'data [u8]>
 where
     R: ReadRef<'data>,
@@ -29,6 +29,15 @@ where
     strings: StringTable<'data, R>,
 }
 
+impl<'data, Elf: FileHeader, R: ReadRef<'data>> Default for SectionTable<'data, Elf, R> {
+    fn default() -> Self {
+        SectionTable {
+            sections: &[],
+            strings: StringTable::default(),
+        }
+    }
+}
+
 impl<'data, Elf: FileHeader, R: ReadRef<'data>> SectionTable<'data, Elf, R> {
     /// Create a new section table.
     #[inline]
@@ -86,10 +95,8 @@ impl<'data, Elf: FileHeader, R: ReadRef<'data>> SectionTable<'data, Elf, R> {
         &self,
         endian: Elf::Endian,
         name: &[u8],
-    ) -> Option<(usize, &'data Elf::SectionHeader)> {
-        self.sections
-            .iter()
-            .enumerate()
+    ) -> Option<(SectionIndex, &'data Elf::SectionHeader)> {
+        self.enumerate()
             .find(|(_, section)| self.section_name(endian, section) == Ok(name))
     }
 
@@ -133,16 +140,12 @@ impl<'data, Elf: FileHeader, R: ReadRef<'data>> SectionTable<'data, Elf, R> {
     ) -> read::Result<SymbolTable<'data, Elf, R>> {
         debug_assert!(sh_type == elf::SHT_DYNSYM || sh_type == elf::SHT_SYMTAB);
 
-        let (index, section) = match self
-            .iter()
-            .enumerate()
-            .find(|s| s.1.sh_type(endian) == sh_type)
-        {
+        let (index, section) = match self.enumerate().find(|s| s.1.sh_type(endian) == sh_type) {
             Some(s) => s,
             None => return Ok(SymbolTable::default()),
         };
 
-        SymbolTable::parse(endian, data, self, SectionIndex(index), section)
+        SymbolTable::parse(endian, data, self, index, section)
     }
 
     /// Return the symbol table at the given section index.

src/read/elf/symbol.rs

@@ -69,9 +69,9 @@ impl<'data, Elf: FileHeader, R: ReadRef<'data>> SymbolTable<'data, Elf, R> {
 
         let mut shndx_section = SectionIndex(0);
         let mut shndx = &[][..];
-        for (i, s) in sections.iter().enumerate() {
+        for (i, s) in sections.enumerate() {
             if s.sh_type(endian) == elf::SHT_SYMTAB_SHNDX && s.link(endian) == section_index {
-                shndx_section = SectionIndex(i);
+                shndx_section = i;
                 shndx = s
                     .data_as_array(endian, data)
                     .read_error("Invalid ELF symtab_shndx data")?;
@@ -431,7 +431,7 @@ impl<'data, 'file, Elf: FileHeader, R: ReadRef<'data>> ObjectSymbol<'data>
 
     #[inline]
     fn is_undefined(&self) -> bool {
-        self.symbol.st_shndx(self.endian) == elf::SHN_UNDEF
+        self.symbol.is_undefined(self.endian)
     }
 
     #[inline]
@@ -441,12 +441,12 @@ impl<'data, 'file, Elf: FileHeader, R: ReadRef<'data>> ObjectSymbol<'data>
 
     #[inline]
     fn is_common(&self) -> bool {
-        self.symbol.st_shndx(self.endian) == elf::SHN_COMMON
+        self.symbol.is_common(self.endian)
     }
 
     #[inline]
     fn is_weak(&self) -> bool {
-        self.symbol.st_bind() == elf::STB_WEAK
+        self.symbol.is_weak()
     }
 
     fn scope(&self) -> SymbolScope {
@@ -469,12 +469,12 @@ impl<'data, 'file, Elf: FileHeader, R: ReadRef<'data>> ObjectSymbol<'data>
 
     #[inline]
     fn is_global(&self) -> bool {
-        self.symbol.st_bind() != elf::STB_LOCAL
+        !self.symbol.is_local()
     }
 
     #[inline]
     fn is_local(&self) -> bool {
-        self.symbol.st_bind() == elf::STB_LOCAL
+        self.symbol.is_local()
     }
 
     #[inline]
@@ -513,7 +513,7 @@ pub trait Sym: Debug + Pod {
             .read_error("Invalid ELF symbol name offset")
     }
 
-    /// Return true if the symbol is undefined.
+    /// Return true if the symbol section is `SHN_UNDEF`.
     #[inline]
     fn is_undefined(&self, endian: Self::Endian) -> bool {
         self.st_shndx(endian) == elf::SHN_UNDEF
@@ -531,6 +531,26 @@ pub trait Sym: Debug + Pod {
             _ => false,
         }
     }
+
+    /// Return true if the symbol section is `SHN_COMMON`.
+    fn is_common(&self, endian: Self::Endian) -> bool {
+        self.st_shndx(endian) == elf::SHN_COMMON
+    }
+
+    /// Return true if the symbol section is `SHN_ABS`.
+    fn is_absolute(&self, endian: Self::Endian) -> bool {
+        self.st_shndx(endian) == elf::SHN_ABS
+    }
+
+    /// Return true if the symbol binding is `STB_LOCAL`.
+    fn is_local(&self) -> bool {
+        self.st_bind() == elf::STB_LOCAL
+    }
+
+    /// Return true if the symbol binding is `STB_WEAK`.
+    fn is_weak(&self) -> bool {
+        self.st_bind() == elf::STB_WEAK
+    }
 }
 
 impl<Endian: endian::Endian> Sym for elf::Sym32<Endian> {