Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

4.1 KB
Raw Blame
use std::sync::{Arc, Mutex};

use gecko::gamecube::GameCube;
use gecko::hooks::{AddressFilter, BusAddressFilter, HookFilters, HookFlags, HookState, Host};
use image::Dol;

const DSP_IROM: &[u8] = include_bytes!("../../../../private/dsp_rom.bin");

const STDOUT_ADDR: u32 = 0x0C00_7000;
const FAIL_COUNT_ADDR: u32 = 0x0C00_7004;
const PASS_COUNT_ADDR: u32 = 0x0C00_7008;
const CONFIG_ADDR: u32 = 0x0C00_700C;

const TOTAL_TESTS: u32 = 25000;

struct DspTestState {
    stdout_buf: String,
    finished: bool,
    fail_count: u32,
    pass_count: u32,
    config_param: u32,
}

struct DspTestHarness {
    state: Arc<Mutex<DspTestState>>,
    hook_state: HookState,
}

impl DspTestHarness {
    fn new(state: Arc<Mutex<DspTestState>>) -> Self {
        let mut flags = HookFlags::empty();
        flags |= HookFlags::BUS_WRITE_POST;
        flags |= HookFlags::BUS_READ_PRE;

        let hook_state = HookState {
            flags,
            filters: HookFilters {
                bus_write_post: BusAddressFilter {
                    phys: AddressFilter::from_addresses([STDOUT_ADDR, FAIL_COUNT_ADDR, PASS_COUNT_ADDR]),
                    ..Default::default()
                },
                bus_read_pre: BusAddressFilter {
                    phys: AddressFilter::Exact(CONFIG_ADDR),
                    ..Default::default()
                },
                ..Default::default()
            },
        };

        Self { state, hook_state }
    }
}

#[rustfmt::skip]
impl Host<{ gecko::system::GC }> for DspTestHarness {
    fn hook_state(&self) -> HookState { self.hook_state.clone() }

    fn on_cpu_pre(&mut self, _emu: &mut GameCube) {}
    fn on_cpu_post(&mut self, _emu: &mut GameCube) {}

    fn on_bus_read_pre(&mut self, _emu: &mut GameCube, _virt_addr: u32, phys_addr: u32, _size: u8) -> Option<u32> {
        if phys_addr == CONFIG_ADDR {
            Some(self.state.lock().unwrap().config_param)
        } else {
            None
        }
    }

    fn on_bus_read_post(&mut self, _emu: &mut GameCube, _virt_addr: u32, _phys_addr: u32, _size: u8, value: u32) -> u32 { value }
    fn on_bus_write_pre(&mut self, _emu: &mut GameCube, _virt_addr: u32, _phys_addr: u32, _size: u8, value: u32) -> u32 { value }

    fn on_bus_write_post(&mut self, _emu: &mut GameCube, _virt_addr: u32, phys_addr: u32, _size: u8, value: u32) {
        let mut state = self.state.lock().unwrap();
        match phys_addr {
            STDOUT_ADDR => {
                let ch = (value & 0xFF) as u8;
                let done = value & 0x100 != 0;
                if ch == b'\n' {
                    println!("{}", state.stdout_buf);
                    state.stdout_buf.clear();
                } else if ch != 0 {
                    state.stdout_buf.push(ch as char);
                }
                if done && !state.stdout_buf.is_empty() {
                    println!("{}", state.stdout_buf);
                    state.stdout_buf.clear();
                }
            }
            FAIL_COUNT_ADDR => {
                state.fail_count = value;
                if value > 0 || state.fail_count + state.pass_count >= TOTAL_TESTS {
                    state.finished = true;
                }
            }
            PASS_COUNT_ADDR => {
                state.pass_count = value;
                if state.pass_count + state.fail_count >= TOTAL_TESTS {
                    state.finished = true;
                }
            }
            _ => {}
        }
    }
}

fn main() {
    let path = std::env::args().nth(1).expect("Usage: hazel <path-to-dol>");

    let dol = Dol::parse(std::fs::read(&path).expect("Failed to read DOL file"));
    let mut gamecube = GameCube::with_image(&dol);
    gamecube.dsp.load_irom(DSP_IROM);

    let state = Arc::new(Mutex::new(DspTestState {
        stdout_buf: String::new(),
        finished: false,
        fail_count: 0,
        pass_count: 0,
        config_param: 0,
    }));
    let harness = DspTestHarness::new(state.clone());
    gamecube.set_hook_host(Box::new(harness));

    while !state.lock().unwrap().finished {
        gamecube.run_until_vsync();
    }

    let results = state.lock().unwrap();
    println!("Passed: {}, Failed: {}", results.pass_count, results.fail_count);
}