add 'write register' command of the RSP protocol

src/gdbstub_impl/mod.rs

@@ -413,6 +413,15 @@ impl<T: Target, C: Connection> GdbStubImpl<T, C> {
                 target.read_register(reg_id, dst).maybe_missing_impl()?;
                 res.write_hex_buf(dst)?;
             }
+            Command::P(p) => {
+                let reg = <<T::Arch as Arch>::Registers as Registers>::RegId::from_raw_id(p.reg_id);
+                let (reg_id, _) = match reg {
+                    Some(v) => v,
+                    None => return Ok(None),
+                };
+                target.write_register(reg_id, p.val).maybe_missing_impl()?;
+                res.write_str("OK")?;
+            }
             Command::vCont(cmd) => {
                 use crate::protocol::_vCont::VContKind;
 
@@ -454,14 +463,14 @@ impl<T: Target, C: Connection> GdbStubImpl<T, C> {
                     res,
                     target,
                     &mut core::iter::once((self.current_tid.tid, ResumeAction::Continue)),
-                )
+                );
             }
             Command::s(_) => {
                 return self.do_vcont(
                     res,
                     target,
                     &mut core::iter::once((self.current_tid.tid, ResumeAction::Step)),
-                )
+                );
             }
 
             // ------------------- Multi-threading Support ------------------ //

src/protocol/commands.rs

@@ -103,6 +103,7 @@ commands! {
     "z" => _z::z,
     "Z" => _z_upcase::Z,
     "p" => _p::p,
+    "P" => _p_upcase::P<'a>,
     // Order Matters (because of prefix matching)
     "vCont?" => vCont_question_mark::vContQuestionMark,
     "vCont" => _vCont::vCont<'a>,

src/protocol/commands/_p_upcase.rs

@@ -0,0 +1,17 @@
+use super::prelude::*;
+
+#[derive(PartialEq, Eq, Debug)]
+pub struct P<'a> {
+    pub reg_id: usize,
+    pub val: &'a [u8]
+}
+
+impl<'a> ParseCommand<'a> for P<'a> {
+    fn from_packet(buf: PacketBuf<'a>) -> Option<Self> {
+        let body = buf.into_body();
+        let mut body = body.split_mut(|&b| b == b'=');
+        let reg_id = decode_hex(body.next()?).ok()?;
+        let val = decode_hex_buf(body.next()?).ok()?;
+        Some(P { reg_id, val })
+    }
+}

src/target.rs

@@ -138,6 +138,19 @@ pub trait Target {
         regs: &<Self::Arch as Arch>::Registers,
     ) -> Result<(), Self::Error>;
 
+    /// Write a single register on the target.
+    ///
+    /// On multi-threaded systems, this method **must** respect the currently
+    /// selected thread (set via the `set_current_thread` method).
+    fn write_register(
+        &mut self,
+        reg_id: <<Self::Arch as Arch>::Registers as Registers>::RegId,
+        val: &[u8],
+    ) -> OptResult<(), Self::Error> {
+        let _ = (reg_id, val);
+        Err(MaybeUnimpl::no_impl())
+    }
+
     /// Read bytes from the specified address range.
     ///
     /// ### Handling non-fatal invalid memory reads
@@ -414,6 +427,14 @@ macro_rules! impl_dyn_target {
                 (**self).write_registers(regs)
             }
 
+            fn write_register(
+                &mut self,
+                reg_number: <<Self::Arch as Arch>::Registers as Registers>::RegId,
+                val: &[u8],
+            ) -> OptResult<(), Self::Error> {
+                (**self).write_register(reg_number, val)
+            }
+
             fn read_addrs(
                 &mut self,
                 start_addr: <Self::Arch as Arch>::Usize,