pull/21/head
parent
547beed847
commit
f015104b95
GPG Key ID:
2C5FD5035250423D
@ -1,6 +1,6 @@ |
||||
[workspace] |
||||
members = [ |
||||
"asm", |
||||
"runtime", |
||||
"crsn" |
||||
"launcher", |
||||
"crsn", |
||||
"crsn_arith", |
||||
] |
||||
|
||||
@ -1,11 +0,0 @@ |
||||
[package] |
||||
name = "asm" |
||||
version = "0.1.0" |
||||
authors = ["Ondřej Hruška <ondra@ondrovo.com>"] |
||||
edition = "2018" |
||||
publish = false |
||||
|
||||
[dependencies] |
||||
sexp = "1.1.4" |
||||
thiserror = "1.0.20" |
||||
anyhow = "1.0.32" |
||||
@ -1,19 +0,0 @@ |
||||
use sexp::Sexp; |
||||
|
||||
use crate::error::Error; |
||||
use crate::instr::{Cond, Instr, cond}; |
||||
use crate::parse::parse_instr::parse_instructions; |
||||
use crate::parse::sexp_expect::{expect_list, expect_string_atom}; |
||||
use crate::patches::TryRemove; |
||||
|
||||
pub fn parse_cond_branch(tok: Sexp) -> Result<(Cond, Vec<Instr>), Error> { |
||||
let mut list = expect_list(Some(tok), false)?; |
||||
let kw = expect_string_atom(list.try_remove(0))?; |
||||
|
||||
if !kw.ends_with('?') { |
||||
return Err(Error::Parse(format!("Condition must end with '?': {}", kw).into())); |
||||
} |
||||
|
||||
Ok((cond::parse_cond(&kw)?, parse_instructions(list)?)) |
||||
} |
||||
|
||||
@ -1,516 +0,0 @@ |
||||
use sexp::Sexp; |
||||
|
||||
use crate::data::{Rd, Wr}; |
||||
use crate::data::literal::{Label, RoutineName}; |
||||
use crate::error::Error; |
||||
use crate::instr::{HLOp, Op}; |
||||
use crate::instr::cond::parse_cond; |
||||
use crate::parse::parse_data::{parse_label, parse_rd, parse_wr}; |
||||
use crate::parse::sexp_expect::expect_string_atom; |
||||
|
||||
pub fn parse_op(keyword: &str, far: bool, mut arg_tokens: impl ExactSizeIterator<Item=Sexp> + Clone) -> Result<HLOp, Error> { |
||||
Ok(match keyword { |
||||
"j" => { |
||||
let dest = parse_label(arg_tokens.next())?; |
||||
if far { |
||||
HLOp::L(Op::FarJump(dest)) |
||||
} else { |
||||
HLOp::Jump(dest) |
||||
} |
||||
} |
||||
|
||||
"call" => { |
||||
let dest = RoutineName(expect_string_atom(arg_tokens.next())?); |
||||
|
||||
let mut args = vec![]; |
||||
for t in arg_tokens { |
||||
args.push(parse_rd(Some(t))?); |
||||
} |
||||
HLOp::L(Op::Call(dest, args)) |
||||
} |
||||
|
||||
"ret" => { |
||||
let mut args = vec![]; |
||||
for t in arg_tokens { |
||||
args.push(parse_rd(Some(t))?); |
||||
} |
||||
HLOp::L(Op::Ret(args)) |
||||
} |
||||
|
||||
"routine" => { |
||||
let dest = RoutineName(expect_string_atom(arg_tokens.next())?); |
||||
HLOp::L(Op::Routine(dest)) |
||||
} |
||||
|
||||
"s" => { |
||||
HLOp::L(Op::Skip(parse_rd(arg_tokens.next())?)) |
||||
} |
||||
|
||||
"sif" => { |
||||
let cond = parse_cond(&expect_string_atom(arg_tokens.next())?)?; |
||||
let offs = parse_rd(arg_tokens.next())?; |
||||
HLOp::L(Op::SkipIf(cond, offs)) |
||||
} |
||||
|
||||
"jif" => { |
||||
let cond = parse_cond(&expect_string_atom(arg_tokens.next())?)?; |
||||
let dest = parse_label(arg_tokens.next())?; |
||||
HLOp::JumpIf(cond, dest) |
||||
} |
||||
|
||||
"barrier" => { |
||||
HLOp::L(Op::Barrier(match arg_tokens.next() { |
||||
None => None, |
||||
Some(s) => Some(expect_string_atom(Some(s))?.into()), |
||||
})) |
||||
} |
||||
|
||||
"fault" => { |
||||
HLOp::L(Op::Fault(match arg_tokens.next() { |
||||
None => None, |
||||
Some(s) => Some(expect_string_atom(Some(s))?.into()), |
||||
})) |
||||
} |
||||
|
||||
"ld" => { |
||||
HLOp::L(Op::Move { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
src: parse_rd(arg_tokens.next())?, |
||||
}) |
||||
} |
||||
|
||||
"cmp" => { |
||||
HLOp::L(Op::Compare { |
||||
a: parse_rd(arg_tokens.next())?, |
||||
b: parse_rd(arg_tokens.next())?, |
||||
}) |
||||
} |
||||
|
||||
"tst" => { |
||||
let arg = parse_rd(arg_tokens.next())?; |
||||
HLOp::L(Op::Test { a: arg }) |
||||
} |
||||
|
||||
"inc" => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
HLOp::L(Op::Add { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
b: Rd::immediate(1), |
||||
}) |
||||
} |
||||
|
||||
"dec" => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
HLOp::L(Op::Sub { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
b: Rd::immediate(1), |
||||
}) |
||||
} |
||||
|
||||
"add" => { |
||||
HLOp::L(match arg_tokens.len() { |
||||
3 => { |
||||
Op::Add { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
Op::Add { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Add requires 2 or 3 arguments".into())); |
||||
} |
||||
}) |
||||
} |
||||
|
||||
"sub" => { |
||||
HLOp::L(match arg_tokens.len() { |
||||
3 => { |
||||
Op::Sub { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
Op::Sub { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Sub requires 2 or 3 arguments".into())); |
||||
} |
||||
}) |
||||
} |
||||
|
||||
"mul" => { |
||||
HLOp::L(match arg_tokens.len() { |
||||
3 => { |
||||
Op::Mul { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
Op::Mul { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Mul requires 2 or 3 arguments".into())); |
||||
} |
||||
}) |
||||
} |
||||
|
||||
"divr" => { |
||||
HLOp::L(match arg_tokens.len() { |
||||
3 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
let rem = parse_wr(arg_tokens.next())?; |
||||
let div = parse_rd(arg_tokens.next())?; |
||||
Op::Div { |
||||
dst, |
||||
rem, |
||||
a: dst.as_rd(), |
||||
div, |
||||
} |
||||
} |
||||
4 => { |
||||
Op::Div { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
rem: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
div: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("DivR requires 3 or 4 arguments".into())); |
||||
} |
||||
}) |
||||
} |
||||
|
||||
"div" => { |
||||
HLOp::L(match arg_tokens.len() { |
||||
3 => { |
||||
Op::Div { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
rem: Wr::discard(), |
||||
a: parse_rd(arg_tokens.next())?, |
||||
div: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
let div = parse_rd(arg_tokens.next())?; |
||||
Op::Div { |
||||
dst, |
||||
rem: Wr::discard(), |
||||
a: dst.as_rd(), |
||||
div, |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Div requires 2 or 3 arguments".into())); |
||||
} |
||||
}) |
||||
} |
||||
|
||||
"mod" => { |
||||
HLOp::L(match arg_tokens.len() { |
||||
3 => { |
||||
Op::Mod { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
div: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
let div = parse_rd(arg_tokens.next())?; |
||||
Op::Mod { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
div, |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Mod requires 2 or 3 arguments".into())); |
||||
} |
||||
}) |
||||
} |
||||
|
||||
"and" => { |
||||
HLOp::L(match arg_tokens.len() { |
||||
3 => { |
||||
Op::And { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
Op::And { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("And requires 2 or 3 arguments".into())); |
||||
} |
||||
}) |
||||
} |
||||
|
||||
"or" => { |
||||
HLOp::L(match arg_tokens.len() { |
||||
3 => { |
||||
Op::Or { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
Op::Or { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Or requires 2 or 3 arguments".into())); |
||||
} |
||||
}) |
||||
} |
||||
|
||||
"xor" => { |
||||
HLOp::L(match arg_tokens.len() { |
||||
3 => { |
||||
Op::Xor { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
Op::Xor { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Xor requires 2 or 3 arguments".into())); |
||||
} |
||||
}) |
||||
} |
||||
|
||||
"cpl" => { |
||||
HLOp::L(match arg_tokens.len() { |
||||
2 => { |
||||
Op::Cpl { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
1 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
Op::Cpl { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Cpl requires 1 or 2 arguments".into())); |
||||
} |
||||
}) |
||||
} |
||||
|
||||
"rol" => { |
||||
HLOp::L(match arg_tokens.len() { |
||||
3 => { |
||||
Op::Rol { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
n: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
Op::Rol { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
n: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
1 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
Op::Rol { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
n: Rd::immediate(1), |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Rol requires 1, 2 or 3 arguments".into())); |
||||
} |
||||
}) |
||||
} |
||||
|
||||
"ror" => { |
||||
HLOp::L(match arg_tokens.len() { |
||||
3 => { |
||||
Op::Ror { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
n: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
Op::Ror { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
n: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
1 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
Op::Ror { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
n: Rd::immediate(1), |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Ror requires 1, 2 or 3 arguments".into())); |
||||
} |
||||
}) |
||||
} |
||||
|
||||
"lsl" | "asl" => { |
||||
HLOp::L(match arg_tokens.len() { |
||||
3 => { |
||||
Op::Lsl { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
n: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
Op::Lsl { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
n: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
1 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
Op::Lsl { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
n: Rd::immediate(1), |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Lsl requires 1, 2 or 3 arguments".into())); |
||||
} |
||||
}) |
||||
} |
||||
|
||||
"lsr" => { |
||||
HLOp::L(match arg_tokens.len() { |
||||
3 => { |
||||
Op::Lsr { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
n: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
Op::Lsr { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
n: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
1 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
Op::Lsr { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
n: Rd::immediate(1), |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Lsr requires 1, 2 or 3 arguments".into())); |
||||
} |
||||
}) |
||||
} |
||||
|
||||
"asr" => { |
||||
HLOp::L(match arg_tokens.len() { |
||||
3 => { |
||||
Op::Asr { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
n: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
Op::Asr { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
n: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
1 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
Op::Asr { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
n: Rd::immediate(1), |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Asr requires 1, 2 or 3 arguments".into())); |
||||
} |
||||
}) |
||||
} |
||||
|
||||
other => { |
||||
if let Some(label) = other.strip_prefix(':') { |
||||
let label = Label::Named(label.to_string()); |
||||
if far { |
||||
HLOp::L(Op::FarLabel(label)) |
||||
} else { |
||||
HLOp::Label(label) |
||||
} |
||||
} else { |
||||
return Err(Error::Parse(format!("Unknown instruction: {}", other).into())); |
||||
} |
||||
} |
||||
}) |
||||
} |
||||
@ -1,22 +0,0 @@ |
||||
use sexp::Sexp; |
||||
|
||||
use crate::data::literal::RoutineName; |
||||
use crate::error::Error; |
||||
use crate::instr::Routine; |
||||
use crate::parse::parse_instr::parse_instructions; |
||||
use crate::parse::sexp_expect::{expect_list, expect_string_atom}; |
||||
use crate::patches::TryRemove; |
||||
|
||||
pub fn parse_routines(routines: Vec<Sexp>) -> Result<Vec<Routine>, Error> { |
||||
let mut parsed = vec![]; |
||||
for rt in routines { |
||||
let mut def = expect_list(Some(rt), false)?; |
||||
let name = expect_string_atom(def.try_remove(0))?; |
||||
let body = parse_instructions(def)?; |
||||
parsed.push(Routine { |
||||
name: RoutineName(name), |
||||
body, |
||||
}) |
||||
} |
||||
Ok(parsed) |
||||
} |
||||
@ -1,6 +1,6 @@ |
||||
//! Mask applied to a data source or destination
|
||||
|
||||
use crate::error::AsmError; |
||||
use crate::asm::error::AsmError; |
||||
|
||||
/// Bit mask to apply to a value
|
||||
#[derive(Debug, Clone, Copy, Eq, PartialEq)] |
||||
@ -1,6 +1,6 @@ |
||||
use std::fmt::{self, Display, Formatter}; |
||||
|
||||
use crate::error::Error; |
||||
use crate::asm::error::Error; |
||||
|
||||
/// Register name
|
||||
#[derive(Debug, Clone, Copy, Eq, PartialEq)] |
||||
@ -1,6 +1,7 @@ |
||||
use std::fmt::{self, Display, Formatter}; |
||||
use std::ops::Not; |
||||
use crate::error::Error; |
||||
|
||||
use crate::asm::error::Error; |
||||
|
||||
/// Condition flag
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)] |
||||
@ -1,10 +1,10 @@ |
||||
use std::collections::HashMap; |
||||
use std::sync::atomic::AtomicU32; |
||||
|
||||
use crate::data::{Rd, SrcDisp}; |
||||
use crate::data::literal::{Label, Value}; |
||||
use crate::error::{AsmError, Error}; |
||||
use crate::instr::{Cond, HLOp, Instr, Op, Routine}; |
||||
use crate::asm::data::{Rd, SrcDisp}; |
||||
use crate::asm::data::literal::{Label, Value}; |
||||
use crate::asm::error::{AsmError, Error}; |
||||
use crate::asm::instr::{Cond, HLOp, Instr, Op, Routine}; |
||||
|
||||
/// A trait for something that can turn into multiple instructions
|
||||
pub trait Flatten { |
||||
@ -0,0 +1,20 @@ |
||||
use sexp::Sexp; |
||||
|
||||
use crate::asm::error::Error; |
||||
use crate::asm::instr::{Cond, cond, Instr}; |
||||
use crate::asm::instr::op::OpParser; |
||||
use crate::asm::parse::parse_instr::parse_instructions; |
||||
use crate::asm::parse::sexp_expect::{expect_list, expect_string_atom}; |
||||
use crate::asm::patches::TryRemove; |
||||
|
||||
pub fn parse_cond_branch(tok: Sexp, parsers: &[Box<dyn OpParser>]) -> Result<(Cond, Vec<Instr>), Error> { |
||||
let mut list = expect_list(Some(tok), false)?; |
||||
let kw = expect_string_atom(list.try_remove(0))?; |
||||
|
||||
if !kw.ends_with('?') { |
||||
return Err(Error::Parse(format!("Condition must end with '?': {}", kw).into())); |
||||
} |
||||
|
||||
Ok((cond::parse_cond(&kw)?, parse_instructions(list, parsers)?)) |
||||
} |
||||
|
||||
@ -0,0 +1,109 @@ |
||||
use sexp::Sexp; |
||||
|
||||
use crate::asm::data::literal::{Label, RoutineName}; |
||||
use crate::asm::error::{AsmError, Error}; |
||||
use crate::asm::instr::{HLOp, Op}; |
||||
use crate::asm::instr::cond::parse_cond; |
||||
use crate::asm::instr::op::OpParser; |
||||
use crate::asm::parse::parse_data::{parse_label, parse_rd, parse_wr}; |
||||
use crate::asm::parse::sexp_expect::expect_string_atom; |
||||
|
||||
pub fn parse_op(keyword: &str, far: bool, arg_tokens_slice: Vec<Sexp>, parsers: &[Box<dyn OpParser>]) -> Result<HLOp, Error> { |
||||
let mut arg_tokens = arg_tokens_slice.clone().into_iter(); |
||||
|
||||
Ok(match keyword { |
||||
"j" => { |
||||
let dest = parse_label(arg_tokens.next())?; |
||||
if far { |
||||
HLOp::L(Op::FarJump(dest)) |
||||
} else { |
||||
HLOp::Jump(dest) |
||||
} |
||||
} |
||||
|
||||
"call" => { |
||||
let dest = RoutineName(expect_string_atom(arg_tokens.next())?); |
||||
|
||||
let mut args = vec![]; |
||||
for t in arg_tokens { |
||||
args.push(parse_rd(Some(t))?); |
||||
} |
||||
HLOp::L(Op::Call(dest, args)) |
||||
} |
||||
|
||||
"ret" => { |
||||
let mut args = vec![]; |
||||
for t in arg_tokens { |
||||
args.push(parse_rd(Some(t))?); |
||||
} |
||||
HLOp::L(Op::Ret(args)) |
||||
} |
||||
|
||||
"routine" => { |
||||
let dest = RoutineName(expect_string_atom(arg_tokens.next())?); |
||||
HLOp::L(Op::Routine(dest)) |
||||
} |
||||
|
||||
"s" => { |
||||
HLOp::L(Op::Skip(parse_rd(arg_tokens.next())?)) |
||||
} |
||||
|
||||
"sif" => { |
||||
let cond = parse_cond(&expect_string_atom(arg_tokens.next())?)?; |
||||
let offs = parse_rd(arg_tokens.next())?; |
||||
HLOp::L(Op::SkipIf(cond, offs)) |
||||
} |
||||
|
||||
"jif" => { |
||||
let cond = parse_cond(&expect_string_atom(arg_tokens.next())?)?; |
||||
let dest = parse_label(arg_tokens.next())?; |
||||
HLOp::JumpIf(cond, dest) |
||||
} |
||||
|
||||
"barrier" => { |
||||
HLOp::L(Op::Barrier(match arg_tokens.next() { |
||||
None => None, |
||||
Some(s) => Some(expect_string_atom(Some(s))?.into()), |
||||
})) |
||||
} |
||||
|
||||
"fault" => { |
||||
HLOp::L(Op::Fault(match arg_tokens.next() { |
||||
None => None, |
||||
Some(s) => Some(expect_string_atom(Some(s))?.into()), |
||||
})) |
||||
} |
||||
|
||||
"ld" => { |
||||
HLOp::L(Op::Move { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
src: parse_rd(arg_tokens.next())?, |
||||
}) |
||||
} |
||||
|
||||
other => { |
||||
if let Some(label) = other.strip_prefix(':') { |
||||
let label = Label::Named(label.to_string()); |
||||
if far { |
||||
HLOp::L(Op::FarLabel(label)) |
||||
} else { |
||||
HLOp::Label(label) |
||||
} |
||||
} else { |
||||
for p in parsers { |
||||
match p.parse_op(keyword, far, arg_tokens_slice.clone()) { |
||||
Ok(op) => return Ok(HLOp::L(Op::Extension(op))), |
||||
Err(Error::Asm(AsmError::UnknownInstruction)) => { |
||||
/* ok, try another */ |
||||
} |
||||
Err(other) => { |
||||
return Err(other); |
||||
} |
||||
} |
||||
} |
||||
|
||||
return Err(Error::Parse(format!("Unknown instruction: {}", other).into())); |
||||
} |
||||
} |
||||
}) |
||||
} |
||||
@ -0,0 +1,23 @@ |
||||
use sexp::Sexp; |
||||
|
||||
use crate::asm::data::literal::RoutineName; |
||||
use crate::asm::error::Error; |
||||
use crate::asm::instr::op::OpParser; |
||||
use crate::asm::instr::Routine; |
||||
use crate::asm::parse::parse_instr::parse_instructions; |
||||
use crate::asm::parse::sexp_expect::{expect_list, expect_string_atom}; |
||||
use crate::asm::patches::TryRemove; |
||||
|
||||
pub fn parse_routines(routines: Vec<Sexp>, parsers: &[Box<dyn OpParser>]) -> Result<Vec<Routine>, Error> { |
||||
let mut parsed = vec![]; |
||||
for rt in routines { |
||||
let mut def = expect_list(Some(rt), false)?; |
||||
let name = expect_string_atom(def.try_remove(0))?; |
||||
let body = parse_instructions(def, parsers)?; |
||||
parsed.push(Routine { |
||||
name: RoutineName(name), |
||||
body, |
||||
}) |
||||
} |
||||
Ok(parsed) |
||||
} |
||||
@ -1,6 +1,6 @@ |
||||
use sexp::{Atom, Sexp}; |
||||
|
||||
use crate::error::Error; |
||||
use crate::asm::error::Error; |
||||
|
||||
pub fn expect_list(expr: Option<Sexp>, allow_empty: bool) -> Result<Vec<Sexp>, Error> { |
||||
if let Some(expr) = expr { |
||||
@ -0,0 +1,8 @@ |
||||
#[macro_use] |
||||
extern crate log; |
||||
|
||||
pub use sexp; |
||||
|
||||
pub mod asm; |
||||
pub mod runtime; |
||||
|
||||
@ -0,0 +1,131 @@ |
||||
use crate::asm::data::literal::Addr; |
||||
use crate::asm::instr::Op; |
||||
use crate::runtime::fault::Fault; |
||||
use crate::runtime::frame::StackFrame; |
||||
use crate::runtime::run_thread::RunThread; |
||||
|
||||
pub type CyclesSpent = usize; |
||||
|
||||
pub struct EvalRes { |
||||
pub cycles: u8, |
||||
pub advance: i64, |
||||
} |
||||
|
||||
impl RunThread { |
||||
// TODO unit tests
|
||||
pub fn eval_op(&mut self) -> Result<EvalRes, Fault> { |
||||
let mut cycles = 1; |
||||
let mut advance = 1; |
||||
|
||||
let frame = &mut self.frame; |
||||
|
||||
let op = self.program.read(frame.pc); |
||||
|
||||
debug!("------------------------"); |
||||
debug!("{} | {:?}", frame.pc, op); |
||||
|
||||
/* Operations can be given different execution times when run in slow mode. */ |
||||
/* Presently, all that do anything use 1 cycle. */ |
||||
|
||||
match op { |
||||
Op::Nop => {} |
||||
Op::FarLabel(_) | Op::Routine(_) => { |
||||
/* this is nop, but without any cost - just markers */ |
||||
cycles = 0; |
||||
} |
||||
Op::Barrier(msg) => { |
||||
return Err(Fault::Barrier { |
||||
msg: msg.clone().unwrap_or_else(|| "No msg".into()) |
||||
}); |
||||
} |
||||
Op::Fault(msg) => { |
||||
return Err(Fault::FaultInstr { |
||||
msg: msg.clone().unwrap_or_else(|| "No msg".into()) |
||||
}); |
||||
} |
||||
Op::FarJump(name) => { |
||||
debug!("Far jump to {}", name); |
||||
match self.program.find_far_label(name) { |
||||
Ok(pos) => { |
||||
debug!("label is at {}", pos); |
||||
self.frame.pc = pos; |
||||
} |
||||
Err(e) => { |
||||
return Err(e); |
||||
} |
||||
} |
||||
} |
||||
Op::Call(name, args) => { |
||||
debug!("Call routine {}", name); |
||||
match self.program.find_routine(name) { |
||||
Ok(pos) => { |
||||
debug!("routine is at {}", pos); |
||||
|
||||
let mut values = Vec::with_capacity(args.len()); |
||||
for arg in args { |
||||
values.push(self.frame.read(*arg)?); |
||||
} |
||||
|
||||
let mut frame2 = StackFrame::new(pos, &values); |
||||
std::mem::swap(&mut self.frame, &mut frame2); |
||||
self.call_stack.push(frame2); |
||||
advance = 0; |
||||
} |
||||
Err(e) => { |
||||
return Err(e); |
||||
} |
||||
} |
||||
} |
||||
Op::Ret(retvals) => { |
||||
match self.call_stack.pop() { |
||||
Some(previous) => { |
||||
let mut values = Vec::with_capacity(retvals.len()); |
||||
for arg in retvals { |
||||
values.push(frame.read(*arg)?); |
||||
} |
||||
*frame = previous; |
||||
frame.set_retvals(&values); |
||||
advance = 1; // advance past the call
|
||||
} |
||||
None => { |
||||
return Err(Fault::CallStackUnderflow); |
||||
} |
||||
} |
||||
} |
||||
Op::Skip(val) => { |
||||
let steps = frame.read(*val)?; |
||||
advance = i64::from_ne_bytes(steps.to_ne_bytes()); |
||||
self.program.validate_jump(frame.pc, Addr((frame.pc.0 as i64 + advance) as u64))?; |
||||
} |
||||
Op::SkipIf(cond, val) => { |
||||
if frame.status.test(*cond) { |
||||
let steps = frame.read(*val)?; |
||||
advance = i64::from_ne_bytes(steps.to_ne_bytes()); |
||||
self.program.validate_jump(frame.pc, Addr((frame.pc.0 as i64 + advance) as u64))?; |
||||
} |
||||
} |
||||
Op::Move { dst, src } => { |
||||
frame.status.clear(); |
||||
let val = frame.read(*src)?; |
||||
frame.status.update(val); |
||||
frame.write(*dst, val)?; |
||||
} |
||||
Op::Extension(xop) => { |
||||
xop.execute(&self.program, &mut self.call_stack, frame)?; |
||||
} |
||||
Op::StoreStatus { dst } => { |
||||
let packed = frame.status.store(); |
||||
frame.write(*dst, packed)?; |
||||
} |
||||
Op::LoadStatus { src } => { |
||||
let x = frame.read(*src)?; |
||||
frame.status.load(x); |
||||
} |
||||
} |
||||
|
||||
Ok(EvalRes { |
||||
cycles, |
||||
advance, |
||||
}) |
||||
} |
||||
} |
||||
@ -1,10 +1,7 @@ |
||||
use thiserror::Error; |
||||
|
||||
// use super::span::MemorySpan;
|
||||
// use crate::run_thread::ThreadToken;
|
||||
// use crate::mlock::ClaimId;
|
||||
use asm::data::literal::{DebugMsg, Label, RoutineName}; |
||||
use asm::data::Register; |
||||
use crate::asm::data::literal::{DebugMsg, Label, RoutineName}; |
||||
use crate::asm::data::Register; |
||||
|
||||
#[derive(Error, Debug)] |
||||
pub enum Fault { |
||||
@ -1,13 +1,16 @@ |
||||
use asm::data::{DstDisp, Rd, Register, SrcDisp, Wr}; |
||||
use asm::data::literal::{Addr, Value}; |
||||
use status::StatusFlags; |
||||
|
||||
use crate::fault::Fault; |
||||
use crate::asm::data::{DstDisp, Rd, Register, SrcDisp, Wr}; |
||||
use crate::asm::data::literal::{Addr, Value}; |
||||
|
||||
use super::fault::Fault; |
||||
|
||||
mod status; |
||||
|
||||
pub const REG_COUNT: usize = 8; |
||||
|
||||
pub type CallStack = Vec<StackFrame>; |
||||
|
||||
#[derive(Default, Clone, Debug)] |
||||
pub struct StackFrame { |
||||
/// Program counter, address of the executed instruction
|
||||
@ -1,8 +1,8 @@ |
||||
use std::fmt::{Display, Formatter}; |
||||
use std::fmt; |
||||
|
||||
use asm::data::literal::{is_negative, is_positive, Value}; |
||||
use asm::instr::Cond; |
||||
use crate::asm::data::literal::{is_negative, is_positive, Value}; |
||||
use crate::asm::instr::Cond; |
||||
|
||||
#[derive(Default, Clone, Debug)] |
||||
pub struct StatusFlags { |
||||
@ -1,6 +1,3 @@ |
||||
#[macro_use] |
||||
extern crate log; |
||||
|
||||
pub mod run_thread; |
||||
// pub mod mlock;
|
||||
// pub mod sparse;
|
||||
@ -1,9 +1,8 @@ |
||||
use std::collections::HashMap; |
||||
|
||||
use asm::data::literal::{Addr, Label, RoutineName}; |
||||
use asm::instr::Op; |
||||
|
||||
use crate::fault::Fault; |
||||
use crate::asm::data::literal::{Addr, Label, RoutineName}; |
||||
use crate::asm::instr::Op; |
||||
use crate::runtime::fault::Fault; |
||||
|
||||
#[derive(Clone, Debug)] |
||||
pub struct Program { |
||||
@ -1,4 +1,4 @@ |
||||
use asm::data::literal::Addr; |
||||
use crate::asm::data::literal::Addr; |
||||
|
||||
#[derive(Debug, Clone, Copy)] |
||||
pub struct MemorySpan { |
||||
@ -0,0 +1,28 @@ |
||||
use crsn::asm::data::{Rd, Wr}; |
||||
|
||||
/// A low level instruction
|
||||
#[derive(Clone, Debug, Eq, PartialEq)] |
||||
pub enum ArithOp { |
||||
Test { a: Rd }, |
||||
Compare { a: Rd, b: Rd }, |
||||
|
||||
Add { dst: Wr, a: Rd, b: Rd }, |
||||
Sub { dst: Wr, a: Rd, b: Rd }, |
||||
Mul { dst: Wr, a: Rd, b: Rd }, |
||||
Div { dst: Wr, rem: Wr, a: Rd, div: Rd }, |
||||
// "Mod" is functionally equivalent to "Div" with the result discarded,
|
||||
// but status flags are updated by the remainder
|
||||
Mod { dst: Wr, a: Rd, div: Rd }, |
||||
|
||||
And { dst: Wr, a: Rd, b: Rd }, |
||||
Or { dst: Wr, a: Rd, b: Rd }, |
||||
Xor { dst: Wr, a: Rd, b: Rd }, |
||||
Cpl { dst: Wr, a: Rd }, |
||||
Rol { dst: Wr, a: Rd, n: Rd }, |
||||
// Rotate (with wrap-around)
|
||||
Ror { dst: Wr, a: Rd, n: Rd }, |
||||
Lsl { dst: Wr, a: Rd, n: Rd }, |
||||
// Shift
|
||||
Lsr { dst: Wr, a: Rd, n: Rd }, |
||||
Asr { dst: Wr, a: Rd, n: Rd }, |
||||
} |
||||
@ -0,0 +1,6 @@ |
||||
pub use parse::ArithOpParser; |
||||
|
||||
mod defs; |
||||
mod parse; |
||||
mod exec; |
||||
|
||||
@ -0,0 +1,452 @@ |
||||
use crsn::asm::data::{Rd, Wr}; |
||||
use crsn::asm::error::{AsmError, Error}; |
||||
use crsn::asm::instr::op::{OpParser, OpTrait}; |
||||
use crsn::asm::parse::parse_data::{parse_rd, parse_wr}; |
||||
use crsn::sexp::Sexp; |
||||
|
||||
use crate::defs::ArithOp; |
||||
|
||||
#[derive(Debug, Clone)] |
||||
pub struct ArithOpParser { |
||||
_internal: () |
||||
} |
||||
|
||||
impl ArithOpParser { |
||||
pub fn new() -> Box<dyn OpParser> { |
||||
Box::new(Self { |
||||
_internal: () |
||||
}) |
||||
} |
||||
} |
||||
|
||||
impl OpParser for ArithOpParser { |
||||
fn parse_op(&self, keyword: &str, _far: bool, arg_tokens_sl: Vec<Sexp>) -> Result<Box<dyn OpTrait>, Error> { |
||||
let mut arg_tokens = arg_tokens_sl.into_iter(); |
||||
Ok(Box::new(match keyword { |
||||
"cmp" => { |
||||
ArithOp::Compare { |
||||
a: parse_rd(arg_tokens.next())?, |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
|
||||
"tst" => { |
||||
let arg = parse_rd(arg_tokens.next())?; |
||||
ArithOp::Test { a: arg } |
||||
} |
||||
|
||||
"inc" => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
ArithOp::Add { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
b: Rd::immediate(1), |
||||
} |
||||
} |
||||
|
||||
"dec" => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
ArithOp::Sub { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
b: Rd::immediate(1), |
||||
} |
||||
} |
||||
|
||||
"add" => { |
||||
match arg_tokens.len() { |
||||
3 => { |
||||
ArithOp::Add { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
ArithOp::Add { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Add requires 2 or 3 arguments".into())); |
||||
} |
||||
} |
||||
} |
||||
|
||||
"sub" => { |
||||
match arg_tokens.len() { |
||||
3 => { |
||||
ArithOp::Sub { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
ArithOp::Sub { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Sub requires 2 or 3 arguments".into())); |
||||
} |
||||
} |
||||
} |
||||
|
||||
"mul" => { |
||||
match arg_tokens.len() { |
||||
3 => { |
||||
ArithOp::Mul { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
ArithOp::Mul { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Mul requires 2 or 3 arguments".into())); |
||||
} |
||||
} |
||||
} |
||||
|
||||
"divr" => { |
||||
match arg_tokens.len() { |
||||
3 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
let rem = parse_wr(arg_tokens.next())?; |
||||
let div = parse_rd(arg_tokens.next())?; |
||||
ArithOp::Div { |
||||
dst, |
||||
rem, |
||||
a: dst.as_rd(), |
||||
div, |
||||
} |
||||
} |
||||
4 => { |
||||
ArithOp::Div { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
rem: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
div: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("DivR requires 3 or 4 arguments".into())); |
||||
} |
||||
} |
||||
} |
||||
|
||||
"div" => { |
||||
match arg_tokens.len() { |
||||
3 => { |
||||
ArithOp::Div { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
rem: Wr::discard(), |
||||
a: parse_rd(arg_tokens.next())?, |
||||
div: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
let div = parse_rd(arg_tokens.next())?; |
||||
ArithOp::Div { |
||||
dst, |
||||
rem: Wr::discard(), |
||||
a: dst.as_rd(), |
||||
div, |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Div requires 2 or 3 arguments".into())); |
||||
} |
||||
} |
||||
} |
||||
|
||||
"mod" => { |
||||
match arg_tokens.len() { |
||||
3 => { |
||||
ArithOp::Mod { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
div: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
let div = parse_rd(arg_tokens.next())?; |
||||
ArithOp::Mod { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
div, |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Mod requires 2 or 3 arguments".into())); |
||||
} |
||||
} |
||||
} |
||||
|
||||
"and" => { |
||||
match arg_tokens.len() { |
||||
3 => { |
||||
ArithOp::And { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
ArithOp::And { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("And requires 2 or 3 arguments".into())); |
||||
} |
||||
} |
||||
} |
||||
|
||||
"or" => { |
||||
match arg_tokens.len() { |
||||
3 => { |
||||
ArithOp::Or { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
ArithOp::Or { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Or requires 2 or 3 arguments".into())); |
||||
} |
||||
} |
||||
} |
||||
|
||||
"xor" => { |
||||
match arg_tokens.len() { |
||||
3 => { |
||||
ArithOp::Xor { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
ArithOp::Xor { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
b: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Xor requires 2 or 3 arguments".into())); |
||||
} |
||||
} |
||||
} |
||||
|
||||
"cpl" => { |
||||
match arg_tokens.len() { |
||||
2 => { |
||||
ArithOp::Cpl { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
1 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
ArithOp::Cpl { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Cpl requires 1 or 2 arguments".into())); |
||||
} |
||||
} |
||||
} |
||||
|
||||
"rol" => { |
||||
match arg_tokens.len() { |
||||
3 => { |
||||
ArithOp::Rol { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
n: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
ArithOp::Rol { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
n: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
1 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
ArithOp::Rol { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
n: Rd::immediate(1), |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Rol requires 1, 2 or 3 arguments".into())); |
||||
} |
||||
} |
||||
} |
||||
|
||||
"ror" => { |
||||
match arg_tokens.len() { |
||||
3 => { |
||||
ArithOp::Ror { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
n: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
ArithOp::Ror { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
n: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
1 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
ArithOp::Ror { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
n: Rd::immediate(1), |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Ror requires 1, 2 or 3 arguments".into())); |
||||
} |
||||
} |
||||
} |
||||
|
||||
"lsl" | "asl" => { |
||||
match arg_tokens.len() { |
||||
3 => { |
||||
ArithOp::Lsl { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
n: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
ArithOp::Lsl { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
n: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
1 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
ArithOp::Lsl { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
n: Rd::immediate(1), |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Lsl requires 1, 2 or 3 arguments".into())); |
||||
} |
||||
} |
||||
} |
||||
|
||||
"lsr" => { |
||||
match arg_tokens.len() { |
||||
3 => { |
||||
ArithOp::Lsr { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
n: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
ArithOp::Lsr { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
n: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
1 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
ArithOp::Lsr { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
n: Rd::immediate(1), |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Lsr requires 1, 2 or 3 arguments".into())); |
||||
} |
||||
} |
||||
} |
||||
|
||||
"asr" => { |
||||
match arg_tokens.len() { |
||||
3 => { |
||||
ArithOp::Asr { |
||||
dst: parse_wr(arg_tokens.next())?, |
||||
a: parse_rd(arg_tokens.next())?, |
||||
n: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
2 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
ArithOp::Asr { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
n: parse_rd(arg_tokens.next())?, |
||||
} |
||||
} |
||||
1 => { |
||||
let dst = parse_wr(arg_tokens.next())?; |
||||
ArithOp::Asr { |
||||
dst, |
||||
a: dst.as_rd(), |
||||
n: Rd::immediate(1), |
||||
} |
||||
} |
||||
_ => { |
||||
return Err(Error::Parse("Asr requires 1, 2 or 3 arguments".into())); |
||||
} |
||||
} |
||||
} |
||||
|
||||
_other => { |
||||
return Err(Error::Asm(AsmError::UnknownInstruction)); |
||||
} |
||||
})) |
||||
} |
||||
} |
||||
@ -0,0 +1,16 @@ |
||||
[package] |
||||
name = "launcher" |
||||
version = "0.1.0" |
||||
authors = ["Ondřej Hruška <ondra@ondrovo.com>"] |
||||
edition = "2018" |
||||
|
||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html |
||||
|
||||
[dependencies] |
||||
crsn = { path = "../crsn" } |
||||
crsn_arith = { path = "../crsn_arith" } |
||||
|
||||
simple_logger = "1.9.0" |
||||
log = "0.4.11" |
||||
thiserror = "1.0.20" |
||||
anyhow = "1.0.32" |
||||
Loading…
Reference in new issue