feat(branch) Implemented basic operand formats.

Author: x4exr

src/instruction.rs

@@ -1 +1,41 @@
-pub mod discriminator;
+use crate::num;
+use crate::operation::branch;
+use crate::state::flag::Flag;
+use crate::state::register::Register;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum RegisterOperation {
+    ReleaseMemory
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum SizedRegisterOperation {
+    
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum DualSizedRegisterOperation {
+    
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum ConditionalBranchOperation {
+
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Instruction {
+    Nothing,
+    WaitForInterrupt,
+    Register { operation: RegisterOperation, register: Register },
+    SizedRegister { 
+        operation: SizedRegisterOperation, 
+        size: num::Size, register: Register },
+    DualSizedRegister {
+        operation: DualSizedRegisterOperation,
+        size: num::Size, registers: [Register; 2] },
+    ConditionalBranch {
+        operation: ConditionalBranchOperation,
+        condition: Option<Flag>, hint: branch::Hint,
+        address: branch::Address }
+}

src/instruction/discriminator.rs

@@ -14,4 +14,7 @@
 #![allow(clippy::unused_io_amount)]
 #![allow(soft_unstable)]
 
-pub mod instruction;
+pub mod instruction;
+pub mod num;
+pub mod operation;
+pub mod state;

src/lib.rs

@@ -0,0 +1,123 @@
+/// # Power
+/// The power is a representation of this primitive data type which when set to the power of 2 gives the size in bytes.
+/// The power only has its 2 least significant bits used and the rest are discarded.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Size {
+    X8,
+    X16,
+    X32,
+    X64
+}
+
+impl Size {
+    /// Construct this enum from an exponent of the power of 2.
+    pub fn from_power(size: u8) -> Self {
+        match size & 0b000000_11 {
+            0 => Self::X8,
+            1 => Self::X16,
+            2 => Self::X32,
+            3 => Self::X64,
+            _ => unreachable!()
+        }
+    }
+
+    /// Convert this enum representation to a power of 2.
+    pub const fn power(self) -> u8 {
+        match self {
+            Self::X8 => 0,
+            Self::X16 => 1,
+            Self::X32 => 2,
+            Self::X64 => 3
+        }
+    }
+
+    /// Get the number of bytes it would take to represent a value of this size.
+    pub const fn size(self) -> u8 {
+        let size = match self {
+            Self::X8 => u8::BITS / 8,
+            Self::X16 => u16::BITS / 8,
+            Self::X32 => u32::BITS / 8,
+            Self::X64 => u64::BITS / 8
+        };
+
+        size as u8
+    }
+
+    /// Attempt to increase the size to the next quantization.
+    pub fn upsize(&mut self) {
+        *self = match self {
+            Self::X8 => Self::X16,
+            Self::X16 => Self::X32,
+            Self::X32 => Self::X64,
+            Self::X64 => Self::X64
+        }
+    }
+
+    /// Whether if upsizing will return a different value.
+    pub const fn can_upsize(self) -> bool {
+        !matches!(self, Self::X64)
+    }
+
+    /// Attempt to decrease the size to the next quantization. 
+    ///
+    /// # Result
+    /// If this cannot be downsized anymore, then self is returned.
+    pub fn downsize(&mut self) {
+        *self = match self {
+            Self::X64 => Self::X32,
+            Self::X32 => Self::X16,
+            Self::X16 => Self::X8,
+            Self::X8 => Self::X8
+        }
+    }
+
+    /// Whether if downsizing will return a different value.
+    pub const fn can_downsize(self) -> bool {
+        !matches!(self, Self::X8)
+    }
+
+    pub const fn mask(self) -> u64 {
+        match self {
+            Self::X8 => u8::MAX as u64,
+            Self::X16 => u16::MAX as u64,
+            Self::X32 => u32::MAX as u64,
+            Self::X64 => u64::MAX
+        }
+    }
+
+    pub const fn minimum(value: u64) -> Self {
+        if value > u32::MAX as u64 { Self::X64 }
+        else if value > u16::MAX as u64 { Self::X32 }
+        else if value > u8::MAX as u64 { Self::X16 }
+        else { Self::X8 }
+    }
+
+    pub const fn minimum_signed(value: i64) -> Self {
+        if value > i32::MAX as i64 || value < i32::MIN as i64 { Self::X64 }
+        else if value > i16::MAX as i64 || value < i16::MIN as i64 { Self::X32 }
+        else if value > i8::MAX as i64 || value < i8::MIN as i64 { Self::X16 }
+        else { Self::X8 }
+    }
+}
+
+macro_rules! impl_mask {
+    ($ty: ty, $name: tt) => {
+        #[derive(Debug, Clone, Copy, PartialEq)]
+        pub struct $name<const MASK: $ty>($ty);
+        
+        impl<const MASK: $ty> $name<MASK> {
+            pub const fn new(value: $ty) -> Self { Self(value & MASK) }
+            pub const fn get(self) -> $ty { self.0 }
+            pub fn set(&mut self, value: $ty) { self.0 = value & MASK }
+        }
+    };
+}
+
+impl_mask!(u8, MaskedU8);
+impl_mask!(u16, MaskedU16);
+impl_mask!(u32, MaskedU32);
+impl_mask!(u64, MaskedU64);
+impl_mask!(i8, MaskedI8);
+impl_mask!(i16, MaskedI16);
+impl_mask!(i32, MaskedI32);
+impl_mask!(i64, MaskedI64);

src/num.rs

@@ -0,0 +1 @@
+pub mod branch;

src/operation.rs

@@ -0,0 +1,62 @@
+use crate::num;
+use crate::state::flag::Flag;
+use crate::state::register::Register;
+
+/// Hint to suggest whether the branch might be taken.
+pub type Hint = Option<bool>;
+
+pub const IMMEDIATE_MASK: u32 = 0x3FFFF;
+pub type Immediate = num::MaskedU32<IMMEDIATE_MASK>;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Mode {
+    Absolute,
+    Relative
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Address {
+    Immediate {
+        mode: Mode,
+        immediate: Immediate },
+    Register {
+        mode: Mode,
+        register: Register }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Condition(pub Option<Flag>);
+
+pub const CONDITION_MASK: u8 = 0x07;
+pub type ConditionCode = num::MaskedU8<CONDITION_MASK>;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct ConditionMapping {
+    pub code: ConditionCode,
+    pub variant: Condition 
+}
+
+impl Condition {
+    pub const MAPPINGS: [Condition; 7] = [
+        Condition(None                  ),
+        Condition(Some(Flag::Negative  )),
+        Condition(Some(Flag::Zero      )),
+        Condition(Some(Flag::Overflow  )),
+        Condition(Some(Flag::Regrouping)),
+        Condition(Some(Flag::Parity    )),
+        Condition(Some(Flag::Auxiliary ))
+    ];
+    
+    pub fn from_code(code: ConditionCode) -> Option<Self> {
+        Self::MAPPINGS.get(code.get() as usize).copied()
+    }
+    
+    pub fn to_code(self) -> ConditionCode {
+        ConditionCode::new(
+            Self::MAPPINGS
+                .iter()
+                .position(|&mapping| mapping == self)
+                .unwrap() as u8,
+        )
+    }
+}

src/operation/branch.rs

@@ -0,0 +1,2 @@
+pub mod flag;
+pub mod register;

src/state.rs

@@ -0,0 +1,9 @@
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Flag {
+    Negative,
+    Zero,
+    Overflow,
+    Regrouping,
+    Parity,
+    Auxiliary
+}

src/state/flag.rs

@@ -0,0 +1,4 @@
+use crate::num;
+
+pub const REGISTER_MASK: u8 = 0x03;
+pub type Register = num::MaskedU8<REGISTER_MASK>;