wasmtime 10.0.1 → 11.0.0

data/ext/cargo-vendor/addr2line-0.20.0/src/lib.rs

@@ -1,1729 +0,0 @@
-//! This crate provides a cross-platform library and binary for translating addresses into
-//! function names, file names and line numbers. Given an address in an executable or an
-//! offset in a section of a relocatable object, it uses the debugging information to
-//! figure out which file name and line number are associated with it.
-//!
-//! When used as a library, files must first be loaded using the
-//! [`object`](https://github.com/gimli-rs/object) crate.
-//! A context can then be created with [`Context::new`](./struct.Context.html#method.new).
-//! The context caches some of the parsed information so that multiple lookups are
-//! efficient.
-//! Location information is obtained with
-//! [`Context::find_location`](./struct.Context.html#method.find_location) or
-//! [`Context::find_location_range`](./struct.Context.html#method.find_location_range).
-//! Function information is obtained with
-//! [`Context::find_frames`](./struct.Context.html#method.find_frames), which returns
-//! a frame for each inline function. Each frame contains both name and location.
-//!
-//! The crate has an example CLI wrapper around the library which provides some of
-//! the functionality of the `addr2line` command line tool distributed with [GNU
-//! binutils](https://www.gnu.org/software/binutils/).
-//!
-//! Currently this library only provides information from the DWARF debugging information,
-//! which is parsed using [`gimli`](https://github.com/gimli-rs/gimli).  The example CLI
-//! wrapper also uses symbol table information provided by the `object` crate.
-#![deny(missing_docs)]
-#![no_std]
-
-#[cfg(feature = "std")]
-extern crate std;
-
-#[allow(unused_imports)]
-#[macro_use]
-extern crate alloc;
-
-#[cfg(feature = "fallible-iterator")]
-pub extern crate fallible_iterator;
-pub extern crate gimli;
-#[cfg(feature = "object")]
-pub extern crate object;
-
-use alloc::borrow::Cow;
-use alloc::boxed::Box;
-#[cfg(feature = "object")]
-use alloc::rc::Rc;
-use alloc::string::{String, ToString};
-use alloc::sync::Arc;
-use alloc::vec::Vec;
-
-use core::cmp::{self, Ordering};
-use core::iter;
-use core::marker::PhantomData;
-use core::mem;
-use core::num::NonZeroU64;
-use core::ops::ControlFlow;
-use core::u64;
-
-use crate::function::{Function, Functions, InlinedFunction};
-use crate::lazy::LazyCell;
-
-#[cfg(feature = "smallvec")]
-mod maybe_small {
-    pub type Vec<T> = smallvec::SmallVec<[T; 16]>;
-    pub type IntoIter<T> = smallvec::IntoIter<[T; 16]>;
-}
-#[cfg(not(feature = "smallvec"))]
-mod maybe_small {
-    pub type Vec<T> = alloc::vec::Vec<T>;
-    pub type IntoIter<T> = alloc::vec::IntoIter<T>;
-}
-
-#[cfg(all(feature = "std", feature = "object", feature = "memmap2"))]
-/// A simple builtin split DWARF loader.
-pub mod builtin_split_dwarf_loader;
-mod function;
-mod lazy;
-
-type Error = gimli::Error;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum DebugFile {
-    Primary,
-    Supplementary,
-    Dwo,
-}
-
-/// Operations that consult debug information may require additional files
-/// to be loaded if split DWARF is being used. This enum returns the result
-/// of the operation in the `Break` variant, or information about the split
-/// DWARF that is required and a continuation to invoke once it is available
-/// in the `Continue` variant.
-///
-/// This enum is intended to be used in a loop like so:
-/// ```no_run
-///   # use addr2line::*;
-///   # use std::sync::Arc;
-///   # let ctx: Context<gimli::EndianRcSlice<gimli::RunTimeEndian>> = todo!();
-///   # let do_split_dwarf_load = |load: SplitDwarfLoad<gimli::EndianRcSlice<gimli::RunTimeEndian>>| -> Option<Arc<gimli::Dwarf<gimli::EndianRcSlice<gimli::RunTimeEndian>>>> { None };
-///   const ADDRESS: u64 = 0xdeadbeef;
-///   let mut r = ctx.find_frames(ADDRESS);
-///   let result = loop {
-///     match r {
-///       LookupResult::Output(result) => break result,
-///       LookupResult::Load { load, continuation } => {
-///         let dwo = do_split_dwarf_load(load);
-///         r = continuation.resume(dwo);
-///       }
-///     }
-///   };
-/// ```
-pub enum LookupResult<L: LookupContinuation> {
-    /// The lookup requires split DWARF data to be loaded.
-    Load {
-        /// The information needed to find the split DWARF data.
-        load: SplitDwarfLoad<<L as LookupContinuation>::Buf>,
-        /// The continuation to resume with the loaded split DWARF data.
-        continuation: L,
-    },
-    /// The lookup has completed and produced an output.
-    Output(<L as LookupContinuation>::Output),
-}
-
-/// This trait represents a partially complete operation that can be resumed
-/// once a load of needed split DWARF data is completed or abandoned by the
-/// API consumer.
-pub trait LookupContinuation: Sized {
-    /// The final output of this operation.
-    type Output;
-    /// The type of reader used.
-    type Buf: gimli::Reader;
-
-    /// Resumes the operation with the provided data.
-    ///
-    /// After the caller loads the split DWARF data required, call this
-    /// method to resume the operation. The return value of this method
-    /// indicates if the computation has completed or if further data is
-    /// required.
-    ///
-    /// If the additional data cannot be located, or the caller does not
-    /// support split DWARF, `resume(None)` can be used to continue the
-    /// operation with the data that is available.
-    fn resume(self, input: Option<Arc<gimli::Dwarf<Self::Buf>>>) -> LookupResult<Self>;
-}
-
-impl<L: LookupContinuation> LookupResult<L> {
-    /// Callers that do not handle split DWARF can call `skip_all_loads`
-    /// to fast-forward to the end result. This result is produced with
-    /// the data that is available and may be less accurate than the
-    /// the results that would be produced if the caller did properly
-    /// support split DWARF.
-    pub fn skip_all_loads(mut self) -> L::Output {
-        loop {
-            self = match self {
-                LookupResult::Output(t) => return t,
-                LookupResult::Load { continuation, .. } => continuation.resume(None),
-            };
-        }
-    }
-
-    fn map<T, F: FnOnce(L::Output) -> T>(self, f: F) -> LookupResult<MappedLookup<T, L, F>> {
-        match self {
-            LookupResult::Output(t) => LookupResult::Output(f(t)),
-            LookupResult::Load { load, continuation } => LookupResult::Load {
-                load,
-                continuation: MappedLookup {
-                    original: continuation,
-                    mutator: f,
-                },
-            },
-        }
-    }
-
-    fn unwrap(self) -> L::Output {
-        match self {
-            LookupResult::Output(t) => t,
-            LookupResult::Load { .. } => unreachable!("Internal API misuse"),
-        }
-    }
-}
-
-/// The state necessary to perform address to line translation.
-///
-/// Constructing a `Context` is somewhat costly, so users should aim to reuse `Context`s
-/// when performing lookups for many addresses in the same executable.
-pub struct Context<R: gimli::Reader> {
-    sections: Arc<gimli::Dwarf<R>>,
-    unit_ranges: Vec<UnitRange>,
-    units: Vec<ResUnit<R>>,
-    sup_units: Vec<SupUnit<R>>,
-}
-
-/// The type of `Context` that supports the `new` method.
-#[cfg(feature = "std-object")]
-pub type ObjectContext = Context<gimli::EndianRcSlice<gimli::RunTimeEndian>>;
-
-#[cfg(feature = "std-object")]
-impl Context<gimli::EndianRcSlice<gimli::RunTimeEndian>> {
-    /// Construct a new `Context`.
-    ///
-    /// The resulting `Context` uses `gimli::EndianRcSlice<gimli::RunTimeEndian>`.
-    /// This means it is not thread safe, has no lifetime constraints (since it copies
-    /// the input data), and works for any endianity.
-    ///
-    /// Performance sensitive applications may want to use `Context::from_dwarf`
-    /// with a more specialised `gimli::Reader` implementation.
-    #[inline]
-    pub fn new<'data: 'file, 'file, O: object::Object<'data, 'file>>(
-        file: &'file O,
-    ) -> Result<Self, Error> {
-        Self::new_with_sup(file, None)
-    }
-
-    /// Construct a new `Context`.
-    ///
-    /// Optionally also use a supplementary object file.
-    ///
-    /// The resulting `Context` uses `gimli::EndianRcSlice<gimli::RunTimeEndian>`.
-    /// This means it is not thread safe, has no lifetime constraints (since it copies
-    /// the input data), and works for any endianity.
-    ///
-    /// Performance sensitive applications may want to use `Context::from_dwarf`
-    /// with a more specialised `gimli::Reader` implementation.
-    pub fn new_with_sup<'data: 'file, 'file, O: object::Object<'data, 'file>>(
-        file: &'file O,
-        sup_file: Option<&'file O>,
-    ) -> Result<Self, Error> {
-        let endian = if file.is_little_endian() {
-            gimli::RunTimeEndian::Little
-        } else {
-            gimli::RunTimeEndian::Big
-        };
-
-        fn load_section<'data: 'file, 'file, O, Endian>(
-            id: gimli::SectionId,
-            file: &'file O,
-            endian: Endian,
-        ) -> Result<gimli::EndianRcSlice<Endian>, Error>
-        where
-            O: object::Object<'data, 'file>,
-            Endian: gimli::Endianity,
-        {
-            use object::ObjectSection;
-
-            let data = file
-                .section_by_name(id.name())
-                .and_then(|section| section.uncompressed_data().ok())
-                .unwrap_or(Cow::Borrowed(&[]));
-            Ok(gimli::EndianRcSlice::new(Rc::from(&*data), endian))
-        }
-
-        let mut dwarf = gimli::Dwarf::load(|id| load_section(id, file, endian))?;
-        if let Some(sup_file) = sup_file {
-            dwarf.load_sup(|id| load_section(id, sup_file, endian))?;
-        }
-        Context::from_dwarf(dwarf)
-    }
-}
-
-impl<R: gimli::Reader> Context<R> {
-    /// Construct a new `Context` from DWARF sections.
-    ///
-    /// This method does not support using a supplementary object file.
-    pub fn from_sections(
-        debug_abbrev: gimli::DebugAbbrev<R>,
-        debug_addr: gimli::DebugAddr<R>,
-        debug_aranges: gimli::DebugAranges<R>,
-        debug_info: gimli::DebugInfo<R>,
-        debug_line: gimli::DebugLine<R>,
-        debug_line_str: gimli::DebugLineStr<R>,
-        debug_ranges: gimli::DebugRanges<R>,
-        debug_rnglists: gimli::DebugRngLists<R>,
-        debug_str: gimli::DebugStr<R>,
-        debug_str_offsets: gimli::DebugStrOffsets<R>,
-        default_section: R,
-    ) -> Result<Self, Error> {
-        Self::from_dwarf(gimli::Dwarf {
-            debug_abbrev,
-            debug_addr,
-            debug_aranges,
-            debug_info,
-            debug_line,
-            debug_line_str,
-            debug_str,
-            debug_str_offsets,
-            debug_types: default_section.clone().into(),
-            locations: gimli::LocationLists::new(
-                default_section.clone().into(),
-                default_section.into(),
-            ),
-            ranges: gimli::RangeLists::new(debug_ranges, debug_rnglists),
-            file_type: gimli::DwarfFileType::Main,
-            sup: None,
-            abbreviations_cache: gimli::AbbreviationsCache::new(),
-        })
-    }
-
-    /// Construct a new `Context` from an existing [`gimli::Dwarf`] object.
-    #[inline]
-    pub fn from_dwarf(sections: gimli::Dwarf<R>) -> Result<Context<R>, Error> {
-        let sections = Arc::new(sections);
-        let (unit_ranges, units) = Context::parse_units(&sections)?;
-        let sup_units = if let Some(sup) = sections.sup.as_ref() {
-            Context::parse_sup(sup)?
-        } else {
-            Vec::new()
-        };
-        Ok(Context {
-            sections,
-            unit_ranges,
-            units,
-            sup_units,
-        })
-    }
-
-    /// Finds the CUs for the function address given.
-    ///
-    /// There might be multiple CUs whose range contains this address.
-    /// Weak symbols have shown up in the wild which cause this to happen
-    /// but otherwise this can happen if the CU has non-contiguous functions
-    /// but only reports a single range.
-    ///
-    /// Consequently we return an iterator for all CUs which may contain the
-    /// address, and the caller must check if there is actually a function or
-    /// location in the CU for that address.
-    fn find_units(&self, probe: u64) -> impl Iterator<Item = &ResUnit<R>> {
-        self.find_units_range(probe, probe + 1)
-            .map(|(unit, _range)| unit)
-    }
-
-    /// Finds the CUs covering the range of addresses given.
-    ///
-    /// The range is [low, high) (ie, the upper bound is exclusive). This can return multiple
-    /// ranges for the same unit.
-    #[inline]
-    fn find_units_range(
-        &self,
-        probe_low: u64,
-        probe_high: u64,
-    ) -> impl Iterator<Item = (&ResUnit<R>, &gimli::Range)> {
-        // First up find the position in the array which could have our function
-        // address.
-        let pos = match self
-            .unit_ranges
-            .binary_search_by_key(&probe_high, |i| i.range.begin)
-        {
-            // Although unlikely, we could find an exact match.
-            Ok(i) => i + 1,
-            // No exact match was found, but this probe would fit at slot `i`.
-            // This means that slot `i` is bigger than `probe`, along with all
-            // indices greater than `i`, so we need to search all previous
-            // entries.
-            Err(i) => i,
-        };
-
-        // Once we have our index we iterate backwards from that position
-        // looking for a matching CU.
-        self.unit_ranges[..pos]
-            .iter()
-            .rev()
-            .take_while(move |i| {
-                // We know that this CU's start is beneath the probe already because
-                // of our sorted array.
-                debug_assert!(i.range.begin <= probe_high);
-
-                // Each entry keeps track of the maximum end address seen so far,
-                // starting from the beginning of the array of unit ranges. We're
-                // iterating in reverse so if our probe is beyond the maximum range
-                // of this entry, then it's guaranteed to not fit in any prior
-                // entries, so we break out.
-                probe_low < i.max_end
-            })
-            .filter_map(move |i| {
-                // If this CU doesn't actually contain this address, move to the
-                // next CU.
-                if probe_low >= i.range.end || probe_high <= i.range.begin {
-                    return None;
-                }
-                Some((&self.units[i.unit_id], &i.range))
-            })
-    }
-
-    /// Find the DWARF unit corresponding to the given virtual memory address.
-    pub fn find_dwarf_and_unit(
-        &self,
-        probe: u64,
-    ) -> LookupResult<
-        impl LookupContinuation<Output = Option<(&gimli::Dwarf<R>, &gimli::Unit<R>)>, Buf = R>,
-    > {
-        let mut units_iter = self.find_units(probe);
-        if let Some(unit) = units_iter.next() {
-            return LoopingLookup::new_lookup(
-                unit.find_function_or_location(probe, self),
-                move |r| {
-                    ControlFlow::Break(match r {
-                        Ok((Some(_), _)) | Ok((_, Some(_))) => {
-                            let (_file, sections, unit) = unit
-                                .dwarf_and_unit_dwo(self)
-                                // We've already been through both error cases here to get to this point.
-                                .unwrap()
-                                .unwrap();
-                            Some((sections, unit))
-                        }
-                        _ => match units_iter.next() {
-                            Some(next_unit) => {
-                                return ControlFlow::Continue(
-                                    next_unit.find_function_or_location(probe, self),
-                                );
-                            }
-                            None => None,
-                        },
-                    })
-                },
-            );
-        }
-
-        LoopingLookup::new_complete(None)
-    }
-
-    /// Find the source file and line corresponding to the given virtual memory address.
-    pub fn find_location(&self, probe: u64) -> Result<Option<Location<'_>>, Error> {
-        for unit in self.find_units(probe) {
-            if let Some(location) = unit.find_location(probe, &self.sections)? {
-                return Ok(Some(location));
-            }
-        }
-        Ok(None)
-    }
-
-    /// Return source file and lines for a range of addresses. For each location it also
-    /// returns the address and size of the range of the underlying instructions.
-    pub fn find_location_range(
-        &self,
-        probe_low: u64,
-        probe_high: u64,
-    ) -> Result<LocationRangeIter<'_, R>, Error> {
-        LocationRangeIter::new(self, probe_low, probe_high)
-    }
-
-    /// Return an iterator for the function frames corresponding to the given virtual
-    /// memory address.
-    ///
-    /// If the probe address is not for an inline function then only one frame is
-    /// returned.
-    ///
-    /// If the probe address is for an inline function then the first frame corresponds
-    /// to the innermost inline function.  Subsequent frames contain the caller and call
-    /// location, until an non-inline caller is reached.
-    pub fn find_frames(
-        &self,
-        probe: u64,
-    ) -> LookupResult<impl LookupContinuation<Output = Result<FrameIter<'_, R>, Error>, Buf = R>>
-    {
-        let mut units_iter = self.find_units(probe);
-        if let Some(unit) = units_iter.next() {
-            LoopingLookup::new_lookup(unit.find_function_or_location(probe, self), move |r| {
-                ControlFlow::Break(match r {
-                    Err(e) => Err(e),
-                    Ok((Some(function), location)) => {
-                        let inlined_functions = function.find_inlined_functions(probe);
-                        Ok(FrameIter(FrameIterState::Frames(FrameIterFrames {
-                            unit,
-                            sections: &self.sections,
-                            function,
-                            inlined_functions,
-                            next: location,
-                        })))
-                    }
-                    Ok((None, Some(location))) => {
-                        Ok(FrameIter(FrameIterState::Location(Some(location))))
-                    }
-                    Ok((None, None)) => match units_iter.next() {
-                        Some(next_unit) => {
-                            return ControlFlow::Continue(
-                                next_unit.find_function_or_location(probe, self),
-                            );
-                        }
-                        None => Ok(FrameIter(FrameIterState::Empty)),
-                    },
-                })
-            })
-        } else {
-            LoopingLookup::new_complete(Ok(FrameIter(FrameIterState::Empty)))
-        }
-    }
-
-    /// Preload units for `probe`.
-    ///
-    /// The iterator returns pairs of `SplitDwarfLoad`s containing the
-    /// information needed to locate and load split DWARF for `probe` and
-    /// a matching callback to invoke once that data is available.
-    ///
-    /// If this method is called, and all of the returned closures are invoked,
-    /// addr2line guarantees that any future API call for the address `probe`
-    /// will not require the loading of any split DWARF.
-    ///
-    /// ```no_run
-    ///   # use addr2line::*;
-    ///   # use std::sync::Arc;
-    ///   # let ctx: Context<gimli::EndianRcSlice<gimli::RunTimeEndian>> = todo!();
-    ///   # let do_split_dwarf_load = |load: SplitDwarfLoad<gimli::EndianRcSlice<gimli::RunTimeEndian>>| -> Option<Arc<gimli::Dwarf<gimli::EndianRcSlice<gimli::RunTimeEndian>>>> { None };
-    ///   const ADDRESS: u64 = 0xdeadbeef;
-    ///   ctx.preload_units(ADDRESS).for_each(|(load, callback)| {
-    ///     let dwo = do_split_dwarf_load(load);
-    ///     callback(dwo);
-    ///   });
-    ///
-    ///   let frames_iter = match ctx.find_frames(ADDRESS) {
-    ///     LookupResult::Output(result) => result,
-    ///     LookupResult::Load { .. } => unreachable!("addr2line promised we wouldn't get here"),
-    ///   };
-    ///
-    ///   // ...
-    /// ```
-    pub fn preload_units(
-        &'_ self,
-        probe: u64,
-    ) -> impl Iterator<
-        Item = (
-            SplitDwarfLoad<R>,
-            impl FnOnce(Option<Arc<gimli::Dwarf<R>>>) -> Result<(), gimli::Error> + '_,
-        ),
-    > {
-        self.find_units(probe)
-            .filter_map(move |unit| match unit.dwarf_and_unit_dwo(self) {
-                LookupResult::Output(_) => None,
-                LookupResult::Load { load, continuation } => Some((load, |result| {
-                    continuation.resume(result).unwrap().map(|_| ())
-                })),
-            })
-    }
-
-    /// Initialize all line data structures. This is used for benchmarks.
-    #[doc(hidden)]
-    pub fn parse_lines(&self) -> Result<(), Error> {
-        for unit in &self.units {
-            unit.parse_lines(&self.sections)?;
-        }
-        Ok(())
-    }
-
-    /// Initialize all function data structures. This is used for benchmarks.
-    #[doc(hidden)]
-    pub fn parse_functions(&self) -> Result<(), Error> {
-        for unit in &self.units {
-            unit.parse_functions(self).skip_all_loads()?;
-        }
-        Ok(())
-    }
-
-    /// Initialize all inlined function data structures. This is used for benchmarks.
-    #[doc(hidden)]
-    pub fn parse_inlined_functions(&self) -> Result<(), Error> {
-        for unit in &self.units {
-            unit.parse_inlined_functions(self).skip_all_loads()?;
-        }
-        Ok(())
-    }
-}
-
-struct UnitRange {
-    unit_id: usize,
-    max_end: u64,
-    range: gimli::Range,
-}
-
-struct ResUnit<R: gimli::Reader> {
-    offset: gimli::DebugInfoOffset<R::Offset>,
-    dw_unit: gimli::Unit<R>,
-    lang: Option<gimli::DwLang>,
-    lines: LazyCell<Result<Lines, Error>>,
-    funcs: LazyCell<Result<Functions<R>, Error>>,
-    dwo: LazyCell<Result<Option<Box<(Arc<gimli::Dwarf<R>>, gimli::Unit<R>)>>, Error>>,
-}
-
-struct SupUnit<R: gimli::Reader> {
-    offset: gimli::DebugInfoOffset<R::Offset>,
-    dw_unit: gimli::Unit<R>,
-}
-
-impl<R: gimli::Reader> Context<R> {
-    fn parse_units(sections: &gimli::Dwarf<R>) -> Result<(Vec<UnitRange>, Vec<ResUnit<R>>), Error> {
-        // Find all the references to compilation units in .debug_aranges.
-        // Note that we always also iterate through all of .debug_info to
-        // find compilation units, because .debug_aranges may be missing some.
-        let mut aranges = Vec::new();
-        let mut headers = sections.debug_aranges.headers();
-        while let Some(header) = headers.next()? {
-            aranges.push((header.debug_info_offset(), header.offset()));
-        }
-        aranges.sort_by_key(|i| i.0);
-
-        let mut unit_ranges = Vec::new();
-        let mut res_units = Vec::new();
-        let mut units = sections.units();
-        while let Some(header) = units.next()? {
-            let unit_id = res_units.len();
-            let offset = match header.offset().as_debug_info_offset() {
-                Some(offset) => offset,
-                None => continue,
-            };
-            // We mainly want compile units, but we may need to follow references to entries
-            // within other units for function names.  We don't need anything from type units.
-            match header.type_() {
-                gimli::UnitType::Type { .. } | gimli::UnitType::SplitType { .. } => continue,
-                _ => {}
-            }
-            let dw_unit = match sections.unit(header) {
-                Ok(dw_unit) => dw_unit,
-                Err(_) => continue,
-            };
-
-            let mut lang = None;
-            let mut have_unit_range = false;
-            {
-                let mut entries = dw_unit.entries_raw(None)?;
-
-                let abbrev = match entries.read_abbreviation()? {
-                    Some(abbrev) => abbrev,
-                    None => continue,
-                };
-
-                let mut ranges = RangeAttributes::default();
-                for spec in abbrev.attributes() {
-                    let attr = entries.read_attribute(*spec)?;
-                    match attr.name() {
-                        gimli::DW_AT_low_pc => match attr.value() {
-                            gimli::AttributeValue::Addr(val) => ranges.low_pc = Some(val),
-                            gimli::AttributeValue::DebugAddrIndex(index) => {
-                                ranges.low_pc = Some(sections.address(&dw_unit, index)?);
-                            }
-                            _ => {}
-                        },
-                        gimli::DW_AT_high_pc => match attr.value() {
-                            gimli::AttributeValue::Addr(val) => ranges.high_pc = Some(val),
-                            gimli::AttributeValue::DebugAddrIndex(index) => {
-                                ranges.high_pc = Some(sections.address(&dw_unit, index)?);
-                            }
-                            gimli::AttributeValue::Udata(val) => ranges.size = Some(val),
-                            _ => {}
-                        },
-                        gimli::DW_AT_ranges => {
-                            ranges.ranges_offset =
-                                sections.attr_ranges_offset(&dw_unit, attr.value())?;
-                        }
-                        gimli::DW_AT_language => {
-                            if let gimli::AttributeValue::Language(val) = attr.value() {
-                                lang = Some(val);
-                            }
-                        }
-                        _ => {}
-                    }
-                }
-
-                // Find the address ranges for the CU, using in order of preference:
-                // - DW_AT_ranges
-                // - .debug_aranges
-                // - DW_AT_low_pc/DW_AT_high_pc
-                //
-                // Using DW_AT_ranges before .debug_aranges is possibly an arbitrary choice,
-                // but the feeling is that DW_AT_ranges is more likely to be reliable or complete
-                // if it is present.
-                //
-                // .debug_aranges must be used before DW_AT_low_pc/DW_AT_high_pc because
-                // it has been observed on macOS that DW_AT_ranges was not emitted even for
-                // discontiguous CUs.
-                let i = match ranges.ranges_offset {
-                    Some(_) => None,
-                    None => aranges.binary_search_by_key(&offset, |x| x.0).ok(),
-                };
-                if let Some(mut i) = i {
-                    // There should be only one set per CU, but in practice multiple
-                    // sets have been observed. This is probably a compiler bug, but
-                    // either way we need to handle it.
-                    while i > 0 && aranges[i - 1].0 == offset {
-                        i -= 1;
-                    }
-                    for (_, aranges_offset) in aranges[i..].iter().take_while(|x| x.0 == offset) {
-                        let aranges_header = sections.debug_aranges.header(*aranges_offset)?;
-                        let mut aranges = aranges_header.entries();
-                        while let Some(arange) = aranges.next()? {
-                            if arange.length() != 0 {
-                                unit_ranges.push(UnitRange {
-                                    range: arange.range(),
-                                    unit_id,
-                                    max_end: 0,
-                                });
-                                have_unit_range = true;
-                            }
-                        }
-                    }
-                } else {
-                    have_unit_range |= ranges.for_each_range(sections, &dw_unit, |range| {
-                        unit_ranges.push(UnitRange {
-                            range,
-                            unit_id,
-                            max_end: 0,
-                        });
-                    })?;
-                }
-            }
-
-            let lines = LazyCell::new();
-            if !have_unit_range {
-                // The unit did not declare any ranges.
-                // Try to get some ranges from the line program sequences.
-                if let Some(ref ilnp) = dw_unit.line_program {
-                    if let Ok(lines) = lines
-                        .borrow_with(|| Lines::parse(&dw_unit, ilnp.clone(), sections))
-                        .as_ref()
-                    {
-                        for sequence in lines.sequences.iter() {
-                            unit_ranges.push(UnitRange {
-                                range: gimli::Range {
-                                    begin: sequence.start,
-                                    end: sequence.end,
-                                },
-                                unit_id,
-                                max_end: 0,
-                            })
-                        }
-                    }
-                }
-            }
-
-            res_units.push(ResUnit {
-                offset,
-                dw_unit,
-                lang,
-                lines,
-                funcs: LazyCell::new(),
-                dwo: LazyCell::new(),
-            });
-        }
-
-        // Sort this for faster lookup in `find_unit_and_address` below.
-        unit_ranges.sort_by_key(|i| i.range.begin);
-
-        // Calculate the `max_end` field now that we've determined the order of
-        // CUs.
-        let mut max = 0;
-        for i in unit_ranges.iter_mut() {
-            max = max.max(i.range.end);
-            i.max_end = max;
-        }
-
-        Ok((unit_ranges, res_units))
-    }
-
-    fn parse_sup(sections: &gimli::Dwarf<R>) -> Result<Vec<SupUnit<R>>, Error> {
-        let mut sup_units = Vec::new();
-        let mut units = sections.units();
-        while let Some(header) = units.next()? {
-            let offset = match header.offset().as_debug_info_offset() {
-                Some(offset) => offset,
-                None => continue,
-            };
-            let dw_unit = match sections.unit(header) {
-                Ok(dw_unit) => dw_unit,
-                Err(_) => continue,
-            };
-            sup_units.push(SupUnit { dw_unit, offset });
-        }
-        Ok(sup_units)
-    }
-
-    // Find the unit containing the given offset, and convert the offset into a unit offset.
-    fn find_unit(
-        &self,
-        offset: gimli::DebugInfoOffset<R::Offset>,
-        file: DebugFile,
-    ) -> Result<(&gimli::Unit<R>, gimli::UnitOffset<R::Offset>), Error> {
-        let unit = match file {
-            DebugFile::Primary => {
-                match self
-                    .units
-                    .binary_search_by_key(&offset.0, |unit| unit.offset.0)
-                {
-                    // There is never a DIE at the unit offset or before the first unit.
-                    Ok(_) | Err(0) => return Err(gimli::Error::NoEntryAtGivenOffset),
-                    Err(i) => &self.units[i - 1].dw_unit,
-                }
-            }
-            DebugFile::Supplementary => {
-                match self
-                    .sup_units
-                    .binary_search_by_key(&offset.0, |unit| unit.offset.0)
-                {
-                    // There is never a DIE at the unit offset or before the first unit.
-                    Ok(_) | Err(0) => return Err(gimli::Error::NoEntryAtGivenOffset),
-                    Err(i) => &self.sup_units[i - 1].dw_unit,
-                }
-            }
-            DebugFile::Dwo => return Err(gimli::Error::NoEntryAtGivenOffset),
-        };
-
-        let unit_offset = offset
-            .to_unit_offset(&unit.header)
-            .ok_or(gimli::Error::NoEntryAtGivenOffset)?;
-        Ok((unit, unit_offset))
-    }
-}
-
-struct Lines {
-    files: Box<[String]>,
-    sequences: Box<[LineSequence]>,
-}
-
-impl Lines {
-    fn parse<R: gimli::Reader>(
-        dw_unit: &gimli::Unit<R>,
-        ilnp: gimli::IncompleteLineProgram<R, R::Offset>,
-        sections: &gimli::Dwarf<R>,
-    ) -> Result<Self, Error> {
-        let mut sequences = Vec::new();
-        let mut sequence_rows = Vec::<LineRow>::new();
-        let mut rows = ilnp.rows();
-        while let Some((_, row)) = rows.next_row()? {
-            if row.end_sequence() {
-                if let Some(start) = sequence_rows.first().map(|x| x.address) {
-                    let end = row.address();
-                    let mut rows = Vec::new();
-                    mem::swap(&mut rows, &mut sequence_rows);
-                    sequences.push(LineSequence {
-                        start,
-                        end,
-                        rows: rows.into_boxed_slice(),
-                    });
-                }
-                continue;
-            }
-
-            let address = row.address();
-            let file_index = row.file_index();
-            let line = row.line().map(NonZeroU64::get).unwrap_or(0) as u32;
-            let column = match row.column() {
-                gimli::ColumnType::LeftEdge => 0,
-                gimli::ColumnType::Column(x) => x.get() as u32,
-            };
-
-            if let Some(last_row) = sequence_rows.last_mut() {
-                if last_row.address == address {
-                    last_row.file_index = file_index;
-                    last_row.line = line;
-                    last_row.column = column;
-                    continue;
-                }
-            }
-
-            sequence_rows.push(LineRow {
-                address,
-                file_index,
-                line,
-                column,
-            });
-        }
-        sequences.sort_by_key(|x| x.start);
-
-        let mut files = Vec::new();
-        let header = rows.header();
-        match header.file(0) {
-            Some(file) => files.push(render_file(dw_unit, file, header, sections)?),
-            None => files.push(String::from("")), // DWARF version <= 4 may not have 0th index
-        }
-        let mut index = 1;
-        while let Some(file) = header.file(index) {
-            files.push(render_file(dw_unit, file, header, sections)?);
-            index += 1;
-        }
-
-        Ok(Self {
-            files: files.into_boxed_slice(),
-            sequences: sequences.into_boxed_slice(),
-        })
-    }
-}
-
-fn render_file<R: gimli::Reader>(
-    dw_unit: &gimli::Unit<R>,
-    file: &gimli::FileEntry<R, R::Offset>,
-    header: &gimli::LineProgramHeader<R, R::Offset>,
-    sections: &gimli::Dwarf<R>,
-) -> Result<String, gimli::Error> {
-    let mut path = if let Some(ref comp_dir) = dw_unit.comp_dir {
-        comp_dir.to_string_lossy()?.into_owned()
-    } else {
-        String::new()
-    };
-
-    // The directory index 0 is defined to correspond to the compilation unit directory.
-    if file.directory_index() != 0 {
-        if let Some(directory) = file.directory(header) {
-            path_push(
-                &mut path,
-                sections
-                    .attr_string(dw_unit, directory)?
-                    .to_string_lossy()?
-                    .as_ref(),
-            );
-        }
-    }
-
-    path_push(
-        &mut path,
-        sections
-            .attr_string(dw_unit, file.path_name())?
-            .to_string_lossy()?
-            .as_ref(),
-    );
-
-    Ok(path)
-}
-
-struct LineSequence {
-    start: u64,
-    end: u64,
-    rows: Box<[LineRow]>,
-}
-
-struct LineRow {
-    address: u64,
-    file_index: u64,
-    line: u32,
-    column: u32,
-}
-
-/// This struct contains the information needed to find split DWARF data
-/// and to produce a `gimli::Dwarf<R>` for it.
-pub struct SplitDwarfLoad<R> {
-    /// The dwo id, for looking up in a DWARF package, or for
-    /// verifying an unpacked dwo found on the file system
-    pub dwo_id: gimli::DwoId,
-    /// The compilation directory `path` is relative to.
-    pub comp_dir: Option<R>,
-    /// A path on the filesystem, relative to `comp_dir` to find this dwo.
-    pub path: Option<R>,
-    /// Once the split DWARF data is loaded, the loader is expected
-    /// to call [make_dwo(parent)](gimli::read::Dwarf::make_dwo) before
-    /// returning the data.
-    pub parent: Arc<gimli::Dwarf<R>>,
-}
-
-struct SimpleLookup<T, R, F>
-where
-    F: FnOnce(Option<Arc<gimli::Dwarf<R>>>) -> T,
-    R: gimli::Reader,
-{
-    f: F,
-    phantom: PhantomData<(T, R)>,
-}
-
-impl<T, R, F> SimpleLookup<T, R, F>
-where
-    F: FnOnce(Option<Arc<gimli::Dwarf<R>>>) -> T,
-    R: gimli::Reader,
-{
-    fn new_complete(t: F::Output) -> LookupResult<SimpleLookup<T, R, F>> {
-        LookupResult::Output(t)
-    }
-
-    fn new_needs_load(load: SplitDwarfLoad<R>, f: F) -> LookupResult<SimpleLookup<T, R, F>> {
-        LookupResult::Load {
-            load,
-            continuation: SimpleLookup {
-                f,
-                phantom: PhantomData,
-            },
-        }
-    }
-}
-
-impl<T, R, F> LookupContinuation for SimpleLookup<T, R, F>
-where
-    F: FnOnce(Option<Arc<gimli::Dwarf<R>>>) -> T,
-    R: gimli::Reader,
-{
-    type Output = T;
-    type Buf = R;
-
-    fn resume(self, v: Option<Arc<gimli::Dwarf<Self::Buf>>>) -> LookupResult<Self> {
-        LookupResult::Output((self.f)(v))
-    }
-}
-
-struct MappedLookup<T, L, F>
-where
-    L: LookupContinuation,
-    F: FnOnce(L::Output) -> T,
-{
-    original: L,
-    mutator: F,
-}
-
-impl<T, L, F> LookupContinuation for MappedLookup<T, L, F>
-where
-    L: LookupContinuation,
-    F: FnOnce(L::Output) -> T,
-{
-    type Output = T;
-    type Buf = L::Buf;
-
-    fn resume(self, v: Option<Arc<gimli::Dwarf<Self::Buf>>>) -> LookupResult<Self> {
-        match self.original.resume(v) {
-            LookupResult::Output(t) => LookupResult::Output((self.mutator)(t)),
-            LookupResult::Load { load, continuation } => LookupResult::Load {
-                load,
-                continuation: MappedLookup {
-                    original: continuation,
-                    mutator: self.mutator,
-                },
-            },
-        }
-    }
-}
-
-/// Some functions (e.g. `find_frames`) require considering multiple
-/// compilation units, each of which might require their own split DWARF
-/// lookup (and thus produce a continuation).
-///
-/// We store the underlying continuation here as well as a mutator function
-/// that will either a) decide that the result of this continuation is
-/// what is needed and mutate it to the final result or b) produce another
-/// `LookupResult`. `new_lookup` will in turn eagerly drive any non-continuation
-/// `LookupResult` with successive invocations of the mutator, until a new
-/// continuation or a final result is produced. And finally, the impl of
-/// `LookupContinuation::resume` will call `new_lookup` each time the
-/// computation is resumed.
-struct LoopingLookup<T, L, F>
-where
-    L: LookupContinuation,
-    F: FnMut(L::Output) -> ControlFlow<T, LookupResult<L>>,
-{
-    continuation: L,
-    mutator: F,
-}
-
-impl<T, L, F> LoopingLookup<T, L, F>
-where
-    L: LookupContinuation,
-    F: FnMut(L::Output) -> ControlFlow<T, LookupResult<L>>,
-{
-    fn new_complete(t: T) -> LookupResult<Self> {
-        LookupResult::Output(t)
-    }
-
-    fn new_lookup(mut r: LookupResult<L>, mut mutator: F) -> LookupResult<Self> {
-        // Drive the loop eagerly so that we only ever have to represent one state
-        // (the r == ControlFlow::Continue state) in LoopingLookup.
-        loop {
-            match r {
-                LookupResult::Output(l) => match mutator(l) {
-                    ControlFlow::Break(t) => return LookupResult::Output(t),
-                    ControlFlow::Continue(r2) => {
-                        r = r2;
-                    }
-                },
-                LookupResult::Load { load, continuation } => {
-                    return LookupResult::Load {
-                        load,
-                        continuation: LoopingLookup {
-                            continuation,
-                            mutator,
-                        },
-                    };
-                }
-            }
-        }
-    }
-}
-
-impl<T, L, F> LookupContinuation for LoopingLookup<T, L, F>
-where
-    L: LookupContinuation,
-    F: FnMut(L::Output) -> ControlFlow<T, LookupResult<L>>,
-{
-    type Output = T;
-    type Buf = L::Buf;
-
-    fn resume(self, v: Option<Arc<gimli::Dwarf<Self::Buf>>>) -> LookupResult<Self> {
-        let r = self.continuation.resume(v);
-        LoopingLookup::new_lookup(r, self.mutator)
-    }
-}
-
-impl<R: gimli::Reader> ResUnit<R> {
-    fn dwarf_and_unit_dwo<'unit, 'ctx: 'unit>(
-        &'unit self,
-        ctx: &'ctx Context<R>,
-    ) -> LookupResult<
-        SimpleLookup<
-            Result<(DebugFile, &'unit gimli::Dwarf<R>, &'unit gimli::Unit<R>), Error>,
-            R,
-            impl FnOnce(
-                Option<Arc<gimli::Dwarf<R>>>,
-            )
-                -> Result<(DebugFile, &'unit gimli::Dwarf<R>, &'unit gimli::Unit<R>), Error>,
-        >,
-    > {
-        loop {
-            break SimpleLookup::new_complete(match self.dwo.borrow() {
-                Some(Ok(Some(v))) => Ok((DebugFile::Dwo, &*v.0, &v.1)),
-                Some(Ok(None)) => Ok((DebugFile::Primary, &*ctx.sections, &self.dw_unit)),
-                Some(Err(e)) => Err(*e),
-                None => {
-                    let dwo_id = match self.dw_unit.dwo_id {
-                        None => {
-                            self.dwo.borrow_with(|| Ok(None));
-                            continue;
-                        }
-                        Some(dwo_id) => dwo_id,
-                    };
-
-                    let comp_dir = self.dw_unit.comp_dir.clone();
-
-                    let dwo_name = self.dw_unit.dwo_name().and_then(|s| {
-                        if let Some(s) = s {
-                            Ok(Some(ctx.sections.attr_string(&self.dw_unit, s)?))
-                        } else {
-                            Ok(None)
-                        }
-                    });
-
-                    let path = match dwo_name {
-                        Ok(v) => v,
-                        Err(e) => {
-                            self.dwo.borrow_with(|| Err(e));
-                            continue;
-                        }
-                    };
-
-                    let process_dwo = move |dwo_dwarf: Option<Arc<gimli::Dwarf<R>>>| {
-                        let dwo_dwarf = match dwo_dwarf {
-                            None => return Ok(None),
-                            Some(dwo_dwarf) => dwo_dwarf,
-                        };
-                        let mut dwo_units = dwo_dwarf.units();
-                        let dwo_header = match dwo_units.next()? {
-                            Some(dwo_header) => dwo_header,
-                            None => return Ok(None),
-                        };
-
-                        let mut dwo_unit = dwo_dwarf.unit(dwo_header)?;
-                        dwo_unit.copy_relocated_attributes(&self.dw_unit);
-                        Ok(Some(Box::new((dwo_dwarf, dwo_unit))))
-                    };
-
-                    return SimpleLookup::new_needs_load(
-                        SplitDwarfLoad {
-                            dwo_id,
-                            comp_dir,
-                            path,
-                            parent: ctx.sections.clone(),
-                        },
-                        move |dwo_dwarf| match self.dwo.borrow_with(|| process_dwo(dwo_dwarf)) {
-                            Ok(Some(v)) => Ok((DebugFile::Dwo, &*v.0, &v.1)),
-                            Ok(None) => Ok((DebugFile::Primary, &*ctx.sections, &self.dw_unit)),
-                            Err(e) => Err(*e),
-                        },
-                    );
-                }
-            });
-        }
-    }
-
-    fn parse_lines(&self, sections: &gimli::Dwarf<R>) -> Result<Option<&Lines>, Error> {
-        // NB: line information is always stored in the main debug file so this does not need
-        // to handle DWOs.
-        let ilnp = match self.dw_unit.line_program {
-            Some(ref ilnp) => ilnp,
-            None => return Ok(None),
-        };
-        self.lines
-            .borrow_with(|| Lines::parse(&self.dw_unit, ilnp.clone(), sections))
-            .as_ref()
-            .map(Some)
-            .map_err(Error::clone)
-    }
-
-    fn parse_functions_dwarf_and_unit(
-        &self,
-        unit: &gimli::Unit<R>,
-        sections: &gimli::Dwarf<R>,
-    ) -> Result<&Functions<R>, Error> {
-        self.funcs
-            .borrow_with(|| Functions::parse(unit, sections))
-            .as_ref()
-            .map_err(Error::clone)
-    }
-
-    fn parse_functions<'unit, 'ctx: 'unit>(
-        &'unit self,
-        ctx: &'ctx Context<R>,
-    ) -> LookupResult<impl LookupContinuation<Output = Result<&'unit Functions<R>, Error>, Buf = R>>
-    {
-        self.dwarf_and_unit_dwo(ctx).map(move |r| {
-            let (_file, sections, unit) = r?;
-            self.parse_functions_dwarf_and_unit(unit, sections)
-        })
-    }
-    fn parse_inlined_functions<'unit, 'ctx: 'unit>(
-        &'unit self,
-        ctx: &'ctx Context<R>,
-    ) -> LookupResult<impl LookupContinuation<Output = Result<(), Error>, Buf = R> + 'unit> {
-        self.dwarf_and_unit_dwo(ctx).map(move |r| {
-            let (file, sections, unit) = r?;
-            self.funcs
-                .borrow_with(|| Functions::parse(unit, sections))
-                .as_ref()
-                .map_err(Error::clone)?
-                .parse_inlined_functions(file, unit, ctx, sections)
-        })
-    }
-
-    fn find_location(
-        &self,
-        probe: u64,
-        sections: &gimli::Dwarf<R>,
-    ) -> Result<Option<Location<'_>>, Error> {
-        if let Some(mut iter) = LocationRangeUnitIter::new(self, sections, probe, probe + 1)? {
-            match iter.next() {
-                None => Ok(None),
-                Some((_addr, _len, loc)) => Ok(Some(loc)),
-            }
-        } else {
-            Ok(None)
-        }
-    }
-
-    #[inline]
-    fn find_location_range(
-        &self,
-        probe_low: u64,
-        probe_high: u64,
-        sections: &gimli::Dwarf<R>,
-    ) -> Result<Option<LocationRangeUnitIter<'_>>, Error> {
-        LocationRangeUnitIter::new(self, sections, probe_low, probe_high)
-    }
-
-    fn find_function_or_location<'unit, 'ctx: 'unit>(
-        &'unit self,
-        probe: u64,
-        ctx: &'ctx Context<R>,
-    ) -> LookupResult<
-        impl LookupContinuation<
-            Output = Result<(Option<&'unit Function<R>>, Option<Location<'unit>>), Error>,
-            Buf = R,
-        >,
-    > {
-        self.dwarf_and_unit_dwo(ctx).map(move |r| {
-            let (file, sections, unit) = r?;
-            let functions = self.parse_functions_dwarf_and_unit(unit, sections)?;
-            let function = match functions.find_address(probe) {
-                Some(address) => {
-                    let function_index = functions.addresses[address].function;
-                    let (offset, ref function) = functions.functions[function_index];
-                    Some(
-                        function
-                            .borrow_with(|| Function::parse(offset, file, unit, ctx, sections))
-                            .as_ref()
-                            .map_err(Error::clone)?,
-                    )
-                }
-                None => None,
-            };
-            let location = self.find_location(probe, sections)?;
-            Ok((function, location))
-        })
-    }
-}
-
-/// Iterator over `Location`s in a range of addresses, returned by `Context::find_location_range`.
-pub struct LocationRangeIter<'ctx, R: gimli::Reader> {
-    unit_iter: Box<dyn Iterator<Item = (&'ctx ResUnit<R>, &'ctx gimli::Range)> + 'ctx>,
-    iter: Option<LocationRangeUnitIter<'ctx>>,
-
-    probe_low: u64,
-    probe_high: u64,
-    sections: &'ctx gimli::Dwarf<R>,
-}
-
-impl<'ctx, R: gimli::Reader> LocationRangeIter<'ctx, R> {
-    #[inline]
-    fn new(ctx: &'ctx Context<R>, probe_low: u64, probe_high: u64) -> Result<Self, Error> {
-        let sections = &ctx.sections;
-        let unit_iter = ctx.find_units_range(probe_low, probe_high);
-        Ok(Self {
-            unit_iter: Box::new(unit_iter),
-            iter: None,
-            probe_low,
-            probe_high,
-            sections,
-        })
-    }
-
-    fn next_loc(&mut self) -> Result<Option<(u64, u64, Location<'ctx>)>, Error> {
-        loop {
-            let iter = self.iter.take();
-            match iter {
-                None => match self.unit_iter.next() {
-                    Some((unit, range)) => {
-                        self.iter = unit.find_location_range(
-                            cmp::max(self.probe_low, range.begin),
-                            cmp::min(self.probe_high, range.end),
-                            self.sections,
-                        )?;
-                    }
-                    None => return Ok(None),
-                },
-                Some(mut iter) => {
-                    if let item @ Some(_) = iter.next() {
-                        self.iter = Some(iter);
-                        return Ok(item);
-                    }
-                }
-            }
-        }
-    }
-}
-
-impl<'ctx, R> Iterator for LocationRangeIter<'ctx, R>
-where
-    R: gimli::Reader + 'ctx,
-{
-    type Item = (u64, u64, Location<'ctx>);
-
-    #[inline]
-    fn next(&mut self) -> Option<Self::Item> {
-        match self.next_loc() {
-            Err(_) => None,
-            Ok(loc) => loc,
-        }
-    }
-}
-
-#[cfg(feature = "fallible-iterator")]
-impl<'ctx, R> fallible_iterator::FallibleIterator for LocationRangeIter<'ctx, R>
-where
-    R: gimli::Reader + 'ctx,
-{
-    type Item = (u64, u64, Location<'ctx>);
-    type Error = Error;
-
-    #[inline]
-    fn next(&mut self) -> Result<Option<Self::Item>, Self::Error> {
-        self.next_loc()
-    }
-}
-
-struct LocationRangeUnitIter<'ctx> {
-    lines: &'ctx Lines,
-    seqs: &'ctx [LineSequence],
-    seq_idx: usize,
-    row_idx: usize,
-    probe_high: u64,
-}
-
-impl<'ctx> LocationRangeUnitIter<'ctx> {
-    fn new<R: gimli::Reader>(
-        resunit: &'ctx ResUnit<R>,
-        sections: &gimli::Dwarf<R>,
-        probe_low: u64,
-        probe_high: u64,
-    ) -> Result<Option<Self>, Error> {
-        let lines = resunit.parse_lines(sections)?;
-
-        if let Some(lines) = lines {
-            // Find index for probe_low.
-            let seq_idx = lines.sequences.binary_search_by(|sequence| {
-                if probe_low < sequence.start {
-                    Ordering::Greater
-                } else if probe_low >= sequence.end {
-                    Ordering::Less
-                } else {
-                    Ordering::Equal
-                }
-            });
-            let seq_idx = match seq_idx {
-                Ok(x) => x,
-                Err(0) => 0, // probe below sequence, but range could overlap
-                Err(_) => lines.sequences.len(),
-            };
-
-            let row_idx = if let Some(seq) = lines.sequences.get(seq_idx) {
-                let idx = seq.rows.binary_search_by(|row| row.address.cmp(&probe_low));
-                match idx {
-                    Ok(x) => x,
-                    Err(0) => 0, // probe below sequence, but range could overlap
-                    Err(x) => x - 1,
-                }
-            } else {
-                0
-            };
-
-            Ok(Some(Self {
-                lines,
-                seqs: &*lines.sequences,
-                seq_idx,
-                row_idx,
-                probe_high,
-            }))
-        } else {
-            Ok(None)
-        }
-    }
-}
-
-impl<'ctx> Iterator for LocationRangeUnitIter<'ctx> {
-    type Item = (u64, u64, Location<'ctx>);
-
-    fn next(&mut self) -> Option<(u64, u64, Location<'ctx>)> {
-        while let Some(seq) = self.seqs.get(self.seq_idx) {
-            if seq.start >= self.probe_high {
-                break;
-            }
-
-            match seq.rows.get(self.row_idx) {
-                Some(row) => {
-                    if row.address >= self.probe_high {
-                        break;
-                    }
-
-                    let file = self
-                        .lines
-                        .files
-                        .get(row.file_index as usize)
-                        .map(String::as_str);
-                    let nextaddr = seq
-                        .rows
-                        .get(self.row_idx + 1)
-                        .map(|row| row.address)
-                        .unwrap_or(seq.end);
-
-                    let item = (
-                        row.address,
-                        nextaddr - row.address,
-                        Location {
-                            file,
-                            line: if row.line != 0 { Some(row.line) } else { None },
-                            column: if row.column != 0 {
-                                Some(row.column)
-                            } else {
-                                None
-                            },
-                        },
-                    );
-                    self.row_idx += 1;
-
-                    return Some(item);
-                }
-                None => {
-                    self.seq_idx += 1;
-                    self.row_idx = 0;
-                }
-            }
-        }
-        None
-    }
-}
-
-fn path_push(path: &mut String, p: &str) {
-    if has_unix_root(p) || has_windows_root(p) {
-        *path = p.to_string();
-    } else {
-        let dir_separator = if has_windows_root(path.as_str()) {
-            '\\'
-        } else {
-            '/'
-        };
-
-        if !path.is_empty() && !path.ends_with(dir_separator) {
-            path.push(dir_separator);
-        }
-        *path += p;
-    }
-}
-
-/// Check if the path in the given string has a unix style root
-fn has_unix_root(p: &str) -> bool {
-    p.starts_with('/')
-}
-
-/// Check if the path in the given string has a windows style root
-fn has_windows_root(p: &str) -> bool {
-    p.starts_with('\\') || p.get(1..3) == Some(":\\")
-}
-struct RangeAttributes<R: gimli::Reader> {
-    low_pc: Option<u64>,
-    high_pc: Option<u64>,
-    size: Option<u64>,
-    ranges_offset: Option<gimli::RangeListsOffset<<R as gimli::Reader>::Offset>>,
-}
-
-impl<R: gimli::Reader> Default for RangeAttributes<R> {
-    fn default() -> Self {
-        RangeAttributes {
-            low_pc: None,
-            high_pc: None,
-            size: None,
-            ranges_offset: None,
-        }
-    }
-}
-
-impl<R: gimli::Reader> RangeAttributes<R> {
-    fn for_each_range<F: FnMut(gimli::Range)>(
-        &self,
-        sections: &gimli::Dwarf<R>,
-        unit: &gimli::Unit<R>,
-        mut f: F,
-    ) -> Result<bool, Error> {
-        let mut added_any = false;
-        let mut add_range = |range: gimli::Range| {
-            if range.begin < range.end {
-                f(range);
-                added_any = true
-            }
-        };
-        if let Some(ranges_offset) = self.ranges_offset {
-            let mut range_list = sections.ranges(unit, ranges_offset)?;
-            while let Some(range) = range_list.next()? {
-                add_range(range);
-            }
-        } else if let (Some(begin), Some(end)) = (self.low_pc, self.high_pc) {
-            add_range(gimli::Range { begin, end });
-        } else if let (Some(begin), Some(size)) = (self.low_pc, self.size) {
-            add_range(gimli::Range {
-                begin,
-                end: begin + size,
-            });
-        }
-        Ok(added_any)
-    }
-}
-
-/// An iterator over function frames.
-pub struct FrameIter<'ctx, R>(FrameIterState<'ctx, R>)
-where
-    R: gimli::Reader;
-
-enum FrameIterState<'ctx, R>
-where
-    R: gimli::Reader,
-{
-    Empty,
-    Location(Option<Location<'ctx>>),
-    Frames(FrameIterFrames<'ctx, R>),
-}
-
-struct FrameIterFrames<'ctx, R>
-where
-    R: gimli::Reader,
-{
-    unit: &'ctx ResUnit<R>,
-    sections: &'ctx gimli::Dwarf<R>,
-    function: &'ctx Function<R>,
-    inlined_functions: iter::Rev<maybe_small::IntoIter<&'ctx InlinedFunction<R>>>,
-    next: Option<Location<'ctx>>,
-}
-
-impl<'ctx, R> FrameIter<'ctx, R>
-where
-    R: gimli::Reader + 'ctx,
-{
-    /// Advances the iterator and returns the next frame.
-    pub fn next(&mut self) -> Result<Option<Frame<'ctx, R>>, Error> {
-        let frames = match &mut self.0 {
-            FrameIterState::Empty => return Ok(None),
-            FrameIterState::Location(location) => {
-                // We can't move out of a mutable reference, so use `take` instead.
-                let location = location.take();
-                self.0 = FrameIterState::Empty;
-                return Ok(Some(Frame {
-                    dw_die_offset: None,
-                    function: None,
-                    location,
-                }));
-            }
-            FrameIterState::Frames(frames) => frames,
-        };
-
-        let loc = frames.next.take();
-        let func = match frames.inlined_functions.next() {
-            Some(func) => func,
-            None => {
-                let frame = Frame {
-                    dw_die_offset: Some(frames.function.dw_die_offset),
-                    function: frames.function.name.clone().map(|name| FunctionName {
-                        name,
-                        language: frames.unit.lang,
-                    }),
-                    location: loc,
-                };
-                self.0 = FrameIterState::Empty;
-                return Ok(Some(frame));
-            }
-        };
-
-        let mut next = Location {
-            file: None,
-            line: if func.call_line != 0 {
-                Some(func.call_line)
-            } else {
-                None
-            },
-            column: if func.call_column != 0 {
-                Some(func.call_column)
-            } else {
-                None
-            },
-        };
-        if let Some(call_file) = func.call_file {
-            if let Some(lines) = frames.unit.parse_lines(frames.sections)? {
-                next.file = lines.files.get(call_file as usize).map(String::as_str);
-            }
-        }
-        frames.next = Some(next);
-
-        Ok(Some(Frame {
-            dw_die_offset: Some(func.dw_die_offset),
-            function: func.name.clone().map(|name| FunctionName {
-                name,
-                language: frames.unit.lang,
-            }),
-            location: loc,
-        }))
-    }
-}
-
-#[cfg(feature = "fallible-iterator")]
-impl<'ctx, R> fallible_iterator::FallibleIterator for FrameIter<'ctx, R>
-where
-    R: gimli::Reader + 'ctx,
-{
-    type Item = Frame<'ctx, R>;
-    type Error = Error;
-
-    #[inline]
-    fn next(&mut self) -> Result<Option<Frame<'ctx, R>>, Error> {
-        self.next()
-    }
-}
-
-/// A function frame.
-pub struct Frame<'ctx, R: gimli::Reader> {
-    /// The DWARF unit offset corresponding to the DIE of the function.
-    pub dw_die_offset: Option<gimli::UnitOffset<R::Offset>>,
-    /// The name of the function.
-    pub function: Option<FunctionName<R>>,
-    /// The source location corresponding to this frame.
-    pub location: Option<Location<'ctx>>,
-}
-
-/// A function name.
-pub struct FunctionName<R: gimli::Reader> {
-    /// The name of the function.
-    pub name: R,
-    /// The language of the compilation unit containing this function.
-    pub language: Option<gimli::DwLang>,
-}
-
-impl<R: gimli::Reader> FunctionName<R> {
-    /// The raw name of this function before demangling.
-    pub fn raw_name(&self) -> Result<Cow<'_, str>, Error> {
-        self.name.to_string_lossy()
-    }
-
-    /// The name of this function after demangling (if applicable).
-    pub fn demangle(&self) -> Result<Cow<'_, str>, Error> {
-        self.raw_name().map(|x| demangle_auto(x, self.language))
-    }
-}
-
-/// Demangle a symbol name using the demangling scheme for the given language.
-///
-/// Returns `None` if demangling failed or is not required.
-#[allow(unused_variables)]
-pub fn demangle(name: &str, language: gimli::DwLang) -> Option<String> {
-    match language {
-        #[cfg(feature = "rustc-demangle")]
-        gimli::DW_LANG_Rust => rustc_demangle::try_demangle(name)
-            .ok()
-            .as_ref()
-            .map(|x| format!("{:#}", x)),
-        #[cfg(feature = "cpp_demangle")]
-        gimli::DW_LANG_C_plus_plus
-        | gimli::DW_LANG_C_plus_plus_03
-        | gimli::DW_LANG_C_plus_plus_11
-        | gimli::DW_LANG_C_plus_plus_14 => cpp_demangle::Symbol::new(name)
-            .ok()
-            .and_then(|x| x.demangle(&Default::default()).ok()),
-        _ => None,
-    }
-}
-
-/// Apply 'best effort' demangling of a symbol name.
-///
-/// If `language` is given, then only the demangling scheme for that language
-/// is used.
-///
-/// If `language` is `None`, then heuristics are used to determine how to
-/// demangle the name. Currently, these heuristics are very basic.
-///
-/// If demangling fails or is not required, then `name` is returned unchanged.
-pub fn demangle_auto(name: Cow<'_, str>, language: Option<gimli::DwLang>) -> Cow<'_, str> {
-    match language {
-        Some(language) => demangle(name.as_ref(), language),
-        None => demangle(name.as_ref(), gimli::DW_LANG_Rust)
-            .or_else(|| demangle(name.as_ref(), gimli::DW_LANG_C_plus_plus)),
-    }
-    .map(Cow::from)
-    .unwrap_or(name)
-}
-
-/// A source location.
-pub struct Location<'a> {
-    /// The file name.
-    pub file: Option<&'a str>,
-    /// The line number.
-    pub line: Option<u32>,
-    /// The column number.
-    pub column: Option<u32>,
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn context_is_send() {
-        fn assert_is_send<T: Send>() {}
-        assert_is_send::<crate::Context<gimli::read::EndianSlice<'_, gimli::LittleEndian>>>();
-    }
-}