feat(operation) Added format entries for operations universally.

Author: x4exr

examples/counter.rs

@@ -25,4 +25,6 @@ fn main() {
         // }
         // ```
     ];
+    
+    dbg!(Instruction::decode(0b1111111111111111_00_0000001));
 }

src/core.rs

@@ -0,0 +1,17 @@
+pub mod arithmetic;
+
+use crate::instruction::RegisterCode;
+
+#[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_vectors: []
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Core {
+    /// The emulation context
+    pub state: State
+}

src/core/arithmetic.rs

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

src/instruction.rs

@@ -2,6 +2,7 @@ pub mod operation;
 pub mod address;
 pub mod vector;
 pub mod flag;
+pub mod encoding;
 
 use crate::instruction::address::Address;
 use crate::instruction::flag::Flag;
@@ -13,6 +14,27 @@ pub type RegisterCode = MaskedU8<0xF>;
 pub type BranchHintCode = MaskedU8<0x3>;
 pub type OperandCode = MaskedU8<0x3>;
 
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Format {
+    WaitForInterrupt,
+    LoadImmediate,
+    LoadVectorComponents,
+    ExtractVectorComponents,
+    FlagVectorComponents,
+    MapVector,
+    Branch,
+    
+    DualSource,
+    Destination,
+    DestinationSource,
+    DestinationDualSource,
+    DestinationTripleSource,
+    DualDestinationDualSource,
+    Memory,
+    SourceMemory,
+    DestinationMemory
+}
+
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum Instruction {
     WaitForInterrupt,
@@ -21,6 +43,31 @@ pub enum Instruction {
         segment: SegmentCode,
         immediate: u16
     },
+    LoadVectorComponents {
+        destination: RegisterCode,
+        /// Having [None] means that the component corresponding to the index should be 0.
+        components: [Option<vector::ComponentCode>; vector::SIZE]
+    },
+    ExtractVectorComponents {
+        vector: RegisterCode,
+        /// Having [None] means that the component corresponding to the index should not be extracted into a register.
+        components: [Option<RegisterCode>; vector::SIZE]
+    },
+    FlagVectorComponents {
+        flags: [VectorComponentFlags; vector::SIZE],
+        temporary: bool
+    },
+    /// Only supports 2 operands due to the size constrain of an instruction.
+    MapVector {
+        mappings: [VectorComponentMapping; 2],
+        temporary: bool
+    },
+    Branch {
+        condition: Flag,
+        hint: Option<bool>,
+        address: Address
+    },
+    
     DualSource {
         operation: operation::DualSource,
         sources: [RegisterCode; 2]
@@ -49,25 +96,6 @@ pub enum Instruction {
         destinations: [RegisterCode; 2], 
         sources: [RegisterCode; 2]
     },
-    LoadVectorComponents {
-        destination: RegisterCode,
-        /// Having [None] means that the component corresponding to the index should be 0.
-        components: [Option<vector::ComponentCode>; vector::SIZE]
-    },
-    ExtractVectorComponents {
-        vector: RegisterCode,
-        /// Having [None] means that the component corresponding to the index should not be extracted into a register.
-        components: [Option<RegisterCode>; vector::SIZE]
-    },
-    FlagVectorComponents {
-        flags: [VectorComponentFlags; vector::SIZE],
-        temporary: bool
-    },
-    /// Only supports 2 operands due to the size constrain of an instruction.
-    MapVector {
-        mappings: [VectorComponentMapping; 2],
-        temporary: bool
-    },
     Memory {
         operation: operation::Memory,
         address: Address
@@ -81,10 +109,5 @@ pub enum Instruction {
         operation: operation::DestinationMemory,
         destination: Address,
         source: RegisterCode
-    },
-    Branch {
-        condition: Flag,
-        hint: Option<bool>,
-        address: Address
     }
 }

src/instruction/encoding.rs

@@ -0,0 +1,10 @@
+use crate::instruction::Instruction;
+
+pub const OPERATION_MASK: u32 = 0x0000007F;
+
+impl Instruction {
+    pub fn decode(encoded: u32) {
+        let operation = encoded & OPERATION_MASK;
+        dbg!(operation);
+    }
+}

src/instruction/operation.rs

@@ -1,10 +1,24 @@
+use crate::instruction::Format;
+use crate::num::MaskedU8;
+
+pub type Code = MaskedU8<0x7F>;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum DualSource {
+    Compare
+}
+
+impl DualSource {
+    pub const MAPPINGS: [(Code, DualSource); 1] = [(Code::new(0), Self::Compare)];
+}
+
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum Destination {
     Unstack
 }
 
 impl Destination {
-    pub const MAPPINGS: [Destination; 1] = [Self::Unstack];
+    pub const MAPPINGS: [(Code, Destination); 1] = [(Code::new(1), Self::Unstack)];
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -13,7 +27,7 @@ pub enum DestinationSource {
 }
 
 impl DestinationSource {
-    pub const MAPPINGS: [DestinationSource; 1] = [Self::CopyRegisterToRegister];
+    pub const MAPPINGS: [(Code, DestinationSource); 1] = [(Code::new(2), Self::CopyRegisterToRegister)];
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -40,38 +54,40 @@ pub enum DestinationDualSource {
 }
 
 impl DestinationDualSource {
-    pub const MAPPINGS: [DestinationDualSource; 16] = [
-        Self::Add, Self::Subtract, Self::Multiply, Self::Divide,
-        Self::AddFloat, Self::SubtractFloat, Self::MultiplyFloat, Self::DivideFloat,
-        Self::AddVector, Self::SubtractVector, Self::MultiplyVector, Self::DivideVector,
-        Self::AddFloatVector, Self::SubtractFloatVector, Self::MultiplyFloatVector, Self::DivideFloatVector,
+    pub const MAPPINGS: [(Code, DestinationDualSource); 16] = [
+        (Code::new(3), Self::Add),             (Code::new(4), Self::Subtract),             (Code::new(5), Self::Multiply),             (Code::new(6), Self::Divide),
+        (Code::new(7), Self::AddFloat),        (Code::new(8), Self::SubtractFloat),        (Code::new(9), Self::MultiplyFloat),        (Code::new(10), Self::DivideFloat),
+        (Code::new(11), Self::AddVector),      (Code::new(12), Self::SubtractVector),      (Code::new(13), Self::MultiplyVector),      (Code::new(14), Self::DivideVector),
+        (Code::new(15), Self::AddFloatVector), (Code::new(16), Self::SubtractFloatVector), (Code::new(17), Self::MultiplyFloatVector), (Code::new(18), Self::DivideFloatVector),
     ];
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum DestinationTripleSource {
     MultiplyAndAdd,
     AddAndMultiply
+    
+    // todo: Consider neccessity and operation space
 }
 
 impl DestinationTripleSource {
-    pub const MAPPINGS: [DestinationTripleSource; 2] = [
-        Self::MultiplyAndAdd, Self::AddAndMultiply,
+    pub const MAPPINGS: [(Code, DestinationTripleSource); 2] = [
+        (Code::new(19), Self::MultiplyAndAdd), (Code::new(20), Self::AddAndMultiply),
     ];
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum DualDestinationDualSource {
     DivideWithRemainder,
-    DivideFloatingWithRemainder,
+    DivideFloatWithRemainder,
     DivideVectorWithRemainder,
     DivideFloatVectorWithRemainder
 }
 
 impl DualDestinationDualSource {
-    pub const MAPPINGS: [DualDestinationDualSource; 4] = [
-        Self::DivideWithRemainder, Self::DivideFloatingWithRemainder,
-        Self::DivideVectorWithRemainder, Self::DivideFloatVectorWithRemainder,
+    pub const MAPPINGS: [(Code, DualDestinationDualSource); 4] = [
+        (Code::new(21), Self::DivideWithRemainder),       (Code::new(22), Self::DivideFloatingWithRemainder),
+        (Code::new(23), Self::DivideVectorWithRemainder), (Code::new(24), Self::DivideFloatVectorWithRemainder),
     ];
 }
 
@@ -83,8 +99,8 @@ pub enum Memory {
 }
 
 impl Memory {
-    pub const MAPPINGS: [Memory; 3] = [
-        Self::Call, Self::ReleaseMemory, Self::Branch,
+    pub const MAPPINGS: [(Code, Memory); 3] = [
+        (Code::new(25), Self::Call), (Code::new(26), Self::ReleaseMemory), (Code::new(27), Self::Branch),
     ];
 }
 
@@ -102,11 +118,11 @@ pub enum SourceMemory {
 }
 
 impl SourceMemory {
-    pub const MAPPINGS: [SourceMemory; 8] = [
-        Self::CopyMemoryByteToRegister, Self::CopyMemoryWordToRegister,
-        Self::CopyMemoryDwordToRegister, Self::CopyMemoryQwordToRegister,
-        Self::AcquireMemoryByte, Self::AcquireMemoryWord,
-        Self::AcquireMemoryDword, Self::AcquireMemoryQword,
+    pub const MAPPINGS: [(Code, SourceMemory); 8] = [
+        (Code::new(28), Self::CopyMemoryByteToRegister),  (Code::new(29), Self::CopyMemoryWordToRegister),
+        (Code::new(30), Self::CopyMemoryDwordToRegister), (Code::new(31), Self::CopyMemoryQwordToRegister),
+        (Code::new(32), Self::AcquireMemoryByte),         (Code::new(33), Self::AcquireMemoryWord),
+        (Code::new(34), Self::AcquireMemoryDword),        (Code::new(35), Self::AcquireMemoryQword),
     ];
 }
 
@@ -119,8 +135,64 @@ pub enum DestinationMemory {
 }
 
 impl DestinationMemory {
-    pub const MAPPINGS: [DestinationMemory; 4] = [
-        Self::CopyRegisterByteToMemory, Self::CopyRegisterWordToMemory,
-        Self::CopyRegisterDwordToMemory, Self::CopyRegisterQwordToMemory,
+    pub const MAPPINGS: [(Code, DestinationMemory); 4] = [
+        (Code::new(36), Self::CopyRegisterByteToMemory),  (Code::new(37), Self::CopyRegisterWordToMemory),
+        (Code::new(38), Self::CopyRegisterDwordToMemory), (Code::new(39), Self::CopyRegisterQwordToMemory),
     ];
 }
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Entry<'a> {
+    pub format: Format,
+    pub name: &'a str
+}
+
+pub const MAPPINGS: [Entry; 47] = [
+    Entry { format: Format::WaitForInterrupt,          name: "wait_for_interrupt" },
+    Entry { format: Format::LoadImmediate,             name: "load_immediate" },
+    Entry { format: Format::LoadVectorComponents,      name: "load_vector_components" },
+    Entry { format: Format::ExtractVectorComponents,   name: "extract_vector_components" },
+    Entry { format: Format::FlagVectorComponents,      name: "flag_vector_components" },
+    Entry { format: Format::MapVector,                 name: "map_vector" },
+    Entry { format: Format::Branch,                    name: "branch" },
+    Entry { format: Format::DualSource,                name: "compare" },
+    Entry { format: Format::Destination,               name: "unstack" },
+    Entry { format: Format::DestinationSource,         name: "copy_register_to_register" },
+    Entry { format: Format::DestinationDualSource,     name: "add" },
+    Entry { format: Format::DestinationDualSource,     name: "subtract" },
+    Entry { format: Format::DestinationDualSource,     name: "multiply" },
+    Entry { format: Format::DestinationDualSource,     name: "divide" },
+    Entry { format: Format::DestinationDualSource,     name: "add_float" },
+    Entry { format: Format::DestinationDualSource,     name: "subtract_float" },
+    Entry { format: Format::DestinationDualSource,     name: "multiply_float" },
+    Entry { format: Format::DestinationDualSource,     name: "divide_float" },
+    Entry { format: Format::DestinationDualSource,     name: "add_vector" },
+    Entry { format: Format::DestinationDualSource,     name: "subtract_vector" },
+    Entry { format: Format::DestinationDualSource,     name: "multiply_vector" },
+    Entry { format: Format::DestinationDualSource,     name: "divide_vector" },
+    Entry { format: Format::DestinationDualSource,     name: "add_float_vector" },
+    Entry { format: Format::DestinationDualSource,     name: "subtract_float_vector" },
+    Entry { format: Format::DestinationDualSource,     name: "multiply_float_vector" },
+    Entry { format: Format::DestinationDualSource,     name: "divide_float_vector" },
+    Entry { format: Format::DestinationTripleSource,   name: "multiply_and_add" },
+    Entry { format: Format::DestinationTripleSource,   name: "add_and_multiply" },
+    Entry { format: Format::DualDestinationDualSource, name: "divide_with_remainder" },
+    Entry { format: Format::DualDestinationDualSource, name: "divide_float_with_remainder" },
+    Entry { format: Format::DualDestinationDualSource, name: "divide_vector_with_remainder" },
+    Entry { format: Format::DualDestinationDualSource, name: "divide_float_vector_with_remainder" },
+    Entry { format: Format::Memory,                    name: "call" },
+    Entry { format: Format::Memory,                    name: "release_memory" },
+    Entry { format: Format::Memory,                    name: "branch" },
+    Entry { format: Format::SourceMemory,              name: "copy_memory_byte_to_register" },
+    Entry { format: Format::SourceMemory,              name: "copy_memory_word_to_register" },
+    Entry { format: Format::SourceMemory,              name: "copy_memory_dword_to_register" },
+    Entry { format: Format::SourceMemory,              name: "copy_memory_qword_to_register" },
+    Entry { format: Format::SourceMemory,              name: "aquire_memory_byte" },
+    Entry { format: Format::SourceMemory,              name: "aquire_memory_word" },
+    Entry { format: Format::SourceMemory,              name: "aquire_memory_dword" },
+    Entry { format: Format::SourceMemory,              name: "aquire_memory_qword" },
+    Entry { format: Format::DestinationMemory,         name: "copy_register_byte_to_memory" },
+    Entry { format: Format::DestinationMemory,         name: "copy_register_word_to_memory" },
+    Entry { format: Format::DestinationMemory,         name: "copy_register_dword_to_memory" },
+    Entry { format: Format::DestinationMemory,         name: "copy_register_qword_to_memory" }
+];