A GameCube/Wii emulator and debugger written in Rust.
part 2
Laylec9af6f16a920
diff --git a/crates/gecko/src/flipper/dsp/core/stack.rs b/crates/gecko/src/flipper/dsp/core/stack.rsindex 948dcc8..c832522 100644--- a/crates/gecko/src/flipper/dsp/core/stack.rs+++ b/crates/gecko/src/flipper/dsp/core/stack.rs@@ -12,6 +12,14 @@ impl<const N: usize> Default for DspStack<N> {impl<const N: usize> DspStack<N> {const MASK: u8 = (N - 1) as u8;+ pub const fn data_offset() -> usize {+ core::mem::offset_of!(Self, data)+ }++ pub const fn ptr_offset() -> usize {+ core::mem::offset_of!(Self, ptr)+ }+#[inline(always)]pub fn top(&self) -> u16 {debug_assert!((self.ptr as usize) < N);diff --git a/crates/gecko/src/flipper/dsp/jit.rs b/crates/gecko/src/flipper/dsp/jit.rsindex 8c4335e..5dff109 100644--- a/crates/gecko/src/flipper/dsp/jit.rs+++ b/crates/gecko/src/flipper/dsp/jit.rs@@ -83,83 +83,30 @@ impl<const SYSTEM: SystemId> JitEngine<SYSTEM> {let mut jit_builder = JITBuilder::with_isa(isa, default_libcall_names());struct Syms {- loop_tail: (&'static str, *const u8),read_dmem: (&'static str, *const u8),write_dmem: (&'static str, *const u8),- inc_ar: (&'static str, *const u8),- dec_ar: (&'static str, *const u8),- increase_ar: (&'static str, *const u8),- decrease_ar_ix: (&'static str, *const u8),- dynamic_shift: (&'static str, *const u8),- read_imem: (&'static str, *const u8),- call_stack_push: (&'static str, *const u8),- call_stack_pop: (&'static str, *const u8),- data_stack_pop: (&'static str, *const u8),read_reg_full: (&'static str, *const u8),write_reg_full: (&'static str, *const u8),- loop_setup: (&'static str, *const u8),}let syms: Syms = match SYSTEM {GC => Syms {- loop_tail: ("gecko_dsp_jit_loop_tail_gc", runtime::dsp_loop_tail_gc as *const u8),read_dmem: ("gecko_dsp_jit_rdmem_gc", runtime::dsp_read_dmem_gc as *const u8),write_dmem: ("gecko_dsp_jit_wdmem_gc", runtime::dsp_write_dmem_gc as *const u8),- inc_ar: ("gecko_dsp_jit_incar_gc", runtime::dsp_increment_ar_gc as *const u8),- dec_ar: ("gecko_dsp_jit_decar_gc", runtime::dsp_decrement_ar_gc as *const u8),- increase_ar: ("gecko_dsp_jit_incrar_gc", runtime::dsp_increase_ar_gc as *const u8),- decrease_ar_ix: ("gecko_dsp_jit_decarix_gc", runtime::dsp_decrease_ar_ix_gc as *const u8),- dynamic_shift: ("gecko_dsp_jit_dynshift_gc", runtime::dsp_dynamic_shift_gc as *const u8),- read_imem: ("gecko_dsp_jit_rimem_gc", runtime::dsp_read_imem_gc as *const u8),- call_stack_push: ("gecko_dsp_jit_cspush_gc", runtime::dsp_call_stack_push_gc as *const u8),- call_stack_pop: ("gecko_dsp_jit_cspop_gc", runtime::dsp_call_stack_pop_gc as *const u8),- data_stack_pop: ("gecko_dsp_jit_dspop_gc", runtime::dsp_data_stack_pop_gc as *const u8),read_reg_full: ("gecko_dsp_jit_rdregf_gc", runtime::dsp_read_reg_full_gc as *const u8),write_reg_full: ("gecko_dsp_jit_wrregf_gc", runtime::dsp_write_reg_full_gc as *const u8),- loop_setup: ("gecko_dsp_jit_loopsetup_gc", runtime::dsp_loop_setup_gc as *const u8),},WII => Syms {- loop_tail: ("gecko_dsp_jit_loop_tail_wii", runtime::dsp_loop_tail_wii as *const u8),read_dmem: ("gecko_dsp_jit_rdmem_wii", runtime::dsp_read_dmem_wii as *const u8),write_dmem: ("gecko_dsp_jit_wdmem_wii", runtime::dsp_write_dmem_wii as *const u8),- inc_ar: ("gecko_dsp_jit_incar_wii", runtime::dsp_increment_ar_wii as *const u8),- dec_ar: ("gecko_dsp_jit_decar_wii", runtime::dsp_decrement_ar_wii as *const u8),- increase_ar: ("gecko_dsp_jit_incrar_wii", runtime::dsp_increase_ar_wii as *const u8),- decrease_ar_ix: (- "gecko_dsp_jit_decarix_wii",- runtime::dsp_decrease_ar_ix_wii as *const u8,- ),- dynamic_shift: (- "gecko_dsp_jit_dynshift_wii",- runtime::dsp_dynamic_shift_wii as *const u8,- ),- read_imem: ("gecko_dsp_jit_rimem_wii", runtime::dsp_read_imem_wii as *const u8),- call_stack_push: (- "gecko_dsp_jit_cspush_wii",- runtime::dsp_call_stack_push_wii as *const u8,- ),- call_stack_pop: ("gecko_dsp_jit_cspop_wii", runtime::dsp_call_stack_pop_wii as *const u8),- data_stack_pop: ("gecko_dsp_jit_dspop_wii", runtime::dsp_data_stack_pop_wii as *const u8),read_reg_full: ("gecko_dsp_jit_rdregf_wii", runtime::dsp_read_reg_full_wii as *const u8),write_reg_full: ("gecko_dsp_jit_wrregf_wii", runtime::dsp_write_reg_full_wii as *const u8),- loop_setup: ("gecko_dsp_jit_loopsetup_wii", runtime::dsp_loop_setup_wii as *const u8),},_ => unreachable!(),};- jit_builder.symbol(syms.loop_tail.0, syms.loop_tail.1);jit_builder.symbol(syms.read_dmem.0, syms.read_dmem.1);jit_builder.symbol(syms.write_dmem.0, syms.write_dmem.1);- jit_builder.symbol(syms.inc_ar.0, syms.inc_ar.1);- jit_builder.symbol(syms.dec_ar.0, syms.dec_ar.1);- jit_builder.symbol(syms.increase_ar.0, syms.increase_ar.1);- jit_builder.symbol(syms.decrease_ar_ix.0, syms.decrease_ar_ix.1);- jit_builder.symbol(syms.dynamic_shift.0, syms.dynamic_shift.1);- jit_builder.symbol(syms.read_imem.0, syms.read_imem.1);- jit_builder.symbol(syms.call_stack_push.0, syms.call_stack_push.1);- jit_builder.symbol(syms.call_stack_pop.0, syms.call_stack_pop.1);- jit_builder.symbol(syms.data_stack_pop.0, syms.data_stack_pop.1);jit_builder.symbol(syms.read_reg_full.0, syms.read_reg_full.1);jit_builder.symbol(syms.write_reg_full.0, syms.write_reg_full.1);- jit_builder.symbol(syms.loop_setup.0, syms.loop_setup.1);let mut module = JITModule::new(jit_builder);@@ -167,59 +114,15 @@ impl<const SYSTEM: SystemId> JitEngine<SYSTEM> {let host_cc = module.target_config().default_call_conv;let block_sig = translator::block_signature(pointer_type);- let void_thunk_sig = translator::void_thunk_signature(pointer_type, host_cc);let dmem_read_sig = translator::dmem_read_signature(pointer_type, host_cc);let dmem_write_sig = translator::dmem_write_signature(pointer_type, host_cc);- let ar_unary_sig = translator::ar_unary_signature(pointer_type, host_cc);- let ar_binary_sig = translator::ar_binary_signature(pointer_type, host_cc);- let dynamic_shift_sig = translator::dynamic_shift_signature(pointer_type, host_cc);- let loop_tail_id = module- .declare_function(syms.loop_tail.0, Linkage::Import, &void_thunk_sig)- .expect("declare loop_tail thunk");let read_dmem_id = module.declare_function(syms.read_dmem.0, Linkage::Import, &dmem_read_sig).expect("declare read_dmem thunk");let write_dmem_id = module.declare_function(syms.write_dmem.0, Linkage::Import, &dmem_write_sig).expect("declare write_dmem thunk");- let inc_ar_id = module- .declare_function(syms.inc_ar.0, Linkage::Import, &ar_unary_sig)- .expect("declare inc_ar thunk");- let dec_ar_id = module- .declare_function(syms.dec_ar.0, Linkage::Import, &ar_unary_sig)- .expect("declare dec_ar thunk");- let increase_ar_id = module- .declare_function(syms.increase_ar.0, Linkage::Import, &ar_binary_sig)- .expect("declare increase_ar thunk");- let decrease_ar_ix_id = module- .declare_function(syms.decrease_ar_ix.0, Linkage::Import, &ar_binary_sig)- .expect("declare decrease_ar_ix thunk");- let dynamic_shift_id = module- .declare_function(syms.dynamic_shift.0, Linkage::Import, &dynamic_shift_sig)- .expect("declare dynamic_shift thunk");- let read_imem_id = module- .declare_function(syms.read_imem.0, Linkage::Import, &dmem_read_sig)- .expect("declare read_imem thunk");-- let call_stack_push_sig = {- let mut sig = cranelift_codegen::ir::Signature::new(host_cc);- sig.params.push(cranelift_codegen::ir::AbiParam::new(pointer_type));- sig.params- .push(cranelift_codegen::ir::AbiParam::new(cranelift_codegen::ir::types::I32));- sig- };- let call_stack_push_id = module- .declare_function(syms.call_stack_push.0, Linkage::Import, &call_stack_push_sig)- .expect("declare call_stack_push thunk");-- let stack_pop_sig = translator::stack_pop_signature(pointer_type, host_cc);- let call_stack_pop_id = module- .declare_function(syms.call_stack_pop.0, Linkage::Import, &stack_pop_sig)- .expect("declare call_stack_pop thunk");- let data_stack_pop_id = module- .declare_function(syms.data_stack_pop.0, Linkage::Import, &stack_pop_sig)- .expect("declare data_stack_pop thunk");let read_reg_full_id = module.declare_function(syms.read_reg_full.0, Linkage::Import, &dmem_read_sig)@@ -228,30 +131,12 @@ impl<const SYSTEM: SystemId> JitEngine<SYSTEM> {let write_reg_full_id = module.declare_function(syms.write_reg_full.0, Linkage::Import, &dmem_write_sig).expect("declare write_reg_full thunk");- let loop_setup_id = module- .declare_function(- syms.loop_setup.0,- Linkage::Import,- &translator::loop_setup_signature(pointer_type, host_cc),- )- .expect("declare loop_setup thunk");let extern_funcs = translator::ExternFuncs {- loop_tail: loop_tail_id,read_dmem: read_dmem_id,write_dmem: write_dmem_id,- inc_ar: inc_ar_id,- dec_ar: dec_ar_id,- increase_ar: increase_ar_id,- decrease_ar_ix: decrease_ar_ix_id,- dynamic_shift: dynamic_shift_id,- read_imem: read_imem_id,- call_stack_push: call_stack_push_id,- call_stack_pop: call_stack_pop_id,- data_stack_pop: data_stack_pop_id,read_reg_full: read_reg_full_id,write_reg_full: write_reg_full_id,- loop_setup: loop_setup_id,};let trampoline_fn = build_trampoline(&mut module, host_cc, pointer_type, &block_sig);diff --git a/crates/gecko/src/flipper/dsp/jit/abi.rs b/crates/gecko/src/flipper/dsp/jit/abi.rsindex a2c7d13..9ae215f 100644--- a/crates/gecko/src/flipper/dsp/jit/abi.rs+++ b/crates/gecko/src/flipper/dsp/jit/abi.rs@@ -73,6 +73,10 @@ make_dsp_offset!(dsp_ax_base_offset, ax,);make_dsp_offset!(dsp_axh_base_offset, axh,);make_dsp_offset!(dsp_status_offset, status,);make_dsp_offset!(dsp_ext_ac_cache_base_offset, ext_ac_cache,);+make_dsp_offset!(dsp_call_stack_offset, call_stack,);+make_dsp_offset!(dsp_data_stack_offset, data_stack,);+make_dsp_offset!(dsp_loop_addr_offset, loop_addr,);+make_dsp_offset!(dsp_loop_counter_offset, loop_counter,);#[inline(always)]pub const fn dsp_loop_addr_ptr_offset_max() -> usize {@@ -95,6 +99,10 @@ pub const fn dsp_loop_addr_ptr_offset_max() -> usize {make_dsp_field_offset!(dsp_csr_offset, csr);make_dsp_field_offset!(dsp_chain_budget_offset, chain_budget);make_dsp_field_offset!(dsp_instr_count_offset, instr_count);+make_dsp_field_offset!(dsp_dram_ptr_offset, dram);+make_dsp_field_offset!(dsp_coef_ptr_offset, coef);+make_dsp_field_offset!(dsp_iram_ptr_offset, iram);+make_dsp_field_offset!(dsp_irom_ptr_offset, irom);const _: () = {let _ = dsp_pc_offset_max();@@ -122,6 +130,14 @@ const _: () = {let _ = dsp_loop_addr_ptr_offset_max();let _ = dsp_chain_budget_offset();let _ = dsp_instr_count_offset();+ let _ = dsp_dram_ptr_offset();+ let _ = dsp_coef_ptr_offset();+ let _ = dsp_call_stack_offset();+ let _ = dsp_data_stack_offset();+ let _ = dsp_loop_addr_offset();+ let _ = dsp_loop_counter_offset();+ let _ = dsp_iram_ptr_offset();+ let _ = dsp_irom_ptr_offset();};const _: () = {diff --git a/crates/gecko/src/flipper/dsp/jit/runtime.rs b/crates/gecko/src/flipper/dsp/jit/runtime.rsindex 478b754..0fea5ae 100644--- a/crates/gecko/src/flipper/dsp/jit/runtime.rs+++ b/crates/gecko/src/flipper/dsp/jit/runtime.rs@@ -1,49 +1,6 @@use crate::flipper::dsp::{self};use crate::system::{GC, System, SystemId, WII};-#[inline(always)]-fn cache_ext_ac<const SYSTEM: SystemId>(sys: *mut System<SYSTEM>) {- let sys = unsafe { &mut *sys };- sys.dsp.registers.cache_ext_ac();-}--pub extern "C" fn dsp_cache_ext_ac_gc(sys: *mut core::ffi::c_void) {- cache_ext_ac::<GC>(sys.cast());-}--pub extern "C" fn dsp_cache_ext_ac_wii(sys: *mut core::ffi::c_void) {- cache_ext_ac::<WII>(sys.cast());-}--#[inline(always)]-fn loop_tail<const SYSTEM: SystemId>(sys: *mut System<SYSTEM>) {- let sys = unsafe { &mut *sys };- let dsp = &mut sys.dsp;- let at_loop_end = !dsp.registers.loop_addr.is_empty() && dsp.registers.nia == dsp.registers.loop_addr.top();-- if at_loop_end {- let counter = dsp.registers.loop_counter.top().wrapping_sub(1);- if counter != 0 {- dsp.registers.loop_counter.set_top(counter);- dsp.registers.nia = dsp.registers.call_stack.top();- } else {- dsp.registers.loop_counter.pop();- dsp.registers.loop_addr.pop();- dsp.registers.call_stack.pop();- }- }-- dsp.registers.pc = dsp.registers.nia;-}--pub extern "C" fn dsp_loop_tail_gc(sys: *mut core::ffi::c_void) {- loop_tail::<GC>(sys.cast());-}--pub extern "C" fn dsp_loop_tail_wii(sys: *mut core::ffi::c_void) {- loop_tail::<WII>(sys.cast());-}-pub extern "C" fn dsp_read_dmem_gc(sys: *mut core::ffi::c_void, addr: u32) -> u32 {let sys = unsafe { &mut *(sys as *mut System<GC>) };dsp::read_dmem(sys, addr as u16) as u32@@ -64,143 +21,6 @@ pub extern "C" fn dsp_write_dmem_wii(sys: *mut core::ffi::c_void, addr: u32, valdsp::write_dmem(sys, addr as u16, value as u16);}-pub extern "C" fn dsp_increment_ar_gc(sys: *mut core::ffi::c_void, reg: u32) -> u32 {- let sys = unsafe { &mut *(sys as *mut System<GC>) };- sys.dsp.registers.increment_ar(reg as usize) as u32-}--pub extern "C" fn dsp_increment_ar_wii(sys: *mut core::ffi::c_void, reg: u32) -> u32 {- let sys = unsafe { &mut *(sys as *mut System<WII>) };- sys.dsp.registers.increment_ar(reg as usize) as u32-}--pub extern "C" fn dsp_decrement_ar_gc(sys: *mut core::ffi::c_void, reg: u32) -> u32 {- let sys = unsafe { &mut *(sys as *mut System<GC>) };- sys.dsp.registers.decrement_ar(reg as usize) as u32-}--pub extern "C" fn dsp_decrement_ar_wii(sys: *mut core::ffi::c_void, reg: u32) -> u32 {- let sys = unsafe { &mut *(sys as *mut System<WII>) };- sys.dsp.registers.decrement_ar(reg as usize) as u32-}--pub extern "C" fn dsp_increase_ar_gc(sys: *mut core::ffi::c_void, reg: u32, ix: u32) -> u32 {- let sys = unsafe { &mut *(sys as *mut System<GC>) };- sys.dsp.registers.increase_ar(reg as usize, ix as i16) as u32-}--pub extern "C" fn dsp_increase_ar_wii(sys: *mut core::ffi::c_void, reg: u32, ix: u32) -> u32 {- let sys = unsafe { &mut *(sys as *mut System<WII>) };- sys.dsp.registers.increase_ar(reg as usize, ix as i16) as u32-}--pub extern "C" fn dsp_decrease_ar_ix_gc(sys: *mut core::ffi::c_void, reg: u32, ix: u32) -> u32 {- let sys = unsafe { &mut *(sys as *mut System<GC>) };- sys.dsp.registers.decrease_ar_ix(reg as usize, ix as i16) as u32-}--pub extern "C" fn dsp_decrease_ar_ix_wii(sys: *mut core::ffi::c_void, reg: u32, ix: u32) -> u32 {- let sys = unsafe { &mut *(sys as *mut System<WII>) };- sys.dsp.registers.decrease_ar_ix(reg as usize, ix as i16) as u32-}--#[inline(always)]-fn dynamic_shift_impl<const SYSTEM: SystemId>(sys: *mut System<SYSTEM>, d: u32, shift_val: u32, mode: u32) {- let logical = mode & 1 != 0;- let reversed = mode & 2 != 0;-- let sys = unsafe { &mut *sys };-- let regs = &mut sys.dsp.registers;- let shift_val = shift_val as 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 };- let dn = d as u8;-- if shift_left {- let ac = ((regs.ac(dn) as u64 & 0xFF_FFFF_FFFF) << amount) as i64;- regs.set_ac(dn, ac);- } else if amount != 0 {- let ac = if logical {- ((regs.ac(dn) as u64 & 0xFF_FFFF_FFFF) >> amount) as i64- } else {- regs.ac(dn) >> amount- };- regs.set_ac(dn, ac);- }-- let ac = regs.ac(dn);- regs.update_flags_ac(ac);- regs.status.set_o(false);- regs.status.set_c(false);-}--pub extern "C" fn dsp_dynamic_shift_gc(sys: *mut core::ffi::c_void, d: u32, shift_val: u32, mode: u32) {- dynamic_shift_impl::<GC>(sys.cast(), d, shift_val, mode);-}--pub extern "C" fn dsp_dynamic_shift_wii(sys: *mut core::ffi::c_void, d: u32, shift_val: u32, mode: u32) {- dynamic_shift_impl::<WII>(sys.cast(), d, shift_val, mode);-}--#[inline(always)]-fn read_imem<const SYSTEM: SystemId>(sys: *mut System<SYSTEM>, addr: u32) -> u32 {- let sys = unsafe { &mut *sys };- sys.dsp.read_imem(addr as u16) as u32-}--pub extern "C" fn dsp_read_imem_gc(sys: *mut core::ffi::c_void, addr: u32) -> u32 {- read_imem::<GC>(sys.cast(), addr)-}--pub extern "C" fn dsp_read_imem_wii(sys: *mut core::ffi::c_void, addr: u32) -> u32 {- read_imem::<WII>(sys.cast(), addr)-}--#[inline(always)]-fn call_stack_push<const SYSTEM: SystemId>(sys: *mut System<SYSTEM>, value: u32) {- let sys = unsafe { &mut *sys };- sys.dsp.registers.call_stack.push(value as u16);-}--pub extern "C" fn dsp_call_stack_push_gc(sys: *mut core::ffi::c_void, value: u32) {- call_stack_push::<GC>(sys.cast(), value);-}--pub extern "C" fn dsp_call_stack_push_wii(sys: *mut core::ffi::c_void, value: u32) {- call_stack_push::<WII>(sys.cast(), value);-}--#[inline(always)]-fn call_stack_pop<const SYSTEM: SystemId>(sys: *mut System<SYSTEM>) -> u32 {- let sys = unsafe { &mut *sys };- sys.dsp.registers.call_stack.pop() as u32-}--#[inline(always)]-fn data_stack_pop<const SYSTEM: SystemId>(sys: *mut System<SYSTEM>) -> u32 {- let sys = unsafe { &mut *sys };- sys.dsp.registers.data_stack.pop() as u32-}--pub extern "C" fn dsp_call_stack_pop_gc(sys: *mut core::ffi::c_void) -> u32 {- call_stack_pop::<GC>(sys.cast())-}--pub extern "C" fn dsp_call_stack_pop_wii(sys: *mut core::ffi::c_void) -> u32 {- call_stack_pop::<WII>(sys.cast())-}--pub extern "C" fn dsp_data_stack_pop_gc(sys: *mut core::ffi::c_void) -> u32 {- data_stack_pop::<GC>(sys.cast())-}--pub extern "C" fn dsp_data_stack_pop_wii(sys: *mut core::ffi::c_void) -> u32 {- data_stack_pop::<WII>(sys.cast())-}-#[inline(always)]fn read_reg_full<const SYSTEM: SystemId>(sys: *mut System<SYSTEM>, slot: u32) -> u32 {let sys = unsafe { &mut *sys };@@ -228,25 +48,3 @@ pub extern "C" fn dsp_write_reg_full_gc(sys: *mut core::ffi::c_void, slot: u32,pub extern "C" fn dsp_write_reg_full_wii(sys: *mut core::ffi::c_void, slot: u32, value: u32) {write_reg_full::<WII>(sys.cast(), slot, value);}--#[inline(always)]-fn loop_setup<const SYSTEM: SystemId>(sys: *mut System<SYSTEM>, end_addr_p1: u32, counter: u32, call_stack_val: u32) {- let sys = unsafe { &mut *sys };- let regs = &mut sys.dsp.registers;-- if counter != 0 {- regs.call_stack.push(call_stack_val as u16);- regs.loop_addr.push(end_addr_p1 as u16);- regs.loop_counter.push(counter as u16);- } else {- regs.nia = end_addr_p1 as u16;- }-}--pub extern "C" fn dsp_loop_setup_gc(sys: *mut core::ffi::c_void, end_addr_p1: u32, counter: u32, call_stack_val: u32) {- loop_setup::<GC>(sys.cast(), end_addr_p1, counter, call_stack_val);-}--pub extern "C" fn dsp_loop_setup_wii(sys: *mut core::ffi::c_void, end_addr_p1: u32, counter: u32, call_stack_val: u32) {- loop_setup::<WII>(sys.cast(), end_addr_p1, counter, call_stack_val);-}diff --git a/crates/gecko/src/flipper/dsp/jit/translate.rs b/crates/gecko/src/flipper/dsp/jit/translate.rsindex 4a11363..271d229 100644--- a/crates/gecko/src/flipper/dsp/jit/translate.rs+++ b/crates/gecko/src/flipper/dsp/jit/translate.rs@@ -574,75 +574,320 @@ impl<'a, 'b> TranslatorCtx<'a, 'b> {self.store_status_bits(bits, !0x003C_i64);}+ fn emit_dmem_word_addr(&mut self, ptr_field_offset: usize, addr: Value, word_bias: i64) -> Value {+ let base = self.builder.ins().load(+ types::I64,+ MemFlagsData::trusted(),+ self.sys_ptr,+ ptr_field_offset as i32,+ );++ let biased = if word_bias != 0 {+ self.builder.ins().iadd_imm(addr, word_bias)+ } else {+ addr+ };+ let addr64 = self.builder.ins().uextend(types::I64, biased);+ let byte_off = self.builder.ins().ishl_imm(addr64, 1);++ self.builder.ins().iadd(base, byte_off)+ }+pub fn emit_read_dmem(&mut self, addr_u32: Value) -> Value {+ use cranelift_codegen::ir::BlockArg;+ use cranelift_codegen::ir::condcodes::IntCC;++ let addr = self.builder.ins().band_imm(addr_u32, 0xFFFF);++ let dram_block = self.builder.create_block();+ let not_dram_block = self.builder.create_block();+ let coef_block = self.builder.create_block();+ let slow_block = self.builder.create_block();+ let merge_block = self.builder.create_block();+ self.builder.append_block_param(merge_block, types::I32);++ let is_dram = self.builder.ins().icmp_imm(IntCC::UnsignedLessThan, addr, 0x1000);+ self.builder.ins().brif(is_dram, dram_block, &[], not_dram_block, &[]);++ self.builder.switch_to_block(dram_block);+ self.builder.seal_block(dram_block);+ let p = self.emit_dmem_word_addr(abi::dsp_dram_ptr_offset(), addr, 0);+ let raw = self.builder.ins().load(types::I16, MemFlagsData::trusted(), p, 0);+ let be = self.builder.ins().bswap(raw);+ let v = self.builder.ins().uextend(types::I32, be);+ self.builder.ins().jump(merge_block, &[BlockArg::Value(v)]);++ self.builder.switch_to_block(not_dram_block);+ self.builder.seal_block(not_dram_block);+ let is_coef = self.builder.ins().icmp_imm(IntCC::UnsignedLessThan, addr, 0x2000);+ self.builder.ins().brif(is_coef, coef_block, &[], slow_block, &[]);++ self.builder.switch_to_block(coef_block);+ self.builder.seal_block(coef_block);+ let p = self.emit_dmem_word_addr(abi::dsp_coef_ptr_offset(), addr, -0x1000);+ let raw = self.builder.ins().load(types::I16, MemFlagsData::trusted(), p, 0);+ let be = self.builder.ins().bswap(raw);+ let v = self.builder.ins().uextend(types::I32, be);+ self.builder.ins().jump(merge_block, &[BlockArg::Value(v)]);++ self.builder.switch_to_block(slow_block);+ self.builder.seal_block(slow_block);let f = self.module.declare_func_in_func(self.extern_funcs.read_dmem, self.builder.func);- let inst = self.builder.ins().call(f, &[self.sys_ptr, addr_u32]);- self.builder.inst_results(inst)[0]+ let inst = self.builder.ins().call(f, &[self.sys_ptr, addr]);+ let v = self.builder.inst_results(inst)[0];+ self.builder.ins().jump(merge_block, &[BlockArg::Value(v)]);++ self.builder.switch_to_block(merge_block);+ self.builder.seal_block(merge_block);+ self.builder.block_params(merge_block)[0]}pub fn emit_write_dmem(&mut self, addr_u32: Value, value_u32: Value) {+ use cranelift_codegen::ir::condcodes::IntCC;++ let addr = self.builder.ins().band_imm(addr_u32, 0xFFFF);++ let dram_block = self.builder.create_block();+ let slow_block = self.builder.create_block();+ let merge_block = self.builder.create_block();++ let is_dram = self.builder.ins().icmp_imm(IntCC::UnsignedLessThan, addr, 0x1000);+ self.builder.ins().brif(is_dram, dram_block, &[], slow_block, &[]);++ self.builder.switch_to_block(dram_block);+ self.builder.seal_block(dram_block);+ let p = self.emit_dmem_word_addr(abi::dsp_dram_ptr_offset(), addr, 0);+ let v16 = self.builder.ins().ireduce(types::I16, value_u32);+ let be = self.builder.ins().bswap(v16);+ self.builder.ins().store(MemFlagsData::trusted(), be, p, 0);+ self.builder.ins().jump(merge_block, &[]);++ self.builder.switch_to_block(slow_block);+ self.builder.seal_block(slow_block);let f = self.module.declare_func_in_func(self.extern_funcs.write_dmem, self.builder.func);- self.builder.ins().call(f, &[self.sys_ptr, addr_u32, value_u32]);+ self.builder.ins().call(f, &[self.sys_ptr, addr, value_u32]);+ self.builder.ins().jump(merge_block, &[]);++ self.builder.switch_to_block(merge_block);+ self.builder.seal_block(merge_block);+ }++ fn load_ar_wr_u32(&mut self, reg: u32) -> (Value, Value) {+ let ar_off = (abi::dsp_ar_base_offset() + reg as usize * 2) as i32;+ let wr_off = (abi::dsp_wr_base_offset() + reg as usize * 2) as i32;+ let ar16 = self.load_u16(ar_off);+ let wr16 = self.load_u16(wr_off);+ let ar = self.builder.ins().uextend(types::I32, ar16);+ let wr = self.builder.ins().uextend(types::I32, wr16);+ (ar, wr)}pub fn emit_inc_ar(&mut self, reg: u32) -> Value {- let f = self- .module- .declare_func_in_func(self.extern_funcs.inc_ar, self.builder.func);- let reg_v = self.builder.ins().iconst(types::I32, reg as i64);- let inst = self.builder.ins().call(f, &[self.sys_ptr, reg_v]);- self.builder.inst_results(inst)[0]+ use cranelift_codegen::ir::condcodes::IntCC;++ let (ar, wr) = self.load_ar_wr_u32(reg);++ let nar = self.builder.ins().iadd_imm(ar, 1);+ let x = self.builder.ins().bxor(nar, ar);+ let wr_or1 = self.builder.ins().bor_imm(wr, 1);+ let limit = self.builder.ins().ishl_imm(wr_or1, 1);+ let wrap = self.builder.ins().icmp(IntCC::UnsignedGreaterThan, x, limit);++ let wrp1 = self.builder.ins().iadd_imm(wr, 1);+ let wrapped = self.builder.ins().isub(nar, wrp1);+ let res = self.builder.ins().select(wrap, wrapped, nar);+ self.builder.ins().band_imm(res, 0xFFFF)}pub fn emit_dec_ar(&mut self, reg: u32) -> Value {- let f = self- .module- .declare_func_in_func(self.extern_funcs.dec_ar, self.builder.func);- let reg_v = self.builder.ins().iconst(types::I32, reg as i64);- let inst = self.builder.ins().call(f, &[self.sys_ptr, reg_v]);- self.builder.inst_results(inst)[0]+ use cranelift_codegen::ir::condcodes::IntCC;++ let (ar, wr) = self.load_ar_wr_u32(reg);++ let nar = self.builder.ins().iadd(ar, wr);+ let x = self.builder.ins().bxor(nar, ar);+ let wr_or1 = self.builder.ins().bor_imm(wr, 1);+ let limit = self.builder.ins().ishl_imm(wr_or1, 1);+ let masked = self.builder.ins().band(x, limit);+ let wrap = self.builder.ins().icmp(IntCC::UnsignedGreaterThan, masked, wr);++ let wrp1 = self.builder.ins().iadd_imm(wr, 1);+ let wrapped = self.builder.ins().isub(nar, wrp1);+ let res = self.builder.ins().select(wrap, wrapped, nar);+ self.builder.ins().band_imm(res, 0xFFFF)}pub fn emit_increase_ar(&mut self, reg: u32, ix_value: Value) -> Value {- let f = self- .module- .declare_func_in_func(self.extern_funcs.increase_ar, self.builder.func);- let reg_v = self.builder.ins().iconst(types::I32, reg as i64);- let ix_u32 = self.builder.ins().uextend(types::I32, ix_value);- let inst = self.builder.ins().call(f, &[self.sys_ptr, reg_v, ix_u32]);- self.builder.inst_results(inst)[0]+ use cranelift_codegen::ir::condcodes::IntCC;++ let (ar, wr) = self.load_ar_wr_u32(reg);+ let ixs = self.builder.ins().sextend(types::I32, ix_value);++ let nar = self.builder.ins().iadd(ar, ixs);+ let x1 = self.builder.ins().bxor(nar, ar);+ let x2 = self.builder.ins().bxor(x1, ixs);+ let wr_or1 = self.builder.ins().bor_imm(wr, 1);+ let mx = self.builder.ins().ishl_imm(wr_or1, 1);+ let dar = self.builder.ins().band(x2, mx);+ let wrp1 = self.builder.ins().iadd_imm(wr, 1);++ let pos_wrap = self.builder.ins().icmp(IntCC::UnsignedGreaterThan, dar, wr);+ let pos_wrapped = self.builder.ins().isub(nar, wrp1);+ let res_pos = self.builder.ins().select(pos_wrap, pos_wrapped, nar);++ let t = self.builder.ins().iadd(nar, wrp1);+ let tx = self.builder.ins().bxor(t, nar);+ let u = self.builder.ins().band(tx, dar);+ let neg_wrap = self.builder.ins().icmp(IntCC::UnsignedLessThanOrEqual, u, wr);+ let res_neg = self.builder.ins().select(neg_wrap, t, nar);++ let ge0 = self.builder.ins().icmp_imm(IntCC::SignedGreaterThanOrEqual, ixs, 0);+ let res = self.builder.ins().select(ge0, res_pos, res_neg);+ self.builder.ins().band_imm(res, 0xFFFF)}pub fn emit_decrease_ar_ix(&mut self, reg: u32, ix_value: Value) -> Value {- let f = self- .module- .declare_func_in_func(self.extern_funcs.decrease_ar_ix, self.builder.func);- let reg_v = self.builder.ins().iconst(types::I32, reg as i64);- let ix_u32 = self.builder.ins().uextend(types::I32, ix_value);- let inst = self.builder.ins().call(f, &[self.sys_ptr, reg_v, ix_u32]);- self.builder.inst_results(inst)[0]+ use cranelift_codegen::ir::condcodes::IntCC;++ let (ar, wr) = self.load_ar_wr_u32(reg);++ let v16 = self.builder.ins().bnot(ix_value);+ let vs = self.builder.ins().sextend(types::I32, v16);+ let vu = self.builder.ins().band_imm(vs, 0xFFFF);++ let clz = self.builder.ins().clz(wr);+ let thirty_two = self.builder.ins().iconst(types::I32, 32);+ let n_raw = self.builder.ins().isub(thirty_two, clz);+ let one = self.builder.ins().iconst(types::I32, 1);+ let n = self.builder.ins().smax(n_raw, one);+ let shifted = self.builder.ins().ishl(one, n);+ let mask = self.builder.ins().iadd_imm(shifted, -1);++ let am = self.builder.ins().band(ar, mask);+ let vm = self.builder.ins().band(vu, mask);+ let avm = self.builder.ins().iadd(am, vm);+ let sum = self.builder.ins().iadd_imm(avm, 1);+ let carry = self.builder.ins().icmp(IntCC::UnsignedGreaterThan, sum, mask);++ let arv = self.builder.ins().iadd(ar, vs);+ let r0 = self.builder.ins().iadd_imm(arv, 1);+ let r = self.builder.ins().band_imm(r0, 0xFFFF);+ let wrp1_raw = self.builder.ins().iadd_imm(wr, 1);+ let wrp1 = self.builder.ins().band_imm(wrp1_raw, 0xFFFF);++ let vp1 = self.builder.ins().iadd_imm(v16, 1);+ let gt0 = self.builder.ins().icmp_imm(IntCC::SignedGreaterThan, vp1, 0);+ let ismin = self.builder.ins().icmp_imm(IntCC::Equal, vp1, -32768);+ let cond_pos = self.builder.ins().bor(gt0, ismin);++ let r_sub_raw = self.builder.ins().isub(r, wrp1);+ let r_sub = self.builder.ins().band_imm(r_sub_raw, 0xFFFF);+ let rp = self.builder.ins().select(carry, r_sub, r);++ let low_sum = self.builder.ins().band(r, mask);+ let not_wr_raw = self.builder.ins().bnot(wr);+ let not_wr = self.builder.ins().band_imm(not_wr_raw, 0xFFFF);+ let low_not_wrap = self.builder.ins().band(not_wr, mask);+ let carry_again = self.builder.ins().icmp(IntCC::UnsignedLessThan, low_sum, low_not_wrap);+ let ncarry = self.builder.ins().bxor_imm(carry, 1);+ let cond_add = self.builder.ins().bor(ncarry, carry_again);+ let r_add_raw = self.builder.ins().iadd(r, wrp1);+ let r_add = self.builder.ins().band_imm(r_add_raw, 0xFFFF);+ let rn = self.builder.ins().select(cond_add, r_add, r);++ self.builder.ins().select(cond_pos, rp, rn)}pub fn emit_dynamic_shift(&mut self, d_const: u32, shift_val: Value, mode_const: u32) {- let f = self- .module- .declare_func_in_func(self.extern_funcs.dynamic_shift, self.builder.func);- let d_v = self.builder.ins().iconst(types::I32, d_const as i64);- let shift_u32 = self.builder.ins().uextend(types::I32, shift_val);- let mode_v = self.builder.ins().iconst(types::I32, mode_const as i64);- self.builder.ins().call(f, &[self.sys_ptr, d_v, shift_u32, mode_v]);+ use cranelift_codegen::ir::condcodes::IntCC;++ let logical = mode_const & 1 != 0;+ let reversed = mode_const & 2 != 0;++ let sv = self.builder.ins().uextend(types::I64, shift_val);+ let low6 = self.builder.ins().band_imm(sv, 63);+ let bit6_raw = self.builder.ins().band_imm(sv, 64);+ let bit6 = self.builder.ins().icmp_imm(IntCC::NotEqual, bit6_raw, 0);++ let sixty_four = self.builder.ins().iconst(types::I64, 64);+ let rev_amount_raw = self.builder.ins().isub(sixty_four, low6);+ let rev_amount = self.builder.ins().band_imm(rev_amount_raw, 63);+ let amount = self.builder.ins().select(bit6, rev_amount, low6);++ let shift_left = if reversed {+ self.builder.ins().bxor_imm(bit6, 1)+ } else {+ bit6+ };++ let ac = self.read_ac_i64(d_const as u8);+ let ac40 = self.builder.ins().band_imm(ac, 0xFF_FFFF_FFFF_i64);++ let left = self.builder.ins().ishl(ac40, amount);+ let right = if logical {+ self.builder.ins().ushr(ac40, amount)+ } else {+ self.builder.ins().sshr(ac, amount)+ };+ let result = self.builder.ins().select(shift_left, left, right);+ self.write_ac_i64(d_const as u8, result);++ let new_ac = self.read_ac_i64(d_const as u8);+ let r40 = self.builder.ins().band_imm(new_ac, 0xFF_FFFF_FFFF_i64);+ let bits = self.flags40_szat(r40);+ self.store_status_bits(bits, !0x003F_i64);}pub fn emit_read_imem(&mut self, addr_u32: Value) -> Value {- let f = self- .module- .declare_func_in_func(self.extern_funcs.read_imem, self.builder.func);- let inst = self.builder.ins().call(f, &[self.sys_ptr, addr_u32]);- self.builder.inst_results(inst)[0]+ use cranelift_codegen::ir::BlockArg;+ use cranelift_codegen::ir::condcodes::IntCC;++ let addr = self.builder.ins().band_imm(addr_u32, 0xFFFF);++ let iram_block = self.builder.create_block();+ let not_iram_block = self.builder.create_block();+ let irom_block = self.builder.create_block();+ let zero_block = self.builder.create_block();+ let merge_block = self.builder.create_block();+ self.builder.append_block_param(merge_block, types::I32);++ let is_iram = self.builder.ins().icmp_imm(IntCC::UnsignedLessThan, addr, 0x1000);+ self.builder.ins().brif(is_iram, iram_block, &[], not_iram_block, &[]);++ self.builder.switch_to_block(iram_block);+ self.builder.seal_block(iram_block);+ let p = self.emit_dmem_word_addr(abi::dsp_iram_ptr_offset(), addr, 0);+ let raw = self.builder.ins().load(types::I16, MemFlagsData::trusted(), p, 0);+ let be = self.builder.ins().bswap(raw);+ let v = self.builder.ins().uextend(types::I32, be);+ self.builder.ins().jump(merge_block, &[BlockArg::Value(v)]);++ self.builder.switch_to_block(not_iram_block);+ self.builder.seal_block(not_iram_block);+ let bank = self.builder.ins().band_imm(addr, 0xF000);+ let is_irom = self.builder.ins().icmp_imm(IntCC::Equal, bank, 0x8000);+ self.builder.ins().brif(is_irom, irom_block, &[], zero_block, &[]);++ self.builder.switch_to_block(irom_block);+ self.builder.seal_block(irom_block);+ let p = self.emit_dmem_word_addr(abi::dsp_irom_ptr_offset(), addr, -0x8000);+ let raw = self.builder.ins().load(types::I16, MemFlagsData::trusted(), p, 0);+ let be = self.builder.ins().bswap(raw);+ let v = self.builder.ins().uextend(types::I32, be);+ self.builder.ins().jump(merge_block, &[BlockArg::Value(v)]);++ self.builder.switch_to_block(zero_block);+ self.builder.seal_block(zero_block);+ let zero = self.builder.ins().iconst(types::I32, 0);+ self.builder.ins().jump(merge_block, &[BlockArg::Value(zero)]);++ self.builder.switch_to_block(merge_block);+ self.builder.seal_block(merge_block);+ self.builder.block_params(merge_block)[0]}pub fn emit_write_ac_mid_sxm(&mut self, idx: u32, value: Value) {@@ -686,28 +931,71 @@ impl<'a, 'b> TranslatorCtx<'a, 'b> {self.builder.seal_block(join_block);}+ fn stack_slot_addr(&mut self, ptr_v: Value) -> Value {+ let idx = self.builder.ins().uextend(types::I64, ptr_v);+ let byte_off = self.builder.ins().ishl_imm(idx, 1);+ self.builder.ins().iadd(self.sys_ptr, byte_off)+ }++ fn emit_stack_push(&mut self, base: usize, value16: Value) {+ use crate::flipper::dsp::core::stack::DspStack;++ let data_off = (base + DspStack::<32>::data_offset()) as i32;+ let ptr_off = (base + DspStack::<32>::ptr_offset()) as i32;++ let ptr = self+ .builder+ .ins()+ .load(types::I8, MemFlagsData::trusted(), self.sys_ptr, ptr_off);+ let inc = self.builder.ins().iadd_imm(ptr, 1);+ let new_ptr = self.builder.ins().band_imm(inc, 31);+ self.builder+ .ins()+ .store(MemFlagsData::trusted(), new_ptr, self.sys_ptr, ptr_off);++ let addr = self.stack_slot_addr(new_ptr);+ self.builder+ .ins()+ .store(MemFlagsData::trusted(), value16, addr, data_off);+ }++ fn emit_stack_pop_value(&mut self, base: usize) -> Value {+ use crate::flipper::dsp::core::stack::DspStack;++ let data_off = (base + DspStack::<32>::data_offset()) as i32;+ let ptr_off = (base + DspStack::<32>::ptr_offset()) as i32;++ let ptr = self+ .builder+ .ins()+ .load(types::I8, MemFlagsData::trusted(), self.sys_ptr, ptr_off);+ let addr = self.stack_slot_addr(ptr);+ let value = self+ .builder+ .ins()+ .load(types::I16, MemFlagsData::trusted(), addr, data_off);++ let dec = self.builder.ins().iadd_imm(ptr, -1);+ let new_ptr = self.builder.ins().band_imm(dec, 31);+ self.builder+ .ins()+ .store(MemFlagsData::trusted(), new_ptr, self.sys_ptr, ptr_off);++ value+ }+pub fn emit_call_stack_push(&mut self, value: Value) {- let f = self- .module- .declare_func_in_func(self.extern_funcs.call_stack_push, self.builder.func);- let v_u32 = self.builder.ins().uextend(types::I32, value);- self.builder.ins().call(f, &[self.sys_ptr, v_u32]);+ self.emit_stack_push(abi::dsp_call_stack_offset(), value);}pub fn emit_call_stack_pop(&mut self) -> Value {- let f = self- .module- .declare_func_in_func(self.extern_funcs.call_stack_pop, self.builder.func);- let inst = self.builder.ins().call(f, &[self.sys_ptr]);- self.builder.inst_results(inst)[0]+ let v = self.emit_stack_pop_value(abi::dsp_call_stack_offset());+ self.builder.ins().uextend(types::I32, v)}pub fn emit_data_stack_pop(&mut self) -> Value {- let f = self- .module- .declare_func_in_func(self.extern_funcs.data_stack_pop, self.builder.func);- let inst = self.builder.ins().call(f, &[self.sys_ptr]);- self.builder.inst_results(inst)[0]+ let v = self.emit_stack_pop_value(abi::dsp_data_stack_offset());+ self.builder.ins().uextend(types::I32, v)}pub fn emit_read_reg_full(&mut self, slot: u32) -> Value {@@ -744,13 +1032,32 @@ impl<'a, 'b> TranslatorCtx<'a, 'b> {}pub fn emit_loop_setup(&mut self, end_addr_p1: u16, counter: Value, call_stack_val: u16) {- let f = self- .module- .declare_func_in_func(self.extern_funcs.loop_setup, self.builder.func);- let end_v = self.builder.ins().iconst(types::I32, end_addr_p1 as i64);- let counter_u32 = self.builder.ins().uextend(types::I32, counter);- let csv_v = self.builder.ins().iconst(types::I32, call_stack_val as i64);- self.builder.ins().call(f, &[self.sys_ptr, end_v, counter_u32, csv_v]);+ use cranelift_codegen::ir::condcodes::IntCC;++ let push_block = self.builder.create_block();+ let skip_block = self.builder.create_block();+ let merge_block = self.builder.create_block();++ let nz = self.builder.ins().icmp_imm(IntCC::NotEqual, counter, 0);+ self.builder.ins().brif(nz, push_block, &[], skip_block, &[]);++ self.builder.switch_to_block(push_block);+ self.builder.seal_block(push_block);+ let csv = self.iconst16(call_stack_val);+ self.emit_stack_push(abi::dsp_call_stack_offset(), csv);+ let eap = self.iconst16(end_addr_p1);+ self.emit_stack_push(abi::dsp_loop_addr_offset(), eap);+ self.emit_stack_push(abi::dsp_loop_counter_offset(), counter);+ self.builder.ins().jump(merge_block, &[]);++ self.builder.switch_to_block(skip_block);+ self.builder.seal_block(skip_block);+ let eap = self.iconst16(end_addr_p1);+ self.store_u16(eap, abi::dsp_nia_offset_max() as i32);+ self.builder.ins().jump(merge_block, &[]);++ self.builder.switch_to_block(merge_block);+ self.builder.seal_block(merge_block);}pub fn emit_clear_oc(&mut self) {diff --git a/crates/gecko/src/flipper/dsp/jit/translator.rs b/crates/gecko/src/flipper/dsp/jit/translator.rsindex 3972116..f102885 100644--- a/crates/gecko/src/flipper/dsp/jit/translator.rs+++ b/crates/gecko/src/flipper/dsp/jit/translator.rs@@ -1,5 +1,5 @@use cranelift_codegen::Context;-use cranelift_codegen::ir::{AbiParam, InstBuilder, Signature, Value, types};+use cranelift_codegen::ir::{AbiParam, BlockArg, InstBuilder, Signature, Value, types};use cranelift_codegen::isa::CallConv;use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};use cranelift_jit::JITModule;@@ -8,21 +8,10 @@ use cranelift_module::{FuncId, Module};use super::block::{BlockSpec, TermKind};#[derive(Clone, Copy)]pub struct ExternFuncs {- pub loop_tail: FuncId,pub read_dmem: FuncId,pub write_dmem: FuncId,- pub inc_ar: FuncId,- pub dec_ar: FuncId,- pub increase_ar: FuncId,- pub decrease_ar_ix: FuncId,- pub dynamic_shift: FuncId,- pub read_imem: FuncId,- pub call_stack_push: FuncId,- pub call_stack_pop: FuncId,- pub data_stack_pop: FuncId,pub read_reg_full: FuncId,pub write_reg_full: FuncId,- pub loop_setup: FuncId,}pub fn translate(@@ -45,13 +34,18 @@ pub fn translate(let ctx_ptr: Value = builder.block_params(entry)[0];+ use crate::flipper::dsp::core::stack::DspStack;use crate::flipper::dsp::instruction::Instruction;use crate::flipper::dsp::jit::{jit_lut, translate as t};use cranelift_codegen::ir::MemFlagsData;let nia_offset = super::abi::dsp_nia_offset_max() as i32;let pc_offset = super::abi::dsp_pc_offset_max() as i32;let loop_addr_ptr_offset = super::abi::dsp_loop_addr_ptr_offset_max() as i32;- let loop_tail_ref = module.declare_func_in_func(extern_funcs.loop_tail, builder.func);+ let loop_addr_data_offset = (super::abi::dsp_loop_addr_offset() + DspStack::<32>::data_offset()) as i32;+ let loop_counter_ptr_offset = (super::abi::dsp_loop_counter_offset() + DspStack::<32>::ptr_offset()) as i32;+ let loop_counter_data_offset = (super::abi::dsp_loop_counter_offset() + DspStack::<32>::data_offset()) as i32;+ let call_stack_ptr_offset = (super::abi::dsp_call_stack_offset() + DspStack::<32>::ptr_offset()) as i32;+ let call_stack_data_offset = (super::abi::dsp_call_stack_offset() + DspStack::<32>::data_offset()) as i32;if let Some(addr) = entry_counter_addr {let slot_v = builder.ins().iconst(types::I64, addr as i64);@@ -132,17 +126,101 @@ pub fn translate(builder.switch_to_block(slow_block);builder.seal_block(slow_block);- builder.ins().call(loop_tail_ref, &[ctx_ptr]);- // After loop_tail, PC may have been redirected (jump back from loop iteration).- // If PC != natural_nia, exit the block early so the chain link can dispatch- // the correct next block. Otherwise, fall through to the next instruction.- let pc_after = builder+ // Inline loop_tail: when nia matches the active loop's end address,+ // either decrement the counter and jump back to the loop top (from the+ // call stack), or pop all three loop stacks once the count runs out.+ // If the final nia != natural_nia, exit the block early so the chain+ // link can dispatch the correct next block.+ let loopend_block = builder.create_block();+ let cont_loop_block = builder.create_block();+ let pop_block = builder.create_block();+ let finish_block = builder.create_block();+ builder.append_block_param(finish_block, types::I16);++ let nia_cur = builder.ins()- .load(types::I16, MemFlagsData::trusted(), ctx_ptr, pc_offset);+ .load(types::I16, MemFlagsData::trusted(), ctx_ptr, nia_offset);+ let la_idx = builder.ins().uextend(types::I64, loop_ptr);+ let la_byte = builder.ins().ishl_imm(la_idx, 1);+ let la_addr = builder.ins().iadd(ctx_ptr, la_byte);+ let la_top = builder+ .ins()+ .load(types::I16, MemFlagsData::trusted(), la_addr, loop_addr_data_offset);+ let at_end = builder+ .ins()+ .icmp(cranelift_codegen::ir::condcodes::IntCC::Equal, nia_cur, la_top);+ builder+ .ins()+ .brif(at_end, loopend_block, &[], finish_block, &[BlockArg::Value(nia_cur)]);++ builder.switch_to_block(loopend_block);+ builder.seal_block(loopend_block);+ let lc_ptr = builder+ .ins()+ .load(types::I8, MemFlagsData::trusted(), ctx_ptr, loop_counter_ptr_offset);+ let lc_idx = builder.ins().uextend(types::I64, lc_ptr);+ let lc_byte = builder.ins().ishl_imm(lc_idx, 1);+ let lc_addr = builder.ins().iadd(ctx_ptr, lc_byte);+ let counter = builder+ .ins()+ .load(types::I16, MemFlagsData::trusted(), lc_addr, loop_counter_data_offset);+ let cnt1 = builder.ins().iadd_imm(counter, -1);+ let nz = builder+ .ins()+ .icmp_imm(cranelift_codegen::ir::condcodes::IntCC::NotEqual, cnt1, 0);+ builder.ins().brif(nz, cont_loop_block, &[], pop_block, &[]);++ builder.switch_to_block(cont_loop_block);+ builder.seal_block(cont_loop_block);+ builder+ .ins()+ .store(MemFlagsData::trusted(), cnt1, lc_addr, loop_counter_data_offset);+ let cs_ptr = builder+ .ins()+ .load(types::I8, MemFlagsData::trusted(), ctx_ptr, call_stack_ptr_offset);+ let cs_idx = builder.ins().uextend(types::I64, cs_ptr);+ let cs_byte = builder.ins().ishl_imm(cs_idx, 1);+ let cs_addr = builder.ins().iadd(ctx_ptr, cs_byte);+ let cs_top = builder+ .ins()+ .load(types::I16, MemFlagsData::trusted(), cs_addr, call_stack_data_offset);+ builder.ins().jump(finish_block, &[BlockArg::Value(cs_top)]);++ builder.switch_to_block(pop_block);+ builder.seal_block(pop_block);+ let lc_dec = builder.ins().iadd_imm(lc_ptr, -1);+ let lc_new = builder.ins().band_imm(lc_dec, 31);+ builder+ .ins()+ .store(MemFlagsData::trusted(), lc_new, ctx_ptr, loop_counter_ptr_offset);+ let la_dec = builder.ins().iadd_imm(loop_ptr, -1);+ let la_new = builder.ins().band_imm(la_dec, 31);+ builder+ .ins()+ .store(MemFlagsData::trusted(), la_new, ctx_ptr, loop_addr_ptr_offset);+ let csp = builder+ .ins()+ .load(types::I8, MemFlagsData::trusted(), ctx_ptr, call_stack_ptr_offset);+ let csp_dec = builder.ins().iadd_imm(csp, -1);+ let csp_new = builder.ins().band_imm(csp_dec, 31);+ builder+ .ins()+ .store(MemFlagsData::trusted(), csp_new, ctx_ptr, call_stack_ptr_offset);+ builder.ins().jump(finish_block, &[BlockArg::Value(nia_cur)]);++ builder.switch_to_block(finish_block);+ builder.seal_block(finish_block);+ let nia_final = builder.block_params(finish_block)[0];+ builder+ .ins()+ .store(MemFlagsData::trusted(), nia_final, ctx_ptr, nia_offset);+ builder+ .ins()+ .store(MemFlagsData::trusted(), nia_final, ctx_ptr, pc_offset);let expected = builder.ins().iconst(types::I16, natural_nia as i64);let same = builder.ins()- .icmp(cranelift_codegen::ir::condcodes::IntCC::Equal, pc_after, expected);+ .icmp(cranelift_codegen::ir::condcodes::IntCC::Equal, nia_final, expected);let exit_block = builder.create_block();builder.ins().brif(same, continue_block, &[], exit_block, &[]);@@ -329,12 +407,6 @@ pub fn block_signature(pointer_type: cranelift_codegen::ir::Type) -> Signature {sig}-pub fn void_thunk_signature(pointer_type: cranelift_codegen::ir::Type, host_cc: CallConv) -> Signature {- let mut sig = Signature::new(host_cc);- sig.params.push(AbiParam::new(pointer_type));- sig-}-pub fn dmem_read_signature(pointer_type: cranelift_codegen::ir::Type, host_cc: CallConv) -> Signature {let mut sig = Signature::new(host_cc);sig.params.push(AbiParam::new(pointer_type));@@ -351,39 +423,6 @@ pub fn dmem_write_signature(pointer_type: cranelift_codegen::ir::Type, host_cc:sig}-pub fn ar_unary_signature(pointer_type: cranelift_codegen::ir::Type, host_cc: CallConv) -> Signature {- let mut sig = Signature::new(host_cc);- sig.params.push(AbiParam::new(pointer_type));- sig.params.push(AbiParam::new(types::I32));- sig.returns.push(AbiParam::new(types::I32));- sig-}--pub fn ar_binary_signature(pointer_type: cranelift_codegen::ir::Type, host_cc: CallConv) -> Signature {- let mut sig = Signature::new(host_cc);- sig.params.push(AbiParam::new(pointer_type));- sig.params.push(AbiParam::new(types::I32));- sig.params.push(AbiParam::new(types::I32));- sig.returns.push(AbiParam::new(types::I32));- sig-}--pub fn dynamic_shift_signature(pointer_type: cranelift_codegen::ir::Type, host_cc: CallConv) -> Signature {- let mut sig = Signature::new(host_cc);- sig.params.push(AbiParam::new(pointer_type));- sig.params.push(AbiParam::new(types::I32));- sig.params.push(AbiParam::new(types::I32));- sig.params.push(AbiParam::new(types::I32));- sig-}--pub fn stack_pop_signature(pointer_type: cranelift_codegen::ir::Type, host_cc: CallConv) -> Signature {- let mut sig = Signature::new(host_cc);- sig.params.push(AbiParam::new(pointer_type));- sig.returns.push(AbiParam::new(types::I32));- sig-}-pub fn loop_setup_signature(pointer_type: cranelift_codegen::ir::Type, host_cc: CallConv) -> Signature {let mut sig = Signature::new(host_cc);sig.params.push(AbiParam::new(pointer_type));diff --git a/crates/gecko/src/flipper/dsp/regs.rs b/crates/gecko/src/flipper/dsp/regs.rsindex 766a1ac..357f8fe 100644--- a/crates/gecko/src/flipper/dsp/regs.rs+++ b/crates/gecko/src/flipper/dsp/regs.rs@@ -182,7 +182,7 @@ impl<const SYSTEM: SystemId> MmioAccess<System<SYSTEM>> for MailboxToDspLo {// AID consumes the buffer with the prior cycle's contents at the// start of each render before the new contents land.// Based off of FFCC, thanks SpinningCube, zayd, JustinCase- sys.drain_dsp_synchronous(64 * 1024);+ sys.drain_dsp_synchronous(1024 * 1024);crate::flipper::dsp::wake_dsp_scheduler::<SYSTEM>(sys);}}