80 lines
1.8 KiB
Rust
80 lines
1.8 KiB
Rust
use once_cell::sync::Lazy;
|
|
|
|
mod gen_tools;
|
|
mod opcodes;
|
|
mod rvi;
|
|
|
|
static INSTRUCTIONS: Lazy<[OpcodeHandler; 32]> = Lazy::new(|| {
|
|
let mut instructions = std::array::from_fn(|_i| OpcodeHandler {
|
|
handler: None,
|
|
splitter: None,
|
|
});
|
|
|
|
rvi::add_instrs(&mut instructions);
|
|
|
|
instructions
|
|
});
|
|
|
|
use crate::{
|
|
consts::Word,
|
|
core::{Core, InstructionResult},
|
|
decode::Instruction,
|
|
};
|
|
|
|
type Runner = fn(&mut Core, Instruction) -> InstructionResult;
|
|
|
|
#[derive(Clone, Copy)]
|
|
struct InstructionHandler {
|
|
runner: Runner,
|
|
}
|
|
|
|
struct OpcodeHandler {
|
|
handler: Option<InstructionHandler>,
|
|
splitter: Option<Splitter>,
|
|
}
|
|
|
|
pub fn find_runner(instruction: Instruction) -> Option<Runner> {
|
|
let opcode_handler = &INSTRUCTIONS[instruction.opcode_noncompressed() as usize];
|
|
opcode_handler.find_runner(instruction)
|
|
}
|
|
|
|
impl OpcodeHandler {
|
|
fn find_runner(&self, instruction: Instruction) -> Option<Runner> {
|
|
if let Some(splitter) = &self.splitter {
|
|
splitter.find_runner(instruction)
|
|
} else {
|
|
self.handler.map(|h| h.runner)
|
|
}
|
|
}
|
|
}
|
|
|
|
enum Splitter {
|
|
Funct3Splitter(Box<[OpcodeHandler; 8]>),
|
|
GeneralSplitter(Box<[GeneralSplitterEntry]>),
|
|
}
|
|
|
|
impl Splitter {
|
|
fn find_runner(&self, instruction: Instruction) -> Option<Runner> {
|
|
match self {
|
|
Splitter::Funct3Splitter(f3s) => {
|
|
f3s[instruction.funct3() as usize].find_runner(instruction)
|
|
}
|
|
Splitter::GeneralSplitter(entries) => {
|
|
for entry in entries {
|
|
if instruction.0 & entry.mask == entry.value {
|
|
return Some(entry.handler.runner);
|
|
}
|
|
}
|
|
|
|
None
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
struct GeneralSplitterEntry {
|
|
mask: Word,
|
|
value: Word,
|
|
handler: InstructionHandler,
|
|
}
|