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

chore: Rename Operand -> ImmediateOperand

Browse Source
This commit is contained in:
Marco Thomas
2025-06-05 10:07:57 +09:00
parent ef4663a245
commit 232b73aad8
8 changed files with 141 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
src/interpreter/computer.rs
View File

@@ -1,13 +1,13 @@
use core::fmt;
use crate::operands::{ModRmTarget, Operand};
use crate::operands::{ImmediateOperand, ModRmTarget};
use super::{flags::Flags, memory::Memory, register::Register};
/// Wrapper for easier argument passing of arithmetic operations.
#[derive(Debug, Clone)]
pub enum Argument {
Operand(crate::operands::Operand),
pub enum Operand {
Immediate(crate::operands::ImmediateOperand),
ModRmTarget(ModRmTarget),
}
@@ -30,10 +30,10 @@ impl Computer {
/// Adds two [`Argument`]s, saves it to `dest` and sets flags, if necessary.
/// A value can never be saved to an immediate Operand, so `dest` can only
/// be a [`ModRmTarget`].
pub fn add(&mut self, dest: ModRmTarget, src: Argument) {
pub fn add(&mut self, dest: ModRmTarget, src: Operand) {
match src {
Argument::ModRmTarget(src_target) => self.add_modrm(dest, src_target),
Argument::Operand(src_operand) => self.add_imm(dest, src_operand),
Operand::ModRmTarget(src_target) => self.add_modrm(dest, src_target),
Operand::Immediate(src_operand) => self.add_imm(dest, src_operand),
}
}
@@ -45,11 +45,10 @@ impl Computer {
ModRmTarget::Memory(_) => panic!("Cannot add Memory to Memory!"),
// mem, reg
ModRmTarget::Register(src_register) => {
let lhs = self.memory.read_from_memidx(&self.regs, dest_memory_idx);
let lhs = self.memory.read(&self.regs, dest_memory_idx);
let rhs = self.regs.read(src_register);
let result = lhs + rhs;
self.memory
.write_from_memidx(&self.regs, dest_memory_idx, result);
self.memory.write(&self.regs, dest_memory_idx, result);
// unsigned overflow
self.flags.of = result < rhs;
}
@@ -58,7 +57,7 @@ impl Computer {
// reg, mem
ModRmTarget::Memory(src_memory_index) => {
let lhs = self.regs.read(dest_register);
let rhs = self.memory.read_from_memidx(&self.regs, src_memory_index);
let rhs = self.memory.read(&self.regs, src_memory_index);
let result = lhs + rhs;
self.regs.write(dest_register, result);
// unsigned overflow
@@ -78,16 +77,16 @@ impl Computer {
}
}
/// Adds an immediate [`Operand`] to a location pointed to by a
/// Adds an [`ImmediateOperand`] to a location pointed to by a
/// [`ModRmTarget`], saves it to dest and sets flags, if necessary.
fn add_imm(&mut self, dest: ModRmTarget, src: Operand) {
fn add_imm(&mut self, dest: ModRmTarget, src: ImmediateOperand) {
match dest {
ModRmTarget::Memory(dest_mem) => {
let lhs = self.memory.read_from_memidx(&self.regs, dest_mem);
let lhs = self.memory.read(&self.regs, dest_mem);
let result = lhs + src;
// unsigned overflow
self.flags.of = result < src;
self.memory.write_from_memidx(&self.regs, dest_mem, result);
self.memory.write(&self.regs, dest_mem, result);
}
ModRmTarget::Register(dest_reg) => {
let lhs = self.regs.read(dest_reg);

16
src/interpreter/interpreter.rs
View File

@@ -3,10 +3,10 @@ use std::{fmt::Debug, process::exit};
use crate::{
instructions::{Instruction, Mnemonic},
operands::{Byte, ModRmTarget, Operand, Word},
operands::{Byte, ImmediateOperand, ModRmTarget, Word},
};
use super::computer::{Argument, Computer};
use super::computer::{Computer, Operand};
#[derive(Debug, Clone)]
pub enum InterpreterError {
@@ -56,23 +56,23 @@ impl Interpreter {
*/
Mnemonic::ADD_FromReg(dest, src) => self
.computer
.add(dest, Argument::ModRmTarget(ModRmTarget::Register(src))),
.add(dest, Operand::ModRmTarget(ModRmTarget::Register(src))),
Mnemonic::ADD_ToReg(src, dest) => self
.computer
.add(ModRmTarget::Register(dest), Argument::ModRmTarget(src)),
.add(ModRmTarget::Register(dest), Operand::ModRmTarget(src)),
Mnemonic::ADD_Ib(dest, src) => self
.computer
.add(dest, Argument::Operand(Operand::Byte(src))),
.add(dest, Operand::Immediate(ImmediateOperand::Byte(src))),
Mnemonic::ADD_Iv(dest, src) => self
.computer
.add(dest, Argument::Operand(Operand::Word(src))),
.add(dest, Operand::Immediate(ImmediateOperand::Word(src))),
Mnemonic::ADD_ALIb(src_byte) => self.computer.add(
ModRmTarget::Register(crate::register::Register::AL),
Argument::Operand(Operand::Byte(src_byte)),
Operand::Immediate(ImmediateOperand::Byte(src_byte)),
),
Mnemonic::ADD_AXIv(src_word) => self.computer.add(
ModRmTarget::Register(crate::register::Register::AX),
Argument::Operand(Operand::Word(src_word)),
Operand::Immediate(ImmediateOperand::Word(src_word)),
),
/*

41
src/interpreter/memory.rs
View File

@@ -1,4 +1,4 @@
use crate::operands::{Byte, Displacement, MemoryIndex, Operand, Word};
use crate::operands::{Byte, Displacement, ImmediateOperand, MemoryIndex, Word};
#[derive(Debug, Clone, Copy)]
pub struct Memory {
@@ -10,23 +10,23 @@ impl Memory {
Self { memory: [0; 65536] }
}
// Write an [`Operand`] to a memory location indexed by a [`MemoryIndex`].
// Write an [`ImmediateOperand`] to a memory location indexed by a [`MemoryIndex`].
pub fn write(
&mut self,
regs: &crate::interpreter::register::Register,
idx: MemoryIndex,
val: Operand,
val: ImmediateOperand,
) {
match Memory::calc_memidx(regs, idx) {
Operand::Byte(idx_byte) => match val {
Operand::Byte(value) => {
ImmediateOperand::Byte(idx_byte) => match val {
ImmediateOperand::Byte(value) => {
log::debug!("Writing byte {value:#04x} to memory location {idx_byte:#04x}");
self.memory[idx_byte as usize] = value
}
Operand::Word(_) => panic!("Cannot add Word to Byte Memory Index"),
ImmediateOperand::Word(_) => panic!("Cannot add Word to Byte Memory Index"),
},
Operand::Word(idx_word) => match val {
Operand::Word(value) => {
ImmediateOperand::Word(idx_word) => match val {
ImmediateOperand::Word(value) => {
let byte1 = idx_word / 2;
let byte2 = idx_word / 2 + 1;
let [low, high]: [u8; 2] = value.to_le_bytes();
@@ -36,7 +36,7 @@ impl Memory {
self.memory[byte1 as usize] = low;
self.memory[byte1 as usize] = high;
}
Operand::Byte(value) => {
ImmediateOperand::Byte(value) => {
self.memory[(idx_word * 2) as usize] = value;
}
},
@@ -44,17 +44,21 @@ impl Memory {
}
/// Read into memory with a [`MemoryIndex`] as index.
pub fn read(&self, regs: &crate::interpreter::register::Register, idx: MemoryIndex) -> Operand {
pub fn read(
&self,
regs: &crate::interpreter::register::Register,
idx: MemoryIndex,
) -> ImmediateOperand {
match Memory::calc_memidx(regs, idx) {
Operand::Byte(byte) => {
ImmediateOperand::Byte(byte) => {
log::debug!("Reading byte {byte:#04x} from memory");
Operand::Byte(self.memory[byte as usize])
ImmediateOperand::Byte(self.memory[byte as usize])
}
Operand::Word(word) => {
ImmediateOperand::Word(word) => {
let byte1 = word / 2;
let byte2 = word / 2 + 1;
log::debug!("Reading bytes {byte1:#04x} and {byte2:#04x} from memory");
Operand::Word(Word::from_le_bytes([
ImmediateOperand::Word(Word::from_le_bytes([
self.memory[byte1 as usize],
self.memory[byte2 as usize],
]))
@@ -63,9 +67,12 @@ impl Memory {
}
/// Calculate the absolute Memory Index from a [`MemoryIndex`] struct.
fn calc_memidx(regs: &crate::interpreter::register::Register, idx: MemoryIndex) -> Operand {
let mut base = Operand::Word(0);
let mut index = Operand::Word(0);
fn calc_memidx(
regs: &crate::interpreter::register::Register,
idx: MemoryIndex,
) -> ImmediateOperand {
let mut base = ImmediateOperand::Word(0);
let mut index = ImmediateOperand::Word(0);
let mut disp = Displacement::IWord(0);
if let Some(base_reg) = idx.base {

46
src/interpreter/register.rs
View File

@@ -1,8 +1,6 @@
use crate::operands::{Byte, Operand, Word};
use crate::operands::{Byte, ImmediateOperand, Word};
use core::fmt;
use super::flags::Flags;
#[derive(Debug, Clone, Copy)]
pub struct Register {
pub ax: AX,
@@ -30,31 +28,31 @@ impl Register {
}
/// Read value from a [`crate::register::Register`].
pub fn read(&self, reg: crate::register::Register) -> Operand {
pub fn read(&self, reg: crate::register::Register) -> ImmediateOperand {
match reg {
crate::register::Register::AX => Operand::Word(self.ax.read()),
crate::register::Register::BX => Operand::Word(self.bx.read()),
crate::register::Register::CX => Operand::Word(self.cx.read()),
crate::register::Register::DX => Operand::Word(self.dx.read()),
crate::register::Register::AH => Operand::Byte(self.ax.upper),
crate::register::Register::AL => Operand::Byte(self.ax.lower),
crate::register::Register::BH => Operand::Byte(self.bx.upper),
crate::register::Register::BL => Operand::Byte(self.bx.lower),
crate::register::Register::CH => Operand::Byte(self.cx.upper),
crate::register::Register::CL => Operand::Byte(self.cx.lower),
crate::register::Register::DH => Operand::Byte(self.dx.upper),
crate::register::Register::DL => Operand::Byte(self.dx.lower),
crate::register::Register::DI => Operand::Word(self.di),
crate::register::Register::SI => Operand::Word(self.si),
crate::register::Register::BP => Operand::Word(self.bp),
crate::register::Register::SP => Operand::Word(self.sp),
crate::register::Register::AX => ImmediateOperand::Word(self.ax.read()),
crate::register::Register::BX => ImmediateOperand::Word(self.bx.read()),
crate::register::Register::CX => ImmediateOperand::Word(self.cx.read()),
crate::register::Register::DX => ImmediateOperand::Word(self.dx.read()),
crate::register::Register::AH => ImmediateOperand::Byte(self.ax.upper),
crate::register::Register::AL => ImmediateOperand::Byte(self.ax.lower),
crate::register::Register::BH => ImmediateOperand::Byte(self.bx.upper),
crate::register::Register::BL => ImmediateOperand::Byte(self.bx.lower),
crate::register::Register::CH => ImmediateOperand::Byte(self.cx.upper),
crate::register::Register::CL => ImmediateOperand::Byte(self.cx.lower),
crate::register::Register::DH => ImmediateOperand::Byte(self.dx.upper),
crate::register::Register::DL => ImmediateOperand::Byte(self.dx.lower),
crate::register::Register::DI => ImmediateOperand::Word(self.di),
crate::register::Register::SI => ImmediateOperand::Word(self.si),
crate::register::Register::BP => ImmediateOperand::Word(self.bp),
crate::register::Register::SP => ImmediateOperand::Word(self.sp),
}
}
/// Write an [`Operand`] to a [`crate::register::Register`].
pub fn write(&mut self, reg: crate::register::Register, op: Operand) {
/// Write an [`ImmediateOperand`] to a [`crate::register::Register`].
pub fn write(&mut self, reg: crate::register::Register, op: ImmediateOperand) {
match op {
Operand::Byte(byte) => match reg {
ImmediateOperand::Byte(byte) => match reg {
crate::register::Register::AX => self.ax.lower = byte,
crate::register::Register::BX => self.bx.lower = byte,
crate::register::Register::CX => self.cx.lower = byte,
@@ -72,7 +70,7 @@ impl Register {
crate::register::Register::BP => self.bp = Word::from_le_bytes([0x0, byte]),
crate::register::Register::SP => self.sp = Word::from_le_bytes([0x0, byte]),
},
Operand::Word(word) => {
ImmediateOperand::Word(word) => {
match reg {
crate::register::Register::AX => self.ax.write(word),
crate::register::Register::BX => self.bx.write(word),