Method locate

src/binary_analysis/dwarf.rs:577–625

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

    }

    pub fn locate<'tcx>(
        &self,
        section_index: SectionIndex,
        offset: u64,
    ) -> Result<Option<Location>, Error> {
        // FIXME: should this be optimized?

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

            let mut prev: Option<(_, LineRow)> = None;
            if let Some(ilnp) = unit.line_program.take() {
                let mut rows = ilnp.rows();
                while let Some((_, row)) = rows.next_row()? {
                    let row = *row;
                    let encoded_address = row.address();
                    let (encoded_section, encoded_offset) =
                        self.section_layout.decode(encoded_address)?;

                    // Skip over sections that we don't care about.
                    if encoded_section != section_index {
                        continue;
                    }

                    if let Some((prev_addr, prev_row)) = prev
                        && prev_row.line().is_some()
                        && (prev_addr..encoded_offset).contains(&(offset as i64))
                    {
                        let file = self.file_name(&unit, rows.header(), prev_row.file_index())?;
                        let line = prev_row.line().map_or(0, NonZero::get);
                        let column = match prev_row.column() {
                            gimli::ColumnType::LeftEdge => 0,
                            gimli::ColumnType::Column(v) => v.get(),
                        };
                        return Ok(Some(Location { file, line, column }));
                    }

                    if row.end_sequence() {
                        prev = None;
                    } else {
                        prev = Some((encoded_offset, row));
                    }
                }
            }
        }

        Ok(None)
    }
}