Method inline_info

src/binary_analysis/dwarf.rs:474–546

(
        &self,
        section_index: SectionIndex,
        offset: u64,
    )

    }

    pub fn inline_info<'tcx>(
        &self,
        section_index: SectionIndex,
        offset: u64,
    ) -> Result<Vec<Call>, Error> {
        let mut iter = self.dwarf.units();
        let mut callstack = Vec::<Call>::new();

        while let Some(header) = iter.next()? {
            let unit = self.dwarf.unit(header)?;

            let mut stack = Vec::new();
            let mut entries = unit.entries();
            let mut prev_depth = 0;
            while let Some(die) = entries.next_dfs()? {
                for _ in die.depth()..=prev_depth {
                    stack.pop();
                }
                prev_depth = die.depth;

                if matches!(
                    die.tag(),
                    gimli::DW_TAG_subprogram | gimli::DW_TAG_inlined_subroutine
                ) {
                    stack.push(Some(self.linkage_name(&unit, die)?));
                } else {
                    stack.push(None);
                }

                if die.tag() != gimli::DW_TAG_inlined_subroutine {
                    continue;
                }

                let ranges = self.ranges(&unit, die)?;
                if ranges.0 != section_index {
                    continue;
                }

                if ranges
                    .1
                    .iter()
                    .any(|range| range.contains(&(offset as i64)))
                {
                    let callee = stack.last().unwrap().as_ref().unwrap();
                    let caller = stack
                        .iter()
                        .rev()
                        .skip(1)
                        .find(|x| x.is_some())
                        .and_then(|x| x.as_ref())
                        .ok_or(Error::UnexpectedDwarf(
                            "DW_TAG_inlined_subroutine is not nested inside DW_TAG_subprogram",
                        ))?;

                    // Call stack must form a chain.
                    if let Some(last_call) = callstack.last() {
                        if last_call.callee != *caller {
                            Err(Error::UnexpectedDwarf("Inlined call does not form a chain"))?