systemless 0.90.0

High-Level Emulation for classic Macintosh applications
Documentation
//! Shared scalar math import dispatch for the main and hot PowerPC paths.

use super::*;

pub(super) fn dispatch_math_import(
    target: &PpcImportDispatcherTarget,
    cpu: &mut PpcCpu,
    memory: &mut PpcSectionMem,
) -> Option<PpcImportAction> {
    match target {
        PpcImportDispatcherTarget::MathCeil => {
            ppc_math_ceil(cpu);
            Some(PpcImportAction::ReturnPreserve)
        }
        PpcImportDispatcherTarget::MathSqrt => {
            let value = f64::from_bits(cpu.fpr[1]);
            cpu.fpr[1] = value.sqrt().to_bits();
            Some(PpcImportAction::ReturnPreserve)
        }
        PpcImportDispatcherTarget::MathHypot => {
            // Inside Macintosh: PowerPC Numerics (1994), pp. 10-58--10-59:
            // compute the distance without unnecessary intermediate overflow
            // or underflow; infinity takes precedence over a NaN argument.
            let x = f64::from_bits(cpu.fpr[1]);
            let y = f64::from_bits(cpu.fpr[2]);
            cpu.fpr[1] = x.hypot(y).to_bits();
            Some(PpcImportAction::ReturnPreserve)
        }
        PpcImportDispatcherTarget::MathExp => {
            // Inside Macintosh: PowerPC Numerics (1994), pp. 10-18--10-19:
            // exp returns e raised to the power of x.
            let value = f64::from_bits(cpu.fpr[1]);
            cpu.fpr[1] = value.exp().to_bits();
            Some(PpcImportAction::ReturnPreserve)
        }
        PpcImportDispatcherTarget::MathSin => {
            let value = f64::from_bits(cpu.fpr[1]);
            cpu.fpr[1] = value.sin().to_bits();
            Some(PpcImportAction::ReturnPreserve)
        }
        PpcImportDispatcherTarget::MathCos => {
            let value = f64::from_bits(cpu.fpr[1]);
            cpu.fpr[1] = value.cos().to_bits();
            Some(PpcImportAction::ReturnPreserve)
        }
        PpcImportDispatcherTarget::MathRound => {
            let value = f64::from_bits(cpu.fpr[1]);
            cpu.fpr[1] = value.round().to_bits();
            Some(PpcImportAction::ReturnPreserve)
        }
        PpcImportDispatcherTarget::MathRint => {
            ppc_math_rint(cpu);
            Some(PpcImportAction::ReturnPreserve)
        }
        PpcImportDispatcherTarget::MathAsin => {
            // Inside Macintosh: PowerPC Numerics (1994), pp. 10-34--10-35:
            // asin returns the arc sine in radians through the floating-point
            // result register used by the PowerPC calling convention.
            let value = f64::from_bits(cpu.fpr[1]);
            cpu.fpr[1] = value.asin().to_bits();
            Some(PpcImportAction::ReturnPreserve)
        }
        PpcImportDispatcherTarget::MathAcos => {
            // Inside Macintosh: PowerPC Numerics (1994), pp. 10-33--10-34:
            // acos returns radians in [0, pi] for arguments in [-1, 1].
            let value = f64::from_bits(cpu.fpr[1]);
            cpu.fpr[1] = value.acos().to_bits();
            Some(PpcImportAction::ReturnPreserve)
        }
        PpcImportDispatcherTarget::MathTan => {
            // Inside Macintosh: PowerPC Numerics (1994), pp. 10-32--10-33.
            let value = f64::from_bits(cpu.fpr[1]);
            cpu.fpr[1] = value.tan().to_bits();
            Some(PpcImportAction::ReturnPreserve)
        }
        PpcImportDispatcherTarget::MathAtan => {
            let value = f64::from_bits(cpu.fpr[1]);
            cpu.fpr[1] = value.atan().to_bits();
            Some(PpcImportAction::ReturnPreserve)
        }
        PpcImportDispatcherTarget::MathAtan2 => {
            let y = f64::from_bits(cpu.fpr[1]);
            let x = f64::from_bits(cpu.fpr[2]);
            cpu.fpr[1] = y.atan2(x).to_bits();
            Some(PpcImportAction::ReturnPreserve)
        }
        PpcImportDispatcherTarget::MathPow => {
            // Inside Macintosh: PowerPC Numerics (1994), pp. 10-14--10-16.
            let base = f64::from_bits(cpu.fpr[1]);
            let exponent = f64::from_bits(cpu.fpr[2]);
            cpu.fpr[1] = base.powf(exponent).to_bits();
            Some(PpcImportAction::ReturnPreserve)
        }
        PpcImportDispatcherTarget::MathFmod => {
            ppc_math_fmod(cpu);
            Some(PpcImportAction::ReturnPreserve)
        }
        PpcImportDispatcherTarget::MathLog => {
            // Inside Macintosh: PowerPC Numerics (1994), pp. 10-22--10-23.
            let value = f64::from_bits(cpu.fpr[1]);
            cpu.fpr[1] = value.ln().to_bits();
            Some(PpcImportAction::ReturnPreserve)
        }
        PpcImportDispatcherTarget::MathLog10 => {
            // Inside Macintosh: PowerPC Numerics (1994), pp. 10-23–10-24:
            // `double_t log10(double_t x)` returns the common logarithm of x.
            let value = f64::from_bits(cpu.fpr[1]);
            cpu.fpr[1] = value.log10().to_bits();
            Some(PpcImportAction::ReturnPreserve)
        }
        PpcImportDispatcherTarget::MathDtox80 => {
            ppc_math_dtox80(cpu, memory);
            Some(PpcImportAction::ReturnPreserve)
        }
        PpcImportDispatcherTarget::X2Fix => {
            let value = f64::from_bits(cpu.fpr[1]);
            Some(PpcImportAction::Return(ppc_f64_to_fixed(value)))
        }
        PpcImportDispatcherTarget::FixRatio => Some(PpcImportAction::Return(ppc_fix_ratio(
            cpu.gpr[3] as u16 as i16,
            cpu.gpr[4] as u16 as i16,
        ) as u32)),
        PpcImportDispatcherTarget::FixMul => Some(PpcImportAction::Return(ppc_fix_mul(
            cpu.gpr[3] as i32,
            cpu.gpr[4] as i32,
        ) as u32)),
        PpcImportDispatcherTarget::FixDiv => Some(PpcImportAction::Return(ppc_fix_div(
            cpu.gpr[3] as i32,
            cpu.gpr[4] as i32,
        ) as u32)),
        PpcImportDispatcherTarget::Long2Fix => Some(PpcImportAction::Return(ppc_long_to_fix(
            cpu.gpr[3] as i32,
        ) as u32)),
        PpcImportDispatcherTarget::Fix2Long => Some(PpcImportAction::Return(ppc_fix_to_long(
            cpu.gpr[3] as i32,
        ) as u32)),
        PpcImportDispatcherTarget::FixRound => Some(PpcImportAction::Return(ppc_i16_result(
            ppc_fix_round(cpu.gpr[3] as i32),
        ))),
        PpcImportDispatcherTarget::Fix2Frac => Some(PpcImportAction::Return(ppc_fix_to_frac(
            cpu.gpr[3] as i32,
        ) as u32)),
        PpcImportDispatcherTarget::Frac2Fix => Some(PpcImportAction::Return(ppc_frac_to_fix(
            cpu.gpr[3] as i32,
        ) as u32)),
        PpcImportDispatcherTarget::Frac2X => {
            let frac = cpu.gpr[3] as i32;
            cpu.fpr[1] = (f64::from(frac) / 1_073_741_824.0).to_bits();
            Some(PpcImportAction::ReturnPreserve)
        }
        PpcImportDispatcherTarget::X2Frac => {
            let value = f64::from_bits(cpu.fpr[1]);
            Some(PpcImportAction::Return(ppc_f64_to_frac(value)))
        }
        PpcImportDispatcherTarget::FracSin => Some(PpcImportAction::Return(ppc_frac_sin(
            cpu.gpr[3] as i32,
        ) as u32)),
        PpcImportDispatcherTarget::FracCos => Some(PpcImportAction::Return(ppc_frac_cos(
            cpu.gpr[3] as i32,
        ) as u32)),
        PpcImportDispatcherTarget::FracSqrt => {
            Some(PpcImportAction::Return(ppc_frac_sqrt(cpu.gpr[3])))
        }
        PpcImportDispatcherTarget::FracMul => Some(PpcImportAction::Return(ppc_frac_mul(
            cpu.gpr[3] as i32,
            cpu.gpr[4] as i32,
        ) as u32)),
        PpcImportDispatcherTarget::FracDiv => Some(PpcImportAction::Return(ppc_frac_div(
            cpu.gpr[3] as i32,
            cpu.gpr[4] as i32,
        ) as u32)),
        PpcImportDispatcherTarget::FixATan2 => Some(PpcImportAction::Return(ppc_fix_atan2(
            cpu.gpr[3] as i32,
            cpu.gpr[4] as i32,
        ) as u32)),
        PpcImportDispatcherTarget::WideAdd => Some(PpcImportAction::Return(ppc_wide_add(
            memory, cpu.gpr[3], cpu.gpr[4],
        ))),
        PpcImportDispatcherTarget::WideSubtract => Some(PpcImportAction::Return(
            ppc_wide_subtract(memory, cpu.gpr[3], cpu.gpr[4]),
        )),
        PpcImportDispatcherTarget::WideNegate => {
            Some(PpcImportAction::Return(ppc_wide_negate(memory, cpu.gpr[3])))
        }
        PpcImportDispatcherTarget::WideShift => Some(PpcImportAction::Return(ppc_wide_shift(
            memory,
            cpu.gpr[3],
            cpu.gpr[4] as i32,
        ))),
        PpcImportDispatcherTarget::WideBitShift => Some(PpcImportAction::Return(
            ppc_wide_bit_shift(memory, cpu.gpr[3], cpu.gpr[4] as i32),
        )),
        PpcImportDispatcherTarget::WideMultiply => Some(PpcImportAction::Return(
            ppc_wide_multiply(memory, cpu.gpr[3] as i32, cpu.gpr[4] as i32, cpu.gpr[5]),
        )),
        PpcImportDispatcherTarget::WideDivide => Some(PpcImportAction::Return(ppc_wide_divide(
            memory,
            cpu.gpr[3],
            cpu.gpr[4] as i32,
            cpu.gpr[5],
        ) as u32)),
        PpcImportDispatcherTarget::WideWideDivide => Some(PpcImportAction::Return(
            ppc_wide_wide_divide(memory, cpu.gpr[3], cpu.gpr[4] as i32, cpu.gpr[5]),
        )),
        PpcImportDispatcherTarget::WideCompare => Some(PpcImportAction::Return(ppc_i16_result(
            ppc_wide_compare(memory, cpu.gpr[3], cpu.gpr[4]),
        ))),
        PpcImportDispatcherTarget::WideSquareRoot => Some(PpcImportAction::Return(
            ppc_wide_square_root(memory, cpu.gpr[3]),
        )),
        _ => None,
    }
}

pub(crate) fn ppc_math_ceil(cpu: &mut PpcCpu) {
    // Inside Macintosh: PowerPC Numerics (1994), pp. 9-7--9-8:
    // ceil rounds upward without an inexact exception and preserves signed
    // zero, infinities, and quiet NaNs. A signaling NaN raises invalid and
    // returns the corresponding quiet NaN.
    const EXPONENT_MASK: u64 = 0x7ff0_0000_0000_0000;
    const FRACTION_MASK: u64 = 0x000f_ffff_ffff_ffff;
    const QUIET_NAN_BIT: u64 = 0x0008_0000_0000_0000;
    let bits = cpu.fpr[1];
    let signaling_nan = bits & EXPONENT_MASK == EXPONENT_MASK
        && bits & FRACTION_MASK != 0
        && bits & QUIET_NAN_BIT == 0;
    if signaling_nan {
        cpu.fpr[1] = bits | QUIET_NAN_BIT;
        cpu.set_fpscr_bit(0, true);
        cpu.set_fpscr_bit(2, true);
        cpu.set_fpscr_bit(7, true);
        if cpu.fpscr_bit(24) {
            cpu.set_fpscr_bit(1, true);
        }
    } else {
        cpu.fpr[1] = f64::from_bits(bits).ceil().to_bits();
    }
}

pub(crate) fn ppc_math_rint(cpu: &mut PpcCpu) {
    // Inside Macintosh: PowerPC Numerics (1994), pp. 6-13--6-14:
    // rint rounds in the current direction, defaults to ties-to-even, and
    // raises inexact for finite nonintegral inputs. The PowerPC FPSCR RN
    // field selects nearest, zero, +infinity, or -infinity in that order.
    const EXPONENT_MASK: u64 = 0x7ff0_0000_0000_0000;
    const FRACTION_MASK: u64 = 0x000f_ffff_ffff_ffff;
    const QUIET_NAN_BIT: u64 = 0x0008_0000_0000_0000;
    let bits = cpu.fpr[1];
    let signaling_nan = bits & EXPONENT_MASK == EXPONENT_MASK
        && bits & FRACTION_MASK != 0
        && bits & QUIET_NAN_BIT == 0;
    if signaling_nan {
        cpu.fpr[1] = bits | QUIET_NAN_BIT;
        cpu.set_fpscr_bit(0, true);
        cpu.set_fpscr_bit(2, true);
        cpu.set_fpscr_bit(7, true);
        if cpu.fpscr_bit(24) {
            cpu.set_fpscr_bit(1, true);
        }
        return;
    }

    let value = f64::from_bits(bits);
    let rounded = match cpu.fpscr & 0x3 {
        0 => value.round_ties_even(),
        1 => value.trunc(),
        2 => value.ceil(),
        _ => value.floor(),
    };
    cpu.fpr[1] = rounded.to_bits();
    let inexact = value.is_finite() && value != rounded;
    cpu.set_fpscr_bit(14, inexact);
    if inexact {
        cpu.set_fpscr_bit(0, true);
        cpu.set_fpscr_bit(6, true);
        if cpu.fpscr_bit(28) {
            cpu.set_fpscr_bit(1, true);
        }
    }
}

pub(crate) fn ppc_math_fmod(cpu: &mut PpcCpu) {
    // The PowerPC C ABI passes the two double arguments in f1/f2 and returns
    // the remainder in f1. Rust's floating remainder has C fmod semantics:
    // its magnitude is less than the divisor and its sign follows the dividend.
    let dividend = f64::from_bits(cpu.fpr[1]);
    let divisor = f64::from_bits(cpu.fpr[2]);
    cpu.fpr[1] = (dividend % divisor).to_bits();
}

pub(crate) fn ppc_math_dtox80(cpu: &PpcCpu, memory: &mut PpcSectionMem) -> bool {
    let Some(hi) = memory.read_u32_be(cpu.gpr[3]) else {
        return false;
    };
    let Some(lo) = memory.read_u32_be(cpu.gpr[3].wrapping_add(4)) else {
        return false;
    };
    let extended = Extended80::from(f64::from_bits((u64::from(hi) << 32) | u64::from(lo)));
    let sign_bit = if extended.sign { 0x8000 } else { 0 };
    let out = cpu.gpr[4];

    // Universal Interfaces fp.h (MathLib 2), `dtox80(const double *, extended80 *)`:
    // convert a PowerPC double into the 10-byte big-endian 68K extended format.
    memory
        .write_u16_be(out, sign_bit | extended.exponent)
        .is_some()
        && memory
            .write_u16_be(out.wrapping_add(2), (extended.significand >> 48) as u16)
            .is_some()
        && memory
            .write_u16_be(out.wrapping_add(4), (extended.significand >> 32) as u16)
            .is_some()
        && memory
            .write_u16_be(out.wrapping_add(6), (extended.significand >> 16) as u16)
            .is_some()
        && memory
            .write_u16_be(out.wrapping_add(8), extended.significand as u16)
            .is_some()
}

pub(crate) fn ppc_f64_to_fixed(value: f64) -> u32 {
    (value * 65536.0)
        .round()
        .clamp(i32::MIN as f64, i32::MAX as f64) as i32 as u32
}