use super::*;
use crate::cpu::Register;
use crate::loader::{MpwFarSegmentHeader, Retro68RelocationError};
use crate::managers::resource::ResourceFork;
#[test]
fn load_app_patches_mpw_far_jump_table_offsets_from_segment_start() {
let mut code0 = minimal_code0(40, 0x2000, 8, 32);
code0[16..24].copy_from_slice(&[
0x00, 0x01, 0xA9, 0xF0, 0x00, 0x00, 0x00, 0x28, ]);
let mut code1 = vec![0u8; 0x30];
code1[0] = 0xFF;
code1[1] = 0xFF;
code1[0x28] = 0x4E;
code1[0x29] = 0x75;
let fork_bytes = make_resource_fork_bytes(&[(*b"CODE", 0, &code0), (*b"CODE", 1, &code1)]);
let fork = ResourceFork::parse(&fork_bytes).expect("parse synthetic app fork");
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let app = runner.load_app(&fork).expect("load app");
let jt_base = app.a5_base + app.code0_header.jump_table_offset;
let code1_base = app.segment_bases[&1];
assert_eq!(runner.bus.read_word(jt_base), 1);
assert_eq!(runner.bus.read_word(jt_base + 2), 0x4EF9);
assert_eq!(
runner.bus.read_long(jt_base + 4),
code1_base + 0x28,
"MPW far offsets must not be adjusted by the 40-byte header twice"
);
}
#[test]
fn load_app_executes_far_jump_table_routine_above_64k() {
let offset = 0x0001_A114u32;
let mut code0 = minimal_code0(40, 0x2000, 8, 32);
code0[16..20].copy_from_slice(&[0x00, 0x01, 0xA9, 0xF0]);
code0[20..24].copy_from_slice(&offset.to_be_bytes());
let mut code1 = vec![0; offset as usize + 4];
code1[..2].copy_from_slice(&0xFFFFu16.to_be_bytes());
code1[0xA114..0xA118].copy_from_slice(&[0x70, 0x01, 0x4E, 0x75]);
code1[offset as usize..].copy_from_slice(&[0x70, 0x2A, 0x4E, 0x75]);
let bytes = make_resource_fork_bytes(&[(*b"CODE", 0, &code0), (*b"CODE", 1, &code1)]);
let fork = ResourceFork::parse(&bytes).expect("synthetic far-model resource fork");
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let app = runner.load_app(&fork).expect("load far-model application");
let jt = app.a5_base + app.code0_header.jump_table_offset;
runner.cpu_mut().write_reg(Register::PC, jt + 2);
runner.step(); runner.step(); assert_eq!(runner.cpu().read_reg(Register::D0), 42);
assert_eq!(app.jump_table[0].offset, offset);
assert_eq!(runner.bus.read_long(jt + 4), app.segment_bases[&1] + offset);
}
#[test]
fn load_app_applies_mpw_far_a5_and_pc_relocations() {
let mut code0 = minimal_code0(40, 0x2000, 8, 32);
code0[16..24].copy_from_slice(&[
0x00, 0x01, 0xA9, 0xF0, 0x00, 0x00, 0x00, 0x28,
]);
let mut code1 = vec![0u8; 0x130];
code1[0..2].copy_from_slice(&0xFFFFu16.to_be_bytes());
code1[20..24].copy_from_slice(&0x50u32.to_be_bytes());
code1[28..32].copy_from_slice(&0x54u32.to_be_bytes());
code1[0x28..0x2A].copy_from_slice(&[0x4E, 0xB9]); code1[0x2A..0x2E].copy_from_slice(&0x100u32.to_be_bytes());
code1[0x30..0x32].copy_from_slice(&[0x20, 0x79]); code1[0x32..0x36].copy_from_slice(&0x40u32.to_be_bytes());
code1[0x100..0x104].copy_from_slice(&[0x70, 0x01, 0x4E, 0x75]);
code1[0x128..0x12C].copy_from_slice(&[0x70, 0x2A, 0x4E, 0x75]);
code1[0x50..0x54].copy_from_slice(&[
0x19, 0x00, 0x00, 0x00,
]);
code1[0x54..0x57].copy_from_slice(&[
0x15, 0x00, 0x00,
]);
let fork_bytes = make_resource_fork_bytes(&[(*b"CODE", 0, &code0), (*b"CODE", 1, &code1)]);
let fork = ResourceFork::parse(&fork_bytes).expect("parse synthetic app fork");
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let app = runner.load_app(&fork).expect("load app");
let code1_base = app.segment_bases[&1];
assert_eq!(
runner.bus.read_long(code1_base + 0x2A),
code1_base + MpwFarSegmentHeader::SIZE as u32 + 0x100,
"PC relocation stream must add the loaded code address after the far header"
);
runner.cpu_mut().write_reg(Register::PC, code1_base + 0x28);
runner.step(); runner.step(); assert_eq!(runner.cpu().read_reg(Register::D0), 42);
assert_eq!(
runner.bus.read_long(code1_base + 0x32),
app.a5_base + 0x40,
"A5 relocation stream must add the current A5"
);
assert_eq!(
runner
.bus
.read_long(code1_base + MpwFarSegmentHeader::CURRENT_A5_OFFSET),
app.a5_base
);
assert_eq!(
runner
.bus
.read_long(code1_base + MpwFarSegmentHeader::LOAD_ADDRESS_OFFSET),
code1_base
);
}
#[test]
fn load_app_applies_retro68_code_and_data_relocations() {
let mut code0 = minimal_code0(40, 0x2000, 8, 32);
code0[16..24].copy_from_slice(&[
0x00, 0x01, 0xA9, 0xF0, 0x00, 0x00, 0x00, 0x28,
]);
let mut code1 = vec![0u8; 0x60];
code1[0..2].copy_from_slice(&0xFFFFu16.to_be_bytes());
for (offset, value) in [0x20u32, 0x30, 0x40, 0x50, 0x60].into_iter().enumerate() {
let start = MpwFarSegmentHeader::SIZE + offset * 4;
code1[start..start + 4].copy_from_slice(&value.to_be_bytes());
}
let rela1 = [
0x04, 0x11, 0x12, 0x13, 0x00, 0x44, 0x00, ];
let mut data = Vec::new();
for value in [0x10u32, 0x20, 0x30, 0x40] {
data.extend_from_slice(&value.to_be_bytes());
}
let rela0 = [
0x04, 0x11, 0x12, 0x13, 0x00, 0x00, ];
let fork_bytes = make_resource_fork_bytes(&[
(*b"CODE", 0, &code0),
(*b"CODE", 1, &code1),
(*b"DATA", 0, &data),
(*b"RELA", 0, &rela0),
(*b"RELA", 1, &rela1),
]);
let fork = ResourceFork::parse(&fork_bytes).expect("parse synthetic Retro68 app fork");
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let app = runner.load_app(&fork).expect("load Retro68 app");
let code1_base = app.segment_bases[&1];
let code_body = code1_base + MpwFarSegmentHeader::SIZE as u32;
let data_base = app.a5_base - app.code0_header.below_a5;
assert_eq!(runner.bus.read_long(code_body), code1_base + 0x20);
assert_eq!(runner.bus.read_long(code_body + 4), app.a5_base + 0x30);
assert_eq!(runner.bus.read_long(code_body + 8), app.a5_base + 0x40);
assert_eq!(runner.bus.read_long(code_body + 12), app.a5_base + 0x50);
assert_eq!(
runner.bus.read_long(code_body + 16),
0x28,
"the first PC-relative record must immediately follow the first terminator"
);
assert_eq!(runner.bus.read_long(data_base), 0x10);
assert_eq!(runner.bus.read_long(data_base + 4), app.a5_base + 0x20);
assert_eq!(runner.bus.read_long(data_base + 8), app.a5_base + 0x30);
assert_eq!(runner.bus.read_long(data_base + 12), app.a5_base + 0x40);
assert_eq!(
runner
.bus
.read_long(code1_base + MpwFarSegmentHeader::CURRENT_A5_OFFSET),
app.a5_base
);
assert_eq!(
runner
.bus
.read_long(code1_base + MpwFarSegmentHeader::LOAD_ADDRESS_OFFSET),
code1_base
);
}
#[test]
fn invalid_retro68_relocations_do_not_partially_modify_memory() {
let mut runner = FixtureRunner::new(1024 * 1024, FixtureRunnerConfig::default());
let target = 0x1000;
runner.bus.write_long(target, 0x20);
let result = apply_retro68_rela_relocations(
&mut runner.bus,
target,
4,
&[
0x04, 0x00, 0x08, 0x00,
],
[0x100, 0, 0, 0],
);
assert_eq!(
result,
Err(Retro68RelocationError::TargetOutOfBounds {
offset: 1,
target_size: 4,
})
);
assert_eq!(runner.bus.read_long(target), 0x20);
}
#[test]
fn prepatched_far_jump_table_segments_have_recoverable_handles() {
let mut code0 = minimal_code0(48, 0x2000, 16, 32);
code0[16..24].copy_from_slice(&[0x00, 0x01, 0xA9, 0xF0, 0x00, 0x00, 0x00, 0x28]);
code0[24..32].copy_from_slice(&[0x00, 0x02, 0xA9, 0xF0, 0x00, 0x00, 0x00, 0x28]);
let mut code1 = vec![0u8; 0x30];
let mut code2 = vec![0u8; 0x30];
code1[..2].copy_from_slice(&0xFFFFu16.to_be_bytes());
code2[..2].copy_from_slice(&0xFFFFu16.to_be_bytes());
code1[0x28..0x2A].copy_from_slice(&[0x4E, 0x75]);
code2[0x28..0x2A].copy_from_slice(&[0x4E, 0x75]);
let bytes = make_resource_fork_bytes(&[
(*b"CODE", 0, &code0),
(*b"CODE", 1, &code1),
(*b"CODE", 2, &code2),
]);
let fork = ResourceFork::parse(&bytes).unwrap();
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let app = runner.load_app(&fork).unwrap();
let jt = app.a5_base + app.code0_header.jump_table_offset;
assert_eq!(runner.bus.read_word(jt + 10), 0x4EF9);
assert_eq!(runner.bus.read_long(jt + 12), app.segment_bases[&2] + 0x28);
runner.init_app(&app);
let ptr = app.segment_bases[&2];
runner.m68k.cpu.write_reg(Register::A0, ptr);
runner
.dispatcher
.dispatch(0xA128, &mut runner.m68k.cpu, &mut runner.bus)
.unwrap();
let handle = runner.m68k.cpu.read_reg(Register::A0);
assert_ne!(
handle, 0,
"prepatched executable code must have a recoverable handle"
);
assert_eq!(runner.bus.read_long(handle), ptr);
}
#[test]
fn dynamically_loaded_near_segment_has_recoverable_handle() {
let mut code0 = minimal_code0(48, 0x2000, 16, 32);
code0[16..24].copy_from_slice(&[0, 0, 0x3F, 0x3C, 0, 1, 0xA9, 0xF0]);
code0[24..32].copy_from_slice(&[0, 0, 0x3F, 0x3C, 0, 2, 0xA9, 0xF0]);
let code1 = [0, 0, 0, 1, 0x4E, 0x75];
let code2 = [0, 8, 0, 1, 0x4E, 0x75];
let bytes = make_resource_fork_bytes(&[
(*b"CODE", 0, &code0),
(*b"CODE", 1, &code1),
(*b"CODE", 2, &code2),
]);
let fork = ResourceFork::parse(&bytes).unwrap();
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let app = runner.load_app(&fork).unwrap();
let jt = app.a5_base + app.code0_header.jump_table_offset;
let ptr = app.segment_bases[&2];
runner.init_app(&app);
let sp = runner.m68k.cpu.read_reg(Register::A7) - 2;
runner.bus.write_word(sp, 2);
runner.m68k.cpu.write_reg(Register::A7, sp);
runner.m68k.cpu.write_reg(Register::PC, jt + 16);
runner
.dispatcher
.dispatch(0xA9F0, &mut runner.m68k.cpu, &mut runner.bus)
.unwrap();
assert_eq!(runner.bus.read_word(jt + 10), 0x4EF9);
runner.m68k.cpu.write_reg(Register::A0, ptr);
runner
.dispatcher
.dispatch(0xA128, &mut runner.m68k.cpu, &mut runner.bus)
.unwrap();
let handle = runner.m68k.cpu.read_reg(Register::A0);
assert_ne!(
handle, 0,
"loaded near segment must have a recoverable handle"
);
assert_eq!(runner.bus.read_long(handle), ptr);
}