bugstalker 0.4.5

BugStalker is a modern and lightweight debugger for rust applications.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

use crate::debugger::address::GlobalAddress;
use crate::debugger::debugee::dwarf::unit::BsUnit;
use crate::debugger::debugee::dwarf::{DebugInformation, EndianArcSlice};
use crate::weak_error;
use gimli::{Attribute, AttributeValue, Expression};

pub(super) struct Location<'a>(pub(super) &'a Attribute<EndianArcSlice>);

impl Location<'_> {
    /// Converts location attribute to a dwarf expression.
    /// Expect location attribute one of:
    /// - DW_FORM_exprloc
    /// - DW_FORM_block*
    /// - DW_FORM_loclistx
    /// - W_FORM_sec_offset
    /// - DW_FORM_loclistx
    ///
    ///  Return `None` otherwise.
    pub(super) fn try_as_expression(
        &self,
        di: &DebugInformation<EndianArcSlice>,
        unit: &BsUnit,
        pc: GlobalAddress,
    ) -> Option<Expression<EndianArcSlice>> {
        if let Some(expr) = self.0.exprloc_value() {
            return Some(expr);
        }

        let offset = match self.0.value() {
            AttributeValue::LocationListsRef(offset) => offset,
            AttributeValue::DebugLocListsIndex(index) => weak_error!(di.locations().get_offset(
                unit.encoding(),
                unit.loclists_base(),
                index
            ))?,
            _ => return None,
        };

        let mut iter = weak_error!(di.locations().locations(
            offset,
            unit.encoding(),
            unit.low_pc(),
            di.debug_addr(),
            unit.addr_base(),
        ))?;

        let pc = u64::from(pc);
        let entry = iter
            .find(|list_entry| match list_entry {
                Ok(list_entry) => list_entry.range.begin <= pc && list_entry.range.end >= pc,
                Err(_) => true,
            })
            .transpose()
            .ok()?;

        entry.map(|e| e.data)
    }
}