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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

//! Helper utils for tracking and patching intra unit or section references.

use gimli::write;
use gimli::{DebugInfoOffset, Reader, UnitHeader, UnitOffset};
use std::collections::HashMap;

/// Stores compiled unit references: UnitEntryId+DwAt denotes a patch location
/// and UnitOffset is a location in original DWARF.
pub struct PendingUnitRefs {
    refs: Vec<(write::UnitEntryId, gimli::DwAt, UnitOffset)>,
}

impl PendingUnitRefs {
    pub fn new() -> Self {
        Self { refs: Vec::new() }
    }
    pub fn insert(&mut self, entry_id: write::UnitEntryId, attr: gimli::DwAt, offset: UnitOffset) {
        self.refs.push((entry_id, attr, offset));
    }
}

/// Stores .debug_info references: UnitEntryId+DwAt denotes a patch location
/// and DebugInfoOffset is a location in original DWARF.
pub struct PendingDebugInfoRefs {
    refs: Vec<(write::UnitEntryId, gimli::DwAt, DebugInfoOffset)>,
}

impl PendingDebugInfoRefs {
    pub fn new() -> Self {
        Self { refs: Vec::new() }
    }
    pub fn insert(
        &mut self,
        entry_id: write::UnitEntryId,
        attr: gimli::DwAt,
        offset: DebugInfoOffset,
    ) {
        self.refs.push((entry_id, attr, offset));
    }
}

/// Stores map between read and written references of DWARF entries of
/// a compiled unit.
pub struct UnitRefsMap {
    map: HashMap<UnitOffset, write::UnitEntryId>,
}

impl UnitRefsMap {
    pub fn new() -> Self {
        Self {
            map: HashMap::new(),
        }
    }
    pub fn insert(&mut self, offset: UnitOffset, entry_id: write::UnitEntryId) {
        self.map.insert(offset, entry_id);
    }
    pub fn patch(&self, refs: PendingUnitRefs, comp_unit: &mut write::Unit) {
        for (die_id, attr_name, offset) in refs.refs {
            let die = comp_unit.get_mut(die_id);
            if let Some(unit_id) = self.map.get(&offset) {
                die.set(attr_name, write::AttributeValue::UnitRef(*unit_id));
            }
        }
    }
}

/// Stores map between read and written references of DWARF entries of
/// the entire .debug_info.
pub struct DebugInfoRefsMap {
    map: HashMap<DebugInfoOffset, (write::UnitId, write::UnitEntryId)>,
}

impl DebugInfoRefsMap {
    pub fn new() -> Self {
        Self {
            map: HashMap::new(),
        }
    }
    pub fn insert<R>(&mut self, unit: &UnitHeader<R>, unit_id: write::UnitId, unit_map: UnitRefsMap)
    where
        R: Reader<Offset = usize>,
    {
        self.map
            .extend(unit_map.map.into_iter().map(|(off, entry_id)| {
                let off = off
                    .to_debug_info_offset(unit)
                    .expect("should be in debug_info section");
                (off, (unit_id, entry_id))
            }));
    }
    pub fn patch(
        &self,
        refs: impl Iterator<Item = (write::UnitId, PendingDebugInfoRefs)>,
        units: &mut write::UnitTable,
    ) {
        for (id, refs) in refs {
            let unit = units.get_mut(id);
            for (die_id, attr_name, offset) in refs.refs {
                let die = unit.get_mut(die_id);
                if let Some((id, entry_id)) = self.map.get(&offset) {
                    die.set(
                        attr_name,
                        write::AttributeValue::DebugInfoRef(write::Reference::Entry(
                            *id, *entry_id,
                        )),
                    );
                }
            }
        }
    }
}