Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>

22 files changed, 33057 insertions, 0 deletions

diff --git a/vendor/gimli/src/read/abbrev.rs b/vendor/gimli/src/read/abbrev.rs
new file mode 100644
index 0000000..1162583
--- /dev/null
+++ b/vendor/gimli/src/read/abbrev.rs
@@ -0,0 +1,1102 @@
+//! Functions for parsing DWARF debugging abbreviations.
+
+use alloc::collections::btree_map;
+use alloc::sync::Arc;
+use alloc::vec::Vec;
+use core::convert::TryFrom;
+use core::fmt::{self, Debug};
+use core::iter::FromIterator;
+use core::ops::Deref;
+
+use crate::common::{DebugAbbrevOffset, Encoding, SectionId};
+use crate::constants;
+use crate::endianity::Endianity;
+use crate::read::{
+    DebugInfoUnitHeadersIter, EndianSlice, Error, Reader, ReaderOffset, Result, Section, UnitHeader,
+};
+
+/// The `DebugAbbrev` struct represents the abbreviations describing
+/// `DebuggingInformationEntry`s' attribute names and forms found in the
+/// `.debug_abbrev` section.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct DebugAbbrev<R> {
+    debug_abbrev_section: R,
+}
+
+impl<'input, Endian> DebugAbbrev<EndianSlice<'input, Endian>>
+where
+    Endian: Endianity,
+{
+    /// Construct a new `DebugAbbrev` instance from the data in the `.debug_abbrev`
+    /// section.
+    ///
+    /// It is the caller's responsibility to read the `.debug_abbrev` section and
+    /// present it as a `&[u8]` slice. That means using some ELF loader on
+    /// Linux, a Mach-O loader on macOS, etc.
+    ///
+    /// ```
+    /// use gimli::{DebugAbbrev, LittleEndian};
+    ///
+    /// # let buf = [0x00, 0x01, 0x02, 0x03];
+    /// # let read_debug_abbrev_section_somehow = || &buf;
+    /// let debug_abbrev = DebugAbbrev::new(read_debug_abbrev_section_somehow(), LittleEndian);
+    /// ```
+    pub fn new(debug_abbrev_section: &'input [u8], endian: Endian) -> Self {
+        Self::from(EndianSlice::new(debug_abbrev_section, endian))
+    }
+}
+
+impl<R: Reader> DebugAbbrev<R> {
+    /// Parse the abbreviations at the given `offset` within this
+    /// `.debug_abbrev` section.
+    ///
+    /// The `offset` should generally be retrieved from a unit header.
+    pub fn abbreviations(
+        &self,
+        debug_abbrev_offset: DebugAbbrevOffset<R::Offset>,
+    ) -> Result<Abbreviations> {
+        let input = &mut self.debug_abbrev_section.clone();
+        input.skip(debug_abbrev_offset.0)?;
+        Abbreviations::parse(input)
+    }
+}
+
+impl<T> DebugAbbrev<T> {
+    /// Create a `DebugAbbrev` section that references the data in `self`.
+    ///
+    /// This is useful when `R` implements `Reader` but `T` does not.
+    ///
+    /// ## Example Usage
+    ///
+    /// ```rust,no_run
+    /// # let load_section = || unimplemented!();
+    /// // Read the DWARF section into a `Vec` with whatever object loader you're using.
+    /// let owned_section: gimli::DebugAbbrev<Vec<u8>> = load_section();
+    /// // Create a reference to the DWARF section.
+    /// let section = owned_section.borrow(|section| {
+    ///     gimli::EndianSlice::new(&section, gimli::LittleEndian)
+    /// });
+    /// ```
+    pub fn borrow<'a, F, R>(&'a self, mut borrow: F) -> DebugAbbrev<R>
+    where
+        F: FnMut(&'a T) -> R,
+    {
+        borrow(&self.debug_abbrev_section).into()
+    }
+}
+
+impl<R> Section<R> for DebugAbbrev<R> {
+    fn id() -> SectionId {
+        SectionId::DebugAbbrev
+    }
+
+    fn reader(&self) -> &R {
+        &self.debug_abbrev_section
+    }
+}
+
+impl<R> From<R> for DebugAbbrev<R> {
+    fn from(debug_abbrev_section: R) -> Self {
+        DebugAbbrev {
+            debug_abbrev_section,
+        }
+    }
+}
+
+/// The strategy to use for caching abbreviations.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum AbbreviationsCacheStrategy {
+    /// Cache abbreviations that are used more than once.
+    ///
+    /// This is useful if the units in the `.debug_info` section will be parsed only once.
+    Duplicates,
+    /// Cache all abbreviations.
+    ///
+    /// This is useful if the units in the `.debug_info` section will be parsed more than once.
+    All,
+}
+
+/// A cache of previously parsed `Abbreviations`.
+#[derive(Debug, Default)]
+pub struct AbbreviationsCache {
+    abbreviations: btree_map::BTreeMap<u64, Result<Arc<Abbreviations>>>,
+}
+
+impl AbbreviationsCache {
+    /// Create an empty abbreviations cache.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Parse abbreviations and store them in the cache.
+    ///
+    /// This will iterate over the given units to determine the abbreviations
+    /// offsets. Any existing cache entries are discarded.
+    ///
+    /// Errors during parsing abbreviations are also stored in the cache.
+    /// Errors during iterating over the units are ignored.
+    pub fn populate<R: Reader>(
+        &mut self,
+        strategy: AbbreviationsCacheStrategy,
+        debug_abbrev: &DebugAbbrev<R>,
+        mut units: DebugInfoUnitHeadersIter<R>,
+    ) {
+        let mut offsets = Vec::new();
+        match strategy {
+            AbbreviationsCacheStrategy::Duplicates => {
+                while let Ok(Some(unit)) = units.next() {
+                    offsets.push(unit.debug_abbrev_offset());
+                }
+                offsets.sort_unstable_by_key(|offset| offset.0);
+                let mut prev_offset = R::Offset::from_u8(0);
+                let mut count = 0;
+                offsets.retain(|offset| {
+                    if count == 0 || prev_offset != offset.0 {
+                        prev_offset = offset.0;
+                        count = 1;
+                    } else {
+                        count += 1;
+                    }
+                    count == 2
+                });
+            }
+            AbbreviationsCacheStrategy::All => {
+                while let Ok(Some(unit)) = units.next() {
+                    offsets.push(unit.debug_abbrev_offset());
+                }
+                offsets.sort_unstable_by_key(|offset| offset.0);
+                offsets.dedup();
+            }
+        }
+        self.abbreviations = offsets
+            .into_iter()
+            .map(|offset| {
+                (
+                    offset.0.into_u64(),
+                    debug_abbrev.abbreviations(offset).map(Arc::new),
+                )
+            })
+            .collect();
+    }
+
+    /// Set an entry in the abbreviations cache.
+    ///
+    /// This is only required if you want to manually populate the cache.
+    pub fn set<R: Reader>(
+        &mut self,
+        offset: DebugAbbrevOffset<R::Offset>,
+        abbreviations: Arc<Abbreviations>,
+    ) {
+        self.abbreviations
+            .insert(offset.0.into_u64(), Ok(abbreviations));
+    }
+
+    /// Parse the abbreviations at the given offset.
+    ///
+    /// This uses the cache if possible, but does not update it.
+    pub fn get<R: Reader>(
+        &self,
+        debug_abbrev: &DebugAbbrev<R>,
+        offset: DebugAbbrevOffset<R::Offset>,
+    ) -> Result<Arc<Abbreviations>> {
+        match self.abbreviations.get(&offset.0.into_u64()) {
+            Some(entry) => entry.clone(),
+            None => debug_abbrev.abbreviations(offset).map(Arc::new),
+        }
+    }
+}
+
+/// A set of type abbreviations.
+///
+/// Construct an `Abbreviations` instance with the
+/// [`abbreviations()`](struct.UnitHeader.html#method.abbreviations)
+/// method.
+#[derive(Debug, Default, Clone)]
+pub struct Abbreviations {
+    vec: Vec<Abbreviation>,
+    map: btree_map::BTreeMap<u64, Abbreviation>,
+}
+
+impl Abbreviations {
+    /// Construct a new, empty set of abbreviations.
+    fn empty() -> Abbreviations {
+        Abbreviations {
+            vec: Vec::new(),
+            map: btree_map::BTreeMap::new(),
+        }
+    }
+
+    /// Insert an abbreviation into the set.
+    ///
+    /// Returns `Ok` if it is the first abbreviation in the set with its code,
+    /// `Err` if the code is a duplicate and there already exists an
+    /// abbreviation in the set with the given abbreviation's code.
+    fn insert(&mut self, abbrev: Abbreviation) -> ::core::result::Result<(), ()> {
+        let code_usize = abbrev.code as usize;
+        if code_usize as u64 == abbrev.code {
+            // Optimize for sequential abbreviation codes by storing them
+            // in a Vec, as long as the map doesn't already contain them.
+            // A potential further optimization would be to allow some
+            // holes in the Vec, but there's no need for that yet.
+            if code_usize - 1 < self.vec.len() {
+                return Err(());
+            } else if code_usize - 1 == self.vec.len() {
+                if !self.map.is_empty() && self.map.contains_key(&abbrev.code) {
+                    return Err(());
+                } else {
+                    self.vec.push(abbrev);
+                    return Ok(());
+                }
+            }
+        }
+        match self.map.entry(abbrev.code) {
+            btree_map::Entry::Occupied(_) => Err(()),
+            btree_map::Entry::Vacant(entry) => {
+                entry.insert(abbrev);
+                Ok(())
+            }
+        }
+    }
+
+    /// Get the abbreviation associated with the given code.
+    #[inline]
+    pub fn get(&self, code: u64) -> Option<&Abbreviation> {
+        if let Ok(code) = usize::try_from(code) {
+            let index = code.checked_sub(1)?;
+            if index < self.vec.len() {
+                return Some(&self.vec[index]);
+            }
+        }
+
+        self.map.get(&code)
+    }
+
+    /// Parse a series of abbreviations, terminated by a null abbreviation.
+    fn parse<R: Reader>(input: &mut R) -> Result<Abbreviations> {
+        let mut abbrevs = Abbreviations::empty();
+
+        while let Some(abbrev) = Abbreviation::parse(input)? {
+            if abbrevs.insert(abbrev).is_err() {
+                return Err(Error::DuplicateAbbreviationCode);
+            }
+        }
+
+        Ok(abbrevs)
+    }
+}
+
+/// An abbreviation describes the shape of a `DebuggingInformationEntry`'s type:
+/// its code, tag type, whether it has children, and its set of attributes.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Abbreviation {
+    code: u64,
+    tag: constants::DwTag,
+    has_children: constants::DwChildren,
+    attributes: Attributes,
+}
+
+impl Abbreviation {
+    /// Construct a new `Abbreviation`.
+    ///
+    /// ### Panics
+    ///
+    /// Panics if `code` is `0`.
+    pub(crate) fn new(
+        code: u64,
+        tag: constants::DwTag,
+        has_children: constants::DwChildren,
+        attributes: Attributes,
+    ) -> Abbreviation {
+        assert_ne!(code, 0);
+        Abbreviation {
+            code,
+            tag,
+            has_children,
+            attributes,
+        }
+    }
+
+    /// Get this abbreviation's code.
+    #[inline]
+    pub fn code(&self) -> u64 {
+        self.code
+    }
+
+    /// Get this abbreviation's tag.
+    #[inline]
+    pub fn tag(&self) -> constants::DwTag {
+        self.tag
+    }
+
+    /// Return true if this abbreviation's type has children, false otherwise.
+    #[inline]
+    pub fn has_children(&self) -> bool {
+        self.has_children == constants::DW_CHILDREN_yes
+    }
+
+    /// Get this abbreviation's attributes.
+    #[inline]
+    pub fn attributes(&self) -> &[AttributeSpecification] {
+        &self.attributes[..]
+    }
+
+    /// Parse an abbreviation's tag.
+    fn parse_tag<R: Reader>(input: &mut R) -> Result<constants::DwTag> {
+        let val = input.read_uleb128_u16()?;
+        if val == 0 {
+            Err(Error::AbbreviationTagZero)
+        } else {
+            Ok(constants::DwTag(val))
+        }
+    }
+
+    /// Parse an abbreviation's "does the type have children?" byte.
+    fn parse_has_children<R: Reader>(input: &mut R) -> Result<constants::DwChildren> {
+        let val = input.read_u8()?;
+        let val = constants::DwChildren(val);
+        if val == constants::DW_CHILDREN_no || val == constants::DW_CHILDREN_yes {
+            Ok(val)
+        } else {
+            Err(Error::BadHasChildren)
+        }
+    }
+
+    /// Parse a series of attribute specifications, terminated by a null attribute
+    /// specification.
+    fn parse_attributes<R: Reader>(input: &mut R) -> Result<Attributes> {
+        let mut attrs = Attributes::new();
+
+        while let Some(attr) = AttributeSpecification::parse(input)? {
+            attrs.push(attr);
+        }
+
+        Ok(attrs)
+    }
+
+    /// Parse an abbreviation. Return `None` for the null abbreviation, `Some`
+    /// for an actual abbreviation.
+    fn parse<R: Reader>(input: &mut R) -> Result<Option<Abbreviation>> {
+        let code = input.read_uleb128()?;
+        if code == 0 {
+            return Ok(None);
+        }
+
+        let tag = Self::parse_tag(input)?;
+        let has_children = Self::parse_has_children(input)?;
+        let attributes = Self::parse_attributes(input)?;
+        let abbrev = Abbreviation::new(code, tag, has_children, attributes);
+        Ok(Some(abbrev))
+    }
+}
+
+/// A list of attributes found in an `Abbreviation`
+#[derive(Clone)]
+pub(crate) enum Attributes {
+    Inline {
+        buf: [AttributeSpecification; MAX_ATTRIBUTES_INLINE],
+        len: usize,
+    },
+    Heap(Vec<AttributeSpecification>),
+}
+
+// Length of 5 based on benchmark results for both x86-64 and i686.
+const MAX_ATTRIBUTES_INLINE: usize = 5;
+
+impl Attributes {
+    /// Returns a new empty list of attributes
+    fn new() -> Attributes {
+        let default =
+            AttributeSpecification::new(constants::DW_AT_null, constants::DW_FORM_null, None);
+        Attributes::Inline {
+            buf: [default; 5],
+            len: 0,
+        }
+    }
+
+    /// Pushes a new value onto this list of attributes.
+    fn push(&mut self, attr: AttributeSpecification) {
+        match self {
+            Attributes::Heap(list) => list.push(attr),
+            Attributes::Inline {
+                buf,
+                len: MAX_ATTRIBUTES_INLINE,
+            } => {
+                let mut list = buf.to_vec();
+                list.push(attr);
+                *self = Attributes::Heap(list);
+            }
+            Attributes::Inline { buf, len } => {
+                buf[*len] = attr;
+                *len += 1;
+            }
+        }
+    }
+}
+
+impl Debug for Attributes {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+impl PartialEq for Attributes {
+    fn eq(&self, other: &Attributes) -> bool {
+        **self == **other
+    }
+}
+
+impl Eq for Attributes {}
+
+impl Deref for Attributes {
+    type Target = [AttributeSpecification];
+    fn deref(&self) -> &[AttributeSpecification] {
+        match self {
+            Attributes::Inline { buf, len } => &buf[..*len],
+            Attributes::Heap(list) => list,
+        }
+    }
+}
+
+impl FromIterator<AttributeSpecification> for Attributes {
+    fn from_iter<I>(iter: I) -> Attributes
+    where
+        I: IntoIterator<Item = AttributeSpecification>,
+    {
+        let mut list = Attributes::new();
+        for item in iter {
+            list.push(item);
+        }
+        list
+    }
+}
+
+impl From<Vec<AttributeSpecification>> for Attributes {
+    fn from(list: Vec<AttributeSpecification>) -> Attributes {
+        Attributes::Heap(list)
+    }
+}
+
+/// The description of an attribute in an abbreviated type. It is a pair of name
+/// and form.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct AttributeSpecification {
+    name: constants::DwAt,
+    form: constants::DwForm,
+    implicit_const_value: i64,
+}
+
+impl AttributeSpecification {
+    /// Construct a new `AttributeSpecification` from the given name and form
+    /// and implicit const value.
+    #[inline]
+    pub fn new(
+        name: constants::DwAt,
+        form: constants::DwForm,
+        implicit_const_value: Option<i64>,
+    ) -> AttributeSpecification {
+        debug_assert!(
+            (form == constants::DW_FORM_implicit_const && implicit_const_value.is_some())
+                || (form != constants::DW_FORM_implicit_const && implicit_const_value.is_none())
+        );
+        AttributeSpecification {
+            name,
+            form,
+            implicit_const_value: implicit_const_value.unwrap_or(0),
+        }
+    }
+
+    /// Get the attribute's name.
+    #[inline]
+    pub fn name(&self) -> constants::DwAt {
+        self.name
+    }
+
+    /// Get the attribute's form.
+    #[inline]
+    pub fn form(&self) -> constants::DwForm {
+        self.form
+    }
+
+    /// Get the attribute's implicit const value.
+    #[inline]
+    pub fn implicit_const_value(&self) -> Option<i64> {
+        if self.form == constants::DW_FORM_implicit_const {
+            Some(self.implicit_const_value)
+        } else {
+            None
+        }
+    }
+
+    /// Return the size of the attribute, in bytes.
+    ///
+    /// Note that because some attributes are variably sized, the size cannot
+    /// always be known without parsing, in which case we return `None`.
+    pub fn size<R: Reader>(&self, header: &UnitHeader<R>) -> Option<usize> {
+        get_attribute_size(self.form, header.encoding()).map(usize::from)
+    }
+
+    /// Parse an attribute's form.
+    fn parse_form<R: Reader>(input: &mut R) -> Result<constants::DwForm> {
+        let val = input.read_uleb128_u16()?;
+        if val == 0 {
+            Err(Error::AttributeFormZero)
+        } else {
+            Ok(constants::DwForm(val))
+        }
+    }
+
+    /// Parse an attribute specification. Returns `None` for the null attribute
+    /// specification, `Some` for an actual attribute specification.
+    fn parse<R: Reader>(input: &mut R) -> Result<Option<AttributeSpecification>> {
+        let name = input.read_uleb128_u16()?;
+        if name == 0 {
+            // Parse the null attribute specification.
+            let form = input.read_uleb128_u16()?;
+            return if form == 0 {
+                Ok(None)
+            } else {
+                Err(Error::ExpectedZero)
+            };
+        }
+
+        let name = constants::DwAt(name);
+        let form = Self::parse_form(input)?;
+        let implicit_const_value = if form == constants::DW_FORM_implicit_const {
+            Some(input.read_sleb128()?)
+        } else {
+            None
+        };
+        let spec = AttributeSpecification::new(name, form, implicit_const_value);
+        Ok(Some(spec))
+    }
+}
+
+#[inline]
+pub(crate) fn get_attribute_size(form: constants::DwForm, encoding: Encoding) -> Option<u8> {
+    match form {
+        constants::DW_FORM_addr => Some(encoding.address_size),
+
+        constants::DW_FORM_implicit_const | constants::DW_FORM_flag_present => Some(0),
+
+        constants::DW_FORM_data1
+        | constants::DW_FORM_flag
+        | constants::DW_FORM_strx1
+        | constants::DW_FORM_ref1
+        | constants::DW_FORM_addrx1 => Some(1),
+
+        constants::DW_FORM_data2
+        | constants::DW_FORM_ref2
+        | constants::DW_FORM_addrx2
+        | constants::DW_FORM_strx2 => Some(2),
+
+        constants::DW_FORM_addrx3 | constants::DW_FORM_strx3 => Some(3),
+
+        constants::DW_FORM_data4
+        | constants::DW_FORM_ref_sup4
+        | constants::DW_FORM_ref4
+        | constants::DW_FORM_strx4
+        | constants::DW_FORM_addrx4 => Some(4),
+
+        constants::DW_FORM_data8
+        | constants::DW_FORM_ref8
+        | constants::DW_FORM_ref_sig8
+        | constants::DW_FORM_ref_sup8 => Some(8),
+
+        constants::DW_FORM_data16 => Some(16),
+
+        constants::DW_FORM_sec_offset
+        | constants::DW_FORM_GNU_ref_alt
+        | constants::DW_FORM_strp
+        | constants::DW_FORM_strp_sup
+        | constants::DW_FORM_GNU_strp_alt
+        | constants::DW_FORM_line_strp => Some(encoding.format.word_size()),
+
+        constants::DW_FORM_ref_addr => {
+            // This is an offset, but DWARF version 2 specifies that DW_FORM_ref_addr
+            // has the same size as an address on the target system.  This was changed
+            // in DWARF version 3.
+            Some(if encoding.version == 2 {
+                encoding.address_size
+            } else {
+                encoding.format.word_size()
+            })
+        }
+
+        // Variably sized forms.
+        constants::DW_FORM_block
+        | constants::DW_FORM_block1
+        | constants::DW_FORM_block2
+        | constants::DW_FORM_block4
+        | constants::DW_FORM_exprloc
+        | constants::DW_FORM_ref_udata
+        | constants::DW_FORM_string
+        | constants::DW_FORM_sdata
+        | constants::DW_FORM_udata
+        | constants::DW_FORM_indirect => None,
+
+        // We don't know the size of unknown forms.
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+    use crate::constants;
+    use crate::endianity::LittleEndian;
+    use crate::read::{EndianSlice, Error};
+    use crate::test_util::GimliSectionMethods;
+    #[cfg(target_pointer_width = "32")]
+    use core::u32;
+    use test_assembler::Section;
+
+    pub trait AbbrevSectionMethods {
+        fn abbrev(self, code: u64, tag: constants::DwTag, children: constants::DwChildren) -> Self;
+        fn abbrev_null(self) -> Self;
+        fn abbrev_attr(self, name: constants::DwAt, form: constants::DwForm) -> Self;
+        fn abbrev_attr_implicit_const(self, name: constants::DwAt, value: i64) -> Self;
+        fn abbrev_attr_null(self) -> Self;
+    }
+
+    impl AbbrevSectionMethods for Section {
+        fn abbrev(self, code: u64, tag: constants::DwTag, children: constants::DwChildren) -> Self {
+            self.uleb(code).uleb(tag.0.into()).D8(children.0)
+        }
+
+        fn abbrev_null(self) -> Self {
+            self.D8(0)
+        }
+
+        fn abbrev_attr(self, name: constants::DwAt, form: constants::DwForm) -> Self {
+            self.uleb(name.0.into()).uleb(form.0.into())
+        }
+
+        fn abbrev_attr_implicit_const(self, name: constants::DwAt, value: i64) -> Self {
+            self.uleb(name.0.into())
+                .uleb(constants::DW_FORM_implicit_const.0.into())
+                .sleb(value)
+        }
+
+        fn abbrev_attr_null(self) -> Self {
+            self.D8(0).D8(0)
+        }
+    }
+
+    #[test]
+    fn test_debug_abbrev_ok() {
+        let extra_start = [1, 2, 3, 4];
+        let expected_rest = [5, 6, 7, 8];
+        #[rustfmt::skip]
+        let buf = Section::new()
+            .append_bytes(&extra_start)
+            .abbrev(2, constants::DW_TAG_subprogram, constants::DW_CHILDREN_no)
+                .abbrev_attr(constants::DW_AT_name, constants::DW_FORM_string)
+                .abbrev_attr_null()
+            .abbrev(1, constants::DW_TAG_compile_unit, constants::DW_CHILDREN_yes)
+                .abbrev_attr(constants::DW_AT_producer, constants::DW_FORM_strp)
+                .abbrev_attr(constants::DW_AT_language, constants::DW_FORM_data2)
+                .abbrev_attr_null()
+            .abbrev_null()
+            .append_bytes(&expected_rest)
+            .get_contents()
+            .unwrap();
+
+        let abbrev1 = Abbreviation::new(
+            1,
+            constants::DW_TAG_compile_unit,
+            constants::DW_CHILDREN_yes,
+            vec![
+                AttributeSpecification::new(
+                    constants::DW_AT_producer,
+                    constants::DW_FORM_strp,
+                    None,
+                ),
+                AttributeSpecification::new(
+                    constants::DW_AT_language,
+                    constants::DW_FORM_data2,
+                    None,
+                ),
+            ]
+            .into(),
+        );
+
+        let abbrev2 = Abbreviation::new(
+            2,
+            constants::DW_TAG_subprogram,
+            constants::DW_CHILDREN_no,
+            vec![AttributeSpecification::new(
+                constants::DW_AT_name,
+                constants::DW_FORM_string,
+                None,
+            )]
+            .into(),
+        );
+
+        let debug_abbrev = DebugAbbrev::new(&buf, LittleEndian);
+        let debug_abbrev_offset = DebugAbbrevOffset(extra_start.len());
+        let abbrevs = debug_abbrev
+            .abbreviations(debug_abbrev_offset)
+            .expect("Should parse abbreviations");
+        assert_eq!(abbrevs.get(1), Some(&abbrev1));
+        assert_eq!(abbrevs.get(2), Some(&abbrev2));
+    }
+
+    #[test]
+    fn test_abbreviations_insert() {
+        fn abbrev(code: u16) -> Abbreviation {
+            Abbreviation::new(
+                code.into(),
+                constants::DwTag(code),
+                constants::DW_CHILDREN_no,
+                vec![].into(),
+            )
+        }
+
+        fn assert_abbrev(abbrevs: &Abbreviations, code: u16) {
+            let abbrev = abbrevs.get(code.into()).unwrap();
+            assert_eq!(abbrev.tag(), constants::DwTag(code));
+        }
+
+        // Sequential insert.
+        let mut abbrevs = Abbreviations::empty();
+        abbrevs.insert(abbrev(1)).unwrap();
+        abbrevs.insert(abbrev(2)).unwrap();
+        assert_eq!(abbrevs.vec.len(), 2);
+        assert!(abbrevs.map.is_empty());
+        assert_abbrev(&abbrevs, 1);
+        assert_abbrev(&abbrevs, 2);
+
+        // Out of order insert.
+        let mut abbrevs = Abbreviations::empty();
+        abbrevs.insert(abbrev(2)).unwrap();
+        abbrevs.insert(abbrev(3)).unwrap();
+        assert!(abbrevs.vec.is_empty());
+        assert_abbrev(&abbrevs, 2);
+        assert_abbrev(&abbrevs, 3);
+
+        // Mixed order insert.
+        let mut abbrevs = Abbreviations::empty();
+        abbrevs.insert(abbrev(1)).unwrap();
+        abbrevs.insert(abbrev(3)).unwrap();
+        abbrevs.insert(abbrev(2)).unwrap();
+        assert_eq!(abbrevs.vec.len(), 2);
+        assert_abbrev(&abbrevs, 1);
+        assert_abbrev(&abbrevs, 2);
+        assert_abbrev(&abbrevs, 3);
+
+        // Duplicate code in vec.
+        let mut abbrevs = Abbreviations::empty();
+        abbrevs.insert(abbrev(1)).unwrap();
+        abbrevs.insert(abbrev(2)).unwrap();
+        assert_eq!(abbrevs.insert(abbrev(1)), Err(()));
+        assert_eq!(abbrevs.insert(abbrev(2)), Err(()));
+
+        // Duplicate code in map when adding to map.
+        let mut abbrevs = Abbreviations::empty();
+        abbrevs.insert(abbrev(2)).unwrap();
+        assert_eq!(abbrevs.insert(abbrev(2)), Err(()));
+
+        // Duplicate code in map when adding to vec.
+        let mut abbrevs = Abbreviations::empty();
+        abbrevs.insert(abbrev(2)).unwrap();
+        abbrevs.insert(abbrev(1)).unwrap();
+        assert_eq!(abbrevs.insert(abbrev(2)), Err(()));
+
+        // 32-bit usize conversions.
+        let mut abbrevs = Abbreviations::empty();
+        abbrevs.insert(abbrev(2)).unwrap();
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "32")]
+    fn test_abbreviations_insert_32() {
+        fn abbrev(code: u64) -> Abbreviation {
+            Abbreviation::new(
+                code,
+                constants::DwTag(code as u16),
+                constants::DW_CHILDREN_no,
+                vec![].into(),
+            )
+        }
+
+        fn assert_abbrev(abbrevs: &Abbreviations, code: u64) {
+            let abbrev = abbrevs.get(code).unwrap();
+            assert_eq!(abbrev.tag(), constants::DwTag(code as u16));
+        }
+
+        let mut abbrevs = Abbreviations::empty();
+        abbrevs.insert(abbrev(1)).unwrap();
+
+        let wrap_code = (u32::MAX as u64 + 1) + 1;
+        // `get` should not treat the wrapped code as `1`.
+        assert_eq!(abbrevs.get(wrap_code), None);
+        // `insert` should not treat the wrapped code as `1`.
+        abbrevs.insert(abbrev(wrap_code)).unwrap();
+        assert_abbrev(&abbrevs, 1);
+        assert_abbrev(&abbrevs, wrap_code);
+    }
+
+    #[test]
+    fn test_parse_abbreviations_ok() {
+        let expected_rest = [1, 2, 3, 4];
+        #[rustfmt::skip]
+        let buf = Section::new()
+            .abbrev(2, constants::DW_TAG_subprogram, constants::DW_CHILDREN_no)
+                .abbrev_attr(constants::DW_AT_name, constants::DW_FORM_string)
+                .abbrev_attr_null()
+            .abbrev(1, constants::DW_TAG_compile_unit, constants::DW_CHILDREN_yes)
+                .abbrev_attr(constants::DW_AT_producer, constants::DW_FORM_strp)
+                .abbrev_attr(constants::DW_AT_language, constants::DW_FORM_data2)
+                .abbrev_attr_null()
+            .abbrev_null()
+            .append_bytes(&expected_rest)
+            .get_contents()
+            .unwrap();
+        let rest = &mut EndianSlice::new(&*buf, LittleEndian);
+
+        let abbrev1 = Abbreviation::new(
+            1,
+            constants::DW_TAG_compile_unit,
+            constants::DW_CHILDREN_yes,
+            vec![
+                AttributeSpecification::new(
+                    constants::DW_AT_producer,
+                    constants::DW_FORM_strp,
+                    None,
+                ),
+                AttributeSpecification::new(
+                    constants::DW_AT_language,
+                    constants::DW_FORM_data2,
+                    None,
+                ),
+            ]
+            .into(),
+        );
+
+        let abbrev2 = Abbreviation::new(
+            2,
+            constants::DW_TAG_subprogram,
+            constants::DW_CHILDREN_no,
+            vec![AttributeSpecification::new(
+                constants::DW_AT_name,
+                constants::DW_FORM_string,
+                None,
+            )]
+            .into(),
+        );
+
+        let abbrevs = Abbreviations::parse(rest).expect("Should parse abbreviations");
+        assert_eq!(abbrevs.get(1), Some(&abbrev1));
+        assert_eq!(abbrevs.get(2), Some(&abbrev2));
+        assert_eq!(*rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_abbreviations_duplicate() {
+        let expected_rest = [1, 2, 3, 4];
+        #[rustfmt::skip]
+        let buf = Section::new()
+            .abbrev(1, constants::DW_TAG_subprogram, constants::DW_CHILDREN_no)
+                .abbrev_attr(constants::DW_AT_name, constants::DW_FORM_string)
+                .abbrev_attr_null()
+            .abbrev(1, constants::DW_TAG_compile_unit, constants::DW_CHILDREN_yes)
+                .abbrev_attr(constants::DW_AT_producer, constants::DW_FORM_strp)
+                .abbrev_attr(constants::DW_AT_language, constants::DW_FORM_data2)
+                .abbrev_attr_null()
+            .abbrev_null()
+            .append_bytes(&expected_rest)
+            .get_contents()
+            .unwrap();
+        let buf = &mut EndianSlice::new(&*buf, LittleEndian);
+
+        match Abbreviations::parse(buf) {
+            Err(Error::DuplicateAbbreviationCode) => {}
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    fn test_parse_abbreviation_tag_ok() {
+        let buf = [0x01, 0x02];
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+        let tag = Abbreviation::parse_tag(rest).expect("Should parse tag");
+        assert_eq!(tag, constants::DW_TAG_array_type);
+        assert_eq!(*rest, EndianSlice::new(&buf[1..], LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_abbreviation_tag_zero() {
+        let buf = [0x00];
+        let buf = &mut EndianSlice::new(&buf, LittleEndian);
+        match Abbreviation::parse_tag(buf) {
+            Err(Error::AbbreviationTagZero) => {}
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    fn test_parse_abbreviation_has_children() {
+        let buf = [0x00, 0x01, 0x02];
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+        let val = Abbreviation::parse_has_children(rest).expect("Should parse children");
+        assert_eq!(val, constants::DW_CHILDREN_no);
+        let val = Abbreviation::parse_has_children(rest).expect("Should parse children");
+        assert_eq!(val, constants::DW_CHILDREN_yes);
+        match Abbreviation::parse_has_children(rest) {
+            Err(Error::BadHasChildren) => {}
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    fn test_parse_abbreviation_ok() {
+        let expected_rest = [0x01, 0x02, 0x03, 0x04];
+        let buf = Section::new()
+            .abbrev(1, constants::DW_TAG_subprogram, constants::DW_CHILDREN_no)
+            .abbrev_attr(constants::DW_AT_name, constants::DW_FORM_string)
+            .abbrev_attr_null()
+            .append_bytes(&expected_rest)
+            .get_contents()
+            .unwrap();
+        let rest = &mut EndianSlice::new(&*buf, LittleEndian);
+
+        let expect = Some(Abbreviation::new(
+            1,
+            constants::DW_TAG_subprogram,
+            constants::DW_CHILDREN_no,
+            vec![AttributeSpecification::new(
+                constants::DW_AT_name,
+                constants::DW_FORM_string,
+                None,
+            )]
+            .into(),
+        ));
+
+        let abbrev = Abbreviation::parse(rest).expect("Should parse abbreviation");
+        assert_eq!(abbrev, expect);
+        assert_eq!(*rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_abbreviation_implicit_const_ok() {
+        let expected_rest = [0x01, 0x02, 0x03, 0x04];
+        let buf = Section::new()
+            .abbrev(1, constants::DW_TAG_subprogram, constants::DW_CHILDREN_no)
+            .abbrev_attr_implicit_const(constants::DW_AT_name, -42)
+            .abbrev_attr_null()
+            .append_bytes(&expected_rest)
+            .get_contents()
+            .unwrap();
+        let rest = &mut EndianSlice::new(&*buf, LittleEndian);
+
+        let expect = Some(Abbreviation::new(
+            1,
+            constants::DW_TAG_subprogram,
+            constants::DW_CHILDREN_no,
+            vec![AttributeSpecification::new(
+                constants::DW_AT_name,
+                constants::DW_FORM_implicit_const,
+                Some(-42),
+            )]
+            .into(),
+        ));
+
+        let abbrev = Abbreviation::parse(rest).expect("Should parse abbreviation");
+        assert_eq!(abbrev, expect);
+        assert_eq!(*rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_abbreviation_implicit_const_no_const() {
+        let buf = Section::new()
+            .abbrev(1, constants::DW_TAG_subprogram, constants::DW_CHILDREN_no)
+            .abbrev_attr(constants::DW_AT_name, constants::DW_FORM_implicit_const)
+            .get_contents()
+            .unwrap();
+        let buf = &mut EndianSlice::new(&*buf, LittleEndian);
+
+        match Abbreviation::parse(buf) {
+            Err(Error::UnexpectedEof(_)) => {}
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        }
+    }
+
+    #[test]
+    fn test_parse_null_abbreviation_ok() {
+        let expected_rest = [0x01, 0x02, 0x03, 0x04];
+        let buf = Section::new()
+            .abbrev_null()
+            .append_bytes(&expected_rest)
+            .get_contents()
+            .unwrap();
+        let rest = &mut EndianSlice::new(&*buf, LittleEndian);
+
+        let abbrev = Abbreviation::parse(rest).expect("Should parse null abbreviation");
+        assert!(abbrev.is_none());
+        assert_eq!(*rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_attribute_form_ok() {
+        let buf = [0x01, 0x02];
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+        let tag = AttributeSpecification::parse_form(rest).expect("Should parse form");
+        assert_eq!(tag, constants::DW_FORM_addr);
+        assert_eq!(*rest, EndianSlice::new(&buf[1..], LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_attribute_form_zero() {
+        let buf = [0x00];
+        let buf = &mut EndianSlice::new(&buf, LittleEndian);
+        match AttributeSpecification::parse_form(buf) {
+            Err(Error::AttributeFormZero) => {}
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    fn test_parse_null_attribute_specification_ok() {
+        let buf = [0x00, 0x00, 0x01];
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+        let attr =
+            AttributeSpecification::parse(rest).expect("Should parse null attribute specification");
+        assert!(attr.is_none());
+        assert_eq!(*rest, EndianSlice::new(&buf[2..], LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_attribute_specifications_name_zero() {
+        let buf = [0x00, 0x01, 0x00, 0x00];
+        let buf = &mut EndianSlice::new(&buf, LittleEndian);
+        match AttributeSpecification::parse(buf) {
+            Err(Error::ExpectedZero) => {}
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    fn test_parse_attribute_specifications_form_zero() {
+        let buf = [0x01, 0x00, 0x00, 0x00];
+        let buf = &mut EndianSlice::new(&buf, LittleEndian);
+        match AttributeSpecification::parse(buf) {
+            Err(Error::AttributeFormZero) => {}
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    fn test_get_abbrev_zero() {
+        let mut abbrevs = Abbreviations::empty();
+        abbrevs
+            .insert(Abbreviation::new(
+                1,
+                constants::DwTag(1),
+                constants::DW_CHILDREN_no,
+                vec![].into(),
+            ))
+            .unwrap();
+        assert!(abbrevs.get(0).is_none());
+    }
+}
diff --git a/vendor/gimli/src/read/addr.rs b/vendor/gimli/src/read/addr.rs
new file mode 100644
index 0000000..593f9fe
--- /dev/null
+++ b/vendor/gimli/src/read/addr.rs
@@ -0,0 +1,128 @@
+use crate::common::{DebugAddrBase, DebugAddrIndex, SectionId};
+use crate::read::{Reader, ReaderOffset, Result, Section};
+
+/// The raw contents of the `.debug_addr` section.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct DebugAddr<R> {
+    section: R,
+}
+
+impl<R: Reader> DebugAddr<R> {
+    // TODO: add an iterator over the sets of addresses in the section.
+    // This is not needed for common usage of the section though.
+
+    /// Returns the address at the given `base` and `index`.
+    ///
+    /// A set of addresses in the `.debug_addr` section consists of a header
+    /// followed by a series of addresses.
+    ///
+    /// The `base` must be the `DW_AT_addr_base` value from the compilation unit DIE.
+    /// This is an offset that points to the first address following the header.
+    ///
+    /// The `index` is the value of a `DW_FORM_addrx` attribute.
+    ///
+    /// The `address_size` must be the size of the address for the compilation unit.
+    /// This value must also match the header. However, note that we do not parse the
+    /// header to validate this, since locating the header is unreliable, and the GNU
+    /// extensions do not emit it.
+    pub fn get_address(
+        &self,
+        address_size: u8,
+        base: DebugAddrBase<R::Offset>,
+        index: DebugAddrIndex<R::Offset>,
+    ) -> Result<u64> {
+        let input = &mut self.section.clone();
+        input.skip(base.0)?;
+        input.skip(R::Offset::from_u64(
+            index.0.into_u64() * u64::from(address_size),
+        )?)?;
+        input.read_address(address_size)
+    }
+}
+
+impl<T> DebugAddr<T> {
+    /// Create a `DebugAddr` section that references the data in `self`.
+    ///
+    /// This is useful when `R` implements `Reader` but `T` does not.
+    ///
+    /// ## Example Usage
+    ///
+    /// ```rust,no_run
+    /// # let load_section = || unimplemented!();
+    /// // Read the DWARF section into a `Vec` with whatever object loader you're using.
+    /// let owned_section: gimli::DebugAddr<Vec<u8>> = load_section();
+    /// // Create a reference to the DWARF section.
+    /// let section = owned_section.borrow(|section| {
+    ///     gimli::EndianSlice::new(&section, gimli::LittleEndian)
+    /// });
+    /// ```
+    pub fn borrow<'a, F, R>(&'a self, mut borrow: F) -> DebugAddr<R>
+    where
+        F: FnMut(&'a T) -> R,
+    {
+        borrow(&self.section).into()
+    }
+}
+
+impl<R> Section<R> for DebugAddr<R> {
+    fn id() -> SectionId {
+        SectionId::DebugAddr
+    }
+
+    fn reader(&self) -> &R {
+        &self.section
+    }
+}
+
+impl<R> From<R> for DebugAddr<R> {
+    fn from(section: R) -> Self {
+        DebugAddr { section }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::read::EndianSlice;
+    use crate::test_util::GimliSectionMethods;
+    use crate::{Format, LittleEndian};
+    use test_assembler::{Endian, Label, LabelMaker, Section};
+
+    #[test]
+    fn test_get_address() {
+        for format in vec![Format::Dwarf32, Format::Dwarf64] {
+            for address_size in vec![4, 8] {
+                let zero = Label::new();
+                let length = Label::new();
+                let start = Label::new();
+                let first = Label::new();
+                let end = Label::new();
+                let mut section = Section::with_endian(Endian::Little)
+                    .mark(&zero)
+                    .initial_length(format, &length, &start)
+                    .D16(5)
+                    .D8(address_size)
+                    .D8(0)
+                    .mark(&first);
+                for i in 0..20 {
+                    section = section.word(address_size, 1000 + i);
+                }
+                section = section.mark(&end);
+                length.set_const((&end - &start) as u64);
+
+                let section = section.get_contents().unwrap();
+                let debug_addr = DebugAddr::from(EndianSlice::new(&section, LittleEndian));
+                let base = DebugAddrBase((&first - &zero) as usize);
+
+                assert_eq!(
+                    debug_addr.get_address(address_size, base, DebugAddrIndex(0)),
+                    Ok(1000)
+                );
+                assert_eq!(
+                    debug_addr.get_address(address_size, base, DebugAddrIndex(19)),
+                    Ok(1019)
+                );
+            }
+        }
+    }
+}
diff --git a/vendor/gimli/src/read/aranges.rs b/vendor/gimli/src/read/aranges.rs
new file mode 100644
index 0000000..83159b6
--- /dev/null
+++ b/vendor/gimli/src/read/aranges.rs
@@ -0,0 +1,660 @@
+use crate::common::{DebugArangesOffset, DebugInfoOffset, Encoding, SectionId};
+use crate::endianity::Endianity;
+use crate::read::{EndianSlice, Error, Range, Reader, ReaderOffset, Result, Section};
+
+/// The `DebugAranges` struct represents the DWARF address range information
+/// found in the `.debug_aranges` section.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct DebugAranges<R> {
+    section: R,
+}
+
+impl<'input, Endian> DebugAranges<EndianSlice<'input, Endian>>
+where
+    Endian: Endianity,
+{
+    /// Construct a new `DebugAranges` instance from the data in the `.debug_aranges`
+    /// section.
+    ///
+    /// It is the caller's responsibility to read the `.debug_aranges` section and
+    /// present it as a `&[u8]` slice. That means using some ELF loader on
+    /// Linux, a Mach-O loader on macOS, etc.
+    ///
+    /// ```
+    /// use gimli::{DebugAranges, LittleEndian};
+    ///
+    /// # let buf = [];
+    /// # let read_debug_aranges_section = || &buf;
+    /// let debug_aranges =
+    ///     DebugAranges::new(read_debug_aranges_section(), LittleEndian);
+    /// ```
+    pub fn new(section: &'input [u8], endian: Endian) -> Self {
+        DebugAranges {
+            section: EndianSlice::new(section, endian),
+        }
+    }
+}
+
+impl<R: Reader> DebugAranges<R> {
+    /// Iterate the sets of entries in the `.debug_aranges` section.
+    ///
+    /// Each set of entries belongs to a single unit.
+    pub fn headers(&self) -> ArangeHeaderIter<R> {
+        ArangeHeaderIter {
+            input: self.section.clone(),
+            offset: DebugArangesOffset(R::Offset::from_u8(0)),
+        }
+    }
+
+    /// Get the header at the given offset.
+    pub fn header(&self, offset: DebugArangesOffset<R::Offset>) -> Result<ArangeHeader<R>> {
+        let mut input = self.section.clone();
+        input.skip(offset.0)?;
+        ArangeHeader::parse(&mut input, offset)
+    }
+}
+
+impl<T> DebugAranges<T> {
+    /// Create a `DebugAranges` section that references the data in `self`.
+    ///
+    /// This is useful when `R` implements `Reader` but `T` does not.
+    ///
+    /// ## Example Usage
+    ///
+    /// ```rust,no_run
+    /// # let load_section = || unimplemented!();
+    /// // Read the DWARF section into a `Vec` with whatever object loader you're using.
+    /// let owned_section: gimli::DebugAranges<Vec<u8>> = load_section();
+    /// // Create a reference to the DWARF section.
+    /// let section = owned_section.borrow(|section| {
+    ///     gimli::EndianSlice::new(&section, gimli::LittleEndian)
+    /// });
+    /// ```
+    pub fn borrow<'a, F, R>(&'a self, mut borrow: F) -> DebugAranges<R>
+    where
+        F: FnMut(&'a T) -> R,
+    {
+        borrow(&self.section).into()
+    }
+}
+
+impl<R> Section<R> for DebugAranges<R> {
+    fn id() -> SectionId {
+        SectionId::DebugAranges
+    }
+
+    fn reader(&self) -> &R {
+        &self.section
+    }
+}
+
+impl<R> From<R> for DebugAranges<R> {
+    fn from(section: R) -> Self {
+        DebugAranges { section }
+    }
+}
+
+/// An iterator over the headers of a `.debug_aranges` section.
+#[derive(Clone, Debug)]
+pub struct ArangeHeaderIter<R: Reader> {
+    input: R,
+    offset: DebugArangesOffset<R::Offset>,
+}
+
+impl<R: Reader> ArangeHeaderIter<R> {
+    /// Advance the iterator to the next header.
+    pub fn next(&mut self) -> Result<Option<ArangeHeader<R>>> {
+        if self.input.is_empty() {
+            return Ok(None);
+        }
+
+        let len = self.input.len();
+        match ArangeHeader::parse(&mut self.input, self.offset) {
+            Ok(header) => {
+                self.offset.0 += len - self.input.len();
+                Ok(Some(header))
+            }
+            Err(e) => {
+                self.input.empty();
+                Err(e)
+            }
+        }
+    }
+}
+
+#[cfg(feature = "fallible-iterator")]
+impl<R: Reader> fallible_iterator::FallibleIterator for ArangeHeaderIter<R> {
+    type Item = ArangeHeader<R>;
+    type Error = Error;
+
+    fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> {
+        ArangeHeaderIter::next(self)
+    }
+}
+
+/// A header for a set of entries in the `.debug_arange` section.
+///
+/// These entries all belong to a single unit.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ArangeHeader<R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    offset: DebugArangesOffset<Offset>,
+    encoding: Encoding,
+    length: Offset,
+    debug_info_offset: DebugInfoOffset<Offset>,
+    segment_size: u8,
+    entries: R,
+}
+
+impl<R, Offset> ArangeHeader<R, Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    fn parse(input: &mut R, offset: DebugArangesOffset<Offset>) -> Result<Self> {
+        let (length, format) = input.read_initial_length()?;
+        let mut rest = input.split(length)?;
+
+        // Check the version. The DWARF 5 spec says that this is always 2, but version 3
+        // has been observed in the wild, potentially due to a bug; see
+        // https://github.com/gimli-rs/gimli/issues/559 for more information.
+        // lldb allows versions 2 through 5, possibly by mistake.
+        let version = rest.read_u16()?;
+        if version != 2 && version != 3 {
+            return Err(Error::UnknownVersion(u64::from(version)));
+        }
+
+        let debug_info_offset = rest.read_offset(format).map(DebugInfoOffset)?;
+        let address_size = rest.read_u8()?;
+        let segment_size = rest.read_u8()?;
+
+        // unit_length + version + offset + address_size + segment_size
+        let header_length = format.initial_length_size() + 2 + format.word_size() + 1 + 1;
+
+        // The first tuple following the header in each set begins at an offset that is
+        // a multiple of the size of a single tuple (that is, the size of a segment selector
+        // plus twice the size of an address).
+        let tuple_length = address_size
+            .checked_mul(2)
+            .and_then(|x| x.checked_add(segment_size))
+            .ok_or(Error::InvalidAddressRange)?;
+        if tuple_length == 0 {
+            return Err(Error::InvalidAddressRange)?;
+        }
+        let padding = if header_length % tuple_length == 0 {
+            0
+        } else {
+            tuple_length - header_length % tuple_length
+        };
+        rest.skip(R::Offset::from_u8(padding))?;
+
+        let encoding = Encoding {
+            format,
+            version,
+            address_size,
+            // TODO: segment_size
+        };
+        Ok(ArangeHeader {
+            offset,
+            encoding,
+            length,
+            debug_info_offset,
+            segment_size,
+            entries: rest,
+        })
+    }
+
+    /// Return the offset of this header within the `.debug_aranges` section.
+    #[inline]
+    pub fn offset(&self) -> DebugArangesOffset<Offset> {
+        self.offset
+    }
+
+    /// Return the length of this set of entries, including the header.
+    #[inline]
+    pub fn length(&self) -> Offset {
+        self.length
+    }
+
+    /// Return the encoding parameters for this set of entries.
+    #[inline]
+    pub fn encoding(&self) -> Encoding {
+        self.encoding
+    }
+
+    /// Return the segment size for this set of entries.
+    #[inline]
+    pub fn segment_size(&self) -> u8 {
+        self.segment_size
+    }
+
+    /// Return the offset into the .debug_info section for this set of arange entries.
+    #[inline]
+    pub fn debug_info_offset(&self) -> DebugInfoOffset<Offset> {
+        self.debug_info_offset
+    }
+
+    /// Return the arange entries in this set.
+    #[inline]
+    pub fn entries(&self) -> ArangeEntryIter<R> {
+        ArangeEntryIter {
+            input: self.entries.clone(),
+            encoding: self.encoding,
+            segment_size: self.segment_size,
+        }
+    }
+}
+
+/// An iterator over the aranges from a `.debug_aranges` section.
+///
+/// Can be [used with
+/// `FallibleIterator`](./index.html#using-with-fallibleiterator).
+#[derive(Debug, Clone)]
+pub struct ArangeEntryIter<R: Reader> {
+    input: R,
+    encoding: Encoding,
+    segment_size: u8,
+}
+
+impl<R: Reader> ArangeEntryIter<R> {
+    /// Advance the iterator and return the next arange.
+    ///
+    /// Returns the newly parsed arange as `Ok(Some(arange))`. Returns `Ok(None)`
+    /// when iteration is complete and all aranges have already been parsed and
+    /// yielded. If an error occurs while parsing the next arange, then this error
+    /// is returned as `Err(e)`, and all subsequent calls return `Ok(None)`.
+    pub fn next(&mut self) -> Result<Option<ArangeEntry>> {
+        if self.input.is_empty() {
+            return Ok(None);
+        }
+
+        match ArangeEntry::parse(&mut self.input, self.encoding, self.segment_size) {
+            Ok(Some(entry)) => Ok(Some(entry)),
+            Ok(None) => {
+                self.input.empty();
+                Ok(None)
+            }
+            Err(e) => {
+                self.input.empty();
+                Err(e)
+            }
+        }
+    }
+}
+
+#[cfg(feature = "fallible-iterator")]
+impl<R: Reader> fallible_iterator::FallibleIterator for ArangeEntryIter<R> {
+    type Item = ArangeEntry;
+    type Error = Error;
+
+    fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> {
+        ArangeEntryIter::next(self)
+    }
+}
+
+/// A single parsed arange.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct ArangeEntry {
+    segment: Option<u64>,
+    address: u64,
+    length: u64,
+}
+
+impl ArangeEntry {
+    /// Parse a single arange. Return `None` for the null arange, `Some` for an actual arange.
+    fn parse<R: Reader>(
+        input: &mut R,
+        encoding: Encoding,
+        segment_size: u8,
+    ) -> Result<Option<Self>> {
+        let address_size = encoding.address_size;
+
+        let tuple_length = R::Offset::from_u8(2 * address_size + segment_size);
+        if tuple_length > input.len() {
+            input.empty();
+            return Ok(None);
+        }
+
+        let segment = if segment_size != 0 {
+            input.read_address(segment_size)?
+        } else {
+            0
+        };
+        let address = input.read_address(address_size)?;
+        let length = input.read_address(address_size)?;
+
+        match (segment, address, length) {
+            // This is meant to be a null terminator, but in practice it can occur
+            // before the end, possibly due to a linker omitting a function and
+            // leaving an unrelocated entry.
+            (0, 0, 0) => Self::parse(input, encoding, segment_size),
+            _ => Ok(Some(ArangeEntry {
+                segment: if segment_size != 0 {
+                    Some(segment)
+                } else {
+                    None
+                },
+                address,
+                length,
+            })),
+        }
+    }
+
+    /// Return the segment selector of this arange.
+    #[inline]
+    pub fn segment(&self) -> Option<u64> {
+        self.segment
+    }
+
+    /// Return the beginning address of this arange.
+    #[inline]
+    pub fn address(&self) -> u64 {
+        self.address
+    }
+
+    /// Return the length of this arange.
+    #[inline]
+    pub fn length(&self) -> u64 {
+        self.length
+    }
+
+    /// Return the range.
+    #[inline]
+    pub fn range(&self) -> Range {
+        Range {
+            begin: self.address,
+            end: self.address.wrapping_add(self.length),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::common::{DebugInfoOffset, Format};
+    use crate::endianity::LittleEndian;
+    use crate::read::EndianSlice;
+
+    #[test]
+    fn test_iterate_headers() {
+        #[rustfmt::skip]
+        let buf = [
+            // 32-bit length = 28.
+            0x1c, 0x00, 0x00, 0x00,
+            // Version.
+            0x02, 0x00,
+            // Offset.
+            0x01, 0x02, 0x03, 0x04,
+            // Address size.
+            0x04,
+            // Segment size.
+            0x00,
+            // Dummy padding and arange tuples.
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+
+            // 32-bit length = 36.
+            0x24, 0x00, 0x00, 0x00,
+            // Version.
+            0x02, 0x00,
+            // Offset.
+            0x11, 0x12, 0x13, 0x14,
+            // Address size.
+            0x04,
+            // Segment size.
+            0x00,
+            // Dummy padding and arange tuples.
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+
+        let debug_aranges = DebugAranges::new(&buf, LittleEndian);
+        let mut headers = debug_aranges.headers();
+
+        let header = headers
+            .next()
+            .expect("should parse header ok")
+            .expect("should have a header");
+        assert_eq!(header.offset(), DebugArangesOffset(0));
+        assert_eq!(header.debug_info_offset(), DebugInfoOffset(0x0403_0201));
+
+        let header = headers
+            .next()
+            .expect("should parse header ok")
+            .expect("should have a header");
+        assert_eq!(header.offset(), DebugArangesOffset(0x20));
+        assert_eq!(header.debug_info_offset(), DebugInfoOffset(0x1413_1211));
+    }
+
+    #[test]
+    fn test_parse_header_ok() {
+        #[rustfmt::skip]
+        let buf = [
+            // 32-bit length = 32.
+            0x20, 0x00, 0x00, 0x00,
+            // Version.
+            0x02, 0x00,
+            // Offset.
+            0x01, 0x02, 0x03, 0x04,
+            // Address size.
+            0x08,
+            // Segment size.
+            0x04,
+            // Length to here = 12, tuple length = 20.
+            // Padding to tuple length multiple = 4.
+            0x10, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+
+            // Dummy arange tuple data.
+            0x20, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+
+            // Dummy next arange.
+            0x30, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+        ];
+
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        let header =
+            ArangeHeader::parse(rest, DebugArangesOffset(0x10)).expect("should parse header ok");
+
+        assert_eq!(
+            *rest,
+            EndianSlice::new(&buf[buf.len() - 16..], LittleEndian)
+        );
+        assert_eq!(
+            header,
+            ArangeHeader {
+                offset: DebugArangesOffset(0x10),
+                encoding: Encoding {
+                    format: Format::Dwarf32,
+                    version: 2,
+                    address_size: 8,
+                },
+                length: 0x20,
+                debug_info_offset: DebugInfoOffset(0x0403_0201),
+                segment_size: 4,
+                entries: EndianSlice::new(&buf[buf.len() - 32..buf.len() - 16], LittleEndian),
+            }
+        );
+    }
+
+    #[test]
+    fn test_parse_header_overflow_error() {
+        #[rustfmt::skip]
+        let buf = [
+            // 32-bit length = 32.
+            0x20, 0x00, 0x00, 0x00,
+            // Version.
+            0x02, 0x00,
+            // Offset.
+            0x01, 0x02, 0x03, 0x04,
+            // Address size.
+            0xff,
+            // Segment size.
+            0xff,
+            // Length to here = 12, tuple length = 20.
+            // Padding to tuple length multiple = 4.
+            0x10, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+
+            // Dummy arange tuple data.
+            0x20, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+
+            // Dummy next arange.
+            0x30, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+        ];
+
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        let error = ArangeHeader::parse(rest, DebugArangesOffset(0x10))
+            .expect_err("should fail to parse header");
+        assert_eq!(error, Error::InvalidAddressRange);
+    }
+
+    #[test]
+    fn test_parse_header_div_by_zero_error() {
+        #[rustfmt::skip]
+        let buf = [
+            // 32-bit length = 32.
+            0x20, 0x00, 0x00, 0x00,
+            // Version.
+            0x02, 0x00,
+            // Offset.
+            0x01, 0x02, 0x03, 0x04,
+            // Address size = 0. Could cause a division by zero if we aren't
+            // careful.
+            0x00,
+            // Segment size.
+            0x00,
+            // Length to here = 12, tuple length = 20.
+            // Padding to tuple length multiple = 4.
+            0x10, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+
+            // Dummy arange tuple data.
+            0x20, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+
+            // Dummy next arange.
+            0x30, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+        ];
+
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        let error = ArangeHeader::parse(rest, DebugArangesOffset(0x10))
+            .expect_err("should fail to parse header");
+        assert_eq!(error, Error::InvalidAddressRange);
+    }
+
+    #[test]
+    fn test_parse_entry_ok() {
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 2,
+            address_size: 4,
+        };
+        let segment_size = 0;
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09];
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+        let entry =
+            ArangeEntry::parse(rest, encoding, segment_size).expect("should parse entry ok");
+        assert_eq!(*rest, EndianSlice::new(&buf[buf.len() - 1..], LittleEndian));
+        assert_eq!(
+            entry,
+            Some(ArangeEntry {
+                segment: None,
+                address: 0x0403_0201,
+                length: 0x0807_0605,
+            })
+        );
+    }
+
+    #[test]
+    fn test_parse_entry_segment() {
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 2,
+            address_size: 4,
+        };
+        let segment_size = 8;
+        #[rustfmt::skip]
+        let buf = [
+            // Segment.
+            0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
+            // Address.
+            0x01, 0x02, 0x03, 0x04,
+            // Length.
+            0x05, 0x06, 0x07, 0x08,
+            // Next tuple.
+            0x09
+        ];
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+        let entry =
+            ArangeEntry::parse(rest, encoding, segment_size).expect("should parse entry ok");
+        assert_eq!(*rest, EndianSlice::new(&buf[buf.len() - 1..], LittleEndian));
+        assert_eq!(
+            entry,
+            Some(ArangeEntry {
+                segment: Some(0x1817_1615_1413_1211),
+                address: 0x0403_0201,
+                length: 0x0807_0605,
+            })
+        );
+    }
+
+    #[test]
+    fn test_parse_entry_zero() {
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 2,
+            address_size: 4,
+        };
+        let segment_size = 0;
+        #[rustfmt::skip]
+        let buf = [
+            // Zero tuple.
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            // Address.
+            0x01, 0x02, 0x03, 0x04,
+            // Length.
+            0x05, 0x06, 0x07, 0x08,
+            // Next tuple.
+            0x09
+        ];
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+        let entry =
+            ArangeEntry::parse(rest, encoding, segment_size).expect("should parse entry ok");
+        assert_eq!(*rest, EndianSlice::new(&buf[buf.len() - 1..], LittleEndian));
+        assert_eq!(
+            entry,
+            Some(ArangeEntry {
+                segment: None,
+                address: 0x0403_0201,
+                length: 0x0807_0605,
+            })
+        );
+    }
+}
diff --git a/vendor/gimli/src/read/cfi.rs b/vendor/gimli/src/read/cfi.rs
new file mode 100644
index 0000000..d92c8b2
--- /dev/null
+++ b/vendor/gimli/src/read/cfi.rs
@@ -0,0 +1,7823 @@
+#[cfg(feature = "read")]
+use alloc::boxed::Box;
+
+use core::cmp::{Ord, Ordering};
+use core::fmt::{self, Debug};
+use core::iter::FromIterator;
+use core::mem;
+use core::num::Wrapping;
+
+use super::util::{ArrayLike, ArrayVec};
+use crate::common::{
+    DebugFrameOffset, EhFrameOffset, Encoding, Format, Register, SectionId, Vendor,
+};
+use crate::constants::{self, DwEhPe};
+use crate::endianity::Endianity;
+use crate::read::{
+    EndianSlice, Error, Expression, Reader, ReaderOffset, Result, Section, StoreOnHeap,
+};
+
+/// `DebugFrame` contains the `.debug_frame` section's frame unwinding
+/// information required to unwind to and recover registers from older frames on
+/// the stack. For example, this is useful for a debugger that wants to print
+/// locals in a backtrace.
+///
+/// Most interesting methods are defined in the
+/// [`UnwindSection`](trait.UnwindSection.html) trait.
+///
+/// ### Differences between `.debug_frame` and `.eh_frame`
+///
+/// While the `.debug_frame` section's information has a lot of overlap with the
+/// `.eh_frame` section's information, the `.eh_frame` information tends to only
+/// encode the subset of information needed for exception handling. Often, only
+/// one of `.eh_frame` or `.debug_frame` will be present in an object file.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct DebugFrame<R: Reader> {
+    section: R,
+    address_size: u8,
+    segment_size: u8,
+    vendor: Vendor,
+}
+
+impl<R: Reader> DebugFrame<R> {
+    /// Set the size of a target address in bytes.
+    ///
+    /// This defaults to the native word size.
+    /// This is only used if the CIE version is less than 4.
+    pub fn set_address_size(&mut self, address_size: u8) {
+        self.address_size = address_size
+    }
+
+    /// Set the size of a segment selector in bytes.
+    ///
+    /// This defaults to 0.
+    /// This is only used if the CIE version is less than 4.
+    pub fn set_segment_size(&mut self, segment_size: u8) {
+        self.segment_size = segment_size
+    }
+
+    /// Set the vendor extensions to use.
+    ///
+    /// This defaults to `Vendor::Default`.
+    pub fn set_vendor(&mut self, vendor: Vendor) {
+        self.vendor = vendor;
+    }
+}
+
+impl<'input, Endian> DebugFrame<EndianSlice<'input, Endian>>
+where
+    Endian: Endianity,
+{
+    /// Construct a new `DebugFrame` instance from the data in the
+    /// `.debug_frame` section.
+    ///
+    /// It is the caller's responsibility to read the section and present it as
+    /// a `&[u8]` slice. That means using some ELF loader on Linux, a Mach-O
+    /// loader on macOS, etc.
+    ///
+    /// ```
+    /// use gimli::{DebugFrame, NativeEndian};
+    ///
+    /// // Use with `.debug_frame`
+    /// # let buf = [0x00, 0x01, 0x02, 0x03];
+    /// # let read_debug_frame_section_somehow = || &buf;
+    /// let debug_frame = DebugFrame::new(read_debug_frame_section_somehow(), NativeEndian);
+    /// ```
+    pub fn new(section: &'input [u8], endian: Endian) -> Self {
+        Self::from(EndianSlice::new(section, endian))
+    }
+}
+
+impl<R: Reader> Section<R> for DebugFrame<R> {
+    fn id() -> SectionId {
+        SectionId::DebugFrame
+    }
+
+    fn reader(&self) -> &R {
+        &self.section
+    }
+}
+
+impl<R: Reader> From<R> for DebugFrame<R> {
+    fn from(section: R) -> Self {
+        // Default to no segments and native word size.
+        DebugFrame {
+            section,
+            address_size: mem::size_of::<usize>() as u8,
+            segment_size: 0,
+            vendor: Vendor::Default,
+        }
+    }
+}
+
+/// `EhFrameHdr` contains the information about the `.eh_frame_hdr` section.
+///
+/// A pointer to the start of the `.eh_frame` data, and optionally, a binary
+/// search table of pointers to the `.eh_frame` records that are found in this section.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct EhFrameHdr<R: Reader>(R);
+
+/// `ParsedEhFrameHdr` contains the parsed information from the `.eh_frame_hdr` section.
+#[derive(Clone, Debug)]
+pub struct ParsedEhFrameHdr<R: Reader> {
+    address_size: u8,
+    section: R,
+
+    eh_frame_ptr: Pointer,
+    fde_count: u64,
+    table_enc: DwEhPe,
+    table: R,
+}
+
+impl<'input, Endian> EhFrameHdr<EndianSlice<'input, Endian>>
+where
+    Endian: Endianity,
+{
+    /// Constructs a new `EhFrameHdr` instance from the data in the `.eh_frame_hdr` section.
+    pub fn new(section: &'input [u8], endian: Endian) -> Self {
+        Self::from(EndianSlice::new(section, endian))
+    }
+}
+
+impl<R: Reader> EhFrameHdr<R> {
+    /// Parses this `EhFrameHdr` to a `ParsedEhFrameHdr`.
+    pub fn parse(&self, bases: &BaseAddresses, address_size: u8) -> Result<ParsedEhFrameHdr<R>> {
+        let mut reader = self.0.clone();
+        let version = reader.read_u8()?;
+        if version != 1 {
+            return Err(Error::UnknownVersion(u64::from(version)));
+        }
+
+        let eh_frame_ptr_enc = parse_pointer_encoding(&mut reader)?;
+        let fde_count_enc = parse_pointer_encoding(&mut reader)?;
+        let table_enc = parse_pointer_encoding(&mut reader)?;
+
+        let parameters = PointerEncodingParameters {
+            bases: &bases.eh_frame_hdr,
+            func_base: None,
+            address_size,
+            section: &self.0,
+        };
+
+        // Omitting this pointer is not valid (defeats the purpose of .eh_frame_hdr entirely)
+        if eh_frame_ptr_enc == constants::DW_EH_PE_omit {
+            return Err(Error::CannotParseOmitPointerEncoding);
+        }
+        let eh_frame_ptr = parse_encoded_pointer(eh_frame_ptr_enc, &parameters, &mut reader)?;
+
+        let fde_count;
+        if fde_count_enc == constants::DW_EH_PE_omit || table_enc == constants::DW_EH_PE_omit {
+            fde_count = 0
+        } else {
+            fde_count = parse_encoded_pointer(fde_count_enc, &parameters, &mut reader)?.direct()?;
+        }
+
+        Ok(ParsedEhFrameHdr {
+            address_size,
+            section: self.0.clone(),
+
+            eh_frame_ptr,
+            fde_count,
+            table_enc,
+            table: reader,
+        })
+    }
+}
+
+impl<R: Reader> Section<R> for EhFrameHdr<R> {
+    fn id() -> SectionId {
+        SectionId::EhFrameHdr
+    }
+
+    fn reader(&self) -> &R {
+        &self.0
+    }
+}
+
+impl<R: Reader> From<R> for EhFrameHdr<R> {
+    fn from(section: R) -> Self {
+        EhFrameHdr(section)
+    }
+}
+
+impl<R: Reader> ParsedEhFrameHdr<R> {
+    /// Returns the address of the binary's `.eh_frame` section.
+    pub fn eh_frame_ptr(&self) -> Pointer {
+        self.eh_frame_ptr
+    }
+
+    /// Retrieves the CFI binary search table, if there is one.
+    pub fn table(&self) -> Option<EhHdrTable<R>> {
+        // There are two big edge cases here:
+        // * You search the table for an invalid address. As this is just a binary
+        //   search table, we always have to return a valid result for that (unless
+        //   you specify an address that is lower than the first address in the
+        //   table). Since this means that you have to recheck that the FDE contains
+        //   your address anyways, we just return the first FDE even when the address
+        //   is too low. After all, we're just doing a normal binary search.
+        // * This falls apart when the table is empty - there is no entry we could
+        //   return. We conclude that an empty table is not really a table at all.
+        if self.fde_count == 0 {
+            None
+        } else {
+            Some(EhHdrTable { hdr: self })
+        }
+    }
+}
+
+/// An iterator for `.eh_frame_hdr` section's binary search table.
+///
+/// Each table entry consists of a tuple containing an  `initial_location` and `address`.
+/// The `initial location` represents the first address that the targeted FDE
+/// is able to decode. The `address` is the address of the FDE in the `.eh_frame` section.
+/// The `address` can be converted with `EhHdrTable::pointer_to_offset` and `EhFrame::fde_from_offset` to an FDE.
+#[derive(Debug)]
+pub struct EhHdrTableIter<'a, 'bases, R: Reader> {
+    hdr: &'a ParsedEhFrameHdr<R>,
+    table: R,
+    bases: &'bases BaseAddresses,
+    remain: u64,
+}
+
+impl<'a, 'bases, R: Reader> EhHdrTableIter<'a, 'bases, R> {
+    /// Yield the next entry in the `EhHdrTableIter`.
+    pub fn next(&mut self) -> Result<Option<(Pointer, Pointer)>> {
+        if self.remain == 0 {
+            return Ok(None);
+        }
+
+        let parameters = PointerEncodingParameters {
+            bases: &self.bases.eh_frame_hdr,
+            func_base: None,
+            address_size: self.hdr.address_size,
+            section: &self.hdr.section,
+        };
+
+        self.remain -= 1;
+        let from = parse_encoded_pointer(self.hdr.table_enc, &parameters, &mut self.table)?;
+        let to = parse_encoded_pointer(self.hdr.table_enc, &parameters, &mut self.table)?;
+        Ok(Some((from, to)))
+    }
+    /// Yield the nth entry in the `EhHdrTableIter`
+    pub fn nth(&mut self, n: usize) -> Result<Option<(Pointer, Pointer)>> {
+        use core::convert::TryFrom;
+        let size = match self.hdr.table_enc.format() {
+            constants::DW_EH_PE_uleb128 | constants::DW_EH_PE_sleb128 => {
+                return Err(Error::VariableLengthSearchTable);
+            }
+            constants::DW_EH_PE_sdata2 | constants::DW_EH_PE_udata2 => 2,
+            constants::DW_EH_PE_sdata4 | constants::DW_EH_PE_udata4 => 4,
+            constants::DW_EH_PE_sdata8 | constants::DW_EH_PE_udata8 => 8,
+            _ => return Err(Error::UnknownPointerEncoding),
+        };
+
+        let row_size = size * 2;
+        let n = u64::try_from(n).map_err(|_| Error::UnsupportedOffset)?;
+        self.remain = self.remain.saturating_sub(n);
+        self.table.skip(R::Offset::from_u64(n * row_size)?)?;
+        self.next()
+    }
+}
+
+#[cfg(feature = "fallible-iterator")]
+impl<'a, 'bases, R: Reader> fallible_iterator::FallibleIterator for EhHdrTableIter<'a, 'bases, R> {
+    type Item = (Pointer, Pointer);
+    type Error = Error;
+    fn next(&mut self) -> Result<Option<Self::Item>> {
+        EhHdrTableIter::next(self)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        use core::convert::TryInto;
+        (
+            self.remain.try_into().unwrap_or(0),
+            self.remain.try_into().ok(),
+        )
+    }
+
+    fn nth(&mut self, n: usize) -> Result<Option<Self::Item>> {
+        EhHdrTableIter::nth(self, n)
+    }
+}
+
+/// The CFI binary search table that is an optional part of the `.eh_frame_hdr` section.
+#[derive(Debug, Clone)]
+pub struct EhHdrTable<'a, R: Reader> {
+    hdr: &'a ParsedEhFrameHdr<R>,
+}
+
+impl<'a, R: Reader + 'a> EhHdrTable<'a, R> {
+    /// Return an iterator that can walk the `.eh_frame_hdr` table.
+    ///
+    /// Each table entry consists of a tuple containing an `initial_location` and `address`.
+    /// The `initial location` represents the first address that the targeted FDE
+    /// is able to decode. The `address` is the address of the FDE in the `.eh_frame` section.
+    /// The `address` can be converted with `EhHdrTable::pointer_to_offset` and `EhFrame::fde_from_offset` to an FDE.
+    pub fn iter<'bases>(&self, bases: &'bases BaseAddresses) -> EhHdrTableIter<'_, 'bases, R> {
+        EhHdrTableIter {
+            hdr: self.hdr,
+            bases,
+            remain: self.hdr.fde_count,
+            table: self.hdr.table.clone(),
+        }
+    }
+    /// *Probably* returns a pointer to the FDE for the given address.
+    ///
+    /// This performs a binary search, so if there is no FDE for the given address,
+    /// this function **will** return a pointer to any other FDE that's close by.
+    ///
+    /// To be sure, you **must** call `contains` on the FDE.
+    pub fn lookup(&self, address: u64, bases: &BaseAddresses) -> Result<Pointer> {
+        let size = match self.hdr.table_enc.format() {
+            constants::DW_EH_PE_uleb128 | constants::DW_EH_PE_sleb128 => {
+                return Err(Error::VariableLengthSearchTable);
+            }
+            constants::DW_EH_PE_sdata2 | constants::DW_EH_PE_udata2 => 2,
+            constants::DW_EH_PE_sdata4 | constants::DW_EH_PE_udata4 => 4,
+            constants::DW_EH_PE_sdata8 | constants::DW_EH_PE_udata8 => 8,
+            _ => return Err(Error::UnknownPointerEncoding),
+        };
+
+        let row_size = size * 2;
+
+        let mut len = self.hdr.fde_count;
+
+        let mut reader = self.hdr.table.clone();
+
+        let parameters = PointerEncodingParameters {
+            bases: &bases.eh_frame_hdr,
+            func_base: None,
+            address_size: self.hdr.address_size,
+            section: &self.hdr.section,
+        };
+
+        while len > 1 {
+            let head = reader.split(R::Offset::from_u64((len / 2) * row_size)?)?;
+            let tail = reader.clone();
+
+            let pivot =
+                parse_encoded_pointer(self.hdr.table_enc, &parameters, &mut reader)?.direct()?;
+
+            match pivot.cmp(&address) {
+                Ordering::Equal => {
+                    reader = tail;
+                    break;
+                }
+                Ordering::Less => {
+                    reader = tail;
+                    len = len - (len / 2);
+                }
+                Ordering::Greater => {
+                    reader = head;
+                    len /= 2;
+                }
+            }
+        }
+
+        reader.skip(R::Offset::from_u64(size)?)?;
+
+        parse_encoded_pointer(self.hdr.table_enc, &parameters, &mut reader)
+    }
+
+    /// Convert a `Pointer` to a section offset.
+    ///
+    /// This does not support indirect pointers.
+    pub fn pointer_to_offset(&self, ptr: Pointer) -> Result<EhFrameOffset<R::Offset>> {
+        let ptr = ptr.direct()?;
+        let eh_frame_ptr = self.hdr.eh_frame_ptr().direct()?;
+
+        // Calculate the offset in the EhFrame section
+        R::Offset::from_u64(ptr - eh_frame_ptr).map(EhFrameOffset)
+    }
+
+    /// Returns a parsed FDE for the given address, or `NoUnwindInfoForAddress`
+    /// if there are none.
+    ///
+    /// You must provide a function to get its associated CIE. See
+    /// `PartialFrameDescriptionEntry::parse` for more information.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use gimli::{BaseAddresses, EhFrame, ParsedEhFrameHdr, EndianSlice, NativeEndian, Error, UnwindSection};
+    /// # fn foo() -> Result<(), Error> {
+    /// # let eh_frame: EhFrame<EndianSlice<NativeEndian>> = unreachable!();
+    /// # let eh_frame_hdr: ParsedEhFrameHdr<EndianSlice<NativeEndian>> = unimplemented!();
+    /// # let addr = 0;
+    /// # let bases = unimplemented!();
+    /// let table = eh_frame_hdr.table().unwrap();
+    /// let fde = table.fde_for_address(&eh_frame, &bases, addr, EhFrame::cie_from_offset)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn fde_for_address<F>(
+        &self,
+        frame: &EhFrame<R>,
+        bases: &BaseAddresses,
+        address: u64,
+        get_cie: F,
+    ) -> Result<FrameDescriptionEntry<R>>
+    where
+        F: FnMut(
+            &EhFrame<R>,
+            &BaseAddresses,
+            EhFrameOffset<R::Offset>,
+        ) -> Result<CommonInformationEntry<R>>,
+    {
+        let fdeptr = self.lookup(address, bases)?;
+        let offset = self.pointer_to_offset(fdeptr)?;
+        let entry = frame.fde_from_offset(bases, offset, get_cie)?;
+        if entry.contains(address) {
+            Ok(entry)
+        } else {
+            Err(Error::NoUnwindInfoForAddress)
+        }
+    }
+
+    #[inline]
+    #[doc(hidden)]
+    #[deprecated(note = "Method renamed to fde_for_address; use that instead.")]
+    pub fn lookup_and_parse<F>(
+        &self,
+        address: u64,
+        bases: &BaseAddresses,
+        frame: EhFrame<R>,
+        get_cie: F,
+    ) -> Result<FrameDescriptionEntry<R>>
+    where
+        F: FnMut(
+            &EhFrame<R>,
+            &BaseAddresses,
+            EhFrameOffset<R::Offset>,
+        ) -> Result<CommonInformationEntry<R>>,
+    {
+        self.fde_for_address(&frame, bases, address, get_cie)
+    }
+
+    /// Returns the frame unwind information for the given address,
+    /// or `NoUnwindInfoForAddress` if there are none.
+    ///
+    /// You must provide a function to get the associated CIE. See
+    /// `PartialFrameDescriptionEntry::parse` for more information.
+    pub fn unwind_info_for_address<'ctx, F, A: UnwindContextStorage<R>>(
+        &self,
+        frame: &EhFrame<R>,
+        bases: &BaseAddresses,
+        ctx: &'ctx mut UnwindContext<R, A>,
+        address: u64,
+        get_cie: F,
+    ) -> Result<&'ctx UnwindTableRow<R, A>>
+    where
+        F: FnMut(
+            &EhFrame<R>,
+            &BaseAddresses,
+            EhFrameOffset<R::Offset>,
+        ) -> Result<CommonInformationEntry<R>>,
+    {
+        let fde = self.fde_for_address(frame, bases, address, get_cie)?;
+        fde.unwind_info_for_address(frame, bases, ctx, address)
+    }
+}
+
+/// `EhFrame` contains the frame unwinding information needed during exception
+/// handling found in the `.eh_frame` section.
+///
+/// Most interesting methods are defined in the
+/// [`UnwindSection`](trait.UnwindSection.html) trait.
+///
+/// See
+/// [`DebugFrame`](./struct.DebugFrame.html#differences-between-debug_frame-and-eh_frame)
+/// for some discussion on the differences between `.debug_frame` and
+/// `.eh_frame`.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct EhFrame<R: Reader> {
+    section: R,
+    address_size: u8,
+    vendor: Vendor,
+}
+
+impl<R: Reader> EhFrame<R> {
+    /// Set the size of a target address in bytes.
+    ///
+    /// This defaults to the native word size.
+    pub fn set_address_size(&mut self, address_size: u8) {
+        self.address_size = address_size
+    }
+
+    /// Set the vendor extensions to use.
+    ///
+    /// This defaults to `Vendor::Default`.
+    pub fn set_vendor(&mut self, vendor: Vendor) {
+        self.vendor = vendor;
+    }
+}
+
+impl<'input, Endian> EhFrame<EndianSlice<'input, Endian>>
+where
+    Endian: Endianity,
+{
+    /// Construct a new `EhFrame` instance from the data in the
+    /// `.eh_frame` section.
+    ///
+    /// It is the caller's responsibility to read the section and present it as
+    /// a `&[u8]` slice. That means using some ELF loader on Linux, a Mach-O
+    /// loader on macOS, etc.
+    ///
+    /// ```
+    /// use gimli::{EhFrame, EndianSlice, NativeEndian};
+    ///
+    /// // Use with `.eh_frame`
+    /// # let buf = [0x00, 0x01, 0x02, 0x03];
+    /// # let read_eh_frame_section_somehow = || &buf;
+    /// let eh_frame = EhFrame::new(read_eh_frame_section_somehow(), NativeEndian);
+    /// ```
+    pub fn new(section: &'input [u8], endian: Endian) -> Self {
+        Self::from(EndianSlice::new(section, endian))
+    }
+}
+
+impl<R: Reader> Section<R> for EhFrame<R> {
+    fn id() -> SectionId {
+        SectionId::EhFrame
+    }
+
+    fn reader(&self) -> &R {
+        &self.section
+    }
+}
+
+impl<R: Reader> From<R> for EhFrame<R> {
+    fn from(section: R) -> Self {
+        // Default to native word size.
+        EhFrame {
+            section,
+            address_size: mem::size_of::<usize>() as u8,
+            vendor: Vendor::Default,
+        }
+    }
+}
+
+// This has to be `pub` to silence a warning (that is deny(..)'d by default) in
+// rustc. Eventually, not having this `pub` will become a hard error.
+#[doc(hidden)]
+#[allow(missing_docs)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum CieOffsetEncoding {
+    U32,
+    U64,
+}
+
+/// An offset into an `UnwindSection`.
+//
+// Needed to avoid conflicting implementations of `Into<T>`.
+pub trait UnwindOffset<T = usize>: Copy + Debug + Eq + From<T>
+where
+    T: ReaderOffset,
+{
+    /// Convert an `UnwindOffset<T>` into a `T`.
+    fn into(self) -> T;
+}
+
+impl<T> UnwindOffset<T> for DebugFrameOffset<T>
+where
+    T: ReaderOffset,
+{
+    #[inline]
+    fn into(self) -> T {
+        self.0
+    }
+}
+
+impl<T> UnwindOffset<T> for EhFrameOffset<T>
+where
+    T: ReaderOffset,
+{
+    #[inline]
+    fn into(self) -> T {
+        self.0
+    }
+}
+
+/// This trait completely encapsulates everything that is different between
+/// `.eh_frame` and `.debug_frame`, as well as all the bits that can change
+/// between DWARF versions.
+#[doc(hidden)]
+pub trait _UnwindSectionPrivate<R: Reader> {
+    /// Get the underlying section data.
+    fn section(&self) -> &R;
+
+    /// Returns true if the given length value should be considered an
+    /// end-of-entries sentinel.
+    fn length_value_is_end_of_entries(length: R::Offset) -> bool;
+
+    /// Return true if the given offset if the CIE sentinel, false otherwise.
+    fn is_cie(format: Format, id: u64) -> bool;
+
+    /// Return the CIE offset/ID encoding used by this unwind section with the
+    /// given DWARF format.
+    fn cie_offset_encoding(format: Format) -> CieOffsetEncoding;
+
+    /// For `.eh_frame`, CIE offsets are relative to the current position. For
+    /// `.debug_frame`, they are relative to the start of the section. We always
+    /// internally store them relative to the section, so we handle translating
+    /// `.eh_frame`'s relative offsets in this method. If the offset calculation
+    /// underflows, return `None`.
+    fn resolve_cie_offset(&self, base: R::Offset, offset: R::Offset) -> Option<R::Offset>;
+
+    /// Does this version of this unwind section encode address and segment
+    /// sizes in its CIEs?
+    fn has_address_and_segment_sizes(version: u8) -> bool;
+
+    /// The address size to use if `has_address_and_segment_sizes` returns false.
+    fn address_size(&self) -> u8;
+
+    /// The segment size to use if `has_address_and_segment_sizes` returns false.
+    fn segment_size(&self) -> u8;
+
+    /// The vendor extensions to use.
+    fn vendor(&self) -> Vendor;
+}
+
+/// A section holding unwind information: either `.debug_frame` or
+/// `.eh_frame`. See [`DebugFrame`](./struct.DebugFrame.html) and
+/// [`EhFrame`](./struct.EhFrame.html) respectively.
+pub trait UnwindSection<R: Reader>: Clone + Debug + _UnwindSectionPrivate<R> {
+    /// The offset type associated with this CFI section. Either
+    /// `DebugFrameOffset` or `EhFrameOffset`.
+    type Offset: UnwindOffset<R::Offset>;
+
+    /// Iterate over the `CommonInformationEntry`s and `FrameDescriptionEntry`s
+    /// in this `.debug_frame` section.
+    ///
+    /// Can be [used with
+    /// `FallibleIterator`](./index.html#using-with-fallibleiterator).
+    fn entries<'bases>(&self, bases: &'bases BaseAddresses) -> CfiEntriesIter<'bases, Self, R> {
+        CfiEntriesIter {
+            section: self.clone(),
+            bases,
+            input: self.section().clone(),
+        }
+    }
+
+    /// Parse the `CommonInformationEntry` at the given offset.
+    fn cie_from_offset(
+        &self,
+        bases: &BaseAddresses,
+        offset: Self::Offset,
+    ) -> Result<CommonInformationEntry<R>> {
+        let offset = UnwindOffset::into(offset);
+        let input = &mut self.section().clone();
+        input.skip(offset)?;
+        CommonInformationEntry::parse(bases, self, input)
+    }
+
+    /// Parse the `PartialFrameDescriptionEntry` at the given offset.
+    fn partial_fde_from_offset<'bases>(
+        &self,
+        bases: &'bases BaseAddresses,
+        offset: Self::Offset,
+    ) -> Result<PartialFrameDescriptionEntry<'bases, Self, R>> {
+        let offset = UnwindOffset::into(offset);
+        let input = &mut self.section().clone();
+        input.skip(offset)?;
+        PartialFrameDescriptionEntry::parse_partial(self, bases, input)
+    }
+
+    /// Parse the `FrameDescriptionEntry` at the given offset.
+    fn fde_from_offset<F>(
+        &self,
+        bases: &BaseAddresses,
+        offset: Self::Offset,
+        get_cie: F,
+    ) -> Result<FrameDescriptionEntry<R>>
+    where
+        F: FnMut(&Self, &BaseAddresses, Self::Offset) -> Result<CommonInformationEntry<R>>,
+    {
+        let partial = self.partial_fde_from_offset(bases, offset)?;
+        partial.parse(get_cie)
+    }
+
+    /// Find the `FrameDescriptionEntry` for the given address.
+    ///
+    /// If found, the FDE is returned.  If not found,
+    /// `Err(gimli::Error::NoUnwindInfoForAddress)` is returned.
+    /// If parsing fails, the error is returned.
+    ///
+    /// You must provide a function to get its associated CIE. See
+    /// `PartialFrameDescriptionEntry::parse` for more information.
+    ///
+    /// Note: this iterates over all FDEs. If available, it is possible
+    /// to do a binary search with `EhFrameHdr::fde_for_address` instead.
+    fn fde_for_address<F>(
+        &self,
+        bases: &BaseAddresses,
+        address: u64,
+        mut get_cie: F,
+    ) -> Result<FrameDescriptionEntry<R>>
+    where
+        F: FnMut(&Self, &BaseAddresses, Self::Offset) -> Result<CommonInformationEntry<R>>,
+    {
+        let mut entries = self.entries(bases);
+        while let Some(entry) = entries.next()? {
+            match entry {
+                CieOrFde::Cie(_) => {}
+                CieOrFde::Fde(partial) => {
+                    let fde = partial.parse(&mut get_cie)?;
+                    if fde.contains(address) {
+                        return Ok(fde);
+                    }
+                }
+            }
+        }
+        Err(Error::NoUnwindInfoForAddress)
+    }
+
+    /// Find the frame unwind information for the given address.
+    ///
+    /// If found, the unwind information is returned.  If not found,
+    /// `Err(gimli::Error::NoUnwindInfoForAddress)` is returned. If parsing or
+    /// CFI evaluation fails, the error is returned.
+    ///
+    /// ```
+    /// use gimli::{BaseAddresses, EhFrame, EndianSlice, NativeEndian, UnwindContext,
+    ///             UnwindSection};
+    ///
+    /// # fn foo() -> gimli::Result<()> {
+    /// # let read_eh_frame_section = || unimplemented!();
+    /// // Get the `.eh_frame` section from the object file. Alternatively,
+    /// // use `EhFrame` with the `.eh_frame` section of the object file.
+    /// let eh_frame = EhFrame::new(read_eh_frame_section(), NativeEndian);
+    ///
+    /// # let get_frame_pc = || unimplemented!();
+    /// // Get the address of the PC for a frame you'd like to unwind.
+    /// let address = get_frame_pc();
+    ///
+    /// // This context is reusable, which cuts down on heap allocations.
+    /// let ctx = UnwindContext::new();
+    ///
+    /// // Optionally provide base addresses for any relative pointers. If a
+    /// // base address isn't provided and a pointer is found that is relative to
+    /// // it, we will return an `Err`.
+    /// # let address_of_text_section_in_memory = unimplemented!();
+    /// # let address_of_got_section_in_memory = unimplemented!();
+    /// let bases = BaseAddresses::default()
+    ///     .set_text(address_of_text_section_in_memory)
+    ///     .set_got(address_of_got_section_in_memory);
+    ///
+    /// let unwind_info = eh_frame.unwind_info_for_address(
+    ///     &bases,
+    ///     &mut ctx,
+    ///     address,
+    ///     EhFrame::cie_from_offset,
+    /// )?;
+    ///
+    /// # let do_stuff_with = |_| unimplemented!();
+    /// do_stuff_with(unwind_info);
+    /// # let _ = ctx;
+    /// # unreachable!()
+    /// # }
+    /// ```
+    #[inline]
+    fn unwind_info_for_address<'ctx, F, A: UnwindContextStorage<R>>(
+        &self,
+        bases: &BaseAddresses,
+        ctx: &'ctx mut UnwindContext<R, A>,
+        address: u64,
+        get_cie: F,
+    ) -> Result<&'ctx UnwindTableRow<R, A>>
+    where
+        F: FnMut(&Self, &BaseAddresses, Self::Offset) -> Result<CommonInformationEntry<R>>,
+    {
+        let fde = self.fde_for_address(bases, address, get_cie)?;
+        fde.unwind_info_for_address(self, bases, ctx, address)
+    }
+}
+
+impl<R: Reader> _UnwindSectionPrivate<R> for DebugFrame<R> {
+    fn section(&self) -> &R {
+        &self.section
+    }
+
+    fn length_value_is_end_of_entries(_: R::Offset) -> bool {
+        false
+    }
+
+    fn is_cie(format: Format, id: u64) -> bool {
+        match format {
+            Format::Dwarf32 => id == 0xffff_ffff,
+            Format::Dwarf64 => id == 0xffff_ffff_ffff_ffff,
+        }
+    }
+
+    fn cie_offset_encoding(format: Format) -> CieOffsetEncoding {
+        match format {
+            Format::Dwarf32 => CieOffsetEncoding::U32,
+            Format::Dwarf64 => CieOffsetEncoding::U64,
+        }
+    }
+
+    fn resolve_cie_offset(&self, _: R::Offset, offset: R::Offset) -> Option<R::Offset> {
+        Some(offset)
+    }
+
+    fn has_address_and_segment_sizes(version: u8) -> bool {
+        version == 4
+    }
+
+    fn address_size(&self) -> u8 {
+        self.address_size
+    }
+
+    fn segment_size(&self) -> u8 {
+        self.segment_size
+    }
+
+    fn vendor(&self) -> Vendor {
+        self.vendor
+    }
+}
+
+impl<R: Reader> UnwindSection<R> for DebugFrame<R> {
+    type Offset = DebugFrameOffset<R::Offset>;
+}
+
+impl<R: Reader> _UnwindSectionPrivate<R> for EhFrame<R> {
+    fn section(&self) -> &R {
+        &self.section
+    }
+
+    fn length_value_is_end_of_entries(length: R::Offset) -> bool {
+        length.into_u64() == 0
+    }
+
+    fn is_cie(_: Format, id: u64) -> bool {
+        id == 0
+    }
+
+    fn cie_offset_encoding(_format: Format) -> CieOffsetEncoding {
+        // `.eh_frame` offsets are always 4 bytes, regardless of the DWARF
+        // format.
+        CieOffsetEncoding::U32
+    }
+
+    fn resolve_cie_offset(&self, base: R::Offset, offset: R::Offset) -> Option<R::Offset> {
+        base.checked_sub(offset)
+    }
+
+    fn has_address_and_segment_sizes(_version: u8) -> bool {
+        false
+    }
+
+    fn address_size(&self) -> u8 {
+        self.address_size
+    }
+
+    fn segment_size(&self) -> u8 {
+        0
+    }
+
+    fn vendor(&self) -> Vendor {
+        self.vendor
+    }
+}
+
+impl<R: Reader> UnwindSection<R> for EhFrame<R> {
+    type Offset = EhFrameOffset<R::Offset>;
+}
+
+/// Optional base addresses for the relative `DW_EH_PE_*` encoded pointers.
+///
+/// During CIE/FDE parsing, if a relative pointer is encountered for a base
+/// address that is unknown, an Err will be returned.
+///
+/// ```
+/// use gimli::BaseAddresses;
+///
+/// # fn foo() {
+/// # let address_of_eh_frame_hdr_section_in_memory = unimplemented!();
+/// # let address_of_eh_frame_section_in_memory = unimplemented!();
+/// # let address_of_text_section_in_memory = unimplemented!();
+/// # let address_of_got_section_in_memory = unimplemented!();
+/// # let address_of_the_start_of_current_func = unimplemented!();
+/// let bases = BaseAddresses::default()
+///     .set_eh_frame_hdr(address_of_eh_frame_hdr_section_in_memory)
+///     .set_eh_frame(address_of_eh_frame_section_in_memory)
+///     .set_text(address_of_text_section_in_memory)
+///     .set_got(address_of_got_section_in_memory);
+/// # let _ = bases;
+/// # }
+/// ```
+#[derive(Clone, Default, Debug, PartialEq, Eq)]
+pub struct BaseAddresses {
+    /// The base addresses to use for pointers in the `.eh_frame_hdr` section.
+    pub eh_frame_hdr: SectionBaseAddresses,
+
+    /// The base addresses to use for pointers in the `.eh_frame` section.
+    pub eh_frame: SectionBaseAddresses,
+}
+
+/// Optional base addresses for the relative `DW_EH_PE_*` encoded pointers
+/// in a particular section.
+///
+/// See `BaseAddresses` for methods that are helpful in setting these addresses.
+#[derive(Clone, Default, Debug, PartialEq, Eq)]
+pub struct SectionBaseAddresses {
+    /// The address of the section containing the pointer.
+    pub section: Option<u64>,
+
+    /// The base address for text relative pointers.
+    /// This is generally the address of the `.text` section.
+    pub text: Option<u64>,
+
+    /// The base address for data relative pointers.
+    ///
+    /// For pointers in the `.eh_frame_hdr` section, this is the address
+    /// of the `.eh_frame_hdr` section
+    ///
+    /// For pointers in the `.eh_frame` section, this is generally the
+    /// global pointer, such as the address of the `.got` section.
+    pub data: Option<u64>,
+}
+
+impl BaseAddresses {
+    /// Set the `.eh_frame_hdr` section base address.
+    #[inline]
+    pub fn set_eh_frame_hdr(mut self, addr: u64) -> Self {
+        self.eh_frame_hdr.section = Some(addr);
+        self.eh_frame_hdr.data = Some(addr);
+        self
+    }
+
+    /// Set the `.eh_frame` section base address.
+    #[inline]
+    pub fn set_eh_frame(mut self, addr: u64) -> Self {
+        self.eh_frame.section = Some(addr);
+        self
+    }
+
+    /// Set the `.text` section base address.
+    #[inline]
+    pub fn set_text(mut self, addr: u64) -> Self {
+        self.eh_frame_hdr.text = Some(addr);
+        self.eh_frame.text = Some(addr);
+        self
+    }
+
+    /// Set the `.got` section base address.
+    #[inline]
+    pub fn set_got(mut self, addr: u64) -> Self {
+        self.eh_frame.data = Some(addr);
+        self
+    }
+}
+
+/// An iterator over CIE and FDE entries in a `.debug_frame` or `.eh_frame`
+/// section.
+///
+/// Some pointers may be encoded relative to various base addresses. Use the
+/// [`BaseAddresses`](./struct.BaseAddresses.html) parameter to provide them. By
+/// default, none are provided. If a relative pointer is encountered for a base
+/// address that is unknown, an `Err` will be returned and iteration will abort.
+///
+/// Can be [used with
+/// `FallibleIterator`](./index.html#using-with-fallibleiterator).
+///
+/// ```
+/// use gimli::{BaseAddresses, EhFrame, EndianSlice, NativeEndian, UnwindSection};
+///
+/// # fn foo() -> gimli::Result<()> {
+/// # let read_eh_frame_somehow = || unimplemented!();
+/// let eh_frame = EhFrame::new(read_eh_frame_somehow(), NativeEndian);
+///
+/// # let address_of_eh_frame_hdr_section_in_memory = unimplemented!();
+/// # let address_of_eh_frame_section_in_memory = unimplemented!();
+/// # let address_of_text_section_in_memory = unimplemented!();
+/// # let address_of_got_section_in_memory = unimplemented!();
+/// # let address_of_the_start_of_current_func = unimplemented!();
+/// // Provide base addresses for relative pointers.
+/// let bases = BaseAddresses::default()
+///     .set_eh_frame_hdr(address_of_eh_frame_hdr_section_in_memory)
+///     .set_eh_frame(address_of_eh_frame_section_in_memory)
+///     .set_text(address_of_text_section_in_memory)
+///     .set_got(address_of_got_section_in_memory);
+///
+/// let mut entries = eh_frame.entries(&bases);
+///
+/// # let do_stuff_with = |_| unimplemented!();
+/// while let Some(entry) = entries.next()? {
+///     do_stuff_with(entry)
+/// }
+/// # unreachable!()
+/// # }
+/// ```
+#[derive(Clone, Debug)]
+pub struct CfiEntriesIter<'bases, Section, R>
+where
+    R: Reader,
+    Section: UnwindSection<R>,
+{
+    section: Section,
+    bases: &'bases BaseAddresses,
+    input: R,
+}
+
+impl<'bases, Section, R> CfiEntriesIter<'bases, Section, R>
+where
+    R: Reader,
+    Section: UnwindSection<R>,
+{
+    /// Advance the iterator to the next entry.
+    pub fn next(&mut self) -> Result<Option<CieOrFde<'bases, Section, R>>> {
+        if self.input.is_empty() {
+            return Ok(None);
+        }
+
+        match parse_cfi_entry(self.bases, &self.section, &mut self.input) {
+            Err(e) => {
+                self.input.empty();
+                Err(e)
+            }
+            Ok(None) => {
+                self.input.empty();
+                Ok(None)
+            }
+            Ok(Some(entry)) => Ok(Some(entry)),
+        }
+    }
+}
+
+#[cfg(feature = "fallible-iterator")]
+impl<'bases, Section, R> fallible_iterator::FallibleIterator for CfiEntriesIter<'bases, Section, R>
+where
+    R: Reader,
+    Section: UnwindSection<R>,
+{
+    type Item = CieOrFde<'bases, Section, R>;
+    type Error = Error;
+
+    fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> {
+        CfiEntriesIter::next(self)
+    }
+}
+
+/// Either a `CommonInformationEntry` (CIE) or a `FrameDescriptionEntry` (FDE).
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum CieOrFde<'bases, Section, R>
+where
+    R: Reader,
+    Section: UnwindSection<R>,
+{
+    /// This CFI entry is a `CommonInformationEntry`.
+    Cie(CommonInformationEntry<R>),
+    /// This CFI entry is a `FrameDescriptionEntry`, however fully parsing it
+    /// requires parsing its CIE first, so it is left in a partially parsed
+    /// state.
+    Fde(PartialFrameDescriptionEntry<'bases, Section, R>),
+}
+
+fn parse_cfi_entry<'bases, Section, R>(
+    bases: &'bases BaseAddresses,
+    section: &Section,
+    input: &mut R,
+) -> Result<Option<CieOrFde<'bases, Section, R>>>
+where
+    R: Reader,
+    Section: UnwindSection<R>,
+{
+    let (offset, length, format) = loop {
+        let offset = input.offset_from(section.section());
+        let (length, format) = input.read_initial_length()?;
+
+        if Section::length_value_is_end_of_entries(length) {
+            return Ok(None);
+        }
+
+        // Hack: skip zero padding inserted by buggy compilers/linkers.
+        // We require that the padding is a multiple of 32-bits, otherwise
+        // there is no reliable way to determine when the padding ends. This
+        // should be okay since CFI entries must be aligned to the address size.
+
+        if length.into_u64() != 0 || format != Format::Dwarf32 {
+            break (offset, length, format);
+        }
+    };
+
+    let mut rest = input.split(length)?;
+    let cie_offset_base = rest.offset_from(section.section());
+    let cie_id_or_offset = match Section::cie_offset_encoding(format) {
+        CieOffsetEncoding::U32 => rest.read_u32().map(u64::from)?,
+        CieOffsetEncoding::U64 => rest.read_u64()?,
+    };
+
+    if Section::is_cie(format, cie_id_or_offset) {
+        let cie = CommonInformationEntry::parse_rest(offset, length, format, bases, section, rest)?;
+        Ok(Some(CieOrFde::Cie(cie)))
+    } else {
+        let cie_offset = R::Offset::from_u64(cie_id_or_offset)?;
+        let cie_offset = match section.resolve_cie_offset(cie_offset_base, cie_offset) {
+            None => return Err(Error::OffsetOutOfBounds),
+            Some(cie_offset) => cie_offset,
+        };
+
+        let fde = PartialFrameDescriptionEntry {
+            offset,
+            length,
+            format,
+            cie_offset: cie_offset.into(),
+            rest,
+            section: section.clone(),
+            bases,
+        };
+
+        Ok(Some(CieOrFde::Fde(fde)))
+    }
+}
+
+/// We support the z-style augmentation [defined by `.eh_frame`][ehframe].
+///
+/// [ehframe]: https://refspecs.linuxfoundation.org/LSB_3.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
+pub struct Augmentation {
+    /// > A 'L' may be present at any position after the first character of the
+    /// > string. This character may only be present if 'z' is the first character
+    /// > of the string. If present, it indicates the presence of one argument in
+    /// > the Augmentation Data of the CIE, and a corresponding argument in the
+    /// > Augmentation Data of the FDE. The argument in the Augmentation Data of
+    /// > the CIE is 1-byte and represents the pointer encoding used for the
+    /// > argument in the Augmentation Data of the FDE, which is the address of a
+    /// > language-specific data area (LSDA). The size of the LSDA pointer is
+    /// > specified by the pointer encoding used.
+    lsda: Option<constants::DwEhPe>,
+
+    /// > A 'P' may be present at any position after the first character of the
+    /// > string. This character may only be present if 'z' is the first character
+    /// > of the string. If present, it indicates the presence of two arguments in
+    /// > the Augmentation Data of the CIE. The first argument is 1-byte and
+    /// > represents the pointer encoding used for the second argument, which is
+    /// > the address of a personality routine handler. The size of the
+    /// > personality routine pointer is specified by the pointer encoding used.
+    personality: Option<(constants::DwEhPe, Pointer)>,
+
+    /// > A 'R' may be present at any position after the first character of the
+    /// > string. This character may only be present if 'z' is the first character
+    /// > of the string. If present, The Augmentation Data shall include a 1 byte
+    /// > argument that represents the pointer encoding for the address pointers
+    /// > used in the FDE.
+    fde_address_encoding: Option<constants::DwEhPe>,
+
+    /// True if this CIE's FDEs are trampolines for signal handlers.
+    is_signal_trampoline: bool,
+}
+
+impl Augmentation {
+    fn parse<Section, R>(
+        augmentation_str: &mut R,
+        bases: &BaseAddresses,
+        address_size: u8,
+        section: &Section,
+        input: &mut R,
+    ) -> Result<Augmentation>
+    where
+        R: Reader,
+        Section: UnwindSection<R>,
+    {
+        debug_assert!(
+            !augmentation_str.is_empty(),
+            "Augmentation::parse should only be called if we have an augmentation"
+        );
+
+        let mut augmentation = Augmentation::default();
+
+        let mut parsed_first = false;
+        let mut data = None;
+
+        while !augmentation_str.is_empty() {
+            let ch = augmentation_str.read_u8()?;
+            match ch {
+                b'z' => {
+                    if parsed_first {
+                        return Err(Error::UnknownAugmentation);
+                    }
+
+                    let augmentation_length = input.read_uleb128().and_then(R::Offset::from_u64)?;
+                    data = Some(input.split(augmentation_length)?);
+                }
+                b'L' => {
+                    let rest = data.as_mut().ok_or(Error::UnknownAugmentation)?;
+                    let encoding = parse_pointer_encoding(rest)?;
+                    augmentation.lsda = Some(encoding);
+                }
+                b'P' => {
+                    let rest = data.as_mut().ok_or(Error::UnknownAugmentation)?;
+                    let encoding = parse_pointer_encoding(rest)?;
+                    let parameters = PointerEncodingParameters {
+                        bases: &bases.eh_frame,
+                        func_base: None,
+                        address_size,
+                        section: section.section(),
+                    };
+
+                    let personality = parse_encoded_pointer(encoding, &parameters, rest)?;
+                    augmentation.personality = Some((encoding, personality));
+                }
+                b'R' => {
+                    let rest = data.as_mut().ok_or(Error::UnknownAugmentation)?;
+                    let encoding = parse_pointer_encoding(rest)?;
+                    augmentation.fde_address_encoding = Some(encoding);
+                }
+                b'S' => augmentation.is_signal_trampoline = true,
+                _ => return Err(Error::UnknownAugmentation),
+            }
+
+            parsed_first = true;
+        }
+
+        Ok(augmentation)
+    }
+}
+
+/// Parsed augmentation data for a `FrameDescriptEntry`.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+struct AugmentationData {
+    lsda: Option<Pointer>,
+}
+
+impl AugmentationData {
+    fn parse<R: Reader>(
+        augmentation: &Augmentation,
+        encoding_parameters: &PointerEncodingParameters<R>,
+        input: &mut R,
+    ) -> Result<AugmentationData> {
+        // In theory, we should be iterating over the original augmentation
+        // string, interpreting each character, and reading the appropriate bits
+        // out of the augmentation data as we go. However, the only character
+        // that defines augmentation data in the FDE is the 'L' character, so we
+        // can just check for its presence directly.
+
+        let aug_data_len = input.read_uleb128().and_then(R::Offset::from_u64)?;
+        let rest = &mut input.split(aug_data_len)?;
+        let mut augmentation_data = AugmentationData::default();
+        if let Some(encoding) = augmentation.lsda {
+            let lsda = parse_encoded_pointer(encoding, encoding_parameters, rest)?;
+            augmentation_data.lsda = Some(lsda);
+        }
+        Ok(augmentation_data)
+    }
+}
+
+/// > A Common Information Entry holds information that is shared among many
+/// > Frame Description Entries. There is at least one CIE in every non-empty
+/// > `.debug_frame` section.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CommonInformationEntry<R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    /// The offset of this entry from the start of its containing section.
+    offset: Offset,
+
+    /// > A constant that gives the number of bytes of the CIE structure, not
+    /// > including the length field itself (see Section 7.2.2). The size of the
+    /// > length field plus the value of length must be an integral multiple of
+    /// > the address size.
+    length: Offset,
+
+    format: Format,
+
+    /// > A version number (see Section 7.23). This number is specific to the
+    /// > call frame information and is independent of the DWARF version number.
+    version: u8,
+
+    /// The parsed augmentation, if any.
+    augmentation: Option<Augmentation>,
+
+    /// > The size of a target address in this CIE and any FDEs that use it, in
+    /// > bytes. If a compilation unit exists for this frame, its address size
+    /// > must match the address size here.
+    address_size: u8,
+
+    /// "The size of a segment selector in this CIE and any FDEs that use it, in
+    /// bytes."
+    segment_size: u8,
+
+    /// "A constant that is factored out of all advance location instructions
+    /// (see Section 6.4.2.1)."
+    code_alignment_factor: u64,
+
+    /// > A constant that is factored out of certain offset instructions (see
+    /// > below). The resulting value is (operand * data_alignment_factor).
+    data_alignment_factor: i64,
+
+    /// > An unsigned LEB128 constant that indicates which column in the rule
+    /// > table represents the return address of the function. Note that this
+    /// > column might not correspond to an actual machine register.
+    return_address_register: Register,
+
+    /// > A sequence of rules that are interpreted to create the initial setting
+    /// > of each column in the table.
+    ///
+    /// > The default rule for all columns before interpretation of the initial
+    /// > instructions is the undefined rule. However, an ABI authoring body or a
+    /// > compilation system authoring body may specify an alternate default
+    /// > value for any or all columns.
+    ///
+    /// This is followed by `DW_CFA_nop` padding until the end of `length` bytes
+    /// in the input.
+    initial_instructions: R,
+}
+
+impl<R: Reader> CommonInformationEntry<R> {
+    fn parse<Section: UnwindSection<R>>(
+        bases: &BaseAddresses,
+        section: &Section,
+        input: &mut R,
+    ) -> Result<CommonInformationEntry<R>> {
+        match parse_cfi_entry(bases, section, input)? {
+            Some(CieOrFde::Cie(cie)) => Ok(cie),
+            Some(CieOrFde::Fde(_)) => Err(Error::NotCieId),
+            None => Err(Error::NoEntryAtGivenOffset),
+        }
+    }
+
+    fn parse_rest<Section: UnwindSection<R>>(
+        offset: R::Offset,
+        length: R::Offset,
+        format: Format,
+        bases: &BaseAddresses,
+        section: &Section,
+        mut rest: R,
+    ) -> Result<CommonInformationEntry<R>> {
+        let version = rest.read_u8()?;
+
+        // Version 1 of `.debug_frame` corresponds to DWARF 2, and then for
+        // DWARF 3 and 4, I think they decided to just match the standard's
+        // version.
+        match version {
+            1 | 3 | 4 => (),
+            _ => return Err(Error::UnknownVersion(u64::from(version))),
+        }
+
+        let mut augmentation_string = rest.read_null_terminated_slice()?;
+
+        let (address_size, segment_size) = if Section::has_address_and_segment_sizes(version) {
+            let address_size = rest.read_u8()?;
+            let segment_size = rest.read_u8()?;
+            (address_size, segment_size)
+        } else {
+            (section.address_size(), section.segment_size())
+        };
+
+        let code_alignment_factor = rest.read_uleb128()?;
+        let data_alignment_factor = rest.read_sleb128()?;
+
+        let return_address_register = if version == 1 {
+            Register(rest.read_u8()?.into())
+        } else {
+            rest.read_uleb128().and_then(Register::from_u64)?
+        };
+
+        let augmentation = if augmentation_string.is_empty() {
+            None
+        } else {
+            Some(Augmentation::parse(
+                &mut augmentation_string,
+                bases,
+                address_size,
+                section,
+                &mut rest,
+            )?)
+        };
+
+        let entry = CommonInformationEntry {
+            offset,
+            length,
+            format,
+            version,
+            augmentation,
+            address_size,
+            segment_size,
+            code_alignment_factor,
+            data_alignment_factor,
+            return_address_register,
+            initial_instructions: rest,
+        };
+
+        Ok(entry)
+    }
+}
+
+/// # Signal Safe Methods
+///
+/// These methods are guaranteed not to allocate, acquire locks, or perform any
+/// other signal-unsafe operations.
+impl<R: Reader> CommonInformationEntry<R> {
+    /// Get the offset of this entry from the start of its containing section.
+    pub fn offset(&self) -> R::Offset {
+        self.offset
+    }
+
+    /// Return the encoding parameters for this CIE.
+    pub fn encoding(&self) -> Encoding {
+        Encoding {
+            format: self.format,
+            version: u16::from(self.version),
+            address_size: self.address_size,
+        }
+    }
+
+    /// The size of addresses (in bytes) in this CIE.
+    pub fn address_size(&self) -> u8 {
+        self.address_size
+    }
+
+    /// Iterate over this CIE's initial instructions.
+    ///
+    /// Can be [used with
+    /// `FallibleIterator`](./index.html#using-with-fallibleiterator).
+    pub fn instructions<'a, Section>(
+        &self,
+        section: &'a Section,
+        bases: &'a BaseAddresses,
+    ) -> CallFrameInstructionIter<'a, R>
+    where
+        Section: UnwindSection<R>,
+    {
+        CallFrameInstructionIter {
+            input: self.initial_instructions.clone(),
+            address_encoding: None,
+            parameters: PointerEncodingParameters {
+                bases: &bases.eh_frame,
+                func_base: None,
+                address_size: self.address_size,
+                section: section.section(),
+            },
+            vendor: section.vendor(),
+        }
+    }
+
+    /// > A constant that gives the number of bytes of the CIE structure, not
+    /// > including the length field itself (see Section 7.2.2). The size of the
+    /// > length field plus the value of length must be an integral multiple of
+    /// > the address size.
+    pub fn entry_len(&self) -> R::Offset {
+        self.length
+    }
+
+    /// > A version number (see Section 7.23). This number is specific to the
+    /// > call frame information and is independent of the DWARF version number.
+    pub fn version(&self) -> u8 {
+        self.version
+    }
+
+    /// Get the augmentation data, if any exists.
+    ///
+    /// The only augmentation understood by `gimli` is that which is defined by
+    /// `.eh_frame`.
+    pub fn augmentation(&self) -> Option<&Augmentation> {
+        self.augmentation.as_ref()
+    }
+
+    /// True if this CIE's FDEs have a LSDA.
+    pub fn has_lsda(&self) -> bool {
+        self.augmentation.map_or(false, |a| a.lsda.is_some())
+    }
+
+    /// Return the encoding of the LSDA address for this CIE's FDEs.
+    pub fn lsda_encoding(&self) -> Option<constants::DwEhPe> {
+        self.augmentation.and_then(|a| a.lsda)
+    }
+
+    /// Return the encoding and address of the personality routine handler
+    /// for this CIE's FDEs.
+    pub fn personality_with_encoding(&self) -> Option<(constants::DwEhPe, Pointer)> {
+        self.augmentation.as_ref().and_then(|a| a.personality)
+    }
+
+    /// Return the address of the personality routine handler
+    /// for this CIE's FDEs.
+    pub fn personality(&self) -> Option<Pointer> {
+        self.augmentation
+            .as_ref()
+            .and_then(|a| a.personality)
+            .map(|(_, p)| p)
+    }
+
+    /// Return the encoding of the addresses for this CIE's FDEs.
+    pub fn fde_address_encoding(&self) -> Option<constants::DwEhPe> {
+        self.augmentation.and_then(|a| a.fde_address_encoding)
+    }
+
+    /// True if this CIE's FDEs are trampolines for signal handlers.
+    pub fn is_signal_trampoline(&self) -> bool {
+        self.augmentation.map_or(false, |a| a.is_signal_trampoline)
+    }
+
+    /// > A constant that is factored out of all advance location instructions
+    /// > (see Section 6.4.2.1).
+    pub fn code_alignment_factor(&self) -> u64 {
+        self.code_alignment_factor
+    }
+
+    /// > A constant that is factored out of certain offset instructions (see
+    /// > below). The resulting value is (operand * data_alignment_factor).
+    pub fn data_alignment_factor(&self) -> i64 {
+        self.data_alignment_factor
+    }
+
+    /// > An unsigned ... constant that indicates which column in the rule
+    /// > table represents the return address of the function. Note that this
+    /// > column might not correspond to an actual machine register.
+    pub fn return_address_register(&self) -> Register {
+        self.return_address_register
+    }
+}
+
+/// A partially parsed `FrameDescriptionEntry`.
+///
+/// Fully parsing this FDE requires first parsing its CIE.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PartialFrameDescriptionEntry<'bases, Section, R>
+where
+    R: Reader,
+    Section: UnwindSection<R>,
+{
+    offset: R::Offset,
+    length: R::Offset,
+    format: Format,
+    cie_offset: Section::Offset,
+    rest: R,
+    section: Section,
+    bases: &'bases BaseAddresses,
+}
+
+impl<'bases, Section, R> PartialFrameDescriptionEntry<'bases, Section, R>
+where
+    R: Reader,
+    Section: UnwindSection<R>,
+{
+    fn parse_partial(
+        section: &Section,
+        bases: &'bases BaseAddresses,
+        input: &mut R,
+    ) -> Result<PartialFrameDescriptionEntry<'bases, Section, R>> {
+        match parse_cfi_entry(bases, section, input)? {
+            Some(CieOrFde::Cie(_)) => Err(Error::NotFdePointer),
+            Some(CieOrFde::Fde(partial)) => Ok(partial),
+            None => Err(Error::NoEntryAtGivenOffset),
+        }
+    }
+
+    /// Fully parse this FDE.
+    ///
+    /// You must provide a function get its associated CIE (either by parsing it
+    /// on demand, or looking it up in some table mapping offsets to CIEs that
+    /// you've already parsed, etc.)
+    pub fn parse<F>(&self, get_cie: F) -> Result<FrameDescriptionEntry<R>>
+    where
+        F: FnMut(&Section, &BaseAddresses, Section::Offset) -> Result<CommonInformationEntry<R>>,
+    {
+        FrameDescriptionEntry::parse_rest(
+            self.offset,
+            self.length,
+            self.format,
+            self.cie_offset,
+            self.rest.clone(),
+            &self.section,
+            self.bases,
+            get_cie,
+        )
+    }
+
+    /// Get the offset of this entry from the start of its containing section.
+    pub fn offset(&self) -> R::Offset {
+        self.offset
+    }
+
+    /// Get the offset of this FDE's CIE.
+    pub fn cie_offset(&self) -> Section::Offset {
+        self.cie_offset
+    }
+
+    /// > A constant that gives the number of bytes of the header and
+    /// > instruction stream for this function, not including the length field
+    /// > itself (see Section 7.2.2). The size of the length field plus the value
+    /// > of length must be an integral multiple of the address size.
+    pub fn entry_len(&self) -> R::Offset {
+        self.length
+    }
+}
+
+/// A `FrameDescriptionEntry` is a set of CFA instructions for an address range.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct FrameDescriptionEntry<R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    /// The start of this entry within its containing section.
+    offset: Offset,
+
+    /// > A constant that gives the number of bytes of the header and
+    /// > instruction stream for this function, not including the length field
+    /// > itself (see Section 7.2.2). The size of the length field plus the value
+    /// > of length must be an integral multiple of the address size.
+    length: Offset,
+
+    format: Format,
+
+    /// "A constant offset into the .debug_frame section that denotes the CIE
+    /// that is associated with this FDE."
+    ///
+    /// This is the CIE at that offset.
+    cie: CommonInformationEntry<R, Offset>,
+
+    /// > The address of the first location associated with this table entry. If
+    /// > the segment_size field of this FDE's CIE is non-zero, the initial
+    /// > location is preceded by a segment selector of the given length.
+    initial_segment: u64,
+    initial_address: u64,
+
+    /// "The number of bytes of program instructions described by this entry."
+    address_range: u64,
+
+    /// The parsed augmentation data, if we have any.
+    augmentation: Option<AugmentationData>,
+
+    /// "A sequence of table defining instructions that are described below."
+    ///
+    /// This is followed by `DW_CFA_nop` padding until `length` bytes of the
+    /// input are consumed.
+    instructions: R,
+}
+
+impl<R: Reader> FrameDescriptionEntry<R> {
+    fn parse_rest<Section, F>(
+        offset: R::Offset,
+        length: R::Offset,
+        format: Format,
+        cie_pointer: Section::Offset,
+        mut rest: R,
+        section: &Section,
+        bases: &BaseAddresses,
+        mut get_cie: F,
+    ) -> Result<FrameDescriptionEntry<R>>
+    where
+        Section: UnwindSection<R>,
+        F: FnMut(&Section, &BaseAddresses, Section::Offset) -> Result<CommonInformationEntry<R>>,
+    {
+        let cie = get_cie(section, bases, cie_pointer)?;
+
+        let initial_segment = if cie.segment_size > 0 {
+            rest.read_address(cie.segment_size)?
+        } else {
+            0
+        };
+
+        let mut parameters = PointerEncodingParameters {
+            bases: &bases.eh_frame,
+            func_base: None,
+            address_size: cie.address_size,
+            section: section.section(),
+        };
+
+        let (initial_address, address_range) = Self::parse_addresses(&mut rest, &cie, &parameters)?;
+        parameters.func_base = Some(initial_address);
+
+        let aug_data = if let Some(ref augmentation) = cie.augmentation {
+            Some(AugmentationData::parse(
+                augmentation,
+                &parameters,
+                &mut rest,
+            )?)
+        } else {
+            None
+        };
+
+        let entry = FrameDescriptionEntry {
+            offset,
+            length,
+            format,
+            cie,
+            initial_segment,
+            initial_address,
+            address_range,
+            augmentation: aug_data,
+            instructions: rest,
+        };
+
+        Ok(entry)
+    }
+
+    fn parse_addresses(
+        input: &mut R,
+        cie: &CommonInformationEntry<R>,
+        parameters: &PointerEncodingParameters<R>,
+    ) -> Result<(u64, u64)> {
+        let encoding = cie.augmentation().and_then(|a| a.fde_address_encoding);
+        if let Some(encoding) = encoding {
+            let initial_address = parse_encoded_pointer(encoding, parameters, input)?;
+
+            // Ignore indirection.
+            let initial_address = initial_address.pointer();
+
+            // Address ranges cannot be relative to anything, so just grab the
+            // data format bits from the encoding.
+            let address_range = parse_encoded_pointer(encoding.format(), parameters, input)?;
+            Ok((initial_address, address_range.pointer()))
+        } else {
+            let initial_address = input.read_address(cie.address_size)?;
+            let address_range = input.read_address(cie.address_size)?;
+            Ok((initial_address, address_range))
+        }
+    }
+
+    /// Return the table of unwind information for this FDE.
+    #[inline]
+    pub fn rows<'a, 'ctx, Section: UnwindSection<R>, A: UnwindContextStorage<R>>(
+        &self,
+        section: &'a Section,
+        bases: &'a BaseAddresses,
+        ctx: &'ctx mut UnwindContext<R, A>,
+    ) -> Result<UnwindTable<'a, 'ctx, R, A>> {
+        UnwindTable::new(section, bases, ctx, self)
+    }
+
+    /// Find the frame unwind information for the given address.
+    ///
+    /// If found, the unwind information is returned along with the reset
+    /// context in the form `Ok((unwind_info, context))`. If not found,
+    /// `Err(gimli::Error::NoUnwindInfoForAddress)` is returned. If parsing or
+    /// CFI evaluation fails, the error is returned.
+    pub fn unwind_info_for_address<'ctx, Section: UnwindSection<R>, A: UnwindContextStorage<R>>(
+        &self,
+        section: &Section,
+        bases: &BaseAddresses,
+        ctx: &'ctx mut UnwindContext<R, A>,
+        address: u64,
+    ) -> Result<&'ctx UnwindTableRow<R, A>> {
+        let mut table = self.rows(section, bases, ctx)?;
+        while let Some(row) = table.next_row()? {
+            if row.contains(address) {
+                return Ok(table.ctx.row());
+            }
+        }
+        Err(Error::NoUnwindInfoForAddress)
+    }
+}
+
+/// # Signal Safe Methods
+///
+/// These methods are guaranteed not to allocate, acquire locks, or perform any
+/// other signal-unsafe operations.
+#[allow(clippy::len_without_is_empty)]
+impl<R: Reader> FrameDescriptionEntry<R> {
+    /// Get the offset of this entry from the start of its containing section.
+    pub fn offset(&self) -> R::Offset {
+        self.offset
+    }
+
+    /// Get a reference to this FDE's CIE.
+    pub fn cie(&self) -> &CommonInformationEntry<R> {
+        &self.cie
+    }
+
+    /// > A constant that gives the number of bytes of the header and
+    /// > instruction stream for this function, not including the length field
+    /// > itself (see Section 7.2.2). The size of the length field plus the value
+    /// > of length must be an integral multiple of the address size.
+    pub fn entry_len(&self) -> R::Offset {
+        self.length
+    }
+
+    /// Iterate over this FDE's instructions.
+    ///
+    /// Will not include the CIE's initial instructions, if you want those do
+    /// `fde.cie().instructions()` first.
+    ///
+    /// Can be [used with
+    /// `FallibleIterator`](./index.html#using-with-fallibleiterator).
+    pub fn instructions<'a, Section>(
+        &self,
+        section: &'a Section,
+        bases: &'a BaseAddresses,
+    ) -> CallFrameInstructionIter<'a, R>
+    where
+        Section: UnwindSection<R>,
+    {
+        CallFrameInstructionIter {
+            input: self.instructions.clone(),
+            address_encoding: self.cie.augmentation().and_then(|a| a.fde_address_encoding),
+            parameters: PointerEncodingParameters {
+                bases: &bases.eh_frame,
+                func_base: None,
+                address_size: self.cie.address_size,
+                section: section.section(),
+            },
+            vendor: section.vendor(),
+        }
+    }
+
+    /// The first address for which this entry has unwind information for.
+    pub fn initial_address(&self) -> u64 {
+        self.initial_address
+    }
+
+    /// The number of bytes of instructions that this entry has unwind
+    /// information for.
+    pub fn len(&self) -> u64 {
+        self.address_range
+    }
+
+    /// Return `true` if the given address is within this FDE, `false`
+    /// otherwise.
+    ///
+    /// This is equivalent to `entry.initial_address() <= address <
+    /// entry.initial_address() + entry.len()`.
+    pub fn contains(&self, address: u64) -> bool {
+        let start = self.initial_address();
+        let end = start + self.len();
+        start <= address && address < end
+    }
+
+    /// The address of this FDE's language-specific data area (LSDA), if it has
+    /// any.
+    pub fn lsda(&self) -> Option<Pointer> {
+        self.augmentation.as_ref().and_then(|a| a.lsda)
+    }
+
+    /// Return true if this FDE's function is a trampoline for a signal handler.
+    #[inline]
+    pub fn is_signal_trampoline(&self) -> bool {
+        self.cie().is_signal_trampoline()
+    }
+
+    /// Return the address of the FDE's function's personality routine
+    /// handler. The personality routine does language-specific clean up when
+    /// unwinding the stack frames with the intent to not run them again.
+    #[inline]
+    pub fn personality(&self) -> Option<Pointer> {
+        self.cie().personality()
+    }
+}
+
+/// Specification of what storage should be used for [`UnwindContext`].
+///
+#[cfg_attr(
+    feature = "read",
+    doc = "
+Normally you would only need to use [`StoreOnHeap`], which places the stack
+on the heap using [`Vec`]. This is the default storage type parameter for [`UnwindContext`].
+"
+)]
+///
+/// If you need to avoid [`UnwindContext`] from allocating memory, e.g. for signal safety,
+/// you can provide you own storage specification:
+/// ```rust,no_run
+/// # use gimli::*;
+/// #
+/// # fn foo<'a>(some_fde: gimli::FrameDescriptionEntry<gimli::EndianSlice<'a, gimli::LittleEndian>>)
+/// #            -> gimli::Result<()> {
+/// # let eh_frame: gimli::EhFrame<_> = unreachable!();
+/// # let bases = unimplemented!();
+/// #
+/// struct StoreOnStack;
+///
+/// impl<R: Reader> UnwindContextStorage<R> for StoreOnStack {
+///     type Rules = [(Register, RegisterRule<R>); 192];
+///     type Stack = [UnwindTableRow<R, Self>; 4];
+/// }
+///
+/// let mut ctx = UnwindContext::<_, StoreOnStack>::new_in();
+///
+/// // Initialize the context by evaluating the CIE's initial instruction program,
+/// // and generate the unwind table.
+/// let mut table = some_fde.rows(&eh_frame, &bases, &mut ctx)?;
+/// while let Some(row) = table.next_row()? {
+///     // Do stuff with each row...
+/// #   let _ = row;
+/// }
+/// # unreachable!()
+/// # }
+/// ```
+pub trait UnwindContextStorage<R: Reader>: Sized {
+    /// The storage used for register rules in a unwind table row.
+    ///
+    /// Note that this is nested within the stack.
+    type Rules: ArrayLike<Item = (Register, RegisterRule<R>)>;
+
+    /// The storage used for unwind table row stack.
+    type Stack: ArrayLike<Item = UnwindTableRow<R, Self>>;
+}
+
+#[cfg(feature = "read")]
+const MAX_RULES: usize = 192;
+#[cfg(feature = "read")]
+const MAX_UNWIND_STACK_DEPTH: usize = 4;
+
+#[cfg(feature = "read")]
+impl<R: Reader> UnwindContextStorage<R> for StoreOnHeap {
+    type Rules = [(Register, RegisterRule<R>); MAX_RULES];
+    type Stack = Box<[UnwindTableRow<R, Self>; MAX_UNWIND_STACK_DEPTH]>;
+}
+
+/// Common context needed when evaluating the call frame unwinding information.
+///
+/// This structure can be large so it is advisable to place it on the heap.
+/// To avoid re-allocating the context multiple times when evaluating multiple
+/// CFI programs, it can be reused.
+///
+/// ```
+/// use gimli::{UnwindContext, UnwindTable};
+///
+/// # fn foo<'a>(some_fde: gimli::FrameDescriptionEntry<gimli::EndianSlice<'a, gimli::LittleEndian>>)
+/// #            -> gimli::Result<()> {
+/// # let eh_frame: gimli::EhFrame<_> = unreachable!();
+/// # let bases = unimplemented!();
+/// // An uninitialized context.
+/// let mut ctx = Box::new(UnwindContext::new());
+///
+/// // Initialize the context by evaluating the CIE's initial instruction program,
+/// // and generate the unwind table.
+/// let mut table = some_fde.rows(&eh_frame, &bases, &mut ctx)?;
+/// while let Some(row) = table.next_row()? {
+///     // Do stuff with each row...
+/// #   let _ = row;
+/// }
+/// # unreachable!()
+/// # }
+/// ```
+#[derive(Clone, PartialEq, Eq)]
+pub struct UnwindContext<R: Reader, A: UnwindContextStorage<R> = StoreOnHeap> {
+    // Stack of rows. The last row is the row currently being built by the
+    // program. There is always at least one row. The vast majority of CFI
+    // programs will only ever have one row on the stack.
+    stack: ArrayVec<A::Stack>,
+
+    // If we are evaluating an FDE's instructions, then `is_initialized` will be
+    // `true`. If `initial_rule` is `Some`, then the initial register rules are either
+    // all default rules or have just 1 non-default rule, stored in `initial_rule`.
+    // If it's `None`, `stack[0]` will contain the initial register rules
+    // described by the CIE's initial instructions. These rules are used by
+    // `DW_CFA_restore`. Otherwise, when we are currently evaluating a CIE's
+    // initial instructions, `is_initialized` will be `false` and initial rules
+    // cannot be read.
+    initial_rule: Option<(Register, RegisterRule<R>)>,
+
+    is_initialized: bool,
+}
+
+impl<R: Reader, S: UnwindContextStorage<R>> Debug for UnwindContext<R, S> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("UnwindContext")
+            .field("stack", &self.stack)
+            .field("initial_rule", &self.initial_rule)
+            .field("is_initialized", &self.is_initialized)
+            .finish()
+    }
+}
+
+impl<R: Reader, A: UnwindContextStorage<R>> Default for UnwindContext<R, A> {
+    fn default() -> Self {
+        Self::new_in()
+    }
+}
+
+#[cfg(feature = "read")]
+impl<R: Reader> UnwindContext<R> {
+    /// Construct a new call frame unwinding context.
+    pub fn new() -> Self {
+        Self::new_in()
+    }
+}
+
+/// # Signal Safe Methods
+///
+/// These methods are guaranteed not to allocate, acquire locks, or perform any
+/// other signal-unsafe operations, if an non-allocating storage is used.
+impl<R: Reader, A: UnwindContextStorage<R>> UnwindContext<R, A> {
+    /// Construct a new call frame unwinding context.
+    pub fn new_in() -> Self {
+        let mut ctx = UnwindContext {
+            stack: Default::default(),
+            initial_rule: None,
+            is_initialized: false,
+        };
+        ctx.reset();
+        ctx
+    }
+
+    /// Run the CIE's initial instructions and initialize this `UnwindContext`.
+    fn initialize<Section: UnwindSection<R>>(
+        &mut self,
+        section: &Section,
+        bases: &BaseAddresses,
+        cie: &CommonInformationEntry<R>,
+    ) -> Result<()> {
+        // Always reset because previous initialization failure may leave dirty state.
+        self.reset();
+
+        let mut table = UnwindTable::new_for_cie(section, bases, self, cie);
+        while table.next_row()?.is_some() {}
+
+        self.save_initial_rules()?;
+        Ok(())
+    }
+
+    fn reset(&mut self) {
+        self.stack.clear();
+        self.stack.try_push(UnwindTableRow::default()).unwrap();
+        debug_assert!(self.stack[0].is_default());
+        self.initial_rule = None;
+        self.is_initialized = false;
+    }
+
+    fn row(&self) -> &UnwindTableRow<R, A> {
+        self.stack.last().unwrap()
+    }
+
+    fn row_mut(&mut self) -> &mut UnwindTableRow<R, A> {
+        self.stack.last_mut().unwrap()
+    }
+
+    fn save_initial_rules(&mut self) -> Result<()> {
+        debug_assert!(!self.is_initialized);
+        self.initial_rule = match *self.stack.last().unwrap().registers.rules {
+            // All rules are default (undefined). In this case just synthesize
+            // an undefined rule.
+            [] => Some((Register(0), RegisterRule::Undefined)),
+            [ref rule] => Some(rule.clone()),
+            _ => {
+                let rules = self.stack.last().unwrap().clone();
+                self.stack
+                    .try_insert(0, rules)
+                    .map_err(|_| Error::StackFull)?;
+                None
+            }
+        };
+        self.is_initialized = true;
+        Ok(())
+    }
+
+    fn start_address(&self) -> u64 {
+        self.row().start_address
+    }
+
+    fn set_start_address(&mut self, start_address: u64) {
+        let row = self.row_mut();
+        row.start_address = start_address;
+    }
+
+    fn set_register_rule(&mut self, register: Register, rule: RegisterRule<R>) -> Result<()> {
+        let row = self.row_mut();
+        row.registers.set(register, rule)
+    }
+
+    /// Returns `None` if we have not completed evaluation of a CIE's initial
+    /// instructions.
+    fn get_initial_rule(&self, register: Register) -> Option<RegisterRule<R>> {
+        if !self.is_initialized {
+            return None;
+        }
+        Some(match self.initial_rule {
+            None => self.stack[0].registers.get(register),
+            Some((r, ref rule)) if r == register => rule.clone(),
+            _ => RegisterRule::Undefined,
+        })
+    }
+
+    fn set_cfa(&mut self, cfa: CfaRule<R>) {
+        self.row_mut().cfa = cfa;
+    }
+
+    fn cfa_mut(&mut self) -> &mut CfaRule<R> {
+        &mut self.row_mut().cfa
+    }
+
+    fn push_row(&mut self) -> Result<()> {
+        let new_row = self.row().clone();
+        self.stack.try_push(new_row).map_err(|_| Error::StackFull)
+    }
+
+    fn pop_row(&mut self) -> Result<()> {
+        let min_size = if self.is_initialized && self.initial_rule.is_none() {
+            2
+        } else {
+            1
+        };
+        if self.stack.len() <= min_size {
+            return Err(Error::PopWithEmptyStack);
+        }
+        self.stack.pop().unwrap();
+        Ok(())
+    }
+}
+
+/// The `UnwindTable` iteratively evaluates a `FrameDescriptionEntry`'s
+/// `CallFrameInstruction` program, yielding the each row one at a time.
+///
+/// > 6.4.1 Structure of Call Frame Information
+/// >
+/// > DWARF supports virtual unwinding by defining an architecture independent
+/// > basis for recording how procedures save and restore registers during their
+/// > lifetimes. This basis must be augmented on some machines with specific
+/// > information that is defined by an architecture specific ABI authoring
+/// > committee, a hardware vendor, or a compiler producer. The body defining a
+/// > specific augmentation is referred to below as the “augmenter.”
+/// >
+/// > Abstractly, this mechanism describes a very large table that has the
+/// > following structure:
+/// >
+/// > <table>
+/// >   <tr>
+/// >     <th>LOC</th><th>CFA</th><th>R0</th><th>R1</th><td>...</td><th>RN</th>
+/// >   </tr>
+/// >   <tr>
+/// >     <th>L0</th> <td></td>   <td></td>  <td></td>  <td></td>   <td></td>
+/// >   </tr>
+/// >   <tr>
+/// >     <th>L1</th> <td></td>   <td></td>  <td></td>  <td></td>   <td></td>
+/// >   </tr>
+/// >   <tr>
+/// >     <td>...</td><td></td>   <td></td>  <td></td>  <td></td>   <td></td>
+/// >   </tr>
+/// >   <tr>
+/// >     <th>LN</th> <td></td>   <td></td>  <td></td>  <td></td>   <td></td>
+/// >   </tr>
+/// > </table>
+/// >
+/// > The first column indicates an address for every location that contains code
+/// > in a program. (In shared objects, this is an object-relative offset.) The
+/// > remaining columns contain virtual unwinding rules that are associated with
+/// > the indicated location.
+/// >
+/// > The CFA column defines the rule which computes the Canonical Frame Address
+/// > value; it may be either a register and a signed offset that are added
+/// > together, or a DWARF expression that is evaluated.
+/// >
+/// > The remaining columns are labeled by register number. This includes some
+/// > registers that have special designation on some architectures such as the PC
+/// > and the stack pointer register. (The actual mapping of registers for a
+/// > particular architecture is defined by the augmenter.) The register columns
+/// > contain rules that describe whether a given register has been saved and the
+/// > rule to find the value for the register in the previous frame.
+/// >
+/// > ...
+/// >
+/// > This table would be extremely large if actually constructed as
+/// > described. Most of the entries at any point in the table are identical to
+/// > the ones above them. The whole table can be represented quite compactly by
+/// > recording just the differences starting at the beginning address of each
+/// > subroutine in the program.
+#[derive(Debug)]
+pub struct UnwindTable<'a, 'ctx, R: Reader, A: UnwindContextStorage<R> = StoreOnHeap> {
+    code_alignment_factor: Wrapping<u64>,
+    data_alignment_factor: Wrapping<i64>,
+    next_start_address: u64,
+    last_end_address: u64,
+    returned_last_row: bool,
+    current_row_valid: bool,
+    instructions: CallFrameInstructionIter<'a, R>,
+    ctx: &'ctx mut UnwindContext<R, A>,
+}
+
+/// # Signal Safe Methods
+///
+/// These methods are guaranteed not to allocate, acquire locks, or perform any
+/// other signal-unsafe operations.
+impl<'a, 'ctx, R: Reader, A: UnwindContextStorage<R>> UnwindTable<'a, 'ctx, R, A> {
+    /// Construct a new `UnwindTable` for the given
+    /// `FrameDescriptionEntry`'s CFI unwinding program.
+    pub fn new<Section: UnwindSection<R>>(
+        section: &'a Section,
+        bases: &'a BaseAddresses,
+        ctx: &'ctx mut UnwindContext<R, A>,
+        fde: &FrameDescriptionEntry<R>,
+    ) -> Result<Self> {
+        ctx.initialize(section, bases, fde.cie())?;
+        Ok(Self::new_for_fde(section, bases, ctx, fde))
+    }
+
+    fn new_for_fde<Section: UnwindSection<R>>(
+        section: &'a Section,
+        bases: &'a BaseAddresses,
+        ctx: &'ctx mut UnwindContext<R, A>,
+        fde: &FrameDescriptionEntry<R>,
+    ) -> Self {
+        assert!(ctx.stack.len() >= 1);
+        UnwindTable {
+            code_alignment_factor: Wrapping(fde.cie().code_alignment_factor()),
+            data_alignment_factor: Wrapping(fde.cie().data_alignment_factor()),
+            next_start_address: fde.initial_address(),
+            last_end_address: fde.initial_address().wrapping_add(fde.len()),
+            returned_last_row: false,
+            current_row_valid: false,
+            instructions: fde.instructions(section, bases),
+            ctx,
+        }
+    }
+
+    fn new_for_cie<Section: UnwindSection<R>>(
+        section: &'a Section,
+        bases: &'a BaseAddresses,
+        ctx: &'ctx mut UnwindContext<R, A>,
+        cie: &CommonInformationEntry<R>,
+    ) -> Self {
+        assert!(ctx.stack.len() >= 1);
+        UnwindTable {
+            code_alignment_factor: Wrapping(cie.code_alignment_factor()),
+            data_alignment_factor: Wrapping(cie.data_alignment_factor()),
+            next_start_address: 0,
+            last_end_address: 0,
+            returned_last_row: false,
+            current_row_valid: false,
+            instructions: cie.instructions(section, bases),
+            ctx,
+        }
+    }
+
+    /// Evaluate call frame instructions until the next row of the table is
+    /// completed, and return it.
+    ///
+    /// Unfortunately, this cannot be used with `FallibleIterator` because of
+    /// the restricted lifetime of the yielded item.
+    pub fn next_row(&mut self) -> Result<Option<&UnwindTableRow<R, A>>> {
+        assert!(self.ctx.stack.len() >= 1);
+        self.ctx.set_start_address(self.next_start_address);
+        self.current_row_valid = false;
+
+        loop {
+            match self.instructions.next() {
+                Err(e) => return Err(e),
+
+                Ok(None) => {
+                    if self.returned_last_row {
+                        return Ok(None);
+                    }
+
+                    let row = self.ctx.row_mut();
+                    row.end_address = self.last_end_address;
+
+                    self.returned_last_row = true;
+                    self.current_row_valid = true;
+                    return Ok(Some(row));
+                }
+
+                Ok(Some(instruction)) => {
+                    if self.evaluate(instruction)? {
+                        self.current_row_valid = true;
+                        return Ok(Some(self.ctx.row()));
+                    }
+                }
+            };
+        }
+    }
+
+    /// Returns the current row with the lifetime of the context.
+    pub fn into_current_row(self) -> Option<&'ctx UnwindTableRow<R, A>> {
+        if self.current_row_valid {
+            Some(self.ctx.row())
+        } else {
+            None
+        }
+    }
+
+    /// Evaluate one call frame instruction. Return `Ok(true)` if the row is
+    /// complete, `Ok(false)` otherwise.
+    fn evaluate(&mut self, instruction: CallFrameInstruction<R>) -> Result<bool> {
+        use crate::CallFrameInstruction::*;
+
+        match instruction {
+            // Instructions that complete the current row and advance the
+            // address for the next row.
+            SetLoc { address } => {
+                if address < self.ctx.start_address() {
+                    return Err(Error::InvalidAddressRange);
+                }
+
+                self.next_start_address = address;
+                self.ctx.row_mut().end_address = self.next_start_address;
+                return Ok(true);
+            }
+            AdvanceLoc { delta } => {
+                let delta = Wrapping(u64::from(delta)) * self.code_alignment_factor;
+                self.next_start_address = (Wrapping(self.ctx.start_address()) + delta).0;
+                self.ctx.row_mut().end_address = self.next_start_address;
+                return Ok(true);
+            }
+
+            // Instructions that modify the CFA.
+            DefCfa { register, offset } => {
+                self.ctx.set_cfa(CfaRule::RegisterAndOffset {
+                    register,
+                    offset: offset as i64,
+                });
+            }
+            DefCfaSf {
+                register,
+                factored_offset,
+            } => {
+                let data_align = self.data_alignment_factor;
+                self.ctx.set_cfa(CfaRule::RegisterAndOffset {
+                    register,
+                    offset: (Wrapping(factored_offset) * data_align).0,
+                });
+            }
+            DefCfaRegister { register } => {
+                if let CfaRule::RegisterAndOffset {
+                    register: ref mut reg,
+                    ..
+                } = *self.ctx.cfa_mut()
+                {
+                    *reg = register;
+                } else {
+                    return Err(Error::CfiInstructionInInvalidContext);
+                }
+            }
+            DefCfaOffset { offset } => {
+                if let CfaRule::RegisterAndOffset {
+                    offset: ref mut off,
+                    ..
+                } = *self.ctx.cfa_mut()
+                {
+                    *off = offset as i64;
+                } else {
+                    return Err(Error::CfiInstructionInInvalidContext);
+                }
+            }
+            DefCfaOffsetSf { factored_offset } => {
+                if let CfaRule::RegisterAndOffset {
+                    offset: ref mut off,
+                    ..
+                } = *self.ctx.cfa_mut()
+                {
+                    let data_align = self.data_alignment_factor;
+                    *off = (Wrapping(factored_offset) * data_align).0;
+                } else {
+                    return Err(Error::CfiInstructionInInvalidContext);
+                }
+            }
+            DefCfaExpression { expression } => {
+                self.ctx.set_cfa(CfaRule::Expression(expression));
+            }
+
+            // Instructions that define register rules.
+            Undefined { register } => {
+                self.ctx
+                    .set_register_rule(register, RegisterRule::Undefined)?;
+            }
+            SameValue { register } => {
+                self.ctx
+                    .set_register_rule(register, RegisterRule::SameValue)?;
+            }
+            Offset {
+                register,
+                factored_offset,
+            } => {
+                let offset = Wrapping(factored_offset as i64) * self.data_alignment_factor;
+                self.ctx
+                    .set_register_rule(register, RegisterRule::Offset(offset.0))?;
+            }
+            OffsetExtendedSf {
+                register,
+                factored_offset,
+            } => {
+                let offset = Wrapping(factored_offset) * self.data_alignment_factor;
+                self.ctx
+                    .set_register_rule(register, RegisterRule::Offset(offset.0))?;
+            }
+            ValOffset {
+                register,
+                factored_offset,
+            } => {
+                let offset = Wrapping(factored_offset as i64) * self.data_alignment_factor;
+                self.ctx
+                    .set_register_rule(register, RegisterRule::ValOffset(offset.0))?;
+            }
+            ValOffsetSf {
+                register,
+                factored_offset,
+            } => {
+                let offset = Wrapping(factored_offset) * self.data_alignment_factor;
+                self.ctx
+                    .set_register_rule(register, RegisterRule::ValOffset(offset.0))?;
+            }
+            Register {
+                dest_register,
+                src_register,
+            } => {
+                self.ctx
+                    .set_register_rule(dest_register, RegisterRule::Register(src_register))?;
+            }
+            Expression {
+                register,
+                expression,
+            } => {
+                let expression = RegisterRule::Expression(expression);
+                self.ctx.set_register_rule(register, expression)?;
+            }
+            ValExpression {
+                register,
+                expression,
+            } => {
+                let expression = RegisterRule::ValExpression(expression);
+                self.ctx.set_register_rule(register, expression)?;
+            }
+            Restore { register } => {
+                let initial_rule = if let Some(rule) = self.ctx.get_initial_rule(register) {
+                    rule
+                } else {
+                    // Can't restore the initial rule when we are
+                    // evaluating the initial rules!
+                    return Err(Error::CfiInstructionInInvalidContext);
+                };
+
+                self.ctx.set_register_rule(register, initial_rule)?;
+            }
+
+            // Row push and pop instructions.
+            RememberState => {
+                self.ctx.push_row()?;
+            }
+            RestoreState => {
+                // Pop state while preserving current location.
+                let start_address = self.ctx.start_address();
+                self.ctx.pop_row()?;
+                self.ctx.set_start_address(start_address);
+            }
+
+            // GNU Extension. Save the size somewhere so the unwinder can use
+            // it when restoring IP
+            ArgsSize { size } => {
+                self.ctx.row_mut().saved_args_size = size;
+            }
+
+            // AArch64 extension.
+            NegateRaState => {
+                let register = crate::AArch64::RA_SIGN_STATE;
+                let value = match self.ctx.row().register(register) {
+                    RegisterRule::Undefined => 0,
+                    RegisterRule::Constant(value) => value,
+                    _ => return Err(Error::CfiInstructionInInvalidContext),
+                };
+                self.ctx
+                    .set_register_rule(register, RegisterRule::Constant(value ^ 1))?;
+            }
+
+            // No operation.
+            Nop => {}
+        };
+
+        Ok(false)
+    }
+}
+
+// We tend to have very few register rules: usually only a couple. Even if we
+// have a rule for every register, on x86-64 with SSE and everything we're
+// talking about ~100 rules. So rather than keeping the rules in a hash map, or
+// a vector indexed by register number (which would lead to filling lots of
+// empty entries), we store them as a vec of (register number, register rule)
+// pairs.
+//
+// Additionally, because every register's default rule is implicitly
+// `RegisterRule::Undefined`, we never store a register's rule in this vec if it
+// is undefined and save a little bit more space and do a little fewer
+// comparisons that way.
+//
+// The maximum number of rules preallocated by libunwind is 97 for AArch64, 128
+// for ARM, and even 188 for MIPS. It is extremely unlikely to encounter this
+// many register rules in practice.
+//
+// See:
+// - https://github.com/libunwind/libunwind/blob/11fd461095ea98f4b3e3a361f5a8a558519363fa/include/tdep-x86_64/dwarf-config.h#L36
+// - https://github.com/libunwind/libunwind/blob/11fd461095ea98f4b3e3a361f5a8a558519363fa/include/tdep-aarch64/dwarf-config.h#L32
+// - https://github.com/libunwind/libunwind/blob/11fd461095ea98f4b3e3a361f5a8a558519363fa/include/tdep-arm/dwarf-config.h#L31
+// - https://github.com/libunwind/libunwind/blob/11fd461095ea98f4b3e3a361f5a8a558519363fa/include/tdep-mips/dwarf-config.h#L31
+struct RegisterRuleMap<R: Reader, S: UnwindContextStorage<R> = StoreOnHeap> {
+    rules: ArrayVec<S::Rules>,
+}
+
+impl<R: Reader, S: UnwindContextStorage<R>> Debug for RegisterRuleMap<R, S> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("RegisterRuleMap")
+            .field("rules", &self.rules)
+            .finish()
+    }
+}
+
+impl<R: Reader, S: UnwindContextStorage<R>> Clone for RegisterRuleMap<R, S> {
+    fn clone(&self) -> Self {
+        Self {
+            rules: self.rules.clone(),
+        }
+    }
+}
+
+impl<R: Reader, S: UnwindContextStorage<R>> Default for RegisterRuleMap<R, S> {
+    fn default() -> Self {
+        RegisterRuleMap {
+            rules: Default::default(),
+        }
+    }
+}
+
+/// # Signal Safe Methods
+///
+/// These methods are guaranteed not to allocate, acquire locks, or perform any
+/// other signal-unsafe operations.
+impl<R: Reader, S: UnwindContextStorage<R>> RegisterRuleMap<R, S> {
+    fn is_default(&self) -> bool {
+        self.rules.is_empty()
+    }
+
+    fn get(&self, register: Register) -> RegisterRule<R> {
+        self.rules
+            .iter()
+            .find(|rule| rule.0 == register)
+            .map(|r| {
+                debug_assert!(r.1.is_defined());
+                r.1.clone()
+            })
+            .unwrap_or(RegisterRule::Undefined)
+    }
+
+    fn set(&mut self, register: Register, rule: RegisterRule<R>) -> Result<()> {
+        if !rule.is_defined() {
+            let idx = self
+                .rules
+                .iter()
+                .enumerate()
+                .find(|&(_, r)| r.0 == register)
+                .map(|(i, _)| i);
+            if let Some(idx) = idx {
+                self.rules.swap_remove(idx);
+            }
+            return Ok(());
+        }
+
+        for &mut (reg, ref mut old_rule) in &mut *self.rules {
+            debug_assert!(old_rule.is_defined());
+            if reg == register {
+                *old_rule = rule;
+                return Ok(());
+            }
+        }
+
+        self.rules
+            .try_push((register, rule))
+            .map_err(|_| Error::TooManyRegisterRules)
+    }
+
+    fn iter(&self) -> RegisterRuleIter<R> {
+        RegisterRuleIter(self.rules.iter())
+    }
+}
+
+impl<'a, R, S: UnwindContextStorage<R>> FromIterator<&'a (Register, RegisterRule<R>)>
+    for RegisterRuleMap<R, S>
+where
+    R: 'a + Reader,
+{
+    fn from_iter<T>(iter: T) -> Self
+    where
+        T: IntoIterator<Item = &'a (Register, RegisterRule<R>)>,
+    {
+        let iter = iter.into_iter();
+        let mut rules = RegisterRuleMap::default();
+        for &(reg, ref rule) in iter.filter(|r| r.1.is_defined()) {
+            rules.set(reg, rule.clone()).expect(
+                "This is only used in tests, impl isn't exposed publicly.
+                         If you trip this, fix your test",
+            );
+        }
+        rules
+    }
+}
+
+impl<R, S: UnwindContextStorage<R>> PartialEq for RegisterRuleMap<R, S>
+where
+    R: Reader + PartialEq,
+{
+    fn eq(&self, rhs: &Self) -> bool {
+        for &(reg, ref rule) in &*self.rules {
+            debug_assert!(rule.is_defined());
+            if *rule != rhs.get(reg) {
+                return false;
+            }
+        }
+
+        for &(reg, ref rhs_rule) in &*rhs.rules {
+            debug_assert!(rhs_rule.is_defined());
+            if *rhs_rule != self.get(reg) {
+                return false;
+            }
+        }
+
+        true
+    }
+}
+
+impl<R, S: UnwindContextStorage<R>> Eq for RegisterRuleMap<R, S> where R: Reader + Eq {}
+
+/// An unordered iterator for register rules.
+#[derive(Debug, Clone)]
+pub struct RegisterRuleIter<'iter, R>(::core::slice::Iter<'iter, (Register, RegisterRule<R>)>)
+where
+    R: Reader;
+
+impl<'iter, R: Reader> Iterator for RegisterRuleIter<'iter, R> {
+    type Item = &'iter (Register, RegisterRule<R>);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.next()
+    }
+}
+
+/// A row in the virtual unwind table that describes how to find the values of
+/// the registers in the *previous* frame for a range of PC addresses.
+#[derive(PartialEq, Eq)]
+pub struct UnwindTableRow<R: Reader, S: UnwindContextStorage<R> = StoreOnHeap> {
+    start_address: u64,
+    end_address: u64,
+    saved_args_size: u64,
+    cfa: CfaRule<R>,
+    registers: RegisterRuleMap<R, S>,
+}
+
+impl<R: Reader, S: UnwindContextStorage<R>> Debug for UnwindTableRow<R, S> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("UnwindTableRow")
+            .field("start_address", &self.start_address)
+            .field("end_address", &self.end_address)
+            .field("saved_args_size", &self.saved_args_size)
+            .field("cfa", &self.cfa)
+            .field("registers", &self.registers)
+            .finish()
+    }
+}
+
+impl<R: Reader, S: UnwindContextStorage<R>> Clone for UnwindTableRow<R, S> {
+    fn clone(&self) -> Self {
+        Self {
+            start_address: self.start_address,
+            end_address: self.end_address,
+            saved_args_size: self.saved_args_size,
+            cfa: self.cfa.clone(),
+            registers: self.registers.clone(),
+        }
+    }
+}
+
+impl<R: Reader, S: UnwindContextStorage<R>> Default for UnwindTableRow<R, S> {
+    fn default() -> Self {
+        UnwindTableRow {
+            start_address: 0,
+            end_address: 0,
+            saved_args_size: 0,
+            cfa: Default::default(),
+            registers: Default::default(),
+        }
+    }
+}
+
+impl<R: Reader, S: UnwindContextStorage<R>> UnwindTableRow<R, S> {
+    fn is_default(&self) -> bool {
+        self.start_address == 0
+            && self.end_address == 0
+            && self.cfa.is_default()
+            && self.registers.is_default()
+    }
+
+    /// Get the starting PC address that this row applies to.
+    pub fn start_address(&self) -> u64 {
+        self.start_address
+    }
+
+    /// Get the end PC address where this row's register rules become
+    /// unapplicable.
+    ///
+    /// In other words, this row describes how to recover the last frame's
+    /// registers for all PCs where `row.start_address() <= PC <
+    /// row.end_address()`. This row does NOT describe how to recover registers
+    /// when `PC == row.end_address()`.
+    pub fn end_address(&self) -> u64 {
+        self.end_address
+    }
+
+    /// Return `true` if the given `address` is within this row's address range,
+    /// `false` otherwise.
+    pub fn contains(&self, address: u64) -> bool {
+        self.start_address <= address && address < self.end_address
+    }
+
+    /// Returns the amount of args currently on the stack.
+    ///
+    /// When unwinding, if the personality function requested a change in IP,
+    /// the SP needs to be adjusted by saved_args_size.
+    pub fn saved_args_size(&self) -> u64 {
+        self.saved_args_size
+    }
+
+    /// Get the canonical frame address (CFA) recovery rule for this row.
+    pub fn cfa(&self) -> &CfaRule<R> {
+        &self.cfa
+    }
+
+    /// Get the register recovery rule for the given register number.
+    ///
+    /// The register number mapping is architecture dependent. For example, in
+    /// the x86-64 ABI the register number mapping is defined in Figure 3.36:
+    ///
+    /// > Figure 3.36: DWARF Register Number Mapping
+    /// >
+    /// > <table>
+    /// >   <tr><th>Register Name</th>                    <th>Number</th>  <th>Abbreviation</th></tr>
+    /// >   <tr><td>General Purpose Register RAX</td>     <td>0</td>       <td>%rax</td></tr>
+    /// >   <tr><td>General Purpose Register RDX</td>     <td>1</td>       <td>%rdx</td></tr>
+    /// >   <tr><td>General Purpose Register RCX</td>     <td>2</td>       <td>%rcx</td></tr>
+    /// >   <tr><td>General Purpose Register RBX</td>     <td>3</td>       <td>%rbx</td></tr>
+    /// >   <tr><td>General Purpose Register RSI</td>     <td>4</td>       <td>%rsi</td></tr>
+    /// >   <tr><td>General Purpose Register RDI</td>     <td>5</td>       <td>%rdi</td></tr>
+    /// >   <tr><td>General Purpose Register RBP</td>     <td>6</td>       <td>%rbp</td></tr>
+    /// >   <tr><td>Stack Pointer Register RSP</td>       <td>7</td>       <td>%rsp</td></tr>
+    /// >   <tr><td>Extended Integer Registers 8-15</td>  <td>8-15</td>    <td>%r8-%r15</td></tr>
+    /// >   <tr><td>Return Address RA</td>                <td>16</td>      <td></td></tr>
+    /// >   <tr><td>Vector Registers 0–7</td>             <td>17-24</td>   <td>%xmm0–%xmm7</td></tr>
+    /// >   <tr><td>Extended Vector Registers 8–15</td>   <td>25-32</td>   <td>%xmm8–%xmm15</td></tr>
+    /// >   <tr><td>Floating Point Registers 0–7</td>     <td>33-40</td>   <td>%st0–%st7</td></tr>
+    /// >   <tr><td>MMX Registers 0–7</td>                <td>41-48</td>   <td>%mm0–%mm7</td></tr>
+    /// >   <tr><td>Flag Register</td>                    <td>49</td>      <td>%rFLAGS</td></tr>
+    /// >   <tr><td>Segment Register ES</td>              <td>50</td>      <td>%es</td></tr>
+    /// >   <tr><td>Segment Register CS</td>              <td>51</td>      <td>%cs</td></tr>
+    /// >   <tr><td>Segment Register SS</td>              <td>52</td>      <td>%ss</td></tr>
+    /// >   <tr><td>Segment Register DS</td>              <td>53</td>      <td>%ds</td></tr>
+    /// >   <tr><td>Segment Register FS</td>              <td>54</td>      <td>%fs</td></tr>
+    /// >   <tr><td>Segment Register GS</td>              <td>55</td>      <td>%gs</td></tr>
+    /// >   <tr><td>Reserved</td>                         <td>56-57</td>   <td></td></tr>
+    /// >   <tr><td>FS Base address</td>                  <td>58</td>      <td>%fs.base</td></tr>
+    /// >   <tr><td>GS Base address</td>                  <td>59</td>      <td>%gs.base</td></tr>
+    /// >   <tr><td>Reserved</td>                         <td>60-61</td>   <td></td></tr>
+    /// >   <tr><td>Task Register</td>                    <td>62</td>      <td>%tr</td></tr>
+    /// >   <tr><td>LDT Register</td>                     <td>63</td>      <td>%ldtr</td></tr>
+    /// >   <tr><td>128-bit Media Control and Status</td> <td>64</td>      <td>%mxcsr</td></tr>
+    /// >   <tr><td>x87 Control Word</td>                 <td>65</td>      <td>%fcw</td></tr>
+    /// >   <tr><td>x87 Status Word</td>                  <td>66</td>      <td>%fsw</td></tr>
+    /// >   <tr><td>Upper Vector Registers 16–31</td>     <td>67-82</td>   <td>%xmm16–%xmm31</td></tr>
+    /// >   <tr><td>Reserved</td>                         <td>83-117</td>  <td></td></tr>
+    /// >   <tr><td>Vector Mask Registers 0–7</td>        <td>118-125</td> <td>%k0–%k7</td></tr>
+    /// >   <tr><td>Reserved</td>                         <td>126-129</td> <td></td></tr>
+    /// > </table>
+    pub fn register(&self, register: Register) -> RegisterRule<R> {
+        self.registers.get(register)
+    }
+
+    /// Iterate over all defined register `(number, rule)` pairs.
+    ///
+    /// The rules are not iterated in any guaranteed order. Any register that
+    /// does not make an appearance in the iterator implicitly has the rule
+    /// `RegisterRule::Undefined`.
+    ///
+    /// ```
+    /// # use gimli::{EndianSlice, LittleEndian, UnwindTableRow};
+    /// # fn foo<'input>(unwind_table_row: UnwindTableRow<EndianSlice<'input, LittleEndian>>) {
+    /// for &(register, ref rule) in unwind_table_row.registers() {
+    ///     // ...
+    ///     # drop(register); drop(rule);
+    /// }
+    /// # }
+    /// ```
+    pub fn registers(&self) -> RegisterRuleIter<R> {
+        self.registers.iter()
+    }
+}
+
+/// The canonical frame address (CFA) recovery rules.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum CfaRule<R: Reader> {
+    /// The CFA is given offset from the given register's value.
+    RegisterAndOffset {
+        /// The register containing the base value.
+        register: Register,
+        /// The offset from the register's base value.
+        offset: i64,
+    },
+    /// The CFA is obtained by evaluating this `Reader` as a DWARF expression
+    /// program.
+    Expression(Expression<R>),
+}
+
+impl<R: Reader> Default for CfaRule<R> {
+    fn default() -> Self {
+        CfaRule::RegisterAndOffset {
+            register: Register(0),
+            offset: 0,
+        }
+    }
+}
+
+impl<R: Reader> CfaRule<R> {
+    fn is_default(&self) -> bool {
+        match *self {
+            CfaRule::RegisterAndOffset { register, offset } => {
+                register == Register(0) && offset == 0
+            }
+            _ => false,
+        }
+    }
+}
+
+/// An entry in the abstract CFI table that describes how to find the value of a
+/// register.
+///
+/// "The register columns contain rules that describe whether a given register
+/// has been saved and the rule to find the value for the register in the
+/// previous frame."
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum RegisterRule<R: Reader> {
+    /// > A register that has this rule has no recoverable value in the previous
+    /// > frame. (By convention, it is not preserved by a callee.)
+    Undefined,
+
+    /// > This register has not been modified from the previous frame. (By
+    /// > convention, it is preserved by the callee, but the callee has not
+    /// > modified it.)
+    SameValue,
+
+    /// "The previous value of this register is saved at the address CFA+N where
+    /// CFA is the current CFA value and N is a signed offset."
+    Offset(i64),
+
+    /// "The previous value of this register is the value CFA+N where CFA is the
+    /// current CFA value and N is a signed offset."
+    ValOffset(i64),
+
+    /// "The previous value of this register is stored in another register
+    /// numbered R."
+    Register(Register),
+
+    /// "The previous value of this register is located at the address produced
+    /// by executing the DWARF expression."
+    Expression(Expression<R>),
+
+    /// "The previous value of this register is the value produced by executing
+    /// the DWARF expression."
+    ValExpression(Expression<R>),
+
+    /// "The rule is defined externally to this specification by the augmenter."
+    Architectural,
+
+    /// This is a pseudo-register with a constant value.
+    Constant(u64),
+}
+
+impl<R: Reader> RegisterRule<R> {
+    fn is_defined(&self) -> bool {
+        !matches!(*self, RegisterRule::Undefined)
+    }
+}
+
+/// A parsed call frame instruction.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum CallFrameInstruction<R: Reader> {
+    // 6.4.2.1 Row Creation Methods
+    /// > 1. DW_CFA_set_loc
+    /// >
+    /// > The DW_CFA_set_loc instruction takes a single operand that represents
+    /// > a target address. The required action is to create a new table row
+    /// > using the specified address as the location. All other values in the
+    /// > new row are initially identical to the current row. The new location
+    /// > value is always greater than the current one. If the segment_size
+    /// > field of this FDE's CIE is non- zero, the initial location is preceded
+    /// > by a segment selector of the given length.
+    SetLoc {
+        /// The target address.
+        address: u64,
+    },
+
+    /// The `AdvanceLoc` instruction is used for all of `DW_CFA_advance_loc` and
+    /// `DW_CFA_advance_loc{1,2,4}`.
+    ///
+    /// > 2. DW_CFA_advance_loc
+    /// >
+    /// > The DW_CFA_advance instruction takes a single operand (encoded with
+    /// > the opcode) that represents a constant delta. The required action is
+    /// > to create a new table row with a location value that is computed by
+    /// > taking the current entry’s location value and adding the value of
+    /// > delta * code_alignment_factor. All other values in the new row are
+    /// > initially identical to the current row.
+    AdvanceLoc {
+        /// The delta to be added to the current address.
+        delta: u32,
+    },
+
+    // 6.4.2.2 CFA Definition Methods
+    /// > 1. DW_CFA_def_cfa
+    /// >
+    /// > The DW_CFA_def_cfa instruction takes two unsigned LEB128 operands
+    /// > representing a register number and a (non-factored) offset. The
+    /// > required action is to define the current CFA rule to use the provided
+    /// > register and offset.
+    DefCfa {
+        /// The target register's number.
+        register: Register,
+        /// The non-factored offset.
+        offset: u64,
+    },
+
+    /// > 2. DW_CFA_def_cfa_sf
+    /// >
+    /// > The DW_CFA_def_cfa_sf instruction takes two operands: an unsigned
+    /// > LEB128 value representing a register number and a signed LEB128
+    /// > factored offset. This instruction is identical to DW_CFA_def_cfa
+    /// > except that the second operand is signed and factored. The resulting
+    /// > offset is factored_offset * data_alignment_factor.
+    DefCfaSf {
+        /// The target register's number.
+        register: Register,
+        /// The factored offset.
+        factored_offset: i64,
+    },
+
+    /// > 3. DW_CFA_def_cfa_register
+    /// >
+    /// > The DW_CFA_def_cfa_register instruction takes a single unsigned LEB128
+    /// > operand representing a register number. The required action is to
+    /// > define the current CFA rule to use the provided register (but to keep
+    /// > the old offset). This operation is valid only if the current CFA rule
+    /// > is defined to use a register and offset.
+    DefCfaRegister {
+        /// The target register's number.
+        register: Register,
+    },
+
+    /// > 4. DW_CFA_def_cfa_offset
+    /// >
+    /// > The DW_CFA_def_cfa_offset instruction takes a single unsigned LEB128
+    /// > operand representing a (non-factored) offset. The required action is
+    /// > to define the current CFA rule to use the provided offset (but to keep
+    /// > the old register). This operation is valid only if the current CFA
+    /// > rule is defined to use a register and offset.
+    DefCfaOffset {
+        /// The non-factored offset.
+        offset: u64,
+    },
+
+    /// > 5. DW_CFA_def_cfa_offset_sf
+    /// >
+    /// > The DW_CFA_def_cfa_offset_sf instruction takes a signed LEB128 operand
+    /// > representing a factored offset. This instruction is identical to
+    /// > DW_CFA_def_cfa_offset except that the operand is signed and
+    /// > factored. The resulting offset is factored_offset *
+    /// > data_alignment_factor. This operation is valid only if the current CFA
+    /// > rule is defined to use a register and offset.
+    DefCfaOffsetSf {
+        /// The factored offset.
+        factored_offset: i64,
+    },
+
+    /// > 6. DW_CFA_def_cfa_expression
+    /// >
+    /// > The DW_CFA_def_cfa_expression instruction takes a single operand
+    /// > encoded as a DW_FORM_exprloc value representing a DWARF
+    /// > expression. The required action is to establish that expression as the
+    /// > means by which the current CFA is computed.
+    DefCfaExpression {
+        /// The DWARF expression.
+        expression: Expression<R>,
+    },
+
+    // 6.4.2.3 Register Rule Instructions
+    /// > 1. DW_CFA_undefined
+    /// >
+    /// > The DW_CFA_undefined instruction takes a single unsigned LEB128
+    /// > operand that represents a register number. The required action is to
+    /// > set the rule for the specified register to “undefined.”
+    Undefined {
+        /// The target register's number.
+        register: Register,
+    },
+
+    /// > 2. DW_CFA_same_value
+    /// >
+    /// > The DW_CFA_same_value instruction takes a single unsigned LEB128
+    /// > operand that represents a register number. The required action is to
+    /// > set the rule for the specified register to “same value.”
+    SameValue {
+        /// The target register's number.
+        register: Register,
+    },
+
+    /// The `Offset` instruction represents both `DW_CFA_offset` and
+    /// `DW_CFA_offset_extended`.
+    ///
+    /// > 3. DW_CFA_offset
+    /// >
+    /// > The DW_CFA_offset instruction takes two operands: a register number
+    /// > (encoded with the opcode) and an unsigned LEB128 constant representing
+    /// > a factored offset. The required action is to change the rule for the
+    /// > register indicated by the register number to be an offset(N) rule
+    /// > where the value of N is factored offset * data_alignment_factor.
+    Offset {
+        /// The target register's number.
+        register: Register,
+        /// The factored offset.
+        factored_offset: u64,
+    },
+
+    /// > 5. DW_CFA_offset_extended_sf
+    /// >
+    /// > The DW_CFA_offset_extended_sf instruction takes two operands: an
+    /// > unsigned LEB128 value representing a register number and a signed
+    /// > LEB128 factored offset. This instruction is identical to
+    /// > DW_CFA_offset_extended except that the second operand is signed and
+    /// > factored. The resulting offset is factored_offset *
+    /// > data_alignment_factor.
+    OffsetExtendedSf {
+        /// The target register's number.
+        register: Register,
+        /// The factored offset.
+        factored_offset: i64,
+    },
+
+    /// > 6. DW_CFA_val_offset
+    /// >
+    /// > The DW_CFA_val_offset instruction takes two unsigned LEB128 operands
+    /// > representing a register number and a factored offset. The required
+    /// > action is to change the rule for the register indicated by the
+    /// > register number to be a val_offset(N) rule where the value of N is
+    /// > factored_offset * data_alignment_factor.
+    ValOffset {
+        /// The target register's number.
+        register: Register,
+        /// The factored offset.
+        factored_offset: u64,
+    },
+
+    /// > 7. DW_CFA_val_offset_sf
+    /// >
+    /// > The DW_CFA_val_offset_sf instruction takes two operands: an unsigned
+    /// > LEB128 value representing a register number and a signed LEB128
+    /// > factored offset. This instruction is identical to DW_CFA_val_offset
+    /// > except that the second operand is signed and factored. The resulting
+    /// > offset is factored_offset * data_alignment_factor.
+    ValOffsetSf {
+        /// The target register's number.
+        register: Register,
+        /// The factored offset.
+        factored_offset: i64,
+    },
+
+    /// > 8. DW_CFA_register
+    /// >
+    /// > The DW_CFA_register instruction takes two unsigned LEB128 operands
+    /// > representing register numbers. The required action is to set the rule
+    /// > for the first register to be register(R) where R is the second
+    /// > register.
+    Register {
+        /// The number of the register whose rule is being changed.
+        dest_register: Register,
+        /// The number of the register where the other register's value can be
+        /// found.
+        src_register: Register,
+    },
+
+    /// > 9. DW_CFA_expression
+    /// >
+    /// > The DW_CFA_expression instruction takes two operands: an unsigned
+    /// > LEB128 value representing a register number, and a DW_FORM_block value
+    /// > representing a DWARF expression. The required action is to change the
+    /// > rule for the register indicated by the register number to be an
+    /// > expression(E) rule where E is the DWARF expression. That is, the DWARF
+    /// > expression computes the address. The value of the CFA is pushed on the
+    /// > DWARF evaluation stack prior to execution of the DWARF expression.
+    Expression {
+        /// The target register's number.
+        register: Register,
+        /// The DWARF expression.
+        expression: Expression<R>,
+    },
+
+    /// > 10. DW_CFA_val_expression
+    /// >
+    /// > The DW_CFA_val_expression instruction takes two operands: an unsigned
+    /// > LEB128 value representing a register number, and a DW_FORM_block value
+    /// > representing a DWARF expression. The required action is to change the
+    /// > rule for the register indicated by the register number to be a
+    /// > val_expression(E) rule where E is the DWARF expression. That is, the
+    /// > DWARF expression computes the value of the given register. The value
+    /// > of the CFA is pushed on the DWARF evaluation stack prior to execution
+    /// > of the DWARF expression.
+    ValExpression {
+        /// The target register's number.
+        register: Register,
+        /// The DWARF expression.
+        expression: Expression<R>,
+    },
+
+    /// The `Restore` instruction represents both `DW_CFA_restore` and
+    /// `DW_CFA_restore_extended`.
+    ///
+    /// > 11. DW_CFA_restore
+    /// >
+    /// > The DW_CFA_restore instruction takes a single operand (encoded with
+    /// > the opcode) that represents a register number. The required action is
+    /// > to change the rule for the indicated register to the rule assigned it
+    /// > by the initial_instructions in the CIE.
+    Restore {
+        /// The register to be reset.
+        register: Register,
+    },
+
+    // 6.4.2.4 Row State Instructions
+    /// > 1. DW_CFA_remember_state
+    /// >
+    /// > The DW_CFA_remember_state instruction takes no operands. The required
+    /// > action is to push the set of rules for every register onto an implicit
+    /// > stack.
+    RememberState,
+
+    /// > 2. DW_CFA_restore_state
+    /// >
+    /// > The DW_CFA_restore_state instruction takes no operands. The required
+    /// > action is to pop the set of rules off the implicit stack and place
+    /// > them in the current row.
+    RestoreState,
+
+    /// > DW_CFA_GNU_args_size
+    /// >
+    /// > GNU Extension
+    /// >
+    /// > The DW_CFA_GNU_args_size instruction takes an unsigned LEB128 operand
+    /// > representing an argument size. This instruction specifies the total of
+    /// > the size of the arguments which have been pushed onto the stack.
+    ArgsSize {
+        /// The size of the arguments which have been pushed onto the stack
+        size: u64,
+    },
+
+    /// > DW_CFA_AARCH64_negate_ra_state
+    /// >
+    /// > AArch64 Extension
+    /// >
+    /// > The DW_CFA_AARCH64_negate_ra_state operation negates bit 0 of the
+    /// > RA_SIGN_STATE pseudo-register. It does not take any operands. The
+    /// > DW_CFA_AARCH64_negate_ra_state must not be mixed with other DWARF Register
+    /// > Rule Instructions on the RA_SIGN_STATE pseudo-register in one Common
+    /// > Information Entry (CIE) and Frame Descriptor Entry (FDE) program sequence.
+    NegateRaState,
+
+    // 6.4.2.5 Padding Instruction
+    /// > 1. DW_CFA_nop
+    /// >
+    /// > The DW_CFA_nop instruction has no operands and no required actions. It
+    /// > is used as padding to make a CIE or FDE an appropriate size.
+    Nop,
+}
+
+const CFI_INSTRUCTION_HIGH_BITS_MASK: u8 = 0b1100_0000;
+const CFI_INSTRUCTION_LOW_BITS_MASK: u8 = !CFI_INSTRUCTION_HIGH_BITS_MASK;
+
+impl<R: Reader> CallFrameInstruction<R> {
+    fn parse(
+        input: &mut R,
+        address_encoding: Option<DwEhPe>,
+        parameters: &PointerEncodingParameters<R>,
+        vendor: Vendor,
+    ) -> Result<CallFrameInstruction<R>> {
+        let instruction = input.read_u8()?;
+        let high_bits = instruction & CFI_INSTRUCTION_HIGH_BITS_MASK;
+
+        if high_bits == constants::DW_CFA_advance_loc.0 {
+            let delta = instruction & CFI_INSTRUCTION_LOW_BITS_MASK;
+            return Ok(CallFrameInstruction::AdvanceLoc {
+                delta: u32::from(delta),
+            });
+        }
+
+        if high_bits == constants::DW_CFA_offset.0 {
+            let register = Register((instruction & CFI_INSTRUCTION_LOW_BITS_MASK).into());
+            let offset = input.read_uleb128()?;
+            return Ok(CallFrameInstruction::Offset {
+                register,
+                factored_offset: offset,
+            });
+        }
+
+        if high_bits == constants::DW_CFA_restore.0 {
+            let register = Register((instruction & CFI_INSTRUCTION_LOW_BITS_MASK).into());
+            return Ok(CallFrameInstruction::Restore { register });
+        }
+
+        debug_assert_eq!(high_bits, 0);
+        let instruction = constants::DwCfa(instruction);
+
+        match instruction {
+            constants::DW_CFA_nop => Ok(CallFrameInstruction::Nop),
+
+            constants::DW_CFA_set_loc => {
+                let address = if let Some(encoding) = address_encoding {
+                    parse_encoded_pointer(encoding, parameters, input)?.direct()?
+                } else {
+                    input.read_address(parameters.address_size)?
+                };
+                Ok(CallFrameInstruction::SetLoc { address })
+            }
+
+            constants::DW_CFA_advance_loc1 => {
+                let delta = input.read_u8()?;
+                Ok(CallFrameInstruction::AdvanceLoc {
+                    delta: u32::from(delta),
+                })
+            }
+
+            constants::DW_CFA_advance_loc2 => {
+                let delta = input.read_u16()?;
+                Ok(CallFrameInstruction::AdvanceLoc {
+                    delta: u32::from(delta),
+                })
+            }
+
+            constants::DW_CFA_advance_loc4 => {
+                let delta = input.read_u32()?;
+                Ok(CallFrameInstruction::AdvanceLoc { delta })
+            }
+
+            constants::DW_CFA_offset_extended => {
+                let register = input.read_uleb128().and_then(Register::from_u64)?;
+                let offset = input.read_uleb128()?;
+                Ok(CallFrameInstruction::Offset {
+                    register,
+                    factored_offset: offset,
+                })
+            }
+
+            constants::DW_CFA_restore_extended => {
+                let register = input.read_uleb128().and_then(Register::from_u64)?;
+                Ok(CallFrameInstruction::Restore { register })
+            }
+
+            constants::DW_CFA_undefined => {
+                let register = input.read_uleb128().and_then(Register::from_u64)?;
+                Ok(CallFrameInstruction::Undefined { register })
+            }
+
+            constants::DW_CFA_same_value => {
+                let register = input.read_uleb128().and_then(Register::from_u64)?;
+                Ok(CallFrameInstruction::SameValue { register })
+            }
+
+            constants::DW_CFA_register => {
+                let dest = input.read_uleb128().and_then(Register::from_u64)?;
+                let src = input.read_uleb128().and_then(Register::from_u64)?;
+                Ok(CallFrameInstruction::Register {
+                    dest_register: dest,
+                    src_register: src,
+                })
+            }
+
+            constants::DW_CFA_remember_state => Ok(CallFrameInstruction::RememberState),
+
+            constants::DW_CFA_restore_state => Ok(CallFrameInstruction::RestoreState),
+
+            constants::DW_CFA_def_cfa => {
+                let register = input.read_uleb128().and_then(Register::from_u64)?;
+                let offset = input.read_uleb128()?;
+                Ok(CallFrameInstruction::DefCfa { register, offset })
+            }
+
+            constants::DW_CFA_def_cfa_register => {
+                let register = input.read_uleb128().and_then(Register::from_u64)?;
+                Ok(CallFrameInstruction::DefCfaRegister { register })
+            }
+
+            constants::DW_CFA_def_cfa_offset => {
+                let offset = input.read_uleb128()?;
+                Ok(CallFrameInstruction::DefCfaOffset { offset })
+            }
+
+            constants::DW_CFA_def_cfa_expression => {
+                let len = input.read_uleb128().and_then(R::Offset::from_u64)?;
+                let expression = input.split(len)?;
+                Ok(CallFrameInstruction::DefCfaExpression {
+                    expression: Expression(expression),
+                })
+            }
+
+            constants::DW_CFA_expression => {
+                let register = input.read_uleb128().and_then(Register::from_u64)?;
+                let len = input.read_uleb128().and_then(R::Offset::from_u64)?;
+                let expression = input.split(len)?;
+                Ok(CallFrameInstruction::Expression {
+                    register,
+                    expression: Expression(expression),
+                })
+            }
+
+            constants::DW_CFA_offset_extended_sf => {
+                let register = input.read_uleb128().and_then(Register::from_u64)?;
+                let offset = input.read_sleb128()?;
+                Ok(CallFrameInstruction::OffsetExtendedSf {
+                    register,
+                    factored_offset: offset,
+                })
+            }
+
+            constants::DW_CFA_def_cfa_sf => {
+                let register = input.read_uleb128().and_then(Register::from_u64)?;
+                let offset = input.read_sleb128()?;
+                Ok(CallFrameInstruction::DefCfaSf {
+                    register,
+                    factored_offset: offset,
+                })
+            }
+
+            constants::DW_CFA_def_cfa_offset_sf => {
+                let offset = input.read_sleb128()?;
+                Ok(CallFrameInstruction::DefCfaOffsetSf {
+                    factored_offset: offset,
+                })
+            }
+
+            constants::DW_CFA_val_offset => {
+                let register = input.read_uleb128().and_then(Register::from_u64)?;
+                let offset = input.read_uleb128()?;
+                Ok(CallFrameInstruction::ValOffset {
+                    register,
+                    factored_offset: offset,
+                })
+            }
+
+            constants::DW_CFA_val_offset_sf => {
+                let register = input.read_uleb128().and_then(Register::from_u64)?;
+                let offset = input.read_sleb128()?;
+                Ok(CallFrameInstruction::ValOffsetSf {
+                    register,
+                    factored_offset: offset,
+                })
+            }
+
+            constants::DW_CFA_val_expression => {
+                let register = input.read_uleb128().and_then(Register::from_u64)?;
+                let len = input.read_uleb128().and_then(R::Offset::from_u64)?;
+                let expression = input.split(len)?;
+                Ok(CallFrameInstruction::ValExpression {
+                    register,
+                    expression: Expression(expression),
+                })
+            }
+
+            constants::DW_CFA_GNU_args_size => {
+                let size = input.read_uleb128()?;
+                Ok(CallFrameInstruction::ArgsSize { size })
+            }
+
+            constants::DW_CFA_AARCH64_negate_ra_state if vendor == Vendor::AArch64 => {
+                Ok(CallFrameInstruction::NegateRaState)
+            }
+
+            otherwise => Err(Error::UnknownCallFrameInstruction(otherwise)),
+        }
+    }
+}
+
+/// A lazy iterator parsing call frame instructions.
+///
+/// Can be [used with
+/// `FallibleIterator`](./index.html#using-with-fallibleiterator).
+#[derive(Clone, Debug)]
+pub struct CallFrameInstructionIter<'a, R: Reader> {
+    input: R,
+    address_encoding: Option<constants::DwEhPe>,
+    parameters: PointerEncodingParameters<'a, R>,
+    vendor: Vendor,
+}
+
+impl<'a, R: Reader> CallFrameInstructionIter<'a, R> {
+    /// Parse the next call frame instruction.
+    pub fn next(&mut self) -> Result<Option<CallFrameInstruction<R>>> {
+        if self.input.is_empty() {
+            return Ok(None);
+        }
+
+        match CallFrameInstruction::parse(
+            &mut self.input,
+            self.address_encoding,
+            &self.parameters,
+            self.vendor,
+        ) {
+            Ok(instruction) => Ok(Some(instruction)),
+            Err(e) => {
+                self.input.empty();
+                Err(e)
+            }
+        }
+    }
+}
+
+#[cfg(feature = "fallible-iterator")]
+impl<'a, R: Reader> fallible_iterator::FallibleIterator for CallFrameInstructionIter<'a, R> {
+    type Item = CallFrameInstruction<R>;
+    type Error = Error;
+
+    fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> {
+        CallFrameInstructionIter::next(self)
+    }
+}
+
+/// Parse a `DW_EH_PE_*` pointer encoding.
+#[doc(hidden)]
+#[inline]
+fn parse_pointer_encoding<R: Reader>(input: &mut R) -> Result<constants::DwEhPe> {
+    let eh_pe = input.read_u8()?;
+    let eh_pe = constants::DwEhPe(eh_pe);
+
+    if eh_pe.is_valid_encoding() {
+        Ok(eh_pe)
+    } else {
+        Err(Error::UnknownPointerEncoding)
+    }
+}
+
+/// A decoded pointer.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum Pointer {
+    /// This value is the decoded pointer value.
+    Direct(u64),
+
+    /// This value is *not* the pointer value, but points to the address of
+    /// where the real pointer value lives. In other words, deref this pointer
+    /// to get the real pointer value.
+    ///
+    /// Chase this pointer at your own risk: do you trust the DWARF data it came
+    /// from?
+    Indirect(u64),
+}
+
+impl Default for Pointer {
+    #[inline]
+    fn default() -> Self {
+        Pointer::Direct(0)
+    }
+}
+
+impl Pointer {
+    #[inline]
+    fn new(encoding: constants::DwEhPe, address: u64) -> Pointer {
+        if encoding.is_indirect() {
+            Pointer::Indirect(address)
+        } else {
+            Pointer::Direct(address)
+        }
+    }
+
+    /// Return the direct pointer value.
+    #[inline]
+    pub fn direct(self) -> Result<u64> {
+        match self {
+            Pointer::Direct(p) => Ok(p),
+            Pointer::Indirect(_) => Err(Error::UnsupportedPointerEncoding),
+        }
+    }
+
+    /// Return the pointer value, discarding indirectness information.
+    #[inline]
+    pub fn pointer(self) -> u64 {
+        match self {
+            Pointer::Direct(p) | Pointer::Indirect(p) => p,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+struct PointerEncodingParameters<'a, R: Reader> {
+    bases: &'a SectionBaseAddresses,
+    func_base: Option<u64>,
+    address_size: u8,
+    section: &'a R,
+}
+
+fn parse_encoded_pointer<R: Reader>(
+    encoding: constants::DwEhPe,
+    parameters: &PointerEncodingParameters<R>,
+    input: &mut R,
+) -> Result<Pointer> {
+    // TODO: check this once only in parse_pointer_encoding
+    if !encoding.is_valid_encoding() {
+        return Err(Error::UnknownPointerEncoding);
+    }
+
+    if encoding == constants::DW_EH_PE_omit {
+        return Err(Error::CannotParseOmitPointerEncoding);
+    }
+
+    let base = match encoding.application() {
+        constants::DW_EH_PE_absptr => 0,
+        constants::DW_EH_PE_pcrel => {
+            if let Some(section_base) = parameters.bases.section {
+                let offset_from_section = input.offset_from(parameters.section);
+                section_base.wrapping_add(offset_from_section.into_u64())
+            } else {
+                return Err(Error::PcRelativePointerButSectionBaseIsUndefined);
+            }
+        }
+        constants::DW_EH_PE_textrel => {
+            if let Some(text) = parameters.bases.text {
+                text
+            } else {
+                return Err(Error::TextRelativePointerButTextBaseIsUndefined);
+            }
+        }
+        constants::DW_EH_PE_datarel => {
+            if let Some(data) = parameters.bases.data {
+                data
+            } else {
+                return Err(Error::DataRelativePointerButDataBaseIsUndefined);
+            }
+        }
+        constants::DW_EH_PE_funcrel => {
+            if let Some(func) = parameters.func_base {
+                func
+            } else {
+                return Err(Error::FuncRelativePointerInBadContext);
+            }
+        }
+        constants::DW_EH_PE_aligned => return Err(Error::UnsupportedPointerEncoding),
+        _ => unreachable!(),
+    };
+
+    let offset = match encoding.format() {
+        // Unsigned variants.
+        constants::DW_EH_PE_absptr => input.read_address(parameters.address_size),
+        constants::DW_EH_PE_uleb128 => input.read_uleb128(),
+        constants::DW_EH_PE_udata2 => input.read_u16().map(u64::from),
+        constants::DW_EH_PE_udata4 => input.read_u32().map(u64::from),
+        constants::DW_EH_PE_udata8 => input.read_u64(),
+
+        // Signed variants. Here we sign extend the values (happens by
+        // default when casting a signed integer to a larger range integer
+        // in Rust), return them as u64, and rely on wrapping addition to do
+        // the right thing when adding these offsets to their bases.
+        constants::DW_EH_PE_sleb128 => input.read_sleb128().map(|a| a as u64),
+        constants::DW_EH_PE_sdata2 => input.read_i16().map(|a| a as u64),
+        constants::DW_EH_PE_sdata4 => input.read_i32().map(|a| a as u64),
+        constants::DW_EH_PE_sdata8 => input.read_i64().map(|a| a as u64),
+
+        // That was all of the valid encoding formats.
+        _ => unreachable!(),
+    }?;
+
+    Ok(Pointer::new(encoding, base.wrapping_add(offset)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use super::{parse_cfi_entry, AugmentationData, RegisterRuleMap, UnwindContext};
+    use crate::common::Format;
+    use crate::constants;
+    use crate::endianity::{BigEndian, Endianity, LittleEndian, NativeEndian};
+    use crate::read::{
+        EndianSlice, Error, Expression, Pointer, ReaderOffsetId, Result, Section as ReadSection,
+    };
+    use crate::test_util::GimliSectionMethods;
+    use alloc::boxed::Box;
+    use alloc::vec::Vec;
+    use core::marker::PhantomData;
+    use core::mem;
+    use core::u64;
+    use test_assembler::{Endian, Label, LabelMaker, LabelOrNum, Section, ToLabelOrNum};
+
+    // Ensure each test tries to read the same section kind that it wrote.
+    #[derive(Clone, Copy)]
+    struct SectionKind<Section>(PhantomData<Section>);
+
+    impl<T> SectionKind<T> {
+        fn endian<'input, E>(self) -> Endian
+        where
+            E: Endianity,
+            T: UnwindSection<EndianSlice<'input, E>>,
+            T::Offset: UnwindOffset<usize>,
+        {
+            if E::default().is_big_endian() {
+                Endian::Big
+            } else {
+                Endian::Little
+            }
+        }
+
+        fn section<'input, E>(self, contents: &'input [u8]) -> T
+        where
+            E: Endianity,
+            T: UnwindSection<EndianSlice<'input, E>> + ReadSection<EndianSlice<'input, E>>,
+            T::Offset: UnwindOffset<usize>,
+        {
+            EndianSlice::new(contents, E::default()).into()
+        }
+    }
+
+    fn debug_frame_le<'a>() -> SectionKind<DebugFrame<EndianSlice<'a, LittleEndian>>> {
+        SectionKind(PhantomData)
+    }
+
+    fn debug_frame_be<'a>() -> SectionKind<DebugFrame<EndianSlice<'a, BigEndian>>> {
+        SectionKind(PhantomData)
+    }
+
+    fn eh_frame_le<'a>() -> SectionKind<EhFrame<EndianSlice<'a, LittleEndian>>> {
+        SectionKind(PhantomData)
+    }
+
+    fn parse_fde<Section, O, F, R>(
+        section: Section,
+        input: &mut R,
+        get_cie: F,
+    ) -> Result<FrameDescriptionEntry<R>>
+    where
+        R: Reader,
+        Section: UnwindSection<R, Offset = O>,
+        O: UnwindOffset<R::Offset>,
+        F: FnMut(&Section, &BaseAddresses, O) -> Result<CommonInformationEntry<R>>,
+    {
+        let bases = Default::default();
+        match parse_cfi_entry(&bases, &section, input) {
+            Ok(Some(CieOrFde::Fde(partial))) => partial.parse(get_cie),
+            Ok(_) => Err(Error::NoEntryAtGivenOffset),
+            Err(e) => Err(e),
+        }
+    }
+
+    // Mixin methods for `Section` to help define binary test data.
+
+    trait CfiSectionMethods: GimliSectionMethods {
+        fn cie<'aug, 'input, E, T>(
+            self,
+            _kind: SectionKind<T>,
+            augmentation: Option<&'aug str>,
+            cie: &mut CommonInformationEntry<EndianSlice<'input, E>>,
+        ) -> Self
+        where
+            E: Endianity,
+            T: UnwindSection<EndianSlice<'input, E>>,
+            T::Offset: UnwindOffset;
+        fn fde<'a, 'input, E, T, L>(
+            self,
+            _kind: SectionKind<T>,
+            cie_offset: L,
+            fde: &mut FrameDescriptionEntry<EndianSlice<'input, E>>,
+        ) -> Self
+        where
+            E: Endianity,
+            T: UnwindSection<EndianSlice<'input, E>>,
+            T::Offset: UnwindOffset,
+            L: ToLabelOrNum<'a, u64>;
+    }
+
+    impl CfiSectionMethods for Section {
+        fn cie<'aug, 'input, E, T>(
+            self,
+            _kind: SectionKind<T>,
+            augmentation: Option<&'aug str>,
+            cie: &mut CommonInformationEntry<EndianSlice<'input, E>>,
+        ) -> Self
+        where
+            E: Endianity,
+            T: UnwindSection<EndianSlice<'input, E>>,
+            T::Offset: UnwindOffset,
+        {
+            cie.offset = self.size() as _;
+            let length = Label::new();
+            let start = Label::new();
+            let end = Label::new();
+
+            let section = match cie.format {
+                Format::Dwarf32 => self.D32(&length).mark(&start).D32(0xffff_ffff),
+                Format::Dwarf64 => {
+                    let section = self.D32(0xffff_ffff);
+                    section.D64(&length).mark(&start).D64(0xffff_ffff_ffff_ffff)
+                }
+            };
+
+            let mut section = section.D8(cie.version);
+
+            if let Some(augmentation) = augmentation {
+                section = section.append_bytes(augmentation.as_bytes());
+            }
+
+            // Null terminator for augmentation string.
+            let section = section.D8(0);
+
+            let section = if T::has_address_and_segment_sizes(cie.version) {
+                section.D8(cie.address_size).D8(cie.segment_size)
+            } else {
+                section
+            };
+
+            let section = section
+                .uleb(cie.code_alignment_factor)
+                .sleb(cie.data_alignment_factor)
+                .uleb(cie.return_address_register.0.into())
+                .append_bytes(cie.initial_instructions.slice())
+                .mark(&end);
+
+            cie.length = (&end - &start) as usize;
+            length.set_const(cie.length as u64);
+
+            section
+        }
+
+        fn fde<'a, 'input, E, T, L>(
+            self,
+            _kind: SectionKind<T>,
+            cie_offset: L,
+            fde: &mut FrameDescriptionEntry<EndianSlice<'input, E>>,
+        ) -> Self
+        where
+            E: Endianity,
+            T: UnwindSection<EndianSlice<'input, E>>,
+            T::Offset: UnwindOffset,
+            L: ToLabelOrNum<'a, u64>,
+        {
+            fde.offset = self.size() as _;
+            let length = Label::new();
+            let start = Label::new();
+            let end = Label::new();
+
+            assert_eq!(fde.format, fde.cie.format);
+
+            let section = match T::cie_offset_encoding(fde.format) {
+                CieOffsetEncoding::U32 => {
+                    let section = self.D32(&length).mark(&start);
+                    match cie_offset.to_labelornum() {
+                        LabelOrNum::Label(ref l) => section.D32(l),
+                        LabelOrNum::Num(o) => section.D32(o as u32),
+                    }
+                }
+                CieOffsetEncoding::U64 => {
+                    let section = self.D32(0xffff_ffff);
+                    section.D64(&length).mark(&start).D64(cie_offset)
+                }
+            };
+
+            let section = match fde.cie.segment_size {
+                0 => section,
+                4 => section.D32(fde.initial_segment as u32),
+                8 => section.D64(fde.initial_segment),
+                x => panic!("Unsupported test segment size: {}", x),
+            };
+
+            let section = match fde.cie.address_size {
+                4 => section
+                    .D32(fde.initial_address() as u32)
+                    .D32(fde.len() as u32),
+                8 => section.D64(fde.initial_address()).D64(fde.len()),
+                x => panic!("Unsupported address size: {}", x),
+            };
+
+            let section = if let Some(ref augmentation) = fde.augmentation {
+                let cie_aug = fde
+                    .cie
+                    .augmentation
+                    .expect("FDE has augmentation, but CIE doesn't");
+
+                if let Some(lsda) = augmentation.lsda {
+                    // We only support writing `DW_EH_PE_absptr` here.
+                    assert_eq!(
+                        cie_aug
+                            .lsda
+                            .expect("FDE has lsda, but CIE doesn't")
+                            .format(),
+                        constants::DW_EH_PE_absptr
+                    );
+
+                    // Augmentation data length
+                    let section = section.uleb(u64::from(fde.cie.address_size));
+                    match fde.cie.address_size {
+                        4 => section.D32({
+                            let x: u64 = lsda.pointer();
+                            x as u32
+                        }),
+                        8 => section.D64({
+                            let x: u64 = lsda.pointer();
+                            x
+                        }),
+                        x => panic!("Unsupported address size: {}", x),
+                    }
+                } else {
+                    // Even if we don't have any augmentation data, if there is
+                    // an augmentation defined, we need to put the length in.
+                    section.uleb(0)
+                }
+            } else {
+                section
+            };
+
+            let section = section.append_bytes(fde.instructions.slice()).mark(&end);
+
+            fde.length = (&end - &start) as usize;
+            length.set_const(fde.length as u64);
+
+            section
+        }
+    }
+
+    trait ResultExt {
+        fn map_eof(self, input: &[u8]) -> Self;
+    }
+
+    impl<T> ResultExt for Result<T> {
+        fn map_eof(self, input: &[u8]) -> Self {
+            match self {
+                Err(Error::UnexpectedEof(id)) => {
+                    let id = ReaderOffsetId(id.0 - input.as_ptr() as u64);
+                    Err(Error::UnexpectedEof(id))
+                }
+                r => r,
+            }
+        }
+    }
+
+    fn assert_parse_cie<'input, E>(
+        kind: SectionKind<DebugFrame<EndianSlice<'input, E>>>,
+        section: Section,
+        address_size: u8,
+        expected: Result<(
+            EndianSlice<'input, E>,
+            CommonInformationEntry<EndianSlice<'input, E>>,
+        )>,
+    ) where
+        E: Endianity,
+    {
+        let section = section.get_contents().unwrap();
+        let mut debug_frame = kind.section(&section);
+        debug_frame.set_address_size(address_size);
+        let input = &mut EndianSlice::new(&section, E::default());
+        let bases = Default::default();
+        let result = CommonInformationEntry::parse(&bases, &debug_frame, input);
+        let result = result.map(|cie| (*input, cie)).map_eof(&section);
+        assert_eq!(result, expected);
+    }
+
+    #[test]
+    fn test_parse_cie_incomplete_length_32() {
+        let kind = debug_frame_le();
+        let section = Section::with_endian(kind.endian()).L16(5);
+        assert_parse_cie(
+            kind,
+            section,
+            8,
+            Err(Error::UnexpectedEof(ReaderOffsetId(0))),
+        );
+    }
+
+    #[test]
+    fn test_parse_cie_incomplete_length_64() {
+        let kind = debug_frame_le();
+        let section = Section::with_endian(kind.endian())
+            .L32(0xffff_ffff)
+            .L32(12345);
+        assert_parse_cie(
+            kind,
+            section,
+            8,
+            Err(Error::UnexpectedEof(ReaderOffsetId(4))),
+        );
+    }
+
+    #[test]
+    fn test_parse_cie_incomplete_id_32() {
+        let kind = debug_frame_be();
+        let section = Section::with_endian(kind.endian())
+            // The length is not large enough to contain the ID.
+            .B32(3)
+            .B32(0xffff_ffff);
+        assert_parse_cie(
+            kind,
+            section,
+            8,
+            Err(Error::UnexpectedEof(ReaderOffsetId(4))),
+        );
+    }
+
+    #[test]
+    fn test_parse_cie_bad_id_32() {
+        let kind = debug_frame_be();
+        let section = Section::with_endian(kind.endian())
+            // Initial length
+            .B32(4)
+            // Not the CIE Id.
+            .B32(0xbad1_bad2);
+        assert_parse_cie(kind, section, 8, Err(Error::NotCieId));
+    }
+
+    #[test]
+    fn test_parse_cie_32_bad_version() {
+        let mut cie = CommonInformationEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            version: 99,
+            augmentation: None,
+            address_size: 4,
+            segment_size: 0,
+            code_alignment_factor: 1,
+            data_alignment_factor: 2,
+            return_address_register: Register(3),
+            initial_instructions: EndianSlice::new(&[], LittleEndian),
+        };
+
+        let kind = debug_frame_le();
+        let section = Section::with_endian(kind.endian()).cie(kind, None, &mut cie);
+        assert_parse_cie(kind, section, 4, Err(Error::UnknownVersion(99)));
+    }
+
+    #[test]
+    fn test_parse_cie_unknown_augmentation() {
+        let length = Label::new();
+        let start = Label::new();
+        let end = Label::new();
+
+        let augmentation = Some("replicant");
+        let expected_rest = [1, 2, 3];
+
+        let kind = debug_frame_le();
+        let section = Section::with_endian(kind.endian())
+            // Initial length
+            .L32(&length)
+            .mark(&start)
+            // CIE Id
+            .L32(0xffff_ffff)
+            // Version
+            .D8(4)
+            // Augmentation
+            .append_bytes(augmentation.unwrap().as_bytes())
+            // Null terminator
+            .D8(0)
+            // Extra augmented data that we can't understand.
+            .L32(1)
+            .L32(2)
+            .L32(3)
+            .L32(4)
+            .L32(5)
+            .L32(6)
+            .mark(&end)
+            .append_bytes(&expected_rest);
+
+        let expected_length = (&end - &start) as u64;
+        length.set_const(expected_length);
+
+        assert_parse_cie(kind, section, 8, Err(Error::UnknownAugmentation));
+    }
+
+    fn test_parse_cie(format: Format, version: u8, address_size: u8) {
+        let expected_rest = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let expected_instrs: Vec<_> = (0..4).map(|_| constants::DW_CFA_nop.0).collect();
+
+        let mut cie = CommonInformationEntry {
+            offset: 0,
+            length: 0,
+            format,
+            version,
+            augmentation: None,
+            address_size,
+            segment_size: 0,
+            code_alignment_factor: 16,
+            data_alignment_factor: 32,
+            return_address_register: Register(1),
+            initial_instructions: EndianSlice::new(&expected_instrs, LittleEndian),
+        };
+
+        let kind = debug_frame_le();
+        let section = Section::with_endian(kind.endian())
+            .cie(kind, None, &mut cie)
+            .append_bytes(&expected_rest);
+
+        assert_parse_cie(
+            kind,
+            section,
+            address_size,
+            Ok((EndianSlice::new(&expected_rest, LittleEndian), cie)),
+        );
+    }
+
+    #[test]
+    fn test_parse_cie_32_ok() {
+        test_parse_cie(Format::Dwarf32, 1, 4);
+        test_parse_cie(Format::Dwarf32, 1, 8);
+        test_parse_cie(Format::Dwarf32, 4, 4);
+        test_parse_cie(Format::Dwarf32, 4, 8);
+    }
+
+    #[test]
+    fn test_parse_cie_64_ok() {
+        test_parse_cie(Format::Dwarf64, 1, 4);
+        test_parse_cie(Format::Dwarf64, 1, 8);
+        test_parse_cie(Format::Dwarf64, 4, 4);
+        test_parse_cie(Format::Dwarf64, 4, 8);
+    }
+
+    #[test]
+    fn test_parse_cie_length_too_big() {
+        let expected_instrs: Vec<_> = (0..13).map(|_| constants::DW_CFA_nop.0).collect();
+
+        let mut cie = CommonInformationEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            version: 4,
+            augmentation: None,
+            address_size: 4,
+            segment_size: 0,
+            code_alignment_factor: 0,
+            data_alignment_factor: 0,
+            return_address_register: Register(3),
+            initial_instructions: EndianSlice::new(&expected_instrs, LittleEndian),
+        };
+
+        let kind = debug_frame_le();
+        let section = Section::with_endian(kind.endian()).cie(kind, None, &mut cie);
+
+        let mut contents = section.get_contents().unwrap();
+
+        // Overwrite the length to be too big.
+        contents[0] = 0;
+        contents[1] = 0;
+        contents[2] = 0;
+        contents[3] = 255;
+
+        let debug_frame = DebugFrame::new(&contents, LittleEndian);
+        let bases = Default::default();
+        assert_eq!(
+            CommonInformationEntry::parse(
+                &bases,
+                &debug_frame,
+                &mut EndianSlice::new(&contents, LittleEndian)
+            )
+            .map_eof(&contents),
+            Err(Error::UnexpectedEof(ReaderOffsetId(4)))
+        );
+    }
+
+    #[test]
+    fn test_parse_fde_incomplete_length_32() {
+        let kind = debug_frame_le();
+        let section = Section::with_endian(kind.endian()).L16(5);
+        let section = section.get_contents().unwrap();
+        let debug_frame = kind.section(&section);
+        let rest = &mut EndianSlice::new(&section, LittleEndian);
+        assert_eq!(
+            parse_fde(debug_frame, rest, UnwindSection::cie_from_offset).map_eof(&section),
+            Err(Error::UnexpectedEof(ReaderOffsetId(0)))
+        );
+    }
+
+    #[test]
+    fn test_parse_fde_incomplete_length_64() {
+        let kind = debug_frame_le();
+        let section = Section::with_endian(kind.endian())
+            .L32(0xffff_ffff)
+            .L32(12345);
+        let section = section.get_contents().unwrap();
+        let debug_frame = kind.section(&section);
+        let rest = &mut EndianSlice::new(&section, LittleEndian);
+        assert_eq!(
+            parse_fde(debug_frame, rest, UnwindSection::cie_from_offset).map_eof(&section),
+            Err(Error::UnexpectedEof(ReaderOffsetId(4)))
+        );
+    }
+
+    #[test]
+    fn test_parse_fde_incomplete_cie_pointer_32() {
+        let kind = debug_frame_be();
+        let section = Section::with_endian(kind.endian())
+            // The length is not large enough to contain the CIE pointer.
+            .B32(3)
+            .B32(1994);
+        let section = section.get_contents().unwrap();
+        let debug_frame = kind.section(&section);
+        let rest = &mut EndianSlice::new(&section, BigEndian);
+        assert_eq!(
+            parse_fde(debug_frame, rest, UnwindSection::cie_from_offset).map_eof(&section),
+            Err(Error::UnexpectedEof(ReaderOffsetId(4)))
+        );
+    }
+
+    #[test]
+    fn test_parse_fde_32_ok() {
+        let expected_rest = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let cie_offset = 0xbad0_bad1;
+        let expected_instrs: Vec<_> = (0..7).map(|_| constants::DW_CFA_nop.0).collect();
+
+        let cie = CommonInformationEntry {
+            offset: 0,
+            length: 100,
+            format: Format::Dwarf32,
+            version: 4,
+            augmentation: None,
+            // DWARF32 with a 64 bit address size! Holy moly!
+            address_size: 8,
+            segment_size: 0,
+            code_alignment_factor: 3,
+            data_alignment_factor: 2,
+            return_address_register: Register(1),
+            initial_instructions: EndianSlice::new(&[], LittleEndian),
+        };
+
+        let mut fde = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            cie: cie.clone(),
+            initial_segment: 0,
+            initial_address: 0xfeed_beef,
+            address_range: 39,
+            augmentation: None,
+            instructions: EndianSlice::new(&expected_instrs, LittleEndian),
+        };
+
+        let kind = debug_frame_le();
+        let section = Section::with_endian(kind.endian())
+            .fde(kind, cie_offset, &mut fde)
+            .append_bytes(&expected_rest);
+
+        let section = section.get_contents().unwrap();
+        let debug_frame = kind.section(&section);
+        let rest = &mut EndianSlice::new(&section, LittleEndian);
+
+        let get_cie = |_: &_, _: &_, offset| {
+            assert_eq!(offset, DebugFrameOffset(cie_offset as usize));
+            Ok(cie.clone())
+        };
+
+        assert_eq!(parse_fde(debug_frame, rest, get_cie), Ok(fde));
+        assert_eq!(*rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_fde_32_with_segment_ok() {
+        let expected_rest = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let cie_offset = 0xbad0_bad1;
+        let expected_instrs: Vec<_> = (0..92).map(|_| constants::DW_CFA_nop.0).collect();
+
+        let cie = CommonInformationEntry {
+            offset: 0,
+            length: 100,
+            format: Format::Dwarf32,
+            version: 4,
+            augmentation: None,
+            address_size: 4,
+            segment_size: 4,
+            code_alignment_factor: 3,
+            data_alignment_factor: 2,
+            return_address_register: Register(1),
+            initial_instructions: EndianSlice::new(&[], LittleEndian),
+        };
+
+        let mut fde = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            cie: cie.clone(),
+            initial_segment: 0xbadb_ad11,
+            initial_address: 0xfeed_beef,
+            address_range: 999,
+            augmentation: None,
+            instructions: EndianSlice::new(&expected_instrs, LittleEndian),
+        };
+
+        let kind = debug_frame_le();
+        let section = Section::with_endian(kind.endian())
+            .fde(kind, cie_offset, &mut fde)
+            .append_bytes(&expected_rest);
+
+        let section = section.get_contents().unwrap();
+        let debug_frame = kind.section(&section);
+        let rest = &mut EndianSlice::new(&section, LittleEndian);
+
+        let get_cie = |_: &_, _: &_, offset| {
+            assert_eq!(offset, DebugFrameOffset(cie_offset as usize));
+            Ok(cie.clone())
+        };
+
+        assert_eq!(parse_fde(debug_frame, rest, get_cie), Ok(fde));
+        assert_eq!(*rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_fde_64_ok() {
+        let expected_rest = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let cie_offset = 0xbad0_bad1;
+        let expected_instrs: Vec<_> = (0..7).map(|_| constants::DW_CFA_nop.0).collect();
+
+        let cie = CommonInformationEntry {
+            offset: 0,
+            length: 100,
+            format: Format::Dwarf64,
+            version: 4,
+            augmentation: None,
+            address_size: 8,
+            segment_size: 0,
+            code_alignment_factor: 3,
+            data_alignment_factor: 2,
+            return_address_register: Register(1),
+            initial_instructions: EndianSlice::new(&[], LittleEndian),
+        };
+
+        let mut fde = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf64,
+            cie: cie.clone(),
+            initial_segment: 0,
+            initial_address: 0xfeed_beef,
+            address_range: 999,
+            augmentation: None,
+            instructions: EndianSlice::new(&expected_instrs, LittleEndian),
+        };
+
+        let kind = debug_frame_le();
+        let section = Section::with_endian(kind.endian())
+            .fde(kind, cie_offset, &mut fde)
+            .append_bytes(&expected_rest);
+
+        let section = section.get_contents().unwrap();
+        let debug_frame = kind.section(&section);
+        let rest = &mut EndianSlice::new(&section, LittleEndian);
+
+        let get_cie = |_: &_, _: &_, offset| {
+            assert_eq!(offset, DebugFrameOffset(cie_offset as usize));
+            Ok(cie.clone())
+        };
+
+        assert_eq!(parse_fde(debug_frame, rest, get_cie), Ok(fde));
+        assert_eq!(*rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_entry_on_cie_32_ok() {
+        let expected_rest = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let expected_instrs: Vec<_> = (0..4).map(|_| constants::DW_CFA_nop.0).collect();
+
+        let mut cie = CommonInformationEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            version: 4,
+            augmentation: None,
+            address_size: 4,
+            segment_size: 0,
+            code_alignment_factor: 16,
+            data_alignment_factor: 32,
+            return_address_register: Register(1),
+            initial_instructions: EndianSlice::new(&expected_instrs, BigEndian),
+        };
+
+        let kind = debug_frame_be();
+        let section = Section::with_endian(kind.endian())
+            .cie(kind, None, &mut cie)
+            .append_bytes(&expected_rest);
+        let section = section.get_contents().unwrap();
+        let debug_frame = kind.section(&section);
+        let rest = &mut EndianSlice::new(&section, BigEndian);
+
+        let bases = Default::default();
+        assert_eq!(
+            parse_cfi_entry(&bases, &debug_frame, rest),
+            Ok(Some(CieOrFde::Cie(cie)))
+        );
+        assert_eq!(*rest, EndianSlice::new(&expected_rest, BigEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_entry_on_fde_32_ok() {
+        let cie_offset = 0x1234_5678;
+        let expected_rest = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let expected_instrs: Vec<_> = (0..4).map(|_| constants::DW_CFA_nop.0).collect();
+
+        let cie = CommonInformationEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            version: 4,
+            augmentation: None,
+            address_size: 4,
+            segment_size: 0,
+            code_alignment_factor: 16,
+            data_alignment_factor: 32,
+            return_address_register: Register(1),
+            initial_instructions: EndianSlice::new(&[], BigEndian),
+        };
+
+        let mut fde = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            cie: cie.clone(),
+            initial_segment: 0,
+            initial_address: 0xfeed_beef,
+            address_range: 39,
+            augmentation: None,
+            instructions: EndianSlice::new(&expected_instrs, BigEndian),
+        };
+
+        let kind = debug_frame_be();
+        let section = Section::with_endian(kind.endian())
+            .fde(kind, cie_offset, &mut fde)
+            .append_bytes(&expected_rest);
+
+        let section = section.get_contents().unwrap();
+        let debug_frame = kind.section(&section);
+        let rest = &mut EndianSlice::new(&section, BigEndian);
+
+        let bases = Default::default();
+        match parse_cfi_entry(&bases, &debug_frame, rest) {
+            Ok(Some(CieOrFde::Fde(partial))) => {
+                assert_eq!(*rest, EndianSlice::new(&expected_rest, BigEndian));
+
+                assert_eq!(partial.length, fde.length);
+                assert_eq!(partial.format, fde.format);
+                assert_eq!(partial.cie_offset, DebugFrameOffset(cie_offset as usize));
+
+                let get_cie = |_: &_, _: &_, offset| {
+                    assert_eq!(offset, DebugFrameOffset(cie_offset as usize));
+                    Ok(cie.clone())
+                };
+
+                assert_eq!(partial.parse(get_cie), Ok(fde));
+            }
+            otherwise => panic!("Unexpected result: {:#?}", otherwise),
+        }
+    }
+
+    #[test]
+    fn test_cfi_entries_iter() {
+        let expected_instrs1: Vec<_> = (0..4).map(|_| constants::DW_CFA_nop.0).collect();
+
+        let expected_instrs2: Vec<_> = (0..8).map(|_| constants::DW_CFA_nop.0).collect();
+
+        let expected_instrs3: Vec<_> = (0..12).map(|_| constants::DW_CFA_nop.0).collect();
+
+        let expected_instrs4: Vec<_> = (0..16).map(|_| constants::DW_CFA_nop.0).collect();
+
+        let mut cie1 = CommonInformationEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            version: 4,
+            augmentation: None,
+            address_size: 4,
+            segment_size: 0,
+            code_alignment_factor: 1,
+            data_alignment_factor: 2,
+            return_address_register: Register(3),
+            initial_instructions: EndianSlice::new(&expected_instrs1, BigEndian),
+        };
+
+        let mut cie2 = CommonInformationEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            version: 4,
+            augmentation: None,
+            address_size: 4,
+            segment_size: 0,
+            code_alignment_factor: 3,
+            data_alignment_factor: 2,
+            return_address_register: Register(1),
+            initial_instructions: EndianSlice::new(&expected_instrs2, BigEndian),
+        };
+
+        let cie1_location = Label::new();
+        let cie2_location = Label::new();
+
+        // Write the CIEs first so that their length gets set before we clone
+        // them into the FDEs and our equality assertions down the line end up
+        // with all the CIEs always having he correct length.
+        let kind = debug_frame_be();
+        let section = Section::with_endian(kind.endian())
+            .mark(&cie1_location)
+            .cie(kind, None, &mut cie1)
+            .mark(&cie2_location)
+            .cie(kind, None, &mut cie2);
+
+        let mut fde1 = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            cie: cie1.clone(),
+            initial_segment: 0,
+            initial_address: 0xfeed_beef,
+            address_range: 39,
+            augmentation: None,
+            instructions: EndianSlice::new(&expected_instrs3, BigEndian),
+        };
+
+        let mut fde2 = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            cie: cie2.clone(),
+            initial_segment: 0,
+            initial_address: 0xfeed_face,
+            address_range: 9000,
+            augmentation: None,
+            instructions: EndianSlice::new(&expected_instrs4, BigEndian),
+        };
+
+        let section =
+            section
+                .fde(kind, &cie1_location, &mut fde1)
+                .fde(kind, &cie2_location, &mut fde2);
+
+        section.start().set_const(0);
+
+        let cie1_offset = cie1_location.value().unwrap() as usize;
+        let cie2_offset = cie2_location.value().unwrap() as usize;
+
+        let contents = section.get_contents().unwrap();
+        let debug_frame = kind.section(&contents);
+
+        let bases = Default::default();
+        let mut entries = debug_frame.entries(&bases);
+
+        assert_eq!(entries.next(), Ok(Some(CieOrFde::Cie(cie1.clone()))));
+        assert_eq!(entries.next(), Ok(Some(CieOrFde::Cie(cie2.clone()))));
+
+        match entries.next() {
+            Ok(Some(CieOrFde::Fde(partial))) => {
+                assert_eq!(partial.length, fde1.length);
+                assert_eq!(partial.format, fde1.format);
+                assert_eq!(partial.cie_offset, DebugFrameOffset(cie1_offset));
+
+                let get_cie = |_: &_, _: &_, offset| {
+                    assert_eq!(offset, DebugFrameOffset(cie1_offset));
+                    Ok(cie1.clone())
+                };
+                assert_eq!(partial.parse(get_cie), Ok(fde1));
+            }
+            otherwise => panic!("Unexpected result: {:#?}", otherwise),
+        }
+
+        match entries.next() {
+            Ok(Some(CieOrFde::Fde(partial))) => {
+                assert_eq!(partial.length, fde2.length);
+                assert_eq!(partial.format, fde2.format);
+                assert_eq!(partial.cie_offset, DebugFrameOffset(cie2_offset));
+
+                let get_cie = |_: &_, _: &_, offset| {
+                    assert_eq!(offset, DebugFrameOffset(cie2_offset));
+                    Ok(cie2.clone())
+                };
+                assert_eq!(partial.parse(get_cie), Ok(fde2));
+            }
+            otherwise => panic!("Unexpected result: {:#?}", otherwise),
+        }
+
+        assert_eq!(entries.next(), Ok(None));
+    }
+
+    #[test]
+    fn test_parse_cie_from_offset() {
+        let filler = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let instrs: Vec<_> = (0..5).map(|_| constants::DW_CFA_nop.0).collect();
+
+        let mut cie = CommonInformationEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf64,
+            version: 4,
+            augmentation: None,
+            address_size: 4,
+            segment_size: 0,
+            code_alignment_factor: 4,
+            data_alignment_factor: 8,
+            return_address_register: Register(12),
+            initial_instructions: EndianSlice::new(&instrs, LittleEndian),
+        };
+
+        let cie_location = Label::new();
+
+        let kind = debug_frame_le();
+        let section = Section::with_endian(kind.endian())
+            .append_bytes(&filler)
+            .mark(&cie_location)
+            .cie(kind, None, &mut cie)
+            .append_bytes(&filler);
+
+        section.start().set_const(0);
+
+        let cie_offset = DebugFrameOffset(cie_location.value().unwrap() as usize);
+
+        let contents = section.get_contents().unwrap();
+        let debug_frame = kind.section(&contents);
+        let bases = Default::default();
+
+        assert_eq!(debug_frame.cie_from_offset(&bases, cie_offset), Ok(cie));
+    }
+
+    fn parse_cfi_instruction<R: Reader + Default>(
+        input: &mut R,
+        address_size: u8,
+    ) -> Result<CallFrameInstruction<R>> {
+        let parameters = &PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: None,
+            address_size,
+            section: &R::default(),
+        };
+        CallFrameInstruction::parse(input, None, parameters, Vendor::Default)
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_advance_loc() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_delta = 42;
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_advance_loc.0 | expected_delta)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::AdvanceLoc {
+                delta: u32::from(expected_delta),
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_offset() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_reg = 3;
+        let expected_offset = 1997;
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_offset.0 | expected_reg)
+            .uleb(expected_offset)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::Offset {
+                register: Register(expected_reg.into()),
+                factored_offset: expected_offset,
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_restore() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_reg = 3;
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_restore.0 | expected_reg)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::Restore {
+                register: Register(expected_reg.into()),
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_nop() {
+        let expected_rest = [1, 2, 3, 4];
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_nop.0)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::Nop)
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_set_loc() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_addr = 0xdead_beef;
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_set_loc.0)
+            .L64(expected_addr)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::SetLoc {
+                address: expected_addr,
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_set_loc_encoding() {
+        let text_base = 0xfeed_face;
+        let addr_offset = 0xbeef;
+        let expected_addr = text_base + addr_offset;
+        let expected_rest = [1, 2, 3, 4];
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_set_loc.0)
+            .L64(addr_offset)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        let parameters = &PointerEncodingParameters {
+            bases: &BaseAddresses::default().set_text(text_base).eh_frame,
+            func_base: None,
+            address_size: 8,
+            section: &EndianSlice::new(&[], LittleEndian),
+        };
+        assert_eq!(
+            CallFrameInstruction::parse(
+                input,
+                Some(constants::DW_EH_PE_textrel),
+                parameters,
+                Vendor::Default
+            ),
+            Ok(CallFrameInstruction::SetLoc {
+                address: expected_addr,
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_advance_loc1() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_delta = 8;
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_advance_loc1.0)
+            .D8(expected_delta)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::AdvanceLoc {
+                delta: u32::from(expected_delta),
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_advance_loc2() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_delta = 500;
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_advance_loc2.0)
+            .L16(expected_delta)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::AdvanceLoc {
+                delta: u32::from(expected_delta),
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_advance_loc4() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_delta = 1 << 20;
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_advance_loc4.0)
+            .L32(expected_delta)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::AdvanceLoc {
+                delta: expected_delta,
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_offset_extended() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_reg = 7;
+        let expected_offset = 33;
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_offset_extended.0)
+            .uleb(expected_reg.into())
+            .uleb(expected_offset)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::Offset {
+                register: Register(expected_reg),
+                factored_offset: expected_offset,
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_restore_extended() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_reg = 7;
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_restore_extended.0)
+            .uleb(expected_reg.into())
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::Restore {
+                register: Register(expected_reg),
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_undefined() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_reg = 7;
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_undefined.0)
+            .uleb(expected_reg.into())
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::Undefined {
+                register: Register(expected_reg),
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_same_value() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_reg = 7;
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_same_value.0)
+            .uleb(expected_reg.into())
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::SameValue {
+                register: Register(expected_reg),
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_register() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_dest_reg = 7;
+        let expected_src_reg = 8;
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_register.0)
+            .uleb(expected_dest_reg.into())
+            .uleb(expected_src_reg.into())
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::Register {
+                dest_register: Register(expected_dest_reg),
+                src_register: Register(expected_src_reg),
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_remember_state() {
+        let expected_rest = [1, 2, 3, 4];
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_remember_state.0)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::RememberState)
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_restore_state() {
+        let expected_rest = [1, 2, 3, 4];
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_restore_state.0)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::RestoreState)
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_def_cfa() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_reg = 2;
+        let expected_offset = 0;
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_def_cfa.0)
+            .uleb(expected_reg.into())
+            .uleb(expected_offset)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::DefCfa {
+                register: Register(expected_reg),
+                offset: expected_offset,
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_def_cfa_register() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_reg = 2;
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_def_cfa_register.0)
+            .uleb(expected_reg.into())
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::DefCfaRegister {
+                register: Register(expected_reg),
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_def_cfa_offset() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_offset = 23;
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_def_cfa_offset.0)
+            .uleb(expected_offset)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::DefCfaOffset {
+                offset: expected_offset,
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_def_cfa_expression() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_expr = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
+
+        let length = Label::new();
+        let start = Label::new();
+        let end = Label::new();
+
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_def_cfa_expression.0)
+            .D8(&length)
+            .mark(&start)
+            .append_bytes(&expected_expr)
+            .mark(&end)
+            .append_bytes(&expected_rest);
+
+        length.set_const((&end - &start) as u64);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::DefCfaExpression {
+                expression: Expression(EndianSlice::new(&expected_expr, LittleEndian)),
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_expression() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_reg = 99;
+        let expected_expr = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
+
+        let length = Label::new();
+        let start = Label::new();
+        let end = Label::new();
+
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_expression.0)
+            .uleb(expected_reg.into())
+            .D8(&length)
+            .mark(&start)
+            .append_bytes(&expected_expr)
+            .mark(&end)
+            .append_bytes(&expected_rest);
+
+        length.set_const((&end - &start) as u64);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::Expression {
+                register: Register(expected_reg),
+                expression: Expression(EndianSlice::new(&expected_expr, LittleEndian)),
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_offset_extended_sf() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_reg = 7;
+        let expected_offset = -33;
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_offset_extended_sf.0)
+            .uleb(expected_reg.into())
+            .sleb(expected_offset)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::OffsetExtendedSf {
+                register: Register(expected_reg),
+                factored_offset: expected_offset,
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_def_cfa_sf() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_reg = 2;
+        let expected_offset = -9999;
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_def_cfa_sf.0)
+            .uleb(expected_reg.into())
+            .sleb(expected_offset)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::DefCfaSf {
+                register: Register(expected_reg),
+                factored_offset: expected_offset,
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_def_cfa_offset_sf() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_offset = -123;
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_def_cfa_offset_sf.0)
+            .sleb(expected_offset)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::DefCfaOffsetSf {
+                factored_offset: expected_offset,
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_val_offset() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_reg = 50;
+        let expected_offset = 23;
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_val_offset.0)
+            .uleb(expected_reg.into())
+            .uleb(expected_offset)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::ValOffset {
+                register: Register(expected_reg),
+                factored_offset: expected_offset,
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_val_offset_sf() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_reg = 50;
+        let expected_offset = -23;
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_val_offset_sf.0)
+            .uleb(expected_reg.into())
+            .sleb(expected_offset)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::ValOffsetSf {
+                register: Register(expected_reg),
+                factored_offset: expected_offset,
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_val_expression() {
+        let expected_rest = [1, 2, 3, 4];
+        let expected_reg = 50;
+        let expected_expr = [2, 2, 1, 1, 5, 5];
+
+        let length = Label::new();
+        let start = Label::new();
+        let end = Label::new();
+
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_val_expression.0)
+            .uleb(expected_reg.into())
+            .D8(&length)
+            .mark(&start)
+            .append_bytes(&expected_expr)
+            .mark(&end)
+            .append_bytes(&expected_rest);
+
+        length.set_const((&end - &start) as u64);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Ok(CallFrameInstruction::ValExpression {
+                register: Register(expected_reg),
+                expression: Expression(EndianSlice::new(&expected_expr, LittleEndian)),
+            })
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_negate_ra_state() {
+        let expected_rest = [1, 2, 3, 4];
+        let section = Section::with_endian(Endian::Little)
+            .D8(constants::DW_CFA_AARCH64_negate_ra_state.0)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        let parameters = &PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: None,
+            address_size: 8,
+            section: &EndianSlice::default(),
+        };
+        assert_eq!(
+            CallFrameInstruction::parse(input, None, parameters, Vendor::AArch64),
+            Ok(CallFrameInstruction::NegateRaState)
+        );
+        assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_cfi_instruction_unknown_instruction() {
+        let expected_rest = [1, 2, 3, 4];
+        let unknown_instr = constants::DwCfa(0b0011_1111);
+        let section = Section::with_endian(Endian::Little)
+            .D8(unknown_instr.0)
+            .append_bytes(&expected_rest);
+        let contents = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&contents, LittleEndian);
+        assert_eq!(
+            parse_cfi_instruction(input, 8),
+            Err(Error::UnknownCallFrameInstruction(unknown_instr))
+        );
+    }
+
+    #[test]
+    fn test_call_frame_instruction_iter_ok() {
+        let expected_reg = 50;
+        let expected_expr = [2, 2, 1, 1, 5, 5];
+        let expected_delta = 230;
+
+        let length = Label::new();
+        let start = Label::new();
+        let end = Label::new();
+
+        let section = Section::with_endian(Endian::Big)
+            .D8(constants::DW_CFA_val_expression.0)
+            .uleb(expected_reg.into())
+            .D8(&length)
+            .mark(&start)
+            .append_bytes(&expected_expr)
+            .mark(&end)
+            .D8(constants::DW_CFA_advance_loc1.0)
+            .D8(expected_delta);
+
+        length.set_const((&end - &start) as u64);
+        let contents = section.get_contents().unwrap();
+        let input = EndianSlice::new(&contents, BigEndian);
+        let parameters = PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: None,
+            address_size: 8,
+            section: &EndianSlice::default(),
+        };
+        let mut iter = CallFrameInstructionIter {
+            input,
+            address_encoding: None,
+            parameters,
+            vendor: Vendor::Default,
+        };
+
+        assert_eq!(
+            iter.next(),
+            Ok(Some(CallFrameInstruction::ValExpression {
+                register: Register(expected_reg),
+                expression: Expression(EndianSlice::new(&expected_expr, BigEndian)),
+            }))
+        );
+
+        assert_eq!(
+            iter.next(),
+            Ok(Some(CallFrameInstruction::AdvanceLoc {
+                delta: u32::from(expected_delta),
+            }))
+        );
+
+        assert_eq!(iter.next(), Ok(None));
+    }
+
+    #[test]
+    fn test_call_frame_instruction_iter_err() {
+        // DW_CFA_advance_loc1 without an operand.
+        let section = Section::with_endian(Endian::Big).D8(constants::DW_CFA_advance_loc1.0);
+
+        let contents = section.get_contents().unwrap();
+        let input = EndianSlice::new(&contents, BigEndian);
+        let parameters = PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: None,
+            address_size: 8,
+            section: &EndianSlice::default(),
+        };
+        let mut iter = CallFrameInstructionIter {
+            input,
+            address_encoding: None,
+            parameters,
+            vendor: Vendor::Default,
+        };
+
+        assert_eq!(
+            iter.next().map_eof(&contents),
+            Err(Error::UnexpectedEof(ReaderOffsetId(1)))
+        );
+        assert_eq!(iter.next(), Ok(None));
+    }
+
+    fn assert_eval<'a, I>(
+        mut initial_ctx: UnwindContext<EndianSlice<'a, LittleEndian>>,
+        expected_ctx: UnwindContext<EndianSlice<'a, LittleEndian>>,
+        cie: CommonInformationEntry<EndianSlice<'a, LittleEndian>>,
+        fde: Option<FrameDescriptionEntry<EndianSlice<'a, LittleEndian>>>,
+        instructions: I,
+    ) where
+        I: AsRef<
+            [(
+                Result<bool>,
+                CallFrameInstruction<EndianSlice<'a, LittleEndian>>,
+            )],
+        >,
+    {
+        {
+            let section = &DebugFrame::from(EndianSlice::default());
+            let bases = &BaseAddresses::default();
+            let mut table = match fde {
+                Some(fde) => UnwindTable::new_for_fde(section, bases, &mut initial_ctx, &fde),
+                None => UnwindTable::new_for_cie(section, bases, &mut initial_ctx, &cie),
+            };
+            for &(ref expected_result, ref instruction) in instructions.as_ref() {
+                assert_eq!(*expected_result, table.evaluate(instruction.clone()));
+            }
+        }
+
+        assert_eq!(expected_ctx, initial_ctx);
+    }
+
+    fn make_test_cie<'a>() -> CommonInformationEntry<EndianSlice<'a, LittleEndian>> {
+        CommonInformationEntry {
+            offset: 0,
+            format: Format::Dwarf64,
+            length: 0,
+            return_address_register: Register(0),
+            version: 4,
+            address_size: mem::size_of::<usize>() as u8,
+            initial_instructions: EndianSlice::new(&[], LittleEndian),
+            augmentation: None,
+            segment_size: 0,
+            data_alignment_factor: 2,
+            code_alignment_factor: 3,
+        }
+    }
+
+    #[test]
+    fn test_eval_set_loc() {
+        let cie = make_test_cie();
+        let ctx = UnwindContext::new();
+        let mut expected = ctx.clone();
+        expected.row_mut().end_address = 42;
+        let instructions = [(Ok(true), CallFrameInstruction::SetLoc { address: 42 })];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_set_loc_backwards() {
+        let cie = make_test_cie();
+        let mut ctx = UnwindContext::new();
+        ctx.row_mut().start_address = 999;
+        let expected = ctx.clone();
+        let instructions = [(
+            Err(Error::InvalidAddressRange),
+            CallFrameInstruction::SetLoc { address: 42 },
+        )];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_advance_loc() {
+        let cie = make_test_cie();
+        let mut ctx = UnwindContext::new();
+        ctx.row_mut().start_address = 3;
+        let mut expected = ctx.clone();
+        expected.row_mut().end_address = 3 + 2 * cie.code_alignment_factor;
+        let instructions = [(Ok(true), CallFrameInstruction::AdvanceLoc { delta: 2 })];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_advance_loc_overflow() {
+        let cie = make_test_cie();
+        let mut ctx = UnwindContext::new();
+        ctx.row_mut().start_address = u64::MAX;
+        let mut expected = ctx.clone();
+        expected.row_mut().end_address = 42 * cie.code_alignment_factor - 1;
+        let instructions = [(Ok(true), CallFrameInstruction::AdvanceLoc { delta: 42 })];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_def_cfa() {
+        let cie = make_test_cie();
+        let ctx = UnwindContext::new();
+        let mut expected = ctx.clone();
+        expected.set_cfa(CfaRule::RegisterAndOffset {
+            register: Register(42),
+            offset: 36,
+        });
+        let instructions = [(
+            Ok(false),
+            CallFrameInstruction::DefCfa {
+                register: Register(42),
+                offset: 36,
+            },
+        )];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_def_cfa_sf() {
+        let cie = make_test_cie();
+        let ctx = UnwindContext::new();
+        let mut expected = ctx.clone();
+        expected.set_cfa(CfaRule::RegisterAndOffset {
+            register: Register(42),
+            offset: 36 * cie.data_alignment_factor as i64,
+        });
+        let instructions = [(
+            Ok(false),
+            CallFrameInstruction::DefCfaSf {
+                register: Register(42),
+                factored_offset: 36,
+            },
+        )];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_def_cfa_register() {
+        let cie = make_test_cie();
+        let mut ctx = UnwindContext::new();
+        ctx.set_cfa(CfaRule::RegisterAndOffset {
+            register: Register(3),
+            offset: 8,
+        });
+        let mut expected = ctx.clone();
+        expected.set_cfa(CfaRule::RegisterAndOffset {
+            register: Register(42),
+            offset: 8,
+        });
+        let instructions = [(
+            Ok(false),
+            CallFrameInstruction::DefCfaRegister {
+                register: Register(42),
+            },
+        )];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_def_cfa_register_invalid_context() {
+        let cie = make_test_cie();
+        let mut ctx = UnwindContext::new();
+        ctx.set_cfa(CfaRule::Expression(Expression(EndianSlice::new(
+            &[],
+            LittleEndian,
+        ))));
+        let expected = ctx.clone();
+        let instructions = [(
+            Err(Error::CfiInstructionInInvalidContext),
+            CallFrameInstruction::DefCfaRegister {
+                register: Register(42),
+            },
+        )];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_def_cfa_offset() {
+        let cie = make_test_cie();
+        let mut ctx = UnwindContext::new();
+        ctx.set_cfa(CfaRule::RegisterAndOffset {
+            register: Register(3),
+            offset: 8,
+        });
+        let mut expected = ctx.clone();
+        expected.set_cfa(CfaRule::RegisterAndOffset {
+            register: Register(3),
+            offset: 42,
+        });
+        let instructions = [(Ok(false), CallFrameInstruction::DefCfaOffset { offset: 42 })];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_def_cfa_offset_invalid_context() {
+        let cie = make_test_cie();
+        let mut ctx = UnwindContext::new();
+        ctx.set_cfa(CfaRule::Expression(Expression(EndianSlice::new(
+            &[],
+            LittleEndian,
+        ))));
+        let expected = ctx.clone();
+        let instructions = [(
+            Err(Error::CfiInstructionInInvalidContext),
+            CallFrameInstruction::DefCfaOffset { offset: 1993 },
+        )];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_def_cfa_expression() {
+        let expr = [1, 2, 3, 4];
+        let cie = make_test_cie();
+        let ctx = UnwindContext::new();
+        let mut expected = ctx.clone();
+        expected.set_cfa(CfaRule::Expression(Expression(EndianSlice::new(
+            &expr,
+            LittleEndian,
+        ))));
+        let instructions = [(
+            Ok(false),
+            CallFrameInstruction::DefCfaExpression {
+                expression: Expression(EndianSlice::new(&expr, LittleEndian)),
+            },
+        )];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_undefined() {
+        let cie = make_test_cie();
+        let ctx = UnwindContext::new();
+        let mut expected = ctx.clone();
+        expected
+            .set_register_rule(Register(5), RegisterRule::Undefined)
+            .unwrap();
+        let instructions = [(
+            Ok(false),
+            CallFrameInstruction::Undefined {
+                register: Register(5),
+            },
+        )];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_same_value() {
+        let cie = make_test_cie();
+        let ctx = UnwindContext::new();
+        let mut expected = ctx.clone();
+        expected
+            .set_register_rule(Register(0), RegisterRule::SameValue)
+            .unwrap();
+        let instructions = [(
+            Ok(false),
+            CallFrameInstruction::SameValue {
+                register: Register(0),
+            },
+        )];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_offset() {
+        let cie = make_test_cie();
+        let ctx = UnwindContext::new();
+        let mut expected = ctx.clone();
+        expected
+            .set_register_rule(
+                Register(2),
+                RegisterRule::Offset(3 * cie.data_alignment_factor),
+            )
+            .unwrap();
+        let instructions = [(
+            Ok(false),
+            CallFrameInstruction::Offset {
+                register: Register(2),
+                factored_offset: 3,
+            },
+        )];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_offset_extended_sf() {
+        let cie = make_test_cie();
+        let ctx = UnwindContext::new();
+        let mut expected = ctx.clone();
+        expected
+            .set_register_rule(
+                Register(4),
+                RegisterRule::Offset(-3 * cie.data_alignment_factor),
+            )
+            .unwrap();
+        let instructions = [(
+            Ok(false),
+            CallFrameInstruction::OffsetExtendedSf {
+                register: Register(4),
+                factored_offset: -3,
+            },
+        )];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_val_offset() {
+        let cie = make_test_cie();
+        let ctx = UnwindContext::new();
+        let mut expected = ctx.clone();
+        expected
+            .set_register_rule(
+                Register(5),
+                RegisterRule::ValOffset(7 * cie.data_alignment_factor),
+            )
+            .unwrap();
+        let instructions = [(
+            Ok(false),
+            CallFrameInstruction::ValOffset {
+                register: Register(5),
+                factored_offset: 7,
+            },
+        )];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_val_offset_sf() {
+        let cie = make_test_cie();
+        let ctx = UnwindContext::new();
+        let mut expected = ctx.clone();
+        expected
+            .set_register_rule(
+                Register(5),
+                RegisterRule::ValOffset(-7 * cie.data_alignment_factor),
+            )
+            .unwrap();
+        let instructions = [(
+            Ok(false),
+            CallFrameInstruction::ValOffsetSf {
+                register: Register(5),
+                factored_offset: -7,
+            },
+        )];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_expression() {
+        let expr = [1, 2, 3, 4];
+        let cie = make_test_cie();
+        let ctx = UnwindContext::new();
+        let mut expected = ctx.clone();
+        expected
+            .set_register_rule(
+                Register(9),
+                RegisterRule::Expression(Expression(EndianSlice::new(&expr, LittleEndian))),
+            )
+            .unwrap();
+        let instructions = [(
+            Ok(false),
+            CallFrameInstruction::Expression {
+                register: Register(9),
+                expression: Expression(EndianSlice::new(&expr, LittleEndian)),
+            },
+        )];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_val_expression() {
+        let expr = [1, 2, 3, 4];
+        let cie = make_test_cie();
+        let ctx = UnwindContext::new();
+        let mut expected = ctx.clone();
+        expected
+            .set_register_rule(
+                Register(9),
+                RegisterRule::ValExpression(Expression(EndianSlice::new(&expr, LittleEndian))),
+            )
+            .unwrap();
+        let instructions = [(
+            Ok(false),
+            CallFrameInstruction::ValExpression {
+                register: Register(9),
+                expression: Expression(EndianSlice::new(&expr, LittleEndian)),
+            },
+        )];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_restore() {
+        let cie = make_test_cie();
+        let fde = FrameDescriptionEntry {
+            offset: 0,
+            format: Format::Dwarf64,
+            length: 0,
+            address_range: 0,
+            augmentation: None,
+            initial_address: 0,
+            initial_segment: 0,
+            cie: cie.clone(),
+            instructions: EndianSlice::new(&[], LittleEndian),
+        };
+
+        let mut ctx = UnwindContext::new();
+        ctx.set_register_rule(Register(0), RegisterRule::Offset(1))
+            .unwrap();
+        ctx.save_initial_rules().unwrap();
+        let expected = ctx.clone();
+        ctx.set_register_rule(Register(0), RegisterRule::Offset(2))
+            .unwrap();
+
+        let instructions = [(
+            Ok(false),
+            CallFrameInstruction::Restore {
+                register: Register(0),
+            },
+        )];
+        assert_eval(ctx, expected, cie, Some(fde), instructions);
+    }
+
+    #[test]
+    fn test_eval_restore_havent_saved_initial_context() {
+        let cie = make_test_cie();
+        let ctx = UnwindContext::new();
+        let expected = ctx.clone();
+        let instructions = [(
+            Err(Error::CfiInstructionInInvalidContext),
+            CallFrameInstruction::Restore {
+                register: Register(0),
+            },
+        )];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_remember_state() {
+        let cie = make_test_cie();
+        let ctx = UnwindContext::new();
+        let mut expected = ctx.clone();
+        expected.push_row().unwrap();
+        let instructions = [(Ok(false), CallFrameInstruction::RememberState)];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_restore_state() {
+        let cie = make_test_cie();
+
+        let mut ctx = UnwindContext::new();
+        ctx.set_start_address(1);
+        ctx.set_register_rule(Register(0), RegisterRule::SameValue)
+            .unwrap();
+        let mut expected = ctx.clone();
+        ctx.push_row().unwrap();
+        ctx.set_start_address(2);
+        ctx.set_register_rule(Register(0), RegisterRule::Offset(16))
+            .unwrap();
+
+        // Restore state should preserve current location.
+        expected.set_start_address(2);
+
+        let instructions = [
+            // First one pops just fine.
+            (Ok(false), CallFrameInstruction::RestoreState),
+            // Second pop would try to pop out of bounds.
+            (
+                Err(Error::PopWithEmptyStack),
+                CallFrameInstruction::RestoreState,
+            ),
+        ];
+
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_negate_ra_state() {
+        let cie = make_test_cie();
+        let ctx = UnwindContext::new();
+        let mut expected = ctx.clone();
+        expected
+            .set_register_rule(crate::AArch64::RA_SIGN_STATE, RegisterRule::Constant(1))
+            .unwrap();
+        let instructions = [(Ok(false), CallFrameInstruction::NegateRaState)];
+        assert_eval(ctx, expected, cie, None, instructions);
+
+        let cie = make_test_cie();
+        let ctx = UnwindContext::new();
+        let mut expected = ctx.clone();
+        expected
+            .set_register_rule(crate::AArch64::RA_SIGN_STATE, RegisterRule::Constant(0))
+            .unwrap();
+        let instructions = [
+            (Ok(false), CallFrameInstruction::NegateRaState),
+            (Ok(false), CallFrameInstruction::NegateRaState),
+        ];
+        assert_eval(ctx, expected, cie, None, instructions);
+
+        // NegateRaState can't be used with other instructions.
+        let cie = make_test_cie();
+        let ctx = UnwindContext::new();
+        let mut expected = ctx.clone();
+        expected
+            .set_register_rule(
+                crate::AArch64::RA_SIGN_STATE,
+                RegisterRule::Offset(cie.data_alignment_factor as i64),
+            )
+            .unwrap();
+        let instructions = [
+            (
+                Ok(false),
+                CallFrameInstruction::Offset {
+                    register: crate::AArch64::RA_SIGN_STATE,
+                    factored_offset: 1,
+                },
+            ),
+            (
+                Err(Error::CfiInstructionInInvalidContext),
+                CallFrameInstruction::NegateRaState,
+            ),
+        ];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_eval_nop() {
+        let cie = make_test_cie();
+        let ctx = UnwindContext::new();
+        let expected = ctx.clone();
+        let instructions = [(Ok(false), CallFrameInstruction::Nop)];
+        assert_eval(ctx, expected, cie, None, instructions);
+    }
+
+    #[test]
+    fn test_unwind_table_cie_no_rule() {
+        let initial_instructions = Section::with_endian(Endian::Little)
+            // The CFA is -12 from register 4.
+            .D8(constants::DW_CFA_def_cfa_sf.0)
+            .uleb(4)
+            .sleb(-12)
+            .append_repeated(constants::DW_CFA_nop.0, 4);
+        let initial_instructions = initial_instructions.get_contents().unwrap();
+
+        let cie = CommonInformationEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            version: 4,
+            augmentation: None,
+            address_size: 8,
+            segment_size: 0,
+            code_alignment_factor: 1,
+            data_alignment_factor: 1,
+            return_address_register: Register(3),
+            initial_instructions: EndianSlice::new(&initial_instructions, LittleEndian),
+        };
+
+        let instructions = Section::with_endian(Endian::Little)
+            // A bunch of nop padding.
+            .append_repeated(constants::DW_CFA_nop.0, 8);
+        let instructions = instructions.get_contents().unwrap();
+
+        let fde = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            cie: cie.clone(),
+            initial_segment: 0,
+            initial_address: 0,
+            address_range: 100,
+            augmentation: None,
+            instructions: EndianSlice::new(&instructions, LittleEndian),
+        };
+
+        let section = &DebugFrame::from(EndianSlice::default());
+        let bases = &BaseAddresses::default();
+        let mut ctx = Box::new(UnwindContext::new());
+
+        let mut table = fde
+            .rows(section, bases, &mut ctx)
+            .expect("Should run initial program OK");
+        assert!(table.ctx.is_initialized);
+        let expected_initial_rule = (Register(0), RegisterRule::Undefined);
+        assert_eq!(table.ctx.initial_rule, Some(expected_initial_rule));
+
+        {
+            let row = table.next_row().expect("Should evaluate first row OK");
+            let expected = UnwindTableRow {
+                start_address: 0,
+                end_address: 100,
+                saved_args_size: 0,
+                cfa: CfaRule::RegisterAndOffset {
+                    register: Register(4),
+                    offset: -12,
+                },
+                registers: [].iter().collect(),
+            };
+            assert_eq!(Some(&expected), row);
+        }
+
+        // All done!
+        assert_eq!(Ok(None), table.next_row());
+        assert_eq!(Ok(None), table.next_row());
+    }
+
+    #[test]
+    fn test_unwind_table_cie_single_rule() {
+        let initial_instructions = Section::with_endian(Endian::Little)
+            // The CFA is -12 from register 4.
+            .D8(constants::DW_CFA_def_cfa_sf.0)
+            .uleb(4)
+            .sleb(-12)
+            // Register 3 is 4 from the CFA.
+            .D8(constants::DW_CFA_offset.0 | 3)
+            .uleb(4)
+            .append_repeated(constants::DW_CFA_nop.0, 4);
+        let initial_instructions = initial_instructions.get_contents().unwrap();
+
+        let cie = CommonInformationEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            version: 4,
+            augmentation: None,
+            address_size: 8,
+            segment_size: 0,
+            code_alignment_factor: 1,
+            data_alignment_factor: 1,
+            return_address_register: Register(3),
+            initial_instructions: EndianSlice::new(&initial_instructions, LittleEndian),
+        };
+
+        let instructions = Section::with_endian(Endian::Little)
+            // A bunch of nop padding.
+            .append_repeated(constants::DW_CFA_nop.0, 8);
+        let instructions = instructions.get_contents().unwrap();
+
+        let fde = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            cie: cie.clone(),
+            initial_segment: 0,
+            initial_address: 0,
+            address_range: 100,
+            augmentation: None,
+            instructions: EndianSlice::new(&instructions, LittleEndian),
+        };
+
+        let section = &DebugFrame::from(EndianSlice::default());
+        let bases = &BaseAddresses::default();
+        let mut ctx = Box::new(UnwindContext::new());
+
+        let mut table = fde
+            .rows(section, bases, &mut ctx)
+            .expect("Should run initial program OK");
+        assert!(table.ctx.is_initialized);
+        let expected_initial_rule = (Register(3), RegisterRule::Offset(4));
+        assert_eq!(table.ctx.initial_rule, Some(expected_initial_rule));
+
+        {
+            let row = table.next_row().expect("Should evaluate first row OK");
+            let expected = UnwindTableRow {
+                start_address: 0,
+                end_address: 100,
+                saved_args_size: 0,
+                cfa: CfaRule::RegisterAndOffset {
+                    register: Register(4),
+                    offset: -12,
+                },
+                registers: [(Register(3), RegisterRule::Offset(4))].iter().collect(),
+            };
+            assert_eq!(Some(&expected), row);
+        }
+
+        // All done!
+        assert_eq!(Ok(None), table.next_row());
+        assert_eq!(Ok(None), table.next_row());
+    }
+
+    #[test]
+    fn test_unwind_table_cie_invalid_rule() {
+        let initial_instructions1 = Section::with_endian(Endian::Little)
+            // Test that stack length is reset.
+            .D8(constants::DW_CFA_remember_state.0)
+            // Test that stack value is reset (different register from that used later).
+            .D8(constants::DW_CFA_offset.0 | 4)
+            .uleb(8)
+            // Invalid due to missing operands.
+            .D8(constants::DW_CFA_offset.0);
+        let initial_instructions1 = initial_instructions1.get_contents().unwrap();
+
+        let cie1 = CommonInformationEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            version: 4,
+            augmentation: None,
+            address_size: 8,
+            segment_size: 0,
+            code_alignment_factor: 1,
+            data_alignment_factor: 1,
+            return_address_register: Register(3),
+            initial_instructions: EndianSlice::new(&initial_instructions1, LittleEndian),
+        };
+
+        let initial_instructions2 = Section::with_endian(Endian::Little)
+            // Register 3 is 4 from the CFA.
+            .D8(constants::DW_CFA_offset.0 | 3)
+            .uleb(4)
+            .append_repeated(constants::DW_CFA_nop.0, 4);
+        let initial_instructions2 = initial_instructions2.get_contents().unwrap();
+
+        let cie2 = CommonInformationEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            version: 4,
+            augmentation: None,
+            address_size: 8,
+            segment_size: 0,
+            code_alignment_factor: 1,
+            data_alignment_factor: 1,
+            return_address_register: Register(3),
+            initial_instructions: EndianSlice::new(&initial_instructions2, LittleEndian),
+        };
+
+        let fde1 = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            cie: cie1.clone(),
+            initial_segment: 0,
+            initial_address: 0,
+            address_range: 100,
+            augmentation: None,
+            instructions: EndianSlice::new(&[], LittleEndian),
+        };
+
+        let fde2 = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            cie: cie2.clone(),
+            initial_segment: 0,
+            initial_address: 0,
+            address_range: 100,
+            augmentation: None,
+            instructions: EndianSlice::new(&[], LittleEndian),
+        };
+
+        let section = &DebugFrame::from(EndianSlice::default());
+        let bases = &BaseAddresses::default();
+        let mut ctx = Box::new(UnwindContext::new());
+
+        let table = fde1
+            .rows(section, bases, &mut ctx)
+            .map_eof(&initial_instructions1);
+        assert_eq!(table.err(), Some(Error::UnexpectedEof(ReaderOffsetId(4))));
+        assert!(!ctx.is_initialized);
+        assert_eq!(ctx.stack.len(), 2);
+        assert_eq!(ctx.initial_rule, None);
+
+        let _table = fde2
+            .rows(section, bases, &mut ctx)
+            .expect("Should run initial program OK");
+        assert!(ctx.is_initialized);
+        assert_eq!(ctx.stack.len(), 1);
+        let expected_initial_rule = (Register(3), RegisterRule::Offset(4));
+        assert_eq!(ctx.initial_rule, Some(expected_initial_rule));
+    }
+
+    #[test]
+    fn test_unwind_table_next_row() {
+        let initial_instructions = Section::with_endian(Endian::Little)
+            // The CFA is -12 from register 4.
+            .D8(constants::DW_CFA_def_cfa_sf.0)
+            .uleb(4)
+            .sleb(-12)
+            // Register 0 is 8 from the CFA.
+            .D8(constants::DW_CFA_offset.0 | 0)
+            .uleb(8)
+            // Register 3 is 4 from the CFA.
+            .D8(constants::DW_CFA_offset.0 | 3)
+            .uleb(4)
+            .append_repeated(constants::DW_CFA_nop.0, 4);
+        let initial_instructions = initial_instructions.get_contents().unwrap();
+
+        let cie = CommonInformationEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            version: 4,
+            augmentation: None,
+            address_size: 8,
+            segment_size: 0,
+            code_alignment_factor: 1,
+            data_alignment_factor: 1,
+            return_address_register: Register(3),
+            initial_instructions: EndianSlice::new(&initial_instructions, LittleEndian),
+        };
+
+        let instructions = Section::with_endian(Endian::Little)
+            // Initial instructions form a row, advance the address by 1.
+            .D8(constants::DW_CFA_advance_loc1.0)
+            .D8(1)
+            // Register 0 is -16 from the CFA.
+            .D8(constants::DW_CFA_offset_extended_sf.0)
+            .uleb(0)
+            .sleb(-16)
+            // Finish this row, advance the address by 32.
+            .D8(constants::DW_CFA_advance_loc1.0)
+            .D8(32)
+            // Register 3 is -4 from the CFA.
+            .D8(constants::DW_CFA_offset_extended_sf.0)
+            .uleb(3)
+            .sleb(-4)
+            // Finish this row, advance the address by 64.
+            .D8(constants::DW_CFA_advance_loc1.0)
+            .D8(64)
+            // Register 5 is 4 from the CFA.
+            .D8(constants::DW_CFA_offset.0 | 5)
+            .uleb(4)
+            // A bunch of nop padding.
+            .append_repeated(constants::DW_CFA_nop.0, 8);
+        let instructions = instructions.get_contents().unwrap();
+
+        let fde = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            cie: cie.clone(),
+            initial_segment: 0,
+            initial_address: 0,
+            address_range: 100,
+            augmentation: None,
+            instructions: EndianSlice::new(&instructions, LittleEndian),
+        };
+
+        let section = &DebugFrame::from(EndianSlice::default());
+        let bases = &BaseAddresses::default();
+        let mut ctx = Box::new(UnwindContext::new());
+
+        let mut table = fde
+            .rows(section, bases, &mut ctx)
+            .expect("Should run initial program OK");
+        assert!(table.ctx.is_initialized);
+        assert!(table.ctx.initial_rule.is_none());
+        let expected_initial_rules: RegisterRuleMap<_> = [
+            (Register(0), RegisterRule::Offset(8)),
+            (Register(3), RegisterRule::Offset(4)),
+        ]
+        .iter()
+        .collect();
+        assert_eq!(table.ctx.stack[0].registers, expected_initial_rules);
+
+        {
+            let row = table.next_row().expect("Should evaluate first row OK");
+            let expected = UnwindTableRow {
+                start_address: 0,
+                end_address: 1,
+                saved_args_size: 0,
+                cfa: CfaRule::RegisterAndOffset {
+                    register: Register(4),
+                    offset: -12,
+                },
+                registers: [
+                    (Register(0), RegisterRule::Offset(8)),
+                    (Register(3), RegisterRule::Offset(4)),
+                ]
+                .iter()
+                .collect(),
+            };
+            assert_eq!(Some(&expected), row);
+        }
+
+        {
+            let row = table.next_row().expect("Should evaluate second row OK");
+            let expected = UnwindTableRow {
+                start_address: 1,
+                end_address: 33,
+                saved_args_size: 0,
+                cfa: CfaRule::RegisterAndOffset {
+                    register: Register(4),
+                    offset: -12,
+                },
+                registers: [
+                    (Register(0), RegisterRule::Offset(-16)),
+                    (Register(3), RegisterRule::Offset(4)),
+                ]
+                .iter()
+                .collect(),
+            };
+            assert_eq!(Some(&expected), row);
+        }
+
+        {
+            let row = table.next_row().expect("Should evaluate third row OK");
+            let expected = UnwindTableRow {
+                start_address: 33,
+                end_address: 97,
+                saved_args_size: 0,
+                cfa: CfaRule::RegisterAndOffset {
+                    register: Register(4),
+                    offset: -12,
+                },
+                registers: [
+                    (Register(0), RegisterRule::Offset(-16)),
+                    (Register(3), RegisterRule::Offset(-4)),
+                ]
+                .iter()
+                .collect(),
+            };
+            assert_eq!(Some(&expected), row);
+        }
+
+        {
+            let row = table.next_row().expect("Should evaluate fourth row OK");
+            let expected = UnwindTableRow {
+                start_address: 97,
+                end_address: 100,
+                saved_args_size: 0,
+                cfa: CfaRule::RegisterAndOffset {
+                    register: Register(4),
+                    offset: -12,
+                },
+                registers: [
+                    (Register(0), RegisterRule::Offset(-16)),
+                    (Register(3), RegisterRule::Offset(-4)),
+                    (Register(5), RegisterRule::Offset(4)),
+                ]
+                .iter()
+                .collect(),
+            };
+            assert_eq!(Some(&expected), row);
+        }
+
+        // All done!
+        assert_eq!(Ok(None), table.next_row());
+        assert_eq!(Ok(None), table.next_row());
+    }
+
+    #[test]
+    fn test_unwind_info_for_address_ok() {
+        let instrs1 = Section::with_endian(Endian::Big)
+            // The CFA is -12 from register 4.
+            .D8(constants::DW_CFA_def_cfa_sf.0)
+            .uleb(4)
+            .sleb(-12);
+        let instrs1 = instrs1.get_contents().unwrap();
+
+        let instrs2: Vec<_> = (0..8).map(|_| constants::DW_CFA_nop.0).collect();
+
+        let instrs3 = Section::with_endian(Endian::Big)
+            // Initial instructions form a row, advance the address by 100.
+            .D8(constants::DW_CFA_advance_loc1.0)
+            .D8(100)
+            // Register 0 is -16 from the CFA.
+            .D8(constants::DW_CFA_offset_extended_sf.0)
+            .uleb(0)
+            .sleb(-16);
+        let instrs3 = instrs3.get_contents().unwrap();
+
+        let instrs4: Vec<_> = (0..16).map(|_| constants::DW_CFA_nop.0).collect();
+
+        let mut cie1 = CommonInformationEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            version: 4,
+            augmentation: None,
+            address_size: 8,
+            segment_size: 0,
+            code_alignment_factor: 1,
+            data_alignment_factor: 1,
+            return_address_register: Register(3),
+            initial_instructions: EndianSlice::new(&instrs1, BigEndian),
+        };
+
+        let mut cie2 = CommonInformationEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            version: 4,
+            augmentation: None,
+            address_size: 4,
+            segment_size: 0,
+            code_alignment_factor: 1,
+            data_alignment_factor: 1,
+            return_address_register: Register(1),
+            initial_instructions: EndianSlice::new(&instrs2, BigEndian),
+        };
+
+        let cie1_location = Label::new();
+        let cie2_location = Label::new();
+
+        // Write the CIEs first so that their length gets set before we clone
+        // them into the FDEs and our equality assertions down the line end up
+        // with all the CIEs always having he correct length.
+        let kind = debug_frame_be();
+        let section = Section::with_endian(kind.endian())
+            .mark(&cie1_location)
+            .cie(kind, None, &mut cie1)
+            .mark(&cie2_location)
+            .cie(kind, None, &mut cie2);
+
+        let mut fde1 = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            cie: cie1.clone(),
+            initial_segment: 0,
+            initial_address: 0xfeed_beef,
+            address_range: 200,
+            augmentation: None,
+            instructions: EndianSlice::new(&instrs3, BigEndian),
+        };
+
+        let mut fde2 = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            cie: cie2.clone(),
+            initial_segment: 0,
+            initial_address: 0xfeed_face,
+            address_range: 9000,
+            augmentation: None,
+            instructions: EndianSlice::new(&instrs4, BigEndian),
+        };
+
+        let section =
+            section
+                .fde(kind, &cie1_location, &mut fde1)
+                .fde(kind, &cie2_location, &mut fde2);
+        section.start().set_const(0);
+
+        let contents = section.get_contents().unwrap();
+        let debug_frame = kind.section(&contents);
+
+        // Get the second row of the unwind table in `instrs3`.
+        let bases = Default::default();
+        let mut ctx = Box::new(UnwindContext::new());
+        let result = debug_frame.unwind_info_for_address(
+            &bases,
+            &mut ctx,
+            0xfeed_beef + 150,
+            DebugFrame::cie_from_offset,
+        );
+        assert!(result.is_ok());
+        let unwind_info = result.unwrap();
+
+        assert_eq!(
+            *unwind_info,
+            UnwindTableRow {
+                start_address: fde1.initial_address() + 100,
+                end_address: fde1.initial_address() + fde1.len(),
+                saved_args_size: 0,
+                cfa: CfaRule::RegisterAndOffset {
+                    register: Register(4),
+                    offset: -12,
+                },
+                registers: [(Register(0), RegisterRule::Offset(-16))].iter().collect(),
+            }
+        );
+    }
+
+    #[test]
+    fn test_unwind_info_for_address_not_found() {
+        let debug_frame = DebugFrame::new(&[], NativeEndian);
+        let bases = Default::default();
+        let mut ctx = Box::new(UnwindContext::new());
+        let result = debug_frame.unwind_info_for_address(
+            &bases,
+            &mut ctx,
+            0xbadb_ad99,
+            DebugFrame::cie_from_offset,
+        );
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), Error::NoUnwindInfoForAddress);
+    }
+
+    #[test]
+    fn test_eh_frame_hdr_unknown_version() {
+        let bases = BaseAddresses::default();
+        let buf = &[42];
+        let result = EhFrameHdr::new(buf, NativeEndian).parse(&bases, 8);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), Error::UnknownVersion(42));
+    }
+
+    #[test]
+    fn test_eh_frame_hdr_omit_ehptr() {
+        let section = Section::with_endian(Endian::Little)
+            .L8(1)
+            .L8(0xff)
+            .L8(0x03)
+            .L8(0x0b)
+            .L32(2)
+            .L32(10)
+            .L32(1)
+            .L32(20)
+            .L32(2)
+            .L32(0);
+        let section = section.get_contents().unwrap();
+        let bases = BaseAddresses::default();
+        let result = EhFrameHdr::new(&section, LittleEndian).parse(&bases, 8);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), Error::CannotParseOmitPointerEncoding);
+    }
+
+    #[test]
+    fn test_eh_frame_hdr_omit_count() {
+        let section = Section::with_endian(Endian::Little)
+            .L8(1)
+            .L8(0x0b)
+            .L8(0xff)
+            .L8(0x0b)
+            .L32(0x12345);
+        let section = section.get_contents().unwrap();
+        let bases = BaseAddresses::default();
+        let result = EhFrameHdr::new(&section, LittleEndian).parse(&bases, 8);
+        assert!(result.is_ok());
+        let result = result.unwrap();
+        assert_eq!(result.eh_frame_ptr(), Pointer::Direct(0x12345));
+        assert!(result.table().is_none());
+    }
+
+    #[test]
+    fn test_eh_frame_hdr_omit_table() {
+        let section = Section::with_endian(Endian::Little)
+            .L8(1)
+            .L8(0x0b)
+            .L8(0x03)
+            .L8(0xff)
+            .L32(0x12345)
+            .L32(2);
+        let section = section.get_contents().unwrap();
+        let bases = BaseAddresses::default();
+        let result = EhFrameHdr::new(&section, LittleEndian).parse(&bases, 8);
+        assert!(result.is_ok());
+        let result = result.unwrap();
+        assert_eq!(result.eh_frame_ptr(), Pointer::Direct(0x12345));
+        assert!(result.table().is_none());
+    }
+
+    #[test]
+    fn test_eh_frame_hdr_varlen_table() {
+        let section = Section::with_endian(Endian::Little)
+            .L8(1)
+            .L8(0x0b)
+            .L8(0x03)
+            .L8(0x01)
+            .L32(0x12345)
+            .L32(2);
+        let section = section.get_contents().unwrap();
+        let bases = BaseAddresses::default();
+        let result = EhFrameHdr::new(&section, LittleEndian).parse(&bases, 8);
+        assert!(result.is_ok());
+        let result = result.unwrap();
+        assert_eq!(result.eh_frame_ptr(), Pointer::Direct(0x12345));
+        let table = result.table();
+        assert!(table.is_some());
+        let table = table.unwrap();
+        assert_eq!(
+            table.lookup(0, &bases),
+            Err(Error::VariableLengthSearchTable)
+        );
+    }
+
+    #[test]
+    fn test_eh_frame_hdr_indirect_length() {
+        let section = Section::with_endian(Endian::Little)
+            .L8(1)
+            .L8(0x0b)
+            .L8(0x83)
+            .L8(0x0b)
+            .L32(0x12345)
+            .L32(2);
+        let section = section.get_contents().unwrap();
+        let bases = BaseAddresses::default();
+        let result = EhFrameHdr::new(&section, LittleEndian).parse(&bases, 8);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), Error::UnsupportedPointerEncoding);
+    }
+
+    #[test]
+    fn test_eh_frame_hdr_indirect_ptrs() {
+        let section = Section::with_endian(Endian::Little)
+            .L8(1)
+            .L8(0x8b)
+            .L8(0x03)
+            .L8(0x8b)
+            .L32(0x12345)
+            .L32(2)
+            .L32(10)
+            .L32(1)
+            .L32(20)
+            .L32(2);
+        let section = section.get_contents().unwrap();
+        let bases = BaseAddresses::default();
+        let result = EhFrameHdr::new(&section, LittleEndian).parse(&bases, 8);
+        assert!(result.is_ok());
+        let result = result.unwrap();
+        assert_eq!(result.eh_frame_ptr(), Pointer::Indirect(0x12345));
+        let table = result.table();
+        assert!(table.is_some());
+        let table = table.unwrap();
+        assert_eq!(
+            table.lookup(0, &bases),
+            Err(Error::UnsupportedPointerEncoding)
+        );
+    }
+
+    #[test]
+    fn test_eh_frame_hdr_good() {
+        let section = Section::with_endian(Endian::Little)
+            .L8(1)
+            .L8(0x0b)
+            .L8(0x03)
+            .L8(0x0b)
+            .L32(0x12345)
+            .L32(2)
+            .L32(10)
+            .L32(1)
+            .L32(20)
+            .L32(2);
+        let section = section.get_contents().unwrap();
+        let bases = BaseAddresses::default();
+        let result = EhFrameHdr::new(&section, LittleEndian).parse(&bases, 8);
+        assert!(result.is_ok());
+        let result = result.unwrap();
+        assert_eq!(result.eh_frame_ptr(), Pointer::Direct(0x12345));
+        let table = result.table();
+        assert!(table.is_some());
+        let table = table.unwrap();
+        assert_eq!(table.lookup(0, &bases), Ok(Pointer::Direct(1)));
+        assert_eq!(table.lookup(9, &bases), Ok(Pointer::Direct(1)));
+        assert_eq!(table.lookup(10, &bases), Ok(Pointer::Direct(1)));
+        assert_eq!(table.lookup(11, &bases), Ok(Pointer::Direct(1)));
+        assert_eq!(table.lookup(19, &bases), Ok(Pointer::Direct(1)));
+        assert_eq!(table.lookup(20, &bases), Ok(Pointer::Direct(2)));
+        assert_eq!(table.lookup(21, &bases), Ok(Pointer::Direct(2)));
+        assert_eq!(table.lookup(100_000, &bases), Ok(Pointer::Direct(2)));
+    }
+
+    #[test]
+    fn test_eh_frame_fde_for_address_good() {
+        // First, setup eh_frame
+        // Write the CIE first so that its length gets set before we clone it
+        // into the FDE.
+        let mut cie = make_test_cie();
+        cie.format = Format::Dwarf32;
+        cie.version = 1;
+
+        let start_of_cie = Label::new();
+        let end_of_cie = Label::new();
+
+        let kind = eh_frame_le();
+        let section = Section::with_endian(kind.endian())
+            .append_repeated(0, 16)
+            .mark(&start_of_cie)
+            .cie(kind, None, &mut cie)
+            .mark(&end_of_cie);
+
+        let mut fde1 = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            cie: cie.clone(),
+            initial_segment: 0,
+            initial_address: 9,
+            address_range: 4,
+            augmentation: None,
+            instructions: EndianSlice::new(&[], LittleEndian),
+        };
+        let mut fde2 = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            cie: cie.clone(),
+            initial_segment: 0,
+            initial_address: 20,
+            address_range: 8,
+            augmentation: None,
+            instructions: EndianSlice::new(&[], LittleEndian),
+        };
+
+        let start_of_fde1 = Label::new();
+        let start_of_fde2 = Label::new();
+
+        let section = section
+            // +4 for the FDE length before the CIE offset.
+            .mark(&start_of_fde1)
+            .fde(kind, (&start_of_fde1 - &start_of_cie + 4) as u64, &mut fde1)
+            .mark(&start_of_fde2)
+            .fde(kind, (&start_of_fde2 - &start_of_cie + 4) as u64, &mut fde2);
+
+        section.start().set_const(0);
+        let section = section.get_contents().unwrap();
+        let eh_frame = kind.section(&section);
+
+        // Setup eh_frame_hdr
+        let section = Section::with_endian(kind.endian())
+            .L8(1)
+            .L8(0x0b)
+            .L8(0x03)
+            .L8(0x0b)
+            .L32(0x12345)
+            .L32(2)
+            .L32(10)
+            .L32(0x12345 + start_of_fde1.value().unwrap() as u32)
+            .L32(20)
+            .L32(0x12345 + start_of_fde2.value().unwrap() as u32);
+
+        let section = section.get_contents().unwrap();
+        let bases = BaseAddresses::default();
+        let eh_frame_hdr = EhFrameHdr::new(&section, LittleEndian).parse(&bases, 8);
+        assert!(eh_frame_hdr.is_ok());
+        let eh_frame_hdr = eh_frame_hdr.unwrap();
+
+        let table = eh_frame_hdr.table();
+        assert!(table.is_some());
+        let table = table.unwrap();
+
+        let bases = Default::default();
+        let mut iter = table.iter(&bases);
+        assert_eq!(
+            iter.next(),
+            Ok(Some((
+                Pointer::Direct(10),
+                Pointer::Direct(0x12345 + start_of_fde1.value().unwrap() as u64)
+            )))
+        );
+        assert_eq!(
+            iter.next(),
+            Ok(Some((
+                Pointer::Direct(20),
+                Pointer::Direct(0x12345 + start_of_fde2.value().unwrap() as u64)
+            )))
+        );
+        assert_eq!(iter.next(), Ok(None));
+
+        assert_eq!(
+            table.iter(&bases).nth(0),
+            Ok(Some((
+                Pointer::Direct(10),
+                Pointer::Direct(0x12345 + start_of_fde1.value().unwrap() as u64)
+            )))
+        );
+
+        assert_eq!(
+            table.iter(&bases).nth(1),
+            Ok(Some((
+                Pointer::Direct(20),
+                Pointer::Direct(0x12345 + start_of_fde2.value().unwrap() as u64)
+            )))
+        );
+        assert_eq!(table.iter(&bases).nth(2), Ok(None));
+
+        let f = |_: &_, _: &_, o: EhFrameOffset| {
+            assert_eq!(o, EhFrameOffset(start_of_cie.value().unwrap() as usize));
+            Ok(cie.clone())
+        };
+        assert_eq!(
+            table.fde_for_address(&eh_frame, &bases, 9, f),
+            Ok(fde1.clone())
+        );
+        assert_eq!(
+            table.fde_for_address(&eh_frame, &bases, 10, f),
+            Ok(fde1.clone())
+        );
+        assert_eq!(table.fde_for_address(&eh_frame, &bases, 11, f), Ok(fde1));
+        assert_eq!(
+            table.fde_for_address(&eh_frame, &bases, 19, f),
+            Err(Error::NoUnwindInfoForAddress)
+        );
+        assert_eq!(
+            table.fde_for_address(&eh_frame, &bases, 20, f),
+            Ok(fde2.clone())
+        );
+        assert_eq!(table.fde_for_address(&eh_frame, &bases, 21, f), Ok(fde2));
+        assert_eq!(
+            table.fde_for_address(&eh_frame, &bases, 100_000, f),
+            Err(Error::NoUnwindInfoForAddress)
+        );
+    }
+
+    #[test]
+    fn test_eh_frame_stops_at_zero_length() {
+        let section = Section::with_endian(Endian::Little).L32(0);
+        let section = section.get_contents().unwrap();
+        let rest = &mut EndianSlice::new(&section, LittleEndian);
+        let bases = Default::default();
+
+        assert_eq!(
+            parse_cfi_entry(&bases, &EhFrame::new(&*section, LittleEndian), rest),
+            Ok(None)
+        );
+
+        assert_eq!(
+            EhFrame::new(&section, LittleEndian).cie_from_offset(&bases, EhFrameOffset(0)),
+            Err(Error::NoEntryAtGivenOffset)
+        );
+    }
+
+    fn resolve_cie_offset(buf: &[u8], cie_offset: usize) -> Result<usize> {
+        let mut fde = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf64,
+            cie: make_test_cie(),
+            initial_segment: 0,
+            initial_address: 0xfeed_beef,
+            address_range: 39,
+            augmentation: None,
+            instructions: EndianSlice::new(&[], LittleEndian),
+        };
+
+        let kind = eh_frame_le();
+        let section = Section::with_endian(kind.endian())
+            .append_bytes(&buf)
+            .fde(kind, cie_offset as u64, &mut fde)
+            .append_bytes(&buf);
+
+        let section = section.get_contents().unwrap();
+        let eh_frame = kind.section(&section);
+        let input = &mut EndianSlice::new(&section[buf.len()..], LittleEndian);
+
+        let bases = Default::default();
+        match parse_cfi_entry(&bases, &eh_frame, input) {
+            Ok(Some(CieOrFde::Fde(partial))) => Ok(partial.cie_offset.0),
+            Err(e) => Err(e),
+            otherwise => panic!("Unexpected result: {:#?}", otherwise),
+        }
+    }
+
+    #[test]
+    fn test_eh_frame_resolve_cie_offset_ok() {
+        let buf = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let cie_offset = 2;
+        // + 4 for size of length field
+        assert_eq!(
+            resolve_cie_offset(&buf, buf.len() + 4 - cie_offset),
+            Ok(cie_offset)
+        );
+    }
+
+    #[test]
+    fn test_eh_frame_resolve_cie_offset_out_of_bounds() {
+        let buf = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+        assert_eq!(
+            resolve_cie_offset(&buf, buf.len() + 4 + 2),
+            Err(Error::OffsetOutOfBounds)
+        );
+    }
+
+    #[test]
+    fn test_eh_frame_resolve_cie_offset_underflow() {
+        let buf = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+        assert_eq!(
+            resolve_cie_offset(&buf, ::core::usize::MAX),
+            Err(Error::OffsetOutOfBounds)
+        );
+    }
+
+    #[test]
+    fn test_eh_frame_fde_ok() {
+        let mut cie = make_test_cie();
+        cie.format = Format::Dwarf32;
+        cie.version = 1;
+
+        let start_of_cie = Label::new();
+        let end_of_cie = Label::new();
+
+        // Write the CIE first so that its length gets set before we clone it
+        // into the FDE.
+        let kind = eh_frame_le();
+        let section = Section::with_endian(kind.endian())
+            .append_repeated(0, 16)
+            .mark(&start_of_cie)
+            .cie(kind, None, &mut cie)
+            .mark(&end_of_cie);
+
+        let mut fde = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            cie: cie.clone(),
+            initial_segment: 0,
+            initial_address: 0xfeed_beef,
+            address_range: 999,
+            augmentation: None,
+            instructions: EndianSlice::new(&[], LittleEndian),
+        };
+
+        let section = section
+            // +4 for the FDE length before the CIE offset.
+            .fde(kind, (&end_of_cie - &start_of_cie + 4) as u64, &mut fde);
+
+        section.start().set_const(0);
+        let section = section.get_contents().unwrap();
+        let eh_frame = kind.section(&section);
+        let section = EndianSlice::new(&section, LittleEndian);
+
+        let mut offset = None;
+        match parse_fde(
+            eh_frame,
+            &mut section.range_from(end_of_cie.value().unwrap() as usize..),
+            |_, _, o| {
+                offset = Some(o);
+                assert_eq!(o, EhFrameOffset(start_of_cie.value().unwrap() as usize));
+                Ok(cie.clone())
+            },
+        ) {
+            Ok(actual) => assert_eq!(actual, fde),
+            otherwise => panic!("Unexpected result {:?}", otherwise),
+        }
+        assert!(offset.is_some());
+    }
+
+    #[test]
+    fn test_eh_frame_fde_out_of_bounds() {
+        let mut cie = make_test_cie();
+        cie.version = 1;
+
+        let end_of_cie = Label::new();
+
+        let mut fde = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf64,
+            cie: cie.clone(),
+            initial_segment: 0,
+            initial_address: 0xfeed_beef,
+            address_range: 999,
+            augmentation: None,
+            instructions: EndianSlice::new(&[], LittleEndian),
+        };
+
+        let kind = eh_frame_le();
+        let section = Section::with_endian(kind.endian())
+            .cie(kind, None, &mut cie)
+            .mark(&end_of_cie)
+            .fde(kind, 99_999_999_999_999, &mut fde);
+
+        section.start().set_const(0);
+        let section = section.get_contents().unwrap();
+        let eh_frame = kind.section(&section);
+        let section = EndianSlice::new(&section, LittleEndian);
+
+        let result = parse_fde(
+            eh_frame,
+            &mut section.range_from(end_of_cie.value().unwrap() as usize..),
+            UnwindSection::cie_from_offset,
+        );
+        assert_eq!(result, Err(Error::OffsetOutOfBounds));
+    }
+
+    #[test]
+    fn test_augmentation_parse_not_z_augmentation() {
+        let augmentation = &mut EndianSlice::new(b"wtf", NativeEndian);
+        let bases = Default::default();
+        let address_size = 8;
+        let section = EhFrame::new(&[], NativeEndian);
+        let input = &mut EndianSlice::new(&[], NativeEndian);
+        assert_eq!(
+            Augmentation::parse(augmentation, &bases, address_size, &section, input),
+            Err(Error::UnknownAugmentation)
+        );
+    }
+
+    #[test]
+    fn test_augmentation_parse_just_signal_trampoline() {
+        let aug_str = &mut EndianSlice::new(b"S", LittleEndian);
+        let bases = Default::default();
+        let address_size = 8;
+        let section = EhFrame::new(&[], LittleEndian);
+        let input = &mut EndianSlice::new(&[], LittleEndian);
+
+        let mut augmentation = Augmentation::default();
+        augmentation.is_signal_trampoline = true;
+
+        assert_eq!(
+            Augmentation::parse(aug_str, &bases, address_size, &section, input),
+            Ok(augmentation)
+        );
+    }
+
+    #[test]
+    fn test_augmentation_parse_unknown_part_of_z_augmentation() {
+        // The 'Z' character is not defined by the z-style augmentation.
+        let bases = Default::default();
+        let address_size = 8;
+        let section = Section::with_endian(Endian::Little)
+            .uleb(4)
+            .append_repeated(4, 4)
+            .get_contents()
+            .unwrap();
+        let section = EhFrame::new(&section, LittleEndian);
+        let input = &mut section.section().clone();
+        let augmentation = &mut EndianSlice::new(b"zZ", LittleEndian);
+        assert_eq!(
+            Augmentation::parse(augmentation, &bases, address_size, &section, input),
+            Err(Error::UnknownAugmentation)
+        );
+    }
+
+    #[test]
+    #[allow(non_snake_case)]
+    fn test_augmentation_parse_L() {
+        let bases = Default::default();
+        let address_size = 8;
+        let rest = [9, 8, 7, 6, 5, 4, 3, 2, 1];
+
+        let section = Section::with_endian(Endian::Little)
+            .uleb(1)
+            .D8(constants::DW_EH_PE_uleb128.0)
+            .append_bytes(&rest)
+            .get_contents()
+            .unwrap();
+        let section = EhFrame::new(&section, LittleEndian);
+        let input = &mut section.section().clone();
+        let aug_str = &mut EndianSlice::new(b"zL", LittleEndian);
+
+        let mut augmentation = Augmentation::default();
+        augmentation.lsda = Some(constants::DW_EH_PE_uleb128);
+
+        assert_eq!(
+            Augmentation::parse(aug_str, &bases, address_size, &section, input),
+            Ok(augmentation)
+        );
+        assert_eq!(*input, EndianSlice::new(&rest, LittleEndian));
+    }
+
+    #[test]
+    #[allow(non_snake_case)]
+    fn test_augmentation_parse_P() {
+        let bases = Default::default();
+        let address_size = 8;
+        let rest = [9, 8, 7, 6, 5, 4, 3, 2, 1];
+
+        let section = Section::with_endian(Endian::Little)
+            .uleb(9)
+            .D8(constants::DW_EH_PE_udata8.0)
+            .L64(0xf00d_f00d)
+            .append_bytes(&rest)
+            .get_contents()
+            .unwrap();
+        let section = EhFrame::new(&section, LittleEndian);
+        let input = &mut section.section().clone();
+        let aug_str = &mut EndianSlice::new(b"zP", LittleEndian);
+
+        let mut augmentation = Augmentation::default();
+        augmentation.personality = Some((constants::DW_EH_PE_udata8, Pointer::Direct(0xf00d_f00d)));
+
+        assert_eq!(
+            Augmentation::parse(aug_str, &bases, address_size, &section, input),
+            Ok(augmentation)
+        );
+        assert_eq!(*input, EndianSlice::new(&rest, LittleEndian));
+    }
+
+    #[test]
+    #[allow(non_snake_case)]
+    fn test_augmentation_parse_R() {
+        let bases = Default::default();
+        let address_size = 8;
+        let rest = [9, 8, 7, 6, 5, 4, 3, 2, 1];
+
+        let section = Section::with_endian(Endian::Little)
+            .uleb(1)
+            .D8(constants::DW_EH_PE_udata4.0)
+            .append_bytes(&rest)
+            .get_contents()
+            .unwrap();
+        let section = EhFrame::new(&section, LittleEndian);
+        let input = &mut section.section().clone();
+        let aug_str = &mut EndianSlice::new(b"zR", LittleEndian);
+
+        let mut augmentation = Augmentation::default();
+        augmentation.fde_address_encoding = Some(constants::DW_EH_PE_udata4);
+
+        assert_eq!(
+            Augmentation::parse(aug_str, &bases, address_size, &section, input),
+            Ok(augmentation)
+        );
+        assert_eq!(*input, EndianSlice::new(&rest, LittleEndian));
+    }
+
+    #[test]
+    #[allow(non_snake_case)]
+    fn test_augmentation_parse_S() {
+        let bases = Default::default();
+        let address_size = 8;
+        let rest = [9, 8, 7, 6, 5, 4, 3, 2, 1];
+
+        let section = Section::with_endian(Endian::Little)
+            .uleb(0)
+            .append_bytes(&rest)
+            .get_contents()
+            .unwrap();
+        let section = EhFrame::new(&section, LittleEndian);
+        let input = &mut section.section().clone();
+        let aug_str = &mut EndianSlice::new(b"zS", LittleEndian);
+
+        let mut augmentation = Augmentation::default();
+        augmentation.is_signal_trampoline = true;
+
+        assert_eq!(
+            Augmentation::parse(aug_str, &bases, address_size, &section, input),
+            Ok(augmentation)
+        );
+        assert_eq!(*input, EndianSlice::new(&rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_augmentation_parse_all() {
+        let bases = Default::default();
+        let address_size = 8;
+        let rest = [9, 8, 7, 6, 5, 4, 3, 2, 1];
+
+        let section = Section::with_endian(Endian::Little)
+            .uleb(1 + 9 + 1)
+            // L
+            .D8(constants::DW_EH_PE_uleb128.0)
+            // P
+            .D8(constants::DW_EH_PE_udata8.0)
+            .L64(0x1bad_f00d)
+            // R
+            .D8(constants::DW_EH_PE_uleb128.0)
+            .append_bytes(&rest)
+            .get_contents()
+            .unwrap();
+        let section = EhFrame::new(&section, LittleEndian);
+        let input = &mut section.section().clone();
+        let aug_str = &mut EndianSlice::new(b"zLPRS", LittleEndian);
+
+        let augmentation = Augmentation {
+            lsda: Some(constants::DW_EH_PE_uleb128),
+            personality: Some((constants::DW_EH_PE_udata8, Pointer::Direct(0x1bad_f00d))),
+            fde_address_encoding: Some(constants::DW_EH_PE_uleb128),
+            is_signal_trampoline: true,
+        };
+
+        assert_eq!(
+            Augmentation::parse(aug_str, &bases, address_size, &section, input),
+            Ok(augmentation)
+        );
+        assert_eq!(*input, EndianSlice::new(&rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_eh_frame_fde_no_augmentation() {
+        let instrs = [1, 2, 3, 4];
+        let cie_offset = 1;
+
+        let mut cie = make_test_cie();
+        cie.format = Format::Dwarf32;
+        cie.version = 1;
+
+        let mut fde = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            cie: cie.clone(),
+            initial_segment: 0,
+            initial_address: 0xfeed_face,
+            address_range: 9000,
+            augmentation: None,
+            instructions: EndianSlice::new(&instrs, LittleEndian),
+        };
+
+        let rest = [1, 2, 3, 4];
+
+        let kind = eh_frame_le();
+        let section = Section::with_endian(kind.endian())
+            .fde(kind, cie_offset, &mut fde)
+            .append_bytes(&rest)
+            .get_contents()
+            .unwrap();
+        let section = kind.section(&section);
+        let input = &mut section.section().clone();
+
+        let result = parse_fde(section, input, |_, _, _| Ok(cie.clone()));
+        assert_eq!(result, Ok(fde));
+        assert_eq!(*input, EndianSlice::new(&rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_eh_frame_fde_empty_augmentation() {
+        let instrs = [1, 2, 3, 4];
+        let cie_offset = 1;
+
+        let mut cie = make_test_cie();
+        cie.format = Format::Dwarf32;
+        cie.version = 1;
+        cie.augmentation = Some(Augmentation::default());
+
+        let mut fde = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            cie: cie.clone(),
+            initial_segment: 0,
+            initial_address: 0xfeed_face,
+            address_range: 9000,
+            augmentation: Some(AugmentationData::default()),
+            instructions: EndianSlice::new(&instrs, LittleEndian),
+        };
+
+        let rest = [1, 2, 3, 4];
+
+        let kind = eh_frame_le();
+        let section = Section::with_endian(kind.endian())
+            .fde(kind, cie_offset, &mut fde)
+            .append_bytes(&rest)
+            .get_contents()
+            .unwrap();
+        let section = kind.section(&section);
+        let input = &mut section.section().clone();
+
+        let result = parse_fde(section, input, |_, _, _| Ok(cie.clone()));
+        assert_eq!(result, Ok(fde));
+        assert_eq!(*input, EndianSlice::new(&rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_eh_frame_fde_lsda_augmentation() {
+        let instrs = [1, 2, 3, 4];
+        let cie_offset = 1;
+
+        let mut cie = make_test_cie();
+        cie.format = Format::Dwarf32;
+        cie.version = 1;
+        cie.augmentation = Some(Augmentation::default());
+        cie.augmentation.as_mut().unwrap().lsda = Some(constants::DW_EH_PE_absptr);
+
+        let mut fde = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            cie: cie.clone(),
+            initial_segment: 0,
+            initial_address: 0xfeed_face,
+            address_range: 9000,
+            augmentation: Some(AugmentationData {
+                lsda: Some(Pointer::Direct(0x1122_3344)),
+            }),
+            instructions: EndianSlice::new(&instrs, LittleEndian),
+        };
+
+        let rest = [1, 2, 3, 4];
+
+        let kind = eh_frame_le();
+        let section = Section::with_endian(kind.endian())
+            .fde(kind, cie_offset, &mut fde)
+            .append_bytes(&rest)
+            .get_contents()
+            .unwrap();
+        let section = kind.section(&section);
+        let input = &mut section.section().clone();
+
+        let result = parse_fde(section, input, |_, _, _| Ok(cie.clone()));
+        assert_eq!(result, Ok(fde));
+        assert_eq!(*input, EndianSlice::new(&rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_eh_frame_fde_lsda_function_relative() {
+        let instrs = [1, 2, 3, 4];
+        let cie_offset = 1;
+
+        let mut cie = make_test_cie();
+        cie.format = Format::Dwarf32;
+        cie.version = 1;
+        cie.augmentation = Some(Augmentation::default());
+        cie.augmentation.as_mut().unwrap().lsda = Some(constants::DwEhPe(
+            constants::DW_EH_PE_funcrel.0 | constants::DW_EH_PE_absptr.0,
+        ));
+
+        let mut fde = FrameDescriptionEntry {
+            offset: 0,
+            length: 0,
+            format: Format::Dwarf32,
+            cie: cie.clone(),
+            initial_segment: 0,
+            initial_address: 0xfeed_face,
+            address_range: 9000,
+            augmentation: Some(AugmentationData {
+                lsda: Some(Pointer::Direct(0xbeef)),
+            }),
+            instructions: EndianSlice::new(&instrs, LittleEndian),
+        };
+
+        let rest = [1, 2, 3, 4];
+
+        let kind = eh_frame_le();
+        let section = Section::with_endian(kind.endian())
+            .append_repeated(10, 10)
+            .fde(kind, cie_offset, &mut fde)
+            .append_bytes(&rest)
+            .get_contents()
+            .unwrap();
+        let section = kind.section(&section);
+        let input = &mut section.section().range_from(10..);
+
+        // Adjust the FDE's augmentation to be relative to the function.
+        fde.augmentation.as_mut().unwrap().lsda = Some(Pointer::Direct(0xfeed_face + 0xbeef));
+
+        let result = parse_fde(section, input, |_, _, _| Ok(cie.clone()));
+        assert_eq!(result, Ok(fde));
+        assert_eq!(*input, EndianSlice::new(&rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_eh_frame_cie_personality_function_relative_bad_context() {
+        let instrs = [1, 2, 3, 4];
+
+        let length = Label::new();
+        let start = Label::new();
+        let end = Label::new();
+
+        let aug_len = Label::new();
+        let aug_start = Label::new();
+        let aug_end = Label::new();
+
+        let section = Section::with_endian(Endian::Little)
+            // Length
+            .L32(&length)
+            .mark(&start)
+            // CIE ID
+            .L32(0)
+            // Version
+            .D8(1)
+            // Augmentation
+            .append_bytes(b"zP\0")
+            // Code alignment factor
+            .uleb(1)
+            // Data alignment factor
+            .sleb(1)
+            // Return address register
+            .uleb(1)
+            // Augmentation data length. This is a uleb, be we rely on the value
+            // being less than 2^7 and therefore a valid uleb (can't use Label
+            // with uleb).
+            .D8(&aug_len)
+            .mark(&aug_start)
+            // Augmentation data. Personality encoding and then encoded pointer.
+            .D8(constants::DW_EH_PE_funcrel.0 | constants::DW_EH_PE_uleb128.0)
+            .uleb(1)
+            .mark(&aug_end)
+            // Initial instructions
+            .append_bytes(&instrs)
+            .mark(&end);
+
+        length.set_const((&end - &start) as u64);
+        aug_len.set_const((&aug_end - &aug_start) as u64);
+
+        let section = section.get_contents().unwrap();
+        let section = EhFrame::new(&section, LittleEndian);
+
+        let bases = BaseAddresses::default();
+        let mut iter = section.entries(&bases);
+        assert_eq!(iter.next(), Err(Error::FuncRelativePointerInBadContext));
+    }
+
+    #[test]
+    fn register_rule_map_eq() {
+        // Different order, but still equal.
+        let map1: RegisterRuleMap<EndianSlice<LittleEndian>> = [
+            (Register(0), RegisterRule::SameValue),
+            (Register(3), RegisterRule::Offset(1)),
+        ]
+        .iter()
+        .collect();
+        let map2: RegisterRuleMap<EndianSlice<LittleEndian>> = [
+            (Register(3), RegisterRule::Offset(1)),
+            (Register(0), RegisterRule::SameValue),
+        ]
+        .iter()
+        .collect();
+        assert_eq!(map1, map2);
+        assert_eq!(map2, map1);
+
+        // Not equal.
+        let map3: RegisterRuleMap<EndianSlice<LittleEndian>> = [
+            (Register(0), RegisterRule::SameValue),
+            (Register(2), RegisterRule::Offset(1)),
+        ]
+        .iter()
+        .collect();
+        let map4: RegisterRuleMap<EndianSlice<LittleEndian>> = [
+            (Register(3), RegisterRule::Offset(1)),
+            (Register(0), RegisterRule::SameValue),
+        ]
+        .iter()
+        .collect();
+        assert!(map3 != map4);
+        assert!(map4 != map3);
+
+        // One has undefined explicitly set, other implicitly has undefined.
+        let mut map5 = RegisterRuleMap::<EndianSlice<LittleEndian>>::default();
+        map5.set(Register(0), RegisterRule::SameValue).unwrap();
+        map5.set(Register(0), RegisterRule::Undefined).unwrap();
+        let map6 = RegisterRuleMap::<EndianSlice<LittleEndian>>::default();
+        assert_eq!(map5, map6);
+        assert_eq!(map6, map5);
+    }
+
+    #[test]
+    fn iter_register_rules() {
+        let mut row = UnwindTableRow::<EndianSlice<LittleEndian>>::default();
+        row.registers = [
+            (Register(0), RegisterRule::SameValue),
+            (Register(1), RegisterRule::Offset(1)),
+            (Register(2), RegisterRule::ValOffset(2)),
+        ]
+        .iter()
+        .collect();
+
+        let mut found0 = false;
+        let mut found1 = false;
+        let mut found2 = false;
+
+        for &(register, ref rule) in row.registers() {
+            match register.0 {
+                0 => {
+                    assert_eq!(found0, false);
+                    found0 = true;
+                    assert_eq!(*rule, RegisterRule::SameValue);
+                }
+                1 => {
+                    assert_eq!(found1, false);
+                    found1 = true;
+                    assert_eq!(*rule, RegisterRule::Offset(1));
+                }
+                2 => {
+                    assert_eq!(found2, false);
+                    found2 = true;
+                    assert_eq!(*rule, RegisterRule::ValOffset(2));
+                }
+                x => panic!("Unexpected register rule: ({}, {:?})", x, rule),
+            }
+        }
+
+        assert_eq!(found0, true);
+        assert_eq!(found1, true);
+        assert_eq!(found2, true);
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn size_of_unwind_ctx() {
+        use core::mem;
+        let size = mem::size_of::<UnwindContext<EndianSlice<NativeEndian>>>();
+        let max_size = 30968;
+        if size > max_size {
+            assert_eq!(size, max_size);
+        }
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn size_of_register_rule_map() {
+        use core::mem;
+        let size = mem::size_of::<RegisterRuleMap<EndianSlice<NativeEndian>>>();
+        let max_size = 6152;
+        if size > max_size {
+            assert_eq!(size, max_size);
+        }
+    }
+
+    #[test]
+    fn test_parse_pointer_encoding_ok() {
+        use crate::endianity::NativeEndian;
+        let expected =
+            constants::DwEhPe(constants::DW_EH_PE_uleb128.0 | constants::DW_EH_PE_pcrel.0);
+        let input = [expected.0, 1, 2, 3, 4];
+        let input = &mut EndianSlice::new(&input, NativeEndian);
+        assert_eq!(parse_pointer_encoding(input), Ok(expected));
+        assert_eq!(*input, EndianSlice::new(&[1, 2, 3, 4], NativeEndian));
+    }
+
+    #[test]
+    fn test_parse_pointer_encoding_bad_encoding() {
+        use crate::endianity::NativeEndian;
+        let expected =
+            constants::DwEhPe((constants::DW_EH_PE_sdata8.0 + 1) | constants::DW_EH_PE_pcrel.0);
+        let input = [expected.0, 1, 2, 3, 4];
+        let input = &mut EndianSlice::new(&input, NativeEndian);
+        assert_eq!(
+            Err(Error::UnknownPointerEncoding),
+            parse_pointer_encoding(input)
+        );
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_absptr() {
+        let encoding = constants::DW_EH_PE_absptr;
+        let expected_rest = [1, 2, 3, 4];
+
+        let input = Section::with_endian(Endian::Little)
+            .L32(0xf00d_f00d)
+            .append_bytes(&expected_rest);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input;
+
+        let parameters = PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: None,
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Ok(Pointer::Direct(0xf00d_f00d))
+        );
+        assert_eq!(rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_pcrel() {
+        let encoding = constants::DW_EH_PE_pcrel;
+        let expected_rest = [1, 2, 3, 4];
+
+        let input = Section::with_endian(Endian::Little)
+            .append_repeated(0, 0x10)
+            .L32(0x1)
+            .append_bytes(&expected_rest);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input.range_from(0x10..);
+
+        let parameters = PointerEncodingParameters {
+            bases: &BaseAddresses::default().set_eh_frame(0x100).eh_frame,
+            func_base: None,
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Ok(Pointer::Direct(0x111))
+        );
+        assert_eq!(rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_pcrel_undefined() {
+        let encoding = constants::DW_EH_PE_pcrel;
+
+        let input = Section::with_endian(Endian::Little).L32(0x1);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input;
+
+        let parameters = PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: None,
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Err(Error::PcRelativePointerButSectionBaseIsUndefined)
+        );
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_textrel() {
+        let encoding = constants::DW_EH_PE_textrel;
+        let expected_rest = [1, 2, 3, 4];
+
+        let input = Section::with_endian(Endian::Little)
+            .L32(0x1)
+            .append_bytes(&expected_rest);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input;
+
+        let parameters = PointerEncodingParameters {
+            bases: &BaseAddresses::default().set_text(0x10).eh_frame,
+            func_base: None,
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Ok(Pointer::Direct(0x11))
+        );
+        assert_eq!(rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_textrel_undefined() {
+        let encoding = constants::DW_EH_PE_textrel;
+
+        let input = Section::with_endian(Endian::Little).L32(0x1);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input;
+
+        let parameters = PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: None,
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Err(Error::TextRelativePointerButTextBaseIsUndefined)
+        );
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_datarel() {
+        let encoding = constants::DW_EH_PE_datarel;
+        let expected_rest = [1, 2, 3, 4];
+
+        let input = Section::with_endian(Endian::Little)
+            .L32(0x1)
+            .append_bytes(&expected_rest);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input;
+
+        let parameters = PointerEncodingParameters {
+            bases: &BaseAddresses::default().set_got(0x10).eh_frame,
+            func_base: None,
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Ok(Pointer::Direct(0x11))
+        );
+        assert_eq!(rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_datarel_undefined() {
+        let encoding = constants::DW_EH_PE_datarel;
+
+        let input = Section::with_endian(Endian::Little).L32(0x1);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input;
+
+        let parameters = PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: None,
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Err(Error::DataRelativePointerButDataBaseIsUndefined)
+        );
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_funcrel() {
+        let encoding = constants::DW_EH_PE_funcrel;
+        let expected_rest = [1, 2, 3, 4];
+
+        let input = Section::with_endian(Endian::Little)
+            .L32(0x1)
+            .append_bytes(&expected_rest);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input;
+
+        let parameters = PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: Some(0x10),
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Ok(Pointer::Direct(0x11))
+        );
+        assert_eq!(rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_funcrel_undefined() {
+        let encoding = constants::DW_EH_PE_funcrel;
+
+        let input = Section::with_endian(Endian::Little).L32(0x1);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input;
+
+        let parameters = PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: None,
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Err(Error::FuncRelativePointerInBadContext)
+        );
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_uleb128() {
+        let encoding =
+            constants::DwEhPe(constants::DW_EH_PE_absptr.0 | constants::DW_EH_PE_uleb128.0);
+        let expected_rest = [1, 2, 3, 4];
+
+        let input = Section::with_endian(Endian::Little)
+            .uleb(0x12_3456)
+            .append_bytes(&expected_rest);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input;
+
+        let parameters = PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: None,
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Ok(Pointer::Direct(0x12_3456))
+        );
+        assert_eq!(rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_udata2() {
+        let encoding =
+            constants::DwEhPe(constants::DW_EH_PE_absptr.0 | constants::DW_EH_PE_udata2.0);
+        let expected_rest = [1, 2, 3, 4];
+
+        let input = Section::with_endian(Endian::Little)
+            .L16(0x1234)
+            .append_bytes(&expected_rest);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input;
+
+        let parameters = PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: None,
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Ok(Pointer::Direct(0x1234))
+        );
+        assert_eq!(rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_udata4() {
+        let encoding =
+            constants::DwEhPe(constants::DW_EH_PE_absptr.0 | constants::DW_EH_PE_udata4.0);
+        let expected_rest = [1, 2, 3, 4];
+
+        let input = Section::with_endian(Endian::Little)
+            .L32(0x1234_5678)
+            .append_bytes(&expected_rest);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input;
+
+        let parameters = PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: None,
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Ok(Pointer::Direct(0x1234_5678))
+        );
+        assert_eq!(rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_udata8() {
+        let encoding =
+            constants::DwEhPe(constants::DW_EH_PE_absptr.0 | constants::DW_EH_PE_udata8.0);
+        let expected_rest = [1, 2, 3, 4];
+
+        let input = Section::with_endian(Endian::Little)
+            .L64(0x1234_5678_1234_5678)
+            .append_bytes(&expected_rest);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input;
+
+        let parameters = PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: None,
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Ok(Pointer::Direct(0x1234_5678_1234_5678))
+        );
+        assert_eq!(rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_sleb128() {
+        let encoding =
+            constants::DwEhPe(constants::DW_EH_PE_textrel.0 | constants::DW_EH_PE_sleb128.0);
+        let expected_rest = [1, 2, 3, 4];
+
+        let input = Section::with_endian(Endian::Little)
+            .sleb(-0x1111)
+            .append_bytes(&expected_rest);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input;
+
+        let parameters = PointerEncodingParameters {
+            bases: &BaseAddresses::default().set_text(0x1111_1111).eh_frame,
+            func_base: None,
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Ok(Pointer::Direct(0x1111_0000))
+        );
+        assert_eq!(rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_sdata2() {
+        let encoding =
+            constants::DwEhPe(constants::DW_EH_PE_absptr.0 | constants::DW_EH_PE_sdata2.0);
+        let expected_rest = [1, 2, 3, 4];
+        let expected = 0x111 as i16;
+
+        let input = Section::with_endian(Endian::Little)
+            .L16(expected as u16)
+            .append_bytes(&expected_rest);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input;
+
+        let parameters = PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: None,
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Ok(Pointer::Direct(expected as u64))
+        );
+        assert_eq!(rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_sdata4() {
+        let encoding =
+            constants::DwEhPe(constants::DW_EH_PE_absptr.0 | constants::DW_EH_PE_sdata4.0);
+        let expected_rest = [1, 2, 3, 4];
+        let expected = 0x111_1111 as i32;
+
+        let input = Section::with_endian(Endian::Little)
+            .L32(expected as u32)
+            .append_bytes(&expected_rest);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input;
+
+        let parameters = PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: None,
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Ok(Pointer::Direct(expected as u64))
+        );
+        assert_eq!(rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_sdata8() {
+        let encoding =
+            constants::DwEhPe(constants::DW_EH_PE_absptr.0 | constants::DW_EH_PE_sdata8.0);
+        let expected_rest = [1, 2, 3, 4];
+        let expected = -0x11_1111_1222_2222 as i64;
+
+        let input = Section::with_endian(Endian::Little)
+            .L64(expected as u64)
+            .append_bytes(&expected_rest);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input;
+
+        let parameters = PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: None,
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Ok(Pointer::Direct(expected as u64))
+        );
+        assert_eq!(rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_omit() {
+        let encoding = constants::DW_EH_PE_omit;
+
+        let input = Section::with_endian(Endian::Little).L32(0x1);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input;
+
+        let parameters = PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: None,
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Err(Error::CannotParseOmitPointerEncoding)
+        );
+        assert_eq!(rest, input);
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_bad_encoding() {
+        let encoding = constants::DwEhPe(constants::DW_EH_PE_sdata8.0 + 1);
+
+        let input = Section::with_endian(Endian::Little).L32(0x1);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input;
+
+        let parameters = PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: None,
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Err(Error::UnknownPointerEncoding)
+        );
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_aligned() {
+        // FIXME: support this encoding!
+
+        let encoding = constants::DW_EH_PE_aligned;
+
+        let input = Section::with_endian(Endian::Little).L32(0x1);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input;
+
+        let parameters = PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: None,
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Err(Error::UnsupportedPointerEncoding)
+        );
+    }
+
+    #[test]
+    fn test_parse_encoded_pointer_indirect() {
+        let expected_rest = [1, 2, 3, 4];
+        let encoding = constants::DW_EH_PE_indirect;
+
+        let input = Section::with_endian(Endian::Little)
+            .L32(0x1234_5678)
+            .append_bytes(&expected_rest);
+        let input = input.get_contents().unwrap();
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut rest = input;
+
+        let parameters = PointerEncodingParameters {
+            bases: &SectionBaseAddresses::default(),
+            func_base: None,
+            address_size: 4,
+            section: &input,
+        };
+        assert_eq!(
+            parse_encoded_pointer(encoding, &parameters, &mut rest),
+            Ok(Pointer::Indirect(0x1234_5678))
+        );
+        assert_eq!(rest, EndianSlice::new(&expected_rest, LittleEndian));
+    }
+}
diff --git a/vendor/gimli/src/read/dwarf.rs b/vendor/gimli/src/read/dwarf.rs
new file mode 100644
index 0000000..2f8dcb3
--- /dev/null
+++ b/vendor/gimli/src/read/dwarf.rs
@@ -0,0 +1,1210 @@
+use alloc::string::String;
+use alloc::sync::Arc;
+
+use crate::common::{
+    DebugAddrBase, DebugAddrIndex, DebugInfoOffset, DebugLineStrOffset, DebugLocListsBase,
+    DebugLocListsIndex, DebugRngListsBase, DebugRngListsIndex, DebugStrOffset, DebugStrOffsetsBase,
+    DebugStrOffsetsIndex, DebugTypeSignature, DebugTypesOffset, DwarfFileType, DwoId, Encoding,
+    LocationListsOffset, RangeListsOffset, RawRangeListsOffset, SectionId, UnitSectionOffset,
+};
+use crate::constants;
+use crate::read::{
+    Abbreviations, AbbreviationsCache, AbbreviationsCacheStrategy, AttributeValue, DebugAbbrev,
+    DebugAddr, DebugAranges, DebugCuIndex, DebugInfo, DebugInfoUnitHeadersIter, DebugLine,
+    DebugLineStr, DebugLoc, DebugLocLists, DebugRngLists, DebugStr, DebugStrOffsets, DebugTuIndex,
+    DebugTypes, DebugTypesUnitHeadersIter, DebuggingInformationEntry, EntriesCursor, EntriesRaw,
+    EntriesTree, Error, IncompleteLineProgram, LocListIter, LocationLists, Range, RangeLists,
+    RawLocListIter, RawRngListIter, Reader, ReaderOffset, ReaderOffsetId, Result, RngListIter,
+    Section, UnitHeader, UnitIndex, UnitIndexSectionIterator, UnitOffset, UnitType,
+};
+
+/// All of the commonly used DWARF sections, and other common information.
+#[derive(Debug, Default)]
+pub struct Dwarf<R> {
+    /// The `.debug_abbrev` section.
+    pub debug_abbrev: DebugAbbrev<R>,
+
+    /// The `.debug_addr` section.
+    pub debug_addr: DebugAddr<R>,
+
+    /// The `.debug_aranges` section.
+    pub debug_aranges: DebugAranges<R>,
+
+    /// The `.debug_info` section.
+    pub debug_info: DebugInfo<R>,
+
+    /// The `.debug_line` section.
+    pub debug_line: DebugLine<R>,
+
+    /// The `.debug_line_str` section.
+    pub debug_line_str: DebugLineStr<R>,
+
+    /// The `.debug_str` section.
+    pub debug_str: DebugStr<R>,
+
+    /// The `.debug_str_offsets` section.
+    pub debug_str_offsets: DebugStrOffsets<R>,
+
+    /// The `.debug_types` section.
+    pub debug_types: DebugTypes<R>,
+
+    /// The location lists in the `.debug_loc` and `.debug_loclists` sections.
+    pub locations: LocationLists<R>,
+
+    /// The range lists in the `.debug_ranges` and `.debug_rnglists` sections.
+    pub ranges: RangeLists<R>,
+
+    /// The type of this file.
+    pub file_type: DwarfFileType,
+
+    /// The DWARF sections for a supplementary object file.
+    pub sup: Option<Arc<Dwarf<R>>>,
+
+    /// A cache of previously parsed abbreviations for units in this file.
+    pub abbreviations_cache: AbbreviationsCache,
+}
+
+impl<T> Dwarf<T> {
+    /// Try to load the DWARF sections using the given loader function.
+    ///
+    /// `section` loads a DWARF section from the object file.
+    /// It should return an empty section if the section does not exist.
+    ///
+    /// `section` may either directly return a `Reader` instance (such as
+    /// `EndianSlice`), or it may return some other type and then convert
+    /// that type into a `Reader` using `Dwarf::borrow`.
+    ///
+    /// After loading, the user should set the `file_type` field and
+    /// call `load_sup` if required.
+    pub fn load<F, E>(mut section: F) -> core::result::Result<Self, E>
+    where
+        F: FnMut(SectionId) -> core::result::Result<T, E>,
+    {
+        // Section types are inferred.
+        let debug_loc = Section::load(&mut section)?;
+        let debug_loclists = Section::load(&mut section)?;
+        let debug_ranges = Section::load(&mut section)?;
+        let debug_rnglists = Section::load(&mut section)?;
+        Ok(Dwarf {
+            debug_abbrev: Section::load(&mut section)?,
+            debug_addr: Section::load(&mut section)?,
+            debug_aranges: Section::load(&mut section)?,
+            debug_info: Section::load(&mut section)?,
+            debug_line: Section::load(&mut section)?,
+            debug_line_str: Section::load(&mut section)?,
+            debug_str: Section::load(&mut section)?,
+            debug_str_offsets: Section::load(&mut section)?,
+            debug_types: Section::load(&mut section)?,
+            locations: LocationLists::new(debug_loc, debug_loclists),
+            ranges: RangeLists::new(debug_ranges, debug_rnglists),
+            file_type: DwarfFileType::Main,
+            sup: None,
+            abbreviations_cache: AbbreviationsCache::new(),
+        })
+    }
+
+    /// Load the DWARF sections from the supplementary object file.
+    ///
+    /// `section` operates the same as for `load`.
+    ///
+    /// Sets `self.sup`, replacing any previous value.
+    pub fn load_sup<F, E>(&mut self, section: F) -> core::result::Result<(), E>
+    where
+        F: FnMut(SectionId) -> core::result::Result<T, E>,
+    {
+        self.sup = Some(Arc::new(Self::load(section)?));
+        Ok(())
+    }
+
+    /// Create a `Dwarf` structure that references the data in `self`.
+    ///
+    /// This is useful when `R` implements `Reader` but `T` does not.
+    ///
+    /// ## Example Usage
+    ///
+    /// It can be useful to load DWARF sections into owned data structures,
+    /// such as `Vec`. However, we do not implement the `Reader` trait
+    /// for `Vec`, because it would be very inefficient, but this trait
+    /// is required for all of the methods that parse the DWARF data.
+    /// So we first load the DWARF sections into `Vec`s, and then use
+    /// `borrow` to create `Reader`s that reference the data.
+    ///
+    /// ```rust,no_run
+    /// # fn example() -> Result<(), gimli::Error> {
+    /// # let loader = |name| -> Result<_, gimli::Error> { unimplemented!() };
+    /// # let sup_loader = |name| -> Result<_, gimli::Error> { unimplemented!() };
+    /// // Read the DWARF sections into `Vec`s with whatever object loader you're using.
+    /// let mut owned_dwarf: gimli::Dwarf<Vec<u8>> = gimli::Dwarf::load(loader)?;
+    /// owned_dwarf.load_sup(sup_loader)?;
+    /// // Create references to the DWARF sections.
+    /// let dwarf = owned_dwarf.borrow(|section| {
+    ///     gimli::EndianSlice::new(&section, gimli::LittleEndian)
+    /// });
+    /// # unreachable!()
+    /// # }
+    /// ```
+    pub fn borrow<'a, F, R>(&'a self, mut borrow: F) -> Dwarf<R>
+    where
+        F: FnMut(&'a T) -> R,
+    {
+        Dwarf {
+            debug_abbrev: self.debug_abbrev.borrow(&mut borrow),
+            debug_addr: self.debug_addr.borrow(&mut borrow),
+            debug_aranges: self.debug_aranges.borrow(&mut borrow),
+            debug_info: self.debug_info.borrow(&mut borrow),
+            debug_line: self.debug_line.borrow(&mut borrow),
+            debug_line_str: self.debug_line_str.borrow(&mut borrow),
+            debug_str: self.debug_str.borrow(&mut borrow),
+            debug_str_offsets: self.debug_str_offsets.borrow(&mut borrow),
+            debug_types: self.debug_types.borrow(&mut borrow),
+            locations: self.locations.borrow(&mut borrow),
+            ranges: self.ranges.borrow(&mut borrow),
+            file_type: self.file_type,
+            sup: self.sup().map(|sup| Arc::new(sup.borrow(borrow))),
+            abbreviations_cache: AbbreviationsCache::new(),
+        }
+    }
+
+    /// Return a reference to the DWARF sections for supplementary object file.
+    pub fn sup(&self) -> Option<&Dwarf<T>> {
+        self.sup.as_ref().map(Arc::as_ref)
+    }
+}
+
+impl<R: Reader> Dwarf<R> {
+    /// Parse abbreviations and store them in the cache.
+    ///
+    /// This will iterate over the units in `self.debug_info` to determine the
+    /// abbreviations offsets.
+    ///
+    /// Errors during parsing abbreviations are also stored in the cache.
+    /// Errors during iterating over the units are ignored.
+    pub fn populate_abbreviations_cache(&mut self, strategy: AbbreviationsCacheStrategy) {
+        self.abbreviations_cache
+            .populate(strategy, &self.debug_abbrev, self.debug_info.units());
+    }
+
+    /// Iterate the unit headers in the `.debug_info` section.
+    ///
+    /// Can be [used with
+    /// `FallibleIterator`](./index.html#using-with-fallibleiterator).
+    #[inline]
+    pub fn units(&self) -> DebugInfoUnitHeadersIter<R> {
+        self.debug_info.units()
+    }
+
+    /// Construct a new `Unit` from the given unit header.
+    #[inline]
+    pub fn unit(&self, header: UnitHeader<R>) -> Result<Unit<R>> {
+        Unit::new(self, header)
+    }
+
+    /// Iterate the type-unit headers in the `.debug_types` section.
+    ///
+    /// Can be [used with
+    /// `FallibleIterator`](./index.html#using-with-fallibleiterator).
+    #[inline]
+    pub fn type_units(&self) -> DebugTypesUnitHeadersIter<R> {
+        self.debug_types.units()
+    }
+
+    /// Parse the abbreviations for a compilation unit.
+    #[inline]
+    pub fn abbreviations(&self, unit: &UnitHeader<R>) -> Result<Arc<Abbreviations>> {
+        self.abbreviations_cache
+            .get(&self.debug_abbrev, unit.debug_abbrev_offset())
+    }
+
+    /// Return the string offset at the given index.
+    #[inline]
+    pub fn string_offset(
+        &self,
+        unit: &Unit<R>,
+        index: DebugStrOffsetsIndex<R::Offset>,
+    ) -> Result<DebugStrOffset<R::Offset>> {
+        self.debug_str_offsets
+            .get_str_offset(unit.header.format(), unit.str_offsets_base, index)
+    }
+
+    /// Return the string at the given offset in `.debug_str`.
+    #[inline]
+    pub fn string(&self, offset: DebugStrOffset<R::Offset>) -> Result<R> {
+        self.debug_str.get_str(offset)
+    }
+
+    /// Return the string at the given offset in `.debug_line_str`.
+    #[inline]
+    pub fn line_string(&self, offset: DebugLineStrOffset<R::Offset>) -> Result<R> {
+        self.debug_line_str.get_str(offset)
+    }
+
+    /// Return an attribute value as a string slice.
+    ///
+    /// If the attribute value is one of:
+    ///
+    /// - an inline `DW_FORM_string` string
+    /// - a `DW_FORM_strp` reference to an offset into the `.debug_str` section
+    /// - a `DW_FORM_strp_sup` reference to an offset into a supplementary
+    /// object file
+    /// - a `DW_FORM_line_strp` reference to an offset into the `.debug_line_str`
+    /// section
+    /// - a `DW_FORM_strx` index into the `.debug_str_offsets` entries for the unit
+    ///
+    /// then return the attribute's string value. Returns an error if the attribute
+    /// value does not have a string form, or if a string form has an invalid value.
+    pub fn attr_string(&self, unit: &Unit<R>, attr: AttributeValue<R>) -> Result<R> {
+        match attr {
+            AttributeValue::String(string) => Ok(string),
+            AttributeValue::DebugStrRef(offset) => self.debug_str.get_str(offset),
+            AttributeValue::DebugStrRefSup(offset) => {
+                if let Some(sup) = self.sup() {
+                    sup.debug_str.get_str(offset)
+                } else {
+                    Err(Error::ExpectedStringAttributeValue)
+                }
+            }
+            AttributeValue::DebugLineStrRef(offset) => self.debug_line_str.get_str(offset),
+            AttributeValue::DebugStrOffsetsIndex(index) => {
+                let offset = self.debug_str_offsets.get_str_offset(
+                    unit.header.format(),
+                    unit.str_offsets_base,
+                    index,
+                )?;
+                self.debug_str.get_str(offset)
+            }
+            _ => Err(Error::ExpectedStringAttributeValue),
+        }
+    }
+
+    /// Return the address at the given index.
+    pub fn address(&self, unit: &Unit<R>, index: DebugAddrIndex<R::Offset>) -> Result<u64> {
+        self.debug_addr
+            .get_address(unit.encoding().address_size, unit.addr_base, index)
+    }
+
+    /// Try to return an attribute value as an address.
+    ///
+    /// If the attribute value is one of:
+    ///
+    /// - a `DW_FORM_addr`
+    /// - a `DW_FORM_addrx` index into the `.debug_addr` entries for the unit
+    ///
+    /// then return the address.
+    /// Returns `None` for other forms.
+    pub fn attr_address(&self, unit: &Unit<R>, attr: AttributeValue<R>) -> Result<Option<u64>> {
+        match attr {
+            AttributeValue::Addr(addr) => Ok(Some(addr)),
+            AttributeValue::DebugAddrIndex(index) => self.address(unit, index).map(Some),
+            _ => Ok(None),
+        }
+    }
+
+    /// Return the range list offset for the given raw offset.
+    ///
+    /// This handles adding `DW_AT_GNU_ranges_base` if required.
+    pub fn ranges_offset_from_raw(
+        &self,
+        unit: &Unit<R>,
+        offset: RawRangeListsOffset<R::Offset>,
+    ) -> RangeListsOffset<R::Offset> {
+        if self.file_type == DwarfFileType::Dwo && unit.header.version() < 5 {
+            RangeListsOffset(offset.0.wrapping_add(unit.rnglists_base.0))
+        } else {
+            RangeListsOffset(offset.0)
+        }
+    }
+
+    /// Return the range list offset at the given index.
+    pub fn ranges_offset(
+        &self,
+        unit: &Unit<R>,
+        index: DebugRngListsIndex<R::Offset>,
+    ) -> Result<RangeListsOffset<R::Offset>> {
+        self.ranges
+            .get_offset(unit.encoding(), unit.rnglists_base, index)
+    }
+
+    /// Iterate over the `RangeListEntry`s starting at the given offset.
+    pub fn ranges(
+        &self,
+        unit: &Unit<R>,
+        offset: RangeListsOffset<R::Offset>,
+    ) -> Result<RngListIter<R>> {
+        self.ranges.ranges(
+            offset,
+            unit.encoding(),
+            unit.low_pc,
+            &self.debug_addr,
+            unit.addr_base,
+        )
+    }
+
+    /// Iterate over the `RawRngListEntry`ies starting at the given offset.
+    pub fn raw_ranges(
+        &self,
+        unit: &Unit<R>,
+        offset: RangeListsOffset<R::Offset>,
+    ) -> Result<RawRngListIter<R>> {
+        self.ranges.raw_ranges(offset, unit.encoding())
+    }
+
+    /// Try to return an attribute value as a range list offset.
+    ///
+    /// If the attribute value is one of:
+    ///
+    /// - a `DW_FORM_sec_offset` reference to the `.debug_ranges` or `.debug_rnglists` sections
+    /// - a `DW_FORM_rnglistx` index into the `.debug_rnglists` entries for the unit
+    ///
+    /// then return the range list offset of the range list.
+    /// Returns `None` for other forms.
+    pub fn attr_ranges_offset(
+        &self,
+        unit: &Unit<R>,
+        attr: AttributeValue<R>,
+    ) -> Result<Option<RangeListsOffset<R::Offset>>> {
+        match attr {
+            AttributeValue::RangeListsRef(offset) => {
+                Ok(Some(self.ranges_offset_from_raw(unit, offset)))
+            }
+            AttributeValue::DebugRngListsIndex(index) => self.ranges_offset(unit, index).map(Some),
+            _ => Ok(None),
+        }
+    }
+
+    /// Try to return an attribute value as a range list entry iterator.
+    ///
+    /// If the attribute value is one of:
+    ///
+    /// - a `DW_FORM_sec_offset` reference to the `.debug_ranges` or `.debug_rnglists` sections
+    /// - a `DW_FORM_rnglistx` index into the `.debug_rnglists` entries for the unit
+    ///
+    /// then return an iterator over the entries in the range list.
+    /// Returns `None` for other forms.
+    pub fn attr_ranges(
+        &self,
+        unit: &Unit<R>,
+        attr: AttributeValue<R>,
+    ) -> Result<Option<RngListIter<R>>> {
+        match self.attr_ranges_offset(unit, attr)? {
+            Some(offset) => Ok(Some(self.ranges(unit, offset)?)),
+            None => Ok(None),
+        }
+    }
+
+    /// Return an iterator for the address ranges of a `DebuggingInformationEntry`.
+    ///
+    /// This uses `DW_AT_low_pc`, `DW_AT_high_pc` and `DW_AT_ranges`.
+    pub fn die_ranges(
+        &self,
+        unit: &Unit<R>,
+        entry: &DebuggingInformationEntry<R>,
+    ) -> Result<RangeIter<R>> {
+        let mut low_pc = None;
+        let mut high_pc = None;
+        let mut size = None;
+        let mut attrs = entry.attrs();
+        while let Some(attr) = attrs.next()? {
+            match attr.name() {
+                constants::DW_AT_low_pc => {
+                    low_pc = Some(
+                        self.attr_address(unit, attr.value())?
+                            .ok_or(Error::UnsupportedAttributeForm)?,
+                    );
+                }
+                constants::DW_AT_high_pc => match attr.value() {
+                    AttributeValue::Udata(val) => size = Some(val),
+                    attr => {
+                        high_pc = Some(
+                            self.attr_address(unit, attr)?
+                                .ok_or(Error::UnsupportedAttributeForm)?,
+                        );
+                    }
+                },
+                constants::DW_AT_ranges => {
+                    if let Some(list) = self.attr_ranges(unit, attr.value())? {
+                        return Ok(RangeIter(RangeIterInner::List(list)));
+                    }
+                }
+                _ => {}
+            }
+        }
+        let range = low_pc.and_then(|begin| {
+            let end = size.map(|size| begin + size).or(high_pc);
+            // TODO: perhaps return an error if `end` is `None`
+            end.map(|end| Range { begin, end })
+        });
+        Ok(RangeIter(RangeIterInner::Single(range)))
+    }
+
+    /// Return an iterator for the address ranges of a `Unit`.
+    ///
+    /// This uses `DW_AT_low_pc`, `DW_AT_high_pc` and `DW_AT_ranges` of the
+    /// root `DebuggingInformationEntry`.
+    pub fn unit_ranges(&self, unit: &Unit<R>) -> Result<RangeIter<R>> {
+        let mut cursor = unit.header.entries(&unit.abbreviations);
+        cursor.next_dfs()?;
+        let root = cursor.current().ok_or(Error::MissingUnitDie)?;
+        self.die_ranges(unit, root)
+    }
+
+    /// Return the location list offset at the given index.
+    pub fn locations_offset(
+        &self,
+        unit: &Unit<R>,
+        index: DebugLocListsIndex<R::Offset>,
+    ) -> Result<LocationListsOffset<R::Offset>> {
+        self.locations
+            .get_offset(unit.encoding(), unit.loclists_base, index)
+    }
+
+    /// Iterate over the `LocationListEntry`s starting at the given offset.
+    pub fn locations(
+        &self,
+        unit: &Unit<R>,
+        offset: LocationListsOffset<R::Offset>,
+    ) -> Result<LocListIter<R>> {
+        match self.file_type {
+            DwarfFileType::Main => self.locations.locations(
+                offset,
+                unit.encoding(),
+                unit.low_pc,
+                &self.debug_addr,
+                unit.addr_base,
+            ),
+            DwarfFileType::Dwo => self.locations.locations_dwo(
+                offset,
+                unit.encoding(),
+                unit.low_pc,
+                &self.debug_addr,
+                unit.addr_base,
+            ),
+        }
+    }
+
+    /// Iterate over the raw `LocationListEntry`s starting at the given offset.
+    pub fn raw_locations(
+        &self,
+        unit: &Unit<R>,
+        offset: LocationListsOffset<R::Offset>,
+    ) -> Result<RawLocListIter<R>> {
+        match self.file_type {
+            DwarfFileType::Main => self.locations.raw_locations(offset, unit.encoding()),
+            DwarfFileType::Dwo => self.locations.raw_locations_dwo(offset, unit.encoding()),
+        }
+    }
+
+    /// Try to return an attribute value as a location list offset.
+    ///
+    /// If the attribute value is one of:
+    ///
+    /// - a `DW_FORM_sec_offset` reference to the `.debug_loc` or `.debug_loclists` sections
+    /// - a `DW_FORM_loclistx` index into the `.debug_loclists` entries for the unit
+    ///
+    /// then return the location list offset of the location list.
+    /// Returns `None` for other forms.
+    pub fn attr_locations_offset(
+        &self,
+        unit: &Unit<R>,
+        attr: AttributeValue<R>,
+    ) -> Result<Option<LocationListsOffset<R::Offset>>> {
+        match attr {
+            AttributeValue::LocationListsRef(offset) => Ok(Some(offset)),
+            AttributeValue::DebugLocListsIndex(index) => {
+                self.locations_offset(unit, index).map(Some)
+            }
+            _ => Ok(None),
+        }
+    }
+
+    /// Try to return an attribute value as a location list entry iterator.
+    ///
+    /// If the attribute value is one of:
+    ///
+    /// - a `DW_FORM_sec_offset` reference to the `.debug_loc` or `.debug_loclists` sections
+    /// - a `DW_FORM_loclistx` index into the `.debug_loclists` entries for the unit
+    ///
+    /// then return an iterator over the entries in the location list.
+    /// Returns `None` for other forms.
+    pub fn attr_locations(
+        &self,
+        unit: &Unit<R>,
+        attr: AttributeValue<R>,
+    ) -> Result<Option<LocListIter<R>>> {
+        match self.attr_locations_offset(unit, attr)? {
+            Some(offset) => Ok(Some(self.locations(unit, offset)?)),
+            None => Ok(None),
+        }
+    }
+
+    /// Call `Reader::lookup_offset_id` for each section, and return the first match.
+    ///
+    /// The first element of the tuple is `true` for supplementary sections.
+    pub fn lookup_offset_id(&self, id: ReaderOffsetId) -> Option<(bool, SectionId, R::Offset)> {
+        None.or_else(|| self.debug_abbrev.lookup_offset_id(id))
+            .or_else(|| self.debug_addr.lookup_offset_id(id))
+            .or_else(|| self.debug_aranges.lookup_offset_id(id))
+            .or_else(|| self.debug_info.lookup_offset_id(id))
+            .or_else(|| self.debug_line.lookup_offset_id(id))
+            .or_else(|| self.debug_line_str.lookup_offset_id(id))
+            .or_else(|| self.debug_str.lookup_offset_id(id))
+            .or_else(|| self.debug_str_offsets.lookup_offset_id(id))
+            .or_else(|| self.debug_types.lookup_offset_id(id))
+            .or_else(|| self.locations.lookup_offset_id(id))
+            .or_else(|| self.ranges.lookup_offset_id(id))
+            .map(|(id, offset)| (false, id, offset))
+            .or_else(|| {
+                self.sup()
+                    .and_then(|sup| sup.lookup_offset_id(id))
+                    .map(|(_, id, offset)| (true, id, offset))
+            })
+    }
+
+    /// Returns a string representation of the given error.
+    ///
+    /// This uses information from the DWARF sections to provide more information in some cases.
+    pub fn format_error(&self, err: Error) -> String {
+        #[allow(clippy::single_match)]
+        match err {
+            Error::UnexpectedEof(id) => match self.lookup_offset_id(id) {
+                Some((sup, section, offset)) => {
+                    return format!(
+                        "{} at {}{}+0x{:x}",
+                        err,
+                        section.name(),
+                        if sup { "(sup)" } else { "" },
+                        offset.into_u64(),
+                    );
+                }
+                None => {}
+            },
+            _ => {}
+        }
+        err.description().into()
+    }
+}
+
+impl<R: Clone> Dwarf<R> {
+    /// Assuming `self` was loaded from a .dwo, take the appropriate
+    /// sections from `parent` (which contains the skeleton unit for this
+    /// dwo) such as `.debug_addr` and merge them into this `Dwarf`.
+    pub fn make_dwo(&mut self, parent: &Dwarf<R>) {
+        self.file_type = DwarfFileType::Dwo;
+        // These sections are always taken from the parent file and not the dwo.
+        self.debug_addr = parent.debug_addr.clone();
+        // .debug_rnglists comes from the DWO, .debug_ranges comes from the
+        // parent file.
+        self.ranges
+            .set_debug_ranges(parent.ranges.debug_ranges().clone());
+        self.sup = parent.sup.clone();
+    }
+}
+
+/// The sections from a `.dwp` file.
+#[derive(Debug)]
+pub struct DwarfPackage<R: Reader> {
+    /// The compilation unit index in the `.debug_cu_index` section.
+    pub cu_index: UnitIndex<R>,
+
+    /// The type unit index in the `.debug_tu_index` section.
+    pub tu_index: UnitIndex<R>,
+
+    /// The `.debug_abbrev.dwo` section.
+    pub debug_abbrev: DebugAbbrev<R>,
+
+    /// The `.debug_info.dwo` section.
+    pub debug_info: DebugInfo<R>,
+
+    /// The `.debug_line.dwo` section.
+    pub debug_line: DebugLine<R>,
+
+    /// The `.debug_str.dwo` section.
+    pub debug_str: DebugStr<R>,
+
+    /// The `.debug_str_offsets.dwo` section.
+    pub debug_str_offsets: DebugStrOffsets<R>,
+
+    /// The `.debug_loc.dwo` section.
+    ///
+    /// Only present when using GNU split-dwarf extension to DWARF 4.
+    pub debug_loc: DebugLoc<R>,
+
+    /// The `.debug_loclists.dwo` section.
+    pub debug_loclists: DebugLocLists<R>,
+
+    /// The `.debug_rnglists.dwo` section.
+    pub debug_rnglists: DebugRngLists<R>,
+
+    /// The `.debug_types.dwo` section.
+    ///
+    /// Only present when using GNU split-dwarf extension to DWARF 4.
+    pub debug_types: DebugTypes<R>,
+
+    /// An empty section.
+    ///
+    /// Used when creating `Dwarf<R>`.
+    pub empty: R,
+}
+
+impl<R: Reader> DwarfPackage<R> {
+    /// Try to load the `.dwp` sections using the given loader function.
+    ///
+    /// `section` loads a DWARF section from the object file.
+    /// It should return an empty section if the section does not exist.
+    pub fn load<F, E>(mut section: F, empty: R) -> core::result::Result<Self, E>
+    where
+        F: FnMut(SectionId) -> core::result::Result<R, E>,
+        E: From<Error>,
+    {
+        Ok(DwarfPackage {
+            cu_index: DebugCuIndex::load(&mut section)?.index()?,
+            tu_index: DebugTuIndex::load(&mut section)?.index()?,
+            // Section types are inferred.
+            debug_abbrev: Section::load(&mut section)?,
+            debug_info: Section::load(&mut section)?,
+            debug_line: Section::load(&mut section)?,
+            debug_str: Section::load(&mut section)?,
+            debug_str_offsets: Section::load(&mut section)?,
+            debug_loc: Section::load(&mut section)?,
+            debug_loclists: Section::load(&mut section)?,
+            debug_rnglists: Section::load(&mut section)?,
+            debug_types: Section::load(&mut section)?,
+            empty,
+        })
+    }
+
+    /// Find the compilation unit with the given DWO identifier and return its section
+    /// contributions.
+    pub fn find_cu(&self, id: DwoId, parent: &Dwarf<R>) -> Result<Option<Dwarf<R>>> {
+        let row = match self.cu_index.find(id.0) {
+            Some(row) => row,
+            None => return Ok(None),
+        };
+        self.cu_sections(row, parent).map(Some)
+    }
+
+    /// Find the type unit with the given type signature and return its section
+    /// contributions.
+    pub fn find_tu(
+        &self,
+        signature: DebugTypeSignature,
+        parent: &Dwarf<R>,
+    ) -> Result<Option<Dwarf<R>>> {
+        let row = match self.tu_index.find(signature.0) {
+            Some(row) => row,
+            None => return Ok(None),
+        };
+        self.tu_sections(row, parent).map(Some)
+    }
+
+    /// Return the section contributions of the compilation unit at the given index.
+    ///
+    /// The index must be in the range `1..cu_index.unit_count`.
+    ///
+    /// This function should only be needed by low level parsers.
+    pub fn cu_sections(&self, index: u32, parent: &Dwarf<R>) -> Result<Dwarf<R>> {
+        self.sections(self.cu_index.sections(index)?, parent)
+    }
+
+    /// Return the section contributions of the compilation unit at the given index.
+    ///
+    /// The index must be in the range `1..tu_index.unit_count`.
+    ///
+    /// This function should only be needed by low level parsers.
+    pub fn tu_sections(&self, index: u32, parent: &Dwarf<R>) -> Result<Dwarf<R>> {
+        self.sections(self.tu_index.sections(index)?, parent)
+    }
+
+    /// Return the section contributions of a unit.
+    ///
+    /// This function should only be needed by low level parsers.
+    pub fn sections(
+        &self,
+        sections: UnitIndexSectionIterator<R>,
+        parent: &Dwarf<R>,
+    ) -> Result<Dwarf<R>> {
+        let mut abbrev_offset = 0;
+        let mut abbrev_size = 0;
+        let mut info_offset = 0;
+        let mut info_size = 0;
+        let mut line_offset = 0;
+        let mut line_size = 0;
+        let mut loc_offset = 0;
+        let mut loc_size = 0;
+        let mut loclists_offset = 0;
+        let mut loclists_size = 0;
+        let mut str_offsets_offset = 0;
+        let mut str_offsets_size = 0;
+        let mut rnglists_offset = 0;
+        let mut rnglists_size = 0;
+        let mut types_offset = 0;
+        let mut types_size = 0;
+        for section in sections {
+            match section.section {
+                SectionId::DebugAbbrev => {
+                    abbrev_offset = section.offset;
+                    abbrev_size = section.size;
+                }
+                SectionId::DebugInfo => {
+                    info_offset = section.offset;
+                    info_size = section.size;
+                }
+                SectionId::DebugLine => {
+                    line_offset = section.offset;
+                    line_size = section.size;
+                }
+                SectionId::DebugLoc => {
+                    loc_offset = section.offset;
+                    loc_size = section.size;
+                }
+                SectionId::DebugLocLists => {
+                    loclists_offset = section.offset;
+                    loclists_size = section.size;
+                }
+                SectionId::DebugStrOffsets => {
+                    str_offsets_offset = section.offset;
+                    str_offsets_size = section.size;
+                }
+                SectionId::DebugRngLists => {
+                    rnglists_offset = section.offset;
+                    rnglists_size = section.size;
+                }
+                SectionId::DebugTypes => {
+                    types_offset = section.offset;
+                    types_size = section.size;
+                }
+                SectionId::DebugMacro | SectionId::DebugMacinfo => {
+                    // These are valid but we can't parse these yet.
+                }
+                _ => return Err(Error::UnknownIndexSection),
+            }
+        }
+
+        let debug_abbrev = self.debug_abbrev.dwp_range(abbrev_offset, abbrev_size)?;
+        let debug_info = self.debug_info.dwp_range(info_offset, info_size)?;
+        let debug_line = self.debug_line.dwp_range(line_offset, line_size)?;
+        let debug_loc = self.debug_loc.dwp_range(loc_offset, loc_size)?;
+        let debug_loclists = self
+            .debug_loclists
+            .dwp_range(loclists_offset, loclists_size)?;
+        let debug_str_offsets = self
+            .debug_str_offsets
+            .dwp_range(str_offsets_offset, str_offsets_size)?;
+        let debug_rnglists = self
+            .debug_rnglists
+            .dwp_range(rnglists_offset, rnglists_size)?;
+        let debug_types = self.debug_types.dwp_range(types_offset, types_size)?;
+
+        let debug_str = self.debug_str.clone();
+
+        let debug_addr = parent.debug_addr.clone();
+        let debug_ranges = parent.ranges.debug_ranges().clone();
+
+        let debug_aranges = self.empty.clone().into();
+        let debug_line_str = self.empty.clone().into();
+
+        Ok(Dwarf {
+            debug_abbrev,
+            debug_addr,
+            debug_aranges,
+            debug_info,
+            debug_line,
+            debug_line_str,
+            debug_str,
+            debug_str_offsets,
+            debug_types,
+            locations: LocationLists::new(debug_loc, debug_loclists),
+            ranges: RangeLists::new(debug_ranges, debug_rnglists),
+            file_type: DwarfFileType::Dwo,
+            sup: parent.sup.clone(),
+            abbreviations_cache: AbbreviationsCache::new(),
+        })
+    }
+}
+
+/// All of the commonly used information for a unit in the `.debug_info` or `.debug_types`
+/// sections.
+#[derive(Debug)]
+pub struct Unit<R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    /// The header of the unit.
+    pub header: UnitHeader<R, Offset>,
+
+    /// The parsed abbreviations for the unit.
+    pub abbreviations: Arc<Abbreviations>,
+
+    /// The `DW_AT_name` attribute of the unit.
+    pub name: Option<R>,
+
+    /// The `DW_AT_comp_dir` attribute of the unit.
+    pub comp_dir: Option<R>,
+
+    /// The `DW_AT_low_pc` attribute of the unit. Defaults to 0.
+    pub low_pc: u64,
+
+    /// The `DW_AT_str_offsets_base` attribute of the unit. Defaults to 0.
+    pub str_offsets_base: DebugStrOffsetsBase<Offset>,
+
+    /// The `DW_AT_addr_base` attribute of the unit. Defaults to 0.
+    pub addr_base: DebugAddrBase<Offset>,
+
+    /// The `DW_AT_loclists_base` attribute of the unit. Defaults to 0.
+    pub loclists_base: DebugLocListsBase<Offset>,
+
+    /// The `DW_AT_rnglists_base` attribute of the unit. Defaults to 0.
+    pub rnglists_base: DebugRngListsBase<Offset>,
+
+    /// The line number program of the unit.
+    pub line_program: Option<IncompleteLineProgram<R, Offset>>,
+
+    /// The DWO ID of a skeleton unit or split compilation unit.
+    pub dwo_id: Option<DwoId>,
+}
+
+impl<R: Reader> Unit<R> {
+    /// Construct a new `Unit` from the given unit header.
+    #[inline]
+    pub fn new(dwarf: &Dwarf<R>, header: UnitHeader<R>) -> Result<Self> {
+        let abbreviations = dwarf.abbreviations(&header)?;
+        Self::new_with_abbreviations(dwarf, header, abbreviations)
+    }
+
+    /// Construct a new `Unit` from the given unit header and abbreviations.
+    ///
+    /// The abbreviations for this call can be obtained using `dwarf.abbreviations(&header)`.
+    /// The caller may implement caching to reuse the `Abbreviations` across units with the
+    /// same `header.debug_abbrev_offset()` value.
+    #[inline]
+    pub fn new_with_abbreviations(
+        dwarf: &Dwarf<R>,
+        header: UnitHeader<R>,
+        abbreviations: Arc<Abbreviations>,
+    ) -> Result<Self> {
+        let mut unit = Unit {
+            abbreviations,
+            name: None,
+            comp_dir: None,
+            low_pc: 0,
+            str_offsets_base: DebugStrOffsetsBase::default_for_encoding_and_file(
+                header.encoding(),
+                dwarf.file_type,
+            ),
+            // NB: Because the .debug_addr section never lives in a .dwo, we can assume its base is always 0 or provided.
+            addr_base: DebugAddrBase(R::Offset::from_u8(0)),
+            loclists_base: DebugLocListsBase::default_for_encoding_and_file(
+                header.encoding(),
+                dwarf.file_type,
+            ),
+            rnglists_base: DebugRngListsBase::default_for_encoding_and_file(
+                header.encoding(),
+                dwarf.file_type,
+            ),
+            line_program: None,
+            dwo_id: match header.type_() {
+                UnitType::Skeleton(dwo_id) | UnitType::SplitCompilation(dwo_id) => Some(dwo_id),
+                _ => None,
+            },
+            header,
+        };
+        let mut name = None;
+        let mut comp_dir = None;
+        let mut line_program_offset = None;
+        let mut low_pc_attr = None;
+
+        {
+            let mut cursor = unit.header.entries(&unit.abbreviations);
+            cursor.next_dfs()?;
+            let root = cursor.current().ok_or(Error::MissingUnitDie)?;
+            let mut attrs = root.attrs();
+            while let Some(attr) = attrs.next()? {
+                match attr.name() {
+                    constants::DW_AT_name => {
+                        name = Some(attr.value());
+                    }
+                    constants::DW_AT_comp_dir => {
+                        comp_dir = Some(attr.value());
+                    }
+                    constants::DW_AT_low_pc => {
+                        low_pc_attr = Some(attr.value());
+                    }
+                    constants::DW_AT_stmt_list => {
+                        if let AttributeValue::DebugLineRef(offset) = attr.value() {
+                            line_program_offset = Some(offset);
+                        }
+                    }
+                    constants::DW_AT_str_offsets_base => {
+                        if let AttributeValue::DebugStrOffsetsBase(base) = attr.value() {
+                            unit.str_offsets_base = base;
+                        }
+                    }
+                    constants::DW_AT_addr_base | constants::DW_AT_GNU_addr_base => {
+                        if let AttributeValue::DebugAddrBase(base) = attr.value() {
+                            unit.addr_base = base;
+                        }
+                    }
+                    constants::DW_AT_loclists_base => {
+                        if let AttributeValue::DebugLocListsBase(base) = attr.value() {
+                            unit.loclists_base = base;
+                        }
+                    }
+                    constants::DW_AT_rnglists_base | constants::DW_AT_GNU_ranges_base => {
+                        if let AttributeValue::DebugRngListsBase(base) = attr.value() {
+                            unit.rnglists_base = base;
+                        }
+                    }
+                    constants::DW_AT_GNU_dwo_id => {
+                        if unit.dwo_id.is_none() {
+                            if let AttributeValue::DwoId(dwo_id) = attr.value() {
+                                unit.dwo_id = Some(dwo_id);
+                            }
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        }
+
+        unit.name = match name {
+            Some(val) => dwarf.attr_string(&unit, val).ok(),
+            None => None,
+        };
+        unit.comp_dir = match comp_dir {
+            Some(val) => dwarf.attr_string(&unit, val).ok(),
+            None => None,
+        };
+        unit.line_program = match line_program_offset {
+            Some(offset) => Some(dwarf.debug_line.program(
+                offset,
+                unit.header.address_size(),
+                unit.comp_dir.clone(),
+                unit.name.clone(),
+            )?),
+            None => None,
+        };
+        if let Some(low_pc_attr) = low_pc_attr {
+            if let Some(addr) = dwarf.attr_address(&unit, low_pc_attr)? {
+                unit.low_pc = addr;
+            }
+        }
+        Ok(unit)
+    }
+
+    /// Return the encoding parameters for this unit.
+    #[inline]
+    pub fn encoding(&self) -> Encoding {
+        self.header.encoding()
+    }
+
+    /// Read the `DebuggingInformationEntry` at the given offset.
+    pub fn entry(&self, offset: UnitOffset<R::Offset>) -> Result<DebuggingInformationEntry<R>> {
+        self.header.entry(&self.abbreviations, offset)
+    }
+
+    /// Navigate this unit's `DebuggingInformationEntry`s.
+    #[inline]
+    pub fn entries(&self) -> EntriesCursor<R> {
+        self.header.entries(&self.abbreviations)
+    }
+
+    /// Navigate this unit's `DebuggingInformationEntry`s
+    /// starting at the given offset.
+    #[inline]
+    pub fn entries_at_offset(&self, offset: UnitOffset<R::Offset>) -> Result<EntriesCursor<R>> {
+        self.header.entries_at_offset(&self.abbreviations, offset)
+    }
+
+    /// Navigate this unit's `DebuggingInformationEntry`s as a tree
+    /// starting at the given offset.
+    #[inline]
+    pub fn entries_tree(&self, offset: Option<UnitOffset<R::Offset>>) -> Result<EntriesTree<R>> {
+        self.header.entries_tree(&self.abbreviations, offset)
+    }
+
+    /// Read the raw data that defines the Debugging Information Entries.
+    #[inline]
+    pub fn entries_raw(&self, offset: Option<UnitOffset<R::Offset>>) -> Result<EntriesRaw<R>> {
+        self.header.entries_raw(&self.abbreviations, offset)
+    }
+
+    /// Copy attributes that are subject to relocation from another unit. This is intended
+    /// to be used to copy attributes from a skeleton compilation unit to the corresponding
+    /// split compilation unit.
+    pub fn copy_relocated_attributes(&mut self, other: &Unit<R>) {
+        self.low_pc = other.low_pc;
+        self.addr_base = other.addr_base;
+        if self.header.version() < 5 {
+            self.rnglists_base = other.rnglists_base;
+        }
+    }
+
+    /// Find the dwo name (if any) for this unit, automatically handling the differences
+    /// between the standardized DWARF 5 split DWARF format and the pre-DWARF 5 GNU
+    /// extension.
+    ///
+    /// The returned value is relative to this unit's `comp_dir`.
+    pub fn dwo_name(&self) -> Result<Option<AttributeValue<R>>> {
+        let mut entries = self.entries();
+        if let None = entries.next_entry()? {
+            return Ok(None);
+        }
+
+        let entry = entries.current().unwrap();
+        if self.header.version() < 5 {
+            entry.attr_value(constants::DW_AT_GNU_dwo_name)
+        } else {
+            entry.attr_value(constants::DW_AT_dwo_name)
+        }
+    }
+}
+
+impl<T: ReaderOffset> UnitSectionOffset<T> {
+    /// Convert an offset to be relative to the start of the given unit,
+    /// instead of relative to the start of the section.
+    /// Returns `None` if the offset is not within the unit entries.
+    pub fn to_unit_offset<R>(&self, unit: &Unit<R>) -> Option<UnitOffset<T>>
+    where
+        R: Reader<Offset = T>,
+    {
+        let (offset, unit_offset) = match (self, unit.header.offset()) {
+            (
+                UnitSectionOffset::DebugInfoOffset(offset),
+                UnitSectionOffset::DebugInfoOffset(unit_offset),
+            ) => (offset.0, unit_offset.0),
+            (
+                UnitSectionOffset::DebugTypesOffset(offset),
+                UnitSectionOffset::DebugTypesOffset(unit_offset),
+            ) => (offset.0, unit_offset.0),
+            _ => return None,
+        };
+        let offset = match offset.checked_sub(unit_offset) {
+            Some(offset) => UnitOffset(offset),
+            None => return None,
+        };
+        if !unit.header.is_valid_offset(offset) {
+            return None;
+        }
+        Some(offset)
+    }
+}
+
+impl<T: ReaderOffset> UnitOffset<T> {
+    /// Convert an offset to be relative to the start of the .debug_info section,
+    /// instead of relative to the start of the given compilation unit.
+    ///
+    /// Does not check that the offset is valid.
+    pub fn to_unit_section_offset<R>(&self, unit: &Unit<R>) -> UnitSectionOffset<T>
+    where
+        R: Reader<Offset = T>,
+    {
+        match unit.header.offset() {
+            UnitSectionOffset::DebugInfoOffset(unit_offset) => {
+                DebugInfoOffset(unit_offset.0 + self.0).into()
+            }
+            UnitSectionOffset::DebugTypesOffset(unit_offset) => {
+                DebugTypesOffset(unit_offset.0 + self.0).into()
+            }
+        }
+    }
+}
+
+/// An iterator for the address ranges of a `DebuggingInformationEntry`.
+///
+/// Returned by `Dwarf::die_ranges` and `Dwarf::unit_ranges`.
+#[derive(Debug)]
+pub struct RangeIter<R: Reader>(RangeIterInner<R>);
+
+#[derive(Debug)]
+enum RangeIterInner<R: Reader> {
+    Single(Option<Range>),
+    List(RngListIter<R>),
+}
+
+impl<R: Reader> Default for RangeIter<R> {
+    fn default() -> Self {
+        RangeIter(RangeIterInner::Single(None))
+    }
+}
+
+impl<R: Reader> RangeIter<R> {
+    /// Advance the iterator to the next range.
+    pub fn next(&mut self) -> Result<Option<Range>> {
+        match self.0 {
+            RangeIterInner::Single(ref mut range) => Ok(range.take()),
+            RangeIterInner::List(ref mut list) => list.next(),
+        }
+    }
+}
+
+#[cfg(feature = "fallible-iterator")]
+impl<R: Reader> fallible_iterator::FallibleIterator for RangeIter<R> {
+    type Item = Range;
+    type Error = Error;
+
+    #[inline]
+    fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> {
+        RangeIter::next(self)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::read::EndianSlice;
+    use crate::{Endianity, LittleEndian};
+
+    /// Ensure that `Dwarf<R>` is covariant wrt R.
+    #[test]
+    fn test_dwarf_variance() {
+        /// This only needs to compile.
+        fn _f<'a: 'b, 'b, E: Endianity>(x: Dwarf<EndianSlice<'a, E>>) -> Dwarf<EndianSlice<'b, E>> {
+            x
+        }
+    }
+
+    /// Ensure that `Unit<R>` is covariant wrt R.
+    #[test]
+    fn test_dwarf_unit_variance() {
+        /// This only needs to compile.
+        fn _f<'a: 'b, 'b, E: Endianity>(x: Unit<EndianSlice<'a, E>>) -> Unit<EndianSlice<'b, E>> {
+            x
+        }
+    }
+
+    #[test]
+    fn test_send() {
+        fn assert_is_send<T: Send>() {}
+        assert_is_send::<Dwarf<EndianSlice<LittleEndian>>>();
+        assert_is_send::<Unit<EndianSlice<LittleEndian>>>();
+    }
+
+    #[test]
+    fn test_format_error() {
+        let mut owned_dwarf = Dwarf::load(|_| -> Result<_> { Ok(vec![1, 2]) }).unwrap();
+        owned_dwarf
+            .load_sup(|_| -> Result<_> { Ok(vec![1, 2]) })
+            .unwrap();
+        let dwarf = owned_dwarf.borrow(|section| EndianSlice::new(&section, LittleEndian));
+
+        match dwarf.debug_str.get_str(DebugStrOffset(1)) {
+            Ok(r) => panic!("Unexpected str {:?}", r),
+            Err(e) => {
+                assert_eq!(
+                    dwarf.format_error(e),
+                    "Hit the end of input before it was expected at .debug_str+0x1"
+                );
+            }
+        }
+        match dwarf.sup().unwrap().debug_str.get_str(DebugStrOffset(1)) {
+            Ok(r) => panic!("Unexpected str {:?}", r),
+            Err(e) => {
+                assert_eq!(
+                    dwarf.format_error(e),
+                    "Hit the end of input before it was expected at .debug_str(sup)+0x1"
+                );
+            }
+        }
+        assert_eq!(dwarf.format_error(Error::Io), Error::Io.description());
+    }
+}
diff --git a/vendor/gimli/src/read/endian_reader.rs b/vendor/gimli/src/read/endian_reader.rs
new file mode 100644
index 0000000..8852b38
--- /dev/null
+++ b/vendor/gimli/src/read/endian_reader.rs
@@ -0,0 +1,639 @@
+//! Defining custom `Reader`s quickly.
+
+use alloc::borrow::Cow;
+use alloc::rc::Rc;
+use alloc::string::String;
+use alloc::sync::Arc;
+use core::fmt::Debug;
+use core::ops::{Deref, Index, Range, RangeFrom, RangeTo};
+use core::slice;
+use core::str;
+use stable_deref_trait::CloneStableDeref;
+
+use crate::endianity::Endianity;
+use crate::read::{Error, Reader, ReaderOffsetId, Result};
+
+/// A reference counted, non-thread-safe slice of bytes and associated
+/// endianity.
+///
+/// ```
+/// # #[cfg(feature = "std")] {
+/// use std::rc::Rc;
+///
+/// let buf = Rc::from(&[1, 2, 3, 4][..]);
+/// let reader = gimli::EndianRcSlice::new(buf, gimli::NativeEndian);
+/// # let _ = reader;
+/// # }
+/// ```
+pub type EndianRcSlice<Endian> = EndianReader<Endian, Rc<[u8]>>;
+
+/// An atomically reference counted, thread-safe slice of bytes and associated
+/// endianity.
+///
+/// ```
+/// # #[cfg(feature = "std")] {
+/// use std::sync::Arc;
+///
+/// let buf = Arc::from(&[1, 2, 3, 4][..]);
+/// let reader = gimli::EndianArcSlice::new(buf, gimli::NativeEndian);
+/// # let _ = reader;
+/// # }
+/// ```
+pub type EndianArcSlice<Endian> = EndianReader<Endian, Arc<[u8]>>;
+
+/// An easy way to define a custom `Reader` implementation with a reference to a
+/// generic buffer of bytes and an associated endianity.
+///
+/// Note that the whole original buffer is kept alive in memory even if there is
+/// only one reader that references only a handful of bytes from that original
+/// buffer. That is, `EndianReader` will not do any copying, moving, or
+/// compacting in order to free up unused regions of the original buffer. If you
+/// require this kind of behavior, it is up to you to implement `Reader`
+/// directly by-hand.
+///
+/// # Example
+///
+/// Say you have an `mmap`ed file that you want to serve as a `gimli::Reader`.
+/// You can wrap that `mmap`ed file up in a `MmapFile` type and use
+/// `EndianReader<Rc<MmapFile>>` or `EndianReader<Arc<MmapFile>>` as readers as
+/// long as `MmapFile` dereferences to the underlying `[u8]` data.
+///
+/// ```
+/// use std::io;
+/// use std::ops::Deref;
+/// use std::path::Path;
+/// use std::slice;
+/// use std::sync::Arc;
+///
+/// /// A type that represents an `mmap`ed file.
+/// #[derive(Debug)]
+/// pub struct MmapFile {
+///     ptr: *const u8,
+///     len: usize,
+/// }
+///
+/// impl MmapFile {
+///     pub fn new(path: &Path) -> io::Result<MmapFile> {
+///         // Call `mmap` and check for errors and all that...
+/// #       unimplemented!()
+///     }
+/// }
+///
+/// impl Drop for MmapFile {
+///     fn drop(&mut self) {
+///         // Call `munmap` to clean up after ourselves...
+/// #       unimplemented!()
+///     }
+/// }
+///
+/// // And `MmapFile` can deref to a slice of the `mmap`ed region of memory.
+/// impl Deref for MmapFile {
+///     type Target = [u8];
+///     fn deref(&self) -> &[u8] {
+///         unsafe {
+///             slice::from_raw_parts(self.ptr, self.len)
+///         }
+///     }
+/// }
+///
+/// /// A type that represents a shared `mmap`ed file.
+/// #[derive(Debug, Clone)]
+/// pub struct ArcMmapFile(Arc<MmapFile>);
+///
+/// // And `ArcMmapFile` can deref to a slice of the `mmap`ed region of memory.
+/// impl Deref for ArcMmapFile {
+///     type Target = [u8];
+///     fn deref(&self) -> &[u8] {
+///         &self.0
+///     }
+/// }
+///
+/// // These are both valid for any `Rc` or `Arc`.
+/// unsafe impl gimli::StableDeref for ArcMmapFile {}
+/// unsafe impl gimli::CloneStableDeref for ArcMmapFile {}
+///
+/// /// A `gimli::Reader` that is backed by an `mmap`ed file!
+/// pub type MmapFileReader<Endian> = gimli::EndianReader<Endian, ArcMmapFile>;
+/// # fn test(_: &MmapFileReader<gimli::NativeEndian>) { }
+/// ```
+#[derive(Debug, Clone, Copy, Hash)]
+pub struct EndianReader<Endian, T>
+where
+    Endian: Endianity,
+    T: CloneStableDeref<Target = [u8]> + Debug,
+{
+    range: SubRange<T>,
+    endian: Endian,
+}
+
+impl<Endian, T1, T2> PartialEq<EndianReader<Endian, T2>> for EndianReader<Endian, T1>
+where
+    Endian: Endianity,
+    T1: CloneStableDeref<Target = [u8]> + Debug,
+    T2: CloneStableDeref<Target = [u8]> + Debug,
+{
+    fn eq(&self, rhs: &EndianReader<Endian, T2>) -> bool {
+        self.bytes() == rhs.bytes()
+    }
+}
+
+impl<Endian, T> Eq for EndianReader<Endian, T>
+where
+    Endian: Endianity,
+    T: CloneStableDeref<Target = [u8]> + Debug,
+{
+}
+
+// This is separated out from `EndianReader` so that we can avoid running afoul
+// of borrowck. We need to `read_slice(&mut self, ...) -> &[u8]` and then call
+// `self.endian.read_whatever` on the result. The problem is that the returned
+// slice keeps the `&mut self` borrow active, so we wouldn't be able to access
+// `self.endian`. Splitting the sub-range out from the endian lets us work
+// around this, making it so that only the `self.range` borrow is held active,
+// not all of `self`.
+//
+// This also serves to encapsulate the unsafe code concerning `CloneStableDeref`.
+// The `bytes` member is held so that the bytes live long enough, and the
+// `CloneStableDeref` ensures these bytes never move.  The `ptr` and `len`
+// members point inside `bytes`, and are updated during read operations.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+struct SubRange<T>
+where
+    T: CloneStableDeref<Target = [u8]> + Debug,
+{
+    bytes: T,
+    ptr: *const u8,
+    len: usize,
+}
+
+unsafe impl<T> Send for SubRange<T> where T: CloneStableDeref<Target = [u8]> + Debug + Send {}
+
+unsafe impl<T> Sync for SubRange<T> where T: CloneStableDeref<Target = [u8]> + Debug + Sync {}
+
+impl<T> SubRange<T>
+where
+    T: CloneStableDeref<Target = [u8]> + Debug,
+{
+    #[inline]
+    fn new(bytes: T) -> Self {
+        let ptr = bytes.as_ptr();
+        let len = bytes.len();
+        SubRange { bytes, ptr, len }
+    }
+
+    #[inline]
+    fn bytes(&self) -> &[u8] {
+        // Safe because `T` implements `CloneStableDeref`, `bytes` can't be modified,
+        // and all operations that modify `ptr` and `len` ensure they stay in range.
+        unsafe { slice::from_raw_parts(self.ptr, self.len) }
+    }
+
+    #[inline]
+    fn len(&self) -> usize {
+        self.len
+    }
+
+    #[inline]
+    fn truncate(&mut self, len: usize) {
+        assert!(len <= self.len);
+        self.len = len;
+    }
+
+    #[inline]
+    fn skip(&mut self, len: usize) {
+        assert!(len <= self.len);
+        self.ptr = unsafe { self.ptr.add(len) };
+        self.len -= len;
+    }
+
+    #[inline]
+    fn read_slice(&mut self, len: usize) -> Option<&[u8]> {
+        if self.len() < len {
+            None
+        } else {
+            // Same as for `bytes()`.
+            let bytes = unsafe { slice::from_raw_parts(self.ptr, len) };
+            self.skip(len);
+            Some(bytes)
+        }
+    }
+}
+
+impl<Endian, T> EndianReader<Endian, T>
+where
+    Endian: Endianity,
+    T: CloneStableDeref<Target = [u8]> + Debug,
+{
+    /// Construct a new `EndianReader` with the given bytes.
+    #[inline]
+    pub fn new(bytes: T, endian: Endian) -> EndianReader<Endian, T> {
+        EndianReader {
+            range: SubRange::new(bytes),
+            endian,
+        }
+    }
+
+    /// Return a reference to the raw bytes underlying this reader.
+    #[inline]
+    pub fn bytes(&self) -> &[u8] {
+        self.range.bytes()
+    }
+}
+
+/// # Range Methods
+///
+/// Unfortunately, `std::ops::Index` *must* return a reference, so we can't
+/// implement `Index<Range<usize>>` to return a new `EndianReader` the way we
+/// would like to. Instead, we abandon fancy indexing operators and have these
+/// plain old methods.
+impl<Endian, T> EndianReader<Endian, T>
+where
+    Endian: Endianity,
+    T: CloneStableDeref<Target = [u8]> + Debug,
+{
+    /// Take the given `start..end` range of the underlying buffer and return a
+    /// new `EndianReader`.
+    ///
+    /// ```
+    /// # #[cfg(feature = "std")] {
+    /// use gimli::{EndianReader, LittleEndian};
+    /// use std::sync::Arc;
+    ///
+    /// let buf = Arc::<[u8]>::from(&[0x01, 0x02, 0x03, 0x04][..]);
+    /// let reader = EndianReader::new(buf.clone(), LittleEndian);
+    /// assert_eq!(reader.range(1..3),
+    ///            EndianReader::new(&buf[1..3], LittleEndian));
+    /// # }
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// Panics if the range is out of bounds.
+    pub fn range(&self, idx: Range<usize>) -> EndianReader<Endian, T> {
+        let mut r = self.clone();
+        r.range.skip(idx.start);
+        r.range.truncate(idx.len());
+        r
+    }
+
+    /// Take the given `start..` range of the underlying buffer and return a new
+    /// `EndianReader`.
+    ///
+    /// ```
+    /// # #[cfg(feature = "std")] {
+    /// use gimli::{EndianReader, LittleEndian};
+    /// use std::sync::Arc;
+    ///
+    /// let buf = Arc::<[u8]>::from(&[0x01, 0x02, 0x03, 0x04][..]);
+    /// let reader = EndianReader::new(buf.clone(), LittleEndian);
+    /// assert_eq!(reader.range_from(2..),
+    ///            EndianReader::new(&buf[2..], LittleEndian));
+    /// # }
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// Panics if the range is out of bounds.
+    pub fn range_from(&self, idx: RangeFrom<usize>) -> EndianReader<Endian, T> {
+        let mut r = self.clone();
+        r.range.skip(idx.start);
+        r
+    }
+
+    /// Take the given `..end` range of the underlying buffer and return a new
+    /// `EndianReader`.
+    ///
+    /// ```
+    /// # #[cfg(feature = "std")] {
+    /// use gimli::{EndianReader, LittleEndian};
+    /// use std::sync::Arc;
+    ///
+    /// let buf = Arc::<[u8]>::from(&[0x01, 0x02, 0x03, 0x04][..]);
+    /// let reader = EndianReader::new(buf.clone(), LittleEndian);
+    /// assert_eq!(reader.range_to(..3),
+    ///            EndianReader::new(&buf[..3], LittleEndian));
+    /// # }
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// Panics if the range is out of bounds.
+    pub fn range_to(&self, idx: RangeTo<usize>) -> EndianReader<Endian, T> {
+        let mut r = self.clone();
+        r.range.truncate(idx.end);
+        r
+    }
+}
+
+impl<Endian, T> Index<usize> for EndianReader<Endian, T>
+where
+    Endian: Endianity,
+    T: CloneStableDeref<Target = [u8]> + Debug,
+{
+    type Output = u8;
+    fn index(&self, idx: usize) -> &Self::Output {
+        &self.bytes()[idx]
+    }
+}
+
+impl<Endian, T> Index<RangeFrom<usize>> for EndianReader<Endian, T>
+where
+    Endian: Endianity,
+    T: CloneStableDeref<Target = [u8]> + Debug,
+{
+    type Output = [u8];
+    fn index(&self, idx: RangeFrom<usize>) -> &Self::Output {
+        &self.bytes()[idx]
+    }
+}
+
+impl<Endian, T> Deref for EndianReader<Endian, T>
+where
+    Endian: Endianity,
+    T: CloneStableDeref<Target = [u8]> + Debug,
+{
+    type Target = [u8];
+    fn deref(&self) -> &Self::Target {
+        self.bytes()
+    }
+}
+
+impl<Endian, T> Reader for EndianReader<Endian, T>
+where
+    Endian: Endianity,
+    T: CloneStableDeref<Target = [u8]> + Debug,
+{
+    type Endian = Endian;
+    type Offset = usize;
+
+    #[inline]
+    fn endian(&self) -> Endian {
+        self.endian
+    }
+
+    #[inline]
+    fn len(&self) -> usize {
+        self.range.len()
+    }
+
+    #[inline]
+    fn empty(&mut self) {
+        self.range.truncate(0);
+    }
+
+    #[inline]
+    fn truncate(&mut self, len: usize) -> Result<()> {
+        if self.len() < len {
+            Err(Error::UnexpectedEof(self.offset_id()))
+        } else {
+            self.range.truncate(len);
+            Ok(())
+        }
+    }
+
+    #[inline]
+    fn offset_from(&self, base: &EndianReader<Endian, T>) -> usize {
+        let base_ptr = base.bytes().as_ptr() as *const u8 as usize;
+        let ptr = self.bytes().as_ptr() as *const u8 as usize;
+        debug_assert!(base_ptr <= ptr);
+        debug_assert!(ptr + self.bytes().len() <= base_ptr + base.bytes().len());
+        ptr - base_ptr
+    }
+
+    #[inline]
+    fn offset_id(&self) -> ReaderOffsetId {
+        ReaderOffsetId(self.bytes().as_ptr() as u64)
+    }
+
+    #[inline]
+    fn lookup_offset_id(&self, id: ReaderOffsetId) -> Option<Self::Offset> {
+        let id = id.0;
+        let self_id = self.bytes().as_ptr() as u64;
+        let self_len = self.bytes().len() as u64;
+        if id >= self_id && id <= self_id + self_len {
+            Some((id - self_id) as usize)
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    fn find(&self, byte: u8) -> Result<usize> {
+        self.bytes()
+            .iter()
+            .position(|x| *x == byte)
+            .ok_or_else(|| Error::UnexpectedEof(self.offset_id()))
+    }
+
+    #[inline]
+    fn skip(&mut self, len: usize) -> Result<()> {
+        if self.len() < len {
+            Err(Error::UnexpectedEof(self.offset_id()))
+        } else {
+            self.range.skip(len);
+            Ok(())
+        }
+    }
+
+    #[inline]
+    fn split(&mut self, len: usize) -> Result<Self> {
+        if self.len() < len {
+            Err(Error::UnexpectedEof(self.offset_id()))
+        } else {
+            let mut r = self.clone();
+            r.range.truncate(len);
+            self.range.skip(len);
+            Ok(r)
+        }
+    }
+
+    #[inline]
+    fn to_slice(&self) -> Result<Cow<[u8]>> {
+        Ok(self.bytes().into())
+    }
+
+    #[inline]
+    fn to_string(&self) -> Result<Cow<str>> {
+        match str::from_utf8(self.bytes()) {
+            Ok(s) => Ok(s.into()),
+            _ => Err(Error::BadUtf8),
+        }
+    }
+
+    #[inline]
+    fn to_string_lossy(&self) -> Result<Cow<str>> {
+        Ok(String::from_utf8_lossy(self.bytes()))
+    }
+
+    #[inline]
+    fn read_slice(&mut self, buf: &mut [u8]) -> Result<()> {
+        match self.range.read_slice(buf.len()) {
+            Some(slice) => {
+                buf.copy_from_slice(slice);
+                Ok(())
+            }
+            None => Err(Error::UnexpectedEof(self.offset_id())),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::endianity::NativeEndian;
+    use crate::read::Reader;
+
+    fn native_reader<T: CloneStableDeref<Target = [u8]> + Debug>(
+        bytes: T,
+    ) -> EndianReader<NativeEndian, T> {
+        EndianReader::new(bytes, NativeEndian)
+    }
+
+    const BUF: &[u8] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
+
+    #[test]
+    fn test_reader_split() {
+        let mut reader = native_reader(BUF);
+        let left = reader.split(3).unwrap();
+        assert_eq!(left, native_reader(&BUF[..3]));
+        assert_eq!(reader, native_reader(&BUF[3..]));
+    }
+
+    #[test]
+    fn test_reader_split_out_of_bounds() {
+        let mut reader = native_reader(BUF);
+        assert!(reader.split(30).is_err());
+    }
+
+    #[test]
+    fn bytes_and_len_and_range_and_eq() {
+        let reader = native_reader(BUF);
+        assert_eq!(reader.len(), BUF.len());
+        assert_eq!(reader.bytes(), BUF);
+        assert_eq!(reader, native_reader(BUF));
+
+        let range = reader.range(2..8);
+        let buf_range = &BUF[2..8];
+        assert_eq!(range.len(), buf_range.len());
+        assert_eq!(range.bytes(), buf_range);
+        assert_ne!(range, native_reader(BUF));
+        assert_eq!(range, native_reader(buf_range));
+
+        let range_from = range.range_from(1..);
+        let buf_range_from = &buf_range[1..];
+        assert_eq!(range_from.len(), buf_range_from.len());
+        assert_eq!(range_from.bytes(), buf_range_from);
+        assert_ne!(range_from, native_reader(BUF));
+        assert_eq!(range_from, native_reader(buf_range_from));
+
+        let range_to = range_from.range_to(..4);
+        let buf_range_to = &buf_range_from[..4];
+        assert_eq!(range_to.len(), buf_range_to.len());
+        assert_eq!(range_to.bytes(), buf_range_to);
+        assert_ne!(range_to, native_reader(BUF));
+        assert_eq!(range_to, native_reader(buf_range_to));
+    }
+
+    #[test]
+    fn find() {
+        let mut reader = native_reader(BUF);
+        reader.skip(2).unwrap();
+        assert_eq!(
+            reader.find(5),
+            Ok(BUF[2..].iter().position(|x| *x == 5).unwrap())
+        );
+    }
+
+    #[test]
+    fn indexing() {
+        let mut reader = native_reader(BUF);
+        reader.skip(2).unwrap();
+        assert_eq!(reader[0], BUF[2]);
+    }
+
+    #[test]
+    #[should_panic]
+    fn indexing_out_of_bounds() {
+        let mut reader = native_reader(BUF);
+        reader.skip(2).unwrap();
+        let _ = reader[900];
+    }
+
+    #[test]
+    fn endian() {
+        let reader = native_reader(BUF);
+        assert_eq!(reader.endian(), NativeEndian);
+    }
+
+    #[test]
+    fn empty() {
+        let mut reader = native_reader(BUF);
+        assert!(!reader.is_empty());
+        reader.empty();
+        assert!(reader.is_empty());
+        assert!(reader.bytes().is_empty());
+    }
+
+    #[test]
+    fn truncate() {
+        let reader = native_reader(BUF);
+        let mut reader = reader.range(2..8);
+        reader.truncate(2).unwrap();
+        assert_eq!(reader.bytes(), &BUF[2..4]);
+    }
+
+    #[test]
+    fn offset_from() {
+        let reader = native_reader(BUF);
+        let sub = reader.range(2..8);
+        assert_eq!(sub.offset_from(&reader), 2);
+    }
+
+    #[test]
+    fn skip() {
+        let mut reader = native_reader(BUF);
+        reader.skip(2).unwrap();
+        assert_eq!(reader.bytes(), &BUF[2..]);
+    }
+
+    #[test]
+    fn to_slice() {
+        assert_eq!(
+            native_reader(BUF).range(2..5).to_slice(),
+            Ok(Cow::from(&BUF[2..5]))
+        );
+    }
+
+    #[test]
+    fn to_string_ok() {
+        let buf = b"hello, world!";
+        let reader = native_reader(&buf[..]);
+        let reader = reader.range_from(7..);
+        assert_eq!(reader.to_string(), Ok(Cow::from("world!")));
+    }
+
+    // The rocket emoji (🚀 = [0xf0, 0x9f, 0x9a, 0x80]) but rotated left by one
+    // to make it invalid UTF-8.
+    const BAD_UTF8: &[u8] = &[0x9f, 0x9a, 0x80, 0xf0];
+
+    #[test]
+    fn to_string_err() {
+        let reader = native_reader(BAD_UTF8);
+        assert!(reader.to_string().is_err());
+    }
+
+    #[test]
+    fn to_string_lossy() {
+        let reader = native_reader(BAD_UTF8);
+        assert_eq!(reader.to_string_lossy(), Ok(Cow::from("����")));
+    }
+
+    #[test]
+    fn read_u8_array() {
+        let mut reader = native_reader(BAD_UTF8);
+        reader.skip(1).unwrap();
+        let arr: [u8; 2] = reader.read_u8_array().unwrap();
+        assert_eq!(arr, &BAD_UTF8[1..3]);
+        assert_eq!(reader.bytes(), &BAD_UTF8[3..]);
+    }
+}
diff --git a/vendor/gimli/src/read/endian_slice.rs b/vendor/gimli/src/read/endian_slice.rs
new file mode 100644
index 0000000..0db28da
--- /dev/null
+++ b/vendor/gimli/src/read/endian_slice.rs
@@ -0,0 +1,360 @@
+//! Working with byte slices that have an associated endianity.
+
+#[cfg(feature = "read")]
+use alloc::borrow::Cow;
+#[cfg(feature = "read")]
+use alloc::string::String;
+use core::fmt;
+use core::ops::{Deref, Range, RangeFrom, RangeTo};
+use core::str;
+
+use crate::endianity::Endianity;
+use crate::read::{Error, Reader, ReaderOffsetId, Result};
+
+/// A `&[u8]` slice with endianity metadata.
+///
+/// This implements the `Reader` trait, which is used for all reading of DWARF sections.
+#[derive(Default, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct EndianSlice<'input, Endian>
+where
+    Endian: Endianity,
+{
+    slice: &'input [u8],
+    endian: Endian,
+}
+
+impl<'input, Endian> EndianSlice<'input, Endian>
+where
+    Endian: Endianity,
+{
+    /// Construct a new `EndianSlice` with the given slice and endianity.
+    #[inline]
+    pub fn new(slice: &'input [u8], endian: Endian) -> EndianSlice<'input, Endian> {
+        EndianSlice { slice, endian }
+    }
+
+    /// Return a reference to the raw slice.
+    #[inline]
+    #[doc(hidden)]
+    #[deprecated(note = "Method renamed to EndianSlice::slice; use that instead.")]
+    pub fn buf(&self) -> &'input [u8] {
+        self.slice
+    }
+
+    /// Return a reference to the raw slice.
+    #[inline]
+    pub fn slice(&self) -> &'input [u8] {
+        self.slice
+    }
+
+    /// Split the slice in two at the given index, resulting in the tuple where
+    /// the first item has range [0, idx), and the second has range [idx,
+    /// len). Panics if the index is out of bounds.
+    #[inline]
+    pub fn split_at(
+        &self,
+        idx: usize,
+    ) -> (EndianSlice<'input, Endian>, EndianSlice<'input, Endian>) {
+        (self.range_to(..idx), self.range_from(idx..))
+    }
+
+    /// Find the first occurrence of a byte in the slice, and return its index.
+    #[inline]
+    pub fn find(&self, byte: u8) -> Option<usize> {
+        self.slice.iter().position(|ch| *ch == byte)
+    }
+
+    /// Return the offset of the start of the slice relative to the start
+    /// of the given slice.
+    #[inline]
+    pub fn offset_from(&self, base: EndianSlice<'input, Endian>) -> usize {
+        let base_ptr = base.slice.as_ptr() as *const u8 as usize;
+        let ptr = self.slice.as_ptr() as *const u8 as usize;
+        debug_assert!(base_ptr <= ptr);
+        debug_assert!(ptr + self.slice.len() <= base_ptr + base.slice.len());
+        ptr - base_ptr
+    }
+
+    /// Converts the slice to a string using `str::from_utf8`.
+    ///
+    /// Returns an error if the slice contains invalid characters.
+    #[inline]
+    pub fn to_string(&self) -> Result<&'input str> {
+        str::from_utf8(self.slice).map_err(|_| Error::BadUtf8)
+    }
+
+    /// Converts the slice to a string, including invalid characters,
+    /// using `String::from_utf8_lossy`.
+    #[cfg(feature = "read")]
+    #[inline]
+    pub fn to_string_lossy(&self) -> Cow<'input, str> {
+        String::from_utf8_lossy(self.slice)
+    }
+
+    #[inline]
+    fn read_slice(&mut self, len: usize) -> Result<&'input [u8]> {
+        if self.slice.len() < len {
+            Err(Error::UnexpectedEof(self.offset_id()))
+        } else {
+            let val = &self.slice[..len];
+            self.slice = &self.slice[len..];
+            Ok(val)
+        }
+    }
+}
+
+/// # Range Methods
+///
+/// Unfortunately, `std::ops::Index` *must* return a reference, so we can't
+/// implement `Index<Range<usize>>` to return a new `EndianSlice` the way we would
+/// like to. Instead, we abandon fancy indexing operators and have these plain
+/// old methods.
+impl<'input, Endian> EndianSlice<'input, Endian>
+where
+    Endian: Endianity,
+{
+    /// Take the given `start..end` range of the underlying slice and return a
+    /// new `EndianSlice`.
+    ///
+    /// ```
+    /// use gimli::{EndianSlice, LittleEndian};
+    ///
+    /// let slice = &[0x01, 0x02, 0x03, 0x04];
+    /// let endian_slice = EndianSlice::new(slice, LittleEndian);
+    /// assert_eq!(endian_slice.range(1..3),
+    ///            EndianSlice::new(&slice[1..3], LittleEndian));
+    /// ```
+    pub fn range(&self, idx: Range<usize>) -> EndianSlice<'input, Endian> {
+        EndianSlice {
+            slice: &self.slice[idx],
+            endian: self.endian,
+        }
+    }
+
+    /// Take the given `start..` range of the underlying slice and return a new
+    /// `EndianSlice`.
+    ///
+    /// ```
+    /// use gimli::{EndianSlice, LittleEndian};
+    ///
+    /// let slice = &[0x01, 0x02, 0x03, 0x04];
+    /// let endian_slice = EndianSlice::new(slice, LittleEndian);
+    /// assert_eq!(endian_slice.range_from(2..),
+    ///            EndianSlice::new(&slice[2..], LittleEndian));
+    /// ```
+    pub fn range_from(&self, idx: RangeFrom<usize>) -> EndianSlice<'input, Endian> {
+        EndianSlice {
+            slice: &self.slice[idx],
+            endian: self.endian,
+        }
+    }
+
+    /// Take the given `..end` range of the underlying slice and return a new
+    /// `EndianSlice`.
+    ///
+    /// ```
+    /// use gimli::{EndianSlice, LittleEndian};
+    ///
+    /// let slice = &[0x01, 0x02, 0x03, 0x04];
+    /// let endian_slice = EndianSlice::new(slice, LittleEndian);
+    /// assert_eq!(endian_slice.range_to(..3),
+    ///            EndianSlice::new(&slice[..3], LittleEndian));
+    /// ```
+    pub fn range_to(&self, idx: RangeTo<usize>) -> EndianSlice<'input, Endian> {
+        EndianSlice {
+            slice: &self.slice[idx],
+            endian: self.endian,
+        }
+    }
+}
+
+impl<'input, Endian> Deref for EndianSlice<'input, Endian>
+where
+    Endian: Endianity,
+{
+    type Target = [u8];
+    fn deref(&self) -> &Self::Target {
+        self.slice
+    }
+}
+
+impl<'input, Endian: Endianity> fmt::Debug for EndianSlice<'input, Endian> {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> core::result::Result<(), fmt::Error> {
+        fmt.debug_tuple("EndianSlice")
+            .field(&self.endian)
+            .field(&DebugBytes(self.slice))
+            .finish()
+    }
+}
+
+struct DebugBytes<'input>(&'input [u8]);
+
+impl<'input> core::fmt::Debug for DebugBytes<'input> {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> core::result::Result<(), fmt::Error> {
+        let mut list = fmt.debug_list();
+        list.entries(self.0.iter().take(8).copied().map(DebugByte));
+        if self.0.len() > 8 {
+            list.entry(&DebugLen(self.0.len()));
+        }
+        list.finish()
+    }
+}
+
+struct DebugByte(u8);
+
+impl fmt::Debug for DebugByte {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(fmt, "0x{:02x}", self.0)
+    }
+}
+
+struct DebugLen(usize);
+
+impl fmt::Debug for DebugLen {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(fmt, "...; {}", self.0)
+    }
+}
+
+impl<'input, Endian> Reader for EndianSlice<'input, Endian>
+where
+    Endian: Endianity,
+{
+    type Endian = Endian;
+    type Offset = usize;
+
+    #[inline]
+    fn endian(&self) -> Endian {
+        self.endian
+    }
+
+    #[inline]
+    fn len(&self) -> usize {
+        self.slice.len()
+    }
+
+    #[inline]
+    fn is_empty(&self) -> bool {
+        self.slice.is_empty()
+    }
+
+    #[inline]
+    fn empty(&mut self) {
+        self.slice = &[];
+    }
+
+    #[inline]
+    fn truncate(&mut self, len: usize) -> Result<()> {
+        if self.slice.len() < len {
+            Err(Error::UnexpectedEof(self.offset_id()))
+        } else {
+            self.slice = &self.slice[..len];
+            Ok(())
+        }
+    }
+
+    #[inline]
+    fn offset_from(&self, base: &Self) -> usize {
+        self.offset_from(*base)
+    }
+
+    #[inline]
+    fn offset_id(&self) -> ReaderOffsetId {
+        ReaderOffsetId(self.slice.as_ptr() as u64)
+    }
+
+    #[inline]
+    fn lookup_offset_id(&self, id: ReaderOffsetId) -> Option<Self::Offset> {
+        let id = id.0;
+        let self_id = self.slice.as_ptr() as u64;
+        let self_len = self.slice.len() as u64;
+        if id >= self_id && id <= self_id + self_len {
+            Some((id - self_id) as usize)
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    fn find(&self, byte: u8) -> Result<usize> {
+        self.find(byte)
+            .ok_or_else(|| Error::UnexpectedEof(self.offset_id()))
+    }
+
+    #[inline]
+    fn skip(&mut self, len: usize) -> Result<()> {
+        if self.slice.len() < len {
+            Err(Error::UnexpectedEof(self.offset_id()))
+        } else {
+            self.slice = &self.slice[len..];
+            Ok(())
+        }
+    }
+
+    #[inline]
+    fn split(&mut self, len: usize) -> Result<Self> {
+        let slice = self.read_slice(len)?;
+        Ok(EndianSlice::new(slice, self.endian))
+    }
+
+    #[cfg(not(feature = "read"))]
+    fn cannot_implement() -> super::reader::seal_if_no_alloc::Sealed {
+        super::reader::seal_if_no_alloc::Sealed
+    }
+
+    #[cfg(feature = "read")]
+    #[inline]
+    fn to_slice(&self) -> Result<Cow<[u8]>> {
+        Ok(self.slice.into())
+    }
+
+    #[cfg(feature = "read")]
+    #[inline]
+    fn to_string(&self) -> Result<Cow<str>> {
+        match str::from_utf8(self.slice) {
+            Ok(s) => Ok(s.into()),
+            _ => Err(Error::BadUtf8),
+        }
+    }
+
+    #[cfg(feature = "read")]
+    #[inline]
+    fn to_string_lossy(&self) -> Result<Cow<str>> {
+        Ok(String::from_utf8_lossy(self.slice))
+    }
+
+    #[inline]
+    fn read_slice(&mut self, buf: &mut [u8]) -> Result<()> {
+        let slice = self.read_slice(buf.len())?;
+        buf.copy_from_slice(slice);
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::endianity::NativeEndian;
+
+    #[test]
+    fn test_endian_slice_split_at() {
+        let endian = NativeEndian;
+        let slice = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
+        let eb = EndianSlice::new(slice, endian);
+        assert_eq!(
+            eb.split_at(3),
+            (
+                EndianSlice::new(&slice[..3], endian),
+                EndianSlice::new(&slice[3..], endian)
+            )
+        );
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_endian_slice_split_at_out_of_bounds() {
+        let slice = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
+        let eb = EndianSlice::new(slice, NativeEndian);
+        eb.split_at(30);
+    }
+}
diff --git a/vendor/gimli/src/read/index.rs b/vendor/gimli/src/read/index.rs
new file mode 100644
index 0000000..129eb2f
--- /dev/null
+++ b/vendor/gimli/src/read/index.rs
@@ -0,0 +1,535 @@
+use core::slice;
+
+use crate::common::SectionId;
+use crate::constants;
+use crate::endianity::Endianity;
+use crate::read::{EndianSlice, Error, Reader, ReaderOffset, Result, Section};
+
+/// The data in the `.debug_cu_index` section of a `.dwp` file.
+///
+/// This section contains the compilation unit index.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct DebugCuIndex<R> {
+    section: R,
+}
+
+impl<'input, Endian> DebugCuIndex<EndianSlice<'input, Endian>>
+where
+    Endian: Endianity,
+{
+    /// Construct a new `DebugCuIndex` instance from the data in the `.debug_cu_index`
+    /// section.
+    pub fn new(section: &'input [u8], endian: Endian) -> Self {
+        Self::from(EndianSlice::new(section, endian))
+    }
+}
+
+impl<R> Section<R> for DebugCuIndex<R> {
+    fn id() -> SectionId {
+        SectionId::DebugCuIndex
+    }
+
+    fn reader(&self) -> &R {
+        &self.section
+    }
+}
+
+impl<R> From<R> for DebugCuIndex<R> {
+    fn from(section: R) -> Self {
+        DebugCuIndex { section }
+    }
+}
+
+impl<R: Reader> DebugCuIndex<R> {
+    /// Parse the index header.
+    pub fn index(self) -> Result<UnitIndex<R>> {
+        UnitIndex::parse(self.section)
+    }
+}
+
+/// The data in the `.debug_tu_index` section of a `.dwp` file.
+///
+/// This section contains the type unit index.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct DebugTuIndex<R> {
+    section: R,
+}
+
+impl<'input, Endian> DebugTuIndex<EndianSlice<'input, Endian>>
+where
+    Endian: Endianity,
+{
+    /// Construct a new `DebugTuIndex` instance from the data in the `.debug_tu_index`
+    /// section.
+    pub fn new(section: &'input [u8], endian: Endian) -> Self {
+        Self::from(EndianSlice::new(section, endian))
+    }
+}
+
+impl<R> Section<R> for DebugTuIndex<R> {
+    fn id() -> SectionId {
+        SectionId::DebugTuIndex
+    }
+
+    fn reader(&self) -> &R {
+        &self.section
+    }
+}
+
+impl<R> From<R> for DebugTuIndex<R> {
+    fn from(section: R) -> Self {
+        DebugTuIndex { section }
+    }
+}
+
+impl<R: Reader> DebugTuIndex<R> {
+    /// Parse the index header.
+    pub fn index(self) -> Result<UnitIndex<R>> {
+        UnitIndex::parse(self.section)
+    }
+}
+
+const SECTION_COUNT_MAX: u8 = 8;
+
+/// The partially parsed index from a `DebugCuIndex` or `DebugTuIndex`.
+#[derive(Debug, Clone)]
+pub struct UnitIndex<R: Reader> {
+    version: u16,
+    section_count: u32,
+    unit_count: u32,
+    slot_count: u32,
+    hash_ids: R,
+    hash_rows: R,
+    // Only `section_count` values are valid.
+    sections: [SectionId; SECTION_COUNT_MAX as usize],
+    offsets: R,
+    sizes: R,
+}
+
+impl<R: Reader> UnitIndex<R> {
+    fn parse(mut input: R) -> Result<UnitIndex<R>> {
+        if input.is_empty() {
+            return Ok(UnitIndex {
+                version: 5,
+                section_count: 0,
+                unit_count: 0,
+                slot_count: 0,
+                hash_ids: input.clone(),
+                hash_rows: input.clone(),
+                sections: [SectionId::DebugAbbrev; SECTION_COUNT_MAX as usize],
+                offsets: input.clone(),
+                sizes: input.clone(),
+            });
+        }
+
+        // GNU split-dwarf extension to DWARF 4 uses a 32-bit version,
+        // but DWARF 5 uses a 16-bit version followed by 16-bit padding.
+        let mut original_input = input.clone();
+        let version;
+        if input.read_u32()? == 2 {
+            version = 2
+        } else {
+            version = original_input.read_u16()?;
+            if version != 5 {
+                return Err(Error::UnknownVersion(version.into()));
+            }
+        }
+
+        let section_count = input.read_u32()?;
+        let unit_count = input.read_u32()?;
+        let slot_count = input.read_u32()?;
+        if slot_count == 0 || slot_count & (slot_count - 1) != 0 || slot_count <= unit_count {
+            return Err(Error::InvalidIndexSlotCount);
+        }
+
+        let hash_ids = input.split(R::Offset::from_u64(u64::from(slot_count) * 8)?)?;
+        let hash_rows = input.split(R::Offset::from_u64(u64::from(slot_count) * 4)?)?;
+
+        let mut sections = [SectionId::DebugAbbrev; SECTION_COUNT_MAX as usize];
+        if section_count > SECTION_COUNT_MAX.into() {
+            return Err(Error::InvalidIndexSectionCount);
+        }
+        for i in 0..section_count {
+            let section = input.read_u32()?;
+            sections[i as usize] = if version == 2 {
+                match constants::DwSectV2(section) {
+                    constants::DW_SECT_V2_INFO => SectionId::DebugInfo,
+                    constants::DW_SECT_V2_TYPES => SectionId::DebugTypes,
+                    constants::DW_SECT_V2_ABBREV => SectionId::DebugAbbrev,
+                    constants::DW_SECT_V2_LINE => SectionId::DebugLine,
+                    constants::DW_SECT_V2_LOC => SectionId::DebugLoc,
+                    constants::DW_SECT_V2_STR_OFFSETS => SectionId::DebugStrOffsets,
+                    constants::DW_SECT_V2_MACINFO => SectionId::DebugMacinfo,
+                    constants::DW_SECT_V2_MACRO => SectionId::DebugMacro,
+                    _ => return Err(Error::UnknownIndexSection),
+                }
+            } else {
+                match constants::DwSect(section) {
+                    constants::DW_SECT_INFO => SectionId::DebugInfo,
+                    constants::DW_SECT_ABBREV => SectionId::DebugAbbrev,
+                    constants::DW_SECT_LINE => SectionId::DebugLine,
+                    constants::DW_SECT_LOCLISTS => SectionId::DebugLocLists,
+                    constants::DW_SECT_STR_OFFSETS => SectionId::DebugStrOffsets,
+                    constants::DW_SECT_MACRO => SectionId::DebugMacro,
+                    constants::DW_SECT_RNGLISTS => SectionId::DebugRngLists,
+                    _ => return Err(Error::UnknownIndexSection),
+                }
+            };
+        }
+
+        let offsets = input.split(R::Offset::from_u64(
+            u64::from(unit_count) * u64::from(section_count) * 4,
+        )?)?;
+        let sizes = input.split(R::Offset::from_u64(
+            u64::from(unit_count) * u64::from(section_count) * 4,
+        )?)?;
+
+        Ok(UnitIndex {
+            version,
+            section_count,
+            unit_count,
+            slot_count,
+            hash_ids,
+            hash_rows,
+            sections,
+            offsets,
+            sizes,
+        })
+    }
+
+    /// Find `id` in the index hash table, and return the row index.
+    ///
+    /// `id` may be a compilation unit ID if this index is from `.debug_cu_index`,
+    /// or a type signature if this index is from `.debug_tu_index`.
+    pub fn find(&self, id: u64) -> Option<u32> {
+        if self.slot_count == 0 {
+            return None;
+        }
+        let mask = u64::from(self.slot_count - 1);
+        let mut hash1 = id & mask;
+        let hash2 = ((id >> 32) & mask) | 1;
+        for _ in 0..self.slot_count {
+            // The length of these arrays was validated in `UnitIndex::parse`.
+            let mut hash_ids = self.hash_ids.clone();
+            hash_ids.skip(R::Offset::from_u64(hash1 * 8).ok()?).ok()?;
+            let hash_id = hash_ids.read_u64().ok()?;
+            if hash_id == id {
+                let mut hash_rows = self.hash_rows.clone();
+                hash_rows.skip(R::Offset::from_u64(hash1 * 4).ok()?).ok()?;
+                let hash_row = hash_rows.read_u32().ok()?;
+                return Some(hash_row);
+            }
+            if hash_id == 0 {
+                return None;
+            }
+            hash1 = (hash1 + hash2) & mask;
+        }
+        None
+    }
+
+    /// Return the section offsets and sizes for the given row index.
+    pub fn sections(&self, mut row: u32) -> Result<UnitIndexSectionIterator<R>> {
+        if row == 0 {
+            return Err(Error::InvalidIndexRow);
+        }
+        row -= 1;
+        if row >= self.unit_count {
+            return Err(Error::InvalidIndexRow);
+        }
+        let mut offsets = self.offsets.clone();
+        offsets.skip(R::Offset::from_u64(
+            u64::from(row) * u64::from(self.section_count) * 4,
+        )?)?;
+        let mut sizes = self.sizes.clone();
+        sizes.skip(R::Offset::from_u64(
+            u64::from(row) * u64::from(self.section_count) * 4,
+        )?)?;
+        Ok(UnitIndexSectionIterator {
+            sections: self.sections[..self.section_count as usize].iter(),
+            offsets,
+            sizes,
+        })
+    }
+
+    /// Return the version.
+    pub fn version(&self) -> u16 {
+        self.version
+    }
+
+    /// Return the number of sections.
+    pub fn section_count(&self) -> u32 {
+        self.section_count
+    }
+
+    /// Return the number of units.
+    pub fn unit_count(&self) -> u32 {
+        self.unit_count
+    }
+
+    /// Return the number of slots.
+    pub fn slot_count(&self) -> u32 {
+        self.slot_count
+    }
+}
+
+/// An iterator over the section offsets and sizes for a row in a `UnitIndex`.
+#[derive(Debug, Clone)]
+pub struct UnitIndexSectionIterator<'index, R: Reader> {
+    sections: slice::Iter<'index, SectionId>,
+    offsets: R,
+    sizes: R,
+}
+
+impl<'index, R: Reader> Iterator for UnitIndexSectionIterator<'index, R> {
+    type Item = UnitIndexSection;
+
+    fn next(&mut self) -> Option<UnitIndexSection> {
+        let section = *self.sections.next()?;
+        // The length of these arrays was validated in `UnitIndex::parse`.
+        let offset = self.offsets.read_u32().ok()?;
+        let size = self.sizes.read_u32().ok()?;
+        Some(UnitIndexSection {
+            section,
+            offset,
+            size,
+        })
+    }
+}
+
+/// Information about a unit's contribution to a section in a `.dwp` file.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct UnitIndexSection {
+    /// The section kind.
+    pub section: SectionId,
+    /// The base offset of the unit's contribution to the section.
+    pub offset: u32,
+    /// The size of the unit's contribution to the section.
+    pub size: u32,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::endianity::BigEndian;
+    use test_assembler::{Endian, Section};
+
+    #[test]
+    fn test_empty() {
+        let buf = EndianSlice::new(&[], BigEndian);
+        let index = UnitIndex::parse(buf).unwrap();
+        assert!(index.find(0).is_none());
+    }
+
+    #[test]
+    fn test_version_2() {
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Big)
+            // Header.
+            .D32(2).D32(0).D32(0).D32(1)
+            // Slots.
+            .D64(0).D32(0);
+        let buf = section.get_contents().unwrap();
+        let buf = EndianSlice::new(&buf, BigEndian);
+        let index = UnitIndex::parse(buf).unwrap();
+        assert_eq!(index.version, 2);
+    }
+
+    #[test]
+    fn test_version_5() {
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Big)
+            // Header.
+            .D16(5).D16(0).D32(0).D32(0).D32(1)
+            // Slots.
+            .D64(0).D32(0);
+        let buf = section.get_contents().unwrap();
+        let buf = EndianSlice::new(&buf, BigEndian);
+        let index = UnitIndex::parse(buf).unwrap();
+        assert_eq!(index.version, 5);
+    }
+
+    #[test]
+    fn test_version_5_invalid() {
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Big)
+            // Header.
+            .D32(5).D32(0).D32(0).D32(1)
+            // Slots.
+            .D64(0).D32(0);
+        let buf = section.get_contents().unwrap();
+        let buf = EndianSlice::new(&buf, BigEndian);
+        assert!(UnitIndex::parse(buf).is_err());
+    }
+
+    #[test]
+    fn test_version_2_sections() {
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Big)
+            // Header.
+            .D32(2).D32(8).D32(1).D32(2)
+            // Slots.
+            .D64(0).D64(0).D32(0).D32(0)
+            // Sections.
+            .D32(constants::DW_SECT_V2_INFO.0)
+            .D32(constants::DW_SECT_V2_TYPES.0)
+            .D32(constants::DW_SECT_V2_ABBREV.0)
+            .D32(constants::DW_SECT_V2_LINE.0)
+            .D32(constants::DW_SECT_V2_LOC.0)
+            .D32(constants::DW_SECT_V2_STR_OFFSETS.0)
+            .D32(constants::DW_SECT_V2_MACINFO.0)
+            .D32(constants::DW_SECT_V2_MACRO.0)
+            // Offsets.
+            .D32(11).D32(12).D32(13).D32(14).D32(15).D32(16).D32(17).D32(18)
+            // Sizes.
+            .D32(21).D32(22).D32(23).D32(24).D32(25).D32(26).D32(27).D32(28);
+        let buf = section.get_contents().unwrap();
+        let buf = EndianSlice::new(&buf, BigEndian);
+        let index = UnitIndex::parse(buf).unwrap();
+        assert_eq!(index.section_count, 8);
+        assert_eq!(
+            index.sections,
+            [
+                SectionId::DebugInfo,
+                SectionId::DebugTypes,
+                SectionId::DebugAbbrev,
+                SectionId::DebugLine,
+                SectionId::DebugLoc,
+                SectionId::DebugStrOffsets,
+                SectionId::DebugMacinfo,
+                SectionId::DebugMacro,
+            ]
+        );
+        #[rustfmt::skip]
+        let expect = [
+            UnitIndexSection { section: SectionId::DebugInfo, offset: 11, size: 21 },
+            UnitIndexSection { section: SectionId::DebugTypes, offset: 12, size: 22 },
+            UnitIndexSection { section: SectionId::DebugAbbrev, offset: 13, size: 23 },
+            UnitIndexSection { section: SectionId::DebugLine, offset: 14, size: 24 },
+            UnitIndexSection { section: SectionId::DebugLoc, offset: 15, size: 25 },
+            UnitIndexSection { section: SectionId::DebugStrOffsets, offset: 16, size: 26 },
+            UnitIndexSection { section: SectionId::DebugMacinfo, offset: 17, size: 27 },
+            UnitIndexSection { section: SectionId::DebugMacro, offset: 18, size: 28 },
+        ];
+        let mut sections = index.sections(1).unwrap();
+        for section in &expect {
+            assert_eq!(*section, sections.next().unwrap());
+        }
+        assert!(sections.next().is_none());
+    }
+
+    #[test]
+    fn test_version_5_sections() {
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Big)
+            // Header.
+            .D16(5).D16(0).D32(7).D32(1).D32(2)
+            // Slots.
+            .D64(0).D64(0).D32(0).D32(0)
+            // Sections.
+            .D32(constants::DW_SECT_INFO.0)
+            .D32(constants::DW_SECT_ABBREV.0)
+            .D32(constants::DW_SECT_LINE.0)
+            .D32(constants::DW_SECT_LOCLISTS.0)
+            .D32(constants::DW_SECT_STR_OFFSETS.0)
+            .D32(constants::DW_SECT_MACRO.0)
+            .D32(constants::DW_SECT_RNGLISTS.0)
+            // Offsets.
+            .D32(11).D32(12).D32(13).D32(14).D32(15).D32(16).D32(17)
+            // Sizes.
+            .D32(21).D32(22).D32(23).D32(24).D32(25).D32(26).D32(27);
+        let buf = section.get_contents().unwrap();
+        let buf = EndianSlice::new(&buf, BigEndian);
+        let index = UnitIndex::parse(buf).unwrap();
+        assert_eq!(index.section_count, 7);
+        assert_eq!(
+            index.sections[..7],
+            [
+                SectionId::DebugInfo,
+                SectionId::DebugAbbrev,
+                SectionId::DebugLine,
+                SectionId::DebugLocLists,
+                SectionId::DebugStrOffsets,
+                SectionId::DebugMacro,
+                SectionId::DebugRngLists,
+            ]
+        );
+        #[rustfmt::skip]
+        let expect = [
+            UnitIndexSection { section: SectionId::DebugInfo, offset: 11, size: 21 },
+            UnitIndexSection { section: SectionId::DebugAbbrev, offset: 12, size: 22 },
+            UnitIndexSection { section: SectionId::DebugLine, offset: 13, size: 23 },
+            UnitIndexSection { section: SectionId::DebugLocLists, offset: 14, size: 24 },
+            UnitIndexSection { section: SectionId::DebugStrOffsets, offset: 15, size: 25 },
+            UnitIndexSection { section: SectionId::DebugMacro, offset: 16, size: 26 },
+            UnitIndexSection { section: SectionId::DebugRngLists, offset: 17, size: 27 },
+        ];
+        let mut sections = index.sections(1).unwrap();
+        for section in &expect {
+            assert_eq!(*section, sections.next().unwrap());
+        }
+        assert!(sections.next().is_none());
+
+        assert!(index.sections(0).is_err());
+        assert!(index.sections(2).is_err());
+    }
+
+    #[test]
+    fn test_hash() {
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Big)
+            // Header.
+            .D16(5).D16(0).D32(2).D32(3).D32(4)
+            // Slots.
+            .D64(0xffff_fff2_ffff_fff1)
+            .D64(0xffff_fff0_ffff_fff1)
+            .D64(0xffff_fff1_ffff_fff1)
+            .D64(0)
+            .D32(3).D32(1).D32(2).D32(0)
+            // Sections.
+            .D32(constants::DW_SECT_INFO.0)
+            .D32(constants::DW_SECT_ABBREV.0)
+            // Offsets.
+            .D32(0).D32(0).D32(0).D32(0).D32(0).D32(0)
+            // Sizes.
+            .D32(0).D32(0).D32(0).D32(0).D32(0).D32(0);
+        let buf = section.get_contents().unwrap();
+        let buf = EndianSlice::new(&buf, BigEndian);
+        let index = UnitIndex::parse(buf).unwrap();
+        assert_eq!(index.version(), 5);
+        assert_eq!(index.slot_count(), 4);
+        assert_eq!(index.unit_count(), 3);
+        assert_eq!(index.section_count(), 2);
+        assert_eq!(index.find(0xffff_fff0_ffff_fff1), Some(1));
+        assert_eq!(index.find(0xffff_fff1_ffff_fff1), Some(2));
+        assert_eq!(index.find(0xffff_fff2_ffff_fff1), Some(3));
+        assert_eq!(index.find(0xffff_fff3_ffff_fff1), None);
+    }
+
+    #[test]
+    fn test_cu_index() {
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Big)
+            // Header.
+            .D16(5).D16(0).D32(0).D32(0).D32(1)
+            // Slots.
+            .D64(0).D32(0);
+        let buf = section.get_contents().unwrap();
+        let cu_index = DebugCuIndex::new(&buf, BigEndian);
+        let index = cu_index.index().unwrap();
+        assert_eq!(index.version, 5);
+    }
+
+    #[test]
+    fn test_tu_index() {
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Big)
+            // Header.
+            .D16(5).D16(0).D32(0).D32(0).D32(1)
+            // Slots.
+            .D64(0).D32(0);
+        let buf = section.get_contents().unwrap();
+        let tu_index = DebugTuIndex::new(&buf, BigEndian);
+        let index = tu_index.index().unwrap();
+        assert_eq!(index.version, 5);
+    }
+}
diff --git a/vendor/gimli/src/read/line.rs b/vendor/gimli/src/read/line.rs
new file mode 100644
index 0000000..47eae92
--- /dev/null
+++ b/vendor/gimli/src/read/line.rs
@@ -0,0 +1,3130 @@
+use alloc::vec::Vec;
+use core::fmt;
+use core::num::{NonZeroU64, Wrapping};
+use core::result;
+
+use crate::common::{
+    DebugLineOffset, DebugLineStrOffset, DebugStrOffset, DebugStrOffsetsIndex, Encoding, Format,
+    LineEncoding, SectionId,
+};
+use crate::constants;
+use crate::endianity::Endianity;
+use crate::read::{AttributeValue, EndianSlice, Error, Reader, ReaderOffset, Result, Section};
+
+/// The `DebugLine` struct contains the source location to instruction mapping
+/// found in the `.debug_line` section.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct DebugLine<R> {
+    debug_line_section: R,
+}
+
+impl<'input, Endian> DebugLine<EndianSlice<'input, Endian>>
+where
+    Endian: Endianity,
+{
+    /// Construct a new `DebugLine` instance from the data in the `.debug_line`
+    /// section.
+    ///
+    /// It is the caller's responsibility to read the `.debug_line` section and
+    /// present it as a `&[u8]` slice. That means using some ELF loader on
+    /// Linux, a Mach-O loader on macOS, etc.
+    ///
+    /// ```
+    /// use gimli::{DebugLine, LittleEndian};
+    ///
+    /// # let buf = [0x00, 0x01, 0x02, 0x03];
+    /// # let read_debug_line_section_somehow = || &buf;
+    /// let debug_line = DebugLine::new(read_debug_line_section_somehow(), LittleEndian);
+    /// ```
+    pub fn new(debug_line_section: &'input [u8], endian: Endian) -> Self {
+        Self::from(EndianSlice::new(debug_line_section, endian))
+    }
+}
+
+impl<R: Reader> DebugLine<R> {
+    /// Parse the line number program whose header is at the given `offset` in the
+    /// `.debug_line` section.
+    ///
+    /// The `address_size` must match the compilation unit that the lines apply to.
+    /// The `comp_dir` should be from the `DW_AT_comp_dir` attribute of the compilation
+    /// unit. The `comp_name` should be from the `DW_AT_name` attribute of the
+    /// compilation unit.
+    ///
+    /// ```rust,no_run
+    /// use gimli::{DebugLine, DebugLineOffset, IncompleteLineProgram, EndianSlice, LittleEndian};
+    ///
+    /// # let buf = [];
+    /// # let read_debug_line_section_somehow = || &buf;
+    /// let debug_line = DebugLine::new(read_debug_line_section_somehow(), LittleEndian);
+    ///
+    /// // In a real example, we'd grab the offset via a compilation unit
+    /// // entry's `DW_AT_stmt_list` attribute, and the address size from that
+    /// // unit directly.
+    /// let offset = DebugLineOffset(0);
+    /// let address_size = 8;
+    ///
+    /// let program = debug_line.program(offset, address_size, None, None)
+    ///     .expect("should have found a header at that offset, and parsed it OK");
+    /// ```
+    pub fn program(
+        &self,
+        offset: DebugLineOffset<R::Offset>,
+        address_size: u8,
+        comp_dir: Option<R>,
+        comp_name: Option<R>,
+    ) -> Result<IncompleteLineProgram<R>> {
+        let input = &mut self.debug_line_section.clone();
+        input.skip(offset.0)?;
+        let header = LineProgramHeader::parse(input, offset, address_size, comp_dir, comp_name)?;
+        let program = IncompleteLineProgram { header };
+        Ok(program)
+    }
+}
+
+impl<T> DebugLine<T> {
+    /// Create a `DebugLine` section that references the data in `self`.
+    ///
+    /// This is useful when `R` implements `Reader` but `T` does not.
+    ///
+    /// ## Example Usage
+    ///
+    /// ```rust,no_run
+    /// # let load_section = || unimplemented!();
+    /// // Read the DWARF section into a `Vec` with whatever object loader you're using.
+    /// let owned_section: gimli::DebugLine<Vec<u8>> = load_section();
+    /// // Create a reference to the DWARF section.
+    /// let section = owned_section.borrow(|section| {
+    ///     gimli::EndianSlice::new(&section, gimli::LittleEndian)
+    /// });
+    /// ```
+    pub fn borrow<'a, F, R>(&'a self, mut borrow: F) -> DebugLine<R>
+    where
+        F: FnMut(&'a T) -> R,
+    {
+        borrow(&self.debug_line_section).into()
+    }
+}
+
+impl<R> Section<R> for DebugLine<R> {
+    fn id() -> SectionId {
+        SectionId::DebugLine
+    }
+
+    fn reader(&self) -> &R {
+        &self.debug_line_section
+    }
+}
+
+impl<R> From<R> for DebugLine<R> {
+    fn from(debug_line_section: R) -> Self {
+        DebugLine { debug_line_section }
+    }
+}
+
+/// Deprecated. `LineNumberProgram` has been renamed to `LineProgram`.
+#[deprecated(note = "LineNumberProgram has been renamed to LineProgram, use that instead.")]
+pub type LineNumberProgram<R, Offset> = dyn LineProgram<R, Offset>;
+
+/// A `LineProgram` provides access to a `LineProgramHeader` and
+/// a way to add files to the files table if necessary. Gimli consumers should
+/// never need to use or see this trait.
+pub trait LineProgram<R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    /// Get a reference to the held `LineProgramHeader`.
+    fn header(&self) -> &LineProgramHeader<R, Offset>;
+    /// Add a file to the file table if necessary.
+    fn add_file(&mut self, file: FileEntry<R, Offset>);
+}
+
+impl<R, Offset> LineProgram<R, Offset> for IncompleteLineProgram<R, Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    fn header(&self) -> &LineProgramHeader<R, Offset> {
+        &self.header
+    }
+    fn add_file(&mut self, file: FileEntry<R, Offset>) {
+        self.header.file_names.push(file);
+    }
+}
+
+impl<'program, R, Offset> LineProgram<R, Offset> for &'program CompleteLineProgram<R, Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    fn header(&self) -> &LineProgramHeader<R, Offset> {
+        &self.header
+    }
+    fn add_file(&mut self, _: FileEntry<R, Offset>) {
+        // Nop. Our file table is already complete.
+    }
+}
+
+/// Deprecated. `StateMachine` has been renamed to `LineRows`.
+#[deprecated(note = "StateMachine has been renamed to LineRows, use that instead.")]
+pub type StateMachine<R, Program, Offset> = LineRows<R, Program, Offset>;
+
+/// Executes a `LineProgram` to iterate over the rows in the matrix of line number information.
+///
+/// "The hypothetical machine used by a consumer of the line number information
+/// to expand the byte-coded instruction stream into a matrix of line number
+/// information." -- Section 6.2.1
+#[derive(Debug, Clone)]
+pub struct LineRows<R, Program, Offset = <R as Reader>::Offset>
+where
+    Program: LineProgram<R, Offset>,
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    program: Program,
+    row: LineRow,
+    instructions: LineInstructions<R>,
+}
+
+type OneShotLineRows<R, Offset = <R as Reader>::Offset> =
+    LineRows<R, IncompleteLineProgram<R, Offset>, Offset>;
+
+type ResumedLineRows<'program, R, Offset = <R as Reader>::Offset> =
+    LineRows<R, &'program CompleteLineProgram<R, Offset>, Offset>;
+
+impl<R, Program, Offset> LineRows<R, Program, Offset>
+where
+    Program: LineProgram<R, Offset>,
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    fn new(program: IncompleteLineProgram<R, Offset>) -> OneShotLineRows<R, Offset> {
+        let row = LineRow::new(program.header());
+        let instructions = LineInstructions {
+            input: program.header().program_buf.clone(),
+        };
+        LineRows {
+            program,
+            row,
+            instructions,
+        }
+    }
+
+    fn resume<'program>(
+        program: &'program CompleteLineProgram<R, Offset>,
+        sequence: &LineSequence<R>,
+    ) -> ResumedLineRows<'program, R, Offset> {
+        let row = LineRow::new(program.header());
+        let instructions = sequence.instructions.clone();
+        LineRows {
+            program,
+            row,
+            instructions,
+        }
+    }
+
+    /// Get a reference to the header for this state machine's line number
+    /// program.
+    #[inline]
+    pub fn header(&self) -> &LineProgramHeader<R, Offset> {
+        self.program.header()
+    }
+
+    /// Parse and execute the next instructions in the line number program until
+    /// another row in the line number matrix is computed.
+    ///
+    /// The freshly computed row is returned as `Ok(Some((header, row)))`.
+    /// If the matrix is complete, and there are no more new rows in the line
+    /// number matrix, then `Ok(None)` is returned. If there was an error parsing
+    /// an instruction, then `Err(e)` is returned.
+    ///
+    /// Unfortunately, the references mean that this cannot be a
+    /// `FallibleIterator`.
+    pub fn next_row(&mut self) -> Result<Option<(&LineProgramHeader<R, Offset>, &LineRow)>> {
+        // Perform any reset that was required after copying the previous row.
+        self.row.reset(self.program.header());
+
+        loop {
+            // Split the borrow here, rather than calling `self.header()`.
+            match self.instructions.next_instruction(self.program.header()) {
+                Err(err) => return Err(err),
+                Ok(None) => return Ok(None),
+                Ok(Some(instruction)) => {
+                    if self.row.execute(instruction, &mut self.program) {
+                        if self.row.tombstone {
+                            // Perform any reset that was required for the tombstone row.
+                            // Normally this is done when `next_row` is called again, but for
+                            // tombstones we loop immediately.
+                            self.row.reset(self.program.header());
+                        } else {
+                            return Ok(Some((self.header(), &self.row)));
+                        }
+                    }
+                    // Fall through, parse the next instruction, and see if that
+                    // yields a row.
+                }
+            }
+        }
+    }
+}
+
+/// Deprecated. `Opcode` has been renamed to `LineInstruction`.
+#[deprecated(note = "Opcode has been renamed to LineInstruction, use that instead.")]
+pub type Opcode<R> = LineInstruction<R, <R as Reader>::Offset>;
+
+/// A parsed line number program instruction.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum LineInstruction<R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    /// > ### 6.2.5.1 Special Opcodes
+    /// >
+    /// > Each ubyte special opcode has the following effect on the state machine:
+    /// >
+    /// >   1. Add a signed integer to the line register.
+    /// >
+    /// >   2. Modify the operation pointer by incrementing the address and
+    /// >   op_index registers as described below.
+    /// >
+    /// >   3. Append a row to the matrix using the current values of the state
+    /// >   machine registers.
+    /// >
+    /// >   4. Set the basic_block register to “false.”
+    /// >
+    /// >   5. Set the prologue_end register to “false.”
+    /// >
+    /// >   6. Set the epilogue_begin register to “false.”
+    /// >
+    /// >   7. Set the discriminator register to 0.
+    /// >
+    /// > All of the special opcodes do those same seven things; they differ from
+    /// > one another only in what values they add to the line, address and
+    /// > op_index registers.
+    Special(u8),
+
+    /// "[`LineInstruction::Copy`] appends a row to the matrix using the current
+    /// values of the state machine registers. Then it sets the discriminator
+    /// register to 0, and sets the basic_block, prologue_end and epilogue_begin
+    /// registers to “false.”"
+    Copy,
+
+    /// "The DW_LNS_advance_pc opcode takes a single unsigned LEB128 operand as
+    /// the operation advance and modifies the address and op_index registers
+    /// [the same as `LineInstruction::Special`]"
+    AdvancePc(u64),
+
+    /// "The DW_LNS_advance_line opcode takes a single signed LEB128 operand and
+    /// adds that value to the line register of the state machine."
+    AdvanceLine(i64),
+
+    /// "The DW_LNS_set_file opcode takes a single unsigned LEB128 operand and
+    /// stores it in the file register of the state machine."
+    SetFile(u64),
+
+    /// "The DW_LNS_set_column opcode takes a single unsigned LEB128 operand and
+    /// stores it in the column register of the state machine."
+    SetColumn(u64),
+
+    /// "The DW_LNS_negate_stmt opcode takes no operands. It sets the is_stmt
+    /// register of the state machine to the logical negation of its current
+    /// value."
+    NegateStatement,
+
+    /// "The DW_LNS_set_basic_block opcode takes no operands. It sets the
+    /// basic_block register of the state machine to “true.”"
+    SetBasicBlock,
+
+    /// > The DW_LNS_const_add_pc opcode takes no operands. It advances the
+    /// > address and op_index registers by the increments corresponding to
+    /// > special opcode 255.
+    /// >
+    /// > When the line number program needs to advance the address by a small
+    /// > amount, it can use a single special opcode, which occupies a single
+    /// > byte. When it needs to advance the address by up to twice the range of
+    /// > the last special opcode, it can use DW_LNS_const_add_pc followed by a
+    /// > special opcode, for a total of two bytes. Only if it needs to advance
+    /// > the address by more than twice that range will it need to use both
+    /// > DW_LNS_advance_pc and a special opcode, requiring three or more bytes.
+    ConstAddPc,
+
+    /// > The DW_LNS_fixed_advance_pc opcode takes a single uhalf (unencoded)
+    /// > operand and adds it to the address register of the state machine and
+    /// > sets the op_index register to 0. This is the only standard opcode whose
+    /// > operand is not a variable length number. It also does not multiply the
+    /// > operand by the minimum_instruction_length field of the header.
+    FixedAddPc(u16),
+
+    /// "[`LineInstruction::SetPrologueEnd`] sets the prologue_end register to “true”."
+    SetPrologueEnd,
+
+    /// "[`LineInstruction::SetEpilogueBegin`] sets the epilogue_begin register to
+    /// “true”."
+    SetEpilogueBegin,
+
+    /// "The DW_LNS_set_isa opcode takes a single unsigned LEB128 operand and
+    /// stores that value in the isa register of the state machine."
+    SetIsa(u64),
+
+    /// An unknown standard opcode with zero operands.
+    UnknownStandard0(constants::DwLns),
+
+    /// An unknown standard opcode with one operand.
+    UnknownStandard1(constants::DwLns, u64),
+
+    /// An unknown standard opcode with multiple operands.
+    UnknownStandardN(constants::DwLns, R),
+
+    /// > [`LineInstruction::EndSequence`] sets the end_sequence register of the state
+    /// > machine to “true” and appends a row to the matrix using the current
+    /// > values of the state-machine registers. Then it resets the registers to
+    /// > the initial values specified above (see Section 6.2.2). Every line
+    /// > number program sequence must end with a DW_LNE_end_sequence instruction
+    /// > which creates a row whose address is that of the byte after the last
+    /// > target machine instruction of the sequence.
+    EndSequence,
+
+    /// > The DW_LNE_set_address opcode takes a single relocatable address as an
+    /// > operand. The size of the operand is the size of an address on the target
+    /// > machine. It sets the address register to the value given by the
+    /// > relocatable address and sets the op_index register to 0.
+    /// >
+    /// > All of the other line number program opcodes that affect the address
+    /// > register add a delta to it. This instruction stores a relocatable value
+    /// > into it instead.
+    SetAddress(u64),
+
+    /// Defines a new source file in the line number program and appends it to
+    /// the line number program header's list of source files.
+    DefineFile(FileEntry<R, Offset>),
+
+    /// "The DW_LNE_set_discriminator opcode takes a single parameter, an
+    /// unsigned LEB128 integer. It sets the discriminator register to the new
+    /// value."
+    SetDiscriminator(u64),
+
+    /// An unknown extended opcode and the slice of its unparsed operands.
+    UnknownExtended(constants::DwLne, R),
+}
+
+impl<R, Offset> LineInstruction<R, Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    fn parse<'header>(
+        header: &'header LineProgramHeader<R>,
+        input: &mut R,
+    ) -> Result<LineInstruction<R>>
+    where
+        R: 'header,
+    {
+        let opcode = input.read_u8()?;
+        if opcode == 0 {
+            let length = input.read_uleb128().and_then(R::Offset::from_u64)?;
+            let mut instr_rest = input.split(length)?;
+            let opcode = instr_rest.read_u8()?;
+
+            match constants::DwLne(opcode) {
+                constants::DW_LNE_end_sequence => Ok(LineInstruction::EndSequence),
+
+                constants::DW_LNE_set_address => {
+                    let address = instr_rest.read_address(header.address_size())?;
+                    Ok(LineInstruction::SetAddress(address))
+                }
+
+                constants::DW_LNE_define_file => {
+                    if header.version() <= 4 {
+                        let path_name = instr_rest.read_null_terminated_slice()?;
+                        let entry = FileEntry::parse(&mut instr_rest, path_name)?;
+                        Ok(LineInstruction::DefineFile(entry))
+                    } else {
+                        Ok(LineInstruction::UnknownExtended(
+                            constants::DW_LNE_define_file,
+                            instr_rest,
+                        ))
+                    }
+                }
+
+                constants::DW_LNE_set_discriminator => {
+                    let discriminator = instr_rest.read_uleb128()?;
+                    Ok(LineInstruction::SetDiscriminator(discriminator))
+                }
+
+                otherwise => Ok(LineInstruction::UnknownExtended(otherwise, instr_rest)),
+            }
+        } else if opcode >= header.opcode_base {
+            Ok(LineInstruction::Special(opcode))
+        } else {
+            match constants::DwLns(opcode) {
+                constants::DW_LNS_copy => Ok(LineInstruction::Copy),
+
+                constants::DW_LNS_advance_pc => {
+                    let advance = input.read_uleb128()?;
+                    Ok(LineInstruction::AdvancePc(advance))
+                }
+
+                constants::DW_LNS_advance_line => {
+                    let increment = input.read_sleb128()?;
+                    Ok(LineInstruction::AdvanceLine(increment))
+                }
+
+                constants::DW_LNS_set_file => {
+                    let file = input.read_uleb128()?;
+                    Ok(LineInstruction::SetFile(file))
+                }
+
+                constants::DW_LNS_set_column => {
+                    let column = input.read_uleb128()?;
+                    Ok(LineInstruction::SetColumn(column))
+                }
+
+                constants::DW_LNS_negate_stmt => Ok(LineInstruction::NegateStatement),
+
+                constants::DW_LNS_set_basic_block => Ok(LineInstruction::SetBasicBlock),
+
+                constants::DW_LNS_const_add_pc => Ok(LineInstruction::ConstAddPc),
+
+                constants::DW_LNS_fixed_advance_pc => {
+                    let advance = input.read_u16()?;
+                    Ok(LineInstruction::FixedAddPc(advance))
+                }
+
+                constants::DW_LNS_set_prologue_end => Ok(LineInstruction::SetPrologueEnd),
+
+                constants::DW_LNS_set_epilogue_begin => Ok(LineInstruction::SetEpilogueBegin),
+
+                constants::DW_LNS_set_isa => {
+                    let isa = input.read_uleb128()?;
+                    Ok(LineInstruction::SetIsa(isa))
+                }
+
+                otherwise => {
+                    let mut opcode_lengths = header.standard_opcode_lengths().clone();
+                    opcode_lengths.skip(R::Offset::from_u8(opcode - 1))?;
+                    let num_args = opcode_lengths.read_u8()? as usize;
+                    match num_args {
+                        0 => Ok(LineInstruction::UnknownStandard0(otherwise)),
+                        1 => {
+                            let arg = input.read_uleb128()?;
+                            Ok(LineInstruction::UnknownStandard1(otherwise, arg))
+                        }
+                        _ => {
+                            let mut args = input.clone();
+                            for _ in 0..num_args {
+                                input.read_uleb128()?;
+                            }
+                            let len = input.offset_from(&args);
+                            args.truncate(len)?;
+                            Ok(LineInstruction::UnknownStandardN(otherwise, args))
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl<R, Offset> fmt::Display for LineInstruction<R, Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> result::Result<(), fmt::Error> {
+        match *self {
+            LineInstruction::Special(opcode) => write!(f, "Special opcode {}", opcode),
+            LineInstruction::Copy => write!(f, "{}", constants::DW_LNS_copy),
+            LineInstruction::AdvancePc(advance) => {
+                write!(f, "{} by {}", constants::DW_LNS_advance_pc, advance)
+            }
+            LineInstruction::AdvanceLine(increment) => {
+                write!(f, "{} by {}", constants::DW_LNS_advance_line, increment)
+            }
+            LineInstruction::SetFile(file) => {
+                write!(f, "{} to {}", constants::DW_LNS_set_file, file)
+            }
+            LineInstruction::SetColumn(column) => {
+                write!(f, "{} to {}", constants::DW_LNS_set_column, column)
+            }
+            LineInstruction::NegateStatement => write!(f, "{}", constants::DW_LNS_negate_stmt),
+            LineInstruction::SetBasicBlock => write!(f, "{}", constants::DW_LNS_set_basic_block),
+            LineInstruction::ConstAddPc => write!(f, "{}", constants::DW_LNS_const_add_pc),
+            LineInstruction::FixedAddPc(advance) => {
+                write!(f, "{} by {}", constants::DW_LNS_fixed_advance_pc, advance)
+            }
+            LineInstruction::SetPrologueEnd => write!(f, "{}", constants::DW_LNS_set_prologue_end),
+            LineInstruction::SetEpilogueBegin => {
+                write!(f, "{}", constants::DW_LNS_set_epilogue_begin)
+            }
+            LineInstruction::SetIsa(isa) => write!(f, "{} to {}", constants::DW_LNS_set_isa, isa),
+            LineInstruction::UnknownStandard0(opcode) => write!(f, "Unknown {}", opcode),
+            LineInstruction::UnknownStandard1(opcode, arg) => {
+                write!(f, "Unknown {} with operand {}", opcode, arg)
+            }
+            LineInstruction::UnknownStandardN(opcode, ref args) => {
+                write!(f, "Unknown {} with operands {:?}", opcode, args)
+            }
+            LineInstruction::EndSequence => write!(f, "{}", constants::DW_LNE_end_sequence),
+            LineInstruction::SetAddress(address) => {
+                write!(f, "{} to {}", constants::DW_LNE_set_address, address)
+            }
+            LineInstruction::DefineFile(_) => write!(f, "{}", constants::DW_LNE_define_file),
+            LineInstruction::SetDiscriminator(discr) => {
+                write!(f, "{} to {}", constants::DW_LNE_set_discriminator, discr)
+            }
+            LineInstruction::UnknownExtended(opcode, _) => write!(f, "Unknown {}", opcode),
+        }
+    }
+}
+
+/// Deprecated. `OpcodesIter` has been renamed to `LineInstructions`.
+#[deprecated(note = "OpcodesIter has been renamed to LineInstructions, use that instead.")]
+pub type OpcodesIter<R> = LineInstructions<R>;
+
+/// An iterator yielding parsed instructions.
+///
+/// See
+/// [`LineProgramHeader::instructions`](./struct.LineProgramHeader.html#method.instructions)
+/// for more details.
+#[derive(Clone, Debug)]
+pub struct LineInstructions<R: Reader> {
+    input: R,
+}
+
+impl<R: Reader> LineInstructions<R> {
+    fn remove_trailing(&self, other: &LineInstructions<R>) -> Result<LineInstructions<R>> {
+        let offset = other.input.offset_from(&self.input);
+        let mut input = self.input.clone();
+        input.truncate(offset)?;
+        Ok(LineInstructions { input })
+    }
+}
+
+impl<R: Reader> LineInstructions<R> {
+    /// Advance the iterator and return the next instruction.
+    ///
+    /// Returns the newly parsed instruction as `Ok(Some(instruction))`. Returns
+    /// `Ok(None)` when iteration is complete and all instructions have already been
+    /// parsed and yielded. If an error occurs while parsing the next attribute,
+    /// then this error is returned as `Err(e)`, and all subsequent calls return
+    /// `Ok(None)`.
+    ///
+    /// Unfortunately, the `header` parameter means that this cannot be a
+    /// `FallibleIterator`.
+    #[inline(always)]
+    pub fn next_instruction(
+        &mut self,
+        header: &LineProgramHeader<R>,
+    ) -> Result<Option<LineInstruction<R>>> {
+        if self.input.is_empty() {
+            return Ok(None);
+        }
+
+        match LineInstruction::parse(header, &mut self.input) {
+            Ok(instruction) => Ok(Some(instruction)),
+            Err(e) => {
+                self.input.empty();
+                Err(e)
+            }
+        }
+    }
+}
+
+/// Deprecated. `LineNumberRow` has been renamed to `LineRow`.
+#[deprecated(note = "LineNumberRow has been renamed to LineRow, use that instead.")]
+pub type LineNumberRow = LineRow;
+
+/// A row in the line number program's resulting matrix.
+///
+/// Each row is a copy of the registers of the state machine, as defined in section 6.2.2.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct LineRow {
+    tombstone: bool,
+    address: Wrapping<u64>,
+    op_index: Wrapping<u64>,
+    file: u64,
+    line: Wrapping<u64>,
+    column: u64,
+    is_stmt: bool,
+    basic_block: bool,
+    end_sequence: bool,
+    prologue_end: bool,
+    epilogue_begin: bool,
+    isa: u64,
+    discriminator: u64,
+}
+
+impl LineRow {
+    /// Create a line number row in the initial state for the given program.
+    pub fn new<R: Reader>(header: &LineProgramHeader<R>) -> Self {
+        LineRow {
+            // "At the beginning of each sequence within a line number program, the
+            // state of the registers is:" -- Section 6.2.2
+            tombstone: false,
+            address: Wrapping(0),
+            op_index: Wrapping(0),
+            file: 1,
+            line: Wrapping(1),
+            column: 0,
+            // "determined by default_is_stmt in the line number program header"
+            is_stmt: header.line_encoding.default_is_stmt,
+            basic_block: false,
+            end_sequence: false,
+            prologue_end: false,
+            epilogue_begin: false,
+            // "The isa value 0 specifies that the instruction set is the
+            // architecturally determined default instruction set. This may be fixed
+            // by the ABI, or it may be specified by other means, for example, by
+            // the object file description."
+            isa: 0,
+            discriminator: 0,
+        }
+    }
+
+    /// "The program-counter value corresponding to a machine instruction
+    /// generated by the compiler."
+    #[inline]
+    pub fn address(&self) -> u64 {
+        self.address.0
+    }
+
+    /// > An unsigned integer representing the index of an operation within a VLIW
+    /// > instruction. The index of the first operation is 0. For non-VLIW
+    /// > architectures, this register will always be 0.
+    /// >
+    /// > The address and op_index registers, taken together, form an operation
+    /// > pointer that can reference any individual operation with the
+    /// > instruction stream.
+    #[inline]
+    pub fn op_index(&self) -> u64 {
+        self.op_index.0
+    }
+
+    /// "An unsigned integer indicating the identity of the source file
+    /// corresponding to a machine instruction."
+    #[inline]
+    pub fn file_index(&self) -> u64 {
+        self.file
+    }
+
+    /// The source file corresponding to the current machine instruction.
+    #[inline]
+    pub fn file<'header, R: Reader>(
+        &self,
+        header: &'header LineProgramHeader<R>,
+    ) -> Option<&'header FileEntry<R>> {
+        header.file(self.file)
+    }
+
+    /// "An unsigned integer indicating a source line number. Lines are numbered
+    /// beginning at 1. The compiler may emit the value 0 in cases where an
+    /// instruction cannot be attributed to any source line."
+    /// Line number values of 0 are represented as `None`.
+    #[inline]
+    pub fn line(&self) -> Option<NonZeroU64> {
+        NonZeroU64::new(self.line.0)
+    }
+
+    /// "An unsigned integer indicating a column number within a source
+    /// line. Columns are numbered beginning at 1. The value 0 is reserved to
+    /// indicate that a statement begins at the “left edge” of the line."
+    #[inline]
+    pub fn column(&self) -> ColumnType {
+        NonZeroU64::new(self.column)
+            .map(ColumnType::Column)
+            .unwrap_or(ColumnType::LeftEdge)
+    }
+
+    /// "A boolean indicating that the current instruction is a recommended
+    /// breakpoint location. A recommended breakpoint location is intended to
+    /// “represent” a line, a statement and/or a semantically distinct subpart
+    /// of a statement."
+    #[inline]
+    pub fn is_stmt(&self) -> bool {
+        self.is_stmt
+    }
+
+    /// "A boolean indicating that the current instruction is the beginning of a
+    /// basic block."
+    #[inline]
+    pub fn basic_block(&self) -> bool {
+        self.basic_block
+    }
+
+    /// "A boolean indicating that the current address is that of the first byte
+    /// after the end of a sequence of target machine instructions. end_sequence
+    /// terminates a sequence of lines; therefore other information in the same
+    /// row is not meaningful."
+    #[inline]
+    pub fn end_sequence(&self) -> bool {
+        self.end_sequence
+    }
+
+    /// "A boolean indicating that the current address is one (of possibly many)
+    /// where execution should be suspended for an entry breakpoint of a
+    /// function."
+    #[inline]
+    pub fn prologue_end(&self) -> bool {
+        self.prologue_end
+    }
+
+    /// "A boolean indicating that the current address is one (of possibly many)
+    /// where execution should be suspended for an exit breakpoint of a
+    /// function."
+    #[inline]
+    pub fn epilogue_begin(&self) -> bool {
+        self.epilogue_begin
+    }
+
+    /// Tag for the current instruction set architecture.
+    ///
+    /// > An unsigned integer whose value encodes the applicable instruction set
+    /// > architecture for the current instruction.
+    /// >
+    /// > The encoding of instruction sets should be shared by all users of a
+    /// > given architecture. It is recommended that this encoding be defined by
+    /// > the ABI authoring committee for each architecture.
+    #[inline]
+    pub fn isa(&self) -> u64 {
+        self.isa
+    }
+
+    /// "An unsigned integer identifying the block to which the current
+    /// instruction belongs. Discriminator values are assigned arbitrarily by
+    /// the DWARF producer and serve to distinguish among multiple blocks that
+    /// may all be associated with the same source file, line, and column. Where
+    /// only one block exists for a given source position, the discriminator
+    /// value should be zero."
+    #[inline]
+    pub fn discriminator(&self) -> u64 {
+        self.discriminator
+    }
+
+    /// Execute the given instruction, and return true if a new row in the
+    /// line number matrix needs to be generated.
+    ///
+    /// Unknown opcodes are treated as no-ops.
+    #[inline]
+    pub fn execute<R, Program>(
+        &mut self,
+        instruction: LineInstruction<R>,
+        program: &mut Program,
+    ) -> bool
+    where
+        Program: LineProgram<R>,
+        R: Reader,
+    {
+        match instruction {
+            LineInstruction::Special(opcode) => {
+                self.exec_special_opcode(opcode, program.header());
+                true
+            }
+
+            LineInstruction::Copy => true,
+
+            LineInstruction::AdvancePc(operation_advance) => {
+                self.apply_operation_advance(operation_advance, program.header());
+                false
+            }
+
+            LineInstruction::AdvanceLine(line_increment) => {
+                self.apply_line_advance(line_increment);
+                false
+            }
+
+            LineInstruction::SetFile(file) => {
+                self.file = file;
+                false
+            }
+
+            LineInstruction::SetColumn(column) => {
+                self.column = column;
+                false
+            }
+
+            LineInstruction::NegateStatement => {
+                self.is_stmt = !self.is_stmt;
+                false
+            }
+
+            LineInstruction::SetBasicBlock => {
+                self.basic_block = true;
+                false
+            }
+
+            LineInstruction::ConstAddPc => {
+                let adjusted = self.adjust_opcode(255, program.header());
+                let operation_advance = adjusted / program.header().line_encoding.line_range;
+                self.apply_operation_advance(u64::from(operation_advance), program.header());
+                false
+            }
+
+            LineInstruction::FixedAddPc(operand) => {
+                self.address += Wrapping(u64::from(operand));
+                self.op_index.0 = 0;
+                false
+            }
+
+            LineInstruction::SetPrologueEnd => {
+                self.prologue_end = true;
+                false
+            }
+
+            LineInstruction::SetEpilogueBegin => {
+                self.epilogue_begin = true;
+                false
+            }
+
+            LineInstruction::SetIsa(isa) => {
+                self.isa = isa;
+                false
+            }
+
+            LineInstruction::EndSequence => {
+                self.end_sequence = true;
+                true
+            }
+
+            LineInstruction::SetAddress(address) => {
+                let tombstone_address = !0 >> (64 - program.header().encoding.address_size * 8);
+                self.tombstone = address == tombstone_address;
+                self.address.0 = address;
+                self.op_index.0 = 0;
+                false
+            }
+
+            LineInstruction::DefineFile(entry) => {
+                program.add_file(entry);
+                false
+            }
+
+            LineInstruction::SetDiscriminator(discriminator) => {
+                self.discriminator = discriminator;
+                false
+            }
+
+            // Compatibility with future opcodes.
+            LineInstruction::UnknownStandard0(_)
+            | LineInstruction::UnknownStandard1(_, _)
+            | LineInstruction::UnknownStandardN(_, _)
+            | LineInstruction::UnknownExtended(_, _) => false,
+        }
+    }
+
+    /// Perform any reset that was required after copying the previous row.
+    #[inline]
+    pub fn reset<R: Reader>(&mut self, header: &LineProgramHeader<R>) {
+        if self.end_sequence {
+            // Previous instruction was EndSequence, so reset everything
+            // as specified in Section 6.2.5.3.
+            *self = Self::new(header);
+        } else {
+            // Previous instruction was one of:
+            // - Special - specified in Section 6.2.5.1, steps 4-7
+            // - Copy - specified in Section 6.2.5.2
+            // The reset behaviour is the same in both cases.
+            self.discriminator = 0;
+            self.basic_block = false;
+            self.prologue_end = false;
+            self.epilogue_begin = false;
+        }
+    }
+
+    /// Step 1 of section 6.2.5.1
+    fn apply_line_advance(&mut self, line_increment: i64) {
+        if line_increment < 0 {
+            let decrement = -line_increment as u64;
+            if decrement <= self.line.0 {
+                self.line.0 -= decrement;
+            } else {
+                self.line.0 = 0;
+            }
+        } else {
+            self.line += Wrapping(line_increment as u64);
+        }
+    }
+
+    /// Step 2 of section 6.2.5.1
+    fn apply_operation_advance<R: Reader>(
+        &mut self,
+        operation_advance: u64,
+        header: &LineProgramHeader<R>,
+    ) {
+        let operation_advance = Wrapping(operation_advance);
+
+        let minimum_instruction_length = u64::from(header.line_encoding.minimum_instruction_length);
+        let minimum_instruction_length = Wrapping(minimum_instruction_length);
+
+        let maximum_operations_per_instruction =
+            u64::from(header.line_encoding.maximum_operations_per_instruction);
+        let maximum_operations_per_instruction = Wrapping(maximum_operations_per_instruction);
+
+        if maximum_operations_per_instruction.0 == 1 {
+            self.address += minimum_instruction_length * operation_advance;
+            self.op_index.0 = 0;
+        } else {
+            let op_index_with_advance = self.op_index + operation_advance;
+            self.address += minimum_instruction_length
+                * (op_index_with_advance / maximum_operations_per_instruction);
+            self.op_index = op_index_with_advance % maximum_operations_per_instruction;
+        }
+    }
+
+    #[inline]
+    fn adjust_opcode<R: Reader>(&self, opcode: u8, header: &LineProgramHeader<R>) -> u8 {
+        opcode - header.opcode_base
+    }
+
+    /// Section 6.2.5.1
+    fn exec_special_opcode<R: Reader>(&mut self, opcode: u8, header: &LineProgramHeader<R>) {
+        let adjusted_opcode = self.adjust_opcode(opcode, header);
+
+        let line_range = header.line_encoding.line_range;
+        let line_advance = adjusted_opcode % line_range;
+        let operation_advance = adjusted_opcode / line_range;
+
+        // Step 1
+        let line_base = i64::from(header.line_encoding.line_base);
+        self.apply_line_advance(line_base + i64::from(line_advance));
+
+        // Step 2
+        self.apply_operation_advance(u64::from(operation_advance), header);
+    }
+}
+
+/// The type of column that a row is referring to.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum ColumnType {
+    /// The `LeftEdge` means that the statement begins at the start of the new
+    /// line.
+    LeftEdge,
+    /// A column number, whose range begins at 1.
+    Column(NonZeroU64),
+}
+
+/// Deprecated. `LineNumberSequence` has been renamed to `LineSequence`.
+#[deprecated(note = "LineNumberSequence has been renamed to LineSequence, use that instead.")]
+pub type LineNumberSequence<R> = LineSequence<R>;
+
+/// A sequence within a line number program.  A sequence, as defined in section
+/// 6.2.5 of the standard, is a linear subset of a line number program within
+/// which addresses are monotonically increasing.
+#[derive(Clone, Debug)]
+pub struct LineSequence<R: Reader> {
+    /// The first address that is covered by this sequence within the line number
+    /// program.
+    pub start: u64,
+    /// The first address that is *not* covered by this sequence within the line
+    /// number program.
+    pub end: u64,
+    instructions: LineInstructions<R>,
+}
+
+/// Deprecated. `LineNumberProgramHeader` has been renamed to `LineProgramHeader`.
+#[deprecated(
+    note = "LineNumberProgramHeader has been renamed to LineProgramHeader, use that instead."
+)]
+pub type LineNumberProgramHeader<R, Offset> = LineProgramHeader<R, Offset>;
+
+/// A header for a line number program in the `.debug_line` section, as defined
+/// in section 6.2.4 of the standard.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct LineProgramHeader<R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    encoding: Encoding,
+    offset: DebugLineOffset<Offset>,
+    unit_length: Offset,
+
+    header_length: Offset,
+
+    line_encoding: LineEncoding,
+
+    /// "The number assigned to the first special opcode."
+    opcode_base: u8,
+
+    /// "This array specifies the number of LEB128 operands for each of the
+    /// standard opcodes. The first element of the array corresponds to the
+    /// opcode whose value is 1, and the last element corresponds to the opcode
+    /// whose value is `opcode_base - 1`."
+    standard_opcode_lengths: R,
+
+    /// "A sequence of directory entry format descriptions."
+    directory_entry_format: Vec<FileEntryFormat>,
+
+    /// > Entries in this sequence describe each path that was searched for
+    /// > included source files in this compilation. (The paths include those
+    /// > directories specified explicitly by the user for the compiler to search
+    /// > and those the compiler searches without explicit direction.) Each path
+    /// > entry is either a full path name or is relative to the current directory
+    /// > of the compilation.
+    /// >
+    /// > The last entry is followed by a single null byte.
+    include_directories: Vec<AttributeValue<R, Offset>>,
+
+    /// "A sequence of file entry format descriptions."
+    file_name_entry_format: Vec<FileEntryFormat>,
+
+    /// "Entries in this sequence describe source files that contribute to the
+    /// line number information for this compilation unit or is used in other
+    /// contexts."
+    file_names: Vec<FileEntry<R, Offset>>,
+
+    /// The encoded line program instructions.
+    program_buf: R,
+
+    /// The current directory of the compilation.
+    comp_dir: Option<R>,
+
+    /// The primary source file.
+    comp_file: Option<FileEntry<R, Offset>>,
+}
+
+impl<R, Offset> LineProgramHeader<R, Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    /// Return the offset of the line number program header in the `.debug_line` section.
+    pub fn offset(&self) -> DebugLineOffset<R::Offset> {
+        self.offset
+    }
+
+    /// Return the length of the line number program and header, not including
+    /// the length of the encoded length itself.
+    pub fn unit_length(&self) -> R::Offset {
+        self.unit_length
+    }
+
+    /// Return the encoding parameters for this header's line program.
+    pub fn encoding(&self) -> Encoding {
+        self.encoding
+    }
+
+    /// Get the version of this header's line program.
+    pub fn version(&self) -> u16 {
+        self.encoding.version
+    }
+
+    /// Get the length of the encoded line number program header, not including
+    /// the length of the encoded length itself.
+    pub fn header_length(&self) -> R::Offset {
+        self.header_length
+    }
+
+    /// Get the size in bytes of a target machine address.
+    pub fn address_size(&self) -> u8 {
+        self.encoding.address_size
+    }
+
+    /// Whether this line program is encoded in 64- or 32-bit DWARF.
+    pub fn format(&self) -> Format {
+        self.encoding.format
+    }
+
+    /// Get the line encoding parameters for this header's line program.
+    pub fn line_encoding(&self) -> LineEncoding {
+        self.line_encoding
+    }
+
+    /// Get the minimum instruction length any instruction in this header's line
+    /// program may have.
+    pub fn minimum_instruction_length(&self) -> u8 {
+        self.line_encoding.minimum_instruction_length
+    }
+
+    /// Get the maximum number of operations each instruction in this header's
+    /// line program may have.
+    pub fn maximum_operations_per_instruction(&self) -> u8 {
+        self.line_encoding.maximum_operations_per_instruction
+    }
+
+    /// Get the default value of the `is_stmt` register for this header's line
+    /// program.
+    pub fn default_is_stmt(&self) -> bool {
+        self.line_encoding.default_is_stmt
+    }
+
+    /// Get the line base for this header's line program.
+    pub fn line_base(&self) -> i8 {
+        self.line_encoding.line_base
+    }
+
+    /// Get the line range for this header's line program.
+    pub fn line_range(&self) -> u8 {
+        self.line_encoding.line_range
+    }
+
+    /// Get opcode base for this header's line program.
+    pub fn opcode_base(&self) -> u8 {
+        self.opcode_base
+    }
+
+    /// An array of `u8` that specifies the number of LEB128 operands for
+    /// each of the standard opcodes.
+    pub fn standard_opcode_lengths(&self) -> &R {
+        &self.standard_opcode_lengths
+    }
+
+    /// Get the format of a directory entry.
+    pub fn directory_entry_format(&self) -> &[FileEntryFormat] {
+        &self.directory_entry_format[..]
+    }
+
+    /// Get the set of include directories for this header's line program.
+    ///
+    /// For DWARF version <= 4, the compilation's current directory is not included
+    /// in the return value, but is implicitly considered to be in the set per spec.
+    pub fn include_directories(&self) -> &[AttributeValue<R, Offset>] {
+        &self.include_directories[..]
+    }
+
+    /// The include directory with the given directory index.
+    ///
+    /// A directory index of 0 corresponds to the compilation unit directory.
+    pub fn directory(&self, directory: u64) -> Option<AttributeValue<R, Offset>> {
+        if self.encoding.version <= 4 {
+            if directory == 0 {
+                self.comp_dir.clone().map(AttributeValue::String)
+            } else {
+                let directory = directory as usize - 1;
+                self.include_directories.get(directory).cloned()
+            }
+        } else {
+            self.include_directories.get(directory as usize).cloned()
+        }
+    }
+
+    /// Get the format of a file name entry.
+    pub fn file_name_entry_format(&self) -> &[FileEntryFormat] {
+        &self.file_name_entry_format[..]
+    }
+
+    /// Return true if the file entries may have valid timestamps.
+    ///
+    /// Only returns false if we definitely know that all timestamp fields
+    /// are invalid.
+    pub fn file_has_timestamp(&self) -> bool {
+        self.encoding.version <= 4
+            || self
+                .file_name_entry_format
+                .iter()
+                .any(|x| x.content_type == constants::DW_LNCT_timestamp)
+    }
+
+    /// Return true if the file entries may have valid sizes.
+    ///
+    /// Only returns false if we definitely know that all size fields
+    /// are invalid.
+    pub fn file_has_size(&self) -> bool {
+        self.encoding.version <= 4
+            || self
+                .file_name_entry_format
+                .iter()
+                .any(|x| x.content_type == constants::DW_LNCT_size)
+    }
+
+    /// Return true if the file name entry format contains an MD5 field.
+    pub fn file_has_md5(&self) -> bool {
+        self.file_name_entry_format
+            .iter()
+            .any(|x| x.content_type == constants::DW_LNCT_MD5)
+    }
+
+    /// Get the list of source files that appear in this header's line program.
+    pub fn file_names(&self) -> &[FileEntry<R, Offset>] {
+        &self.file_names[..]
+    }
+
+    /// The source file with the given file index.
+    ///
+    /// A file index of 0 corresponds to the compilation unit file.
+    /// Note that a file index of 0 is invalid for DWARF version <= 4,
+    /// but we support it anyway.
+    pub fn file(&self, file: u64) -> Option<&FileEntry<R, Offset>> {
+        if self.encoding.version <= 4 {
+            if file == 0 {
+                self.comp_file.as_ref()
+            } else {
+                let file = file as usize - 1;
+                self.file_names.get(file)
+            }
+        } else {
+            self.file_names.get(file as usize)
+        }
+    }
+
+    /// Get the raw, un-parsed `EndianSlice` containing this header's line number
+    /// program.
+    ///
+    /// ```
+    /// # fn foo() {
+    /// use gimli::{LineProgramHeader, EndianSlice, NativeEndian};
+    ///
+    /// fn get_line_number_program_header<'a>() -> LineProgramHeader<EndianSlice<'a, NativeEndian>> {
+    ///     // Get a line number program header from some offset in a
+    ///     // `.debug_line` section...
+    /// #   unimplemented!()
+    /// }
+    ///
+    /// let header = get_line_number_program_header();
+    /// let raw_program = header.raw_program_buf();
+    /// println!("The length of the raw program in bytes is {}", raw_program.len());
+    /// # }
+    /// ```
+    pub fn raw_program_buf(&self) -> R {
+        self.program_buf.clone()
+    }
+
+    /// Iterate over the instructions in this header's line number program, parsing
+    /// them as we go.
+    pub fn instructions(&self) -> LineInstructions<R> {
+        LineInstructions {
+            input: self.program_buf.clone(),
+        }
+    }
+
+    fn parse(
+        input: &mut R,
+        offset: DebugLineOffset<Offset>,
+        mut address_size: u8,
+        mut comp_dir: Option<R>,
+        comp_name: Option<R>,
+    ) -> Result<LineProgramHeader<R, Offset>> {
+        let (unit_length, format) = input.read_initial_length()?;
+        let rest = &mut input.split(unit_length)?;
+
+        let version = rest.read_u16()?;
+        if version < 2 || version > 5 {
+            return Err(Error::UnknownVersion(u64::from(version)));
+        }
+
+        if version >= 5 {
+            address_size = rest.read_u8()?;
+            let segment_selector_size = rest.read_u8()?;
+            if segment_selector_size != 0 {
+                return Err(Error::UnsupportedSegmentSize);
+            }
+        }
+
+        let encoding = Encoding {
+            format,
+            version,
+            address_size,
+        };
+
+        let header_length = rest.read_length(format)?;
+
+        let mut program_buf = rest.clone();
+        program_buf.skip(header_length)?;
+        rest.truncate(header_length)?;
+
+        let minimum_instruction_length = rest.read_u8()?;
+        if minimum_instruction_length == 0 {
+            return Err(Error::MinimumInstructionLengthZero);
+        }
+
+        // This field did not exist before DWARF 4, but is specified to be 1 for
+        // non-VLIW architectures, which makes it a no-op.
+        let maximum_operations_per_instruction = if version >= 4 { rest.read_u8()? } else { 1 };
+        if maximum_operations_per_instruction == 0 {
+            return Err(Error::MaximumOperationsPerInstructionZero);
+        }
+
+        let default_is_stmt = rest.read_u8()? != 0;
+        let line_base = rest.read_i8()?;
+        let line_range = rest.read_u8()?;
+        if line_range == 0 {
+            return Err(Error::LineRangeZero);
+        }
+        let line_encoding = LineEncoding {
+            minimum_instruction_length,
+            maximum_operations_per_instruction,
+            default_is_stmt,
+            line_base,
+            line_range,
+        };
+
+        let opcode_base = rest.read_u8()?;
+        if opcode_base == 0 {
+            return Err(Error::OpcodeBaseZero);
+        }
+
+        let standard_opcode_count = R::Offset::from_u8(opcode_base - 1);
+        let standard_opcode_lengths = rest.split(standard_opcode_count)?;
+
+        let directory_entry_format;
+        let mut include_directories = Vec::new();
+        if version <= 4 {
+            directory_entry_format = Vec::new();
+            loop {
+                let directory = rest.read_null_terminated_slice()?;
+                if directory.is_empty() {
+                    break;
+                }
+                include_directories.push(AttributeValue::String(directory));
+            }
+        } else {
+            comp_dir = None;
+            directory_entry_format = FileEntryFormat::parse(rest)?;
+            let count = rest.read_uleb128()?;
+            for _ in 0..count {
+                include_directories.push(parse_directory_v5(
+                    rest,
+                    encoding,
+                    &directory_entry_format,
+                )?);
+            }
+        }
+
+        let comp_file;
+        let file_name_entry_format;
+        let mut file_names = Vec::new();
+        if version <= 4 {
+            comp_file = comp_name.map(|name| FileEntry {
+                path_name: AttributeValue::String(name),
+                directory_index: 0,
+                timestamp: 0,
+                size: 0,
+                md5: [0; 16],
+            });
+
+            file_name_entry_format = Vec::new();
+            loop {
+                let path_name = rest.read_null_terminated_slice()?;
+                if path_name.is_empty() {
+                    break;
+                }
+                file_names.push(FileEntry::parse(rest, path_name)?);
+            }
+        } else {
+            comp_file = None;
+            file_name_entry_format = FileEntryFormat::parse(rest)?;
+            let count = rest.read_uleb128()?;
+            for _ in 0..count {
+                file_names.push(parse_file_v5(rest, encoding, &file_name_entry_format)?);
+            }
+        }
+
+        let header = LineProgramHeader {
+            encoding,
+            offset,
+            unit_length,
+            header_length,
+            line_encoding,
+            opcode_base,
+            standard_opcode_lengths,
+            directory_entry_format,
+            include_directories,
+            file_name_entry_format,
+            file_names,
+            program_buf,
+            comp_dir,
+            comp_file,
+        };
+        Ok(header)
+    }
+}
+
+/// Deprecated. `IncompleteLineNumberProgram` has been renamed to `IncompleteLineProgram`.
+#[deprecated(
+    note = "IncompleteLineNumberProgram has been renamed to IncompleteLineProgram, use that instead."
+)]
+pub type IncompleteLineNumberProgram<R, Offset> = IncompleteLineProgram<R, Offset>;
+
+/// A line number program that has not been run to completion.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct IncompleteLineProgram<R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    header: LineProgramHeader<R, Offset>,
+}
+
+impl<R, Offset> IncompleteLineProgram<R, Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    /// Retrieve the `LineProgramHeader` for this program.
+    pub fn header(&self) -> &LineProgramHeader<R, Offset> {
+        &self.header
+    }
+
+    /// Construct a new `LineRows` for executing this program to iterate
+    /// over rows in the line information matrix.
+    pub fn rows(self) -> OneShotLineRows<R, Offset> {
+        OneShotLineRows::new(self)
+    }
+
+    /// Execute the line number program, completing the `IncompleteLineProgram`
+    /// into a `CompleteLineProgram` and producing an array of sequences within
+    /// the line number program that can later be used with
+    /// `CompleteLineProgram::resume_from`.
+    ///
+    /// ```
+    /// # fn foo() {
+    /// use gimli::{IncompleteLineProgram, EndianSlice, NativeEndian};
+    ///
+    /// fn get_line_number_program<'a>() -> IncompleteLineProgram<EndianSlice<'a, NativeEndian>> {
+    ///     // Get a line number program from some offset in a
+    ///     // `.debug_line` section...
+    /// #   unimplemented!()
+    /// }
+    ///
+    /// let program = get_line_number_program();
+    /// let (program, sequences) = program.sequences().unwrap();
+    /// println!("There are {} sequences in this line number program", sequences.len());
+    /// # }
+    /// ```
+    #[allow(clippy::type_complexity)]
+    pub fn sequences(self) -> Result<(CompleteLineProgram<R, Offset>, Vec<LineSequence<R>>)> {
+        let mut sequences = Vec::new();
+        let mut rows = self.rows();
+        let mut instructions = rows.instructions.clone();
+        let mut sequence_start_addr = None;
+        loop {
+            let sequence_end_addr;
+            if rows.next_row()?.is_none() {
+                break;
+            }
+
+            let row = &rows.row;
+            if row.end_sequence() {
+                sequence_end_addr = row.address();
+            } else if sequence_start_addr.is_none() {
+                sequence_start_addr = Some(row.address());
+                continue;
+            } else {
+                continue;
+            }
+
+            // We just finished a sequence.
+            sequences.push(LineSequence {
+                // In theory one could have multiple DW_LNE_end_sequence instructions
+                // in a row.
+                start: sequence_start_addr.unwrap_or(0),
+                end: sequence_end_addr,
+                instructions: instructions.remove_trailing(&rows.instructions)?,
+            });
+            sequence_start_addr = None;
+            instructions = rows.instructions.clone();
+        }
+
+        let program = CompleteLineProgram {
+            header: rows.program.header,
+        };
+        Ok((program, sequences))
+    }
+}
+
+/// Deprecated. `CompleteLineNumberProgram` has been renamed to `CompleteLineProgram`.
+#[deprecated(
+    note = "CompleteLineNumberProgram has been renamed to CompleteLineProgram, use that instead."
+)]
+pub type CompleteLineNumberProgram<R, Offset> = CompleteLineProgram<R, Offset>;
+
+/// A line number program that has previously been run to completion.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct CompleteLineProgram<R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    header: LineProgramHeader<R, Offset>,
+}
+
+impl<R, Offset> CompleteLineProgram<R, Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    /// Retrieve the `LineProgramHeader` for this program.
+    pub fn header(&self) -> &LineProgramHeader<R, Offset> {
+        &self.header
+    }
+
+    /// Construct a new `LineRows` for executing the subset of the line
+    /// number program identified by 'sequence' and  generating the line information
+    /// matrix.
+    ///
+    /// ```
+    /// # fn foo() {
+    /// use gimli::{IncompleteLineProgram, EndianSlice, NativeEndian};
+    ///
+    /// fn get_line_number_program<'a>() -> IncompleteLineProgram<EndianSlice<'a, NativeEndian>> {
+    ///     // Get a line number program from some offset in a
+    ///     // `.debug_line` section...
+    /// #   unimplemented!()
+    /// }
+    ///
+    /// let program = get_line_number_program();
+    /// let (program, sequences) = program.sequences().unwrap();
+    /// for sequence in &sequences {
+    ///     let mut sm = program.resume_from(sequence);
+    /// }
+    /// # }
+    /// ```
+    pub fn resume_from<'program>(
+        &'program self,
+        sequence: &LineSequence<R>,
+    ) -> ResumedLineRows<'program, R, Offset> {
+        ResumedLineRows::resume(self, sequence)
+    }
+}
+
+/// An entry in the `LineProgramHeader`'s `file_names` set.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct FileEntry<R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    path_name: AttributeValue<R, Offset>,
+    directory_index: u64,
+    timestamp: u64,
+    size: u64,
+    md5: [u8; 16],
+}
+
+impl<R, Offset> FileEntry<R, Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    // version 2-4
+    fn parse(input: &mut R, path_name: R) -> Result<FileEntry<R, Offset>> {
+        let directory_index = input.read_uleb128()?;
+        let timestamp = input.read_uleb128()?;
+        let size = input.read_uleb128()?;
+
+        let entry = FileEntry {
+            path_name: AttributeValue::String(path_name),
+            directory_index,
+            timestamp,
+            size,
+            md5: [0; 16],
+        };
+
+        Ok(entry)
+    }
+
+    /// > A slice containing the full or relative path name of
+    /// > a source file. If the entry contains a file name or a relative path
+    /// > name, the file is located relative to either the compilation directory
+    /// > (as specified by the DW_AT_comp_dir attribute given in the compilation
+    /// > unit) or one of the directories in the include_directories section.
+    pub fn path_name(&self) -> AttributeValue<R, Offset> {
+        self.path_name.clone()
+    }
+
+    /// > An unsigned LEB128 number representing the directory index of the
+    /// > directory in which the file was found.
+    /// >
+    /// > ...
+    /// >
+    /// > The directory index represents an entry in the include_directories
+    /// > section of the line number program header. The index is 0 if the file
+    /// > was found in the current directory of the compilation, 1 if it was found
+    /// > in the first directory in the include_directories section, and so
+    /// > on. The directory index is ignored for file names that represent full
+    /// > path names.
+    pub fn directory_index(&self) -> u64 {
+        self.directory_index
+    }
+
+    /// Get this file's directory.
+    ///
+    /// A directory index of 0 corresponds to the compilation unit directory.
+    pub fn directory(&self, header: &LineProgramHeader<R>) -> Option<AttributeValue<R, Offset>> {
+        header.directory(self.directory_index)
+    }
+
+    /// The implementation-defined time of last modification of the file,
+    /// or 0 if not available.
+    pub fn timestamp(&self) -> u64 {
+        self.timestamp
+    }
+
+    /// "An unsigned LEB128 number representing the time of last modification of
+    /// the file, or 0 if not available."
+    // Terminology changed in DWARF version 5.
+    #[doc(hidden)]
+    pub fn last_modification(&self) -> u64 {
+        self.timestamp
+    }
+
+    /// The size of the file in bytes, or 0 if not available.
+    pub fn size(&self) -> u64 {
+        self.size
+    }
+
+    /// "An unsigned LEB128 number representing the length in bytes of the file,
+    /// or 0 if not available."
+    // Terminology changed in DWARF version 5.
+    #[doc(hidden)]
+    pub fn length(&self) -> u64 {
+        self.size
+    }
+
+    /// A 16-byte MD5 digest of the file contents.
+    ///
+    /// Only valid if `LineProgramHeader::file_has_md5` returns `true`.
+    pub fn md5(&self) -> &[u8; 16] {
+        &self.md5
+    }
+}
+
+/// The format of a component of an include directory or file name entry.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct FileEntryFormat {
+    /// The type of information that is represented by the component.
+    pub content_type: constants::DwLnct,
+
+    /// The encoding form of the component value.
+    pub form: constants::DwForm,
+}
+
+impl FileEntryFormat {
+    fn parse<R: Reader>(input: &mut R) -> Result<Vec<FileEntryFormat>> {
+        let format_count = input.read_u8()? as usize;
+        let mut format = Vec::with_capacity(format_count);
+        let mut path_count = 0;
+        for _ in 0..format_count {
+            let content_type = input.read_uleb128()?;
+            let content_type = if content_type > u64::from(u16::max_value()) {
+                constants::DwLnct(u16::max_value())
+            } else {
+                constants::DwLnct(content_type as u16)
+            };
+            if content_type == constants::DW_LNCT_path {
+                path_count += 1;
+            }
+
+            let form = constants::DwForm(input.read_uleb128_u16()?);
+
+            format.push(FileEntryFormat { content_type, form });
+        }
+        if path_count != 1 {
+            return Err(Error::MissingFileEntryFormatPath);
+        }
+        Ok(format)
+    }
+}
+
+fn parse_directory_v5<R: Reader>(
+    input: &mut R,
+    encoding: Encoding,
+    formats: &[FileEntryFormat],
+) -> Result<AttributeValue<R>> {
+    let mut path_name = None;
+
+    for format in formats {
+        let value = parse_attribute(input, encoding, format.form)?;
+        if format.content_type == constants::DW_LNCT_path {
+            path_name = Some(value);
+        }
+    }
+
+    Ok(path_name.unwrap())
+}
+
+fn parse_file_v5<R: Reader>(
+    input: &mut R,
+    encoding: Encoding,
+    formats: &[FileEntryFormat],
+) -> Result<FileEntry<R>> {
+    let mut path_name = None;
+    let mut directory_index = 0;
+    let mut timestamp = 0;
+    let mut size = 0;
+    let mut md5 = [0; 16];
+
+    for format in formats {
+        let value = parse_attribute(input, encoding, format.form)?;
+        match format.content_type {
+            constants::DW_LNCT_path => path_name = Some(value),
+            constants::DW_LNCT_directory_index => {
+                if let Some(value) = value.udata_value() {
+                    directory_index = value;
+                }
+            }
+            constants::DW_LNCT_timestamp => {
+                if let Some(value) = value.udata_value() {
+                    timestamp = value;
+                }
+            }
+            constants::DW_LNCT_size => {
+                if let Some(value) = value.udata_value() {
+                    size = value;
+                }
+            }
+            constants::DW_LNCT_MD5 => {
+                if let AttributeValue::Block(mut value) = value {
+                    if value.len().into_u64() == 16 {
+                        md5 = value.read_u8_array()?;
+                    }
+                }
+            }
+            // Ignore unknown content types.
+            _ => {}
+        }
+    }
+
+    Ok(FileEntry {
+        path_name: path_name.unwrap(),
+        directory_index,
+        timestamp,
+        size,
+        md5,
+    })
+}
+
+// TODO: this should be shared with unit::parse_attribute(), but that is hard to do.
+fn parse_attribute<R: Reader>(
+    input: &mut R,
+    encoding: Encoding,
+    form: constants::DwForm,
+) -> Result<AttributeValue<R>> {
+    Ok(match form {
+        constants::DW_FORM_block1 => {
+            let len = input.read_u8().map(R::Offset::from_u8)?;
+            let block = input.split(len)?;
+            AttributeValue::Block(block)
+        }
+        constants::DW_FORM_block2 => {
+            let len = input.read_u16().map(R::Offset::from_u16)?;
+            let block = input.split(len)?;
+            AttributeValue::Block(block)
+        }
+        constants::DW_FORM_block4 => {
+            let len = input.read_u32().map(R::Offset::from_u32)?;
+            let block = input.split(len)?;
+            AttributeValue::Block(block)
+        }
+        constants::DW_FORM_block => {
+            let len = input.read_uleb128().and_then(R::Offset::from_u64)?;
+            let block = input.split(len)?;
+            AttributeValue::Block(block)
+        }
+        constants::DW_FORM_data1 => {
+            let data = input.read_u8()?;
+            AttributeValue::Data1(data)
+        }
+        constants::DW_FORM_data2 => {
+            let data = input.read_u16()?;
+            AttributeValue::Data2(data)
+        }
+        constants::DW_FORM_data4 => {
+            let data = input.read_u32()?;
+            AttributeValue::Data4(data)
+        }
+        constants::DW_FORM_data8 => {
+            let data = input.read_u64()?;
+            AttributeValue::Data8(data)
+        }
+        constants::DW_FORM_data16 => {
+            let block = input.split(R::Offset::from_u8(16))?;
+            AttributeValue::Block(block)
+        }
+        constants::DW_FORM_udata => {
+            let data = input.read_uleb128()?;
+            AttributeValue::Udata(data)
+        }
+        constants::DW_FORM_sdata => {
+            let data = input.read_sleb128()?;
+            AttributeValue::Sdata(data)
+        }
+        constants::DW_FORM_flag => {
+            let present = input.read_u8()?;
+            AttributeValue::Flag(present != 0)
+        }
+        constants::DW_FORM_sec_offset => {
+            let offset = input.read_offset(encoding.format)?;
+            AttributeValue::SecOffset(offset)
+        }
+        constants::DW_FORM_string => {
+            let string = input.read_null_terminated_slice()?;
+            AttributeValue::String(string)
+        }
+        constants::DW_FORM_strp => {
+            let offset = input.read_offset(encoding.format)?;
+            AttributeValue::DebugStrRef(DebugStrOffset(offset))
+        }
+        constants::DW_FORM_strp_sup | constants::DW_FORM_GNU_strp_alt => {
+            let offset = input.read_offset(encoding.format)?;
+            AttributeValue::DebugStrRefSup(DebugStrOffset(offset))
+        }
+        constants::DW_FORM_line_strp => {
+            let offset = input.read_offset(encoding.format)?;
+            AttributeValue::DebugLineStrRef(DebugLineStrOffset(offset))
+        }
+        constants::DW_FORM_strx | constants::DW_FORM_GNU_str_index => {
+            let index = input.read_uleb128().and_then(R::Offset::from_u64)?;
+            AttributeValue::DebugStrOffsetsIndex(DebugStrOffsetsIndex(index))
+        }
+        constants::DW_FORM_strx1 => {
+            let index = input.read_u8().map(R::Offset::from_u8)?;
+            AttributeValue::DebugStrOffsetsIndex(DebugStrOffsetsIndex(index))
+        }
+        constants::DW_FORM_strx2 => {
+            let index = input.read_u16().map(R::Offset::from_u16)?;
+            AttributeValue::DebugStrOffsetsIndex(DebugStrOffsetsIndex(index))
+        }
+        constants::DW_FORM_strx3 => {
+            let index = input.read_uint(3).and_then(R::Offset::from_u64)?;
+            AttributeValue::DebugStrOffsetsIndex(DebugStrOffsetsIndex(index))
+        }
+        constants::DW_FORM_strx4 => {
+            let index = input.read_u32().map(R::Offset::from_u32)?;
+            AttributeValue::DebugStrOffsetsIndex(DebugStrOffsetsIndex(index))
+        }
+        _ => {
+            return Err(Error::UnknownForm);
+        }
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::constants;
+    use crate::endianity::LittleEndian;
+    use crate::read::{EndianSlice, Error};
+    use crate::test_util::GimliSectionMethods;
+    use core::u64;
+    use core::u8;
+    use test_assembler::{Endian, Label, LabelMaker, Section};
+
+    #[test]
+    fn test_parse_debug_line_32_ok() {
+        #[rustfmt::skip]
+        let buf = [
+            // 32-bit length = 62.
+            0x3e, 0x00, 0x00, 0x00,
+            // Version.
+            0x04, 0x00,
+            // Header length = 40.
+            0x28, 0x00, 0x00, 0x00,
+            // Minimum instruction length.
+            0x01,
+            // Maximum operations per byte.
+            0x01,
+            // Default is_stmt.
+            0x01,
+            // Line base.
+            0x00,
+            // Line range.
+            0x01,
+            // Opcode base.
+            0x03,
+            // Standard opcode lengths for opcodes 1 .. opcode base - 1.
+            0x01, 0x02,
+            // Include directories = '/', 'i', 'n', 'c', '\0', '/', 'i', 'n', 'c', '2', '\0', '\0'
+            0x2f, 0x69, 0x6e, 0x63, 0x00, 0x2f, 0x69, 0x6e, 0x63, 0x32, 0x00, 0x00,
+            // File names
+                // foo.rs
+                0x66, 0x6f, 0x6f, 0x2e, 0x72, 0x73, 0x00,
+                0x00,
+                0x00,
+                0x00,
+                // bar.h
+                0x62, 0x61, 0x72, 0x2e, 0x68, 0x00,
+                0x01,
+                0x00,
+                0x00,
+            // End file names.
+            0x00,
+
+            // Dummy line program data.
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+
+            // Dummy next line program.
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+        ];
+
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+        let comp_dir = EndianSlice::new(b"/comp_dir", LittleEndian);
+        let comp_name = EndianSlice::new(b"/comp_name", LittleEndian);
+
+        let header =
+            LineProgramHeader::parse(rest, DebugLineOffset(0), 4, Some(comp_dir), Some(comp_name))
+                .expect("should parse header ok");
+
+        assert_eq!(
+            *rest,
+            EndianSlice::new(&buf[buf.len() - 16..], LittleEndian)
+        );
+
+        assert_eq!(header.offset, DebugLineOffset(0));
+        assert_eq!(header.version(), 4);
+        assert_eq!(header.minimum_instruction_length(), 1);
+        assert_eq!(header.maximum_operations_per_instruction(), 1);
+        assert_eq!(header.default_is_stmt(), true);
+        assert_eq!(header.line_base(), 0);
+        assert_eq!(header.line_range(), 1);
+        assert_eq!(header.opcode_base(), 3);
+        assert_eq!(header.directory(0), Some(AttributeValue::String(comp_dir)));
+        assert_eq!(
+            header.file(0).unwrap().path_name,
+            AttributeValue::String(comp_name)
+        );
+
+        let expected_lengths = [1, 2];
+        assert_eq!(header.standard_opcode_lengths().slice(), &expected_lengths);
+
+        let expected_include_directories = [
+            AttributeValue::String(EndianSlice::new(b"/inc", LittleEndian)),
+            AttributeValue::String(EndianSlice::new(b"/inc2", LittleEndian)),
+        ];
+        assert_eq!(header.include_directories(), &expected_include_directories);
+
+        let expected_file_names = [
+            FileEntry {
+                path_name: AttributeValue::String(EndianSlice::new(b"foo.rs", LittleEndian)),
+                directory_index: 0,
+                timestamp: 0,
+                size: 0,
+                md5: [0; 16],
+            },
+            FileEntry {
+                path_name: AttributeValue::String(EndianSlice::new(b"bar.h", LittleEndian)),
+                directory_index: 1,
+                timestamp: 0,
+                size: 0,
+                md5: [0; 16],
+            },
+        ];
+        assert_eq!(&*header.file_names(), &expected_file_names);
+    }
+
+    #[test]
+    fn test_parse_debug_line_header_length_too_short() {
+        #[rustfmt::skip]
+        let buf = [
+            // 32-bit length = 62.
+            0x3e, 0x00, 0x00, 0x00,
+            // Version.
+            0x04, 0x00,
+            // Header length = 20. TOO SHORT!!!
+            0x15, 0x00, 0x00, 0x00,
+            // Minimum instruction length.
+            0x01,
+            // Maximum operations per byte.
+            0x01,
+            // Default is_stmt.
+            0x01,
+            // Line base.
+            0x00,
+            // Line range.
+            0x01,
+            // Opcode base.
+            0x03,
+            // Standard opcode lengths for opcodes 1 .. opcode base - 1.
+            0x01, 0x02,
+            // Include directories = '/', 'i', 'n', 'c', '\0', '/', 'i', 'n', 'c', '2', '\0', '\0'
+            0x2f, 0x69, 0x6e, 0x63, 0x00, 0x2f, 0x69, 0x6e, 0x63, 0x32, 0x00, 0x00,
+            // File names
+                // foo.rs
+                0x66, 0x6f, 0x6f, 0x2e, 0x72, 0x73, 0x00,
+                0x00,
+                0x00,
+                0x00,
+                // bar.h
+                0x62, 0x61, 0x72, 0x2e, 0x68, 0x00,
+                0x01,
+                0x00,
+                0x00,
+            // End file names.
+            0x00,
+
+            // Dummy line program data.
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+
+            // Dummy next line program.
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+        ];
+
+        let input = &mut EndianSlice::new(&buf, LittleEndian);
+
+        match LineProgramHeader::parse(input, DebugLineOffset(0), 4, None, None) {
+            Err(Error::UnexpectedEof(_)) => return,
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        }
+    }
+
+    #[test]
+    fn test_parse_debug_line_unit_length_too_short() {
+        #[rustfmt::skip]
+        let buf = [
+            // 32-bit length = 40. TOO SHORT!!!
+            0x28, 0x00, 0x00, 0x00,
+            // Version.
+            0x04, 0x00,
+            // Header length = 40.
+            0x28, 0x00, 0x00, 0x00,
+            // Minimum instruction length.
+            0x01,
+            // Maximum operations per byte.
+            0x01,
+            // Default is_stmt.
+            0x01,
+            // Line base.
+            0x00,
+            // Line range.
+            0x01,
+            // Opcode base.
+            0x03,
+            // Standard opcode lengths for opcodes 1 .. opcode base - 1.
+            0x01, 0x02,
+            // Include directories = '/', 'i', 'n', 'c', '\0', '/', 'i', 'n', 'c', '2', '\0', '\0'
+            0x2f, 0x69, 0x6e, 0x63, 0x00, 0x2f, 0x69, 0x6e, 0x63, 0x32, 0x00, 0x00,
+            // File names
+                // foo.rs
+                0x66, 0x6f, 0x6f, 0x2e, 0x72, 0x73, 0x00,
+                0x00,
+                0x00,
+                0x00,
+                // bar.h
+                0x62, 0x61, 0x72, 0x2e, 0x68, 0x00,
+                0x01,
+                0x00,
+                0x00,
+            // End file names.
+            0x00,
+
+            // Dummy line program data.
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+
+            // Dummy next line program.
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+        ];
+
+        let input = &mut EndianSlice::new(&buf, LittleEndian);
+
+        match LineProgramHeader::parse(input, DebugLineOffset(0), 4, None, None) {
+            Err(Error::UnexpectedEof(_)) => return,
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        }
+    }
+
+    const OPCODE_BASE: u8 = 13;
+    const STANDARD_OPCODE_LENGTHS: &[u8] = &[0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1];
+
+    fn make_test_header(
+        buf: EndianSlice<LittleEndian>,
+    ) -> LineProgramHeader<EndianSlice<LittleEndian>> {
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 8,
+        };
+        let line_encoding = LineEncoding {
+            line_base: -3,
+            line_range: 12,
+            ..Default::default()
+        };
+        LineProgramHeader {
+            encoding,
+            offset: DebugLineOffset(0),
+            unit_length: 1,
+            header_length: 1,
+            line_encoding,
+            opcode_base: OPCODE_BASE,
+            standard_opcode_lengths: EndianSlice::new(STANDARD_OPCODE_LENGTHS, LittleEndian),
+            file_names: vec![
+                FileEntry {
+                    path_name: AttributeValue::String(EndianSlice::new(b"foo.c", LittleEndian)),
+                    directory_index: 0,
+                    timestamp: 0,
+                    size: 0,
+                    md5: [0; 16],
+                },
+                FileEntry {
+                    path_name: AttributeValue::String(EndianSlice::new(b"bar.rs", LittleEndian)),
+                    directory_index: 0,
+                    timestamp: 0,
+                    size: 0,
+                    md5: [0; 16],
+                },
+            ],
+            include_directories: vec![],
+            directory_entry_format: vec![],
+            file_name_entry_format: vec![],
+            program_buf: buf,
+            comp_dir: None,
+            comp_file: None,
+        }
+    }
+
+    fn make_test_program(
+        buf: EndianSlice<LittleEndian>,
+    ) -> IncompleteLineProgram<EndianSlice<LittleEndian>> {
+        IncompleteLineProgram {
+            header: make_test_header(buf),
+        }
+    }
+
+    #[test]
+    fn test_parse_special_opcodes() {
+        for i in OPCODE_BASE..u8::MAX {
+            let input = [i, 0, 0, 0];
+            let input = EndianSlice::new(&input, LittleEndian);
+            let header = make_test_header(input);
+
+            let mut rest = input;
+            let opcode =
+                LineInstruction::parse(&header, &mut rest).expect("Should parse the opcode OK");
+
+            assert_eq!(*rest, *input.range_from(1..));
+            assert_eq!(opcode, LineInstruction::Special(i));
+        }
+    }
+
+    #[test]
+    fn test_parse_standard_opcodes() {
+        fn test<Operands>(
+            raw: constants::DwLns,
+            operands: Operands,
+            expected: LineInstruction<EndianSlice<LittleEndian>>,
+        ) where
+            Operands: AsRef<[u8]>,
+        {
+            let mut input = Vec::new();
+            input.push(raw.0);
+            input.extend_from_slice(operands.as_ref());
+
+            let expected_rest = [0, 1, 2, 3, 4];
+            input.extend_from_slice(&expected_rest);
+
+            let input = EndianSlice::new(&*input, LittleEndian);
+            let header = make_test_header(input);
+
+            let mut rest = input;
+            let opcode =
+                LineInstruction::parse(&header, &mut rest).expect("Should parse the opcode OK");
+
+            assert_eq!(opcode, expected);
+            assert_eq!(*rest, expected_rest);
+        }
+
+        test(constants::DW_LNS_copy, [], LineInstruction::Copy);
+        test(
+            constants::DW_LNS_advance_pc,
+            [42],
+            LineInstruction::AdvancePc(42),
+        );
+        test(
+            constants::DW_LNS_advance_line,
+            [9],
+            LineInstruction::AdvanceLine(9),
+        );
+        test(constants::DW_LNS_set_file, [7], LineInstruction::SetFile(7));
+        test(
+            constants::DW_LNS_set_column,
+            [1],
+            LineInstruction::SetColumn(1),
+        );
+        test(
+            constants::DW_LNS_negate_stmt,
+            [],
+            LineInstruction::NegateStatement,
+        );
+        test(
+            constants::DW_LNS_set_basic_block,
+            [],
+            LineInstruction::SetBasicBlock,
+        );
+        test(
+            constants::DW_LNS_const_add_pc,
+            [],
+            LineInstruction::ConstAddPc,
+        );
+        test(
+            constants::DW_LNS_fixed_advance_pc,
+            [42, 0],
+            LineInstruction::FixedAddPc(42),
+        );
+        test(
+            constants::DW_LNS_set_prologue_end,
+            [],
+            LineInstruction::SetPrologueEnd,
+        );
+        test(
+            constants::DW_LNS_set_isa,
+            [57 + 0x80, 100],
+            LineInstruction::SetIsa(12857),
+        );
+    }
+
+    #[test]
+    fn test_parse_unknown_standard_opcode_no_args() {
+        let input = [OPCODE_BASE, 1, 2, 3];
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut standard_opcode_lengths = Vec::new();
+        let mut header = make_test_header(input);
+        standard_opcode_lengths.extend(header.standard_opcode_lengths.slice());
+        standard_opcode_lengths.push(0);
+        header.opcode_base += 1;
+        header.standard_opcode_lengths = EndianSlice::new(&standard_opcode_lengths, LittleEndian);
+
+        let mut rest = input;
+        let opcode =
+            LineInstruction::parse(&header, &mut rest).expect("Should parse the opcode OK");
+
+        assert_eq!(
+            opcode,
+            LineInstruction::UnknownStandard0(constants::DwLns(OPCODE_BASE))
+        );
+        assert_eq!(*rest, *input.range_from(1..));
+    }
+
+    #[test]
+    fn test_parse_unknown_standard_opcode_one_arg() {
+        let input = [OPCODE_BASE, 1, 2, 3];
+        let input = EndianSlice::new(&input, LittleEndian);
+        let mut standard_opcode_lengths = Vec::new();
+        let mut header = make_test_header(input);
+        standard_opcode_lengths.extend(header.standard_opcode_lengths.slice());
+        standard_opcode_lengths.push(1);
+        header.opcode_base += 1;
+        header.standard_opcode_lengths = EndianSlice::new(&standard_opcode_lengths, LittleEndian);
+
+        let mut rest = input;
+        let opcode =
+            LineInstruction::parse(&header, &mut rest).expect("Should parse the opcode OK");
+
+        assert_eq!(
+            opcode,
+            LineInstruction::UnknownStandard1(constants::DwLns(OPCODE_BASE), 1)
+        );
+        assert_eq!(*rest, *input.range_from(2..));
+    }
+
+    #[test]
+    fn test_parse_unknown_standard_opcode_many_args() {
+        let input = [OPCODE_BASE, 1, 2, 3];
+        let input = EndianSlice::new(&input, LittleEndian);
+        let args = input.range_from(1..);
+        let mut standard_opcode_lengths = Vec::new();
+        let mut header = make_test_header(input);
+        standard_opcode_lengths.extend(header.standard_opcode_lengths.slice());
+        standard_opcode_lengths.push(3);
+        header.opcode_base += 1;
+        header.standard_opcode_lengths = EndianSlice::new(&standard_opcode_lengths, LittleEndian);
+
+        let mut rest = input;
+        let opcode =
+            LineInstruction::parse(&header, &mut rest).expect("Should parse the opcode OK");
+
+        assert_eq!(
+            opcode,
+            LineInstruction::UnknownStandardN(constants::DwLns(OPCODE_BASE), args)
+        );
+        assert_eq!(*rest, []);
+    }
+
+    #[test]
+    fn test_parse_extended_opcodes() {
+        fn test<Operands>(
+            raw: constants::DwLne,
+            operands: Operands,
+            expected: LineInstruction<EndianSlice<LittleEndian>>,
+        ) where
+            Operands: AsRef<[u8]>,
+        {
+            let mut input = Vec::new();
+            input.push(0);
+
+            let operands = operands.as_ref();
+            input.push(1 + operands.len() as u8);
+
+            input.push(raw.0);
+            input.extend_from_slice(operands);
+
+            let expected_rest = [0, 1, 2, 3, 4];
+            input.extend_from_slice(&expected_rest);
+
+            let input = EndianSlice::new(&input, LittleEndian);
+            let header = make_test_header(input);
+
+            let mut rest = input;
+            let opcode =
+                LineInstruction::parse(&header, &mut rest).expect("Should parse the opcode OK");
+
+            assert_eq!(opcode, expected);
+            assert_eq!(*rest, expected_rest);
+        }
+
+        test(
+            constants::DW_LNE_end_sequence,
+            [],
+            LineInstruction::EndSequence,
+        );
+        test(
+            constants::DW_LNE_set_address,
+            [1, 2, 3, 4, 5, 6, 7, 8],
+            LineInstruction::SetAddress(578_437_695_752_307_201),
+        );
+        test(
+            constants::DW_LNE_set_discriminator,
+            [42],
+            LineInstruction::SetDiscriminator(42),
+        );
+
+        let mut file = Vec::new();
+        // "foo.c"
+        let path_name = [b'f', b'o', b'o', b'.', b'c', 0];
+        file.extend_from_slice(&path_name);
+        // Directory index.
+        file.push(0);
+        // Last modification of file.
+        file.push(1);
+        // Size of file.
+        file.push(2);
+
+        test(
+            constants::DW_LNE_define_file,
+            file,
+            LineInstruction::DefineFile(FileEntry {
+                path_name: AttributeValue::String(EndianSlice::new(b"foo.c", LittleEndian)),
+                directory_index: 0,
+                timestamp: 1,
+                size: 2,
+                md5: [0; 16],
+            }),
+        );
+
+        // Unknown extended opcode.
+        let operands = [1, 2, 3, 4, 5, 6];
+        let opcode = constants::DwLne(99);
+        test(
+            opcode,
+            operands,
+            LineInstruction::UnknownExtended(opcode, EndianSlice::new(&operands, LittleEndian)),
+        );
+    }
+
+    #[test]
+    fn test_file_entry_directory() {
+        let path_name = [b'f', b'o', b'o', b'.', b'r', b's', 0];
+
+        let mut file = FileEntry {
+            path_name: AttributeValue::String(EndianSlice::new(&path_name, LittleEndian)),
+            directory_index: 1,
+            timestamp: 0,
+            size: 0,
+            md5: [0; 16],
+        };
+
+        let mut header = make_test_header(EndianSlice::new(&[], LittleEndian));
+
+        let dir = AttributeValue::String(EndianSlice::new(b"dir", LittleEndian));
+        header.include_directories.push(dir);
+
+        assert_eq!(file.directory(&header), Some(dir));
+
+        // Now test the compilation's current directory.
+        file.directory_index = 0;
+        assert_eq!(file.directory(&header), None);
+    }
+
+    fn assert_exec_opcode<'input>(
+        header: LineProgramHeader<EndianSlice<'input, LittleEndian>>,
+        mut registers: LineRow,
+        opcode: LineInstruction<EndianSlice<'input, LittleEndian>>,
+        expected_registers: LineRow,
+        expect_new_row: bool,
+    ) {
+        let mut program = IncompleteLineProgram { header };
+        let is_new_row = registers.execute(opcode, &mut program);
+
+        assert_eq!(is_new_row, expect_new_row);
+        assert_eq!(registers, expected_registers);
+    }
+
+    #[test]
+    fn test_exec_special_noop() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+
+        let initial_registers = LineRow::new(&header);
+        let opcode = LineInstruction::Special(16);
+        let expected_registers = initial_registers;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, true);
+    }
+
+    #[test]
+    fn test_exec_special_negative_line_advance() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+
+        let mut initial_registers = LineRow::new(&header);
+        initial_registers.line.0 = 10;
+
+        let opcode = LineInstruction::Special(13);
+
+        let mut expected_registers = initial_registers;
+        expected_registers.line.0 -= 3;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, true);
+    }
+
+    #[test]
+    fn test_exec_special_positive_line_advance() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+
+        let initial_registers = LineRow::new(&header);
+
+        let opcode = LineInstruction::Special(19);
+
+        let mut expected_registers = initial_registers;
+        expected_registers.line.0 += 3;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, true);
+    }
+
+    #[test]
+    fn test_exec_special_positive_address_advance() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+
+        let initial_registers = LineRow::new(&header);
+
+        let opcode = LineInstruction::Special(52);
+
+        let mut expected_registers = initial_registers;
+        expected_registers.address.0 += 3;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, true);
+    }
+
+    #[test]
+    fn test_exec_special_positive_address_and_line_advance() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+
+        let initial_registers = LineRow::new(&header);
+
+        let opcode = LineInstruction::Special(55);
+
+        let mut expected_registers = initial_registers;
+        expected_registers.address.0 += 3;
+        expected_registers.line.0 += 3;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, true);
+    }
+
+    #[test]
+    fn test_exec_special_positive_address_and_negative_line_advance() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+
+        let mut initial_registers = LineRow::new(&header);
+        initial_registers.line.0 = 10;
+
+        let opcode = LineInstruction::Special(49);
+
+        let mut expected_registers = initial_registers;
+        expected_registers.address.0 += 3;
+        expected_registers.line.0 -= 3;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, true);
+    }
+
+    #[test]
+    fn test_exec_special_line_underflow() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+
+        let mut initial_registers = LineRow::new(&header);
+        initial_registers.line.0 = 2;
+
+        // -3 line advance.
+        let opcode = LineInstruction::Special(13);
+
+        let mut expected_registers = initial_registers;
+        // Clamp at 0. No idea if this is the best way to handle this situation
+        // or not...
+        expected_registers.line.0 = 0;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, true);
+    }
+
+    #[test]
+    fn test_exec_copy() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+
+        let mut initial_registers = LineRow::new(&header);
+        initial_registers.address.0 = 1337;
+        initial_registers.line.0 = 42;
+
+        let opcode = LineInstruction::Copy;
+
+        let expected_registers = initial_registers;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, true);
+    }
+
+    #[test]
+    fn test_exec_advance_pc() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+        let initial_registers = LineRow::new(&header);
+        let opcode = LineInstruction::AdvancePc(42);
+
+        let mut expected_registers = initial_registers;
+        expected_registers.address.0 += 42;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, false);
+    }
+
+    #[test]
+    fn test_exec_advance_pc_overflow() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+        let opcode = LineInstruction::AdvancePc(42);
+
+        let mut initial_registers = LineRow::new(&header);
+        initial_registers.address.0 = u64::MAX;
+
+        let mut expected_registers = initial_registers;
+        expected_registers.address.0 = 41;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, false);
+    }
+
+    #[test]
+    fn test_exec_advance_line() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+        let initial_registers = LineRow::new(&header);
+        let opcode = LineInstruction::AdvanceLine(42);
+
+        let mut expected_registers = initial_registers;
+        expected_registers.line.0 += 42;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, false);
+    }
+
+    #[test]
+    fn test_exec_advance_line_overflow() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+        let opcode = LineInstruction::AdvanceLine(42);
+
+        let mut initial_registers = LineRow::new(&header);
+        initial_registers.line.0 = u64::MAX;
+
+        let mut expected_registers = initial_registers;
+        expected_registers.line.0 = 41;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, false);
+    }
+
+    #[test]
+    fn test_exec_set_file_in_bounds() {
+        for file_idx in 1..3 {
+            let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+            let initial_registers = LineRow::new(&header);
+            let opcode = LineInstruction::SetFile(file_idx);
+
+            let mut expected_registers = initial_registers;
+            expected_registers.file = file_idx;
+
+            assert_exec_opcode(header, initial_registers, opcode, expected_registers, false);
+        }
+    }
+
+    #[test]
+    fn test_exec_set_file_out_of_bounds() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+        let initial_registers = LineRow::new(&header);
+        let opcode = LineInstruction::SetFile(100);
+
+        // The spec doesn't say anything about rejecting input programs
+        // that set the file register out of bounds of the actual number
+        // of files that have been defined. Instead, we cross our
+        // fingers and hope that one gets defined before
+        // `LineRow::file` gets called and handle the error at
+        // that time if need be.
+        let mut expected_registers = initial_registers;
+        expected_registers.file = 100;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, false);
+    }
+
+    #[test]
+    fn test_file_entry_file_index_out_of_bounds() {
+        // These indices are 1-based, so 0 is invalid. 100 is way more than the
+        // number of files defined in the header.
+        let out_of_bounds_indices = [0, 100];
+
+        for file_idx in &out_of_bounds_indices[..] {
+            let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+            let mut row = LineRow::new(&header);
+
+            row.file = *file_idx;
+
+            assert_eq!(row.file(&header), None);
+        }
+    }
+
+    #[test]
+    fn test_file_entry_file_index_in_bounds() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+        let mut row = LineRow::new(&header);
+
+        row.file = 2;
+
+        assert_eq!(row.file(&header), Some(&header.file_names()[1]));
+    }
+
+    #[test]
+    fn test_exec_set_column() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+        let initial_registers = LineRow::new(&header);
+        let opcode = LineInstruction::SetColumn(42);
+
+        let mut expected_registers = initial_registers;
+        expected_registers.column = 42;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, false);
+    }
+
+    #[test]
+    fn test_exec_negate_statement() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+        let initial_registers = LineRow::new(&header);
+        let opcode = LineInstruction::NegateStatement;
+
+        let mut expected_registers = initial_registers;
+        expected_registers.is_stmt = !initial_registers.is_stmt;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, false);
+    }
+
+    #[test]
+    fn test_exec_set_basic_block() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+
+        let mut initial_registers = LineRow::new(&header);
+        initial_registers.basic_block = false;
+
+        let opcode = LineInstruction::SetBasicBlock;
+
+        let mut expected_registers = initial_registers;
+        expected_registers.basic_block = true;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, false);
+    }
+
+    #[test]
+    fn test_exec_const_add_pc() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+        let initial_registers = LineRow::new(&header);
+        let opcode = LineInstruction::ConstAddPc;
+
+        let mut expected_registers = initial_registers;
+        expected_registers.address.0 += 20;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, false);
+    }
+
+    #[test]
+    fn test_exec_fixed_add_pc() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+
+        let mut initial_registers = LineRow::new(&header);
+        initial_registers.op_index.0 = 1;
+
+        let opcode = LineInstruction::FixedAddPc(10);
+
+        let mut expected_registers = initial_registers;
+        expected_registers.address.0 += 10;
+        expected_registers.op_index.0 = 0;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, false);
+    }
+
+    #[test]
+    fn test_exec_set_prologue_end() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+
+        let mut initial_registers = LineRow::new(&header);
+        initial_registers.prologue_end = false;
+
+        let opcode = LineInstruction::SetPrologueEnd;
+
+        let mut expected_registers = initial_registers;
+        expected_registers.prologue_end = true;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, false);
+    }
+
+    #[test]
+    fn test_exec_set_isa() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+        let initial_registers = LineRow::new(&header);
+        let opcode = LineInstruction::SetIsa(1993);
+
+        let mut expected_registers = initial_registers;
+        expected_registers.isa = 1993;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, false);
+    }
+
+    #[test]
+    fn test_exec_unknown_standard_0() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+        let initial_registers = LineRow::new(&header);
+        let opcode = LineInstruction::UnknownStandard0(constants::DwLns(111));
+        let expected_registers = initial_registers;
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, false);
+    }
+
+    #[test]
+    fn test_exec_unknown_standard_1() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+        let initial_registers = LineRow::new(&header);
+        let opcode = LineInstruction::UnknownStandard1(constants::DwLns(111), 2);
+        let expected_registers = initial_registers;
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, false);
+    }
+
+    #[test]
+    fn test_exec_unknown_standard_n() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+        let initial_registers = LineRow::new(&header);
+        let opcode = LineInstruction::UnknownStandardN(
+            constants::DwLns(111),
+            EndianSlice::new(&[2, 2, 2], LittleEndian),
+        );
+        let expected_registers = initial_registers;
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, false);
+    }
+
+    #[test]
+    fn test_exec_end_sequence() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+        let initial_registers = LineRow::new(&header);
+        let opcode = LineInstruction::EndSequence;
+
+        let mut expected_registers = initial_registers;
+        expected_registers.end_sequence = true;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, true);
+    }
+
+    #[test]
+    fn test_exec_set_address() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+        let initial_registers = LineRow::new(&header);
+        let opcode = LineInstruction::SetAddress(3030);
+
+        let mut expected_registers = initial_registers;
+        expected_registers.address.0 = 3030;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, false);
+    }
+
+    #[test]
+    fn test_exec_set_address_tombstone() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+        let initial_registers = LineRow::new(&header);
+        let opcode = LineInstruction::SetAddress(!0);
+
+        let mut expected_registers = initial_registers;
+        expected_registers.tombstone = true;
+        expected_registers.address.0 = !0;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, false);
+    }
+
+    #[test]
+    fn test_exec_define_file() {
+        let mut program = make_test_program(EndianSlice::new(&[], LittleEndian));
+        let mut row = LineRow::new(program.header());
+
+        let file = FileEntry {
+            path_name: AttributeValue::String(EndianSlice::new(b"test.cpp", LittleEndian)),
+            directory_index: 0,
+            timestamp: 0,
+            size: 0,
+            md5: [0; 16],
+        };
+
+        let opcode = LineInstruction::DefineFile(file);
+        let is_new_row = row.execute(opcode, &mut program);
+
+        assert_eq!(is_new_row, false);
+        assert_eq!(Some(&file), program.header().file_names.last());
+    }
+
+    #[test]
+    fn test_exec_set_discriminator() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+        let initial_registers = LineRow::new(&header);
+        let opcode = LineInstruction::SetDiscriminator(9);
+
+        let mut expected_registers = initial_registers;
+        expected_registers.discriminator = 9;
+
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, false);
+    }
+
+    #[test]
+    fn test_exec_unknown_extended() {
+        let header = make_test_header(EndianSlice::new(&[], LittleEndian));
+        let initial_registers = LineRow::new(&header);
+        let opcode = LineInstruction::UnknownExtended(
+            constants::DwLne(74),
+            EndianSlice::new(&[], LittleEndian),
+        );
+        let expected_registers = initial_registers;
+        assert_exec_opcode(header, initial_registers, opcode, expected_registers, false);
+    }
+
+    /// Ensure that `LineRows<R,P>` is covariant wrt R.
+    /// This only needs to compile.
+    #[allow(dead_code, unreachable_code, unused_variables)]
+    fn test_line_rows_variance<'a, 'b>(_: &'a [u8], _: &'b [u8])
+    where
+        'a: 'b,
+    {
+        let a: &OneShotLineRows<EndianSlice<'a, LittleEndian>> = unimplemented!();
+        let _: &OneShotLineRows<EndianSlice<'b, LittleEndian>> = a;
+    }
+
+    #[test]
+    fn test_parse_debug_line_v5_ok() {
+        let expected_lengths = &[1, 2];
+        let expected_program = &[0, 1, 2, 3, 4];
+        let expected_rest = &[5, 6, 7, 8, 9];
+        let expected_include_directories = [
+            AttributeValue::String(EndianSlice::new(b"dir1", LittleEndian)),
+            AttributeValue::String(EndianSlice::new(b"dir2", LittleEndian)),
+        ];
+        let expected_file_names = [
+            FileEntry {
+                path_name: AttributeValue::String(EndianSlice::new(b"file1", LittleEndian)),
+                directory_index: 0,
+                timestamp: 0,
+                size: 0,
+                md5: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+            },
+            FileEntry {
+                path_name: AttributeValue::String(EndianSlice::new(b"file2", LittleEndian)),
+                directory_index: 1,
+                timestamp: 0,
+                size: 0,
+                md5: [
+                    11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
+                ],
+            },
+        ];
+
+        for format in vec![Format::Dwarf32, Format::Dwarf64] {
+            let length = Label::new();
+            let header_length = Label::new();
+            let start = Label::new();
+            let header_start = Label::new();
+            let end = Label::new();
+            let header_end = Label::new();
+            let section = Section::with_endian(Endian::Little)
+                .initial_length(format, &length, &start)
+                .D16(5)
+                // Address size.
+                .D8(4)
+                // Segment selector size.
+                .D8(0)
+                .word_label(format.word_size(), &header_length)
+                .mark(&header_start)
+                // Minimum instruction length.
+                .D8(1)
+                // Maximum operations per byte.
+                .D8(1)
+                // Default is_stmt.
+                .D8(1)
+                // Line base.
+                .D8(0)
+                // Line range.
+                .D8(1)
+                // Opcode base.
+                .D8(expected_lengths.len() as u8 + 1)
+                // Standard opcode lengths for opcodes 1 .. opcode base - 1.
+                .append_bytes(expected_lengths)
+                // Directory entry format count.
+                .D8(1)
+                .uleb(constants::DW_LNCT_path.0 as u64)
+                .uleb(constants::DW_FORM_string.0 as u64)
+                // Directory count.
+                .D8(2)
+                .append_bytes(b"dir1\0")
+                .append_bytes(b"dir2\0")
+                // File entry format count.
+                .D8(3)
+                .uleb(constants::DW_LNCT_path.0 as u64)
+                .uleb(constants::DW_FORM_string.0 as u64)
+                .uleb(constants::DW_LNCT_directory_index.0 as u64)
+                .uleb(constants::DW_FORM_data1.0 as u64)
+                .uleb(constants::DW_LNCT_MD5.0 as u64)
+                .uleb(constants::DW_FORM_data16.0 as u64)
+                // File count.
+                .D8(2)
+                .append_bytes(b"file1\0")
+                .D8(0)
+                .append_bytes(&expected_file_names[0].md5)
+                .append_bytes(b"file2\0")
+                .D8(1)
+                .append_bytes(&expected_file_names[1].md5)
+                .mark(&header_end)
+                // Dummy line program data.
+                .append_bytes(expected_program)
+                .mark(&end)
+                // Dummy trailing data.
+                .append_bytes(expected_rest);
+            length.set_const((&end - &start) as u64);
+            header_length.set_const((&header_end - &header_start) as u64);
+            let section = section.get_contents().unwrap();
+
+            let input = &mut EndianSlice::new(&section, LittleEndian);
+
+            let header = LineProgramHeader::parse(input, DebugLineOffset(0), 0, None, None)
+                .expect("should parse header ok");
+
+            assert_eq!(header.raw_program_buf().slice(), expected_program);
+            assert_eq!(input.slice(), expected_rest);
+
+            assert_eq!(header.offset, DebugLineOffset(0));
+            assert_eq!(header.version(), 5);
+            assert_eq!(header.address_size(), 4);
+            assert_eq!(header.minimum_instruction_length(), 1);
+            assert_eq!(header.maximum_operations_per_instruction(), 1);
+            assert_eq!(header.default_is_stmt(), true);
+            assert_eq!(header.line_base(), 0);
+            assert_eq!(header.line_range(), 1);
+            assert_eq!(header.opcode_base(), expected_lengths.len() as u8 + 1);
+            assert_eq!(header.standard_opcode_lengths().slice(), expected_lengths);
+            assert_eq!(
+                header.directory_entry_format(),
+                &[FileEntryFormat {
+                    content_type: constants::DW_LNCT_path,
+                    form: constants::DW_FORM_string,
+                }]
+            );
+            assert_eq!(header.include_directories(), expected_include_directories);
+            assert_eq!(header.directory(0), Some(expected_include_directories[0]));
+            assert_eq!(
+                header.file_name_entry_format(),
+                &[
+                    FileEntryFormat {
+                        content_type: constants::DW_LNCT_path,
+                        form: constants::DW_FORM_string,
+                    },
+                    FileEntryFormat {
+                        content_type: constants::DW_LNCT_directory_index,
+                        form: constants::DW_FORM_data1,
+                    },
+                    FileEntryFormat {
+                        content_type: constants::DW_LNCT_MD5,
+                        form: constants::DW_FORM_data16,
+                    }
+                ]
+            );
+            assert_eq!(header.file_names(), expected_file_names);
+            assert_eq!(header.file(0), Some(&expected_file_names[0]));
+        }
+    }
+
+    #[test]
+    fn test_sequences() {
+        #[rustfmt::skip]
+        let buf = [
+            // 32-bit length
+            94, 0x00, 0x00, 0x00,
+            // Version.
+            0x04, 0x00,
+            // Header length = 40.
+            0x28, 0x00, 0x00, 0x00,
+            // Minimum instruction length.
+            0x01,
+            // Maximum operations per byte.
+            0x01,
+            // Default is_stmt.
+            0x01,
+            // Line base.
+            0x00,
+            // Line range.
+            0x01,
+            // Opcode base.
+            0x03,
+            // Standard opcode lengths for opcodes 1 .. opcode base - 1.
+            0x01, 0x02,
+            // Include directories = '/', 'i', 'n', 'c', '\0', '/', 'i', 'n', 'c', '2', '\0', '\0'
+            0x2f, 0x69, 0x6e, 0x63, 0x00, 0x2f, 0x69, 0x6e, 0x63, 0x32, 0x00, 0x00,
+            // File names
+                // foo.rs
+                0x66, 0x6f, 0x6f, 0x2e, 0x72, 0x73, 0x00,
+                0x00,
+                0x00,
+                0x00,
+                // bar.h
+                0x62, 0x61, 0x72, 0x2e, 0x68, 0x00,
+                0x01,
+                0x00,
+                0x00,
+            // End file names.
+            0x00,
+
+            0, 5, constants::DW_LNE_set_address.0, 1, 0, 0, 0,
+            constants::DW_LNS_copy.0,
+            constants::DW_LNS_advance_pc.0, 1,
+            constants::DW_LNS_copy.0,
+            constants::DW_LNS_advance_pc.0, 2,
+            0, 1, constants::DW_LNE_end_sequence.0,
+
+            // Tombstone
+            0, 5, constants::DW_LNE_set_address.0, 0xff, 0xff, 0xff, 0xff,
+            constants::DW_LNS_copy.0,
+            constants::DW_LNS_advance_pc.0, 1,
+            constants::DW_LNS_copy.0,
+            constants::DW_LNS_advance_pc.0, 2,
+            0, 1, constants::DW_LNE_end_sequence.0,
+
+            0, 5, constants::DW_LNE_set_address.0, 11, 0, 0, 0,
+            constants::DW_LNS_copy.0,
+            constants::DW_LNS_advance_pc.0, 1,
+            constants::DW_LNS_copy.0,
+            constants::DW_LNS_advance_pc.0, 2,
+            0, 1, constants::DW_LNE_end_sequence.0,
+        ];
+        assert_eq!(buf[0] as usize, buf.len() - 4);
+
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        let header = LineProgramHeader::parse(rest, DebugLineOffset(0), 4, None, None)
+            .expect("should parse header ok");
+        let program = IncompleteLineProgram { header };
+
+        let sequences = program.sequences().unwrap().1;
+        assert_eq!(sequences.len(), 2);
+        assert_eq!(sequences[0].start, 1);
+        assert_eq!(sequences[0].end, 4);
+        assert_eq!(sequences[1].start, 11);
+        assert_eq!(sequences[1].end, 14);
+    }
+}
diff --git a/vendor/gimli/src/read/lists.rs b/vendor/gimli/src/read/lists.rs
new file mode 100644
index 0000000..898a757
--- /dev/null
+++ b/vendor/gimli/src/read/lists.rs
@@ -0,0 +1,68 @@
+use crate::common::{Encoding, Format};
+use crate::read::{Error, Reader, Result};
+
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct ListsHeader {
+    encoding: Encoding,
+    #[allow(dead_code)]
+    offset_entry_count: u32,
+}
+
+impl Default for ListsHeader {
+    fn default() -> Self {
+        ListsHeader {
+            encoding: Encoding {
+                format: Format::Dwarf32,
+                version: 5,
+                address_size: 0,
+            },
+            offset_entry_count: 0,
+        }
+    }
+}
+
+impl ListsHeader {
+    /// Return the serialized size of the table header.
+    #[allow(dead_code)]
+    #[inline]
+    fn size(self) -> u8 {
+        // initial_length + version + address_size + segment_selector_size + offset_entry_count
+        ListsHeader::size_for_encoding(self.encoding)
+    }
+
+    /// Return the serialized size of the table header.
+    #[inline]
+    pub(crate) fn size_for_encoding(encoding: Encoding) -> u8 {
+        // initial_length + version + address_size + segment_selector_size + offset_entry_count
+        encoding.format.initial_length_size() + 2 + 1 + 1 + 4
+    }
+}
+
+// TODO: add an iterator over headers in the appropriate sections section
+#[allow(dead_code)]
+fn parse_header<R: Reader>(input: &mut R) -> Result<ListsHeader> {
+    let (length, format) = input.read_initial_length()?;
+    input.truncate(length)?;
+
+    let version = input.read_u16()?;
+    if version != 5 {
+        return Err(Error::UnknownVersion(u64::from(version)));
+    }
+
+    let address_size = input.read_u8()?;
+    let segment_selector_size = input.read_u8()?;
+    if segment_selector_size != 0 {
+        return Err(Error::UnsupportedSegmentSize);
+    }
+    let offset_entry_count = input.read_u32()?;
+
+    let encoding = Encoding {
+        format,
+        version,
+        address_size,
+    };
+    Ok(ListsHeader {
+        encoding,
+        offset_entry_count,
+    })
+}
diff --git a/vendor/gimli/src/read/loclists.rs b/vendor/gimli/src/read/loclists.rs
new file mode 100644
index 0000000..5cba675
--- /dev/null
+++ b/vendor/gimli/src/read/loclists.rs
@@ -0,0 +1,1627 @@
+use crate::common::{
+    DebugAddrBase, DebugAddrIndex, DebugLocListsBase, DebugLocListsIndex, DwarfFileType, Encoding,
+    LocationListsOffset, SectionId,
+};
+use crate::constants;
+use crate::endianity::Endianity;
+use crate::read::{
+    lists::ListsHeader, DebugAddr, EndianSlice, Error, Expression, Range, RawRange, Reader,
+    ReaderOffset, ReaderOffsetId, Result, Section,
+};
+
+/// The raw contents of the `.debug_loc` section.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct DebugLoc<R> {
+    pub(crate) section: R,
+}
+
+impl<'input, Endian> DebugLoc<EndianSlice<'input, Endian>>
+where
+    Endian: Endianity,
+{
+    /// Construct a new `DebugLoc` instance from the data in the `.debug_loc`
+    /// section.
+    ///
+    /// It is the caller's responsibility to read the `.debug_loc` section and
+    /// present it as a `&[u8]` slice. That means using some ELF loader on
+    /// Linux, a Mach-O loader on macOS, etc.
+    ///
+    /// ```
+    /// use gimli::{DebugLoc, LittleEndian};
+    ///
+    /// # let buf = [0x00, 0x01, 0x02, 0x03];
+    /// # let read_debug_loc_section_somehow = || &buf;
+    /// let debug_loc = DebugLoc::new(read_debug_loc_section_somehow(), LittleEndian);
+    /// ```
+    pub fn new(section: &'input [u8], endian: Endian) -> Self {
+        Self::from(EndianSlice::new(section, endian))
+    }
+}
+
+impl<R> Section<R> for DebugLoc<R> {
+    fn id() -> SectionId {
+        SectionId::DebugLoc
+    }
+
+    fn reader(&self) -> &R {
+        &self.section
+    }
+}
+
+impl<R> From<R> for DebugLoc<R> {
+    fn from(section: R) -> Self {
+        DebugLoc { section }
+    }
+}
+
+/// The `DebugLocLists` struct represents the DWARF data
+/// found in the `.debug_loclists` section.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct DebugLocLists<R> {
+    section: R,
+}
+
+impl<'input, Endian> DebugLocLists<EndianSlice<'input, Endian>>
+where
+    Endian: Endianity,
+{
+    /// Construct a new `DebugLocLists` instance from the data in the `.debug_loclists`
+    /// section.
+    ///
+    /// It is the caller's responsibility to read the `.debug_loclists` section and
+    /// present it as a `&[u8]` slice. That means using some ELF loader on
+    /// Linux, a Mach-O loader on macOS, etc.
+    ///
+    /// ```
+    /// use gimli::{DebugLocLists, LittleEndian};
+    ///
+    /// # let buf = [0x00, 0x01, 0x02, 0x03];
+    /// # let read_debug_loclists_section_somehow = || &buf;
+    /// let debug_loclists = DebugLocLists::new(read_debug_loclists_section_somehow(), LittleEndian);
+    /// ```
+    pub fn new(section: &'input [u8], endian: Endian) -> Self {
+        Self::from(EndianSlice::new(section, endian))
+    }
+}
+
+impl<R> Section<R> for DebugLocLists<R> {
+    fn id() -> SectionId {
+        SectionId::DebugLocLists
+    }
+
+    fn reader(&self) -> &R {
+        &self.section
+    }
+}
+
+impl<R> From<R> for DebugLocLists<R> {
+    fn from(section: R) -> Self {
+        DebugLocLists { section }
+    }
+}
+
+pub(crate) type LocListsHeader = ListsHeader;
+
+impl<Offset> DebugLocListsBase<Offset>
+where
+    Offset: ReaderOffset,
+{
+    /// Returns a `DebugLocListsBase` with the default value of DW_AT_loclists_base
+    /// for the given `Encoding` and `DwarfFileType`.
+    pub fn default_for_encoding_and_file(
+        encoding: Encoding,
+        file_type: DwarfFileType,
+    ) -> DebugLocListsBase<Offset> {
+        if encoding.version >= 5 && file_type == DwarfFileType::Dwo {
+            // In .dwo files, the compiler omits the DW_AT_loclists_base attribute (because there is
+            // only a single unit in the file) but we must skip past the header, which the attribute
+            // would normally do for us.
+            DebugLocListsBase(Offset::from_u8(LocListsHeader::size_for_encoding(encoding)))
+        } else {
+            DebugLocListsBase(Offset::from_u8(0))
+        }
+    }
+}
+
+/// The DWARF data found in `.debug_loc` and `.debug_loclists` sections.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct LocationLists<R> {
+    debug_loc: DebugLoc<R>,
+    debug_loclists: DebugLocLists<R>,
+}
+
+impl<R> LocationLists<R> {
+    /// Construct a new `LocationLists` instance from the data in the `.debug_loc` and
+    /// `.debug_loclists` sections.
+    pub fn new(debug_loc: DebugLoc<R>, debug_loclists: DebugLocLists<R>) -> LocationLists<R> {
+        LocationLists {
+            debug_loc,
+            debug_loclists,
+        }
+    }
+}
+
+impl<T> LocationLists<T> {
+    /// Create a `LocationLists` that references the data in `self`.
+    ///
+    /// This is useful when `R` implements `Reader` but `T` does not.
+    ///
+    /// ## Example Usage
+    ///
+    /// ```rust,no_run
+    /// # let load_section = || unimplemented!();
+    /// // Read the DWARF section into a `Vec` with whatever object loader you're using.
+    /// let owned_section: gimli::LocationLists<Vec<u8>> = load_section();
+    /// // Create a reference to the DWARF section.
+    /// let section = owned_section.borrow(|section| {
+    ///     gimli::EndianSlice::new(&section, gimli::LittleEndian)
+    /// });
+    /// ```
+    pub fn borrow<'a, F, R>(&'a self, mut borrow: F) -> LocationLists<R>
+    where
+        F: FnMut(&'a T) -> R,
+    {
+        LocationLists {
+            debug_loc: borrow(&self.debug_loc.section).into(),
+            debug_loclists: borrow(&self.debug_loclists.section).into(),
+        }
+    }
+}
+
+impl<R: Reader> LocationLists<R> {
+    /// Iterate over the `LocationListEntry`s starting at the given offset.
+    ///
+    /// The `unit_encoding` must match the compilation unit that the
+    /// offset was contained in.
+    ///
+    /// The `base_address` should be obtained from the `DW_AT_low_pc` attribute in the
+    /// `DW_TAG_compile_unit` entry for the compilation unit that contains this location
+    /// list.
+    ///
+    /// Can be [used with
+    /// `FallibleIterator`](./index.html#using-with-fallibleiterator).
+    pub fn locations(
+        &self,
+        offset: LocationListsOffset<R::Offset>,
+        unit_encoding: Encoding,
+        base_address: u64,
+        debug_addr: &DebugAddr<R>,
+        debug_addr_base: DebugAddrBase<R::Offset>,
+    ) -> Result<LocListIter<R>> {
+        Ok(LocListIter::new(
+            self.raw_locations(offset, unit_encoding)?,
+            base_address,
+            debug_addr.clone(),
+            debug_addr_base,
+        ))
+    }
+
+    /// Similar to `locations`, but with special handling for .dwo files.
+    /// This should only been used when this `LocationLists` was loaded from a
+    /// .dwo file.
+    pub fn locations_dwo(
+        &self,
+        offset: LocationListsOffset<R::Offset>,
+        unit_encoding: Encoding,
+        base_address: u64,
+        debug_addr: &DebugAddr<R>,
+        debug_addr_base: DebugAddrBase<R::Offset>,
+    ) -> Result<LocListIter<R>> {
+        Ok(LocListIter::new(
+            self.raw_locations_dwo(offset, unit_encoding)?,
+            base_address,
+            debug_addr.clone(),
+            debug_addr_base,
+        ))
+    }
+
+    /// Iterate over the raw `LocationListEntry`s starting at the given offset.
+    ///
+    /// The `unit_encoding` must match the compilation unit that the
+    /// offset was contained in.
+    ///
+    /// This iterator does not perform any processing of the location entries,
+    /// such as handling base addresses.
+    ///
+    /// Can be [used with
+    /// `FallibleIterator`](./index.html#using-with-fallibleiterator).
+    pub fn raw_locations(
+        &self,
+        offset: LocationListsOffset<R::Offset>,
+        unit_encoding: Encoding,
+    ) -> Result<RawLocListIter<R>> {
+        let (mut input, format) = if unit_encoding.version <= 4 {
+            (self.debug_loc.section.clone(), LocListsFormat::Bare)
+        } else {
+            (self.debug_loclists.section.clone(), LocListsFormat::Lle)
+        };
+        input.skip(offset.0)?;
+        Ok(RawLocListIter::new(input, unit_encoding, format))
+    }
+
+    /// Similar to `raw_locations`, but with special handling for .dwo files.
+    /// This should only been used when this `LocationLists` was loaded from a
+    /// .dwo file.
+    pub fn raw_locations_dwo(
+        &self,
+        offset: LocationListsOffset<R::Offset>,
+        unit_encoding: Encoding,
+    ) -> Result<RawLocListIter<R>> {
+        let mut input = if unit_encoding.version <= 4 {
+            // In the GNU split dwarf extension the locations are present in the
+            // .debug_loc section but are encoded with the DW_LLE values used
+            // for the DWARF 5 .debug_loclists section.
+            self.debug_loc.section.clone()
+        } else {
+            self.debug_loclists.section.clone()
+        };
+        input.skip(offset.0)?;
+        Ok(RawLocListIter::new(
+            input,
+            unit_encoding,
+            LocListsFormat::Lle,
+        ))
+    }
+
+    /// Returns the `.debug_loclists` offset at the given `base` and `index`.
+    ///
+    /// The `base` must be the `DW_AT_loclists_base` value from the compilation unit DIE.
+    /// This is an offset that points to the first entry following the header.
+    ///
+    /// The `index` is the value of a `DW_FORM_loclistx` attribute.
+    pub fn get_offset(
+        &self,
+        unit_encoding: Encoding,
+        base: DebugLocListsBase<R::Offset>,
+        index: DebugLocListsIndex<R::Offset>,
+    ) -> Result<LocationListsOffset<R::Offset>> {
+        let format = unit_encoding.format;
+        let input = &mut self.debug_loclists.section.clone();
+        input.skip(base.0)?;
+        input.skip(R::Offset::from_u64(
+            index.0.into_u64() * u64::from(format.word_size()),
+        )?)?;
+        input
+            .read_offset(format)
+            .map(|x| LocationListsOffset(base.0 + x))
+    }
+
+    /// Call `Reader::lookup_offset_id` for each section, and return the first match.
+    pub fn lookup_offset_id(&self, id: ReaderOffsetId) -> Option<(SectionId, R::Offset)> {
+        self.debug_loc
+            .lookup_offset_id(id)
+            .or_else(|| self.debug_loclists.lookup_offset_id(id))
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum LocListsFormat {
+    /// The bare location list format used before DWARF 5.
+    Bare,
+    /// The DW_LLE encoded range list format used in DWARF 5 and the non-standard GNU
+    /// split dwarf extension.
+    Lle,
+}
+
+/// A raw iterator over a location list.
+///
+/// This iterator does not perform any processing of the location entries,
+/// such as handling base addresses.
+#[derive(Debug)]
+pub struct RawLocListIter<R: Reader> {
+    input: R,
+    encoding: Encoding,
+    format: LocListsFormat,
+}
+
+/// A raw entry in .debug_loclists.
+#[derive(Clone, Debug)]
+pub enum RawLocListEntry<R: Reader> {
+    /// A location from DWARF version <= 4.
+    AddressOrOffsetPair {
+        /// Start of range. May be an address or an offset.
+        begin: u64,
+        /// End of range. May be an address or an offset.
+        end: u64,
+        /// expression
+        data: Expression<R>,
+    },
+    /// DW_LLE_base_address
+    BaseAddress {
+        /// base address
+        addr: u64,
+    },
+    /// DW_LLE_base_addressx
+    BaseAddressx {
+        /// base address
+        addr: DebugAddrIndex<R::Offset>,
+    },
+    /// DW_LLE_startx_endx
+    StartxEndx {
+        /// start of range
+        begin: DebugAddrIndex<R::Offset>,
+        /// end of range
+        end: DebugAddrIndex<R::Offset>,
+        /// expression
+        data: Expression<R>,
+    },
+    /// DW_LLE_startx_length
+    StartxLength {
+        /// start of range
+        begin: DebugAddrIndex<R::Offset>,
+        /// length of range
+        length: u64,
+        /// expression
+        data: Expression<R>,
+    },
+    /// DW_LLE_offset_pair
+    OffsetPair {
+        /// start of range
+        begin: u64,
+        /// end of range
+        end: u64,
+        /// expression
+        data: Expression<R>,
+    },
+    /// DW_LLE_default_location
+    DefaultLocation {
+        /// expression
+        data: Expression<R>,
+    },
+    /// DW_LLE_start_end
+    StartEnd {
+        /// start of range
+        begin: u64,
+        /// end of range
+        end: u64,
+        /// expression
+        data: Expression<R>,
+    },
+    /// DW_LLE_start_length
+    StartLength {
+        /// start of range
+        begin: u64,
+        /// length of range
+        length: u64,
+        /// expression
+        data: Expression<R>,
+    },
+}
+
+fn parse_data<R: Reader>(input: &mut R, encoding: Encoding) -> Result<Expression<R>> {
+    if encoding.version >= 5 {
+        let len = R::Offset::from_u64(input.read_uleb128()?)?;
+        Ok(Expression(input.split(len)?))
+    } else {
+        // In the GNU split-dwarf extension this is a fixed 2 byte value.
+        let len = R::Offset::from_u16(input.read_u16()?);
+        Ok(Expression(input.split(len)?))
+    }
+}
+
+impl<R: Reader> RawLocListEntry<R> {
+    /// Parse a location list entry from `.debug_loclists`
+    fn parse(input: &mut R, encoding: Encoding, format: LocListsFormat) -> Result<Option<Self>> {
+        Ok(match format {
+            LocListsFormat::Bare => {
+                let range = RawRange::parse(input, encoding.address_size)?;
+                if range.is_end() {
+                    None
+                } else if range.is_base_address(encoding.address_size) {
+                    Some(RawLocListEntry::BaseAddress { addr: range.end })
+                } else {
+                    let len = R::Offset::from_u16(input.read_u16()?);
+                    let data = Expression(input.split(len)?);
+                    Some(RawLocListEntry::AddressOrOffsetPair {
+                        begin: range.begin,
+                        end: range.end,
+                        data,
+                    })
+                }
+            }
+            LocListsFormat::Lle => match constants::DwLle(input.read_u8()?) {
+                constants::DW_LLE_end_of_list => None,
+                constants::DW_LLE_base_addressx => Some(RawLocListEntry::BaseAddressx {
+                    addr: DebugAddrIndex(input.read_uleb128().and_then(R::Offset::from_u64)?),
+                }),
+                constants::DW_LLE_startx_endx => Some(RawLocListEntry::StartxEndx {
+                    begin: DebugAddrIndex(input.read_uleb128().and_then(R::Offset::from_u64)?),
+                    end: DebugAddrIndex(input.read_uleb128().and_then(R::Offset::from_u64)?),
+                    data: parse_data(input, encoding)?,
+                }),
+                constants::DW_LLE_startx_length => Some(RawLocListEntry::StartxLength {
+                    begin: DebugAddrIndex(input.read_uleb128().and_then(R::Offset::from_u64)?),
+                    length: if encoding.version >= 5 {
+                        input.read_uleb128()?
+                    } else {
+                        // In the GNU split-dwarf extension this is a fixed 4 byte value.
+                        input.read_u32()? as u64
+                    },
+                    data: parse_data(input, encoding)?,
+                }),
+                constants::DW_LLE_offset_pair => Some(RawLocListEntry::OffsetPair {
+                    begin: input.read_uleb128()?,
+                    end: input.read_uleb128()?,
+                    data: parse_data(input, encoding)?,
+                }),
+                constants::DW_LLE_default_location => Some(RawLocListEntry::DefaultLocation {
+                    data: parse_data(input, encoding)?,
+                }),
+                constants::DW_LLE_base_address => Some(RawLocListEntry::BaseAddress {
+                    addr: input.read_address(encoding.address_size)?,
+                }),
+                constants::DW_LLE_start_end => Some(RawLocListEntry::StartEnd {
+                    begin: input.read_address(encoding.address_size)?,
+                    end: input.read_address(encoding.address_size)?,
+                    data: parse_data(input, encoding)?,
+                }),
+                constants::DW_LLE_start_length => Some(RawLocListEntry::StartLength {
+                    begin: input.read_address(encoding.address_size)?,
+                    length: input.read_uleb128()?,
+                    data: parse_data(input, encoding)?,
+                }),
+                _ => {
+                    return Err(Error::InvalidAddressRange);
+                }
+            },
+        })
+    }
+}
+
+impl<R: Reader> RawLocListIter<R> {
+    /// Construct a `RawLocListIter`.
+    fn new(input: R, encoding: Encoding, format: LocListsFormat) -> RawLocListIter<R> {
+        RawLocListIter {
+            input,
+            encoding,
+            format,
+        }
+    }
+
+    /// Advance the iterator to the next location.
+    pub fn next(&mut self) -> Result<Option<RawLocListEntry<R>>> {
+        if self.input.is_empty() {
+            return Ok(None);
+        }
+
+        match RawLocListEntry::parse(&mut self.input, self.encoding, self.format) {
+            Ok(entry) => {
+                if entry.is_none() {
+                    self.input.empty();
+                }
+                Ok(entry)
+            }
+            Err(e) => {
+                self.input.empty();
+                Err(e)
+            }
+        }
+    }
+}
+
+#[cfg(feature = "fallible-iterator")]
+impl<R: Reader> fallible_iterator::FallibleIterator for RawLocListIter<R> {
+    type Item = RawLocListEntry<R>;
+    type Error = Error;
+
+    fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> {
+        RawLocListIter::next(self)
+    }
+}
+
+/// An iterator over a location list.
+///
+/// This iterator internally handles processing of base address selection entries
+/// and list end entries.  Thus, it only returns location entries that are valid
+/// and already adjusted for the base address.
+#[derive(Debug)]
+pub struct LocListIter<R: Reader> {
+    raw: RawLocListIter<R>,
+    base_address: u64,
+    debug_addr: DebugAddr<R>,
+    debug_addr_base: DebugAddrBase<R::Offset>,
+}
+
+impl<R: Reader> LocListIter<R> {
+    /// Construct a `LocListIter`.
+    fn new(
+        raw: RawLocListIter<R>,
+        base_address: u64,
+        debug_addr: DebugAddr<R>,
+        debug_addr_base: DebugAddrBase<R::Offset>,
+    ) -> LocListIter<R> {
+        LocListIter {
+            raw,
+            base_address,
+            debug_addr,
+            debug_addr_base,
+        }
+    }
+
+    #[inline]
+    fn get_address(&self, index: DebugAddrIndex<R::Offset>) -> Result<u64> {
+        self.debug_addr
+            .get_address(self.raw.encoding.address_size, self.debug_addr_base, index)
+    }
+
+    /// Advance the iterator to the next location.
+    pub fn next(&mut self) -> Result<Option<LocationListEntry<R>>> {
+        loop {
+            let raw_loc = match self.raw.next()? {
+                Some(loc) => loc,
+                None => return Ok(None),
+            };
+
+            let loc = self.convert_raw(raw_loc)?;
+            if loc.is_some() {
+                return Ok(loc);
+            }
+        }
+    }
+
+    /// Return the next raw location.
+    ///
+    /// The raw location should be passed to `convert_raw`.
+    #[doc(hidden)]
+    pub fn next_raw(&mut self) -> Result<Option<RawLocListEntry<R>>> {
+        self.raw.next()
+    }
+
+    /// Convert a raw location into a location, and update the state of the iterator.
+    ///
+    /// The raw location should have been obtained from `next_raw`.
+    #[doc(hidden)]
+    pub fn convert_raw(
+        &mut self,
+        raw_loc: RawLocListEntry<R>,
+    ) -> Result<Option<LocationListEntry<R>>> {
+        let mask = !0 >> (64 - self.raw.encoding.address_size * 8);
+        let tombstone = if self.raw.encoding.version <= 4 {
+            mask - 1
+        } else {
+            mask
+        };
+
+        let (range, data) = match raw_loc {
+            RawLocListEntry::BaseAddress { addr } => {
+                self.base_address = addr;
+                return Ok(None);
+            }
+            RawLocListEntry::BaseAddressx { addr } => {
+                self.base_address = self.get_address(addr)?;
+                return Ok(None);
+            }
+            RawLocListEntry::StartxEndx { begin, end, data } => {
+                let begin = self.get_address(begin)?;
+                let end = self.get_address(end)?;
+                (Range { begin, end }, data)
+            }
+            RawLocListEntry::StartxLength {
+                begin,
+                length,
+                data,
+            } => {
+                let begin = self.get_address(begin)?;
+                let end = begin.wrapping_add(length) & mask;
+                (Range { begin, end }, data)
+            }
+            RawLocListEntry::DefaultLocation { data } => (
+                Range {
+                    begin: 0,
+                    end: u64::max_value(),
+                },
+                data,
+            ),
+            RawLocListEntry::AddressOrOffsetPair { begin, end, data }
+            | RawLocListEntry::OffsetPair { begin, end, data } => {
+                if self.base_address == tombstone {
+                    return Ok(None);
+                }
+                let mut range = Range { begin, end };
+                range.add_base_address(self.base_address, self.raw.encoding.address_size);
+                (range, data)
+            }
+            RawLocListEntry::StartEnd { begin, end, data } => (Range { begin, end }, data),
+            RawLocListEntry::StartLength {
+                begin,
+                length,
+                data,
+            } => {
+                let end = begin.wrapping_add(length) & mask;
+                (Range { begin, end }, data)
+            }
+        };
+
+        if range.begin == tombstone {
+            return Ok(None);
+        }
+
+        if range.begin > range.end {
+            self.raw.input.empty();
+            return Err(Error::InvalidLocationAddressRange);
+        }
+
+        Ok(Some(LocationListEntry { range, data }))
+    }
+}
+
+#[cfg(feature = "fallible-iterator")]
+impl<R: Reader> fallible_iterator::FallibleIterator for LocListIter<R> {
+    type Item = LocationListEntry<R>;
+    type Error = Error;
+
+    fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> {
+        LocListIter::next(self)
+    }
+}
+
+/// A location list entry from the `.debug_loc` or `.debug_loclists` sections.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct LocationListEntry<R: Reader> {
+    /// The address range that this location is valid for.
+    pub range: Range,
+
+    /// The data containing a single location description.
+    pub data: Expression<R>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::common::Format;
+    use crate::endianity::LittleEndian;
+    use crate::read::{EndianSlice, Range};
+    use crate::test_util::GimliSectionMethods;
+    use test_assembler::{Endian, Label, LabelMaker, Section};
+
+    #[test]
+    fn test_loclists_32() {
+        let tombstone = !0u32;
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 5,
+            address_size: 4,
+        };
+
+        let section = Section::with_endian(Endian::Little)
+            .L32(0x0300_0000)
+            .L32(0x0301_0300)
+            .L32(0x0301_0400)
+            .L32(0x0301_0500)
+            .L32(tombstone)
+            .L32(0x0301_0600);
+        let buf = section.get_contents().unwrap();
+        let debug_addr = &DebugAddr::from(EndianSlice::new(&buf, LittleEndian));
+        let debug_addr_base = DebugAddrBase(0);
+
+        let start = Label::new();
+        let first = Label::new();
+        let size = Label::new();
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Little)
+            // Header
+            .mark(&start)
+            .L32(&size)
+            .L16(encoding.version)
+            .L8(encoding.address_size)
+            .L8(0)
+            .L32(0)
+            .mark(&first)
+            // OffsetPair
+            .L8(4).uleb(0x10200).uleb(0x10300).uleb(4).L32(2)
+            // A base address selection followed by an OffsetPair.
+            .L8(6).L32(0x0200_0000)
+            .L8(4).uleb(0x10400).uleb(0x10500).uleb(4).L32(3)
+            // An empty OffsetPair followed by a normal OffsetPair.
+            .L8(4).uleb(0x10600).uleb(0x10600).uleb(4).L32(4)
+            .L8(4).uleb(0x10800).uleb(0x10900).uleb(4).L32(5)
+            // A StartEnd
+            .L8(7).L32(0x201_0a00).L32(0x201_0b00).uleb(4).L32(6)
+            // A StartLength
+            .L8(8).L32(0x201_0c00).uleb(0x100).uleb(4).L32(7)
+            // An OffsetPair that starts at 0.
+            .L8(4).uleb(0).uleb(1).uleb(4).L32(8)
+            // An OffsetPair that ends at -1.
+            .L8(6).L32(0)
+            .L8(4).uleb(0).uleb(0xffff_ffff).uleb(4).L32(9)
+            // A DefaultLocation
+            .L8(5).uleb(4).L32(10)
+            // A BaseAddressx + OffsetPair
+            .L8(1).uleb(0)
+            .L8(4).uleb(0x10100).uleb(0x10200).uleb(4).L32(11)
+            // A StartxEndx
+            .L8(2).uleb(1).uleb(2).uleb(4).L32(12)
+            // A StartxLength
+            .L8(3).uleb(3).uleb(0x100).uleb(4).L32(13)
+
+            // Tombstone entries, all of which should be ignored.
+            // A BaseAddressx that is a tombstone.
+            .L8(1).uleb(4)
+            .L8(4).uleb(0x11100).uleb(0x11200).uleb(4).L32(20)
+            // A BaseAddress that is a tombstone.
+            .L8(6).L32(tombstone)
+            .L8(4).uleb(0x11300).uleb(0x11400).uleb(4).L32(21)
+            // A StartxEndx that is a tombstone.
+            .L8(2).uleb(4).uleb(5).uleb(4).L32(22)
+            // A StartxLength that is a tombstone.
+            .L8(3).uleb(4).uleb(0x100).uleb(4).L32(23)
+            // A StartEnd that is a tombstone.
+            .L8(7).L32(tombstone).L32(0x201_1500).uleb(4).L32(24)
+            // A StartLength that is a tombstone.
+            .L8(8).L32(tombstone).uleb(0x100).uleb(4).L32(25)
+            // A StartEnd (not ignored)
+            .L8(7).L32(0x201_1600).L32(0x201_1700).uleb(4).L32(26)
+
+            // A range end.
+            .L8(0)
+            // Some extra data.
+            .L32(0xffff_ffff);
+        size.set_const((&section.here() - &start - 4) as u64);
+
+        let buf = section.get_contents().unwrap();
+        let debug_loc = DebugLoc::new(&[], LittleEndian);
+        let debug_loclists = DebugLocLists::new(&buf, LittleEndian);
+        let loclists = LocationLists::new(debug_loc, debug_loclists);
+        let offset = LocationListsOffset((&first - &start) as usize);
+        let mut locations = loclists
+            .locations(offset, encoding, 0x0100_0000, debug_addr, debug_addr_base)
+            .unwrap();
+
+        // A normal location.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0101_0200,
+                    end: 0x0101_0300,
+                },
+                data: Expression(EndianSlice::new(&[2, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A base address selection followed by a normal location.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0201_0400,
+                    end: 0x0201_0500,
+                },
+                data: Expression(EndianSlice::new(&[3, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // An empty location range followed by a normal location.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0201_0600,
+                    end: 0x0201_0600,
+                },
+                data: Expression(EndianSlice::new(&[4, 0, 0, 0], LittleEndian)),
+            }))
+        );
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0201_0800,
+                    end: 0x0201_0900,
+                },
+                data: Expression(EndianSlice::new(&[5, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A normal location.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0201_0a00,
+                    end: 0x0201_0b00,
+                },
+                data: Expression(EndianSlice::new(&[6, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A normal location.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0201_0c00,
+                    end: 0x0201_0d00,
+                },
+                data: Expression(EndianSlice::new(&[7, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A location range that starts at 0.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0200_0000,
+                    end: 0x0200_0001,
+                },
+                data: Expression(EndianSlice::new(&[8, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A location range that ends at -1.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0000_0000,
+                    end: 0xffff_ffff,
+                },
+                data: Expression(EndianSlice::new(&[9, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A DefaultLocation.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0,
+                    end: u64::max_value(),
+                },
+                data: Expression(EndianSlice::new(&[10, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A BaseAddressx + OffsetPair
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0301_0100,
+                    end: 0x0301_0200,
+                },
+                data: Expression(EndianSlice::new(&[11, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A StartxEndx
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0301_0300,
+                    end: 0x0301_0400,
+                },
+                data: Expression(EndianSlice::new(&[12, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A StartxLength
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0301_0500,
+                    end: 0x0301_0600,
+                },
+                data: Expression(EndianSlice::new(&[13, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A StartEnd location following the tombstones
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0201_1600,
+                    end: 0x0201_1700,
+                },
+                data: Expression(EndianSlice::new(&[26, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A location list end.
+        assert_eq!(locations.next(), Ok(None));
+
+        // An offset at the end of buf.
+        let mut locations = loclists
+            .locations(
+                LocationListsOffset(buf.len()),
+                encoding,
+                0x0100_0000,
+                debug_addr,
+                debug_addr_base,
+            )
+            .unwrap();
+        assert_eq!(locations.next(), Ok(None));
+    }
+
+    #[test]
+    fn test_loclists_64() {
+        let tombstone = !0u64;
+        let encoding = Encoding {
+            format: Format::Dwarf64,
+            version: 5,
+            address_size: 8,
+        };
+
+        let section = Section::with_endian(Endian::Little)
+            .L64(0x0300_0000)
+            .L64(0x0301_0300)
+            .L64(0x0301_0400)
+            .L64(0x0301_0500)
+            .L64(tombstone)
+            .L64(0x0301_0600);
+        let buf = section.get_contents().unwrap();
+        let debug_addr = &DebugAddr::from(EndianSlice::new(&buf, LittleEndian));
+        let debug_addr_base = DebugAddrBase(0);
+
+        let start = Label::new();
+        let first = Label::new();
+        let size = Label::new();
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Little)
+            // Header
+            .mark(&start)
+            .L32(0xffff_ffff)
+            .L64(&size)
+            .L16(encoding.version)
+            .L8(encoding.address_size)
+            .L8(0)
+            .L32(0)
+            .mark(&first)
+            // OffsetPair
+            .L8(4).uleb(0x10200).uleb(0x10300).uleb(4).L32(2)
+            // A base address selection followed by an OffsetPair.
+            .L8(6).L64(0x0200_0000)
+            .L8(4).uleb(0x10400).uleb(0x10500).uleb(4).L32(3)
+            // An empty OffsetPair followed by a normal OffsetPair.
+            .L8(4).uleb(0x10600).uleb(0x10600).uleb(4).L32(4)
+            .L8(4).uleb(0x10800).uleb(0x10900).uleb(4).L32(5)
+            // A StartEnd
+            .L8(7).L64(0x201_0a00).L64(0x201_0b00).uleb(4).L32(6)
+            // A StartLength
+            .L8(8).L64(0x201_0c00).uleb(0x100).uleb(4).L32(7)
+            // An OffsetPair that starts at 0.
+            .L8(4).uleb(0).uleb(1).uleb(4).L32(8)
+            // An OffsetPair that ends at -1.
+            .L8(6).L64(0)
+            .L8(4).uleb(0).uleb(0xffff_ffff).uleb(4).L32(9)
+            // A DefaultLocation
+            .L8(5).uleb(4).L32(10)
+            // A BaseAddressx + OffsetPair
+            .L8(1).uleb(0)
+            .L8(4).uleb(0x10100).uleb(0x10200).uleb(4).L32(11)
+            // A StartxEndx
+            .L8(2).uleb(1).uleb(2).uleb(4).L32(12)
+            // A StartxLength
+            .L8(3).uleb(3).uleb(0x100).uleb(4).L32(13)
+
+            // Tombstone entries, all of which should be ignored.
+            // A BaseAddressx that is a tombstone.
+            .L8(1).uleb(4)
+            .L8(4).uleb(0x11100).uleb(0x11200).uleb(4).L32(20)
+            // A BaseAddress that is a tombstone.
+            .L8(6).L64(tombstone)
+            .L8(4).uleb(0x11300).uleb(0x11400).uleb(4).L32(21)
+            // A StartxEndx that is a tombstone.
+            .L8(2).uleb(4).uleb(5).uleb(4).L32(22)
+            // A StartxLength that is a tombstone.
+            .L8(3).uleb(4).uleb(0x100).uleb(4).L32(23)
+            // A StartEnd that is a tombstone.
+            .L8(7).L64(tombstone).L64(0x201_1500).uleb(4).L32(24)
+            // A StartLength that is a tombstone.
+            .L8(8).L64(tombstone).uleb(0x100).uleb(4).L32(25)
+            // A StartEnd (not ignored)
+            .L8(7).L64(0x201_1600).L64(0x201_1700).uleb(4).L32(26)
+
+            // A range end.
+            .L8(0)
+            // Some extra data.
+            .L32(0xffff_ffff);
+        size.set_const((&section.here() - &start - 12) as u64);
+
+        let buf = section.get_contents().unwrap();
+        let debug_loc = DebugLoc::new(&[], LittleEndian);
+        let debug_loclists = DebugLocLists::new(&buf, LittleEndian);
+        let loclists = LocationLists::new(debug_loc, debug_loclists);
+        let offset = LocationListsOffset((&first - &start) as usize);
+        let mut locations = loclists
+            .locations(offset, encoding, 0x0100_0000, debug_addr, debug_addr_base)
+            .unwrap();
+
+        // A normal location.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0101_0200,
+                    end: 0x0101_0300,
+                },
+                data: Expression(EndianSlice::new(&[2, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A base address selection followed by a normal location.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0201_0400,
+                    end: 0x0201_0500,
+                },
+                data: Expression(EndianSlice::new(&[3, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // An empty location range followed by a normal location.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0201_0600,
+                    end: 0x0201_0600,
+                },
+                data: Expression(EndianSlice::new(&[4, 0, 0, 0], LittleEndian)),
+            }))
+        );
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0201_0800,
+                    end: 0x0201_0900,
+                },
+                data: Expression(EndianSlice::new(&[5, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A normal location.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0201_0a00,
+                    end: 0x0201_0b00,
+                },
+                data: Expression(EndianSlice::new(&[6, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A normal location.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0201_0c00,
+                    end: 0x0201_0d00,
+                },
+                data: Expression(EndianSlice::new(&[7, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A location range that starts at 0.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0200_0000,
+                    end: 0x0200_0001,
+                },
+                data: Expression(EndianSlice::new(&[8, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A location range that ends at -1.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0000_0000,
+                    end: 0xffff_ffff,
+                },
+                data: Expression(EndianSlice::new(&[9, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A DefaultLocation.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0,
+                    end: u64::max_value(),
+                },
+                data: Expression(EndianSlice::new(&[10, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A BaseAddressx + OffsetPair
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0301_0100,
+                    end: 0x0301_0200,
+                },
+                data: Expression(EndianSlice::new(&[11, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A StartxEndx
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0301_0300,
+                    end: 0x0301_0400,
+                },
+                data: Expression(EndianSlice::new(&[12, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A StartxLength
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0301_0500,
+                    end: 0x0301_0600,
+                },
+                data: Expression(EndianSlice::new(&[13, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A StartEnd location following the tombstones
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0201_1600,
+                    end: 0x0201_1700,
+                },
+                data: Expression(EndianSlice::new(&[26, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A location list end.
+        assert_eq!(locations.next(), Ok(None));
+
+        // An offset at the end of buf.
+        let mut locations = loclists
+            .locations(
+                LocationListsOffset(buf.len()),
+                encoding,
+                0x0100_0000,
+                debug_addr,
+                debug_addr_base,
+            )
+            .unwrap();
+        assert_eq!(locations.next(), Ok(None));
+    }
+
+    #[test]
+    fn test_location_list_32() {
+        let tombstone = !0u32 - 1;
+        let start = Label::new();
+        let first = Label::new();
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Little)
+            // A location before the offset.
+            .mark(&start)
+            .L32(0x10000).L32(0x10100).L16(4).L32(1)
+            .mark(&first)
+            // A normal location.
+            .L32(0x10200).L32(0x10300).L16(4).L32(2)
+            // A base address selection followed by a normal location.
+            .L32(0xffff_ffff).L32(0x0200_0000)
+            .L32(0x10400).L32(0x10500).L16(4).L32(3)
+            // An empty location range followed by a normal location.
+            .L32(0x10600).L32(0x10600).L16(4).L32(4)
+            .L32(0x10800).L32(0x10900).L16(4).L32(5)
+            // A location range that starts at 0.
+            .L32(0).L32(1).L16(4).L32(6)
+            // A location range that ends at -1.
+            .L32(0xffff_ffff).L32(0x0000_0000)
+            .L32(0).L32(0xffff_ffff).L16(4).L32(7)
+            // A normal location with tombstone.
+            .L32(tombstone).L32(tombstone).L16(4).L32(8)
+            // A base address selection with tombstone followed by a normal location.
+            .L32(0xffff_ffff).L32(tombstone)
+            .L32(0x10a00).L32(0x10b00).L16(4).L32(9)
+            // A location list end.
+            .L32(0).L32(0)
+            // Some extra data.
+            .L32(0);
+
+        let buf = section.get_contents().unwrap();
+        let debug_loc = DebugLoc::new(&buf, LittleEndian);
+        let debug_loclists = DebugLocLists::new(&[], LittleEndian);
+        let loclists = LocationLists::new(debug_loc, debug_loclists);
+        let offset = LocationListsOffset((&first - &start) as usize);
+        let debug_addr = &DebugAddr::from(EndianSlice::new(&[], LittleEndian));
+        let debug_addr_base = DebugAddrBase(0);
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 4,
+        };
+        let mut locations = loclists
+            .locations(offset, encoding, 0x0100_0000, debug_addr, debug_addr_base)
+            .unwrap();
+
+        // A normal location.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0101_0200,
+                    end: 0x0101_0300,
+                },
+                data: Expression(EndianSlice::new(&[2, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A base address selection followed by a normal location.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0201_0400,
+                    end: 0x0201_0500,
+                },
+                data: Expression(EndianSlice::new(&[3, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // An empty location range followed by a normal location.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0201_0600,
+                    end: 0x0201_0600,
+                },
+                data: Expression(EndianSlice::new(&[4, 0, 0, 0], LittleEndian)),
+            }))
+        );
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0201_0800,
+                    end: 0x0201_0900,
+                },
+                data: Expression(EndianSlice::new(&[5, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A location range that starts at 0.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0200_0000,
+                    end: 0x0200_0001,
+                },
+                data: Expression(EndianSlice::new(&[6, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A location range that ends at -1.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0000_0000,
+                    end: 0xffff_ffff,
+                },
+                data: Expression(EndianSlice::new(&[7, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A location list end.
+        assert_eq!(locations.next(), Ok(None));
+
+        // An offset at the end of buf.
+        let mut locations = loclists
+            .locations(
+                LocationListsOffset(buf.len()),
+                encoding,
+                0x0100_0000,
+                debug_addr,
+                debug_addr_base,
+            )
+            .unwrap();
+        assert_eq!(locations.next(), Ok(None));
+    }
+
+    #[test]
+    fn test_location_list_64() {
+        let tombstone = !0u64 - 1;
+        let start = Label::new();
+        let first = Label::new();
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Little)
+            // A location before the offset.
+            .mark(&start)
+            .L64(0x10000).L64(0x10100).L16(4).L32(1)
+            .mark(&first)
+            // A normal location.
+            .L64(0x10200).L64(0x10300).L16(4).L32(2)
+            // A base address selection followed by a normal location.
+            .L64(0xffff_ffff_ffff_ffff).L64(0x0200_0000)
+            .L64(0x10400).L64(0x10500).L16(4).L32(3)
+            // An empty location range followed by a normal location.
+            .L64(0x10600).L64(0x10600).L16(4).L32(4)
+            .L64(0x10800).L64(0x10900).L16(4).L32(5)
+            // A location range that starts at 0.
+            .L64(0).L64(1).L16(4).L32(6)
+            // A location range that ends at -1.
+            .L64(0xffff_ffff_ffff_ffff).L64(0x0000_0000)
+            .L64(0).L64(0xffff_ffff_ffff_ffff).L16(4).L32(7)
+            // A normal location with tombstone.
+            .L64(tombstone).L64(tombstone).L16(4).L32(8)
+            // A base address selection with tombstone followed by a normal location.
+            .L64(0xffff_ffff_ffff_ffff).L64(tombstone)
+            .L64(0x10a00).L64(0x10b00).L16(4).L32(9)
+            // A location list end.
+            .L64(0).L64(0)
+            // Some extra data.
+            .L64(0);
+
+        let buf = section.get_contents().unwrap();
+        let debug_loc = DebugLoc::new(&buf, LittleEndian);
+        let debug_loclists = DebugLocLists::new(&[], LittleEndian);
+        let loclists = LocationLists::new(debug_loc, debug_loclists);
+        let offset = LocationListsOffset((&first - &start) as usize);
+        let debug_addr = &DebugAddr::from(EndianSlice::new(&[], LittleEndian));
+        let debug_addr_base = DebugAddrBase(0);
+        let encoding = Encoding {
+            format: Format::Dwarf64,
+            version: 4,
+            address_size: 8,
+        };
+        let mut locations = loclists
+            .locations(offset, encoding, 0x0100_0000, debug_addr, debug_addr_base)
+            .unwrap();
+
+        // A normal location.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0101_0200,
+                    end: 0x0101_0300,
+                },
+                data: Expression(EndianSlice::new(&[2, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A base address selection followed by a normal location.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0201_0400,
+                    end: 0x0201_0500,
+                },
+                data: Expression(EndianSlice::new(&[3, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // An empty location range followed by a normal location.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0201_0600,
+                    end: 0x0201_0600,
+                },
+                data: Expression(EndianSlice::new(&[4, 0, 0, 0], LittleEndian)),
+            }))
+        );
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0201_0800,
+                    end: 0x0201_0900,
+                },
+                data: Expression(EndianSlice::new(&[5, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A location range that starts at 0.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0200_0000,
+                    end: 0x0200_0001,
+                },
+                data: Expression(EndianSlice::new(&[6, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A location range that ends at -1.
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0,
+                    end: 0xffff_ffff_ffff_ffff,
+                },
+                data: Expression(EndianSlice::new(&[7, 0, 0, 0], LittleEndian)),
+            }))
+        );
+
+        // A location list end.
+        assert_eq!(locations.next(), Ok(None));
+
+        // An offset at the end of buf.
+        let mut locations = loclists
+            .locations(
+                LocationListsOffset(buf.len()),
+                encoding,
+                0x0100_0000,
+                debug_addr,
+                debug_addr_base,
+            )
+            .unwrap();
+        assert_eq!(locations.next(), Ok(None));
+    }
+
+    #[test]
+    fn test_locations_invalid() {
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Little)
+            // An invalid location range.
+            .L32(0x20000).L32(0x10000).L16(4).L32(1)
+            // An invalid range after wrapping.
+            .L32(0x20000).L32(0xff01_0000).L16(4).L32(2);
+
+        let buf = section.get_contents().unwrap();
+        let debug_loc = DebugLoc::new(&buf, LittleEndian);
+        let debug_loclists = DebugLocLists::new(&[], LittleEndian);
+        let loclists = LocationLists::new(debug_loc, debug_loclists);
+        let debug_addr = &DebugAddr::from(EndianSlice::new(&[], LittleEndian));
+        let debug_addr_base = DebugAddrBase(0);
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 4,
+        };
+
+        // An invalid location range.
+        let mut locations = loclists
+            .locations(
+                LocationListsOffset(0x0),
+                encoding,
+                0x0100_0000,
+                debug_addr,
+                debug_addr_base,
+            )
+            .unwrap();
+        assert_eq!(locations.next(), Err(Error::InvalidLocationAddressRange));
+
+        // An invalid location range after wrapping.
+        let mut locations = loclists
+            .locations(
+                LocationListsOffset(14),
+                encoding,
+                0x0100_0000,
+                debug_addr,
+                debug_addr_base,
+            )
+            .unwrap();
+        assert_eq!(locations.next(), Err(Error::InvalidLocationAddressRange));
+
+        // An invalid offset.
+        match loclists.locations(
+            LocationListsOffset(buf.len() + 1),
+            encoding,
+            0x0100_0000,
+            debug_addr,
+            debug_addr_base,
+        ) {
+            Err(Error::UnexpectedEof(_)) => {}
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        }
+    }
+
+    #[test]
+    fn test_get_offset() {
+        for format in vec![Format::Dwarf32, Format::Dwarf64] {
+            let encoding = Encoding {
+                format,
+                version: 5,
+                address_size: 4,
+            };
+
+            let zero = Label::new();
+            let length = Label::new();
+            let start = Label::new();
+            let first = Label::new();
+            let end = Label::new();
+            let mut section = Section::with_endian(Endian::Little)
+                .mark(&zero)
+                .initial_length(format, &length, &start)
+                .D16(encoding.version)
+                .D8(encoding.address_size)
+                .D8(0)
+                .D32(20)
+                .mark(&first);
+            for i in 0..20 {
+                section = section.word(format.word_size(), 1000 + i);
+            }
+            section = section.mark(&end);
+            length.set_const((&end - &start) as u64);
+            let section = section.get_contents().unwrap();
+
+            let debug_loc = DebugLoc::from(EndianSlice::new(&[], LittleEndian));
+            let debug_loclists = DebugLocLists::from(EndianSlice::new(&section, LittleEndian));
+            let locations = LocationLists::new(debug_loc, debug_loclists);
+
+            let base = DebugLocListsBase((&first - &zero) as usize);
+            assert_eq!(
+                locations.get_offset(encoding, base, DebugLocListsIndex(0)),
+                Ok(LocationListsOffset(base.0 + 1000))
+            );
+            assert_eq!(
+                locations.get_offset(encoding, base, DebugLocListsIndex(19)),
+                Ok(LocationListsOffset(base.0 + 1019))
+            );
+        }
+    }
+
+    #[test]
+    fn test_loclists_gnu_v4_split_dwarf() {
+        #[rustfmt::skip]
+        let buf = [
+            0x03, // DW_LLE_startx_length
+            0x00, // ULEB encoded b7
+            0x08, 0x00, 0x00, 0x00, // Fixed 4 byte length of 8
+            0x03, 0x00, // Fixed two byte length of the location
+            0x11, 0x00, // DW_OP_constu 0
+            0x9f, // DW_OP_stack_value
+            // Padding data
+            //0x99, 0x99, 0x99, 0x99
+        ];
+        let data_buf = [0x11, 0x00, 0x9f];
+        let expected_data = EndianSlice::new(&data_buf, LittleEndian);
+        let debug_loc = DebugLoc::new(&buf, LittleEndian);
+        let debug_loclists = DebugLocLists::new(&[], LittleEndian);
+        let loclists = LocationLists::new(debug_loc, debug_loclists);
+        let debug_addr =
+            &DebugAddr::from(EndianSlice::new(&[0x01, 0x02, 0x03, 0x04], LittleEndian));
+        let debug_addr_base = DebugAddrBase(0);
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 4,
+        };
+
+        // An invalid location range.
+        let mut locations = loclists
+            .locations_dwo(
+                LocationListsOffset(0x0),
+                encoding,
+                0,
+                debug_addr,
+                debug_addr_base,
+            )
+            .unwrap();
+        assert_eq!(
+            locations.next(),
+            Ok(Some(LocationListEntry {
+                range: Range {
+                    begin: 0x0403_0201,
+                    end: 0x0403_0209
+                },
+                data: Expression(expected_data),
+            }))
+        );
+    }
+}
diff --git a/vendor/gimli/src/read/lookup.rs b/vendor/gimli/src/read/lookup.rs
new file mode 100644
index 0000000..1d082f2
--- /dev/null
+++ b/vendor/gimli/src/read/lookup.rs
@@ -0,0 +1,202 @@
+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,
+            )))
+        }
+    }
+}
diff --git a/vendor/gimli/src/read/mod.rs b/vendor/gimli/src/read/mod.rs
new file mode 100644
index 0000000..2ad7f6a
--- /dev/null
+++ b/vendor/gimli/src/read/mod.rs
@@ -0,0 +1,827 @@
+//! Read DWARF debugging information.
+//!
+//! * [Example Usage](#example-usage)
+//! * [API Structure](#api-structure)
+//! * [Using with `FallibleIterator`](#using-with-fallibleiterator)
+//!
+//! ## Example Usage
+//!
+//! Print out all of the functions in the debuggee program:
+//!
+//! ```rust,no_run
+//! # fn example() -> Result<(), gimli::Error> {
+//! # type R = gimli::EndianSlice<'static, gimli::LittleEndian>;
+//! # let get_file_section_reader = |name| -> Result<R, gimli::Error> { unimplemented!() };
+//! # let get_sup_file_section_reader = |name| -> Result<R, gimli::Error> { unimplemented!() };
+//! // Read the DWARF sections with whatever object loader you're using.
+//! // These closures should return a `Reader` instance (e.g. `EndianSlice`).
+//! let loader = |section: gimli::SectionId| { get_file_section_reader(section.name()) };
+//! let sup_loader = |section: gimli::SectionId| { get_sup_file_section_reader(section.name()) };
+//! let mut dwarf = gimli::Dwarf::load(loader)?;
+//! dwarf.load_sup(sup_loader)?;
+//!
+//! // Iterate over all compilation units.
+//! let mut iter = dwarf.units();
+//! while let Some(header) = iter.next()? {
+//!     // Parse the abbreviations and other information for this compilation unit.
+//!     let unit = dwarf.unit(header)?;
+//!
+//!     // Iterate over all of this compilation unit's entries.
+//!     let mut entries = unit.entries();
+//!     while let Some((_, entry)) = entries.next_dfs()? {
+//!         // If we find an entry for a function, print it.
+//!         if entry.tag() == gimli::DW_TAG_subprogram {
+//!             println!("Found a function: {:?}", entry);
+//!         }
+//!     }
+//! }
+//! # unreachable!()
+//! # }
+//! ```
+//!
+//! Full example programs:
+//!
+//!   * [A simple parser](https://github.com/gimli-rs/gimli/blob/master/crates/examples/src/bin/simple.rs)
+//!
+//!   * [A `dwarfdump`
+//!     clone](https://github.com/gimli-rs/gimli/blob/master/crates/examples/src/bin/dwarfdump.rs)
+//!
+//!   * [An `addr2line` clone](https://github.com/gimli-rs/addr2line)
+//!
+//!   * [`ddbug`](https://github.com/gimli-rs/ddbug), a utility giving insight into
+//!     code generation by making debugging information readable
+//!
+//!   * [`dwprod`](https://github.com/fitzgen/dwprod), a tiny utility to list the
+//!     compilers used to create each compilation unit within a shared library or
+//!     executable (via `DW_AT_producer`)
+//!
+//!   * [`dwarf-validate`](https://github.com/gimli-rs/gimli/blob/master/crates/examples/src/bin/dwarf-validate.rs),
+//!     a program to validate the integrity of some DWARF and its references
+//!     between sections and compilation units.
+//!
+//! ## API Structure
+//!
+//! * Basic familiarity with DWARF is assumed.
+//!
+//! * The [`Dwarf`](./struct.Dwarf.html) type contains the commonly used DWARF
+//! sections. It has methods that simplify access to debugging data that spans
+//! multiple sections. Use of this type is optional, but recommended.
+//!
+//! * Each section gets its own type. Consider these types the entry points to
+//! the library:
+//!
+//!   * [`DebugAbbrev`](./struct.DebugAbbrev.html): The `.debug_abbrev` section.
+//!
+//!   * [`DebugAddr`](./struct.DebugAddr.html): The `.debug_addr` section.
+//!
+//!   * [`DebugAranges`](./struct.DebugAranges.html): The `.debug_aranges`
+//!   section.
+//!
+//!   * [`DebugFrame`](./struct.DebugFrame.html): The `.debug_frame` section.
+//!
+//!   * [`DebugInfo`](./struct.DebugInfo.html): The `.debug_info` section.
+//!
+//!   * [`DebugLine`](./struct.DebugLine.html): The `.debug_line` section.
+//!
+//!   * [`DebugLineStr`](./struct.DebugLineStr.html): The `.debug_line_str` section.
+//!
+//!   * [`DebugLoc`](./struct.DebugLoc.html): The `.debug_loc` section.
+//!
+//!   * [`DebugLocLists`](./struct.DebugLocLists.html): The `.debug_loclists` section.
+//!
+//!   * [`DebugPubNames`](./struct.DebugPubNames.html): The `.debug_pubnames`
+//!   section.
+//!
+//!   * [`DebugPubTypes`](./struct.DebugPubTypes.html): The `.debug_pubtypes`
+//!   section.
+//!
+//!   * [`DebugRanges`](./struct.DebugRanges.html): The `.debug_ranges` section.
+//!
+//!   * [`DebugRngLists`](./struct.DebugRngLists.html): The `.debug_rnglists` section.
+//!
+//!   * [`DebugStr`](./struct.DebugStr.html): The `.debug_str` section.
+//!
+//!   * [`DebugStrOffsets`](./struct.DebugStrOffsets.html): The `.debug_str_offsets` section.
+//!
+//!   * [`DebugTypes`](./struct.DebugTypes.html): The `.debug_types` section.
+//!
+//!   * [`DebugCuIndex`](./struct.DebugCuIndex.html): The `.debug_cu_index` section.
+//!
+//!   * [`DebugTuIndex`](./struct.DebugTuIndex.html): The `.debug_tu_index` section.
+//!
+//!   * [`EhFrame`](./struct.EhFrame.html): The `.eh_frame` section.
+//!
+//!   * [`EhFrameHdr`](./struct.EhFrameHdr.html): The `.eh_frame_hdr` section.
+//!
+//! * Each section type exposes methods for accessing the debugging data encoded
+//! in that section. For example, the [`DebugInfo`](./struct.DebugInfo.html)
+//! struct has the [`units`](./struct.DebugInfo.html#method.units) method for
+//! iterating over the compilation units defined within it.
+//!
+//! * Offsets into a section are strongly typed: an offset into `.debug_info` is
+//! the [`DebugInfoOffset`](./struct.DebugInfoOffset.html) type. It cannot be
+//! used to index into the [`DebugLine`](./struct.DebugLine.html) type because
+//! `DebugLine` represents the `.debug_line` section. There are similar types
+//! for offsets relative to a compilation unit rather than a section.
+//!
+//! ## Using with `FallibleIterator`
+//!
+//! The standard library's `Iterator` trait and related APIs do not play well
+//! with iterators where the `next` operation is fallible. One can make the
+//! `Iterator`'s associated `Item` type be a `Result<T, E>`, however the
+//! provided methods cannot gracefully handle the case when an `Err` is
+//! returned.
+//!
+//! This situation led to the
+//! [`fallible-iterator`](https://crates.io/crates/fallible-iterator) crate's
+//! existence. You can read more of the rationale for its existence in its
+//! docs. The crate provides the helpers you have come to expect (eg `map`,
+//! `filter`, etc) for iterators that can fail.
+//!
+//! `gimli`'s many lazy parsing iterators are a perfect match for the
+//! `fallible-iterator` crate's `FallibleIterator` trait because parsing is not
+//! done eagerly. Parse errors later in the input might only be discovered after
+//! having iterated through many items.
+//!
+//! To use `gimli` iterators with `FallibleIterator`, import the crate and trait
+//! into your code:
+//!
+//! ```
+//! # #[cfg(feature = "fallible-iterator")]
+//! # fn foo() {
+//! // Use the `FallibleIterator` trait so its methods are in scope!
+//! use fallible_iterator::FallibleIterator;
+//! use gimli::{DebugAranges, EndianSlice, LittleEndian};
+//!
+//! fn find_sum_of_address_range_lengths(aranges: DebugAranges<EndianSlice<LittleEndian>>)
+//!     -> gimli::Result<u64>
+//! {
+//!     // `DebugAranges::headers` returns a `FallibleIterator`!
+//!     aranges.headers()
+//!         // `flat_map` is provided by `FallibleIterator`!
+//!         .flat_map(|header| Ok(header.entries()))
+//!         // `map` is provided by `FallibleIterator`!
+//!         .map(|arange| Ok(arange.length()))
+//!         // `fold` is provided by `FallibleIterator`!
+//!         .fold(0, |sum, len| Ok(sum + len))
+//! }
+//! # }
+//! # fn main() {}
+//! ```
+
+use core::fmt::{self, Debug};
+use core::result;
+#[cfg(feature = "std")]
+use std::{error, io};
+
+use crate::common::{Register, SectionId};
+use crate::constants;
+
+mod util;
+pub use util::*;
+
+mod addr;
+pub use self::addr::*;
+
+mod cfi;
+pub use self::cfi::*;
+
+#[cfg(feature = "read")]
+mod dwarf;
+#[cfg(feature = "read")]
+pub use self::dwarf::*;
+
+mod endian_slice;
+pub use self::endian_slice::*;
+
+#[cfg(feature = "endian-reader")]
+mod endian_reader;
+#[cfg(feature = "endian-reader")]
+pub use self::endian_reader::*;
+
+mod reader;
+pub use self::reader::*;
+
+#[cfg(feature = "read")]
+mod abbrev;
+#[cfg(feature = "read")]
+pub use self::abbrev::*;
+
+mod aranges;
+pub use self::aranges::*;
+
+mod index;
+pub use self::index::*;
+
+#[cfg(feature = "read")]
+mod line;
+#[cfg(feature = "read")]
+pub use self::line::*;
+
+mod lists;
+
+mod loclists;
+pub use self::loclists::*;
+
+#[cfg(feature = "read")]
+mod lookup;
+
+mod op;
+pub use self::op::*;
+
+#[cfg(feature = "read")]
+mod pubnames;
+#[cfg(feature = "read")]
+pub use self::pubnames::*;
+
+#[cfg(feature = "read")]
+mod pubtypes;
+#[cfg(feature = "read")]
+pub use self::pubtypes::*;
+
+mod rnglists;
+pub use self::rnglists::*;
+
+mod str;
+pub use self::str::*;
+
+/// An offset into the current compilation or type unit.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Hash)]
+pub struct UnitOffset<T = usize>(pub T);
+
+#[cfg(feature = "read")]
+mod unit;
+#[cfg(feature = "read")]
+pub use self::unit::*;
+
+mod value;
+pub use self::value::*;
+
+/// Indicates that storage should be allocated on heap.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct StoreOnHeap;
+
+/// `EndianBuf` has been renamed to `EndianSlice`. For ease of upgrading across
+/// `gimli` versions, we export this type alias.
+#[deprecated(note = "EndianBuf has been renamed to EndianSlice, use that instead.")]
+pub type EndianBuf<'input, Endian> = EndianSlice<'input, Endian>;
+
+/// An error that occurred when parsing.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Error {
+    /// An I/O error occurred while reading.
+    Io,
+    /// Found a PC relative pointer, but the section base is undefined.
+    PcRelativePointerButSectionBaseIsUndefined,
+    /// Found a `.text` relative pointer, but the `.text` base is undefined.
+    TextRelativePointerButTextBaseIsUndefined,
+    /// Found a data relative pointer, but the data base is undefined.
+    DataRelativePointerButDataBaseIsUndefined,
+    /// Found a function relative pointer in a context that does not have a
+    /// function base.
+    FuncRelativePointerInBadContext,
+    /// Cannot parse a pointer with a `DW_EH_PE_omit` encoding.
+    CannotParseOmitPointerEncoding,
+    /// An error parsing an unsigned LEB128 value.
+    BadUnsignedLeb128,
+    /// An error parsing a signed LEB128 value.
+    BadSignedLeb128,
+    /// An abbreviation declared that its tag is zero, but zero is reserved for
+    /// null records.
+    AbbreviationTagZero,
+    /// An attribute specification declared that its form is zero, but zero is
+    /// reserved for null records.
+    AttributeFormZero,
+    /// The abbreviation's has-children byte was not one of
+    /// `DW_CHILDREN_{yes,no}`.
+    BadHasChildren,
+    /// The specified length is impossible.
+    BadLength,
+    /// Found an unknown `DW_FORM_*` type.
+    UnknownForm,
+    /// Expected a zero, found something else.
+    ExpectedZero,
+    /// Found an abbreviation code that has already been used.
+    DuplicateAbbreviationCode,
+    /// Found a duplicate arange.
+    DuplicateArange,
+    /// Found an unknown reserved length value.
+    UnknownReservedLength,
+    /// Found an unknown DWARF version.
+    UnknownVersion(u64),
+    /// Found a record with an unknown abbreviation code.
+    UnknownAbbreviation,
+    /// Hit the end of input before it was expected.
+    UnexpectedEof(ReaderOffsetId),
+    /// Read a null entry before it was expected.
+    UnexpectedNull,
+    /// Found an unknown standard opcode.
+    UnknownStandardOpcode(constants::DwLns),
+    /// Found an unknown extended opcode.
+    UnknownExtendedOpcode(constants::DwLne),
+    /// The specified address size is not supported.
+    UnsupportedAddressSize(u8),
+    /// The specified offset size is not supported.
+    UnsupportedOffsetSize(u8),
+    /// The specified field size is not supported.
+    UnsupportedFieldSize(u8),
+    /// The minimum instruction length must not be zero.
+    MinimumInstructionLengthZero,
+    /// The maximum operations per instruction must not be zero.
+    MaximumOperationsPerInstructionZero,
+    /// The line range must not be zero.
+    LineRangeZero,
+    /// The opcode base must not be zero.
+    OpcodeBaseZero,
+    /// Found an invalid UTF-8 string.
+    BadUtf8,
+    /// Expected to find the CIE ID, but found something else.
+    NotCieId,
+    /// Expected to find a pointer to a CIE, but found the CIE ID instead.
+    NotCiePointer,
+    /// Expected to find a pointer to an FDE, but found a CIE instead.
+    NotFdePointer,
+    /// Invalid branch target for a DW_OP_bra or DW_OP_skip.
+    BadBranchTarget(u64),
+    /// DW_OP_push_object_address used but no address passed in.
+    InvalidPushObjectAddress,
+    /// Not enough items on the stack when evaluating an expression.
+    NotEnoughStackItems,
+    /// Too many iterations to compute the expression.
+    TooManyIterations,
+    /// An unrecognized operation was found while parsing a DWARF
+    /// expression.
+    InvalidExpression(constants::DwOp),
+    /// An unsupported operation was found while evaluating a DWARF expression.
+    UnsupportedEvaluation,
+    /// The expression had a piece followed by an expression
+    /// terminator without a piece.
+    InvalidPiece,
+    /// An expression-terminating operation was followed by something
+    /// other than the end of the expression or a piece operation.
+    InvalidExpressionTerminator(u64),
+    /// Division or modulus by zero when evaluating an expression.
+    DivisionByZero,
+    /// An expression operation used mismatching types.
+    TypeMismatch,
+    /// An expression operation required an integral type but saw a
+    /// floating point type.
+    IntegralTypeRequired,
+    /// An expression operation used types that are not supported.
+    UnsupportedTypeOperation,
+    /// The shift value in an expression must be a non-negative integer.
+    InvalidShiftExpression,
+    /// An unknown DW_CFA_* instruction.
+    UnknownCallFrameInstruction(constants::DwCfa),
+    /// The end of an address range was before the beginning.
+    InvalidAddressRange,
+    /// The end offset of a loc list entry was before the beginning.
+    InvalidLocationAddressRange,
+    /// Encountered a call frame instruction in a context in which it is not
+    /// valid.
+    CfiInstructionInInvalidContext,
+    /// When evaluating call frame instructions, found a `DW_CFA_restore_state`
+    /// stack pop instruction, but the stack was empty, and had nothing to pop.
+    PopWithEmptyStack,
+    /// Do not have unwind info for the given address.
+    NoUnwindInfoForAddress,
+    /// An offset value was larger than the maximum supported value.
+    UnsupportedOffset,
+    /// The given pointer encoding is either unknown or invalid.
+    UnknownPointerEncoding,
+    /// Did not find an entry at the given offset.
+    NoEntryAtGivenOffset,
+    /// The given offset is out of bounds.
+    OffsetOutOfBounds,
+    /// Found an unknown CFI augmentation.
+    UnknownAugmentation,
+    /// We do not support the given pointer encoding yet.
+    UnsupportedPointerEncoding,
+    /// Registers larger than `u16` are not supported.
+    UnsupportedRegister(u64),
+    /// The CFI program defined more register rules than we have storage for.
+    TooManyRegisterRules,
+    /// Attempted to push onto the CFI or evaluation stack, but it was already
+    /// at full capacity.
+    StackFull,
+    /// The `.eh_frame_hdr` binary search table claims to be variable-length encoded,
+    /// which makes binary search impossible.
+    VariableLengthSearchTable,
+    /// The `DW_UT_*` value for this unit is not supported yet.
+    UnsupportedUnitType,
+    /// Ranges using AddressIndex are not supported yet.
+    UnsupportedAddressIndex,
+    /// Nonzero segment selector sizes aren't supported yet.
+    UnsupportedSegmentSize,
+    /// A compilation unit or type unit is missing its top level DIE.
+    MissingUnitDie,
+    /// A DIE attribute used an unsupported form.
+    UnsupportedAttributeForm,
+    /// Missing DW_LNCT_path in file entry format.
+    MissingFileEntryFormatPath,
+    /// Expected an attribute value to be a string form.
+    ExpectedStringAttributeValue,
+    /// `DW_FORM_implicit_const` used in an invalid context.
+    InvalidImplicitConst,
+    /// Invalid section count in `.dwp` index.
+    InvalidIndexSectionCount,
+    /// Invalid slot count in `.dwp` index.
+    InvalidIndexSlotCount,
+    /// Invalid hash row in `.dwp` index.
+    InvalidIndexRow,
+    /// Unknown section type in `.dwp` index.
+    UnknownIndexSection,
+}
+
+impl fmt::Display for Error {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> ::core::result::Result<(), fmt::Error> {
+        write!(f, "{}", self.description())
+    }
+}
+
+impl Error {
+    /// A short description of the error.
+    pub fn description(&self) -> &str {
+        match *self {
+            Error::Io => "An I/O error occurred while reading.",
+            Error::PcRelativePointerButSectionBaseIsUndefined => {
+                "Found a PC relative pointer, but the section base is undefined."
+            }
+            Error::TextRelativePointerButTextBaseIsUndefined => {
+                "Found a `.text` relative pointer, but the `.text` base is undefined."
+            }
+            Error::DataRelativePointerButDataBaseIsUndefined => {
+                "Found a data relative pointer, but the data base is undefined."
+            }
+            Error::FuncRelativePointerInBadContext => {
+                "Found a function relative pointer in a context that does not have a function base."
+            }
+            Error::CannotParseOmitPointerEncoding => {
+                "Cannot parse a pointer with a `DW_EH_PE_omit` encoding."
+            }
+            Error::BadUnsignedLeb128 => "An error parsing an unsigned LEB128 value",
+            Error::BadSignedLeb128 => "An error parsing a signed LEB128 value",
+            Error::AbbreviationTagZero => {
+                "An abbreviation declared that its tag is zero,
+                 but zero is reserved for null records"
+            }
+            Error::AttributeFormZero => {
+                "An attribute specification declared that its form is zero,
+                 but zero is reserved for null records"
+            }
+            Error::BadHasChildren => {
+                "The abbreviation's has-children byte was not one of
+                 `DW_CHILDREN_{yes,no}`"
+            }
+            Error::BadLength => "The specified length is impossible",
+            Error::UnknownForm => "Found an unknown `DW_FORM_*` type",
+            Error::ExpectedZero => "Expected a zero, found something else",
+            Error::DuplicateAbbreviationCode => {
+                "Found an abbreviation code that has already been used"
+            }
+            Error::DuplicateArange => "Found a duplicate arange",
+            Error::UnknownReservedLength => "Found an unknown reserved length value",
+            Error::UnknownVersion(_) => "Found an unknown DWARF version",
+            Error::UnknownAbbreviation => "Found a record with an unknown abbreviation code",
+            Error::UnexpectedEof(_) => "Hit the end of input before it was expected",
+            Error::UnexpectedNull => "Read a null entry before it was expected.",
+            Error::UnknownStandardOpcode(_) => "Found an unknown standard opcode",
+            Error::UnknownExtendedOpcode(_) => "Found an unknown extended opcode",
+            Error::UnsupportedAddressSize(_) => "The specified address size is not supported",
+            Error::UnsupportedOffsetSize(_) => "The specified offset size is not supported",
+            Error::UnsupportedFieldSize(_) => "The specified field size is not supported",
+            Error::MinimumInstructionLengthZero => {
+                "The minimum instruction length must not be zero."
+            }
+            Error::MaximumOperationsPerInstructionZero => {
+                "The maximum operations per instruction must not be zero."
+            }
+            Error::LineRangeZero => "The line range must not be zero.",
+            Error::OpcodeBaseZero => "The opcode base must not be zero.",
+            Error::BadUtf8 => "Found an invalid UTF-8 string.",
+            Error::NotCieId => "Expected to find the CIE ID, but found something else.",
+            Error::NotCiePointer => "Expected to find a CIE pointer, but found the CIE ID instead.",
+            Error::NotFdePointer => {
+                "Expected to find an FDE pointer, but found a CIE pointer instead."
+            }
+            Error::BadBranchTarget(_) => "Invalid branch target in DWARF expression",
+            Error::InvalidPushObjectAddress => {
+                "DW_OP_push_object_address used but no object address given"
+            }
+            Error::NotEnoughStackItems => "Not enough items on stack when evaluating expression",
+            Error::TooManyIterations => "Too many iterations to evaluate DWARF expression",
+            Error::InvalidExpression(_) => "Invalid opcode in DWARF expression",
+            Error::UnsupportedEvaluation => "Unsupported operation when evaluating expression",
+            Error::InvalidPiece => {
+                "DWARF expression has piece followed by non-piece expression at end"
+            }
+            Error::InvalidExpressionTerminator(_) => "Expected DW_OP_piece or DW_OP_bit_piece",
+            Error::DivisionByZero => "Division or modulus by zero when evaluating expression",
+            Error::TypeMismatch => "Type mismatch when evaluating expression",
+            Error::IntegralTypeRequired => "Integral type expected when evaluating expression",
+            Error::UnsupportedTypeOperation => {
+                "An expression operation used types that are not supported"
+            }
+            Error::InvalidShiftExpression => {
+                "The shift value in an expression must be a non-negative integer."
+            }
+            Error::UnknownCallFrameInstruction(_) => "An unknown DW_CFA_* instructiion",
+            Error::InvalidAddressRange => {
+                "The end of an address range must not be before the beginning."
+            }
+            Error::InvalidLocationAddressRange => {
+                "The end offset of a location list entry must not be before the beginning."
+            }
+            Error::CfiInstructionInInvalidContext => {
+                "Encountered a call frame instruction in a context in which it is not valid."
+            }
+            Error::PopWithEmptyStack => {
+                "When evaluating call frame instructions, found a `DW_CFA_restore_state` stack pop \
+                 instruction, but the stack was empty, and had nothing to pop."
+            }
+            Error::NoUnwindInfoForAddress => "Do not have unwind info for the given address.",
+            Error::UnsupportedOffset => {
+                "An offset value was larger than the maximum supported value."
+            }
+            Error::UnknownPointerEncoding => {
+                "The given pointer encoding is either unknown or invalid."
+            }
+            Error::NoEntryAtGivenOffset => "Did not find an entry at the given offset.",
+            Error::OffsetOutOfBounds => "The given offset is out of bounds.",
+            Error::UnknownAugmentation => "Found an unknown CFI augmentation.",
+            Error::UnsupportedPointerEncoding => {
+                "We do not support the given pointer encoding yet."
+            }
+            Error::UnsupportedRegister(_) => "Registers larger than `u16` are not supported.",
+            Error::TooManyRegisterRules => {
+                "The CFI program defined more register rules than we have storage for."
+            }
+            Error::StackFull => {
+                "Attempted to push onto the CFI stack, but it was already at full capacity."
+            }
+            Error::VariableLengthSearchTable => {
+                "The `.eh_frame_hdr` binary search table claims to be variable-length encoded, \
+                 which makes binary search impossible."
+            }
+            Error::UnsupportedUnitType => "The `DW_UT_*` value for this unit is not supported yet",
+            Error::UnsupportedAddressIndex => "Ranges involving AddressIndex are not supported yet",
+            Error::UnsupportedSegmentSize => "Nonzero segment size not supported yet",
+            Error::MissingUnitDie => {
+                "A compilation unit or type unit is missing its top level DIE."
+            }
+            Error::UnsupportedAttributeForm => "A DIE attribute used an unsupported form.",
+            Error::MissingFileEntryFormatPath => "Missing DW_LNCT_path in file entry format.",
+            Error::ExpectedStringAttributeValue => {
+                "Expected an attribute value to be a string form."
+            }
+            Error::InvalidImplicitConst => "DW_FORM_implicit_const used in an invalid context.",
+            Error::InvalidIndexSectionCount => "Invalid section count in `.dwp` index.",
+            Error::InvalidIndexSlotCount => "Invalid slot count in `.dwp` index.",
+            Error::InvalidIndexRow => "Invalid hash row in `.dwp` index.",
+            Error::UnknownIndexSection => "Unknown section type in `.dwp` index.",
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl error::Error for Error {}
+
+#[cfg(feature = "std")]
+impl From<io::Error> for Error {
+    fn from(_: io::Error) -> Self {
+        Error::Io
+    }
+}
+
+/// The result of a parse.
+pub type Result<T> = result::Result<T, Error>;
+
+/// A convenience trait for loading DWARF sections from object files.  To be
+/// used like:
+///
+/// ```
+/// use gimli::{DebugInfo, EndianSlice, LittleEndian, Reader, Section};
+///
+/// let buf = [0x00, 0x01, 0x02, 0x03];
+/// let reader = EndianSlice::new(&buf, LittleEndian);
+/// let loader = |name| -> Result<_, ()> { Ok(reader) };
+///
+/// let debug_info: DebugInfo<_> = Section::load(loader).unwrap();
+/// ```
+pub trait Section<R>: From<R> {
+    /// Returns the section id for this type.
+    fn id() -> SectionId;
+
+    /// Returns the ELF section name for this type.
+    fn section_name() -> &'static str {
+        Self::id().name()
+    }
+
+    /// Returns the ELF section name (if any) for this type when used in a dwo
+    /// file.
+    fn dwo_section_name() -> Option<&'static str> {
+        Self::id().dwo_name()
+    }
+
+    /// Returns the XCOFF section name (if any) for this type when used in a XCOFF
+    /// file.
+    fn xcoff_section_name() -> Option<&'static str> {
+        Self::id().xcoff_name()
+    }
+
+    /// Try to load the section using the given loader function.
+    fn load<F, E>(f: F) -> core::result::Result<Self, E>
+    where
+        F: FnOnce(SectionId) -> core::result::Result<R, E>,
+    {
+        f(Self::id()).map(From::from)
+    }
+
+    /// Returns the `Reader` for this section.
+    fn reader(&self) -> &R
+    where
+        R: Reader;
+
+    /// Returns the subrange of the section that is the contribution of
+    /// a unit in a `.dwp` file.
+    fn dwp_range(&self, offset: u32, size: u32) -> Result<Self>
+    where
+        R: Reader,
+    {
+        let mut data = self.reader().clone();
+        data.skip(R::Offset::from_u32(offset))?;
+        data.truncate(R::Offset::from_u32(size))?;
+        Ok(data.into())
+    }
+
+    /// Returns the `Reader` for this section.
+    fn lookup_offset_id(&self, id: ReaderOffsetId) -> Option<(SectionId, R::Offset)>
+    where
+        R: Reader,
+    {
+        self.reader()
+            .lookup_offset_id(id)
+            .map(|offset| (Self::id(), offset))
+    }
+}
+
+impl Register {
+    pub(crate) fn from_u64(x: u64) -> Result<Register> {
+        let y = x as u16;
+        if u64::from(y) == x {
+            Ok(Register(y))
+        } else {
+            Err(Error::UnsupportedRegister(x))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::common::Format;
+    use crate::endianity::LittleEndian;
+    use test_assembler::{Endian, Section};
+
+    #[test]
+    fn test_parse_initial_length_32_ok() {
+        let section = Section::with_endian(Endian::Little).L32(0x7856_3412);
+        let buf = section.get_contents().unwrap();
+
+        let input = &mut EndianSlice::new(&buf, LittleEndian);
+        match input.read_initial_length() {
+            Ok((length, format)) => {
+                assert_eq!(input.len(), 0);
+                assert_eq!(format, Format::Dwarf32);
+                assert_eq!(0x7856_3412, length);
+            }
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        }
+    }
+
+    #[test]
+    fn test_parse_initial_length_64_ok() {
+        let section = Section::with_endian(Endian::Little)
+            // Dwarf_64_INITIAL_UNIT_LENGTH
+            .L32(0xffff_ffff)
+            // Actual length
+            .L64(0xffde_bc9a_7856_3412);
+        let buf = section.get_contents().unwrap();
+        let input = &mut EndianSlice::new(&buf, LittleEndian);
+
+        #[cfg(target_pointer_width = "64")]
+        match input.read_initial_length() {
+            Ok((length, format)) => {
+                assert_eq!(input.len(), 0);
+                assert_eq!(format, Format::Dwarf64);
+                assert_eq!(0xffde_bc9a_7856_3412, length);
+            }
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        }
+
+        #[cfg(target_pointer_width = "32")]
+        match input.read_initial_length() {
+            Err(Error::UnsupportedOffset) => {}
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    fn test_parse_initial_length_unknown_reserved_value() {
+        let section = Section::with_endian(Endian::Little).L32(0xffff_fffe);
+        let buf = section.get_contents().unwrap();
+
+        let input = &mut EndianSlice::new(&buf, LittleEndian);
+        match input.read_initial_length() {
+            Err(Error::UnknownReservedLength) => assert!(true),
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    fn test_parse_initial_length_incomplete() {
+        let buf = [0xff, 0xff, 0xff]; // Need at least 4 bytes.
+
+        let input = &mut EndianSlice::new(&buf, LittleEndian);
+        match input.read_initial_length() {
+            Err(Error::UnexpectedEof(_)) => assert!(true),
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    fn test_parse_initial_length_64_incomplete() {
+        let section = Section::with_endian(Endian::Little)
+            // Dwarf_64_INITIAL_UNIT_LENGTH
+            .L32(0xffff_ffff)
+            // Actual length is not long enough.
+            .L32(0x7856_3412);
+        let buf = section.get_contents().unwrap();
+
+        let input = &mut EndianSlice::new(&buf, LittleEndian);
+        match input.read_initial_length() {
+            Err(Error::UnexpectedEof(_)) => assert!(true),
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    fn test_parse_offset_32() {
+        let section = Section::with_endian(Endian::Little).L32(0x0123_4567);
+        let buf = section.get_contents().unwrap();
+
+        let input = &mut EndianSlice::new(&buf, LittleEndian);
+        match input.read_offset(Format::Dwarf32) {
+            Ok(val) => {
+                assert_eq!(input.len(), 0);
+                assert_eq!(val, 0x0123_4567);
+            }
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    fn test_parse_offset_64_small() {
+        let section = Section::with_endian(Endian::Little).L64(0x0123_4567);
+        let buf = section.get_contents().unwrap();
+
+        let input = &mut EndianSlice::new(&buf, LittleEndian);
+        match input.read_offset(Format::Dwarf64) {
+            Ok(val) => {
+                assert_eq!(input.len(), 0);
+                assert_eq!(val, 0x0123_4567);
+            }
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_offset_64_large() {
+        let section = Section::with_endian(Endian::Little).L64(0x0123_4567_89ab_cdef);
+        let buf = section.get_contents().unwrap();
+
+        let input = &mut EndianSlice::new(&buf, LittleEndian);
+        match input.read_offset(Format::Dwarf64) {
+            Ok(val) => {
+                assert_eq!(input.len(), 0);
+                assert_eq!(val, 0x0123_4567_89ab_cdef);
+            }
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "32")]
+    fn test_parse_offset_64_large() {
+        let section = Section::with_endian(Endian::Little).L64(0x0123_4567_89ab_cdef);
+        let buf = section.get_contents().unwrap();
+
+        let input = &mut EndianSlice::new(&buf, LittleEndian);
+        match input.read_offset(Format::Dwarf64) {
+            Err(Error::UnsupportedOffset) => assert!(true),
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+}
diff --git a/vendor/gimli/src/read/op.rs b/vendor/gimli/src/read/op.rs
new file mode 100644
index 0000000..4cb681e
--- /dev/null
+++ b/vendor/gimli/src/read/op.rs
@@ -0,0 +1,4140 @@
+//! Functions for parsing and evaluating DWARF expressions.
+
+#[cfg(feature = "read")]
+use alloc::vec::Vec;
+use core::mem;
+
+use super::util::{ArrayLike, ArrayVec};
+use crate::common::{DebugAddrIndex, DebugInfoOffset, Encoding, Register};
+use crate::constants;
+use crate::read::{Error, Reader, ReaderOffset, Result, StoreOnHeap, UnitOffset, Value, ValueType};
+
+/// A reference to a DIE, either relative to the current CU or
+/// relative to the section.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DieReference<T = usize> {
+    /// A CU-relative reference.
+    UnitRef(UnitOffset<T>),
+    /// A section-relative reference.
+    DebugInfoRef(DebugInfoOffset<T>),
+}
+
+/// A single decoded DWARF expression operation.
+///
+/// DWARF expression evaluation is done in two parts: first the raw
+/// bytes of the next part of the expression are decoded; and then the
+/// decoded operation is evaluated.  This approach lets other
+/// consumers inspect the DWARF expression without reimplementing the
+/// decoding operation.
+///
+/// Multiple DWARF opcodes may decode into a single `Operation`.  For
+/// example, both `DW_OP_deref` and `DW_OP_xderef` are represented
+/// using `Operation::Deref`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Operation<R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    /// Dereference the topmost value of the stack.
+    Deref {
+        /// The DIE of the base type or 0 to indicate the generic type
+        base_type: UnitOffset<Offset>,
+        /// The size of the data to dereference.
+        size: u8,
+        /// True if the dereference operation takes an address space
+        /// argument from the stack; false otherwise.
+        space: bool,
+    },
+    /// Drop an item from the stack.
+    Drop,
+    /// Pick an item from the stack and push it on top of the stack.
+    /// This operation handles `DW_OP_pick`, `DW_OP_dup`, and
+    /// `DW_OP_over`.
+    Pick {
+        /// The index, from the top of the stack, of the item to copy.
+        index: u8,
+    },
+    /// Swap the top two stack items.
+    Swap,
+    /// Rotate the top three stack items.
+    Rot,
+    /// Take the absolute value of the top of the stack.
+    Abs,
+    /// Bitwise `and` of the top two values on the stack.
+    And,
+    /// Divide the top two values on the stack.
+    Div,
+    /// Subtract the top two values on the stack.
+    Minus,
+    /// Modulus of the top two values on the stack.
+    Mod,
+    /// Multiply the top two values on the stack.
+    Mul,
+    /// Negate the top of the stack.
+    Neg,
+    /// Bitwise `not` of the top of the stack.
+    Not,
+    /// Bitwise `or` of the top two values on the stack.
+    Or,
+    /// Add the top two values on the stack.
+    Plus,
+    /// Add a constant to the topmost value on the stack.
+    PlusConstant {
+        /// The value to add.
+        value: u64,
+    },
+    /// Logical left shift of the 2nd value on the stack by the number
+    /// of bits given by the topmost value on the stack.
+    Shl,
+    /// Right shift of the 2nd value on the stack by the number of
+    /// bits given by the topmost value on the stack.
+    Shr,
+    /// Arithmetic left shift of the 2nd value on the stack by the
+    /// number of bits given by the topmost value on the stack.
+    Shra,
+    /// Bitwise `xor` of the top two values on the stack.
+    Xor,
+    /// Branch to the target location if the top of stack is nonzero.
+    Bra {
+        /// The relative offset to the target bytecode.
+        target: i16,
+    },
+    /// Compare the top two stack values for equality.
+    Eq,
+    /// Compare the top two stack values using `>=`.
+    Ge,
+    /// Compare the top two stack values using `>`.
+    Gt,
+    /// Compare the top two stack values using `<=`.
+    Le,
+    /// Compare the top two stack values using `<`.
+    Lt,
+    /// Compare the top two stack values using `!=`.
+    Ne,
+    /// Unconditional branch to the target location.
+    Skip {
+        /// The relative offset to the target bytecode.
+        target: i16,
+    },
+    /// Push an unsigned constant value on the stack.  This handles multiple
+    /// DWARF opcodes.
+    UnsignedConstant {
+        /// The value to push.
+        value: u64,
+    },
+    /// Push a signed constant value on the stack.  This handles multiple
+    /// DWARF opcodes.
+    SignedConstant {
+        /// The value to push.
+        value: i64,
+    },
+    /// Indicate that this piece's location is in the given register.
+    ///
+    /// Completes the piece or expression.
+    Register {
+        /// The register number.
+        register: Register,
+    },
+    /// Find the value of the given register, add the offset, and then
+    /// push the resulting sum on the stack.
+    RegisterOffset {
+        /// The register number.
+        register: Register,
+        /// The offset to add.
+        offset: i64,
+        /// The DIE of the base type or 0 to indicate the generic type
+        base_type: UnitOffset<Offset>,
+    },
+    /// Compute the frame base (using `DW_AT_frame_base`), add the
+    /// given offset, and then push the resulting sum on the stack.
+    FrameOffset {
+        /// The offset to add.
+        offset: i64,
+    },
+    /// No operation.
+    Nop,
+    /// Push the object address on the stack.
+    PushObjectAddress,
+    /// Evaluate a DWARF expression as a subroutine.  The expression
+    /// comes from the `DW_AT_location` attribute of the indicated
+    /// DIE.
+    Call {
+        /// The DIE to use.
+        offset: DieReference<Offset>,
+    },
+    /// Compute the address of a thread-local variable and push it on
+    /// the stack.
+    TLS,
+    /// Compute the call frame CFA and push it on the stack.
+    CallFrameCFA,
+    /// Terminate a piece.
+    Piece {
+        /// The size of this piece in bits.
+        size_in_bits: u64,
+        /// The bit offset of this piece.  If `None`, then this piece
+        /// was specified using `DW_OP_piece` and should start at the
+        /// next byte boundary.
+        bit_offset: Option<u64>,
+    },
+    /// The object has no location, but has a known constant value.
+    ///
+    /// Represents `DW_OP_implicit_value`.
+    /// Completes the piece or expression.
+    ImplicitValue {
+        /// The implicit value to use.
+        data: R,
+    },
+    /// The object has no location, but its value is at the top of the stack.
+    ///
+    /// Represents `DW_OP_stack_value`.
+    /// Completes the piece or expression.
+    StackValue,
+    /// The object is a pointer to a value which has no actual location,
+    /// such as an implicit value or a stack value.
+    ///
+    /// Represents `DW_OP_implicit_pointer`.
+    /// Completes the piece or expression.
+    ImplicitPointer {
+        /// The `.debug_info` offset of the value that this is an implicit pointer into.
+        value: DebugInfoOffset<Offset>,
+        /// The byte offset into the value that the implicit pointer points to.
+        byte_offset: i64,
+    },
+    /// Evaluate an expression at the entry to the current subprogram, and push it on the stack.
+    ///
+    /// Represents `DW_OP_entry_value`.
+    EntryValue {
+        /// The expression to be evaluated.
+        expression: R,
+    },
+    /// This represents a parameter that was optimized out.
+    ///
+    /// The offset points to the definition of the parameter, and is
+    /// matched to the `DW_TAG_GNU_call_site_parameter` in the caller that also
+    /// points to the same definition of the parameter.
+    ///
+    /// Represents `DW_OP_GNU_parameter_ref`.
+    ParameterRef {
+        /// The DIE to use.
+        offset: UnitOffset<Offset>,
+    },
+    /// Relocate the address if needed, and push it on the stack.
+    ///
+    /// Represents `DW_OP_addr`.
+    Address {
+        /// The offset to add.
+        address: u64,
+    },
+    /// Read the address at the given index in `.debug_addr, relocate the address if needed,
+    /// and push it on the stack.
+    ///
+    /// Represents `DW_OP_addrx`.
+    AddressIndex {
+        /// The index of the address in `.debug_addr`.
+        index: DebugAddrIndex<Offset>,
+    },
+    /// Read the address at the given index in `.debug_addr, and push it on the stack.
+    /// Do not relocate the address.
+    ///
+    /// Represents `DW_OP_constx`.
+    ConstantIndex {
+        /// The index of the address in `.debug_addr`.
+        index: DebugAddrIndex<Offset>,
+    },
+    /// Interpret the value bytes as a constant of a given type, and push it on the stack.
+    ///
+    /// Represents `DW_OP_const_type`.
+    TypedLiteral {
+        /// The DIE of the base type.
+        base_type: UnitOffset<Offset>,
+        /// The value bytes.
+        value: R,
+    },
+    /// Pop the top stack entry, convert it to a different type, and push it on the stack.
+    ///
+    /// Represents `DW_OP_convert`.
+    Convert {
+        /// The DIE of the base type.
+        base_type: UnitOffset<Offset>,
+    },
+    /// Pop the top stack entry, reinterpret the bits in its value as a different type,
+    /// and push it on the stack.
+    ///
+    /// Represents `DW_OP_reinterpret`.
+    Reinterpret {
+        /// The DIE of the base type.
+        base_type: UnitOffset<Offset>,
+    },
+    /// The index of a local in the currently executing function.
+    ///
+    /// Represents `DW_OP_WASM_location 0x00`.
+    /// Completes the piece or expression.
+    WasmLocal {
+        /// The index of the local.
+        index: u32,
+    },
+    /// The index of a global.
+    ///
+    /// Represents `DW_OP_WASM_location 0x01` or `DW_OP_WASM_location 0x03`.
+    /// Completes the piece or expression.
+    WasmGlobal {
+        /// The index of the global.
+        index: u32,
+    },
+    /// The index of an item on the operand stack.
+    ///
+    /// Represents `DW_OP_WASM_location 0x02`.
+    /// Completes the piece or expression.
+    WasmStack {
+        /// The index of the stack item. 0 is the bottom of the operand stack.
+        index: u32,
+    },
+}
+
+#[derive(Debug)]
+enum OperationEvaluationResult<R: Reader> {
+    Piece,
+    Incomplete,
+    Complete { location: Location<R> },
+    Waiting(EvaluationWaiting<R>, EvaluationResult<R>),
+}
+
+/// A single location of a piece of the result of a DWARF expression.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Location<R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    /// The piece is empty.  Ordinarily this means the piece has been
+    /// optimized away.
+    Empty,
+    /// The piece is found in a register.
+    Register {
+        /// The register number.
+        register: Register,
+    },
+    /// The piece is found in memory.
+    Address {
+        /// The address.
+        address: u64,
+    },
+    /// The piece has no location but its value is known.
+    Value {
+        /// The value.
+        value: Value,
+    },
+    /// The piece is represented by some constant bytes.
+    Bytes {
+        /// The value.
+        value: R,
+    },
+    /// The piece is a pointer to a value which has no actual location.
+    ImplicitPointer {
+        /// The `.debug_info` offset of the value that this is an implicit pointer into.
+        value: DebugInfoOffset<Offset>,
+        /// The byte offset into the value that the implicit pointer points to.
+        byte_offset: i64,
+    },
+}
+
+impl<R, Offset> Location<R, Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    /// Return true if the piece is empty.
+    pub fn is_empty(&self) -> bool {
+        matches!(*self, Location::Empty)
+    }
+}
+
+/// The description of a single piece of the result of a DWARF
+/// expression.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Piece<R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    /// If given, the size of the piece in bits.  If `None`, there
+    /// must be only one piece whose size is all of the object.
+    pub size_in_bits: Option<u64>,
+    /// If given, the bit offset of the piece within the location.
+    /// If the location is a `Location::Register` or `Location::Value`,
+    /// then this offset is from the least significant bit end of
+    /// the register or value.
+    /// If the location is a `Location::Address` then the offset uses
+    /// the bit numbering and direction conventions of the language
+    /// and target system.
+    ///
+    /// If `None`, the piece starts at the location. If the
+    /// location is a register whose size is larger than the piece,
+    /// then placement within the register is defined by the ABI.
+    pub bit_offset: Option<u64>,
+    /// Where this piece is to be found.
+    pub location: Location<R, Offset>,
+}
+
+// A helper function to handle branch offsets.
+fn compute_pc<R: Reader>(pc: &R, bytecode: &R, offset: i16) -> Result<R> {
+    let pc_offset = pc.offset_from(bytecode);
+    let new_pc_offset = pc_offset.wrapping_add(R::Offset::from_i16(offset));
+    if new_pc_offset > bytecode.len() {
+        Err(Error::BadBranchTarget(new_pc_offset.into_u64()))
+    } else {
+        let mut new_pc = bytecode.clone();
+        new_pc.skip(new_pc_offset)?;
+        Ok(new_pc)
+    }
+}
+
+fn generic_type<O: ReaderOffset>() -> UnitOffset<O> {
+    UnitOffset(O::from_u64(0).unwrap())
+}
+
+impl<R, Offset> Operation<R, Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    /// Parse a single DWARF expression operation.
+    ///
+    /// This is useful when examining a DWARF expression for reasons other
+    /// than direct evaluation.
+    ///
+    /// `bytes` points to a the operation to decode.  It should point into
+    /// the same array as `bytecode`, which should be the entire
+    /// expression.
+    pub fn parse(bytes: &mut R, encoding: Encoding) -> Result<Operation<R, Offset>> {
+        let opcode = bytes.read_u8()?;
+        let name = constants::DwOp(opcode);
+        match name {
+            constants::DW_OP_addr => {
+                let address = bytes.read_address(encoding.address_size)?;
+                Ok(Operation::Address { address })
+            }
+            constants::DW_OP_deref => Ok(Operation::Deref {
+                base_type: generic_type(),
+                size: encoding.address_size,
+                space: false,
+            }),
+            constants::DW_OP_const1u => {
+                let value = bytes.read_u8()?;
+                Ok(Operation::UnsignedConstant {
+                    value: u64::from(value),
+                })
+            }
+            constants::DW_OP_const1s => {
+                let value = bytes.read_i8()?;
+                Ok(Operation::SignedConstant {
+                    value: i64::from(value),
+                })
+            }
+            constants::DW_OP_const2u => {
+                let value = bytes.read_u16()?;
+                Ok(Operation::UnsignedConstant {
+                    value: u64::from(value),
+                })
+            }
+            constants::DW_OP_const2s => {
+                let value = bytes.read_i16()?;
+                Ok(Operation::SignedConstant {
+                    value: i64::from(value),
+                })
+            }
+            constants::DW_OP_const4u => {
+                let value = bytes.read_u32()?;
+                Ok(Operation::UnsignedConstant {
+                    value: u64::from(value),
+                })
+            }
+            constants::DW_OP_const4s => {
+                let value = bytes.read_i32()?;
+                Ok(Operation::SignedConstant {
+                    value: i64::from(value),
+                })
+            }
+            constants::DW_OP_const8u => {
+                let value = bytes.read_u64()?;
+                Ok(Operation::UnsignedConstant { value })
+            }
+            constants::DW_OP_const8s => {
+                let value = bytes.read_i64()?;
+                Ok(Operation::SignedConstant { value })
+            }
+            constants::DW_OP_constu => {
+                let value = bytes.read_uleb128()?;
+                Ok(Operation::UnsignedConstant { value })
+            }
+            constants::DW_OP_consts => {
+                let value = bytes.read_sleb128()?;
+                Ok(Operation::SignedConstant { value })
+            }
+            constants::DW_OP_dup => Ok(Operation::Pick { index: 0 }),
+            constants::DW_OP_drop => Ok(Operation::Drop),
+            constants::DW_OP_over => Ok(Operation::Pick { index: 1 }),
+            constants::DW_OP_pick => {
+                let value = bytes.read_u8()?;
+                Ok(Operation::Pick { index: value })
+            }
+            constants::DW_OP_swap => Ok(Operation::Swap),
+            constants::DW_OP_rot => Ok(Operation::Rot),
+            constants::DW_OP_xderef => Ok(Operation::Deref {
+                base_type: generic_type(),
+                size: encoding.address_size,
+                space: true,
+            }),
+            constants::DW_OP_abs => Ok(Operation::Abs),
+            constants::DW_OP_and => Ok(Operation::And),
+            constants::DW_OP_div => Ok(Operation::Div),
+            constants::DW_OP_minus => Ok(Operation::Minus),
+            constants::DW_OP_mod => Ok(Operation::Mod),
+            constants::DW_OP_mul => Ok(Operation::Mul),
+            constants::DW_OP_neg => Ok(Operation::Neg),
+            constants::DW_OP_not => Ok(Operation::Not),
+            constants::DW_OP_or => Ok(Operation::Or),
+            constants::DW_OP_plus => Ok(Operation::Plus),
+            constants::DW_OP_plus_uconst => {
+                let value = bytes.read_uleb128()?;
+                Ok(Operation::PlusConstant { value })
+            }
+            constants::DW_OP_shl => Ok(Operation::Shl),
+            constants::DW_OP_shr => Ok(Operation::Shr),
+            constants::DW_OP_shra => Ok(Operation::Shra),
+            constants::DW_OP_xor => Ok(Operation::Xor),
+            constants::DW_OP_bra => {
+                let target = bytes.read_i16()?;
+                Ok(Operation::Bra { target })
+            }
+            constants::DW_OP_eq => Ok(Operation::Eq),
+            constants::DW_OP_ge => Ok(Operation::Ge),
+            constants::DW_OP_gt => Ok(Operation::Gt),
+            constants::DW_OP_le => Ok(Operation::Le),
+            constants::DW_OP_lt => Ok(Operation::Lt),
+            constants::DW_OP_ne => Ok(Operation::Ne),
+            constants::DW_OP_skip => {
+                let target = bytes.read_i16()?;
+                Ok(Operation::Skip { target })
+            }
+            constants::DW_OP_lit0
+            | constants::DW_OP_lit1
+            | constants::DW_OP_lit2
+            | constants::DW_OP_lit3
+            | constants::DW_OP_lit4
+            | constants::DW_OP_lit5
+            | constants::DW_OP_lit6
+            | constants::DW_OP_lit7
+            | constants::DW_OP_lit8
+            | constants::DW_OP_lit9
+            | constants::DW_OP_lit10
+            | constants::DW_OP_lit11
+            | constants::DW_OP_lit12
+            | constants::DW_OP_lit13
+            | constants::DW_OP_lit14
+            | constants::DW_OP_lit15
+            | constants::DW_OP_lit16
+            | constants::DW_OP_lit17
+            | constants::DW_OP_lit18
+            | constants::DW_OP_lit19
+            | constants::DW_OP_lit20
+            | constants::DW_OP_lit21
+            | constants::DW_OP_lit22
+            | constants::DW_OP_lit23
+            | constants::DW_OP_lit24
+            | constants::DW_OP_lit25
+            | constants::DW_OP_lit26
+            | constants::DW_OP_lit27
+            | constants::DW_OP_lit28
+            | constants::DW_OP_lit29
+            | constants::DW_OP_lit30
+            | constants::DW_OP_lit31 => Ok(Operation::UnsignedConstant {
+                value: (opcode - constants::DW_OP_lit0.0).into(),
+            }),
+            constants::DW_OP_reg0
+            | constants::DW_OP_reg1
+            | constants::DW_OP_reg2
+            | constants::DW_OP_reg3
+            | constants::DW_OP_reg4
+            | constants::DW_OP_reg5
+            | constants::DW_OP_reg6
+            | constants::DW_OP_reg7
+            | constants::DW_OP_reg8
+            | constants::DW_OP_reg9
+            | constants::DW_OP_reg10
+            | constants::DW_OP_reg11
+            | constants::DW_OP_reg12
+            | constants::DW_OP_reg13
+            | constants::DW_OP_reg14
+            | constants::DW_OP_reg15
+            | constants::DW_OP_reg16
+            | constants::DW_OP_reg17
+            | constants::DW_OP_reg18
+            | constants::DW_OP_reg19
+            | constants::DW_OP_reg20
+            | constants::DW_OP_reg21
+            | constants::DW_OP_reg22
+            | constants::DW_OP_reg23
+            | constants::DW_OP_reg24
+            | constants::DW_OP_reg25
+            | constants::DW_OP_reg26
+            | constants::DW_OP_reg27
+            | constants::DW_OP_reg28
+            | constants::DW_OP_reg29
+            | constants::DW_OP_reg30
+            | constants::DW_OP_reg31 => Ok(Operation::Register {
+                register: Register((opcode - constants::DW_OP_reg0.0).into()),
+            }),
+            constants::DW_OP_breg0
+            | constants::DW_OP_breg1
+            | constants::DW_OP_breg2
+            | constants::DW_OP_breg3
+            | constants::DW_OP_breg4
+            | constants::DW_OP_breg5
+            | constants::DW_OP_breg6
+            | constants::DW_OP_breg7
+            | constants::DW_OP_breg8
+            | constants::DW_OP_breg9
+            | constants::DW_OP_breg10
+            | constants::DW_OP_breg11
+            | constants::DW_OP_breg12
+            | constants::DW_OP_breg13
+            | constants::DW_OP_breg14
+            | constants::DW_OP_breg15
+            | constants::DW_OP_breg16
+            | constants::DW_OP_breg17
+            | constants::DW_OP_breg18
+            | constants::DW_OP_breg19
+            | constants::DW_OP_breg20
+            | constants::DW_OP_breg21
+            | constants::DW_OP_breg22
+            | constants::DW_OP_breg23
+            | constants::DW_OP_breg24
+            | constants::DW_OP_breg25
+            | constants::DW_OP_breg26
+            | constants::DW_OP_breg27
+            | constants::DW_OP_breg28
+            | constants::DW_OP_breg29
+            | constants::DW_OP_breg30
+            | constants::DW_OP_breg31 => {
+                let value = bytes.read_sleb128()?;
+                Ok(Operation::RegisterOffset {
+                    register: Register((opcode - constants::DW_OP_breg0.0).into()),
+                    offset: value,
+                    base_type: generic_type(),
+                })
+            }
+            constants::DW_OP_regx => {
+                let register = bytes.read_uleb128().and_then(Register::from_u64)?;
+                Ok(Operation::Register { register })
+            }
+            constants::DW_OP_fbreg => {
+                let value = bytes.read_sleb128()?;
+                Ok(Operation::FrameOffset { offset: value })
+            }
+            constants::DW_OP_bregx => {
+                let register = bytes.read_uleb128().and_then(Register::from_u64)?;
+                let offset = bytes.read_sleb128()?;
+                Ok(Operation::RegisterOffset {
+                    register,
+                    offset,
+                    base_type: generic_type(),
+                })
+            }
+            constants::DW_OP_piece => {
+                let size = bytes.read_uleb128()?;
+                Ok(Operation::Piece {
+                    size_in_bits: 8 * size,
+                    bit_offset: None,
+                })
+            }
+            constants::DW_OP_deref_size => {
+                let size = bytes.read_u8()?;
+                Ok(Operation::Deref {
+                    base_type: generic_type(),
+                    size,
+                    space: false,
+                })
+            }
+            constants::DW_OP_xderef_size => {
+                let size = bytes.read_u8()?;
+                Ok(Operation::Deref {
+                    base_type: generic_type(),
+                    size,
+                    space: true,
+                })
+            }
+            constants::DW_OP_nop => Ok(Operation::Nop),
+            constants::DW_OP_push_object_address => Ok(Operation::PushObjectAddress),
+            constants::DW_OP_call2 => {
+                let value = bytes.read_u16().map(R::Offset::from_u16)?;
+                Ok(Operation::Call {
+                    offset: DieReference::UnitRef(UnitOffset(value)),
+                })
+            }
+            constants::DW_OP_call4 => {
+                let value = bytes.read_u32().map(R::Offset::from_u32)?;
+                Ok(Operation::Call {
+                    offset: DieReference::UnitRef(UnitOffset(value)),
+                })
+            }
+            constants::DW_OP_call_ref => {
+                let value = bytes.read_offset(encoding.format)?;
+                Ok(Operation::Call {
+                    offset: DieReference::DebugInfoRef(DebugInfoOffset(value)),
+                })
+            }
+            constants::DW_OP_form_tls_address | constants::DW_OP_GNU_push_tls_address => {
+                Ok(Operation::TLS)
+            }
+            constants::DW_OP_call_frame_cfa => Ok(Operation::CallFrameCFA),
+            constants::DW_OP_bit_piece => {
+                let size = bytes.read_uleb128()?;
+                let offset = bytes.read_uleb128()?;
+                Ok(Operation::Piece {
+                    size_in_bits: size,
+                    bit_offset: Some(offset),
+                })
+            }
+            constants::DW_OP_implicit_value => {
+                let len = bytes.read_uleb128().and_then(R::Offset::from_u64)?;
+                let data = bytes.split(len)?;
+                Ok(Operation::ImplicitValue { data })
+            }
+            constants::DW_OP_stack_value => Ok(Operation::StackValue),
+            constants::DW_OP_implicit_pointer | constants::DW_OP_GNU_implicit_pointer => {
+                let value = if encoding.version == 2 {
+                    bytes
+                        .read_address(encoding.address_size)
+                        .and_then(Offset::from_u64)?
+                } else {
+                    bytes.read_offset(encoding.format)?
+                };
+                let byte_offset = bytes.read_sleb128()?;
+                Ok(Operation::ImplicitPointer {
+                    value: DebugInfoOffset(value),
+                    byte_offset,
+                })
+            }
+            constants::DW_OP_addrx | constants::DW_OP_GNU_addr_index => {
+                let index = bytes.read_uleb128().and_then(R::Offset::from_u64)?;
+                Ok(Operation::AddressIndex {
+                    index: DebugAddrIndex(index),
+                })
+            }
+            constants::DW_OP_constx | constants::DW_OP_GNU_const_index => {
+                let index = bytes.read_uleb128().and_then(R::Offset::from_u64)?;
+                Ok(Operation::ConstantIndex {
+                    index: DebugAddrIndex(index),
+                })
+            }
+            constants::DW_OP_entry_value | constants::DW_OP_GNU_entry_value => {
+                let len = bytes.read_uleb128().and_then(R::Offset::from_u64)?;
+                let expression = bytes.split(len)?;
+                Ok(Operation::EntryValue { expression })
+            }
+            constants::DW_OP_GNU_parameter_ref => {
+                let value = bytes.read_u32().map(R::Offset::from_u32)?;
+                Ok(Operation::ParameterRef {
+                    offset: UnitOffset(value),
+                })
+            }
+            constants::DW_OP_const_type | constants::DW_OP_GNU_const_type => {
+                let base_type = bytes.read_uleb128().and_then(R::Offset::from_u64)?;
+                let len = bytes.read_u8()?;
+                let value = bytes.split(R::Offset::from_u8(len))?;
+                Ok(Operation::TypedLiteral {
+                    base_type: UnitOffset(base_type),
+                    value,
+                })
+            }
+            constants::DW_OP_regval_type | constants::DW_OP_GNU_regval_type => {
+                let register = bytes.read_uleb128().and_then(Register::from_u64)?;
+                let base_type = bytes.read_uleb128().and_then(R::Offset::from_u64)?;
+                Ok(Operation::RegisterOffset {
+                    register,
+                    offset: 0,
+                    base_type: UnitOffset(base_type),
+                })
+            }
+            constants::DW_OP_deref_type | constants::DW_OP_GNU_deref_type => {
+                let size = bytes.read_u8()?;
+                let base_type = bytes.read_uleb128().and_then(R::Offset::from_u64)?;
+                Ok(Operation::Deref {
+                    base_type: UnitOffset(base_type),
+                    size,
+                    space: false,
+                })
+            }
+            constants::DW_OP_xderef_type => {
+                let size = bytes.read_u8()?;
+                let base_type = bytes.read_uleb128().and_then(R::Offset::from_u64)?;
+                Ok(Operation::Deref {
+                    base_type: UnitOffset(base_type),
+                    size,
+                    space: true,
+                })
+            }
+            constants::DW_OP_convert | constants::DW_OP_GNU_convert => {
+                let base_type = bytes.read_uleb128().and_then(R::Offset::from_u64)?;
+                Ok(Operation::Convert {
+                    base_type: UnitOffset(base_type),
+                })
+            }
+            constants::DW_OP_reinterpret | constants::DW_OP_GNU_reinterpret => {
+                let base_type = bytes.read_uleb128().and_then(R::Offset::from_u64)?;
+                Ok(Operation::Reinterpret {
+                    base_type: UnitOffset(base_type),
+                })
+            }
+            constants::DW_OP_WASM_location => match bytes.read_u8()? {
+                0x0 => {
+                    let index = bytes.read_uleb128_u32()?;
+                    Ok(Operation::WasmLocal { index })
+                }
+                0x1 => {
+                    let index = bytes.read_uleb128_u32()?;
+                    Ok(Operation::WasmGlobal { index })
+                }
+                0x2 => {
+                    let index = bytes.read_uleb128_u32()?;
+                    Ok(Operation::WasmStack { index })
+                }
+                0x3 => {
+                    let index = bytes.read_u32()?;
+                    Ok(Operation::WasmGlobal { index })
+                }
+                _ => Err(Error::InvalidExpression(name)),
+            },
+            _ => Err(Error::InvalidExpression(name)),
+        }
+    }
+}
+
+#[derive(Debug)]
+enum EvaluationState<R: Reader> {
+    Start(Option<u64>),
+    Ready,
+    Error(Error),
+    Complete,
+    Waiting(EvaluationWaiting<R>),
+}
+
+#[derive(Debug)]
+enum EvaluationWaiting<R: Reader> {
+    Memory,
+    Register { offset: i64 },
+    FrameBase { offset: i64 },
+    Tls,
+    Cfa,
+    AtLocation,
+    EntryValue,
+    ParameterRef,
+    RelocatedAddress,
+    IndexedAddress,
+    TypedLiteral { value: R },
+    Convert,
+    Reinterpret,
+}
+
+/// The state of an `Evaluation` after evaluating a DWARF expression.
+/// The evaluation is either `Complete`, or it requires more data
+/// to continue, as described by the variant.
+#[derive(Debug, PartialEq)]
+pub enum EvaluationResult<R: Reader> {
+    /// The `Evaluation` is complete, and `Evaluation::result()` can be called.
+    Complete,
+    /// The `Evaluation` needs a value from memory to proceed further.  Once the
+    /// caller determines what value to provide it should resume the `Evaluation`
+    /// by calling `Evaluation::resume_with_memory`.
+    RequiresMemory {
+        /// The address of the value required.
+        address: u64,
+        /// The size of the value required. This is guaranteed to be at most the
+        /// word size of the target architecture.
+        size: u8,
+        /// If not `None`, a target-specific address space value.
+        space: Option<u64>,
+        /// The DIE of the base type or 0 to indicate the generic type
+        base_type: UnitOffset<R::Offset>,
+    },
+    /// The `Evaluation` needs a value from a register to proceed further.  Once
+    /// the caller determines what value to provide it should resume the
+    /// `Evaluation` by calling `Evaluation::resume_with_register`.
+    RequiresRegister {
+        /// The register number.
+        register: Register,
+        /// The DIE of the base type or 0 to indicate the generic type
+        base_type: UnitOffset<R::Offset>,
+    },
+    /// The `Evaluation` needs the frame base address to proceed further.  Once
+    /// the caller determines what value to provide it should resume the
+    /// `Evaluation` by calling `Evaluation::resume_with_frame_base`.  The frame
+    /// base address is the address produced by the location description in the
+    /// `DW_AT_frame_base` attribute of the current function.
+    RequiresFrameBase,
+    /// The `Evaluation` needs a value from TLS to proceed further.  Once the
+    /// caller determines what value to provide it should resume the
+    /// `Evaluation` by calling `Evaluation::resume_with_tls`.
+    RequiresTls(u64),
+    /// The `Evaluation` needs the CFA to proceed further.  Once the caller
+    /// determines what value to provide it should resume the `Evaluation` by
+    /// calling `Evaluation::resume_with_call_frame_cfa`.
+    RequiresCallFrameCfa,
+    /// The `Evaluation` needs the DWARF expression at the given location to
+    /// proceed further.  Once the caller determines what value to provide it
+    /// should resume the `Evaluation` by calling
+    /// `Evaluation::resume_with_at_location`.
+    RequiresAtLocation(DieReference<R::Offset>),
+    /// The `Evaluation` needs the value produced by evaluating a DWARF
+    /// expression at the entry point of the current subprogram.  Once the
+    /// caller determines what value to provide it should resume the
+    /// `Evaluation` by calling `Evaluation::resume_with_entry_value`.
+    RequiresEntryValue(Expression<R>),
+    /// The `Evaluation` needs the value of the parameter at the given location
+    /// in the current function's caller.  Once the caller determines what value
+    /// to provide it should resume the `Evaluation` by calling
+    /// `Evaluation::resume_with_parameter_ref`.
+    RequiresParameterRef(UnitOffset<R::Offset>),
+    /// The `Evaluation` needs an address to be relocated to proceed further.
+    /// Once the caller determines what value to provide it should resume the
+    /// `Evaluation` by calling `Evaluation::resume_with_relocated_address`.
+    RequiresRelocatedAddress(u64),
+    /// The `Evaluation` needs an address from the `.debug_addr` section.
+    /// This address may also need to be relocated.
+    /// Once the caller determines what value to provide it should resume the
+    /// `Evaluation` by calling `Evaluation::resume_with_indexed_address`.
+    RequiresIndexedAddress {
+        /// The index of the address in the `.debug_addr` section,
+        /// relative to the `DW_AT_addr_base` of the compilation unit.
+        index: DebugAddrIndex<R::Offset>,
+        /// Whether the address also needs to be relocated.
+        relocate: bool,
+    },
+    /// The `Evaluation` needs the `ValueType` for the base type DIE at
+    /// the give unit offset.  Once the caller determines what value to provide it
+    /// should resume the `Evaluation` by calling
+    /// `Evaluation::resume_with_base_type`.
+    RequiresBaseType(UnitOffset<R::Offset>),
+}
+
+/// The bytecode for a DWARF expression or location description.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct Expression<R: Reader>(pub R);
+
+impl<R: Reader> Expression<R> {
+    /// Create an evaluation for this expression.
+    ///
+    /// The `encoding` is determined by the
+    /// [`CompilationUnitHeader`](struct.CompilationUnitHeader.html) or
+    /// [`TypeUnitHeader`](struct.TypeUnitHeader.html) that this expression
+    /// relates to.
+    ///
+    /// # Examples
+    /// ```rust,no_run
+    /// use gimli::Expression;
+    /// # let endian = gimli::LittleEndian;
+    /// # let debug_info = gimli::DebugInfo::from(gimli::EndianSlice::new(&[], endian));
+    /// # let unit = debug_info.units().next().unwrap().unwrap();
+    /// # let bytecode = gimli::EndianSlice::new(&[], endian);
+    /// let expression = gimli::Expression(bytecode);
+    /// let mut eval = expression.evaluation(unit.encoding());
+    /// let mut result = eval.evaluate().unwrap();
+    /// ```
+    #[cfg(feature = "read")]
+    #[inline]
+    pub fn evaluation(self, encoding: Encoding) -> Evaluation<R> {
+        Evaluation::new(self.0, encoding)
+    }
+
+    /// Return an iterator for the operations in the expression.
+    pub fn operations(self, encoding: Encoding) -> OperationIter<R> {
+        OperationIter {
+            input: self.0,
+            encoding,
+        }
+    }
+}
+
+/// An iterator for the operations in an expression.
+#[derive(Debug, Clone, Copy)]
+pub struct OperationIter<R: Reader> {
+    input: R,
+    encoding: Encoding,
+}
+
+impl<R: Reader> OperationIter<R> {
+    /// Read the next operation in an expression.
+    pub fn next(&mut self) -> Result<Option<Operation<R>>> {
+        if self.input.is_empty() {
+            return Ok(None);
+        }
+        match Operation::parse(&mut self.input, self.encoding) {
+            Ok(op) => Ok(Some(op)),
+            Err(e) => {
+                self.input.empty();
+                Err(e)
+            }
+        }
+    }
+
+    /// Return the current byte offset of the iterator.
+    pub fn offset_from(&self, expression: &Expression<R>) -> R::Offset {
+        self.input.offset_from(&expression.0)
+    }
+}
+
+#[cfg(feature = "fallible-iterator")]
+impl<R: Reader> fallible_iterator::FallibleIterator for OperationIter<R> {
+    type Item = Operation<R>;
+    type Error = Error;
+
+    fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> {
+        OperationIter::next(self)
+    }
+}
+
+/// Specification of what storage should be used for [`Evaluation`].
+///
+#[cfg_attr(
+    feature = "read",
+    doc = "
+Normally you would only need to use [`StoreOnHeap`], which places the stacks and the results
+on the heap using [`Vec`]. This is the default storage type parameter for [`Evaluation`].
+"
+)]
+///
+/// If you need to avoid [`Evaluation`] from allocating memory, e.g. for signal safety,
+/// you can provide you own storage specification:
+/// ```rust,no_run
+/// # use gimli::*;
+/// # let bytecode = EndianSlice::new(&[], LittleEndian);
+/// # let encoding = unimplemented!();
+/// # let get_register_value = |_, _| Value::Generic(42);
+/// # let get_frame_base = || 0xdeadbeef;
+/// #
+/// struct StoreOnStack;
+///
+/// impl<R: Reader> EvaluationStorage<R> for StoreOnStack {
+///     type Stack = [Value; 64];
+///     type ExpressionStack = [(R, R); 4];
+///     type Result = [Piece<R>; 1];
+/// }
+///
+/// let mut eval = Evaluation::<_, StoreOnStack>::new_in(bytecode, encoding);
+/// let mut result = eval.evaluate().unwrap();
+/// while result != EvaluationResult::Complete {
+///   match result {
+///     EvaluationResult::RequiresRegister { register, base_type } => {
+///       let value = get_register_value(register, base_type);
+///       result = eval.resume_with_register(value).unwrap();
+///     },
+///     EvaluationResult::RequiresFrameBase => {
+///       let frame_base = get_frame_base();
+///       result = eval.resume_with_frame_base(frame_base).unwrap();
+///     },
+///     _ => unimplemented!(),
+///   };
+/// }
+///
+/// let result = eval.as_result();
+/// println!("{:?}", result);
+/// ```
+pub trait EvaluationStorage<R: Reader> {
+    /// The storage used for the evaluation stack.
+    type Stack: ArrayLike<Item = Value>;
+    /// The storage used for the expression stack.
+    type ExpressionStack: ArrayLike<Item = (R, R)>;
+    /// The storage used for the results.
+    type Result: ArrayLike<Item = Piece<R>>;
+}
+
+#[cfg(feature = "read")]
+impl<R: Reader> EvaluationStorage<R> for StoreOnHeap {
+    type Stack = Vec<Value>;
+    type ExpressionStack = Vec<(R, R)>;
+    type Result = Vec<Piece<R>>;
+}
+
+/// A DWARF expression evaluator.
+///
+/// # Usage
+/// A DWARF expression may require additional data to produce a final result,
+/// such as the value of a register or a memory location.  Once initial setup
+/// is complete (i.e. `set_initial_value()`, `set_object_address()`) the
+/// consumer calls the `evaluate()` method.  That returns an `EvaluationResult`,
+/// which is either `EvaluationResult::Complete` or a value indicating what
+/// data is needed to resume the `Evaluation`.  The consumer is responsible for
+/// producing that data and resuming the computation with the correct method,
+/// as documented for `EvaluationResult`.  Only once an `EvaluationResult::Complete`
+/// is returned can the consumer call `result()`.
+///
+/// This design allows the consumer of `Evaluation` to decide how and when to
+/// produce the required data and resume the computation.  The `Evaluation` can
+/// be driven synchronously (as shown below) or by some asynchronous mechanism
+/// such as futures.
+///
+/// # Examples
+/// ```rust,no_run
+/// use gimli::{Evaluation, EvaluationResult, Expression};
+/// # let bytecode = gimli::EndianSlice::new(&[], gimli::LittleEndian);
+/// # let encoding = unimplemented!();
+/// # let get_register_value = |_, _| gimli::Value::Generic(42);
+/// # let get_frame_base = || 0xdeadbeef;
+///
+/// let mut eval = Evaluation::new(bytecode, encoding);
+/// let mut result = eval.evaluate().unwrap();
+/// while result != EvaluationResult::Complete {
+///   match result {
+///     EvaluationResult::RequiresRegister { register, base_type } => {
+///       let value = get_register_value(register, base_type);
+///       result = eval.resume_with_register(value).unwrap();
+///     },
+///     EvaluationResult::RequiresFrameBase => {
+///       let frame_base = get_frame_base();
+///       result = eval.resume_with_frame_base(frame_base).unwrap();
+///     },
+///     _ => unimplemented!(),
+///   };
+/// }
+///
+/// let result = eval.result();
+/// println!("{:?}", result);
+/// ```
+#[derive(Debug)]
+pub struct Evaluation<R: Reader, S: EvaluationStorage<R> = StoreOnHeap> {
+    bytecode: R,
+    encoding: Encoding,
+    object_address: Option<u64>,
+    max_iterations: Option<u32>,
+    iteration: u32,
+    state: EvaluationState<R>,
+
+    // Stack operations are done on word-sized values.  We do all
+    // operations on 64-bit values, and then mask the results
+    // appropriately when popping.
+    addr_mask: u64,
+
+    // The stack.
+    stack: ArrayVec<S::Stack>,
+
+    // The next operation to decode and evaluate.
+    pc: R,
+
+    // If we see a DW_OP_call* operation, the previous PC and bytecode
+    // is stored here while evaluating the subroutine.
+    expression_stack: ArrayVec<S::ExpressionStack>,
+
+    value_result: Option<Value>,
+    result: ArrayVec<S::Result>,
+}
+
+#[cfg(feature = "read")]
+impl<R: Reader> Evaluation<R> {
+    /// Create a new DWARF expression evaluator.
+    ///
+    /// The new evaluator is created without an initial value, without
+    /// an object address, and without a maximum number of iterations.
+    pub fn new(bytecode: R, encoding: Encoding) -> Self {
+        Self::new_in(bytecode, encoding)
+    }
+
+    /// Get the result of this `Evaluation`.
+    ///
+    /// # Panics
+    /// Panics if this `Evaluation` has not been driven to completion.
+    pub fn result(self) -> Vec<Piece<R>> {
+        match self.state {
+            EvaluationState::Complete => self.result.into_vec(),
+            _ => {
+                panic!("Called `Evaluation::result` on an `Evaluation` that has not been completed")
+            }
+        }
+    }
+}
+
+impl<R: Reader, S: EvaluationStorage<R>> Evaluation<R, S> {
+    /// Create a new DWARF expression evaluator.
+    ///
+    /// The new evaluator is created without an initial value, without
+    /// an object address, and without a maximum number of iterations.
+    pub fn new_in(bytecode: R, encoding: Encoding) -> Self {
+        let pc = bytecode.clone();
+        Evaluation {
+            bytecode,
+            encoding,
+            object_address: None,
+            max_iterations: None,
+            iteration: 0,
+            state: EvaluationState::Start(None),
+            addr_mask: if encoding.address_size == 8 {
+                !0u64
+            } else {
+                (1 << (8 * u64::from(encoding.address_size))) - 1
+            },
+            stack: Default::default(),
+            expression_stack: Default::default(),
+            pc,
+            value_result: None,
+            result: Default::default(),
+        }
+    }
+
+    /// Set an initial value to be pushed on the DWARF expression
+    /// evaluator's stack.  This can be used in cases like
+    /// `DW_AT_vtable_elem_location`, which require a value on the
+    /// stack before evaluation commences.  If no initial value is
+    /// set, and the expression uses an opcode requiring the initial
+    /// value, then evaluation will fail with an error.
+    ///
+    /// # Panics
+    /// Panics if `set_initial_value()` has already been called, or if
+    /// `evaluate()` has already been called.
+    pub fn set_initial_value(&mut self, value: u64) {
+        match self.state {
+            EvaluationState::Start(None) => {
+                self.state = EvaluationState::Start(Some(value));
+            }
+            _ => panic!(
+                "`Evaluation::set_initial_value` was called twice, or after evaluation began."
+            ),
+        };
+    }
+
+    /// Set the enclosing object's address, as used by
+    /// `DW_OP_push_object_address`.  If no object address is set, and
+    /// the expression uses an opcode requiring the object address,
+    /// then evaluation will fail with an error.
+    pub fn set_object_address(&mut self, value: u64) {
+        self.object_address = Some(value);
+    }
+
+    /// Set the maximum number of iterations to be allowed by the
+    /// expression evaluator.
+    ///
+    /// An iteration corresponds approximately to the evaluation of a
+    /// single operation in an expression ("approximately" because the
+    /// implementation may allow two such operations in some cases).
+    /// The default is not to have a maximum; once set, it's not
+    /// possible to go back to this default state.  This value can be
+    /// set to avoid denial of service attacks by bad DWARF bytecode.
+    pub fn set_max_iterations(&mut self, value: u32) {
+        self.max_iterations = Some(value);
+    }
+
+    fn pop(&mut self) -> Result<Value> {
+        match self.stack.pop() {
+            Some(value) => Ok(value),
+            None => Err(Error::NotEnoughStackItems),
+        }
+    }
+
+    fn push(&mut self, value: Value) -> Result<()> {
+        self.stack.try_push(value).map_err(|_| Error::StackFull)
+    }
+
+    fn evaluate_one_operation(&mut self) -> Result<OperationEvaluationResult<R>> {
+        let operation = Operation::parse(&mut self.pc, self.encoding)?;
+
+        match operation {
+            Operation::Deref {
+                base_type,
+                size,
+                space,
+            } => {
+                let entry = self.pop()?;
+                let addr = entry.to_u64(self.addr_mask)?;
+                let addr_space = if space {
+                    let entry = self.pop()?;
+                    let value = entry.to_u64(self.addr_mask)?;
+                    Some(value)
+                } else {
+                    None
+                };
+                return Ok(OperationEvaluationResult::Waiting(
+                    EvaluationWaiting::Memory,
+                    EvaluationResult::RequiresMemory {
+                        address: addr,
+                        size,
+                        space: addr_space,
+                        base_type,
+                    },
+                ));
+            }
+
+            Operation::Drop => {
+                self.pop()?;
+            }
+            Operation::Pick { index } => {
+                let len = self.stack.len();
+                let index = index as usize;
+                if index >= len {
+                    return Err(Error::NotEnoughStackItems);
+                }
+                let value = self.stack[len - index - 1];
+                self.push(value)?;
+            }
+            Operation::Swap => {
+                let top = self.pop()?;
+                let next = self.pop()?;
+                self.push(top)?;
+                self.push(next)?;
+            }
+            Operation::Rot => {
+                let one = self.pop()?;
+                let two = self.pop()?;
+                let three = self.pop()?;
+                self.push(one)?;
+                self.push(three)?;
+                self.push(two)?;
+            }
+
+            Operation::Abs => {
+                let value = self.pop()?;
+                let result = value.abs(self.addr_mask)?;
+                self.push(result)?;
+            }
+            Operation::And => {
+                let rhs = self.pop()?;
+                let lhs = self.pop()?;
+                let result = lhs.and(rhs, self.addr_mask)?;
+                self.push(result)?;
+            }
+            Operation::Div => {
+                let rhs = self.pop()?;
+                let lhs = self.pop()?;
+                let result = lhs.div(rhs, self.addr_mask)?;
+                self.push(result)?;
+            }
+            Operation::Minus => {
+                let rhs = self.pop()?;
+                let lhs = self.pop()?;
+                let result = lhs.sub(rhs, self.addr_mask)?;
+                self.push(result)?;
+            }
+            Operation::Mod => {
+                let rhs = self.pop()?;
+                let lhs = self.pop()?;
+                let result = lhs.rem(rhs, self.addr_mask)?;
+                self.push(result)?;
+            }
+            Operation::Mul => {
+                let rhs = self.pop()?;
+                let lhs = self.pop()?;
+                let result = lhs.mul(rhs, self.addr_mask)?;
+                self.push(result)?;
+            }
+            Operation::Neg => {
+                let v = self.pop()?;
+                let result = v.neg(self.addr_mask)?;
+                self.push(result)?;
+            }
+            Operation::Not => {
+                let value = self.pop()?;
+                let result = value.not(self.addr_mask)?;
+                self.push(result)?;
+            }
+            Operation::Or => {
+                let rhs = self.pop()?;
+                let lhs = self.pop()?;
+                let result = lhs.or(rhs, self.addr_mask)?;
+                self.push(result)?;
+            }
+            Operation::Plus => {
+                let rhs = self.pop()?;
+                let lhs = self.pop()?;
+                let result = lhs.add(rhs, self.addr_mask)?;
+                self.push(result)?;
+            }
+            Operation::PlusConstant { value } => {
+                let lhs = self.pop()?;
+                let rhs = Value::from_u64(lhs.value_type(), value)?;
+                let result = lhs.add(rhs, self.addr_mask)?;
+                self.push(result)?;
+            }
+            Operation::Shl => {
+                let rhs = self.pop()?;
+                let lhs = self.pop()?;
+                let result = lhs.shl(rhs, self.addr_mask)?;
+                self.push(result)?;
+            }
+            Operation::Shr => {
+                let rhs = self.pop()?;
+                let lhs = self.pop()?;
+                let result = lhs.shr(rhs, self.addr_mask)?;
+                self.push(result)?;
+            }
+            Operation::Shra => {
+                let rhs = self.pop()?;
+                let lhs = self.pop()?;
+                let result = lhs.shra(rhs, self.addr_mask)?;
+                self.push(result)?;
+            }
+            Operation::Xor => {
+                let rhs = self.pop()?;
+                let lhs = self.pop()?;
+                let result = lhs.xor(rhs, self.addr_mask)?;
+                self.push(result)?;
+            }
+
+            Operation::Bra { target } => {
+                let entry = self.pop()?;
+                let v = entry.to_u64(self.addr_mask)?;
+                if v != 0 {
+                    self.pc = compute_pc(&self.pc, &self.bytecode, target)?;
+                }
+            }
+
+            Operation::Eq => {
+                let rhs = self.pop()?;
+                let lhs = self.pop()?;
+                let result = lhs.eq(rhs, self.addr_mask)?;
+                self.push(result)?;
+            }
+            Operation::Ge => {
+                let rhs = self.pop()?;
+                let lhs = self.pop()?;
+                let result = lhs.ge(rhs, self.addr_mask)?;
+                self.push(result)?;
+            }
+            Operation::Gt => {
+                let rhs = self.pop()?;
+                let lhs = self.pop()?;
+                let result = lhs.gt(rhs, self.addr_mask)?;
+                self.push(result)?;
+            }
+            Operation::Le => {
+                let rhs = self.pop()?;
+                let lhs = self.pop()?;
+                let result = lhs.le(rhs, self.addr_mask)?;
+                self.push(result)?;
+            }
+            Operation::Lt => {
+                let rhs = self.pop()?;
+                let lhs = self.pop()?;
+                let result = lhs.lt(rhs, self.addr_mask)?;
+                self.push(result)?;
+            }
+            Operation::Ne => {
+                let rhs = self.pop()?;
+                let lhs = self.pop()?;
+                let result = lhs.ne(rhs, self.addr_mask)?;
+                self.push(result)?;
+            }
+
+            Operation::Skip { target } => {
+                self.pc = compute_pc(&self.pc, &self.bytecode, target)?;
+            }
+
+            Operation::UnsignedConstant { value } => {
+                self.push(Value::Generic(value))?;
+            }
+
+            Operation::SignedConstant { value } => {
+                self.push(Value::Generic(value as u64))?;
+            }
+
+            Operation::RegisterOffset {
+                register,
+                offset,
+                base_type,
+            } => {
+                return Ok(OperationEvaluationResult::Waiting(
+                    EvaluationWaiting::Register { offset },
+                    EvaluationResult::RequiresRegister {
+                        register,
+                        base_type,
+                    },
+                ));
+            }
+
+            Operation::FrameOffset { offset } => {
+                return Ok(OperationEvaluationResult::Waiting(
+                    EvaluationWaiting::FrameBase { offset },
+                    EvaluationResult::RequiresFrameBase,
+                ));
+            }
+
+            Operation::Nop => {}
+
+            Operation::PushObjectAddress => {
+                if let Some(value) = self.object_address {
+                    self.push(Value::Generic(value))?;
+                } else {
+                    return Err(Error::InvalidPushObjectAddress);
+                }
+            }
+
+            Operation::Call { offset } => {
+                return Ok(OperationEvaluationResult::Waiting(
+                    EvaluationWaiting::AtLocation,
+                    EvaluationResult::RequiresAtLocation(offset),
+                ));
+            }
+
+            Operation::TLS => {
+                let entry = self.pop()?;
+                let index = entry.to_u64(self.addr_mask)?;
+                return Ok(OperationEvaluationResult::Waiting(
+                    EvaluationWaiting::Tls,
+                    EvaluationResult::RequiresTls(index),
+                ));
+            }
+
+            Operation::CallFrameCFA => {
+                return Ok(OperationEvaluationResult::Waiting(
+                    EvaluationWaiting::Cfa,
+                    EvaluationResult::RequiresCallFrameCfa,
+                ));
+            }
+
+            Operation::Register { register } => {
+                let location = Location::Register { register };
+                return Ok(OperationEvaluationResult::Complete { location });
+            }
+
+            Operation::ImplicitValue { ref data } => {
+                let location = Location::Bytes {
+                    value: data.clone(),
+                };
+                return Ok(OperationEvaluationResult::Complete { location });
+            }
+
+            Operation::StackValue => {
+                let value = self.pop()?;
+                let location = Location::Value { value };
+                return Ok(OperationEvaluationResult::Complete { location });
+            }
+
+            Operation::ImplicitPointer { value, byte_offset } => {
+                let location = Location::ImplicitPointer { value, byte_offset };
+                return Ok(OperationEvaluationResult::Complete { location });
+            }
+
+            Operation::EntryValue { ref expression } => {
+                return Ok(OperationEvaluationResult::Waiting(
+                    EvaluationWaiting::EntryValue,
+                    EvaluationResult::RequiresEntryValue(Expression(expression.clone())),
+                ));
+            }
+
+            Operation::ParameterRef { offset } => {
+                return Ok(OperationEvaluationResult::Waiting(
+                    EvaluationWaiting::ParameterRef,
+                    EvaluationResult::RequiresParameterRef(offset),
+                ));
+            }
+
+            Operation::Address { address } => {
+                return Ok(OperationEvaluationResult::Waiting(
+                    EvaluationWaiting::RelocatedAddress,
+                    EvaluationResult::RequiresRelocatedAddress(address),
+                ));
+            }
+
+            Operation::AddressIndex { index } => {
+                return Ok(OperationEvaluationResult::Waiting(
+                    EvaluationWaiting::IndexedAddress,
+                    EvaluationResult::RequiresIndexedAddress {
+                        index,
+                        relocate: true,
+                    },
+                ));
+            }
+
+            Operation::ConstantIndex { index } => {
+                return Ok(OperationEvaluationResult::Waiting(
+                    EvaluationWaiting::IndexedAddress,
+                    EvaluationResult::RequiresIndexedAddress {
+                        index,
+                        relocate: false,
+                    },
+                ));
+            }
+
+            Operation::Piece {
+                size_in_bits,
+                bit_offset,
+            } => {
+                let location = if self.stack.is_empty() {
+                    Location::Empty
+                } else {
+                    let entry = self.pop()?;
+                    let address = entry.to_u64(self.addr_mask)?;
+                    Location::Address { address }
+                };
+                self.result
+                    .try_push(Piece {
+                        size_in_bits: Some(size_in_bits),
+                        bit_offset,
+                        location,
+                    })
+                    .map_err(|_| Error::StackFull)?;
+                return Ok(OperationEvaluationResult::Piece);
+            }
+
+            Operation::TypedLiteral { base_type, value } => {
+                return Ok(OperationEvaluationResult::Waiting(
+                    EvaluationWaiting::TypedLiteral { value },
+                    EvaluationResult::RequiresBaseType(base_type),
+                ));
+            }
+            Operation::Convert { base_type } => {
+                return Ok(OperationEvaluationResult::Waiting(
+                    EvaluationWaiting::Convert,
+                    EvaluationResult::RequiresBaseType(base_type),
+                ));
+            }
+            Operation::Reinterpret { base_type } => {
+                return Ok(OperationEvaluationResult::Waiting(
+                    EvaluationWaiting::Reinterpret,
+                    EvaluationResult::RequiresBaseType(base_type),
+                ));
+            }
+            Operation::WasmLocal { .. }
+            | Operation::WasmGlobal { .. }
+            | Operation::WasmStack { .. } => {
+                return Err(Error::UnsupportedEvaluation);
+            }
+        }
+
+        Ok(OperationEvaluationResult::Incomplete)
+    }
+
+    /// Get the result if this is an evaluation for a value.
+    ///
+    /// Returns `None` if the evaluation contained operations that are only
+    /// valid for location descriptions.
+    ///
+    /// # Panics
+    /// Panics if this `Evaluation` has not been driven to completion.
+    pub fn value_result(&self) -> Option<Value> {
+        match self.state {
+            EvaluationState::Complete => self.value_result,
+            _ => {
+                panic!("Called `Evaluation::value_result` on an `Evaluation` that has not been completed")
+            }
+        }
+    }
+
+    /// Get the result of this `Evaluation`.
+    ///
+    /// # Panics
+    /// Panics if this `Evaluation` has not been driven to completion.
+    pub fn as_result(&self) -> &[Piece<R>] {
+        match self.state {
+            EvaluationState::Complete => &self.result,
+            _ => {
+                panic!(
+                    "Called `Evaluation::as_result` on an `Evaluation` that has not been completed"
+                )
+            }
+        }
+    }
+
+    /// Evaluate a DWARF expression.  This method should only ever be called
+    /// once.  If the returned `EvaluationResult` is not
+    /// `EvaluationResult::Complete`, the caller should provide the required
+    /// value and resume the evaluation by calling the appropriate resume_with
+    /// method on `Evaluation`.
+    pub fn evaluate(&mut self) -> Result<EvaluationResult<R>> {
+        match self.state {
+            EvaluationState::Start(initial_value) => {
+                if let Some(value) = initial_value {
+                    self.push(Value::Generic(value))?;
+                }
+                self.state = EvaluationState::Ready;
+            }
+            EvaluationState::Ready => {}
+            EvaluationState::Error(err) => return Err(err),
+            EvaluationState::Complete => return Ok(EvaluationResult::Complete),
+            EvaluationState::Waiting(_) => panic!(),
+        };
+
+        match self.evaluate_internal() {
+            Ok(r) => Ok(r),
+            Err(e) => {
+                self.state = EvaluationState::Error(e);
+                Err(e)
+            }
+        }
+    }
+
+    /// Resume the `Evaluation` with the provided memory `value`.  This will apply
+    /// the provided memory value to the evaluation and continue evaluating
+    /// opcodes until the evaluation is completed, reaches an error, or needs
+    /// more information again.
+    ///
+    /// # Panics
+    /// Panics if this `Evaluation` did not previously stop with `EvaluationResult::RequiresMemory`.
+    pub fn resume_with_memory(&mut self, value: Value) -> Result<EvaluationResult<R>> {
+        match self.state {
+            EvaluationState::Error(err) => return Err(err),
+            EvaluationState::Waiting(EvaluationWaiting::Memory) => {
+                self.push(value)?;
+            }
+            _ => panic!(
+                "Called `Evaluation::resume_with_memory` without a preceding `EvaluationResult::RequiresMemory`"
+            ),
+        };
+
+        self.evaluate_internal()
+    }
+
+    /// Resume the `Evaluation` with the provided `register` value.  This will apply
+    /// the provided register value to the evaluation and continue evaluating
+    /// opcodes until the evaluation is completed, reaches an error, or needs
+    /// more information again.
+    ///
+    /// # Panics
+    /// Panics if this `Evaluation` did not previously stop with `EvaluationResult::RequiresRegister`.
+    pub fn resume_with_register(&mut self, value: Value) -> Result<EvaluationResult<R>> {
+        match self.state {
+            EvaluationState::Error(err) => return Err(err),
+            EvaluationState::Waiting(EvaluationWaiting::Register { offset }) => {
+                let offset = Value::from_u64(value.value_type(), offset as u64)?;
+                let value = value.add(offset, self.addr_mask)?;
+                self.push(value)?;
+            }
+            _ => panic!(
+                "Called `Evaluation::resume_with_register` without a preceding `EvaluationResult::RequiresRegister`"
+            ),
+        };
+
+        self.evaluate_internal()
+    }
+
+    /// Resume the `Evaluation` with the provided `frame_base`.  This will
+    /// apply the provided frame base value to the evaluation and continue
+    /// evaluating opcodes until the evaluation is completed, reaches an error,
+    /// or needs more information again.
+    ///
+    /// # Panics
+    /// Panics if this `Evaluation` did not previously stop with `EvaluationResult::RequiresFrameBase`.
+    pub fn resume_with_frame_base(&mut self, frame_base: u64) -> Result<EvaluationResult<R>> {
+        match self.state {
+            EvaluationState::Error(err) => return Err(err),
+            EvaluationState::Waiting(EvaluationWaiting::FrameBase { offset }) => {
+                self.push(Value::Generic(frame_base.wrapping_add(offset as u64)))?;
+            }
+            _ => panic!(
+                "Called `Evaluation::resume_with_frame_base` without a preceding `EvaluationResult::RequiresFrameBase`"
+            ),
+        };
+
+        self.evaluate_internal()
+    }
+
+    /// Resume the `Evaluation` with the provided `value`.  This will apply
+    /// the provided TLS value to the evaluation and continue evaluating
+    /// opcodes until the evaluation is completed, reaches an error, or needs
+    /// more information again.
+    ///
+    /// # Panics
+    /// Panics if this `Evaluation` did not previously stop with `EvaluationResult::RequiresTls`.
+    pub fn resume_with_tls(&mut self, value: u64) -> Result<EvaluationResult<R>> {
+        match self.state {
+            EvaluationState::Error(err) => return Err(err),
+            EvaluationState::Waiting(EvaluationWaiting::Tls) => {
+                self.push(Value::Generic(value))?;
+            }
+            _ => panic!(
+                "Called `Evaluation::resume_with_tls` without a preceding `EvaluationResult::RequiresTls`"
+            ),
+        };
+
+        self.evaluate_internal()
+    }
+
+    /// Resume the `Evaluation` with the provided `cfa`.  This will
+    /// apply the provided CFA value to the evaluation and continue evaluating
+    /// opcodes until the evaluation is completed, reaches an error, or needs
+    /// more information again.
+    ///
+    /// # Panics
+    /// Panics if this `Evaluation` did not previously stop with `EvaluationResult::RequiresCallFrameCfa`.
+    pub fn resume_with_call_frame_cfa(&mut self, cfa: u64) -> Result<EvaluationResult<R>> {
+        match self.state {
+            EvaluationState::Error(err) => return Err(err),
+            EvaluationState::Waiting(EvaluationWaiting::Cfa) => {
+                self.push(Value::Generic(cfa))?;
+            }
+            _ => panic!(
+                "Called `Evaluation::resume_with_call_frame_cfa` without a preceding `EvaluationResult::RequiresCallFrameCfa`"
+            ),
+        };
+
+        self.evaluate_internal()
+    }
+
+    /// Resume the `Evaluation` with the provided `bytes`.  This will
+    /// continue processing the evaluation with the new expression provided
+    /// until the evaluation is completed, reaches an error, or needs more
+    /// information again.
+    ///
+    /// # Panics
+    /// Panics if this `Evaluation` did not previously stop with `EvaluationResult::RequiresAtLocation`.
+    pub fn resume_with_at_location(&mut self, mut bytes: R) -> Result<EvaluationResult<R>> {
+        match self.state {
+            EvaluationState::Error(err) => return Err(err),
+            EvaluationState::Waiting(EvaluationWaiting::AtLocation) => {
+                if !bytes.is_empty() {
+                    let mut pc = bytes.clone();
+                    mem::swap(&mut pc, &mut self.pc);
+                    mem::swap(&mut bytes, &mut self.bytecode);
+                    self.expression_stack.try_push((pc, bytes)).map_err(|_| Error::StackFull)?;
+                }
+            }
+            _ => panic!(
+                "Called `Evaluation::resume_with_at_location` without a precedeing `EvaluationResult::RequiresAtLocation`"
+            ),
+        };
+
+        self.evaluate_internal()
+    }
+
+    /// Resume the `Evaluation` with the provided `entry_value`.  This will
+    /// apply the provided entry value to the evaluation and continue evaluating
+    /// opcodes until the evaluation is completed, reaches an error, or needs
+    /// more information again.
+    ///
+    /// # Panics
+    /// Panics if this `Evaluation` did not previously stop with `EvaluationResult::RequiresEntryValue`.
+    pub fn resume_with_entry_value(&mut self, entry_value: Value) -> Result<EvaluationResult<R>> {
+        match self.state {
+            EvaluationState::Error(err) => return Err(err),
+            EvaluationState::Waiting(EvaluationWaiting::EntryValue) => {
+                self.push(entry_value)?;
+            }
+            _ => panic!(
+                "Called `Evaluation::resume_with_entry_value` without a preceding `EvaluationResult::RequiresEntryValue`"
+            ),
+        };
+
+        self.evaluate_internal()
+    }
+
+    /// Resume the `Evaluation` with the provided `parameter_value`.  This will
+    /// apply the provided parameter value to the evaluation and continue evaluating
+    /// opcodes until the evaluation is completed, reaches an error, or needs
+    /// more information again.
+    ///
+    /// # Panics
+    /// Panics if this `Evaluation` did not previously stop with `EvaluationResult::RequiresParameterRef`.
+    pub fn resume_with_parameter_ref(
+        &mut self,
+        parameter_value: u64,
+    ) -> Result<EvaluationResult<R>> {
+        match self.state {
+            EvaluationState::Error(err) => return Err(err),
+            EvaluationState::Waiting(EvaluationWaiting::ParameterRef) => {
+                self.push(Value::Generic(parameter_value))?;
+            }
+            _ => panic!(
+                "Called `Evaluation::resume_with_parameter_ref` without a preceding `EvaluationResult::RequiresParameterRef`"
+            ),
+        };
+
+        self.evaluate_internal()
+    }
+
+    /// Resume the `Evaluation` with the provided relocated `address`.  This will use the
+    /// provided relocated address for the operation that required it, and continue evaluating
+    /// opcodes until the evaluation is completed, reaches an error, or needs
+    /// more information again.
+    ///
+    /// # Panics
+    /// Panics if this `Evaluation` did not previously stop with
+    /// `EvaluationResult::RequiresRelocatedAddress`.
+    pub fn resume_with_relocated_address(&mut self, address: u64) -> Result<EvaluationResult<R>> {
+        match self.state {
+            EvaluationState::Error(err) => return Err(err),
+            EvaluationState::Waiting(EvaluationWaiting::RelocatedAddress) => {
+                self.push(Value::Generic(address))?;
+            }
+            _ => panic!(
+                "Called `Evaluation::resume_with_relocated_address` without a preceding `EvaluationResult::RequiresRelocatedAddress`"
+            ),
+        };
+
+        self.evaluate_internal()
+    }
+
+    /// Resume the `Evaluation` with the provided indexed `address`.  This will use the
+    /// provided indexed address for the operation that required it, and continue evaluating
+    /// opcodes until the evaluation is completed, reaches an error, or needs
+    /// more information again.
+    ///
+    /// # Panics
+    /// Panics if this `Evaluation` did not previously stop with
+    /// `EvaluationResult::RequiresIndexedAddress`.
+    pub fn resume_with_indexed_address(&mut self, address: u64) -> Result<EvaluationResult<R>> {
+        match self.state {
+            EvaluationState::Error(err) => return Err(err),
+            EvaluationState::Waiting(EvaluationWaiting::IndexedAddress) => {
+                self.push(Value::Generic(address))?;
+            }
+            _ => panic!(
+                "Called `Evaluation::resume_with_indexed_address` without a preceding `EvaluationResult::RequiresIndexedAddress`"
+            ),
+        };
+
+        self.evaluate_internal()
+    }
+
+    /// Resume the `Evaluation` with the provided `base_type`.  This will use the
+    /// provided base type for the operation that required it, and continue evaluating
+    /// opcodes until the evaluation is completed, reaches an error, or needs
+    /// more information again.
+    ///
+    /// # Panics
+    /// Panics if this `Evaluation` did not previously stop with `EvaluationResult::RequiresBaseType`.
+    pub fn resume_with_base_type(&mut self, base_type: ValueType) -> Result<EvaluationResult<R>> {
+        let value = match self.state {
+            EvaluationState::Error(err) => return Err(err),
+            EvaluationState::Waiting(EvaluationWaiting::TypedLiteral { ref value }) => {
+                Value::parse(base_type, value.clone())?
+            }
+            EvaluationState::Waiting(EvaluationWaiting::Convert) => {
+                let entry = self.pop()?;
+                entry.convert(base_type, self.addr_mask)?
+            }
+            EvaluationState::Waiting(EvaluationWaiting::Reinterpret) => {
+                let entry = self.pop()?;
+                entry.reinterpret(base_type, self.addr_mask)?
+            }
+            _ => panic!(
+                "Called `Evaluation::resume_with_base_type` without a preceding `EvaluationResult::RequiresBaseType`"
+            ),
+        };
+        self.push(value)?;
+        self.evaluate_internal()
+    }
+
+    fn end_of_expression(&mut self) -> bool {
+        while self.pc.is_empty() {
+            match self.expression_stack.pop() {
+                Some((newpc, newbytes)) => {
+                    self.pc = newpc;
+                    self.bytecode = newbytes;
+                }
+                None => return true,
+            }
+        }
+        false
+    }
+
+    fn evaluate_internal(&mut self) -> Result<EvaluationResult<R>> {
+        while !self.end_of_expression() {
+            self.iteration += 1;
+            if let Some(max_iterations) = self.max_iterations {
+                if self.iteration > max_iterations {
+                    return Err(Error::TooManyIterations);
+                }
+            }
+
+            let op_result = self.evaluate_one_operation()?;
+            match op_result {
+                OperationEvaluationResult::Piece => {}
+                OperationEvaluationResult::Incomplete => {
+                    if self.end_of_expression() && !self.result.is_empty() {
+                        // We saw a piece earlier and then some
+                        // unterminated piece.  It's not clear this is
+                        // well-defined.
+                        return Err(Error::InvalidPiece);
+                    }
+                }
+                OperationEvaluationResult::Complete { location } => {
+                    if self.end_of_expression() {
+                        if !self.result.is_empty() {
+                            // We saw a piece earlier and then some
+                            // unterminated piece.  It's not clear this is
+                            // well-defined.
+                            return Err(Error::InvalidPiece);
+                        }
+                        self.result
+                            .try_push(Piece {
+                                size_in_bits: None,
+                                bit_offset: None,
+                                location,
+                            })
+                            .map_err(|_| Error::StackFull)?;
+                    } else {
+                        // If there are more operations, then the next operation must
+                        // be a Piece.
+                        match Operation::parse(&mut self.pc, self.encoding)? {
+                            Operation::Piece {
+                                size_in_bits,
+                                bit_offset,
+                            } => {
+                                self.result
+                                    .try_push(Piece {
+                                        size_in_bits: Some(size_in_bits),
+                                        bit_offset,
+                                        location,
+                                    })
+                                    .map_err(|_| Error::StackFull)?;
+                            }
+                            _ => {
+                                let value =
+                                    self.bytecode.len().into_u64() - self.pc.len().into_u64() - 1;
+                                return Err(Error::InvalidExpressionTerminator(value));
+                            }
+                        }
+                    }
+                }
+                OperationEvaluationResult::Waiting(waiting, result) => {
+                    self.state = EvaluationState::Waiting(waiting);
+                    return Ok(result);
+                }
+            }
+        }
+
+        // If no pieces have been seen, use the stack top as the
+        // result.
+        if self.result.is_empty() {
+            let entry = self.pop()?;
+            self.value_result = Some(entry);
+            let addr = entry.to_u64(self.addr_mask)?;
+            self.result
+                .try_push(Piece {
+                    size_in_bits: None,
+                    bit_offset: None,
+                    location: Location::Address { address: addr },
+                })
+                .map_err(|_| Error::StackFull)?;
+        }
+
+        self.state = EvaluationState::Complete;
+        Ok(EvaluationResult::Complete)
+    }
+}
+
+#[cfg(test)]
+// Tests require leb128::write.
+#[cfg(feature = "write")]
+mod tests {
+    use super::*;
+    use crate::common::Format;
+    use crate::constants;
+    use crate::endianity::LittleEndian;
+    use crate::leb128;
+    use crate::read::{EndianSlice, Error, Result, UnitOffset};
+    use crate::test_util::GimliSectionMethods;
+    use core::usize;
+    use test_assembler::{Endian, Section};
+
+    fn encoding4() -> Encoding {
+        Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 4,
+        }
+    }
+
+    fn encoding8() -> Encoding {
+        Encoding {
+            format: Format::Dwarf64,
+            version: 4,
+            address_size: 8,
+        }
+    }
+
+    #[test]
+    fn test_compute_pc() {
+        // Contents don't matter for this test, just length.
+        let bytes = [0, 1, 2, 3, 4];
+        let bytecode = &bytes[..];
+        let ebuf = &EndianSlice::new(bytecode, LittleEndian);
+
+        assert_eq!(compute_pc(ebuf, ebuf, 0), Ok(*ebuf));
+        assert_eq!(
+            compute_pc(ebuf, ebuf, -1),
+            Err(Error::BadBranchTarget(usize::MAX as u64))
+        );
+        assert_eq!(compute_pc(ebuf, ebuf, 5), Ok(ebuf.range_from(5..)));
+        assert_eq!(
+            compute_pc(&ebuf.range_from(3..), ebuf, -2),
+            Ok(ebuf.range_from(1..))
+        );
+        assert_eq!(
+            compute_pc(&ebuf.range_from(2..), ebuf, 2),
+            Ok(ebuf.range_from(4..))
+        );
+    }
+
+    fn check_op_parse_simple<'input>(
+        input: &'input [u8],
+        expect: &Operation<EndianSlice<'input, LittleEndian>>,
+        encoding: Encoding,
+    ) {
+        let buf = EndianSlice::new(input, LittleEndian);
+        let mut pc = buf;
+        let value = Operation::parse(&mut pc, encoding);
+        match value {
+            Ok(val) => {
+                assert_eq!(val, *expect);
+                assert_eq!(pc.len(), 0);
+            }
+            _ => panic!("Unexpected result"),
+        }
+    }
+
+    fn check_op_parse_eof(input: &[u8], encoding: Encoding) {
+        let buf = EndianSlice::new(input, LittleEndian);
+        let mut pc = buf;
+        match Operation::parse(&mut pc, encoding) {
+            Err(Error::UnexpectedEof(id)) => {
+                assert!(buf.lookup_offset_id(id).is_some());
+            }
+
+            _ => panic!("Unexpected result"),
+        }
+    }
+
+    fn check_op_parse<F>(
+        input: F,
+        expect: &Operation<EndianSlice<LittleEndian>>,
+        encoding: Encoding,
+    ) where
+        F: Fn(Section) -> Section,
+    {
+        let input = input(Section::with_endian(Endian::Little))
+            .get_contents()
+            .unwrap();
+        for i in 1..input.len() {
+            check_op_parse_eof(&input[..i], encoding);
+        }
+        check_op_parse_simple(&input, expect, encoding);
+    }
+
+    #[test]
+    fn test_op_parse_onebyte() {
+        // Doesn't matter for this test.
+        let encoding = encoding4();
+
+        // Test all single-byte opcodes.
+        #[rustfmt::skip]
+        let inputs = [
+            (
+                constants::DW_OP_deref,
+                Operation::Deref {
+                    base_type: generic_type(),
+                    size: encoding.address_size,
+                    space: false,
+                },
+            ),
+            (constants::DW_OP_dup, Operation::Pick { index: 0 }),
+            (constants::DW_OP_drop, Operation::Drop),
+            (constants::DW_OP_over, Operation::Pick { index: 1 }),
+            (constants::DW_OP_swap, Operation::Swap),
+            (constants::DW_OP_rot, Operation::Rot),
+            (
+                constants::DW_OP_xderef,
+                Operation::Deref {
+                    base_type: generic_type(),
+                    size: encoding.address_size,
+                    space: true,
+                },
+            ),
+            (constants::DW_OP_abs, Operation::Abs),
+            (constants::DW_OP_and, Operation::And),
+            (constants::DW_OP_div, Operation::Div),
+            (constants::DW_OP_minus, Operation::Minus),
+            (constants::DW_OP_mod, Operation::Mod),
+            (constants::DW_OP_mul, Operation::Mul),
+            (constants::DW_OP_neg, Operation::Neg),
+            (constants::DW_OP_not, Operation::Not),
+            (constants::DW_OP_or, Operation::Or),
+            (constants::DW_OP_plus, Operation::Plus),
+            (constants::DW_OP_shl, Operation::Shl),
+            (constants::DW_OP_shr, Operation::Shr),
+            (constants::DW_OP_shra, Operation::Shra),
+            (constants::DW_OP_xor, Operation::Xor),
+            (constants::DW_OP_eq, Operation::Eq),
+            (constants::DW_OP_ge, Operation::Ge),
+            (constants::DW_OP_gt, Operation::Gt),
+            (constants::DW_OP_le, Operation::Le),
+            (constants::DW_OP_lt, Operation::Lt),
+            (constants::DW_OP_ne, Operation::Ne),
+            (constants::DW_OP_lit0, Operation::UnsignedConstant { value: 0 }),
+            (constants::DW_OP_lit1, Operation::UnsignedConstant { value: 1 }),
+            (constants::DW_OP_lit2, Operation::UnsignedConstant { value: 2 }),
+            (constants::DW_OP_lit3, Operation::UnsignedConstant { value: 3 }),
+            (constants::DW_OP_lit4, Operation::UnsignedConstant { value: 4 }),
+            (constants::DW_OP_lit5, Operation::UnsignedConstant { value: 5 }),
+            (constants::DW_OP_lit6, Operation::UnsignedConstant { value: 6 }),
+            (constants::DW_OP_lit7, Operation::UnsignedConstant { value: 7 }),
+            (constants::DW_OP_lit8, Operation::UnsignedConstant { value: 8 }),
+            (constants::DW_OP_lit9, Operation::UnsignedConstant { value: 9 }),
+            (constants::DW_OP_lit10, Operation::UnsignedConstant { value: 10 }),
+            (constants::DW_OP_lit11, Operation::UnsignedConstant { value: 11 }),
+            (constants::DW_OP_lit12, Operation::UnsignedConstant { value: 12 }),
+            (constants::DW_OP_lit13, Operation::UnsignedConstant { value: 13 }),
+            (constants::DW_OP_lit14, Operation::UnsignedConstant { value: 14 }),
+            (constants::DW_OP_lit15, Operation::UnsignedConstant { value: 15 }),
+            (constants::DW_OP_lit16, Operation::UnsignedConstant { value: 16 }),
+            (constants::DW_OP_lit17, Operation::UnsignedConstant { value: 17 }),
+            (constants::DW_OP_lit18, Operation::UnsignedConstant { value: 18 }),
+            (constants::DW_OP_lit19, Operation::UnsignedConstant { value: 19 }),
+            (constants::DW_OP_lit20, Operation::UnsignedConstant { value: 20 }),
+            (constants::DW_OP_lit21, Operation::UnsignedConstant { value: 21 }),
+            (constants::DW_OP_lit22, Operation::UnsignedConstant { value: 22 }),
+            (constants::DW_OP_lit23, Operation::UnsignedConstant { value: 23 }),
+            (constants::DW_OP_lit24, Operation::UnsignedConstant { value: 24 }),
+            (constants::DW_OP_lit25, Operation::UnsignedConstant { value: 25 }),
+            (constants::DW_OP_lit26, Operation::UnsignedConstant { value: 26 }),
+            (constants::DW_OP_lit27, Operation::UnsignedConstant { value: 27 }),
+            (constants::DW_OP_lit28, Operation::UnsignedConstant { value: 28 }),
+            (constants::DW_OP_lit29, Operation::UnsignedConstant { value: 29 }),
+            (constants::DW_OP_lit30, Operation::UnsignedConstant { value: 30 }),
+            (constants::DW_OP_lit31, Operation::UnsignedConstant { value: 31 }),
+            (constants::DW_OP_reg0, Operation::Register { register: Register(0) }),
+            (constants::DW_OP_reg1, Operation::Register { register: Register(1) }),
+            (constants::DW_OP_reg2, Operation::Register { register: Register(2) }),
+            (constants::DW_OP_reg3, Operation::Register { register: Register(3) }),
+            (constants::DW_OP_reg4, Operation::Register { register: Register(4) }),
+            (constants::DW_OP_reg5, Operation::Register { register: Register(5) }),
+            (constants::DW_OP_reg6, Operation::Register { register: Register(6) }),
+            (constants::DW_OP_reg7, Operation::Register { register: Register(7) }),
+            (constants::DW_OP_reg8, Operation::Register { register: Register(8) }),
+            (constants::DW_OP_reg9, Operation::Register { register: Register(9) }),
+            (constants::DW_OP_reg10, Operation::Register { register: Register(10) }),
+            (constants::DW_OP_reg11, Operation::Register { register: Register(11) }),
+            (constants::DW_OP_reg12, Operation::Register { register: Register(12) }),
+            (constants::DW_OP_reg13, Operation::Register { register: Register(13) }),
+            (constants::DW_OP_reg14, Operation::Register { register: Register(14) }),
+            (constants::DW_OP_reg15, Operation::Register { register: Register(15) }),
+            (constants::DW_OP_reg16, Operation::Register { register: Register(16) }),
+            (constants::DW_OP_reg17, Operation::Register { register: Register(17) }),
+            (constants::DW_OP_reg18, Operation::Register { register: Register(18) }),
+            (constants::DW_OP_reg19, Operation::Register { register: Register(19) }),
+            (constants::DW_OP_reg20, Operation::Register { register: Register(20) }),
+            (constants::DW_OP_reg21, Operation::Register { register: Register(21) }),
+            (constants::DW_OP_reg22, Operation::Register { register: Register(22) }),
+            (constants::DW_OP_reg23, Operation::Register { register: Register(23) }),
+            (constants::DW_OP_reg24, Operation::Register { register: Register(24) }),
+            (constants::DW_OP_reg25, Operation::Register { register: Register(25) }),
+            (constants::DW_OP_reg26, Operation::Register { register: Register(26) }),
+            (constants::DW_OP_reg27, Operation::Register { register: Register(27) }),
+            (constants::DW_OP_reg28, Operation::Register { register: Register(28) }),
+            (constants::DW_OP_reg29, Operation::Register { register: Register(29) }),
+            (constants::DW_OP_reg30, Operation::Register { register: Register(30) }),
+            (constants::DW_OP_reg31, Operation::Register { register: Register(31) }),
+            (constants::DW_OP_nop, Operation::Nop),
+            (constants::DW_OP_push_object_address, Operation::PushObjectAddress),
+            (constants::DW_OP_form_tls_address, Operation::TLS),
+            (constants::DW_OP_GNU_push_tls_address, Operation::TLS),
+            (constants::DW_OP_call_frame_cfa, Operation::CallFrameCFA),
+            (constants::DW_OP_stack_value, Operation::StackValue),
+        ];
+
+        let input = [];
+        check_op_parse_eof(&input[..], encoding);
+
+        for item in inputs.iter() {
+            let (opcode, ref result) = *item;
+            check_op_parse(|s| s.D8(opcode.0), result, encoding);
+        }
+    }
+
+    #[test]
+    fn test_op_parse_twobyte() {
+        // Doesn't matter for this test.
+        let encoding = encoding4();
+
+        let inputs = [
+            (
+                constants::DW_OP_const1u,
+                23,
+                Operation::UnsignedConstant { value: 23 },
+            ),
+            (
+                constants::DW_OP_const1s,
+                (-23i8) as u8,
+                Operation::SignedConstant { value: -23 },
+            ),
+            (constants::DW_OP_pick, 7, Operation::Pick { index: 7 }),
+            (
+                constants::DW_OP_deref_size,
+                19,
+                Operation::Deref {
+                    base_type: generic_type(),
+                    size: 19,
+                    space: false,
+                },
+            ),
+            (
+                constants::DW_OP_xderef_size,
+                19,
+                Operation::Deref {
+                    base_type: generic_type(),
+                    size: 19,
+                    space: true,
+                },
+            ),
+        ];
+
+        for item in inputs.iter() {
+            let (opcode, arg, ref result) = *item;
+            check_op_parse(|s| s.D8(opcode.0).D8(arg), result, encoding);
+        }
+    }
+
+    #[test]
+    fn test_op_parse_threebyte() {
+        // Doesn't matter for this test.
+        let encoding = encoding4();
+
+        // While bra and skip are 3-byte opcodes, they aren't tested here,
+        // but rather specially in their own function.
+        let inputs = [
+            (
+                constants::DW_OP_const2u,
+                23,
+                Operation::UnsignedConstant { value: 23 },
+            ),
+            (
+                constants::DW_OP_const2s,
+                (-23i16) as u16,
+                Operation::SignedConstant { value: -23 },
+            ),
+            (
+                constants::DW_OP_call2,
+                1138,
+                Operation::Call {
+                    offset: DieReference::UnitRef(UnitOffset(1138)),
+                },
+            ),
+            (
+                constants::DW_OP_bra,
+                (-23i16) as u16,
+                Operation::Bra { target: -23 },
+            ),
+            (
+                constants::DW_OP_skip,
+                (-23i16) as u16,
+                Operation::Skip { target: -23 },
+            ),
+        ];
+
+        for item in inputs.iter() {
+            let (opcode, arg, ref result) = *item;
+            check_op_parse(|s| s.D8(opcode.0).L16(arg), result, encoding);
+        }
+    }
+
+    #[test]
+    fn test_op_parse_fivebyte() {
+        // There are some tests here that depend on address size.
+        let encoding = encoding4();
+
+        let inputs = [
+            (
+                constants::DW_OP_addr,
+                0x1234_5678,
+                Operation::Address {
+                    address: 0x1234_5678,
+                },
+            ),
+            (
+                constants::DW_OP_const4u,
+                0x1234_5678,
+                Operation::UnsignedConstant { value: 0x1234_5678 },
+            ),
+            (
+                constants::DW_OP_const4s,
+                (-23i32) as u32,
+                Operation::SignedConstant { value: -23 },
+            ),
+            (
+                constants::DW_OP_call4,
+                0x1234_5678,
+                Operation::Call {
+                    offset: DieReference::UnitRef(UnitOffset(0x1234_5678)),
+                },
+            ),
+            (
+                constants::DW_OP_call_ref,
+                0x1234_5678,
+                Operation::Call {
+                    offset: DieReference::DebugInfoRef(DebugInfoOffset(0x1234_5678)),
+                },
+            ),
+        ];
+
+        for item in inputs.iter() {
+            let (op, arg, ref expect) = *item;
+            check_op_parse(|s| s.D8(op.0).L32(arg), expect, encoding);
+        }
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_op_parse_ninebyte() {
+        // There are some tests here that depend on address size.
+        let encoding = encoding8();
+
+        let inputs = [
+            (
+                constants::DW_OP_addr,
+                0x1234_5678_1234_5678,
+                Operation::Address {
+                    address: 0x1234_5678_1234_5678,
+                },
+            ),
+            (
+                constants::DW_OP_const8u,
+                0x1234_5678_1234_5678,
+                Operation::UnsignedConstant {
+                    value: 0x1234_5678_1234_5678,
+                },
+            ),
+            (
+                constants::DW_OP_const8s,
+                (-23i64) as u64,
+                Operation::SignedConstant { value: -23 },
+            ),
+            (
+                constants::DW_OP_call_ref,
+                0x1234_5678_1234_5678,
+                Operation::Call {
+                    offset: DieReference::DebugInfoRef(DebugInfoOffset(0x1234_5678_1234_5678)),
+                },
+            ),
+        ];
+
+        for item in inputs.iter() {
+            let (op, arg, ref expect) = *item;
+            check_op_parse(|s| s.D8(op.0).L64(arg), expect, encoding);
+        }
+    }
+
+    #[test]
+    fn test_op_parse_sleb() {
+        // Doesn't matter for this test.
+        let encoding = encoding4();
+
+        let values = [
+            -1i64,
+            0,
+            1,
+            0x100,
+            0x1eee_eeee,
+            0x7fff_ffff_ffff_ffff,
+            -0x100,
+            -0x1eee_eeee,
+            -0x7fff_ffff_ffff_ffff,
+        ];
+        for value in values.iter() {
+            let mut inputs = vec![
+                (
+                    constants::DW_OP_consts.0,
+                    Operation::SignedConstant { value: *value },
+                ),
+                (
+                    constants::DW_OP_fbreg.0,
+                    Operation::FrameOffset { offset: *value },
+                ),
+            ];
+
+            for i in 0..32 {
+                inputs.push((
+                    constants::DW_OP_breg0.0 + i,
+                    Operation::RegisterOffset {
+                        register: Register(i.into()),
+                        offset: *value,
+                        base_type: UnitOffset(0),
+                    },
+                ));
+            }
+
+            for item in inputs.iter() {
+                let (op, ref expect) = *item;
+                check_op_parse(|s| s.D8(op).sleb(*value), expect, encoding);
+            }
+        }
+    }
+
+    #[test]
+    fn test_op_parse_uleb() {
+        // Doesn't matter for this test.
+        let encoding = encoding4();
+
+        let values = [
+            0,
+            1,
+            0x100,
+            (!0u16).into(),
+            0x1eee_eeee,
+            0x7fff_ffff_ffff_ffff,
+            !0u64,
+        ];
+        for value in values.iter() {
+            let mut inputs = vec![
+                (
+                    constants::DW_OP_constu,
+                    Operation::UnsignedConstant { value: *value },
+                ),
+                (
+                    constants::DW_OP_plus_uconst,
+                    Operation::PlusConstant { value: *value },
+                ),
+            ];
+
+            if *value <= (!0u16).into() {
+                inputs.push((
+                    constants::DW_OP_regx,
+                    Operation::Register {
+                        register: Register::from_u64(*value).unwrap(),
+                    },
+                ));
+            }
+
+            if *value <= (!0u32).into() {
+                inputs.extend(&[
+                    (
+                        constants::DW_OP_addrx,
+                        Operation::AddressIndex {
+                            index: DebugAddrIndex(*value as usize),
+                        },
+                    ),
+                    (
+                        constants::DW_OP_constx,
+                        Operation::ConstantIndex {
+                            index: DebugAddrIndex(*value as usize),
+                        },
+                    ),
+                ]);
+            }
+
+            // FIXME
+            if *value < !0u64 / 8 {
+                inputs.push((
+                    constants::DW_OP_piece,
+                    Operation::Piece {
+                        size_in_bits: 8 * value,
+                        bit_offset: None,
+                    },
+                ));
+            }
+
+            for item in inputs.iter() {
+                let (op, ref expect) = *item;
+                let input = Section::with_endian(Endian::Little)
+                    .D8(op.0)
+                    .uleb(*value)
+                    .get_contents()
+                    .unwrap();
+                check_op_parse_simple(&input, expect, encoding);
+            }
+        }
+    }
+
+    #[test]
+    fn test_op_parse_bregx() {
+        // Doesn't matter for this test.
+        let encoding = encoding4();
+
+        let uvalues = [0, 1, 0x100, !0u16];
+        let svalues = [
+            -1i64,
+            0,
+            1,
+            0x100,
+            0x1eee_eeee,
+            0x7fff_ffff_ffff_ffff,
+            -0x100,
+            -0x1eee_eeee,
+            -0x7fff_ffff_ffff_ffff,
+        ];
+
+        for v1 in uvalues.iter() {
+            for v2 in svalues.iter() {
+                check_op_parse(
+                    |s| s.D8(constants::DW_OP_bregx.0).uleb((*v1).into()).sleb(*v2),
+                    &Operation::RegisterOffset {
+                        register: Register(*v1),
+                        offset: *v2,
+                        base_type: UnitOffset(0),
+                    },
+                    encoding,
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn test_op_parse_bit_piece() {
+        // Doesn't matter for this test.
+        let encoding = encoding4();
+
+        let values = [0, 1, 0x100, 0x1eee_eeee, 0x7fff_ffff_ffff_ffff, !0u64];
+
+        for v1 in values.iter() {
+            for v2 in values.iter() {
+                let input = Section::with_endian(Endian::Little)
+                    .D8(constants::DW_OP_bit_piece.0)
+                    .uleb(*v1)
+                    .uleb(*v2)
+                    .get_contents()
+                    .unwrap();
+                check_op_parse_simple(
+                    &input,
+                    &Operation::Piece {
+                        size_in_bits: *v1,
+                        bit_offset: Some(*v2),
+                    },
+                    encoding,
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn test_op_parse_implicit_value() {
+        // Doesn't matter for this test.
+        let encoding = encoding4();
+
+        let data = b"hello";
+
+        check_op_parse(
+            |s| {
+                s.D8(constants::DW_OP_implicit_value.0)
+                    .uleb(data.len() as u64)
+                    .append_bytes(&data[..])
+            },
+            &Operation::ImplicitValue {
+                data: EndianSlice::new(&data[..], LittleEndian),
+            },
+            encoding,
+        );
+    }
+
+    #[test]
+    fn test_op_parse_const_type() {
+        // Doesn't matter for this test.
+        let encoding = encoding4();
+
+        let data = b"hello";
+
+        check_op_parse(
+            |s| {
+                s.D8(constants::DW_OP_const_type.0)
+                    .uleb(100)
+                    .D8(data.len() as u8)
+                    .append_bytes(&data[..])
+            },
+            &Operation::TypedLiteral {
+                base_type: UnitOffset(100),
+                value: EndianSlice::new(&data[..], LittleEndian),
+            },
+            encoding,
+        );
+        check_op_parse(
+            |s| {
+                s.D8(constants::DW_OP_GNU_const_type.0)
+                    .uleb(100)
+                    .D8(data.len() as u8)
+                    .append_bytes(&data[..])
+            },
+            &Operation::TypedLiteral {
+                base_type: UnitOffset(100),
+                value: EndianSlice::new(&data[..], LittleEndian),
+            },
+            encoding,
+        );
+    }
+
+    #[test]
+    fn test_op_parse_regval_type() {
+        // Doesn't matter for this test.
+        let encoding = encoding4();
+
+        check_op_parse(
+            |s| s.D8(constants::DW_OP_regval_type.0).uleb(1).uleb(100),
+            &Operation::RegisterOffset {
+                register: Register(1),
+                offset: 0,
+                base_type: UnitOffset(100),
+            },
+            encoding,
+        );
+        check_op_parse(
+            |s| s.D8(constants::DW_OP_GNU_regval_type.0).uleb(1).uleb(100),
+            &Operation::RegisterOffset {
+                register: Register(1),
+                offset: 0,
+                base_type: UnitOffset(100),
+            },
+            encoding,
+        );
+    }
+
+    #[test]
+    fn test_op_parse_deref_type() {
+        // Doesn't matter for this test.
+        let encoding = encoding4();
+
+        check_op_parse(
+            |s| s.D8(constants::DW_OP_deref_type.0).D8(8).uleb(100),
+            &Operation::Deref {
+                base_type: UnitOffset(100),
+                size: 8,
+                space: false,
+            },
+            encoding,
+        );
+        check_op_parse(
+            |s| s.D8(constants::DW_OP_GNU_deref_type.0).D8(8).uleb(100),
+            &Operation::Deref {
+                base_type: UnitOffset(100),
+                size: 8,
+                space: false,
+            },
+            encoding,
+        );
+        check_op_parse(
+            |s| s.D8(constants::DW_OP_xderef_type.0).D8(8).uleb(100),
+            &Operation::Deref {
+                base_type: UnitOffset(100),
+                size: 8,
+                space: true,
+            },
+            encoding,
+        );
+    }
+
+    #[test]
+    fn test_op_convert() {
+        // Doesn't matter for this test.
+        let encoding = encoding4();
+
+        check_op_parse(
+            |s| s.D8(constants::DW_OP_convert.0).uleb(100),
+            &Operation::Convert {
+                base_type: UnitOffset(100),
+            },
+            encoding,
+        );
+        check_op_parse(
+            |s| s.D8(constants::DW_OP_GNU_convert.0).uleb(100),
+            &Operation::Convert {
+                base_type: UnitOffset(100),
+            },
+            encoding,
+        );
+    }
+
+    #[test]
+    fn test_op_reinterpret() {
+        // Doesn't matter for this test.
+        let encoding = encoding4();
+
+        check_op_parse(
+            |s| s.D8(constants::DW_OP_reinterpret.0).uleb(100),
+            &Operation::Reinterpret {
+                base_type: UnitOffset(100),
+            },
+            encoding,
+        );
+        check_op_parse(
+            |s| s.D8(constants::DW_OP_GNU_reinterpret.0).uleb(100),
+            &Operation::Reinterpret {
+                base_type: UnitOffset(100),
+            },
+            encoding,
+        );
+    }
+
+    #[test]
+    fn test_op_parse_implicit_pointer() {
+        for op in &[
+            constants::DW_OP_implicit_pointer,
+            constants::DW_OP_GNU_implicit_pointer,
+        ] {
+            check_op_parse(
+                |s| s.D8(op.0).D32(0x1234_5678).sleb(0x123),
+                &Operation::ImplicitPointer {
+                    value: DebugInfoOffset(0x1234_5678),
+                    byte_offset: 0x123,
+                },
+                encoding4(),
+            );
+
+            check_op_parse(
+                |s| s.D8(op.0).D64(0x1234_5678).sleb(0x123),
+                &Operation::ImplicitPointer {
+                    value: DebugInfoOffset(0x1234_5678),
+                    byte_offset: 0x123,
+                },
+                encoding8(),
+            );
+
+            check_op_parse(
+                |s| s.D8(op.0).D64(0x1234_5678).sleb(0x123),
+                &Operation::ImplicitPointer {
+                    value: DebugInfoOffset(0x1234_5678),
+                    byte_offset: 0x123,
+                },
+                Encoding {
+                    format: Format::Dwarf32,
+                    version: 2,
+                    address_size: 8,
+                },
+            )
+        }
+    }
+
+    #[test]
+    fn test_op_parse_entry_value() {
+        for op in &[
+            constants::DW_OP_entry_value,
+            constants::DW_OP_GNU_entry_value,
+        ] {
+            let data = b"hello";
+            check_op_parse(
+                |s| s.D8(op.0).uleb(data.len() as u64).append_bytes(&data[..]),
+                &Operation::EntryValue {
+                    expression: EndianSlice::new(&data[..], LittleEndian),
+                },
+                encoding4(),
+            );
+        }
+    }
+
+    #[test]
+    fn test_op_parse_gnu_parameter_ref() {
+        check_op_parse(
+            |s| s.D8(constants::DW_OP_GNU_parameter_ref.0).D32(0x1234_5678),
+            &Operation::ParameterRef {
+                offset: UnitOffset(0x1234_5678),
+            },
+            encoding4(),
+        )
+    }
+
+    #[test]
+    fn test_op_wasm() {
+        // Doesn't matter for this test.
+        let encoding = encoding4();
+
+        check_op_parse(
+            |s| s.D8(constants::DW_OP_WASM_location.0).D8(0).uleb(1000),
+            &Operation::WasmLocal { index: 1000 },
+            encoding,
+        );
+        check_op_parse(
+            |s| s.D8(constants::DW_OP_WASM_location.0).D8(1).uleb(1000),
+            &Operation::WasmGlobal { index: 1000 },
+            encoding,
+        );
+        check_op_parse(
+            |s| s.D8(constants::DW_OP_WASM_location.0).D8(2).uleb(1000),
+            &Operation::WasmStack { index: 1000 },
+            encoding,
+        );
+        check_op_parse(
+            |s| s.D8(constants::DW_OP_WASM_location.0).D8(3).D32(1000),
+            &Operation::WasmGlobal { index: 1000 },
+            encoding,
+        );
+    }
+
+    enum AssemblerEntry {
+        Op(constants::DwOp),
+        Mark(u8),
+        Branch(u8),
+        U8(u8),
+        U16(u16),
+        U32(u32),
+        U64(u64),
+        Uleb(u64),
+        Sleb(u64),
+    }
+
+    fn assemble(entries: &[AssemblerEntry]) -> Vec<u8> {
+        let mut result = Vec::new();
+
+        struct Marker(Option<usize>, Vec<usize>);
+
+        let mut markers = Vec::new();
+        for _ in 0..256 {
+            markers.push(Marker(None, Vec::new()));
+        }
+
+        fn write(stack: &mut Vec<u8>, index: usize, mut num: u64, nbytes: u8) {
+            for i in 0..nbytes as usize {
+                stack[index + i] = (num & 0xff) as u8;
+                num >>= 8;
+            }
+        }
+
+        fn push(stack: &mut Vec<u8>, num: u64, nbytes: u8) {
+            let index = stack.len();
+            for _ in 0..nbytes {
+                stack.push(0);
+            }
+            write(stack, index, num, nbytes);
+        }
+
+        for item in entries {
+            match *item {
+                AssemblerEntry::Op(op) => result.push(op.0),
+                AssemblerEntry::Mark(num) => {
+                    assert!(markers[num as usize].0.is_none());
+                    markers[num as usize].0 = Some(result.len());
+                }
+                AssemblerEntry::Branch(num) => {
+                    markers[num as usize].1.push(result.len());
+                    push(&mut result, 0, 2);
+                }
+                AssemblerEntry::U8(num) => result.push(num),
+                AssemblerEntry::U16(num) => push(&mut result, u64::from(num), 2),
+                AssemblerEntry::U32(num) => push(&mut result, u64::from(num), 4),
+                AssemblerEntry::U64(num) => push(&mut result, num, 8),
+                AssemblerEntry::Uleb(num) => {
+                    leb128::write::unsigned(&mut result, num).unwrap();
+                }
+                AssemblerEntry::Sleb(num) => {
+                    leb128::write::signed(&mut result, num as i64).unwrap();
+                }
+            }
+        }
+
+        // Update all the branches.
+        for marker in markers {
+            if let Some(offset) = marker.0 {
+                for branch_offset in marker.1 {
+                    let delta = offset.wrapping_sub(branch_offset + 2) as u64;
+                    write(&mut result, branch_offset, delta, 2);
+                }
+            }
+        }
+
+        result
+    }
+
+    fn check_eval_with_args<F>(
+        program: &[AssemblerEntry],
+        expect: Result<&[Piece<EndianSlice<LittleEndian>>]>,
+        encoding: Encoding,
+        object_address: Option<u64>,
+        initial_value: Option<u64>,
+        max_iterations: Option<u32>,
+        f: F,
+    ) where
+        for<'a> F: Fn(
+            &mut Evaluation<EndianSlice<'a, LittleEndian>>,
+            EvaluationResult<EndianSlice<'a, LittleEndian>>,
+        ) -> Result<EvaluationResult<EndianSlice<'a, LittleEndian>>>,
+    {
+        let bytes = assemble(program);
+        let bytes = EndianSlice::new(&bytes, LittleEndian);
+
+        let mut eval = Evaluation::new(bytes, encoding);
+
+        if let Some(val) = object_address {
+            eval.set_object_address(val);
+        }
+        if let Some(val) = initial_value {
+            eval.set_initial_value(val);
+        }
+        if let Some(val) = max_iterations {
+            eval.set_max_iterations(val);
+        }
+
+        let result = match eval.evaluate() {
+            Err(e) => Err(e),
+            Ok(r) => f(&mut eval, r),
+        };
+
+        match (result, expect) {
+            (Ok(EvaluationResult::Complete), Ok(pieces)) => {
+                let vec = eval.result();
+                assert_eq!(vec.len(), pieces.len());
+                for i in 0..pieces.len() {
+                    assert_eq!(vec[i], pieces[i]);
+                }
+            }
+            (Err(f1), Err(f2)) => {
+                assert_eq!(f1, f2);
+            }
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        }
+    }
+
+    fn check_eval(
+        program: &[AssemblerEntry],
+        expect: Result<&[Piece<EndianSlice<LittleEndian>>]>,
+        encoding: Encoding,
+    ) {
+        check_eval_with_args(program, expect, encoding, None, None, None, |_, result| {
+            Ok(result)
+        });
+    }
+
+    #[test]
+    fn test_eval_arith() {
+        // It's nice if an operation and its arguments can fit on a single
+        // line in the test program.
+        use self::AssemblerEntry::*;
+        use crate::constants::*;
+
+        // Indices of marks in the assembly.
+        let done = 0;
+        let fail = 1;
+
+        #[rustfmt::skip]
+        let program = [
+            Op(DW_OP_const1u), U8(23),
+            Op(DW_OP_const1s), U8((-23i8) as u8),
+            Op(DW_OP_plus),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const2u), U16(23),
+            Op(DW_OP_const2s), U16((-23i16) as u16),
+            Op(DW_OP_plus),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const4u), U32(0x1111_2222),
+            Op(DW_OP_const4s), U32((-0x1111_2222i32) as u32),
+            Op(DW_OP_plus),
+            Op(DW_OP_bra), Branch(fail),
+
+            // Plus should overflow.
+            Op(DW_OP_const1s), U8(0xff),
+            Op(DW_OP_const1u), U8(1),
+            Op(DW_OP_plus),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const1s), U8(0xff),
+            Op(DW_OP_plus_uconst), Uleb(1),
+            Op(DW_OP_bra), Branch(fail),
+
+            // Minus should underflow.
+            Op(DW_OP_const1s), U8(0),
+            Op(DW_OP_const1u), U8(1),
+            Op(DW_OP_minus),
+            Op(DW_OP_const1s), U8(0xff),
+            Op(DW_OP_ne),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const1s), U8(0xff),
+            Op(DW_OP_abs),
+            Op(DW_OP_const1u), U8(1),
+            Op(DW_OP_minus),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const4u), U32(0xf078_fffe),
+            Op(DW_OP_const4u), U32(0x0f87_0001),
+            Op(DW_OP_and),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const4u), U32(0xf078_fffe),
+            Op(DW_OP_const4u), U32(0xf000_00fe),
+            Op(DW_OP_and),
+            Op(DW_OP_const4u), U32(0xf000_00fe),
+            Op(DW_OP_ne),
+            Op(DW_OP_bra), Branch(fail),
+
+            // Division is signed.
+            Op(DW_OP_const1s), U8(0xfe),
+            Op(DW_OP_const1s), U8(2),
+            Op(DW_OP_div),
+            Op(DW_OP_plus_uconst), Uleb(1),
+            Op(DW_OP_bra), Branch(fail),
+
+            // Mod is unsigned.
+            Op(DW_OP_const1s), U8(0xfd),
+            Op(DW_OP_const1s), U8(2),
+            Op(DW_OP_mod),
+            Op(DW_OP_neg),
+            Op(DW_OP_plus_uconst), Uleb(1),
+            Op(DW_OP_bra), Branch(fail),
+
+            // Overflow is defined for multiplication.
+            Op(DW_OP_const4u), U32(0x8000_0001),
+            Op(DW_OP_lit2),
+            Op(DW_OP_mul),
+            Op(DW_OP_lit2),
+            Op(DW_OP_ne),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const4u), U32(0xf0f0_f0f0),
+            Op(DW_OP_const4u), U32(0xf0f0_f0f0),
+            Op(DW_OP_xor),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const4u), U32(0xf0f0_f0f0),
+            Op(DW_OP_const4u), U32(0x0f0f_0f0f),
+            Op(DW_OP_or),
+            Op(DW_OP_not),
+            Op(DW_OP_bra), Branch(fail),
+
+            // In 32 bit mode, values are truncated.
+            Op(DW_OP_const8u), U64(0xffff_ffff_0000_0000),
+            Op(DW_OP_lit2),
+            Op(DW_OP_div),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const1u), U8(0xff),
+            Op(DW_OP_lit1),
+            Op(DW_OP_shl),
+            Op(DW_OP_const2u), U16(0x1fe),
+            Op(DW_OP_ne),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const1u), U8(0xff),
+            Op(DW_OP_const1u), U8(50),
+            Op(DW_OP_shl),
+            Op(DW_OP_bra), Branch(fail),
+
+            // Absurd shift.
+            Op(DW_OP_const1u), U8(0xff),
+            Op(DW_OP_const1s), U8(0xff),
+            Op(DW_OP_shl),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const1s), U8(0xff),
+            Op(DW_OP_lit1),
+            Op(DW_OP_shr),
+            Op(DW_OP_const4u), U32(0x7fff_ffff),
+            Op(DW_OP_ne),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const1s), U8(0xff),
+            Op(DW_OP_const1u), U8(0xff),
+            Op(DW_OP_shr),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const1s), U8(0xff),
+            Op(DW_OP_lit1),
+            Op(DW_OP_shra),
+            Op(DW_OP_const1s), U8(0xff),
+            Op(DW_OP_ne),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const1s), U8(0xff),
+            Op(DW_OP_const1u), U8(0xff),
+            Op(DW_OP_shra),
+            Op(DW_OP_const1s), U8(0xff),
+            Op(DW_OP_ne),
+            Op(DW_OP_bra), Branch(fail),
+
+            // Success.
+            Op(DW_OP_lit0),
+            Op(DW_OP_nop),
+            Op(DW_OP_skip), Branch(done),
+
+            Mark(fail),
+            Op(DW_OP_lit1),
+
+            Mark(done),
+            Op(DW_OP_stack_value),
+        ];
+
+        let result = [Piece {
+            size_in_bits: None,
+            bit_offset: None,
+            location: Location::Value {
+                value: Value::Generic(0),
+            },
+        }];
+
+        check_eval(&program, Ok(&result), encoding4());
+    }
+
+    #[test]
+    fn test_eval_arith64() {
+        // It's nice if an operation and its arguments can fit on a single
+        // line in the test program.
+        use self::AssemblerEntry::*;
+        use crate::constants::*;
+
+        // Indices of marks in the assembly.
+        let done = 0;
+        let fail = 1;
+
+        #[rustfmt::skip]
+        let program = [
+            Op(DW_OP_const8u), U64(0x1111_2222_3333_4444),
+            Op(DW_OP_const8s), U64((-0x1111_2222_3333_4444i64) as u64),
+            Op(DW_OP_plus),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_constu), Uleb(0x1111_2222_3333_4444),
+            Op(DW_OP_consts), Sleb((-0x1111_2222_3333_4444i64) as u64),
+            Op(DW_OP_plus),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_lit1),
+            Op(DW_OP_plus_uconst), Uleb(!0u64),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_lit1),
+            Op(DW_OP_neg),
+            Op(DW_OP_not),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const8u), U64(0x8000_0000_0000_0000),
+            Op(DW_OP_const1u), U8(63),
+            Op(DW_OP_shr),
+            Op(DW_OP_lit1),
+            Op(DW_OP_ne),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const8u), U64(0x8000_0000_0000_0000),
+            Op(DW_OP_const1u), U8(62),
+            Op(DW_OP_shra),
+            Op(DW_OP_plus_uconst), Uleb(2),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_lit1),
+            Op(DW_OP_const1u), U8(63),
+            Op(DW_OP_shl),
+            Op(DW_OP_const8u), U64(0x8000_0000_0000_0000),
+            Op(DW_OP_ne),
+            Op(DW_OP_bra), Branch(fail),
+
+            // Success.
+            Op(DW_OP_lit0),
+            Op(DW_OP_nop),
+            Op(DW_OP_skip), Branch(done),
+
+            Mark(fail),
+            Op(DW_OP_lit1),
+
+            Mark(done),
+            Op(DW_OP_stack_value),
+        ];
+
+        let result = [Piece {
+            size_in_bits: None,
+            bit_offset: None,
+            location: Location::Value {
+                value: Value::Generic(0),
+            },
+        }];
+
+        check_eval(&program, Ok(&result), encoding8());
+    }
+
+    #[test]
+    fn test_eval_compare() {
+        // It's nice if an operation and its arguments can fit on a single
+        // line in the test program.
+        use self::AssemblerEntry::*;
+        use crate::constants::*;
+
+        // Indices of marks in the assembly.
+        let done = 0;
+        let fail = 1;
+
+        #[rustfmt::skip]
+        let program = [
+            // Comparisons are signed.
+            Op(DW_OP_const1s), U8(1),
+            Op(DW_OP_const1s), U8(0xff),
+            Op(DW_OP_lt),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const1s), U8(0xff),
+            Op(DW_OP_const1s), U8(1),
+            Op(DW_OP_gt),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const1s), U8(1),
+            Op(DW_OP_const1s), U8(0xff),
+            Op(DW_OP_le),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const1s), U8(0xff),
+            Op(DW_OP_const1s), U8(1),
+            Op(DW_OP_ge),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const1s), U8(0xff),
+            Op(DW_OP_const1s), U8(1),
+            Op(DW_OP_eq),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_const4s), U32(1),
+            Op(DW_OP_const1s), U8(1),
+            Op(DW_OP_ne),
+            Op(DW_OP_bra), Branch(fail),
+
+            // Success.
+            Op(DW_OP_lit0),
+            Op(DW_OP_nop),
+            Op(DW_OP_skip), Branch(done),
+
+            Mark(fail),
+            Op(DW_OP_lit1),
+
+            Mark(done),
+            Op(DW_OP_stack_value),
+        ];
+
+        let result = [Piece {
+            size_in_bits: None,
+            bit_offset: None,
+            location: Location::Value {
+                value: Value::Generic(0),
+            },
+        }];
+
+        check_eval(&program, Ok(&result), encoding4());
+    }
+
+    #[test]
+    fn test_eval_stack() {
+        // It's nice if an operation and its arguments can fit on a single
+        // line in the test program.
+        use self::AssemblerEntry::*;
+        use crate::constants::*;
+
+        #[rustfmt::skip]
+        let program = [
+            Op(DW_OP_lit17),                // -- 17
+            Op(DW_OP_dup),                  // -- 17 17
+            Op(DW_OP_over),                 // -- 17 17 17
+            Op(DW_OP_minus),                // -- 17 0
+            Op(DW_OP_swap),                 // -- 0 17
+            Op(DW_OP_dup),                  // -- 0 17 17
+            Op(DW_OP_plus_uconst), Uleb(1), // -- 0 17 18
+            Op(DW_OP_rot),                  // -- 18 0 17
+            Op(DW_OP_pick), U8(2),          // -- 18 0 17 18
+            Op(DW_OP_pick), U8(3),          // -- 18 0 17 18 18
+            Op(DW_OP_minus),                // -- 18 0 17 0
+            Op(DW_OP_drop),                 // -- 18 0 17
+            Op(DW_OP_swap),                 // -- 18 17 0
+            Op(DW_OP_drop),                 // -- 18 17
+            Op(DW_OP_minus),                // -- 1
+            Op(DW_OP_stack_value),
+        ];
+
+        let result = [Piece {
+            size_in_bits: None,
+            bit_offset: None,
+            location: Location::Value {
+                value: Value::Generic(1),
+            },
+        }];
+
+        check_eval(&program, Ok(&result), encoding4());
+    }
+
+    #[test]
+    fn test_eval_lit_and_reg() {
+        // It's nice if an operation and its arguments can fit on a single
+        // line in the test program.
+        use self::AssemblerEntry::*;
+        use crate::constants::*;
+
+        let mut program = Vec::new();
+        program.push(Op(DW_OP_lit0));
+        for i in 0..32 {
+            program.push(Op(DwOp(DW_OP_lit0.0 + i)));
+            program.push(Op(DwOp(DW_OP_breg0.0 + i)));
+            program.push(Sleb(u64::from(i)));
+            program.push(Op(DW_OP_plus));
+            program.push(Op(DW_OP_plus));
+        }
+
+        program.push(Op(DW_OP_bregx));
+        program.push(Uleb(0x1234));
+        program.push(Sleb(0x1234));
+        program.push(Op(DW_OP_plus));
+
+        program.push(Op(DW_OP_stack_value));
+
+        let result = [Piece {
+            size_in_bits: None,
+            bit_offset: None,
+            location: Location::Value {
+                value: Value::Generic(496),
+            },
+        }];
+
+        check_eval_with_args(
+            &program,
+            Ok(&result),
+            encoding4(),
+            None,
+            None,
+            None,
+            |eval, mut result| {
+                while result != EvaluationResult::Complete {
+                    result = eval.resume_with_register(match result {
+                        EvaluationResult::RequiresRegister {
+                            register,
+                            base_type,
+                        } => {
+                            assert_eq!(base_type, UnitOffset(0));
+                            Value::Generic(u64::from(register.0).wrapping_neg())
+                        }
+                        _ => panic!(),
+                    })?;
+                }
+                Ok(result)
+            },
+        );
+    }
+
+    #[test]
+    fn test_eval_memory() {
+        // It's nice if an operation and its arguments can fit on a single
+        // line in the test program.
+        use self::AssemblerEntry::*;
+        use crate::constants::*;
+
+        // Indices of marks in the assembly.
+        let done = 0;
+        let fail = 1;
+
+        #[rustfmt::skip]
+        let program = [
+            Op(DW_OP_addr), U32(0x7fff_ffff),
+            Op(DW_OP_deref),
+            Op(DW_OP_const4u), U32(0xffff_fffc),
+            Op(DW_OP_ne),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_addr), U32(0x7fff_ffff),
+            Op(DW_OP_deref_size), U8(2),
+            Op(DW_OP_const4u), U32(0xfffc),
+            Op(DW_OP_ne),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_lit1),
+            Op(DW_OP_addr), U32(0x7fff_ffff),
+            Op(DW_OP_xderef),
+            Op(DW_OP_const4u), U32(0xffff_fffd),
+            Op(DW_OP_ne),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_lit1),
+            Op(DW_OP_addr), U32(0x7fff_ffff),
+            Op(DW_OP_xderef_size), U8(2),
+            Op(DW_OP_const4u), U32(0xfffd),
+            Op(DW_OP_ne),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_lit17),
+            Op(DW_OP_form_tls_address),
+            Op(DW_OP_constu), Uleb(!17),
+            Op(DW_OP_ne),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_lit17),
+            Op(DW_OP_GNU_push_tls_address),
+            Op(DW_OP_constu), Uleb(!17),
+            Op(DW_OP_ne),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_addrx), Uleb(0x10),
+            Op(DW_OP_deref),
+            Op(DW_OP_const4u), U32(0x4040),
+            Op(DW_OP_ne),
+            Op(DW_OP_bra), Branch(fail),
+
+            Op(DW_OP_constx), Uleb(17),
+            Op(DW_OP_form_tls_address),
+            Op(DW_OP_constu), Uleb(!27),
+            Op(DW_OP_ne),
+            Op(DW_OP_bra), Branch(fail),
+
+            // Success.
+            Op(DW_OP_lit0),
+            Op(DW_OP_nop),
+            Op(DW_OP_skip), Branch(done),
+
+            Mark(fail),
+            Op(DW_OP_lit1),
+
+            Mark(done),
+            Op(DW_OP_stack_value),
+        ];
+
+        let result = [Piece {
+            size_in_bits: None,
+            bit_offset: None,
+            location: Location::Value {
+                value: Value::Generic(0),
+            },
+        }];
+
+        check_eval_with_args(
+            &program,
+            Ok(&result),
+            encoding4(),
+            None,
+            None,
+            None,
+            |eval, mut result| {
+                while result != EvaluationResult::Complete {
+                    result = match result {
+                        EvaluationResult::RequiresMemory {
+                            address,
+                            size,
+                            space,
+                            base_type,
+                        } => {
+                            assert_eq!(base_type, UnitOffset(0));
+                            let mut v = address << 2;
+                            if let Some(value) = space {
+                                v += value;
+                            }
+                            v &= (1u64 << (8 * size)) - 1;
+                            eval.resume_with_memory(Value::Generic(v))?
+                        }
+                        EvaluationResult::RequiresTls(slot) => eval.resume_with_tls(!slot)?,
+                        EvaluationResult::RequiresRelocatedAddress(address) => {
+                            eval.resume_with_relocated_address(address)?
+                        }
+                        EvaluationResult::RequiresIndexedAddress { index, relocate } => {
+                            if relocate {
+                                eval.resume_with_indexed_address(0x1000 + index.0 as u64)?
+                            } else {
+                                eval.resume_with_indexed_address(10 + index.0 as u64)?
+                            }
+                        }
+                        _ => panic!(),
+                    };
+                }
+
+                Ok(result)
+            },
+        );
+    }
+
+    #[test]
+    fn test_eval_register() {
+        // It's nice if an operation and its arguments can fit on a single
+        // line in the test program.
+        use self::AssemblerEntry::*;
+        use crate::constants::*;
+
+        for i in 0..32 {
+            #[rustfmt::skip]
+            let program = [
+                Op(DwOp(DW_OP_reg0.0 + i)),
+                // Included only in the "bad" run.
+                Op(DW_OP_lit23),
+            ];
+            let ok_result = [Piece {
+                size_in_bits: None,
+                bit_offset: None,
+                location: Location::Register {
+                    register: Register(i.into()),
+                },
+            }];
+
+            check_eval(&program[..1], Ok(&ok_result), encoding4());
+
+            check_eval(
+                &program,
+                Err(Error::InvalidExpressionTerminator(1)),
+                encoding4(),
+            );
+        }
+
+        #[rustfmt::skip]
+        let program = [
+            Op(DW_OP_regx), Uleb(0x1234)
+        ];
+
+        let result = [Piece {
+            size_in_bits: None,
+            bit_offset: None,
+            location: Location::Register {
+                register: Register(0x1234),
+            },
+        }];
+
+        check_eval(&program, Ok(&result), encoding4());
+    }
+
+    #[test]
+    fn test_eval_context() {
+        // It's nice if an operation and its arguments can fit on a single
+        // line in the test program.
+        use self::AssemblerEntry::*;
+        use crate::constants::*;
+
+        // Test `frame_base` and `call_frame_cfa` callbacks.
+        #[rustfmt::skip]
+        let program = [
+            Op(DW_OP_fbreg), Sleb((-8i8) as u64),
+            Op(DW_OP_call_frame_cfa),
+            Op(DW_OP_plus),
+            Op(DW_OP_neg),
+            Op(DW_OP_stack_value)
+        ];
+
+        let result = [Piece {
+            size_in_bits: None,
+            bit_offset: None,
+            location: Location::Value {
+                value: Value::Generic(9),
+            },
+        }];
+
+        check_eval_with_args(
+            &program,
+            Ok(&result),
+            encoding8(),
+            None,
+            None,
+            None,
+            |eval, result| {
+                match result {
+                    EvaluationResult::RequiresFrameBase => {}
+                    _ => panic!(),
+                };
+                match eval.resume_with_frame_base(0x0123_4567_89ab_cdef)? {
+                    EvaluationResult::RequiresCallFrameCfa => {}
+                    _ => panic!(),
+                };
+                eval.resume_with_call_frame_cfa(0xfedc_ba98_7654_3210)
+            },
+        );
+
+        // Test `evaluate_entry_value` callback.
+        #[rustfmt::skip]
+        let program = [
+            Op(DW_OP_entry_value), Uleb(8), U64(0x1234_5678),
+            Op(DW_OP_stack_value)
+        ];
+
+        let result = [Piece {
+            size_in_bits: None,
+            bit_offset: None,
+            location: Location::Value {
+                value: Value::Generic(0x1234_5678),
+            },
+        }];
+
+        check_eval_with_args(
+            &program,
+            Ok(&result),
+            encoding8(),
+            None,
+            None,
+            None,
+            |eval, result| {
+                let entry_value = match result {
+                    EvaluationResult::RequiresEntryValue(mut expression) => {
+                        expression.0.read_u64()?
+                    }
+                    _ => panic!(),
+                };
+                eval.resume_with_entry_value(Value::Generic(entry_value))
+            },
+        );
+
+        // Test missing `object_address` field.
+        #[rustfmt::skip]
+        let program = [
+            Op(DW_OP_push_object_address),
+        ];
+
+        check_eval_with_args(
+            &program,
+            Err(Error::InvalidPushObjectAddress),
+            encoding4(),
+            None,
+            None,
+            None,
+            |_, _| panic!(),
+        );
+
+        // Test `object_address` field.
+        #[rustfmt::skip]
+        let program = [
+            Op(DW_OP_push_object_address),
+            Op(DW_OP_stack_value),
+        ];
+
+        let result = [Piece {
+            size_in_bits: None,
+            bit_offset: None,
+            location: Location::Value {
+                value: Value::Generic(0xff),
+            },
+        }];
+
+        check_eval_with_args(
+            &program,
+            Ok(&result),
+            encoding8(),
+            Some(0xff),
+            None,
+            None,
+            |_, result| Ok(result),
+        );
+
+        // Test `initial_value` field.
+        #[rustfmt::skip]
+        let program = [
+        ];
+
+        let result = [Piece {
+            size_in_bits: None,
+            bit_offset: None,
+            location: Location::Address {
+                address: 0x1234_5678,
+            },
+        }];
+
+        check_eval_with_args(
+            &program,
+            Ok(&result),
+            encoding8(),
+            None,
+            Some(0x1234_5678),
+            None,
+            |_, result| Ok(result),
+        );
+    }
+
+    #[test]
+    fn test_eval_empty_stack() {
+        // It's nice if an operation and its arguments can fit on a single
+        // line in the test program.
+        use self::AssemblerEntry::*;
+        use crate::constants::*;
+
+        #[rustfmt::skip]
+        let program = [
+            Op(DW_OP_stack_value)
+        ];
+
+        check_eval(&program, Err(Error::NotEnoughStackItems), encoding4());
+    }
+
+    #[test]
+    fn test_eval_call() {
+        // It's nice if an operation and its arguments can fit on a single
+        // line in the test program.
+        use self::AssemblerEntry::*;
+        use crate::constants::*;
+
+        #[rustfmt::skip]
+        let program = [
+            Op(DW_OP_lit23),
+            Op(DW_OP_call2), U16(0x7755),
+            Op(DW_OP_call4), U32(0x7755_aaee),
+            Op(DW_OP_call_ref), U32(0x7755_aaee),
+            Op(DW_OP_stack_value)
+        ];
+
+        let result = [Piece {
+            size_in_bits: None,
+            bit_offset: None,
+            location: Location::Value {
+                value: Value::Generic(23),
+            },
+        }];
+
+        check_eval_with_args(
+            &program,
+            Ok(&result),
+            encoding4(),
+            None,
+            None,
+            None,
+            |eval, result| {
+                let buf = EndianSlice::new(&[], LittleEndian);
+                match result {
+                    EvaluationResult::RequiresAtLocation(_) => {}
+                    _ => panic!(),
+                };
+
+                eval.resume_with_at_location(buf)?;
+
+                match result {
+                    EvaluationResult::RequiresAtLocation(_) => {}
+                    _ => panic!(),
+                };
+
+                eval.resume_with_at_location(buf)?;
+
+                match result {
+                    EvaluationResult::RequiresAtLocation(_) => {}
+                    _ => panic!(),
+                };
+
+                eval.resume_with_at_location(buf)
+            },
+        );
+
+        // DW_OP_lit2 DW_OP_mul
+        const SUBR: &[u8] = &[0x32, 0x1e];
+
+        let result = [Piece {
+            size_in_bits: None,
+            bit_offset: None,
+            location: Location::Value {
+                value: Value::Generic(184),
+            },
+        }];
+
+        check_eval_with_args(
+            &program,
+            Ok(&result),
+            encoding4(),
+            None,
+            None,
+            None,
+            |eval, result| {
+                let buf = EndianSlice::new(SUBR, LittleEndian);
+                match result {
+                    EvaluationResult::RequiresAtLocation(_) => {}
+                    _ => panic!(),
+                };
+
+                eval.resume_with_at_location(buf)?;
+
+                match result {
+                    EvaluationResult::RequiresAtLocation(_) => {}
+                    _ => panic!(),
+                };
+
+                eval.resume_with_at_location(buf)?;
+
+                match result {
+                    EvaluationResult::RequiresAtLocation(_) => {}
+                    _ => panic!(),
+                };
+
+                eval.resume_with_at_location(buf)
+            },
+        );
+    }
+
+    #[test]
+    fn test_eval_pieces() {
+        // It's nice if an operation and its arguments can fit on a single
+        // line in the test program.
+        use self::AssemblerEntry::*;
+        use crate::constants::*;
+
+        // Example from DWARF 2.6.1.3.
+        #[rustfmt::skip]
+        let program = [
+            Op(DW_OP_reg3),
+            Op(DW_OP_piece), Uleb(4),
+            Op(DW_OP_reg4),
+            Op(DW_OP_piece), Uleb(2),
+        ];
+
+        let result = [
+            Piece {
+                size_in_bits: Some(32),
+                bit_offset: None,
+                location: Location::Register {
+                    register: Register(3),
+                },
+            },
+            Piece {
+                size_in_bits: Some(16),
+                bit_offset: None,
+                location: Location::Register {
+                    register: Register(4),
+                },
+            },
+        ];
+
+        check_eval(&program, Ok(&result), encoding4());
+
+        // Example from DWARF 2.6.1.3 (but hacked since dealing with fbreg
+        // in the tests is a pain).
+        #[rustfmt::skip]
+        let program = [
+            Op(DW_OP_reg0),
+            Op(DW_OP_piece), Uleb(4),
+            Op(DW_OP_piece), Uleb(4),
+            Op(DW_OP_addr), U32(0x7fff_ffff),
+            Op(DW_OP_piece), Uleb(4),
+        ];
+
+        let result = [
+            Piece {
+                size_in_bits: Some(32),
+                bit_offset: None,
+                location: Location::Register {
+                    register: Register(0),
+                },
+            },
+            Piece {
+                size_in_bits: Some(32),
+                bit_offset: None,
+                location: Location::Empty,
+            },
+            Piece {
+                size_in_bits: Some(32),
+                bit_offset: None,
+                location: Location::Address {
+                    address: 0x7fff_ffff,
+                },
+            },
+        ];
+
+        check_eval_with_args(
+            &program,
+            Ok(&result),
+            encoding4(),
+            None,
+            None,
+            None,
+            |eval, mut result| {
+                while result != EvaluationResult::Complete {
+                    result = match result {
+                        EvaluationResult::RequiresRelocatedAddress(address) => {
+                            eval.resume_with_relocated_address(address)?
+                        }
+                        _ => panic!(),
+                    };
+                }
+
+                Ok(result)
+            },
+        );
+
+        #[rustfmt::skip]
+        let program = [
+            Op(DW_OP_implicit_value), Uleb(5),
+            U8(23), U8(24), U8(25), U8(26), U8(0),
+        ];
+
+        const BYTES: &[u8] = &[23, 24, 25, 26, 0];
+
+        let result = [Piece {
+            size_in_bits: None,
+            bit_offset: None,
+            location: Location::Bytes {
+                value: EndianSlice::new(BYTES, LittleEndian),
+            },
+        }];
+
+        check_eval(&program, Ok(&result), encoding4());
+
+        #[rustfmt::skip]
+        let program = [
+            Op(DW_OP_lit7),
+            Op(DW_OP_stack_value),
+            Op(DW_OP_bit_piece), Uleb(5), Uleb(0),
+            Op(DW_OP_bit_piece), Uleb(3), Uleb(0),
+        ];
+
+        let result = [
+            Piece {
+                size_in_bits: Some(5),
+                bit_offset: Some(0),
+                location: Location::Value {
+                    value: Value::Generic(7),
+                },
+            },
+            Piece {
+                size_in_bits: Some(3),
+                bit_offset: Some(0),
+                location: Location::Empty,
+            },
+        ];
+
+        check_eval(&program, Ok(&result), encoding4());
+
+        #[rustfmt::skip]
+        let program = [
+            Op(DW_OP_lit7),
+        ];
+
+        let result = [Piece {
+            size_in_bits: None,
+            bit_offset: None,
+            location: Location::Address { address: 7 },
+        }];
+
+        check_eval(&program, Ok(&result), encoding4());
+
+        #[rustfmt::skip]
+        let program = [
+            Op(DW_OP_implicit_pointer), U32(0x1234_5678), Sleb(0x123),
+        ];
+
+        let result = [Piece {
+            size_in_bits: None,
+            bit_offset: None,
+            location: Location::ImplicitPointer {
+                value: DebugInfoOffset(0x1234_5678),
+                byte_offset: 0x123,
+            },
+        }];
+
+        check_eval(&program, Ok(&result), encoding4());
+
+        #[rustfmt::skip]
+        let program = [
+            Op(DW_OP_reg3),
+            Op(DW_OP_piece), Uleb(4),
+            Op(DW_OP_reg4),
+        ];
+
+        check_eval(&program, Err(Error::InvalidPiece), encoding4());
+
+        #[rustfmt::skip]
+        let program = [
+            Op(DW_OP_reg3),
+            Op(DW_OP_piece), Uleb(4),
+            Op(DW_OP_lit0),
+        ];
+
+        check_eval(&program, Err(Error::InvalidPiece), encoding4());
+    }
+
+    #[test]
+    fn test_eval_max_iterations() {
+        // It's nice if an operation and its arguments can fit on a single
+        // line in the test program.
+        use self::AssemblerEntry::*;
+        use crate::constants::*;
+
+        #[rustfmt::skip]
+        let program = [
+            Mark(1),
+            Op(DW_OP_skip), Branch(1),
+        ];
+
+        check_eval_with_args(
+            &program,
+            Err(Error::TooManyIterations),
+            encoding4(),
+            None,
+            None,
+            Some(150),
+            |_, _| panic!(),
+        );
+    }
+
+    #[test]
+    fn test_eval_typed_stack() {
+        use self::AssemblerEntry::*;
+        use crate::constants::*;
+
+        let base_types = [
+            ValueType::Generic,
+            ValueType::U16,
+            ValueType::U32,
+            ValueType::F32,
+        ];
+
+        // TODO: convert, reinterpret
+        #[rustfmt::skip]
+        let tests = [
+            (
+                &[
+                    Op(DW_OP_const_type), Uleb(1), U8(2), U16(0x1234),
+                    Op(DW_OP_stack_value),
+                ][..],
+                Value::U16(0x1234),
+            ),
+            (
+                &[
+                    Op(DW_OP_regval_type), Uleb(0x1234), Uleb(1),
+                    Op(DW_OP_stack_value),
+                ][..],
+                Value::U16(0x2340),
+            ),
+            (
+                &[
+                    Op(DW_OP_addr), U32(0x7fff_ffff),
+                    Op(DW_OP_deref_type), U8(2), Uleb(1),
+                    Op(DW_OP_stack_value),
+                ][..],
+                Value::U16(0xfff0),
+            ),
+            (
+                &[
+                    Op(DW_OP_lit1),
+                    Op(DW_OP_addr), U32(0x7fff_ffff),
+                    Op(DW_OP_xderef_type), U8(2), Uleb(1),
+                    Op(DW_OP_stack_value),
+                ][..],
+                Value::U16(0xfff1),
+            ),
+            (
+                &[
+                    Op(DW_OP_const_type), Uleb(1), U8(2), U16(0x1234),
+                    Op(DW_OP_convert), Uleb(2),
+                    Op(DW_OP_stack_value),
+                ][..],
+                Value::U32(0x1234),
+            ),
+            (
+                &[
+                    Op(DW_OP_const_type), Uleb(2), U8(4), U32(0x3f80_0000),
+                    Op(DW_OP_reinterpret), Uleb(3),
+                    Op(DW_OP_stack_value),
+                ][..],
+                Value::F32(1.0),
+            ),
+        ];
+        for &(program, value) in &tests {
+            let result = [Piece {
+                size_in_bits: None,
+                bit_offset: None,
+                location: Location::Value { value },
+            }];
+
+            check_eval_with_args(
+                program,
+                Ok(&result),
+                encoding4(),
+                None,
+                None,
+                None,
+                |eval, mut result| {
+                    while result != EvaluationResult::Complete {
+                        result = match result {
+                            EvaluationResult::RequiresMemory {
+                                address,
+                                size,
+                                space,
+                                base_type,
+                            } => {
+                                let mut v = address << 4;
+                                if let Some(value) = space {
+                                    v += value;
+                                }
+                                v &= (1u64 << (8 * size)) - 1;
+                                let v = Value::from_u64(base_types[base_type.0], v)?;
+                                eval.resume_with_memory(v)?
+                            }
+                            EvaluationResult::RequiresRegister {
+                                register,
+                                base_type,
+                            } => {
+                                let v = Value::from_u64(
+                                    base_types[base_type.0],
+                                    u64::from(register.0) << 4,
+                                )?;
+                                eval.resume_with_register(v)?
+                            }
+                            EvaluationResult::RequiresBaseType(offset) => {
+                                eval.resume_with_base_type(base_types[offset.0])?
+                            }
+                            EvaluationResult::RequiresRelocatedAddress(address) => {
+                                eval.resume_with_relocated_address(address)?
+                            }
+                            _ => panic!("Unexpected result {:?}", result),
+                        }
+                    }
+                    Ok(result)
+                },
+            );
+        }
+    }
+}
diff --git a/vendor/gimli/src/read/pubnames.rs b/vendor/gimli/src/read/pubnames.rs
new file mode 100644
index 0000000..e8b7e55
--- /dev/null
+++ b/vendor/gimli/src/read/pubnames.rs
@@ -0,0 +1,141 @@
+use crate::common::{DebugInfoOffset, SectionId};
+use crate::endianity::Endianity;
+use crate::read::lookup::{DebugLookup, LookupEntryIter, PubStuffEntry, PubStuffParser};
+use crate::read::{EndianSlice, Reader, Result, Section, UnitOffset};
+
+/// A single parsed pubname.
+#[derive(Debug, Clone)]
+pub struct PubNamesEntry<R: Reader> {
+    unit_header_offset: DebugInfoOffset<R::Offset>,
+    die_offset: UnitOffset<R::Offset>,
+    name: R,
+}
+
+impl<R: Reader> PubNamesEntry<R> {
+    /// Returns the name this entry refers to.
+    pub fn name(&self) -> &R {
+        &self.name
+    }
+
+    /// Returns the offset into the .debug_info section for the header of the compilation unit
+    /// which contains this name.
+    pub fn unit_header_offset(&self) -> DebugInfoOffset<R::Offset> {
+        self.unit_header_offset
+    }
+
+    /// Returns the offset into the compilation unit for the debugging information entry which
+    /// has this name.
+    pub fn die_offset(&self) -> UnitOffset<R::Offset> {
+        self.die_offset
+    }
+}
+
+impl<R: Reader> PubStuffEntry<R> for PubNamesEntry<R> {
+    fn new(
+        die_offset: UnitOffset<R::Offset>,
+        name: R,
+        unit_header_offset: DebugInfoOffset<R::Offset>,
+    ) -> Self {
+        PubNamesEntry {
+            unit_header_offset,
+            die_offset,
+            name,
+        }
+    }
+}
+
+/// The `DebugPubNames` struct represents the DWARF public names information
+/// found in the `.debug_pubnames` section.
+#[derive(Debug, Clone)]
+pub struct DebugPubNames<R: Reader>(DebugLookup<R, PubStuffParser<R, PubNamesEntry<R>>>);
+
+impl<'input, Endian> DebugPubNames<EndianSlice<'input, Endian>>
+where
+    Endian: Endianity,
+{
+    /// Construct a new `DebugPubNames` instance from the data in the `.debug_pubnames`
+    /// section.
+    ///
+    /// It is the caller's responsibility to read the `.debug_pubnames` section and
+    /// present it as a `&[u8]` slice. That means using some ELF loader on
+    /// Linux, a Mach-O loader on macOS, etc.
+    ///
+    /// ```
+    /// use gimli::{DebugPubNames, LittleEndian};
+    ///
+    /// # let buf = [];
+    /// # let read_debug_pubnames_section_somehow = || &buf;
+    /// let debug_pubnames =
+    ///     DebugPubNames::new(read_debug_pubnames_section_somehow(), LittleEndian);
+    /// ```
+    pub fn new(debug_pubnames_section: &'input [u8], endian: Endian) -> Self {
+        Self::from(EndianSlice::new(debug_pubnames_section, endian))
+    }
+}
+
+impl<R: Reader> DebugPubNames<R> {
+    /// Iterate the pubnames in the `.debug_pubnames` section.
+    ///
+    /// ```
+    /// use gimli::{DebugPubNames, EndianSlice, LittleEndian};
+    ///
+    /// # let buf = [];
+    /// # let read_debug_pubnames_section_somehow = || &buf;
+    /// let debug_pubnames =
+    ///     DebugPubNames::new(read_debug_pubnames_section_somehow(), LittleEndian);
+    ///
+    /// let mut iter = debug_pubnames.items();
+    /// while let Some(pubname) = iter.next().unwrap() {
+    ///   println!("pubname {} found!", pubname.name().to_string_lossy());
+    /// }
+    /// ```
+    pub fn items(&self) -> PubNamesEntryIter<R> {
+        PubNamesEntryIter(self.0.items())
+    }
+}
+
+impl<R: Reader> Section<R> for DebugPubNames<R> {
+    fn id() -> SectionId {
+        SectionId::DebugPubNames
+    }
+
+    fn reader(&self) -> &R {
+        self.0.reader()
+    }
+}
+
+impl<R: Reader> From<R> for DebugPubNames<R> {
+    fn from(debug_pubnames_section: R) -> Self {
+        DebugPubNames(DebugLookup::from(debug_pubnames_section))
+    }
+}
+
+/// An iterator over the pubnames from a `.debug_pubnames` section.
+///
+/// Can be [used with
+/// `FallibleIterator`](./index.html#using-with-fallibleiterator).
+#[derive(Debug, Clone)]
+pub struct PubNamesEntryIter<R: Reader>(LookupEntryIter<R, PubStuffParser<R, PubNamesEntry<R>>>);
+
+impl<R: Reader> PubNamesEntryIter<R> {
+    /// Advance the iterator and return the next pubname.
+    ///
+    /// Returns the newly parsed pubname as `Ok(Some(pubname))`. Returns
+    /// `Ok(None)` when iteration is complete and all pubnames have already been
+    /// parsed and yielded. If an error occurs while parsing the next pubname,
+    /// then this error is returned as `Err(e)`, and all subsequent calls return
+    /// `Ok(None)`.
+    pub fn next(&mut self) -> Result<Option<PubNamesEntry<R>>> {
+        self.0.next()
+    }
+}
+
+#[cfg(feature = "fallible-iterator")]
+impl<R: Reader> fallible_iterator::FallibleIterator for PubNamesEntryIter<R> {
+    type Item = PubNamesEntry<R>;
+    type Error = crate::read::Error;
+
+    fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> {
+        self.0.next()
+    }
+}
diff --git a/vendor/gimli/src/read/pubtypes.rs b/vendor/gimli/src/read/pubtypes.rs
new file mode 100644
index 0000000..6723b42
--- /dev/null
+++ b/vendor/gimli/src/read/pubtypes.rs
@@ -0,0 +1,141 @@
+use crate::common::{DebugInfoOffset, SectionId};
+use crate::endianity::Endianity;
+use crate::read::lookup::{DebugLookup, LookupEntryIter, PubStuffEntry, PubStuffParser};
+use crate::read::{EndianSlice, Reader, Result, Section, UnitOffset};
+
+/// A single parsed pubtype.
+#[derive(Debug, Clone)]
+pub struct PubTypesEntry<R: Reader> {
+    unit_header_offset: DebugInfoOffset<R::Offset>,
+    die_offset: UnitOffset<R::Offset>,
+    name: R,
+}
+
+impl<R: Reader> PubTypesEntry<R> {
+    /// Returns the name of the type this entry refers to.
+    pub fn name(&self) -> &R {
+        &self.name
+    }
+
+    /// Returns the offset into the .debug_info section for the header of the compilation unit
+    /// which contains the type with this name.
+    pub fn unit_header_offset(&self) -> DebugInfoOffset<R::Offset> {
+        self.unit_header_offset
+    }
+
+    /// Returns the offset into the compilation unit for the debugging information entry which
+    /// the type with this name.
+    pub fn die_offset(&self) -> UnitOffset<R::Offset> {
+        self.die_offset
+    }
+}
+
+impl<R: Reader> PubStuffEntry<R> for PubTypesEntry<R> {
+    fn new(
+        die_offset: UnitOffset<R::Offset>,
+        name: R,
+        unit_header_offset: DebugInfoOffset<R::Offset>,
+    ) -> Self {
+        PubTypesEntry {
+            unit_header_offset,
+            die_offset,
+            name,
+        }
+    }
+}
+
+/// The `DebugPubTypes` struct represents the DWARF public types information
+/// found in the `.debug_info` section.
+#[derive(Debug, Clone)]
+pub struct DebugPubTypes<R: Reader>(DebugLookup<R, PubStuffParser<R, PubTypesEntry<R>>>);
+
+impl<'input, Endian> DebugPubTypes<EndianSlice<'input, Endian>>
+where
+    Endian: Endianity,
+{
+    /// Construct a new `DebugPubTypes` instance from the data in the `.debug_pubtypes`
+    /// section.
+    ///
+    /// It is the caller's responsibility to read the `.debug_pubtypes` section and
+    /// present it as a `&[u8]` slice. That means using some ELF loader on
+    /// Linux, a Mach-O loader on macOS, etc.
+    ///
+    /// ```
+    /// use gimli::{DebugPubTypes, LittleEndian};
+    ///
+    /// # let buf = [];
+    /// # let read_debug_pubtypes_somehow = || &buf;
+    /// let debug_pubtypes =
+    ///     DebugPubTypes::new(read_debug_pubtypes_somehow(), LittleEndian);
+    /// ```
+    pub fn new(debug_pubtypes_section: &'input [u8], endian: Endian) -> Self {
+        Self::from(EndianSlice::new(debug_pubtypes_section, endian))
+    }
+}
+
+impl<R: Reader> DebugPubTypes<R> {
+    /// Iterate the pubtypes in the `.debug_pubtypes` section.
+    ///
+    /// ```
+    /// use gimli::{DebugPubTypes, EndianSlice, LittleEndian};
+    ///
+    /// # let buf = [];
+    /// # let read_debug_pubtypes_section_somehow = || &buf;
+    /// let debug_pubtypes =
+    ///     DebugPubTypes::new(read_debug_pubtypes_section_somehow(), LittleEndian);
+    ///
+    /// let mut iter = debug_pubtypes.items();
+    /// while let Some(pubtype) = iter.next().unwrap() {
+    ///   println!("pubtype {} found!", pubtype.name().to_string_lossy());
+    /// }
+    /// ```
+    pub fn items(&self) -> PubTypesEntryIter<R> {
+        PubTypesEntryIter(self.0.items())
+    }
+}
+
+impl<R: Reader> Section<R> for DebugPubTypes<R> {
+    fn id() -> SectionId {
+        SectionId::DebugPubTypes
+    }
+
+    fn reader(&self) -> &R {
+        self.0.reader()
+    }
+}
+
+impl<R: Reader> From<R> for DebugPubTypes<R> {
+    fn from(debug_pubtypes_section: R) -> Self {
+        DebugPubTypes(DebugLookup::from(debug_pubtypes_section))
+    }
+}
+
+/// An iterator over the pubtypes from a `.debug_pubtypes` section.
+///
+/// Can be [used with
+/// `FallibleIterator`](./index.html#using-with-fallibleiterator).
+#[derive(Debug, Clone)]
+pub struct PubTypesEntryIter<R: Reader>(LookupEntryIter<R, PubStuffParser<R, PubTypesEntry<R>>>);
+
+impl<R: Reader> PubTypesEntryIter<R> {
+    /// Advance the iterator and return the next pubtype.
+    ///
+    /// Returns the newly parsed pubtype as `Ok(Some(pubtype))`. Returns
+    /// `Ok(None)` when iteration is complete and all pubtypes have already been
+    /// parsed and yielded. If an error occurs while parsing the next pubtype,
+    /// then this error is returned as `Err(e)`, and all subsequent calls return
+    /// `Ok(None)`.
+    pub fn next(&mut self) -> Result<Option<PubTypesEntry<R>>> {
+        self.0.next()
+    }
+}
+
+#[cfg(feature = "fallible-iterator")]
+impl<R: Reader> fallible_iterator::FallibleIterator for PubTypesEntryIter<R> {
+    type Item = PubTypesEntry<R>;
+    type Error = crate::read::Error;
+
+    fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> {
+        self.0.next()
+    }
+}
diff --git a/vendor/gimli/src/read/reader.rs b/vendor/gimli/src/read/reader.rs
new file mode 100644
index 0000000..e7dd477
--- /dev/null
+++ b/vendor/gimli/src/read/reader.rs
@@ -0,0 +1,502 @@
+#[cfg(feature = "read")]
+use alloc::borrow::Cow;
+use core::convert::TryInto;
+use core::fmt::Debug;
+use core::hash::Hash;
+use core::ops::{Add, AddAssign, Sub};
+
+use crate::common::Format;
+use crate::endianity::Endianity;
+use crate::leb128;
+use crate::read::{Error, Result};
+
+/// An identifier for an offset within a section reader.
+///
+/// This is used for error reporting. The meaning of this value is specific to
+/// each reader implementation. The values should be chosen to be unique amongst
+/// all readers. If values are not unique then errors may point to the wrong reader.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ReaderOffsetId(pub u64);
+
+/// A trait for offsets with a DWARF section.
+///
+/// This allows consumers to choose a size that is appropriate for their address space.
+pub trait ReaderOffset:
+    Debug + Copy + Eq + Ord + Hash + Add<Output = Self> + AddAssign + Sub<Output = Self>
+{
+    /// Convert a u8 to an offset.
+    fn from_u8(offset: u8) -> Self;
+
+    /// Convert a u16 to an offset.
+    fn from_u16(offset: u16) -> Self;
+
+    /// Convert an i16 to an offset.
+    fn from_i16(offset: i16) -> Self;
+
+    /// Convert a u32 to an offset.
+    fn from_u32(offset: u32) -> Self;
+
+    /// Convert a u64 to an offset.
+    ///
+    /// Returns `Error::UnsupportedOffset` if the value is too large.
+    fn from_u64(offset: u64) -> Result<Self>;
+
+    /// Convert an offset to a u64.
+    fn into_u64(self) -> u64;
+
+    /// Wrapping (modular) addition. Computes `self + other`.
+    fn wrapping_add(self, other: Self) -> Self;
+
+    /// Checked subtraction. Computes `self - other`.
+    fn checked_sub(self, other: Self) -> Option<Self>;
+}
+
+impl ReaderOffset for u64 {
+    #[inline]
+    fn from_u8(offset: u8) -> Self {
+        u64::from(offset)
+    }
+
+    #[inline]
+    fn from_u16(offset: u16) -> Self {
+        u64::from(offset)
+    }
+
+    #[inline]
+    fn from_i16(offset: i16) -> Self {
+        offset as u64
+    }
+
+    #[inline]
+    fn from_u32(offset: u32) -> Self {
+        u64::from(offset)
+    }
+
+    #[inline]
+    fn from_u64(offset: u64) -> Result<Self> {
+        Ok(offset)
+    }
+
+    #[inline]
+    fn into_u64(self) -> u64 {
+        self
+    }
+
+    #[inline]
+    fn wrapping_add(self, other: Self) -> Self {
+        self.wrapping_add(other)
+    }
+
+    #[inline]
+    fn checked_sub(self, other: Self) -> Option<Self> {
+        self.checked_sub(other)
+    }
+}
+
+impl ReaderOffset for u32 {
+    #[inline]
+    fn from_u8(offset: u8) -> Self {
+        u32::from(offset)
+    }
+
+    #[inline]
+    fn from_u16(offset: u16) -> Self {
+        u32::from(offset)
+    }
+
+    #[inline]
+    fn from_i16(offset: i16) -> Self {
+        offset as u32
+    }
+
+    #[inline]
+    fn from_u32(offset: u32) -> Self {
+        offset
+    }
+
+    #[inline]
+    fn from_u64(offset64: u64) -> Result<Self> {
+        let offset = offset64 as u32;
+        if u64::from(offset) == offset64 {
+            Ok(offset)
+        } else {
+            Err(Error::UnsupportedOffset)
+        }
+    }
+
+    #[inline]
+    fn into_u64(self) -> u64 {
+        u64::from(self)
+    }
+
+    #[inline]
+    fn wrapping_add(self, other: Self) -> Self {
+        self.wrapping_add(other)
+    }
+
+    #[inline]
+    fn checked_sub(self, other: Self) -> Option<Self> {
+        self.checked_sub(other)
+    }
+}
+
+impl ReaderOffset for usize {
+    #[inline]
+    fn from_u8(offset: u8) -> Self {
+        offset as usize
+    }
+
+    #[inline]
+    fn from_u16(offset: u16) -> Self {
+        offset as usize
+    }
+
+    #[inline]
+    fn from_i16(offset: i16) -> Self {
+        offset as usize
+    }
+
+    #[inline]
+    fn from_u32(offset: u32) -> Self {
+        offset as usize
+    }
+
+    #[inline]
+    fn from_u64(offset64: u64) -> Result<Self> {
+        let offset = offset64 as usize;
+        if offset as u64 == offset64 {
+            Ok(offset)
+        } else {
+            Err(Error::UnsupportedOffset)
+        }
+    }
+
+    #[inline]
+    fn into_u64(self) -> u64 {
+        self as u64
+    }
+
+    #[inline]
+    fn wrapping_add(self, other: Self) -> Self {
+        self.wrapping_add(other)
+    }
+
+    #[inline]
+    fn checked_sub(self, other: Self) -> Option<Self> {
+        self.checked_sub(other)
+    }
+}
+
+#[cfg(not(feature = "read"))]
+pub(crate) mod seal_if_no_alloc {
+    #[derive(Debug)]
+    pub struct Sealed;
+}
+
+/// A trait for reading the data from a DWARF section.
+///
+/// All read operations advance the section offset of the reader
+/// unless specified otherwise.
+///
+/// ## Choosing a `Reader` Implementation
+///
+/// `gimli` comes with a few different `Reader` implementations and lets you
+/// choose the one that is right for your use case. A `Reader` is essentially a
+/// view into the raw bytes that make up some DWARF, but this view might borrow
+/// the underlying data or use reference counting ownership, and it might be
+/// thread safe or not.
+///
+/// | Implementation    | Ownership         | Thread Safe | Notes |
+/// |:------------------|:------------------|:------------|:------|
+/// | [`EndianSlice`](./struct.EndianSlice.html)        | Borrowed          | Yes         | Fastest, but requires that all of your code work with borrows. |
+/// | [`EndianRcSlice`](./struct.EndianRcSlice.html)    | Reference counted | No          | Shared ownership via reference counting, which alleviates the borrow restrictions of `EndianSlice` but imposes reference counting increments and decrements. Cannot be sent across threads, because the reference count is not atomic. |
+/// | [`EndianArcSlice`](./struct.EndianArcSlice.html)  | Reference counted | Yes         | The same as `EndianRcSlice`, but uses atomic reference counting, and therefore reference counting operations are slower but `EndianArcSlice`s may be sent across threads. |
+/// | [`EndianReader<T>`](./struct.EndianReader.html)   | Same as `T`       | Same as `T` | Escape hatch for easily defining your own type of `Reader`. |
+pub trait Reader: Debug + Clone {
+    /// The endianity of bytes that are read.
+    type Endian: Endianity;
+
+    /// The type used for offsets and lengths.
+    type Offset: ReaderOffset;
+
+    /// Return the endianity of bytes that are read.
+    fn endian(&self) -> Self::Endian;
+
+    /// Return the number of bytes remaining.
+    fn len(&self) -> Self::Offset;
+
+    /// Set the number of bytes remaining to zero.
+    fn empty(&mut self);
+
+    /// Set the number of bytes remaining to the specified length.
+    fn truncate(&mut self, len: Self::Offset) -> Result<()>;
+
+    /// Return the offset of this reader's data relative to the start of
+    /// the given base reader's data.
+    ///
+    /// May panic if this reader's data is not contained within the given
+    /// base reader's data.
+    fn offset_from(&self, base: &Self) -> Self::Offset;
+
+    /// Return an identifier for the current reader offset.
+    fn offset_id(&self) -> ReaderOffsetId;
+
+    /// Return the offset corresponding to the given `id` if
+    /// it is associated with this reader.
+    fn lookup_offset_id(&self, id: ReaderOffsetId) -> Option<Self::Offset>;
+
+    /// Find the index of the first occurrence of the given byte.
+    /// The offset of the reader is not changed.
+    fn find(&self, byte: u8) -> Result<Self::Offset>;
+
+    /// Discard the specified number of bytes.
+    fn skip(&mut self, len: Self::Offset) -> Result<()>;
+
+    /// Split a reader in two.
+    ///
+    /// A new reader is returned that can be used to read the next
+    /// `len` bytes, and `self` is advanced so that it reads the remainder.
+    fn split(&mut self, len: Self::Offset) -> Result<Self>;
+
+    /// This trait cannot be implemented if "read" feature is not enabled.
+    ///
+    /// `Reader` trait has a few methods that depend on `alloc` crate.
+    /// Disallowing `Reader` trait implementation prevents a crate that only depends on
+    /// "read-core" from being broken if another crate depending on `gimli` enables
+    /// "read" feature.
+    #[cfg(not(feature = "read"))]
+    fn cannot_implement() -> seal_if_no_alloc::Sealed;
+
+    /// Return all remaining data as a clone-on-write slice.
+    ///
+    /// The slice will be borrowed where possible, but some readers may
+    /// always return an owned vector.
+    ///
+    /// Does not advance the reader.
+    #[cfg(feature = "read")]
+    fn to_slice(&self) -> Result<Cow<[u8]>>;
+
+    /// Convert all remaining data to a clone-on-write string.
+    ///
+    /// The string will be borrowed where possible, but some readers may
+    /// always return an owned string.
+    ///
+    /// Does not advance the reader.
+    ///
+    /// Returns an error if the data contains invalid characters.
+    #[cfg(feature = "read")]
+    fn to_string(&self) -> Result<Cow<str>>;
+
+    /// Convert all remaining data to a clone-on-write string, including invalid characters.
+    ///
+    /// The string will be borrowed where possible, but some readers may
+    /// always return an owned string.
+    ///
+    /// Does not advance the reader.
+    #[cfg(feature = "read")]
+    fn to_string_lossy(&self) -> Result<Cow<str>>;
+
+    /// Read exactly `buf.len()` bytes into `buf`.
+    fn read_slice(&mut self, buf: &mut [u8]) -> Result<()>;
+
+    /// Read a u8 array.
+    #[inline]
+    fn read_u8_array<A>(&mut self) -> Result<A>
+    where
+        A: Sized + Default + AsMut<[u8]>,
+    {
+        let mut val = Default::default();
+        self.read_slice(<A as AsMut<[u8]>>::as_mut(&mut val))?;
+        Ok(val)
+    }
+
+    /// Return true if the number of bytes remaining is zero.
+    #[inline]
+    fn is_empty(&self) -> bool {
+        self.len() == Self::Offset::from_u8(0)
+    }
+
+    /// Read a u8.
+    #[inline]
+    fn read_u8(&mut self) -> Result<u8> {
+        let a: [u8; 1] = self.read_u8_array()?;
+        Ok(a[0])
+    }
+
+    /// Read an i8.
+    #[inline]
+    fn read_i8(&mut self) -> Result<i8> {
+        let a: [u8; 1] = self.read_u8_array()?;
+        Ok(a[0] as i8)
+    }
+
+    /// Read a u16.
+    #[inline]
+    fn read_u16(&mut self) -> Result<u16> {
+        let a: [u8; 2] = self.read_u8_array()?;
+        Ok(self.endian().read_u16(&a))
+    }
+
+    /// Read an i16.
+    #[inline]
+    fn read_i16(&mut self) -> Result<i16> {
+        let a: [u8; 2] = self.read_u8_array()?;
+        Ok(self.endian().read_i16(&a))
+    }
+
+    /// Read a u32.
+    #[inline]
+    fn read_u32(&mut self) -> Result<u32> {
+        let a: [u8; 4] = self.read_u8_array()?;
+        Ok(self.endian().read_u32(&a))
+    }
+
+    /// Read an i32.
+    #[inline]
+    fn read_i32(&mut self) -> Result<i32> {
+        let a: [u8; 4] = self.read_u8_array()?;
+        Ok(self.endian().read_i32(&a))
+    }
+
+    /// Read a u64.
+    #[inline]
+    fn read_u64(&mut self) -> Result<u64> {
+        let a: [u8; 8] = self.read_u8_array()?;
+        Ok(self.endian().read_u64(&a))
+    }
+
+    /// Read an i64.
+    #[inline]
+    fn read_i64(&mut self) -> Result<i64> {
+        let a: [u8; 8] = self.read_u8_array()?;
+        Ok(self.endian().read_i64(&a))
+    }
+
+    /// Read a f32.
+    #[inline]
+    fn read_f32(&mut self) -> Result<f32> {
+        let a: [u8; 4] = self.read_u8_array()?;
+        Ok(self.endian().read_f32(&a))
+    }
+
+    /// Read a f64.
+    #[inline]
+    fn read_f64(&mut self) -> Result<f64> {
+        let a: [u8; 8] = self.read_u8_array()?;
+        Ok(self.endian().read_f64(&a))
+    }
+
+    /// Read an unsigned n-bytes integer u64.
+    ///
+    /// # Panics
+    ///
+    /// Panics when nbytes < 1 or nbytes > 8
+    #[inline]
+    fn read_uint(&mut self, n: usize) -> Result<u64> {
+        let mut buf = [0; 8];
+        self.read_slice(&mut buf[..n])?;
+        Ok(self.endian().read_uint(&buf[..n]))
+    }
+
+    /// Read a null-terminated slice, and return it (excluding the null).
+    fn read_null_terminated_slice(&mut self) -> Result<Self> {
+        let idx = self.find(0)?;
+        let val = self.split(idx)?;
+        self.skip(Self::Offset::from_u8(1))?;
+        Ok(val)
+    }
+
+    /// Skip a LEB128 encoded integer.
+    fn skip_leb128(&mut self) -> Result<()> {
+        leb128::read::skip(self)
+    }
+
+    /// Read an unsigned LEB128 encoded integer.
+    fn read_uleb128(&mut self) -> Result<u64> {
+        leb128::read::unsigned(self)
+    }
+
+    /// Read an unsigned LEB128 encoded u32.
+    fn read_uleb128_u32(&mut self) -> Result<u32> {
+        leb128::read::unsigned(self)?
+            .try_into()
+            .map_err(|_| Error::BadUnsignedLeb128)
+    }
+
+    /// Read an unsigned LEB128 encoded u16.
+    fn read_uleb128_u16(&mut self) -> Result<u16> {
+        leb128::read::u16(self)
+    }
+
+    /// Read a signed LEB128 encoded integer.
+    fn read_sleb128(&mut self) -> Result<i64> {
+        leb128::read::signed(self)
+    }
+
+    /// Read an initial length field.
+    ///
+    /// This field is encoded as either a 32-bit length or
+    /// a 64-bit length, and the returned `Format` indicates which.
+    fn read_initial_length(&mut self) -> Result<(Self::Offset, Format)> {
+        const MAX_DWARF_32_UNIT_LENGTH: u32 = 0xffff_fff0;
+        const DWARF_64_INITIAL_UNIT_LENGTH: u32 = 0xffff_ffff;
+
+        let val = self.read_u32()?;
+        if val < MAX_DWARF_32_UNIT_LENGTH {
+            Ok((Self::Offset::from_u32(val), Format::Dwarf32))
+        } else if val == DWARF_64_INITIAL_UNIT_LENGTH {
+            let val = self.read_u64().and_then(Self::Offset::from_u64)?;
+            Ok((val, Format::Dwarf64))
+        } else {
+            Err(Error::UnknownReservedLength)
+        }
+    }
+
+    /// Read an address-sized integer, and return it as a `u64`.
+    fn read_address(&mut self, address_size: u8) -> Result<u64> {
+        match address_size {
+            1 => self.read_u8().map(u64::from),
+            2 => self.read_u16().map(u64::from),
+            4 => self.read_u32().map(u64::from),
+            8 => self.read_u64(),
+            otherwise => Err(Error::UnsupportedAddressSize(otherwise)),
+        }
+    }
+
+    /// Parse a word-sized integer according to the DWARF format.
+    ///
+    /// These are always used to encode section offsets or lengths,
+    /// and so have a type of `Self::Offset`.
+    fn read_word(&mut self, format: Format) -> Result<Self::Offset> {
+        match format {
+            Format::Dwarf32 => self.read_u32().map(Self::Offset::from_u32),
+            Format::Dwarf64 => self.read_u64().and_then(Self::Offset::from_u64),
+        }
+    }
+
+    /// Parse a word-sized section length according to the DWARF format.
+    #[inline]
+    fn read_length(&mut self, format: Format) -> Result<Self::Offset> {
+        self.read_word(format)
+    }
+
+    /// Parse a word-sized section offset according to the DWARF format.
+    #[inline]
+    fn read_offset(&mut self, format: Format) -> Result<Self::Offset> {
+        self.read_word(format)
+    }
+
+    /// Parse a section offset of the given size.
+    ///
+    /// This is used for `DW_FORM_ref_addr` values in DWARF version 2.
+    fn read_sized_offset(&mut self, size: u8) -> Result<Self::Offset> {
+        match size {
+            1 => self.read_u8().map(u64::from),
+            2 => self.read_u16().map(u64::from),
+            4 => self.read_u32().map(u64::from),
+            8 => self.read_u64(),
+            otherwise => Err(Error::UnsupportedOffsetSize(otherwise)),
+        }
+        .and_then(Self::Offset::from_u64)
+    }
+}
diff --git a/vendor/gimli/src/read/rnglists.rs b/vendor/gimli/src/read/rnglists.rs
new file mode 100644
index 0000000..12e3e04
--- /dev/null
+++ b/vendor/gimli/src/read/rnglists.rs
@@ -0,0 +1,1458 @@
+use crate::common::{
+    DebugAddrBase, DebugAddrIndex, DebugRngListsBase, DebugRngListsIndex, DwarfFileType, Encoding,
+    RangeListsOffset, SectionId,
+};
+use crate::constants;
+use crate::endianity::Endianity;
+use crate::read::{
+    lists::ListsHeader, DebugAddr, EndianSlice, Error, Reader, ReaderOffset, ReaderOffsetId,
+    Result, Section,
+};
+
+/// The raw contents of the `.debug_ranges` section.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct DebugRanges<R> {
+    pub(crate) section: R,
+}
+
+impl<'input, Endian> DebugRanges<EndianSlice<'input, Endian>>
+where
+    Endian: Endianity,
+{
+    /// Construct a new `DebugRanges` instance from the data in the `.debug_ranges`
+    /// section.
+    ///
+    /// It is the caller's responsibility to read the `.debug_ranges` section and
+    /// present it as a `&[u8]` slice. That means using some ELF loader on
+    /// Linux, a Mach-O loader on macOS, etc.
+    ///
+    /// ```
+    /// use gimli::{DebugRanges, LittleEndian};
+    ///
+    /// # let buf = [0x00, 0x01, 0x02, 0x03];
+    /// # let read_debug_ranges_section_somehow = || &buf;
+    /// let debug_ranges = DebugRanges::new(read_debug_ranges_section_somehow(), LittleEndian);
+    /// ```
+    pub fn new(section: &'input [u8], endian: Endian) -> Self {
+        Self::from(EndianSlice::new(section, endian))
+    }
+}
+
+impl<R> Section<R> for DebugRanges<R> {
+    fn id() -> SectionId {
+        SectionId::DebugRanges
+    }
+
+    fn reader(&self) -> &R {
+        &self.section
+    }
+}
+
+impl<R> From<R> for DebugRanges<R> {
+    fn from(section: R) -> Self {
+        DebugRanges { section }
+    }
+}
+
+/// The `DebugRngLists` struct represents the contents of the
+/// `.debug_rnglists` section.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct DebugRngLists<R> {
+    section: R,
+}
+
+impl<'input, Endian> DebugRngLists<EndianSlice<'input, Endian>>
+where
+    Endian: Endianity,
+{
+    /// Construct a new `DebugRngLists` instance from the data in the
+    /// `.debug_rnglists` section.
+    ///
+    /// It is the caller's responsibility to read the `.debug_rnglists`
+    /// section and present it as a `&[u8]` slice. That means using some ELF
+    /// loader on Linux, a Mach-O loader on macOS, etc.
+    ///
+    /// ```
+    /// use gimli::{DebugRngLists, LittleEndian};
+    ///
+    /// # let buf = [0x00, 0x01, 0x02, 0x03];
+    /// # let read_debug_rnglists_section_somehow = || &buf;
+    /// let debug_rnglists =
+    ///     DebugRngLists::new(read_debug_rnglists_section_somehow(), LittleEndian);
+    /// ```
+    pub fn new(section: &'input [u8], endian: Endian) -> Self {
+        Self::from(EndianSlice::new(section, endian))
+    }
+}
+
+impl<R> Section<R> for DebugRngLists<R> {
+    fn id() -> SectionId {
+        SectionId::DebugRngLists
+    }
+
+    fn reader(&self) -> &R {
+        &self.section
+    }
+}
+
+impl<R> From<R> for DebugRngLists<R> {
+    fn from(section: R) -> Self {
+        DebugRngLists { section }
+    }
+}
+
+#[allow(unused)]
+pub(crate) type RngListsHeader = ListsHeader;
+
+impl<Offset> DebugRngListsBase<Offset>
+where
+    Offset: ReaderOffset,
+{
+    /// Returns a `DebugRngListsBase` with the default value of DW_AT_rnglists_base
+    /// for the given `Encoding` and `DwarfFileType`.
+    pub fn default_for_encoding_and_file(
+        encoding: Encoding,
+        file_type: DwarfFileType,
+    ) -> DebugRngListsBase<Offset> {
+        if encoding.version >= 5 && file_type == DwarfFileType::Dwo {
+            // In .dwo files, the compiler omits the DW_AT_rnglists_base attribute (because there is
+            // only a single unit in the file) but we must skip past the header, which the attribute
+            // would normally do for us.
+            DebugRngListsBase(Offset::from_u8(RngListsHeader::size_for_encoding(encoding)))
+        } else {
+            DebugRngListsBase(Offset::from_u8(0))
+        }
+    }
+}
+
+/// The DWARF data found in `.debug_ranges` and `.debug_rnglists` sections.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct RangeLists<R> {
+    debug_ranges: DebugRanges<R>,
+    debug_rnglists: DebugRngLists<R>,
+}
+
+impl<R> RangeLists<R> {
+    /// Construct a new `RangeLists` instance from the data in the `.debug_ranges` and
+    /// `.debug_rnglists` sections.
+    pub fn new(debug_ranges: DebugRanges<R>, debug_rnglists: DebugRngLists<R>) -> RangeLists<R> {
+        RangeLists {
+            debug_ranges,
+            debug_rnglists,
+        }
+    }
+
+    /// Return the `.debug_ranges` section.
+    pub fn debug_ranges(&self) -> &DebugRanges<R> {
+        &self.debug_ranges
+    }
+
+    /// Replace the `.debug_ranges` section.
+    ///
+    /// This is useful for `.dwo` files when using the GNU split-dwarf extension to DWARF 4.
+    pub fn set_debug_ranges(&mut self, debug_ranges: DebugRanges<R>) {
+        self.debug_ranges = debug_ranges;
+    }
+
+    /// Return the `.debug_rnglists` section.
+    pub fn debug_rnglists(&self) -> &DebugRngLists<R> {
+        &self.debug_rnglists
+    }
+}
+
+impl<T> RangeLists<T> {
+    /// Create a `RangeLists` that references the data in `self`.
+    ///
+    /// This is useful when `R` implements `Reader` but `T` does not.
+    ///
+    /// ## Example Usage
+    ///
+    /// ```rust,no_run
+    /// # let load_section = || unimplemented!();
+    /// // Read the DWARF section into a `Vec` with whatever object loader you're using.
+    /// let owned_section: gimli::RangeLists<Vec<u8>> = load_section();
+    /// // Create a reference to the DWARF section.
+    /// let section = owned_section.borrow(|section| {
+    ///     gimli::EndianSlice::new(&section, gimli::LittleEndian)
+    /// });
+    /// ```
+    pub fn borrow<'a, F, R>(&'a self, mut borrow: F) -> RangeLists<R>
+    where
+        F: FnMut(&'a T) -> R,
+    {
+        RangeLists {
+            debug_ranges: borrow(&self.debug_ranges.section).into(),
+            debug_rnglists: borrow(&self.debug_rnglists.section).into(),
+        }
+    }
+}
+
+impl<R: Reader> RangeLists<R> {
+    /// Iterate over the `Range` list entries starting at the given offset.
+    ///
+    /// The `unit_version` and `address_size` must match the compilation unit that the
+    /// offset was contained in.
+    ///
+    /// The `base_address` should be obtained from the `DW_AT_low_pc` attribute in the
+    /// `DW_TAG_compile_unit` entry for the compilation unit that contains this range list.
+    ///
+    /// Can be [used with
+    /// `FallibleIterator`](./index.html#using-with-fallibleiterator).
+    pub fn ranges(
+        &self,
+        offset: RangeListsOffset<R::Offset>,
+        unit_encoding: Encoding,
+        base_address: u64,
+        debug_addr: &DebugAddr<R>,
+        debug_addr_base: DebugAddrBase<R::Offset>,
+    ) -> Result<RngListIter<R>> {
+        Ok(RngListIter::new(
+            self.raw_ranges(offset, unit_encoding)?,
+            base_address,
+            debug_addr.clone(),
+            debug_addr_base,
+        ))
+    }
+
+    /// Iterate over the `RawRngListEntry`ies starting at the given offset.
+    ///
+    /// The `unit_encoding` must match the compilation unit that the
+    /// offset was contained in.
+    ///
+    /// This iterator does not perform any processing of the range entries,
+    /// such as handling base addresses.
+    ///
+    /// Can be [used with
+    /// `FallibleIterator`](./index.html#using-with-fallibleiterator).
+    pub fn raw_ranges(
+        &self,
+        offset: RangeListsOffset<R::Offset>,
+        unit_encoding: Encoding,
+    ) -> Result<RawRngListIter<R>> {
+        let (mut input, format) = if unit_encoding.version <= 4 {
+            (self.debug_ranges.section.clone(), RangeListsFormat::Bare)
+        } else {
+            (self.debug_rnglists.section.clone(), RangeListsFormat::Rle)
+        };
+        input.skip(offset.0)?;
+        Ok(RawRngListIter::new(input, unit_encoding, format))
+    }
+
+    /// Returns the `.debug_rnglists` offset at the given `base` and `index`.
+    ///
+    /// The `base` must be the `DW_AT_rnglists_base` value from the compilation unit DIE.
+    /// This is an offset that points to the first entry following the header.
+    ///
+    /// The `index` is the value of a `DW_FORM_rnglistx` attribute.
+    ///
+    /// The `unit_encoding` must match the compilation unit that the
+    /// index was contained in.
+    pub fn get_offset(
+        &self,
+        unit_encoding: Encoding,
+        base: DebugRngListsBase<R::Offset>,
+        index: DebugRngListsIndex<R::Offset>,
+    ) -> Result<RangeListsOffset<R::Offset>> {
+        let format = unit_encoding.format;
+        let input = &mut self.debug_rnglists.section.clone();
+        input.skip(base.0)?;
+        input.skip(R::Offset::from_u64(
+            index.0.into_u64() * u64::from(format.word_size()),
+        )?)?;
+        input
+            .read_offset(format)
+            .map(|x| RangeListsOffset(base.0 + x))
+    }
+
+    /// Call `Reader::lookup_offset_id` for each section, and return the first match.
+    pub fn lookup_offset_id(&self, id: ReaderOffsetId) -> Option<(SectionId, R::Offset)> {
+        self.debug_ranges
+            .lookup_offset_id(id)
+            .or_else(|| self.debug_rnglists.lookup_offset_id(id))
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum RangeListsFormat {
+    /// The bare range list format used before DWARF 5.
+    Bare,
+    /// The DW_RLE encoded range list format used in DWARF 5.
+    Rle,
+}
+
+/// A raw iterator over an address range list.
+///
+/// This iterator does not perform any processing of the range entries,
+/// such as handling base addresses.
+#[derive(Debug)]
+pub struct RawRngListIter<R: Reader> {
+    input: R,
+    encoding: Encoding,
+    format: RangeListsFormat,
+}
+
+/// A raw entry in .debug_rnglists
+#[derive(Clone, Debug)]
+pub enum RawRngListEntry<T> {
+    /// A range from DWARF version <= 4.
+    AddressOrOffsetPair {
+        /// Start of range. May be an address or an offset.
+        begin: u64,
+        /// End of range. May be an address or an offset.
+        end: u64,
+    },
+    /// DW_RLE_base_address
+    BaseAddress {
+        /// base address
+        addr: u64,
+    },
+    /// DW_RLE_base_addressx
+    BaseAddressx {
+        /// base address
+        addr: DebugAddrIndex<T>,
+    },
+    /// DW_RLE_startx_endx
+    StartxEndx {
+        /// start of range
+        begin: DebugAddrIndex<T>,
+        /// end of range
+        end: DebugAddrIndex<T>,
+    },
+    /// DW_RLE_startx_length
+    StartxLength {
+        /// start of range
+        begin: DebugAddrIndex<T>,
+        /// length of range
+        length: u64,
+    },
+    /// DW_RLE_offset_pair
+    OffsetPair {
+        /// start of range
+        begin: u64,
+        /// end of range
+        end: u64,
+    },
+    /// DW_RLE_start_end
+    StartEnd {
+        /// start of range
+        begin: u64,
+        /// end of range
+        end: u64,
+    },
+    /// DW_RLE_start_length
+    StartLength {
+        /// start of range
+        begin: u64,
+        /// length of range
+        length: u64,
+    },
+}
+
+impl<T: ReaderOffset> RawRngListEntry<T> {
+    /// Parse a range entry from `.debug_rnglists`
+    fn parse<R: Reader<Offset = T>>(
+        input: &mut R,
+        encoding: Encoding,
+        format: RangeListsFormat,
+    ) -> Result<Option<Self>> {
+        Ok(match format {
+            RangeListsFormat::Bare => {
+                let range = RawRange::parse(input, encoding.address_size)?;
+                if range.is_end() {
+                    None
+                } else if range.is_base_address(encoding.address_size) {
+                    Some(RawRngListEntry::BaseAddress { addr: range.end })
+                } else {
+                    Some(RawRngListEntry::AddressOrOffsetPair {
+                        begin: range.begin,
+                        end: range.end,
+                    })
+                }
+            }
+            RangeListsFormat::Rle => match constants::DwRle(input.read_u8()?) {
+                constants::DW_RLE_end_of_list => None,
+                constants::DW_RLE_base_addressx => Some(RawRngListEntry::BaseAddressx {
+                    addr: DebugAddrIndex(input.read_uleb128().and_then(R::Offset::from_u64)?),
+                }),
+                constants::DW_RLE_startx_endx => Some(RawRngListEntry::StartxEndx {
+                    begin: DebugAddrIndex(input.read_uleb128().and_then(R::Offset::from_u64)?),
+                    end: DebugAddrIndex(input.read_uleb128().and_then(R::Offset::from_u64)?),
+                }),
+                constants::DW_RLE_startx_length => Some(RawRngListEntry::StartxLength {
+                    begin: DebugAddrIndex(input.read_uleb128().and_then(R::Offset::from_u64)?),
+                    length: input.read_uleb128()?,
+                }),
+                constants::DW_RLE_offset_pair => Some(RawRngListEntry::OffsetPair {
+                    begin: input.read_uleb128()?,
+                    end: input.read_uleb128()?,
+                }),
+                constants::DW_RLE_base_address => Some(RawRngListEntry::BaseAddress {
+                    addr: input.read_address(encoding.address_size)?,
+                }),
+                constants::DW_RLE_start_end => Some(RawRngListEntry::StartEnd {
+                    begin: input.read_address(encoding.address_size)?,
+                    end: input.read_address(encoding.address_size)?,
+                }),
+                constants::DW_RLE_start_length => Some(RawRngListEntry::StartLength {
+                    begin: input.read_address(encoding.address_size)?,
+                    length: input.read_uleb128()?,
+                }),
+                _ => {
+                    return Err(Error::InvalidAddressRange);
+                }
+            },
+        })
+    }
+}
+
+impl<R: Reader> RawRngListIter<R> {
+    /// Construct a `RawRngListIter`.
+    fn new(input: R, encoding: Encoding, format: RangeListsFormat) -> RawRngListIter<R> {
+        RawRngListIter {
+            input,
+            encoding,
+            format,
+        }
+    }
+
+    /// Advance the iterator to the next range.
+    pub fn next(&mut self) -> Result<Option<RawRngListEntry<R::Offset>>> {
+        if self.input.is_empty() {
+            return Ok(None);
+        }
+
+        match RawRngListEntry::parse(&mut self.input, self.encoding, self.format) {
+            Ok(range) => {
+                if range.is_none() {
+                    self.input.empty();
+                }
+                Ok(range)
+            }
+            Err(e) => {
+                self.input.empty();
+                Err(e)
+            }
+        }
+    }
+}
+
+#[cfg(feature = "fallible-iterator")]
+impl<R: Reader> fallible_iterator::FallibleIterator for RawRngListIter<R> {
+    type Item = RawRngListEntry<R::Offset>;
+    type Error = Error;
+
+    fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> {
+        RawRngListIter::next(self)
+    }
+}
+
+/// An iterator over an address range list.
+///
+/// This iterator internally handles processing of base addresses and different
+/// entry types.  Thus, it only returns range entries that are valid
+/// and already adjusted for the base address.
+#[derive(Debug)]
+pub struct RngListIter<R: Reader> {
+    raw: RawRngListIter<R>,
+    base_address: u64,
+    debug_addr: DebugAddr<R>,
+    debug_addr_base: DebugAddrBase<R::Offset>,
+}
+
+impl<R: Reader> RngListIter<R> {
+    /// Construct a `RngListIter`.
+    fn new(
+        raw: RawRngListIter<R>,
+        base_address: u64,
+        debug_addr: DebugAddr<R>,
+        debug_addr_base: DebugAddrBase<R::Offset>,
+    ) -> RngListIter<R> {
+        RngListIter {
+            raw,
+            base_address,
+            debug_addr,
+            debug_addr_base,
+        }
+    }
+
+    #[inline]
+    fn get_address(&self, index: DebugAddrIndex<R::Offset>) -> Result<u64> {
+        self.debug_addr
+            .get_address(self.raw.encoding.address_size, self.debug_addr_base, index)
+    }
+
+    /// Advance the iterator to the next range.
+    pub fn next(&mut self) -> Result<Option<Range>> {
+        loop {
+            let raw_range = match self.raw.next()? {
+                Some(range) => range,
+                None => return Ok(None),
+            };
+
+            let range = self.convert_raw(raw_range)?;
+            if range.is_some() {
+                return Ok(range);
+            }
+        }
+    }
+
+    /// Return the next raw range.
+    ///
+    /// The raw range should be passed to `convert_range`.
+    #[doc(hidden)]
+    pub fn next_raw(&mut self) -> Result<Option<RawRngListEntry<R::Offset>>> {
+        self.raw.next()
+    }
+
+    /// Convert a raw range into a range, and update the state of the iterator.
+    ///
+    /// The raw range should have been obtained from `next_raw`.
+    #[doc(hidden)]
+    pub fn convert_raw(&mut self, raw_range: RawRngListEntry<R::Offset>) -> Result<Option<Range>> {
+        let mask = !0 >> (64 - self.raw.encoding.address_size * 8);
+        let tombstone = if self.raw.encoding.version <= 4 {
+            mask - 1
+        } else {
+            mask
+        };
+
+        let range = match raw_range {
+            RawRngListEntry::BaseAddress { addr } => {
+                self.base_address = addr;
+                return Ok(None);
+            }
+            RawRngListEntry::BaseAddressx { addr } => {
+                self.base_address = self.get_address(addr)?;
+                return Ok(None);
+            }
+            RawRngListEntry::StartxEndx { begin, end } => {
+                let begin = self.get_address(begin)?;
+                let end = self.get_address(end)?;
+                Range { begin, end }
+            }
+            RawRngListEntry::StartxLength { begin, length } => {
+                let begin = self.get_address(begin)?;
+                let end = begin.wrapping_add(length) & mask;
+                Range { begin, end }
+            }
+            RawRngListEntry::AddressOrOffsetPair { begin, end }
+            | RawRngListEntry::OffsetPair { begin, end } => {
+                if self.base_address == tombstone {
+                    return Ok(None);
+                }
+                let mut range = Range { begin, end };
+                range.add_base_address(self.base_address, self.raw.encoding.address_size);
+                range
+            }
+            RawRngListEntry::StartEnd { begin, end } => Range { begin, end },
+            RawRngListEntry::StartLength { begin, length } => {
+                let end = begin.wrapping_add(length) & mask;
+                Range { begin, end }
+            }
+        };
+
+        if range.begin == tombstone {
+            return Ok(None);
+        }
+
+        if range.begin > range.end {
+            self.raw.input.empty();
+            return Err(Error::InvalidAddressRange);
+        }
+
+        Ok(Some(range))
+    }
+}
+
+#[cfg(feature = "fallible-iterator")]
+impl<R: Reader> fallible_iterator::FallibleIterator for RngListIter<R> {
+    type Item = Range;
+    type Error = Error;
+
+    fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> {
+        RngListIter::next(self)
+    }
+}
+
+/// A raw address range from the `.debug_ranges` section.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub(crate) struct RawRange {
+    /// The beginning address of the range.
+    pub begin: u64,
+
+    /// The first address past the end of the range.
+    pub end: u64,
+}
+
+impl RawRange {
+    /// Check if this is a range end entry.
+    #[inline]
+    pub fn is_end(&self) -> bool {
+        self.begin == 0 && self.end == 0
+    }
+
+    /// Check if this is a base address selection entry.
+    ///
+    /// A base address selection entry changes the base address that subsequent
+    /// range entries are relative to.
+    #[inline]
+    pub fn is_base_address(&self, address_size: u8) -> bool {
+        self.begin == !0 >> (64 - address_size * 8)
+    }
+
+    /// Parse an address range entry from `.debug_ranges` or `.debug_loc`.
+    #[inline]
+    pub fn parse<R: Reader>(input: &mut R, address_size: u8) -> Result<RawRange> {
+        let begin = input.read_address(address_size)?;
+        let end = input.read_address(address_size)?;
+        let range = RawRange { begin, end };
+        Ok(range)
+    }
+}
+
+/// An address range from the `.debug_ranges`, `.debug_rnglists`, or `.debug_aranges` sections.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct Range {
+    /// The beginning address of the range.
+    pub begin: u64,
+
+    /// The first address past the end of the range.
+    pub end: u64,
+}
+
+impl Range {
+    /// Add a base address to this range.
+    #[inline]
+    pub(crate) fn add_base_address(&mut self, base_address: u64, address_size: u8) {
+        let mask = !0 >> (64 - address_size * 8);
+        self.begin = base_address.wrapping_add(self.begin) & mask;
+        self.end = base_address.wrapping_add(self.end) & mask;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::common::Format;
+    use crate::endianity::LittleEndian;
+    use crate::test_util::GimliSectionMethods;
+    use test_assembler::{Endian, Label, LabelMaker, Section};
+
+    #[test]
+    fn test_rnglists_32() {
+        let tombstone = !0u32;
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 5,
+            address_size: 4,
+        };
+        let section = Section::with_endian(Endian::Little)
+            .L32(0x0300_0000)
+            .L32(0x0301_0300)
+            .L32(0x0301_0400)
+            .L32(0x0301_0500)
+            .L32(tombstone)
+            .L32(0x0301_0600);
+        let buf = section.get_contents().unwrap();
+        let debug_addr = &DebugAddr::from(EndianSlice::new(&buf, LittleEndian));
+        let debug_addr_base = DebugAddrBase(0);
+
+        let start = Label::new();
+        let first = Label::new();
+        let size = Label::new();
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Little)
+            // Header
+            .mark(&start)
+            .L32(&size)
+            .L16(encoding.version)
+            .L8(encoding.address_size)
+            .L8(0)
+            .L32(0)
+            .mark(&first)
+            // An OffsetPair using the unit base address.
+            .L8(4).uleb(0x10200).uleb(0x10300)
+            // A base address selection followed by an OffsetPair.
+            .L8(5).L32(0x0200_0000)
+            .L8(4).uleb(0x10400).uleb(0x10500)
+            // An empty OffsetPair followed by a normal OffsetPair.
+            .L8(4).uleb(0x10600).uleb(0x10600)
+            .L8(4).uleb(0x10800).uleb(0x10900)
+            // A StartEnd
+            .L8(6).L32(0x201_0a00).L32(0x201_0b00)
+            // A StartLength
+            .L8(7).L32(0x201_0c00).uleb(0x100)
+            // An OffsetPair that starts at 0.
+            .L8(4).uleb(0).uleb(1)
+            // An OffsetPair that starts and ends at 0.
+            .L8(4).uleb(0).uleb(0)
+            // An OffsetPair that ends at -1.
+            .L8(5).L32(0)
+            .L8(4).uleb(0).uleb(0xffff_ffff)
+            // A BaseAddressx + OffsetPair
+            .L8(1).uleb(0)
+            .L8(4).uleb(0x10100).uleb(0x10200)
+            // A StartxEndx
+            .L8(2).uleb(1).uleb(2)
+            // A StartxLength
+            .L8(3).uleb(3).uleb(0x100)
+
+            // Tombstone entries, all of which should be ignored.
+            // A BaseAddressx that is a tombstone.
+            .L8(1).uleb(4)
+            .L8(4).uleb(0x11100).uleb(0x11200)
+            // A BaseAddress that is a tombstone.
+            .L8(5).L32(tombstone)
+            .L8(4).uleb(0x11300).uleb(0x11400)
+            // A StartxEndx that is a tombstone.
+            .L8(2).uleb(4).uleb(5)
+            // A StartxLength that is a tombstone.
+            .L8(3).uleb(4).uleb(0x100)
+            // A StartEnd that is a tombstone.
+            .L8(6).L32(tombstone).L32(0x201_1500)
+            // A StartLength that is a tombstone.
+            .L8(7).L32(tombstone).uleb(0x100)
+            // A StartEnd (not ignored)
+            .L8(6).L32(0x201_1600).L32(0x201_1700)
+
+            // A range end.
+            .L8(0)
+            // Some extra data.
+            .L32(0xffff_ffff);
+        size.set_const((&section.here() - &start - 4) as u64);
+
+        let buf = section.get_contents().unwrap();
+        let debug_ranges = DebugRanges::new(&[], LittleEndian);
+        let debug_rnglists = DebugRngLists::new(&buf, LittleEndian);
+        let rnglists = RangeLists::new(debug_ranges, debug_rnglists);
+        let offset = RangeListsOffset((&first - &start) as usize);
+        let mut ranges = rnglists
+            .ranges(offset, encoding, 0x0100_0000, debug_addr, debug_addr_base)
+            .unwrap();
+
+        // A normal range.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0101_0200,
+                end: 0x0101_0300,
+            }))
+        );
+
+        // A base address selection followed by a normal range.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0201_0400,
+                end: 0x0201_0500,
+            }))
+        );
+
+        // An empty range followed by a normal range.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0201_0600,
+                end: 0x0201_0600,
+            }))
+        );
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0201_0800,
+                end: 0x0201_0900,
+            }))
+        );
+
+        // A normal range.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0201_0a00,
+                end: 0x0201_0b00,
+            }))
+        );
+
+        // A normal range.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0201_0c00,
+                end: 0x0201_0d00,
+            }))
+        );
+
+        // A range that starts at 0.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0200_0000,
+                end: 0x0200_0001,
+            }))
+        );
+
+        // A range that starts and ends at 0.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0200_0000,
+                end: 0x0200_0000,
+            }))
+        );
+
+        // A range that ends at -1.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0000_0000,
+                end: 0xffff_ffff,
+            }))
+        );
+
+        // A BaseAddressx + OffsetPair
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0301_0100,
+                end: 0x0301_0200,
+            }))
+        );
+
+        // A StartxEndx
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0301_0300,
+                end: 0x0301_0400,
+            }))
+        );
+
+        // A StartxLength
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0301_0500,
+                end: 0x0301_0600,
+            }))
+        );
+
+        // A StartEnd range following the tombstones
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0201_1600,
+                end: 0x0201_1700,
+            }))
+        );
+
+        // A range end.
+        assert_eq!(ranges.next(), Ok(None));
+
+        // An offset at the end of buf.
+        let mut ranges = rnglists
+            .ranges(
+                RangeListsOffset(buf.len()),
+                encoding,
+                0x0100_0000,
+                debug_addr,
+                debug_addr_base,
+            )
+            .unwrap();
+        assert_eq!(ranges.next(), Ok(None));
+    }
+
+    #[test]
+    fn test_rnglists_64() {
+        let tombstone = !0u64;
+        let encoding = Encoding {
+            format: Format::Dwarf64,
+            version: 5,
+            address_size: 8,
+        };
+        let section = Section::with_endian(Endian::Little)
+            .L64(0x0300_0000)
+            .L64(0x0301_0300)
+            .L64(0x0301_0400)
+            .L64(0x0301_0500)
+            .L64(tombstone)
+            .L64(0x0301_0600);
+        let buf = section.get_contents().unwrap();
+        let debug_addr = &DebugAddr::from(EndianSlice::new(&buf, LittleEndian));
+        let debug_addr_base = DebugAddrBase(0);
+
+        let start = Label::new();
+        let first = Label::new();
+        let size = Label::new();
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Little)
+            // Header
+            .mark(&start)
+            .L32(0xffff_ffff)
+            .L64(&size)
+            .L16(encoding.version)
+            .L8(encoding.address_size)
+            .L8(0)
+            .L32(0)
+            .mark(&first)
+            // An OffsetPair using the unit base address.
+            .L8(4).uleb(0x10200).uleb(0x10300)
+            // A base address selection followed by an OffsetPair.
+            .L8(5).L64(0x0200_0000)
+            .L8(4).uleb(0x10400).uleb(0x10500)
+            // An empty OffsetPair followed by a normal OffsetPair.
+            .L8(4).uleb(0x10600).uleb(0x10600)
+            .L8(4).uleb(0x10800).uleb(0x10900)
+            // A StartEnd
+            .L8(6).L64(0x201_0a00).L64(0x201_0b00)
+            // A StartLength
+            .L8(7).L64(0x201_0c00).uleb(0x100)
+            // An OffsetPair that starts at 0.
+            .L8(4).uleb(0).uleb(1)
+            // An OffsetPair that starts and ends at 0.
+            .L8(4).uleb(0).uleb(0)
+            // An OffsetPair that ends at -1.
+            .L8(5).L64(0)
+            .L8(4).uleb(0).uleb(0xffff_ffff)
+            // A BaseAddressx + OffsetPair
+            .L8(1).uleb(0)
+            .L8(4).uleb(0x10100).uleb(0x10200)
+            // A StartxEndx
+            .L8(2).uleb(1).uleb(2)
+            // A StartxLength
+            .L8(3).uleb(3).uleb(0x100)
+
+            // Tombstone entries, all of which should be ignored.
+            // A BaseAddressx that is a tombstone.
+            .L8(1).uleb(4)
+            .L8(4).uleb(0x11100).uleb(0x11200)
+            // A BaseAddress that is a tombstone.
+            .L8(5).L64(tombstone)
+            .L8(4).uleb(0x11300).uleb(0x11400)
+            // A StartxEndx that is a tombstone.
+            .L8(2).uleb(4).uleb(5)
+            // A StartxLength that is a tombstone.
+            .L8(3).uleb(4).uleb(0x100)
+            // A StartEnd that is a tombstone.
+            .L8(6).L64(tombstone).L64(0x201_1500)
+            // A StartLength that is a tombstone.
+            .L8(7).L64(tombstone).uleb(0x100)
+            // A StartEnd (not ignored)
+            .L8(6).L64(0x201_1600).L64(0x201_1700)
+
+            // A range end.
+            .L8(0)
+            // Some extra data.
+            .L32(0xffff_ffff);
+        size.set_const((&section.here() - &start - 12) as u64);
+
+        let buf = section.get_contents().unwrap();
+        let debug_ranges = DebugRanges::new(&[], LittleEndian);
+        let debug_rnglists = DebugRngLists::new(&buf, LittleEndian);
+        let rnglists = RangeLists::new(debug_ranges, debug_rnglists);
+        let offset = RangeListsOffset((&first - &start) as usize);
+        let mut ranges = rnglists
+            .ranges(offset, encoding, 0x0100_0000, debug_addr, debug_addr_base)
+            .unwrap();
+
+        // A normal range.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0101_0200,
+                end: 0x0101_0300,
+            }))
+        );
+
+        // A base address selection followed by a normal range.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0201_0400,
+                end: 0x0201_0500,
+            }))
+        );
+
+        // An empty range followed by a normal range.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0201_0600,
+                end: 0x0201_0600,
+            }))
+        );
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0201_0800,
+                end: 0x0201_0900,
+            }))
+        );
+
+        // A normal range.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0201_0a00,
+                end: 0x0201_0b00,
+            }))
+        );
+
+        // A normal range.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0201_0c00,
+                end: 0x0201_0d00,
+            }))
+        );
+
+        // A range that starts at 0.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0200_0000,
+                end: 0x0200_0001,
+            }))
+        );
+
+        // A range that starts and ends at 0.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0200_0000,
+                end: 0x0200_0000,
+            }))
+        );
+
+        // A range that ends at -1.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0000_0000,
+                end: 0xffff_ffff,
+            }))
+        );
+
+        // A BaseAddressx + OffsetPair
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0301_0100,
+                end: 0x0301_0200,
+            }))
+        );
+
+        // A StartxEndx
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0301_0300,
+                end: 0x0301_0400,
+            }))
+        );
+
+        // A StartxLength
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0301_0500,
+                end: 0x0301_0600,
+            }))
+        );
+
+        // A StartEnd range following the tombstones
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0201_1600,
+                end: 0x0201_1700,
+            }))
+        );
+
+        // A range end.
+        assert_eq!(ranges.next(), Ok(None));
+
+        // An offset at the end of buf.
+        let mut ranges = rnglists
+            .ranges(
+                RangeListsOffset(buf.len()),
+                encoding,
+                0x0100_0000,
+                debug_addr,
+                debug_addr_base,
+            )
+            .unwrap();
+        assert_eq!(ranges.next(), Ok(None));
+    }
+
+    #[test]
+    fn test_raw_range() {
+        let range = RawRange {
+            begin: 0,
+            end: 0xffff_ffff,
+        };
+        assert!(!range.is_end());
+        assert!(!range.is_base_address(4));
+        assert!(!range.is_base_address(8));
+
+        let range = RawRange { begin: 0, end: 0 };
+        assert!(range.is_end());
+        assert!(!range.is_base_address(4));
+        assert!(!range.is_base_address(8));
+
+        let range = RawRange {
+            begin: 0xffff_ffff,
+            end: 0,
+        };
+        assert!(!range.is_end());
+        assert!(range.is_base_address(4));
+        assert!(!range.is_base_address(8));
+
+        let range = RawRange {
+            begin: 0xffff_ffff_ffff_ffff,
+            end: 0,
+        };
+        assert!(!range.is_end());
+        assert!(!range.is_base_address(4));
+        assert!(range.is_base_address(8));
+    }
+
+    #[test]
+    fn test_ranges_32() {
+        let tombstone = !0u32 - 1;
+        let start = Label::new();
+        let first = Label::new();
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Little)
+            // A range before the offset.
+            .mark(&start)
+            .L32(0x10000).L32(0x10100)
+            .mark(&first)
+            // A normal range.
+            .L32(0x10200).L32(0x10300)
+            // A base address selection followed by a normal range.
+            .L32(0xffff_ffff).L32(0x0200_0000)
+            .L32(0x10400).L32(0x10500)
+            // An empty range followed by a normal range.
+            .L32(0x10600).L32(0x10600)
+            .L32(0x10800).L32(0x10900)
+            // A range that starts at 0.
+            .L32(0).L32(1)
+            // A range that ends at -1.
+            .L32(0xffff_ffff).L32(0x0000_0000)
+            .L32(0).L32(0xffff_ffff)
+            // A normal range with tombstone.
+            .L32(tombstone).L32(tombstone)
+            // A base address selection with tombstone followed by a normal range.
+            .L32(0xffff_ffff).L32(tombstone)
+            .L32(0x10a00).L32(0x10b00)
+            // A range end.
+            .L32(0).L32(0)
+            // Some extra data.
+            .L32(0);
+
+        let buf = section.get_contents().unwrap();
+        let debug_ranges = DebugRanges::new(&buf, LittleEndian);
+        let debug_rnglists = DebugRngLists::new(&[], LittleEndian);
+        let rnglists = RangeLists::new(debug_ranges, debug_rnglists);
+        let offset = RangeListsOffset((&first - &start) as usize);
+        let debug_addr = &DebugAddr::from(EndianSlice::new(&[], LittleEndian));
+        let debug_addr_base = DebugAddrBase(0);
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 4,
+        };
+        let mut ranges = rnglists
+            .ranges(offset, encoding, 0x0100_0000, debug_addr, debug_addr_base)
+            .unwrap();
+
+        // A normal range.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0101_0200,
+                end: 0x0101_0300,
+            }))
+        );
+
+        // A base address selection followed by a normal range.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0201_0400,
+                end: 0x0201_0500,
+            }))
+        );
+
+        // An empty range followed by a normal range.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0201_0600,
+                end: 0x0201_0600,
+            }))
+        );
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0201_0800,
+                end: 0x0201_0900,
+            }))
+        );
+
+        // A range that starts at 0.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0200_0000,
+                end: 0x0200_0001,
+            }))
+        );
+
+        // A range that ends at -1.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0000_0000,
+                end: 0xffff_ffff,
+            }))
+        );
+
+        // A range end.
+        assert_eq!(ranges.next(), Ok(None));
+
+        // An offset at the end of buf.
+        let mut ranges = rnglists
+            .ranges(
+                RangeListsOffset(buf.len()),
+                encoding,
+                0x0100_0000,
+                debug_addr,
+                debug_addr_base,
+            )
+            .unwrap();
+        assert_eq!(ranges.next(), Ok(None));
+    }
+
+    #[test]
+    fn test_ranges_64() {
+        let tombstone = !0u64 - 1;
+        let start = Label::new();
+        let first = Label::new();
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Little)
+            // A range before the offset.
+            .mark(&start)
+            .L64(0x10000).L64(0x10100)
+            .mark(&first)
+            // A normal range.
+            .L64(0x10200).L64(0x10300)
+            // A base address selection followed by a normal range.
+            .L64(0xffff_ffff_ffff_ffff).L64(0x0200_0000)
+            .L64(0x10400).L64(0x10500)
+            // An empty range followed by a normal range.
+            .L64(0x10600).L64(0x10600)
+            .L64(0x10800).L64(0x10900)
+            // A range that starts at 0.
+            .L64(0).L64(1)
+            // A range that ends at -1.
+            .L64(0xffff_ffff_ffff_ffff).L64(0x0000_0000)
+            .L64(0).L64(0xffff_ffff_ffff_ffff)
+            // A normal range with tombstone.
+            .L64(tombstone).L64(tombstone)
+            // A base address selection with tombstone followed by a normal range.
+            .L64(0xffff_ffff_ffff_ffff).L64(tombstone)
+            .L64(0x10a00).L64(0x10b00)
+            // A range end.
+            .L64(0).L64(0)
+            // Some extra data.
+            .L64(0);
+
+        let buf = section.get_contents().unwrap();
+        let debug_ranges = DebugRanges::new(&buf, LittleEndian);
+        let debug_rnglists = DebugRngLists::new(&[], LittleEndian);
+        let rnglists = RangeLists::new(debug_ranges, debug_rnglists);
+        let offset = RangeListsOffset((&first - &start) as usize);
+        let debug_addr = &DebugAddr::from(EndianSlice::new(&[], LittleEndian));
+        let debug_addr_base = DebugAddrBase(0);
+        let encoding = Encoding {
+            format: Format::Dwarf64,
+            version: 4,
+            address_size: 8,
+        };
+        let mut ranges = rnglists
+            .ranges(offset, encoding, 0x0100_0000, debug_addr, debug_addr_base)
+            .unwrap();
+
+        // A normal range.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0101_0200,
+                end: 0x0101_0300,
+            }))
+        );
+
+        // A base address selection followed by a normal range.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0201_0400,
+                end: 0x0201_0500,
+            }))
+        );
+
+        // An empty range followed by a normal range.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0201_0600,
+                end: 0x0201_0600,
+            }))
+        );
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0201_0800,
+                end: 0x0201_0900,
+            }))
+        );
+
+        // A range that starts at 0.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0200_0000,
+                end: 0x0200_0001,
+            }))
+        );
+
+        // A range that ends at -1.
+        assert_eq!(
+            ranges.next(),
+            Ok(Some(Range {
+                begin: 0x0,
+                end: 0xffff_ffff_ffff_ffff,
+            }))
+        );
+
+        // A range end.
+        assert_eq!(ranges.next(), Ok(None));
+
+        // An offset at the end of buf.
+        let mut ranges = rnglists
+            .ranges(
+                RangeListsOffset(buf.len()),
+                encoding,
+                0x0100_0000,
+                debug_addr,
+                debug_addr_base,
+            )
+            .unwrap();
+        assert_eq!(ranges.next(), Ok(None));
+    }
+
+    #[test]
+    fn test_ranges_invalid() {
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Little)
+            // An invalid range.
+            .L32(0x20000).L32(0x10000)
+            // An invalid range after wrapping.
+            .L32(0x20000).L32(0xff01_0000);
+
+        let buf = section.get_contents().unwrap();
+        let debug_ranges = DebugRanges::new(&buf, LittleEndian);
+        let debug_rnglists = DebugRngLists::new(&[], LittleEndian);
+        let rnglists = RangeLists::new(debug_ranges, debug_rnglists);
+        let debug_addr = &DebugAddr::from(EndianSlice::new(&[], LittleEndian));
+        let debug_addr_base = DebugAddrBase(0);
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 4,
+        };
+
+        // An invalid range.
+        let mut ranges = rnglists
+            .ranges(
+                RangeListsOffset(0x0),
+                encoding,
+                0x0100_0000,
+                debug_addr,
+                debug_addr_base,
+            )
+            .unwrap();
+        assert_eq!(ranges.next(), Err(Error::InvalidAddressRange));
+
+        // An invalid range after wrapping.
+        let mut ranges = rnglists
+            .ranges(
+                RangeListsOffset(0x8),
+                encoding,
+                0x0100_0000,
+                debug_addr,
+                debug_addr_base,
+            )
+            .unwrap();
+        assert_eq!(ranges.next(), Err(Error::InvalidAddressRange));
+
+        // An invalid offset.
+        match rnglists.ranges(
+            RangeListsOffset(buf.len() + 1),
+            encoding,
+            0x0100_0000,
+            debug_addr,
+            debug_addr_base,
+        ) {
+            Err(Error::UnexpectedEof(_)) => {}
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        }
+    }
+
+    #[test]
+    fn test_get_offset() {
+        for format in vec![Format::Dwarf32, Format::Dwarf64] {
+            let encoding = Encoding {
+                format,
+                version: 5,
+                address_size: 4,
+            };
+
+            let zero = Label::new();
+            let length = Label::new();
+            let start = Label::new();
+            let first = Label::new();
+            let end = Label::new();
+            let mut section = Section::with_endian(Endian::Little)
+                .mark(&zero)
+                .initial_length(format, &length, &start)
+                .D16(encoding.version)
+                .D8(encoding.address_size)
+                .D8(0)
+                .D32(20)
+                .mark(&first);
+            for i in 0..20 {
+                section = section.word(format.word_size(), 1000 + i);
+            }
+            section = section.mark(&end);
+            length.set_const((&end - &start) as u64);
+            let section = section.get_contents().unwrap();
+
+            let debug_ranges = DebugRanges::from(EndianSlice::new(&[], LittleEndian));
+            let debug_rnglists = DebugRngLists::from(EndianSlice::new(&section, LittleEndian));
+            let ranges = RangeLists::new(debug_ranges, debug_rnglists);
+
+            let base = DebugRngListsBase((&first - &zero) as usize);
+            assert_eq!(
+                ranges.get_offset(encoding, base, DebugRngListsIndex(0)),
+                Ok(RangeListsOffset(base.0 + 1000))
+            );
+            assert_eq!(
+                ranges.get_offset(encoding, base, DebugRngListsIndex(19)),
+                Ok(RangeListsOffset(base.0 + 1019))
+            );
+        }
+    }
+}
diff --git a/vendor/gimli/src/read/str.rs b/vendor/gimli/src/read/str.rs
new file mode 100644
index 0000000..c6b87d8
--- /dev/null
+++ b/vendor/gimli/src/read/str.rs
@@ -0,0 +1,321 @@
+use crate::common::{
+    DebugLineStrOffset, DebugStrOffset, DebugStrOffsetsBase, DebugStrOffsetsIndex, DwarfFileType,
+    Encoding, SectionId,
+};
+use crate::endianity::Endianity;
+use crate::read::{EndianSlice, Reader, ReaderOffset, Result, Section};
+use crate::Format;
+
+/// The `DebugStr` struct represents the DWARF strings
+/// found in the `.debug_str` section.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct DebugStr<R> {
+    debug_str_section: R,
+}
+
+impl<'input, Endian> DebugStr<EndianSlice<'input, Endian>>
+where
+    Endian: Endianity,
+{
+    /// Construct a new `DebugStr` instance from the data in the `.debug_str`
+    /// section.
+    ///
+    /// It is the caller's responsibility to read the `.debug_str` section and
+    /// present it as a `&[u8]` slice. That means using some ELF loader on
+    /// Linux, a Mach-O loader on macOS, etc.
+    ///
+    /// ```
+    /// use gimli::{DebugStr, LittleEndian};
+    ///
+    /// # let buf = [0x00, 0x01, 0x02, 0x03];
+    /// # let read_debug_str_section_somehow = || &buf;
+    /// let debug_str = DebugStr::new(read_debug_str_section_somehow(), LittleEndian);
+    /// ```
+    pub fn new(debug_str_section: &'input [u8], endian: Endian) -> Self {
+        Self::from(EndianSlice::new(debug_str_section, endian))
+    }
+}
+
+impl<R: Reader> DebugStr<R> {
+    /// Lookup a string from the `.debug_str` section by DebugStrOffset.
+    ///
+    /// ```
+    /// use gimli::{DebugStr, DebugStrOffset, LittleEndian};
+    ///
+    /// # let buf = [0x01, 0x02, 0x00];
+    /// # let offset = DebugStrOffset(0);
+    /// # let read_debug_str_section_somehow = || &buf;
+    /// # let debug_str_offset_somehow = || offset;
+    /// let debug_str = DebugStr::new(read_debug_str_section_somehow(), LittleEndian);
+    /// println!("Found string {:?}", debug_str.get_str(debug_str_offset_somehow()));
+    /// ```
+    pub fn get_str(&self, offset: DebugStrOffset<R::Offset>) -> Result<R> {
+        let input = &mut self.debug_str_section.clone();
+        input.skip(offset.0)?;
+        input.read_null_terminated_slice()
+    }
+}
+
+impl<T> DebugStr<T> {
+    /// Create a `DebugStr` section that references the data in `self`.
+    ///
+    /// This is useful when `R` implements `Reader` but `T` does not.
+    ///
+    /// ## Example Usage
+    ///
+    /// ```rust,no_run
+    /// # let load_section = || unimplemented!();
+    /// // Read the DWARF section into a `Vec` with whatever object loader you're using.
+    /// let owned_section: gimli::DebugStr<Vec<u8>> = load_section();
+    /// // Create a reference to the DWARF section.
+    /// let section = owned_section.borrow(|section| {
+    ///     gimli::EndianSlice::new(&section, gimli::LittleEndian)
+    /// });
+    /// ```
+    pub fn borrow<'a, F, R>(&'a self, mut borrow: F) -> DebugStr<R>
+    where
+        F: FnMut(&'a T) -> R,
+    {
+        borrow(&self.debug_str_section).into()
+    }
+}
+
+impl<R> Section<R> for DebugStr<R> {
+    fn id() -> SectionId {
+        SectionId::DebugStr
+    }
+
+    fn reader(&self) -> &R {
+        &self.debug_str_section
+    }
+}
+
+impl<R> From<R> for DebugStr<R> {
+    fn from(debug_str_section: R) -> Self {
+        DebugStr { debug_str_section }
+    }
+}
+
+/// The raw contents of the `.debug_str_offsets` section.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct DebugStrOffsets<R> {
+    section: R,
+}
+
+impl<R: Reader> DebugStrOffsets<R> {
+    // TODO: add an iterator over the sets of entries in the section.
+    // This is not needed for common usage of the section though.
+
+    /// Returns the `.debug_str` offset at the given `base` and `index`.
+    ///
+    /// A set of entries in the `.debug_str_offsets` section consists of a header
+    /// followed by a series of string table offsets.
+    ///
+    /// The `base` must be the `DW_AT_str_offsets_base` value from the compilation unit DIE.
+    /// This is an offset that points to the first entry following the header.
+    ///
+    /// The `index` is the value of a `DW_FORM_strx` attribute.
+    ///
+    /// The `format` must be the DWARF format of the compilation unit. This format must
+    /// match the header. However, note that we do not parse the header to validate this,
+    /// since locating the header is unreliable, and the GNU extensions do not emit it.
+    pub fn get_str_offset(
+        &self,
+        format: Format,
+        base: DebugStrOffsetsBase<R::Offset>,
+        index: DebugStrOffsetsIndex<R::Offset>,
+    ) -> Result<DebugStrOffset<R::Offset>> {
+        let input = &mut self.section.clone();
+        input.skip(base.0)?;
+        input.skip(R::Offset::from_u64(
+            index.0.into_u64() * u64::from(format.word_size()),
+        )?)?;
+        input.read_offset(format).map(DebugStrOffset)
+    }
+}
+
+impl<T> DebugStrOffsets<T> {
+    /// Create a `DebugStrOffsets` section that references the data in `self`.
+    ///
+    /// This is useful when `R` implements `Reader` but `T` does not.
+    ///
+    /// ## Example Usage
+    ///
+    /// ```rust,no_run
+    /// # let load_section = || unimplemented!();
+    /// // Read the DWARF section into a `Vec` with whatever object loader you're using.
+    /// let owned_section: gimli::DebugStrOffsets<Vec<u8>> = load_section();
+    /// // Create a reference to the DWARF section.
+    /// let section = owned_section.borrow(|section| {
+    ///     gimli::EndianSlice::new(&section, gimli::LittleEndian)
+    /// });
+    /// ```
+    pub fn borrow<'a, F, R>(&'a self, mut borrow: F) -> DebugStrOffsets<R>
+    where
+        F: FnMut(&'a T) -> R,
+    {
+        borrow(&self.section).into()
+    }
+}
+
+impl<R> Section<R> for DebugStrOffsets<R> {
+    fn id() -> SectionId {
+        SectionId::DebugStrOffsets
+    }
+
+    fn reader(&self) -> &R {
+        &self.section
+    }
+}
+
+impl<R> From<R> for DebugStrOffsets<R> {
+    fn from(section: R) -> Self {
+        DebugStrOffsets { section }
+    }
+}
+
+impl<Offset> DebugStrOffsetsBase<Offset>
+where
+    Offset: ReaderOffset,
+{
+    /// Returns a `DebugStrOffsetsBase` with the default value of DW_AT_str_offsets_base
+    /// for the given `Encoding` and `DwarfFileType`.
+    pub fn default_for_encoding_and_file(
+        encoding: Encoding,
+        file_type: DwarfFileType,
+    ) -> DebugStrOffsetsBase<Offset> {
+        if encoding.version >= 5 && file_type == DwarfFileType::Dwo {
+            // In .dwo files, the compiler omits the DW_AT_str_offsets_base attribute (because there is
+            // only a single unit in the file) but we must skip past the header, which the attribute
+            // would normally do for us.
+            // initial_length_size + version + 2 bytes of padding.
+            DebugStrOffsetsBase(Offset::from_u8(
+                encoding.format.initial_length_size() + 2 + 2,
+            ))
+        } else {
+            DebugStrOffsetsBase(Offset::from_u8(0))
+        }
+    }
+}
+
+/// The `DebugLineStr` struct represents the DWARF strings
+/// found in the `.debug_line_str` section.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct DebugLineStr<R> {
+    section: R,
+}
+
+impl<'input, Endian> DebugLineStr<EndianSlice<'input, Endian>>
+where
+    Endian: Endianity,
+{
+    /// Construct a new `DebugLineStr` instance from the data in the `.debug_line_str`
+    /// section.
+    ///
+    /// It is the caller's responsibility to read the `.debug_line_str` section and
+    /// present it as a `&[u8]` slice. That means using some ELF loader on
+    /// Linux, a Mach-O loader on macOS, etc.
+    ///
+    /// ```
+    /// use gimli::{DebugLineStr, LittleEndian};
+    ///
+    /// # let buf = [0x00, 0x01, 0x02, 0x03];
+    /// # let read_debug_line_str_section_somehow = || &buf;
+    /// let debug_str = DebugLineStr::new(read_debug_line_str_section_somehow(), LittleEndian);
+    /// ```
+    pub fn new(debug_line_str_section: &'input [u8], endian: Endian) -> Self {
+        Self::from(EndianSlice::new(debug_line_str_section, endian))
+    }
+}
+
+impl<R: Reader> DebugLineStr<R> {
+    /// Lookup a string from the `.debug_line_str` section by DebugLineStrOffset.
+    pub fn get_str(&self, offset: DebugLineStrOffset<R::Offset>) -> Result<R> {
+        let input = &mut self.section.clone();
+        input.skip(offset.0)?;
+        input.read_null_terminated_slice()
+    }
+}
+
+impl<T> DebugLineStr<T> {
+    /// Create a `DebugLineStr` section that references the data in `self`.
+    ///
+    /// This is useful when `R` implements `Reader` but `T` does not.
+    ///
+    /// ## Example Usage
+    ///
+    /// ```rust,no_run
+    /// # let load_section = || unimplemented!();
+    /// // Read the DWARF section into a `Vec` with whatever object loader you're using.
+    /// let owned_section: gimli::DebugLineStr<Vec<u8>> = load_section();
+    /// // Create a reference to the DWARF section.
+    /// let section = owned_section.borrow(|section| {
+    ///     gimli::EndianSlice::new(&section, gimli::LittleEndian)
+    /// });
+    /// ```
+    pub fn borrow<'a, F, R>(&'a self, mut borrow: F) -> DebugLineStr<R>
+    where
+        F: FnMut(&'a T) -> R,
+    {
+        borrow(&self.section).into()
+    }
+}
+
+impl<R> Section<R> for DebugLineStr<R> {
+    fn id() -> SectionId {
+        SectionId::DebugLineStr
+    }
+
+    fn reader(&self) -> &R {
+        &self.section
+    }
+}
+
+impl<R> From<R> for DebugLineStr<R> {
+    fn from(section: R) -> Self {
+        DebugLineStr { section }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_util::GimliSectionMethods;
+    use crate::LittleEndian;
+    use test_assembler::{Endian, Label, LabelMaker, Section};
+
+    #[test]
+    fn test_get_str_offset() {
+        for format in vec![Format::Dwarf32, Format::Dwarf64] {
+            let zero = Label::new();
+            let length = Label::new();
+            let start = Label::new();
+            let first = Label::new();
+            let end = Label::new();
+            let mut section = Section::with_endian(Endian::Little)
+                .mark(&zero)
+                .initial_length(format, &length, &start)
+                .D16(5)
+                .D16(0)
+                .mark(&first);
+            for i in 0..20 {
+                section = section.word(format.word_size(), 1000 + i);
+            }
+            section = section.mark(&end);
+            length.set_const((&end - &start) as u64);
+
+            let section = section.get_contents().unwrap();
+            let debug_str_offsets = DebugStrOffsets::from(EndianSlice::new(&section, LittleEndian));
+            let base = DebugStrOffsetsBase((&first - &zero) as usize);
+
+            assert_eq!(
+                debug_str_offsets.get_str_offset(format, base, DebugStrOffsetsIndex(0)),
+                Ok(DebugStrOffset(1000))
+            );
+            assert_eq!(
+                debug_str_offsets.get_str_offset(format, base, DebugStrOffsetsIndex(19)),
+                Ok(DebugStrOffset(1019))
+            );
+        }
+    }
+}
diff --git a/vendor/gimli/src/read/unit.rs b/vendor/gimli/src/read/unit.rs
new file mode 100644
index 0000000..d799f0f
--- /dev/null
+++ b/vendor/gimli/src/read/unit.rs
@@ -0,0 +1,6139 @@
+//! Functions for parsing DWARF `.debug_info` and `.debug_types` sections.
+
+use core::cell::Cell;
+use core::ops::{Range, RangeFrom, RangeTo};
+use core::{u16, u8};
+
+use crate::common::{
+    DebugAbbrevOffset, DebugAddrBase, DebugAddrIndex, DebugInfoOffset, DebugLineOffset,
+    DebugLineStrOffset, DebugLocListsBase, DebugLocListsIndex, DebugMacinfoOffset,
+    DebugMacroOffset, DebugRngListsBase, DebugRngListsIndex, DebugStrOffset, DebugStrOffsetsBase,
+    DebugStrOffsetsIndex, DebugTypeSignature, DebugTypesOffset, DwoId, Encoding, Format,
+    LocationListsOffset, RawRangeListsOffset, SectionId, UnitSectionOffset,
+};
+use crate::constants;
+use crate::endianity::Endianity;
+use crate::read::abbrev::get_attribute_size;
+use crate::read::{
+    Abbreviation, Abbreviations, AttributeSpecification, DebugAbbrev, DebugStr, EndianSlice, Error,
+    Expression, Reader, ReaderOffset, Result, Section, UnitOffset,
+};
+
+impl<T: ReaderOffset> DebugTypesOffset<T> {
+    /// Convert an offset to be relative to the start of the given unit,
+    /// instead of relative to the start of the .debug_types section.
+    /// Returns `None` if the offset is not within the unit entries.
+    pub fn to_unit_offset<R>(&self, unit: &UnitHeader<R>) -> Option<UnitOffset<T>>
+    where
+        R: Reader<Offset = T>,
+    {
+        let unit_offset = unit.offset().as_debug_types_offset()?;
+        let offset = UnitOffset(self.0.checked_sub(unit_offset.0)?);
+        if !unit.is_valid_offset(offset) {
+            return None;
+        }
+        Some(offset)
+    }
+}
+
+impl<T: ReaderOffset> DebugInfoOffset<T> {
+    /// Convert an offset to be relative to the start of the given unit,
+    /// instead of relative to the start of the .debug_info section.
+    /// Returns `None` if the offset is not within this unit entries.
+    pub fn to_unit_offset<R>(&self, unit: &UnitHeader<R>) -> Option<UnitOffset<T>>
+    where
+        R: Reader<Offset = T>,
+    {
+        let unit_offset = unit.offset().as_debug_info_offset()?;
+        let offset = UnitOffset(self.0.checked_sub(unit_offset.0)?);
+        if !unit.is_valid_offset(offset) {
+            return None;
+        }
+        Some(offset)
+    }
+}
+
+impl<T: ReaderOffset> UnitOffset<T> {
+    /// Convert an offset to be relative to the start of the .debug_info section,
+    /// instead of relative to the start of the given unit. Returns None if the
+    /// provided unit lives in the .debug_types section.
+    pub fn to_debug_info_offset<R>(&self, unit: &UnitHeader<R>) -> Option<DebugInfoOffset<T>>
+    where
+        R: Reader<Offset = T>,
+    {
+        let unit_offset = unit.offset().as_debug_info_offset()?;
+        Some(DebugInfoOffset(unit_offset.0 + self.0))
+    }
+
+    /// Convert an offset to be relative to the start of the .debug_types section,
+    /// instead of relative to the start of the given unit. Returns None if the
+    /// provided unit lives in the .debug_info section.
+    pub fn to_debug_types_offset<R>(&self, unit: &UnitHeader<R>) -> Option<DebugTypesOffset<T>>
+    where
+        R: Reader<Offset = T>,
+    {
+        let unit_offset = unit.offset().as_debug_types_offset()?;
+        Some(DebugTypesOffset(unit_offset.0 + self.0))
+    }
+}
+
+/// The `DebugInfo` struct represents the DWARF debugging information found in
+/// the `.debug_info` section.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct DebugInfo<R> {
+    debug_info_section: R,
+}
+
+impl<'input, Endian> DebugInfo<EndianSlice<'input, Endian>>
+where
+    Endian: Endianity,
+{
+    /// Construct a new `DebugInfo` instance from the data in the `.debug_info`
+    /// section.
+    ///
+    /// It is the caller's responsibility to read the `.debug_info` section and
+    /// present it as a `&[u8]` slice. That means using some ELF loader on
+    /// Linux, a Mach-O loader on macOS, etc.
+    ///
+    /// ```
+    /// use gimli::{DebugInfo, LittleEndian};
+    ///
+    /// # let buf = [0x00, 0x01, 0x02, 0x03];
+    /// # let read_debug_info_section_somehow = || &buf;
+    /// let debug_info = DebugInfo::new(read_debug_info_section_somehow(), LittleEndian);
+    /// ```
+    pub fn new(debug_info_section: &'input [u8], endian: Endian) -> Self {
+        Self::from(EndianSlice::new(debug_info_section, endian))
+    }
+}
+
+impl<R: Reader> DebugInfo<R> {
+    /// Iterate the units in this `.debug_info` section.
+    ///
+    /// ```
+    /// use gimli::{DebugInfo, LittleEndian};
+    ///
+    /// # let buf = [];
+    /// # let read_debug_info_section_somehow = || &buf;
+    /// let debug_info = DebugInfo::new(read_debug_info_section_somehow(), LittleEndian);
+    ///
+    /// let mut iter = debug_info.units();
+    /// while let Some(unit) = iter.next().unwrap() {
+    ///     println!("unit's length is {}", unit.unit_length());
+    /// }
+    /// ```
+    ///
+    /// Can be [used with
+    /// `FallibleIterator`](./index.html#using-with-fallibleiterator).
+    pub fn units(&self) -> DebugInfoUnitHeadersIter<R> {
+        DebugInfoUnitHeadersIter {
+            input: self.debug_info_section.clone(),
+            offset: DebugInfoOffset(R::Offset::from_u8(0)),
+        }
+    }
+
+    /// Get the UnitHeader located at offset from this .debug_info section.
+    ///
+    ///
+    pub fn header_from_offset(&self, offset: DebugInfoOffset<R::Offset>) -> Result<UnitHeader<R>> {
+        let input = &mut self.debug_info_section.clone();
+        input.skip(offset.0)?;
+        parse_unit_header(input, offset.into())
+    }
+}
+
+impl<T> DebugInfo<T> {
+    /// Create a `DebugInfo` section that references the data in `self`.
+    ///
+    /// This is useful when `R` implements `Reader` but `T` does not.
+    ///
+    /// ## Example Usage
+    ///
+    /// ```rust,no_run
+    /// # let load_section = || unimplemented!();
+    /// // Read the DWARF section into a `Vec` with whatever object loader you're using.
+    /// let owned_section: gimli::DebugInfo<Vec<u8>> = load_section();
+    /// // Create a reference to the DWARF section.
+    /// let section = owned_section.borrow(|section| {
+    ///     gimli::EndianSlice::new(&section, gimli::LittleEndian)
+    /// });
+    /// ```
+    pub fn borrow<'a, F, R>(&'a self, mut borrow: F) -> DebugInfo<R>
+    where
+        F: FnMut(&'a T) -> R,
+    {
+        borrow(&self.debug_info_section).into()
+    }
+}
+
+impl<R> Section<R> for DebugInfo<R> {
+    fn id() -> SectionId {
+        SectionId::DebugInfo
+    }
+
+    fn reader(&self) -> &R {
+        &self.debug_info_section
+    }
+}
+
+impl<R> From<R> for DebugInfo<R> {
+    fn from(debug_info_section: R) -> Self {
+        DebugInfo { debug_info_section }
+    }
+}
+
+/// An iterator over the units of a .debug_info section.
+///
+/// See the [documentation on
+/// `DebugInfo::units`](./struct.DebugInfo.html#method.units) for more detail.
+#[derive(Clone, Debug)]
+pub struct DebugInfoUnitHeadersIter<R: Reader> {
+    input: R,
+    offset: DebugInfoOffset<R::Offset>,
+}
+
+impl<R: Reader> DebugInfoUnitHeadersIter<R> {
+    /// Advance the iterator to the next unit header.
+    pub fn next(&mut self) -> Result<Option<UnitHeader<R>>> {
+        if self.input.is_empty() {
+            Ok(None)
+        } else {
+            let len = self.input.len();
+            match parse_unit_header(&mut self.input, self.offset.into()) {
+                Ok(header) => {
+                    self.offset.0 += len - self.input.len();
+                    Ok(Some(header))
+                }
+                Err(e) => {
+                    self.input.empty();
+                    Err(e)
+                }
+            }
+        }
+    }
+}
+
+#[cfg(feature = "fallible-iterator")]
+impl<R: Reader> fallible_iterator::FallibleIterator for DebugInfoUnitHeadersIter<R> {
+    type Item = UnitHeader<R>;
+    type Error = Error;
+
+    fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> {
+        DebugInfoUnitHeadersIter::next(self)
+    }
+}
+
+/// Parse the unit type from the unit header.
+fn parse_unit_type<R: Reader>(input: &mut R) -> Result<constants::DwUt> {
+    let val = input.read_u8()?;
+    Ok(constants::DwUt(val))
+}
+
+/// Parse the `debug_abbrev_offset` in the compilation unit header.
+fn parse_debug_abbrev_offset<R: Reader>(
+    input: &mut R,
+    format: Format,
+) -> Result<DebugAbbrevOffset<R::Offset>> {
+    input.read_offset(format).map(DebugAbbrevOffset)
+}
+
+/// Parse the `debug_info_offset` in the arange header.
+pub(crate) fn parse_debug_info_offset<R: Reader>(
+    input: &mut R,
+    format: Format,
+) -> Result<DebugInfoOffset<R::Offset>> {
+    input.read_offset(format).map(DebugInfoOffset)
+}
+
+/// This enum specifies the type of the unit and any type
+/// specific data carried in the header (e.g. the type
+/// signature/type offset of a type unit).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum UnitType<Offset>
+where
+    Offset: ReaderOffset,
+{
+    /// In DWARF5, a unit with type `DW_UT_compile`. In previous DWARF versions,
+    /// any unit appearing in the .debug_info section.
+    Compilation,
+    /// In DWARF5, a unit with type `DW_UT_type`. In DWARF4, any unit appearing
+    /// in the .debug_types section.
+    Type {
+        /// The unique type signature for this type unit.
+        type_signature: DebugTypeSignature,
+        /// The offset within this type unit where the type is defined.
+        type_offset: UnitOffset<Offset>,
+    },
+    /// A unit with type `DW_UT_partial`. The root DIE of this unit should be a
+    /// `DW_TAG_partial_unit`.
+    Partial,
+    /// A unit with type `DW_UT_skeleton`. The enclosed dwo_id can be used to
+    /// link this with the corresponding `SplitCompilation` unit in a dwo file.
+    /// NB: The non-standard GNU split DWARF extension to DWARF 4 will instead
+    /// be a `Compilation` unit with the dwo_id present as an attribute on the
+    /// root DIE.
+    Skeleton(DwoId),
+    /// A unit with type `DW_UT_split_compile`. The enclosed dwo_id can be used to
+    /// link this with the corresponding `Skeleton` unit in the original binary.
+    /// NB: The non-standard GNU split DWARF extension to DWARF 4 will instead
+    /// be a `Compilation` unit with the dwo_id present as an attribute on the
+    /// root DIE.
+    SplitCompilation(DwoId),
+    /// A unit with type `DW_UT_split_type`. A split type unit is identical to a
+    /// conventional type unit except for the section in which it appears.
+    SplitType {
+        /// The unique type signature for this type unit.
+        type_signature: DebugTypeSignature,
+        /// The offset within this type unit where the type is defined.
+        type_offset: UnitOffset<Offset>,
+    },
+}
+
+impl<Offset> UnitType<Offset>
+where
+    Offset: ReaderOffset,
+{
+    // TODO: This will be used by the DWARF writing code once it
+    // supports unit types other than simple compilation units.
+    #[allow(unused)]
+    pub(crate) fn dw_ut(&self) -> constants::DwUt {
+        match self {
+            UnitType::Compilation => constants::DW_UT_compile,
+            UnitType::Type { .. } => constants::DW_UT_type,
+            UnitType::Partial => constants::DW_UT_partial,
+            UnitType::Skeleton(_) => constants::DW_UT_skeleton,
+            UnitType::SplitCompilation(_) => constants::DW_UT_split_compile,
+            UnitType::SplitType { .. } => constants::DW_UT_split_type,
+        }
+    }
+}
+
+/// The common fields for the headers of compilation units and
+/// type units.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct UnitHeader<R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    encoding: Encoding,
+    unit_length: Offset,
+    unit_type: UnitType<Offset>,
+    debug_abbrev_offset: DebugAbbrevOffset<Offset>,
+    unit_offset: UnitSectionOffset<Offset>,
+    entries_buf: R,
+}
+
+/// Static methods.
+impl<R, Offset> UnitHeader<R, Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    /// Construct a new `UnitHeader`.
+    pub fn new(
+        encoding: Encoding,
+        unit_length: Offset,
+        unit_type: UnitType<Offset>,
+        debug_abbrev_offset: DebugAbbrevOffset<Offset>,
+        unit_offset: UnitSectionOffset<Offset>,
+        entries_buf: R,
+    ) -> Self {
+        UnitHeader {
+            encoding,
+            unit_length,
+            unit_type,
+            debug_abbrev_offset,
+            unit_offset,
+            entries_buf,
+        }
+    }
+}
+
+/// Instance methods.
+impl<R, Offset> UnitHeader<R, Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    /// Get the offset of this unit within its section.
+    pub fn offset(&self) -> UnitSectionOffset<Offset> {
+        self.unit_offset
+    }
+
+    /// Return the serialized size of the common unit header for the given
+    /// DWARF format.
+    pub fn size_of_header(&self) -> usize {
+        let unit_length_size = self.encoding.format.initial_length_size() as usize;
+        let version_size = 2;
+        let debug_abbrev_offset_size = self.encoding.format.word_size() as usize;
+        let address_size_size = 1;
+        let unit_type_size = if self.encoding.version == 5 { 1 } else { 0 };
+        let type_specific_size = match self.unit_type {
+            UnitType::Compilation | UnitType::Partial => 0,
+            UnitType::Type { .. } | UnitType::SplitType { .. } => {
+                let type_signature_size = 8;
+                let type_offset_size = self.encoding.format.word_size() as usize;
+                type_signature_size + type_offset_size
+            }
+            UnitType::Skeleton(_) | UnitType::SplitCompilation(_) => 8,
+        };
+
+        unit_length_size
+            + version_size
+            + debug_abbrev_offset_size
+            + address_size_size
+            + unit_type_size
+            + type_specific_size
+    }
+
+    /// Get the length of the debugging info for this compilation unit, not
+    /// including the byte length of the encoded length itself.
+    pub fn unit_length(&self) -> Offset {
+        self.unit_length
+    }
+
+    /// Get the length of the debugging info for this compilation unit,
+    /// including the byte length of the encoded length itself.
+    pub fn length_including_self(&self) -> Offset {
+        Offset::from_u8(self.format().initial_length_size()) + self.unit_length
+    }
+
+    /// Return the encoding parameters for this unit.
+    pub fn encoding(&self) -> Encoding {
+        self.encoding
+    }
+
+    /// Get the DWARF version of the debugging info for this compilation unit.
+    pub fn version(&self) -> u16 {
+        self.encoding.version
+    }
+
+    /// Get the UnitType of this unit.
+    pub fn type_(&self) -> UnitType<Offset> {
+        self.unit_type
+    }
+
+    /// The offset into the `.debug_abbrev` section for this compilation unit's
+    /// debugging information entries' abbreviations.
+    pub fn debug_abbrev_offset(&self) -> DebugAbbrevOffset<Offset> {
+        self.debug_abbrev_offset
+    }
+
+    /// The size of addresses (in bytes) in this compilation unit.
+    pub fn address_size(&self) -> u8 {
+        self.encoding.address_size
+    }
+
+    /// Whether this compilation unit is encoded in 64- or 32-bit DWARF.
+    pub fn format(&self) -> Format {
+        self.encoding.format
+    }
+
+    /// The serialized size of the header for this compilation unit.
+    pub fn header_size(&self) -> Offset {
+        self.length_including_self() - self.entries_buf.len()
+    }
+
+    pub(crate) fn is_valid_offset(&self, offset: UnitOffset<Offset>) -> bool {
+        let size_of_header = self.header_size();
+        if offset.0 < size_of_header {
+            return false;
+        }
+
+        let relative_to_entries_buf = offset.0 - size_of_header;
+        relative_to_entries_buf < self.entries_buf.len()
+    }
+
+    /// Get the underlying bytes for the supplied range.
+    pub fn range(&self, idx: Range<UnitOffset<Offset>>) -> Result<R> {
+        if !self.is_valid_offset(idx.start) {
+            return Err(Error::OffsetOutOfBounds);
+        }
+        if !self.is_valid_offset(idx.end) {
+            return Err(Error::OffsetOutOfBounds);
+        }
+        assert!(idx.start <= idx.end);
+        let size_of_header = self.header_size();
+        let start = idx.start.0 - size_of_header;
+        let end = idx.end.0 - size_of_header;
+        let mut input = self.entries_buf.clone();
+        input.skip(start)?;
+        input.truncate(end - start)?;
+        Ok(input)
+    }
+
+    /// Get the underlying bytes for the supplied range.
+    pub fn range_from(&self, idx: RangeFrom<UnitOffset<Offset>>) -> Result<R> {
+        if !self.is_valid_offset(idx.start) {
+            return Err(Error::OffsetOutOfBounds);
+        }
+        let start = idx.start.0 - self.header_size();
+        let mut input = self.entries_buf.clone();
+        input.skip(start)?;
+        Ok(input)
+    }
+
+    /// Get the underlying bytes for the supplied range.
+    pub fn range_to(&self, idx: RangeTo<UnitOffset<Offset>>) -> Result<R> {
+        if !self.is_valid_offset(idx.end) {
+            return Err(Error::OffsetOutOfBounds);
+        }
+        let end = idx.end.0 - self.header_size();
+        let mut input = self.entries_buf.clone();
+        input.truncate(end)?;
+        Ok(input)
+    }
+
+    /// Read the `DebuggingInformationEntry` at the given offset.
+    pub fn entry<'me, 'abbrev>(
+        &'me self,
+        abbreviations: &'abbrev Abbreviations,
+        offset: UnitOffset<Offset>,
+    ) -> Result<DebuggingInformationEntry<'abbrev, 'me, R>> {
+        let mut input = self.range_from(offset..)?;
+        let entry = DebuggingInformationEntry::parse(&mut input, self, abbreviations)?;
+        entry.ok_or(Error::NoEntryAtGivenOffset)
+    }
+
+    /// Navigate this unit's `DebuggingInformationEntry`s.
+    pub fn entries<'me, 'abbrev>(
+        &'me self,
+        abbreviations: &'abbrev Abbreviations,
+    ) -> EntriesCursor<'abbrev, 'me, R> {
+        EntriesCursor {
+            unit: self,
+            input: self.entries_buf.clone(),
+            abbreviations,
+            cached_current: None,
+            delta_depth: 0,
+        }
+    }
+
+    /// Navigate this compilation unit's `DebuggingInformationEntry`s
+    /// starting at the given offset.
+    pub fn entries_at_offset<'me, 'abbrev>(
+        &'me self,
+        abbreviations: &'abbrev Abbreviations,
+        offset: UnitOffset<Offset>,
+    ) -> Result<EntriesCursor<'abbrev, 'me, R>> {
+        let input = self.range_from(offset..)?;
+        Ok(EntriesCursor {
+            unit: self,
+            input,
+            abbreviations,
+            cached_current: None,
+            delta_depth: 0,
+        })
+    }
+
+    /// Navigate this unit's `DebuggingInformationEntry`s as a tree
+    /// starting at the given offset.
+    pub fn entries_tree<'me, 'abbrev>(
+        &'me self,
+        abbreviations: &'abbrev Abbreviations,
+        offset: Option<UnitOffset<Offset>>,
+    ) -> Result<EntriesTree<'abbrev, 'me, R>> {
+        let input = match offset {
+            Some(offset) => self.range_from(offset..)?,
+            None => self.entries_buf.clone(),
+        };
+        Ok(EntriesTree::new(input, self, abbreviations))
+    }
+
+    /// Read the raw data that defines the Debugging Information Entries.
+    pub fn entries_raw<'me, 'abbrev>(
+        &'me self,
+        abbreviations: &'abbrev Abbreviations,
+        offset: Option<UnitOffset<Offset>>,
+    ) -> Result<EntriesRaw<'abbrev, 'me, R>> {
+        let input = match offset {
+            Some(offset) => self.range_from(offset..)?,
+            None => self.entries_buf.clone(),
+        };
+        Ok(EntriesRaw {
+            input,
+            unit: self,
+            abbreviations,
+            depth: 0,
+        })
+    }
+
+    /// Parse this unit's abbreviations.
+    pub fn abbreviations(&self, debug_abbrev: &DebugAbbrev<R>) -> Result<Abbreviations> {
+        debug_abbrev.abbreviations(self.debug_abbrev_offset())
+    }
+}
+
+/// Parse a unit header.
+fn parse_unit_header<R, Offset>(
+    input: &mut R,
+    unit_offset: UnitSectionOffset<Offset>,
+) -> Result<UnitHeader<R>>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    let (unit_length, format) = input.read_initial_length()?;
+    let mut rest = input.split(unit_length)?;
+
+    let version = rest.read_u16()?;
+    let abbrev_offset;
+    let address_size;
+    let unit_type;
+    // DWARF 1 was very different, and is obsolete, so isn't supported by this
+    // reader.
+    if 2 <= version && version <= 4 {
+        abbrev_offset = parse_debug_abbrev_offset(&mut rest, format)?;
+        address_size = rest.read_u8()?;
+        // Before DWARF5, all units in the .debug_info section are compilation
+        // units, and all units in the .debug_types section are type units.
+        unit_type = match unit_offset {
+            UnitSectionOffset::DebugInfoOffset(_) => constants::DW_UT_compile,
+            UnitSectionOffset::DebugTypesOffset(_) => constants::DW_UT_type,
+        };
+    } else if version == 5 {
+        unit_type = parse_unit_type(&mut rest)?;
+        address_size = rest.read_u8()?;
+        abbrev_offset = parse_debug_abbrev_offset(&mut rest, format)?;
+    } else {
+        return Err(Error::UnknownVersion(u64::from(version)));
+    }
+    let encoding = Encoding {
+        format,
+        version,
+        address_size,
+    };
+
+    // Parse any data specific to this type of unit.
+    let unit_type = match unit_type {
+        constants::DW_UT_compile => UnitType::Compilation,
+        constants::DW_UT_type => {
+            let type_signature = parse_type_signature(&mut rest)?;
+            let type_offset = parse_type_offset(&mut rest, format)?;
+            UnitType::Type {
+                type_signature,
+                type_offset,
+            }
+        }
+        constants::DW_UT_partial => UnitType::Partial,
+        constants::DW_UT_skeleton => {
+            let dwo_id = parse_dwo_id(&mut rest)?;
+            UnitType::Skeleton(dwo_id)
+        }
+        constants::DW_UT_split_compile => {
+            let dwo_id = parse_dwo_id(&mut rest)?;
+            UnitType::SplitCompilation(dwo_id)
+        }
+        constants::DW_UT_split_type => {
+            let type_signature = parse_type_signature(&mut rest)?;
+            let type_offset = parse_type_offset(&mut rest, format)?;
+            UnitType::SplitType {
+                type_signature,
+                type_offset,
+            }
+        }
+        _ => return Err(Error::UnsupportedUnitType),
+    };
+
+    Ok(UnitHeader::new(
+        encoding,
+        unit_length,
+        unit_type,
+        abbrev_offset,
+        unit_offset,
+        rest,
+    ))
+}
+
+/// Parse a dwo_id from a header
+fn parse_dwo_id<R: Reader>(input: &mut R) -> Result<DwoId> {
+    Ok(DwoId(input.read_u64()?))
+}
+
+/// A Debugging Information Entry (DIE).
+///
+/// DIEs have a set of attributes and optionally have children DIEs as well.
+#[derive(Clone, Debug)]
+pub struct DebuggingInformationEntry<'abbrev, 'unit, R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    offset: UnitOffset<Offset>,
+    attrs_slice: R,
+    attrs_len: Cell<Option<Offset>>,
+    abbrev: &'abbrev Abbreviation,
+    unit: &'unit UnitHeader<R, Offset>,
+}
+
+impl<'abbrev, 'unit, R, Offset> DebuggingInformationEntry<'abbrev, 'unit, R, Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    /// Construct a new `DebuggingInformationEntry`.
+    pub fn new(
+        offset: UnitOffset<Offset>,
+        attrs_slice: R,
+        abbrev: &'abbrev Abbreviation,
+        unit: &'unit UnitHeader<R, Offset>,
+    ) -> Self {
+        DebuggingInformationEntry {
+            offset,
+            attrs_slice,
+            attrs_len: Cell::new(None),
+            abbrev,
+            unit,
+        }
+    }
+
+    /// Get this entry's code.
+    pub fn code(&self) -> u64 {
+        self.abbrev.code()
+    }
+
+    /// Get this entry's offset.
+    pub fn offset(&self) -> UnitOffset<Offset> {
+        self.offset
+    }
+
+    /// Get this entry's `DW_TAG_whatever` tag.
+    ///
+    /// ```
+    /// # use gimli::{DebugAbbrev, DebugInfo, LittleEndian};
+    /// # let info_buf = [
+    /// #     // Comilation unit header
+    /// #
+    /// #     // 32-bit unit length = 12
+    /// #     0x0c, 0x00, 0x00, 0x00,
+    /// #     // Version 4
+    /// #     0x04, 0x00,
+    /// #     // debug_abbrev_offset
+    /// #     0x00, 0x00, 0x00, 0x00,
+    /// #     // Address size
+    /// #     0x04,
+    /// #
+    /// #     // DIEs
+    /// #
+    /// #     // Abbreviation code
+    /// #     0x01,
+    /// #     // Attribute of form DW_FORM_string = "foo\0"
+    /// #     0x66, 0x6f, 0x6f, 0x00,
+    /// # ];
+    /// # let debug_info = DebugInfo::new(&info_buf, LittleEndian);
+    /// # let abbrev_buf = [
+    /// #     // Code
+    /// #     0x01,
+    /// #     // DW_TAG_subprogram
+    /// #     0x2e,
+    /// #     // DW_CHILDREN_no
+    /// #     0x00,
+    /// #     // Begin attributes
+    /// #       // Attribute name = DW_AT_name
+    /// #       0x03,
+    /// #       // Attribute form = DW_FORM_string
+    /// #       0x08,
+    /// #     // End attributes
+    /// #     0x00,
+    /// #     0x00,
+    /// #     // Null terminator
+    /// #     0x00
+    /// # ];
+    /// # let debug_abbrev = DebugAbbrev::new(&abbrev_buf, LittleEndian);
+    /// # let unit = debug_info.units().next().unwrap().unwrap();
+    /// # let abbrevs = unit.abbreviations(&debug_abbrev).unwrap();
+    /// # let mut cursor = unit.entries(&abbrevs);
+    /// # let (_, entry) = cursor.next_dfs().unwrap().unwrap();
+    /// # let mut get_some_entry = || entry;
+    /// let entry = get_some_entry();
+    ///
+    /// match entry.tag() {
+    ///     gimli::DW_TAG_subprogram =>
+    ///         println!("this entry contains debug info about a function"),
+    ///     gimli::DW_TAG_inlined_subroutine =>
+    ///         println!("this entry contains debug info about a particular instance of inlining"),
+    ///     gimli::DW_TAG_variable =>
+    ///         println!("this entry contains debug info about a local variable"),
+    ///     gimli::DW_TAG_formal_parameter =>
+    ///         println!("this entry contains debug info about a function parameter"),
+    ///     otherwise =>
+    ///         println!("this entry is some other kind of data: {:?}", otherwise),
+    /// };
+    /// ```
+    pub fn tag(&self) -> constants::DwTag {
+        self.abbrev.tag()
+    }
+
+    /// Return true if this entry's type can have children, false otherwise.
+    pub fn has_children(&self) -> bool {
+        self.abbrev.has_children()
+    }
+
+    /// Iterate over this entry's set of attributes.
+    ///
+    /// ```
+    /// use gimli::{DebugAbbrev, DebugInfo, LittleEndian};
+    ///
+    /// // Read the `.debug_info` section.
+    ///
+    /// # let info_buf = [
+    /// #     // Comilation unit header
+    /// #
+    /// #     // 32-bit unit length = 12
+    /// #     0x0c, 0x00, 0x00, 0x00,
+    /// #     // Version 4
+    /// #     0x04, 0x00,
+    /// #     // debug_abbrev_offset
+    /// #     0x00, 0x00, 0x00, 0x00,
+    /// #     // Address size
+    /// #     0x04,
+    /// #
+    /// #     // DIEs
+    /// #
+    /// #     // Abbreviation code
+    /// #     0x01,
+    /// #     // Attribute of form DW_FORM_string = "foo\0"
+    /// #     0x66, 0x6f, 0x6f, 0x00,
+    /// # ];
+    /// # let read_debug_info_section_somehow = || &info_buf;
+    /// let debug_info = DebugInfo::new(read_debug_info_section_somehow(), LittleEndian);
+    ///
+    /// // Get the data about the first compilation unit out of the `.debug_info`.
+    ///
+    /// let unit = debug_info.units().next()
+    ///     .expect("Should have at least one compilation unit")
+    ///     .expect("and it should parse ok");
+    ///
+    /// // Read the `.debug_abbrev` section and parse the
+    /// // abbreviations for our compilation unit.
+    ///
+    /// # let abbrev_buf = [
+    /// #     // Code
+    /// #     0x01,
+    /// #     // DW_TAG_subprogram
+    /// #     0x2e,
+    /// #     // DW_CHILDREN_no
+    /// #     0x00,
+    /// #     // Begin attributes
+    /// #       // Attribute name = DW_AT_name
+    /// #       0x03,
+    /// #       // Attribute form = DW_FORM_string
+    /// #       0x08,
+    /// #     // End attributes
+    /// #     0x00,
+    /// #     0x00,
+    /// #     // Null terminator
+    /// #     0x00
+    /// # ];
+    /// # let read_debug_abbrev_section_somehow = || &abbrev_buf;
+    /// let debug_abbrev = DebugAbbrev::new(read_debug_abbrev_section_somehow(), LittleEndian);
+    /// let abbrevs = unit.abbreviations(&debug_abbrev).unwrap();
+    ///
+    /// // Get the first entry from that compilation unit.
+    ///
+    /// let mut cursor = unit.entries(&abbrevs);
+    /// let (_, entry) = cursor.next_dfs()
+    ///     .expect("Should parse next entry")
+    ///     .expect("Should have at least one entry");
+    ///
+    /// // Finally, print the first entry's attributes.
+    ///
+    /// let mut attrs = entry.attrs();
+    /// while let Some(attr) = attrs.next().unwrap() {
+    ///     println!("Attribute name = {:?}", attr.name());
+    ///     println!("Attribute value = {:?}", attr.value());
+    /// }
+    /// ```
+    ///
+    /// Can be [used with
+    /// `FallibleIterator`](./index.html#using-with-fallibleiterator).
+    pub fn attrs<'me>(&'me self) -> AttrsIter<'abbrev, 'me, 'unit, R> {
+        AttrsIter {
+            input: self.attrs_slice.clone(),
+            attributes: self.abbrev.attributes(),
+            entry: self,
+        }
+    }
+
+    /// Find the first attribute in this entry which has the given name,
+    /// and return it. Returns `Ok(None)` if no attribute is found.
+    pub fn attr(&self, name: constants::DwAt) -> Result<Option<Attribute<R>>> {
+        let mut attrs = self.attrs();
+        while let Some(attr) = attrs.next()? {
+            if attr.name() == name {
+                return Ok(Some(attr));
+            }
+        }
+        Ok(None)
+    }
+
+    /// Find the first attribute in this entry which has the given name,
+    /// and return its raw value. Returns `Ok(None)` if no attribute is found.
+    pub fn attr_value_raw(&self, name: constants::DwAt) -> Result<Option<AttributeValue<R>>> {
+        self.attr(name)
+            .map(|attr| attr.map(|attr| attr.raw_value()))
+    }
+
+    /// Find the first attribute in this entry which has the given name,
+    /// and return its normalized value.  Returns `Ok(None)` if no
+    /// attribute is found.
+    pub fn attr_value(&self, name: constants::DwAt) -> Result<Option<AttributeValue<R>>> {
+        self.attr(name).map(|attr| attr.map(|attr| attr.value()))
+    }
+
+    /// Return the input buffer after the last attribute.
+    #[inline(always)]
+    fn after_attrs(&self) -> Result<R> {
+        if let Some(attrs_len) = self.attrs_len.get() {
+            let mut input = self.attrs_slice.clone();
+            input.skip(attrs_len)?;
+            Ok(input)
+        } else {
+            let mut attrs = self.attrs();
+            while attrs.next()?.is_some() {}
+            Ok(attrs.input)
+        }
+    }
+
+    /// Use the `DW_AT_sibling` attribute to find the input buffer for the
+    /// next sibling. Returns `None` if the attribute is missing or invalid.
+    fn sibling(&self) -> Option<R> {
+        let attr = self.attr_value(constants::DW_AT_sibling);
+        if let Ok(Some(AttributeValue::UnitRef(offset))) = attr {
+            if offset.0 > self.offset.0 {
+                if let Ok(input) = self.unit.range_from(offset..) {
+                    return Some(input);
+                }
+            }
+        }
+        None
+    }
+
+    /// Parse an entry. Returns `Ok(None)` for null entries.
+    #[inline(always)]
+    fn parse(
+        input: &mut R,
+        unit: &'unit UnitHeader<R>,
+        abbreviations: &'abbrev Abbreviations,
+    ) -> Result<Option<Self>> {
+        let offset = unit.header_size() + input.offset_from(&unit.entries_buf);
+        let code = input.read_uleb128()?;
+        if code == 0 {
+            return Ok(None);
+        };
+        let abbrev = abbreviations.get(code).ok_or(Error::UnknownAbbreviation)?;
+        Ok(Some(DebuggingInformationEntry {
+            offset: UnitOffset(offset),
+            attrs_slice: input.clone(),
+            attrs_len: Cell::new(None),
+            abbrev,
+            unit,
+        }))
+    }
+}
+
+/// The value of an attribute in a `DebuggingInformationEntry`.
+//
+// Set the discriminant size so that all variants use the same alignment
+// for their data.  This gives better code generation in `parse_attribute`.
+#[repr(u64)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum AttributeValue<R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    /// "Refers to some location in the address space of the described program."
+    Addr(u64),
+
+    /// A slice of an arbitrary number of bytes.
+    Block(R),
+
+    /// A one byte constant data value. How to interpret the byte depends on context.
+    ///
+    /// From section 7 of the standard: "Depending on context, it may be a
+    /// signed integer, an unsigned integer, a floating-point constant, or
+    /// anything else."
+    Data1(u8),
+
+    /// A two byte constant data value. How to interpret the bytes depends on context.
+    ///
+    /// These bytes have been converted from `R::Endian`. This may need to be reversed
+    /// if this was not required.
+    ///
+    /// From section 7 of the standard: "Depending on context, it may be a
+    /// signed integer, an unsigned integer, a floating-point constant, or
+    /// anything else."
+    Data2(u16),
+
+    /// A four byte constant data value. How to interpret the bytes depends on context.
+    ///
+    /// These bytes have been converted from `R::Endian`. This may need to be reversed
+    /// if this was not required.
+    ///
+    /// From section 7 of the standard: "Depending on context, it may be a
+    /// signed integer, an unsigned integer, a floating-point constant, or
+    /// anything else."
+    Data4(u32),
+
+    /// An eight byte constant data value. How to interpret the bytes depends on context.
+    ///
+    /// These bytes have been converted from `R::Endian`. This may need to be reversed
+    /// if this was not required.
+    ///
+    /// From section 7 of the standard: "Depending on context, it may be a
+    /// signed integer, an unsigned integer, a floating-point constant, or
+    /// anything else."
+    Data8(u64),
+
+    /// A signed integer constant.
+    Sdata(i64),
+
+    /// An unsigned integer constant.
+    Udata(u64),
+
+    /// "The information bytes contain a DWARF expression (see Section 2.5) or
+    /// location description (see Section 2.6)."
+    Exprloc(Expression<R>),
+
+    /// A boolean that indicates presence or absence of the attribute.
+    Flag(bool),
+
+    /// An offset into another section. Which section this is an offset into
+    /// depends on context.
+    SecOffset(Offset),
+
+    /// An offset to a set of addresses in the `.debug_addr` section.
+    DebugAddrBase(DebugAddrBase<Offset>),
+
+    /// An index into a set of addresses in the `.debug_addr` section.
+    DebugAddrIndex(DebugAddrIndex<Offset>),
+
+    /// An offset into the current compilation unit.
+    UnitRef(UnitOffset<Offset>),
+
+    /// An offset into the current `.debug_info` section, but possibly a
+    /// different compilation unit from the current one.
+    DebugInfoRef(DebugInfoOffset<Offset>),
+
+    /// An offset into the `.debug_info` section of the supplementary object file.
+    DebugInfoRefSup(DebugInfoOffset<Offset>),
+
+    /// An offset into the `.debug_line` section.
+    DebugLineRef(DebugLineOffset<Offset>),
+
+    /// An offset into either the `.debug_loc` section or the `.debug_loclists` section.
+    LocationListsRef(LocationListsOffset<Offset>),
+
+    /// An offset to a set of offsets in the `.debug_loclists` section.
+    DebugLocListsBase(DebugLocListsBase<Offset>),
+
+    /// An index into a set of offsets in the `.debug_loclists` section.
+    DebugLocListsIndex(DebugLocListsIndex<Offset>),
+
+    /// An offset into the `.debug_macinfo` section.
+    DebugMacinfoRef(DebugMacinfoOffset<Offset>),
+
+    /// An offset into the `.debug_macro` section.
+    DebugMacroRef(DebugMacroOffset<Offset>),
+
+    /// An offset into the `.debug_ranges` section.
+    RangeListsRef(RawRangeListsOffset<Offset>),
+
+    /// An offset to a set of offsets in the `.debug_rnglists` section.
+    DebugRngListsBase(DebugRngListsBase<Offset>),
+
+    /// An index into a set of offsets in the `.debug_rnglists` section.
+    DebugRngListsIndex(DebugRngListsIndex<Offset>),
+
+    /// A type signature.
+    DebugTypesRef(DebugTypeSignature),
+
+    /// An offset into the `.debug_str` section.
+    DebugStrRef(DebugStrOffset<Offset>),
+
+    /// An offset into the `.debug_str` section of the supplementary object file.
+    DebugStrRefSup(DebugStrOffset<Offset>),
+
+    /// An offset to a set of entries in the `.debug_str_offsets` section.
+    DebugStrOffsetsBase(DebugStrOffsetsBase<Offset>),
+
+    /// An index into a set of entries in the `.debug_str_offsets` section.
+    DebugStrOffsetsIndex(DebugStrOffsetsIndex<Offset>),
+
+    /// An offset into the `.debug_line_str` section.
+    DebugLineStrRef(DebugLineStrOffset<Offset>),
+
+    /// A slice of bytes representing a string. Does not include a final null byte.
+    /// Not guaranteed to be UTF-8 or anything like that.
+    String(R),
+
+    /// The value of a `DW_AT_encoding` attribute.
+    Encoding(constants::DwAte),
+
+    /// The value of a `DW_AT_decimal_sign` attribute.
+    DecimalSign(constants::DwDs),
+
+    /// The value of a `DW_AT_endianity` attribute.
+    Endianity(constants::DwEnd),
+
+    /// The value of a `DW_AT_accessibility` attribute.
+    Accessibility(constants::DwAccess),
+
+    /// The value of a `DW_AT_visibility` attribute.
+    Visibility(constants::DwVis),
+
+    /// The value of a `DW_AT_virtuality` attribute.
+    Virtuality(constants::DwVirtuality),
+
+    /// The value of a `DW_AT_language` attribute.
+    Language(constants::DwLang),
+
+    /// The value of a `DW_AT_address_class` attribute.
+    AddressClass(constants::DwAddr),
+
+    /// The value of a `DW_AT_identifier_case` attribute.
+    IdentifierCase(constants::DwId),
+
+    /// The value of a `DW_AT_calling_convention` attribute.
+    CallingConvention(constants::DwCc),
+
+    /// The value of a `DW_AT_inline` attribute.
+    Inline(constants::DwInl),
+
+    /// The value of a `DW_AT_ordering` attribute.
+    Ordering(constants::DwOrd),
+
+    /// An index into the filename entries from the line number information
+    /// table for the compilation unit containing this value.
+    FileIndex(u64),
+
+    /// An implementation-defined identifier uniquely identifying a compilation
+    /// unit.
+    DwoId(DwoId),
+}
+
+/// An attribute in a `DebuggingInformationEntry`, consisting of a name and
+/// associated value.
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct Attribute<R: Reader> {
+    name: constants::DwAt,
+    value: AttributeValue<R>,
+}
+
+impl<R: Reader> Attribute<R> {
+    /// Get this attribute's name.
+    pub fn name(&self) -> constants::DwAt {
+        self.name
+    }
+
+    /// Get this attribute's raw value.
+    pub fn raw_value(&self) -> AttributeValue<R> {
+        self.value.clone()
+    }
+
+    /// Get this attribute's normalized value.
+    ///
+    /// Attribute values can potentially be encoded in multiple equivalent forms,
+    /// and may have special meaning depending on the attribute name.  This method
+    /// converts the attribute value to a normalized form based on the attribute
+    /// name.
+    ///
+    /// See "Table 7.5: Attribute encodings" and "Table 7.6: Attribute form encodings".
+    pub fn value(&self) -> AttributeValue<R> {
+        // Table 7.5 shows the possible attribute classes for each name.
+        // Table 7.6 shows the possible attribute classes for each form.
+        // For each attribute name, we need to match on the form, and
+        // convert it to one of the classes that is allowed for both
+        // the name and the form.
+        //
+        // The individual class conversions rarely vary for each name,
+        // so for each class conversion we define a macro that matches
+        // on the allowed forms for that class.
+        //
+        // For some classes, we don't need to do any conversion, so their
+        // macro is empty.  In the future we may want to fill them in to
+        // provide strict checking of the forms for each class.  For now,
+        // they simply provide a way to document the allowed classes for
+        // each name.
+
+        // DW_FORM_addr
+        // DW_FORM_addrx
+        // DW_FORM_addrx1
+        // DW_FORM_addrx2
+        // DW_FORM_addrx3
+        // DW_FORM_addrx4
+        macro_rules! address {
+            () => {};
+        }
+        // DW_FORM_sec_offset
+        macro_rules! addrptr {
+            () => {
+                if let Some(offset) = self.offset_value() {
+                    return AttributeValue::DebugAddrBase(DebugAddrBase(offset));
+                }
+            };
+        }
+        // DW_FORM_block
+        // DW_FORM_block1
+        // DW_FORM_block2
+        // DW_FORM_block4
+        macro_rules! block {
+            () => {};
+        }
+        // DW_FORM_sdata
+        // DW_FORM_udata
+        // DW_FORM_data1
+        // DW_FORM_data2
+        // DW_FORM_data4
+        // DW_FORM_data8
+        // DW_FORM_data16
+        // DW_FORM_implicit_const
+        macro_rules! constant {
+            ($value:ident, $variant:ident) => {
+                if let Some(value) = self.$value() {
+                    return AttributeValue::$variant(value);
+                }
+            };
+            ($value:ident, $variant:ident, $constant:ident) => {
+                if let Some(value) = self.$value() {
+                    return AttributeValue::$variant(constants::$constant(value));
+                }
+            };
+        }
+        // DW_FORM_exprloc
+        macro_rules! exprloc {
+            () => {
+                if let Some(value) = self.exprloc_value() {
+                    return AttributeValue::Exprloc(value);
+                }
+            };
+        }
+        // DW_FORM_flag
+        // DW_FORM_flag_present
+        macro_rules! flag {
+            () => {};
+        }
+        // DW_FORM_sec_offset
+        macro_rules! lineptr {
+            () => {
+                if let Some(offset) = self.offset_value() {
+                    return AttributeValue::DebugLineRef(DebugLineOffset(offset));
+                }
+            };
+        }
+        // This also covers `loclist` in DWARF version 5.
+        // DW_FORM_sec_offset
+        // DW_FORM_loclistx
+        macro_rules! loclistptr {
+            () => {
+                // DebugLocListsIndex is also an allowed form in DWARF version 5.
+                if let Some(offset) = self.offset_value() {
+                    return AttributeValue::LocationListsRef(LocationListsOffset(offset));
+                }
+            };
+        }
+        // DW_FORM_sec_offset
+        macro_rules! loclistsptr {
+            () => {
+                if let Some(offset) = self.offset_value() {
+                    return AttributeValue::DebugLocListsBase(DebugLocListsBase(offset));
+                }
+            };
+        }
+        // DWARF version <= 4.
+        // DW_FORM_sec_offset
+        macro_rules! macinfoptr {
+            () => {
+                if let Some(offset) = self.offset_value() {
+                    return AttributeValue::DebugMacinfoRef(DebugMacinfoOffset(offset));
+                }
+            };
+        }
+        // DWARF version >= 5.
+        // DW_FORM_sec_offset
+        macro_rules! macroptr {
+            () => {
+                if let Some(offset) = self.offset_value() {
+                    return AttributeValue::DebugMacroRef(DebugMacroOffset(offset));
+                }
+            };
+        }
+        // DW_FORM_ref_addr
+        // DW_FORM_ref1
+        // DW_FORM_ref2
+        // DW_FORM_ref4
+        // DW_FORM_ref8
+        // DW_FORM_ref_udata
+        // DW_FORM_ref_sig8
+        // DW_FORM_ref_sup4
+        // DW_FORM_ref_sup8
+        macro_rules! reference {
+            () => {};
+        }
+        // This also covers `rnglist` in DWARF version 5.
+        // DW_FORM_sec_offset
+        // DW_FORM_rnglistx
+        macro_rules! rangelistptr {
+            () => {
+                // DebugRngListsIndex is also an allowed form in DWARF version 5.
+                if let Some(offset) = self.offset_value() {
+                    return AttributeValue::RangeListsRef(RawRangeListsOffset(offset));
+                }
+            };
+        }
+        // DW_FORM_sec_offset
+        macro_rules! rnglistsptr {
+            () => {
+                if let Some(offset) = self.offset_value() {
+                    return AttributeValue::DebugRngListsBase(DebugRngListsBase(offset));
+                }
+            };
+        }
+        // DW_FORM_string
+        // DW_FORM_strp
+        // DW_FORM_strx
+        // DW_FORM_strx1
+        // DW_FORM_strx2
+        // DW_FORM_strx3
+        // DW_FORM_strx4
+        // DW_FORM_strp_sup
+        // DW_FORM_line_strp
+        macro_rules! string {
+            () => {};
+        }
+        // DW_FORM_sec_offset
+        macro_rules! stroffsetsptr {
+            () => {
+                if let Some(offset) = self.offset_value() {
+                    return AttributeValue::DebugStrOffsetsBase(DebugStrOffsetsBase(offset));
+                }
+            };
+        }
+        // This isn't a separate form but it's useful to distinguish it from a generic udata.
+        macro_rules! dwoid {
+            () => {
+                if let Some(value) = self.udata_value() {
+                    return AttributeValue::DwoId(DwoId(value));
+                }
+            };
+        }
+
+        // Perform the allowed class conversions for each attribute name.
+        match self.name {
+            constants::DW_AT_sibling => {
+                reference!();
+            }
+            constants::DW_AT_location => {
+                exprloc!();
+                loclistptr!();
+            }
+            constants::DW_AT_name => {
+                string!();
+            }
+            constants::DW_AT_ordering => {
+                constant!(u8_value, Ordering, DwOrd);
+            }
+            constants::DW_AT_byte_size
+            | constants::DW_AT_bit_offset
+            | constants::DW_AT_bit_size => {
+                constant!(udata_value, Udata);
+                exprloc!();
+                reference!();
+            }
+            constants::DW_AT_stmt_list => {
+                lineptr!();
+            }
+            constants::DW_AT_low_pc => {
+                address!();
+            }
+            constants::DW_AT_high_pc => {
+                address!();
+                constant!(udata_value, Udata);
+            }
+            constants::DW_AT_language => {
+                constant!(u16_value, Language, DwLang);
+            }
+            constants::DW_AT_discr => {
+                reference!();
+            }
+            constants::DW_AT_discr_value => {
+                // constant: depends on type of DW_TAG_variant_part,
+                // so caller must normalize.
+            }
+            constants::DW_AT_visibility => {
+                constant!(u8_value, Visibility, DwVis);
+            }
+            constants::DW_AT_import => {
+                reference!();
+            }
+            constants::DW_AT_string_length => {
+                exprloc!();
+                loclistptr!();
+                reference!();
+            }
+            constants::DW_AT_common_reference => {
+                reference!();
+            }
+            constants::DW_AT_comp_dir => {
+                string!();
+            }
+            constants::DW_AT_const_value => {
+                // TODO: constant: sign depends on DW_AT_type.
+                block!();
+                string!();
+            }
+            constants::DW_AT_containing_type => {
+                reference!();
+            }
+            constants::DW_AT_default_value => {
+                // TODO: constant: sign depends on DW_AT_type.
+                reference!();
+                flag!();
+            }
+            constants::DW_AT_inline => {
+                constant!(u8_value, Inline, DwInl);
+            }
+            constants::DW_AT_is_optional => {
+                flag!();
+            }
+            constants::DW_AT_lower_bound => {
+                // TODO: constant: sign depends on DW_AT_type.
+                exprloc!();
+                reference!();
+            }
+            constants::DW_AT_producer => {
+                string!();
+            }
+            constants::DW_AT_prototyped => {
+                flag!();
+            }
+            constants::DW_AT_return_addr => {
+                exprloc!();
+                loclistptr!();
+            }
+            constants::DW_AT_start_scope => {
+                // TODO: constant
+                rangelistptr!();
+            }
+            constants::DW_AT_bit_stride => {
+                constant!(udata_value, Udata);
+                exprloc!();
+                reference!();
+            }
+            constants::DW_AT_upper_bound => {
+                // TODO: constant: sign depends on DW_AT_type.
+                exprloc!();
+                reference!();
+            }
+            constants::DW_AT_abstract_origin => {
+                reference!();
+            }
+            constants::DW_AT_accessibility => {
+                constant!(u8_value, Accessibility, DwAccess);
+            }
+            constants::DW_AT_address_class => {
+                constant!(udata_value, AddressClass, DwAddr);
+            }
+            constants::DW_AT_artificial => {
+                flag!();
+            }
+            constants::DW_AT_base_types => {
+                reference!();
+            }
+            constants::DW_AT_calling_convention => {
+                constant!(u8_value, CallingConvention, DwCc);
+            }
+            constants::DW_AT_count => {
+                // TODO: constant
+                exprloc!();
+                reference!();
+            }
+            constants::DW_AT_data_member_location => {
+                // Constants must be handled before loclistptr so that DW_FORM_data4/8
+                // are correctly interpreted for DWARF version 4+.
+                constant!(udata_value, Udata);
+                exprloc!();
+                loclistptr!();
+            }
+            constants::DW_AT_decl_column => {
+                constant!(udata_value, Udata);
+            }
+            constants::DW_AT_decl_file => {
+                constant!(udata_value, FileIndex);
+            }
+            constants::DW_AT_decl_line => {
+                constant!(udata_value, Udata);
+            }
+            constants::DW_AT_declaration => {
+                flag!();
+            }
+            constants::DW_AT_discr_list => {
+                block!();
+            }
+            constants::DW_AT_encoding => {
+                constant!(u8_value, Encoding, DwAte);
+            }
+            constants::DW_AT_external => {
+                flag!();
+            }
+            constants::DW_AT_frame_base => {
+                exprloc!();
+                loclistptr!();
+            }
+            constants::DW_AT_friend => {
+                reference!();
+            }
+            constants::DW_AT_identifier_case => {
+                constant!(u8_value, IdentifierCase, DwId);
+            }
+            constants::DW_AT_macro_info => {
+                macinfoptr!();
+            }
+            constants::DW_AT_namelist_item => {
+                reference!();
+            }
+            constants::DW_AT_priority => {
+                reference!();
+            }
+            constants::DW_AT_segment => {
+                exprloc!();
+                loclistptr!();
+            }
+            constants::DW_AT_specification => {
+                reference!();
+            }
+            constants::DW_AT_static_link => {
+                exprloc!();
+                loclistptr!();
+            }
+            constants::DW_AT_type => {
+                reference!();
+            }
+            constants::DW_AT_use_location => {
+                exprloc!();
+                loclistptr!();
+            }
+            constants::DW_AT_variable_parameter => {
+                flag!();
+            }
+            constants::DW_AT_virtuality => {
+                constant!(u8_value, Virtuality, DwVirtuality);
+            }
+            constants::DW_AT_vtable_elem_location => {
+                exprloc!();
+                loclistptr!();
+            }
+            constants::DW_AT_allocated => {
+                // TODO: constant
+                exprloc!();
+                reference!();
+            }
+            constants::DW_AT_associated => {
+                // TODO: constant
+                exprloc!();
+                reference!();
+            }
+            constants::DW_AT_data_location => {
+                exprloc!();
+            }
+            constants::DW_AT_byte_stride => {
+                constant!(udata_value, Udata);
+                exprloc!();
+                reference!();
+            }
+            constants::DW_AT_entry_pc => {
+                // TODO: constant
+                address!();
+            }
+            constants::DW_AT_use_UTF8 => {
+                flag!();
+            }
+            constants::DW_AT_extension => {
+                reference!();
+            }
+            constants::DW_AT_ranges => {
+                rangelistptr!();
+            }
+            constants::DW_AT_trampoline => {
+                address!();
+                flag!();
+                reference!();
+                string!();
+            }
+            constants::DW_AT_call_column => {
+                constant!(udata_value, Udata);
+            }
+            constants::DW_AT_call_file => {
+                constant!(udata_value, FileIndex);
+            }
+            constants::DW_AT_call_line => {
+                constant!(udata_value, Udata);
+            }
+            constants::DW_AT_description => {
+                string!();
+            }
+            constants::DW_AT_binary_scale => {
+                // TODO: constant
+            }
+            constants::DW_AT_decimal_scale => {
+                // TODO: constant
+            }
+            constants::DW_AT_small => {
+                reference!();
+            }
+            constants::DW_AT_decimal_sign => {
+                constant!(u8_value, DecimalSign, DwDs);
+            }
+            constants::DW_AT_digit_count => {
+                // TODO: constant
+            }
+            constants::DW_AT_picture_string => {
+                string!();
+            }
+            constants::DW_AT_mutable => {
+                flag!();
+            }
+            constants::DW_AT_threads_scaled => {
+                flag!();
+            }
+            constants::DW_AT_explicit => {
+                flag!();
+            }
+            constants::DW_AT_object_pointer => {
+                reference!();
+            }
+            constants::DW_AT_endianity => {
+                constant!(u8_value, Endianity, DwEnd);
+            }
+            constants::DW_AT_elemental => {
+                flag!();
+            }
+            constants::DW_AT_pure => {
+                flag!();
+            }
+            constants::DW_AT_recursive => {
+                flag!();
+            }
+            constants::DW_AT_signature => {
+                reference!();
+            }
+            constants::DW_AT_main_subprogram => {
+                flag!();
+            }
+            constants::DW_AT_data_bit_offset => {
+                // TODO: constant
+            }
+            constants::DW_AT_const_expr => {
+                flag!();
+            }
+            constants::DW_AT_enum_class => {
+                flag!();
+            }
+            constants::DW_AT_linkage_name => {
+                string!();
+            }
+            constants::DW_AT_string_length_bit_size => {
+                // TODO: constant
+            }
+            constants::DW_AT_string_length_byte_size => {
+                // TODO: constant
+            }
+            constants::DW_AT_rank => {
+                // TODO: constant
+                exprloc!();
+            }
+            constants::DW_AT_str_offsets_base => {
+                stroffsetsptr!();
+            }
+            constants::DW_AT_addr_base | constants::DW_AT_GNU_addr_base => {
+                addrptr!();
+            }
+            constants::DW_AT_rnglists_base | constants::DW_AT_GNU_ranges_base => {
+                rnglistsptr!();
+            }
+            constants::DW_AT_dwo_name => {
+                string!();
+            }
+            constants::DW_AT_reference => {
+                flag!();
+            }
+            constants::DW_AT_rvalue_reference => {
+                flag!();
+            }
+            constants::DW_AT_macros => {
+                macroptr!();
+            }
+            constants::DW_AT_call_all_calls => {
+                flag!();
+            }
+            constants::DW_AT_call_all_source_calls => {
+                flag!();
+            }
+            constants::DW_AT_call_all_tail_calls => {
+                flag!();
+            }
+            constants::DW_AT_call_return_pc => {
+                address!();
+            }
+            constants::DW_AT_call_value => {
+                exprloc!();
+            }
+            constants::DW_AT_call_origin => {
+                exprloc!();
+            }
+            constants::DW_AT_call_parameter => {
+                reference!();
+            }
+            constants::DW_AT_call_pc => {
+                address!();
+            }
+            constants::DW_AT_call_tail_call => {
+                flag!();
+            }
+            constants::DW_AT_call_target => {
+                exprloc!();
+            }
+            constants::DW_AT_call_target_clobbered => {
+                exprloc!();
+            }
+            constants::DW_AT_call_data_location => {
+                exprloc!();
+            }
+            constants::DW_AT_call_data_value => {
+                exprloc!();
+            }
+            constants::DW_AT_noreturn => {
+                flag!();
+            }
+            constants::DW_AT_alignment => {
+                // TODO: constant
+            }
+            constants::DW_AT_export_symbols => {
+                flag!();
+            }
+            constants::DW_AT_deleted => {
+                flag!();
+            }
+            constants::DW_AT_defaulted => {
+                // TODO: constant
+            }
+            constants::DW_AT_loclists_base => {
+                loclistsptr!();
+            }
+            constants::DW_AT_GNU_dwo_id => {
+                dwoid!();
+            }
+            _ => {}
+        }
+        self.value.clone()
+    }
+
+    /// Try to convert this attribute's value to a u8.
+    #[inline]
+    pub fn u8_value(&self) -> Option<u8> {
+        self.value.u8_value()
+    }
+
+    /// Try to convert this attribute's value to a u16.
+    #[inline]
+    pub fn u16_value(&self) -> Option<u16> {
+        self.value.u16_value()
+    }
+
+    /// Try to convert this attribute's value to an unsigned integer.
+    #[inline]
+    pub fn udata_value(&self) -> Option<u64> {
+        self.value.udata_value()
+    }
+
+    /// Try to convert this attribute's value to a signed integer.
+    #[inline]
+    pub fn sdata_value(&self) -> Option<i64> {
+        self.value.sdata_value()
+    }
+
+    /// Try to convert this attribute's value to an offset.
+    #[inline]
+    pub fn offset_value(&self) -> Option<R::Offset> {
+        self.value.offset_value()
+    }
+
+    /// Try to convert this attribute's value to an expression or location buffer.
+    ///
+    /// Expressions and locations may be `DW_FORM_block*` or `DW_FORM_exprloc`.
+    /// The standard doesn't mention `DW_FORM_block*` as a possible form, but
+    /// it is encountered in practice.
+    #[inline]
+    pub fn exprloc_value(&self) -> Option<Expression<R>> {
+        self.value.exprloc_value()
+    }
+
+    /// Try to return this attribute's value as a string slice.
+    ///
+    /// If this attribute's value is either an inline `DW_FORM_string` string,
+    /// or a `DW_FORM_strp` reference to an offset into the `.debug_str`
+    /// section, return the attribute's string value as `Some`. Other attribute
+    /// value forms are returned as `None`.
+    ///
+    /// Warning: this function does not handle all possible string forms.
+    /// Use `Dwarf::attr_string` instead.
+    #[inline]
+    pub fn string_value(&self, debug_str: &DebugStr<R>) -> Option<R> {
+        self.value.string_value(debug_str)
+    }
+
+    /// Try to return this attribute's value as a string slice.
+    ///
+    /// If this attribute's value is either an inline `DW_FORM_string` string,
+    /// or a `DW_FORM_strp` reference to an offset into the `.debug_str`
+    /// section, or a `DW_FORM_strp_sup` reference to an offset into a supplementary
+    /// object file, return the attribute's string value as `Some`. Other attribute
+    /// value forms are returned as `None`.
+    ///
+    /// Warning: this function does not handle all possible string forms.
+    /// Use `Dwarf::attr_string` instead.
+    #[inline]
+    pub fn string_value_sup(
+        &self,
+        debug_str: &DebugStr<R>,
+        debug_str_sup: Option<&DebugStr<R>>,
+    ) -> Option<R> {
+        self.value.string_value_sup(debug_str, debug_str_sup)
+    }
+}
+
+impl<R, Offset> AttributeValue<R, Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    /// Try to convert this attribute's value to a u8.
+    pub fn u8_value(&self) -> Option<u8> {
+        if let Some(value) = self.udata_value() {
+            if value <= u64::from(u8::MAX) {
+                return Some(value as u8);
+            }
+        }
+        None
+    }
+
+    /// Try to convert this attribute's value to a u16.
+    pub fn u16_value(&self) -> Option<u16> {
+        if let Some(value) = self.udata_value() {
+            if value <= u64::from(u16::MAX) {
+                return Some(value as u16);
+            }
+        }
+        None
+    }
+
+    /// Try to convert this attribute's value to an unsigned integer.
+    pub fn udata_value(&self) -> Option<u64> {
+        Some(match *self {
+            AttributeValue::Data1(data) => u64::from(data),
+            AttributeValue::Data2(data) => u64::from(data),
+            AttributeValue::Data4(data) => u64::from(data),
+            AttributeValue::Data8(data) => data,
+            AttributeValue::Udata(data) => data,
+            AttributeValue::Sdata(data) => {
+                if data < 0 {
+                    // Maybe we should emit a warning here
+                    return None;
+                }
+                data as u64
+            }
+            _ => return None,
+        })
+    }
+
+    /// Try to convert this attribute's value to a signed integer.
+    pub fn sdata_value(&self) -> Option<i64> {
+        Some(match *self {
+            AttributeValue::Data1(data) => i64::from(data as i8),
+            AttributeValue::Data2(data) => i64::from(data as i16),
+            AttributeValue::Data4(data) => i64::from(data as i32),
+            AttributeValue::Data8(data) => data as i64,
+            AttributeValue::Sdata(data) => data,
+            AttributeValue::Udata(data) => {
+                if data > i64::max_value() as u64 {
+                    // Maybe we should emit a warning here
+                    return None;
+                }
+                data as i64
+            }
+            _ => return None,
+        })
+    }
+
+    /// Try to convert this attribute's value to an offset.
+    pub fn offset_value(&self) -> Option<R::Offset> {
+        // While offsets will be DW_FORM_data4/8 in DWARF version 2/3,
+        // these have already been converted to `SecOffset.
+        if let AttributeValue::SecOffset(offset) = *self {
+            Some(offset)
+        } else {
+            None
+        }
+    }
+
+    /// Try to convert this attribute's value to an expression or location buffer.
+    ///
+    /// Expressions and locations may be `DW_FORM_block*` or `DW_FORM_exprloc`.
+    /// The standard doesn't mention `DW_FORM_block*` as a possible form, but
+    /// it is encountered in practice.
+    pub fn exprloc_value(&self) -> Option<Expression<R>> {
+        Some(match *self {
+            AttributeValue::Block(ref data) => Expression(data.clone()),
+            AttributeValue::Exprloc(ref data) => data.clone(),
+            _ => return None,
+        })
+    }
+
+    /// Try to return this attribute's value as a string slice.
+    ///
+    /// If this attribute's value is either an inline `DW_FORM_string` string,
+    /// or a `DW_FORM_strp` reference to an offset into the `.debug_str`
+    /// section, return the attribute's string value as `Some`. Other attribute
+    /// value forms are returned as `None`.
+    ///
+    /// Warning: this function does not handle all possible string forms.
+    /// Use `Dwarf::attr_string` instead.
+    pub fn string_value(&self, debug_str: &DebugStr<R>) -> Option<R> {
+        match *self {
+            AttributeValue::String(ref string) => Some(string.clone()),
+            AttributeValue::DebugStrRef(offset) => debug_str.get_str(offset).ok(),
+            _ => None,
+        }
+    }
+
+    /// Try to return this attribute's value as a string slice.
+    ///
+    /// If this attribute's value is either an inline `DW_FORM_string` string,
+    /// or a `DW_FORM_strp` reference to an offset into the `.debug_str`
+    /// section, or a `DW_FORM_strp_sup` reference to an offset into a supplementary
+    /// object file, return the attribute's string value as `Some`. Other attribute
+    /// value forms are returned as `None`.
+    ///
+    /// Warning: this function does not handle all possible string forms.
+    /// Use `Dwarf::attr_string` instead.
+    pub fn string_value_sup(
+        &self,
+        debug_str: &DebugStr<R>,
+        debug_str_sup: Option<&DebugStr<R>>,
+    ) -> Option<R> {
+        match *self {
+            AttributeValue::String(ref string) => Some(string.clone()),
+            AttributeValue::DebugStrRef(offset) => debug_str.get_str(offset).ok(),
+            AttributeValue::DebugStrRefSup(offset) => {
+                debug_str_sup.and_then(|s| s.get_str(offset).ok())
+            }
+            _ => None,
+        }
+    }
+}
+
+fn length_u8_value<R: Reader>(input: &mut R) -> Result<R> {
+    let len = input.read_u8().map(R::Offset::from_u8)?;
+    input.split(len)
+}
+
+fn length_u16_value<R: Reader>(input: &mut R) -> Result<R> {
+    let len = input.read_u16().map(R::Offset::from_u16)?;
+    input.split(len)
+}
+
+fn length_u32_value<R: Reader>(input: &mut R) -> Result<R> {
+    let len = input.read_u32().map(R::Offset::from_u32)?;
+    input.split(len)
+}
+
+fn length_uleb128_value<R: Reader>(input: &mut R) -> Result<R> {
+    let len = input.read_uleb128().and_then(R::Offset::from_u64)?;
+    input.split(len)
+}
+
+// Return true if the given `name` can be a section offset in DWARF version 2/3.
+// This is required to correctly handle relocations.
+fn allow_section_offset(name: constants::DwAt, version: u16) -> bool {
+    match name {
+        constants::DW_AT_location
+        | constants::DW_AT_stmt_list
+        | constants::DW_AT_string_length
+        | constants::DW_AT_return_addr
+        | constants::DW_AT_start_scope
+        | constants::DW_AT_frame_base
+        | constants::DW_AT_macro_info
+        | constants::DW_AT_macros
+        | constants::DW_AT_segment
+        | constants::DW_AT_static_link
+        | constants::DW_AT_use_location
+        | constants::DW_AT_vtable_elem_location
+        | constants::DW_AT_ranges => true,
+        constants::DW_AT_data_member_location => version == 2 || version == 3,
+        _ => false,
+    }
+}
+
+pub(crate) fn parse_attribute<R: Reader>(
+    input: &mut R,
+    encoding: Encoding,
+    spec: AttributeSpecification,
+) -> Result<Attribute<R>> {
+    let mut form = spec.form();
+    loop {
+        let value = match form {
+            constants::DW_FORM_indirect => {
+                let dynamic_form = input.read_uleb128_u16()?;
+                form = constants::DwForm(dynamic_form);
+                continue;
+            }
+            constants::DW_FORM_addr => {
+                let addr = input.read_address(encoding.address_size)?;
+                AttributeValue::Addr(addr)
+            }
+            constants::DW_FORM_block1 => {
+                let block = length_u8_value(input)?;
+                AttributeValue::Block(block)
+            }
+            constants::DW_FORM_block2 => {
+                let block = length_u16_value(input)?;
+                AttributeValue::Block(block)
+            }
+            constants::DW_FORM_block4 => {
+                let block = length_u32_value(input)?;
+                AttributeValue::Block(block)
+            }
+            constants::DW_FORM_block => {
+                let block = length_uleb128_value(input)?;
+                AttributeValue::Block(block)
+            }
+            constants::DW_FORM_data1 => {
+                let data = input.read_u8()?;
+                AttributeValue::Data1(data)
+            }
+            constants::DW_FORM_data2 => {
+                let data = input.read_u16()?;
+                AttributeValue::Data2(data)
+            }
+            constants::DW_FORM_data4 => {
+                // DWARF version 2/3 may use DW_FORM_data4/8 for section offsets.
+                // Ensure we handle relocations here.
+                if encoding.format == Format::Dwarf32
+                    && allow_section_offset(spec.name(), encoding.version)
+                {
+                    let offset = input.read_offset(Format::Dwarf32)?;
+                    AttributeValue::SecOffset(offset)
+                } else {
+                    let data = input.read_u32()?;
+                    AttributeValue::Data4(data)
+                }
+            }
+            constants::DW_FORM_data8 => {
+                // DWARF version 2/3 may use DW_FORM_data4/8 for section offsets.
+                // Ensure we handle relocations here.
+                if encoding.format == Format::Dwarf64
+                    && allow_section_offset(spec.name(), encoding.version)
+                {
+                    let offset = input.read_offset(Format::Dwarf64)?;
+                    AttributeValue::SecOffset(offset)
+                } else {
+                    let data = input.read_u64()?;
+                    AttributeValue::Data8(data)
+                }
+            }
+            constants::DW_FORM_data16 => {
+                let block = input.split(R::Offset::from_u8(16))?;
+                AttributeValue::Block(block)
+            }
+            constants::DW_FORM_udata => {
+                let data = input.read_uleb128()?;
+                AttributeValue::Udata(data)
+            }
+            constants::DW_FORM_sdata => {
+                let data = input.read_sleb128()?;
+                AttributeValue::Sdata(data)
+            }
+            constants::DW_FORM_exprloc => {
+                let block = length_uleb128_value(input)?;
+                AttributeValue::Exprloc(Expression(block))
+            }
+            constants::DW_FORM_flag => {
+                let present = input.read_u8()?;
+                AttributeValue::Flag(present != 0)
+            }
+            constants::DW_FORM_flag_present => {
+                // FlagPresent is this weird compile time always true thing that
+                // isn't actually present in the serialized DIEs, only in the abbreviation.
+                AttributeValue::Flag(true)
+            }
+            constants::DW_FORM_sec_offset => {
+                let offset = input.read_offset(encoding.format)?;
+                AttributeValue::SecOffset(offset)
+            }
+            constants::DW_FORM_ref1 => {
+                let reference = input.read_u8().map(R::Offset::from_u8)?;
+                AttributeValue::UnitRef(UnitOffset(reference))
+            }
+            constants::DW_FORM_ref2 => {
+                let reference = input.read_u16().map(R::Offset::from_u16)?;
+                AttributeValue::UnitRef(UnitOffset(reference))
+            }
+            constants::DW_FORM_ref4 => {
+                let reference = input.read_u32().map(R::Offset::from_u32)?;
+                AttributeValue::UnitRef(UnitOffset(reference))
+            }
+            constants::DW_FORM_ref8 => {
+                let reference = input.read_u64().and_then(R::Offset::from_u64)?;
+                AttributeValue::UnitRef(UnitOffset(reference))
+            }
+            constants::DW_FORM_ref_udata => {
+                let reference = input.read_uleb128().and_then(R::Offset::from_u64)?;
+                AttributeValue::UnitRef(UnitOffset(reference))
+            }
+            constants::DW_FORM_ref_addr => {
+                // This is an offset, but DWARF version 2 specifies that DW_FORM_ref_addr
+                // has the same size as an address on the target system.  This was changed
+                // in DWARF version 3.
+                let offset = if encoding.version == 2 {
+                    input.read_sized_offset(encoding.address_size)?
+                } else {
+                    input.read_offset(encoding.format)?
+                };
+                AttributeValue::DebugInfoRef(DebugInfoOffset(offset))
+            }
+            constants::DW_FORM_ref_sig8 => {
+                let signature = input.read_u64()?;
+                AttributeValue::DebugTypesRef(DebugTypeSignature(signature))
+            }
+            constants::DW_FORM_ref_sup4 => {
+                let offset = input.read_u32().map(R::Offset::from_u32)?;
+                AttributeValue::DebugInfoRefSup(DebugInfoOffset(offset))
+            }
+            constants::DW_FORM_ref_sup8 => {
+                let offset = input.read_u64().and_then(R::Offset::from_u64)?;
+                AttributeValue::DebugInfoRefSup(DebugInfoOffset(offset))
+            }
+            constants::DW_FORM_GNU_ref_alt => {
+                let offset = input.read_offset(encoding.format)?;
+                AttributeValue::DebugInfoRefSup(DebugInfoOffset(offset))
+            }
+            constants::DW_FORM_string => {
+                let string = input.read_null_terminated_slice()?;
+                AttributeValue::String(string)
+            }
+            constants::DW_FORM_strp => {
+                let offset = input.read_offset(encoding.format)?;
+                AttributeValue::DebugStrRef(DebugStrOffset(offset))
+            }
+            constants::DW_FORM_strp_sup | constants::DW_FORM_GNU_strp_alt => {
+                let offset = input.read_offset(encoding.format)?;
+                AttributeValue::DebugStrRefSup(DebugStrOffset(offset))
+            }
+            constants::DW_FORM_line_strp => {
+                let offset = input.read_offset(encoding.format)?;
+                AttributeValue::DebugLineStrRef(DebugLineStrOffset(offset))
+            }
+            constants::DW_FORM_implicit_const => {
+                let data = spec
+                    .implicit_const_value()
+                    .ok_or(Error::InvalidImplicitConst)?;
+                AttributeValue::Sdata(data)
+            }
+            constants::DW_FORM_strx | constants::DW_FORM_GNU_str_index => {
+                let index = input.read_uleb128().and_then(R::Offset::from_u64)?;
+                AttributeValue::DebugStrOffsetsIndex(DebugStrOffsetsIndex(index))
+            }
+            constants::DW_FORM_strx1 => {
+                let index = input.read_u8().map(R::Offset::from_u8)?;
+                AttributeValue::DebugStrOffsetsIndex(DebugStrOffsetsIndex(index))
+            }
+            constants::DW_FORM_strx2 => {
+                let index = input.read_u16().map(R::Offset::from_u16)?;
+                AttributeValue::DebugStrOffsetsIndex(DebugStrOffsetsIndex(index))
+            }
+            constants::DW_FORM_strx3 => {
+                let index = input.read_uint(3).and_then(R::Offset::from_u64)?;
+                AttributeValue::DebugStrOffsetsIndex(DebugStrOffsetsIndex(index))
+            }
+            constants::DW_FORM_strx4 => {
+                let index = input.read_u32().map(R::Offset::from_u32)?;
+                AttributeValue::DebugStrOffsetsIndex(DebugStrOffsetsIndex(index))
+            }
+            constants::DW_FORM_addrx | constants::DW_FORM_GNU_addr_index => {
+                let index = input.read_uleb128().and_then(R::Offset::from_u64)?;
+                AttributeValue::DebugAddrIndex(DebugAddrIndex(index))
+            }
+            constants::DW_FORM_addrx1 => {
+                let index = input.read_u8().map(R::Offset::from_u8)?;
+                AttributeValue::DebugAddrIndex(DebugAddrIndex(index))
+            }
+            constants::DW_FORM_addrx2 => {
+                let index = input.read_u16().map(R::Offset::from_u16)?;
+                AttributeValue::DebugAddrIndex(DebugAddrIndex(index))
+            }
+            constants::DW_FORM_addrx3 => {
+                let index = input.read_uint(3).and_then(R::Offset::from_u64)?;
+                AttributeValue::DebugAddrIndex(DebugAddrIndex(index))
+            }
+            constants::DW_FORM_addrx4 => {
+                let index = input.read_u32().map(R::Offset::from_u32)?;
+                AttributeValue::DebugAddrIndex(DebugAddrIndex(index))
+            }
+            constants::DW_FORM_loclistx => {
+                let index = input.read_uleb128().and_then(R::Offset::from_u64)?;
+                AttributeValue::DebugLocListsIndex(DebugLocListsIndex(index))
+            }
+            constants::DW_FORM_rnglistx => {
+                let index = input.read_uleb128().and_then(R::Offset::from_u64)?;
+                AttributeValue::DebugRngListsIndex(DebugRngListsIndex(index))
+            }
+            _ => {
+                return Err(Error::UnknownForm);
+            }
+        };
+        let attr = Attribute {
+            name: spec.name(),
+            value,
+        };
+        return Ok(attr);
+    }
+}
+
+pub(crate) fn skip_attributes<R: Reader>(
+    input: &mut R,
+    encoding: Encoding,
+    specs: &[AttributeSpecification],
+) -> Result<()> {
+    let mut skip_bytes = R::Offset::from_u8(0);
+    for spec in specs {
+        let mut form = spec.form();
+        loop {
+            if let Some(len) = get_attribute_size(form, encoding) {
+                // We know the length of this attribute. Accumulate that length.
+                skip_bytes += R::Offset::from_u8(len);
+                break;
+            }
+
+            // We have encountered a variable-length attribute.
+            if skip_bytes != R::Offset::from_u8(0) {
+                // Skip the accumulated skip bytes and then read the attribute normally.
+                input.skip(skip_bytes)?;
+                skip_bytes = R::Offset::from_u8(0);
+            }
+
+            match form {
+                constants::DW_FORM_indirect => {
+                    let dynamic_form = input.read_uleb128_u16()?;
+                    form = constants::DwForm(dynamic_form);
+                    continue;
+                }
+                constants::DW_FORM_block1 => {
+                    skip_bytes = input.read_u8().map(R::Offset::from_u8)?;
+                }
+                constants::DW_FORM_block2 => {
+                    skip_bytes = input.read_u16().map(R::Offset::from_u16)?;
+                }
+                constants::DW_FORM_block4 => {
+                    skip_bytes = input.read_u32().map(R::Offset::from_u32)?;
+                }
+                constants::DW_FORM_block | constants::DW_FORM_exprloc => {
+                    skip_bytes = input.read_uleb128().and_then(R::Offset::from_u64)?;
+                }
+                constants::DW_FORM_string => {
+                    let _ = input.read_null_terminated_slice()?;
+                }
+                constants::DW_FORM_udata
+                | constants::DW_FORM_sdata
+                | constants::DW_FORM_ref_udata
+                | constants::DW_FORM_strx
+                | constants::DW_FORM_GNU_str_index
+                | constants::DW_FORM_addrx
+                | constants::DW_FORM_GNU_addr_index
+                | constants::DW_FORM_loclistx
+                | constants::DW_FORM_rnglistx => {
+                    input.skip_leb128()?;
+                }
+                _ => {
+                    return Err(Error::UnknownForm);
+                }
+            };
+            break;
+        }
+    }
+    if skip_bytes != R::Offset::from_u8(0) {
+        // Skip the remaining accumulated skip bytes.
+        input.skip(skip_bytes)?;
+    }
+    Ok(())
+}
+
+/// An iterator over a particular entry's attributes.
+///
+/// See [the documentation for
+/// `DebuggingInformationEntry::attrs()`](./struct.DebuggingInformationEntry.html#method.attrs)
+/// for details.
+///
+/// Can be [used with
+/// `FallibleIterator`](./index.html#using-with-fallibleiterator).
+#[derive(Clone, Copy, Debug)]
+pub struct AttrsIter<'abbrev, 'entry, 'unit, R: Reader> {
+    input: R,
+    attributes: &'abbrev [AttributeSpecification],
+    entry: &'entry DebuggingInformationEntry<'abbrev, 'unit, R>,
+}
+
+impl<'abbrev, 'entry, 'unit, R: Reader> AttrsIter<'abbrev, 'entry, 'unit, R> {
+    /// Advance the iterator and return the next attribute.
+    ///
+    /// Returns `None` when iteration is finished. If an error
+    /// occurs while parsing the next attribute, then this error
+    /// is returned, and all subsequent calls return `None`.
+    #[inline(always)]
+    pub fn next(&mut self) -> Result<Option<Attribute<R>>> {
+        if self.attributes.is_empty() {
+            // Now that we have parsed all of the attributes, we know where
+            // either (1) this entry's children start, if the abbreviation says
+            // this entry has children; or (2) where this entry's siblings
+            // begin.
+            if let Some(end) = self.entry.attrs_len.get() {
+                debug_assert_eq!(end, self.input.offset_from(&self.entry.attrs_slice));
+            } else {
+                self.entry
+                    .attrs_len
+                    .set(Some(self.input.offset_from(&self.entry.attrs_slice)));
+            }
+
+            return Ok(None);
+        }
+
+        let spec = self.attributes[0];
+        let rest_spec = &self.attributes[1..];
+        match parse_attribute(&mut self.input, self.entry.unit.encoding(), spec) {
+            Ok(attr) => {
+                self.attributes = rest_spec;
+                Ok(Some(attr))
+            }
+            Err(e) => {
+                self.input.empty();
+                Err(e)
+            }
+        }
+    }
+}
+
+#[cfg(feature = "fallible-iterator")]
+impl<'abbrev, 'entry, 'unit, R: Reader> fallible_iterator::FallibleIterator
+    for AttrsIter<'abbrev, 'entry, 'unit, R>
+{
+    type Item = Attribute<R>;
+    type Error = Error;
+
+    fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> {
+        AttrsIter::next(self)
+    }
+}
+
+/// A raw reader of the data that defines the Debugging Information Entries.
+///
+/// `EntriesRaw` provides primitives to read the components of Debugging Information
+/// Entries (DIEs). A DIE consists of an abbreviation code (read with `read_abbreviation`)
+/// followed by a number of attributes (read with `read_attribute`).
+/// The user must provide the control flow to read these correctly.
+/// In particular, all attributes must always be read before reading another
+/// abbreviation code.
+///
+/// `EntriesRaw` lacks some features of `EntriesCursor`, such as the ability to skip
+/// to the next sibling DIE. However, this also allows it to optimize better, since it
+/// does not need to perform the extra bookkeeping required to support these features,
+/// and thus it is suitable for cases where performance is important.
+///
+/// ## Example Usage
+/// ```rust,no_run
+/// # fn example() -> Result<(), gimli::Error> {
+/// # let debug_info = gimli::DebugInfo::new(&[], gimli::LittleEndian);
+/// # let get_some_unit = || debug_info.units().next().unwrap().unwrap();
+/// let unit = get_some_unit();
+/// # let debug_abbrev = gimli::DebugAbbrev::new(&[], gimli::LittleEndian);
+/// # let get_abbrevs_for_unit = |_| unit.abbreviations(&debug_abbrev).unwrap();
+/// let abbrevs = get_abbrevs_for_unit(&unit);
+///
+/// let mut entries = unit.entries_raw(&abbrevs, None)?;
+/// while !entries.is_empty() {
+///     let abbrev = if let Some(abbrev) = entries.read_abbreviation()? {
+///         abbrev
+///     } else {
+///         // Null entry with no attributes.
+///         continue
+///     };
+///     match abbrev.tag() {
+///         gimli::DW_TAG_subprogram => {
+///             // Loop over attributes for DIEs we care about.
+///             for spec in abbrev.attributes() {
+///                 let attr = entries.read_attribute(*spec)?;
+///                 match attr.name() {
+///                     // Handle attributes.
+///                     _ => {}
+///                 }
+///             }
+///         }
+///         _ => {
+///             // Skip attributes for DIEs we don't care about.
+///             entries.skip_attributes(abbrev.attributes());
+///         }
+///     }
+/// }
+/// # unreachable!()
+/// # }
+/// ```
+#[derive(Clone, Debug)]
+pub struct EntriesRaw<'abbrev, 'unit, R>
+where
+    R: Reader,
+{
+    input: R,
+    unit: &'unit UnitHeader<R>,
+    abbreviations: &'abbrev Abbreviations,
+    depth: isize,
+}
+
+impl<'abbrev, 'unit, R: Reader> EntriesRaw<'abbrev, 'unit, R> {
+    /// Return true if there is no more input.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.input.is_empty()
+    }
+
+    /// Return the unit offset at which the reader will read next.
+    ///
+    /// If you want the offset of the next entry, then this must be called prior to reading
+    /// the next entry.
+    pub fn next_offset(&self) -> UnitOffset<R::Offset> {
+        UnitOffset(self.unit.header_size() + self.input.offset_from(&self.unit.entries_buf))
+    }
+
+    /// Return the depth of the next entry.
+    ///
+    /// This depth is updated when `read_abbreviation` is called, and is updated
+    /// based on null entries and the `has_children` field in the abbreviation.
+    #[inline]
+    pub fn next_depth(&self) -> isize {
+        self.depth
+    }
+
+    /// Read an abbreviation code and lookup the corresponding `Abbreviation`.
+    ///
+    /// Returns `Ok(None)` for null entries.
+    #[inline]
+    pub fn read_abbreviation(&mut self) -> Result<Option<&'abbrev Abbreviation>> {
+        let code = self.input.read_uleb128()?;
+        if code == 0 {
+            self.depth -= 1;
+            return Ok(None);
+        };
+        let abbrev = self
+            .abbreviations
+            .get(code)
+            .ok_or(Error::UnknownAbbreviation)?;
+        if abbrev.has_children() {
+            self.depth += 1;
+        }
+        Ok(Some(abbrev))
+    }
+
+    /// Read an attribute.
+    #[inline]
+    pub fn read_attribute(&mut self, spec: AttributeSpecification) -> Result<Attribute<R>> {
+        parse_attribute(&mut self.input, self.unit.encoding(), spec)
+    }
+
+    /// Skip all the attributes of an abbreviation.
+    #[inline]
+    pub fn skip_attributes(&mut self, specs: &[AttributeSpecification]) -> Result<()> {
+        skip_attributes(&mut self.input, self.unit.encoding(), specs)
+    }
+}
+
+/// A cursor into the Debugging Information Entries tree for a compilation unit.
+///
+/// The `EntriesCursor` can traverse the DIE tree in DFS order using `next_dfs()`,
+/// or skip to the next sibling of the entry the cursor is currently pointing to
+/// using `next_sibling()`.
+///
+/// It is also possible to traverse the DIE tree at a lower abstraction level
+/// using `next_entry()`. This method does not skip over null entries, or provide
+/// any indication of the current tree depth. In this case, you must use `current()`
+/// to obtain the current entry, and `current().has_children()` to determine if
+/// the entry following the current entry will be a sibling or child. `current()`
+/// will return `None` if the current entry is a null entry, which signifies the
+/// end of the current tree depth.
+#[derive(Clone, Debug)]
+pub struct EntriesCursor<'abbrev, 'unit, R>
+where
+    R: Reader,
+{
+    input: R,
+    unit: &'unit UnitHeader<R>,
+    abbreviations: &'abbrev Abbreviations,
+    cached_current: Option<DebuggingInformationEntry<'abbrev, 'unit, R>>,
+    delta_depth: isize,
+}
+
+impl<'abbrev, 'unit, R: Reader> EntriesCursor<'abbrev, 'unit, R> {
+    /// Get a reference to the entry that the cursor is currently pointing to.
+    ///
+    /// If the cursor is not pointing at an entry, or if the current entry is a
+    /// null entry, then `None` is returned.
+    #[inline]
+    pub fn current(&self) -> Option<&DebuggingInformationEntry<'abbrev, 'unit, R>> {
+        self.cached_current.as_ref()
+    }
+
+    /// Move the cursor to the next DIE in the tree.
+    ///
+    /// Returns `Some` if there is a next entry, even if this entry is null.
+    /// If there is no next entry, then `None` is returned.
+    pub fn next_entry(&mut self) -> Result<Option<()>> {
+        if let Some(ref current) = self.cached_current {
+            self.input = current.after_attrs()?;
+        }
+
+        if self.input.is_empty() {
+            self.cached_current = None;
+            self.delta_depth = 0;
+            return Ok(None);
+        }
+
+        match DebuggingInformationEntry::parse(&mut self.input, self.unit, self.abbreviations) {
+            Ok(Some(entry)) => {
+                self.delta_depth = entry.has_children() as isize;
+                self.cached_current = Some(entry);
+                Ok(Some(()))
+            }
+            Ok(None) => {
+                self.delta_depth = -1;
+                self.cached_current = None;
+                Ok(Some(()))
+            }
+            Err(e) => {
+                self.input.empty();
+                self.delta_depth = 0;
+                self.cached_current = None;
+                Err(e)
+            }
+        }
+    }
+
+    /// Move the cursor to the next DIE in the tree in DFS order.
+    ///
+    /// Upon successful movement of the cursor, return the delta traversal
+    /// depth and the entry:
+    ///
+    ///   * If we moved down into the previous current entry's children, we get
+    ///     `Some((1, entry))`.
+    ///
+    ///   * If we moved to the previous current entry's sibling, we get
+    ///     `Some((0, entry))`.
+    ///
+    ///   * If the previous entry does not have any siblings and we move up to
+    ///     its parent's next sibling, then we get `Some((-1, entry))`. Note that
+    ///     if the parent doesn't have a next sibling, then it could go up to the
+    ///     parent's parent's next sibling and return `Some((-2, entry))`, etc.
+    ///
+    /// If there is no next entry, then `None` is returned.
+    ///
+    /// Here is an example that finds the first entry in a compilation unit that
+    /// does not have any children.
+    ///
+    /// ```
+    /// # use gimli::{DebugAbbrev, DebugInfo, LittleEndian};
+    /// # let info_buf = [
+    /// #     // Comilation unit header
+    /// #
+    /// #     // 32-bit unit length = 25
+    /// #     0x19, 0x00, 0x00, 0x00,
+    /// #     // Version 4
+    /// #     0x04, 0x00,
+    /// #     // debug_abbrev_offset
+    /// #     0x00, 0x00, 0x00, 0x00,
+    /// #     // Address size
+    /// #     0x04,
+    /// #
+    /// #     // DIEs
+    /// #
+    /// #     // Abbreviation code
+    /// #     0x01,
+    /// #     // Attribute of form DW_FORM_string = "foo\0"
+    /// #     0x66, 0x6f, 0x6f, 0x00,
+    /// #
+    /// #       // Children
+    /// #
+    /// #       // Abbreviation code
+    /// #       0x01,
+    /// #       // Attribute of form DW_FORM_string = "foo\0"
+    /// #       0x66, 0x6f, 0x6f, 0x00,
+    /// #
+    /// #         // Children
+    /// #
+    /// #         // Abbreviation code
+    /// #         0x01,
+    /// #         // Attribute of form DW_FORM_string = "foo\0"
+    /// #         0x66, 0x6f, 0x6f, 0x00,
+    /// #
+    /// #           // Children
+    /// #
+    /// #           // End of children
+    /// #           0x00,
+    /// #
+    /// #         // End of children
+    /// #         0x00,
+    /// #
+    /// #       // End of children
+    /// #       0x00,
+    /// # ];
+    /// # let debug_info = DebugInfo::new(&info_buf, LittleEndian);
+    /// #
+    /// # let abbrev_buf = [
+    /// #     // Code
+    /// #     0x01,
+    /// #     // DW_TAG_subprogram
+    /// #     0x2e,
+    /// #     // DW_CHILDREN_yes
+    /// #     0x01,
+    /// #     // Begin attributes
+    /// #       // Attribute name = DW_AT_name
+    /// #       0x03,
+    /// #       // Attribute form = DW_FORM_string
+    /// #       0x08,
+    /// #     // End attributes
+    /// #     0x00,
+    /// #     0x00,
+    /// #     // Null terminator
+    /// #     0x00
+    /// # ];
+    /// # let debug_abbrev = DebugAbbrev::new(&abbrev_buf, LittleEndian);
+    /// #
+    /// # let get_some_unit = || debug_info.units().next().unwrap().unwrap();
+    ///
+    /// let unit = get_some_unit();
+    /// # let get_abbrevs_for_unit = |_| unit.abbreviations(&debug_abbrev).unwrap();
+    /// let abbrevs = get_abbrevs_for_unit(&unit);
+    ///
+    /// let mut first_entry_with_no_children = None;
+    /// let mut cursor = unit.entries(&abbrevs);
+    ///
+    /// // Move the cursor to the root.
+    /// assert!(cursor.next_dfs().unwrap().is_some());
+    ///
+    /// // Traverse the DIE tree in depth-first search order.
+    /// let mut depth = 0;
+    /// while let Some((delta_depth, current)) = cursor.next_dfs().expect("Should parse next dfs") {
+    ///     // Update depth value, and break out of the loop when we
+    ///     // return to the original starting position.
+    ///     depth += delta_depth;
+    ///     if depth <= 0 {
+    ///         break;
+    ///     }
+    ///
+    ///     first_entry_with_no_children = Some(current.clone());
+    /// }
+    ///
+    /// println!("The first entry with no children is {:?}",
+    ///          first_entry_with_no_children.unwrap());
+    /// ```
+    pub fn next_dfs(
+        &mut self,
+    ) -> Result<Option<(isize, &DebuggingInformationEntry<'abbrev, 'unit, R>)>> {
+        let mut delta_depth = self.delta_depth;
+        loop {
+            // The next entry should be the one we want.
+            if self.next_entry()?.is_some() {
+                if let Some(ref entry) = self.cached_current {
+                    return Ok(Some((delta_depth, entry)));
+                }
+
+                // next_entry() read a null entry.
+                delta_depth += self.delta_depth;
+            } else {
+                return Ok(None);
+            }
+        }
+    }
+
+    /// Move the cursor to the next sibling DIE of the current one.
+    ///
+    /// Returns `Ok(Some(entry))` when the cursor has been moved to
+    /// the next sibling, `Ok(None)` when there is no next sibling.
+    ///
+    /// The depth of the cursor is never changed if this method returns `Ok`.
+    /// Once `Ok(None)` is returned, this method will continue to return
+    /// `Ok(None)` until either `next_entry` or `next_dfs` is called.
+    ///
+    /// Here is an example that iterates over all of the direct children of the
+    /// root entry:
+    ///
+    /// ```
+    /// # use gimli::{DebugAbbrev, DebugInfo, LittleEndian};
+    /// # let info_buf = [
+    /// #     // Comilation unit header
+    /// #
+    /// #     // 32-bit unit length = 25
+    /// #     0x19, 0x00, 0x00, 0x00,
+    /// #     // Version 4
+    /// #     0x04, 0x00,
+    /// #     // debug_abbrev_offset
+    /// #     0x00, 0x00, 0x00, 0x00,
+    /// #     // Address size
+    /// #     0x04,
+    /// #
+    /// #     // DIEs
+    /// #
+    /// #     // Abbreviation code
+    /// #     0x01,
+    /// #     // Attribute of form DW_FORM_string = "foo\0"
+    /// #     0x66, 0x6f, 0x6f, 0x00,
+    /// #
+    /// #       // Children
+    /// #
+    /// #       // Abbreviation code
+    /// #       0x01,
+    /// #       // Attribute of form DW_FORM_string = "foo\0"
+    /// #       0x66, 0x6f, 0x6f, 0x00,
+    /// #
+    /// #         // Children
+    /// #
+    /// #         // Abbreviation code
+    /// #         0x01,
+    /// #         // Attribute of form DW_FORM_string = "foo\0"
+    /// #         0x66, 0x6f, 0x6f, 0x00,
+    /// #
+    /// #           // Children
+    /// #
+    /// #           // End of children
+    /// #           0x00,
+    /// #
+    /// #         // End of children
+    /// #         0x00,
+    /// #
+    /// #       // End of children
+    /// #       0x00,
+    /// # ];
+    /// # let debug_info = DebugInfo::new(&info_buf, LittleEndian);
+    /// #
+    /// # let get_some_unit = || debug_info.units().next().unwrap().unwrap();
+    ///
+    /// # let abbrev_buf = [
+    /// #     // Code
+    /// #     0x01,
+    /// #     // DW_TAG_subprogram
+    /// #     0x2e,
+    /// #     // DW_CHILDREN_yes
+    /// #     0x01,
+    /// #     // Begin attributes
+    /// #       // Attribute name = DW_AT_name
+    /// #       0x03,
+    /// #       // Attribute form = DW_FORM_string
+    /// #       0x08,
+    /// #     // End attributes
+    /// #     0x00,
+    /// #     0x00,
+    /// #     // Null terminator
+    /// #     0x00
+    /// # ];
+    /// # let debug_abbrev = DebugAbbrev::new(&abbrev_buf, LittleEndian);
+    /// #
+    /// let unit = get_some_unit();
+    /// # let get_abbrevs_for_unit = |_| unit.abbreviations(&debug_abbrev).unwrap();
+    /// let abbrevs = get_abbrevs_for_unit(&unit);
+    ///
+    /// let mut cursor = unit.entries(&abbrevs);
+    ///
+    /// // Move the cursor to the root.
+    /// assert!(cursor.next_dfs().unwrap().is_some());
+    ///
+    /// // Move the cursor to the root's first child.
+    /// assert!(cursor.next_dfs().unwrap().is_some());
+    ///
+    /// // Iterate the root's children.
+    /// loop {
+    ///     {
+    ///         let current = cursor.current().expect("Should be at an entry");
+    ///         println!("{:?} is a child of the root", current);
+    ///     }
+    ///
+    ///     if cursor.next_sibling().expect("Should parse next sibling").is_none() {
+    ///         break;
+    ///     }
+    /// }
+    /// ```
+    pub fn next_sibling(
+        &mut self,
+    ) -> Result<Option<&DebuggingInformationEntry<'abbrev, 'unit, R>>> {
+        if self.current().is_none() {
+            // We're already at the null for the end of the sibling list.
+            return Ok(None);
+        }
+
+        // Loop until we find an entry at the current level.
+        let mut depth = 0;
+        loop {
+            // Use is_some() and unwrap() to keep borrow checker happy.
+            if self.current().is_some() && self.current().unwrap().has_children() {
+                if let Some(sibling_input) = self.current().unwrap().sibling() {
+                    // Fast path: this entry has a DW_AT_sibling
+                    // attribute pointing to its sibling, so jump
+                    // to it (which keeps us at the same depth).
+                    self.input = sibling_input;
+                    self.cached_current = None;
+                } else {
+                    // This entry has children, so the next entry is
+                    // down one level.
+                    depth += 1;
+                }
+            }
+
+            if self.next_entry()?.is_none() {
+                // End of input.
+                return Ok(None);
+            }
+
+            if depth == 0 {
+                // Found an entry at the current level.
+                return Ok(self.current());
+            }
+
+            if self.current().is_none() {
+                // A null entry means the end of a child list, so we're
+                // back up a level.
+                depth -= 1;
+            }
+        }
+    }
+}
+
+/// The state information for a tree view of the Debugging Information Entries.
+///
+/// The `EntriesTree` can be used to recursively iterate through the DIE
+/// tree, following the parent/child relationships. The `EntriesTree` contains
+/// shared state for all nodes in the tree, avoiding any duplicate parsing of
+/// entries during the traversal.
+///
+/// ## Example Usage
+/// ```rust,no_run
+/// # fn example() -> Result<(), gimli::Error> {
+/// # let debug_info = gimli::DebugInfo::new(&[], gimli::LittleEndian);
+/// # let get_some_unit = || debug_info.units().next().unwrap().unwrap();
+/// let unit = get_some_unit();
+/// # let debug_abbrev = gimli::DebugAbbrev::new(&[], gimli::LittleEndian);
+/// # let get_abbrevs_for_unit = |_| unit.abbreviations(&debug_abbrev).unwrap();
+/// let abbrevs = get_abbrevs_for_unit(&unit);
+///
+/// let mut tree = unit.entries_tree(&abbrevs, None)?;
+/// let root = tree.root()?;
+/// process_tree(root)?;
+/// # unreachable!()
+/// # }
+///
+/// fn process_tree<R>(mut node: gimli::EntriesTreeNode<R>) -> gimli::Result<()>
+///     where R: gimli::Reader
+/// {
+///     {
+///         // Examine the entry attributes.
+///         let mut attrs = node.entry().attrs();
+///         while let Some(attr) = attrs.next()? {
+///         }
+///     }
+///     let mut children = node.children();
+///     while let Some(child) = children.next()? {
+///         // Recursively process a child.
+///         process_tree(child);
+///     }
+///     Ok(())
+/// }
+/// ```
+#[derive(Clone, Debug)]
+pub struct EntriesTree<'abbrev, 'unit, R>
+where
+    R: Reader,
+{
+    root: R,
+    unit: &'unit UnitHeader<R>,
+    abbreviations: &'abbrev Abbreviations,
+    input: R,
+    entry: Option<DebuggingInformationEntry<'abbrev, 'unit, R>>,
+    depth: isize,
+}
+
+impl<'abbrev, 'unit, R: Reader> EntriesTree<'abbrev, 'unit, R> {
+    fn new(root: R, unit: &'unit UnitHeader<R>, abbreviations: &'abbrev Abbreviations) -> Self {
+        let input = root.clone();
+        EntriesTree {
+            root,
+            unit,
+            abbreviations,
+            input,
+            entry: None,
+            depth: 0,
+        }
+    }
+
+    /// Returns the root node of the tree.
+    pub fn root<'me>(&'me mut self) -> Result<EntriesTreeNode<'abbrev, 'unit, 'me, R>> {
+        self.input = self.root.clone();
+        self.entry =
+            DebuggingInformationEntry::parse(&mut self.input, self.unit, self.abbreviations)?;
+        if self.entry.is_none() {
+            return Err(Error::UnexpectedNull);
+        }
+        self.depth = 0;
+        Ok(EntriesTreeNode::new(self, 1))
+    }
+
+    /// Move the cursor to the next entry at the specified depth.
+    ///
+    /// Requires `depth <= self.depth + 1`.
+    ///
+    /// Returns `true` if successful.
+    fn next(&mut self, depth: isize) -> Result<bool> {
+        if self.depth < depth {
+            debug_assert_eq!(self.depth + 1, depth);
+
+            match self.entry {
+                Some(ref entry) => {
+                    if !entry.has_children() {
+                        return Ok(false);
+                    }
+                    self.depth += 1;
+                    self.input = entry.after_attrs()?;
+                }
+                None => return Ok(false),
+            }
+
+            if self.input.is_empty() {
+                self.entry = None;
+                return Ok(false);
+            }
+
+            return match DebuggingInformationEntry::parse(
+                &mut self.input,
+                self.unit,
+                self.abbreviations,
+            ) {
+                Ok(entry) => {
+                    self.entry = entry;
+                    Ok(self.entry.is_some())
+                }
+                Err(e) => {
+                    self.input.empty();
+                    self.entry = None;
+                    Err(e)
+                }
+            };
+        }
+
+        loop {
+            match self.entry {
+                Some(ref entry) => {
+                    if entry.has_children() {
+                        if let Some(sibling_input) = entry.sibling() {
+                            // Fast path: this entry has a DW_AT_sibling
+                            // attribute pointing to its sibling, so jump
+                            // to it (which keeps us at the same depth).
+                            self.input = sibling_input;
+                        } else {
+                            // This entry has children, so the next entry is
+                            // down one level.
+                            self.depth += 1;
+                            self.input = entry.after_attrs()?;
+                        }
+                    } else {
+                        // This entry has no children, so next entry is at same depth.
+                        self.input = entry.after_attrs()?;
+                    }
+                }
+                None => {
+                    // This entry is a null, so next entry is up one level.
+                    self.depth -= 1;
+                }
+            }
+
+            if self.input.is_empty() {
+                self.entry = None;
+                return Ok(false);
+            }
+
+            match DebuggingInformationEntry::parse(&mut self.input, self.unit, self.abbreviations) {
+                Ok(entry) => {
+                    self.entry = entry;
+                    if self.depth == depth {
+                        return Ok(self.entry.is_some());
+                    }
+                }
+                Err(e) => {
+                    self.input.empty();
+                    self.entry = None;
+                    return Err(e);
+                }
+            }
+        }
+    }
+}
+
+/// A node in the Debugging Information Entry tree.
+///
+/// The root node of a tree can be obtained
+/// via [`EntriesTree::root`](./struct.EntriesTree.html#method.root).
+#[derive(Debug)]
+pub struct EntriesTreeNode<'abbrev, 'unit, 'tree, R: Reader> {
+    tree: &'tree mut EntriesTree<'abbrev, 'unit, R>,
+    depth: isize,
+}
+
+impl<'abbrev, 'unit, 'tree, R: Reader> EntriesTreeNode<'abbrev, 'unit, 'tree, R> {
+    fn new(
+        tree: &'tree mut EntriesTree<'abbrev, 'unit, R>,
+        depth: isize,
+    ) -> EntriesTreeNode<'abbrev, 'unit, 'tree, R> {
+        debug_assert!(tree.entry.is_some());
+        EntriesTreeNode { tree, depth }
+    }
+
+    /// Returns the current entry in the tree.
+    pub fn entry(&self) -> &DebuggingInformationEntry<'abbrev, 'unit, R> {
+        // We never create a node without an entry.
+        self.tree.entry.as_ref().unwrap()
+    }
+
+    /// Create an iterator for the children of the current entry.
+    ///
+    /// The current entry can no longer be accessed after creating the
+    /// iterator.
+    pub fn children(self) -> EntriesTreeIter<'abbrev, 'unit, 'tree, R> {
+        EntriesTreeIter::new(self.tree, self.depth)
+    }
+}
+
+/// An iterator that allows traversal of the children of an
+/// `EntriesTreeNode`.
+///
+/// The items returned by this iterator are also `EntriesTreeNode`s,
+/// which allow recursive traversal of grandchildren, etc.
+#[derive(Debug)]
+pub struct EntriesTreeIter<'abbrev, 'unit, 'tree, R: Reader> {
+    tree: &'tree mut EntriesTree<'abbrev, 'unit, R>,
+    depth: isize,
+    empty: bool,
+}
+
+impl<'abbrev, 'unit, 'tree, R: Reader> EntriesTreeIter<'abbrev, 'unit, 'tree, R> {
+    fn new(
+        tree: &'tree mut EntriesTree<'abbrev, 'unit, R>,
+        depth: isize,
+    ) -> EntriesTreeIter<'abbrev, 'unit, 'tree, R> {
+        EntriesTreeIter {
+            tree,
+            depth,
+            empty: false,
+        }
+    }
+
+    /// Returns an `EntriesTreeNode` for the next child entry.
+    ///
+    /// Returns `None` if there are no more children.
+    pub fn next<'me>(&'me mut self) -> Result<Option<EntriesTreeNode<'abbrev, 'unit, 'me, R>>> {
+        if self.empty {
+            Ok(None)
+        } else if self.tree.next(self.depth)? {
+            Ok(Some(EntriesTreeNode::new(self.tree, self.depth + 1)))
+        } else {
+            self.empty = true;
+            Ok(None)
+        }
+    }
+}
+
+/// Parse a type unit header's unique type signature. Callers should handle
+/// unique-ness checking.
+fn parse_type_signature<R: Reader>(input: &mut R) -> Result<DebugTypeSignature> {
+    input.read_u64().map(DebugTypeSignature)
+}
+
+/// Parse a type unit header's type offset.
+fn parse_type_offset<R: Reader>(input: &mut R, format: Format) -> Result<UnitOffset<R::Offset>> {
+    input.read_offset(format).map(UnitOffset)
+}
+
+/// The `DebugTypes` struct represents the DWARF type information
+/// found in the `.debug_types` section.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct DebugTypes<R> {
+    debug_types_section: R,
+}
+
+impl<'input, Endian> DebugTypes<EndianSlice<'input, Endian>>
+where
+    Endian: Endianity,
+{
+    /// Construct a new `DebugTypes` instance from the data in the `.debug_types`
+    /// section.
+    ///
+    /// It is the caller's responsibility to read the `.debug_types` section and
+    /// present it as a `&[u8]` slice. That means using some ELF loader on
+    /// Linux, a Mach-O loader on macOS, etc.
+    ///
+    /// ```
+    /// use gimli::{DebugTypes, LittleEndian};
+    ///
+    /// # let buf = [0x00, 0x01, 0x02, 0x03];
+    /// # let read_debug_types_section_somehow = || &buf;
+    /// let debug_types = DebugTypes::new(read_debug_types_section_somehow(), LittleEndian);
+    /// ```
+    pub fn new(debug_types_section: &'input [u8], endian: Endian) -> Self {
+        Self::from(EndianSlice::new(debug_types_section, endian))
+    }
+}
+
+impl<T> DebugTypes<T> {
+    /// Create a `DebugTypes` section that references the data in `self`.
+    ///
+    /// This is useful when `R` implements `Reader` but `T` does not.
+    ///
+    /// ## Example Usage
+    ///
+    /// ```rust,no_run
+    /// # let load_section = || unimplemented!();
+    /// // Read the DWARF section into a `Vec` with whatever object loader you're using.
+    /// let owned_section: gimli::DebugTypes<Vec<u8>> = load_section();
+    /// // Create a reference to the DWARF section.
+    /// let section = owned_section.borrow(|section| {
+    ///     gimli::EndianSlice::new(&section, gimli::LittleEndian)
+    /// });
+    /// ```
+    pub fn borrow<'a, F, R>(&'a self, mut borrow: F) -> DebugTypes<R>
+    where
+        F: FnMut(&'a T) -> R,
+    {
+        borrow(&self.debug_types_section).into()
+    }
+}
+
+impl<R> Section<R> for DebugTypes<R> {
+    fn id() -> SectionId {
+        SectionId::DebugTypes
+    }
+
+    fn reader(&self) -> &R {
+        &self.debug_types_section
+    }
+}
+
+impl<R> From<R> for DebugTypes<R> {
+    fn from(debug_types_section: R) -> Self {
+        DebugTypes {
+            debug_types_section,
+        }
+    }
+}
+
+impl<R: Reader> DebugTypes<R> {
+    /// Iterate the type-units in this `.debug_types` section.
+    ///
+    /// ```
+    /// use gimli::{DebugTypes, LittleEndian};
+    ///
+    /// # let buf = [];
+    /// # let read_debug_types_section_somehow = || &buf;
+    /// let debug_types = DebugTypes::new(read_debug_types_section_somehow(), LittleEndian);
+    ///
+    /// let mut iter = debug_types.units();
+    /// while let Some(unit) = iter.next().unwrap() {
+    ///     println!("unit's length is {}", unit.unit_length());
+    /// }
+    /// ```
+    ///
+    /// Can be [used with
+    /// `FallibleIterator`](./index.html#using-with-fallibleiterator).
+    pub fn units(&self) -> DebugTypesUnitHeadersIter<R> {
+        DebugTypesUnitHeadersIter {
+            input: self.debug_types_section.clone(),
+            offset: DebugTypesOffset(R::Offset::from_u8(0)),
+        }
+    }
+}
+
+/// An iterator over the type-units of this `.debug_types` section.
+///
+/// See the [documentation on
+/// `DebugTypes::units`](./struct.DebugTypes.html#method.units) for
+/// more detail.
+#[derive(Clone, Debug)]
+pub struct DebugTypesUnitHeadersIter<R: Reader> {
+    input: R,
+    offset: DebugTypesOffset<R::Offset>,
+}
+
+impl<R: Reader> DebugTypesUnitHeadersIter<R> {
+    /// Advance the iterator to the next type unit header.
+    pub fn next(&mut self) -> Result<Option<UnitHeader<R>>> {
+        if self.input.is_empty() {
+            Ok(None)
+        } else {
+            let len = self.input.len();
+            match parse_unit_header(&mut self.input, self.offset.into()) {
+                Ok(header) => {
+                    self.offset.0 += len - self.input.len();
+                    Ok(Some(header))
+                }
+                Err(e) => {
+                    self.input.empty();
+                    Err(e)
+                }
+            }
+        }
+    }
+}
+
+#[cfg(feature = "fallible-iterator")]
+impl<R: Reader> fallible_iterator::FallibleIterator for DebugTypesUnitHeadersIter<R> {
+    type Item = UnitHeader<R>;
+    type Error = Error;
+
+    fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> {
+        DebugTypesUnitHeadersIter::next(self)
+    }
+}
+
+#[cfg(test)]
+// Tests require leb128::write.
+#[cfg(feature = "write")]
+mod tests {
+    use super::*;
+    use crate::constants;
+    use crate::constants::*;
+    use crate::endianity::{Endianity, LittleEndian};
+    use crate::leb128;
+    use crate::read::abbrev::tests::AbbrevSectionMethods;
+    use crate::read::{
+        Abbreviation, AttributeSpecification, DebugAbbrev, EndianSlice, Error, Result,
+    };
+    use crate::test_util::GimliSectionMethods;
+    use alloc::vec::Vec;
+    use core::cell::Cell;
+    use test_assembler::{Endian, Label, LabelMaker, Section};
+
+    // Mixin methods for `Section` to help define binary test data.
+
+    trait UnitSectionMethods {
+        fn unit<'input, E>(self, unit: &mut UnitHeader<EndianSlice<'input, E>>) -> Self
+        where
+            E: Endianity;
+        fn die<F>(self, code: u64, attr: F) -> Self
+        where
+            F: Fn(Section) -> Section;
+        fn die_null(self) -> Self;
+        fn attr_string(self, s: &str) -> Self;
+        fn attr_ref1(self, o: u8) -> Self;
+        fn offset(self, offset: usize, format: Format) -> Self;
+    }
+
+    impl UnitSectionMethods for Section {
+        fn unit<'input, E>(self, unit: &mut UnitHeader<EndianSlice<'input, E>>) -> Self
+        where
+            E: Endianity,
+        {
+            let size = self.size();
+            let length = Label::new();
+            let start = Label::new();
+            let end = Label::new();
+
+            let section = match unit.format() {
+                Format::Dwarf32 => self.L32(&length),
+                Format::Dwarf64 => self.L32(0xffff_ffff).L64(&length),
+            };
+
+            let section = match unit.version() {
+                2 | 3 | 4 => section
+                    .mark(&start)
+                    .L16(unit.version())
+                    .offset(unit.debug_abbrev_offset.0, unit.format())
+                    .D8(unit.address_size()),
+                5 => section
+                    .mark(&start)
+                    .L16(unit.version())
+                    .D8(unit.type_().dw_ut().0)
+                    .D8(unit.address_size())
+                    .offset(unit.debug_abbrev_offset.0, unit.format()),
+                _ => unreachable!(),
+            };
+
+            let section = match unit.type_() {
+                UnitType::Compilation | UnitType::Partial => {
+                    unit.unit_offset = DebugInfoOffset(size as usize).into();
+                    section
+                }
+                UnitType::Type {
+                    type_signature,
+                    type_offset,
+                }
+                | UnitType::SplitType {
+                    type_signature,
+                    type_offset,
+                } => {
+                    if unit.version() == 5 {
+                        unit.unit_offset = DebugInfoOffset(size as usize).into();
+                    } else {
+                        unit.unit_offset = DebugTypesOffset(size as usize).into();
+                    }
+                    section
+                        .L64(type_signature.0)
+                        .offset(type_offset.0, unit.format())
+                }
+                UnitType::Skeleton(dwo_id) | UnitType::SplitCompilation(dwo_id) => {
+                    unit.unit_offset = DebugInfoOffset(size as usize).into();
+                    section.L64(dwo_id.0)
+                }
+            };
+
+            let section = section.append_bytes(unit.entries_buf.slice()).mark(&end);
+
+            unit.unit_length = (&end - &start) as usize;
+            length.set_const(unit.unit_length as u64);
+
+            section
+        }
+
+        fn die<F>(self, code: u64, attr: F) -> Self
+        where
+            F: Fn(Section) -> Section,
+        {
+            let section = self.uleb(code);
+            attr(section)
+        }
+
+        fn die_null(self) -> Self {
+            self.D8(0)
+        }
+
+        fn attr_string(self, attr: &str) -> Self {
+            self.append_bytes(attr.as_bytes()).D8(0)
+        }
+
+        fn attr_ref1(self, attr: u8) -> Self {
+            self.D8(attr)
+        }
+
+        fn offset(self, offset: usize, format: Format) -> Self {
+            match format {
+                Format::Dwarf32 => self.L32(offset as u32),
+                Format::Dwarf64 => self.L64(offset as u64),
+            }
+        }
+    }
+
+    /// Ensure that `UnitHeader<R>` is covariant wrt R.
+    #[test]
+    fn test_unit_header_variance() {
+        /// This only needs to compile.
+        fn _f<'a: 'b, 'b, E: Endianity>(
+            x: UnitHeader<EndianSlice<'a, E>>,
+        ) -> UnitHeader<EndianSlice<'b, E>> {
+            x
+        }
+    }
+
+    #[test]
+    fn test_parse_debug_abbrev_offset_32() {
+        let section = Section::with_endian(Endian::Little).L32(0x0403_0201);
+        let buf = section.get_contents().unwrap();
+        let buf = &mut EndianSlice::new(&buf, LittleEndian);
+
+        match parse_debug_abbrev_offset(buf, Format::Dwarf32) {
+            Ok(val) => assert_eq!(val, DebugAbbrevOffset(0x0403_0201)),
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    fn test_parse_debug_abbrev_offset_32_incomplete() {
+        let buf = [0x01, 0x02];
+        let buf = &mut EndianSlice::new(&buf, LittleEndian);
+
+        match parse_debug_abbrev_offset(buf, Format::Dwarf32) {
+            Err(Error::UnexpectedEof(_)) => assert!(true),
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_debug_abbrev_offset_64() {
+        let section = Section::with_endian(Endian::Little).L64(0x0807_0605_0403_0201);
+        let buf = section.get_contents().unwrap();
+        let buf = &mut EndianSlice::new(&buf, LittleEndian);
+
+        match parse_debug_abbrev_offset(buf, Format::Dwarf64) {
+            Ok(val) => assert_eq!(val, DebugAbbrevOffset(0x0807_0605_0403_0201)),
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    fn test_parse_debug_abbrev_offset_64_incomplete() {
+        let buf = [0x01, 0x02];
+        let buf = &mut EndianSlice::new(&buf, LittleEndian);
+
+        match parse_debug_abbrev_offset(buf, Format::Dwarf64) {
+            Err(Error::UnexpectedEof(_)) => assert!(true),
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    fn test_parse_debug_info_offset_32() {
+        let section = Section::with_endian(Endian::Little).L32(0x0403_0201);
+        let buf = section.get_contents().unwrap();
+        let buf = &mut EndianSlice::new(&buf, LittleEndian);
+
+        match parse_debug_info_offset(buf, Format::Dwarf32) {
+            Ok(val) => assert_eq!(val, DebugInfoOffset(0x0403_0201)),
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    fn test_parse_debug_info_offset_32_incomplete() {
+        let buf = [0x01, 0x02];
+        let buf = &mut EndianSlice::new(&buf, LittleEndian);
+
+        match parse_debug_info_offset(buf, Format::Dwarf32) {
+            Err(Error::UnexpectedEof(_)) => assert!(true),
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_debug_info_offset_64() {
+        let section = Section::with_endian(Endian::Little).L64(0x0807_0605_0403_0201);
+        let buf = section.get_contents().unwrap();
+        let buf = &mut EndianSlice::new(&buf, LittleEndian);
+
+        match parse_debug_info_offset(buf, Format::Dwarf64) {
+            Ok(val) => assert_eq!(val, DebugInfoOffset(0x0807_0605_0403_0201)),
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    fn test_parse_debug_info_offset_64_incomplete() {
+        let buf = [0x01, 0x02];
+        let buf = &mut EndianSlice::new(&buf, LittleEndian);
+
+        match parse_debug_info_offset(buf, Format::Dwarf64) {
+            Err(Error::UnexpectedEof(_)) => assert!(true),
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_units() {
+        let expected_rest = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let mut unit64 = UnitHeader {
+            encoding: Encoding {
+                format: Format::Dwarf64,
+                version: 4,
+                address_size: 8,
+            },
+            unit_length: 0,
+            unit_type: UnitType::Compilation,
+            debug_abbrev_offset: DebugAbbrevOffset(0x0102_0304_0506_0708),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(expected_rest, LittleEndian),
+        };
+        let mut unit32 = UnitHeader {
+            encoding: Encoding {
+                format: Format::Dwarf32,
+                version: 4,
+                address_size: 4,
+            },
+            unit_length: 0,
+            unit_type: UnitType::Compilation,
+            debug_abbrev_offset: DebugAbbrevOffset(0x0807_0605),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(expected_rest, LittleEndian),
+        };
+        let section = Section::with_endian(Endian::Little)
+            .unit(&mut unit64)
+            .unit(&mut unit32);
+        let buf = section.get_contents().unwrap();
+
+        let debug_info = DebugInfo::new(&buf, LittleEndian);
+        let mut units = debug_info.units();
+
+        assert_eq!(units.next(), Ok(Some(unit64)));
+        assert_eq!(units.next(), Ok(Some(unit32)));
+        assert_eq!(units.next(), Ok(None));
+    }
+
+    #[test]
+    fn test_unit_version_unknown_version() {
+        let buf = [0x02, 0x00, 0x00, 0x00, 0xab, 0xcd];
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        match parse_unit_header(rest, DebugInfoOffset(0).into()) {
+            Err(Error::UnknownVersion(0xcdab)) => assert!(true),
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+
+        let buf = [0x02, 0x00, 0x00, 0x00, 0x1, 0x0];
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        match parse_unit_header(rest, DebugInfoOffset(0).into()) {
+            Err(Error::UnknownVersion(1)) => assert!(true),
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    fn test_unit_version_incomplete() {
+        let buf = [0x01, 0x00, 0x00, 0x00, 0x04];
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        match parse_unit_header(rest, DebugInfoOffset(0).into()) {
+            Err(Error::UnexpectedEof(_)) => assert!(true),
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    fn test_parse_unit_header_32_ok() {
+        let expected_rest = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 4,
+        };
+        let mut expected_unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Compilation,
+            debug_abbrev_offset: DebugAbbrevOffset(0x0807_0605),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(expected_rest, LittleEndian),
+        };
+        let section = Section::with_endian(Endian::Little)
+            .unit(&mut expected_unit)
+            .append_bytes(expected_rest);
+        let buf = section.get_contents().unwrap();
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        assert_eq!(
+            parse_unit_header(rest, DebugInfoOffset(0).into()),
+            Ok(expected_unit)
+        );
+        assert_eq!(*rest, EndianSlice::new(expected_rest, LittleEndian));
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_unit_header_64_ok() {
+        let expected_rest = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let encoding = Encoding {
+            format: Format::Dwarf64,
+            version: 4,
+            address_size: 8,
+        };
+        let mut expected_unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Compilation,
+            debug_abbrev_offset: DebugAbbrevOffset(0x0102_0304_0506_0708),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(expected_rest, LittleEndian),
+        };
+        let section = Section::with_endian(Endian::Little)
+            .unit(&mut expected_unit)
+            .append_bytes(expected_rest);
+        let buf = section.get_contents().unwrap();
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        assert_eq!(
+            parse_unit_header(rest, DebugInfoOffset(0).into()),
+            Ok(expected_unit)
+        );
+        assert_eq!(*rest, EndianSlice::new(expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_v5_unit_header_32_ok() {
+        let expected_rest = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 5,
+            address_size: 4,
+        };
+        let mut expected_unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Compilation,
+            debug_abbrev_offset: DebugAbbrevOffset(0x0807_0605),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(expected_rest, LittleEndian),
+        };
+        let section = Section::with_endian(Endian::Little)
+            .unit(&mut expected_unit)
+            .append_bytes(expected_rest);
+        let buf = section.get_contents().unwrap();
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        assert_eq!(
+            parse_unit_header(rest, DebugInfoOffset(0).into()),
+            Ok(expected_unit)
+        );
+        assert_eq!(*rest, EndianSlice::new(expected_rest, LittleEndian));
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_v5_unit_header_64_ok() {
+        let expected_rest = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let encoding = Encoding {
+            format: Format::Dwarf64,
+            version: 5,
+            address_size: 8,
+        };
+        let mut expected_unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Compilation,
+            debug_abbrev_offset: DebugAbbrevOffset(0x0102_0304_0506_0708),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(expected_rest, LittleEndian),
+        };
+        let section = Section::with_endian(Endian::Little)
+            .unit(&mut expected_unit)
+            .append_bytes(expected_rest);
+        let buf = section.get_contents().unwrap();
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        assert_eq!(
+            parse_unit_header(rest, DebugInfoOffset(0).into()),
+            Ok(expected_unit)
+        );
+        assert_eq!(*rest, EndianSlice::new(expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_v5_partial_unit_header_32_ok() {
+        let expected_rest = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 5,
+            address_size: 4,
+        };
+        let mut expected_unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Partial,
+            debug_abbrev_offset: DebugAbbrevOffset(0x0807_0605),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(expected_rest, LittleEndian),
+        };
+        let section = Section::with_endian(Endian::Little)
+            .unit(&mut expected_unit)
+            .append_bytes(expected_rest);
+        let buf = section.get_contents().unwrap();
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        assert_eq!(
+            parse_unit_header(rest, DebugInfoOffset(0).into()),
+            Ok(expected_unit)
+        );
+        assert_eq!(*rest, EndianSlice::new(expected_rest, LittleEndian));
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_v5_partial_unit_header_64_ok() {
+        let expected_rest = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let encoding = Encoding {
+            format: Format::Dwarf64,
+            version: 5,
+            address_size: 8,
+        };
+        let mut expected_unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Partial,
+            debug_abbrev_offset: DebugAbbrevOffset(0x0102_0304_0506_0708),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(expected_rest, LittleEndian),
+        };
+        let section = Section::with_endian(Endian::Little)
+            .unit(&mut expected_unit)
+            .append_bytes(expected_rest);
+        let buf = section.get_contents().unwrap();
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        assert_eq!(
+            parse_unit_header(rest, DebugInfoOffset(0).into()),
+            Ok(expected_unit)
+        );
+        assert_eq!(*rest, EndianSlice::new(expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_v5_skeleton_unit_header_32_ok() {
+        let expected_rest = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 5,
+            address_size: 4,
+        };
+        let mut expected_unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Skeleton(DwoId(0x0706_5040_0302_1000)),
+            debug_abbrev_offset: DebugAbbrevOffset(0x0807_0605),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(expected_rest, LittleEndian),
+        };
+        let section = Section::with_endian(Endian::Little)
+            .unit(&mut expected_unit)
+            .append_bytes(expected_rest);
+        let buf = section.get_contents().unwrap();
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        assert_eq!(
+            parse_unit_header(rest, DebugInfoOffset(0).into()),
+            Ok(expected_unit)
+        );
+        assert_eq!(*rest, EndianSlice::new(expected_rest, LittleEndian));
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_v5_skeleton_unit_header_64_ok() {
+        let expected_rest = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let encoding = Encoding {
+            format: Format::Dwarf64,
+            version: 5,
+            address_size: 8,
+        };
+        let mut expected_unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Skeleton(DwoId(0x0706_5040_0302_1000)),
+            debug_abbrev_offset: DebugAbbrevOffset(0x0102_0304_0506_0708),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(expected_rest, LittleEndian),
+        };
+        let section = Section::with_endian(Endian::Little)
+            .unit(&mut expected_unit)
+            .append_bytes(expected_rest);
+        let buf = section.get_contents().unwrap();
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        assert_eq!(
+            parse_unit_header(rest, DebugInfoOffset(0).into()),
+            Ok(expected_unit)
+        );
+        assert_eq!(*rest, EndianSlice::new(expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_v5_split_compilation_unit_header_32_ok() {
+        let expected_rest = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 5,
+            address_size: 4,
+        };
+        let mut expected_unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::SplitCompilation(DwoId(0x0706_5040_0302_1000)),
+            debug_abbrev_offset: DebugAbbrevOffset(0x0807_0605),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(expected_rest, LittleEndian),
+        };
+        let section = Section::with_endian(Endian::Little)
+            .unit(&mut expected_unit)
+            .append_bytes(expected_rest);
+        let buf = section.get_contents().unwrap();
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        assert_eq!(
+            parse_unit_header(rest, DebugInfoOffset(0).into()),
+            Ok(expected_unit)
+        );
+        assert_eq!(*rest, EndianSlice::new(expected_rest, LittleEndian));
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_v5_split_compilation_unit_header_64_ok() {
+        let expected_rest = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let encoding = Encoding {
+            format: Format::Dwarf64,
+            version: 5,
+            address_size: 8,
+        };
+        let mut expected_unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::SplitCompilation(DwoId(0x0706_5040_0302_1000)),
+            debug_abbrev_offset: DebugAbbrevOffset(0x0102_0304_0506_0708),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(expected_rest, LittleEndian),
+        };
+        let section = Section::with_endian(Endian::Little)
+            .unit(&mut expected_unit)
+            .append_bytes(expected_rest);
+        let buf = section.get_contents().unwrap();
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        assert_eq!(
+            parse_unit_header(rest, DebugInfoOffset(0).into()),
+            Ok(expected_unit)
+        );
+        assert_eq!(*rest, EndianSlice::new(expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_type_offset_32_ok() {
+        let buf = [0x12, 0x34, 0x56, 0x78, 0x00];
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        match parse_type_offset(rest, Format::Dwarf32) {
+            Ok(offset) => {
+                assert_eq!(rest.len(), 1);
+                assert_eq!(UnitOffset(0x7856_3412), offset);
+            }
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        }
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_type_offset_64_ok() {
+        let buf = [0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xff, 0x00];
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        match parse_type_offset(rest, Format::Dwarf64) {
+            Ok(offset) => {
+                assert_eq!(rest.len(), 1);
+                assert_eq!(UnitOffset(0xffde_bc9a_7856_3412), offset);
+            }
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        }
+    }
+
+    #[test]
+    fn test_parse_type_offset_incomplete() {
+        // Need at least 4 bytes.
+        let buf = [0xff, 0xff, 0xff];
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        match parse_type_offset(rest, Format::Dwarf32) {
+            Err(Error::UnexpectedEof(_)) => assert!(true),
+            otherwise => panic!("Unexpected result: {:?}", otherwise),
+        };
+    }
+
+    #[test]
+    fn test_parse_type_unit_header_32_ok() {
+        let expected_rest = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 8,
+        };
+        let mut expected_unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Type {
+                type_signature: DebugTypeSignature(0xdead_beef_dead_beef),
+                type_offset: UnitOffset(0x7856_3412),
+            },
+            debug_abbrev_offset: DebugAbbrevOffset(0x0807_0605),
+            unit_offset: DebugTypesOffset(0).into(),
+            entries_buf: EndianSlice::new(expected_rest, LittleEndian),
+        };
+        let section = Section::with_endian(Endian::Little)
+            .unit(&mut expected_unit)
+            .append_bytes(expected_rest);
+        let buf = section.get_contents().unwrap();
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        assert_eq!(
+            parse_unit_header(rest, DebugTypesOffset(0).into()),
+            Ok(expected_unit)
+        );
+        assert_eq!(*rest, EndianSlice::new(expected_rest, LittleEndian));
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_type_unit_header_64_ok() {
+        let expected_rest = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let encoding = Encoding {
+            format: Format::Dwarf64,
+            version: 4,
+            address_size: 8,
+        };
+        let mut expected_unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Type {
+                type_signature: DebugTypeSignature(0xdead_beef_dead_beef),
+                type_offset: UnitOffset(0x7856_3412_7856_3412),
+            },
+            debug_abbrev_offset: DebugAbbrevOffset(0x0807_0605),
+            unit_offset: DebugTypesOffset(0).into(),
+            entries_buf: EndianSlice::new(expected_rest, LittleEndian),
+        };
+        let section = Section::with_endian(Endian::Little)
+            .unit(&mut expected_unit)
+            .append_bytes(expected_rest);
+        let buf = section.get_contents().unwrap();
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        assert_eq!(
+            parse_unit_header(rest, DebugTypesOffset(0).into()),
+            Ok(expected_unit)
+        );
+        assert_eq!(*rest, EndianSlice::new(expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_v5_type_unit_header_32_ok() {
+        let expected_rest = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 5,
+            address_size: 8,
+        };
+        let mut expected_unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Type {
+                type_signature: DebugTypeSignature(0xdead_beef_dead_beef),
+                type_offset: UnitOffset(0x7856_3412),
+            },
+            debug_abbrev_offset: DebugAbbrevOffset(0x0807_0605),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(expected_rest, LittleEndian),
+        };
+        let section = Section::with_endian(Endian::Little)
+            .unit(&mut expected_unit)
+            .append_bytes(expected_rest);
+        let buf = section.get_contents().unwrap();
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        assert_eq!(
+            parse_unit_header(rest, DebugInfoOffset(0).into()),
+            Ok(expected_unit)
+        );
+        assert_eq!(*rest, EndianSlice::new(expected_rest, LittleEndian));
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_v5_type_unit_header_64_ok() {
+        let expected_rest = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let encoding = Encoding {
+            format: Format::Dwarf64,
+            version: 5,
+            address_size: 8,
+        };
+        let mut expected_unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Type {
+                type_signature: DebugTypeSignature(0xdead_beef_dead_beef),
+                type_offset: UnitOffset(0x7856_3412_7856_3412),
+            },
+            debug_abbrev_offset: DebugAbbrevOffset(0x0807_0605),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(expected_rest, LittleEndian),
+        };
+        let section = Section::with_endian(Endian::Little)
+            .unit(&mut expected_unit)
+            .append_bytes(expected_rest);
+        let buf = section.get_contents().unwrap();
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        assert_eq!(
+            parse_unit_header(rest, DebugInfoOffset(0).into()),
+            Ok(expected_unit)
+        );
+        assert_eq!(*rest, EndianSlice::new(expected_rest, LittleEndian));
+    }
+
+    #[test]
+    fn test_parse_v5_split_type_unit_header_32_ok() {
+        let expected_rest = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 5,
+            address_size: 8,
+        };
+        let mut expected_unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::SplitType {
+                type_signature: DebugTypeSignature(0xdead_beef_dead_beef),
+                type_offset: UnitOffset(0x7856_3412),
+            },
+            debug_abbrev_offset: DebugAbbrevOffset(0x0807_0605),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(expected_rest, LittleEndian),
+        };
+        let section = Section::with_endian(Endian::Little)
+            .unit(&mut expected_unit)
+            .append_bytes(expected_rest);
+        let buf = section.get_contents().unwrap();
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        assert_eq!(
+            parse_unit_header(rest, DebugInfoOffset(0).into()),
+            Ok(expected_unit)
+        );
+        assert_eq!(*rest, EndianSlice::new(expected_rest, LittleEndian));
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_v5_split_type_unit_header_64_ok() {
+        let expected_rest = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let encoding = Encoding {
+            format: Format::Dwarf64,
+            version: 5,
+            address_size: 8,
+        };
+        let mut expected_unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::SplitType {
+                type_signature: DebugTypeSignature(0xdead_beef_dead_beef),
+                type_offset: UnitOffset(0x7856_3412_7856_3412),
+            },
+            debug_abbrev_offset: DebugAbbrevOffset(0x0807_0605),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(expected_rest, LittleEndian),
+        };
+        let section = Section::with_endian(Endian::Little)
+            .unit(&mut expected_unit)
+            .append_bytes(expected_rest);
+        let buf = section.get_contents().unwrap();
+        let rest = &mut EndianSlice::new(&buf, LittleEndian);
+
+        assert_eq!(
+            parse_unit_header(rest, DebugInfoOffset(0).into()),
+            Ok(expected_unit)
+        );
+        assert_eq!(*rest, EndianSlice::new(expected_rest, LittleEndian));
+    }
+
+    fn section_contents<F>(f: F) -> Vec<u8>
+    where
+        F: Fn(Section) -> Section,
+    {
+        f(Section::with_endian(Endian::Little))
+            .get_contents()
+            .unwrap()
+    }
+
+    #[test]
+    fn test_attribute_value() {
+        let mut unit = test_parse_attribute_unit_default();
+        let endian = unit.entries_buf.endian();
+
+        let block_data = &[1, 2, 3, 4];
+        let buf = section_contents(|s| s.uleb(block_data.len() as u64).append_bytes(block_data));
+        let block = EndianSlice::new(&buf, endian);
+
+        let buf = section_contents(|s| s.L32(0x0102_0304));
+        let data4 = EndianSlice::new(&buf, endian);
+
+        let buf = section_contents(|s| s.L64(0x0102_0304_0506_0708));
+        let data8 = EndianSlice::new(&buf, endian);
+
+        let tests = [
+            (
+                Format::Dwarf32,
+                2,
+                constants::DW_AT_data_member_location,
+                constants::DW_FORM_block,
+                block,
+                AttributeValue::Block(EndianSlice::new(block_data, endian)),
+                AttributeValue::Exprloc(Expression(EndianSlice::new(block_data, endian))),
+            ),
+            (
+                Format::Dwarf32,
+                2,
+                constants::DW_AT_data_member_location,
+                constants::DW_FORM_data4,
+                data4,
+                AttributeValue::SecOffset(0x0102_0304),
+                AttributeValue::LocationListsRef(LocationListsOffset(0x0102_0304)),
+            ),
+            (
+                Format::Dwarf64,
+                2,
+                constants::DW_AT_data_member_location,
+                constants::DW_FORM_data4,
+                data4,
+                AttributeValue::Data4(0x0102_0304),
+                AttributeValue::Udata(0x0102_0304),
+            ),
+            (
+                Format::Dwarf32,
+                4,
+                constants::DW_AT_data_member_location,
+                constants::DW_FORM_data4,
+                data4,
+                AttributeValue::Data4(0x0102_0304),
+                AttributeValue::Udata(0x0102_0304),
+            ),
+            (
+                Format::Dwarf32,
+                2,
+                constants::DW_AT_data_member_location,
+                constants::DW_FORM_data8,
+                data8,
+                AttributeValue::Data8(0x0102_0304_0506_0708),
+                AttributeValue::Udata(0x0102_0304_0506_0708),
+            ),
+            #[cfg(target_pointer_width = "64")]
+            (
+                Format::Dwarf64,
+                2,
+                constants::DW_AT_data_member_location,
+                constants::DW_FORM_data8,
+                data8,
+                AttributeValue::SecOffset(0x0102_0304_0506_0708),
+                AttributeValue::LocationListsRef(LocationListsOffset(0x0102_0304_0506_0708)),
+            ),
+            (
+                Format::Dwarf64,
+                4,
+                constants::DW_AT_data_member_location,
+                constants::DW_FORM_data8,
+                data8,
+                AttributeValue::Data8(0x0102_0304_0506_0708),
+                AttributeValue::Udata(0x0102_0304_0506_0708),
+            ),
+            (
+                Format::Dwarf32,
+                4,
+                constants::DW_AT_location,
+                constants::DW_FORM_data4,
+                data4,
+                AttributeValue::SecOffset(0x0102_0304),
+                AttributeValue::LocationListsRef(LocationListsOffset(0x0102_0304)),
+            ),
+            #[cfg(target_pointer_width = "64")]
+            (
+                Format::Dwarf64,
+                4,
+                constants::DW_AT_location,
+                constants::DW_FORM_data8,
+                data8,
+                AttributeValue::SecOffset(0x0102_0304_0506_0708),
+                AttributeValue::LocationListsRef(LocationListsOffset(0x0102_0304_0506_0708)),
+            ),
+            (
+                Format::Dwarf32,
+                4,
+                constants::DW_AT_str_offsets_base,
+                constants::DW_FORM_sec_offset,
+                data4,
+                AttributeValue::SecOffset(0x0102_0304),
+                AttributeValue::DebugStrOffsetsBase(DebugStrOffsetsBase(0x0102_0304)),
+            ),
+            (
+                Format::Dwarf32,
+                4,
+                constants::DW_AT_stmt_list,
+                constants::DW_FORM_sec_offset,
+                data4,
+                AttributeValue::SecOffset(0x0102_0304),
+                AttributeValue::DebugLineRef(DebugLineOffset(0x0102_0304)),
+            ),
+            (
+                Format::Dwarf32,
+                4,
+                constants::DW_AT_addr_base,
+                constants::DW_FORM_sec_offset,
+                data4,
+                AttributeValue::SecOffset(0x0102_0304),
+                AttributeValue::DebugAddrBase(DebugAddrBase(0x0102_0304)),
+            ),
+            (
+                Format::Dwarf32,
+                4,
+                constants::DW_AT_rnglists_base,
+                constants::DW_FORM_sec_offset,
+                data4,
+                AttributeValue::SecOffset(0x0102_0304),
+                AttributeValue::DebugRngListsBase(DebugRngListsBase(0x0102_0304)),
+            ),
+            (
+                Format::Dwarf32,
+                4,
+                constants::DW_AT_loclists_base,
+                constants::DW_FORM_sec_offset,
+                data4,
+                AttributeValue::SecOffset(0x0102_0304),
+                AttributeValue::DebugLocListsBase(DebugLocListsBase(0x0102_0304)),
+            ),
+        ];
+
+        for test in tests.iter() {
+            let (format, version, name, form, mut input, expect_raw, expect_value) = *test;
+            unit.encoding.format = format;
+            unit.encoding.version = version;
+            let spec = AttributeSpecification::new(name, form, None);
+            let attribute =
+                parse_attribute(&mut input, unit.encoding(), spec).expect("Should parse attribute");
+            assert_eq!(attribute.raw_value(), expect_raw);
+            assert_eq!(attribute.value(), expect_value);
+        }
+    }
+
+    #[test]
+    fn test_attribute_udata_sdata_value() {
+        let tests: &[(
+            AttributeValue<EndianSlice<LittleEndian>>,
+            Option<u64>,
+            Option<i64>,
+        )] = &[
+            (AttributeValue::Data1(1), Some(1), Some(1)),
+            (
+                AttributeValue::Data1(core::u8::MAX),
+                Some(u64::from(std::u8::MAX)),
+                Some(-1),
+            ),
+            (AttributeValue::Data2(1), Some(1), Some(1)),
+            (
+                AttributeValue::Data2(core::u16::MAX),
+                Some(u64::from(std::u16::MAX)),
+                Some(-1),
+            ),
+            (AttributeValue::Data4(1), Some(1), Some(1)),
+            (
+                AttributeValue::Data4(core::u32::MAX),
+                Some(u64::from(std::u32::MAX)),
+                Some(-1),
+            ),
+            (AttributeValue::Data8(1), Some(1), Some(1)),
+            (
+                AttributeValue::Data8(core::u64::MAX),
+                Some(core::u64::MAX),
+                Some(-1),
+            ),
+            (AttributeValue::Sdata(1), Some(1), Some(1)),
+            (AttributeValue::Sdata(-1), None, Some(-1)),
+            (AttributeValue::Udata(1), Some(1), Some(1)),
+            (AttributeValue::Udata(1u64 << 63), Some(1u64 << 63), None),
+        ];
+        for test in tests.iter() {
+            let (value, expect_udata, expect_sdata) = *test;
+            let attribute = Attribute {
+                name: DW_AT_data_member_location,
+                value,
+            };
+            assert_eq!(attribute.udata_value(), expect_udata);
+            assert_eq!(attribute.sdata_value(), expect_sdata);
+        }
+    }
+
+    fn test_parse_attribute_unit<Endian>(
+        address_size: u8,
+        format: Format,
+        endian: Endian,
+    ) -> UnitHeader<EndianSlice<'static, Endian>>
+    where
+        Endian: Endianity,
+    {
+        let encoding = Encoding {
+            format,
+            version: 4,
+            address_size,
+        };
+        UnitHeader::new(
+            encoding,
+            7,
+            UnitType::Compilation,
+            DebugAbbrevOffset(0x0807_0605),
+            DebugInfoOffset(0).into(),
+            EndianSlice::new(&[], endian),
+        )
+    }
+
+    fn test_parse_attribute_unit_default() -> UnitHeader<EndianSlice<'static, LittleEndian>> {
+        test_parse_attribute_unit(4, Format::Dwarf32, LittleEndian)
+    }
+
+    fn test_parse_attribute<'input, Endian>(
+        buf: &'input [u8],
+        len: usize,
+        unit: &UnitHeader<EndianSlice<'input, Endian>>,
+        form: constants::DwForm,
+        value: AttributeValue<EndianSlice<'input, Endian>>,
+    ) where
+        Endian: Endianity,
+    {
+        let spec = AttributeSpecification::new(constants::DW_AT_low_pc, form, None);
+
+        let expect = Attribute {
+            name: constants::DW_AT_low_pc,
+            value,
+        };
+
+        let rest = &mut EndianSlice::new(buf, Endian::default());
+        match parse_attribute(rest, unit.encoding(), spec) {
+            Ok(attr) => {
+                assert_eq!(attr, expect);
+                assert_eq!(*rest, EndianSlice::new(&buf[len..], Endian::default()));
+                if let Some(size) = spec.size(unit) {
+                    assert_eq!(rest.len() + size, buf.len());
+                }
+            }
+            otherwise => {
+                assert!(false, "Unexpected parse result = {:#?}", otherwise);
+            }
+        };
+    }
+
+    #[test]
+    fn test_parse_attribute_addr() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf32, LittleEndian);
+        let form = constants::DW_FORM_addr;
+        let value = AttributeValue::Addr(0x0403_0201);
+        test_parse_attribute(&buf, 4, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_addr8() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08];
+        let unit = test_parse_attribute_unit(8, Format::Dwarf32, LittleEndian);
+        let form = constants::DW_FORM_addr;
+        let value = AttributeValue::Addr(0x0807_0605_0403_0201);
+        test_parse_attribute(&buf, 8, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_block1() {
+        // Length of data (3), three bytes of data, two bytes of left over input.
+        let buf = [0x03, 0x09, 0x09, 0x09, 0x00, 0x00];
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_block1;
+        let value = AttributeValue::Block(EndianSlice::new(&buf[1..4], LittleEndian));
+        test_parse_attribute(&buf, 4, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_block2() {
+        // Two byte length of data (2), two bytes of data, two bytes of left over input.
+        let buf = [0x02, 0x00, 0x09, 0x09, 0x00, 0x00];
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_block2;
+        let value = AttributeValue::Block(EndianSlice::new(&buf[2..4], LittleEndian));
+        test_parse_attribute(&buf, 4, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_block4() {
+        // Four byte length of data (2), two bytes of data, no left over input.
+        let buf = [0x02, 0x00, 0x00, 0x00, 0x99, 0x99];
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_block4;
+        let value = AttributeValue::Block(EndianSlice::new(&buf[4..], LittleEndian));
+        test_parse_attribute(&buf, 6, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_block() {
+        // LEB length of data (2, one byte), two bytes of data, no left over input.
+        let buf = [0x02, 0x99, 0x99];
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_block;
+        let value = AttributeValue::Block(EndianSlice::new(&buf[1..], LittleEndian));
+        test_parse_attribute(&buf, 3, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_data1() {
+        let buf = [0x03];
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_data1;
+        let value = AttributeValue::Data1(0x03);
+        test_parse_attribute(&buf, 1, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_data2() {
+        let buf = [0x02, 0x01, 0x0];
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_data2;
+        let value = AttributeValue::Data2(0x0102);
+        test_parse_attribute(&buf, 2, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_data4() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x99, 0x99];
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_data4;
+        let value = AttributeValue::Data4(0x0403_0201);
+        test_parse_attribute(&buf, 4, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_data8() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x99, 0x99];
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_data8;
+        let value = AttributeValue::Data8(0x0807_0605_0403_0201);
+        test_parse_attribute(&buf, 8, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_udata() {
+        let mut buf = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+        let bytes_written = {
+            let mut writable = &mut buf[..];
+            leb128::write::unsigned(&mut writable, 4097).expect("should write ok")
+        };
+
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_udata;
+        let value = AttributeValue::Udata(4097);
+        test_parse_attribute(&buf, bytes_written, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_sdata() {
+        let mut buf = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+        let bytes_written = {
+            let mut writable = &mut buf[..];
+            leb128::write::signed(&mut writable, -4097).expect("should write ok")
+        };
+
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_sdata;
+        let value = AttributeValue::Sdata(-4097);
+        test_parse_attribute(&buf, bytes_written, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_exprloc() {
+        // LEB length of data (2, one byte), two bytes of data, one byte left over input.
+        let buf = [0x02, 0x99, 0x99, 0x11];
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_exprloc;
+        let value = AttributeValue::Exprloc(Expression(EndianSlice::new(&buf[1..3], LittleEndian)));
+        test_parse_attribute(&buf, 3, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_flag_true() {
+        let buf = [0x42];
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_flag;
+        let value = AttributeValue::Flag(true);
+        test_parse_attribute(&buf, 1, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_flag_false() {
+        let buf = [0x00];
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_flag;
+        let value = AttributeValue::Flag(false);
+        test_parse_attribute(&buf, 1, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_flag_present() {
+        let buf = [0x01, 0x02, 0x03, 0x04];
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_flag_present;
+        let value = AttributeValue::Flag(true);
+        // DW_FORM_flag_present does not consume any bytes of the input stream.
+        test_parse_attribute(&buf, 0, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_sec_offset_32() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf32, LittleEndian);
+        let form = constants::DW_FORM_sec_offset;
+        let value = AttributeValue::SecOffset(0x0403_0201);
+        test_parse_attribute(&buf, 4, &unit, form, value);
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_attribute_sec_offset_64() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf64, LittleEndian);
+        let form = constants::DW_FORM_sec_offset;
+        let value = AttributeValue::SecOffset(0x0807_0605_0403_0201);
+        test_parse_attribute(&buf, 8, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_ref1() {
+        let buf = [0x03];
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_ref1;
+        let value = AttributeValue::UnitRef(UnitOffset(3));
+        test_parse_attribute(&buf, 1, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_ref2() {
+        let buf = [0x02, 0x01, 0x0];
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_ref2;
+        let value = AttributeValue::UnitRef(UnitOffset(258));
+        test_parse_attribute(&buf, 2, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_ref4() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x99, 0x99];
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_ref4;
+        let value = AttributeValue::UnitRef(UnitOffset(0x0403_0201));
+        test_parse_attribute(&buf, 4, &unit, form, value);
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_attribute_ref8() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x99, 0x99];
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_ref8;
+        let value = AttributeValue::UnitRef(UnitOffset(0x0807_0605_0403_0201));
+        test_parse_attribute(&buf, 8, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_ref_sup4() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x99, 0x99];
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_ref_sup4;
+        let value = AttributeValue::DebugInfoRefSup(DebugInfoOffset(0x0403_0201));
+        test_parse_attribute(&buf, 4, &unit, form, value);
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_attribute_ref_sup8() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x99, 0x99];
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_ref_sup8;
+        let value = AttributeValue::DebugInfoRefSup(DebugInfoOffset(0x0807_0605_0403_0201));
+        test_parse_attribute(&buf, 8, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_refudata() {
+        let mut buf = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+        let bytes_written = {
+            let mut writable = &mut buf[..];
+            leb128::write::unsigned(&mut writable, 4097).expect("should write ok")
+        };
+
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_ref_udata;
+        let value = AttributeValue::UnitRef(UnitOffset(4097));
+        test_parse_attribute(&buf, bytes_written, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_refaddr_32() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x99, 0x99];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf32, LittleEndian);
+        let form = constants::DW_FORM_ref_addr;
+        let value = AttributeValue::DebugInfoRef(DebugInfoOffset(0x0403_0201));
+        test_parse_attribute(&buf, 4, &unit, form, value);
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_attribute_refaddr_64() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x99, 0x99];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf64, LittleEndian);
+        let form = constants::DW_FORM_ref_addr;
+        let value = AttributeValue::DebugInfoRef(DebugInfoOffset(0x0807_0605_0403_0201));
+        test_parse_attribute(&buf, 8, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_refaddr_version2() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x99, 0x99];
+        let mut unit = test_parse_attribute_unit(4, Format::Dwarf32, LittleEndian);
+        unit.encoding.version = 2;
+        let form = constants::DW_FORM_ref_addr;
+        let value = AttributeValue::DebugInfoRef(DebugInfoOffset(0x0403_0201));
+        test_parse_attribute(&buf, 4, &unit, form, value);
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_attribute_refaddr8_version2() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x99, 0x99];
+        let mut unit = test_parse_attribute_unit(8, Format::Dwarf32, LittleEndian);
+        unit.encoding.version = 2;
+        let form = constants::DW_FORM_ref_addr;
+        let value = AttributeValue::DebugInfoRef(DebugInfoOffset(0x0807_0605_0403_0201));
+        test_parse_attribute(&buf, 8, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_gnu_ref_alt_32() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x99, 0x99];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf32, LittleEndian);
+        let form = constants::DW_FORM_GNU_ref_alt;
+        let value = AttributeValue::DebugInfoRefSup(DebugInfoOffset(0x0403_0201));
+        test_parse_attribute(&buf, 4, &unit, form, value);
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_attribute_gnu_ref_alt_64() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x99, 0x99];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf64, LittleEndian);
+        let form = constants::DW_FORM_GNU_ref_alt;
+        let value = AttributeValue::DebugInfoRefSup(DebugInfoOffset(0x0807_0605_0403_0201));
+        test_parse_attribute(&buf, 8, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_refsig8() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x99, 0x99];
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_ref_sig8;
+        let value = AttributeValue::DebugTypesRef(DebugTypeSignature(0x0807_0605_0403_0201));
+        test_parse_attribute(&buf, 8, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_string() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x0, 0x99, 0x99];
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_string;
+        let value = AttributeValue::String(EndianSlice::new(&buf[..5], LittleEndian));
+        test_parse_attribute(&buf, 6, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_strp_32() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x99, 0x99];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf32, LittleEndian);
+        let form = constants::DW_FORM_strp;
+        let value = AttributeValue::DebugStrRef(DebugStrOffset(0x0403_0201));
+        test_parse_attribute(&buf, 4, &unit, form, value);
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_attribute_strp_64() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x99, 0x99];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf64, LittleEndian);
+        let form = constants::DW_FORM_strp;
+        let value = AttributeValue::DebugStrRef(DebugStrOffset(0x0807_0605_0403_0201));
+        test_parse_attribute(&buf, 8, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_strp_sup_32() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x99, 0x99];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf32, LittleEndian);
+        let form = constants::DW_FORM_strp_sup;
+        let value = AttributeValue::DebugStrRefSup(DebugStrOffset(0x0403_0201));
+        test_parse_attribute(&buf, 4, &unit, form, value);
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_attribute_strp_sup_64() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x99, 0x99];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf64, LittleEndian);
+        let form = constants::DW_FORM_strp_sup;
+        let value = AttributeValue::DebugStrRefSup(DebugStrOffset(0x0807_0605_0403_0201));
+        test_parse_attribute(&buf, 8, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_gnu_strp_alt_32() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x99, 0x99];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf32, LittleEndian);
+        let form = constants::DW_FORM_GNU_strp_alt;
+        let value = AttributeValue::DebugStrRefSup(DebugStrOffset(0x0403_0201));
+        test_parse_attribute(&buf, 4, &unit, form, value);
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_attribute_gnu_strp_alt_64() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x99, 0x99];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf64, LittleEndian);
+        let form = constants::DW_FORM_GNU_strp_alt;
+        let value = AttributeValue::DebugStrRefSup(DebugStrOffset(0x0807_0605_0403_0201));
+        test_parse_attribute(&buf, 8, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_strx() {
+        let mut buf = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+        let bytes_written = {
+            let mut writable = &mut buf[..];
+            leb128::write::unsigned(&mut writable, 4097).expect("should write ok")
+        };
+
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_strx;
+        let value = AttributeValue::DebugStrOffsetsIndex(DebugStrOffsetsIndex(4097));
+        test_parse_attribute(&buf, bytes_written, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_strx1() {
+        let buf = [0x01, 0x99, 0x99];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf64, LittleEndian);
+        let form = constants::DW_FORM_strx1;
+        let value = AttributeValue::DebugStrOffsetsIndex(DebugStrOffsetsIndex(0x01));
+        test_parse_attribute(&buf, 1, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_strx2() {
+        let buf = [0x01, 0x02, 0x99, 0x99];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf64, LittleEndian);
+        let form = constants::DW_FORM_strx2;
+        let value = AttributeValue::DebugStrOffsetsIndex(DebugStrOffsetsIndex(0x0201));
+        test_parse_attribute(&buf, 2, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_strx3() {
+        let buf = [0x01, 0x02, 0x03, 0x99, 0x99];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf64, LittleEndian);
+        let form = constants::DW_FORM_strx3;
+        let value = AttributeValue::DebugStrOffsetsIndex(DebugStrOffsetsIndex(0x03_0201));
+        test_parse_attribute(&buf, 3, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_strx4() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x99, 0x99];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf64, LittleEndian);
+        let form = constants::DW_FORM_strx4;
+        let value = AttributeValue::DebugStrOffsetsIndex(DebugStrOffsetsIndex(0x0403_0201));
+        test_parse_attribute(&buf, 4, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_addrx() {
+        let mut buf = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+        let bytes_written = {
+            let mut writable = &mut buf[..];
+            leb128::write::unsigned(&mut writable, 4097).expect("should write ok")
+        };
+
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_addrx;
+        let value = AttributeValue::DebugAddrIndex(DebugAddrIndex(4097));
+        test_parse_attribute(&buf, bytes_written, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_addrx1() {
+        let buf = [0x01, 0x99, 0x99];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf64, LittleEndian);
+        let form = constants::DW_FORM_addrx1;
+        let value = AttributeValue::DebugAddrIndex(DebugAddrIndex(0x01));
+        test_parse_attribute(&buf, 1, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_addrx2() {
+        let buf = [0x01, 0x02, 0x99, 0x99];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf64, LittleEndian);
+        let form = constants::DW_FORM_addrx2;
+        let value = AttributeValue::DebugAddrIndex(DebugAddrIndex(0x0201));
+        test_parse_attribute(&buf, 2, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_addrx3() {
+        let buf = [0x01, 0x02, 0x03, 0x99, 0x99];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf64, LittleEndian);
+        let form = constants::DW_FORM_addrx3;
+        let value = AttributeValue::DebugAddrIndex(DebugAddrIndex(0x03_0201));
+        test_parse_attribute(&buf, 3, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_addrx4() {
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x99, 0x99];
+        let unit = test_parse_attribute_unit(4, Format::Dwarf64, LittleEndian);
+        let form = constants::DW_FORM_addrx4;
+        let value = AttributeValue::DebugAddrIndex(DebugAddrIndex(0x0403_0201));
+        test_parse_attribute(&buf, 4, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_loclistx() {
+        let mut buf = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+        let bytes_written = {
+            let mut writable = &mut buf[..];
+            leb128::write::unsigned(&mut writable, 4097).expect("should write ok")
+        };
+
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_loclistx;
+        let value = AttributeValue::DebugLocListsIndex(DebugLocListsIndex(4097));
+        test_parse_attribute(&buf, bytes_written, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_rnglistx() {
+        let mut buf = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+        let bytes_written = {
+            let mut writable = &mut buf[..];
+            leb128::write::unsigned(&mut writable, 4097).expect("should write ok")
+        };
+
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_rnglistx;
+        let value = AttributeValue::DebugRngListsIndex(DebugRngListsIndex(4097));
+        test_parse_attribute(&buf, bytes_written, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_indirect() {
+        let mut buf = [0; 100];
+
+        let bytes_written = {
+            let mut writable = &mut buf[..];
+            leb128::write::unsigned(&mut writable, constants::DW_FORM_udata.0.into())
+                .expect("should write udata")
+                + leb128::write::unsigned(&mut writable, 9_999_999).expect("should write value")
+        };
+
+        let unit = test_parse_attribute_unit_default();
+        let form = constants::DW_FORM_indirect;
+        let value = AttributeValue::Udata(9_999_999);
+        test_parse_attribute(&buf, bytes_written, &unit, form, value);
+    }
+
+    #[test]
+    fn test_parse_attribute_indirect_implicit_const() {
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 4,
+        };
+        let mut buf = [0; 100];
+        let mut writable = &mut buf[..];
+        leb128::write::unsigned(&mut writable, constants::DW_FORM_implicit_const.0.into())
+            .expect("should write implicit_const");
+
+        let input = &mut EndianSlice::new(&buf, LittleEndian);
+        let spec =
+            AttributeSpecification::new(constants::DW_AT_low_pc, constants::DW_FORM_indirect, None);
+        assert_eq!(
+            parse_attribute(input, encoding, spec),
+            Err(Error::InvalidImplicitConst)
+        );
+    }
+
+    #[test]
+    fn test_attrs_iter() {
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 4,
+        };
+        let unit = UnitHeader::new(
+            encoding,
+            7,
+            UnitType::Compilation,
+            DebugAbbrevOffset(0x0807_0605),
+            DebugInfoOffset(0).into(),
+            EndianSlice::new(&[], LittleEndian),
+        );
+
+        let abbrev = Abbreviation::new(
+            42,
+            constants::DW_TAG_subprogram,
+            constants::DW_CHILDREN_yes,
+            vec![
+                AttributeSpecification::new(constants::DW_AT_name, constants::DW_FORM_string, None),
+                AttributeSpecification::new(constants::DW_AT_low_pc, constants::DW_FORM_addr, None),
+                AttributeSpecification::new(
+                    constants::DW_AT_high_pc,
+                    constants::DW_FORM_addr,
+                    None,
+                ),
+            ]
+            .into(),
+        );
+
+        // "foo", 42, 1337, 4 dangling bytes of 0xaa where children would be
+        let buf = [
+            0x66, 0x6f, 0x6f, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x39, 0x05, 0x00, 0x00, 0xaa, 0xaa,
+            0xaa, 0xaa,
+        ];
+
+        let entry = DebuggingInformationEntry {
+            offset: UnitOffset(0),
+            attrs_slice: EndianSlice::new(&buf, LittleEndian),
+            attrs_len: Cell::new(None),
+            abbrev: &abbrev,
+            unit: &unit,
+        };
+
+        let mut attrs = AttrsIter {
+            input: EndianSlice::new(&buf, LittleEndian),
+            attributes: abbrev.attributes(),
+            entry: &entry,
+        };
+
+        match attrs.next() {
+            Ok(Some(attr)) => {
+                assert_eq!(
+                    attr,
+                    Attribute {
+                        name: constants::DW_AT_name,
+                        value: AttributeValue::String(EndianSlice::new(b"foo", LittleEndian)),
+                    }
+                );
+            }
+            otherwise => {
+                assert!(false, "Unexpected parse result = {:#?}", otherwise);
+            }
+        }
+
+        assert!(entry.attrs_len.get().is_none());
+
+        match attrs.next() {
+            Ok(Some(attr)) => {
+                assert_eq!(
+                    attr,
+                    Attribute {
+                        name: constants::DW_AT_low_pc,
+                        value: AttributeValue::Addr(0x2a),
+                    }
+                );
+            }
+            otherwise => {
+                assert!(false, "Unexpected parse result = {:#?}", otherwise);
+            }
+        }
+
+        assert!(entry.attrs_len.get().is_none());
+
+        match attrs.next() {
+            Ok(Some(attr)) => {
+                assert_eq!(
+                    attr,
+                    Attribute {
+                        name: constants::DW_AT_high_pc,
+                        value: AttributeValue::Addr(0x539),
+                    }
+                );
+            }
+            otherwise => {
+                assert!(false, "Unexpected parse result = {:#?}", otherwise);
+            }
+        }
+
+        assert!(entry.attrs_len.get().is_none());
+
+        assert!(attrs.next().expect("should parse next").is_none());
+        assert!(entry.attrs_len.get().is_some());
+        assert_eq!(
+            entry.attrs_len.get().expect("should have entry.attrs_len"),
+            buf.len() - 4
+        )
+    }
+
+    #[test]
+    fn test_attrs_iter_incomplete() {
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 4,
+        };
+        let unit = UnitHeader::new(
+            encoding,
+            7,
+            UnitType::Compilation,
+            DebugAbbrevOffset(0x0807_0605),
+            DebugInfoOffset(0).into(),
+            EndianSlice::new(&[], LittleEndian),
+        );
+
+        let abbrev = Abbreviation::new(
+            42,
+            constants::DW_TAG_subprogram,
+            constants::DW_CHILDREN_yes,
+            vec![
+                AttributeSpecification::new(constants::DW_AT_name, constants::DW_FORM_string, None),
+                AttributeSpecification::new(constants::DW_AT_low_pc, constants::DW_FORM_addr, None),
+                AttributeSpecification::new(
+                    constants::DW_AT_high_pc,
+                    constants::DW_FORM_addr,
+                    None,
+                ),
+            ]
+            .into(),
+        );
+
+        // "foo"
+        let buf = [0x66, 0x6f, 0x6f, 0x00];
+
+        let entry = DebuggingInformationEntry {
+            offset: UnitOffset(0),
+            attrs_slice: EndianSlice::new(&buf, LittleEndian),
+            attrs_len: Cell::new(None),
+            abbrev: &abbrev,
+            unit: &unit,
+        };
+
+        let mut attrs = AttrsIter {
+            input: EndianSlice::new(&buf, LittleEndian),
+            attributes: abbrev.attributes(),
+            entry: &entry,
+        };
+
+        match attrs.next() {
+            Ok(Some(attr)) => {
+                assert_eq!(
+                    attr,
+                    Attribute {
+                        name: constants::DW_AT_name,
+                        value: AttributeValue::String(EndianSlice::new(b"foo", LittleEndian)),
+                    }
+                );
+            }
+            otherwise => {
+                assert!(false, "Unexpected parse result = {:#?}", otherwise);
+            }
+        }
+
+        assert!(entry.attrs_len.get().is_none());
+
+        // Return error for incomplete attribute.
+        assert!(attrs.next().is_err());
+        assert!(entry.attrs_len.get().is_none());
+
+        // Return error for all subsequent calls.
+        assert!(attrs.next().is_err());
+        assert!(attrs.next().is_err());
+        assert!(attrs.next().is_err());
+        assert!(attrs.next().is_err());
+        assert!(entry.attrs_len.get().is_none());
+    }
+
+    fn assert_entry_name<Endian>(entry: &DebuggingInformationEntry<EndianSlice<Endian>>, name: &str)
+    where
+        Endian: Endianity,
+    {
+        let value = entry
+            .attr_value(constants::DW_AT_name)
+            .expect("Should have parsed the name attribute")
+            .expect("Should have found the name attribute");
+
+        assert_eq!(
+            value,
+            AttributeValue::String(EndianSlice::new(name.as_bytes(), Endian::default()))
+        );
+    }
+
+    fn assert_current_name<Endian>(cursor: &EntriesCursor<EndianSlice<Endian>>, name: &str)
+    where
+        Endian: Endianity,
+    {
+        let entry = cursor.current().expect("Should have an entry result");
+        assert_entry_name(entry, name);
+    }
+
+    fn assert_next_entry<Endian>(cursor: &mut EntriesCursor<EndianSlice<Endian>>, name: &str)
+    where
+        Endian: Endianity,
+    {
+        cursor
+            .next_entry()
+            .expect("Should parse next entry")
+            .expect("Should have an entry");
+        assert_current_name(cursor, name);
+    }
+
+    fn assert_next_entry_null<Endian>(cursor: &mut EntriesCursor<EndianSlice<Endian>>)
+    where
+        Endian: Endianity,
+    {
+        cursor
+            .next_entry()
+            .expect("Should parse next entry")
+            .expect("Should have an entry");
+        assert!(cursor.current().is_none());
+    }
+
+    fn assert_next_dfs<Endian>(
+        cursor: &mut EntriesCursor<EndianSlice<Endian>>,
+        name: &str,
+        depth: isize,
+    ) where
+        Endian: Endianity,
+    {
+        {
+            let (val, entry) = cursor
+                .next_dfs()
+                .expect("Should parse next dfs")
+                .expect("Should not be done with traversal");
+            assert_eq!(val, depth);
+            assert_entry_name(entry, name);
+        }
+        assert_current_name(cursor, name);
+    }
+
+    fn assert_next_sibling<Endian>(cursor: &mut EntriesCursor<EndianSlice<Endian>>, name: &str)
+    where
+        Endian: Endianity,
+    {
+        {
+            let entry = cursor
+                .next_sibling()
+                .expect("Should parse next sibling")
+                .expect("Should not be done with traversal");
+            assert_entry_name(entry, name);
+        }
+        assert_current_name(cursor, name);
+    }
+
+    fn assert_valid_sibling_ptr<Endian>(cursor: &EntriesCursor<EndianSlice<Endian>>)
+    where
+        Endian: Endianity,
+    {
+        let sibling_ptr = cursor
+            .current()
+            .expect("Should have current entry")
+            .attr_value(constants::DW_AT_sibling);
+        match sibling_ptr {
+            Ok(Some(AttributeValue::UnitRef(offset))) => {
+                cursor
+                    .unit
+                    .range_from(offset..)
+                    .expect("Sibling offset should be valid");
+            }
+            _ => panic!("Invalid sibling pointer {:?}", sibling_ptr),
+        }
+    }
+
+    fn entries_cursor_tests_abbrev_buf() -> Vec<u8> {
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Little)
+            .abbrev(1, DW_TAG_subprogram, DW_CHILDREN_yes)
+                .abbrev_attr(DW_AT_name, DW_FORM_string)
+                .abbrev_attr_null()
+            .abbrev_null();
+        section.get_contents().unwrap()
+    }
+
+    fn entries_cursor_tests_debug_info_buf() -> Vec<u8> {
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Little)
+            .die(1, |s| s.attr_string("001"))
+                .die(1, |s| s.attr_string("002"))
+                    .die(1, |s| s.attr_string("003"))
+                        .die_null()
+                    .die_null()
+                .die(1, |s| s.attr_string("004"))
+                    .die(1, |s| s.attr_string("005"))
+                        .die_null()
+                    .die(1, |s| s.attr_string("006"))
+                        .die_null()
+                    .die_null()
+                .die(1, |s| s.attr_string("007"))
+                    .die(1, |s| s.attr_string("008"))
+                        .die(1, |s| s.attr_string("009"))
+                            .die_null()
+                        .die_null()
+                    .die_null()
+                .die(1, |s| s.attr_string("010"))
+                    .die_null()
+                .die_null();
+        let entries_buf = section.get_contents().unwrap();
+
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 4,
+        };
+        let mut unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Compilation,
+            debug_abbrev_offset: DebugAbbrevOffset(0),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(&entries_buf, LittleEndian),
+        };
+        let section = Section::with_endian(Endian::Little).unit(&mut unit);
+        section.get_contents().unwrap()
+    }
+
+    #[test]
+    fn test_cursor_next_entry_incomplete() {
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Little)
+            .die(1, |s| s.attr_string("001"))
+                .die(1, |s| s.attr_string("002"))
+                    .die(1, |s| s);
+        let entries_buf = section.get_contents().unwrap();
+
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 4,
+        };
+        let mut unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Compilation,
+            debug_abbrev_offset: DebugAbbrevOffset(0),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(&entries_buf, LittleEndian),
+        };
+        let section = Section::with_endian(Endian::Little).unit(&mut unit);
+        let info_buf = &section.get_contents().unwrap();
+        let debug_info = DebugInfo::new(info_buf, LittleEndian);
+
+        let unit = debug_info
+            .units()
+            .next()
+            .expect("should have a unit result")
+            .expect("and it should be ok");
+
+        let abbrevs_buf = &entries_cursor_tests_abbrev_buf();
+        let debug_abbrev = DebugAbbrev::new(abbrevs_buf, LittleEndian);
+
+        let abbrevs = unit
+            .abbreviations(&debug_abbrev)
+            .expect("Should parse abbreviations");
+
+        let mut cursor = unit.entries(&abbrevs);
+
+        assert_next_entry(&mut cursor, "001");
+        assert_next_entry(&mut cursor, "002");
+
+        {
+            // Entry code is present, but none of the attributes.
+            cursor
+                .next_entry()
+                .expect("Should parse next entry")
+                .expect("Should have an entry");
+            let entry = cursor.current().expect("Should have an entry result");
+            assert!(entry.attrs().next().is_err());
+        }
+
+        assert!(cursor.next_entry().is_err());
+        assert!(cursor.next_entry().is_err());
+    }
+
+    #[test]
+    fn test_cursor_next_entry() {
+        let info_buf = &entries_cursor_tests_debug_info_buf();
+        let debug_info = DebugInfo::new(info_buf, LittleEndian);
+
+        let unit = debug_info
+            .units()
+            .next()
+            .expect("should have a unit result")
+            .expect("and it should be ok");
+
+        let abbrevs_buf = &entries_cursor_tests_abbrev_buf();
+        let debug_abbrev = DebugAbbrev::new(abbrevs_buf, LittleEndian);
+
+        let abbrevs = unit
+            .abbreviations(&debug_abbrev)
+            .expect("Should parse abbreviations");
+
+        let mut cursor = unit.entries(&abbrevs);
+
+        assert_next_entry(&mut cursor, "001");
+        assert_next_entry(&mut cursor, "002");
+        assert_next_entry(&mut cursor, "003");
+        assert_next_entry_null(&mut cursor);
+        assert_next_entry_null(&mut cursor);
+        assert_next_entry(&mut cursor, "004");
+        assert_next_entry(&mut cursor, "005");
+        assert_next_entry_null(&mut cursor);
+        assert_next_entry(&mut cursor, "006");
+        assert_next_entry_null(&mut cursor);
+        assert_next_entry_null(&mut cursor);
+        assert_next_entry(&mut cursor, "007");
+        assert_next_entry(&mut cursor, "008");
+        assert_next_entry(&mut cursor, "009");
+        assert_next_entry_null(&mut cursor);
+        assert_next_entry_null(&mut cursor);
+        assert_next_entry_null(&mut cursor);
+        assert_next_entry(&mut cursor, "010");
+        assert_next_entry_null(&mut cursor);
+        assert_next_entry_null(&mut cursor);
+
+        assert!(cursor
+            .next_entry()
+            .expect("Should parse next entry")
+            .is_none());
+        assert!(cursor.current().is_none());
+    }
+
+    #[test]
+    fn test_cursor_next_dfs() {
+        let info_buf = &entries_cursor_tests_debug_info_buf();
+        let debug_info = DebugInfo::new(info_buf, LittleEndian);
+
+        let unit = debug_info
+            .units()
+            .next()
+            .expect("should have a unit result")
+            .expect("and it should be ok");
+
+        let abbrevs_buf = &entries_cursor_tests_abbrev_buf();
+        let debug_abbrev = DebugAbbrev::new(abbrevs_buf, LittleEndian);
+
+        let abbrevs = unit
+            .abbreviations(&debug_abbrev)
+            .expect("Should parse abbreviations");
+
+        let mut cursor = unit.entries(&abbrevs);
+
+        assert_next_dfs(&mut cursor, "001", 0);
+        assert_next_dfs(&mut cursor, "002", 1);
+        assert_next_dfs(&mut cursor, "003", 1);
+        assert_next_dfs(&mut cursor, "004", -1);
+        assert_next_dfs(&mut cursor, "005", 1);
+        assert_next_dfs(&mut cursor, "006", 0);
+        assert_next_dfs(&mut cursor, "007", -1);
+        assert_next_dfs(&mut cursor, "008", 1);
+        assert_next_dfs(&mut cursor, "009", 1);
+        assert_next_dfs(&mut cursor, "010", -2);
+
+        assert!(cursor.next_dfs().expect("Should parse next dfs").is_none());
+        assert!(cursor.current().is_none());
+    }
+
+    #[test]
+    fn test_cursor_next_sibling_no_sibling_ptr() {
+        let info_buf = &entries_cursor_tests_debug_info_buf();
+        let debug_info = DebugInfo::new(info_buf, LittleEndian);
+
+        let unit = debug_info
+            .units()
+            .next()
+            .expect("should have a unit result")
+            .expect("and it should be ok");
+
+        let abbrevs_buf = &entries_cursor_tests_abbrev_buf();
+        let debug_abbrev = DebugAbbrev::new(abbrevs_buf, LittleEndian);
+
+        let abbrevs = unit
+            .abbreviations(&debug_abbrev)
+            .expect("Should parse abbreviations");
+
+        let mut cursor = unit.entries(&abbrevs);
+
+        assert_next_dfs(&mut cursor, "001", 0);
+
+        // Down to the first child of the root entry.
+
+        assert_next_dfs(&mut cursor, "002", 1);
+
+        // Now iterate all children of the root via `next_sibling`.
+
+        assert_next_sibling(&mut cursor, "004");
+        assert_next_sibling(&mut cursor, "007");
+        assert_next_sibling(&mut cursor, "010");
+
+        // There should be no more siblings.
+
+        assert!(cursor
+            .next_sibling()
+            .expect("Should parse next sibling")
+            .is_none());
+        assert!(cursor.current().is_none());
+    }
+
+    #[test]
+    fn test_cursor_next_sibling_continuation() {
+        let info_buf = &entries_cursor_tests_debug_info_buf();
+        let debug_info = DebugInfo::new(info_buf, LittleEndian);
+
+        let unit = debug_info
+            .units()
+            .next()
+            .expect("should have a unit result")
+            .expect("and it should be ok");
+
+        let abbrevs_buf = &entries_cursor_tests_abbrev_buf();
+        let debug_abbrev = DebugAbbrev::new(abbrevs_buf, LittleEndian);
+
+        let abbrevs = unit
+            .abbreviations(&debug_abbrev)
+            .expect("Should parse abbreviations");
+
+        let mut cursor = unit.entries(&abbrevs);
+
+        assert_next_dfs(&mut cursor, "001", 0);
+
+        // Down to the first child of the root entry.
+
+        assert_next_dfs(&mut cursor, "002", 1);
+
+        // Get the next sibling, then iterate its children
+
+        assert_next_sibling(&mut cursor, "004");
+        assert_next_dfs(&mut cursor, "005", 1);
+        assert_next_sibling(&mut cursor, "006");
+        assert!(cursor
+            .next_sibling()
+            .expect("Should parse next sibling")
+            .is_none());
+        assert!(cursor
+            .next_sibling()
+            .expect("Should parse next sibling")
+            .is_none());
+        assert!(cursor
+            .next_sibling()
+            .expect("Should parse next sibling")
+            .is_none());
+        assert!(cursor
+            .next_sibling()
+            .expect("Should parse next sibling")
+            .is_none());
+
+        // And we should be able to continue with the children of the root entry.
+
+        assert_next_dfs(&mut cursor, "007", -1);
+        assert_next_sibling(&mut cursor, "010");
+
+        // There should be no more siblings.
+
+        assert!(cursor
+            .next_sibling()
+            .expect("Should parse next sibling")
+            .is_none());
+        assert!(cursor.current().is_none());
+    }
+
+    fn entries_cursor_sibling_abbrev_buf() -> Vec<u8> {
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Little)
+            .abbrev(1, DW_TAG_subprogram, DW_CHILDREN_yes)
+                .abbrev_attr(DW_AT_name, DW_FORM_string)
+                .abbrev_attr(DW_AT_sibling, DW_FORM_ref1)
+                .abbrev_attr_null()
+            .abbrev(2, DW_TAG_subprogram, DW_CHILDREN_yes)
+                .abbrev_attr(DW_AT_name, DW_FORM_string)
+                .abbrev_attr_null()
+                .abbrev_null();
+        section.get_contents().unwrap()
+    }
+
+    fn entries_cursor_sibling_entries_buf(header_size: usize) -> Vec<u8> {
+        let start = Label::new();
+        let sibling004_ref = Label::new();
+        let sibling004 = Label::new();
+        let sibling009_ref = Label::new();
+        let sibling009 = Label::new();
+
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Little)
+            .mark(&start)
+            .die(2, |s| s.attr_string("001"))
+                // Valid sibling attribute.
+                .die(1, |s| s.attr_string("002").D8(&sibling004_ref))
+                    // Invalid code to ensure the sibling attribute was used.
+                    .die(10, |s| s.attr_string("003"))
+                        .die_null()
+                    .die_null()
+                .mark(&sibling004)
+                // Invalid sibling attribute.
+                .die(1, |s| s.attr_string("004").attr_ref1(255))
+                    .die(2, |s| s.attr_string("005"))
+                        .die_null()
+                    .die_null()
+                // Sibling attribute in child only.
+                .die(2, |s| s.attr_string("006"))
+                    // Valid sibling attribute.
+                    .die(1, |s| s.attr_string("007").D8(&sibling009_ref))
+                        // Invalid code to ensure the sibling attribute was used.
+                        .die(10, |s| s.attr_string("008"))
+                            .die_null()
+                        .die_null()
+                    .mark(&sibling009)
+                    .die(2, |s| s.attr_string("009"))
+                        .die_null()
+                    .die_null()
+                // No sibling attribute.
+                .die(2, |s| s.attr_string("010"))
+                    .die(2, |s| s.attr_string("011"))
+                        .die_null()
+                    .die_null()
+                .die_null();
+
+        let offset = header_size as u64 + (&sibling004 - &start) as u64;
+        sibling004_ref.set_const(offset);
+
+        let offset = header_size as u64 + (&sibling009 - &start) as u64;
+        sibling009_ref.set_const(offset);
+
+        section.get_contents().unwrap()
+    }
+
+    fn test_cursor_next_sibling_with_ptr(cursor: &mut EntriesCursor<EndianSlice<LittleEndian>>) {
+        assert_next_dfs(cursor, "001", 0);
+
+        // Down to the first child of the root.
+
+        assert_next_dfs(cursor, "002", 1);
+
+        // Now iterate all children of the root via `next_sibling`.
+
+        assert_valid_sibling_ptr(&cursor);
+        assert_next_sibling(cursor, "004");
+        assert_next_sibling(cursor, "006");
+        assert_next_sibling(cursor, "010");
+
+        // There should be no more siblings.
+
+        assert!(cursor
+            .next_sibling()
+            .expect("Should parse next sibling")
+            .is_none());
+        assert!(cursor.current().is_none());
+    }
+
+    #[test]
+    fn test_debug_info_next_sibling_with_ptr() {
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 4,
+        };
+
+        let mut unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Compilation,
+            debug_abbrev_offset: DebugAbbrevOffset(0),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(&[], LittleEndian),
+        };
+        let header_size = unit.size_of_header();
+        let entries_buf = entries_cursor_sibling_entries_buf(header_size);
+        unit.entries_buf = EndianSlice::new(&entries_buf, LittleEndian);
+        let section = Section::with_endian(Endian::Little).unit(&mut unit);
+        let info_buf = section.get_contents().unwrap();
+        let debug_info = DebugInfo::new(&info_buf, LittleEndian);
+
+        let unit = debug_info
+            .units()
+            .next()
+            .expect("should have a unit result")
+            .expect("and it should be ok");
+
+        let abbrev_buf = entries_cursor_sibling_abbrev_buf();
+        let debug_abbrev = DebugAbbrev::new(&abbrev_buf, LittleEndian);
+
+        let abbrevs = unit
+            .abbreviations(&debug_abbrev)
+            .expect("Should parse abbreviations");
+
+        let mut cursor = unit.entries(&abbrevs);
+        test_cursor_next_sibling_with_ptr(&mut cursor);
+    }
+
+    #[test]
+    fn test_debug_types_next_sibling_with_ptr() {
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 4,
+        };
+        let mut unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Type {
+                type_signature: DebugTypeSignature(0),
+                type_offset: UnitOffset(0),
+            },
+            debug_abbrev_offset: DebugAbbrevOffset(0),
+            unit_offset: DebugTypesOffset(0).into(),
+            entries_buf: EndianSlice::new(&[], LittleEndian),
+        };
+        let header_size = unit.size_of_header();
+        let entries_buf = entries_cursor_sibling_entries_buf(header_size);
+        unit.entries_buf = EndianSlice::new(&entries_buf, LittleEndian);
+        let section = Section::with_endian(Endian::Little).unit(&mut unit);
+        let info_buf = section.get_contents().unwrap();
+        let debug_types = DebugTypes::new(&info_buf, LittleEndian);
+
+        let unit = debug_types
+            .units()
+            .next()
+            .expect("should have a unit result")
+            .expect("and it should be ok");
+
+        let abbrev_buf = entries_cursor_sibling_abbrev_buf();
+        let debug_abbrev = DebugAbbrev::new(&abbrev_buf, LittleEndian);
+
+        let abbrevs = unit
+            .abbreviations(&debug_abbrev)
+            .expect("Should parse abbreviations");
+
+        let mut cursor = unit.entries(&abbrevs);
+        test_cursor_next_sibling_with_ptr(&mut cursor);
+    }
+
+    #[test]
+    fn test_entries_at_offset() {
+        let info_buf = &entries_cursor_tests_debug_info_buf();
+        let debug_info = DebugInfo::new(info_buf, LittleEndian);
+
+        let unit = debug_info
+            .units()
+            .next()
+            .expect("should have a unit result")
+            .expect("and it should be ok");
+
+        let abbrevs_buf = &entries_cursor_tests_abbrev_buf();
+        let debug_abbrev = DebugAbbrev::new(abbrevs_buf, LittleEndian);
+
+        let abbrevs = unit
+            .abbreviations(&debug_abbrev)
+            .expect("Should parse abbreviations");
+
+        let mut cursor = unit
+            .entries_at_offset(&abbrevs, UnitOffset(unit.header_size()))
+            .unwrap();
+        assert_next_entry(&mut cursor, "001");
+
+        let cursor = unit.entries_at_offset(&abbrevs, UnitOffset(0));
+        match cursor {
+            Err(Error::OffsetOutOfBounds) => {}
+            otherwise => {
+                assert!(false, "Unexpected parse result = {:#?}", otherwise);
+            }
+        }
+    }
+
+    fn entries_tree_tests_debug_abbrevs_buf() -> Vec<u8> {
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Little)
+            .abbrev(1, DW_TAG_subprogram, DW_CHILDREN_yes)
+                .abbrev_attr(DW_AT_name, DW_FORM_string)
+                .abbrev_attr_null()
+            .abbrev(2, DW_TAG_subprogram, DW_CHILDREN_no)
+                .abbrev_attr(DW_AT_name, DW_FORM_string)
+                .abbrev_attr_null()
+            .abbrev_null()
+            .get_contents()
+            .unwrap();
+        section
+    }
+
+    fn entries_tree_tests_debug_info_buf(header_size: usize) -> (Vec<u8>, UnitOffset) {
+        let start = Label::new();
+        let entry2 = Label::new();
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Little)
+            .mark(&start)
+            .die(1, |s| s.attr_string("root"))
+                .die(1, |s| s.attr_string("1"))
+                    .die(1, |s| s.attr_string("1a"))
+                        .die_null()
+                    .die(2, |s| s.attr_string("1b"))
+                    .die_null()
+                .mark(&entry2)
+                .die(1, |s| s.attr_string("2"))
+                    .die(1, |s| s.attr_string("2a"))
+                        .die(1, |s| s.attr_string("2a1"))
+                            .die_null()
+                        .die_null()
+                    .die(1, |s| s.attr_string("2b"))
+                        .die(2, |s| s.attr_string("2b1"))
+                        .die_null()
+                    .die_null()
+                .die(1, |s| s.attr_string("3"))
+                    .die(1, |s| s.attr_string("3a"))
+                        .die(2, |s| s.attr_string("3a1"))
+                        .die(2, |s| s.attr_string("3a2"))
+                        .die_null()
+                    .die(2, |s| s.attr_string("3b"))
+                    .die_null()
+                .die(2, |s| s.attr_string("final"))
+                .die_null()
+            .get_contents()
+            .unwrap();
+        let entry2 = UnitOffset(header_size + (&entry2 - &start) as usize);
+        (section, entry2)
+    }
+
+    #[test]
+    fn test_entries_tree() {
+        fn assert_entry<'input, 'abbrev, 'unit, 'tree, Endian>(
+            node: Result<
+                Option<EntriesTreeNode<'abbrev, 'unit, 'tree, EndianSlice<'input, Endian>>>,
+            >,
+            name: &str,
+        ) -> EntriesTreeIter<'abbrev, 'unit, 'tree, EndianSlice<'input, Endian>>
+        where
+            Endian: Endianity,
+        {
+            let node = node
+                .expect("Should parse entry")
+                .expect("Should have entry");
+            assert_entry_name(node.entry(), name);
+            node.children()
+        }
+
+        fn assert_null<E: Endianity>(node: Result<Option<EntriesTreeNode<EndianSlice<E>>>>) {
+            match node {
+                Ok(None) => {}
+                otherwise => {
+                    assert!(false, "Unexpected parse result = {:#?}", otherwise);
+                }
+            }
+        }
+
+        let abbrevs_buf = entries_tree_tests_debug_abbrevs_buf();
+        let debug_abbrev = DebugAbbrev::new(&abbrevs_buf, LittleEndian);
+
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 4,
+        };
+        let mut unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Compilation,
+            debug_abbrev_offset: DebugAbbrevOffset(0),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(&[], LittleEndian),
+        };
+        let header_size = unit.size_of_header();
+        let (entries_buf, entry2) = entries_tree_tests_debug_info_buf(header_size);
+        unit.entries_buf = EndianSlice::new(&entries_buf, LittleEndian);
+        let info_buf = Section::with_endian(Endian::Little)
+            .unit(&mut unit)
+            .get_contents()
+            .unwrap();
+        let debug_info = DebugInfo::new(&info_buf, LittleEndian);
+
+        let unit = debug_info
+            .units()
+            .next()
+            .expect("Should parse unit")
+            .expect("and it should be some");
+        let abbrevs = unit
+            .abbreviations(&debug_abbrev)
+            .expect("Should parse abbreviations");
+        let mut tree = unit
+            .entries_tree(&abbrevs, None)
+            .expect("Should have entries tree");
+
+        // Test we can restart iteration of the tree.
+        {
+            let mut iter = assert_entry(tree.root().map(Some), "root");
+            assert_entry(iter.next(), "1");
+        }
+        {
+            let mut iter = assert_entry(tree.root().map(Some), "root");
+            assert_entry(iter.next(), "1");
+        }
+
+        let mut iter = assert_entry(tree.root().map(Some), "root");
+        {
+            // Test iteration with children.
+            let mut iter = assert_entry(iter.next(), "1");
+            {
+                // Test iteration with children flag, but no children.
+                let mut iter = assert_entry(iter.next(), "1a");
+                assert_null(iter.next());
+                assert_null(iter.next());
+            }
+            {
+                // Test iteration without children flag.
+                let mut iter = assert_entry(iter.next(), "1b");
+                assert_null(iter.next());
+                assert_null(iter.next());
+            }
+            assert_null(iter.next());
+            assert_null(iter.next());
+        }
+        {
+            // Test skipping over children.
+            let mut iter = assert_entry(iter.next(), "2");
+            assert_entry(iter.next(), "2a");
+            assert_entry(iter.next(), "2b");
+            assert_null(iter.next());
+        }
+        {
+            // Test skipping after partial iteration.
+            let mut iter = assert_entry(iter.next(), "3");
+            {
+                let mut iter = assert_entry(iter.next(), "3a");
+                assert_entry(iter.next(), "3a1");
+                // Parent iter should be able to skip over "3a2".
+            }
+            assert_entry(iter.next(), "3b");
+            assert_null(iter.next());
+        }
+        assert_entry(iter.next(), "final");
+        assert_null(iter.next());
+
+        // Test starting at an offset.
+        let mut tree = unit
+            .entries_tree(&abbrevs, Some(entry2))
+            .expect("Should have entries tree");
+        let mut iter = assert_entry(tree.root().map(Some), "2");
+        assert_entry(iter.next(), "2a");
+        assert_entry(iter.next(), "2b");
+        assert_null(iter.next());
+    }
+
+    #[test]
+    fn test_entries_raw() {
+        fn assert_abbrev<'input, 'abbrev, 'unit, Endian>(
+            entries: &mut EntriesRaw<'abbrev, 'unit, EndianSlice<'input, Endian>>,
+            tag: DwTag,
+        ) -> &'abbrev Abbreviation
+        where
+            Endian: Endianity,
+        {
+            let abbrev = entries
+                .read_abbreviation()
+                .expect("Should parse abbrev")
+                .expect("Should have abbrev");
+            assert_eq!(abbrev.tag(), tag);
+            abbrev
+        }
+
+        fn assert_null<'input, 'abbrev, 'unit, Endian>(
+            entries: &mut EntriesRaw<'abbrev, 'unit, EndianSlice<'input, Endian>>,
+        ) where
+            Endian: Endianity,
+        {
+            match entries.read_abbreviation() {
+                Ok(None) => {}
+                otherwise => {
+                    assert!(false, "Unexpected parse result = {:#?}", otherwise);
+                }
+            }
+        }
+
+        fn assert_attr<'input, 'abbrev, 'unit, Endian>(
+            entries: &mut EntriesRaw<'abbrev, 'unit, EndianSlice<'input, Endian>>,
+            spec: Option<AttributeSpecification>,
+            name: DwAt,
+            value: &str,
+        ) where
+            Endian: Endianity,
+        {
+            let spec = spec.expect("Should have attribute specification");
+            let attr = entries
+                .read_attribute(spec)
+                .expect("Should parse attribute");
+            assert_eq!(attr.name(), name);
+            assert_eq!(
+                attr.value(),
+                AttributeValue::String(EndianSlice::new(value.as_bytes(), Endian::default()))
+            );
+        }
+
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Little)
+            .abbrev(1, DW_TAG_subprogram, DW_CHILDREN_yes)
+                .abbrev_attr(DW_AT_name, DW_FORM_string)
+                .abbrev_attr(DW_AT_linkage_name, DW_FORM_string)
+                .abbrev_attr_null()
+            .abbrev(2, DW_TAG_variable, DW_CHILDREN_no)
+                .abbrev_attr(DW_AT_name, DW_FORM_string)
+                .abbrev_attr_null()
+            .abbrev_null();
+        let abbrevs_buf = section.get_contents().unwrap();
+        let debug_abbrev = DebugAbbrev::new(&abbrevs_buf, LittleEndian);
+
+        #[rustfmt::skip]
+        let section = Section::with_endian(Endian::Little)
+            .die(1, |s| s.attr_string("f1").attr_string("l1"))
+                .die(2, |s| s.attr_string("v1"))
+                .die(2, |s| s.attr_string("v2"))
+                .die(1, |s| s.attr_string("f2").attr_string("l2"))
+                    .die_null()
+                .die_null();
+        let entries_buf = section.get_contents().unwrap();
+
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 4,
+        };
+        let mut unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Compilation,
+            debug_abbrev_offset: DebugAbbrevOffset(0),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(&entries_buf, LittleEndian),
+        };
+        let section = Section::with_endian(Endian::Little).unit(&mut unit);
+        let info_buf = section.get_contents().unwrap();
+        let debug_info = DebugInfo::new(&info_buf, LittleEndian);
+
+        let unit = debug_info
+            .units()
+            .next()
+            .expect("should have a unit result")
+            .expect("and it should be ok");
+
+        let abbrevs = unit
+            .abbreviations(&debug_abbrev)
+            .expect("Should parse abbreviations");
+
+        let mut entries = unit
+            .entries_raw(&abbrevs, None)
+            .expect("Should have entries");
+
+        assert_eq!(entries.next_depth(), 0);
+        let abbrev = assert_abbrev(&mut entries, DW_TAG_subprogram);
+        let mut attrs = abbrev.attributes().iter().copied();
+        assert_attr(&mut entries, attrs.next(), DW_AT_name, "f1");
+        assert_attr(&mut entries, attrs.next(), DW_AT_linkage_name, "l1");
+        assert!(attrs.next().is_none());
+
+        assert_eq!(entries.next_depth(), 1);
+        let abbrev = assert_abbrev(&mut entries, DW_TAG_variable);
+        let mut attrs = abbrev.attributes().iter().copied();
+        assert_attr(&mut entries, attrs.next(), DW_AT_name, "v1");
+        assert!(attrs.next().is_none());
+
+        assert_eq!(entries.next_depth(), 1);
+        let abbrev = assert_abbrev(&mut entries, DW_TAG_variable);
+        let mut attrs = abbrev.attributes().iter().copied();
+        assert_attr(&mut entries, attrs.next(), DW_AT_name, "v2");
+        assert!(attrs.next().is_none());
+
+        assert_eq!(entries.next_depth(), 1);
+        let abbrev = assert_abbrev(&mut entries, DW_TAG_subprogram);
+        let mut attrs = abbrev.attributes().iter().copied();
+        assert_attr(&mut entries, attrs.next(), DW_AT_name, "f2");
+        assert_attr(&mut entries, attrs.next(), DW_AT_linkage_name, "l2");
+        assert!(attrs.next().is_none());
+
+        assert_eq!(entries.next_depth(), 2);
+        assert_null(&mut entries);
+
+        assert_eq!(entries.next_depth(), 1);
+        assert_null(&mut entries);
+
+        assert_eq!(entries.next_depth(), 0);
+        assert!(entries.is_empty());
+    }
+
+    #[test]
+    fn test_debug_info_offset() {
+        let padding = &[0; 10];
+        let entries = &[0; 20];
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 4,
+        };
+        let mut unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Compilation,
+            debug_abbrev_offset: DebugAbbrevOffset(0),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(entries, LittleEndian),
+        };
+        Section::with_endian(Endian::Little)
+            .append_bytes(padding)
+            .unit(&mut unit);
+        let offset = padding.len();
+        let header_length = unit.size_of_header();
+        let length = unit.length_including_self();
+        assert_eq!(DebugInfoOffset(0).to_unit_offset(&unit), None);
+        assert_eq!(DebugInfoOffset(offset - 1).to_unit_offset(&unit), None);
+        assert_eq!(DebugInfoOffset(offset).to_unit_offset(&unit), None);
+        assert_eq!(
+            DebugInfoOffset(offset + header_length - 1).to_unit_offset(&unit),
+            None
+        );
+        assert_eq!(
+            DebugInfoOffset(offset + header_length).to_unit_offset(&unit),
+            Some(UnitOffset(header_length))
+        );
+        assert_eq!(
+            DebugInfoOffset(offset + length - 1).to_unit_offset(&unit),
+            Some(UnitOffset(length - 1))
+        );
+        assert_eq!(DebugInfoOffset(offset + length).to_unit_offset(&unit), None);
+        assert_eq!(
+            UnitOffset(header_length).to_debug_info_offset(&unit),
+            Some(DebugInfoOffset(offset + header_length))
+        );
+        assert_eq!(
+            UnitOffset(length - 1).to_debug_info_offset(&unit),
+            Some(DebugInfoOffset(offset + length - 1))
+        );
+    }
+
+    #[test]
+    fn test_debug_types_offset() {
+        let padding = &[0; 10];
+        let entries = &[0; 20];
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 4,
+        };
+        let mut unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Type {
+                type_signature: DebugTypeSignature(0),
+                type_offset: UnitOffset(0),
+            },
+            debug_abbrev_offset: DebugAbbrevOffset(0),
+            unit_offset: DebugTypesOffset(0).into(),
+            entries_buf: EndianSlice::new(entries, LittleEndian),
+        };
+        Section::with_endian(Endian::Little)
+            .append_bytes(padding)
+            .unit(&mut unit);
+        let offset = padding.len();
+        let header_length = unit.size_of_header();
+        let length = unit.length_including_self();
+        assert_eq!(DebugTypesOffset(0).to_unit_offset(&unit), None);
+        assert_eq!(DebugTypesOffset(offset - 1).to_unit_offset(&unit), None);
+        assert_eq!(DebugTypesOffset(offset).to_unit_offset(&unit), None);
+        assert_eq!(
+            DebugTypesOffset(offset + header_length - 1).to_unit_offset(&unit),
+            None
+        );
+        assert_eq!(
+            DebugTypesOffset(offset + header_length).to_unit_offset(&unit),
+            Some(UnitOffset(header_length))
+        );
+        assert_eq!(
+            DebugTypesOffset(offset + length - 1).to_unit_offset(&unit),
+            Some(UnitOffset(length - 1))
+        );
+        assert_eq!(
+            DebugTypesOffset(offset + length).to_unit_offset(&unit),
+            None
+        );
+        assert_eq!(
+            UnitOffset(header_length).to_debug_types_offset(&unit),
+            Some(DebugTypesOffset(offset + header_length))
+        );
+        assert_eq!(
+            UnitOffset(length - 1).to_debug_types_offset(&unit),
+            Some(DebugTypesOffset(offset + length - 1))
+        );
+    }
+
+    #[test]
+    fn test_length_including_self() {
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 4,
+        };
+        let mut unit = UnitHeader {
+            encoding,
+            unit_length: 0,
+            unit_type: UnitType::Compilation,
+            debug_abbrev_offset: DebugAbbrevOffset(0),
+            unit_offset: DebugInfoOffset(0).into(),
+            entries_buf: EndianSlice::new(&[], LittleEndian),
+        };
+        unit.encoding.format = Format::Dwarf32;
+        assert_eq!(unit.length_including_self(), 4);
+        unit.encoding.format = Format::Dwarf64;
+        assert_eq!(unit.length_including_self(), 12);
+        unit.unit_length = 10;
+        assert_eq!(unit.length_including_self(), 22);
+    }
+
+    #[test]
+    fn test_parse_type_unit_abbrevs() {
+        let types_buf = [
+            // Type unit header
+            0x25, 0x00, 0x00, 0x00, // 32-bit unit length = 37
+            0x04, 0x00, // Version 4
+            0x00, 0x00, 0x00, 0x00, // debug_abbrev_offset
+            0x04, // Address size
+            0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // Type signature
+            0x01, 0x02, 0x03, 0x04, // Type offset
+            // DIEs
+            // Abbreviation code
+            0x01, // Attribute of form DW_FORM_string = "foo\0"
+            0x66, 0x6f, 0x6f, 0x00, // Children
+            // Abbreviation code
+            0x01, // Attribute of form DW_FORM_string = "foo\0"
+            0x66, 0x6f, 0x6f, 0x00, // Children
+            // Abbreviation code
+            0x01, // Attribute of form DW_FORM_string = "foo\0"
+            0x66, 0x6f, 0x6f, 0x00, // Children
+            0x00, // End of children
+            0x00, // End of children
+            0x00, // End of children
+        ];
+        let debug_types = DebugTypes::new(&types_buf, LittleEndian);
+
+        let abbrev_buf = [
+            // Code
+            0x01, // DW_TAG_subprogram
+            0x2e, // DW_CHILDREN_yes
+            0x01, // Begin attributes
+            0x03, // Attribute name = DW_AT_name
+            0x08, // Attribute form = DW_FORM_string
+            0x00, 0x00, // End attributes
+            0x00, // Null terminator
+        ];
+
+        let get_some_type_unit = || debug_types.units().next().unwrap().unwrap();
+
+        let unit = get_some_type_unit();
+
+        let read_debug_abbrev_section_somehow = || &abbrev_buf;
+        let debug_abbrev = DebugAbbrev::new(read_debug_abbrev_section_somehow(), LittleEndian);
+        let _abbrevs_for_unit = unit.abbreviations(&debug_abbrev).unwrap();
+    }
+}
diff --git a/vendor/gimli/src/read/util.rs b/vendor/gimli/src/read/util.rs
new file mode 100644
index 0000000..041ca5a
--- /dev/null
+++ b/vendor/gimli/src/read/util.rs
@@ -0,0 +1,283 @@
+#[cfg(feature = "read")]
+use alloc::boxed::Box;
+#[cfg(feature = "read")]
+use alloc::vec::Vec;
+use core::fmt;
+use core::mem::MaybeUninit;
+use core::ops;
+use core::ptr;
+use core::slice;
+
+mod sealed {
+    /// # Safety
+    /// Implementer must not modify the content in storage.
+    pub unsafe trait Sealed {
+        type Storage;
+
+        fn new_storage() -> Self::Storage;
+
+        fn grow(_storage: &mut Self::Storage, _additional: usize) -> Result<(), CapacityFull> {
+            Err(CapacityFull)
+        }
+    }
+
+    #[derive(Clone, Copy, Debug)]
+    pub struct CapacityFull;
+}
+
+use sealed::*;
+
+/// Marker trait for types that can be used as backing storage when a growable array type is needed.
+///
+/// This trait is sealed and cannot be implemented for types outside this crate.
+pub trait ArrayLike: Sealed {
+    /// Type of the elements being stored.
+    type Item;
+
+    #[doc(hidden)]
+    fn as_slice(storage: &Self::Storage) -> &[MaybeUninit<Self::Item>];
+
+    #[doc(hidden)]
+    fn as_mut_slice(storage: &mut Self::Storage) -> &mut [MaybeUninit<Self::Item>];
+}
+
+// Use macro since const generics can't be used due to MSRV.
+macro_rules! impl_array {
+    () => {};
+    ($n:literal $($rest:tt)*) => {
+        // SAFETY: does not modify the content in storage.
+        unsafe impl<T> Sealed for [T; $n] {
+            type Storage = [MaybeUninit<T>; $n];
+
+            fn new_storage() -> Self::Storage {
+                // SAFETY: An uninitialized `[MaybeUninit<_>; _]` is valid.
+                unsafe { MaybeUninit::uninit().assume_init() }
+            }
+        }
+
+        impl<T> ArrayLike for [T; $n] {
+            type Item = T;
+
+            fn as_slice(storage: &Self::Storage) -> &[MaybeUninit<T>] {
+                storage
+            }
+
+            fn as_mut_slice(storage: &mut Self::Storage) -> &mut [MaybeUninit<T>] {
+                storage
+            }
+        }
+
+        impl_array!($($rest)*);
+    }
+}
+
+#[cfg(feature = "read")]
+macro_rules! impl_box {
+    () => {};
+    ($n:literal $($rest:tt)*) => {
+        // SAFETY: does not modify the content in storage.
+        unsafe impl<T> Sealed for Box<[T; $n]> {
+            type Storage = Box<[MaybeUninit<T>; $n]>;
+
+            fn new_storage() -> Self::Storage {
+                // SAFETY: An uninitialized `[MaybeUninit<_>; _]` is valid.
+                Box::new(unsafe { MaybeUninit::uninit().assume_init() })
+            }
+        }
+
+        impl<T> ArrayLike for Box<[T; $n]> {
+            type Item = T;
+
+            fn as_slice(storage: &Self::Storage) -> &[MaybeUninit<T>] {
+                &storage[..]
+            }
+
+            fn as_mut_slice(storage: &mut Self::Storage) -> &mut [MaybeUninit<T>] {
+                &mut storage[..]
+            }
+        }
+
+        impl_box!($($rest)*);
+    }
+}
+
+impl_array!(0 1 2 3 4 8 16 32 64 128 192);
+#[cfg(feature = "read")]
+impl_box!(0 1 2 3 4 8 16 32 64 128 192);
+
+#[cfg(feature = "read")]
+unsafe impl<T> Sealed for Vec<T> {
+    type Storage = Box<[MaybeUninit<T>]>;
+
+    fn new_storage() -> Self::Storage {
+        Box::new([])
+    }
+
+    fn grow(storage: &mut Self::Storage, additional: usize) -> Result<(), CapacityFull> {
+        let mut vec: Vec<_> = core::mem::replace(storage, Box::new([])).into();
+        vec.reserve(additional);
+        // SAFETY: This is a `Vec` of `MaybeUninit`.
+        unsafe { vec.set_len(vec.capacity()) };
+        *storage = vec.into_boxed_slice();
+        Ok(())
+    }
+}
+
+#[cfg(feature = "read")]
+impl<T> ArrayLike for Vec<T> {
+    type Item = T;
+
+    fn as_slice(storage: &Self::Storage) -> &[MaybeUninit<T>] {
+        storage
+    }
+
+    fn as_mut_slice(storage: &mut Self::Storage) -> &mut [MaybeUninit<T>] {
+        storage
+    }
+}
+
+pub(crate) struct ArrayVec<A: ArrayLike> {
+    storage: A::Storage,
+    len: usize,
+}
+
+impl<A: ArrayLike> ArrayVec<A> {
+    pub fn new() -> Self {
+        Self {
+            storage: A::new_storage(),
+            len: 0,
+        }
+    }
+
+    pub fn clear(&mut self) {
+        let ptr: *mut [A::Item] = &mut **self;
+        // Set length first so the type invariant is upheld even if `drop_in_place` panicks.
+        self.len = 0;
+        // SAFETY: `ptr` contains valid elements only and we "forget" them by setting the length.
+        unsafe { ptr::drop_in_place(ptr) };
+    }
+
+    pub fn try_push(&mut self, value: A::Item) -> Result<(), CapacityFull> {
+        let mut storage = A::as_mut_slice(&mut self.storage);
+        if self.len >= storage.len() {
+            A::grow(&mut self.storage, 1)?;
+            storage = A::as_mut_slice(&mut self.storage);
+        }
+
+        storage[self.len] = MaybeUninit::new(value);
+        self.len += 1;
+        Ok(())
+    }
+
+    pub fn try_insert(&mut self, index: usize, element: A::Item) -> Result<(), CapacityFull> {
+        assert!(index <= self.len);
+
+        let mut storage = A::as_mut_slice(&mut self.storage);
+        if self.len >= storage.len() {
+            A::grow(&mut self.storage, 1)?;
+            storage = A::as_mut_slice(&mut self.storage);
+        }
+
+        // SAFETY: storage[index] is filled later.
+        unsafe {
+            let p = storage.as_mut_ptr().add(index);
+            core::ptr::copy(p as *const _, p.add(1), self.len - index);
+        }
+        storage[index] = MaybeUninit::new(element);
+        self.len += 1;
+        Ok(())
+    }
+
+    pub fn pop(&mut self) -> Option<A::Item> {
+        if self.len == 0 {
+            None
+        } else {
+            self.len -= 1;
+            // SAFETY: this element is valid and we "forget" it by setting the length.
+            Some(unsafe { A::as_slice(&self.storage)[self.len].as_ptr().read() })
+        }
+    }
+
+    pub fn swap_remove(&mut self, index: usize) -> A::Item {
+        assert!(self.len > 0);
+        A::as_mut_slice(&mut self.storage).swap(index, self.len - 1);
+        self.pop().unwrap()
+    }
+}
+
+#[cfg(feature = "read")]
+impl<T> ArrayVec<Vec<T>> {
+    pub fn into_vec(mut self) -> Vec<T> {
+        let len = core::mem::replace(&mut self.len, 0);
+        let storage = core::mem::replace(&mut self.storage, Box::new([]));
+        let slice = Box::leak(storage);
+        debug_assert!(len <= slice.len());
+        // SAFETY: valid elements.
+        unsafe { Vec::from_raw_parts(slice.as_mut_ptr() as *mut T, len, slice.len()) }
+    }
+}
+
+impl<A: ArrayLike> Drop for ArrayVec<A> {
+    fn drop(&mut self) {
+        self.clear();
+    }
+}
+
+impl<A: ArrayLike> Default for ArrayVec<A> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<A: ArrayLike> ops::Deref for ArrayVec<A> {
+    type Target = [A::Item];
+
+    fn deref(&self) -> &[A::Item] {
+        let slice = &A::as_slice(&self.storage);
+        debug_assert!(self.len <= slice.len());
+        // SAFETY: valid elements.
+        unsafe { slice::from_raw_parts(slice.as_ptr() as _, self.len) }
+    }
+}
+
+impl<A: ArrayLike> ops::DerefMut for ArrayVec<A> {
+    fn deref_mut(&mut self) -> &mut [A::Item] {
+        let slice = &mut A::as_mut_slice(&mut self.storage);
+        debug_assert!(self.len <= slice.len());
+        // SAFETY: valid elements.
+        unsafe { slice::from_raw_parts_mut(slice.as_mut_ptr() as _, self.len) }
+    }
+}
+
+impl<A: ArrayLike> Clone for ArrayVec<A>
+where
+    A::Item: Clone,
+{
+    fn clone(&self) -> Self {
+        let mut new = Self::default();
+        for value in &**self {
+            new.try_push(value.clone()).unwrap();
+        }
+        new
+    }
+}
+
+impl<A: ArrayLike> PartialEq for ArrayVec<A>
+where
+    A::Item: PartialEq,
+{
+    fn eq(&self, other: &Self) -> bool {
+        **self == **other
+    }
+}
+
+impl<A: ArrayLike> Eq for ArrayVec<A> where A::Item: Eq {}
+
+impl<A: ArrayLike> fmt::Debug for ArrayVec<A>
+where
+    A::Item: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&**self, f)
+    }
+}
diff --git a/vendor/gimli/src/read/value.rs b/vendor/gimli/src/read/value.rs
new file mode 100644
index 0000000..77b08ed
--- /dev/null
+++ b/vendor/gimli/src/read/value.rs
@@ -0,0 +1,1621 @@
+//! Definitions for values used in DWARF expressions.
+
+use crate::constants;
+#[cfg(feature = "read")]
+use crate::read::{AttributeValue, DebuggingInformationEntry};
+use crate::read::{Error, Reader, Result};
+
+/// Convert a u64 to an i64, with sign extension if required.
+///
+/// This is primarily used when needing to treat `Value::Generic`
+/// as a signed value.
+#[inline]
+fn sign_extend(value: u64, mask: u64) -> i64 {
+    let value = (value & mask) as i64;
+    let sign = ((mask >> 1) + 1) as i64;
+    (value ^ sign).wrapping_sub(sign)
+}
+
+#[inline]
+fn mask_bit_size(addr_mask: u64) -> u32 {
+    64 - addr_mask.leading_zeros()
+}
+
+/// The type of an entry on the DWARF stack.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ValueType {
+    /// The generic type, which is address-sized and of unspecified sign,
+    /// as specified in the DWARF 5 standard, section 2.5.1.
+    /// This type is also used to represent address base types.
+    Generic,
+    /// Signed 8-bit integer type.
+    I8,
+    /// Unsigned 8-bit integer type.
+    U8,
+    /// Signed 16-bit integer type.
+    I16,
+    /// Unsigned 16-bit integer type.
+    U16,
+    /// Signed 32-bit integer type.
+    I32,
+    /// Unsigned 32-bit integer type.
+    U32,
+    /// Signed 64-bit integer type.
+    I64,
+    /// Unsigned 64-bit integer type.
+    U64,
+    /// 32-bit floating point type.
+    F32,
+    /// 64-bit floating point type.
+    F64,
+}
+
+/// The value of an entry on the DWARF stack.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Value {
+    /// A generic value, which is address-sized and of unspecified sign.
+    Generic(u64),
+    /// A signed 8-bit integer value.
+    I8(i8),
+    /// An unsigned 8-bit integer value.
+    U8(u8),
+    /// A signed 16-bit integer value.
+    I16(i16),
+    /// An unsigned 16-bit integer value.
+    U16(u16),
+    /// A signed 32-bit integer value.
+    I32(i32),
+    /// An unsigned 32-bit integer value.
+    U32(u32),
+    /// A signed 64-bit integer value.
+    I64(i64),
+    /// An unsigned 64-bit integer value.
+    U64(u64),
+    /// A 32-bit floating point value.
+    F32(f32),
+    /// A 64-bit floating point value.
+    F64(f64),
+}
+
+impl ValueType {
+    /// The size in bits of a value for this type.
+    pub fn bit_size(self, addr_mask: u64) -> u32 {
+        match self {
+            ValueType::Generic => mask_bit_size(addr_mask),
+            ValueType::I8 | ValueType::U8 => 8,
+            ValueType::I16 | ValueType::U16 => 16,
+            ValueType::I32 | ValueType::U32 | ValueType::F32 => 32,
+            ValueType::I64 | ValueType::U64 | ValueType::F64 => 64,
+        }
+    }
+
+    /// Construct a `ValueType` from the attributes of a base type DIE.
+    pub fn from_encoding(encoding: constants::DwAte, byte_size: u64) -> Option<ValueType> {
+        Some(match (encoding, byte_size) {
+            (constants::DW_ATE_signed, 1) => ValueType::I8,
+            (constants::DW_ATE_signed, 2) => ValueType::I16,
+            (constants::DW_ATE_signed, 4) => ValueType::I32,
+            (constants::DW_ATE_signed, 8) => ValueType::I64,
+            (constants::DW_ATE_unsigned, 1) => ValueType::U8,
+            (constants::DW_ATE_unsigned, 2) => ValueType::U16,
+            (constants::DW_ATE_unsigned, 4) => ValueType::U32,
+            (constants::DW_ATE_unsigned, 8) => ValueType::U64,
+            (constants::DW_ATE_float, 4) => ValueType::F32,
+            (constants::DW_ATE_float, 8) => ValueType::F64,
+            _ => return None,
+        })
+    }
+
+    /// Construct a `ValueType` from a base type DIE.
+    #[cfg(feature = "read")]
+    pub fn from_entry<R: Reader>(
+        entry: &DebuggingInformationEntry<R>,
+    ) -> Result<Option<ValueType>> {
+        if entry.tag() != constants::DW_TAG_base_type {
+            return Ok(None);
+        }
+        let mut encoding = None;
+        let mut byte_size = None;
+        let mut endianity = constants::DW_END_default;
+        let mut attrs = entry.attrs();
+        while let Some(attr) = attrs.next()? {
+            match attr.name() {
+                constants::DW_AT_byte_size => byte_size = attr.udata_value(),
+                constants::DW_AT_encoding => {
+                    if let AttributeValue::Encoding(x) = attr.value() {
+                        encoding = Some(x);
+                    }
+                }
+                constants::DW_AT_endianity => {
+                    if let AttributeValue::Endianity(x) = attr.value() {
+                        endianity = x;
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        if endianity != constants::DW_END_default {
+            // TODO: we could check if it matches the reader endianity,
+            // but normally it would use DW_END_default in that case.
+            return Ok(None);
+        }
+
+        if let (Some(encoding), Some(byte_size)) = (encoding, byte_size) {
+            Ok(ValueType::from_encoding(encoding, byte_size))
+        } else {
+            Ok(None)
+        }
+    }
+}
+
+impl Value {
+    /// Return the `ValueType` corresponding to this `Value`.
+    pub fn value_type(&self) -> ValueType {
+        match *self {
+            Value::Generic(_) => ValueType::Generic,
+            Value::I8(_) => ValueType::I8,
+            Value::U8(_) => ValueType::U8,
+            Value::I16(_) => ValueType::I16,
+            Value::U16(_) => ValueType::U16,
+            Value::I32(_) => ValueType::I32,
+            Value::U32(_) => ValueType::U32,
+            Value::I64(_) => ValueType::I64,
+            Value::U64(_) => ValueType::U64,
+            Value::F32(_) => ValueType::F32,
+            Value::F64(_) => ValueType::F64,
+        }
+    }
+
+    /// Read a `Value` with the given `value_type` from a `Reader`.
+    pub fn parse<R: Reader>(value_type: ValueType, mut bytes: R) -> Result<Value> {
+        let value = match value_type {
+            ValueType::I8 => Value::I8(bytes.read_i8()?),
+            ValueType::U8 => Value::U8(bytes.read_u8()?),
+            ValueType::I16 => Value::I16(bytes.read_i16()?),
+            ValueType::U16 => Value::U16(bytes.read_u16()?),
+            ValueType::I32 => Value::I32(bytes.read_i32()?),
+            ValueType::U32 => Value::U32(bytes.read_u32()?),
+            ValueType::I64 => Value::I64(bytes.read_i64()?),
+            ValueType::U64 => Value::U64(bytes.read_u64()?),
+            ValueType::F32 => Value::F32(bytes.read_f32()?),
+            ValueType::F64 => Value::F64(bytes.read_f64()?),
+            _ => return Err(Error::UnsupportedTypeOperation),
+        };
+        Ok(value)
+    }
+
+    /// Convert a `Value` to a `u64`.
+    ///
+    /// The `ValueType` of `self` must be integral.
+    /// Values are sign extended if the source value is signed.
+    pub fn to_u64(self, addr_mask: u64) -> Result<u64> {
+        let value = match self {
+            Value::Generic(value) => value & addr_mask,
+            Value::I8(value) => value as u64,
+            Value::U8(value) => u64::from(value),
+            Value::I16(value) => value as u64,
+            Value::U16(value) => u64::from(value),
+            Value::I32(value) => value as u64,
+            Value::U32(value) => u64::from(value),
+            Value::I64(value) => value as u64,
+            Value::U64(value) => value as u64,
+            _ => return Err(Error::IntegralTypeRequired),
+        };
+        Ok(value)
+    }
+
+    /// Create a `Value` with the given `value_type` from a `u64` value.
+    ///
+    /// The `value_type` may be integral or floating point.
+    /// The result is truncated if the `u64` value does
+    /// not fit the bounds of the `value_type`.
+    pub fn from_u64(value_type: ValueType, value: u64) -> Result<Value> {
+        let value = match value_type {
+            ValueType::Generic => Value::Generic(value),
+            ValueType::I8 => Value::I8(value as i8),
+            ValueType::U8 => Value::U8(value as u8),
+            ValueType::I16 => Value::I16(value as i16),
+            ValueType::U16 => Value::U16(value as u16),
+            ValueType::I32 => Value::I32(value as i32),
+            ValueType::U32 => Value::U32(value as u32),
+            ValueType::I64 => Value::I64(value as i64),
+            ValueType::U64 => Value::U64(value),
+            ValueType::F32 => Value::F32(value as f32),
+            ValueType::F64 => Value::F64(value as f64),
+        };
+        Ok(value)
+    }
+
+    /// Create a `Value` with the given `value_type` from a `f32` value.
+    ///
+    /// The `value_type` may be integral or floating point.
+    /// The result is not defined if the `f32` value does
+    /// not fit the bounds of the `value_type`.
+    fn from_f32(value_type: ValueType, value: f32) -> Result<Value> {
+        let value = match value_type {
+            ValueType::Generic => Value::Generic(value as u64),
+            ValueType::I8 => Value::I8(value as i8),
+            ValueType::U8 => Value::U8(value as u8),
+            ValueType::I16 => Value::I16(value as i16),
+            ValueType::U16 => Value::U16(value as u16),
+            ValueType::I32 => Value::I32(value as i32),
+            ValueType::U32 => Value::U32(value as u32),
+            ValueType::I64 => Value::I64(value as i64),
+            ValueType::U64 => Value::U64(value as u64),
+            ValueType::F32 => Value::F32(value),
+            ValueType::F64 => Value::F64(f64::from(value)),
+        };
+        Ok(value)
+    }
+
+    /// Create a `Value` with the given `value_type` from a `f64` value.
+    ///
+    /// The `value_type` may be integral or floating point.
+    /// The result is not defined if the `f64` value does
+    /// not fit the bounds of the `value_type`.
+    fn from_f64(value_type: ValueType, value: f64) -> Result<Value> {
+        let value = match value_type {
+            ValueType::Generic => Value::Generic(value as u64),
+            ValueType::I8 => Value::I8(value as i8),
+            ValueType::U8 => Value::U8(value as u8),
+            ValueType::I16 => Value::I16(value as i16),
+            ValueType::U16 => Value::U16(value as u16),
+            ValueType::I32 => Value::I32(value as i32),
+            ValueType::U32 => Value::U32(value as u32),
+            ValueType::I64 => Value::I64(value as i64),
+            ValueType::U64 => Value::U64(value as u64),
+            ValueType::F32 => Value::F32(value as f32),
+            ValueType::F64 => Value::F64(value),
+        };
+        Ok(value)
+    }
+
+    /// Convert a `Value` to the given `value_type`.
+    ///
+    /// When converting between integral types, the result is truncated
+    /// if the source value does not fit the bounds of the `value_type`.
+    /// When converting from floating point types, the result is not defined
+    /// if the source value does not fit the bounds of the `value_type`.
+    ///
+    /// This corresponds to the DWARF `DW_OP_convert` operation.
+    pub fn convert(self, value_type: ValueType, addr_mask: u64) -> Result<Value> {
+        match self {
+            Value::F32(value) => Value::from_f32(value_type, value),
+            Value::F64(value) => Value::from_f64(value_type, value),
+            _ => Value::from_u64(value_type, self.to_u64(addr_mask)?),
+        }
+    }
+
+    /// Reinterpret the bits in a `Value` as the given `value_type`.
+    ///
+    /// The source and result value types must have equal sizes.
+    ///
+    /// This corresponds to the DWARF `DW_OP_reinterpret` operation.
+    pub fn reinterpret(self, value_type: ValueType, addr_mask: u64) -> Result<Value> {
+        if self.value_type().bit_size(addr_mask) != value_type.bit_size(addr_mask) {
+            return Err(Error::TypeMismatch);
+        }
+        let bits = match self {
+            Value::Generic(value) => value,
+            Value::I8(value) => value as u64,
+            Value::U8(value) => u64::from(value),
+            Value::I16(value) => value as u64,
+            Value::U16(value) => u64::from(value),
+            Value::I32(value) => value as u64,
+            Value::U32(value) => u64::from(value),
+            Value::I64(value) => value as u64,
+            Value::U64(value) => value,
+            Value::F32(value) => u64::from(f32::to_bits(value)),
+            Value::F64(value) => f64::to_bits(value),
+        };
+        let value = match value_type {
+            ValueType::Generic => Value::Generic(bits),
+            ValueType::I8 => Value::I8(bits as i8),
+            ValueType::U8 => Value::U8(bits as u8),
+            ValueType::I16 => Value::I16(bits as i16),
+            ValueType::U16 => Value::U16(bits as u16),
+            ValueType::I32 => Value::I32(bits as i32),
+            ValueType::U32 => Value::U32(bits as u32),
+            ValueType::I64 => Value::I64(bits as i64),
+            ValueType::U64 => Value::U64(bits),
+            ValueType::F32 => Value::F32(f32::from_bits(bits as u32)),
+            ValueType::F64 => Value::F64(f64::from_bits(bits)),
+        };
+        Ok(value)
+    }
+
+    /// Perform an absolute value operation.
+    ///
+    /// If the value type is `Generic`, then it is interpreted as a signed value.
+    ///
+    /// This corresponds to the DWARF `DW_OP_abs` operation.
+    pub fn abs(self, addr_mask: u64) -> Result<Value> {
+        // wrapping_abs() can be used because DWARF specifies that the result is undefined
+        // for negative minimal values.
+        let value = match self {
+            Value::Generic(value) => {
+                Value::Generic(sign_extend(value, addr_mask).wrapping_abs() as u64)
+            }
+            Value::I8(value) => Value::I8(value.wrapping_abs()),
+            Value::I16(value) => Value::I16(value.wrapping_abs()),
+            Value::I32(value) => Value::I32(value.wrapping_abs()),
+            Value::I64(value) => Value::I64(value.wrapping_abs()),
+            // f32/f64::abs() is not available in libcore
+            Value::F32(value) => Value::F32(if value < 0. { -value } else { value }),
+            Value::F64(value) => Value::F64(if value < 0. { -value } else { value }),
+            Value::U8(_) | Value::U16(_) | Value::U32(_) | Value::U64(_) => self,
+        };
+        Ok(value)
+    }
+
+    /// Perform a negation operation.
+    ///
+    /// If the value type is `Generic`, then it is interpreted as a signed value.
+    ///
+    /// This corresponds to the DWARF `DW_OP_neg` operation.
+    pub fn neg(self, addr_mask: u64) -> Result<Value> {
+        // wrapping_neg() can be used because DWARF specifies that the result is undefined
+        // for negative minimal values.
+        let value = match self {
+            Value::Generic(value) => {
+                Value::Generic(sign_extend(value, addr_mask).wrapping_neg() as u64)
+            }
+            Value::I8(value) => Value::I8(value.wrapping_neg()),
+            Value::I16(value) => Value::I16(value.wrapping_neg()),
+            Value::I32(value) => Value::I32(value.wrapping_neg()),
+            Value::I64(value) => Value::I64(value.wrapping_neg()),
+            Value::F32(value) => Value::F32(-value),
+            Value::F64(value) => Value::F64(-value),
+            // It's unclear if these should implicitly convert to a signed value.
+            // For now, we don't support them.
+            Value::U8(_) | Value::U16(_) | Value::U32(_) | Value::U64(_) => {
+                return Err(Error::UnsupportedTypeOperation);
+            }
+        };
+        Ok(value)
+    }
+
+    /// Perform an addition operation.
+    ///
+    /// This operation requires matching types.
+    ///
+    /// This corresponds to the DWARF `DW_OP_plus` operation.
+    pub fn add(self, rhs: Value, addr_mask: u64) -> Result<Value> {
+        let value = match (self, rhs) {
+            (Value::Generic(v1), Value::Generic(v2)) => {
+                Value::Generic(v1.wrapping_add(v2) & addr_mask)
+            }
+            (Value::I8(v1), Value::I8(v2)) => Value::I8(v1.wrapping_add(v2)),
+            (Value::U8(v1), Value::U8(v2)) => Value::U8(v1.wrapping_add(v2)),
+            (Value::I16(v1), Value::I16(v2)) => Value::I16(v1.wrapping_add(v2)),
+            (Value::U16(v1), Value::U16(v2)) => Value::U16(v1.wrapping_add(v2)),
+            (Value::I32(v1), Value::I32(v2)) => Value::I32(v1.wrapping_add(v2)),
+            (Value::U32(v1), Value::U32(v2)) => Value::U32(v1.wrapping_add(v2)),
+            (Value::I64(v1), Value::I64(v2)) => Value::I64(v1.wrapping_add(v2)),
+            (Value::U64(v1), Value::U64(v2)) => Value::U64(v1.wrapping_add(v2)),
+            (Value::F32(v1), Value::F32(v2)) => Value::F32(v1 + v2),
+            (Value::F64(v1), Value::F64(v2)) => Value::F64(v1 + v2),
+            _ => return Err(Error::TypeMismatch),
+        };
+        Ok(value)
+    }
+
+    /// Perform a subtraction operation.
+    ///
+    /// This operation requires matching types.
+    ///
+    /// This corresponds to the DWARF `DW_OP_minus` operation.
+    pub fn sub(self, rhs: Value, addr_mask: u64) -> Result<Value> {
+        let value = match (self, rhs) {
+            (Value::Generic(v1), Value::Generic(v2)) => {
+                Value::Generic(v1.wrapping_sub(v2) & addr_mask)
+            }
+            (Value::I8(v1), Value::I8(v2)) => Value::I8(v1.wrapping_sub(v2)),
+            (Value::U8(v1), Value::U8(v2)) => Value::U8(v1.wrapping_sub(v2)),
+            (Value::I16(v1), Value::I16(v2)) => Value::I16(v1.wrapping_sub(v2)),
+            (Value::U16(v1), Value::U16(v2)) => Value::U16(v1.wrapping_sub(v2)),
+            (Value::I32(v1), Value::I32(v2)) => Value::I32(v1.wrapping_sub(v2)),
+            (Value::U32(v1), Value::U32(v2)) => Value::U32(v1.wrapping_sub(v2)),
+            (Value::I64(v1), Value::I64(v2)) => Value::I64(v1.wrapping_sub(v2)),
+            (Value::U64(v1), Value::U64(v2)) => Value::U64(v1.wrapping_sub(v2)),
+            (Value::F32(v1), Value::F32(v2)) => Value::F32(v1 - v2),
+            (Value::F64(v1), Value::F64(v2)) => Value::F64(v1 - v2),
+            _ => return Err(Error::TypeMismatch),
+        };
+        Ok(value)
+    }
+
+    /// Perform a multiplication operation.
+    ///
+    /// This operation requires matching types.
+    ///
+    /// This corresponds to the DWARF `DW_OP_mul` operation.
+    pub fn mul(self, rhs: Value, addr_mask: u64) -> Result<Value> {
+        let value = match (self, rhs) {
+            (Value::Generic(v1), Value::Generic(v2)) => {
+                Value::Generic(v1.wrapping_mul(v2) & addr_mask)
+            }
+            (Value::I8(v1), Value::I8(v2)) => Value::I8(v1.wrapping_mul(v2)),
+            (Value::U8(v1), Value::U8(v2)) => Value::U8(v1.wrapping_mul(v2)),
+            (Value::I16(v1), Value::I16(v2)) => Value::I16(v1.wrapping_mul(v2)),
+            (Value::U16(v1), Value::U16(v2)) => Value::U16(v1.wrapping_mul(v2)),
+            (Value::I32(v1), Value::I32(v2)) => Value::I32(v1.wrapping_mul(v2)),
+            (Value::U32(v1), Value::U32(v2)) => Value::U32(v1.wrapping_mul(v2)),
+            (Value::I64(v1), Value::I64(v2)) => Value::I64(v1.wrapping_mul(v2)),
+            (Value::U64(v1), Value::U64(v2)) => Value::U64(v1.wrapping_mul(v2)),
+            (Value::F32(v1), Value::F32(v2)) => Value::F32(v1 * v2),
+            (Value::F64(v1), Value::F64(v2)) => Value::F64(v1 * v2),
+            _ => return Err(Error::TypeMismatch),
+        };
+        Ok(value)
+    }
+
+    /// Perform a division operation.
+    ///
+    /// This operation requires matching types.
+    /// If the value type is `Generic`, then it is interpreted as a signed value.
+    ///
+    /// This corresponds to the DWARF `DW_OP_div` operation.
+    pub fn div(self, rhs: Value, addr_mask: u64) -> Result<Value> {
+        match rhs {
+            Value::Generic(v2) if sign_extend(v2, addr_mask) == 0 => {
+                return Err(Error::DivisionByZero);
+            }
+            Value::I8(0)
+            | Value::U8(0)
+            | Value::I16(0)
+            | Value::U16(0)
+            | Value::I32(0)
+            | Value::U32(0)
+            | Value::I64(0)
+            | Value::U64(0) => {
+                return Err(Error::DivisionByZero);
+            }
+            _ => {}
+        }
+        let value = match (self, rhs) {
+            (Value::Generic(v1), Value::Generic(v2)) => {
+                // Signed division
+                Value::Generic(
+                    sign_extend(v1, addr_mask).wrapping_div(sign_extend(v2, addr_mask)) as u64,
+                )
+            }
+            (Value::I8(v1), Value::I8(v2)) => Value::I8(v1.wrapping_div(v2)),
+            (Value::U8(v1), Value::U8(v2)) => Value::U8(v1.wrapping_div(v2)),
+            (Value::I16(v1), Value::I16(v2)) => Value::I16(v1.wrapping_div(v2)),
+            (Value::U16(v1), Value::U16(v2)) => Value::U16(v1.wrapping_div(v2)),
+            (Value::I32(v1), Value::I32(v2)) => Value::I32(v1.wrapping_div(v2)),
+            (Value::U32(v1), Value::U32(v2)) => Value::U32(v1.wrapping_div(v2)),
+            (Value::I64(v1), Value::I64(v2)) => Value::I64(v1.wrapping_div(v2)),
+            (Value::U64(v1), Value::U64(v2)) => Value::U64(v1.wrapping_div(v2)),
+            (Value::F32(v1), Value::F32(v2)) => Value::F32(v1 / v2),
+            (Value::F64(v1), Value::F64(v2)) => Value::F64(v1 / v2),
+            _ => return Err(Error::TypeMismatch),
+        };
+        Ok(value)
+    }
+
+    /// Perform a remainder operation.
+    ///
+    /// This operation requires matching integral types.
+    /// If the value type is `Generic`, then it is interpreted as an unsigned value.
+    ///
+    /// This corresponds to the DWARF `DW_OP_mod` operation.
+    pub fn rem(self, rhs: Value, addr_mask: u64) -> Result<Value> {
+        match rhs {
+            Value::Generic(rhs) if (rhs & addr_mask) == 0 => {
+                return Err(Error::DivisionByZero);
+            }
+            Value::I8(0)
+            | Value::U8(0)
+            | Value::I16(0)
+            | Value::U16(0)
+            | Value::I32(0)
+            | Value::U32(0)
+            | Value::I64(0)
+            | Value::U64(0) => {
+                return Err(Error::DivisionByZero);
+            }
+            _ => {}
+        }
+        let value = match (self, rhs) {
+            (Value::Generic(v1), Value::Generic(v2)) => {
+                // Unsigned modulus
+                Value::Generic((v1 & addr_mask).wrapping_rem(v2 & addr_mask))
+            }
+            (Value::I8(v1), Value::I8(v2)) => Value::I8(v1.wrapping_rem(v2)),
+            (Value::U8(v1), Value::U8(v2)) => Value::U8(v1.wrapping_rem(v2)),
+            (Value::I16(v1), Value::I16(v2)) => Value::I16(v1.wrapping_rem(v2)),
+            (Value::U16(v1), Value::U16(v2)) => Value::U16(v1.wrapping_rem(v2)),
+            (Value::I32(v1), Value::I32(v2)) => Value::I32(v1.wrapping_rem(v2)),
+            (Value::U32(v1), Value::U32(v2)) => Value::U32(v1.wrapping_rem(v2)),
+            (Value::I64(v1), Value::I64(v2)) => Value::I64(v1.wrapping_rem(v2)),
+            (Value::U64(v1), Value::U64(v2)) => Value::U64(v1.wrapping_rem(v2)),
+            (Value::F32(_), Value::F32(_)) => return Err(Error::IntegralTypeRequired),
+            (Value::F64(_), Value::F64(_)) => return Err(Error::IntegralTypeRequired),
+            _ => return Err(Error::TypeMismatch),
+        };
+        Ok(value)
+    }
+
+    /// Perform a bitwise not operation.
+    ///
+    /// This operation requires matching integral types.
+    ///
+    /// This corresponds to the DWARF `DW_OP_not` operation.
+    pub fn not(self, addr_mask: u64) -> Result<Value> {
+        let value_type = self.value_type();
+        let v = self.to_u64(addr_mask)?;
+        Value::from_u64(value_type, !v)
+    }
+
+    /// Perform a bitwise and operation.
+    ///
+    /// This operation requires matching integral types.
+    ///
+    /// This corresponds to the DWARF `DW_OP_and` operation.
+    pub fn and(self, rhs: Value, addr_mask: u64) -> Result<Value> {
+        let value_type = self.value_type();
+        if value_type != rhs.value_type() {
+            return Err(Error::TypeMismatch);
+        }
+        let v1 = self.to_u64(addr_mask)?;
+        let v2 = rhs.to_u64(addr_mask)?;
+        Value::from_u64(value_type, v1 & v2)
+    }
+
+    /// Perform a bitwise or operation.
+    ///
+    /// This operation requires matching integral types.
+    ///
+    /// This corresponds to the DWARF `DW_OP_or` operation.
+    pub fn or(self, rhs: Value, addr_mask: u64) -> Result<Value> {
+        let value_type = self.value_type();
+        if value_type != rhs.value_type() {
+            return Err(Error::TypeMismatch);
+        }
+        let v1 = self.to_u64(addr_mask)?;
+        let v2 = rhs.to_u64(addr_mask)?;
+        Value::from_u64(value_type, v1 | v2)
+    }
+
+    /// Perform a bitwise exclusive-or operation.
+    ///
+    /// This operation requires matching integral types.
+    ///
+    /// This corresponds to the DWARF `DW_OP_xor` operation.
+    pub fn xor(self, rhs: Value, addr_mask: u64) -> Result<Value> {
+        let value_type = self.value_type();
+        if value_type != rhs.value_type() {
+            return Err(Error::TypeMismatch);
+        }
+        let v1 = self.to_u64(addr_mask)?;
+        let v2 = rhs.to_u64(addr_mask)?;
+        Value::from_u64(value_type, v1 ^ v2)
+    }
+
+    /// Convert value to bit length suitable for a shift operation.
+    ///
+    /// If the value is negative then an error is returned.
+    fn shift_length(self) -> Result<u64> {
+        let value = match self {
+            Value::Generic(value) => value,
+            Value::I8(value) if value >= 0 => value as u64,
+            Value::U8(value) => u64::from(value),
+            Value::I16(value) if value >= 0 => value as u64,
+            Value::U16(value) => u64::from(value),
+            Value::I32(value) if value >= 0 => value as u64,
+            Value::U32(value) => u64::from(value),
+            Value::I64(value) if value >= 0 => value as u64,
+            Value::U64(value) => value,
+            _ => return Err(Error::InvalidShiftExpression),
+        };
+        Ok(value)
+    }
+
+    /// Perform a shift left operation.
+    ///
+    /// This operation requires integral types.
+    /// If the shift length exceeds the type size, then 0 is returned.
+    /// If the shift length is negative then an error is returned.
+    ///
+    /// This corresponds to the DWARF `DW_OP_shl` operation.
+    pub fn shl(self, rhs: Value, addr_mask: u64) -> Result<Value> {
+        let v2 = rhs.shift_length()?;
+        let value = match self {
+            Value::Generic(v1) => Value::Generic(if v2 >= u64::from(mask_bit_size(addr_mask)) {
+                0
+            } else {
+                (v1 & addr_mask) << v2
+            }),
+            Value::I8(v1) => Value::I8(if v2 >= 8 { 0 } else { v1 << v2 }),
+            Value::U8(v1) => Value::U8(if v2 >= 8 { 0 } else { v1 << v2 }),
+            Value::I16(v1) => Value::I16(if v2 >= 16 { 0 } else { v1 << v2 }),
+            Value::U16(v1) => Value::U16(if v2 >= 16 { 0 } else { v1 << v2 }),
+            Value::I32(v1) => Value::I32(if v2 >= 32 { 0 } else { v1 << v2 }),
+            Value::U32(v1) => Value::U32(if v2 >= 32 { 0 } else { v1 << v2 }),
+            Value::I64(v1) => Value::I64(if v2 >= 64 { 0 } else { v1 << v2 }),
+            Value::U64(v1) => Value::U64(if v2 >= 64 { 0 } else { v1 << v2 }),
+            _ => return Err(Error::IntegralTypeRequired),
+        };
+        Ok(value)
+    }
+
+    /// Perform a logical shift right operation.
+    ///
+    /// This operation requires an unsigned integral type for the value.
+    /// If the value type is `Generic`, then it is interpreted as an unsigned value.
+    ///
+    /// This operation requires an integral type for the shift length.
+    /// If the shift length exceeds the type size, then 0 is returned.
+    /// If the shift length is negative then an error is returned.
+    ///
+    /// This corresponds to the DWARF `DW_OP_shr` operation.
+    pub fn shr(self, rhs: Value, addr_mask: u64) -> Result<Value> {
+        let v2 = rhs.shift_length()?;
+        let value = match self {
+            Value::Generic(v1) => Value::Generic(if v2 >= u64::from(mask_bit_size(addr_mask)) {
+                0
+            } else {
+                (v1 & addr_mask) >> v2
+            }),
+            Value::U8(v1) => Value::U8(if v2 >= 8 { 0 } else { v1 >> v2 }),
+            Value::U16(v1) => Value::U16(if v2 >= 16 { 0 } else { v1 >> v2 }),
+            Value::U32(v1) => Value::U32(if v2 >= 32 { 0 } else { v1 >> v2 }),
+            Value::U64(v1) => Value::U64(if v2 >= 64 { 0 } else { v1 >> v2 }),
+            // It's unclear if signed values should implicitly convert to an unsigned value.
+            // For now, we don't support them.
+            Value::I8(_) | Value::I16(_) | Value::I32(_) | Value::I64(_) => {
+                return Err(Error::UnsupportedTypeOperation);
+            }
+            _ => return Err(Error::IntegralTypeRequired),
+        };
+        Ok(value)
+    }
+
+    /// Perform an arithmetic shift right operation.
+    ///
+    /// This operation requires a signed integral type for the value.
+    /// If the value type is `Generic`, then it is interpreted as a signed value.
+    ///
+    /// This operation requires an integral type for the shift length.
+    /// If the shift length exceeds the type size, then 0 is returned for positive values,
+    /// and -1 is returned for negative values.
+    /// If the shift length is negative then an error is returned.
+    ///
+    /// This corresponds to the DWARF `DW_OP_shra` operation.
+    pub fn shra(self, rhs: Value, addr_mask: u64) -> Result<Value> {
+        let v2 = rhs.shift_length()?;
+        let value = match self {
+            Value::Generic(v1) => {
+                let v1 = sign_extend(v1, addr_mask);
+                let value = if v2 >= u64::from(mask_bit_size(addr_mask)) {
+                    if v1 < 0 {
+                        !0
+                    } else {
+                        0
+                    }
+                } else {
+                    (v1 >> v2) as u64
+                };
+                Value::Generic(value)
+            }
+            Value::I8(v1) => Value::I8(if v2 >= 8 {
+                if v1 < 0 {
+                    !0
+                } else {
+                    0
+                }
+            } else {
+                v1 >> v2
+            }),
+            Value::I16(v1) => Value::I16(if v2 >= 16 {
+                if v1 < 0 {
+                    !0
+                } else {
+                    0
+                }
+            } else {
+                v1 >> v2
+            }),
+            Value::I32(v1) => Value::I32(if v2 >= 32 {
+                if v1 < 0 {
+                    !0
+                } else {
+                    0
+                }
+            } else {
+                v1 >> v2
+            }),
+            Value::I64(v1) => Value::I64(if v2 >= 64 {
+                if v1 < 0 {
+                    !0
+                } else {
+                    0
+                }
+            } else {
+                v1 >> v2
+            }),
+            // It's unclear if unsigned values should implicitly convert to a signed value.
+            // For now, we don't support them.
+            Value::U8(_) | Value::U16(_) | Value::U32(_) | Value::U64(_) => {
+                return Err(Error::UnsupportedTypeOperation);
+            }
+            _ => return Err(Error::IntegralTypeRequired),
+        };
+        Ok(value)
+    }
+
+    /// Perform the `==` relational operation.
+    ///
+    /// This operation requires matching integral types.
+    /// If the value type is `Generic`, then it is interpreted as a signed value.
+    ///
+    /// This corresponds to the DWARF `DW_OP_eq` operation.
+    pub fn eq(self, rhs: Value, addr_mask: u64) -> Result<Value> {
+        let value = match (self, rhs) {
+            (Value::Generic(v1), Value::Generic(v2)) => {
+                sign_extend(v1, addr_mask) == sign_extend(v2, addr_mask)
+            }
+            (Value::I8(v1), Value::I8(v2)) => v1 == v2,
+            (Value::U8(v1), Value::U8(v2)) => v1 == v2,
+            (Value::I16(v1), Value::I16(v2)) => v1 == v2,
+            (Value::U16(v1), Value::U16(v2)) => v1 == v2,
+            (Value::I32(v1), Value::I32(v2)) => v1 == v2,
+            (Value::U32(v1), Value::U32(v2)) => v1 == v2,
+            (Value::I64(v1), Value::I64(v2)) => v1 == v2,
+            (Value::U64(v1), Value::U64(v2)) => v1 == v2,
+            (Value::F32(v1), Value::F32(v2)) => v1 == v2,
+            (Value::F64(v1), Value::F64(v2)) => v1 == v2,
+            _ => return Err(Error::TypeMismatch),
+        };
+        Ok(Value::Generic(value as u64))
+    }
+
+    /// Perform the `>=` relational operation.
+    ///
+    /// This operation requires matching integral types.
+    /// If the value type is `Generic`, then it is interpreted as a signed value.
+    ///
+    /// This corresponds to the DWARF `DW_OP_ge` operation.
+    pub fn ge(self, rhs: Value, addr_mask: u64) -> Result<Value> {
+        let value = match (self, rhs) {
+            (Value::Generic(v1), Value::Generic(v2)) => {
+                sign_extend(v1, addr_mask) >= sign_extend(v2, addr_mask)
+            }
+            (Value::I8(v1), Value::I8(v2)) => v1 >= v2,
+            (Value::U8(v1), Value::U8(v2)) => v1 >= v2,
+            (Value::I16(v1), Value::I16(v2)) => v1 >= v2,
+            (Value::U16(v1), Value::U16(v2)) => v1 >= v2,
+            (Value::I32(v1), Value::I32(v2)) => v1 >= v2,
+            (Value::U32(v1), Value::U32(v2)) => v1 >= v2,
+            (Value::I64(v1), Value::I64(v2)) => v1 >= v2,
+            (Value::U64(v1), Value::U64(v2)) => v1 >= v2,
+            (Value::F32(v1), Value::F32(v2)) => v1 >= v2,
+            (Value::F64(v1), Value::F64(v2)) => v1 >= v2,
+            _ => return Err(Error::TypeMismatch),
+        };
+        Ok(Value::Generic(value as u64))
+    }
+
+    /// Perform the `>` relational operation.
+    ///
+    /// This operation requires matching integral types.
+    /// If the value type is `Generic`, then it is interpreted as a signed value.
+    ///
+    /// This corresponds to the DWARF `DW_OP_gt` operation.
+    pub fn gt(self, rhs: Value, addr_mask: u64) -> Result<Value> {
+        let value = match (self, rhs) {
+            (Value::Generic(v1), Value::Generic(v2)) => {
+                sign_extend(v1, addr_mask) > sign_extend(v2, addr_mask)
+            }
+            (Value::I8(v1), Value::I8(v2)) => v1 > v2,
+            (Value::U8(v1), Value::U8(v2)) => v1 > v2,
+            (Value::I16(v1), Value::I16(v2)) => v1 > v2,
+            (Value::U16(v1), Value::U16(v2)) => v1 > v2,
+            (Value::I32(v1), Value::I32(v2)) => v1 > v2,
+            (Value::U32(v1), Value::U32(v2)) => v1 > v2,
+            (Value::I64(v1), Value::I64(v2)) => v1 > v2,
+            (Value::U64(v1), Value::U64(v2)) => v1 > v2,
+            (Value::F32(v1), Value::F32(v2)) => v1 > v2,
+            (Value::F64(v1), Value::F64(v2)) => v1 > v2,
+            _ => return Err(Error::TypeMismatch),
+        };
+        Ok(Value::Generic(value as u64))
+    }
+
+    /// Perform the `<= relational operation.
+    ///
+    /// This operation requires matching integral types.
+    /// If the value type is `Generic`, then it is interpreted as a signed value.
+    ///
+    /// This corresponds to the DWARF `DW_OP_le` operation.
+    pub fn le(self, rhs: Value, addr_mask: u64) -> Result<Value> {
+        let value = match (self, rhs) {
+            (Value::Generic(v1), Value::Generic(v2)) => {
+                sign_extend(v1, addr_mask) <= sign_extend(v2, addr_mask)
+            }
+            (Value::I8(v1), Value::I8(v2)) => v1 <= v2,
+            (Value::U8(v1), Value::U8(v2)) => v1 <= v2,
+            (Value::I16(v1), Value::I16(v2)) => v1 <= v2,
+            (Value::U16(v1), Value::U16(v2)) => v1 <= v2,
+            (Value::I32(v1), Value::I32(v2)) => v1 <= v2,
+            (Value::U32(v1), Value::U32(v2)) => v1 <= v2,
+            (Value::I64(v1), Value::I64(v2)) => v1 <= v2,
+            (Value::U64(v1), Value::U64(v2)) => v1 <= v2,
+            (Value::F32(v1), Value::F32(v2)) => v1 <= v2,
+            (Value::F64(v1), Value::F64(v2)) => v1 <= v2,
+            _ => return Err(Error::TypeMismatch),
+        };
+        Ok(Value::Generic(value as u64))
+    }
+
+    /// Perform the `< relational operation.
+    ///
+    /// This operation requires matching integral types.
+    /// If the value type is `Generic`, then it is interpreted as a signed value.
+    ///
+    /// This corresponds to the DWARF `DW_OP_lt` operation.
+    pub fn lt(self, rhs: Value, addr_mask: u64) -> Result<Value> {
+        let value = match (self, rhs) {
+            (Value::Generic(v1), Value::Generic(v2)) => {
+                sign_extend(v1, addr_mask) < sign_extend(v2, addr_mask)
+            }
+            (Value::I8(v1), Value::I8(v2)) => v1 < v2,
+            (Value::U8(v1), Value::U8(v2)) => v1 < v2,
+            (Value::I16(v1), Value::I16(v2)) => v1 < v2,
+            (Value::U16(v1), Value::U16(v2)) => v1 < v2,
+            (Value::I32(v1), Value::I32(v2)) => v1 < v2,
+            (Value::U32(v1), Value::U32(v2)) => v1 < v2,
+            (Value::I64(v1), Value::I64(v2)) => v1 < v2,
+            (Value::U64(v1), Value::U64(v2)) => v1 < v2,
+            (Value::F32(v1), Value::F32(v2)) => v1 < v2,
+            (Value::F64(v1), Value::F64(v2)) => v1 < v2,
+            _ => return Err(Error::TypeMismatch),
+        };
+        Ok(Value::Generic(value as u64))
+    }
+
+    /// Perform the `!= relational operation.
+    ///
+    /// This operation requires matching integral types.
+    /// If the value type is `Generic`, then it is interpreted as a signed value.
+    ///
+    /// This corresponds to the DWARF `DW_OP_ne` operation.
+    pub fn ne(self, rhs: Value, addr_mask: u64) -> Result<Value> {
+        let value = match (self, rhs) {
+            (Value::Generic(v1), Value::Generic(v2)) => {
+                sign_extend(v1, addr_mask) != sign_extend(v2, addr_mask)
+            }
+            (Value::I8(v1), Value::I8(v2)) => v1 != v2,
+            (Value::U8(v1), Value::U8(v2)) => v1 != v2,
+            (Value::I16(v1), Value::I16(v2)) => v1 != v2,
+            (Value::U16(v1), Value::U16(v2)) => v1 != v2,
+            (Value::I32(v1), Value::I32(v2)) => v1 != v2,
+            (Value::U32(v1), Value::U32(v2)) => v1 != v2,
+            (Value::I64(v1), Value::I64(v2)) => v1 != v2,
+            (Value::U64(v1), Value::U64(v2)) => v1 != v2,
+            (Value::F32(v1), Value::F32(v2)) => v1 != v2,
+            (Value::F64(v1), Value::F64(v2)) => v1 != v2,
+            _ => return Err(Error::TypeMismatch),
+        };
+        Ok(Value::Generic(value as u64))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::common::{DebugAbbrevOffset, DebugInfoOffset, Encoding, Format};
+    use crate::endianity::LittleEndian;
+    use crate::read::{
+        Abbreviation, AttributeSpecification, DebuggingInformationEntry, EndianSlice, UnitHeader,
+        UnitOffset, UnitType,
+    };
+
+    #[test]
+    #[rustfmt::skip]
+    fn valuetype_from_encoding() {
+        let encoding = Encoding {
+            format: Format::Dwarf32,
+            version: 4,
+            address_size: 4,
+        };
+        let unit = UnitHeader::new(
+            encoding,
+            7,
+            UnitType::Compilation,
+            DebugAbbrevOffset(0),
+            DebugInfoOffset(0).into(),
+            EndianSlice::new(&[], LittleEndian),
+        );
+
+        let abbrev = Abbreviation::new(
+            42,
+            constants::DW_TAG_base_type,
+            constants::DW_CHILDREN_no,
+            vec![
+                AttributeSpecification::new(
+                    constants::DW_AT_byte_size,
+                    constants::DW_FORM_udata,
+                    None,
+                ),
+                AttributeSpecification::new(
+                    constants::DW_AT_encoding,
+                    constants::DW_FORM_udata,
+                    None,
+                ),
+                AttributeSpecification::new(
+                    constants::DW_AT_endianity,
+                    constants::DW_FORM_udata,
+                    None,
+                ),
+            ].into(),
+        );
+
+        for &(attrs, result) in &[
+            ([0x01, constants::DW_ATE_signed.0, constants::DW_END_default.0], ValueType::I8),
+            ([0x02, constants::DW_ATE_signed.0, constants::DW_END_default.0], ValueType::I16),
+            ([0x04, constants::DW_ATE_signed.0, constants::DW_END_default.0], ValueType::I32),
+            ([0x08, constants::DW_ATE_signed.0, constants::DW_END_default.0], ValueType::I64),
+            ([0x01, constants::DW_ATE_unsigned.0, constants::DW_END_default.0], ValueType::U8),
+            ([0x02, constants::DW_ATE_unsigned.0, constants::DW_END_default.0], ValueType::U16),
+            ([0x04, constants::DW_ATE_unsigned.0, constants::DW_END_default.0], ValueType::U32),
+            ([0x08, constants::DW_ATE_unsigned.0, constants::DW_END_default.0], ValueType::U64),
+            ([0x04, constants::DW_ATE_float.0, constants::DW_END_default.0], ValueType::F32),
+            ([0x08, constants::DW_ATE_float.0, constants::DW_END_default.0], ValueType::F64),
+        ] {
+            let entry = DebuggingInformationEntry::new(
+                UnitOffset(0),
+                EndianSlice::new(&attrs, LittleEndian),
+                &abbrev,
+                &unit,
+            );
+            assert_eq!(ValueType::from_entry(&entry), Ok(Some(result)));
+        }
+
+        for attrs in &[
+            [0x03, constants::DW_ATE_signed.0, constants::DW_END_default.0],
+            [0x02, constants::DW_ATE_signed.0, constants::DW_END_big.0],
+        ] {
+            let entry = DebuggingInformationEntry::new(
+                UnitOffset(0),
+                EndianSlice::new(attrs, LittleEndian),
+                &abbrev,
+                &unit,
+            );
+            assert_eq!(ValueType::from_entry(&entry), Ok(None));
+        }
+    }
+
+    #[test]
+    fn value_convert() {
+        let addr_mask = !0 >> 32;
+        for &(v, t, result) in &[
+            (Value::Generic(1), ValueType::I8, Ok(Value::I8(1))),
+            (Value::I8(1), ValueType::U8, Ok(Value::U8(1))),
+            (Value::U8(1), ValueType::I16, Ok(Value::I16(1))),
+            (Value::I16(1), ValueType::U16, Ok(Value::U16(1))),
+            (Value::U16(1), ValueType::I32, Ok(Value::I32(1))),
+            (Value::I32(1), ValueType::U32, Ok(Value::U32(1))),
+            (Value::U32(1), ValueType::F32, Ok(Value::F32(1.))),
+            (Value::F32(1.), ValueType::I64, Ok(Value::I64(1))),
+            (Value::I64(1), ValueType::U64, Ok(Value::U64(1))),
+            (Value::U64(1), ValueType::F64, Ok(Value::F64(1.))),
+            (Value::F64(1.), ValueType::Generic, Ok(Value::Generic(1))),
+        ] {
+            assert_eq!(v.convert(t, addr_mask), result);
+        }
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn value_reinterpret() {
+        let addr_mask = !0 >> 32;
+        for &(v, t, result) in &[
+            // 8-bit
+            (Value::I8(-1), ValueType::U8, Ok(Value::U8(0xff))),
+            (Value::U8(0xff), ValueType::I8, Ok(Value::I8(-1))),
+            // 16-bit
+            (Value::I16(1), ValueType::U16, Ok(Value::U16(1))),
+            (Value::U16(1), ValueType::I16, Ok(Value::I16(1))),
+            // 32-bit
+            (Value::Generic(1), ValueType::I32, Ok(Value::I32(1))),
+            (Value::I32(1), ValueType::U32, Ok(Value::U32(1))),
+            (Value::U32(0x3f80_0000), ValueType::F32, Ok(Value::F32(1.0))),
+            (Value::F32(1.0), ValueType::Generic, Ok(Value::Generic(0x3f80_0000))),
+            // Type mismatches
+            (Value::Generic(1), ValueType::U8, Err(Error::TypeMismatch)),
+            (Value::U8(1), ValueType::U16, Err(Error::TypeMismatch)),
+            (Value::U16(1), ValueType::U32, Err(Error::TypeMismatch)),
+            (Value::U32(1), ValueType::U64, Err(Error::TypeMismatch)),
+            (Value::U64(1), ValueType::Generic, Err(Error::TypeMismatch)),
+        ] {
+            assert_eq!(v.reinterpret(t, addr_mask), result);
+        }
+
+        let addr_mask = !0;
+        for &(v, t, result) in &[
+            // 64-bit
+            (Value::Generic(1), ValueType::I64, Ok(Value::I64(1))),
+            (Value::I64(1), ValueType::U64, Ok(Value::U64(1))),
+            (Value::U64(0x3ff0_0000_0000_0000), ValueType::F64, Ok(Value::F64(1.0))),
+            (Value::F64(1.0), ValueType::Generic, Ok(Value::Generic(0x3ff0_0000_0000_0000))),
+        ] {
+            assert_eq!(v.reinterpret(t, addr_mask), result);
+        }
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn value_abs() {
+        let addr_mask = 0xffff_ffff;
+        for &(v, result) in &[
+            (Value::Generic(0xffff_ffff), Ok(Value::Generic(1))),
+            (Value::I8(-1), Ok(Value::I8(1))),
+            (Value::U8(1), Ok(Value::U8(1))),
+            (Value::I16(-1), Ok(Value::I16(1))),
+            (Value::U16(1), Ok(Value::U16(1))),
+            (Value::I32(-1), Ok(Value::I32(1))),
+            (Value::U32(1), Ok(Value::U32(1))),
+            (Value::I64(-1), Ok(Value::I64(1))),
+            (Value::U64(1), Ok(Value::U64(1))),
+            (Value::F32(-1.), Ok(Value::F32(1.))),
+            (Value::F64(-1.), Ok(Value::F64(1.))),
+        ] {
+            assert_eq!(v.abs(addr_mask), result);
+        }
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn value_neg() {
+        let addr_mask = 0xffff_ffff;
+        for &(v, result) in &[
+            (Value::Generic(0xffff_ffff), Ok(Value::Generic(1))),
+            (Value::I8(1), Ok(Value::I8(-1))),
+            (Value::U8(1), Err(Error::UnsupportedTypeOperation)),
+            (Value::I16(1), Ok(Value::I16(-1))),
+            (Value::U16(1), Err(Error::UnsupportedTypeOperation)),
+            (Value::I32(1), Ok(Value::I32(-1))),
+            (Value::U32(1), Err(Error::UnsupportedTypeOperation)),
+            (Value::I64(1), Ok(Value::I64(-1))),
+            (Value::U64(1), Err(Error::UnsupportedTypeOperation)),
+            (Value::F32(1.), Ok(Value::F32(-1.))),
+            (Value::F64(1.), Ok(Value::F64(-1.))),
+        ] {
+            assert_eq!(v.neg(addr_mask), result);
+        }
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn value_add() {
+        let addr_mask = 0xffff_ffff;
+        for &(v1, v2, result) in &[
+            (Value::Generic(1), Value::Generic(2), Ok(Value::Generic(3))),
+            (Value::I8(-1), Value::I8(2), Ok(Value::I8(1))),
+            (Value::U8(1), Value::U8(2), Ok(Value::U8(3))),
+            (Value::I16(-1), Value::I16(2), Ok(Value::I16(1))),
+            (Value::U16(1), Value::U16(2), Ok(Value::U16(3))),
+            (Value::I32(-1), Value::I32(2), Ok(Value::I32(1))),
+            (Value::U32(1), Value::U32(2), Ok(Value::U32(3))),
+            (Value::I64(-1), Value::I64(2), Ok(Value::I64(1))),
+            (Value::U64(1), Value::U64(2), Ok(Value::U64(3))),
+            (Value::F32(-1.), Value::F32(2.), Ok(Value::F32(1.))),
+            (Value::F64(-1.), Value::F64(2.), Ok(Value::F64(1.))),
+            (Value::Generic(1), Value::U32(2), Err(Error::TypeMismatch)),
+        ] {
+            assert_eq!(v1.add(v2, addr_mask), result);
+        }
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn value_sub() {
+        let addr_mask = 0xffff_ffff;
+        for &(v1, v2, result) in &[
+            (Value::Generic(3), Value::Generic(2), Ok(Value::Generic(1))),
+            (Value::I8(-1), Value::I8(2), Ok(Value::I8(-3))),
+            (Value::U8(3), Value::U8(2), Ok(Value::U8(1))),
+            (Value::I16(-1), Value::I16(2), Ok(Value::I16(-3))),
+            (Value::U16(3), Value::U16(2), Ok(Value::U16(1))),
+            (Value::I32(-1), Value::I32(2), Ok(Value::I32(-3))),
+            (Value::U32(3), Value::U32(2), Ok(Value::U32(1))),
+            (Value::I64(-1), Value::I64(2), Ok(Value::I64(-3))),
+            (Value::U64(3), Value::U64(2), Ok(Value::U64(1))),
+            (Value::F32(-1.), Value::F32(2.), Ok(Value::F32(-3.))),
+            (Value::F64(-1.), Value::F64(2.), Ok(Value::F64(-3.))),
+            (Value::Generic(3), Value::U32(2), Err(Error::TypeMismatch)),
+        ] {
+            assert_eq!(v1.sub(v2, addr_mask), result);
+        }
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn value_mul() {
+        let addr_mask = 0xffff_ffff;
+        for &(v1, v2, result) in &[
+            (Value::Generic(2), Value::Generic(3), Ok(Value::Generic(6))),
+            (Value::I8(-2), Value::I8(3), Ok(Value::I8(-6))),
+            (Value::U8(2), Value::U8(3), Ok(Value::U8(6))),
+            (Value::I16(-2), Value::I16(3), Ok(Value::I16(-6))),
+            (Value::U16(2), Value::U16(3), Ok(Value::U16(6))),
+            (Value::I32(-2), Value::I32(3), Ok(Value::I32(-6))),
+            (Value::U32(2), Value::U32(3), Ok(Value::U32(6))),
+            (Value::I64(-2), Value::I64(3), Ok(Value::I64(-6))),
+            (Value::U64(2), Value::U64(3), Ok(Value::U64(6))),
+            (Value::F32(-2.), Value::F32(3.), Ok(Value::F32(-6.))),
+            (Value::F64(-2.), Value::F64(3.), Ok(Value::F64(-6.))),
+            (Value::Generic(2), Value::U32(3), Err(Error::TypeMismatch)),
+        ] {
+            assert_eq!(v1.mul(v2, addr_mask), result);
+        }
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn value_div() {
+        let addr_mask = 0xffff_ffff;
+        for &(v1, v2, result) in &[
+            (Value::Generic(6), Value::Generic(3), Ok(Value::Generic(2))),
+            (Value::I8(-6), Value::I8(3), Ok(Value::I8(-2))),
+            (Value::U8(6), Value::U8(3), Ok(Value::U8(2))),
+            (Value::I16(-6), Value::I16(3), Ok(Value::I16(-2))),
+            (Value::U16(6), Value::U16(3), Ok(Value::U16(2))),
+            (Value::I32(-6), Value::I32(3), Ok(Value::I32(-2))),
+            (Value::U32(6), Value::U32(3), Ok(Value::U32(2))),
+            (Value::I64(-6), Value::I64(3), Ok(Value::I64(-2))),
+            (Value::U64(6), Value::U64(3), Ok(Value::U64(2))),
+            (Value::F32(-6.), Value::F32(3.), Ok(Value::F32(-2.))),
+            (Value::F64(-6.), Value::F64(3.), Ok(Value::F64(-2.))),
+            (Value::Generic(6), Value::U32(3), Err(Error::TypeMismatch)),
+        ] {
+            assert_eq!(v1.div(v2, addr_mask), result);
+        }
+        for &(v1, v2, result) in &[
+            (Value::Generic(6), Value::Generic(0), Err(Error::DivisionByZero)),
+            (Value::I8(-6), Value::I8(0), Err(Error::DivisionByZero)),
+            (Value::U8(6), Value::U8(0), Err(Error::DivisionByZero)),
+            (Value::I16(-6), Value::I16(0), Err(Error::DivisionByZero)),
+            (Value::U16(6), Value::U16(0), Err(Error::DivisionByZero)),
+            (Value::I32(-6), Value::I32(0), Err(Error::DivisionByZero)),
+            (Value::U32(6), Value::U32(0), Err(Error::DivisionByZero)),
+            (Value::I64(-6), Value::I64(0), Err(Error::DivisionByZero)),
+            (Value::U64(6), Value::U64(0), Err(Error::DivisionByZero)),
+            (Value::F32(-6.), Value::F32(0.), Ok(Value::F32(-6. / 0.))),
+            (Value::F64(-6.), Value::F64(0.), Ok(Value::F64(-6. / 0.))),
+        ] {
+            assert_eq!(v1.div(v2, addr_mask), result);
+        }
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn value_rem() {
+        let addr_mask = 0xffff_ffff;
+        for &(v1, v2, result) in &[
+            (Value::Generic(3), Value::Generic(2), Ok(Value::Generic(1))),
+            (Value::I8(-3), Value::I8(2), Ok(Value::I8(-1))),
+            (Value::U8(3), Value::U8(2), Ok(Value::U8(1))),
+            (Value::I16(-3), Value::I16(2), Ok(Value::I16(-1))),
+            (Value::U16(3), Value::U16(2), Ok(Value::U16(1))),
+            (Value::I32(-3), Value::I32(2), Ok(Value::I32(-1))),
+            (Value::U32(3), Value::U32(2), Ok(Value::U32(1))),
+            (Value::I64(-3), Value::I64(2), Ok(Value::I64(-1))),
+            (Value::U64(3), Value::U64(2), Ok(Value::U64(1))),
+            (Value::F32(-3.), Value::F32(2.), Err(Error::IntegralTypeRequired)),
+            (Value::F64(-3.), Value::F64(2.), Err(Error::IntegralTypeRequired)),
+            (Value::Generic(3), Value::U32(2), Err(Error::TypeMismatch)),
+        ] {
+            assert_eq!(v1.rem(v2, addr_mask), result);
+        }
+        for &(v1, v2, result) in &[
+            (Value::Generic(3), Value::Generic(0), Err(Error::DivisionByZero)),
+            (Value::I8(-3), Value::I8(0), Err(Error::DivisionByZero)),
+            (Value::U8(3), Value::U8(0), Err(Error::DivisionByZero)),
+            (Value::I16(-3), Value::I16(0), Err(Error::DivisionByZero)),
+            (Value::U16(3), Value::U16(0), Err(Error::DivisionByZero)),
+            (Value::I32(-3), Value::I32(0), Err(Error::DivisionByZero)),
+            (Value::U32(3), Value::U32(0), Err(Error::DivisionByZero)),
+            (Value::I64(-3), Value::I64(0), Err(Error::DivisionByZero)),
+            (Value::U64(3), Value::U64(0), Err(Error::DivisionByZero)),
+        ] {
+            assert_eq!(v1.rem(v2, addr_mask), result);
+        }
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn value_not() {
+        let addr_mask = 0xffff_ffff;
+        for &(v, result) in &[
+            (Value::Generic(1), Ok(Value::Generic(!1))),
+            (Value::I8(1), Ok(Value::I8(!1))),
+            (Value::U8(1), Ok(Value::U8(!1))),
+            (Value::I16(1), Ok(Value::I16(!1))),
+            (Value::U16(1), Ok(Value::U16(!1))),
+            (Value::I32(1), Ok(Value::I32(!1))),
+            (Value::U32(1), Ok(Value::U32(!1))),
+            (Value::I64(1), Ok(Value::I64(!1))),
+            (Value::U64(1), Ok(Value::U64(!1))),
+            (Value::F32(1.), Err(Error::IntegralTypeRequired)),
+            (Value::F64(1.), Err(Error::IntegralTypeRequired)),
+        ] {
+            assert_eq!(v.not(addr_mask), result);
+        }
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn value_and() {
+        let addr_mask = 0xffff_ffff;
+        for &(v1, v2, result) in &[
+            (Value::Generic(3), Value::Generic(5), Ok(Value::Generic(1))),
+            (Value::I8(3), Value::I8(5), Ok(Value::I8(1))),
+            (Value::U8(3), Value::U8(5), Ok(Value::U8(1))),
+            (Value::I16(3), Value::I16(5), Ok(Value::I16(1))),
+            (Value::U16(3), Value::U16(5), Ok(Value::U16(1))),
+            (Value::I32(3), Value::I32(5), Ok(Value::I32(1))),
+            (Value::U32(3), Value::U32(5), Ok(Value::U32(1))),
+            (Value::I64(3), Value::I64(5), Ok(Value::I64(1))),
+            (Value::U64(3), Value::U64(5), Ok(Value::U64(1))),
+            (Value::F32(3.), Value::F32(5.), Err(Error::IntegralTypeRequired)),
+            (Value::F64(3.), Value::F64(5.), Err(Error::IntegralTypeRequired)),
+            (Value::Generic(3), Value::U32(5), Err(Error::TypeMismatch)),
+        ] {
+            assert_eq!(v1.and(v2, addr_mask), result);
+        }
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn value_or() {
+        let addr_mask = 0xffff_ffff;
+        for &(v1, v2, result) in &[
+            (Value::Generic(3), Value::Generic(5), Ok(Value::Generic(7))),
+            (Value::I8(3), Value::I8(5), Ok(Value::I8(7))),
+            (Value::U8(3), Value::U8(5), Ok(Value::U8(7))),
+            (Value::I16(3), Value::I16(5), Ok(Value::I16(7))),
+            (Value::U16(3), Value::U16(5), Ok(Value::U16(7))),
+            (Value::I32(3), Value::I32(5), Ok(Value::I32(7))),
+            (Value::U32(3), Value::U32(5), Ok(Value::U32(7))),
+            (Value::I64(3), Value::I64(5), Ok(Value::I64(7))),
+            (Value::U64(3), Value::U64(5), Ok(Value::U64(7))),
+            (Value::F32(3.), Value::F32(5.), Err(Error::IntegralTypeRequired)),
+            (Value::F64(3.), Value::F64(5.), Err(Error::IntegralTypeRequired)),
+            (Value::Generic(3), Value::U32(5), Err(Error::TypeMismatch)),
+        ] {
+            assert_eq!(v1.or(v2, addr_mask), result);
+        }
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn value_xor() {
+        let addr_mask = 0xffff_ffff;
+        for &(v1, v2, result) in &[
+            (Value::Generic(3), Value::Generic(5), Ok(Value::Generic(6))),
+            (Value::I8(3), Value::I8(5), Ok(Value::I8(6))),
+            (Value::U8(3), Value::U8(5), Ok(Value::U8(6))),
+            (Value::I16(3), Value::I16(5), Ok(Value::I16(6))),
+            (Value::U16(3), Value::U16(5), Ok(Value::U16(6))),
+            (Value::I32(3), Value::I32(5), Ok(Value::I32(6))),
+            (Value::U32(3), Value::U32(5), Ok(Value::U32(6))),
+            (Value::I64(3), Value::I64(5), Ok(Value::I64(6))),
+            (Value::U64(3), Value::U64(5), Ok(Value::U64(6))),
+            (Value::F32(3.), Value::F32(5.), Err(Error::IntegralTypeRequired)),
+            (Value::F64(3.), Value::F64(5.), Err(Error::IntegralTypeRequired)),
+            (Value::Generic(3), Value::U32(5), Err(Error::TypeMismatch)),
+        ] {
+            assert_eq!(v1.xor(v2, addr_mask), result);
+        }
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn value_shl() {
+        let addr_mask = 0xffff_ffff;
+        for &(v1, v2, result) in &[
+            // One of each type
+            (Value::Generic(3), Value::Generic(5), Ok(Value::Generic(96))),
+            (Value::I8(3), Value::U8(5), Ok(Value::I8(96))),
+            (Value::U8(3), Value::I8(5), Ok(Value::U8(96))),
+            (Value::I16(3), Value::U16(5), Ok(Value::I16(96))),
+            (Value::U16(3), Value::I16(5), Ok(Value::U16(96))),
+            (Value::I32(3), Value::U32(5), Ok(Value::I32(96))),
+            (Value::U32(3), Value::I32(5), Ok(Value::U32(96))),
+            (Value::I64(3), Value::U64(5), Ok(Value::I64(96))),
+            (Value::U64(3), Value::I64(5), Ok(Value::U64(96))),
+            (Value::F32(3.), Value::U8(5), Err(Error::IntegralTypeRequired)),
+            (Value::F64(3.), Value::U8(5), Err(Error::IntegralTypeRequired)),
+            // Invalid shifts
+            (Value::U8(3), Value::I8(-5), Err(Error::InvalidShiftExpression)),
+            (Value::U8(3), Value::I16(-5), Err(Error::InvalidShiftExpression)),
+            (Value::U8(3), Value::I32(-5), Err(Error::InvalidShiftExpression)),
+            (Value::U8(3), Value::I64(-5), Err(Error::InvalidShiftExpression)),
+            (Value::U8(3), Value::F32(5.), Err(Error::InvalidShiftExpression)),
+            (Value::U8(3), Value::F64(5.), Err(Error::InvalidShiftExpression)),
+            // Large shifts
+            (Value::Generic(3), Value::Generic(32), Ok(Value::Generic(0))),
+            (Value::I8(3), Value::U8(8), Ok(Value::I8(0))),
+            (Value::U8(3), Value::I8(9), Ok(Value::U8(0))),
+            (Value::I16(3), Value::U16(17), Ok(Value::I16(0))),
+            (Value::U16(3), Value::I16(16), Ok(Value::U16(0))),
+            (Value::I32(3), Value::U32(32), Ok(Value::I32(0))),
+            (Value::U32(3), Value::I32(33), Ok(Value::U32(0))),
+            (Value::I64(3), Value::U64(65), Ok(Value::I64(0))),
+            (Value::U64(3), Value::I64(64), Ok(Value::U64(0))),
+        ] {
+            assert_eq!(v1.shl(v2, addr_mask), result);
+        }
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn value_shr() {
+        let addr_mask = 0xffff_ffff;
+        for &(v1, v2, result) in &[
+            // One of each type
+            (Value::Generic(96), Value::Generic(5), Ok(Value::Generic(3))),
+            (Value::I8(96), Value::U8(5), Err(Error::UnsupportedTypeOperation)),
+            (Value::U8(96), Value::I8(5), Ok(Value::U8(3))),
+            (Value::I16(96), Value::U16(5), Err(Error::UnsupportedTypeOperation)),
+            (Value::U16(96), Value::I16(5), Ok(Value::U16(3))),
+            (Value::I32(96), Value::U32(5), Err(Error::UnsupportedTypeOperation)),
+            (Value::U32(96), Value::I32(5), Ok(Value::U32(3))),
+            (Value::I64(96), Value::U64(5), Err(Error::UnsupportedTypeOperation)),
+            (Value::U64(96), Value::I64(5), Ok(Value::U64(3))),
+            (Value::F32(96.), Value::U8(5), Err(Error::IntegralTypeRequired)),
+            (Value::F64(96.), Value::U8(5), Err(Error::IntegralTypeRequired)),
+            // Invalid shifts
+            (Value::U8(96), Value::I8(-5), Err(Error::InvalidShiftExpression)),
+            (Value::U8(96), Value::I16(-5), Err(Error::InvalidShiftExpression)),
+            (Value::U8(96), Value::I32(-5), Err(Error::InvalidShiftExpression)),
+            (Value::U8(96), Value::I64(-5), Err(Error::InvalidShiftExpression)),
+            (Value::U8(96), Value::F32(5.), Err(Error::InvalidShiftExpression)),
+            (Value::U8(96), Value::F64(5.), Err(Error::InvalidShiftExpression)),
+            // Large shifts
+            (Value::Generic(96), Value::Generic(32), Ok(Value::Generic(0))),
+            (Value::U8(96), Value::I8(9), Ok(Value::U8(0))),
+            (Value::U16(96), Value::I16(16), Ok(Value::U16(0))),
+            (Value::U32(96), Value::I32(33), Ok(Value::U32(0))),
+            (Value::U64(96), Value::I64(64), Ok(Value::U64(0))),
+        ] {
+            assert_eq!(v1.shr(v2, addr_mask), result);
+        }
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn value_shra() {
+        let addr_mask = 0xffff_ffff;
+        for &(v1, v2, result) in &[
+            // One of each type
+            (Value::Generic(u64::from(-96i32 as u32)), Value::Generic(5), Ok(Value::Generic(-3i64 as u64))),
+            (Value::I8(-96), Value::U8(5), Ok(Value::I8(-3))),
+            (Value::U8(96), Value::I8(5), Err(Error::UnsupportedTypeOperation)),
+            (Value::I16(-96), Value::U16(5), Ok(Value::I16(-3))),
+            (Value::U16(96), Value::I16(5), Err(Error::UnsupportedTypeOperation)),
+            (Value::I32(-96), Value::U32(5), Ok(Value::I32(-3))),
+            (Value::U32(96), Value::I32(5), Err(Error::UnsupportedTypeOperation)),
+            (Value::I64(-96), Value::U64(5), Ok(Value::I64(-3))),
+            (Value::U64(96), Value::I64(5), Err(Error::UnsupportedTypeOperation)),
+            (Value::F32(96.), Value::U8(5), Err(Error::IntegralTypeRequired)),
+            (Value::F64(96.), Value::U8(5), Err(Error::IntegralTypeRequired)),
+            // Invalid shifts
+            (Value::U8(96), Value::I8(-5), Err(Error::InvalidShiftExpression)),
+            (Value::U8(96), Value::I16(-5), Err(Error::InvalidShiftExpression)),
+            (Value::U8(96), Value::I32(-5), Err(Error::InvalidShiftExpression)),
+            (Value::U8(96), Value::I64(-5), Err(Error::InvalidShiftExpression)),
+            (Value::U8(96), Value::F32(5.), Err(Error::InvalidShiftExpression)),
+            (Value::U8(96), Value::F64(5.), Err(Error::InvalidShiftExpression)),
+            // Large shifts
+            (Value::Generic(96), Value::Generic(32), Ok(Value::Generic(0))),
+            (Value::I8(96), Value::U8(8), Ok(Value::I8(0))),
+            (Value::I8(-96), Value::U8(8), Ok(Value::I8(-1))),
+            (Value::I16(96), Value::U16(17), Ok(Value::I16(0))),
+            (Value::I16(-96), Value::U16(17), Ok(Value::I16(-1))),
+            (Value::I32(96), Value::U32(32), Ok(Value::I32(0))),
+            (Value::I32(-96), Value::U32(32), Ok(Value::I32(-1))),
+            (Value::I64(96), Value::U64(65), Ok(Value::I64(0))),
+            (Value::I64(-96), Value::U64(65), Ok(Value::I64(-1))),
+        ] {
+            assert_eq!(v1.shra(v2, addr_mask), result);
+        }
+    }
+
+    #[test]
+    fn value_eq() {
+        let addr_mask = 0xffff_ffff;
+        for &(v1, v2, result) in &[
+            (Value::Generic(3), Value::Generic(3), Ok(Value::Generic(1))),
+            (Value::Generic(!3), Value::Generic(3), Ok(Value::Generic(0))),
+            (Value::I8(3), Value::I8(3), Ok(Value::Generic(1))),
+            (Value::I8(!3), Value::I8(3), Ok(Value::Generic(0))),
+            (Value::U8(3), Value::U8(3), Ok(Value::Generic(1))),
+            (Value::U8(!3), Value::U8(3), Ok(Value::Generic(0))),
+            (Value::I16(3), Value::I16(3), Ok(Value::Generic(1))),
+            (Value::I16(!3), Value::I16(3), Ok(Value::Generic(0))),
+            (Value::U16(3), Value::U16(3), Ok(Value::Generic(1))),
+            (Value::U16(!3), Value::U16(3), Ok(Value::Generic(0))),
+            (Value::I32(3), Value::I32(3), Ok(Value::Generic(1))),
+            (Value::I32(!3), Value::I32(3), Ok(Value::Generic(0))),
+            (Value::U32(3), Value::U32(3), Ok(Value::Generic(1))),
+            (Value::U32(!3), Value::U32(3), Ok(Value::Generic(0))),
+            (Value::I64(3), Value::I64(3), Ok(Value::Generic(1))),
+            (Value::I64(!3), Value::I64(3), Ok(Value::Generic(0))),
+            (Value::U64(3), Value::U64(3), Ok(Value::Generic(1))),
+            (Value::U64(!3), Value::U64(3), Ok(Value::Generic(0))),
+            (Value::F32(3.), Value::F32(3.), Ok(Value::Generic(1))),
+            (Value::F32(-3.), Value::F32(3.), Ok(Value::Generic(0))),
+            (Value::F64(3.), Value::F64(3.), Ok(Value::Generic(1))),
+            (Value::F64(-3.), Value::F64(3.), Ok(Value::Generic(0))),
+            (Value::Generic(3), Value::U32(3), Err(Error::TypeMismatch)),
+        ] {
+            assert_eq!(v1.eq(v2, addr_mask), result);
+        }
+    }
+
+    #[test]
+    fn value_ne() {
+        let addr_mask = 0xffff_ffff;
+        for &(v1, v2, result) in &[
+            (Value::Generic(3), Value::Generic(3), Ok(Value::Generic(0))),
+            (Value::Generic(!3), Value::Generic(3), Ok(Value::Generic(1))),
+            (Value::I8(3), Value::I8(3), Ok(Value::Generic(0))),
+            (Value::I8(!3), Value::I8(3), Ok(Value::Generic(1))),
+            (Value::U8(3), Value::U8(3), Ok(Value::Generic(0))),
+            (Value::U8(!3), Value::U8(3), Ok(Value::Generic(1))),
+            (Value::I16(3), Value::I16(3), Ok(Value::Generic(0))),
+            (Value::I16(!3), Value::I16(3), Ok(Value::Generic(1))),
+            (Value::U16(3), Value::U16(3), Ok(Value::Generic(0))),
+            (Value::U16(!3), Value::U16(3), Ok(Value::Generic(1))),
+            (Value::I32(3), Value::I32(3), Ok(Value::Generic(0))),
+            (Value::I32(!3), Value::I32(3), Ok(Value::Generic(1))),
+            (Value::U32(3), Value::U32(3), Ok(Value::Generic(0))),
+            (Value::U32(!3), Value::U32(3), Ok(Value::Generic(1))),
+            (Value::I64(3), Value::I64(3), Ok(Value::Generic(0))),
+            (Value::I64(!3), Value::I64(3), Ok(Value::Generic(1))),
+            (Value::U64(3), Value::U64(3), Ok(Value::Generic(0))),
+            (Value::U64(!3), Value::U64(3), Ok(Value::Generic(1))),
+            (Value::F32(3.), Value::F32(3.), Ok(Value::Generic(0))),
+            (Value::F32(-3.), Value::F32(3.), Ok(Value::Generic(1))),
+            (Value::F64(3.), Value::F64(3.), Ok(Value::Generic(0))),
+            (Value::F64(-3.), Value::F64(3.), Ok(Value::Generic(1))),
+            (Value::Generic(3), Value::U32(3), Err(Error::TypeMismatch)),
+        ] {
+            assert_eq!(v1.ne(v2, addr_mask), result);
+        }
+    }
+
+    #[test]
+    fn value_ge() {
+        let addr_mask = 0xffff_ffff;
+        for &(v1, v2, result) in &[
+            (Value::Generic(3), Value::Generic(!3), Ok(Value::Generic(1))),
+            (Value::Generic(!3), Value::Generic(3), Ok(Value::Generic(0))),
+            (Value::I8(3), Value::I8(!3), Ok(Value::Generic(1))),
+            (Value::I8(!3), Value::I8(3), Ok(Value::Generic(0))),
+            (Value::U8(3), Value::U8(!3), Ok(Value::Generic(0))),
+            (Value::U8(!3), Value::U8(3), Ok(Value::Generic(1))),
+            (Value::I16(3), Value::I16(!3), Ok(Value::Generic(1))),
+            (Value::I16(!3), Value::I16(3), Ok(Value::Generic(0))),
+            (Value::U16(3), Value::U16(!3), Ok(Value::Generic(0))),
+            (Value::U16(!3), Value::U16(3), Ok(Value::Generic(1))),
+            (Value::I32(3), Value::I32(!3), Ok(Value::Generic(1))),
+            (Value::I32(!3), Value::I32(3), Ok(Value::Generic(0))),
+            (Value::U32(3), Value::U32(!3), Ok(Value::Generic(0))),
+            (Value::U32(!3), Value::U32(3), Ok(Value::Generic(1))),
+            (Value::I64(3), Value::I64(!3), Ok(Value::Generic(1))),
+            (Value::I64(!3), Value::I64(3), Ok(Value::Generic(0))),
+            (Value::U64(3), Value::U64(!3), Ok(Value::Generic(0))),
+            (Value::U64(!3), Value::U64(3), Ok(Value::Generic(1))),
+            (Value::F32(3.), Value::F32(-3.), Ok(Value::Generic(1))),
+            (Value::F32(-3.), Value::F32(3.), Ok(Value::Generic(0))),
+            (Value::F64(3.), Value::F64(-3.), Ok(Value::Generic(1))),
+            (Value::F64(-3.), Value::F64(3.), Ok(Value::Generic(0))),
+            (Value::Generic(3), Value::U32(3), Err(Error::TypeMismatch)),
+        ] {
+            assert_eq!(v1.ge(v2, addr_mask), result);
+        }
+    }
+
+    #[test]
+    fn value_gt() {
+        let addr_mask = 0xffff_ffff;
+        for &(v1, v2, result) in &[
+            (Value::Generic(3), Value::Generic(!3), Ok(Value::Generic(1))),
+            (Value::Generic(!3), Value::Generic(3), Ok(Value::Generic(0))),
+            (Value::I8(3), Value::I8(!3), Ok(Value::Generic(1))),
+            (Value::I8(!3), Value::I8(3), Ok(Value::Generic(0))),
+            (Value::U8(3), Value::U8(!3), Ok(Value::Generic(0))),
+            (Value::U8(!3), Value::U8(3), Ok(Value::Generic(1))),
+            (Value::I16(3), Value::I16(!3), Ok(Value::Generic(1))),
+            (Value::I16(!3), Value::I16(3), Ok(Value::Generic(0))),
+            (Value::U16(3), Value::U16(!3), Ok(Value::Generic(0))),
+            (Value::U16(!3), Value::U16(3), Ok(Value::Generic(1))),
+            (Value::I32(3), Value::I32(!3), Ok(Value::Generic(1))),
+            (Value::I32(!3), Value::I32(3), Ok(Value::Generic(0))),
+            (Value::U32(3), Value::U32(!3), Ok(Value::Generic(0))),
+            (Value::U32(!3), Value::U32(3), Ok(Value::Generic(1))),
+            (Value::I64(3), Value::I64(!3), Ok(Value::Generic(1))),
+            (Value::I64(!3), Value::I64(3), Ok(Value::Generic(0))),
+            (Value::U64(3), Value::U64(!3), Ok(Value::Generic(0))),
+            (Value::U64(!3), Value::U64(3), Ok(Value::Generic(1))),
+            (Value::F32(3.), Value::F32(-3.), Ok(Value::Generic(1))),
+            (Value::F32(-3.), Value::F32(3.), Ok(Value::Generic(0))),
+            (Value::F64(3.), Value::F64(-3.), Ok(Value::Generic(1))),
+            (Value::F64(-3.), Value::F64(3.), Ok(Value::Generic(0))),
+            (Value::Generic(3), Value::U32(3), Err(Error::TypeMismatch)),
+        ] {
+            assert_eq!(v1.gt(v2, addr_mask), result);
+        }
+    }
+
+    #[test]
+    fn value_le() {
+        let addr_mask = 0xffff_ffff;
+        for &(v1, v2, result) in &[
+            (Value::Generic(3), Value::Generic(!3), Ok(Value::Generic(0))),
+            (Value::Generic(!3), Value::Generic(3), Ok(Value::Generic(1))),
+            (Value::I8(3), Value::I8(!3), Ok(Value::Generic(0))),
+            (Value::I8(!3), Value::I8(3), Ok(Value::Generic(1))),
+            (Value::U8(3), Value::U8(!3), Ok(Value::Generic(1))),
+            (Value::U8(!3), Value::U8(3), Ok(Value::Generic(0))),
+            (Value::I16(3), Value::I16(!3), Ok(Value::Generic(0))),
+            (Value::I16(!3), Value::I16(3), Ok(Value::Generic(1))),
+            (Value::U16(3), Value::U16(!3), Ok(Value::Generic(1))),
+            (Value::U16(!3), Value::U16(3), Ok(Value::Generic(0))),
+            (Value::I32(3), Value::I32(!3), Ok(Value::Generic(0))),
+            (Value::I32(!3), Value::I32(3), Ok(Value::Generic(1))),
+            (Value::U32(3), Value::U32(!3), Ok(Value::Generic(1))),
+            (Value::U32(!3), Value::U32(3), Ok(Value::Generic(0))),
+            (Value::I64(3), Value::I64(!3), Ok(Value::Generic(0))),
+            (Value::I64(!3), Value::I64(3), Ok(Value::Generic(1))),
+            (Value::U64(3), Value::U64(!3), Ok(Value::Generic(1))),
+            (Value::U64(!3), Value::U64(3), Ok(Value::Generic(0))),
+            (Value::F32(3.), Value::F32(-3.), Ok(Value::Generic(0))),
+            (Value::F32(-3.), Value::F32(3.), Ok(Value::Generic(1))),
+            (Value::F64(3.), Value::F64(-3.), Ok(Value::Generic(0))),
+            (Value::F64(-3.), Value::F64(3.), Ok(Value::Generic(1))),
+            (Value::Generic(3), Value::U32(3), Err(Error::TypeMismatch)),
+        ] {
+            assert_eq!(v1.le(v2, addr_mask), result);
+        }
+    }
+
+    #[test]
+    fn value_lt() {
+        let addr_mask = 0xffff_ffff;
+        for &(v1, v2, result) in &[
+            (Value::Generic(3), Value::Generic(!3), Ok(Value::Generic(0))),
+            (Value::Generic(!3), Value::Generic(3), Ok(Value::Generic(1))),
+            (Value::I8(3), Value::I8(!3), Ok(Value::Generic(0))),
+            (Value::I8(!3), Value::I8(3), Ok(Value::Generic(1))),
+            (Value::U8(3), Value::U8(!3), Ok(Value::Generic(1))),
+            (Value::U8(!3), Value::U8(3), Ok(Value::Generic(0))),
+            (Value::I16(3), Value::I16(!3), Ok(Value::Generic(0))),
+            (Value::I16(!3), Value::I16(3), Ok(Value::Generic(1))),
+            (Value::U16(3), Value::U16(!3), Ok(Value::Generic(1))),
+            (Value::U16(!3), Value::U16(3), Ok(Value::Generic(0))),
+            (Value::I32(3), Value::I32(!3), Ok(Value::Generic(0))),
+            (Value::I32(!3), Value::I32(3), Ok(Value::Generic(1))),
+            (Value::U32(3), Value::U32(!3), Ok(Value::Generic(1))),
+            (Value::U32(!3), Value::U32(3), Ok(Value::Generic(0))),
+            (Value::I64(3), Value::I64(!3), Ok(Value::Generic(0))),
+            (Value::I64(!3), Value::I64(3), Ok(Value::Generic(1))),
+            (Value::U64(3), Value::U64(!3), Ok(Value::Generic(1))),
+            (Value::U64(!3), Value::U64(3), Ok(Value::Generic(0))),
+            (Value::F32(3.), Value::F32(-3.), Ok(Value::Generic(0))),
+            (Value::F32(-3.), Value::F32(3.), Ok(Value::Generic(1))),
+            (Value::F64(3.), Value::F64(-3.), Ok(Value::Generic(0))),
+            (Value::F64(-3.), Value::F64(3.), Ok(Value::Generic(1))),
+            (Value::Generic(3), Value::U32(3), Err(Error::TypeMismatch)),
+        ] {
+            assert_eq!(v1.lt(v2, addr_mask), result);
+        }
+    }
+}