Fix wrapping memory reads for 64-bit addresses

src/emulator.rs

@@ -3,7 +3,6 @@ use std::{
     fmt::Display,
     fs::{self, File},
     io::{Read, Seek, SeekFrom, Write},
-    ops::Range,
     path::{Path, PathBuf},
     sync::{
         atomic::{AtomicBool, Ordering},
@@ -529,11 +528,11 @@ impl Emulator {
                 let value = sim.read_register(register);
                 let _ = done.send(value);
             }
-            EmulatorCommand::ReadMemory(sim_id, addresses, mut buffer, done) => {
+            EmulatorCommand::ReadMemory(sim_id, start, length, mut buffer, done) => {
                 let Some(sim) = self.sims.get_mut(sim_id.to_index()) else {
                     return;
                 };
-                sim.read_memory(addresses, &mut buffer);
+                sim.read_memory(start, length, &mut buffer);
                 let _ = done.send(buffer);
             }
             EmulatorCommand::AddBreakpoint(sim_id, address) => {
@@ -611,7 +610,7 @@ pub enum EmulatorCommand {
     DebugContinue(SimId),
     DebugStep(SimId),
     ReadRegister(SimId, VBRegister, oneshot::Sender<u32>),
-    ReadMemory(SimId, Range<u32>, Vec<u8>, oneshot::Sender<Vec<u8>>),
+    ReadMemory(SimId, u32, usize, Vec<u8>, oneshot::Sender<Vec<u8>>),
     AddBreakpoint(SimId, u32),
     RemoveBreakpoint(SimId, u32),
     SetAudioEnabled(bool, bool),

src/emulator/shrooms_vb_core.rs

@@ -1,4 +1,4 @@
-use std::{ffi::c_void, ops::Range, ptr, slice};
+use std::{ffi::c_void, ptr, slice};
 
 use anyhow::{anyhow, Result};
 use bitflags::bitflags;
@@ -349,10 +349,12 @@ impl Sim {
         }
     }
 
-    pub fn read_memory(&mut self, addresses: Range<u32>, into: &mut Vec<u8>) {
+    pub fn read_memory(&mut self, start: u32, length: usize, into: &mut Vec<u8>) {
-        for address in addresses {
+        let mut address = start;
+        for _ in 0..length {
             let byte = unsafe { vb_read(self.sim, address, VBDataType::U8) };
             into.push(byte as u8);
+            address = address.wrapping_add(1);
         }
     }
 

src/gdbserver.rs

@@ -280,17 +280,18 @@ impl GdbConnection {
             }
         } else if let Some(op) = req.match_some_str(["m", "x"]) {
             let mut read_memory = || {
-                let start = req.match_hex::<u32>()?;
+                let start = req.match_hex::<u64>()? as u32;
                 if !req.match_str(",") {
                     return None;
                 };
-                let size = req.match_hex::<u32>()?;
+                let length = req.match_hex::<usize>()?;
                 let mut buf = self.memory_buf.take().unwrap_or_default();
                 buf.clear();
                 let (tx, rx) = ::oneshot::channel();
                 self.client.send_command(EmulatorCommand::ReadMemory(
                     self.sim_id,
-                    start..(start + size),
+                    start,
+                    length,
                     buf,
                     tx,
                 ));