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
112
113

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

#[cfg(feature = "pyo3")]
use pyo3::prelude::*;
use rabbitizer::access_type::AccessType;

use crate::config::Compiler;

use super::LabelType;

#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
#[non_exhaustive]
#[cfg_attr(feature = "pyo3", pyclass(module = "spimdisasm", eq))]
pub enum SymbolType {
    Function,
    Jumptable,
    // HardwareReg,
    // Constant,
    GccExceptTable,
    // DispatchTable,
    Byte,
    Short,
    Word,
    DWord,

    Float32,
    Float64,
    CString,

    VirtualTable,

    UserCustom,
}

impl SymbolType {
    pub fn valid_call_target(&self) -> bool {
        matches!(self, SymbolType::Function)
    }

    pub fn is_table(&self) -> bool {
        matches!(self, SymbolType::Jumptable | SymbolType::GccExceptTable)
    }

    pub(crate) fn label_for_table(maybe_table: Option<Self>) -> Option<LabelType> {
        maybe_table.and_then(|x| match x {
            SymbolType::Jumptable => Some(LabelType::Jumptable),
            SymbolType::GccExceptTable => Some(LabelType::GccExceptTable),
            _ => None,
        })
    }

    pub fn can_reference_symbols(&self) -> bool {
        match self {
            SymbolType::Function => false,
            SymbolType::Jumptable | SymbolType::GccExceptTable => true,
            SymbolType::Byte | SymbolType::Short => false,
            SymbolType::Word => true,
            SymbolType::DWord => false,
            SymbolType::Float32 | SymbolType::Float64 => false,
            SymbolType::CString => false,
            SymbolType::VirtualTable => true,
            SymbolType::UserCustom => true,
        }
    }

    pub fn from_access_type(access_type: AccessType) -> Option<Self> {
        // TODO: use AccessType.min_size and AccessType.min_alignment

        match access_type {
            AccessType::BYTE => Some(SymbolType::Byte),
            AccessType::SHORT => Some(SymbolType::Short),
            AccessType::WORD | AccessType::WORD_COP2 | AccessType::LINKED_WORD_WORD => {
                Some(SymbolType::Word)
            }
            AccessType::DOUBLEWORD
            | AccessType::DOUBLEWORD_COP2
            | AccessType::LINKED_WORD_DOUBLEWORD => Some(SymbolType::DWord),
            AccessType::QUADWORD => Some(SymbolType::DWord), // ?
            AccessType::FLOAT => Some(SymbolType::Float32),
            AccessType::DOUBLEFLOAT => Some(SymbolType::Float64),

            // Struct copies
            AccessType::UNALIGNED_WORD_LEFT
            | AccessType::UNALIGNED_WORD_RIGHT
            | AccessType::UNALIGNED_DOUBLEWORD_LEFT
            | AccessType::UNALIGNED_DOUBLEWORD_RIGHT => None,
        }
    }

    pub(crate) fn may_have_addend(&self) -> bool {
        !matches!(
            self,
            SymbolType::Function
                | SymbolType::Jumptable
                | SymbolType::GccExceptTable
                | SymbolType::VirtualTable
        )
    }

    pub(crate) fn is_late_rodata(&self, compiler: Option<Compiler>) -> bool {
        if compiler.is_some_and(|x| x.has_late_rodata()) {
            // late rodata only exists in IDO's world

            matches!(
                self,
                SymbolType::Jumptable | SymbolType::Float32 | SymbolType::Float64
            )
        } else {
            false
        }
    }
}