binaryninja-api/arch/msp430/src/flag.rs at c376fde7059cabf9290bad213b7def802f6954b1 · Vector35/binaryninja-api · GitHub

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
114
115
116
117
118
119
120
121
122
123
use binaryninja::architecture;
use binaryninja::architecture::{CoreArchitecture, FlagId, FlagRole, FlagWriteId, UnusedFlagClass};

use std::borrow::Cow;

// NOTE: GIE, CPUOFF, OSCOFF, SG0, and SG1 not implemented as it's not clear how they would be used
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Flag {
    C,
    Z,
    N,
    V,
}

impl architecture::Flag for Flag {
    type FlagClass = UnusedFlagClass;

    fn flags(_arch: &CoreArchitecture) -> Vec<Self> {
        vec![Flag::C, Flag::Z, Flag::N, Flag::V]
    }

    fn name(&self) -> Cow<'_, str> {
        match self {
            Self::C => "c".into(),
            Self::Z => "z".into(),
            Self::N => "n".into(),
            Self::V => "v".into(),
        }
    }

    fn role(&self, _class: Option<Self::FlagClass>) -> FlagRole {
        match self {
            Self::C => FlagRole::CarryFlagRole,
            Self::Z => FlagRole::ZeroFlagRole,
            Self::N => FlagRole::NegativeSignFlagRole,
            Self::V => FlagRole::OverflowFlagRole,
        }
    }

    fn id(&self) -> FlagId {
        match self {
            Self::C => 0,
            Self::Z => 1,
            Self::N => 2,
            Self::V => 8,
        }
        .into()
    }

    fn from_id(_arch: &CoreArchitecture, id: FlagId) -> Option<Self> {
        match id.0 {
            0 => Some(Self::C),
            1 => Some(Self::Z),
            2 => Some(Self::N),
            8 => Some(Self::V),
            _ => None,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum FlagWrite {
    All,
    Nz,
    Nvz,
    Cnz,
}

impl architecture::FlagWrite for FlagWrite {
    type FlagType = Flag;
    type FlagClass = UnusedFlagClass;

    fn flag_write_types(_arch: &CoreArchitecture) -> Vec<Self> {
        vec![
            FlagWrite::All,
            FlagWrite::Nz,
            FlagWrite::Nvz,
            FlagWrite::Cnz,
        ]
    }

    fn name(&self) -> Cow<'_, str> {
        match self {
            Self::All => "*".into(),
            Self::Nz => "nz".into(),
            Self::Nvz => "nvz".into(),
            Self::Cnz => "cnz".into(),
        }
    }

    fn class(&self) -> Option<Self::FlagClass> {
        None
    }

    fn id(&self) -> FlagWriteId {
        match self {
            Self::All => 1,
            Self::Nz => 2,
            Self::Nvz => 3,
            Self::Cnz => 4,
        }
        .into()
    }

    fn from_id(_arch: &CoreArchitecture, id: FlagWriteId) -> Option<Self> {
        match id.0 {
            1 => Some(Self::All),
            2 => Some(Self::Nz),
            3 => Some(Self::Nvz),
            4 => Some(Self::Cnz),
            _ => None,
        }
    }

    fn flags_written(&self) -> Vec<Self::FlagType> {
        match self {
            Self::All => vec![Flag::C, Flag::N, Flag::V, Flag::Z],
            Self::Nz => vec![Flag::N, Flag::Z],
            Self::Nvz => vec![Flag::N, Flag::V, Flag::Z],
            Self::Cnz => vec![Flag::C, Flag::N, Flag::Z],
        }
    }
}