Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

optimized bus access

Layle676fda771243
diff --git a/crates/gekko/src/gekko.rs b/crates/gekko/src/gekko.rs
index f09a73b..eb10bcd 100644
--- a/crates/gekko/src/gekko.rs
+++ b/crates/gekko/src/gekko.rs
@@ -156,7 +156,7 @@ impl Gekko {
// Fetch and execute next instruction
self.cpu.cia = self.cpu.pc;
self.cpu.nia = self.cpu.cia.wrapping_add(4);
- let instr = Instruction(self.mmio.virt_read_u32(self.cpu.cia));
+ let instr = Instruction(self.mmio.fetch_instruction(self.cpu.cia));
cpu::lut::dispatch(self, instr);
self.scheduler.cycles += 1;
@@ -197,7 +197,7 @@ impl Gekko {
let count = ((end - start) / 4 + 1) as usize;
let mut buf = [0u32; IDLE_LOOP_MAX_INSTRS];
for i in 0..count.min(buf.len()) {
- buf[i] = self.mmio.virt_read_u32(start + (i as u32) * 4);
+ buf[i] = self.mmio.fetch_instruction(start + (i as u32) * 4);
}
crate::idle::validate_polling_loop(&buf[..count.min(buf.len())], &self.cpu.gprs)
}
diff --git a/crates/gekko/src/mmio.rs b/crates/gekko/src/mmio.rs
index 364945f..97915ba 100644
--- a/crates/gekko/src/mmio.rs
+++ b/crates/gekko/src/mmio.rs
@@ -28,7 +28,7 @@ impl Mmio {
/// Resolve a physical address to a `(backing_slice, offset)` pair
/// This is the one place that maps physical addresses to memory regions
- #[inline]
+ #[inline(always)]
fn resolve(&self, phys: u32) -> (&[u8], usize) {
match phys {
RAM_BASE..=RAM_END => (&self.ram, phys as usize),
@@ -48,7 +48,7 @@ impl Mmio {
/// Resolve a physical address to a `(backing_slice, offset)` pair
/// This is the one place that maps physical addresses to memory regions
/// Returns a mutable slice for write operations
- #[inline]
+ #[inline(always)]
fn resolve_mut(&mut self, phys: u32) -> (&mut [u8], usize) {
match phys {
RAM_BASE..=RAM_END => (&mut self.ram, phys as usize),
@@ -65,7 +65,7 @@ impl Mmio {
}
}
- #[inline]
+ #[inline(always)]
pub fn phys_read_u8(&self, addr: u32) -> u8 {
let (slice, offset) = self.resolve(addr);
tracing::trace!(
@@ -76,10 +76,10 @@ impl Mmio {
slice[offset]
}
- #[inline]
+ #[inline(always)]
pub fn phys_read_u16(&self, addr: u32) -> u16 {
let (slice, offset) = self.resolve(addr);
- let value = u16::from_be_bytes(slice[offset..offset + 2].try_into().unwrap());
+ let value = unsafe { Self::read_be_u16_unchecked(slice.as_ptr().add(offset)) };
tracing::trace!(
phys_addr = format!("{:08X}", addr),
value = format!("{:04X}", value),
@@ -88,10 +88,10 @@ impl Mmio {
value
}
- #[inline]
+ #[inline(always)]
pub fn phys_read_u32(&self, addr: u32) -> u32 {
let (slice, offset) = self.resolve(addr);
- let value = u32::from_be_bytes(slice[offset..offset + 4].try_into().unwrap());
+ let value = unsafe { Self::read_be_u32_unchecked(slice.as_ptr().add(offset)) };
tracing::trace!(
phys_addr = format!("{:08X}", addr),
value = format!("{:08X}", value),
@@ -100,7 +100,7 @@ impl Mmio {
value
}
- #[inline]
+ #[inline(always)]
pub fn phys_write_u8(&mut self, addr: u32, value: u8) {
let (slice, offset) = self.resolve_mut(addr);
tracing::trace!(
@@ -111,69 +111,67 @@ impl Mmio {
slice[offset] = value;
}
- #[inline]
+ #[inline(always)]
pub fn phys_write_u16(&mut self, addr: u32, value: u16) {
let (slice, offset) = self.resolve_mut(addr);
- let bytes = value.to_be_bytes();
tracing::trace!(
phys_addr = format!("{:08X}", addr),
value = format!("{:04X}", value),
"write_u16"
);
- slice[offset..offset + 2].copy_from_slice(&bytes);
+ unsafe { Self::write_be_u16_unchecked(slice.as_mut_ptr().add(offset), value) };
}
- #[inline]
+ #[inline(always)]
pub fn phys_write_u32(&mut self, addr: u32, value: u32) {
let (slice, offset) = self.resolve_mut(addr);
- let bytes = value.to_be_bytes();
tracing::trace!(
phys_addr = format!("{:08X}", addr),
value = format!("{:08X}", value),
"write_u32"
);
- slice[offset..offset + 4].copy_from_slice(&bytes);
+ unsafe { Self::write_be_u32_unchecked(slice.as_mut_ptr().add(offset), value) };
}
- #[inline]
+ #[inline(always)]
pub fn virt_read_u8(&self, addr: u32) -> u8 {
self.phys_read_u8(Self::virt_to_phys(addr))
}
- #[inline]
+ #[inline(always)]
pub fn virt_read_u16(&self, addr: u32) -> u16 {
self.phys_read_u16(Self::virt_to_phys(addr))
}
- #[inline]
+ #[inline(always)]
pub fn virt_read_u32(&self, addr: u32) -> u32 {
self.phys_read_u32(Self::virt_to_phys(addr))
}
- #[inline]
+ #[inline(always)]
pub fn virt_write_u8(&mut self, addr: u32, value: u8) {
self.phys_write_u8(Self::virt_to_phys(addr), value);
}
- #[inline]
+ #[inline(always)]
pub fn virt_write_u16(&mut self, addr: u32, value: u16) {
self.phys_write_u16(Self::virt_to_phys(addr), value);
}
- #[inline]
+ #[inline(always)]
pub fn virt_write_u32(&mut self, addr: u32, value: u32) {
self.phys_write_u32(Self::virt_to_phys(addr), value);
}
/// Return a slice of physical memory starting at `addr` with length `len`
/// Useful for bulk reads (e.g. disassembler)
- #[inline]
+ #[inline(always)]
pub fn phys_slice(&self, addr: u32, len: usize) -> &[u8] {
let (slice, offset) = self.resolve(addr);
&slice[offset..offset + len]
}
- #[inline]
+ #[inline(always)]
pub fn phys_slice_mut(&mut self, addr: u32, len: usize) -> &mut [u8] {
let (slice, offset) = self.resolve_mut(addr);
&mut slice[offset..offset + len]
@@ -181,12 +179,13 @@ impl Mmio {
/// Return a slice of virtual memory starting at `addr` with length `len`
/// This is just a thin wrapper around `phys_slice` that applies virtual-to-physical translation
- #[inline]
+ #[inline(always)]
pub fn virt_slice(&self, addr: u32, len: usize) -> &[u8] {
self.phys_slice(Self::virt_to_phys(addr), len)
}
/// Read a typed MMIO register from its physical address
+ #[inline(always)]
pub fn read_register<T: traits::MmioRegister>(&self) -> T {
let raw = match T::SIZE {
1 => self.phys_read_u8(T::ADDR) as u32,
@@ -198,6 +197,7 @@ impl Mmio {
}
/// Write a typed MMIO register to its physical address
+ #[inline(always)]
pub fn write_register<T: traits::MmioRegister>(&mut self, value: T) {
let raw = value.to_raw();
match T::SIZE {
@@ -209,8 +209,127 @@ impl Mmio {
}
// Simple virtual to physical translation that ignores caching and other MMIO features
- #[inline]
+ #[inline(always)]
pub const fn virt_to_phys(addr: u32) -> u32 {
addr & 0x3FFFFFFF
}
+
+ #[inline(always)]
+ pub fn fetch_instruction(&self, addr: u32) -> u32 {
+ let phys = Self::virt_to_phys(addr);
+ if phys <= RAM_END - 3 {
+ self.ram_read_u32(phys)
+ } else {
+ self.phys_read_u32(phys)
+ }
+ }
+
+ #[inline(always)]
+ pub fn ram_read_u8(&self, phys: u32) -> u8 {
+ let value = self.ram[phys as usize];
+ tracing::trace!(
+ phys_addr = format!("{:08X}", phys),
+ value = format!("{:02X}", value),
+ "read_u8"
+ );
+ value
+ }
+
+ #[inline(always)]
+ pub fn ram_read_u16(&self, phys: u32) -> u16 {
+ debug_assert!(phys <= RAM_END - 1);
+ let value = unsafe { Self::read_be_u16_unchecked(self.ram.as_ptr().add(phys as usize)) };
+ tracing::trace!(
+ phys_addr = format!("{:08X}", phys),
+ value = format!("{:04X}", value),
+ "read_u16"
+ );
+ value
+ }
+
+ #[inline(always)]
+ pub fn ram_read_u32(&self, phys: u32) -> u32 {
+ debug_assert!(phys <= RAM_END - 3);
+ let value = unsafe { Self::read_be_u32_unchecked(self.ram.as_ptr().add(phys as usize)) };
+ tracing::trace!(
+ phys_addr = format!("{:08X}", phys),
+ value = format!("{:08X}", value),
+ "read_u32"
+ );
+ value
+ }
+
+ #[inline(always)]
+ pub fn ram_read_u64(&self, phys: u32) -> u64 {
+ debug_assert!(phys <= RAM_END - 7);
+ unsafe { Self::read_be_u64_unchecked(self.ram.as_ptr().add(phys as usize)) }
+ }
+
+ #[inline(always)]
+ pub fn ram_write_u8(&mut self, phys: u32, value: u8) {
+ tracing::trace!(
+ phys_addr = format!("{:08X}", phys),
+ value = format!("{:02X}", value),
+ "write_u8"
+ );
+ self.ram[phys as usize] = value;
+ }
+
+ #[inline(always)]
+ pub fn ram_write_u16(&mut self, phys: u32, value: u16) {
+ debug_assert!(phys <= RAM_END - 1);
+ tracing::trace!(
+ phys_addr = format!("{:08X}", phys),
+ value = format!("{:04X}", value),
+ "write_u16"
+ );
+ unsafe { Self::write_be_u16_unchecked(self.ram.as_mut_ptr().add(phys as usize), value) };
+ }
+
+ #[inline(always)]
+ pub fn ram_write_u32(&mut self, phys: u32, value: u32) {
+ debug_assert!(phys <= RAM_END - 3);
+ tracing::trace!(
+ phys_addr = format!("{:08X}", phys),
+ value = format!("{:08X}", value),
+ "write_u32"
+ );
+ unsafe { Self::write_be_u32_unchecked(self.ram.as_mut_ptr().add(phys as usize), value) };
+ }
+
+ #[inline(always)]
+ pub fn ram_write_u64(&mut self, phys: u32, value: u64) {
+ debug_assert!(phys <= RAM_END - 7);
+ unsafe { Self::write_be_u64_unchecked(self.ram.as_mut_ptr().add(phys as usize), value) };
+ }
+
+ #[inline(always)]
+ unsafe fn read_be_u16_unchecked(ptr: *const u8) -> u16 {
+ u16::from_be(unsafe { std::ptr::read_unaligned(ptr.cast::<u16>()) })
+ }
+
+ #[inline(always)]
+ unsafe fn read_be_u32_unchecked(ptr: *const u8) -> u32 {
+ u32::from_be(unsafe { std::ptr::read_unaligned(ptr.cast::<u32>()) })
+ }
+
+ #[inline(always)]
+ unsafe fn read_be_u64_unchecked(ptr: *const u8) -> u64 {
+ u64::from_be(unsafe { std::ptr::read_unaligned(ptr.cast::<u64>()) })
+ }
+
+ #[inline(always)]
+ unsafe fn write_be_u16_unchecked(ptr: *mut u8, value: u16) {
+ unsafe { std::ptr::write_unaligned(ptr.cast::<u16>(), value.to_be()) };
+ }
+
+ #[inline(always)]
+ unsafe fn write_be_u32_unchecked(ptr: *mut u8, value: u32) {
+ unsafe { std::ptr::write_unaligned(ptr.cast::<u32>(), value.to_be()) };
+ }
+
+ #[inline(always)]
+ unsafe fn write_be_u64_unchecked(ptr: *mut u8, value: u64) {
+ unsafe { std::ptr::write_unaligned(ptr.cast::<u64>(), value.to_be()) };
+ }
}
diff --git a/crates/gekko/src/mmio/bus.rs b/crates/gekko/src/mmio/bus.rs
index 7bdb075..c4fc868 100644
--- a/crates/gekko/src/mmio/bus.rs
+++ b/crates/gekko/src/mmio/bus.rs
@@ -4,13 +4,14 @@ use crate::{
Mmio,
constants::{
AI_BASE, AI_END, CP_BASE, CP_END, DI_BASE, DI_END, DSP_BASE, DSP_END, EXI_BASE, EXI_END, GX_FIFO_BASE,
- GX_FIFO_END, IPL_BASE, IPL_END, MI_BASE, MI_END, PE_BASE, PE_END, PI_BASE, PI_END, SI_BASE, SI_END,
- VI_BASE, VI_END,
+ GX_FIFO_END, IPL_BASE, IPL_END, MI_BASE, MI_END, PE_BASE, PE_END, PI_BASE, PI_END, RAM_BASE, RAM_END,
+ SI_BASE, SI_END, VI_BASE, VI_END,
},
},
};
enum BusTarget {
+ Ram,
Cp,
Vi,
Pe,
@@ -29,6 +30,7 @@ enum BusTarget {
#[rustfmt::skip]
fn route(phys: u32) -> (BusTarget, u32) {
match phys {
+ RAM_BASE..=RAM_END => (BusTarget::Ram, phys),
CP_BASE..=CP_END => (BusTarget::Cp, phys - CP_BASE),
PE_BASE..=PE_END => (BusTarget::Pe, phys - PE_BASE),
VI_BASE..=VI_END => (BusTarget::Vi, phys - VI_BASE),
@@ -50,6 +52,7 @@ impl Gekko {
pub fn read_u8(&mut self, addr: u32) -> u8 {
let (target, offset) = route(Mmio::virt_to_phys(addr));
match target {
+ BusTarget::Ram => self.mmio.ram_read_u8(offset),
BusTarget::Cp => self.cp.mmio_read_u8(offset),
BusTarget::Vi => {
if offset == 0x2E {
@@ -86,6 +89,7 @@ impl Gekko {
pub fn read_u16(&mut self, addr: u32) -> u16 {
let (target, offset) = route(Mmio::virt_to_phys(addr));
match target {
+ BusTarget::Ram => self.mmio.ram_read_u16(offset),
BusTarget::Cp => self.cp.mmio_read_u16(offset),
BusTarget::Vi => {
if offset == 0x2E {
@@ -119,6 +123,7 @@ impl Gekko {
pub fn read_u32(&mut self, addr: u32) -> u32 {
let (target, offset) = route(Mmio::virt_to_phys(addr));
match target {
+ BusTarget::Ram => self.mmio.ram_read_u32(offset),
BusTarget::Cp => self.cp.mmio_read_u32(offset),
BusTarget::Vi => {
if offset == 0x2C {
@@ -154,6 +159,7 @@ impl Gekko {
pub fn write_u8(&mut self, addr: u32, val: u8) {
let (target, offset) = route(Mmio::virt_to_phys(addr));
match target {
+ BusTarget::Ram => self.mmio.ram_write_u8(offset, val),
BusTarget::Cp => {
self.cp.mmio_write_u8(offset, val);
self.check_cp_interrupts();
@@ -214,6 +220,7 @@ impl Gekko {
pub fn write_u16(&mut self, addr: u32, val: u16) {
let (target, offset) = route(Mmio::virt_to_phys(addr));
match target {
+ BusTarget::Ram => self.mmio.ram_write_u16(offset, val),
BusTarget::Cp => {
self.cp.mmio_write_u16(offset, val);
self.check_cp_interrupts();
@@ -275,6 +282,7 @@ impl Gekko {
pub fn write_u32(&mut self, addr: u32, val: u32) {
let (target, offset) = route(Mmio::virt_to_phys(addr));
match target {
+ BusTarget::Ram => self.mmio.ram_write_u32(offset, val),
BusTarget::Cp => {
self.cp.mmio_write_u32(offset, val);
self.check_cp_interrupts();
@@ -331,4 +339,64 @@ impl Gekko {
BusTarget::Fallback => self.mmio.phys_write_u32(offset, val),
}
}
+
+ #[inline(always)]
+ pub fn load_u8_data(&mut self, addr: u32) -> u8 {
+ let phys = Mmio::virt_to_phys(addr);
+ if phys <= RAM_END {
+ self.mmio.ram_read_u8(phys)
+ } else {
+ self.read_u8(addr)
+ }
+ }
+
+ #[inline(always)]
+ pub fn load_u16_data(&mut self, addr: u32) -> u16 {
+ let phys = Mmio::virt_to_phys(addr);
+ if phys <= RAM_END - 1 {
+ self.mmio.ram_read_u16(phys)
+ } else {
+ self.read_u16(addr)
+ }
+ }
+
+ #[inline(always)]
+ pub fn load_u32_data(&mut self, addr: u32) -> u32 {
+ let phys = Mmio::virt_to_phys(addr);
+ if phys <= RAM_END - 3 {
+ self.mmio.ram_read_u32(phys)
+ } else {
+ self.read_u32(addr)
+ }
+ }
+
+ #[inline(always)]
+ pub fn store_u8_data(&mut self, addr: u32, val: u8) {
+ let phys = Mmio::virt_to_phys(addr);
+ if phys <= RAM_END {
+ self.mmio.ram_write_u8(phys, val);
+ } else {
+ self.write_u8(addr, val);
+ }
+ }
+
+ #[inline(always)]
+ pub fn store_u16_data(&mut self, addr: u32, val: u16) {
+ let phys = Mmio::virt_to_phys(addr);
+ if phys <= RAM_END - 1 {
+ self.mmio.ram_write_u16(phys, val);
+ } else {
+ self.write_u16(addr, val);
+ }
+ }
+
+ #[inline(always)]
+ pub fn store_u32_data(&mut self, addr: u32, val: u32) {
+ let phys = Mmio::virt_to_phys(addr);
+ if phys <= RAM_END - 3 {
+ self.mmio.ram_write_u32(phys, val);
+ } else {
+ self.write_u32(addr, val);
+ }
+ }
}
diff --git a/crates/gekko/src/mmio/fp.rs b/crates/gekko/src/mmio/fp.rs
index d547c4a..ab21fbf 100644
--- a/crates/gekko/src/mmio/fp.rs
+++ b/crates/gekko/src/mmio/fp.rs
@@ -1,31 +1,45 @@
-use crate::gekko::Gekko;
+use crate::{
+ gekko::Gekko,
+ mmio::{Mmio, constants::RAM_END},
+};
impl Gekko {
// Load a 64-bit double from memory
#[inline]
pub fn read_f64(&mut self, addr: u32) -> f64 {
- let hi = self.read_u32(addr) as u64;
- let lo = self.read_u32(addr.wrapping_add(4)) as u64;
+ let phys = Mmio::virt_to_phys(addr);
+ if phys <= RAM_END - 7 {
+ return f64::from_bits(self.mmio.ram_read_u64(phys));
+ }
+
+ let hi = self.load_u32_data(addr) as u64;
+ let lo = self.load_u32_data(addr.wrapping_add(4)) as u64;
f64::from_bits((hi << 32) | lo)
}
/// Store a 64-bit double to memory
#[inline]
pub fn write_f64(&mut self, addr: u32, val: f64) {
+ let phys = Mmio::virt_to_phys(addr);
let bits = val.to_bits();
- self.write_u32(addr, (bits >> 32) as u32);
- self.write_u32(addr.wrapping_add(4), bits as u32);
+ if phys <= RAM_END - 7 {
+ self.mmio.ram_write_u64(phys, bits);
+ return;
+ }
+
+ self.store_u32_data(addr, (bits >> 32) as u32);
+ self.store_u32_data(addr.wrapping_add(4), bits as u32);
}
/// Load a 32-bit float from memory, return as f64
#[inline]
pub fn read_f32(&mut self, addr: u32) -> f64 {
- f32::from_bits(self.read_u32(addr)) as f64
+ f32::from_bits(self.load_u32_data(addr)) as f64
}
/// Store f64 as 32-bit float to memory
#[inline]
pub fn write_f32(&mut self, addr: u32, val: f64) {
- self.write_u32(addr, (val as f32).to_bits());
+ self.store_u32_data(addr, (val as f32).to_bits());
}
}