android/vendor/goblin-0.8.0/src/elf/symver.rs - toolchain/cargo-deny - Git at Google

 //! Symbol versioning
 //!
 //! Implementation of the GNU symbol versioning extension according to
 //! [LSB Core Specification - Symbol Versioning][lsb-symver].
 //!
 //! # Examples
 //!
 //! List the dependencies of an ELF file that have [version needed][lsb-verneed] information along
 //! with the versions needed for each dependency.
 //! ```rust
 //! use goblin::error::Error;
 //!
 //! pub fn show_verneed(bytes: &[u8]) -> Result<(), Error> {
 //!     let binary = goblin::elf::Elf::parse(&bytes)?;
 //!
 //!     if let Some(verneed) = binary.verneed {
 //!         for need_file in verneed.iter() {
 //!             println!(
 //!                 "Depend on {:?} with version(s):",
 //!                 binary.dynstrtab.get_at(need_file.vn_file)
 //!             );
 //!             for need_ver in need_file.iter() {
 //!                 println!("{:?}", binary.dynstrtab.get_at(need_ver.vna_name));
 //!             }
 //!         }
 //!     }
 //!
 //!     Ok(())
 //! }
 //! ```
 //!
 //! List the [version defined][lsb-verdef] information of an ELF file, effectively listing the version
 //! defined by this ELF file.
 //! ```rust
 //! use goblin::error::Error;
 //!
 //! pub fn show_verdef(bytes: &[u8]) -> Result<(), Error> {
 //!     let binary = goblin::elf::Elf::parse(&bytes)?;
 //!
 //!     if let Some(verdef) = &binary.verdef {
 //!         for def in verdef.iter() {
 //!             for (n, aux) in def.iter().enumerate() {
 //!                 let name = binary.dynstrtab.get_at(aux.vda_name);
 //!                 match n {
 //!                     0 => print!("Name: {:?}", name),
 //!                     1 => print!(" Parent: {:?}", name),
 //!                     _ => print!(", {:?}", name),
 //!                 }
 //!             }
 //!             print!("\n");
 //!         }
 //!     }
 //!
 //!     Ok(())
 //! }
 //! ```
 //!
 //! [lsb-symver]: https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html
 //! [lsb-verneed]: https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#SYMVERRQMTS
 //! [lsb-verdef]: https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#SYMVERDEFS

 use crate::container;
 use crate::elf::section_header::{SectionHeader, SHT_GNU_VERDEF, SHT_GNU_VERNEED, SHT_GNU_VERSYM};
 use crate::error::Result;
 use core::iter::FusedIterator;
 use scroll::Pread;

 /******************
  *  ELF Constants *
  ******************/

 // Versym constants.

 /// Constant describing a local symbol, see [`Versym::is_local`].
 pub const VER_NDX_LOCAL: u16 = 0;
 /// Constant describing a global symbol, see [`Versym::is_global`].
 pub const VER_NDX_GLOBAL: u16 = 1;
 /// Bitmask to check hidden bit, see [`Versym::is_hidden`].
 pub const VERSYM_HIDDEN: u16 = 0x8000;
 /// Bitmask to get version information, see [`Versym::version`].
 pub const VERSYM_VERSION: u16 = 0x7fff;

 // Verdef constants.

 /// Bitmask to check `base` flag in [`Verdef::vd_flags`].
 pub const VER_FLG_BASE: u16 = 0x1;
 /// Bitmask to check `weak` flag in [`Verdef::vd_flags`].
 pub const VER_FLG_WEAK: u16 = 0x2;
 /// Bitmask to check `info` flag in [`Verdef::vd_flags`].
 pub const VER_FLG_INFO: u16 = 0x4;

 /********************
  *  ELF Structures  *
  ********************/

 /// An ELF `Symbol Version` entry.
 ///
 /// https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#SYMVERTBL
 #[repr(C)]
 #[derive(Debug, Pread)]
 struct ElfVersym {
     vs_val: u16,
 }

 /// An ELF `Version Definition` entry Elfxx_Verdef.
 ///
 /// https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#VERDEFENTRIES
 #[repr(C)]
 #[derive(Debug, Pread)]
 struct ElfVerdef {
     vd_version: u16,
     vd_flags: u16,
     vd_ndx: u16,
     vd_cnt: u16,
     vd_hash: u32,
     vd_aux: u32,
     vd_next: u32,
 }

 /// An ELF `Version Definition Auxiliary` entry Elfxx_Verdaux.
 ///
 /// https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#VERDEFEXTS
 #[repr(C)]
 #[derive(Debug, Pread)]
 struct ElfVerdaux {
     vda_name: u32,
     vda_next: u32,
 }

 /// An ELF `Version Need` entry Elfxx_Verneed.
 ///
 /// https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#VERNEEDFIG
 #[repr(C)]
 #[derive(Debug, Pread)]
 struct ElfVerneed {
     vn_version: u16,
     vn_cnt: u16,
     vn_file: u32,
     vn_aux: u32,
     vn_next: u32,
 }

 /// An ELF `Version Need Auxiliary` entry Elfxx_Vernaux.
 ///
 /// https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#VERNEEDEXTFIG
 #[repr(C)]
 #[derive(Debug, Pread)]
 struct ElfVernaux {
     vna_hash: u32,
     vna_flags: u16,
     vna_other: u16,
     vna_name: u32,
     vna_next: u32,
 }

 /********************
  *  Symbol Version  *
  ********************/

 /// Helper struct to iterate over [Symbol Version][Versym] entries.
 #[derive(Debug)]
 pub struct VersymSection<'a> {
     bytes: &'a [u8],
     ctx: container::Ctx,
 }

 impl<'a> VersymSection<'a> {
     pub fn parse(
         bytes: &'a [u8],
         shdrs: &[SectionHeader],
         ctx: container::Ctx,
     ) -> Result<Option<VersymSection<'a>>> {
         // Get fields needed from optional `symbol version` section.
         let (offset, size) =
             if let Some(shdr) = shdrs.iter().find(|shdr| shdr.sh_type == SHT_GNU_VERSYM) {
                 (shdr.sh_offset as usize, shdr.sh_size as usize)
             } else {
                 return Ok(None);
             };

         // Get a slice of bytes of the `version definition` section content.
         let bytes: &'a [u8] = bytes.pread_with(offset, size)?;

         Ok(Some(VersymSection { bytes, ctx }))
     }

     /// Get an iterator over the [`Versym`] entries.
     #[inline]
     pub fn iter(&'a self) -> VersymIter<'a> {
         self.into_iter()
     }

     /// True if there are no [`Versym`] entries.
     #[inline]
     pub fn is_empty(&self) -> bool {
         self.bytes.is_empty()
     }

     /// Number of [`Versym`] entries.
     #[inline]
     pub fn len(&self) -> usize {
         let entsize = core::mem::size_of::<ElfVersym>();

         self.bytes.len() / entsize
     }

     /// Get [`Versym`] entry at index.
     #[inline]
     pub fn get_at(&self, idx: usize) -> Option<Versym> {
         let entsize = core::mem::size_of::<ElfVersym>();
         let offset = idx.checked_mul(entsize)?;

         self.bytes
             .pread_with::<ElfVersym>(offset, self.ctx.le)
             .ok()
             .map(Versym::from)
     }
 }

 impl<'a> IntoIterator for &'_ VersymSection<'a> {
     type Item = <VersymIter<'a> as Iterator>::Item;
     type IntoIter = VersymIter<'a>;

     fn into_iter(self) -> Self::IntoIter {
         VersymIter {
             bytes: self.bytes,
             offset: 0,
             ctx: self.ctx,
         }
     }
 }

 /// Iterator over the [`Versym`] entries from the [`SHT_GNU_VERSYM`] section.
 pub struct VersymIter<'a> {
     bytes: &'a [u8],
     offset: usize,
     ctx: container::Ctx,
 }

 impl<'a> Iterator for VersymIter<'a> {
     type Item = Versym;

     fn next(&mut self) -> Option<Self::Item> {
         if self.offset >= self.bytes.len() {
             None
         } else {
             self.bytes
                 .gread_with::<ElfVersym>(&mut self.offset, self.ctx.le)
                 .ok()
                 .map(Versym::from)
                 .or_else(|| {
                     // self.bytes are not a multiple of ElfVersym.
                     // Adjust offset to continue yielding Nones.
                     self.offset = self.bytes.len();
                     None
                 })
         }
     }

     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
         let len = (self.bytes.len() - self.offset) / core::mem::size_of::<Self::Item>();
         (len, Some(len))
     }
 }

 impl ExactSizeIterator for VersymIter<'_> {}

 impl FusedIterator for VersymIter<'_> {}

 /// An ELF [Symbol Version][lsb-versym] entry.
 ///
 /// [lsb-versym]: https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#SYMVERTBL
 #[derive(Debug)]
 pub struct Versym {
     pub vs_val: u16,
 }

 impl Versym {
     /// Returns true if the symbol is local and not available outside the object according to
     /// [`VER_NDX_LOCAL`].
     #[inline]
     pub fn is_local(&self) -> bool {
         self.vs_val == VER_NDX_LOCAL
     }

     /// Returns true if the symbol is defined in this object and globally available according
     /// to [`VER_NDX_GLOBAL`].
     #[inline]
     pub fn is_global(&self) -> bool {
         self.vs_val == VER_NDX_GLOBAL
     }

     /// Returns true if the `hidden` bit is set according to the [`VERSYM_HIDDEN`] bitmask.
     #[inline]
     pub fn is_hidden(&self) -> bool {
         (self.vs_val & VERSYM_HIDDEN) == VERSYM_HIDDEN
     }

     /// Returns the symbol version index according to the [`VERSYM_VERSION`] bitmask.
     #[inline]
     pub fn version(&self) -> u16 {
         self.vs_val & VERSYM_VERSION
     }
 }

 impl From<ElfVersym> for Versym {
     fn from(ElfVersym { vs_val }: ElfVersym) -> Self {
         Versym { vs_val }
     }
 }

 /************************
  *  Version Definition  *
  ************************/

 /// Helper struct to iterate over [Version Definition][Verdef] and [Version Definition
 /// Auxiliary][Verdaux] entries.
 #[derive(Debug)]
 pub struct VerdefSection<'a> {
     /// String table used to resolve version strings.
     bytes: &'a [u8],
     count: usize,
     ctx: container::Ctx,
 }

 impl<'a> VerdefSection<'a> {
     pub fn parse(
         bytes: &'a [u8],
         shdrs: &[SectionHeader],
         ctx: container::Ctx,
     ) -> Result<Option<VerdefSection<'a>>> {
         // Get fields needed from optional `version definition` section.
         let (offset, size, count) =
             if let Some(shdr) = shdrs.iter().find(|shdr| shdr.sh_type == SHT_GNU_VERDEF) {
                 (
                     shdr.sh_offset as usize,
                     shdr.sh_size as usize,
                     shdr.sh_info as usize, // Encodes the number of ElfVerdef entries.
                 )
             } else {
                 return Ok(None);
             };

         // Get a slice of bytes of the `version definition` section content.
         let bytes: &'a [u8] = bytes.pread_with(offset, size)?;

         Ok(Some(VerdefSection { bytes, count, ctx }))
     }

     /// Get an iterator over the [`Verdef`] entries.
     #[inline]
     pub fn iter(&'a self) -> VerdefIter<'a> {
         self.into_iter()
     }
 }

 impl<'a> IntoIterator for &'_ VerdefSection<'a> {
     type Item = <VerdefIter<'a> as Iterator>::Item;
     type IntoIter = VerdefIter<'a>;

     #[inline]
     fn into_iter(self) -> Self::IntoIter {
         VerdefIter {
             bytes: self.bytes,
             count: self.count,
             index: 0,
             offset: 0,
             ctx: self.ctx,
         }
     }
 }

 /// Iterator over the [`Verdef`] entries from the [`SHT_GNU_VERDEF`] section.
 pub struct VerdefIter<'a> {
     bytes: &'a [u8],
     count: usize,
     index: usize,
     offset: usize,
     ctx: container::Ctx,
 }

 impl<'a> Iterator for VerdefIter<'a> {
     type Item = Verdef<'a>;

     fn next(&mut self) -> Option<Self::Item> {
         if self.index >= self.count {
             None
         } else {
             self.index += 1;

             let do_next = |iter: &mut Self| {
                 let ElfVerdef {
                     vd_version,
                     vd_flags,
                     vd_ndx,
                     vd_cnt,
                     vd_hash,
                     vd_aux,
                     vd_next,
                 } = iter.bytes.pread_with(iter.offset, iter.ctx.le).ok()?;

                 // Validate offset to first ElfVerdaux entry.
                 let offset = iter.offset.checked_add(vd_aux as usize)?;

                 // Validate if offset is valid index into bytes slice.
                 if offset >= iter.bytes.len() {
                     return None;
                 }

                 // Get a slice of bytes starting with the first ElfVerdaux entry.
                 let bytes: &'a [u8] = &iter.bytes[offset..];

                 // Bump the offset to the next ElfVerdef entry.
                 iter.offset = iter.offset.checked_add(vd_next as usize)?;

                 // Start yielding None on the next call if there is no next offset.
                 if vd_next == 0 {
                     iter.index = iter.count;
                 }

                 Some(Verdef {
                     vd_version,
                     vd_flags,
                     vd_ndx,
                     vd_cnt,
                     vd_hash,
                     vd_aux,
                     vd_next,
                     bytes,
                     ctx: iter.ctx,
                 })
             };

             do_next(self).or_else(|| {
                 // Adjust current index to count in case of an error.
                 self.index = self.count;
                 None
             })
         }
     }

     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
         let len = self.count - self.index;
         (0, Some(len))
     }
 }

 impl ExactSizeIterator for VerdefIter<'_> {}

 impl FusedIterator for VerdefIter<'_> {}

 /// An ELF [Version Definition][lsb-verdef] entry .
 ///
 /// [lsb-verdef]: https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#VERDEFENTRIES
 #[derive(Debug)]
 pub struct Verdef<'a> {
     /// Version revision. This field shall be set to 1.
     pub vd_version: u16,
     /// Version information flag bitmask.
     pub vd_flags: u16,
     /// Version index numeric value referencing the SHT_GNU_versym section.
     pub vd_ndx: u16,
     /// Number of associated verdaux array entries.
     pub vd_cnt: u16,
     /// Version name hash value (ELF hash function).
     pub vd_hash: u32,
     /// Offset in bytes to a corresponding entry in an array of Elfxx_Verdaux structures.
     pub vd_aux: u32,
     /// Offset to the next verdef entry, in bytes.
     pub vd_next: u32,

     bytes: &'a [u8],
     ctx: container::Ctx,
 }

 impl<'a> Verdef<'a> {
     /// Get an iterator over the [`Verdaux`] entries of this [`Verdef`] entry.
     #[inline]
     pub fn iter(&'a self) -> VerdauxIter<'a> {
         self.into_iter()
     }
 }

 impl<'a> IntoIterator for &'_ Verdef<'a> {
     type Item = <VerdauxIter<'a> as Iterator>::Item;
     type IntoIter = VerdauxIter<'a>;

     fn into_iter(self) -> Self::IntoIter {
         VerdauxIter {
             bytes: self.bytes,
             count: self.vd_cnt,
             index: 0,
             offset: 0,
             ctx: self.ctx,
         }
     }
 }

 /// Iterator over the [`Verdaux`] entries for an specific [`Verdef`] entry.
 pub struct VerdauxIter<'a> {
     bytes: &'a [u8],
     count: u16,
     index: u16,
     offset: usize,
     ctx: container::Ctx,
 }

 impl<'a> Iterator for VerdauxIter<'a> {
     type Item = Verdaux;

     fn next(&mut self) -> Option<Self::Item> {
         if self.index >= self.count {
             None
         } else {
             self.index += 1;

             let do_next = |iter: &mut Self| {
                 let ElfVerdaux { vda_name, vda_next } =
                     iter.bytes.pread_with(iter.offset, iter.ctx.le).ok()?;

                 // Bump the offset to the next ElfVerdaux entry.
                 iter.offset = iter.offset.checked_add(vda_next as usize)?;

                 // Start yielding None on the next call if there is no next offset.
                 if vda_next == 0 {
                     iter.index = iter.count;
                 }

                 Some(Verdaux {
                     vda_name: vda_name as usize,
                     vda_next,
                 })
             };

             do_next(self).or_else(|| {
                 // Adjust current index to count in case of an error.
                 self.index = self.count;
                 None
             })
         }
     }

     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
         let len = usize::from(self.count - self.index);
         (0, Some(len))
     }
 }

 impl ExactSizeIterator for VerdauxIter<'_> {}

 impl FusedIterator for VerdauxIter<'_> {}

 /// An ELF [Version Definition Auxiliary][lsb-verdaux] entry.
 ///
 /// [lsb-verdaux]: https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#VERDEFEXTS
 #[derive(Debug)]
 pub struct Verdaux {
     /// Offset to the version or dependency name string in the section header, in bytes.
     pub vda_name: usize,
     /// Offset to the next verdaux entry, in bytes.
     pub vda_next: u32,
 }

 /**************************
  *  Version Requirements  *
  **************************/

 /// Helper struct to iterate over [Version Needed][Verneed] and [Version Needed
 /// Auxiliary][Vernaux] entries.
 #[derive(Debug)]
 pub struct VerneedSection<'a> {
     bytes: &'a [u8],
     count: usize,
     ctx: container::Ctx,
 }

 impl<'a> VerneedSection<'a> {
     /// Try to parse the optional [`SHT_GNU_VERNEED`] section.
     pub fn parse(
         bytes: &'a [u8],
         shdrs: &[SectionHeader],
         ctx: container::Ctx,
     ) -> Result<Option<VerneedSection<'a>>> {
         // Get fields needed from optional `version needed` section.
         let (offset, size, count) =
             if let Some(shdr) = shdrs.iter().find(|shdr| shdr.sh_type == SHT_GNU_VERNEED) {
                 (
                     shdr.sh_offset as usize,
                     shdr.sh_size as usize,
                     shdr.sh_info as usize, // Encodes the number of ElfVerneed entries.
                 )
             } else {
                 return Ok(None);
             };

         // Get a slice of bytes of the `version needed` section content.
         let bytes: &'a [u8] = bytes.pread_with(offset, size)?;

         Ok(Some(VerneedSection { bytes, count, ctx }))
     }

     /// Get an iterator over the [`Verneed`] entries.
     #[inline]
     pub fn iter(&'a self) -> VerneedIter<'a> {
         self.into_iter()
     }
 }

 impl<'a> IntoIterator for &'_ VerneedSection<'a> {
     type Item = <VerneedIter<'a> as Iterator>::Item;
     type IntoIter = VerneedIter<'a>;

     #[inline]
     fn into_iter(self) -> Self::IntoIter {
         VerneedIter {
             bytes: self.bytes,
             count: self.count,
             index: 0,
             offset: 0,
             ctx: self.ctx,
         }
     }
 }

 /// Iterator over the [`Verneed`] entries from the [`SHT_GNU_VERNEED`] section.
 pub struct VerneedIter<'a> {
     bytes: &'a [u8],
     count: usize,
     index: usize,
     offset: usize,
     ctx: container::Ctx,
 }

 impl<'a> Iterator for VerneedIter<'a> {
     type Item = Verneed<'a>;

     fn next(&mut self) -> Option<Self::Item> {
         if self.index >= self.count {
             None
         } else {
             self.index += 1;

             let do_next = |iter: &mut Self| {
                 let ElfVerneed {
                     vn_version,
                     vn_cnt,
                     vn_file,
                     vn_aux,
                     vn_next,
                 } = iter.bytes.pread_with(iter.offset, iter.ctx.le).ok()?;

                 // Validate offset to first ElfVernaux entry.
                 let offset = iter.offset.checked_add(vn_aux as usize)?;

                 // Validate if offset is valid index into bytes slice.
                 if offset >= iter.bytes.len() {
                     return None;
                 }

                 // Get a slice of bytes starting with the first ElfVernaux entry.
                 let bytes: &'a [u8] = &iter.bytes[offset..];

                 // Bump the offset to the next ElfVerneed entry.
                 iter.offset = iter.offset.checked_add(vn_next as usize)?;

                 // Start yielding None on the next call if there is no next offset.
                 if vn_next == 0 {
                     iter.index = iter.count;
                 }

                 Some(Verneed {
                     vn_version,
                     vn_cnt,
                     vn_file: vn_file as usize,
                     vn_aux,
                     vn_next,
                     bytes,
                     ctx: iter.ctx,
                 })
             };

             do_next(self).or_else(|| {
                 // Adjust current index to count in case of an error.
                 self.index = self.count;
                 None
             })
         }
     }

     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
         let len = self.count - self.index;
         (0, Some(len))
     }
 }

 impl ExactSizeIterator for VerneedIter<'_> {}

 impl FusedIterator for VerneedIter<'_> {}

 /// An ELF [Version Need][lsb-verneed] entry .
 ///
 /// [lsb-verneed]: https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#VERNEEDFIG
 #[derive(Debug)]
 pub struct Verneed<'a> {
     /// Version of structure. This value is currently set to 1, and will be reset if the versioning
     /// implementation is incompatibly altered.
     pub vn_version: u16,
     /// Number of associated verneed array entries.
     pub vn_cnt: u16,
     /// Offset to the file name string in the section header, in bytes.
     pub vn_file: usize,
     /// Offset to a corresponding entry in the vernaux array, in bytes.
     pub vn_aux: u32,
     /// Offset to the next verneed entry, in bytes.
     pub vn_next: u32,

     bytes: &'a [u8],
     ctx: container::Ctx,
 }

 impl<'a> Verneed<'a> {
     /// Get an iterator over the [`Vernaux`] entries of this [`Verneed`] entry.
     #[inline]
     pub fn iter(&'a self) -> VernauxIter<'a> {
         self.into_iter()
     }
 }

 impl<'a> IntoIterator for &'_ Verneed<'a> {
     type Item = <VernauxIter<'a> as Iterator>::Item;
     type IntoIter = VernauxIter<'a>;

     #[inline]
     fn into_iter(self) -> Self::IntoIter {
         VernauxIter {
             bytes: self.bytes,
             count: self.vn_cnt,
             index: 0,
             offset: 0,
             ctx: self.ctx,
         }
     }
 }

 /// Iterator over the [`Vernaux`] entries for an specific [`Verneed`] entry.
 pub struct VernauxIter<'a> {
     bytes: &'a [u8],
     count: u16,
     index: u16,
     offset: usize,
     ctx: container::Ctx,
 }

 impl<'a> Iterator for VernauxIter<'a> {
     type Item = Vernaux;

     fn next(&mut self) -> Option<Self::Item> {
         if self.index >= self.count {
             None
         } else {
             self.index += 1;

             let do_next = |iter: &mut Self| {
                 let ElfVernaux {
                     vna_hash,
                     vna_flags,
                     vna_other,
                     vna_name,
                     vna_next,
                 } = iter.bytes.pread_with(iter.offset, iter.ctx.le).ok()?;

                 // Bump the offset to the next ElfVernaux entry.
                 iter.offset = iter.offset.checked_add(vna_next as usize)?;

                 // Start yielding None on the next call if there is no next offset.
                 if vna_next == 0 {
                     iter.index = iter.count;
                 }

                 Some(Vernaux {
                     vna_hash,
                     vna_flags,
                     vna_other,
                     vna_name: vna_name as usize,
                     vna_next,
                 })
             };

             do_next(self).or_else(|| {
                 // Adjust current index to count in case of an error.
                 self.index = self.count;
                 None
             })
         }
     }

     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
         let len = usize::from(self.count - self.index);
         (0, Some(len))
     }
 }

 impl ExactSizeIterator for VernauxIter<'_> {}

 impl FusedIterator for VernauxIter<'_> {}

 /// An ELF [Version Need Auxiliary][lsb-vernaux] entry.
 ///
 /// [lsb-vernaux]: https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#VERNEEDEXTFIG
 #[derive(Debug)]
 pub struct Vernaux {
     /// Dependency name hash value (ELF hash function).
     pub vna_hash: u32,
     /// Dependency information flag bitmask.
     pub vna_flags: u16,
     /// Object file version identifier used in the .gnu.version symbol version array. Bit number 15
     /// controls whether or not the object is hidden; if this bit is set, the object cannot be used
     /// and the static linker will ignore the symbol's presence in the object.
     pub vna_other: u16,
     /// Offset to the dependency name string in the section header, in bytes.
     pub vna_name: usize,
     /// Offset to the next vernaux entry, in bytes.
     pub vna_next: u32,
 }

 #[cfg(test)]
 mod test {
     use super::{ElfVerdaux, ElfVerdef, ElfVernaux, ElfVerneed, ElfVersym};
     use super::{Versym, VERSYM_HIDDEN, VER_NDX_GLOBAL, VER_NDX_LOCAL};
     use core::mem::size_of;

     #[test]
     fn check_size() {
         assert_eq!(2, size_of::<ElfVersym>());
         assert_eq!(20, size_of::<ElfVerdef>());
         assert_eq!(8, size_of::<ElfVerdaux>());
         assert_eq!(16, size_of::<ElfVerneed>());
         assert_eq!(16, size_of::<ElfVernaux>());
     }

     #[test]
     fn check_versym() {
         let local = Versym {
             vs_val: VER_NDX_LOCAL,
         };
         assert_eq!(true, local.is_local());
         assert_eq!(false, local.is_global());
         assert_eq!(false, local.is_hidden());
         assert_eq!(VER_NDX_LOCAL, local.version());

         let global = Versym {
             vs_val: VER_NDX_GLOBAL,
         };
         assert_eq!(false, global.is_local());
         assert_eq!(true, global.is_global());
         assert_eq!(false, global.is_hidden());
         assert_eq!(VER_NDX_GLOBAL, global.version());

         let hidden = Versym {
             vs_val: VERSYM_HIDDEN,
         };
         assert_eq!(false, hidden.is_local());
         assert_eq!(false, hidden.is_global());
         assert_eq!(true, hidden.is_hidden());
         assert_eq!(0, hidden.version());

         let hidden = Versym {
             vs_val: VERSYM_HIDDEN | 0x123,
         };
         assert_eq!(false, hidden.is_local());
         assert_eq!(false, hidden.is_global());
         assert_eq!(true, hidden.is_hidden());
         assert_eq!(0x123, hidden.version());
     }
 }
	//! Symbol versioning
	//!
	//! Implementation of the GNU symbol versioning extension according to
	//! [LSB Core Specification - Symbol Versioning][lsb-symver].
	//!
	//! # Examples
	//!
	//! List the dependencies of an ELF file that have [version needed][lsb-verneed] information along
	//! with the versions needed for each dependency.
	//! ```rust
	//! use goblin::error::Error;
	//!
	//! pub fn show_verneed(bytes: &[u8]) -> Result<(), Error> {
	//! let binary = goblin::elf::Elf::parse(&bytes)?;
	//!
	//! if let Some(verneed) = binary.verneed {
	//! for need_file in verneed.iter() {
	//! println!(
	//! "Depend on {:?} with version(s):",
	//! binary.dynstrtab.get_at(need_file.vn_file)
	//! );
	//! for need_ver in need_file.iter() {
	//! println!("{:?}", binary.dynstrtab.get_at(need_ver.vna_name));
	//! }
	//! }
	//! }
	//!
	//! Ok(())
	//! }
	//! ```
	//!
	//! List the [version defined][lsb-verdef] information of an ELF file, effectively listing the version
	//! defined by this ELF file.
	//! ```rust
	//! use goblin::error::Error;
	//!
	//! pub fn show_verdef(bytes: &[u8]) -> Result<(), Error> {
	//! let binary = goblin::elf::Elf::parse(&bytes)?;
	//!
	//! if let Some(verdef) = &binary.verdef {
	//! for def in verdef.iter() {
	//! for (n, aux) in def.iter().enumerate() {
	//! let name = binary.dynstrtab.get_at(aux.vda_name);
	//! match n {
	//! 0 => print!("Name: {:?}", name),
	//! 1 => print!(" Parent: {:?}", name),
	//! _ => print!(", {:?}", name),
	//! }
	//! }
	//! print!("\n");
	//! }
	//! }
	//!
	//! Ok(())
	//! }
	//! ```
	//!
	//! [lsb-symver]: https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html
	//! [lsb-verneed]: https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#SYMVERRQMTS
	//! [lsb-verdef]: https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#SYMVERDEFS

	use crate::container;
	use crate::elf::section_header::{SectionHeader, SHT_GNU_VERDEF, SHT_GNU_VERNEED, SHT_GNU_VERSYM};
	use crate::error::Result;
	use core::iter::FusedIterator;
	use scroll::Pread;

	/******************
	* ELF Constants *
	******************/

	// Versym constants.

	/// Constant describing a local symbol, see [`Versym::is_local`].
	pub const VER_NDX_LOCAL: u16 = 0;
	/// Constant describing a global symbol, see [`Versym::is_global`].
	pub const VER_NDX_GLOBAL: u16 = 1;
	/// Bitmask to check hidden bit, see [`Versym::is_hidden`].
	pub const VERSYM_HIDDEN: u16 = 0x8000;
	/// Bitmask to get version information, see [`Versym::version`].
	pub const VERSYM_VERSION: u16 = 0x7fff;

	// Verdef constants.

	/// Bitmask to check `base` flag in [`Verdef::vd_flags`].
	pub const VER_FLG_BASE: u16 = 0x1;
	/// Bitmask to check `weak` flag in [`Verdef::vd_flags`].
	pub const VER_FLG_WEAK: u16 = 0x2;
	/// Bitmask to check `info` flag in [`Verdef::vd_flags`].
	pub const VER_FLG_INFO: u16 = 0x4;

	/********************
	* ELF Structures *
	********************/

	/// An ELF `Symbol Version` entry.
	///
	/// https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#SYMVERTBL
	#[repr(C)]
	#[derive(Debug, Pread)]
	struct ElfVersym {
	vs_val: u16,
	}

	/// An ELF `Version Definition` entry Elfxx_Verdef.
	///
	/// https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#VERDEFENTRIES
	#[repr(C)]
	#[derive(Debug, Pread)]
	struct ElfVerdef {
	vd_version: u16,
	vd_flags: u16,
	vd_ndx: u16,
	vd_cnt: u16,
	vd_hash: u32,
	vd_aux: u32,
	vd_next: u32,
	}

	/// An ELF `Version Definition Auxiliary` entry Elfxx_Verdaux.
	///
	/// https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#VERDEFEXTS
	#[repr(C)]
	#[derive(Debug, Pread)]
	struct ElfVerdaux {
	vda_name: u32,
	vda_next: u32,
	}

	/// An ELF `Version Need` entry Elfxx_Verneed.
	///
	/// https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#VERNEEDFIG
	#[repr(C)]
	#[derive(Debug, Pread)]
	struct ElfVerneed {
	vn_version: u16,
	vn_cnt: u16,
	vn_file: u32,
	vn_aux: u32,
	vn_next: u32,
	}

	/// An ELF `Version Need Auxiliary` entry Elfxx_Vernaux.
	///
	/// https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#VERNEEDEXTFIG
	#[repr(C)]
	#[derive(Debug, Pread)]
	struct ElfVernaux {
	vna_hash: u32,
	vna_flags: u16,
	vna_other: u16,
	vna_name: u32,
	vna_next: u32,
	}

	/********************
	* Symbol Version *
	********************/

	/// Helper struct to iterate over [Symbol Version][Versym] entries.
	#[derive(Debug)]
	pub struct VersymSection<'a> {
	bytes: &'a [u8],
	ctx: container::Ctx,
	}

	impl<'a> VersymSection<'a> {
	pub fn parse(
	bytes: &'a [u8],
	shdrs: &[SectionHeader],
	ctx: container::Ctx,
	) -> Result<Option<VersymSection<'a>>> {
	// Get fields needed from optional `symbol version` section.
	let (offset, size) =
	if let Some(shdr) = shdrs.iter().find(\|shdr\| shdr.sh_type == SHT_GNU_VERSYM) {
	(shdr.sh_offset as usize, shdr.sh_size as usize)
	} else {
	return Ok(None);
	};

	// Get a slice of bytes of the `version definition` section content.
	let bytes: &'a [u8] = bytes.pread_with(offset, size)?;

	Ok(Some(VersymSection { bytes, ctx }))
	}

	/// Get an iterator over the [`Versym`] entries.
	#[inline]
	pub fn iter(&'a self) -> VersymIter<'a> {
	self.into_iter()
	}

	/// True if there are no [`Versym`] entries.
	#[inline]
	pub fn is_empty(&self) -> bool {
	self.bytes.is_empty()
	}

	/// Number of [`Versym`] entries.
	#[inline]
	pub fn len(&self) -> usize {
	let entsize = core::mem::size_of::<ElfVersym>();

	self.bytes.len() / entsize
	}

	/// Get [`Versym`] entry at index.
	#[inline]
	pub fn get_at(&self, idx: usize) -> Option<Versym> {
	let entsize = core::mem::size_of::<ElfVersym>();
	let offset = idx.checked_mul(entsize)?;

	self.bytes
	.pread_with::<ElfVersym>(offset, self.ctx.le)
	.ok()
	.map(Versym::from)
	}
	}

	impl<'a> IntoIterator for &'_ VersymSection<'a> {
	type Item = <VersymIter<'a> as Iterator>::Item;
	type IntoIter = VersymIter<'a>;

	fn into_iter(self) -> Self::IntoIter {
	VersymIter {
	bytes: self.bytes,
	offset: 0,
	ctx: self.ctx,
	}
	}
	}

	/// Iterator over the [`Versym`] entries from the [`SHT_GNU_VERSYM`] section.
	pub struct VersymIter<'a> {
	bytes: &'a [u8],
	offset: usize,
	ctx: container::Ctx,
	}

	impl<'a> Iterator for VersymIter<'a> {
	type Item = Versym;

	fn next(&mut self) -> Option<Self::Item> {
	if self.offset >= self.bytes.len() {
	None
	} else {
	self.bytes
	.gread_with::<ElfVersym>(&mut self.offset, self.ctx.le)
	.ok()
	.map(Versym::from)
	.or_else(\|\| {
	// self.bytes are not a multiple of ElfVersym.
	// Adjust offset to continue yielding Nones.
	self.offset = self.bytes.len();
	None
	})
	}
	}

	#[inline]
	fn size_hint(&self) -> (usize, Option<usize>) {
	let len = (self.bytes.len() - self.offset) / core::mem::size_of::<Self::Item>();
	(len, Some(len))
	}
	}

	impl ExactSizeIterator for VersymIter<'_> {}

	impl FusedIterator for VersymIter<'_> {}

	/// An ELF [Symbol Version][lsb-versym] entry.
	///
	/// [lsb-versym]: https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#SYMVERTBL
	#[derive(Debug)]
	pub struct Versym {
	pub vs_val: u16,
	}

	impl Versym {
	/// Returns true if the symbol is local and not available outside the object according to
	/// [`VER_NDX_LOCAL`].
	#[inline]
	pub fn is_local(&self) -> bool {
	self.vs_val == VER_NDX_LOCAL
	}

	/// Returns true if the symbol is defined in this object and globally available according
	/// to [`VER_NDX_GLOBAL`].
	#[inline]
	pub fn is_global(&self) -> bool {
	self.vs_val == VER_NDX_GLOBAL
	}

	/// Returns true if the `hidden` bit is set according to the [`VERSYM_HIDDEN`] bitmask.
	#[inline]
	pub fn is_hidden(&self) -> bool {
	(self.vs_val & VERSYM_HIDDEN) == VERSYM_HIDDEN
	}

	/// Returns the symbol version index according to the [`VERSYM_VERSION`] bitmask.
	#[inline]
	pub fn version(&self) -> u16 {
	self.vs_val & VERSYM_VERSION
	}
	}

	impl From<ElfVersym> for Versym {
	fn from(ElfVersym { vs_val }: ElfVersym) -> Self {
	Versym { vs_val }
	}
	}

	/************************
	* Version Definition *
	************************/

	/// Helper struct to iterate over [Version Definition][Verdef] and [Version Definition
	/// Auxiliary][Verdaux] entries.
	#[derive(Debug)]
	pub struct VerdefSection<'a> {
	/// String table used to resolve version strings.
	bytes: &'a [u8],
	count: usize,
	ctx: container::Ctx,
	}

	impl<'a> VerdefSection<'a> {
	pub fn parse(
	bytes: &'a [u8],
	shdrs: &[SectionHeader],
	ctx: container::Ctx,
	) -> Result<Option<VerdefSection<'a>>> {
	// Get fields needed from optional `version definition` section.
	let (offset, size, count) =
	if let Some(shdr) = shdrs.iter().find(\|shdr\| shdr.sh_type == SHT_GNU_VERDEF) {
	(
	shdr.sh_offset as usize,
	shdr.sh_size as usize,
	shdr.sh_info as usize, // Encodes the number of ElfVerdef entries.
	)
	} else {
	return Ok(None);
	};

	// Get a slice of bytes of the `version definition` section content.
	let bytes: &'a [u8] = bytes.pread_with(offset, size)?;

	Ok(Some(VerdefSection { bytes, count, ctx }))
	}

	/// Get an iterator over the [`Verdef`] entries.
	#[inline]
	pub fn iter(&'a self) -> VerdefIter<'a> {
	self.into_iter()
	}
	}

	impl<'a> IntoIterator for &'_ VerdefSection<'a> {
	type Item = <VerdefIter<'a> as Iterator>::Item;
	type IntoIter = VerdefIter<'a>;

	#[inline]
	fn into_iter(self) -> Self::IntoIter {
	VerdefIter {
	bytes: self.bytes,
	count: self.count,
	index: 0,
	offset: 0,
	ctx: self.ctx,
	}
	}
	}

	/// Iterator over the [`Verdef`] entries from the [`SHT_GNU_VERDEF`] section.
	pub struct VerdefIter<'a> {
	bytes: &'a [u8],
	count: usize,
	index: usize,
	offset: usize,
	ctx: container::Ctx,
	}

	impl<'a> Iterator for VerdefIter<'a> {
	type Item = Verdef<'a>;

	fn next(&mut self) -> Option<Self::Item> {
	if self.index >= self.count {
	None
	} else {
	self.index += 1;

	let do_next = \|iter: &mut Self\| {
	let ElfVerdef {
	vd_version,
	vd_flags,
	vd_ndx,
	vd_cnt,
	vd_hash,
	vd_aux,
	vd_next,
	} = iter.bytes.pread_with(iter.offset, iter.ctx.le).ok()?;

	// Validate offset to first ElfVerdaux entry.
	let offset = iter.offset.checked_add(vd_aux as usize)?;

	// Validate if offset is valid index into bytes slice.
	if offset >= iter.bytes.len() {
	return None;
	}

	// Get a slice of bytes starting with the first ElfVerdaux entry.
	let bytes: &'a [u8] = &iter.bytes[offset..];

	// Bump the offset to the next ElfVerdef entry.
	iter.offset = iter.offset.checked_add(vd_next as usize)?;

	// Start yielding None on the next call if there is no next offset.
	if vd_next == 0 {
	iter.index = iter.count;
	}

	Some(Verdef {
	vd_version,
	vd_flags,
	vd_ndx,
	vd_cnt,
	vd_hash,
	vd_aux,
	vd_next,
	bytes,
	ctx: iter.ctx,
	})
	};

	do_next(self).or_else(\|\| {
	// Adjust current index to count in case of an error.
	self.index = self.count;
	None
	})
	}
	}

	#[inline]
	fn size_hint(&self) -> (usize, Option<usize>) {
	let len = self.count - self.index;
	(0, Some(len))
	}
	}

	impl ExactSizeIterator for VerdefIter<'_> {}

	impl FusedIterator for VerdefIter<'_> {}

	/// An ELF [Version Definition][lsb-verdef] entry .
	///
	/// [lsb-verdef]: https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#VERDEFENTRIES
	#[derive(Debug)]
	pub struct Verdef<'a> {
	/// Version revision. This field shall be set to 1.
	pub vd_version: u16,
	/// Version information flag bitmask.
	pub vd_flags: u16,
	/// Version index numeric value referencing the SHT_GNU_versym section.
	pub vd_ndx: u16,
	/// Number of associated verdaux array entries.
	pub vd_cnt: u16,
	/// Version name hash value (ELF hash function).
	pub vd_hash: u32,
	/// Offset in bytes to a corresponding entry in an array of Elfxx_Verdaux structures.
	pub vd_aux: u32,
	/// Offset to the next verdef entry, in bytes.
	pub vd_next: u32,

	bytes: &'a [u8],
	ctx: container::Ctx,
	}

	impl<'a> Verdef<'a> {
	/// Get an iterator over the [`Verdaux`] entries of this [`Verdef`] entry.
	#[inline]
	pub fn iter(&'a self) -> VerdauxIter<'a> {
	self.into_iter()
	}
	}

	impl<'a> IntoIterator for &'_ Verdef<'a> {
	type Item = <VerdauxIter<'a> as Iterator>::Item;
	type IntoIter = VerdauxIter<'a>;

	fn into_iter(self) -> Self::IntoIter {
	VerdauxIter {
	bytes: self.bytes,
	count: self.vd_cnt,
	index: 0,
	offset: 0,
	ctx: self.ctx,
	}
	}
	}

	/// Iterator over the [`Verdaux`] entries for an specific [`Verdef`] entry.
	pub struct VerdauxIter<'a> {
	bytes: &'a [u8],
	count: u16,
	index: u16,
	offset: usize,
	ctx: container::Ctx,
	}

	impl<'a> Iterator for VerdauxIter<'a> {
	type Item = Verdaux;

	fn next(&mut self) -> Option<Self::Item> {
	if self.index >= self.count {
	None
	} else {
	self.index += 1;

	let do_next = \|iter: &mut Self\| {
	let ElfVerdaux { vda_name, vda_next } =
	iter.bytes.pread_with(iter.offset, iter.ctx.le).ok()?;

	// Bump the offset to the next ElfVerdaux entry.
	iter.offset = iter.offset.checked_add(vda_next as usize)?;

	// Start yielding None on the next call if there is no next offset.
	if vda_next == 0 {
	iter.index = iter.count;
	}

	Some(Verdaux {
	vda_name: vda_name as usize,
	vda_next,
	})
	};

	do_next(self).or_else(\|\| {
	// Adjust current index to count in case of an error.
	self.index = self.count;
	None
	})
	}
	}

	#[inline]
	fn size_hint(&self) -> (usize, Option<usize>) {
	let len = usize::from(self.count - self.index);
	(0, Some(len))
	}
	}

	impl ExactSizeIterator for VerdauxIter<'_> {}

	impl FusedIterator for VerdauxIter<'_> {}

	/// An ELF [Version Definition Auxiliary][lsb-verdaux] entry.
	///
	/// [lsb-verdaux]: https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#VERDEFEXTS
	#[derive(Debug)]
	pub struct Verdaux {
	/// Offset to the version or dependency name string in the section header, in bytes.
	pub vda_name: usize,
	/// Offset to the next verdaux entry, in bytes.
	pub vda_next: u32,
	}

	/**************************
	* Version Requirements *
	**************************/

	/// Helper struct to iterate over [Version Needed][Verneed] and [Version Needed
	/// Auxiliary][Vernaux] entries.
	#[derive(Debug)]
	pub struct VerneedSection<'a> {
	bytes: &'a [u8],
	count: usize,
	ctx: container::Ctx,
	}

	impl<'a> VerneedSection<'a> {
	/// Try to parse the optional [`SHT_GNU_VERNEED`] section.
	pub fn parse(
	bytes: &'a [u8],
	shdrs: &[SectionHeader],
	ctx: container::Ctx,
	) -> Result<Option<VerneedSection<'a>>> {
	// Get fields needed from optional `version needed` section.
	let (offset, size, count) =
	if let Some(shdr) = shdrs.iter().find(\|shdr\| shdr.sh_type == SHT_GNU_VERNEED) {
	(
	shdr.sh_offset as usize,
	shdr.sh_size as usize,
	shdr.sh_info as usize, // Encodes the number of ElfVerneed entries.
	)
	} else {
	return Ok(None);
	};

	// Get a slice of bytes of the `version needed` section content.
	let bytes: &'a [u8] = bytes.pread_with(offset, size)?;

	Ok(Some(VerneedSection { bytes, count, ctx }))
	}

	/// Get an iterator over the [`Verneed`] entries.
	#[inline]
	pub fn iter(&'a self) -> VerneedIter<'a> {
	self.into_iter()
	}
	}

	impl<'a> IntoIterator for &'_ VerneedSection<'a> {
	type Item = <VerneedIter<'a> as Iterator>::Item;
	type IntoIter = VerneedIter<'a>;

	#[inline]
	fn into_iter(self) -> Self::IntoIter {
	VerneedIter {
	bytes: self.bytes,
	count: self.count,
	index: 0,
	offset: 0,
	ctx: self.ctx,
	}
	}
	}

	/// Iterator over the [`Verneed`] entries from the [`SHT_GNU_VERNEED`] section.
	pub struct VerneedIter<'a> {
	bytes: &'a [u8],
	count: usize,
	index: usize,
	offset: usize,
	ctx: container::Ctx,
	}

	impl<'a> Iterator for VerneedIter<'a> {
	type Item = Verneed<'a>;

	fn next(&mut self) -> Option<Self::Item> {
	if self.index >= self.count {
	None
	} else {
	self.index += 1;

	let do_next = \|iter: &mut Self\| {
	let ElfVerneed {
	vn_version,
	vn_cnt,
	vn_file,
	vn_aux,
	vn_next,
	} = iter.bytes.pread_with(iter.offset, iter.ctx.le).ok()?;

	// Validate offset to first ElfVernaux entry.
	let offset = iter.offset.checked_add(vn_aux as usize)?;

	// Validate if offset is valid index into bytes slice.
	if offset >= iter.bytes.len() {
	return None;
	}

	// Get a slice of bytes starting with the first ElfVernaux entry.
	let bytes: &'a [u8] = &iter.bytes[offset..];

	// Bump the offset to the next ElfVerneed entry.
	iter.offset = iter.offset.checked_add(vn_next as usize)?;

	// Start yielding None on the next call if there is no next offset.
	if vn_next == 0 {
	iter.index = iter.count;
	}

	Some(Verneed {
	vn_version,
	vn_cnt,
	vn_file: vn_file as usize,
	vn_aux,
	vn_next,
	bytes,
	ctx: iter.ctx,
	})
	};

	do_next(self).or_else(\|\| {
	// Adjust current index to count in case of an error.
	self.index = self.count;
	None
	})
	}
	}

	#[inline]
	fn size_hint(&self) -> (usize, Option<usize>) {
	let len = self.count - self.index;
	(0, Some(len))
	}
	}

	impl ExactSizeIterator for VerneedIter<'_> {}

	impl FusedIterator for VerneedIter<'_> {}

	/// An ELF [Version Need][lsb-verneed] entry .
	///
	/// [lsb-verneed]: https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#VERNEEDFIG
	#[derive(Debug)]
	pub struct Verneed<'a> {
	/// Version of structure. This value is currently set to 1, and will be reset if the versioning
	/// implementation is incompatibly altered.
	pub vn_version: u16,
	/// Number of associated verneed array entries.
	pub vn_cnt: u16,
	/// Offset to the file name string in the section header, in bytes.
	pub vn_file: usize,
	/// Offset to a corresponding entry in the vernaux array, in bytes.
	pub vn_aux: u32,
	/// Offset to the next verneed entry, in bytes.
	pub vn_next: u32,

	bytes: &'a [u8],
	ctx: container::Ctx,
	}

	impl<'a> Verneed<'a> {
	/// Get an iterator over the [`Vernaux`] entries of this [`Verneed`] entry.
	#[inline]
	pub fn iter(&'a self) -> VernauxIter<'a> {
	self.into_iter()
	}
	}

	impl<'a> IntoIterator for &'_ Verneed<'a> {
	type Item = <VernauxIter<'a> as Iterator>::Item;
	type IntoIter = VernauxIter<'a>;

	#[inline]
	fn into_iter(self) -> Self::IntoIter {
	VernauxIter {
	bytes: self.bytes,
	count: self.vn_cnt,
	index: 0,
	offset: 0,
	ctx: self.ctx,
	}
	}
	}

	/// Iterator over the [`Vernaux`] entries for an specific [`Verneed`] entry.
	pub struct VernauxIter<'a> {
	bytes: &'a [u8],
	count: u16,
	index: u16,
	offset: usize,
	ctx: container::Ctx,
	}

	impl<'a> Iterator for VernauxIter<'a> {
	type Item = Vernaux;

	fn next(&mut self) -> Option<Self::Item> {
	if self.index >= self.count {
	None
	} else {
	self.index += 1;

	let do_next = \|iter: &mut Self\| {
	let ElfVernaux {
	vna_hash,
	vna_flags,
	vna_other,
	vna_name,
	vna_next,
	} = iter.bytes.pread_with(iter.offset, iter.ctx.le).ok()?;

	// Bump the offset to the next ElfVernaux entry.
	iter.offset = iter.offset.checked_add(vna_next as usize)?;

	// Start yielding None on the next call if there is no next offset.
	if vna_next == 0 {
	iter.index = iter.count;
	}

	Some(Vernaux {
	vna_hash,
	vna_flags,
	vna_other,
	vna_name: vna_name as usize,
	vna_next,
	})
	};

	do_next(self).or_else(\|\| {
	// Adjust current index to count in case of an error.
	self.index = self.count;
	None
	})
	}
	}

	#[inline]
	fn size_hint(&self) -> (usize, Option<usize>) {
	let len = usize::from(self.count - self.index);
	(0, Some(len))
	}
	}

	impl ExactSizeIterator for VernauxIter<'_> {}

	impl FusedIterator for VernauxIter<'_> {}

	/// An ELF [Version Need Auxiliary][lsb-vernaux] entry.
	///
	/// [lsb-vernaux]: https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#VERNEEDEXTFIG
	#[derive(Debug)]
	pub struct Vernaux {
	/// Dependency name hash value (ELF hash function).
	pub vna_hash: u32,
	/// Dependency information flag bitmask.
	pub vna_flags: u16,
	/// Object file version identifier used in the .gnu.version symbol version array. Bit number 15
	/// controls whether or not the object is hidden; if this bit is set, the object cannot be used
	/// and the static linker will ignore the symbol's presence in the object.
	pub vna_other: u16,
	/// Offset to the dependency name string in the section header, in bytes.
	pub vna_name: usize,
	/// Offset to the next vernaux entry, in bytes.
	pub vna_next: u32,
	}

	#[cfg(test)]
	mod test {
	use super::{ElfVerdaux, ElfVerdef, ElfVernaux, ElfVerneed, ElfVersym};
	use super::{Versym, VERSYM_HIDDEN, VER_NDX_GLOBAL, VER_NDX_LOCAL};
	use core::mem::size_of;

	#[test]
	fn check_size() {
	assert_eq!(2, size_of::<ElfVersym>());
	assert_eq!(20, size_of::<ElfVerdef>());
	assert_eq!(8, size_of::<ElfVerdaux>());
	assert_eq!(16, size_of::<ElfVerneed>());
	assert_eq!(16, size_of::<ElfVernaux>());
	}

	#[test]
	fn check_versym() {
	let local = Versym {
	vs_val: VER_NDX_LOCAL,
	};
	assert_eq!(true, local.is_local());
	assert_eq!(false, local.is_global());
	assert_eq!(false, local.is_hidden());
	assert_eq!(VER_NDX_LOCAL, local.version());

	let global = Versym {
	vs_val: VER_NDX_GLOBAL,
	};
	assert_eq!(false, global.is_local());
	assert_eq!(true, global.is_global());
	assert_eq!(false, global.is_hidden());
	assert_eq!(VER_NDX_GLOBAL, global.version());

	let hidden = Versym {
	vs_val: VERSYM_HIDDEN,
	};
	assert_eq!(false, hidden.is_local());
	assert_eq!(false, hidden.is_global());
	assert_eq!(true, hidden.is_hidden());
	assert_eq!(0, hidden.version());

	let hidden = Versym {
	vs_val: VERSYM_HIDDEN \| 0x123,
	};
	assert_eq!(false, hidden.is_local());
	assert_eq!(false, hidden.is_global());
	assert_eq!(true, hidden.is_hidden());
	assert_eq!(0x123, hidden.version());
	}
	}