fix: use unsigned Operand type for immediates

src/disasm.rs

@@ -221,9 +221,9 @@ impl Disassembler {
     /// Group 1 always have an ModRM target (all modrm bits, without reg) as
     /// first and an imm value as second operand (which has to be parsed before
     /// call to this function), but is available in both Byte and Word length.
-    pub fn modrm_reg_to_grp1(reg: u8, target: ModRmTarget, imm: Displacement) -> Mnemonic {
+    pub fn modrm_reg_to_grp1(reg: u8, target: ModRmTarget, imm: Operand) -> Mnemonic {
         match imm {
-            Displacement::IByte(b) => match reg {
+            Operand::Byte(b) => match reg {
                 0b000 => Mnemonic::ADD_Ib(target, b),
                 0b001 => Mnemonic::OR_Ib(target, b),
                 0b010 => Mnemonic::ADC_Ib(target, b),
@@ -234,7 +234,7 @@ impl Disassembler {
                 0b111 => Mnemonic::CMP_Ib(target, b),
                 _ => panic!("Illegal Group 1 mnemonic"),
             },
-            Displacement::IWord(w) => match reg {
+            Operand::Word(w) => match reg {
                 0b000 => Mnemonic::ADD_Iv(target, w),
                 0b001 => Mnemonic::OR_Iv(target, w),
                 0b010 => Mnemonic::ADC_Iv(target, w),
@@ -462,25 +462,25 @@ impl Disassembler {
                 // Group 1
                 0x80 => {
                     let (target, reg) = self.parse_modrm_byte(Operand::Byte(0));
-                    let imm = self.parse_byte() as IByte;
+                    let imm = self.parse_byte();
-                    Self::modrm_reg_to_grp1(reg, target, Displacement::IByte(imm))
+                    Self::modrm_reg_to_grp1(reg, target, Operand::Byte(imm))
                 }
                 0x81 => {
                     let (target, reg) = self.parse_modrm_byte(Operand::Word(0));
-                    let imm = self.parse_word() as IWord;
+                    let imm = self.parse_word();
-                    Self::modrm_reg_to_grp1(reg, target, Displacement::IWord(imm))
+                    Self::modrm_reg_to_grp1(reg, target, Operand::Word(imm))
                 }
                 0x82 => {
                     // same as 0x80
                     let (target, reg) = self.parse_modrm_byte(Operand::Byte(0));
-                    let imm = self.parse_byte() as IByte;
+                    let imm = self.parse_byte();
-                    Self::modrm_reg_to_grp1(reg, target, Displacement::IByte(imm))
+                    Self::modrm_reg_to_grp1(reg, target, Operand::Byte(imm))
                 }
                 0x83 => {
                     // byte extended version
                     let (target, reg) = self.parse_modrm_byte(Operand::Word(0));
-                    let imm = self.parse_byte() as IByte;
+                    let imm = self.parse_byte();
-                    Self::modrm_reg_to_grp1(reg, target, Displacement::IByte(imm))
+                    Self::modrm_reg_to_grp1(reg, target, Operand::Byte(imm))
                 }
 
                 0x84 => modrmb!(self, TEST),

src/instructions.rs

@@ -90,8 +90,8 @@ pub enum Mnemonic {
     // ADD
     ADD_FromReg(ModRmTarget, Register), // From Register into either Memory or Register
     ADD_ToReg(ModRmTarget, Register),   // From either Memory or Register into Reigster
-    ADD_Ib(ModRmTarget, IByte),         // From Immediate into either Memory or Register
+    ADD_Ib(ModRmTarget, Byte),          // From Immediate into either Memory or Register
-    ADD_Iv(ModRmTarget, IWord),         // From Immediate into either Memory or Register
+    ADD_Iv(ModRmTarget, Word),          // From Immediate into either Memory or Register
     ADD_ALIb(Byte),
     ADD_AXIv(Word),
     // PUSH
@@ -105,29 +105,29 @@ pub enum Mnemonic {
     // OR
     OR_FromReg(ModRmTarget, Register),
     OR_ToReg(ModRmTarget, Register),
-    OR_Ib(ModRmTarget, IByte),
+    OR_Ib(ModRmTarget, Byte),
-    OR_Iv(ModRmTarget, IWord),
+    OR_Iv(ModRmTarget, Word),
     OR_ALIb(Byte),
     OR_AXIv(Word),
     // ADC
     ADC_FromReg(ModRmTarget, Register),
     ADC_ToReg(ModRmTarget, Register),
-    ADC_Ib(ModRmTarget, IByte),
+    ADC_Ib(ModRmTarget, Byte),
-    ADC_Iv(ModRmTarget, IWord),
+    ADC_Iv(ModRmTarget, Word),
     ADC_ALIb(Byte),
     ADC_AXIv(Word),
     // SBB
     SBB_FromReg(ModRmTarget, Register),
     SBB_ToReg(ModRmTarget, Register),
-    SBB_Ib(ModRmTarget, IByte),
+    SBB_Ib(ModRmTarget, Byte),
-    SBB_Iv(ModRmTarget, IWord),
+    SBB_Iv(ModRmTarget, Word),
     SBB_ALIb(Byte),
     SBB_AXIv(Word),
     // AND
     AND_FromReg(ModRmTarget, Register),
     AND_ToReg(ModRmTarget, Register),
-    AND_Ib(ModRmTarget, IByte),
+    AND_Ib(ModRmTarget, Byte),
-    AND_Iv(ModRmTarget, IWord),
+    AND_Iv(ModRmTarget, Word),
     AND_ALIb(Byte),
     AND_AXIv(Word),
     // Override
@@ -140,22 +140,22 @@ pub enum Mnemonic {
     // SUB
     SUB_FromReg(ModRmTarget, Register),
     SUB_ToReg(ModRmTarget, Register),
-    SUB_Ib(ModRmTarget, IByte),
+    SUB_Ib(ModRmTarget, Byte),
-    SUB_Iv(ModRmTarget, IWord),
+    SUB_Iv(ModRmTarget, Word),
     SUB_ALIb(Byte),
     SUB_AXIv(Word),
     // XOR
     XOR_FromReg(ModRmTarget, Register),
     XOR_ToReg(ModRmTarget, Register),
-    XOR_Ib(ModRmTarget, IByte),
+    XOR_Ib(ModRmTarget, Byte),
-    XOR_Iv(ModRmTarget, IWord),
+    XOR_Iv(ModRmTarget, Word),
     XOR_ALIb(Byte),
     XOR_AXIv(Word),
     // CMP
     CMP_FromReg(ModRmTarget, Register),
     CMP_ToReg(ModRmTarget, Register),
-    CMP_Ib(ModRmTarget, IByte),
+    CMP_Ib(ModRmTarget, Byte),
-    CMP_Iv(ModRmTarget, IWord),
+    CMP_Iv(ModRmTarget, Word),
     CMP_ALIb(Byte),
     CMP_AXIv(Word),
     // INC