marcothms/8086-rs
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

chore(interpreter): rename Operand -> ArithmeticOperand

Browse Source
This commit is contained in:
Marco Thomas
2025-06-17 10:41:50 +09:00
parent 5fab099cd8
commit 1f5e175c68
2 changed files with 197 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
src/interpreter/computer.rs
View File

@@ -6,7 +6,7 @@ use super::{flags::Flags, interpreter::InterpreterError, memory::Memory, registe
/// Wrapper for easier argument passing of polymorph arithmetic operations. /// Wrapper for easier argument passing of polymorph arithmetic operations.
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub enum Operand { pub enum ArithmeticOperand {
Immediate(crate::operands::ImmediateOperand), Immediate(crate::operands::ImmediateOperand),
ModRmTarget(ModRmTarget), ModRmTarget(ModRmTarget),
} }
@@ -61,7 +61,7 @@ impl Computer {
} }
/// Perform binary `dest` = `dest` + `src`. Sets flags. /// 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 op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs + rhs;
let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, lhs, rhs| { let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, lhs, rhs| {
flags.cf = result < rhs; flags.cf = result < rhs;
@@ -74,7 +74,7 @@ impl Computer {
} }
/// Perform binary `dest` = `dest` - `src`. Sets flags. /// 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 op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs - rhs;
let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, lhs, rhs| { let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, lhs, rhs| {
flags.cf = lhs < rhs; flags.cf = lhs < rhs;
@@ -87,7 +87,7 @@ impl Computer {
} }
/// Perform binary `dest` = `dest` | `src`. Sets flags. /// 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 op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs | rhs;
let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, _, _| { let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, _, _| {
flags.cf = false; flags.cf = false;
@@ -100,7 +100,7 @@ impl Computer {
} }
/// Perform binary `dest` = `dest` & `src`. Sets flags. /// 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 op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs & rhs;
let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, _, _rhs| { let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, _, _rhs| {
flags.cf = false; flags.cf = false;
@@ -113,7 +113,7 @@ impl Computer {
} }
/// Perform binary `dest` = `dest` ^ `src`. Sets flags. /// 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 op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs ^ rhs;
let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, _, _| { let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, _, _| {
flags.cf = false; flags.cf = false;
@@ -127,7 +127,7 @@ impl Computer {
/// Perform compare operation, which acts like [`Self::sub()`], but without /// Perform compare operation, which acts like [`Self::sub()`], but without
/// saving the result and only setting [`Self::flags`]. /// 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 op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs - rhs;
let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, lhs, rhs| { let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, lhs, rhs| {
flags.cf = lhs < rhs; flags.cf = lhs < rhs;
@@ -141,7 +141,7 @@ impl Computer {
/// Perform test operation, which acts like [`Self::and()`], but without /// Perform test operation, which acts like [`Self::and()`], but without
/// saving the result and only setting [`Self::flags`]. /// 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 op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs & rhs;
let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, _, _| { let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, _, _| {
flags.cf = false; flags.cf = false;
@@ -154,15 +154,19 @@ impl Computer {
} }
/// Perform `dest` = `dest` + `src` + CF. Sets flags. /// 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; let cf = self.flags.cf as u8;
// cheating, by flattening into immediates, but this allows to easily add the opt. carry // cheating, by flattening into immediates, but this allows to easily add the opt. carry
let src_with_carry = match src { let src_with_carry = match src {
Operand::Immediate(immediate_operand) => Operand::Immediate(immediate_operand + cf), ArithmeticOperand::Immediate(immediate_operand) => {
Operand::ModRmTarget(mod_rm_target) => Operand::Immediate(match mod_rm_target { 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::Memory(idx) => self.memory.read(&self.regs, idx) + cf,
ModRmTarget::Register(reg) => self.regs.read(reg) + cf, ModRmTarget::Register(reg) => self.regs.read(reg) + cf,
}), })
}
}; };
let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs + rhs; let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs + rhs;
let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, 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. /// 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; let cf = self.flags.cf as u8;
// cheating, by flattening into immediates, but this allows to easily add the opt. carry // cheating, by flattening into immediates, but this allows to easily add the opt. carry
let src_with_carry = match src { let src_with_carry = match src {
Operand::Immediate(immediate_operand) => Operand::Immediate(immediate_operand + cf), ArithmeticOperand::Immediate(immediate_operand) => {
Operand::ModRmTarget(mod_rm_target) => Operand::Immediate(match mod_rm_target { 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::Memory(idx) => self.memory.read(&self.regs, idx) + cf,
ModRmTarget::Register(reg) => self.regs.read(reg) + cf, ModRmTarget::Register(reg) => self.regs.read(reg) + cf,
}), })
}
}; };
let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs - rhs; let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs - rhs;
let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, 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`]. /// 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 /// A result can never be saved to an immediate Operand, so `dest` can only
/// be a [`ModRmTarget`]. /// be a [`ModRmTarget`].
fn op<O, F>(&mut self, op: O, flag_set: F, write: bool, dest: ModRmTarget, src: Operand) fn op<O, F>(
where &mut self,
op: O,
flag_set: F,
write: bool,
dest: ModRmTarget,
src: ArithmeticOperand,
) where
O: Fn(Lhs, Rhs) -> ArithmeticResult, O: Fn(Lhs, Rhs) -> ArithmeticResult,
F: Fn(&mut Flags, ArithmeticResult, Lhs, Rhs), F: Fn(&mut Flags, ArithmeticResult, Lhs, Rhs),
{ {
let lhs = self.read_modrm(dest); let lhs = self.read_modrm(dest);
let rhs = match src { let rhs = match src {
Operand::Immediate(imm) => imm, ArithmeticOperand::Immediate(imm) => imm,
Operand::ModRmTarget(target) => self.read_modrm(target), ArithmeticOperand::ModRmTarget(target) => self.read_modrm(target),
}; };
let result = op(lhs, rhs); let result = op(lhs, rhs);
if write { if write {

283
src/interpreter/interpreter.rs
View File

@@ -8,7 +8,7 @@ use crate::{
}; };
use super::{ use super::{
computer::{Computer, Operand}, computer::{ArithmeticOperand, Computer},
interrupt::InterruptMessage, interrupt::InterruptMessage,
}; };
@@ -78,25 +78,29 @@ impl Interpreter {
/* /*
* ADD * ADD
*/ */
Mnemonic::ADD_FromReg(dest, src) => self Mnemonic::ADD_FromReg(dest, src) => self.computer.add(
.computer dest,
.add(dest, Operand::ModRmTarget(ModRmTarget::Register(src))), ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
Mnemonic::ADD_ToReg(src, dest) => self ),
.computer Mnemonic::ADD_ToReg(src, dest) => self.computer.add(
.add(ModRmTarget::Register(dest), Operand::ModRmTarget(src)), ModRmTarget::Register(dest),
Mnemonic::ADD_Ib(dest, src) => self ArithmeticOperand::ModRmTarget(src),
.computer ),
.add(dest, Operand::Immediate(ImmediateOperand::Byte(src))), Mnemonic::ADD_Ib(dest, src) => self.computer.add(
Mnemonic::ADD_Iv(dest, src) => self dest,
.computer ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
.add(dest, Operand::Immediate(ImmediateOperand::Word(src))), ),
Mnemonic::ADD_Iv(dest, src) => self.computer.add(
dest,
ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
),
Mnemonic::ADD_ALIb(src_byte) => self.computer.add( Mnemonic::ADD_ALIb(src_byte) => self.computer.add(
ModRmTarget::Register(crate::register::Register::AL), 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( Mnemonic::ADD_AXIv(src_word) => self.computer.add(
ModRmTarget::Register(crate::register::Register::AX), ModRmTarget::Register(crate::register::Register::AX),
Operand::Immediate(ImmediateOperand::Word(src_word)), ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
), ),
/* /*
* PUSH * PUSH
@@ -117,97 +121,113 @@ impl Interpreter {
/* /*
* OR * OR
*/ */
Mnemonic::OR_FromReg(dest, src) => self Mnemonic::OR_FromReg(dest, src) => self.computer.or(
.computer dest,
.or(dest, Operand::ModRmTarget(ModRmTarget::Register(src))), ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
Mnemonic::OR_ToReg(src, dest) => self ),
.computer Mnemonic::OR_ToReg(src, dest) => self.computer.or(
.or(ModRmTarget::Register(dest), Operand::ModRmTarget(src)), ModRmTarget::Register(dest),
Mnemonic::OR_Ib(dest, src) => self ArithmeticOperand::ModRmTarget(src),
.computer ),
.or(dest, Operand::Immediate(ImmediateOperand::Byte(src))), Mnemonic::OR_Ib(dest, src) => self.computer.or(
Mnemonic::OR_Iv(dest, src) => self dest,
.computer ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
.or(dest, Operand::Immediate(ImmediateOperand::Word(src))), ),
Mnemonic::OR_Iv(dest, src) => self.computer.or(
dest,
ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
),
Mnemonic::OR_ALIb(src_byte) => self.computer.or( Mnemonic::OR_ALIb(src_byte) => self.computer.or(
ModRmTarget::Register(crate::register::Register::AL), 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( Mnemonic::OR_AXIv(src_word) => self.computer.or(
ModRmTarget::Register(crate::register::Register::AX), ModRmTarget::Register(crate::register::Register::AX),
Operand::Immediate(ImmediateOperand::Word(src_word)), ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
), ),
/* /*
* ADC - add with carry * ADC - add with carry
*/ */
Mnemonic::ADC_FromReg(dest, src) => self Mnemonic::ADC_FromReg(dest, src) => self.computer.adc(
.computer dest,
.adc(dest, Operand::ModRmTarget(ModRmTarget::Register(src))), ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
Mnemonic::ADC_ToReg(src, dest) => self ),
.computer Mnemonic::ADC_ToReg(src, dest) => self.computer.adc(
.adc(ModRmTarget::Register(dest), Operand::ModRmTarget(src)), ModRmTarget::Register(dest),
Mnemonic::ADC_Ib(dest, src) => self ArithmeticOperand::ModRmTarget(src),
.computer ),
.adc(dest, Operand::Immediate(ImmediateOperand::Byte(src))), Mnemonic::ADC_Ib(dest, src) => self.computer.adc(
Mnemonic::ADC_Iv(dest, src) => self dest,
.computer ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
.adc(dest, Operand::Immediate(ImmediateOperand::Word(src))), ),
Mnemonic::ADC_Iv(dest, src) => self.computer.adc(
dest,
ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
),
Mnemonic::ADC_ALIb(src_byte) => self.computer.adc( Mnemonic::ADC_ALIb(src_byte) => self.computer.adc(
ModRmTarget::Register(crate::register::Register::AL), 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( Mnemonic::ADC_AXIv(src_word) => self.computer.adc(
ModRmTarget::Register(crate::register::Register::AX), ModRmTarget::Register(crate::register::Register::AX),
Operand::Immediate(ImmediateOperand::Word(src_word)), ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
), ),
/* /*
* SBB - subtract with borrow * SBB - subtract with borrow
*/ */
Mnemonic::SBB_FromReg(dest, src) => self Mnemonic::SBB_FromReg(dest, src) => self.computer.sbb(
.computer dest,
.sbb(dest, Operand::ModRmTarget(ModRmTarget::Register(src))), ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
Mnemonic::SBB_ToReg(src, dest) => self ),
.computer Mnemonic::SBB_ToReg(src, dest) => self.computer.sbb(
.sbb(ModRmTarget::Register(dest), Operand::ModRmTarget(src)), ModRmTarget::Register(dest),
Mnemonic::SBB_Ib(dest, src) => self ArithmeticOperand::ModRmTarget(src),
.computer ),
.sbb(dest, Operand::Immediate(ImmediateOperand::Byte(src))), Mnemonic::SBB_Ib(dest, src) => self.computer.sbb(
Mnemonic::SBB_Iv(dest, src) => self dest,
.computer ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
.sbb(dest, Operand::Immediate(ImmediateOperand::Word(src))), ),
Mnemonic::SBB_Iv(dest, src) => self.computer.sbb(
dest,
ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
),
Mnemonic::SBB_ALIb(src_byte) => self.computer.sbb( Mnemonic::SBB_ALIb(src_byte) => self.computer.sbb(
ModRmTarget::Register(crate::register::Register::AL), 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( Mnemonic::SBB_AXIv(src_word) => self.computer.sbb(
ModRmTarget::Register(crate::register::Register::AX), ModRmTarget::Register(crate::register::Register::AX),
Operand::Immediate(ImmediateOperand::Word(src_word)), ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
), ),
/* /*
* AND * AND
*/ */
Mnemonic::AND_FromReg(dest, src) => self Mnemonic::AND_FromReg(dest, src) => self.computer.and(
.computer dest,
.and(dest, Operand::ModRmTarget(ModRmTarget::Register(src))), ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
Mnemonic::AND_ToReg(src, dest) => self ),
.computer Mnemonic::AND_ToReg(src, dest) => self.computer.and(
.and(ModRmTarget::Register(dest), Operand::ModRmTarget(src)), ModRmTarget::Register(dest),
Mnemonic::AND_Ib(dest, src) => self ArithmeticOperand::ModRmTarget(src),
.computer ),
.and(dest, Operand::Immediate(ImmediateOperand::Byte(src))), Mnemonic::AND_Ib(dest, src) => self.computer.and(
Mnemonic::AND_Iv(dest, src) => self dest,
.computer ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
.and(dest, Operand::Immediate(ImmediateOperand::Word(src))), ),
Mnemonic::AND_Iv(dest, src) => self.computer.and(
dest,
ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
),
Mnemonic::AND_ALIb(src_byte) => self.computer.and( Mnemonic::AND_ALIb(src_byte) => self.computer.and(
ModRmTarget::Register(crate::register::Register::AL), 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( Mnemonic::AND_AXIv(src_word) => self.computer.and(
ModRmTarget::Register(crate::register::Register::AX), ModRmTarget::Register(crate::register::Register::AX),
Operand::Immediate(ImmediateOperand::Word(src_word)), ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
), ),
/* /*
* Override * Override
@@ -220,73 +240,85 @@ impl Interpreter {
/* /*
* SUB * SUB
*/ */
Mnemonic::SUB_FromReg(dest, src) => self Mnemonic::SUB_FromReg(dest, src) => self.computer.sub(
.computer dest,
.sub(dest, Operand::ModRmTarget(ModRmTarget::Register(src))), ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
Mnemonic::SUB_ToReg(src, dest) => self ),
.computer Mnemonic::SUB_ToReg(src, dest) => self.computer.sub(
.sub(ModRmTarget::Register(dest), Operand::ModRmTarget(src)), ModRmTarget::Register(dest),
Mnemonic::SUB_Ib(dest, src) => self ArithmeticOperand::ModRmTarget(src),
.computer ),
.sub(dest, Operand::Immediate(ImmediateOperand::Byte(src))), Mnemonic::SUB_Ib(dest, src) => self.computer.sub(
Mnemonic::SUB_Iv(dest, src) => self dest,
.computer ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
.sub(dest, Operand::Immediate(ImmediateOperand::Word(src))), ),
Mnemonic::SUB_Iv(dest, src) => self.computer.sub(
dest,
ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
),
Mnemonic::SUB_ALIb(src_byte) => self.computer.sub( Mnemonic::SUB_ALIb(src_byte) => self.computer.sub(
ModRmTarget::Register(crate::register::Register::AL), 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( Mnemonic::SUB_AXIv(src_word) => self.computer.sub(
ModRmTarget::Register(crate::register::Register::AX), ModRmTarget::Register(crate::register::Register::AX),
Operand::Immediate(ImmediateOperand::Word(src_word)), ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
), ),
/* /*
* XOR * XOR
*/ */
Mnemonic::XOR_FromReg(dest, src) => self Mnemonic::XOR_FromReg(dest, src) => self.computer.xor(
.computer dest,
.xor(dest, Operand::ModRmTarget(ModRmTarget::Register(src))), ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
Mnemonic::XOR_ToReg(src, dest) => self ),
.computer Mnemonic::XOR_ToReg(src, dest) => self.computer.xor(
.xor(ModRmTarget::Register(dest), Operand::ModRmTarget(src)), ModRmTarget::Register(dest),
Mnemonic::XOR_Ib(dest, src) => self ArithmeticOperand::ModRmTarget(src),
.computer ),
.xor(dest, Operand::Immediate(ImmediateOperand::Byte(src))), Mnemonic::XOR_Ib(dest, src) => self.computer.xor(
Mnemonic::XOR_Iv(dest, src) => self dest,
.computer ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
.xor(dest, Operand::Immediate(ImmediateOperand::Word(src))), ),
Mnemonic::XOR_Iv(dest, src) => self.computer.xor(
dest,
ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
),
Mnemonic::XOR_ALIb(src_byte) => self.computer.xor( Mnemonic::XOR_ALIb(src_byte) => self.computer.xor(
ModRmTarget::Register(crate::register::Register::AL), 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( Mnemonic::XOR_AXIv(src_word) => self.computer.xor(
ModRmTarget::Register(crate::register::Register::AX), ModRmTarget::Register(crate::register::Register::AX),
Operand::Immediate(ImmediateOperand::Word(src_word)), ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
), ),
/* /*
* CMP * CMP
*/ */
Mnemonic::CMP_FromReg(dest, src) => self Mnemonic::CMP_FromReg(dest, src) => self.computer.cmp(
.computer dest,
.cmp(dest, Operand::ModRmTarget(ModRmTarget::Register(src))), ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
Mnemonic::CMP_ToReg(src, dest) => self ),
.computer Mnemonic::CMP_ToReg(src, dest) => self.computer.cmp(
.cmp(ModRmTarget::Register(dest), Operand::ModRmTarget(src)), ModRmTarget::Register(dest),
Mnemonic::CMP_Ib(dest, src) => self ArithmeticOperand::ModRmTarget(src),
.computer ),
.cmp(dest, Operand::Immediate(ImmediateOperand::Byte(src))), Mnemonic::CMP_Ib(dest, src) => self.computer.cmp(
Mnemonic::CMP_Iv(dest, src) => self dest,
.computer ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
.cmp(dest, Operand::Immediate(ImmediateOperand::Word(src))), ),
Mnemonic::CMP_Iv(dest, src) => self.computer.cmp(
dest,
ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
),
Mnemonic::CMP_ALIb(src_byte) => self.computer.cmp( Mnemonic::CMP_ALIb(src_byte) => self.computer.cmp(
ModRmTarget::Register(crate::register::Register::AL), 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( Mnemonic::CMP_AXIv(src_word) => self.computer.cmp(
ModRmTarget::Register(crate::register::Register::AX), 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 * Test
*/ */
Mnemonic::TEST(dest, src) => self Mnemonic::TEST(dest, src) => self.computer.test(
.computer dest,
.test(dest, Operand::ModRmTarget(ModRmTarget::Register(src))), ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
Mnemonic::TEST_Ib(dest, src) => self ),
.computer Mnemonic::TEST_Ib(dest, src) => self.computer.test(
.test(dest, Operand::Immediate(ImmediateOperand::Byte(src))), dest,
Mnemonic::TEST_Iv(dest, src) => self ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
.computer ),
.test(dest, Operand::Immediate(ImmediateOperand::Word(src))), Mnemonic::TEST_Iv(dest, src) => self.computer.test(
dest,
ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
),
Mnemonic::TEST_ALIb(src_byte) => self.computer.test( Mnemonic::TEST_ALIb(src_byte) => self.computer.test(
ModRmTarget::Register(crate::register::Register::AL), 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( Mnemonic::TEST_AXIv(src_word) => self.computer.test(
ModRmTarget::Register(crate::register::Register::AX), ModRmTarget::Register(crate::register::Register::AX),
Operand::Immediate(ImmediateOperand::Word(src_word)), ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
), ),
/* /*