arch refactor + backend ir start

src/arch/x86_64/reg.rs

@@ -0,0 +1,106 @@
+#[derive(Clone, Copy)]
+pub struct Reg(u8);
+
+#[derive(Clone, Copy)]
+pub struct RegMode {
+    pub reg: Reg,
+    pub width: BitWidth,
+    pub high: bool,
+}
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum BitWidth {
+    B64,
+    B32,
+    B16,
+    B8,
+}
+
+impl RegMode {
+    pub fn base(&self) -> u8 {
+        self.reg.0 & 0b111
+    }
+    /// checks if register is not one of the first 8 (0-7)
+    pub fn gt8(&self) -> bool {
+        self.reg.0 >= 0b1000
+    }
+    pub fn gt4(&self) -> bool {
+        self.reg.0 >= 0b0100
+    }
+}
+
+def_regs! {
+    0b0000 : rax eax ax al ah=spl,
+    0b0001 : rcx ecx cx cl ch=bpl,
+    0b0010 : rdx edx dx dl dh=sil,
+    0b0011 : rbx ebx bx bl bh=dil,
+
+    0b0100 : rsp esp sp spl,
+    0b0101 : rbp ebp bp bpl,
+    0b0110 : rsi esi si sil,
+    0b0111 : rdi edi di dil,
+
+    0b1000 : r8  r8d  r8w  r8b,
+    0b1001 : r9  r9d  r9w  r9b,
+    0b1010 : r10 r10d r10w r10b,
+    0b1011 : r11 r11d r11w r11b,
+    0b1100 : r12 r12d r12w r12b,
+    0b1101 : r13 r13d r13w r13b,
+    0b1110 : r14 r14d r14w r14b,
+    0b1111 : r15 r15d r15w r15b,
+}
+
+impl BitWidth {
+    pub const fn max(&self) -> u64 {
+        match self {
+            Self::B64 => u64::MAX,
+            Self::B32 => u32::MAX as u64,
+            Self::B16 => u16::MAX as u64,
+            Self::B8 => u8::MAX as u64,
+        }
+    }
+    pub const fn bytes(&self) -> usize {
+        match self {
+            Self::B64 => 8,
+            Self::B32 => 4,
+            Self::B16 => 2,
+            Self::B8 => 1,
+        }
+    }
+}
+
+macro_rules! def_regs {
+    ($($val:literal : $B64:ident $B32:ident $B16:ident $B8:ident $($B8H:ident=$hval:expr)?,)*) => {
+        $(
+        #[allow(non_upper_case_globals)]
+        pub const $B64: RegMode = RegMode { reg: Reg($val), width: BitWidth::B64, high: false };
+        #[allow(non_upper_case_globals)]
+        pub const $B32: RegMode = RegMode { reg: Reg($val), width: BitWidth::B32, high: false };
+        #[allow(non_upper_case_globals)]
+        pub const $B16: RegMode = RegMode { reg: Reg($val), width: BitWidth::B16, high: false };
+        #[allow(non_upper_case_globals)]
+        pub const $B8 : RegMode = RegMode { reg: Reg($val), width: BitWidth::B8, high: false  };
+        $(
+        #[allow(non_upper_case_globals)]
+        pub const $B8H: RegMode = RegMode { reg: $hval.reg, width: BitWidth::B8, high: true };
+        )?
+        )*
+        impl RegMode {
+            pub fn parse(s: &str) -> Option<Self> {
+                Some(match s.to_lowercase().as_str() {
+                    $(
+                    stringify!($B64) => $B64,
+                    stringify!($B32) => $B32,
+                    stringify!($B16) => $B16,
+                    stringify!($B8 ) => $B8,
+                    $(
+                    stringify!($B8H) => $B8H,
+                    )?
+                    )*
+                    _ => return None,
+                })
+            }
+        }
+    };
+}
+use def_regs;