1 files changed, 0 insertions, 202 deletions
diff --git a/vendor/gimli-0.27.3/src/read/lookup.rs b/vendor/gimli-0.27.3/src/read/lookup.rs
deleted file mode 100644
index 1d082f24f..000000000
--- a/vendor/gimli-0.27.3/src/read/lookup.rs
+++ /dev/null
@@ -1,202 +0,0 @@
-use core::marker::PhantomData;
-
-use crate::common::{DebugInfoOffset, Format};
-use crate::read::{parse_debug_info_offset, Error, Reader, ReaderOffset, Result, UnitOffset};
-
-// The various "Accelerated Access" sections (DWARF standard v4 Section 6.1) all have
-// similar structures. They consist of a header with metadata and an offset into the
-// .debug_info section for the entire compilation unit, and a series
-// of following entries that list addresses (for .debug_aranges) or names
-// (for .debug_pubnames and .debug_pubtypes) that are covered.
-//
-// Because these three tables all have similar structures, we abstract out some of
-// the parsing mechanics.
-
-pub trait LookupParser<R: Reader> {
-    /// The type of the produced header.
-    type Header;
-    /// The type of the produced entry.
-    type Entry;
-
-    /// Parse a header from `input`. Returns a tuple of `input` sliced to contain just the entries
-    /// corresponding to this header (without the header itself), and the parsed representation of
-    /// the header itself.
-    fn parse_header(input: &mut R) -> Result<(R, Self::Header)>;
-
-    /// Parse a single entry from `input`. Returns either a parsed representation of the entry
-    /// or None if `input` is exhausted.
-    fn parse_entry(input: &mut R, header: &Self::Header) -> Result<Option<Self::Entry>>;
-}
-
-#[derive(Clone, Debug)]
-pub struct DebugLookup<R, Parser>
-where
-    R: Reader,
-    Parser: LookupParser<R>,
-{
-    input_buffer: R,
-    phantom: PhantomData<Parser>,
-}
-
-impl<R, Parser> From<R> for DebugLookup<R, Parser>
-where
-    R: Reader,
-    Parser: LookupParser<R>,
-{
-    fn from(input_buffer: R) -> Self {
-        DebugLookup {
-            input_buffer,
-            phantom: PhantomData,
-        }
-    }
-}
-
-impl<R, Parser> DebugLookup<R, Parser>
-where
-    R: Reader,
-    Parser: LookupParser<R>,
-{
-    pub fn items(&self) -> LookupEntryIter<R, Parser> {
-        LookupEntryIter {
-            current_set: None,
-            remaining_input: self.input_buffer.clone(),
-        }
-    }
-
-    pub fn reader(&self) -> &R {
-        &self.input_buffer
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct LookupEntryIter<R, Parser>
-where
-    R: Reader,
-    Parser: LookupParser<R>,
-{
-    current_set: Option<(R, Parser::Header)>, // Only none at the very beginning and end.
-    remaining_input: R,
-}
-
-impl<R, Parser> LookupEntryIter<R, Parser>
-where
-    R: Reader,
-    Parser: LookupParser<R>,
-{
-    /// Advance the iterator and return the next entry.
-    ///
-    /// Returns the newly parsed entry as `Ok(Some(Parser::Entry))`. Returns
-    /// `Ok(None)` when iteration is complete and all entries have already been
-    /// parsed and yielded. If an error occurs while parsing the next entry,
-    /// then this error is returned as `Err(e)`, and all subsequent calls return
-    /// `Ok(None)`.
-    ///
-    /// Can be [used with `FallibleIterator`](./index.html#using-with-fallibleiterator).
-    pub fn next(&mut self) -> Result<Option<Parser::Entry>> {
-        loop {
-            if let Some((ref mut input, ref header)) = self.current_set {
-                if !input.is_empty() {
-                    match Parser::parse_entry(input, header) {
-                        Ok(Some(entry)) => return Ok(Some(entry)),
-                        Ok(None) => {}
-                        Err(e) => {
-                            input.empty();
-                            self.remaining_input.empty();
-                            return Err(e);
-                        }
-                    }
-                }
-            }
-            if self.remaining_input.is_empty() {
-                self.current_set = None;
-                return Ok(None);
-            }
-            match Parser::parse_header(&mut self.remaining_input) {
-                Ok(set) => {
-                    self.current_set = Some(set);
-                }
-                Err(e) => {
-                    self.current_set = None;
-                    self.remaining_input.empty();
-                    return Err(e);
-                }
-            }
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct PubStuffHeader<T = usize> {
-    format: Format,
-    length: T,
-    version: u16,
-    unit_offset: DebugInfoOffset<T>,
-    unit_length: T,
-}
-
-pub trait PubStuffEntry<R: Reader> {
-    fn new(
-        die_offset: UnitOffset<R::Offset>,
-        name: R,
-        unit_header_offset: DebugInfoOffset<R::Offset>,
-    ) -> Self;
-}
-
-#[derive(Clone, Debug)]
-pub struct PubStuffParser<R, Entry>
-where
-    R: Reader,
-    Entry: PubStuffEntry<R>,
-{
-    // This struct is never instantiated.
-    phantom: PhantomData<(R, Entry)>,
-}
-
-impl<R, Entry> LookupParser<R> for PubStuffParser<R, Entry>
-where
-    R: Reader,
-    Entry: PubStuffEntry<R>,
-{
-    type Header = PubStuffHeader<R::Offset>;
-    type Entry = Entry;
-
-    /// Parse an pubthings set header. Returns a tuple of the
-    /// pubthings to be parsed for this set, and the newly created PubThingHeader struct.
-    fn parse_header(input: &mut R) -> Result<(R, Self::Header)> {
-        let (length, format) = input.read_initial_length()?;
-        let mut rest = input.split(length)?;
-
-        let version = rest.read_u16()?;
-        if version != 2 {
-            return Err(Error::UnknownVersion(u64::from(version)));
-        }
-
-        let unit_offset = parse_debug_info_offset(&mut rest, format)?;
-        let unit_length = rest.read_length(format)?;
-
-        let header = PubStuffHeader {
-            format,
-            length,
-            version,
-            unit_offset,
-            unit_length,
-        };
-        Ok((rest, header))
-    }
-
-    /// Parse a single pubthing. Return `None` for the null pubthing, `Some` for an actual pubthing.
-    fn parse_entry(input: &mut R, header: &Self::Header) -> Result<Option<Self::Entry>> {
-        let offset = input.read_offset(header.format)?;
-        if offset.into_u64() == 0 {
-            input.empty();
-            Ok(None)
-        } else {
-            let name = input.read_null_terminated_slice()?;
-            Ok(Some(Self::Entry::new(
-                UnitOffset(offset),
-                name,
-                header.unit_offset,
-            )))
-        }
-    }
-}