User_4574/crsn
1
0
Fork 0
forked from MightyPork/crsn
Code Issues Pull Requests Releases Wiki Activity

remove "immediate ptr" data type, move read, write funcs to RunState, add %objectPtr syntax

Browse Source
This commit is contained in:
MightyPork
2020-09-28 01:01:57 +02:00
parent d489b214e0
commit 8222efe6da
12 changed files with 328 additions and 271 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crsn_arith/src/exec.rs
+94 -96
View File
@@ -2,191 +2,189 @@ use std::ops::Rem;
use num_traits::PrimInt;
use crsn::asm::instr::op::{OpTrait, EvalRes};
use crsn::asm::instr::Cond;
use crsn::asm::instr::op::{EvalRes, OpTrait};
use crsn::runtime::fault::Fault;
use crsn::runtime::run_thread::{state::RunState, ThreadInfo};
use crate::defs::ArithOp;
use crsn::runtime::run_thread::{ThreadInfo, RunState};
impl OpTrait for ArithOp {
fn execute(&self, _ti : &ThreadInfo, state: &mut RunState) -> Result<EvalRes, Fault> {
let frame = &mut state.frame;
fn execute(&self, _ti: &ThreadInfo, state: &mut RunState) -> Result<EvalRes, Fault> {
let eres = EvalRes::default();
match self {
ArithOp::Test { a } => {
frame.status.clear();
let res = frame.read(*a)?;
frame.status.update(res);
state.clear_status();
let res = state.read(*a)?;
state.update_status(res);
}
ArithOp::Compare { a, b } => {
frame.status.clear();
let x = frame.read(*a)?;
let y = frame.read(*b)?;
frame.status.equal = x == y;
frame.status.lower = x < y;
frame.status.greater = x > y;
state.clear_status();
let x = state.read(*a)?;
let y = state.read(*b)?;
state.set_flag(Cond::Equal, x == y);
state.set_flag(Cond::Lower, x < y);
state.set_flag(Cond::Greater, x > y);
// Test flags are set when both arguments have the property
if x == y {
frame.status.update(x);
state.update_status(x);
}
}
ArithOp::Add { dst, a, b } => {
frame.status.clear();
let x = frame.read(*a)?;
let y = frame.read(*b)?;
state.clear_status();
let x = state.read(*a)?;
let y = state.read(*b)?;
let (res, ov) = if let Some(v) = x.checked_add(y) {
(v, false)
} else {
(x.wrapping_add(y), true)
};
frame.status.update(res);
frame.status.overflow = ov;
frame.write(*dst, res)?;
state.update_status(res);
state.set_flag(Cond::Overflow, ov);
state.write(*dst, res)?;
}
ArithOp::Sub { dst, a, b } => {
frame.status.clear();
let x = frame.read(*a)?;
let y = frame.read(*b)?;
state.clear_status();
let x = state.read(*a)?;
let y = state.read(*b)?;
let (res, ov) = if let Some(v) = x.checked_sub(y) {
(v, false)
} else {
(x.wrapping_sub(y), true)
};
frame.status.update(res);
frame.status.overflow = ov;
frame.write(*dst, res)?;
state.update_status(res);
state.set_flag(Cond::Overflow, ov);
state.write(*dst, res)?;
}
ArithOp::Mul { dst, a, b } => {
frame.status.clear();
let x = frame.read(*a)?;
let y = frame.read(*b)?;
state.clear_status();
let x = state.read(*a)?;
let y = state.read(*b)?;
let (res, ov) = if let Some(v) = x.checked_mul(y) {
(v, false)
} else {
(x.wrapping_mul(y), true)
};
frame.status.update(res);
frame.status.overflow = ov;
frame.write(*dst, res)?;
state.update_status(res);
state.set_flag(Cond::Overflow, ov);
state.write(*dst, res)?;
}
ArithOp::Div { dst, rem, a, div } => {
frame.status.clear();
let x = frame.read(*a)?;
let d = frame.read(*div)?;
state.clear_status();
let x = state.read(*a)?;
let d = state.read(*div)?;
if d == 0 {
frame.status.invalid = true;
state.set_flag(Cond::Invalid, true);
} else {
let (res, remainder, ov) = if let Some(v) = x.checked_div(d) {
(v, x.rem(d), false)
} else {
(x.wrapping_div(d), x.wrapping_rem(d), true)
};
frame.status.update(res);
frame.status.overflow = ov;
frame.write(*dst, res)?;
frame.write(*rem, remainder)?;
state.update_status(res);
state.set_flag(Cond::Overflow, ov);
state.write(*dst, res)?;
state.write(*rem, remainder)?;
}
}
ArithOp::Mod { dst, a, div } => {
frame.status.clear();
let x = frame.read(*a)?;
let d = frame.read(*div)?;
state.clear_status();
let x = state.read(*a)?;
let d = state.read(*div)?;
if d == 0 {
frame.status.invalid = true;
state.set_flag(Cond::Invalid, true);
} else {
let (remainder, ov) = if let Some(v) = x.checked_rem(d) {
(v, false)
} else {
(x.wrapping_rem(d), true)
};
frame.status.update(remainder);
frame.status.overflow = ov;
frame.write(*dst, remainder)?;
state.update_status(remainder);
state.set_flag(Cond::Overflow, ov);
state.write(*dst, remainder)?;
}
}
ArithOp::And { dst, a, b } => {
frame.status.clear();
let x = frame.read(*a)?;
let y = frame.read(*b)?;
state.clear_status();
let x = state.read(*a)?;
let y = state.read(*b)?;
let res = x & y;
frame.status.update(res);
frame.write(*dst, res)?;
state.update_status(res);
state.write(*dst, res)?;
}
ArithOp::Or { dst, a, b } => {
frame.status.clear();
let x = frame.read(*a)?;
let y = frame.read(*b)?;
state.clear_status();
let x = state.read(*a)?;
let y = state.read(*b)?;
let res = x | y;
frame.status.update(res);
frame.write(*dst, res)?;
state.update_status(res);
state.write(*dst, res)?;
}
ArithOp::Xor { dst, a, b } => {
frame.status.clear();
let x = frame.read(*a)?;
let y = frame.read(*b)?;
state.clear_status();
let x = state.read(*a)?;
let y = state.read(*b)?;
let res = x ^ y;
frame.status.update(res);
frame.write(*dst, res)?;
state.update_status(res);
state.write(*dst, res)?;
}
ArithOp::Cpl { dst, a } => {
frame.status.clear();
let x = frame.read(*a)?;
state.clear_status();
let x = state.read(*a)?;
let res = !x;
frame.status.update(res);
frame.write(*dst, res)?;
state.update_status(res);
state.write(*dst, res)?;
}
ArithOp::Rol { dst, a, n } => {
frame.status.clear();
let x = frame.read(*a)?;
let y = frame.read(*n)?;
state.clear_status();
let x = state.read(*a)?;
let y = state.read(*n)?;
if y > u32::MAX as u64 {
frame.status.invalid = true;
state.set_flag(Cond::Invalid, true);
} else {
let res = x.rotate_left(y as u32);
frame.status.update(res);
frame.write(*dst, res)?;
state.update_status(res);
state.write(*dst, res)?;
}
}
ArithOp::Ror { dst, a, n } => {
frame.status.clear();
let x = frame.read(*a)?;
let y = frame.read(*n)?;
state.clear_status();
let x = state.read(*a)?;
let y = state.read(*n)?;
if y > u32::MAX as u64 {
frame.status.invalid = true;
state.set_flag(Cond::Invalid, true);
} else {
let res = x.rotate_right(y as u32);
frame.status.update(res);
frame.write(*dst, res)?;
state.update_status(res);
state.write(*dst, res)?;
}
}
ArithOp::Lsl { dst, a, n } => {
frame.status.clear();
let x = frame.read(*a)?;
let y = frame.read(*n)?;
state.clear_status();
let x = state.read(*a)?;
let y = state.read(*n)?;
let res = x << y;
frame.status.update(res);
frame.write(*dst, res)?;
state.update_status(res);
state.write(*dst, res)?;
}
ArithOp::Lsr { dst, a, n } => {
frame.status.clear();
let x = frame.read(*a)?;
let y = frame.read(*n)?;
state.clear_status();
let x = state.read(*a)?;
let y = state.read(*n)?;
let res = x >> y;
frame.status.update(res);
frame.write(*dst, res)?;
state.update_status(res);
state.write(*dst, res)?;
}
ArithOp::Asr { dst, a, n } => {
frame.status.clear();
let x = frame.read(*a)?;
let y = frame.read(*n)?;
state.clear_status();
let x = state.read(*a)?;
let y = state.read(*n)?;
if y > u32::MAX as u64 {
frame.status.invalid = true;
state.set_flag(Cond::Invalid, true);
} else {
let res = x.signed_shr(y as u32);
frame.status.update(res);
frame.write(*dst, res)?;
state.update_status(res);
state.write(*dst, res)?;
}
}
}