0xrsydn/gameboy-rust
1
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix(memory): ignore CPU and DMA writes to the Game Pak ROM windows

Browse source 
Stores to 0x08-0x0c returned ReadOnly and stopped the machine. Hardware ignores
them, and a second game's boot code stores to a ROM mirror. Emulated writes now
pay their bus cost and change nothing. The 0x0d window stays a diagnostic until
EEPROM is modeled there, and host writes stay strict.

Tests that used a ROM store as their failing write now cross an ignored ROM
word into the 0x0d window.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HhfHfHEuzv2AUTd6erW1gU
This commit is contained in:
0xrsydn 2026-10-14 08:26:03 +07:00
commit 258fbff2fa
25 changed files with 86 additions and 74 deletions
Download patch file Download diff file Expand all files Collapse all files

7
crates/gba-core/tests/bios.rs
View file

@ -437,8 +437,8 @@ fn protected_or_wrapping_source_ranges_return_without_copying() {
}
#[test]
fn copy_failure_keeps_earlier_writes_but_not_partial_instruction_changes() {
let (mut machine, _) = call(0x0b, false, [SOURCE, 0x07ff_fffc, 2 | (1 << 26)]);
fn copy_failure_follows_an_ignored_rom_word_without_partial_instruction_changes() {
let (mut machine, _) = call(0x0b, false, [SOURCE, 0x0cff_fffc, 2 | (1 << 26)]);
machine.memory_mut().write32(SOURCE, 0xaabb_ccdd).unwrap();
let mut failed = false;
for _ in 0..100 {
@ -448,12 +448,11 @@ fn copy_failure_keeps_earlier_writes_but_not_partial_instruction_changes() {
if let Err(error) = machine.step() {
assert_eq!(
error,
MachineError::Cpu(MemoryError::ReadOnly(0x0800_0000).into())
MachineError::Cpu(MemoryError::ReadOnly(0x0d00_0000).into())
);
assert_eq!(machine.cpu(), &before);
assert_eq!(machine.cycles(), cycles);
assert_eq!(machine.last_timing(), timing);
assert_eq!(machine.memory().read32(0x07ff_fffc).unwrap(), 0xaabb_ccdd);
failed = true;
break;
}

5
crates/gba-core/tests/bios/affine.rs
View file

@ -498,12 +498,11 @@ fn destination_failure_keeps_preceding_halfword_stores() {
angle: 0,
}])
};
let (mut m, _) = prepare(service, false, [DATA, 0x07ff_fffc, 1, 2], 0x1f, &data);
let (mut m, _) = prepare(service, false, [DATA, 0x0cff_fffc, 1, 2], 0x1f, &data);
assert_eq!(
fail(&mut m),
MachineError::Cpu(MemoryError::ReadOnly(ROM_START).into())
MachineError::Cpu(MemoryError::ReadOnly(0x0d00_0000).into())
);
assert_eq!(m.memory().read32(0x07ff_fffc).unwrap(), 256);
}
}

7
crates/gba-core/tests/bios/bit_unpack.rs
View file

@ -361,10 +361,10 @@ fn truncated_descriptors_and_sources_return_memory_diagnostics() {
}
#[test]
fn destination_failure_preserves_completed_word() {
fn destination_failure_follows_an_ignored_rom_word() {
let (mut m, _) = prepare(
false,
0x07ff_fffc,
0x0cff_fffc,
&[0x12, 0x34, 0x56, 0x78, 1, 2, 3, 4],
8,
8,
@ -372,9 +372,8 @@ fn destination_failure_preserves_completed_word() {
);
assert_eq!(
fail(&mut m),
MachineError::Cpu(MemoryError::ReadOnly(ROM_START).into())
MachineError::Cpu(MemoryError::ReadOnly(0x0d00_0000).into())
);
assert_eq!(m.memory().read32(0x07ff_fffc).unwrap(), 0x7856_3412);
}
#[test]

10
crates/gba-core/tests/bios/differential.rs
View file

@ -321,17 +321,13 @@ fn failed_source_reads_keep_completed_units_but_not_pending_halfwords() {
}
#[test]
fn destination_failure_preserves_preceding_completed_halfword() {
fn destination_failure_follows_an_ignored_rom_halfword() {
for service in [0x17, 0x18] {
let (data, _) = filtered(service, &[0x12, 0x34, 0x56, 0x78]);
let (mut m, _) = prepare(service, false, 0x07ff_fffe, &data);
let (mut m, _) = prepare(service, false, 0x0cff_fffe, &data);
assert_eq!(
fail(&mut m),
MachineError::Cpu(MemoryError::ReadOnly(ROM_START).into())
);
assert_eq!(
m.memory().read16(0x07ff_fffe).unwrap(),
if service == 0x17 { 0x3412 } else { 0x12 }
MachineError::Cpu(MemoryError::ReadOnly(0x0d00_0000).into())
);
}
}

7
crates/gba-core/tests/bios/huffman.rs
View file

@ -412,14 +412,13 @@ fn input_word_refill_failure_does_not_commit_incomplete_output() {
}
#[test]
fn destination_failure_preserves_preceding_completed_word() {
fn destination_failure_follows_an_ignored_rom_word() {
let (data, _) = encode(8, &pair(), &[0x12; 8]);
let (mut m, _) = prepare(false, 0x07ff_fffc, &data);
let (mut m, _) = prepare(false, 0x0cff_fffc, &data);
assert_eq!(
fail(&mut m),
MachineError::Cpu(MemoryError::ReadOnly(ROM_START).into())
MachineError::Cpu(MemoryError::ReadOnly(0x0d00_0000).into())
);
assert_eq!(m.memory().read32(0x07ff_fffc).unwrap(), 0x1212_1212);
}
#[test]

5
crates/gba-core/tests/bios/lz77.rs
View file

@ -431,10 +431,9 @@ fn destination_failure_preserves_preceding_completed_halfword() {
Token::Literal(0x56),
Token::Literal(0x78),
]);
let (mut machine, _) = prepare(0x12, false, 0x07ff_fffe, &compressed);
let (mut machine, _) = prepare(0x12, false, 0x0cff_fffe, &compressed);
assert_eq!(
fail(&mut machine),
MachineError::Cpu(MemoryError::ReadOnly(0x0800_0000).into())
MachineError::Cpu(MemoryError::ReadOnly(0x0d00_0000).into())
);
assert_eq!(machine.memory().read16(0x07ff_fffe).unwrap(), 0x3412);
}

7
crates/gba-core/tests/bios/run_length.rs
View file

@ -317,14 +317,13 @@ fn incomplete_halfwords_are_not_committed_after_source_failure() {
}
#[test]
fn destination_failure_preserves_earlier_completed_writes() {
fn destination_failure_follows_an_ignored_rom_halfword() {
let (data, _) = stream(&[Block::Literal(vec![0x12, 0x34, 0x56, 0x78])]);
let (mut m, _) = prepare(0x15, false, 0x07ff_fffe, &data);
let (mut m, _) = prepare(0x15, false, 0x0cff_fffe, &data);
assert_eq!(
fail(&mut m),
MachineError::Cpu(MemoryError::ReadOnly(ROM_START).into())
MachineError::Cpu(MemoryError::ReadOnly(0x0d00_0000).into())
);
assert_eq!(m.memory().read16(0x07ff_fffe).unwrap(), 0x3412);
}
#[test]

4
crates/gba-core/tests/dma.rs
View file

@ -686,10 +686,10 @@ fn invalid_memory_and_dma_register_destinations_are_diagnostics() {
),
(
SOURCE,
ROM_START,
0x0d00_0000,
DmaError::Memory {
channel: 3,
error: MemoryError::ReadOnly(ROM_START),
error: MemoryError::ReadOnly(0x0d00_0000),
},
),
(

8
crates/gba-core/tests/dma/latch.rs
View file

@ -145,12 +145,12 @@ fn zero_is_known_data_not_an_unknown_latch() {
fn failed_units_preserve_the_old_latch_without_new_data_or_irq() {
for (source, destination, control) in [
(0x0e00_0000, DEST, 0x4400), // Unmapped reads do not use a known latch.
(SOURCE, ROM_START, 0x4400),
(SOURCE, 0x0d00_0000, 0x4400),
(SOURCE, 0x0400_0058, 0x4400),
(SOURCE, DMA_BASE, 0x4400),
(SOURCE, 0x0400_0300, 0x4400),
(SOURCE, DEST, 0x4580), // Unsupported source mode.
(0, ROM_START, 0x4400), // A blocked source cannot bypass destination checks.
(SOURCE, DEST, 0x4580), // Unsupported source mode.
(0, 0x0d00_0000, 0x4400), // A blocked source cannot bypass destination checks.
] {
let mut machine = machine();
seed(&mut machine, 3, DATA);
@ -175,7 +175,7 @@ fn failed_units_preserve_the_old_latch_without_new_data_or_irq() {
fn failed_destination_does_not_seed_a_cold_channel() {
let mut machine = machine();
machine.memory_mut().write32(SOURCE, DATA).unwrap();
configure(machine.memory_mut(), 3, SOURCE, ROM_START, 1, 0x400);
configure(machine.memory_mut(), 3, SOURCE, 0x0d00_0000, 1, 0x400);
assert!(machine.step().is_err());
machine.memory_mut().write16(base(3) + 10, 0).unwrap();
configure(machine.memory_mut(), 3, 0, DEST, 1, 0x400);