555 lines
18 KiB
Rust
555 lines
18 KiB
Rust
pub mod call_stack;
|
|
pub mod config;
|
|
pub mod enviroment_calls;
|
|
pub mod regs;
|
|
|
|
use {
|
|
self::call_stack::CallStack,
|
|
crate::{
|
|
bytecode::{
|
|
ops::{Operations::*, *},
|
|
types::*,
|
|
},
|
|
engine::call_stack::FnCall,
|
|
memory, HaltStatus, RuntimeErrors,
|
|
},
|
|
alloc::vec::Vec,
|
|
config::EngineConfig,
|
|
log::trace,
|
|
regs::Registers,
|
|
};
|
|
// pub const PAGE_SIZE: usize = 8192;
|
|
|
|
pub struct RealPage {
|
|
pub ptr: *mut u8,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
pub struct VMPage {
|
|
pub data: [u8; 8192],
|
|
}
|
|
impl VMPage {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
data: [0; 4096 * 2],
|
|
}
|
|
}
|
|
}
|
|
|
|
pub enum Page {
|
|
VMPage(VMPage),
|
|
RealPage(RealPage),
|
|
}
|
|
impl Page {
|
|
pub fn data(&self) -> [u8; 4096 * 2] {
|
|
match self {
|
|
Page::VMPage(vmpage) => vmpage.data,
|
|
Page::RealPage(_) => {
|
|
unimplemented!("Memmapped hw page not yet supported")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn empty_enviroment_call(engine: &mut Engine) -> Result<&mut Engine, u64> {
|
|
trace!("Registers {:?}", engine.registers);
|
|
Err(0)
|
|
}
|
|
|
|
pub struct Engine {
|
|
pub index: usize,
|
|
pub program: Vec<u8>,
|
|
pub registers: Registers,
|
|
pub config: EngineConfig,
|
|
|
|
/// BUG: This DOES NOT account for overflowing
|
|
pub last_timer_count: u32,
|
|
pub timer_callback: Option<fn() -> u32>,
|
|
pub memory: memory::Memory,
|
|
pub enviroment_call_table: [EnviromentCall; 256],
|
|
pub call_stack: CallStack,
|
|
}
|
|
use crate::engine::enviroment_calls::EnviromentCall;
|
|
impl Engine {
|
|
pub fn read_mem_addr_8(&mut self, address: u64) -> Result<u8, RuntimeErrors> {
|
|
// println!("{}", address);
|
|
self.memory.read_addr8(address)
|
|
}
|
|
pub fn set_timer_callback(&mut self, func: fn() -> u32) {
|
|
self.timer_callback = Some(func);
|
|
}
|
|
}
|
|
|
|
impl Engine {
|
|
pub fn new(program: Vec<u8>) -> Self {
|
|
let mut mem = memory::Memory::new();
|
|
for (addr, byte) in program.clone().into_iter().enumerate() {
|
|
let _ = mem.set_addr8(addr as u64, byte);
|
|
}
|
|
trace!("{:?}", mem.read_addr8(0));
|
|
|
|
Self {
|
|
index: 0,
|
|
program,
|
|
registers: Registers::new(),
|
|
config: EngineConfig::default(),
|
|
last_timer_count: 0,
|
|
timer_callback: None,
|
|
enviroment_call_table: [empty_enviroment_call; 256],
|
|
memory: mem,
|
|
call_stack: Vec::new(),
|
|
}
|
|
}
|
|
|
|
pub fn dump(&self) {
|
|
trace!("Registers");
|
|
trace!(
|
|
"A {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X}",
|
|
self.registers.a0,
|
|
self.registers.a1,
|
|
self.registers.a2,
|
|
self.registers.a3,
|
|
self.registers.a4,
|
|
self.registers.a5,
|
|
self.registers.a6,
|
|
self.registers.a7,
|
|
self.registers.a8,
|
|
self.registers.a9,
|
|
);
|
|
trace!(
|
|
"B {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X}",
|
|
self.registers.b0,
|
|
self.registers.b1,
|
|
self.registers.b2,
|
|
self.registers.b3,
|
|
self.registers.b4,
|
|
self.registers.b5,
|
|
self.registers.b6,
|
|
self.registers.b7,
|
|
self.registers.b8,
|
|
self.registers.b9,
|
|
);
|
|
trace!(
|
|
"C {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X}",
|
|
self.registers.c0,
|
|
self.registers.c1,
|
|
self.registers.c2,
|
|
self.registers.c3,
|
|
self.registers.c4,
|
|
self.registers.c5,
|
|
self.registers.c6,
|
|
self.registers.c7,
|
|
self.registers.c8,
|
|
self.registers.c9,
|
|
);
|
|
trace!(
|
|
"D0-D4 {:016X} {:016X} {:016X} {:016X} {:016X}
|
|
D5-D9 {:016X} {:016X} {:016X} {:016X} {:016X}",
|
|
self.registers.d0,
|
|
self.registers.d1,
|
|
self.registers.d2,
|
|
self.registers.d3,
|
|
self.registers.d4,
|
|
self.registers.d5,
|
|
self.registers.d6,
|
|
self.registers.d7,
|
|
self.registers.d8,
|
|
self.registers.d9,
|
|
);
|
|
trace!(
|
|
"E0-E4 {:016X} {:016X} {:016X} {:016X} {:016X}
|
|
E5-E9 {:016X} {:016X} {:016X} {:016X} {:016X}",
|
|
self.registers.e0,
|
|
self.registers.e1,
|
|
self.registers.e2,
|
|
self.registers.e3,
|
|
self.registers.e4,
|
|
self.registers.e5,
|
|
self.registers.e6,
|
|
self.registers.e7,
|
|
self.registers.e8,
|
|
self.registers.e9,
|
|
);
|
|
trace!(
|
|
"F0-F4 {:016X} {:016X} {:016X} {:016X} {:016X}
|
|
F5-F9 {:016X} {:016X} {:016X} {:016X} {:016X}",
|
|
self.registers.f0,
|
|
self.registers.f1,
|
|
self.registers.f2,
|
|
self.registers.f3,
|
|
self.registers.f4,
|
|
self.registers.f5,
|
|
self.registers.f6,
|
|
self.registers.f7,
|
|
self.registers.f8,
|
|
self.registers.f9,
|
|
);
|
|
}
|
|
pub fn run(&mut self) -> Result<HaltStatus, RuntimeErrors> {
|
|
use {HaltStatus::*, RuntimeErrors::*};
|
|
loop {
|
|
// Break out of the loop
|
|
if self.index + 1 == self.program.len() {
|
|
break;
|
|
}
|
|
let op = (self.program[self.index], self.program[self.index + 1]);
|
|
// println!("OP {} INDEX {}", op.0, self.index);
|
|
match op {
|
|
(0, _) => {
|
|
trace!("NO OP");
|
|
self.index += 1;
|
|
}
|
|
// Add a 8 bit num
|
|
(1, 1) => {
|
|
let lhs = self.program[self.index + 2];
|
|
// println!("LHS 8BIT {}", lhs);
|
|
let rhs = self.program[self.index + 3];
|
|
// println!("RHS 8BIT {}", rhs);
|
|
|
|
let ret = lhs + rhs;
|
|
let reg = self.program[self.index + 4];
|
|
|
|
match reg {
|
|
0xA0..=0xC9 => {
|
|
self.set_register_8(reg, ret);
|
|
}
|
|
0xD0..=0xF9 => {
|
|
panic!("Register oversized")
|
|
}
|
|
_ => {
|
|
panic!("Not a register.")
|
|
}
|
|
}
|
|
|
|
self.index += 4;
|
|
}
|
|
// Add a 64 bit num
|
|
(1, 2) => {
|
|
let mut lhs_array = [0; 8];
|
|
let mut rhs_array = [0; 8];
|
|
|
|
for (index, byte) in self.program[self.index + 2..self.index + 10]
|
|
.into_iter()
|
|
.enumerate()
|
|
{
|
|
lhs_array[index] = *byte;
|
|
}
|
|
let lhs = u64::from_be_bytes(lhs_array);
|
|
// println!("LHS 64BIT {}", lhs);
|
|
|
|
for (index, byte) in self.program[self.index + 10..self.index + 18]
|
|
.into_iter()
|
|
.enumerate()
|
|
{
|
|
rhs_array[index] = *byte;
|
|
}
|
|
|
|
let rhs = u64::from_be_bytes(rhs_array);
|
|
|
|
// println!("RHS 64BIT {}", rhs);
|
|
|
|
let ret = lhs + rhs;
|
|
|
|
let reg = self.program[self.index + 18];
|
|
// println!("Store {} in {:02X}", ret, reg);
|
|
|
|
match reg {
|
|
0xA0..=0xC9 => {
|
|
panic!("Register undersized")
|
|
}
|
|
0xD0..=0xF9 => {
|
|
self.set_register_64(reg, ret);
|
|
}
|
|
_ => {
|
|
panic!("Not a register.")
|
|
}
|
|
}
|
|
|
|
self.index += 18;
|
|
}
|
|
(2, 1) => {
|
|
let lhs = self.program[self.index + 2];
|
|
// println!("LHS 8BIT {}", lhs);
|
|
let rhs = self.program[self.index + 3];
|
|
// println!("RHS 8BIT {}", rhs);
|
|
let ret = lhs - rhs;
|
|
let reg = self.program[self.index + 4];
|
|
|
|
match reg {
|
|
0xA0..=0xC9 => {
|
|
self.set_register_8(reg, ret);
|
|
}
|
|
0xD0..=0xF9 => {
|
|
panic!("Register oversized")
|
|
}
|
|
_ => {
|
|
panic!("Not a register.")
|
|
}
|
|
}
|
|
|
|
self.index += 4;
|
|
}
|
|
(2, 2) => {
|
|
let mut lhs_array = [0; 8];
|
|
let mut rhs_array = [0; 8];
|
|
|
|
for (index, byte) in self.program[self.index + 2..self.index + 10]
|
|
.into_iter()
|
|
.enumerate()
|
|
{
|
|
lhs_array[index] = *byte;
|
|
}
|
|
let lhs = u64::from_be_bytes(lhs_array);
|
|
// println!("LHS 64BIT {}", lhs);
|
|
|
|
for (index, byte) in self.program[self.index + 10..self.index + 18]
|
|
.into_iter()
|
|
.enumerate()
|
|
{
|
|
rhs_array[index] = *byte;
|
|
}
|
|
|
|
let rhs = u64::from_be_bytes(rhs_array);
|
|
|
|
// println!("RHS 64BIT {}", rhs);
|
|
|
|
let ret = lhs - rhs;
|
|
|
|
let reg = self.program[self.index + 18];
|
|
// println!("Store {} in {:02X}", ret, reg);
|
|
|
|
match reg {
|
|
0xA0..=0xC9 => {
|
|
panic!("Register undersized")
|
|
}
|
|
0xD0..=0xF9 => {
|
|
self.set_register_64(reg, ret);
|
|
}
|
|
_ => {
|
|
panic!("Not a register.")
|
|
}
|
|
}
|
|
|
|
self.index += 19;
|
|
}
|
|
(2, 3) => {
|
|
// 8 bit
|
|
self.index += 4;
|
|
}
|
|
// TODO: Implement 64 bit register to register subtraction
|
|
(2, 4) => {
|
|
// 64 bit
|
|
|
|
let mut lhs_array = [0; 8];
|
|
let mut rhs_array = [0; 8];
|
|
|
|
for (index, byte) in self.program[self.index + 2..self.index + 10]
|
|
.into_iter()
|
|
.enumerate()
|
|
{
|
|
lhs_array[index] = *byte;
|
|
}
|
|
let lhs = u64::from_be_bytes(lhs_array);
|
|
|
|
for (index, byte) in self.program[self.index + 10..self.index + 18]
|
|
.into_iter()
|
|
.enumerate()
|
|
{
|
|
rhs_array[index] = *byte;
|
|
}
|
|
|
|
let rhs = u64::from_be_bytes(rhs_array);
|
|
|
|
// println!("RHS 64BIT {}", rhs);
|
|
|
|
let ret = lhs - rhs;
|
|
|
|
let reg = self.program[self.index + 18];
|
|
// println!("Store {} in {:02X}", ret, reg);
|
|
|
|
match reg {
|
|
0xA0..=0xC9 => {
|
|
panic!("Register undersized")
|
|
}
|
|
0xD0..=0xF9 => {
|
|
self.set_register_64(reg, ret);
|
|
}
|
|
_ => {
|
|
panic!("Not a register.")
|
|
}
|
|
}
|
|
|
|
self.index += 18;
|
|
}
|
|
|
|
// Read from address to register
|
|
(5, 0) => {
|
|
let mut addr_array = [0; 8];
|
|
|
|
for (index, byte) in self.program[self.index + 2..self.index + 10]
|
|
.into_iter()
|
|
.enumerate()
|
|
{
|
|
addr_array[index] = *byte;
|
|
}
|
|
let addr = u64::from_be_bytes(addr_array);
|
|
|
|
trace!("addr {}", addr);
|
|
|
|
let ret = self.read_mem_addr_8(addr);
|
|
match ret {
|
|
Ok(ret) => {
|
|
let reg = self.program[self.index + 10];
|
|
trace!("reg {}", reg);
|
|
self.set_register_8(reg, ret);
|
|
self.index += 10;
|
|
}
|
|
Err(err) => trace!("{:?}", err),
|
|
}
|
|
}
|
|
|
|
(100, _) => {
|
|
if self.call_stack.len() > self.config.call_stack_depth {
|
|
trace!("Callstack {}", self.call_stack.len());
|
|
break;
|
|
}
|
|
|
|
let mut addr_array = [0; 8];
|
|
|
|
for (index, byte) in self.program[self.index + 1..self.index + 9]
|
|
.into_iter()
|
|
.enumerate()
|
|
{
|
|
addr_array[index] = *byte;
|
|
}
|
|
|
|
let addr = usize::from_be_bytes(addr_array);
|
|
if addr > self.program.len() {
|
|
panic!("Invalid jump address {}", addr)
|
|
} else {
|
|
let call = FnCall { ret: self.index };
|
|
self.call_stack.push(call);
|
|
|
|
self.index = addr;
|
|
trace!("Jumping to {}", addr);
|
|
|
|
self.dump();
|
|
// panic!();
|
|
}
|
|
}
|
|
|
|
(255, int) => {
|
|
trace!("Enviroment Call {}", int);
|
|
let ret = self.enviroment_call_table[int as usize](self);
|
|
match ret {
|
|
Ok(eng) => {
|
|
trace!("Resuming execution at {}", eng.index);
|
|
}
|
|
Err(err) => {
|
|
return Err(HostError(err));
|
|
}
|
|
}
|
|
self.index += 2;
|
|
}
|
|
|
|
_op_pair => {
|
|
// println!("OP Pair {}", op_pair.0);
|
|
self.index += 1;
|
|
}
|
|
}
|
|
|
|
// Finish step
|
|
|
|
if self.timer_callback.is_some() {
|
|
let ret = self.timer_callback.unwrap()();
|
|
if (ret - self.last_timer_count) >= self.config.quantum {
|
|
return Ok(Running);
|
|
}
|
|
}
|
|
}
|
|
Ok(Halted)
|
|
}
|
|
|
|
pub fn set_register_8(&mut self, register: u8, value: u8) {
|
|
match register {
|
|
0xA0 => self.registers.a0 = value,
|
|
0xA1 => self.registers.a1 = value,
|
|
0xA2 => self.registers.a2 = value,
|
|
0xA3 => self.registers.a3 = value,
|
|
0xA4 => self.registers.a4 = value,
|
|
0xA5 => self.registers.a5 = value,
|
|
0xA6 => self.registers.a6 = value,
|
|
0xA7 => self.registers.a7 = value,
|
|
0xA8 => self.registers.a8 = value,
|
|
0xA9 => self.registers.a9 = value,
|
|
//
|
|
0xB0 => self.registers.b0 = value,
|
|
0xB1 => self.registers.b1 = value,
|
|
0xB2 => self.registers.b2 = value,
|
|
0xB3 => self.registers.b3 = value,
|
|
0xB4 => self.registers.b4 = value,
|
|
0xB5 => self.registers.b5 = value,
|
|
0xB6 => self.registers.b6 = value,
|
|
0xB7 => self.registers.b7 = value,
|
|
0xB8 => self.registers.b8 = value,
|
|
0xB9 => self.registers.b9 = value,
|
|
//
|
|
0xC0 => self.registers.c0 = value,
|
|
0xC1 => self.registers.c1 = value,
|
|
0xC2 => self.registers.c2 = value,
|
|
0xC3 => self.registers.c3 = value,
|
|
0xC4 => self.registers.c4 = value,
|
|
0xC5 => self.registers.c5 = value,
|
|
0xC6 => self.registers.c6 = value,
|
|
0xC7 => self.registers.c7 = value,
|
|
0xC8 => self.registers.c8 = value,
|
|
0xC9 => self.registers.c9 = value,
|
|
|
|
_ => {
|
|
panic!("Unlikely you are here if everyone behaved.\nThis register is not 8 bit")
|
|
}
|
|
}
|
|
}
|
|
pub fn set_register_64(&mut self, register: u8, value: u64) {
|
|
match register {
|
|
0xD0 => self.registers.d0 = value,
|
|
0xD1 => self.registers.d1 = value,
|
|
0xD2 => self.registers.d2 = value,
|
|
0xD3 => self.registers.d3 = value,
|
|
0xD4 => self.registers.d4 = value,
|
|
0xD5 => self.registers.d5 = value,
|
|
0xD6 => self.registers.d6 = value,
|
|
0xD7 => self.registers.d7 = value,
|
|
0xD8 => self.registers.d8 = value,
|
|
0xD9 => self.registers.d9 = value,
|
|
//
|
|
0xE0 => self.registers.f0 = value,
|
|
0xE1 => self.registers.f1 = value,
|
|
0xE2 => self.registers.f2 = value,
|
|
0xE3 => self.registers.f3 = value,
|
|
0xE4 => self.registers.f4 = value,
|
|
0xE5 => self.registers.f5 = value,
|
|
0xE6 => self.registers.f6 = value,
|
|
0xE7 => self.registers.f7 = value,
|
|
0xE8 => self.registers.f8 = value,
|
|
0xE9 => self.registers.f9 = value,
|
|
|
|
//
|
|
0xF0 => self.registers.f0 = value,
|
|
0xF1 => self.registers.f1 = value,
|
|
0xF2 => self.registers.f2 = value,
|
|
0xF3 => self.registers.f3 = value,
|
|
0xF4 => self.registers.f4 = value,
|
|
0xF5 => self.registers.f5 = value,
|
|
0xF6 => self.registers.f6 = value,
|
|
0xF7 => self.registers.f7 = value,
|
|
0xF8 => self.registers.f8 = value,
|
|
0xF9 => self.registers.f9 = value,
|
|
|
|
_ => {
|
|
panic!("Unlikely you are here if everyone behaved.\nThis register is not 64 bit")
|
|
}
|
|
}
|
|
}
|
|
}
|