Witch of Git - jade-mouse/blob - toolchain/src/inst.rs

   1 pub mod decode;
   2 pub mod encode;
   3 #[cfg(test)]
   4 mod test;
   5 #[cfg(test)]
   6 use proptest_derive::Arbitrary;
   7
   8 pub use self::{decode::Decode, encode::Encode};
   9
  10 use std::cmp::PartialEq;
  11
  12 #[derive(Clone, Copy, Debug, PartialOrd, Ord, PartialEq, Eq)]
  13 #[cfg_attr(test, derive(Arbitrary))]
  14 #[repr(u8)]
  15 pub enum Reg {
  16     R0,
  17     R1,
  18     R2,
  19     R3,
  20 }
  21
  22 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  23 #[cfg_attr(test, derive(Arbitrary))]
  24 #[repr(u8)]
  25 pub enum LdSt {
  26     Ld,
  27     St,
  28 }
  29
  30 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  31 #[cfg_attr(test, derive(Arbitrary))]
  32 #[repr(u8)]
  33 pub enum Op1 {
  34     Inc,
  35     Dec,
  36     Neg,
  37     Compl,
  38 }
  39
  40 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  41 #[cfg_attr(test, derive(Arbitrary))]
  42 pub enum OpI {
  43     Add(I8),
  44     Lsl(U4),
  45     Lsr(U4),
  46     Asr(U4),
  47     Rol(U4),
  48 }
  49
  50 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  51 #[cfg_attr(test, derive(Arbitrary))]
  52 #[repr(u8)]
  53 pub enum Op2 {
  54     Add = 2,
  55     Sub,
  56     AddPc,
  57     And,
  58     Or,
  59     Xor,
  60 }
  61
  62 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  63 #[cfg_attr(test, derive(Arbitrary))]
  64 pub struct U4(#[cfg_attr(test, proptest(strategy = "0..=16u8"))]u8);
  65 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  66 #[cfg_attr(test, derive(Arbitrary))]
  67 pub struct I5(#[cfg_attr(test, proptest(strategy = "-16..=15i8"))]i8);
  68 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  69 #[cfg_attr(test, derive(Arbitrary))]
  70 pub struct I7(#[cfg_attr(test, proptest(strategy = "-64..=63i8"))] i8);
  71 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  72 #[cfg_attr(test, derive(Arbitrary))]
  73 pub struct U7(#[cfg_attr(test, proptest(strategy = "0..=128u8"))]u8);
  74 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  75 #[cfg_attr(test, derive(Arbitrary))]
  76 pub struct U8(u8);
  77 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  78 #[cfg_attr(test, derive(Arbitrary))]
  79 pub struct I8(i8);
  80
  81 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  82 #[cfg_attr(test, derive(Arbitrary))]
  83 #[repr(u8)]
  84 pub enum Size {
  85     Byte,
  86     Word,
  87 }
  88
  89 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  90 #[cfg_attr(test, derive(Arbitrary))]
  91 #[repr(u8)]
  92 pub enum Half {
  93     Low,
  94     High,
  95 }
  96
  97 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  98 #[cfg_attr(test, derive(Arbitrary))]
  99 pub enum Addr {
 100     Fixed(U7),
 101     Reg(Reg),
 102     Extended {
 103         base: Reg,
 104         offset: I5,
 105         stack: bool,
 106         size: Size,
 107     },
 108 }
 109
 110 #[derive(Clone, Copy, Debug, Eq)]
 111 #[cfg_attr(test, derive(Arbitrary))]
 112 #[cfg_attr(test, proptest(no_params))]
 113 pub enum Cond {
 114     Eql(Reg, Reg),
 115     Neq(Reg, Reg),
 116     Test(Reg, Reg),
 117     TestNot(Reg, Reg),
 118     Lt(Reg, Reg),
 119     Ult(Reg, Reg),
 120 }
 121
 122 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 123 #[cfg_attr(test, derive(Arbitrary))]
 124 pub enum Inst {
 125     Halt,
 126     Nope,
 127     Alu2(Reg, Op2, Reg),
 128     Jalr(Reg),
 129     Move(Reg, Reg),
 130     Alu1(Reg, Op1),
 131     Mem(LdSt, Reg, Addr),
 132     Branch(Cond, I7),
 133     JumpI(I8),
 134     AluI(Reg, OpI),
 135     LdImm(Half, Reg, U8),
 136 }
 137
 138 impl PartialEq for Cond {
 139     fn eq(&self, other: &Cond) -> bool {
 140         use Cond::*;
 141         match (self, other) {
 142             (Eql(a1, b1), Eql(a2, b2)) => (a1, b1) == (a2, b2) || (a1, b1) == (b2, a2),
 143             (Neq(a1, b1), Neq(a2, b2)) => (a1, b1) == (a2, b2) || (a1, b1) == (b2, a2),
 144             (Test(a1, b1), Test(a2, b2)) => (a1, b1) == (a2, b2) || (a1, b1) == (b2, a2),
 145             (TestNot(a1, b1), TestNot(a2, b2)) => (a1, b1) == (a2, b2) || (a1, b1) == (b2, a2),
 146             (Lt(a1, b1), Lt(a2, b2)) => (a1, b1) == (a2, b2),
 147             (Ult(a1, b1), Ult(a2, b2)) => (a1, b1) == (a2, b2),
 148             _ => false,
 149         }
 150     }
 151 }