Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

5.9 KB
Raw Blame
use disasm::gekko::GekkoInstruction;
use disasm::tokenizer::{self, AsmToken};
use gecko::flipper::dsp::Dsp;
use gecko::flipper::dsp::core::Registers as DspRegisters;
use gecko::system::{System, SystemId};

const DISASM_COL: usize = 22;
const COMMENT_COL: usize = 50;

/// Format a single trace line for the current PC of the emulator.
///
/// Returns a string like `80003100  4E800020  blr                           ; lr=80001234`
pub fn format_trace_line<const SYSTEM: SystemId>(emulator: &System<SYSTEM>) -> String {
    let pc = emulator.gekko.pc;
    let raw = emulator.mmio.virt_read_u32(pc);

    if let Some((instr, _)) = GekkoInstruction::decode(emulator.mmio.virt_slice(pc, 4)) {
        let text = format!("{}", instr);
        let comment = reg_comment(&text, &emulator.gekko.gprs, &emulator.gekko.fpr_array());
        let pad = COMMENT_COL.saturating_sub(DISASM_COL + text.len());
        if comment.is_empty() {
            format!("{:08X}  {:08X}  {}", pc, raw, text)
        } else {
            format!("{:08X}  {:08X}  {}{}; {}", pc, raw, text, " ".repeat(pad), comment)
        }
    } else {
        format!("{:08X}  {:08X}  <unknown>", pc, raw)
    }
}

/// Generate register-value comments for a disassembled instruction line.
///
/// Parses the disassembly text for register references and returns a comma-separated
/// list of their current values, e.g. `r3=00000001, r4=80003000`.
pub fn reg_comment(disasm_text: &str, gprs: &[u32; 32], fprs: &[f64; 32]) -> String {
    let tokens = tokenizer::tokenize(disasm_text);
    let mut parts = Vec::new();
    let mut gpr_seen = [false; 32];
    let mut fpr_seen = [false; 32];
    for tok in &tokens {
        match tok {
            AsmToken::Gpr(n) => {
                let n = *n as usize;
                if !gpr_seen[n] {
                    gpr_seen[n] = true;
                    parts.push(format!("r{}={:08X}", n, gprs[n]));
                }
            }
            AsmToken::Fpr(n) => {
                let n = *n as usize;
                if !fpr_seen[n] {
                    fpr_seen[n] = true;
                    parts.push(format!("f{}={:.6e}", n, fprs[n]));
                }
            }
            _ => {}
        }
    }
    parts.join(", ")
}

/// Format a single DSP trace line for the current PC.
pub fn format_dsp_trace_line(dsp: &Dsp) -> String {
    let pc = dsp.registers.pc;
    let w0 = dsp.read_imem(pc);
    let w1 = dsp.read_imem(pc.wrapping_add(1));
    let buf = [(w0 >> 8) as u8, w0 as u8, (w1 >> 8) as u8, w1 as u8];

    match disasm::dsp::GcDspInstruction::decode(&buf) {
        Some((instr, byte_len)) => {
            let text = instr.to_string();
            let comment = dsp_reg_comment(&text, &dsp.registers);
            let raw = if byte_len == 2 {
                format!("{:04X}     ", w0)
            } else {
                format!("{:04X} {:04X}", w0, w1)
            };
            if comment.is_empty() {
                format!("{:04X}  {}  {}", pc, raw, text)
            } else {
                format!("{:04X}  {}  {:<30}; {}", pc, raw, text, comment)
            }
        }
        None => format!("{:04X}  {:04X}       <unknown>", pc, w0),
    }
}

fn dsp_reg_comment(disasm_text: &str, regs: &DspRegisters) -> String {
    let tokens = tokenizer::tokenize(disasm_text);
    let mut parts = Vec::new();
    let mut seen = Vec::new();
    for tok in &tokens {
        if let AsmToken::Spr(name) = tok {
            if seen.contains(name) {
                continue;
            }
            seen.push(name);
            if let Some(val) = dsp_reg_value(name, regs) {
                parts.push(val);
            }
        }
    }
    parts.join(", ")
}

fn dsp_reg_value(name: &str, regs: &DspRegisters) -> Option<String> {
    Some(match name {
        "$ar0" => format!("ar0={:04X}", regs.ar[0]),
        "$ar1" => format!("ar1={:04X}", regs.ar[1]),
        "$ar2" => format!("ar2={:04X}", regs.ar[2]),
        "$ar3" => format!("ar3={:04X}", regs.ar[3]),
        "$ix0" => format!("ix0={:04X}", regs.ix[0]),
        "$ix1" => format!("ix1={:04X}", regs.ix[1]),
        "$ix2" => format!("ix2={:04X}", regs.ix[2]),
        "$ix3" => format!("ix3={:04X}", regs.ix[3]),
        "$wr0" => format!("wr0={:04X}", regs.wr[0]),
        "$wr1" => format!("wr1={:04X}", regs.wr[1]),
        "$wr2" => format!("wr2={:04X}", regs.wr[2]),
        "$wr3" => format!("wr3={:04X}", regs.wr[3]),
        "$st0" => format!("st0={:04X}", regs.call_stack.top()),
        "$st1" => format!("st1={:04X}", regs.data_stack.top()),
        "$st2" => format!("st2={:04X}", regs.loop_addr.top()),
        "$st3" => format!("st3={:04X}", regs.loop_counter.top()),
        "$ac0.h" => format!("ac0.h={:04X}", regs.ac0_high),
        "$ac1.h" => format!("ac1.h={:04X}", regs.ac1_high),
        "$ac0.m" => format!("ac0.m={:04X}", regs.ac0_mid),
        "$ac1.m" => format!("ac1.m={:04X}", regs.ac1_mid),
        "$ac0.l" => format!("ac0.l={:04X}", regs.ac0_low),
        "$ac1.l" => format!("ac1.l={:04X}", regs.ac1_low),
        "$ac0" => format!("ac0={:010X}", regs.ac(0) as u64 & 0xFF_FFFF_FFFF),
        "$ac1" => format!("ac1={:010X}", regs.ac(1) as u64 & 0xFF_FFFF_FFFF),
        "$ax0.l" => format!("ax0.l={:04X}", regs.ax[0]),
        "$ax1.l" => format!("ax1.l={:04X}", regs.ax[1]),
        "$ax0.h" => format!("ax0.h={:04X}", regs.axh[0]),
        "$ax1.h" => format!("ax1.h={:04X}", regs.axh[1]),
        "$ax0" => format!("ax0={:08X}", (regs.axh[0] as u32) << 16 | regs.ax[0] as u32),
        "$ax1" => format!("ax1={:08X}", (regs.axh[1] as u32) << 16 | regs.ax[1] as u32),
        "$cr" => format!("cr={:04X}", regs.config),
        "$sr" => format!("sr={:04X}", u16::from(regs.status)),
        "$prod.l" => format!("prod.l={:04X}", regs.product_low),
        "$prod.m1" => format!("prod.m1={:04X}", regs.product_mid1),
        "$prod.h" => format!("prod.h={:04X}", regs.product_high),
        "$prod.m2" => format!("prod.m2={:04X}", regs.product_mid2),
        _ => return None,
    })
}