From a990de90fe41456a23e58bd087d2f107d321f3a1 Mon Sep 17 00:00:00 2001
From: Valentin Popov <valentin@popov.link>
Date: Fri, 19 Jul 2024 16:37:58 +0400
Subject: Deleted vendor folder

---
 vendor/object/src/read/any.rs | 1328 -----------------------------------------
 1 file changed, 1328 deletions(-)
 delete mode 100644 vendor/object/src/read/any.rs

(limited to 'vendor/object/src/read/any.rs')

diff --git a/vendor/object/src/read/any.rs b/vendor/object/src/read/any.rs
deleted file mode 100644
index a14e56d..0000000
--- a/vendor/object/src/read/any.rs
+++ /dev/null
@@ -1,1328 +0,0 @@
-use alloc::fmt;
-use alloc::vec::Vec;
-use core::marker::PhantomData;
-
-#[cfg(feature = "coff")]
-use crate::read::coff;
-#[cfg(feature = "elf")]
-use crate::read::elf;
-#[cfg(feature = "macho")]
-use crate::read::macho;
-#[cfg(feature = "pe")]
-use crate::read::pe;
-#[cfg(feature = "wasm")]
-use crate::read::wasm;
-#[cfg(feature = "xcoff")]
-use crate::read::xcoff;
-use crate::read::{
-    self, Architecture, BinaryFormat, CodeView, ComdatKind, CompressedData, CompressedFileRange,
-    Error, Export, FileFlags, FileKind, Import, Object, ObjectComdat, ObjectKind, ObjectMap,
-    ObjectSection, ObjectSegment, ObjectSymbol, ObjectSymbolTable, ReadRef, Relocation, Result,
-    SectionFlags, SectionIndex, SectionKind, SegmentFlags, SymbolFlags, SymbolIndex, SymbolKind,
-    SymbolMap, SymbolMapName, SymbolScope, SymbolSection,
-};
-#[allow(unused_imports)]
-use crate::{AddressSize, Endian, Endianness, SubArchitecture};
-
-/// Evaluate an expression on the contents of a file format enum.
-///
-/// This is a hack to avoid virtual calls.
-macro_rules! with_inner {
-    ($inner:expr, $enum:ident, | $var:ident | $body:expr) => {
-        match $inner {
-            #[cfg(feature = "coff")]
-            $enum::Coff(ref $var) => $body,
-            #[cfg(feature = "coff")]
-            $enum::CoffBig(ref $var) => $body,
-            #[cfg(feature = "elf")]
-            $enum::Elf32(ref $var) => $body,
-            #[cfg(feature = "elf")]
-            $enum::Elf64(ref $var) => $body,
-            #[cfg(feature = "macho")]
-            $enum::MachO32(ref $var) => $body,
-            #[cfg(feature = "macho")]
-            $enum::MachO64(ref $var) => $body,
-            #[cfg(feature = "pe")]
-            $enum::Pe32(ref $var) => $body,
-            #[cfg(feature = "pe")]
-            $enum::Pe64(ref $var) => $body,
-            #[cfg(feature = "wasm")]
-            $enum::Wasm(ref $var) => $body,
-            #[cfg(feature = "xcoff")]
-            $enum::Xcoff32(ref $var) => $body,
-            #[cfg(feature = "xcoff")]
-            $enum::Xcoff64(ref $var) => $body,
-        }
-    };
-}
-
-macro_rules! with_inner_mut {
-    ($inner:expr, $enum:ident, | $var:ident | $body:expr) => {
-        match $inner {
-            #[cfg(feature = "coff")]
-            $enum::Coff(ref mut $var) => $body,
-            #[cfg(feature = "coff")]
-            $enum::CoffBig(ref mut $var) => $body,
-            #[cfg(feature = "elf")]
-            $enum::Elf32(ref mut $var) => $body,
-            #[cfg(feature = "elf")]
-            $enum::Elf64(ref mut $var) => $body,
-            #[cfg(feature = "macho")]
-            $enum::MachO32(ref mut $var) => $body,
-            #[cfg(feature = "macho")]
-            $enum::MachO64(ref mut $var) => $body,
-            #[cfg(feature = "pe")]
-            $enum::Pe32(ref mut $var) => $body,
-            #[cfg(feature = "pe")]
-            $enum::Pe64(ref mut $var) => $body,
-            #[cfg(feature = "wasm")]
-            $enum::Wasm(ref mut $var) => $body,
-            #[cfg(feature = "xcoff")]
-            $enum::Xcoff32(ref mut $var) => $body,
-            #[cfg(feature = "xcoff")]
-            $enum::Xcoff64(ref mut $var) => $body,
-        }
-    };
-}
-
-/// Like `with_inner!`, but wraps the result in another enum.
-macro_rules! map_inner {
-    ($inner:expr, $from:ident, $to:ident, | $var:ident | $body:expr) => {
-        match $inner {
-            #[cfg(feature = "coff")]
-            $from::Coff(ref $var) => $to::Coff($body),
-            #[cfg(feature = "coff")]
-            $from::CoffBig(ref $var) => $to::CoffBig($body),
-            #[cfg(feature = "elf")]
-            $from::Elf32(ref $var) => $to::Elf32($body),
-            #[cfg(feature = "elf")]
-            $from::Elf64(ref $var) => $to::Elf64($body),
-            #[cfg(feature = "macho")]
-            $from::MachO32(ref $var) => $to::MachO32($body),
-            #[cfg(feature = "macho")]
-            $from::MachO64(ref $var) => $to::MachO64($body),
-            #[cfg(feature = "pe")]
-            $from::Pe32(ref $var) => $to::Pe32($body),
-            #[cfg(feature = "pe")]
-            $from::Pe64(ref $var) => $to::Pe64($body),
-            #[cfg(feature = "wasm")]
-            $from::Wasm(ref $var) => $to::Wasm($body),
-            #[cfg(feature = "xcoff")]
-            $from::Xcoff32(ref $var) => $to::Xcoff32($body),
-            #[cfg(feature = "xcoff")]
-            $from::Xcoff64(ref $var) => $to::Xcoff64($body),
-        }
-    };
-}
-
-/// Like `map_inner!`, but the result is a Result or Option.
-macro_rules! map_inner_option {
-    ($inner:expr, $from:ident, $to:ident, | $var:ident | $body:expr) => {
-        match $inner {
-            #[cfg(feature = "coff")]
-            $from::Coff(ref $var) => $body.map($to::Coff),
-            #[cfg(feature = "coff")]
-            $from::CoffBig(ref $var) => $body.map($to::CoffBig),
-            #[cfg(feature = "elf")]
-            $from::Elf32(ref $var) => $body.map($to::Elf32),
-            #[cfg(feature = "elf")]
-            $from::Elf64(ref $var) => $body.map($to::Elf64),
-            #[cfg(feature = "macho")]
-            $from::MachO32(ref $var) => $body.map($to::MachO32),
-            #[cfg(feature = "macho")]
-            $from::MachO64(ref $var) => $body.map($to::MachO64),
-            #[cfg(feature = "pe")]
-            $from::Pe32(ref $var) => $body.map($to::Pe32),
-            #[cfg(feature = "pe")]
-            $from::Pe64(ref $var) => $body.map($to::Pe64),
-            #[cfg(feature = "wasm")]
-            $from::Wasm(ref $var) => $body.map($to::Wasm),
-            #[cfg(feature = "xcoff")]
-            $from::Xcoff32(ref $var) => $body.map($to::Xcoff32),
-            #[cfg(feature = "xcoff")]
-            $from::Xcoff64(ref $var) => $body.map($to::Xcoff64),
-        }
-    };
-}
-
-macro_rules! map_inner_option_mut {
-    ($inner:expr, $from:ident, $to:ident, | $var:ident | $body:expr) => {
-        match $inner {
-            #[cfg(feature = "coff")]
-            $from::Coff(ref mut $var) => $body.map($to::Coff),
-            #[cfg(feature = "coff")]
-            $from::CoffBig(ref mut $var) => $body.map($to::CoffBig),
-            #[cfg(feature = "elf")]
-            $from::Elf32(ref mut $var) => $body.map($to::Elf32),
-            #[cfg(feature = "elf")]
-            $from::Elf64(ref mut $var) => $body.map($to::Elf64),
-            #[cfg(feature = "macho")]
-            $from::MachO32(ref mut $var) => $body.map($to::MachO32),
-            #[cfg(feature = "macho")]
-            $from::MachO64(ref mut $var) => $body.map($to::MachO64),
-            #[cfg(feature = "pe")]
-            $from::Pe32(ref mut $var) => $body.map($to::Pe32),
-            #[cfg(feature = "pe")]
-            $from::Pe64(ref mut $var) => $body.map($to::Pe64),
-            #[cfg(feature = "wasm")]
-            $from::Wasm(ref mut $var) => $body.map($to::Wasm),
-            #[cfg(feature = "xcoff")]
-            $from::Xcoff32(ref mut $var) => $body.map($to::Xcoff32),
-            #[cfg(feature = "xcoff")]
-            $from::Xcoff64(ref mut $var) => $body.map($to::Xcoff64),
-        }
-    };
-}
-
-/// Call `next` for a file format iterator.
-macro_rules! next_inner {
-    ($inner:expr, $from:ident, $to:ident) => {
-        match $inner {
-            #[cfg(feature = "coff")]
-            $from::Coff(ref mut iter) => iter.next().map($to::Coff),
-            #[cfg(feature = "coff")]
-            $from::CoffBig(ref mut iter) => iter.next().map($to::CoffBig),
-            #[cfg(feature = "elf")]
-            $from::Elf32(ref mut iter) => iter.next().map($to::Elf32),
-            #[cfg(feature = "elf")]
-            $from::Elf64(ref mut iter) => iter.next().map($to::Elf64),
-            #[cfg(feature = "macho")]
-            $from::MachO32(ref mut iter) => iter.next().map($to::MachO32),
-            #[cfg(feature = "macho")]
-            $from::MachO64(ref mut iter) => iter.next().map($to::MachO64),
-            #[cfg(feature = "pe")]
-            $from::Pe32(ref mut iter) => iter.next().map($to::Pe32),
-            #[cfg(feature = "pe")]
-            $from::Pe64(ref mut iter) => iter.next().map($to::Pe64),
-            #[cfg(feature = "wasm")]
-            $from::Wasm(ref mut iter) => iter.next().map($to::Wasm),
-            #[cfg(feature = "xcoff")]
-            $from::Xcoff32(ref mut iter) => iter.next().map($to::Xcoff32),
-            #[cfg(feature = "xcoff")]
-            $from::Xcoff64(ref mut iter) => iter.next().map($to::Xcoff64),
-        }
-    };
-}
-
-/// An object file that can be any supported file format.
-///
-/// Most functionality is provided by the [`Object`] trait implementation.
-#[derive(Debug)]
-#[non_exhaustive]
-#[allow(missing_docs)]
-pub enum File<'data, R: ReadRef<'data> = &'data [u8]> {
-    #[cfg(feature = "coff")]
-    Coff(coff::CoffFile<'data, R>),
-    #[cfg(feature = "coff")]
-    CoffBig(coff::CoffBigFile<'data, R>),
-    #[cfg(feature = "elf")]
-    Elf32(elf::ElfFile32<'data, Endianness, R>),
-    #[cfg(feature = "elf")]
-    Elf64(elf::ElfFile64<'data, Endianness, R>),
-    #[cfg(feature = "macho")]
-    MachO32(macho::MachOFile32<'data, Endianness, R>),
-    #[cfg(feature = "macho")]
-    MachO64(macho::MachOFile64<'data, Endianness, R>),
-    #[cfg(feature = "pe")]
-    Pe32(pe::PeFile32<'data, R>),
-    #[cfg(feature = "pe")]
-    Pe64(pe::PeFile64<'data, R>),
-    #[cfg(feature = "wasm")]
-    Wasm(wasm::WasmFile<'data, R>),
-    #[cfg(feature = "xcoff")]
-    Xcoff32(xcoff::XcoffFile32<'data, R>),
-    #[cfg(feature = "xcoff")]
-    Xcoff64(xcoff::XcoffFile64<'data, R>),
-}
-
-impl<'data, R: ReadRef<'data>> File<'data, R> {
-    /// Parse the raw file data.
-    pub fn parse(data: R) -> Result<Self> {
-        Ok(match FileKind::parse(data)? {
-            #[cfg(feature = "elf")]
-            FileKind::Elf32 => File::Elf32(elf::ElfFile32::parse(data)?),
-            #[cfg(feature = "elf")]
-            FileKind::Elf64 => File::Elf64(elf::ElfFile64::parse(data)?),
-            #[cfg(feature = "macho")]
-            FileKind::MachO32 => File::MachO32(macho::MachOFile32::parse(data)?),
-            #[cfg(feature = "macho")]
-            FileKind::MachO64 => File::MachO64(macho::MachOFile64::parse(data)?),
-            #[cfg(feature = "wasm")]
-            FileKind::Wasm => File::Wasm(wasm::WasmFile::parse(data)?),
-            #[cfg(feature = "pe")]
-            FileKind::Pe32 => File::Pe32(pe::PeFile32::parse(data)?),
-            #[cfg(feature = "pe")]
-            FileKind::Pe64 => File::Pe64(pe::PeFile64::parse(data)?),
-            #[cfg(feature = "coff")]
-            FileKind::Coff => File::Coff(coff::CoffFile::parse(data)?),
-            #[cfg(feature = "coff")]
-            FileKind::CoffBig => File::CoffBig(coff::CoffBigFile::parse(data)?),
-            #[cfg(feature = "xcoff")]
-            FileKind::Xcoff32 => File::Xcoff32(xcoff::XcoffFile32::parse(data)?),
-            #[cfg(feature = "xcoff")]
-            FileKind::Xcoff64 => File::Xcoff64(xcoff::XcoffFile64::parse(data)?),
-            #[allow(unreachable_patterns)]
-            _ => return Err(Error("Unsupported file format")),
-        })
-    }
-
-    /// Parse a Mach-O image from the dyld shared cache.
-    #[cfg(feature = "macho")]
-    pub fn parse_dyld_cache_image<'cache, E: Endian>(
-        image: &macho::DyldCacheImage<'data, 'cache, E, R>,
-    ) -> Result<Self> {
-        Ok(match image.cache.architecture().address_size() {
-            Some(AddressSize::U64) => {
-                File::MachO64(macho::MachOFile64::parse_dyld_cache_image(image)?)
-            }
-            Some(AddressSize::U32) => {
-                File::MachO32(macho::MachOFile32::parse_dyld_cache_image(image)?)
-            }
-            _ => return Err(Error("Unsupported file format")),
-        })
-    }
-
-    /// Return the file format.
-    pub fn format(&self) -> BinaryFormat {
-        match self {
-            #[cfg(feature = "coff")]
-            File::Coff(_) | File::CoffBig(_) => BinaryFormat::Coff,
-            #[cfg(feature = "elf")]
-            File::Elf32(_) | File::Elf64(_) => BinaryFormat::Elf,
-            #[cfg(feature = "macho")]
-            File::MachO32(_) | File::MachO64(_) => BinaryFormat::MachO,
-            #[cfg(feature = "pe")]
-            File::Pe32(_) | File::Pe64(_) => BinaryFormat::Pe,
-            #[cfg(feature = "wasm")]
-            File::Wasm(_) => BinaryFormat::Wasm,
-            #[cfg(feature = "xcoff")]
-            File::Xcoff32(_) | File::Xcoff64(_) => BinaryFormat::Xcoff,
-        }
-    }
-}
-
-impl<'data, R: ReadRef<'data>> read::private::Sealed for File<'data, R> {}
-
-impl<'data, 'file, R> Object<'data, 'file> for File<'data, R>
-where
-    'data: 'file,
-    R: 'file + ReadRef<'data>,
-{
-    type Segment = Segment<'data, 'file, R>;
-    type SegmentIterator = SegmentIterator<'data, 'file, R>;
-    type Section = Section<'data, 'file, R>;
-    type SectionIterator = SectionIterator<'data, 'file, R>;
-    type Comdat = Comdat<'data, 'file, R>;
-    type ComdatIterator = ComdatIterator<'data, 'file, R>;
-    type Symbol = Symbol<'data, 'file, R>;
-    type SymbolIterator = SymbolIterator<'data, 'file, R>;
-    type SymbolTable = SymbolTable<'data, 'file, R>;
-    type DynamicRelocationIterator = DynamicRelocationIterator<'data, 'file, R>;
-
-    fn architecture(&self) -> Architecture {
-        with_inner!(self, File, |x| x.architecture())
-    }
-
-    fn sub_architecture(&self) -> Option<SubArchitecture> {
-        with_inner!(self, File, |x| x.sub_architecture())
-    }
-
-    fn is_little_endian(&self) -> bool {
-        with_inner!(self, File, |x| x.is_little_endian())
-    }
-
-    fn is_64(&self) -> bool {
-        with_inner!(self, File, |x| x.is_64())
-    }
-
-    fn kind(&self) -> ObjectKind {
-        with_inner!(self, File, |x| x.kind())
-    }
-
-    fn segments(&'file self) -> SegmentIterator<'data, 'file, R> {
-        SegmentIterator {
-            inner: map_inner!(self, File, SegmentIteratorInternal, |x| x.segments()),
-        }
-    }
-
-    fn section_by_name_bytes(&'file self, section_name: &[u8]) -> Option<Section<'data, 'file, R>> {
-        map_inner_option!(self, File, SectionInternal, |x| x
-            .section_by_name_bytes(section_name))
-        .map(|inner| Section { inner })
-    }
-
-    fn section_by_index(&'file self, index: SectionIndex) -> Result<Section<'data, 'file, R>> {
-        map_inner_option!(self, File, SectionInternal, |x| x.section_by_index(index))
-            .map(|inner| Section { inner })
-    }
-
-    fn sections(&'file self) -> SectionIterator<'data, 'file, R> {
-        SectionIterator {
-            inner: map_inner!(self, File, SectionIteratorInternal, |x| x.sections()),
-        }
-    }
-
-    fn comdats(&'file self) -> ComdatIterator<'data, 'file, R> {
-        ComdatIterator {
-            inner: map_inner!(self, File, ComdatIteratorInternal, |x| x.comdats()),
-        }
-    }
-
-    fn symbol_by_index(&'file self, index: SymbolIndex) -> Result<Symbol<'data, 'file, R>> {
-        map_inner_option!(self, File, SymbolInternal, |x| x
-            .symbol_by_index(index)
-            .map(|x| (x, PhantomData)))
-        .map(|inner| Symbol { inner })
-    }
-
-    fn symbols(&'file self) -> SymbolIterator<'data, 'file, R> {
-        SymbolIterator {
-            inner: map_inner!(self, File, SymbolIteratorInternal, |x| (
-                x.symbols(),
-                PhantomData
-            )),
-        }
-    }
-
-    fn symbol_table(&'file self) -> Option<SymbolTable<'data, 'file, R>> {
-        map_inner_option!(self, File, SymbolTableInternal, |x| x
-            .symbol_table()
-            .map(|x| (x, PhantomData)))
-        .map(|inner| SymbolTable { inner })
-    }
-
-    fn dynamic_symbols(&'file self) -> SymbolIterator<'data, 'file, R> {
-        SymbolIterator {
-            inner: map_inner!(self, File, SymbolIteratorInternal, |x| (
-                x.dynamic_symbols(),
-                PhantomData
-            )),
-        }
-    }
-
-    fn dynamic_symbol_table(&'file self) -> Option<SymbolTable<'data, 'file, R>> {
-        map_inner_option!(self, File, SymbolTableInternal, |x| x
-            .dynamic_symbol_table()
-            .map(|x| (x, PhantomData)))
-        .map(|inner| SymbolTable { inner })
-    }
-
-    #[cfg(feature = "elf")]
-    fn dynamic_relocations(&'file self) -> Option<DynamicRelocationIterator<'data, 'file, R>> {
-        let inner = match self {
-            File::Elf32(ref elf) => {
-                DynamicRelocationIteratorInternal::Elf32(elf.dynamic_relocations()?)
-            }
-            File::Elf64(ref elf) => {
-                DynamicRelocationIteratorInternal::Elf64(elf.dynamic_relocations()?)
-            }
-            #[allow(unreachable_patterns)]
-            _ => return None,
-        };
-        Some(DynamicRelocationIterator { inner })
-    }
-
-    #[cfg(not(feature = "elf"))]
-    fn dynamic_relocations(&'file self) -> Option<DynamicRelocationIterator<'data, 'file, R>> {
-        None
-    }
-
-    fn symbol_map(&self) -> SymbolMap<SymbolMapName<'data>> {
-        with_inner!(self, File, |x| x.symbol_map())
-    }
-
-    fn object_map(&self) -> ObjectMap<'data> {
-        with_inner!(self, File, |x| x.object_map())
-    }
-
-    fn imports(&self) -> Result<Vec<Import<'data>>> {
-        with_inner!(self, File, |x| x.imports())
-    }
-
-    fn exports(&self) -> Result<Vec<Export<'data>>> {
-        with_inner!(self, File, |x| x.exports())
-    }
-
-    fn has_debug_symbols(&self) -> bool {
-        with_inner!(self, File, |x| x.has_debug_symbols())
-    }
-
-    #[inline]
-    fn mach_uuid(&self) -> Result<Option<[u8; 16]>> {
-        with_inner!(self, File, |x| x.mach_uuid())
-    }
-
-    #[inline]
-    fn build_id(&self) -> Result<Option<&'data [u8]>> {
-        with_inner!(self, File, |x| x.build_id())
-    }
-
-    #[inline]
-    fn gnu_debuglink(&self) -> Result<Option<(&'data [u8], u32)>> {
-        with_inner!(self, File, |x| x.gnu_debuglink())
-    }
-
-    #[inline]
-    fn gnu_debugaltlink(&self) -> Result<Option<(&'data [u8], &'data [u8])>> {
-        with_inner!(self, File, |x| x.gnu_debugaltlink())
-    }
-
-    #[inline]
-    fn pdb_info(&self) -> Result<Option<CodeView<'_>>> {
-        with_inner!(self, File, |x| x.pdb_info())
-    }
-
-    fn relative_address_base(&self) -> u64 {
-        with_inner!(self, File, |x| x.relative_address_base())
-    }
-
-    fn entry(&self) -> u64 {
-        with_inner!(self, File, |x| x.entry())
-    }
-
-    fn flags(&self) -> FileFlags {
-        with_inner!(self, File, |x| x.flags())
-    }
-}
-
-/// An iterator for the loadable segments in a [`File`].
-#[derive(Debug)]
-pub struct SegmentIterator<'data, 'file, R: ReadRef<'data> = &'data [u8]> {
-    inner: SegmentIteratorInternal<'data, 'file, R>,
-}
-
-#[derive(Debug)]
-enum SegmentIteratorInternal<'data, 'file, R: ReadRef<'data>> {
-    #[cfg(feature = "coff")]
-    Coff(coff::CoffSegmentIterator<'data, 'file, R>),
-    #[cfg(feature = "coff")]
-    CoffBig(coff::CoffBigSegmentIterator<'data, 'file, R>),
-    #[cfg(feature = "elf")]
-    Elf32(elf::ElfSegmentIterator32<'data, 'file, Endianness, R>),
-    #[cfg(feature = "elf")]
-    Elf64(elf::ElfSegmentIterator64<'data, 'file, Endianness, R>),
-    #[cfg(feature = "macho")]
-    MachO32(macho::MachOSegmentIterator32<'data, 'file, Endianness, R>),
-    #[cfg(feature = "macho")]
-    MachO64(macho::MachOSegmentIterator64<'data, 'file, Endianness, R>),
-    #[cfg(feature = "pe")]
-    Pe32(pe::PeSegmentIterator32<'data, 'file, R>),
-    #[cfg(feature = "pe")]
-    Pe64(pe::PeSegmentIterator64<'data, 'file, R>),
-    #[cfg(feature = "wasm")]
-    Wasm(wasm::WasmSegmentIterator<'data, 'file, R>),
-    #[cfg(feature = "xcoff")]
-    Xcoff32(xcoff::XcoffSegmentIterator32<'data, 'file, R>),
-    #[cfg(feature = "xcoff")]
-    Xcoff64(xcoff::XcoffSegmentIterator64<'data, 'file, R>),
-}
-
-impl<'data, 'file, R: ReadRef<'data>> Iterator for SegmentIterator<'data, 'file, R> {
-    type Item = Segment<'data, 'file, R>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        next_inner!(self.inner, SegmentIteratorInternal, SegmentInternal)
-            .map(|inner| Segment { inner })
-    }
-}
-
-/// A loadable segment in a [`File`].
-///
-/// Most functionality is provided by the [`ObjectSegment`] trait implementation.
-pub struct Segment<'data, 'file, R: ReadRef<'data> = &'data [u8]> {
-    inner: SegmentInternal<'data, 'file, R>,
-}
-
-#[derive(Debug)]
-enum SegmentInternal<'data, 'file, R: ReadRef<'data>> {
-    #[cfg(feature = "coff")]
-    Coff(coff::CoffSegment<'data, 'file, R>),
-    #[cfg(feature = "coff")]
-    CoffBig(coff::CoffBigSegment<'data, 'file, R>),
-    #[cfg(feature = "elf")]
-    Elf32(elf::ElfSegment32<'data, 'file, Endianness, R>),
-    #[cfg(feature = "elf")]
-    Elf64(elf::ElfSegment64<'data, 'file, Endianness, R>),
-    #[cfg(feature = "macho")]
-    MachO32(macho::MachOSegment32<'data, 'file, Endianness, R>),
-    #[cfg(feature = "macho")]
-    MachO64(macho::MachOSegment64<'data, 'file, Endianness, R>),
-    #[cfg(feature = "pe")]
-    Pe32(pe::PeSegment32<'data, 'file, R>),
-    #[cfg(feature = "pe")]
-    Pe64(pe::PeSegment64<'data, 'file, R>),
-    #[cfg(feature = "wasm")]
-    Wasm(wasm::WasmSegment<'data, 'file, R>),
-    #[cfg(feature = "xcoff")]
-    Xcoff32(xcoff::XcoffSegment32<'data, 'file, R>),
-    #[cfg(feature = "xcoff")]
-    Xcoff64(xcoff::XcoffSegment64<'data, 'file, R>),
-}
-
-impl<'data, 'file, R: ReadRef<'data>> fmt::Debug for Segment<'data, 'file, R> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // It's painful to do much better than this
-        let mut s = f.debug_struct("Segment");
-        match self.name() {
-            Ok(Some(ref name)) => {
-                s.field("name", name);
-            }
-            Ok(None) => {}
-            Err(_) => {
-                s.field("name", &"<invalid>");
-            }
-        }
-        s.field("address", &self.address())
-            .field("size", &self.size())
-            .finish()
-    }
-}
-
-impl<'data, 'file, R: ReadRef<'data>> read::private::Sealed for Segment<'data, 'file, R> {}
-
-impl<'data, 'file, R: ReadRef<'data>> ObjectSegment<'data> for Segment<'data, 'file, R> {
-    fn address(&self) -> u64 {
-        with_inner!(self.inner, SegmentInternal, |x| x.address())
-    }
-
-    fn size(&self) -> u64 {
-        with_inner!(self.inner, SegmentInternal, |x| x.size())
-    }
-
-    fn align(&self) -> u64 {
-        with_inner!(self.inner, SegmentInternal, |x| x.align())
-    }
-
-    fn file_range(&self) -> (u64, u64) {
-        with_inner!(self.inner, SegmentInternal, |x| x.file_range())
-    }
-
-    fn data(&self) -> Result<&'data [u8]> {
-        with_inner!(self.inner, SegmentInternal, |x| x.data())
-    }
-
-    fn data_range(&self, address: u64, size: u64) -> Result<Option<&'data [u8]>> {
-        with_inner!(self.inner, SegmentInternal, |x| x.data_range(address, size))
-    }
-
-    fn name_bytes(&self) -> Result<Option<&[u8]>> {
-        with_inner!(self.inner, SegmentInternal, |x| x.name_bytes())
-    }
-
-    fn name(&self) -> Result<Option<&str>> {
-        with_inner!(self.inner, SegmentInternal, |x| x.name())
-    }
-
-    fn flags(&self) -> SegmentFlags {
-        with_inner!(self.inner, SegmentInternal, |x| x.flags())
-    }
-}
-
-/// An iterator for the sections in a [`File`].
-#[derive(Debug)]
-pub struct SectionIterator<'data, 'file, R: ReadRef<'data> = &'data [u8]> {
-    inner: SectionIteratorInternal<'data, 'file, R>,
-}
-
-// we wrap our enums in a struct so that they are kept private.
-#[derive(Debug)]
-enum SectionIteratorInternal<'data, 'file, R: ReadRef<'data>> {
-    #[cfg(feature = "coff")]
-    Coff(coff::CoffSectionIterator<'data, 'file, R>),
-    #[cfg(feature = "coff")]
-    CoffBig(coff::CoffBigSectionIterator<'data, 'file, R>),
-    #[cfg(feature = "elf")]
-    Elf32(elf::ElfSectionIterator32<'data, 'file, Endianness, R>),
-    #[cfg(feature = "elf")]
-    Elf64(elf::ElfSectionIterator64<'data, 'file, Endianness, R>),
-    #[cfg(feature = "macho")]
-    MachO32(macho::MachOSectionIterator32<'data, 'file, Endianness, R>),
-    #[cfg(feature = "macho")]
-    MachO64(macho::MachOSectionIterator64<'data, 'file, Endianness, R>),
-    #[cfg(feature = "pe")]
-    Pe32(pe::PeSectionIterator32<'data, 'file, R>),
-    #[cfg(feature = "pe")]
-    Pe64(pe::PeSectionIterator64<'data, 'file, R>),
-    #[cfg(feature = "wasm")]
-    Wasm(wasm::WasmSectionIterator<'data, 'file, R>),
-    #[cfg(feature = "xcoff")]
-    Xcoff32(xcoff::XcoffSectionIterator32<'data, 'file, R>),
-    #[cfg(feature = "xcoff")]
-    Xcoff64(xcoff::XcoffSectionIterator64<'data, 'file, R>),
-}
-
-impl<'data, 'file, R: ReadRef<'data>> Iterator for SectionIterator<'data, 'file, R> {
-    type Item = Section<'data, 'file, R>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        next_inner!(self.inner, SectionIteratorInternal, SectionInternal)
-            .map(|inner| Section { inner })
-    }
-}
-
-/// A section in a [`File`].
-///
-/// Most functionality is provided by the [`ObjectSection`] trait implementation.
-pub struct Section<'data, 'file, R: ReadRef<'data> = &'data [u8]> {
-    inner: SectionInternal<'data, 'file, R>,
-}
-
-enum SectionInternal<'data, 'file, R: ReadRef<'data>> {
-    #[cfg(feature = "coff")]
-    Coff(coff::CoffSection<'data, 'file, R>),
-    #[cfg(feature = "coff")]
-    CoffBig(coff::CoffBigSection<'data, 'file, R>),
-    #[cfg(feature = "elf")]
-    Elf32(elf::ElfSection32<'data, 'file, Endianness, R>),
-    #[cfg(feature = "elf")]
-    Elf64(elf::ElfSection64<'data, 'file, Endianness, R>),
-    #[cfg(feature = "macho")]
-    MachO32(macho::MachOSection32<'data, 'file, Endianness, R>),
-    #[cfg(feature = "macho")]
-    MachO64(macho::MachOSection64<'data, 'file, Endianness, R>),
-    #[cfg(feature = "pe")]
-    Pe32(pe::PeSection32<'data, 'file, R>),
-    #[cfg(feature = "pe")]
-    Pe64(pe::PeSection64<'data, 'file, R>),
-    #[cfg(feature = "wasm")]
-    Wasm(wasm::WasmSection<'data, 'file, R>),
-    #[cfg(feature = "xcoff")]
-    Xcoff32(xcoff::XcoffSection32<'data, 'file, R>),
-    #[cfg(feature = "xcoff")]
-    Xcoff64(xcoff::XcoffSection64<'data, 'file, R>),
-}
-
-impl<'data, 'file, R: ReadRef<'data>> fmt::Debug for Section<'data, 'file, R> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // It's painful to do much better than this
-        let mut s = f.debug_struct("Section");
-        match self.segment_name() {
-            Ok(Some(ref name)) => {
-                s.field("segment", name);
-            }
-            Ok(None) => {}
-            Err(_) => {
-                s.field("segment", &"<invalid>");
-            }
-        }
-        s.field("name", &self.name().unwrap_or("<invalid>"))
-            .field("address", &self.address())
-            .field("size", &self.size())
-            .field("align", &self.align())
-            .field("kind", &self.kind())
-            .field("flags", &self.flags())
-            .finish()
-    }
-}
-
-impl<'data, 'file, R: ReadRef<'data>> read::private::Sealed for Section<'data, 'file, R> {}
-
-impl<'data, 'file, R: ReadRef<'data>> ObjectSection<'data> for Section<'data, 'file, R> {
-    type RelocationIterator = SectionRelocationIterator<'data, 'file, R>;
-
-    fn index(&self) -> SectionIndex {
-        with_inner!(self.inner, SectionInternal, |x| x.index())
-    }
-
-    fn address(&self) -> u64 {
-        with_inner!(self.inner, SectionInternal, |x| x.address())
-    }
-
-    fn size(&self) -> u64 {
-        with_inner!(self.inner, SectionInternal, |x| x.size())
-    }
-
-    fn align(&self) -> u64 {
-        with_inner!(self.inner, SectionInternal, |x| x.align())
-    }
-
-    fn file_range(&self) -> Option<(u64, u64)> {
-        with_inner!(self.inner, SectionInternal, |x| x.file_range())
-    }
-
-    fn data(&self) -> Result<&'data [u8]> {
-        with_inner!(self.inner, SectionInternal, |x| x.data())
-    }
-
-    fn data_range(&self, address: u64, size: u64) -> Result<Option<&'data [u8]>> {
-        with_inner!(self.inner, SectionInternal, |x| x.data_range(address, size))
-    }
-
-    fn compressed_file_range(&self) -> Result<CompressedFileRange> {
-        with_inner!(self.inner, SectionInternal, |x| x.compressed_file_range())
-    }
-
-    fn compressed_data(&self) -> Result<CompressedData<'data>> {
-        with_inner!(self.inner, SectionInternal, |x| x.compressed_data())
-    }
-
-    fn name_bytes(&self) -> Result<&[u8]> {
-        with_inner!(self.inner, SectionInternal, |x| x.name_bytes())
-    }
-
-    fn name(&self) -> Result<&str> {
-        with_inner!(self.inner, SectionInternal, |x| x.name())
-    }
-
-    fn segment_name_bytes(&self) -> Result<Option<&[u8]>> {
-        with_inner!(self.inner, SectionInternal, |x| x.segment_name_bytes())
-    }
-
-    fn segment_name(&self) -> Result<Option<&str>> {
-        with_inner!(self.inner, SectionInternal, |x| x.segment_name())
-    }
-
-    fn kind(&self) -> SectionKind {
-        with_inner!(self.inner, SectionInternal, |x| x.kind())
-    }
-
-    fn relocations(&self) -> SectionRelocationIterator<'data, 'file, R> {
-        SectionRelocationIterator {
-            inner: map_inner!(
-                self.inner,
-                SectionInternal,
-                SectionRelocationIteratorInternal,
-                |x| x.relocations()
-            ),
-        }
-    }
-
-    fn flags(&self) -> SectionFlags {
-        with_inner!(self.inner, SectionInternal, |x| x.flags())
-    }
-}
-
-/// An iterator for the COMDAT section groups in a [`File`].
-#[derive(Debug)]
-pub struct ComdatIterator<'data, 'file, R: ReadRef<'data> = &'data [u8]> {
-    inner: ComdatIteratorInternal<'data, 'file, R>,
-}
-
-#[derive(Debug)]
-enum ComdatIteratorInternal<'data, 'file, R: ReadRef<'data>> {
-    #[cfg(feature = "coff")]
-    Coff(coff::CoffComdatIterator<'data, 'file, R>),
-    #[cfg(feature = "coff")]
-    CoffBig(coff::CoffBigComdatIterator<'data, 'file, R>),
-    #[cfg(feature = "elf")]
-    Elf32(elf::ElfComdatIterator32<'data, 'file, Endianness, R>),
-    #[cfg(feature = "elf")]
-    Elf64(elf::ElfComdatIterator64<'data, 'file, Endianness, R>),
-    #[cfg(feature = "macho")]
-    MachO32(macho::MachOComdatIterator32<'data, 'file, Endianness, R>),
-    #[cfg(feature = "macho")]
-    MachO64(macho::MachOComdatIterator64<'data, 'file, Endianness, R>),
-    #[cfg(feature = "pe")]
-    Pe32(pe::PeComdatIterator32<'data, 'file, R>),
-    #[cfg(feature = "pe")]
-    Pe64(pe::PeComdatIterator64<'data, 'file, R>),
-    #[cfg(feature = "wasm")]
-    Wasm(wasm::WasmComdatIterator<'data, 'file, R>),
-    #[cfg(feature = "xcoff")]
-    Xcoff32(xcoff::XcoffComdatIterator32<'data, 'file, R>),
-    #[cfg(feature = "xcoff")]
-    Xcoff64(xcoff::XcoffComdatIterator64<'data, 'file, R>),
-}
-
-impl<'data, 'file, R: ReadRef<'data>> Iterator for ComdatIterator<'data, 'file, R> {
-    type Item = Comdat<'data, 'file, R>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        next_inner!(self.inner, ComdatIteratorInternal, ComdatInternal)
-            .map(|inner| Comdat { inner })
-    }
-}
-
-/// A COMDAT section group in a [`File`].
-///
-/// Most functionality is provided by the [`ObjectComdat`] trait implementation.
-pub struct Comdat<'data, 'file, R: ReadRef<'data> = &'data [u8]> {
-    inner: ComdatInternal<'data, 'file, R>,
-}
-
-enum ComdatInternal<'data, 'file, R: ReadRef<'data>> {
-    #[cfg(feature = "coff")]
-    Coff(coff::CoffComdat<'data, 'file, R>),
-    #[cfg(feature = "coff")]
-    CoffBig(coff::CoffBigComdat<'data, 'file, R>),
-    #[cfg(feature = "elf")]
-    Elf32(elf::ElfComdat32<'data, 'file, Endianness, R>),
-    #[cfg(feature = "elf")]
-    Elf64(elf::ElfComdat64<'data, 'file, Endianness, R>),
-    #[cfg(feature = "macho")]
-    MachO32(macho::MachOComdat32<'data, 'file, Endianness, R>),
-    #[cfg(feature = "macho")]
-    MachO64(macho::MachOComdat64<'data, 'file, Endianness, R>),
-    #[cfg(feature = "pe")]
-    Pe32(pe::PeComdat32<'data, 'file, R>),
-    #[cfg(feature = "pe")]
-    Pe64(pe::PeComdat64<'data, 'file, R>),
-    #[cfg(feature = "wasm")]
-    Wasm(wasm::WasmComdat<'data, 'file, R>),
-    #[cfg(feature = "xcoff")]
-    Xcoff32(xcoff::XcoffComdat32<'data, 'file, R>),
-    #[cfg(feature = "xcoff")]
-    Xcoff64(xcoff::XcoffComdat64<'data, 'file, R>),
-}
-
-impl<'data, 'file, R: ReadRef<'data>> fmt::Debug for Comdat<'data, 'file, R> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut s = f.debug_struct("Comdat");
-        s.field("symbol", &self.symbol())
-            .field("name", &self.name().unwrap_or("<invalid>"))
-            .field("kind", &self.kind())
-            .finish()
-    }
-}
-
-impl<'data, 'file, R: ReadRef<'data>> read::private::Sealed for Comdat<'data, 'file, R> {}
-
-impl<'data, 'file, R: ReadRef<'data>> ObjectComdat<'data> for Comdat<'data, 'file, R> {
-    type SectionIterator = ComdatSectionIterator<'data, 'file, R>;
-
-    fn kind(&self) -> ComdatKind {
-        with_inner!(self.inner, ComdatInternal, |x| x.kind())
-    }
-
-    fn symbol(&self) -> SymbolIndex {
-        with_inner!(self.inner, ComdatInternal, |x| x.symbol())
-    }
-
-    fn name_bytes(&self) -> Result<&[u8]> {
-        with_inner!(self.inner, ComdatInternal, |x| x.name_bytes())
-    }
-
-    fn name(&self) -> Result<&str> {
-        with_inner!(self.inner, ComdatInternal, |x| x.name())
-    }
-
-    fn sections(&self) -> ComdatSectionIterator<'data, 'file, R> {
-        ComdatSectionIterator {
-            inner: map_inner!(
-                self.inner,
-                ComdatInternal,
-                ComdatSectionIteratorInternal,
-                |x| x.sections()
-            ),
-        }
-    }
-}
-
-/// An iterator for the sections in a [`Comdat`].
-#[derive(Debug)]
-pub struct ComdatSectionIterator<'data, 'file, R: ReadRef<'data> = &'data [u8]> {
-    inner: ComdatSectionIteratorInternal<'data, 'file, R>,
-}
-
-#[derive(Debug)]
-enum ComdatSectionIteratorInternal<'data, 'file, R: ReadRef<'data>> {
-    #[cfg(feature = "coff")]
-    Coff(coff::CoffComdatSectionIterator<'data, 'file, R>),
-    #[cfg(feature = "coff")]
-    CoffBig(coff::CoffBigComdatSectionIterator<'data, 'file, R>),
-    #[cfg(feature = "elf")]
-    Elf32(elf::ElfComdatSectionIterator32<'data, 'file, Endianness, R>),
-    #[cfg(feature = "elf")]
-    Elf64(elf::ElfComdatSectionIterator64<'data, 'file, Endianness, R>),
-    #[cfg(feature = "macho")]
-    MachO32(macho::MachOComdatSectionIterator32<'data, 'file, Endianness, R>),
-    #[cfg(feature = "macho")]
-    MachO64(macho::MachOComdatSectionIterator64<'data, 'file, Endianness, R>),
-    #[cfg(feature = "pe")]
-    Pe32(pe::PeComdatSectionIterator32<'data, 'file, R>),
-    #[cfg(feature = "pe")]
-    Pe64(pe::PeComdatSectionIterator64<'data, 'file, R>),
-    #[cfg(feature = "wasm")]
-    Wasm(wasm::WasmComdatSectionIterator<'data, 'file, R>),
-    #[cfg(feature = "xcoff")]
-    Xcoff32(xcoff::XcoffComdatSectionIterator32<'data, 'file, R>),
-    #[cfg(feature = "xcoff")]
-    Xcoff64(xcoff::XcoffComdatSectionIterator64<'data, 'file, R>),
-}
-
-impl<'data, 'file, R: ReadRef<'data>> Iterator for ComdatSectionIterator<'data, 'file, R> {
-    type Item = SectionIndex;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        with_inner_mut!(self.inner, ComdatSectionIteratorInternal, |x| x.next())
-    }
-}
-
-/// A symbol table in a [`File`].
-///
-/// Most functionality is provided by the [`ObjectSymbolTable`] trait implementation.
-#[derive(Debug)]
-pub struct SymbolTable<'data, 'file, R = &'data [u8]>
-where
-    R: ReadRef<'data>,
-{
-    inner: SymbolTableInternal<'data, 'file, R>,
-}
-
-#[derive(Debug)]
-enum SymbolTableInternal<'data, 'file, R>
-where
-    R: ReadRef<'data>,
-{
-    #[cfg(feature = "coff")]
-    Coff((coff::CoffSymbolTable<'data, 'file, R>, PhantomData<R>)),
-    #[cfg(feature = "coff")]
-    CoffBig((coff::CoffBigSymbolTable<'data, 'file, R>, PhantomData<R>)),
-    #[cfg(feature = "elf")]
-    Elf32(
-        (
-            elf::ElfSymbolTable32<'data, 'file, Endianness, R>,
-            PhantomData<R>,
-        ),
-    ),
-    #[cfg(feature = "elf")]
-    Elf64(
-        (
-            elf::ElfSymbolTable64<'data, 'file, Endianness, R>,
-            PhantomData<R>,
-        ),
-    ),
-    #[cfg(feature = "macho")]
-    MachO32(
-        (
-            macho::MachOSymbolTable32<'data, 'file, Endianness, R>,
-            PhantomData<()>,
-        ),
-    ),
-    #[cfg(feature = "macho")]
-    MachO64(
-        (
-            macho::MachOSymbolTable64<'data, 'file, Endianness, R>,
-            PhantomData<()>,
-        ),
-    ),
-    #[cfg(feature = "pe")]
-    Pe32((coff::CoffSymbolTable<'data, 'file, R>, PhantomData<R>)),
-    #[cfg(feature = "pe")]
-    Pe64((coff::CoffSymbolTable<'data, 'file, R>, PhantomData<R>)),
-    #[cfg(feature = "wasm")]
-    Wasm((wasm::WasmSymbolTable<'data, 'file>, PhantomData<R>)),
-    #[cfg(feature = "xcoff")]
-    Xcoff32((xcoff::XcoffSymbolTable32<'data, 'file, R>, PhantomData<R>)),
-    #[cfg(feature = "xcoff")]
-    Xcoff64((xcoff::XcoffSymbolTable64<'data, 'file, R>, PhantomData<R>)),
-}
-
-impl<'data, 'file, R: ReadRef<'data>> read::private::Sealed for SymbolTable<'data, 'file, R> {}
-
-impl<'data, 'file, R: ReadRef<'data>> ObjectSymbolTable<'data> for SymbolTable<'data, 'file, R> {
-    type Symbol = Symbol<'data, 'file, R>;
-    type SymbolIterator = SymbolIterator<'data, 'file, R>;
-
-    fn symbols(&self) -> Self::SymbolIterator {
-        SymbolIterator {
-            inner: map_inner!(
-                self.inner,
-                SymbolTableInternal,
-                SymbolIteratorInternal,
-                |x| (x.0.symbols(), PhantomData)
-            ),
-        }
-    }
-
-    fn symbol_by_index(&self, index: SymbolIndex) -> Result<Self::Symbol> {
-        map_inner_option!(self.inner, SymbolTableInternal, SymbolInternal, |x| x
-            .0
-            .symbol_by_index(index)
-            .map(|x| (x, PhantomData)))
-        .map(|inner| Symbol { inner })
-    }
-}
-
-/// An iterator for the symbols in a [`SymbolTable`].
-#[derive(Debug)]
-pub struct SymbolIterator<'data, 'file, R = &'data [u8]>
-where
-    R: ReadRef<'data>,
-{
-    inner: SymbolIteratorInternal<'data, 'file, R>,
-}
-
-#[derive(Debug)]
-enum SymbolIteratorInternal<'data, 'file, R>
-where
-    R: ReadRef<'data>,
-{
-    #[cfg(feature = "coff")]
-    Coff((coff::CoffSymbolIterator<'data, 'file, R>, PhantomData<R>)),
-    #[cfg(feature = "coff")]
-    CoffBig((coff::CoffBigSymbolIterator<'data, 'file, R>, PhantomData<R>)),
-    #[cfg(feature = "elf")]
-    Elf32(
-        (
-            elf::ElfSymbolIterator32<'data, 'file, Endianness, R>,
-            PhantomData<R>,
-        ),
-    ),
-    #[cfg(feature = "elf")]
-    Elf64(
-        (
-            elf::ElfSymbolIterator64<'data, 'file, Endianness, R>,
-            PhantomData<R>,
-        ),
-    ),
-    #[cfg(feature = "macho")]
-    MachO32(
-        (
-            macho::MachOSymbolIterator32<'data, 'file, Endianness, R>,
-            PhantomData<()>,
-        ),
-    ),
-    #[cfg(feature = "macho")]
-    MachO64(
-        (
-            macho::MachOSymbolIterator64<'data, 'file, Endianness, R>,
-            PhantomData<()>,
-        ),
-    ),
-    #[cfg(feature = "pe")]
-    Pe32((coff::CoffSymbolIterator<'data, 'file, R>, PhantomData<R>)),
-    #[cfg(feature = "pe")]
-    Pe64((coff::CoffSymbolIterator<'data, 'file, R>, PhantomData<R>)),
-    #[cfg(feature = "wasm")]
-    Wasm((wasm::WasmSymbolIterator<'data, 'file>, PhantomData<R>)),
-    #[cfg(feature = "xcoff")]
-    Xcoff32(
-        (
-            xcoff::XcoffSymbolIterator32<'data, 'file, R>,
-            PhantomData<R>,
-        ),
-    ),
-    #[cfg(feature = "xcoff")]
-    Xcoff64(
-        (
-            xcoff::XcoffSymbolIterator64<'data, 'file, R>,
-            PhantomData<R>,
-        ),
-    ),
-}
-
-impl<'data, 'file, R: ReadRef<'data>> Iterator for SymbolIterator<'data, 'file, R> {
-    type Item = Symbol<'data, 'file, R>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        map_inner_option_mut!(self.inner, SymbolIteratorInternal, SymbolInternal, |iter| {
-            iter.0.next().map(|x| (x, PhantomData))
-        })
-        .map(|inner| Symbol { inner })
-    }
-}
-
-/// An symbol in a [`SymbolTable`].
-///
-/// Most functionality is provided by the [`ObjectSymbol`] trait implementation.
-pub struct Symbol<'data, 'file, R = &'data [u8]>
-where
-    R: ReadRef<'data>,
-{
-    inner: SymbolInternal<'data, 'file, R>,
-}
-
-enum SymbolInternal<'data, 'file, R>
-where
-    R: ReadRef<'data>,
-{
-    #[cfg(feature = "coff")]
-    Coff((coff::CoffSymbol<'data, 'file, R>, PhantomData<R>)),
-    #[cfg(feature = "coff")]
-    CoffBig((coff::CoffBigSymbol<'data, 'file, R>, PhantomData<R>)),
-    #[cfg(feature = "elf")]
-    Elf32(
-        (
-            elf::ElfSymbol32<'data, 'file, Endianness, R>,
-            PhantomData<R>,
-        ),
-    ),
-    #[cfg(feature = "elf")]
-    Elf64(
-        (
-            elf::ElfSymbol64<'data, 'file, Endianness, R>,
-            PhantomData<R>,
-        ),
-    ),
-    #[cfg(feature = "macho")]
-    MachO32(
-        (
-            macho::MachOSymbol32<'data, 'file, Endianness, R>,
-            PhantomData<()>,
-        ),
-    ),
-    #[cfg(feature = "macho")]
-    MachO64(
-        (
-            macho::MachOSymbol64<'data, 'file, Endianness, R>,
-            PhantomData<()>,
-        ),
-    ),
-    #[cfg(feature = "pe")]
-    Pe32((coff::CoffSymbol<'data, 'file, R>, PhantomData<R>)),
-    #[cfg(feature = "pe")]
-    Pe64((coff::CoffSymbol<'data, 'file, R>, PhantomData<R>)),
-    #[cfg(feature = "wasm")]
-    Wasm((wasm::WasmSymbol<'data, 'file>, PhantomData<R>)),
-    #[cfg(feature = "xcoff")]
-    Xcoff32((xcoff::XcoffSymbol32<'data, 'file, R>, PhantomData<R>)),
-    #[cfg(feature = "xcoff")]
-    Xcoff64((xcoff::XcoffSymbol64<'data, 'file, R>, PhantomData<R>)),
-}
-
-impl<'data, 'file, R: ReadRef<'data>> fmt::Debug for Symbol<'data, 'file, R> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Symbol")
-            .field("name", &self.name().unwrap_or("<invalid>"))
-            .field("address", &self.address())
-            .field("size", &self.size())
-            .field("kind", &self.kind())
-            .field("section", &self.section())
-            .field("scope", &self.scope())
-            .field("weak", &self.is_weak())
-            .field("flags", &self.flags())
-            .finish()
-    }
-}
-
-impl<'data, 'file, R: ReadRef<'data>> read::private::Sealed for Symbol<'data, 'file, R> {}
-
-impl<'data, 'file, R: ReadRef<'data>> ObjectSymbol<'data> for Symbol<'data, 'file, R> {
-    fn index(&self) -> SymbolIndex {
-        with_inner!(self.inner, SymbolInternal, |x| x.0.index())
-    }
-
-    fn name_bytes(&self) -> Result<&'data [u8]> {
-        with_inner!(self.inner, SymbolInternal, |x| x.0.name_bytes())
-    }
-
-    fn name(&self) -> Result<&'data str> {
-        with_inner!(self.inner, SymbolInternal, |x| x.0.name())
-    }
-
-    fn address(&self) -> u64 {
-        with_inner!(self.inner, SymbolInternal, |x| x.0.address())
-    }
-
-    fn size(&self) -> u64 {
-        with_inner!(self.inner, SymbolInternal, |x| x.0.size())
-    }
-
-    fn kind(&self) -> SymbolKind {
-        with_inner!(self.inner, SymbolInternal, |x| x.0.kind())
-    }
-
-    fn section(&self) -> SymbolSection {
-        with_inner!(self.inner, SymbolInternal, |x| x.0.section())
-    }
-
-    fn is_undefined(&self) -> bool {
-        with_inner!(self.inner, SymbolInternal, |x| x.0.is_undefined())
-    }
-
-    fn is_definition(&self) -> bool {
-        with_inner!(self.inner, SymbolInternal, |x| x.0.is_definition())
-    }
-
-    fn is_common(&self) -> bool {
-        with_inner!(self.inner, SymbolInternal, |x| x.0.is_common())
-    }
-
-    fn is_weak(&self) -> bool {
-        with_inner!(self.inner, SymbolInternal, |x| x.0.is_weak())
-    }
-
-    fn scope(&self) -> SymbolScope {
-        with_inner!(self.inner, SymbolInternal, |x| x.0.scope())
-    }
-
-    fn is_global(&self) -> bool {
-        with_inner!(self.inner, SymbolInternal, |x| x.0.is_global())
-    }
-
-    fn is_local(&self) -> bool {
-        with_inner!(self.inner, SymbolInternal, |x| x.0.is_local())
-    }
-
-    fn flags(&self) -> SymbolFlags<SectionIndex, SymbolIndex> {
-        with_inner!(self.inner, SymbolInternal, |x| x.0.flags())
-    }
-}
-
-/// An iterator for the dynamic relocation entries in a [`File`].
-#[derive(Debug)]
-pub struct DynamicRelocationIterator<'data, 'file, R = &'data [u8]>
-where
-    R: ReadRef<'data>,
-{
-    inner: DynamicRelocationIteratorInternal<'data, 'file, R>,
-}
-
-#[derive(Debug)]
-enum DynamicRelocationIteratorInternal<'data, 'file, R>
-where
-    R: ReadRef<'data>,
-{
-    #[cfg(feature = "elf")]
-    Elf32(elf::ElfDynamicRelocationIterator32<'data, 'file, Endianness, R>),
-    #[cfg(feature = "elf")]
-    Elf64(elf::ElfDynamicRelocationIterator64<'data, 'file, Endianness, R>),
-    // We need to always use the lifetime parameters.
-    #[allow(unused)]
-    None(PhantomData<(&'data (), &'file (), R)>),
-}
-
-impl<'data, 'file, R: ReadRef<'data>> Iterator for DynamicRelocationIterator<'data, 'file, R> {
-    type Item = (u64, Relocation);
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match self.inner {
-            #[cfg(feature = "elf")]
-            DynamicRelocationIteratorInternal::Elf32(ref mut elf) => elf.next(),
-            #[cfg(feature = "elf")]
-            DynamicRelocationIteratorInternal::Elf64(ref mut elf) => elf.next(),
-            DynamicRelocationIteratorInternal::None(_) => None,
-        }
-    }
-}
-
-/// An iterator for the relocation entries in a [`Section`].
-#[derive(Debug)]
-pub struct SectionRelocationIterator<'data, 'file, R: ReadRef<'data> = &'data [u8]> {
-    inner: SectionRelocationIteratorInternal<'data, 'file, R>,
-}
-
-#[derive(Debug)]
-enum SectionRelocationIteratorInternal<'data, 'file, R: ReadRef<'data>> {
-    #[cfg(feature = "coff")]
-    Coff(coff::CoffRelocationIterator<'data, 'file, R>),
-    #[cfg(feature = "coff")]
-    CoffBig(coff::CoffBigRelocationIterator<'data, 'file, R>),
-    #[cfg(feature = "elf")]
-    Elf32(elf::ElfSectionRelocationIterator32<'data, 'file, Endianness, R>),
-    #[cfg(feature = "elf")]
-    Elf64(elf::ElfSectionRelocationIterator64<'data, 'file, Endianness, R>),
-    #[cfg(feature = "macho")]
-    MachO32(macho::MachORelocationIterator32<'data, 'file, Endianness, R>),
-    #[cfg(feature = "macho")]
-    MachO64(macho::MachORelocationIterator64<'data, 'file, Endianness, R>),
-    #[cfg(feature = "pe")]
-    Pe32(pe::PeRelocationIterator<'data, 'file, R>),
-    #[cfg(feature = "pe")]
-    Pe64(pe::PeRelocationIterator<'data, 'file, R>),
-    #[cfg(feature = "wasm")]
-    Wasm(wasm::WasmRelocationIterator<'data, 'file, R>),
-    #[cfg(feature = "xcoff")]
-    Xcoff32(xcoff::XcoffRelocationIterator32<'data, 'file, R>),
-    #[cfg(feature = "xcoff")]
-    Xcoff64(xcoff::XcoffRelocationIterator64<'data, 'file, R>),
-}
-
-impl<'data, 'file, R: ReadRef<'data>> Iterator for SectionRelocationIterator<'data, 'file, R> {
-    type Item = (u64, Relocation);
-
-    fn next(&mut self) -> Option<Self::Item> {
-        with_inner_mut!(self.inner, SectionRelocationIteratorInternal, |x| x.next())
-    }
-}
-- 
cgit v1.2.3