spimdisasm 2.0.0-alpha.1

MIPS disassembler
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
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

/* SPDX-FileCopyrightText: © 2025 Decompollaborate */
/* SPDX-License-Identifier: MIT */

use crate::{
    addresses::{Rom, Vram},
    collections::{unordered_map::UnorderedMap, unordered_set::UnorderedSet},
    parent_segment_info::ParentSegmentInfo,
};

#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) enum ReferrerInfo {
    Function {
        sym_vram: Vram,
        parent: ParentSegmentInfo,
        specific_rom: Rom,
    },
    Data {
        sym_vram: Vram,
        parent: ParentSegmentInfo,
        specific_rom: Rom,
    },
}

impl ReferrerInfo {
    pub(crate) const fn new_function(
        sym_vram: Vram,
        parent: ParentSegmentInfo,
        specific_rom: Rom,
    ) -> Self {
        ReferrerInfo::Function {
            sym_vram,
            parent,
            specific_rom,
        }
    }
    pub(crate) const fn new_data(
        sym_vram: Vram,
        parent: ParentSegmentInfo,
        specific_rom: Rom,
    ) -> Self {
        ReferrerInfo::Data {
            sym_vram,
            parent,
            specific_rom,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Referrers {
    /// Which functions reference this.
    /// Key is the vram of the function and the segment it is contained on (since vrams can overlap
    /// on different segments).
    /// Value is the rom of the instruction that references this symbol, so we can know how many
    /// times a function references the same address.
    reference_functions: UnorderedMap<(Vram, ParentSegmentInfo), UnorderedSet<Rom>>,
    /// Which symbols reference this.
    /// Key is the vram of the non-function symbol and the segment it is contained on (since vrams
    /// can overlap on different segments).
    /// Value is the rom of the word that references this symbol, so we can know how many
    /// times a symbol references the same address.
    reference_symbols: UnorderedMap<(Vram, ParentSegmentInfo), UnorderedSet<Rom>>,
}

impl Referrers {
    pub(crate) fn new() -> Self {
        Self {
            reference_functions: UnorderedMap::new(),
            reference_symbols: UnorderedMap::new(),
        }
    }

    /// How much this address is referenced by something else.
    pub fn reference_counter(&self) -> usize {
        self.reference_functions.values().count() + self.reference_symbols.values().count()
    }

    pub fn reference_functions(
        &self,
    ) -> &UnorderedMap<(Vram, ParentSegmentInfo), UnorderedSet<Rom>> {
        &self.reference_functions
    }
    pub fn reference_symbols(&self) -> &UnorderedMap<(Vram, ParentSegmentInfo), UnorderedSet<Rom>> {
        &self.reference_symbols
    }

    pub(crate) fn add(&mut self, referrer: ReferrerInfo) {
        match referrer {
            ReferrerInfo::Function {
                sym_vram,
                parent,
                specific_rom,
            } => {
                self.reference_functions
                    .entry((sym_vram, parent))
                    .or_default()
                    .insert(specific_rom);
            }
            ReferrerInfo::Data {
                sym_vram,
                parent,
                specific_rom,
            } => {
                self.reference_symbols
                    .entry((sym_vram, parent))
                    .or_default()
                    .insert(specific_rom);
            }
        }
    }
}