raki 1.3.2

RISC-V instruction decoder written in Rust.
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176

//! Base I Instructions.

use super::{InstFormat, Opcode};
use core::fmt::{self, Display, Formatter};

/// Insturctions in Base-I.
#[allow(non_camel_case_types, clippy::module_name_repetitions)]
#[derive(Debug, PartialEq)]
pub enum BaseIOpcode {
    LUI,
    AUIPC,
    JAL,
    JALR,
    BEQ,
    BNE,
    BLT,
    BGE,
    BLTU,
    BGEU,
    LB,
    LH,
    LW,
    LBU,
    LHU,
    SB,
    SH,
    SW,
    ADDI,
    SLTI,
    SLTIU,
    XORI,
    ORI,
    ANDI,
    SLLI,
    SRLI,
    SRAI,
    ADD,
    SUB,
    SLL,
    SLT,
    SLTU,
    XOR,
    SRL,
    SRA,
    OR,
    AND,
    ECALL,
    EBREAK,

    //-- rv64 only --
    LWU,
    LD,
    SD,
    ADDIW,
    SLLIW,
    SRLIW,
    SRAIW,
    ADDW,
    SUBW,
    SLLW,
    SRLW,
    SRAW,
}

impl Display for BaseIOpcode {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        match self {
            BaseIOpcode::LUI => write!(f, "lui"),
            BaseIOpcode::AUIPC => write!(f, "auipc"),
            BaseIOpcode::JAL => write!(f, "jal"),
            BaseIOpcode::JALR => write!(f, "jalr"),
            BaseIOpcode::BEQ => write!(f, "beq"),
            BaseIOpcode::BNE => write!(f, "bne"),
            BaseIOpcode::BLT => write!(f, "blt"),
            BaseIOpcode::BGE => write!(f, "bge"),
            BaseIOpcode::BLTU => write!(f, "bltu"),
            BaseIOpcode::BGEU => write!(f, "bgeu"),
            BaseIOpcode::LB => write!(f, "lb"),
            BaseIOpcode::LH => write!(f, "lh"),
            BaseIOpcode::LW => write!(f, "lw"),
            BaseIOpcode::LBU => write!(f, "lbu"),
            BaseIOpcode::LHU => write!(f, "lhu"),
            BaseIOpcode::SB => write!(f, "sb"),
            BaseIOpcode::SH => write!(f, "sh"),
            BaseIOpcode::SW => write!(f, "sw"),
            BaseIOpcode::ADDI => write!(f, "addi"),
            BaseIOpcode::SLTI => write!(f, "slti"),
            BaseIOpcode::SLTIU => write!(f, "sltiu"),
            BaseIOpcode::XORI => write!(f, "xori"),
            BaseIOpcode::ORI => write!(f, "ori"),
            BaseIOpcode::ANDI => write!(f, "andi"),
            BaseIOpcode::SLLI => write!(f, "slli"),
            BaseIOpcode::SRLI => write!(f, "srli"),
            BaseIOpcode::SRAI => write!(f, "srai"),
            BaseIOpcode::ADD => write!(f, "add"),
            BaseIOpcode::SUB => write!(f, "sub"),
            BaseIOpcode::SLL => write!(f, "sll"),
            BaseIOpcode::SLT => write!(f, "slt"),
            BaseIOpcode::SLTU => write!(f, "sltu"),
            BaseIOpcode::XOR => write!(f, "xor"),
            BaseIOpcode::SRL => write!(f, "srl"),
            BaseIOpcode::SRA => write!(f, "sra"),
            BaseIOpcode::OR => write!(f, "or"),
            BaseIOpcode::AND => write!(f, "and"),
            BaseIOpcode::ECALL => write!(f, "ecall"),
            BaseIOpcode::EBREAK => write!(f, "ebreak"),
            BaseIOpcode::LWU => write!(f, "lwu"),
            BaseIOpcode::LD => write!(f, "ld"),
            BaseIOpcode::SD => write!(f, "sd"),
            BaseIOpcode::ADDIW => write!(f, "addiw"),
            BaseIOpcode::SLLIW => write!(f, "slliw"),
            BaseIOpcode::SRLIW => write!(f, "srliw"),
            BaseIOpcode::SRAIW => write!(f, "sraiw"),
            BaseIOpcode::ADDW => write!(f, "addw"),
            BaseIOpcode::SUBW => write!(f, "subw"),
            BaseIOpcode::SLLW => write!(f, "sllw"),
            BaseIOpcode::SRLW => write!(f, "srlw"),
            BaseIOpcode::SRAW => write!(f, "sraw"),
        }
    }
}

impl Opcode for BaseIOpcode {
    fn get_format(&self) -> InstFormat {
        match self {
            BaseIOpcode::BEQ
            | BaseIOpcode::BNE
            | BaseIOpcode::BLT
            | BaseIOpcode::BGE
            | BaseIOpcode::BLTU
            | BaseIOpcode::BGEU => InstFormat::BFormat,
            BaseIOpcode::JALR
            | BaseIOpcode::LB
            | BaseIOpcode::LH
            | BaseIOpcode::LW
            | BaseIOpcode::LBU
            | BaseIOpcode::LHU
            | BaseIOpcode::ADDI
            | BaseIOpcode::SLTI
            | BaseIOpcode::SLTIU
            | BaseIOpcode::XORI
            | BaseIOpcode::ORI
            | BaseIOpcode::ANDI
            | BaseIOpcode::LWU
            | BaseIOpcode::LD
            | BaseIOpcode::ADDIW => InstFormat::IFormat,
            BaseIOpcode::SLLI
            | BaseIOpcode::SRLI
            | BaseIOpcode::SRAI
            | BaseIOpcode::SLLIW
            | BaseIOpcode::SRLIW
            | BaseIOpcode::SRAIW => InstFormat::RShamtFormat,
            BaseIOpcode::ADD
            | BaseIOpcode::SUB
            | BaseIOpcode::SLL
            | BaseIOpcode::SLT
            | BaseIOpcode::SLTU
            | BaseIOpcode::XOR
            | BaseIOpcode::SRL
            | BaseIOpcode::SRA
            | BaseIOpcode::OR
            | BaseIOpcode::AND
            | BaseIOpcode::ADDW
            | BaseIOpcode::SUBW
            | BaseIOpcode::SLLW
            | BaseIOpcode::SRLW
            | BaseIOpcode::SRAW => InstFormat::RFormat,
            BaseIOpcode::SB | BaseIOpcode::SH | BaseIOpcode::SW | BaseIOpcode::SD => {
                InstFormat::SFormat
            }
            BaseIOpcode::JAL => InstFormat::JFormat,
            BaseIOpcode::LUI | BaseIOpcode::AUIPC => InstFormat::UFormat,
            BaseIOpcode::ECALL | BaseIOpcode::EBREAK => InstFormat::NoOperand,
        }
    }
}