Method ranges

src/binary_analysis/dwarf.rs:361–434

Obtain PC ranges related to a DIE.

(
        &self,
        unit: &Unit<ReaderTy<'_>>,
        die: &DebuggingInformationEntry<ReaderTy<'_>>,
    )

    /// Obtain PC ranges related to a DIE.
    fn ranges(
        &self,
        unit: &Unit<ReaderTy<'_>>,
        die: &DebuggingInformationEntry<ReaderTy<'_>>,
    ) -> Result<(SectionIndex, Vec<Range<i64>>), Error> {
        let mut ranges = Vec::new();

        for attr in die.attrs() {
            match attr.name() {
                gimli::DW_AT_low_pc => {
                    let Some(low_pc) = self.dwarf().attr_address(unit, attr.value())? else {
                        Err(Error::UnexpectedDwarf("DW_AT_low_pc is not an address"))?
                    };

                    let Some(high_pc) = die.attr_value(gimli::DW_AT_high_pc) else {
                        Err(Error::UnexpectedDwarf(
                            "DW_AT_high_pc not found at DW_TAG_inlined_subroutine",
                        ))?
                    };

                    let Some(high_pc) = high_pc.udata_value() else {
                        Err(Error::UnexpectedDwarf("DW_AT_high_pc is not udata"))?
                    };

                    ranges.push((low_pc, high_pc));
                }

                // This is handled by DW_AT_low_pc.
                gimli::DW_AT_high_pc => (),

                gimli::DW_AT_ranges => {
                    let offset = match attr.value() {
                        AttributeValue::DebugRngListsIndex(offset) => {
                            self.dwarf().ranges_offset(unit, offset)?
                        }
                        AttributeValue::RangeListsRef(offset) => {
                            self.dwarf().ranges_offset_from_raw(unit, offset)
                        }
                        _ => Err(Error::UnexpectedDwarf(
                            "DW_AT_ranges is not rnglist reference",
                        ))?,
                    };
                    let mut range = self.dwarf().ranges(unit, offset)?;
                    while let Some(range) = range.next()? {
                        ranges.push((range.begin, range.end.wrapping_sub(range.begin)));
                    }
                }

                _ => (),
            }
        }

        if ranges.is_empty() {
            return Ok((SectionIndex(0), Vec::new()));
        }

        let encoded_section = self.section_layout.decode(ranges[0].0)?.0;