Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

dsp work, dvd command and clippy stuff

Layle0f98d5476a36
diff --git a/Cargo.toml b/Cargo.toml
index 9769823..dfc0ffa 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -41,20 +41,14 @@ ecolor = { git = "https://github.com/ioncodes/egui.git" }
egui-wgpu = { git = "https://github.com/ioncodes/egui.git" }
egui-winit = { git = "https://github.com/ioncodes/egui.git" }
-[profile.release]
+[profile.release-max]
+inherits = "release"
lto = "fat"
codegen-units = 1
-debug = true
-opt-level = 3
-debug-assertions = false
+debug = false
-[profile.dev]
+[profile.release]
debug = true
-opt-level = 3
-debug-assertions = false
-[profile.fast]
-inherits = "dev"
-debug-assertions = true
+[profile.dev]
opt-level = 3
-lto = false
diff --git a/crates/backend-wgpu/src/render.rs b/crates/backend-wgpu/src/render.rs
index bb0c048..98fb91f 100644
--- a/crates/backend-wgpu/src/render.rs
+++ b/crates/backend-wgpu/src/render.rs
@@ -39,22 +39,21 @@ impl GxRenderer {
for dc in &commands.commands {
for desc in dc.textures.iter().flatten() {
let key = (desc.ram_addr, desc.width, desc.height, desc.format);
- if !self.texture_cache.contains_key(&key) {
+ self.texture_cache.entry(key).or_insert_with(|| {
let (tex, view) = texture::upload_texture(device, queue, ram, desc);
- self.texture_cache.insert(key, (tex, view));
- }
+ (tex, view)
+ });
let sampler_key = (desc.wrap_s, desc.wrap_t, desc.mag_filter, desc.min_filter);
- if !self.sampler_cache.contains_key(&sampler_key) {
- let s = device.create_sampler(&wgpu::SamplerDescriptor {
+ self.sampler_cache.entry(sampler_key).or_insert_with(|| {
+ device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("gx_sampler"),
address_mode_u: helpers::map_wrap_mode(sampler_key.0),
address_mode_v: helpers::map_wrap_mode(sampler_key.1),
mag_filter: helpers::map_mag_filter(sampler_key.2),
min_filter: helpers::map_min_filter(sampler_key.3),
..Default::default()
- });
- self.sampler_cache.insert(sampler_key, s);
- }
+ })
+ });
}
let pipeline_key = PipelineKey::from_draw_call(dc);
if !self.pipeline_cache.contains_key(&pipeline_key) {
@@ -64,13 +63,12 @@ impl GxRenderer {
}
let fallback_sampler_key = (WrapMode::Clamp, WrapMode::Clamp, MagFilter::Linear, MinFilter::Linear);
- if !self.sampler_cache.contains_key(&fallback_sampler_key) {
- let s = device.create_sampler(&wgpu::SamplerDescriptor {
+ self.sampler_cache.entry(fallback_sampler_key).or_insert_with(|| {
+ device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("gx_sampler_fallback"),
..Default::default()
- });
- self.sampler_cache.insert(fallback_sampler_key, s);
- }
+ })
+ });
}
fn aggregate_draw_data(&mut self, device: &wgpu::Device, commands: &DrawCommands) -> (Vec<u8>, Vec<usize>) {
diff --git a/crates/backend-wgpu/src/texture.rs b/crates/backend-wgpu/src/texture.rs
index a6bbb4b..5f74fd1 100644
--- a/crates/backend-wgpu/src/texture.rs
+++ b/crates/backend-wgpu/src/texture.rs
@@ -96,8 +96,8 @@ fn decode_i4(ram: &[u8], desc: &TextureDescriptor, rgba: &mut [u8], width: usize
const BLOCK_H: usize = 8;
const BLOCK_BYTES: usize = 32;
- let blocks_x = (width + BLOCK_W - 1) / BLOCK_W;
- let blocks_y = (height + BLOCK_H - 1) / BLOCK_H;
+ let blocks_x = width.div_ceil(BLOCK_W);
+ let blocks_y = height.div_ceil(BLOCK_H);
for block_y in 0..blocks_y {
for block_x in 0..blocks_x {
@@ -138,8 +138,8 @@ fn decode_i8(ram: &[u8], desc: &TextureDescriptor, rgba: &mut [u8], width: usize
const BLOCK_H: usize = 4;
const BLOCK_BYTES: usize = 32;
- let blocks_x = (width + BLOCK_W - 1) / BLOCK_W;
- let blocks_y = (height + BLOCK_H - 1) / BLOCK_H;
+ let blocks_x = width.div_ceil(BLOCK_W);
+ let blocks_y = height.div_ceil(BLOCK_H);
for block_y in 0..blocks_y {
for block_x in 0..blocks_x {
@@ -173,8 +173,8 @@ fn decode_ia4(ram: &[u8], desc: &TextureDescriptor, rgba: &mut [u8], width: usiz
const BLOCK_H: usize = 4;
const BLOCK_BYTES: usize = 32;
- let blocks_x = (width + BLOCK_W - 1) / BLOCK_W;
- let blocks_y = (height + BLOCK_H - 1) / BLOCK_H;
+ let blocks_x = width.div_ceil(BLOCK_W);
+ let blocks_y = height.div_ceil(BLOCK_H);
for block_y in 0..blocks_y {
for block_x in 0..blocks_x {
@@ -208,8 +208,8 @@ fn decode_ia8(ram: &[u8], desc: &TextureDescriptor, rgba: &mut [u8], width: usiz
const BLOCK_H: usize = 4;
const BLOCK_BYTES: usize = 32;
- let blocks_x = (width + BLOCK_W - 1) / BLOCK_W;
- let blocks_y = (height + BLOCK_H - 1) / BLOCK_H;
+ let blocks_x = width.div_ceil(BLOCK_W);
+ let blocks_y = height.div_ceil(BLOCK_H);
for block_y in 0..blocks_y {
for block_x in 0..blocks_x {
@@ -242,8 +242,8 @@ fn decode_rgb565(ram: &[u8], desc: &TextureDescriptor, rgba: &mut [u8], width: u
const BLOCK_H: usize = 4;
const BLOCK_BYTES: usize = 32;
- let blocks_x = (width + BLOCK_W - 1) / BLOCK_W;
- let blocks_y = (height + BLOCK_H - 1) / BLOCK_H;
+ let blocks_x = width.div_ceil(BLOCK_W);
+ let blocks_y = height.div_ceil(BLOCK_H);
for block_y in 0..blocks_y {
for block_x in 0..blocks_x {
@@ -275,8 +275,8 @@ fn decode_rgb5a3(ram: &[u8], desc: &TextureDescriptor, rgba: &mut [u8], width: u
const BLOCK_H: usize = 4;
const BLOCK_BYTES: usize = 32;
- let blocks_x = (width + BLOCK_W - 1) / BLOCK_W;
- let blocks_y = (height + BLOCK_H - 1) / BLOCK_H;
+ let blocks_x = width.div_ceil(BLOCK_W);
+ let blocks_y = height.div_ceil(BLOCK_H);
for block_y in 0..blocks_y {
for block_x in 0..blocks_x {
@@ -321,8 +321,8 @@ fn decode_rgba8(ram: &[u8], desc: &TextureDescriptor, rgba: &mut [u8], width: us
const BLOCK_H: usize = 4;
const BLOCK_BYTES: usize = 64;
- let blocks_x = (width + BLOCK_W - 1) / BLOCK_W;
- let blocks_y = (height + BLOCK_H - 1) / BLOCK_H;
+ let blocks_x = width.div_ceil(BLOCK_W);
+ let blocks_y = height.div_ceil(BLOCK_H);
for block_y in 0..blocks_y {
for block_x in 0..blocks_x {
@@ -360,8 +360,8 @@ fn decode_cmpr(ram: &[u8], desc: &TextureDescriptor, rgba: &mut [u8], width: usi
const MACRO_BYTES: usize = 32;
const SUB_BLOCK_BYTES: usize = 8;
- let blocks_x = (width + MACRO_W - 1) / MACRO_W;
- let blocks_y = (height + MACRO_H - 1) / MACRO_H;
+ let blocks_x = width.div_ceil(MACRO_W);
+ let blocks_y = height.div_ceil(MACRO_H);
for block_y in 0..blocks_y {
for block_x in 0..blocks_x {
diff --git a/crates/dbglib/src/windows/callstack.rs b/crates/dbglib/src/windows/callstack.rs
index 769e0e3..05a4c58 100644
--- a/crates/dbglib/src/windows/callstack.rs
+++ b/crates/dbglib/src/windows/callstack.rs
@@ -29,10 +29,10 @@ pub fn walk_callstack(cpu: &Cpu, mmio: &Mmio, symbols: Option<&SymbolTable>) ->
let mut frames = Vec::new();
let resolve = |addr: u32| -> (Option<String>, u32) {
- if let Some(syms) = symbols {
- if let Some(sym) = syms.lookup(addr) {
- return (Some(sym.name.clone()), addr - sym.addr);
- }
+ if let Some(syms) = symbols
+ && let Some(sym) = syms.lookup(addr)
+ {
+ return (Some(sym.name.clone()), addr - sym.addr);
}
(None, 0)
};
diff --git a/crates/dbglib/src/windows/cpu.rs b/crates/dbglib/src/windows/cpu.rs
index 4e7fc3f..039a5c0 100644
--- a/crates/dbglib/src/windows/cpu.rs
+++ b/crates/dbglib/src/windows/cpu.rs
@@ -82,18 +82,18 @@ pub fn show_cpu(ctx: &Context, open: &mut bool, cpu: &Cpu, mmio: &Mmio, symbols:
let mut addr = start;
while addr <= end {
// Show function label if this address is a function entry
- if let Some(sym) = symbols.and_then(|s| s.lookup_exact(addr)) {
- if sym.kind == image::symbols::SymbolKind::Func {
- ui.label("");
- ui.label("");
- ui.label("");
- ui.label(
- RichText::new(format!("{}:", sym.name))
- .monospace()
- .color(Color32::from_rgb(220, 180, 80)),
- );
- ui.end_row();
- }
+ if let Some(sym) = symbols.and_then(|s| s.lookup_exact(addr))
+ && sym.kind == image::symbols::SymbolKind::Func
+ {
+ ui.label("");
+ ui.label("");
+ ui.label("");
+ ui.label(
+ RichText::new(format!("{}:", sym.name))
+ .monospace()
+ .color(Color32::from_rgb(220, 180, 80)),
+ );
+ ui.end_row();
}
let raw = mmio.virt_read_u32(addr);
diff --git a/crates/debugger/src/render.rs b/crates/debugger/src/render.rs
index 0695bae..02311d9 100644
--- a/crates/debugger/src/render.rs
+++ b/crates/debugger/src/render.rs
@@ -185,10 +185,10 @@ impl RenderState {
}
// Drain Lua log messages from the script host
- if debugger_ui.show_lua {
- if let Some(ref mut host) = emulator.hook_host {
- debugger_ui.lua_log.extend(host.drain_logs());
- }
+ if debugger_ui.show_lua
+ && let Some(ref mut host) = emulator.hook_host
+ {
+ debugger_ui.lua_log.extend(host.drain_logs());
}
// Load a new Lua script if requested
diff --git a/crates/dspemu/src/main.rs b/crates/dspemu/src/main.rs
index 73e0523..bc5000a 100644
--- a/crates/dspemu/src/main.rs
+++ b/crates/dspemu/src/main.rs
@@ -84,18 +84,18 @@ fn main() {
break;
}
- if let Some(max) = args.max_steps {
- if steps >= max {
- eprintln!("reached max steps ({max}) at PC={:04X}", emu.dsp.registers.pc);
- break;
- }
+ if let Some(max) = args.max_steps
+ && steps >= max
+ {
+ eprintln!("reached max steps ({max}) at PC={:04X}", emu.dsp.registers.pc);
+ break;
}
- if let Some(until) = args.until {
- if emu.dsp.registers.pc == until {
- eprintln!("reached target PC={until:04X} after {steps} steps");
- break;
- }
+ if let Some(until) = args.until
+ && emu.dsp.registers.pc == until
+ {
+ eprintln!("reached target PC={until:04X} after {steps} steps");
+ break;
}
let pc = emu.dsp.registers.pc;
diff --git a/crates/gecko/src/dvd.rs b/crates/gecko/src/dvd.rs
index e90df2c..f1dbac5 100644
--- a/crates/gecko/src/dvd.rs
+++ b/crates/gecko/src/dvd.rs
@@ -12,6 +12,7 @@ const DICMDBUF2: u32 = DI_BASE + 0x10;
const DIIMMBUF: u32 = DI_BASE + 0x20;
pub enum Command {
+ DriveInfo,
ReadDiskId,
ReadSectorData,
AudioToggle(bool),
@@ -23,6 +24,7 @@ pub struct DvdInterface {
pub dma_address: regs::DiDmaAddressRegister,
pub dma_length: regs::DiDmaLengthRegister,
pub control: regs::DiControlRegister,
+ pub config: regs::DiConfigurationRegister,
pub cmdbuf0: u32,
pub cmdbuf1: u32,
pub cmdbuf2: u32,
@@ -39,6 +41,7 @@ impl DvdInterface {
dma_address: regs::DiDmaAddressRegister::from_raw(0),
dma_length: regs::DiDmaLengthRegister::from_raw(0),
control: regs::DiControlRegister::from_raw(0),
+ config: regs::DiConfigurationRegister::default(),
cmdbuf0: 0,
cmdbuf1: 0,
cmdbuf2: 0,
@@ -62,6 +65,7 @@ impl DvdInterface {
let sub2 = self.cmdbuf0 & 0xFFFF;
match (cmd, sub1, sub2) {
+ (0x12, 0x00, 0x0000) => Some(Command::DriveInfo),
(0xA8, _, 0x0000) => Some(Command::ReadSectorData),
(0xA8, _, 0x0040) => Some(Command::ReadDiskId),
(0xE4, 0x00, _) => Some(Command::AudioToggle(false)),
@@ -85,6 +89,11 @@ impl GameCube {
#[inline(always)]
fn process_dvd_command(&mut self, cmd: Command, dvd: &image::dvd::Dvd) {
match cmd {
+ Command::DriveInfo => {
+ let dst = self.di.dma_address.address();
+ let buffer = self.mmio.phys_slice_mut(dst, 0x20);
+ buffer.copy_from_slice(&[0x69; 0x20]); // TODO: Drive Info?
+ }
Command::ReadSectorData => {
let src = self.di.cmdbuf1 << 2;
let dst = self.di.dma_address.address();
diff --git a/crates/gecko/src/dvd/regs.rs b/crates/gecko/src/dvd/regs.rs
index a6d9119..66a1f30 100644
--- a/crates/gecko/src/dvd/regs.rs
+++ b/crates/gecko/src/dvd/regs.rs
@@ -1,7 +1,6 @@
-use chapa::BitEnum;
-
use super::DvdInterface;
use crate::mmio::traits::MmioAccess;
+use chapa::BitEnum;
// 0xCC006000 4 R/W DISR - DI Status Register
@@ -173,3 +172,16 @@ impl MmioAccess<DvdInterface> for DiControlRegister {
}
}
}
+
+crate::mmio_register! {
+ DiConfigurationRegister: u32 @ 0xCC006024 {
+ #[bits(0, readonly)]
+ pub config: bool
+ }
+}
+
+impl Default for DiConfigurationRegister {
+ fn default() -> Self {
+ DiConfigurationRegister::from_raw(0b1)
+ }
+}
diff --git a/crates/gecko/src/flipper/dsp.rs b/crates/gecko/src/flipper/dsp.rs
index ab16389..572ee0a 100644
--- a/crates/gecko/src/flipper/dsp.rs
+++ b/crates/gecko/src/flipper/dsp.rs
@@ -208,9 +208,8 @@ impl GameCube {
lut::dispatch_gc_dsp_ext(self, ext);
}
- // Check if we've reached the end of a loop stack
- let is_end_of_loop = self.dsp.registers.nia == self.dsp.registers.loop_addr.top();
- if !self.dsp.registers.loop_addr.is_empty() && is_end_of_loop {
+ // Check if we've reached the end of a loop
+ if !self.dsp.registers.loop_addr.is_empty() && self.dsp.registers.nia == self.dsp.registers.loop_addr.top() {
let counter = self.dsp.registers.loop_counter.top().wrapping_sub(1);
if counter != 0 {
self.dsp.registers.loop_counter.set_top(counter);
diff --git a/crates/gecko/src/flipper/dsp/core.rs b/crates/gecko/src/flipper/dsp/core.rs
index 5003da1..cb9b9a6 100644
--- a/crates/gecko/src/flipper/dsp/core.rs
+++ b/crates/gecko/src/flipper/dsp/core.rs
@@ -68,6 +68,74 @@ pub struct Registers {
}
impl Registers {
+ /// Increment address register by 1 with WR wrapping.
+ #[inline(always)]
+ pub fn increment_ar(&self, reg: usize) -> u16 {
+ let ar = self.ar[reg] as u32;
+ let wr = self.wr[reg] as u32;
+ let nar = ar.wrapping_add(1);
+ if (nar ^ ar) > ((wr | 1) << 1) {
+ nar.wrapping_sub(wr + 1) as u16
+ } else {
+ nar as u16
+ }
+ }
+
+ /// Decrement address register by 1 with WR wrapping.
+ #[inline(always)]
+ pub fn decrement_ar(&self, reg: usize) -> u16 {
+ let ar = self.ar[reg] as u32;
+ let wr = self.wr[reg] as u32;
+ let nar = ar.wrapping_add(wr);
+ if ((nar ^ ar) & ((wr | 1) << 1)) > wr {
+ nar.wrapping_sub(wr + 1) as u16
+ } else {
+ nar as u16
+ }
+ }
+
+ /// Decrease address register by signed IX with WR wrapping (ar -= ix).
+ #[inline(always)]
+ pub fn decrease_ar_ix(&self, reg: usize, ix: i16) -> u16 {
+ let ar = self.ar[reg] as u32;
+ let wr = self.wr[reg] as u32;
+ let mx = (wr | 1) << 1;
+ let nar = ar.wrapping_sub(ix as i32 as u32);
+ let dar = (nar ^ ar ^ !(ix as i32) as u32) & mx;
+ if (ix as u32) > 0xFFFF8000 {
+ if dar > wr {
+ nar.wrapping_sub(wr + 1) as u16
+ } else {
+ nar as u16
+ }
+ } else if (((nar.wrapping_add(wr + 1)) ^ nar) & dar) <= wr {
+ nar.wrapping_add(wr + 1) as u16
+ } else {
+ nar as u16
+ }
+ }
+
+ /// Increase address register by signed IX with WR wrapping.
+ #[inline(always)]
+ pub fn increase_ar(&self, reg: usize, ix: i16) -> u16 {
+ let ar = self.ar[reg] as u32;
+ let wr = self.wr[reg] as u32;
+ let mx = (wr | 1) << 1;
+ let nar = ar.wrapping_add(ix as i32 as u32);
+ let dar = (nar ^ ar ^ ix as i32 as u32) & mx;
+ if ix >= 0 {
+ if dar > wr {
+ nar.wrapping_sub(wr + 1) as u16
+ } else {
+ nar as u16
+ }
+ } else if (((nar.wrapping_add(wr + 1)) ^ nar) & dar) <= wr {
+ nar.wrapping_add(wr + 1) as u16
+ } else {
+ nar as u16
+ }
+ }
+
/// Get 40-bit accumulator as i64 (sign-extended from bit 39).
#[inline(always)]
pub fn ac(&self, idx: u8) -> i64 {
@@ -93,7 +161,7 @@ impl Registers {
#[inline(always)]
pub fn set_ac(&mut self, idx: u8, val: i64) {
let v = val as u64 & 0xFF_FFFF_FFFF;
- let high = (v >> 32) as u16;
+ let high = (((v >> 32) as u8 as i8) as i16) as u16;
let mid = (v >> 16) as u16;
let low = v as u16;
match idx {
@@ -111,6 +179,22 @@ impl Registers {
}
}
+ /// Update flags for 16-bit logic operations: S, Z from 16-bit result; AS32 from full ac; TB from 16-bit result.
+ #[inline(always)]
+ pub fn update_flags_logic(&mut self, result16: u16, ac_full: i64) {
+ let sign = result16 & 0x8000 != 0;
+ let zero = result16 == 0;
+ let r40 = ac_full as u64 & 0xFF_FFFF_FFFF;
+ let upper9 = (r40 >> 31) & 0x1FF;
+ let above_s32 = upper9 != 0 && upper9 != 0x1FF;
+ let tb = (result16 >> 14) == 0 || (result16 >> 14) == 3;
+
+ self.status.set_s(sign);
+ self.status.set_z(zero);
+ self.status.set_as32(above_s32);
+ self.status.set_tb(tb);
+ }
+
/// Update flags based on a 40-bit accumulator result: TB, S32, S, AZ.
#[inline(always)]
pub fn update_flags_ac(&mut self, result: i64) {
@@ -119,7 +203,7 @@ impl Registers {
let zero = r40 == 0;
let upper9 = (r40 >> 31) & 0x1FF;
let above_s32 = upper9 != 0 && upper9 != 0x1FF;
- let tb = ((r40 >> 39) & 1) == ((r40 >> 38) & 1);
+ let tb = (r40 & 0xC000_0000) == 0 || (r40 & 0xC000_0000) == 0xC000_0000;
self.status.set_s(sign);
self.status.set_z(zero);
@@ -143,7 +227,7 @@ impl Registers {
let overflow = (a_sign == b_sign) && (r_sign != a_sign);
let upper9 = (r40 >> 31) & 0x1FF;
let above_s32 = upper9 != 0 && upper9 != 0x1FF;
- let tb = ((r40 >> 39) & 1) == ((r40 >> 38) & 1);
+ let tb = (r40 & 0xC000_0000) == 0 || (r40 & 0xC000_0000) == 0xC000_0000;
self.status.set_s(sign);
self.status.set_z(zero);
@@ -176,7 +260,7 @@ impl Registers {
let upper9 = (r40 >> 31) & 0x1FF;
let above_s32 = upper9 != 0 && upper9 != 0x1FF;
// Top two bits equal
- let tb = ((r40 >> 39) & 1) == ((r40 >> 38) & 1);
+ let tb = (r40 & 0xC000_0000) == 0 || (r40 & 0xC000_0000) == 0xC000_0000;
self.status.set_s(sign);
self.status.set_z(zero);
@@ -207,10 +291,13 @@ impl Registers {
16 => self.ac0_high,
17 => self.ac1_high,
18 => self.config,
- 19 => self.status.into(),
+ 19 => {
+ let raw: u16 = self.status.into();
+ raw & !0x0100 // bit 8 always reads as 0
+ }
20 => self.product_low,
21 => self.product_mid1,
- 22 => self.product_high,
+ 22 => self.product_high & 0xFF,
23 => self.product_mid2,
24..=25 => self.ax[(index - 24) as usize],
26..=27 => self.axh[(index - 26) as usize],
@@ -236,7 +323,7 @@ impl Registers {
/// return 0x7FFF (positive) or 0x8000 (negative).
#[inline(always)]
fn saturate_ac_mid(&self, high: u16, mid: u16) -> u16 {
- let sign_ext = if mid & 0x8000 != 0 { 0x00FF } else { 0 };
+ let sign_ext = if mid & 0x8000 != 0 { 0xFFFF } else { 0 };
if high != sign_ext {
if high & 0x80 != 0 { 0x8000 } else { 0x7FFF }
} else {
@@ -244,6 +331,35 @@ impl Registers {
}
}
+ /// Get the 40-bit product register value.
+ #[inline(always)]
+ pub fn product(&self) -> i64 {
+ let ph = (self.product_high as u8) as i8 as i64;
+ let pm1 = self.product_mid1 as i64;
+ let pm2 = self.product_mid2 as i64;
+ let pl = self.product_low as i64;
+ (ph << 32) + ((pm1 + pm2) << 16) + pl
+ }
+
+ /// Write a value to the product register.
+ #[inline(always)]
+ pub fn write_product(&mut self, val: i64) {
+ self.product_high = (((val >> 32) as u8 as i8) as i16) as u16;
+ self.product_mid1 = (val >> 16) as u16;
+ self.product_low = val as u16;
+ self.product_mid2 = 0;
+ }
+
+ /// Compute carry and overflow flags from the product register's internal structure.
+ #[inline(always)]
+ pub fn product_flags(&self) -> (bool, bool) {
+ let mid_carry = ((self.product_mid1 as u32 + self.product_mid2 as u32) >> 16) as u16;
+ let ph = self.product_high as u8 as u16;
+ let carry = ph + mid_carry > 0xFF;
+ let overflow = ph == 0x7F && mid_carry != 0;
+ (carry, overflow)
+ }
+
#[inline(always)]
pub fn write<const ALLOW_SIGN_EXTENSION: bool>(&mut self, index: u8, value: u16) {
match index {
@@ -272,14 +388,14 @@ impl Registers {
30 => {
self.ac0_mid = value;
if ALLOW_SIGN_EXTENSION && self.sign_extended() {
- self.ac0_high = if value & 0x8000 != 0 { 0x00FF } else { 0 };
+ self.ac0_high = if value & 0x8000 != 0 { 0xFFFF } else { 0 };
self.ac0_low = 0;
}
}
31 => {
self.ac1_mid = value;
if ALLOW_SIGN_EXTENSION && self.sign_extended() {
- self.ac1_high = if value & 0x8000 != 0 { 0x00FF } else { 0 };
+ self.ac1_high = if value & 0x8000 != 0 { 0xFFFF } else { 0 };
self.ac1_low = 0;
}
}
diff --git a/crates/gecko/src/flipper/dsp/interpreter.rs b/crates/gecko/src/flipper/dsp/interpreter.rs
index fd474d8..ea95751 100644
--- a/crates/gecko/src/flipper/dsp/interpreter.rs
+++ b/crates/gecko/src/flipper/dsp/interpreter.rs
@@ -3,30 +3,13 @@ use crate::flipper::dsp::core::reg;
use crate::flipper::dsp::core::regs::{SignExtensionMode, StatusRegister};
use crate::flipper::dsp::lut::*;
-#[inline(always)]
-fn product(regs: &crate::flipper::dsp::core::Registers) -> i64 {
- let ph = (regs.product_high as u8) as i8 as i64;
- let pm1 = regs.product_mid1 as i64;
- let pm2 = regs.product_mid2 as i64;
- let pl = regs.product_low as i64;
- (ph << 32) + ((pm1 + pm2) << 16) + pl
-}
-
-#[inline(always)]
-fn write_product(regs: &mut crate::flipper::dsp::core::Registers, val: i64) {
- regs.product_high = (val >> 32) as u16;
- regs.product_mid1 = (val >> 16) as u16;
- regs.product_low = val as u16;
- regs.product_mid2 = 0;
-}
-
#[inline(always)]
fn multiply(regs: &mut crate::flipper::dsp::core::Registers, a: i16, b: i16) {
let mut result = a as i32 as i64 * b as i32 as i64;
if !regs.status.am() {
result <<= 1;
}
- write_product(regs, result);
+ regs.write_product(result);
}
/// Compute a * b (with AM shift), then add/sub to current product.
@@ -36,58 +19,97 @@ fn multiply_accumulate<const ADD: bool>(regs: &mut crate::flipper::dsp::core::Re
if !regs.status.am() {
mul_result <<= 1;
}
- let prod = product(regs);
+ let prod = regs.product();
let result = if ADD {
prod.wrapping_add(mul_result)
} else {
prod.wrapping_sub(mul_result)
};
- write_product(regs, result);
+ regs.write_product(result);
+}
+
+/// Apply product carry/overflow to status: set O and OS from product flags.
+#[inline(always)]
+fn apply_product_oc(regs: &mut crate::flipper::dsp::core::Registers, carry: bool, overflow: bool) {
+ regs.status.set_o(overflow);
+ if overflow {
+ regs.status.set_os(true);
+ }
+ regs.status.set_c(carry);
+}
+
+/// Apply combined arithmetic + product carry/overflow.
+/// Preserves OS from before the arithmetic flag update, then sets based on the XORed overflow.
+#[inline(always)]
+fn apply_combined_add_product_oc(regs: &mut crate::flipper::dsp::core::Registers, pc: bool, po: bool, os_before: bool) {
+ regs.status.set_os(os_before);
+ let c = regs.status.c();
+ let o = regs.status.o();
+ regs.status.set_c(c || pc);
+ regs.status.set_o(o ^ po);
+ if regs.status.o() {
+ regs.status.set_os(true);
+ }
}
#[inline(always)]
fn move_prod_to_ac(ctx: &mut crate::gamecube::GameCube, r: u8) {
- let prod = product(&ctx.dsp.registers);
+ let prod = ctx.dsp.registers.product();
+ let (carry, overflow) = ctx.dsp.registers.product_flags();
ctx.dsp.registers.set_ac(r, prod);
ctx.dsp.registers.update_flags_ac(prod);
- ctx.dsp.registers.status.set_o(false);
+ apply_product_oc(&mut ctx.dsp.registers, carry, overflow);
}
#[inline(always)]
fn move_prod_to_ac_zero(ctx: &mut crate::gamecube::GameCube, r: u8) {
- let prod = product(&ctx.dsp.registers) & !0xFFFFi64;
+ let (carry, overflow) = ctx.dsp.registers.product_flags();
+ let raw = ctx.dsp.registers.product();
+ let prod = if raw & 0x8000 != 0 {
+ (raw + 0x10000) & !0xFFFFi64
+ } else {
+ raw & !0xFFFFi64
+ };
ctx.dsp.registers.set_ac(r, prod);
ctx.dsp.registers.update_flags_ac(prod);
- ctx.dsp.registers.status.set_o(false);
+ apply_product_oc(&mut ctx.dsp.registers, carry, overflow);
}
#[inline(always)]
fn add_prod_to_ac(ctx: &mut crate::gamecube::GameCube, r: u8) {
let a = ctx.dsp.registers.ac(r);
- let b = product(&ctx.dsp.registers);
+ let (pc, po) = ctx.dsp.registers.product_flags();
+ let b = ctx.dsp.registers.product();
let result = a.wrapping_add(b);
+ let os_before = ctx.dsp.registers.status.os();
ctx.dsp.registers.set_ac(r, result);
ctx.dsp.registers.update_flags_add(a, b, result);
+ apply_combined_add_product_oc(&mut ctx.dsp.registers, pc, po, os_before);
}
-/// Dynamic shift based on a 7-bit shift control value.
-/// LOGICAL: right shift is unsigned. !LOGICAL: right shift is arithmetic.
+/// LOGICAL controls whether right shifts are logical.
+/// REVERSED controls direction: when false (ASRN/LSRN), bit6=LEFT/!bit6=RIGHT.
+/// When true (ASRNR/NRX variants), bit6=RIGHT/!bit6=LEFT.
#[inline(always)]
-fn dynamic_shift<const LOGICAL: bool>(regs: &mut crate::flipper::dsp::core::Registers, d: u8, shift_val: i16) {
- if shift_val & 64 != 0 {
- let amount = (shift_val & 63) as u32;
- if amount != 0 {
- let ac = if LOGICAL {
- ((regs.ac(d) as u64 & 0xFF_FFFF_FFFF) >> (64 - amount)) as i64
- } else {
- regs.ac(d) >> (64 - amount)
- };
- regs.set_ac(d, ac as i64);
- }
- } else {
- let amount = (shift_val & 63) as u32;
+fn dynamic_shift<const LOGICAL: bool, const REVERSED: bool>(
+ regs: &mut crate::flipper::dsp::core::Registers,
+ d: u8,
+ shift_val: i16,
+) {
+ let low6 = (shift_val & 63) as u32;
+ let bit6 = shift_val & 64 != 0;
+ let amount = if bit6 { (64 - low6) % 64 } else { low6 };
+ let shift_left = if REVERSED { !bit6 } else { bit6 };
+ if shift_left {
let ac = ((regs.ac(d) as u64 & 0xFF_FFFF_FFFF) << amount) as i64;
regs.set_ac(d, ac);
+ } else if amount != 0 {
+ let ac = if LOGICAL {
+ ((regs.ac(d) as u64 & 0xFF_FFFF_FFFF) >> amount) as i64
+ } else {
+ regs.ac(d) >> amount
+ };
+ regs.set_ac(d, ac);
}
let ac = regs.ac(d);
regs.update_flags_ac(ac);
@@ -146,13 +168,16 @@ pub fn add_sub<const OP: u32>(
OP_ADDP => {
let d = instr.d_7_7();
let a = ctx.dsp.registers.ac(d);
- let b = product(&ctx.dsp.registers);
+ let (pc, po) = ctx.dsp.registers.product_flags();
+ let b = ctx.dsp.registers.product();
let result = a.wrapping_add(b);
+ let os_before = ctx.dsp.registers.status.os();
ctx.dsp.registers.set_ac(d, result);
ctx.dsp.registers.update_flags_add(a, b, result);
+ apply_combined_add_product_oc(&mut ctx.dsp.registers, pc, po, os_before);
}
OP_SUBR => {
- let ss = instr.ss() as u8;
+ let ss = instr.ss();
let d = instr.d_7_7();
let a = ctx.dsp.registers.ac(d);
let b = (ctx.dsp.registers.read::<true>(reg::AX0L + ss) as i16 as i64) << 16;
@@ -180,16 +205,27 @@ pub fn add_sub<const OP: u32>(
OP_SUBP => {
let d = instr.d_7_7();
let a = ctx.dsp.registers.ac(d);
- let b = product(&ctx.dsp.registers);
+ let (pc, po) = ctx.dsp.registers.product_flags();
+ let b = ctx.dsp.registers.product();
let result = a.wrapping_sub(b);
+ let os_before = ctx.dsp.registers.status.os();
ctx.dsp.registers.set_ac(d, result);
ctx.dsp.registers.update_flags_sub(a, b, result);
+ // SUBP: carry = sub_carry XOR !product_carry
+ ctx.dsp.registers.status.set_os(os_before);
+ let c = ctx.dsp.registers.status.c();
+ let o = ctx.dsp.registers.status.o();
+ ctx.dsp.registers.status.set_c(c ^ !pc);
+ ctx.dsp.registers.status.set_o(o ^ po);
+ if ctx.dsp.registers.status.o() {
+ ctx.dsp.registers.status.set_os(true);
+ }
}
OP_ADDAXL => {
let s = instr.s_6_6() as usize;
let d = instr.d_7_7();
let a = ctx.dsp.registers.ac(d);
- let b = ctx.dsp.registers.ax[s] as u16 as i64;
+ let b = ctx.dsp.registers.ax[s] as i64;
let result = a.wrapping_add(b);
ctx.dsp.registers.set_ac(d, result);
ctx.dsp.registers.update_flags_add(a, b, result);
@@ -197,16 +233,27 @@ pub fn add_sub<const OP: u32>(
OP_ADDPAXZ => {
let s = instr.s_6_6() as usize;
let d = instr.d_7_7();
- let a = product(&ctx.dsp.registers);
+ let (pc, po) = ctx.dsp.registers.product_flags();
+ let a = ctx.dsp.registers.product();
let b = (ctx.dsp.registers.axh[s] as i16 as i64) << 16;
- let result = a.wrapping_add(b) & !0xFFFFi64;
+ let rounded = if a & 0x8000 != 0 {
+ (a + 0x10000) & !0xFFFFi64
+ } else {
+ a & !0xFFFFi64
+ };
+ let result = rounded.wrapping_add(b) & !0xFFFFi64;
+ let os_before = ctx.dsp.registers.status.os();
ctx.dsp.registers.set_ac(d, result);
- ctx.dsp.registers.update_flags_ac(result);
- ctx.dsp.registers.status.set_o(false);
- ctx.dsp.registers.status.set_c(
- ((a as u64 & 0xFF_FFFF_FFFF).wrapping_add(b as u64 & 0xFF_FFFF_FFFF) & 0xFF_FFFF_FFFF)
- < (a as u64 & 0xFF_FFFF_FFFF),
- );
+ ctx.dsp.registers.update_flags_add(rounded, b, result);
+ // carry = add_carry XOR product_carry
+ ctx.dsp.registers.status.set_os(os_before);
+ let c = ctx.dsp.registers.status.c();
+ let o = ctx.dsp.registers.status.o();
+ ctx.dsp.registers.status.set_c(c ^ pc);
+ ctx.dsp.registers.status.set_o(o ^ po);
+ if ctx.dsp.registers.status.o() {
+ ctx.dsp.registers.status.set_os(true);
+ }
}
_ => unreachable!(),
}
@@ -220,20 +267,22 @@ pub fn addr_reg<const OP: u32>(
match OP {
OP_DAR => {
let d = instr.d_14_15() as usize;
- ctx.dsp.registers.ar[d] = ctx.dsp.registers.ar[d].wrapping_sub(1);
+ ctx.dsp.registers.ar[d] = ctx.dsp.registers.decrement_ar(d);
}
OP_IAR => {
let d = instr.d_14_15() as usize;
- ctx.dsp.registers.ar[d] = ctx.dsp.registers.ar[d].wrapping_add(1);
+ ctx.dsp.registers.ar[d] = ctx.dsp.registers.increment_ar(d);
}
OP_SUBARN => {
let d = instr.d_14_15() as usize;
- ctx.dsp.registers.ar[d] = ctx.dsp.registers.ar[d].wrapping_sub(ctx.dsp.registers.ix[d]);
+ let ix = ctx.dsp.registers.ix[d] as i16;
+ ctx.dsp.registers.ar[d] = ctx.dsp.registers.decrease_ar_ix(d, ix);
}
OP_ADDARN => {
let s = instr.s_12_13() as usize;
let d = instr.d_14_15() as usize;
- ctx.dsp.registers.ar[d] = ctx.dsp.registers.ar[d].wrapping_add(ctx.dsp.registers.ix[s]);
+ let ix = ctx.dsp.registers.ix[s] as i16;
+ ctx.dsp.registers.ar[d] = ctx.dsp.registers.increase_ar(d, ix);
}
_ => unreachable!(),
}
@@ -254,8 +303,8 @@ pub fn cmp_test<const OP: u32>(
OP_CMPAXH => {
let s = instr.s_4_4();
let r = instr.s_3_3();
- let a = ctx.dsp.registers.ac(r);
- let b = (ctx.dsp.registers.axh[s as usize] as i16 as i64) << 16;
+ let a = ctx.dsp.registers.ac(s);
+ let b = (ctx.dsp.registers.axh[r as usize] as i16 as i64) << 16;
let result = a.wrapping_sub(b);
ctx.dsp.registers.update_flags_sub(a, b, result);
}
@@ -267,10 +316,14 @@ pub fn cmp_test<const OP: u32>(
ctx.dsp.registers.status.set_c(false);
}
OP_TSTPROD => {
- let prod = product(&ctx.dsp.registers);
+ let (pc, po) = ctx.dsp.registers.product_flags();
+ let prod = ctx.dsp.registers.product();
ctx.dsp.registers.update_flags_ac(prod);
- ctx.dsp.registers.status.set_o(false);
- ctx.dsp.registers.status.set_c(false);
+ ctx.dsp.registers.status.set_o(po);
+ if po {
+ ctx.dsp.registers.status.set_os(true);
+ }
+ ctx.dsp.registers.status.set_c(pc);
}
OP_TSTAXH => {
let r = instr.r_7_7() as usize;
@@ -300,15 +353,17 @@ pub fn cmp_test<const OP: u32>(
OP_CLRL => {
let r = instr.r_7_7();
let ac = ctx.dsp.registers.ac(r);
- let rounded = if (ac & 0x10000) != 0 {
- (ac.wrapping_add(0x8000)) & !0xFFFF
+ let ac40 = ac as u64 & 0xFF_FFFF_FFFF;
+ let (rounded, carry) = if ac40 & 0x8000 != 0 {
+ let sum = ac40.wrapping_add(0x10000);
+ ((sum & !0xFFFFu64) as i64, sum > 0xFF_FFFF_FFFF)
} else {
- (ac.wrapping_add(0x7FFF)) & !0xFFFF
+ ((ac40 & !0xFFFFu64) as i64, false)
};
ctx.dsp.registers.set_ac(r, rounded);
ctx.dsp.registers.update_flags_ac(rounded);
ctx.dsp.registers.status.set_o(false);
- ctx.dsp.registers.status.set_c(false);
+ ctx.dsp.registers.status.set_c(carry);
}
_ => unreachable!(),
}
@@ -392,7 +447,7 @@ pub fn imm_alu<const OP: u32>(
let result = ctx.dsp.registers.ac_mid(d) ^ instr.imm_16_31();
ctx.dsp.registers.write::<false>(reg::AC0M + d, result);
let ac = ctx.dsp.registers.ac(d);
- ctx.dsp.registers.update_flags_ac(ac);
+ ctx.dsp.registers.update_flags_logic(result, ac);
ctx.dsp.registers.status.set_o(false);
ctx.dsp.registers.status.set_c(false);
}
@@ -401,7 +456,7 @@ pub fn imm_alu<const OP: u32>(
let result = ctx.dsp.registers.ac_mid(d) & instr.imm_16_31();
ctx.dsp.registers.write::<false>(reg::AC0M + d, result);
let ac = ctx.dsp.registers.ac(d);
- ctx.dsp.registers.update_flags_ac(ac);
+ ctx.dsp.registers.update_flags_logic(result, ac);
ctx.dsp.registers.status.set_o(false);
ctx.dsp.registers.status.set_c(false);
}
@@ -410,8 +465,9 @@ pub fn imm_alu<const OP: u32>(
let result = ctx.dsp.registers.ac_mid(d) | instr.imm_16_31();
ctx.dsp.registers.write::<false>(reg::AC0M + d, result);
let ac = ctx.dsp.registers.ac(d);
- ctx.dsp.registers.update_flags_ac(ac);
+ ctx.dsp.registers.update_flags_logic(result, ac);
ctx.dsp.registers.status.set_o(false);
+ ctx.dsp.registers.status.set_c(false);
}
OP_CMPI => {
let d = instr.d_7_7();
@@ -498,12 +554,17 @@ pub fn inc_dec<const OP: u32>(
OP_ABS_AC => {
let d = instr.d_4_4();
let a = ctx.dsp.registers.ac(d);
- if a < 0 {
+ let was_negative = a < 0;
+ if was_negative {
ctx.dsp.registers.set_ac(d, a.wrapping_neg());
}
let ac = ctx.dsp.registers.ac(d);
ctx.dsp.registers.update_flags_ac(ac);
- ctx.dsp.registers.status.set_o(false);
+ // Overflow if the value was negative and is still negative
+ ctx.dsp.registers.status.set_o(was_negative && ac < 0);
+ if ctx.dsp.registers.status.o() {
+ ctx.dsp.registers.status.set_os(true);
+ }
ctx.dsp.registers.status.set_c(false);
}
_ => unreachable!(),
@@ -541,9 +602,12 @@ pub fn load_store<const OP: u32>(
let value = ctx.dsp.read_dmem(ctx.dsp.registers.ar[s]);
ctx.dsp.registers.write::<true>(d, value);
match OP {
- OP_LRRD => ctx.dsp.registers.ar[s] = ctx.dsp.registers.ar[s].wrapping_sub(1),
- OP_LRRI => ctx.dsp.registers.ar[s] = ctx.dsp.registers.ar[s].wrapping_add(1),
- OP_LRRN => ctx.dsp.registers.ar[s] = ctx.dsp.registers.ar[s].wrapping_add(ctx.dsp.registers.ix[s]),
+ OP_LRRD => ctx.dsp.registers.ar[s] = ctx.dsp.registers.decrement_ar(s),
+ OP_LRRI => ctx.dsp.registers.ar[s] = ctx.dsp.registers.increment_ar(s),
+ OP_LRRN => {
+ let ix = ctx.dsp.registers.ix[s] as i16;
+ ctx.dsp.registers.ar[s] = ctx.dsp.registers.increase_ar(s, ix);
+ }
_ => {}
}
}
@@ -552,20 +616,23 @@ pub fn load_store<const OP: u32>(
let value = ctx.dsp.registers.read::<true>(instr.d_11_15());
ctx.dsp.write_dmem(ctx.dsp.registers.ar[d], value);
match OP {
- OP_SRRD => ctx.dsp.registers.ar[d] = ctx.dsp.registers.ar[d].wrapping_sub(1),
- OP_SRRI => ctx.dsp.registers.ar[d] = ctx.dsp.registers.ar[d].wrapping_add(1),
- OP_SRRN => ctx.dsp.registers.ar[d] = ctx.dsp.registers.ar[d].wrapping_add(ctx.dsp.registers.ix[d]),
+ OP_SRRD => ctx.dsp.registers.ar[d] = ctx.dsp.registers.decrement_ar(d),
+ OP_SRRI => ctx.dsp.registers.ar[d] = ctx.dsp.registers.increment_ar(d),
+ OP_SRRN => {
+ let ix = ctx.dsp.registers.ix[d] as i16;
+ ctx.dsp.registers.ar[d] = ctx.dsp.registers.increase_ar(d, ix);
+ }
_ => {}
}
}
OP_LRS => {
let dst = reg::AX0L + instr.reg_5_7();
- let addr = ((ctx.dsp.registers.config as u16) << 8) | instr.mem_8_15_u16();
+ let addr = (ctx.dsp.registers.config << 8) | instr.mem_8_15_u16();
let value = ctx.dsp.read_dmem(addr);
ctx.dsp.registers.write::<true>(dst, value);
}
OP_SRSH | OP_SRS => {
- let addr = ((ctx.dsp.registers.config as u16) << 8) | instr.mem_8_15_u16();
+ let addr = (ctx.dsp.registers.config << 8) | instr.mem_8_15_u16();
let src = match OP {
OP_SRSH => {
if instr.s_7_7() != 0 {
@@ -586,10 +653,11 @@ pub fn load_store<const OP: u32>(
let value = ctx.dsp.read_imem(ctx.dsp.registers.ar[src]);
ctx.dsp.registers.write::<true>(dst, value);
match OP {
- OP_ILRRD => ctx.dsp.registers.ar[src] = ctx.dsp.registers.ar[src].wrapping_sub(1),
- OP_ILRRI => ctx.dsp.registers.ar[src] = ctx.dsp.registers.ar[src].wrapping_add(1),
+ OP_ILRRD => ctx.dsp.registers.ar[src] = ctx.dsp.registers.decrement_ar(src),
+ OP_ILRRI => ctx.dsp.registers.ar[src] = ctx.dsp.registers.increment_ar(src),
OP_ILRRN => {
- ctx.dsp.registers.ar[src] = ctx.dsp.registers.ar[src].wrapping_add(ctx.dsp.registers.ix[src])
+ let ix = ctx.dsp.registers.ix[src] as i16;
+ ctx.dsp.registers.ar[src] = ctx.dsp.registers.increase_ar(src, ix);
}
_ => {}
}
@@ -607,7 +675,7 @@ pub fn logic<const OP: u32>(ctx: &mut crate::gamecube::GameCube, instr: crate::f
let result = ctx.dsp.registers.ac_mid(d) ^ ctx.dsp.registers.axh[s];
ctx.dsp.registers.write::<false>(reg::AC0M + d, result);
let ac = ctx.dsp.registers.ac(d);
- ctx.dsp.registers.update_flags_ac(ac);
+ ctx.dsp.registers.update_flags_logic(result, ac);
ctx.dsp.registers.status.set_o(false);
ctx.dsp.registers.status.set_c(false);
}
@@ -617,7 +685,7 @@ pub fn logic<const OP: u32>(ctx: &mut crate::gamecube::GameCube, instr: crate::f
let result = ctx.dsp.registers.ac_mid(d) & ctx.dsp.registers.axh[s];
ctx.dsp.registers.write::<false>(reg::AC0M + d, result);
let ac = ctx.dsp.registers.ac(d);
- ctx.dsp.registers.update_flags_ac(ac);
+ ctx.dsp.registers.update_flags_logic(result, ac);
ctx.dsp.registers.status.set_o(false);
ctx.dsp.registers.status.set_c(false);
}
@@ -627,15 +695,16 @@ pub fn logic<const OP: u32>(ctx: &mut crate::gamecube::GameCube, instr: crate::f
let result = ctx.dsp.registers.ac_mid(d) | ctx.dsp.registers.axh[s];
ctx.dsp.registers.write::<false>(reg::AC0M + d, result);
let ac = ctx.dsp.registers.ac(d);
- ctx.dsp.registers.update_flags_ac(ac);
+ ctx.dsp.registers.update_flags_logic(result, ac);
ctx.dsp.registers.status.set_o(false);
+ ctx.dsp.registers.status.set_c(false);
}
OP_ANDC => {
let d = instr.d_7_7();
let result = ctx.dsp.registers.ac_mid(d) & ctx.dsp.registers.ac_mid(1 - d);
ctx.dsp.registers.write::<false>(reg::AC0M + d, result);
let ac = ctx.dsp.registers.ac(d);
- ctx.dsp.registers.update_flags_ac(ac);
+ ctx.dsp.registers.update_flags_logic(result, ac);
ctx.dsp.registers.status.set_o(false);
ctx.dsp.registers.status.set_c(false);
}
@@ -643,23 +712,26 @@ pub fn logic<const OP: u32>(ctx: &mut crate::gamecube::GameCube, instr: crate::f
let d = instr.d_7_7();
let result = ctx.dsp.registers.ac_mid(d) | ctx.dsp.registers.ac_mid(1 - d);
ctx.dsp.registers.write::<false>(reg::AC0M + d, result);
+ let ac = ctx.dsp.registers.ac(d);
+ ctx.dsp.registers.update_flags_logic(result, ac);
+ ctx.dsp.registers.status.set_o(false);
+ ctx.dsp.registers.status.set_c(false);
}
OP_XORC => {
let d = instr.d_7_7();
let result = ctx.dsp.registers.ac_mid(d) ^ ctx.dsp.registers.ac_mid(1 - d);
ctx.dsp.registers.write::<false>(reg::AC0M + d, result);
let ac = ctx.dsp.registers.ac(d);
- ctx.dsp.registers.update_flags_ac(ac);
+ ctx.dsp.registers.update_flags_logic(result, ac);
ctx.dsp.registers.status.set_o(false);
ctx.dsp.registers.status.set_c(false);
}
OP_NOT_AC => {
let d = instr.d_7_7();
- ctx.dsp
- .registers
- .write::<false>(reg::AC0M + d, !ctx.dsp.registers.ac_mid(d));
+ let result = !ctx.dsp.registers.ac_mid(d);
+ ctx.dsp.registers.write::<false>(reg::AC0M + d, result);
let ac = ctx.dsp.registers.ac(d);
- ctx.dsp.registers.update_flags_ac(ac);
+ ctx.dsp.registers.update_flags_logic(result, ac);
ctx.dsp.registers.status.set_o(false);
ctx.dsp.registers.status.set_c(false);
}
@@ -711,7 +783,7 @@ pub fn move_ops<const OP: u32>(
) {
match OP {
OP_MOVR => {
- let ss = instr.ss() as u8;
+ let ss = instr.ss();
let d = instr.d_7_7();
let val = (ctx.dsp.registers.read::<true>(reg::AX0L + ss) as i16 as i64) << 16;
ctx.dsp.registers.set_ac(d, val);
@@ -733,7 +805,6 @@ pub fn move_ops<const OP: u32>(
let val = ctx.dsp.registers.ac(1 - d);
ctx.dsp.registers.set_ac(d, val);
ctx.dsp.registers.update_flags_ac(val);
- ctx.dsp.registers.status.set_as32(false);
ctx.dsp.registers.status.set_o(false);
ctx.dsp.registers.status.set_c(false);
}
@@ -747,10 +818,16 @@ pub fn move_ops<const OP: u32>(
}
OP_MOVNP => {
let d = instr.d_7_7();
- let val = product(&ctx.dsp.registers).wrapping_neg();
+ let prod = ctx.dsp.registers.product();
+ let (carry, overflow) = ctx.dsp.registers.product_flags();
+ let val = prod.wrapping_neg();
ctx.dsp.registers.set_ac(d, val);
ctx.dsp.registers.update_flags_ac(val);
- ctx.dsp.registers.status.set_o(false);
+ ctx.dsp.registers.status.set_o(overflow);
+ if overflow {
+ ctx.dsp.registers.status.set_os(true);
+ }
+ ctx.dsp.registers.status.set_c(!carry);
}
_ => unreachable!(),
}
@@ -923,33 +1000,33 @@ pub fn shifts<const OP: u32>(
}
OP_LSRN => {
let sv = ctx.dsp.registers.ac1_mid as i16;
- dynamic_shift::<true>(&mut ctx.dsp.registers, 0, sv);
+ dynamic_shift::<true, false>(&mut ctx.dsp.registers, 0, sv);
}
OP_ASRN => {
let sv = ctx.dsp.registers.ac1_mid as i16;
- dynamic_shift::<false>(&mut ctx.dsp.registers, 0, sv);
+ dynamic_shift::<false, false>(&mut ctx.dsp.registers, 0, sv);
}
OP_LSRNRX => {
let s = instr.s_6_6() as usize;
let d = instr.d_7_7();
let sv = ctx.dsp.registers.axh[s] as i16;
- dynamic_shift::<true>(&mut ctx.dsp.registers, d, sv);
+ dynamic_shift::<true, true>(&mut ctx.dsp.registers, d, sv);
}
OP_ASRNRX => {
let s = instr.s_6_6() as usize;
let d = instr.d_7_7();
let sv = ctx.dsp.registers.axh[s] as i16;
- dynamic_shift::<false>(&mut ctx.dsp.registers, d, sv);
+ dynamic_shift::<false, true>(&mut ctx.dsp.registers, d, sv);
}
OP_LSRNR => {
let d = instr.d_7_7();
let sv = ctx.dsp.registers.ac_mid(1 - d) as i16;
- dynamic_shift::<true>(&mut ctx.dsp.registers, d, sv);
+ dynamic_shift::<true, true>(&mut ctx.dsp.registers, d, sv);
}
OP_ASRNR => {
let d = instr.d_7_7();
let sv = ctx.dsp.registers.ac_mid(1 - d) as i16;
- dynamic_shift::<false>(&mut ctx.dsp.registers, d, sv);
+ dynamic_shift::<false, true>(&mut ctx.dsp.registers, d, sv);
}
_ => unreachable!(),
}
@@ -962,10 +1039,16 @@ pub fn status<const OP: u32>(
) {
match OP {
OP_SBCLR => {
- ctx.dsp.registers.status &= !(1 << (6 + instr.bit())) as u16;
+ let idx = 6 + instr.bit();
+ if idx != 13 {
+ ctx.dsp.registers.status &= !(1u16 << idx);
+ }
}
OP_SBSET => {
- ctx.dsp.registers.status |= (1 << (6 + instr.bit())) as u16;
+ let idx = 6 + instr.bit();
+ if idx != 13 && idx != 8 {
+ ctx.dsp.registers.status |= 1u16 << idx;
+ }
}
OP_M2 => {
ctx.dsp.registers.status.set_am(false);
@@ -999,43 +1082,52 @@ pub fn ext_nop(_ctx: &mut crate::gamecube::GameCube, _instr: GcDspExt) {}
pub fn ext_addr<const OP: u32>(ctx: &mut crate::gamecube::GameCube, instr: GcDspExt) {
let r = instr.r_6_7() as usize;
match OP {
- OP_EXT_DR => ctx.dsp.registers.ar[r] = ctx.dsp.registers.ar[r].wrapping_sub(1),
- OP_EXT_IR => ctx.dsp.registers.ar[r] = ctx.dsp.registers.ar[r].wrapping_add(1),
- OP_EXT_NR => ctx.dsp.registers.ar[r] = ctx.dsp.registers.ar[r].wrapping_add(ctx.dsp.registers.ix[r]),
+ OP_EXT_DR => ctx.dsp.registers.ar[r] = ctx.dsp.registers.decrement_ar(r),
+ OP_EXT_IR => ctx.dsp.registers.ar[r] = ctx.dsp.registers.increment_ar(r),
+ OP_EXT_NR => {
+ let ix = ctx.dsp.registers.ix[r] as i16;
+ ctx.dsp.registers.ar[r] = ctx.dsp.registers.increase_ar(r, ix);
+ }
_ => unreachable!(),
}
}
#[inline(always)]
pub fn ext_mv(ctx: &mut crate::gamecube::GameCube, instr: GcDspExt) {
- let d = instr.d_4_5() as u8;
- let s = instr.s_6_7() as u8;
- let value = ctx.dsp.registers.read::<true>(reg::AX0L + s);
+ let d = instr.d_4_5();
+ let s = instr.s_6_7();
+ let value = ctx.dsp.registers.read::<true>(reg::AC0L + s);
ctx.dsp.registers.write::<true>(reg::AX0L + d, value);
}
#[inline(always)]
pub fn ext_store<const OP: u32>(ctx: &mut crate::gamecube::GameCube, instr: GcDspExt) {
let s = instr.s_3_4() as usize;
- let d = instr.d_6_7() as u8;
+ let d = instr.d_6_7();
let value = ctx.dsp.registers.read::<true>(reg::AC0M + d);
ctx.dsp.write_dmem(ctx.dsp.registers.ar[s], value);
match OP {
OP_EXT_S => {}
- OP_EXT_SN => ctx.dsp.registers.ar[s] = ctx.dsp.registers.ar[s].wrapping_add(ctx.dsp.registers.ix[s]),
+ OP_EXT_SN => {
+ let ix = ctx.dsp.registers.ix[s] as i16;
+ ctx.dsp.registers.ar[s] = ctx.dsp.registers.increase_ar(s, ix);
+ }
_ => unreachable!(),
}
}
#[inline(always)]
pub fn ext_load<const OP: u32>(ctx: &mut crate::gamecube::GameCube, instr: GcDspExt) {
- let d = instr.d_2_4() as u8;
+ let d = instr.d_2_4();
let s = instr.s_6_7() as usize;
let value = ctx.dsp.read_dmem(ctx.dsp.registers.ar[s]);
ctx.dsp.registers.write::<true>(reg::AX0L + d, value);
match OP {
OP_EXT_L => {}
- OP_EXT_LN => ctx.dsp.registers.ar[s] = ctx.dsp.registers.ar[s].wrapping_add(ctx.dsp.registers.ix[s]),
+ OP_EXT_LN => {
+ let ix = ctx.dsp.registers.ix[s] as i16;
+ ctx.dsp.registers.ar[s] = ctx.dsp.registers.increase_ar(s, ix);
+ }
_ => unreachable!(),
}
}
@@ -1043,32 +1135,35 @@ pub fn ext_load<const OP: u32>(ctx: &mut crate::gamecube::GameCube, instr: GcDsp
#[inline(always)]
pub fn ext_load_store<const OP: u32>(ctx: &mut crate::gamecube::GameCube, instr: GcDspExt) {
let s = instr.s_7_7() as usize;
- let d = instr.d_2_3() as u8;
+ let d = instr.d_2_3();
- let store_value = ctx.dsp.registers.read::<true>(reg::AC0M + s as u8);
- ctx.dsp.write_dmem(ctx.dsp.registers.ar[3], store_value);
+ // LS: Load from ar[0], Store ac[s].m to ar[3]
+ let load_value = ctx.dsp.read_dmem(ctx.dsp.registers.ar[0]);
+ ctx.dsp.registers.write::<true>(reg::AX0L + d, load_value);
- let load_value = ctx.dsp.read_dmem(ctx.dsp.registers.ar[d as usize]);
- ctx.dsp.registers.write::<true>(reg::AX0H + d, load_value);
+ let store_value = ctx.dsp.registers.ac_mid(s as u8);
+ ctx.dsp.write_dmem(ctx.dsp.registers.ar[3], store_value);
match OP {
OP_EXT_LS => {
- ctx.dsp.registers.ar[d as usize] =
- ctx.dsp.registers.ar[d as usize].wrapping_add(ctx.dsp.registers.ix[d as usize]);
- ctx.dsp.registers.ar[3] = ctx.dsp.registers.ar[3].wrapping_add(ctx.dsp.registers.ix[3]);
+ ctx.dsp.registers.ar[0] = ctx.dsp.registers.increment_ar(0);
+ ctx.dsp.registers.ar[3] = ctx.dsp.registers.increment_ar(3);
}
OP_EXT_LSM => {
- ctx.dsp.registers.ar[d as usize] =
- ctx.dsp.registers.ar[d as usize].wrapping_add(ctx.dsp.registers.ix[d as usize]);
- ctx.dsp.registers.ar[3] = ctx.dsp.registers.ar[3].wrapping_sub(1);
+ ctx.dsp.registers.ar[0] = ctx.dsp.registers.increment_ar(0);
+ let ix3 = ctx.dsp.registers.ix[3] as i16;
+ ctx.dsp.registers.ar[3] = ctx.dsp.registers.increase_ar(3, ix3);
}
OP_EXT_LSN => {
- ctx.dsp.registers.ar[d as usize] = ctx.dsp.registers.ar[d as usize].wrapping_sub(1);
- ctx.dsp.registers.ar[3] = ctx.dsp.registers.ar[3].wrapping_add(ctx.dsp.registers.ix[3]);
+ let ix0 = ctx.dsp.registers.ix[0] as i16;
+ ctx.dsp.registers.ar[0] = ctx.dsp.registers.increase_ar(0, ix0);
+ ctx.dsp.registers.ar[3] = ctx.dsp.registers.increment_ar(3);
}
OP_EXT_LSNM => {
- ctx.dsp.registers.ar[d as usize] = ctx.dsp.registers.ar[d as usize].wrapping_sub(1);
- ctx.dsp.registers.ar[3] = ctx.dsp.registers.ar[3].wrapping_sub(1);
+ let ix0 = ctx.dsp.registers.ix[0] as i16;
+ ctx.dsp.registers.ar[0] = ctx.dsp.registers.increase_ar(0, ix0);
+ let ix3 = ctx.dsp.registers.ix[3] as i16;
+ ctx.dsp.registers.ar[3] = ctx.dsp.registers.increase_ar(3, ix3);
}
_ => unreachable!(),
}
@@ -1076,73 +1171,82 @@ pub fn ext_load_store<const OP: u32>(ctx: &mut crate::gamecube::GameCube, instr:
#[inline(always)]
pub fn ext_ld<const OP: u32>(ctx: &mut crate::gamecube::GameCube, instr: GcDspExt) {
- let d = instr.d_2_2() as u8;
- let r = instr.r_3_3() as usize;
- let s = instr.s_6_7();
+ let d = instr.d_2_2();
+ let r = instr.r_3_3();
+ let s = instr.s_6_7() as usize;
- let value0 = ctx.dsp.read_dmem(ctx.dsp.registers.ar[0]);
- ctx.dsp.registers.write::<true>(reg::AX0L + d * 2, value0);
+ // First load from ar[s] -> AX0 half (d selects low/high)
+ let d_reg = if d != 0 { reg::AX0H } else { reg::AX0L };
+ let value0 = ctx.dsp.read_dmem(ctx.dsp.registers.ar[s]);
+ ctx.dsp.registers.write::<true>(d_reg, value0);
+ // Second load from ar[3] -> AX1 half (r selects low/high)
+ let r_reg = if r != 0 { reg::AX1H } else { reg::AX1L };
let value1 = ctx.dsp.read_dmem(ctx.dsp.registers.ar[3]);
- ctx.dsp.registers.write::<true>(reg::AX0L + d * 2 + 1, value1);
+ ctx.dsp.registers.write::<true>(r_reg, value1);
+ // AR increments: "" = +1/+1, "N" = +ix[s]/+1, "M" = +1/+ix[3], "NM" = +ix[s]/+ix[3]
match OP {
OP_EXT_LD_00 => {
- ctx.dsp.registers.ar[0] = ctx.dsp.registers.ar[0].wrapping_add(ctx.dsp.registers.ix[0]);
- ctx.dsp.registers.ar[3] = ctx.dsp.registers.ar[3].wrapping_add(ctx.dsp.registers.ix[3]);
- }
- OP_EXT_LDM_10 => {
- ctx.dsp.registers.ar[0] = ctx.dsp.registers.ar[0].wrapping_add(ctx.dsp.registers.ix[0]);
- ctx.dsp.registers.ar[3] = ctx.dsp.registers.ar[3].wrapping_sub(1);
+ ctx.dsp.registers.ar[s] = ctx.dsp.registers.increment_ar(s);
+ ctx.dsp.registers.ar[3] = ctx.dsp.registers.increment_ar(3);
}
OP_EXT_LDN_01 => {
- ctx.dsp.registers.ar[0] = ctx.dsp.registers.ar[0].wrapping_sub(1);
- ctx.dsp.registers.ar[3] = ctx.dsp.registers.ar[3].wrapping_add(ctx.dsp.registers.ix[3]);
+ let ixs = ctx.dsp.registers.ix[s] as i16;
+ ctx.dsp.registers.ar[s] = ctx.dsp.registers.increase_ar(s, ixs);
+ ctx.dsp.registers.ar[3] = ctx.dsp.registers.increment_ar(3);
+ }
+ OP_EXT_LDM_10 => {
+ ctx.dsp.registers.ar[s] = ctx.dsp.registers.increment_ar(s);
+ let ix3 = ctx.dsp.registers.ix[3] as i16;
+ ctx.dsp.registers.ar[3] = ctx.dsp.registers.increase_ar(3, ix3);
}
OP_EXT_LDNM_11 => {
- ctx.dsp.registers.ar[0] = ctx.dsp.registers.ar[0].wrapping_sub(1);
- ctx.dsp.registers.ar[3] = ctx.dsp.registers.ar[3].wrapping_sub(1);
+ let ixs = ctx.dsp.registers.ix[s] as i16;
+ ctx.dsp.registers.ar[s] = ctx.dsp.registers.increase_ar(s, ixs);
+ let ix3 = ctx.dsp.registers.ix[3] as i16;
+ ctx.dsp.registers.ar[3] = ctx.dsp.registers.increase_ar(3, ix3);
}
_ => unreachable!(),
}
-
- let _ = (r, s);
}
#[inline(always)]
pub fn ext_ldax<const OP: u32>(ctx: &mut crate::gamecube::GameCube, instr: GcDspExt) {
+ let s = instr.d_2_2() as usize;
let r = instr.r_3_3() as usize;
- let s = instr.s_2_2();
- let value0 = ctx.dsp.read_dmem(ctx.dsp.registers.ar[0]);
- ctx.dsp
- .registers
- .write::<true>(if s != 0 { reg::AX1L } else { reg::AX0L }, value0);
+ // Load high from ar[s]
+ let high = ctx.dsp.read_dmem(ctx.dsp.registers.ar[s]);
+ // Load low from ar[3]
+ let low = ctx.dsp.read_dmem(ctx.dsp.registers.ar[3]);
- let value1 = ctx.dsp.read_dmem(ctx.dsp.registers.ar[3]);
- ctx.dsp
- .registers
- .write::<true>(if s != 0 { reg::AX1H } else { reg::AX0H }, value1);
+ // Write to ax[r] (high and low)
+ ctx.dsp.registers.axh[r] = high;
+ ctx.dsp.registers.ax[r] = low;
+ // AR increments
match OP {
OP_EXT_LDAX => {
- ctx.dsp.registers.ar[0] = ctx.dsp.registers.ar[0].wrapping_add(ctx.dsp.registers.ix[0]);
- ctx.dsp.registers.ar[3] = ctx.dsp.registers.ar[3].wrapping_add(ctx.dsp.registers.ix[3]);
- }
- OP_EXT_LDAXM => {
- ctx.dsp.registers.ar[0] = ctx.dsp.registers.ar[0].wrapping_add(ctx.dsp.registers.ix[0]);
- ctx.dsp.registers.ar[3] = ctx.dsp.registers.ar[3].wrapping_sub(1);
+ ctx.dsp.registers.ar[s] = ctx.dsp.registers.increment_ar(s);
+ ctx.dsp.registers.ar[3] = ctx.dsp.registers.increment_ar(3);
}
OP_EXT_LDAXN => {
- ctx.dsp.registers.ar[0] = ctx.dsp.registers.ar[0].wrapping_sub(1);
- ctx.dsp.registers.ar[3] = ctx.dsp.registers.ar[3].wrapping_add(ctx.dsp.registers.ix[3]);
+ let ixs = ctx.dsp.registers.ix[s] as i16;
+ ctx.dsp.registers.ar[s] = ctx.dsp.registers.increase_ar(s, ixs);
+ ctx.dsp.registers.ar[3] = ctx.dsp.registers.increment_ar(3);
+ }
+ OP_EXT_LDAXM => {
+ ctx.dsp.registers.ar[s] = ctx.dsp.registers.increment_ar(s);
+ let ix3 = ctx.dsp.registers.ix[3] as i16;
+ ctx.dsp.registers.ar[3] = ctx.dsp.registers.increase_ar(3, ix3);
}
OP_EXT_LDAXNM => {
- ctx.dsp.registers.ar[0] = ctx.dsp.registers.ar[0].wrapping_sub(1);
- ctx.dsp.registers.ar[3] = ctx.dsp.registers.ar[3].wrapping_sub(1);
+ let ixs = ctx.dsp.registers.ix[s] as i16;
+ ctx.dsp.registers.ar[s] = ctx.dsp.registers.increase_ar(s, ixs);
+ let ix3 = ctx.dsp.registers.ix[3] as i16;
+ ctx.dsp.registers.ar[3] = ctx.dsp.registers.increase_ar(3, ix3);
}
_ => unreachable!(),
}
-
- let _ = r;
}
diff --git a/crates/image/src/lib.rs b/crates/image/src/lib.rs
index 6d42b38..ebffd5d 100644
--- a/crates/image/src/lib.rs
+++ b/crates/image/src/lib.rs
@@ -31,7 +31,7 @@ impl Dol {
let mut data_sections = Vec::new();
for i in 0..=6 {
- let offset = u32::from_be_bytes(data[0x00 + (i * 4)..0x00 + (i * 4) + 4].try_into().unwrap());
+ let offset = u32::from_be_bytes(data[(i * 4)..(i * 4) + 4].try_into().unwrap());
let vaddr = u32::from_be_bytes(data[0x48 + (i * 4)..0x48 + (i * 4) + 4].try_into().unwrap());
let size = u32::from_be_bytes(data[0x90 + (i * 4)..0x90 + (i * 4) + 4].try_into().unwrap());
diff --git a/crates/scripting/src/lib.rs b/crates/scripting/src/lib.rs
index 6c2ac0e..df078f3 100644
--- a/crates/scripting/src/lib.rs
+++ b/crates/scripting/src/lib.rs
@@ -494,19 +494,19 @@ impl Host for LuaHost {
fn on_cpu_pre(&mut self, emu: &mut GameCube) {
let pc = emu.cpu.pc;
- if let Some(callback) = self.cpu_pre.get(&pc) {
- if let Err(err) = self.call_cpu_hook("cpu_pre", callback, emu) {
- log_hook_error("cpu_pre", &err);
- }
+ if let Some(callback) = self.cpu_pre.get(&pc)
+ && let Err(err) = self.call_cpu_hook("cpu_pre", callback, emu)
+ {
+ log_hook_error("cpu_pre", &err);
}
}
fn on_cpu_post(&mut self, emu: &mut GameCube) {
let pc = emu.cpu.cia;
- if let Some(callback) = self.cpu_post.get(&pc) {
- if let Err(err) = self.call_cpu_hook("cpu_post", callback, emu) {
- log_hook_error("cpu_post", &err);
- }
+ if let Some(callback) = self.cpu_post.get(&pc)
+ && let Err(err) = self.call_cpu_hook("cpu_post", callback, emu)
+ {
+ log_hook_error("cpu_post", &err);
}
}
@@ -548,12 +548,11 @@ impl Host for LuaHost {
}
fn on_bus_write_post(&mut self, emu: &mut GameCube, virt_addr: u32, phys_addr: u32, size: u8, value: u32) {
- if let Some(callback) = self.bus_write_post.resolve(virt_addr, phys_addr) {
- if let Err(err) =
+ if let Some(callback) = self.bus_write_post.resolve(virt_addr, phys_addr)
+ && let Err(err) =
self.call_bus_write_post_hook("bus_write_post", callback, emu, virt_addr, phys_addr, size, value)
- {
- log_hook_error("bus_write_post", &err);
- }
+ {
+ log_hook_error("bus_write_post", &err);
}
}
}
diff --git a/crates/tinytracer/src/fmt.rs b/crates/tinytracer/src/fmt.rs
index c5e848c..4283108 100644
--- a/crates/tinytracer/src/fmt.rs
+++ b/crates/tinytracer/src/fmt.rs
@@ -140,12 +140,12 @@ pub fn dsp_reg_comment(text: &str, regs: &gecko::flipper::dsp::core::Registers)
}
_ => {
// Individual 16-bit registers (reg5 index 0-31)
- if let Some(idx) = dsp_reg_index(name) {
- if !seen[idx as usize] {
- seen[idx as usize] = true;
- let val = dsp_reg_read(regs, idx);
- parts.push(format!("{}={:04X}", name, val));
- }
+ if let Some(idx) = dsp_reg_index(name)
+ && !seen[idx as usize]
+ {
+ seen[idx as usize] = true;
+ let val = dsp_reg_read(regs, idx);
+ parts.push(format!("{}={:04X}", name, val));
}
}
}
diff --git a/crates/tinytracer/src/main.rs b/crates/tinytracer/src/main.rs
index cf640f4..038cf61 100644
--- a/crates/tinytracer/src/main.rs
+++ b/crates/tinytracer/src/main.rs
@@ -151,16 +151,15 @@ fn run_emulator(emulator: &mut gecko::gamecube::GameCube, args: &Args, symbols:
loop {
if !in_busyloop && !args.quiet && trace_cpu {
- if let Some(symbols) = symbols {
- if let Some(sym) = symbols.lookup_exact(emulator.cpu.pc) {
- if sym.kind == image::symbols::SymbolKind::Func {
- let name = &sym.name;
- let changed = current_func.as_ref() != Some(name);
- if changed {
- println!("{}", format!("{name}:").green().bold());
- current_func = Some(name.clone());
- }
- }
+ if let Some(symbols) = symbols
+ && let Some(sym) = symbols.lookup_exact(emulator.cpu.pc)
+ && sym.kind == image::symbols::SymbolKind::Func
+ {
+ let name = &sym.name;
+ let changed = current_func.as_ref() != Some(name);
+ if changed {
+ println!("{}", format!("{name}:").green().bold());
+ current_func = Some(name.clone());
}
}
print_cpu_instruction(emulator, &prev_snapshot, args.debug, is_both);