systemless 0.41.0

High-Level Emulation for classic Macintosh applications
Documentation
use super::*;

#[test]
fn native_ppc_math_decimal_and_modf_compatibility_preserve_binary_values() {
    let mut memory = PpcSectionMem::new();
    memory.add_region(0x1000, vec![0; 64]);
    memory.add_region(0x1100, vec![0; 8]);
    assert!(ppc_decimal_write(&mut memory, 0x1000, -208_000.0, 6));
    assert_eq!(ppc_decimal_read(&mut memory, 0x1000), Some(-208_000.0));

    let mut cpu = PpcCpu::new();
    cpu.fpr[1] = (-12.75f64).to_bits();
    cpu.gpr[5] = 0x1100;
    assert_eq!(
        ppc_dispatch_math_compatibility(
            math_operation("modf"),
            &mut cpu,
            &mut memory,
        ),
        PpcImportAction::ReturnPreserve
    );
    let integer_bits = (u64::from(memory.read_u32_be(0x1100).unwrap()) << 32)
        | u64::from(memory.read_u32_be(0x1104).unwrap());
    assert_eq!(f64::from_bits(integer_bits), -12.0);
    assert_eq!(f64::from_bits(cpu.fpr[1]), -0.75);
}

fn math64_operation(symbol_name: &str) -> PpcMath64Operation {
    match dispatcher_target_for_import("Math64Lib", symbol_name) {
        PpcImportDispatcherTarget::Math64(operation) => operation,
        target => panic!("unexpected Math64 target for {symbol_name}: {target:?}"),
    }
}

fn math_operation(symbol_name: &str) -> PpcMathCompatibilityOperation {
    match dispatcher_target_for_import("MathLib", symbol_name) {
        PpcImportDispatcherTarget::MathCompatibility(operation) => operation,
        target => panic!("unexpected MathLib target for {symbol_name}: {target:?}"),
    }
}

fn math64_set_gprs(cpu: &mut PpcCpu, high_register: usize, value: u64) {
    cpu.gpr[high_register] = (value >> 32) as u32;
    cpu.gpr[high_register + 1] = value as u32;
}

fn math64_read_memory(memory: &mut PpcSectionMem, address: u32) -> u64 {
    (u64::from(memory.read_u32_be(address).unwrap()) << 32)
        | u64::from(memory.read_u32_be(address + 4).unwrap())
}

#[test]
fn native_ppc_math64_maps_every_captured_export_to_the_specific_dispatcher() {
    let symbols = [
        "LongDoubleToSInt64",
        "LongDoubleToUInt64",
        "S32Set",
        "S64Absolute",
        "S64Add",
        "S64And",
        "S64BitwiseAnd",
        "S64BitwiseEor",
        "S64BitwiseNot",
        "S64BitwiseOr",
        "S64Compare",
        "S64Divide",
        "S64Eor",
        "S64Max",
        "S64Min",
        "S64Multiply",
        "S64Negate",
        "S64Not",
        "S64Or",
        "S64Set",
        "S64SetU",
        "S64ShiftLeft",
        "S64ShiftRight",
        "S64Subtract",
        "SInt64ToLongDouble",
        "SInt64ToUInt64",
        "U32SetU",
        "U64Add",
        "U64And",
        "U64BitwiseAnd",
        "U64BitwiseEor",
        "U64BitwiseNot",
        "U64BitwiseOr",
        "U64Compare",
        "U64Divide",
        "U64Eor",
        "U64Max",
        "U64Multiply",
        "U64Not",
        "U64Or",
        "U64Set",
        "U64SetU",
        "U64ShiftLeft",
        "U64ShiftRight",
        "U64Subtract",
        "UInt64ToLongDouble",
        "UInt64ToSInt64",
    ];
    assert_eq!(symbols.len(), 47);
    for symbol in symbols {
        let PpcImportDispatcherTarget::Math64(operation) =
            dispatcher_target_for_import("Math64Lib", symbol)
        else {
            panic!("{symbol} did not resolve to a Math64 operation");
        };
        assert_eq!(format!("{operation:?}"), symbol);
    }
}

#[test]
fn native_ppc_math_compatibility_maps_each_export_to_a_typed_operation() {
    for (symbol, expected) in [
        ("dec2num", PpcMathCompatibilityOperation::Dec2Num),
        ("dec2str", PpcMathCompatibilityOperation::Dec2Str),
        (
            "feclearexcept",
            PpcMathCompatibilityOperation::FeClearExcept,
        ),
        ("fetestexcept", PpcMathCompatibilityOperation::FeTestExcept),
        ("floor", PpcMathCompatibilityOperation::Floor),
        ("modf", PpcMathCompatibilityOperation::Modf),
        ("num2dec", PpcMathCompatibilityOperation::Num2Dec),
        ("str2dec", PpcMathCompatibilityOperation::Str2Dec),
    ] {
        assert_eq!(
            dispatcher_target_for_import("MathLib", symbol),
            PpcImportDispatcherTarget::MathCompatibility(expected),
            "{symbol}",
        );
    }
}

#[test]
fn native_ppc_math64_uses_hidden_results_and_wraps_signed_arithmetic() {
    let mut memory = PpcSectionMem::new();
    memory.add_region(0x1000, vec![0; 32]);
    let mut cpu = PpcCpu::new();
    cpu.gpr[3] = 0x1000;
    math64_set_gprs(&mut cpu, 4, i64::MAX as u64);
    math64_set_gprs(&mut cpu, 6, 1);
    assert_eq!(
        ppc_dispatch_math64(math64_operation("S64Add"), &mut cpu, &mut memory),
        PpcImportAction::ReturnPreserve,
    );
    assert_eq!(math64_read_memory(&mut memory, 0x1000), i64::MIN as u64);
    assert_eq!(cpu.gpr[3], 0x1000);

    math64_set_gprs(&mut cpu, 4, i64::MIN as u64);
    let _ = ppc_dispatch_math64(math64_operation("S64Absolute"), &mut cpu, &mut memory);
    assert_eq!(math64_read_memory(&mut memory, 0x1000), i64::MIN as u64);

    math64_set_gprs(&mut cpu, 4, i64::MAX as u64);
    math64_set_gprs(&mut cpu, 6, 2);
    let _ = ppc_dispatch_math64(math64_operation("S64Multiply"), &mut cpu, &mut memory);
    assert_eq!(math64_read_memory(&mut memory, 0x1000), -2i64 as u64);

    cpu.gpr[4] = 0x8000_0000;
    let _ = ppc_dispatch_math64(math64_operation("S64Set"), &mut cpu, &mut memory);
    assert_eq!(
        math64_read_memory(&mut memory, 0x1000),
        0xffff_ffff_8000_0000,
    );
    let _ = ppc_dispatch_math64(math64_operation("S64SetU"), &mut cpu, &mut memory);
    assert_eq!(
        math64_read_memory(&mut memory, 0x1000),
        0x0000_0000_8000_0000,
    );
    let _ = ppc_dispatch_math64(math64_operation("U64Set"), &mut cpu, &mut memory);
    assert_eq!(
        math64_read_memory(&mut memory, 0x1000),
        0xffff_ffff_8000_0000,
    );
    let _ = ppc_dispatch_math64(math64_operation("U64SetU"), &mut cpu, &mut memory);
    assert_eq!(
        math64_read_memory(&mut memory, 0x1000),
        0x0000_0000_8000_0000,
    );

    cpu.gpr[3] = 0x1234_5678;
    cpu.gpr[4] = 0x9abc_def0;
    assert_eq!(
        ppc_dispatch_math64(math64_operation("S32Set"), &mut cpu, &mut memory),
        PpcImportAction::Return(0x9abc_def0),
    );
    assert_eq!(
        ppc_dispatch_math64(math64_operation("U32SetU"), &mut cpu, &mut memory),
        PpcImportAction::Return(0x9abc_def0),
    );
}

#[test]
fn native_ppc_math64_divide_obeys_remainder_and_zero_rules() {
    let mut memory = PpcSectionMem::new();
    memory.add_region(0x1000, vec![0xaa; 32]);
    let mut cpu = PpcCpu::new();
    cpu.gpr[3] = 0x1000;
    cpu.gpr[8] = 0x1008;
    math64_set_gprs(&mut cpu, 4, -17i64 as u64);
    math64_set_gprs(&mut cpu, 6, 5);
    let _ = ppc_dispatch_math64(math64_operation("S64Divide"), &mut cpu, &mut memory);
    assert_eq!(math64_read_memory(&mut memory, 0x1000), -3i64 as u64);
    assert_eq!(math64_read_memory(&mut memory, 0x1008), -2i64 as u64);

    math64_set_gprs(&mut cpu, 4, -17i64 as u64);
    math64_set_gprs(&mut cpu, 6, 0);
    let _ = ppc_dispatch_math64(math64_operation("S64Divide"), &mut cpu, &mut memory);
    assert_eq!(math64_read_memory(&mut memory, 0x1000), i64::MIN as u64);
    assert_eq!(math64_read_memory(&mut memory, 0x1008), -17i64 as u64);

    cpu.gpr[8] = 0;
    memory.write_u64_be(0x1008, 0xaaaa_aaaa_aaaa_aaaa).unwrap();
    math64_set_gprs(&mut cpu, 4, 17);
    let _ = ppc_dispatch_math64(math64_operation("U64Divide"), &mut cpu, &mut memory);
    assert_eq!(math64_read_memory(&mut memory, 0x1000), u64::MAX);
    assert_eq!(
        math64_read_memory(&mut memory, 0x1008),
        0xaaaa_aaaa_aaaa_aaaa,
    );
}

#[test]
fn native_ppc_math64_masks_shift_counts_to_seven_bits() {
    let mut memory = PpcSectionMem::new();
    memory.add_region(0x1000, vec![0; 8]);
    let mut cpu = PpcCpu::new();
    cpu.gpr[3] = 0x1000;
    math64_set_gprs(&mut cpu, 4, i64::MIN as u64);
    for (shift, expected) in [
        (0, i64::MIN as u64),
        (63, u64::MAX),
        (64, u64::MAX),
        (127, u64::MAX),
        (128, i64::MIN as u64),
    ] {
        cpu.gpr[6] = shift;
        let _ = ppc_dispatch_math64(math64_operation("S64ShiftRight"), &mut cpu, &mut memory);
        assert_eq!(math64_read_memory(&mut memory, 0x1000), expected, "{shift}",);
    }

    math64_set_gprs(&mut cpu, 4, 1);
    for (shift, expected) in [(0, 1), (63, 1 << 63), (64, 0), (127, 0), (128, 1)] {
        cpu.gpr[6] = shift;
        let _ = ppc_dispatch_math64(math64_operation("U64ShiftLeft"), &mut cpu, &mut memory);
        assert_eq!(math64_read_memory(&mut memory, 0x1000), expected, "{shift}",);
    }
}

#[test]
fn native_ppc_math64_distinguishes_scalar_boolean_compare_and_bitwise_results() {
    let mut memory = PpcSectionMem::new();
    memory.add_region(0x1000, vec![0; 8]);
    let mut cpu = PpcCpu::new();
    math64_set_gprs(&mut cpu, 3, u64::MAX);
    math64_set_gprs(&mut cpu, 5, 1);
    assert_eq!(
        ppc_dispatch_math64(math64_operation("S64Compare"), &mut cpu, &mut memory),
        PpcImportAction::Return(u32::MAX),
    );
    assert_eq!(
        ppc_dispatch_math64(math64_operation("U64Compare"), &mut cpu, &mut memory),
        PpcImportAction::Return(1),
    );
    assert_eq!(
        ppc_dispatch_math64(math64_operation("S64And"), &mut cpu, &mut memory),
        PpcImportAction::Return(1),
    );
    math64_set_gprs(&mut cpu, 3, 0);
    assert_eq!(
        ppc_dispatch_math64(math64_operation("U64Not"), &mut cpu, &mut memory),
        PpcImportAction::Return(1),
    );

    cpu.gpr[3] = 0x1000;
    math64_set_gprs(&mut cpu, 4, 0xf0f0_ffff_0000_aaaa);
    math64_set_gprs(&mut cpu, 6, 0x0ff0_00ff_ffff_5555);
    let _ = ppc_dispatch_math64(math64_operation("U64BitwiseEor"), &mut cpu, &mut memory);
    assert_eq!(
        math64_read_memory(&mut memory, 0x1000),
        0xff00_ff00_ffff_ffff,
    );
}

#[test]
fn native_ppc_math64_round_trips_integer_boundaries_through_double_double() {
    let mut memory = PpcSectionMem::new();
    memory.add_region(0x1000, vec![0; 16]);
    let mut cpu = PpcCpu::new();

    for value in [i64::MIN, -1, 0, i64::MAX - 1, i64::MAX] {
        math64_set_gprs(&mut cpu, 3, value as u64);
        let _ =
            ppc_dispatch_math64(math64_operation("SInt64ToLongDouble"), &mut cpu, &mut memory);
        cpu.gpr[3] = 0x1000;
        let _ =
            ppc_dispatch_math64(math64_operation("LongDoubleToSInt64"), &mut cpu, &mut memory);
        assert_eq!(math64_read_memory(&mut memory, 0x1000), value as u64);
    }

    for value in [0, 1, u64::MAX - 1, u64::MAX] {
        math64_set_gprs(&mut cpu, 3, value);
        let _ =
            ppc_dispatch_math64(math64_operation("UInt64ToLongDouble"), &mut cpu, &mut memory);
        cpu.gpr[3] = 0x1008;
        let _ =
            ppc_dispatch_math64(math64_operation("LongDoubleToUInt64"), &mut cpu, &mut memory);
        assert_eq!(math64_read_memory(&mut memory, 0x1008), value);
    }
}

#[test]
fn native_ppc_math_floor_rounds_down_and_preserves_special_values() {
    let mut memory = PpcSectionMem::new();
    let mut cpu = PpcCpu::new();
    for (input, expected) in [(-300.1f64, -301.0f64), (300.1, 300.0)] {
        cpu.fpr[1] = input.to_bits();
        assert_eq!(
            ppc_dispatch_math_compatibility(
                math_operation("floor"),
                &mut cpu,
                &mut memory,
            ),
            PpcImportAction::ReturnPreserve
        );
        assert_eq!(f64::from_bits(cpu.fpr[1]), expected);
    }
    for input in [-0.0f64, f64::INFINITY, f64::NEG_INFINITY] {
        cpu.fpr[1] = input.to_bits();
        let _ = ppc_dispatch_math_compatibility(
            math_operation("floor"),
            &mut cpu,
            &mut memory,
        );
        assert_eq!(cpu.fpr[1], input.to_bits());
    }
}