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.rsindex 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 instructionself.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.rsindex 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.rsindex 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.rsindex 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());}}