Skip to content

armgit / gecko

Public Imported from GitHub
0

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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, val
dsp::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.rs
index 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.rs
index 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.rs
index 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);
}
}