feat(unary) Added unary operations encoding/decoding.

Author: x4exr

examples/counter.rs

@@ -1,8 +1,15 @@
 extern crate arrseq_lightning;
 
 use arrseq_lightning::instruction::Instruction;
+use arrseq_lightning::instruction::memory::LockOperation;
 
 fn main() {
     let ins = Instruction::decode(0b00000000_00000000_00000000_00000100);
     dbg!(ins);
+    
+    let i = Instruction::Lock(LockOperation::from(0)
+        .with_relative(false)
+        .with_base(10));
+    
+    dbg!(i.encode());
 }

src/instruction.rs

@@ -4,7 +4,8 @@ use crate::num::MaskedU8;
 pub mod load_immediate;
 pub mod memory;
 pub mod mnemonic;
-pub mod vector;
+pub mod register;
+pub mod unary;
 
 bitfield! {
     /// A bitfield showcasing how to specify bit ranges.
@@ -21,8 +22,8 @@ pub enum Instruction {
     Mnemonic(mnemonic::Operation),
 
     LoadImmediate(load_immediate::Operation),
-    BuildVector(vector::BuildVectorOperation),
-    UnBuildVector(vector::UnBuildVectorOperation),
+    BuildVector(register::BuildVectorOperation),
+    UnBuildVector(register::UnBuildVectorOperation),
 
     ReadMemory(memory::ReadOperation),
     WriteMemory(memory::WriteOperation),
@@ -31,45 +32,84 @@ pub enum Instruction {
     Lock(memory::LockOperation),
     Branch(memory::BranchOperation),
 
-    Copy,
+    Copy(register::CopyOperation),
+    
+    Unary(unary::Operation),
+    Negate(unary::NegateOperation),
+    ExtendSign(unary::ExtendSignOperation),
 
-    Unary,
-    Negate,
-    SignExtend,
     Binary,
     RegroupingBinary,
+    
     RegroupingQuaternary
 }
 
 impl Instruction {
-    pub const MNEMONIC_CODE      : u8 = 0;
-    pub const LOAD_IMMEDIATE_CODE: u8 = 1;
-    pub const BUILD_VECTOR_CODE  : u8 = 2;
-    pub const UNBUILD_VECTOR_CODE: u8 = 3;
-    pub const READ_MEMORY_CODE   : u8 = 4;
-    pub const WRITE_MEMORY_CODE  : u8 = 5;
-    pub const STACK_CODE         : u8 = 6;
-    pub const UNSTACK_CODE       : u8 = 7;
-    pub const LOCK_CODE          : u8 = 8;
-    pub const BRANCH_CODE        : u8 = 9;
+    pub const MNEMONIC_CODE          : u8 = 0;
+    pub const LOAD_IMMEDIATE_CODE    : u8 = 1;
+    pub const BUILD_VECTOR_CODE      : u8 = 2;
+    pub const UNBUILD_VECTOR_CODE    : u8 = 3;
+    pub const READ_MEMORY_CODE       : u8 = 4;
+    pub const WRITE_MEMORY_CODE      : u8 = 5;
+    pub const STACK_CODE             : u8 = 6;
+    pub const UNSTACK_CODE           : u8 = 7;
+    pub const LOCK_CODE              : u8 = 8;
+    pub const BRANCH_CODE            : u8 = 9;
+    pub const COPY_CODE              : u8 = 10;
+    pub const UNARY_CODE             : u8 = 11;
+    pub const NEGATE_CODE            : u8 = 12;
+    pub const EXTEND_SIGN_CODE       : u8 = 13;
+    pub const BINARY_CODE            : u8 = 14;
+    pub const REGROUP_BINARY_CODE    : u8 = 15;
+    pub const REGROUP_QUATERNARY_CODE: u8 = 16;
 
     pub fn decode(encoded: u32) -> Self {
-        let operation = Format::from(encoded);
-        match operation.operation() {
+        let operation = Format::from(encoded).operation();
+        match operation {
             Self::MNEMONIC_CODE => Self::Mnemonic(mnemonic::Format::from(encoded).operation()),
             Self::LOAD_IMMEDIATE_CODE => Self::LoadImmediate(load_immediate::Operation::from(encoded)),
-            Self::BUILD_VECTOR_CODE => Self::BuildVector(vector::BuildVectorOperation::from(encoded)),
-            Self::UNBUILD_VECTOR_CODE => Self::UnBuildVector(vector::UnBuildVectorOperation::from(encoded)),
+            Self::BUILD_VECTOR_CODE => Self::BuildVector(register::BuildVectorOperation::from(encoded)),
+            Self::UNBUILD_VECTOR_CODE => Self::UnBuildVector(register::UnBuildVectorOperation::from(encoded)),
             Self::READ_MEMORY_CODE => Self::ReadMemory(memory::ReadOperation::from(encoded)),
             Self::WRITE_MEMORY_CODE => Self::WriteMemory(memory::WriteOperation::from(encoded)),
             Self::STACK_CODE => Self::Stack(memory::StackOperation::from(encoded)),
             Self::UNSTACK_CODE => Self::UnStack(memory::UnStackOperation::from(encoded)),
             Self::LOCK_CODE => Self::Lock(memory::LockOperation::from(encoded)),
             Self::BRANCH_CODE => Self::Branch(memory::BranchOperation::from(encoded)),
+            Self::COPY_CODE => Self::Copy(register::CopyOperation::from(encoded)),
+            Self::UNARY_CODE => Self::Unary(unary::Operation::from(encoded)),
+            Self::NEGATE_CODE => Self::Negate(unary::NegateOperation::from(encoded)),
+            Self::EXTEND_SIGN_CODE => Self::ExtendSign(unary::ExtendSignOperation::from(encoded)),
 
             _ => unimplemented!()
         }
     }
+    
+    pub fn encode(self) -> u32 {
+        let (opcode, operands) = match self {
+            Instruction::Mnemonic(op) => (Self::MNEMONIC_CODE, u32::from(op)),
+            Instruction::LoadImmediate(op) => (Self::LOAD_IMMEDIATE_CODE, u32::from(op)),
+            Instruction::BuildVector(op) => (Self::BUILD_VECTOR_CODE, u32::from(op)),
+            Instruction::UnBuildVector(op) => (Self::UNBUILD_VECTOR_CODE, u32::from(op)),
+            Instruction::ReadMemory(op) => (Self::READ_MEMORY_CODE, u32::from(op)),
+            Instruction::WriteMemory(op) => (Self::WRITE_MEMORY_CODE, u32::from(op)),
+            Instruction::Stack(op) => (Self::STACK_CODE, u32::from(op)),
+            Instruction::UnStack(op) => (Self::UNSTACK_CODE, u32::from(op)),
+            Instruction::Lock(op) => (Self::LOCK_CODE, u32::from(op)),
+            Instruction::Branch(op) => (Self::BRANCH_CODE, u32::from(op)),
+            Instruction::Copy(op) => (Self::COPY_CODE, u32::from(op)),
+            Instruction::Unary(op) => (Self::UNARY_CODE, u32::from(op)),
+            Instruction::Negate(op) => (Self::NEGATE_CODE, u32::from(op)),
+            Instruction::ExtendSign(op) => (Self::EXTEND_SIGN_CODE, u32::from(op)),
+            // Instruction::Binary(op) => (Self::BINARY_CODE, u32::from(op)),
+            // Instruction::RegroupingBinary(op) => (Self::REGROUPING_BINARY_CODE, u32::from(op)),
+            // Instruction::RegroupingQuaternary(op) => (Self::REGROUPING_QUATERNARY_CODE, u32::from(op)),
+            _ => todo!()
+        };
+        
+        let opcode = opcode as u32;
+        opcode | operands
+    }
 }
 
 impl Default for Instruction {

src/instruction/vector.rs src/instruction/register.rs

@@ -1,4 +1,14 @@
-use proc_bitfield::bitfield;
+use proc_bitfield::{bitfield, ConvRaw};
+
+#[derive(Debug, Clone, Copy, PartialEq, Default, ConvRaw)]
+#[repr(u8)]
+pub enum File {
+    #[default]
+    General,
+    Vector,
+    Interrupt,
+    Processor
+}
 
 bitfield! {
     #[derive(Clone, Copy, PartialEq, Eq)]
@@ -20,4 +30,14 @@ bitfield! {
         pub destination_3: u8 @ 22..=26,
         pub source: u8 @ 27..=31
     }
+}
+
+bitfield! {
+    #[derive(Clone, Copy, PartialEq, Eq)]
+    pub struct CopyOperation(pub u32): Debug, FromRaw, IntoRaw { 
+        pub source_file: u8 [unsafe! File] @ 5..=6,
+        pub destination_file: u8 [unsafe! File] @ 7..=8,
+        pub source: u8 @ 22..=26,
+        pub destination: u8 @ 27..=31
+    }
 }

src/instruction/unary.rs

@@ -0,0 +1,52 @@
+use proc_bitfield::{bitfield, ConvRaw};
+use crate::instruction::Scale;
+
+#[derive(Debug, Clone, Copy, PartialEq, Default, ConvRaw)]
+#[repr(u8)]
+pub enum Mode {
+    #[default]
+    Invert,
+    Increment,
+    Decrement,
+    ShiftLeft,
+    ShiftRight,
+    TrailingZeros,
+    LeadingZeros,
+    CountZeros
+}
+
+bitfield! {
+    #[derive(Clone, Copy, PartialEq, Eq)]
+    pub struct Operation(pub u32): Debug, FromRaw, IntoRaw {
+        pub vector: bool @ 5,
+        pub atomic: bool @ 6,
+        pub mode: u8 [unsafe! Mode] @ 7..=9,
+        pub source_offset: u8 @ 10..=15,
+        pub destination_offset: u8 @ 16..=21,
+        pub source: u8 @ 21..=26,
+        pub destination: u8 @ 27..=31
+    }
+}
+
+bitfield! {
+    #[derive(Clone, Copy, PartialEq, Eq)]
+    pub struct NegateOperation(pub u32): Debug, FromRaw, IntoRaw {
+        pub vector: bool @ 5,
+        pub atomic: bool @ 6,
+        pub scale: u8 [unsafe! Scale] @ 7..=8,
+        pub source: u8 @ 21..=26,
+        pub destination: u8 @ 27..=31
+    }
+}
+
+bitfield! {
+    #[derive(Clone, Copy, PartialEq, Eq)]
+    pub struct ExtendSignOperation(pub u32): Debug, FromRaw, IntoRaw {
+        pub vector: bool @ 5,
+        pub atomic: bool @ 6,
+        pub source_scale: u8 [unsafe! Scale] @ 7..=8,
+        pub destination_scale: u8 [unsafe! Scale] @ 9..=10,
+        pub source: u8 @ 21..=26,
+        pub destination: u8 @ 27..=31
+    }
+}