feat(v2foxy) Using const method for decoding.

Author: x4exr

cargo.toml

@@ -4,4 +4,5 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+proc-bitfield = "0.4.0"
 thiserror = "1.0.63"

examples/counter.rs

@@ -1,19 +1,16 @@
 extern crate arrseq_lightning;
 
-use arrseq_lightning::instruction::{address, Instruction, operation, RegisterCode};
-use arrseq_lightning::instruction::address::{Address};
-use arrseq_lightning::instruction::branch::Flag;
-use arrseq_lightning::num::MaskedU8;
+use arrseq_lightning::instruction::{Instruction, LargeImmediate, register, SegmentCode};
+use arrseq_lightning::instruction::load_immediate::{Immediate, Segment};
 
 fn main() {
     let c_max = 10u16;
 
     let program = [
-        Instruction::LoadImmediate { destination: RegisterCode::new(0), segment: MaskedU8::new(0), immediate: c_max },                                              // li r0, c_max
-        Instruction::DualSource { operation: operation::DualSource::Compare, sources: [RegisterCode::new(0), RegisterCode::new(1)] },                               // cmp r0, r1
-        Instruction::Branch { hint: None, condition: Flag::Zero, address: Address::Immediate { immediate: address::LargeImmediate::new(8), mode: address::Mode::Relative }},    // jz pc+8
-        Instruction::Memory { operation: operation::Memory::Branch, address: Address::Immediate { immediate: address::LargeImmediate::new(4), mode: address::Mode::Absolute }}, // jmp 0
-        Instruction::WaitForInterrupt                                                                                                                                             // hlt
+        Instruction::LoadImmediate {
+            destination: register::Code::new(0),
+            segment: Segment::Segment0(Immediate::new(c_max as u32))
+        }                                                                                                                                    // hlt
 
         // pseudo code:
         //
@@ -25,7 +22,4 @@ fn main() {
         // }
         // ```
     ];
-
-    // dbg!(Instruction::decode(0b1000_1000_1000_1000_0001_1000_0000010));
-    dbg!(Instruction::decode(0b11_111_110_100_110_101_000_00000_0100001));
 }

src/core.rs

@@ -1,12 +1,12 @@
-pub mod arithmetic;
+use crate::instruction::register;
 
-use crate::instruction::RegisterCode;
+pub mod arithmetic;
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct State {
     pub instruction_pointer: u64,
     // TODO: Operand modifiers state
-    pub general: [u64; RegisterCode::MASK as usize],
+    pub general: [u64; register::Code::MASK as usize],
     // pub general_vectors: []
 }
 

src/core/arithmetic.rs

@@ -1,8 +1,8 @@
 use crate::core::Core;
-use crate::instruction::RegisterCode;
+use crate::instruction::register;
 
 impl Core {
-    pub fn add(&mut self, destination: RegisterCode, sources: [RegisterCode; 2]) {
+    pub fn add(&mut self, destination: register::Code, sources: [register::Code; 2]) {
         todo!()
     }
 }

src/instruction.rs

@@ -1,17 +1,40 @@
-use crate::instruction::address::{AccessMode, Address};
-use crate::num::{MaskedU32, MaskedU8};
+use crate::num::MaskedU8;
 
 pub mod address;
 pub mod vector;
 pub mod branch;
 pub mod encoding;
-mod register;
-mod arithmetic;
+pub mod register;
+pub mod arithmetic;
+pub mod load_immediate;
 
 pub type SegmentCode = MaskedU8<0x3>;
-pub type LargeImmediate = MaskedU32<0x1FFFFF>;
 pub type ScaleCode = MaskedU8<0x03>;
 
+pub const STACK_SOURCE_MASK: (u8, u32) = (0, 0b0000000000000000000000011111);
+pub const UNSTACK_DEST_MASK: (u8, u32) = (0, 0b0000000000000000000000011111);
+
+pub const LOAD_IMMEDIATE_DESTINATION_MASK: (u8, u32) = (0, 0b0000000000000000000000011111);
+pub const LOAD_IMMEDIATE_SEGMENT_MASK    : (u8, u32) = (5, 0b0000000000000000000001100000);
+pub const LOAD_IMMEDIATE_OFFSET_MASK     : (u8, u32) = (7, 0b1111111111111111111110000000);
+
+pub const BUILD_VECTOR_DESTINATION_MASK: (u8, u32) = (0,  0b0000000000000000000000011111);
+pub const BUILD_VECTOR_COMPONENT_0_MASK: (u8, u32) = (5,  0b0000000000000000001111100000);
+pub const BUILD_VECTOR_COMPONENT_1_MASK: (u8, u32) = (10, 0b0000000000000111110000000000);
+pub const BUILD_VECTOR_COMPONENT_2_MASK: (u8, u32) = (15, 0b0000000011111000000000000000);
+pub const BUILD_VECTOR_COMPONENT_3_MASK: (u8, u32) = (20, 0b0001111100000000000000000000);
+
+pub const UNBUILD_VECTOR_SOURCE_MASK       : (u8, u32) = (0,  0b0000000000000000000000011111);
+pub const UNBUILD_VECTOR_DESTINATION_0_MASK: (u8, u32) = (5,  0b0000000000000000001111100000);
+pub const UNBUILD_VECTOR_DESTINATION_1_MASK: (u8, u32) = (10, 0b0000000000000111110000000000);
+pub const UNBUILD_VECTOR_DESTINATION_2_MASK: (u8, u32) = (15, 0b0000000011111000000000000000);
+pub const UNBUILD_VECTOR_DESTINATION_3_MASK: (u8, u32) = (20, 0b0001111100000000000000000000);
+
+pub const COPY_REGISTER_DESTINATION_FILE_MASK: (u8, u32) = (0,  0b0000000000000000000000000011);
+pub const COPY_REGISTER_DESTINATION_MASK     : (u8, u32) = (0,  0b0000000000000000000001111100);
+pub const COPY_REGISTER_SOURCE_FILE_MASK     : (u8, u32) = (0,  0b0000000000000000000110000000);
+pub const COPY_REGISTER_SOURCE_MASK          : (u8, u32) = (0,  0b0000000000000011111000000000);
+
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum Instruction {
     None,
@@ -26,8 +49,7 @@ pub enum Instruction {
 
     LoadImmediate { 
         destination: register::Code,
-        segment: SegmentCode,
-        immediate: LargeImmediate
+        segment: load_immediate::Segment
     },
     BuildVector {
         destination: register::Code,

src/instruction/address.rs

@@ -1,4 +1,4 @@
-use crate::instruction::{register, ScaleCode};
+use crate::instruction::{ScaleCode};
 use crate::num::MaskedU32;
 
 #[derive(Debug, Clone, Copy, PartialEq)]

src/instruction/load_immediate.rs

@@ -0,0 +1,11 @@
+use crate::num::MaskedU32;
+
+pub type Immediate = MaskedU32<0x1FFFFF>;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Segment {
+    Segment0(Immediate),
+    Segment1(Immediate),
+    Segment2(Immediate),
+    Segment3(bool)
+}

src/instruction/vector.rs

@@ -1,4 +1,3 @@
-use crate::instruction::OperandCode;
 use crate::num::MaskedU8;
 
 pub type ComponentCode = MaskedU8<0x3>;