Add support for "expedited registers" in T-stop packets.

src/stub/state_machine.rs

@@ -44,6 +44,7 @@
 use crate::stub::error::GdbStubError;
 use crate::stub::error::InternalError;
 use crate::stub::stop_reason::IntoStopReason;
+use crate::stub::BaseStopReason;
 use crate::target::Target;
 use managed::ManagedSlice;
 
@@ -251,12 +252,60 @@
 impl<'a, T: Target, C: Connection> GdbStubStateMachineInner<'a, state::Running, T, C> {
     /// Report a target stop reason back to GDB.
     pub fn report_stop(
+        self,
+        target: &mut T,
+        reason: impl IntoStopReason<T>,
+    ) -> Result<GdbStubStateMachine<'a, T, C>, GdbStubError<T::Error, C::Error>> {
+        self.report_stop_impl(target, reason, None)
+    }
+
+    /// Report a target stop reason back to GDB, including expedited
+    /// register values in the stop reply T-packet.
+    ///
+    /// The iterator yields `(register_number, value_bytes)` pairs that
+    /// are written as expedition registers in the T-packet. Values
+    /// should be in target byte order (typically little-endian).
+    ///
+    /// This may be useful to use, rather than [`report_stop`], when
+    /// we want to provide register values immediately to, for
+    /// example, avoid a round-trip, or work around a quirk/bug in a
+    /// debugger that does not otherwise request new register values.
+    pub fn report_stop_with_regs(
+        self,
+        target: &mut T,
+        reason: impl IntoStopReason<T>,
+        regs: &mut dyn Iterator<Item = (u32, &[u8])>,
+    ) -> Result<GdbStubStateMachine<'a, T, C>, GdbStubError<T::Error, C::Error>> {
+        self.report_stop_impl(target, reason, Some(regs))
+    }
+
+    /// Shared implementation for the
+    /// `report_stop`/`report_stop_with_regs` API. Takes an `Option`
+    /// around the `&mut dyn Iterator` to avoid making a dynamic
+    /// vtable dispatch in the common `report_stop` case.
+    fn report_stop_impl(
         mut self,
         target: &mut T,
         reason: impl IntoStopReason<T>,
+        regs: Option<&mut dyn Iterator<Item = (u32, &[u8])>>,
     ) -> Result<GdbStubStateMachine<'a, T, C>, GdbStubError<T::Error, C::Error>> {
+        let reason: BaseStopReason<_, _> = reason.into();
+        let is_t_packet = reason.is_t_packet();
+
         let mut res = ResponseWriter::new(&mut self.i.conn, target.use_rle());
-        let event = self.i.inner.finish_exec(&mut res, target, reason.into())?;
+        let event = self.i.inner.finish_exec(&mut res, target, reason)?;
+
+        if let Some(regs) = regs {
+            if is_t_packet {
+                for (reg_id, value) in regs {
+                    res.write_num(reg_id).map_err(InternalError::from)?;
+                    res.write_str(":").map_err(InternalError::from)?;
+                    res.write_hex_buf(value).map_err(InternalError::from)?;
+                    res.write_str(";").map_err(InternalError::from)?;
+                }
+            }
+        }
+
         res.flush().map_err(InternalError::from)?;
 
         Ok(match event {

src/stub/stop_reason.rs

@@ -135,6 +135,28 @@ pub enum BaseStopReason<Tid, U> {
     VForkDone(Tid),
 }
 
+impl<Tid, U> BaseStopReason<Tid, U> {
+    /// Does this stop reason respond with a `T` packet?
+    pub(crate) fn is_t_packet(&self) -> bool {
+        match self {
+            Self::SignalWithThread { .. } => true,
+            Self::SwBreak(_) => true,
+            Self::HwBreak(_) => true,
+            Self::Watch { .. } => true,
+            Self::ReplayLog { .. } => true,
+            Self::CatchSyscall { .. } => true,
+            Self::Library(_) => true,
+            Self::Fork { .. } => true,
+            Self::VFork { .. } => true,
+            Self::VForkDone(_) => true,
+            Self::DoneStep => false,
+            Self::Signal(_) => false,
+            Self::Exited(_) => false,
+            Self::Terminated(_) => false,
+        }
+    }
+}
+
 /// A stop reason for a single threaded target.
 ///
 /// Threads are identified using the unit type `()` (as there is only a single