chore(interpreter): rename Operand -> ArithmeticOperand

2025-06-17 10:41:50 +09:00
parent 5fab099cd8
commit 1f5e175c68
2 changed files with 197 additions and 148 deletions
--- a/src/interpreter/computer.rs
+++ b/src/interpreter/computer.rs
@@ -6,7 +6,7 @@ use super::{flags::Flags, interpreter::InterpreterError, memory::Memory, registe

 /// Wrapper for easier argument passing of polymorph arithmetic operations.
 #[derive(Debug, Clone)]
-pub enum Operand {
+pub enum ArithmeticOperand {
    Immediate(crate::operands::ImmediateOperand),
    ModRmTarget(ModRmTarget),
 }
@@ -61,7 +61,7 @@ impl Computer {
    }

    /// Perform binary `dest` = `dest` + `src`. Sets flags.
-    pub fn add(&mut self, dest: ModRmTarget, src: Operand) {
+    pub fn add(&mut self, dest: ModRmTarget, src: ArithmeticOperand) {
        let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs + rhs;
        let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, lhs, rhs| {
            flags.cf = result < rhs;
@@ -74,7 +74,7 @@ impl Computer {
    }

    /// Perform binary `dest` = `dest` - `src`. Sets flags.
-    pub fn sub(&mut self, dest: ModRmTarget, src: Operand) {
+    pub fn sub(&mut self, dest: ModRmTarget, src: ArithmeticOperand) {
        let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs - rhs;
        let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, lhs, rhs| {
            flags.cf = lhs < rhs;
@@ -87,7 +87,7 @@ impl Computer {
    }

    /// Perform binary `dest` = `dest` | `src`. Sets flags.
-    pub fn or(&mut self, dest: ModRmTarget, src: Operand) {
+    pub fn or(&mut self, dest: ModRmTarget, src: ArithmeticOperand) {
        let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs | rhs;
        let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, _, _| {
            flags.cf = false;
@@ -100,7 +100,7 @@ impl Computer {
    }

    /// Perform binary `dest` = `dest` & `src`. Sets flags.
-    pub fn and(&mut self, dest: ModRmTarget, src: Operand) {
+    pub fn and(&mut self, dest: ModRmTarget, src: ArithmeticOperand) {
        let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs & rhs;
        let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, _, _rhs| {
            flags.cf = false;
@@ -113,7 +113,7 @@ impl Computer {
    }

    /// Perform binary `dest` = `dest` ^ `src`. Sets flags.
-    pub fn xor(&mut self, dest: ModRmTarget, src: Operand) {
+    pub fn xor(&mut self, dest: ModRmTarget, src: ArithmeticOperand) {
        let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs ^ rhs;
        let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, _, _| {
            flags.cf = false;
@@ -127,7 +127,7 @@ impl Computer {

    /// Perform compare operation, which acts like [`Self::sub()`], but without
    /// saving the result and only setting [`Self::flags`].
-    pub fn cmp(&mut self, dest: ModRmTarget, src: Operand) {
+    pub fn cmp(&mut self, dest: ModRmTarget, src: ArithmeticOperand) {
        let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs - rhs;
        let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, lhs, rhs| {
            flags.cf = lhs < rhs;
@@ -141,7 +141,7 @@ impl Computer {

    /// Perform test operation, which acts like [`Self::and()`], but without
    /// saving the result and only setting [`Self::flags`].
-    pub fn test(&mut self, dest: ModRmTarget, src: Operand) {
+    pub fn test(&mut self, dest: ModRmTarget, src: ArithmeticOperand) {
        let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs & rhs;
        let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, _, _| {
            flags.cf = false;
@@ -154,15 +154,19 @@ impl Computer {
    }

    /// Perform `dest` = `dest` + `src` + CF. Sets flags.
-    pub fn adc(&mut self, dest: ModRmTarget, src: Operand) {
+    pub fn adc(&mut self, dest: ModRmTarget, src: ArithmeticOperand) {
        let cf = self.flags.cf as u8;
        // cheating, by flattening into immediates, but this allows to easily add the opt. carry
        let src_with_carry = match src {
-            Operand::Immediate(immediate_operand) => Operand::Immediate(immediate_operand + cf),
-            Operand::ModRmTarget(mod_rm_target) => Operand::Immediate(match mod_rm_target {
+            ArithmeticOperand::Immediate(immediate_operand) => {
+                ArithmeticOperand::Immediate(immediate_operand + cf)
+            }
+            ArithmeticOperand::ModRmTarget(mod_rm_target) => {
+                ArithmeticOperand::Immediate(match mod_rm_target {
                    ModRmTarget::Memory(idx) => self.memory.read(&self.regs, idx) + cf,
                    ModRmTarget::Register(reg) => self.regs.read(reg) + cf,
-            }),
+                })
+            }
        };
        let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs + rhs;
        let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, lhs, rhs| {
@@ -176,15 +180,19 @@ impl Computer {
    }

    /// Perform `dest` = `dest` - (`src` + CF). Sets flags.
-    pub fn sbb(&mut self, dest: ModRmTarget, src: Operand) {
+    pub fn sbb(&mut self, dest: ModRmTarget, src: ArithmeticOperand) {
        let cf = self.flags.cf as u8;
        // cheating, by flattening into immediates, but this allows to easily add the opt. carry
        let src_with_carry = match src {
-            Operand::Immediate(immediate_operand) => Operand::Immediate(immediate_operand + cf),
-            Operand::ModRmTarget(mod_rm_target) => Operand::Immediate(match mod_rm_target {
+            ArithmeticOperand::Immediate(immediate_operand) => {
+                ArithmeticOperand::Immediate(immediate_operand + cf)
+            }
+            ArithmeticOperand::ModRmTarget(mod_rm_target) => {
+                ArithmeticOperand::Immediate(match mod_rm_target {
                    ModRmTarget::Memory(idx) => self.memory.read(&self.regs, idx) + cf,
                    ModRmTarget::Register(reg) => self.regs.read(reg) + cf,
-            }),
+                })
+            }
        };
        let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs - rhs;
        let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, lhs, rhs| {
@@ -201,15 +209,21 @@ impl Computer {
    /// it to `dest`, if `write` is set, and sets flags, according to [`F`].
    /// A result can never be saved to an immediate Operand, so `dest` can only
    /// be a [`ModRmTarget`].
-    fn op<O, F>(&mut self, op: O, flag_set: F, write: bool, dest: ModRmTarget, src: Operand)
-    where
+    fn op<O, F>(
+        &mut self,
+        op: O,
+        flag_set: F,
+        write: bool,
+        dest: ModRmTarget,
+        src: ArithmeticOperand,
+    ) where
        O: Fn(Lhs, Rhs) -> ArithmeticResult,
        F: Fn(&mut Flags, ArithmeticResult, Lhs, Rhs),
    {
        let lhs = self.read_modrm(dest);
        let rhs = match src {
-            Operand::Immediate(imm) => imm,
-            Operand::ModRmTarget(target) => self.read_modrm(target),
+            ArithmeticOperand::Immediate(imm) => imm,
+            ArithmeticOperand::ModRmTarget(target) => self.read_modrm(target),
        };
        let result = op(lhs, rhs);
        if write {
--- a/src/interpreter/interpreter.rs
+++ b/src/interpreter/interpreter.rs
@@ -8,7 +8,7 @@ use crate::{
 };

 use super::{
-    computer::{Computer, Operand},
+    computer::{ArithmeticOperand, Computer},
    interrupt::InterruptMessage,
 };

@@ -78,25 +78,29 @@ impl Interpreter {
                /*
                 * ADD
                 */
-                Mnemonic::ADD_FromReg(dest, src) => self
-                    .computer
-                    .add(dest, Operand::ModRmTarget(ModRmTarget::Register(src))),
-                Mnemonic::ADD_ToReg(src, dest) => self
-                    .computer
-                    .add(ModRmTarget::Register(dest), Operand::ModRmTarget(src)),
-                Mnemonic::ADD_Ib(dest, src) => self
-                    .computer
-                    .add(dest, Operand::Immediate(ImmediateOperand::Byte(src))),
-                Mnemonic::ADD_Iv(dest, src) => self
-                    .computer
-                    .add(dest, Operand::Immediate(ImmediateOperand::Word(src))),
+                Mnemonic::ADD_FromReg(dest, src) => self.computer.add(
+                    dest,
+                    ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
+                ),
+                Mnemonic::ADD_ToReg(src, dest) => self.computer.add(
+                    ModRmTarget::Register(dest),
+                    ArithmeticOperand::ModRmTarget(src),
+                ),
+                Mnemonic::ADD_Ib(dest, src) => self.computer.add(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
+                ),
+                Mnemonic::ADD_Iv(dest, src) => self.computer.add(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
+                ),
                Mnemonic::ADD_ALIb(src_byte) => self.computer.add(
                    ModRmTarget::Register(crate::register::Register::AL),
-                    Operand::Immediate(ImmediateOperand::Byte(src_byte)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src_byte)),
                ),
                Mnemonic::ADD_AXIv(src_word) => self.computer.add(
                    ModRmTarget::Register(crate::register::Register::AX),
-                    Operand::Immediate(ImmediateOperand::Word(src_word)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
                ),
                /*
                 * PUSH
@@ -117,97 +121,113 @@ impl Interpreter {
                /*
                 * OR
                 */
-                Mnemonic::OR_FromReg(dest, src) => self
-                    .computer
-                    .or(dest, Operand::ModRmTarget(ModRmTarget::Register(src))),
-                Mnemonic::OR_ToReg(src, dest) => self
-                    .computer
-                    .or(ModRmTarget::Register(dest), Operand::ModRmTarget(src)),
-                Mnemonic::OR_Ib(dest, src) => self
-                    .computer
-                    .or(dest, Operand::Immediate(ImmediateOperand::Byte(src))),
-                Mnemonic::OR_Iv(dest, src) => self
-                    .computer
-                    .or(dest, Operand::Immediate(ImmediateOperand::Word(src))),
+                Mnemonic::OR_FromReg(dest, src) => self.computer.or(
+                    dest,
+                    ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
+                ),
+                Mnemonic::OR_ToReg(src, dest) => self.computer.or(
+                    ModRmTarget::Register(dest),
+                    ArithmeticOperand::ModRmTarget(src),
+                ),
+                Mnemonic::OR_Ib(dest, src) => self.computer.or(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
+                ),
+                Mnemonic::OR_Iv(dest, src) => self.computer.or(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
+                ),
                Mnemonic::OR_ALIb(src_byte) => self.computer.or(
                    ModRmTarget::Register(crate::register::Register::AL),
-                    Operand::Immediate(ImmediateOperand::Byte(src_byte)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src_byte)),
                ),
                Mnemonic::OR_AXIv(src_word) => self.computer.or(
                    ModRmTarget::Register(crate::register::Register::AX),
-                    Operand::Immediate(ImmediateOperand::Word(src_word)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
                ),

                /*
                 * ADC - add with carry
                 */
-                Mnemonic::ADC_FromReg(dest, src) => self
-                    .computer
-                    .adc(dest, Operand::ModRmTarget(ModRmTarget::Register(src))),
-                Mnemonic::ADC_ToReg(src, dest) => self
-                    .computer
-                    .adc(ModRmTarget::Register(dest), Operand::ModRmTarget(src)),
-                Mnemonic::ADC_Ib(dest, src) => self
-                    .computer
-                    .adc(dest, Operand::Immediate(ImmediateOperand::Byte(src))),
-                Mnemonic::ADC_Iv(dest, src) => self
-                    .computer
-                    .adc(dest, Operand::Immediate(ImmediateOperand::Word(src))),
+                Mnemonic::ADC_FromReg(dest, src) => self.computer.adc(
+                    dest,
+                    ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
+                ),
+                Mnemonic::ADC_ToReg(src, dest) => self.computer.adc(
+                    ModRmTarget::Register(dest),
+                    ArithmeticOperand::ModRmTarget(src),
+                ),
+                Mnemonic::ADC_Ib(dest, src) => self.computer.adc(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
+                ),
+                Mnemonic::ADC_Iv(dest, src) => self.computer.adc(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
+                ),
                Mnemonic::ADC_ALIb(src_byte) => self.computer.adc(
                    ModRmTarget::Register(crate::register::Register::AL),
-                    Operand::Immediate(ImmediateOperand::Byte(src_byte)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src_byte)),
                ),
                Mnemonic::ADC_AXIv(src_word) => self.computer.adc(
                    ModRmTarget::Register(crate::register::Register::AX),
-                    Operand::Immediate(ImmediateOperand::Word(src_word)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
                ),

                /*
                 * SBB - subtract with borrow
                 */
-                Mnemonic::SBB_FromReg(dest, src) => self
-                    .computer
-                    .sbb(dest, Operand::ModRmTarget(ModRmTarget::Register(src))),
-                Mnemonic::SBB_ToReg(src, dest) => self
-                    .computer
-                    .sbb(ModRmTarget::Register(dest), Operand::ModRmTarget(src)),
-                Mnemonic::SBB_Ib(dest, src) => self
-                    .computer
-                    .sbb(dest, Operand::Immediate(ImmediateOperand::Byte(src))),
-                Mnemonic::SBB_Iv(dest, src) => self
-                    .computer
-                    .sbb(dest, Operand::Immediate(ImmediateOperand::Word(src))),
+                Mnemonic::SBB_FromReg(dest, src) => self.computer.sbb(
+                    dest,
+                    ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
+                ),
+                Mnemonic::SBB_ToReg(src, dest) => self.computer.sbb(
+                    ModRmTarget::Register(dest),
+                    ArithmeticOperand::ModRmTarget(src),
+                ),
+                Mnemonic::SBB_Ib(dest, src) => self.computer.sbb(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
+                ),
+                Mnemonic::SBB_Iv(dest, src) => self.computer.sbb(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
+                ),
                Mnemonic::SBB_ALIb(src_byte) => self.computer.sbb(
                    ModRmTarget::Register(crate::register::Register::AL),
-                    Operand::Immediate(ImmediateOperand::Byte(src_byte)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src_byte)),
                ),
                Mnemonic::SBB_AXIv(src_word) => self.computer.sbb(
                    ModRmTarget::Register(crate::register::Register::AX),
-                    Operand::Immediate(ImmediateOperand::Word(src_word)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
                ),

                /*
                 * AND
                 */
-                Mnemonic::AND_FromReg(dest, src) => self
-                    .computer
-                    .and(dest, Operand::ModRmTarget(ModRmTarget::Register(src))),
-                Mnemonic::AND_ToReg(src, dest) => self
-                    .computer
-                    .and(ModRmTarget::Register(dest), Operand::ModRmTarget(src)),
-                Mnemonic::AND_Ib(dest, src) => self
-                    .computer
-                    .and(dest, Operand::Immediate(ImmediateOperand::Byte(src))),
-                Mnemonic::AND_Iv(dest, src) => self
-                    .computer
-                    .and(dest, Operand::Immediate(ImmediateOperand::Word(src))),
+                Mnemonic::AND_FromReg(dest, src) => self.computer.and(
+                    dest,
+                    ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
+                ),
+                Mnemonic::AND_ToReg(src, dest) => self.computer.and(
+                    ModRmTarget::Register(dest),
+                    ArithmeticOperand::ModRmTarget(src),
+                ),
+                Mnemonic::AND_Ib(dest, src) => self.computer.and(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
+                ),
+                Mnemonic::AND_Iv(dest, src) => self.computer.and(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
+                ),
                Mnemonic::AND_ALIb(src_byte) => self.computer.and(
                    ModRmTarget::Register(crate::register::Register::AL),
-                    Operand::Immediate(ImmediateOperand::Byte(src_byte)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src_byte)),
                ),
                Mnemonic::AND_AXIv(src_word) => self.computer.and(
                    ModRmTarget::Register(crate::register::Register::AX),
-                    Operand::Immediate(ImmediateOperand::Word(src_word)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
                ),
                /*
                 * Override
@@ -220,73 +240,85 @@ impl Interpreter {
                /*
                 * SUB
                 */
-                Mnemonic::SUB_FromReg(dest, src) => self
-                    .computer
-                    .sub(dest, Operand::ModRmTarget(ModRmTarget::Register(src))),
-                Mnemonic::SUB_ToReg(src, dest) => self
-                    .computer
-                    .sub(ModRmTarget::Register(dest), Operand::ModRmTarget(src)),
-                Mnemonic::SUB_Ib(dest, src) => self
-                    .computer
-                    .sub(dest, Operand::Immediate(ImmediateOperand::Byte(src))),
-                Mnemonic::SUB_Iv(dest, src) => self
-                    .computer
-                    .sub(dest, Operand::Immediate(ImmediateOperand::Word(src))),
+                Mnemonic::SUB_FromReg(dest, src) => self.computer.sub(
+                    dest,
+                    ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
+                ),
+                Mnemonic::SUB_ToReg(src, dest) => self.computer.sub(
+                    ModRmTarget::Register(dest),
+                    ArithmeticOperand::ModRmTarget(src),
+                ),
+                Mnemonic::SUB_Ib(dest, src) => self.computer.sub(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
+                ),
+                Mnemonic::SUB_Iv(dest, src) => self.computer.sub(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
+                ),
                Mnemonic::SUB_ALIb(src_byte) => self.computer.sub(
                    ModRmTarget::Register(crate::register::Register::AL),
-                    Operand::Immediate(ImmediateOperand::Byte(src_byte)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src_byte)),
                ),
                Mnemonic::SUB_AXIv(src_word) => self.computer.sub(
                    ModRmTarget::Register(crate::register::Register::AX),
-                    Operand::Immediate(ImmediateOperand::Word(src_word)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
                ),

                /*
                 * XOR
                 */
-                Mnemonic::XOR_FromReg(dest, src) => self
-                    .computer
-                    .xor(dest, Operand::ModRmTarget(ModRmTarget::Register(src))),
-                Mnemonic::XOR_ToReg(src, dest) => self
-                    .computer
-                    .xor(ModRmTarget::Register(dest), Operand::ModRmTarget(src)),
-                Mnemonic::XOR_Ib(dest, src) => self
-                    .computer
-                    .xor(dest, Operand::Immediate(ImmediateOperand::Byte(src))),
-                Mnemonic::XOR_Iv(dest, src) => self
-                    .computer
-                    .xor(dest, Operand::Immediate(ImmediateOperand::Word(src))),
+                Mnemonic::XOR_FromReg(dest, src) => self.computer.xor(
+                    dest,
+                    ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
+                ),
+                Mnemonic::XOR_ToReg(src, dest) => self.computer.xor(
+                    ModRmTarget::Register(dest),
+                    ArithmeticOperand::ModRmTarget(src),
+                ),
+                Mnemonic::XOR_Ib(dest, src) => self.computer.xor(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
+                ),
+                Mnemonic::XOR_Iv(dest, src) => self.computer.xor(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
+                ),
                Mnemonic::XOR_ALIb(src_byte) => self.computer.xor(
                    ModRmTarget::Register(crate::register::Register::AL),
-                    Operand::Immediate(ImmediateOperand::Byte(src_byte)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src_byte)),
                ),
                Mnemonic::XOR_AXIv(src_word) => self.computer.xor(
                    ModRmTarget::Register(crate::register::Register::AX),
-                    Operand::Immediate(ImmediateOperand::Word(src_word)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
                ),

                /*
                 * CMP
                 */
-                Mnemonic::CMP_FromReg(dest, src) => self
-                    .computer
-                    .cmp(dest, Operand::ModRmTarget(ModRmTarget::Register(src))),
-                Mnemonic::CMP_ToReg(src, dest) => self
-                    .computer
-                    .cmp(ModRmTarget::Register(dest), Operand::ModRmTarget(src)),
-                Mnemonic::CMP_Ib(dest, src) => self
-                    .computer
-                    .cmp(dest, Operand::Immediate(ImmediateOperand::Byte(src))),
-                Mnemonic::CMP_Iv(dest, src) => self
-                    .computer
-                    .cmp(dest, Operand::Immediate(ImmediateOperand::Word(src))),
+                Mnemonic::CMP_FromReg(dest, src) => self.computer.cmp(
+                    dest,
+                    ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
+                ),
+                Mnemonic::CMP_ToReg(src, dest) => self.computer.cmp(
+                    ModRmTarget::Register(dest),
+                    ArithmeticOperand::ModRmTarget(src),
+                ),
+                Mnemonic::CMP_Ib(dest, src) => self.computer.cmp(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
+                ),
+                Mnemonic::CMP_Iv(dest, src) => self.computer.cmp(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
+                ),
                Mnemonic::CMP_ALIb(src_byte) => self.computer.cmp(
                    ModRmTarget::Register(crate::register::Register::AL),
-                    Operand::Immediate(ImmediateOperand::Byte(src_byte)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src_byte)),
                ),
                Mnemonic::CMP_AXIv(src_word) => self.computer.cmp(
                    ModRmTarget::Register(crate::register::Register::AX),
-                    Operand::Immediate(ImmediateOperand::Word(src_word)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
                ),

                /*
@@ -385,22 +417,25 @@ impl Interpreter {
                /*
                 * Test
                 */
-                Mnemonic::TEST(dest, src) => self
-                    .computer
-                    .test(dest, Operand::ModRmTarget(ModRmTarget::Register(src))),
-                Mnemonic::TEST_Ib(dest, src) => self
-                    .computer
-                    .test(dest, Operand::Immediate(ImmediateOperand::Byte(src))),
-                Mnemonic::TEST_Iv(dest, src) => self
-                    .computer
-                    .test(dest, Operand::Immediate(ImmediateOperand::Word(src))),
+                Mnemonic::TEST(dest, src) => self.computer.test(
+                    dest,
+                    ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
+                ),
+                Mnemonic::TEST_Ib(dest, src) => self.computer.test(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
+                ),
+                Mnemonic::TEST_Iv(dest, src) => self.computer.test(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
+                ),
                Mnemonic::TEST_ALIb(src_byte) => self.computer.test(
                    ModRmTarget::Register(crate::register::Register::AL),
-                    Operand::Immediate(ImmediateOperand::Byte(src_byte)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src_byte)),
                ),
                Mnemonic::TEST_AXIv(src_word) => self.computer.test(
                    ModRmTarget::Register(crate::register::Register::AX),
-                    Operand::Immediate(ImmediateOperand::Word(src_word)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
                ),

                /*