Wrap raw read_register callback, and introduce a weird compiler error

Author: DrChat

src/gdbstub_impl/ext/single_register_access.rs

@@ -2,7 +2,7 @@ use super::prelude::*;
 use crate::protocol::commands::ext::SingleRegisterAccess;
 
 use crate::arch::{Arch, RegId};
-use crate::target::ext::base::BaseOps;
+use crate::target::ext::base::{BaseOps, SendRegisterOutput};
 
 impl<T: Target, C: Connection> GdbStubImpl<T, C> {
     fn inner<Id>(
@@ -20,15 +20,17 @@ impl<T: Target, C: Connection> GdbStubImpl<T, C> {
                     Some(v) => v,
                 };
 
-                // TODO: Limit the number of bytes transferred on the wire to the register size
-                // (if specified). Maybe pad the register if the callee does not
-                // send enough data?
                 let mut err = Ok(());
-                ops.read_register(id, reg_id, &mut |buf| match res.write_hex_buf(buf) {
+                let mut send_output = |buf| match res.write_hex_buf(buf) {
                     Ok(_) => {}
                     Err(e) => err = Err(e),
-                })
-                .handle_error()?;
+                };
+
+                // TODO: Limit the number of bytes transferred on the wire to the register size
+                // (if specified). Maybe pad the register if the callee does not
+                // send enough data?
+                ops.read_register(id, reg_id, SendRegisterOutput::new(&mut send_output))
+                    .handle_error()?;
 
                 err?;
 

src/target/ext/base/mod.rs

@@ -10,7 +10,9 @@ pub mod singlethread;
 
 mod single_register_access;
 
-pub use single_register_access::{SingleRegisterAccess, SingleRegisterAccessOps};
+pub use single_register_access::{
+    SendRegisterOutput, SingleRegisterAccess, SingleRegisterAccessOps,
+};
 
 /// Base operations for single/multi threaded targets.
 pub enum BaseOps<'a, A, E> {

src/target/ext/base/single_register_access.rs

@@ -35,7 +35,7 @@ pub trait SingleRegisterAccess<Id>: Target {
         &mut self,
         tid: Id,
         reg_id: <Self::Arch as Arch>::RegId,
-        output: &mut dyn FnMut(&[u8]),
+        output: SendRegisterOutput<'_>,
     ) -> TargetResult<(), Self>;
 
     /// Write from a single register on the target.
@@ -65,3 +65,19 @@ pub trait SingleRegisterAccess<Id>: Target {
 /// See [`SingleRegisterAccess`]
 pub type SingleRegisterAccessOps<'a, Id, T> =
     &'a mut dyn SingleRegisterAccess<Id, Arch = <T as Target>::Arch, Error = <T as Target>::Error>;
+
+/// An interface to send register data to the GDB remote debugger.
+pub struct SendRegisterOutput<'a> {
+    inner: &'a mut dyn FnMut(&[u8]),
+}
+
+impl<'a> SendRegisterOutput<'a> {
+    pub(crate) fn new(inner: &'a mut dyn FnMut(&[u8])) -> Self {
+        Self { inner }
+    }
+
+    /// Write out raw register bytes to the GDB debugger.
+    pub fn write(&mut self, data: &[u8]) {
+        (self.inner)(data)
+    }
+}