Review feedback.

Author: cfallin

src/common/mod.rs

@@ -9,3 +9,15 @@ pub type Tid = core::num::NonZeroUsize;
 
 /// Process ID
 pub type Pid = core::num::NonZeroUsize;
+
+/// Endinanness.
+///
+/// This is used to report target endianness to the debugger as a
+/// response to certain commands.
+#[derive(Clone, Copy, Debug)]
+pub enum Endianness {
+    /// Big-endian.
+    Big,
+    /// Little-endian.
+    Little,
+}

src/stub/core_impl/process_info.rs

@@ -1,5 +1,51 @@
 use super::prelude::*;
+use crate::common::Endianness;
 use crate::protocol::commands::ext::ProcessInfo;
+use crate::protocol::ResponseWriterError;
+use crate::target::ext::process_info::HostInfoResponse;
+use crate::target::ext::process_info::ProcessInfoResponse;
+
+impl<'a> HostInfoResponse<'a> {
+    fn write_response<C: Connection>(
+        &self,
+        res: &mut ResponseWriter<'_, C>,
+    ) -> Result<(), ResponseWriterError<C::Error>> {
+        res.write_str("triple:")?;
+        res.write_hex_buf(self.triple.as_bytes())?;
+        res.write_str(";endian:")?;
+        res.write_str(match self.endianness {
+            Endianness::Big => "big",
+            Endianness::Little => "little",
+        })?;
+        res.write_str(";ptrsize:")?;
+        res.write_dec(self.ptrsize)?;
+        res.write_str(";")?;
+        Ok(())
+    }
+}
+
+impl<'a> ProcessInfoResponse<'a> {
+    fn write_response<C: Connection>(
+        &self,
+        res: &mut ResponseWriter<'_, C>,
+    ) -> Result<(), ResponseWriterError<C::Error>> {
+        res.write_str("pid:")?;
+        res.write_dec(usize::from(self.pid))?;
+        res.write_str(";")?;
+        self.host_info_portion().write_response(res)?;
+        Ok(())
+    }
+
+    /// A ProcessInfoResponse is a superset of a HostInfoResponse; so
+    /// we reuse the latter to emit most of our fields.
+    fn host_info_portion(&self) -> HostInfoResponse<'a> {
+        HostInfoResponse {
+            triple: self.triple,
+            endianness: self.endianness,
+            ptrsize: self.ptrsize,
+        }
+    }
+}
 
 impl<T: Target, C: Connection> GdbStubImpl<T, C> {
     pub(crate) fn handle_process_info(
@@ -15,25 +61,22 @@ impl<T: Target, C: Connection> GdbStubImpl<T, C> {
 
         crate::__dead_code_marker!("process_info", "impl");
 
-        let mut write_err = Ok(());
-        let mut write_cb = |data: &[u8]| {
-            if write_err.is_ok() {
-                if let Err(e) = res.write_str(core::str::from_utf8(data).unwrap_or("")) {
-                    write_err = Err(e);
-                }
-            }
-        };
-
         let handler_status = match command {
             ProcessInfo::qHostInfo(_cmd) => {
-                ops.host_info(&mut write_cb).map_err(Error::TargetError)?;
-                write_err?;
+                let mut result = Ok(());
+                ops.host_info(&mut |info| {
+                    result = info.write_response(res);
+                })
+                .map_err(Error::TargetError)?;
+                result?;
                 HandlerStatus::Handled
             }
             ProcessInfo::qProcessInfo(_cmd) => {
-                ops.process_info(&mut write_cb)
-                    .map_err(Error::TargetError)?;
-                write_err?;
+                let mut result = Ok(());
+                ops.process_info(&mut |info| {
+                    result = info.write_response(res);
+                })
+                .map_err(Error::TargetError)?;
                 HandlerStatus::Handled
             }
         };

src/target/ext/process_info.rs

@@ -2,33 +2,61 @@
 //!
 //! These correspond to the `qHostInfo` and `qProcessInfo` commands.
 //! They report key-value metadata such as the target triple,
-//! endianness, pointer size, and process ID.
-//!
-//! The callback passed to these methods should be called with byte slices
-//! that together form a semicolon-delimited `key:value;` response string.
-//! For example:
-//!
-//! ```text
-//! triple:7761736d33322d756e6b6e6f776e2d756e6b6e6f776e2d7761736d;pid:1;endian:little;ptrsize:4;
-//! ```
-//!
-//! Note: the `triple` value must be hex-encoded.
+//! endianness, pointer size, and process ID. We take the information
+//! that we can return as responses to this commands in the
+//! [`HostInfoResponse`] and [`ProcessInfoResponse`] structs,
+//! respectively.
+
+use crate::common::{Endianness, Pid};
+
+/// A response to a `qProcessInfo` query from the debugger.
+///
+/// This does not contain all possible fields, but it contains a few
+/// common ones that are needed to satisfy some debuggers. More may be
+/// added in the future.
+pub struct ProcessInfoResponse<'a> {
+    /// The PID.
+    pub pid: Pid,
+    /// The triple (e.g. `wasm32-wasi` or `x86_64-unknown-linux-gnu`).
+    pub triple: &'a str,
+    /// The target endianness.
+    pub endianness: Endianness,
+    /// The pointer size.
+    pub ptrsize: usize,
+}
+
+/// A response to a `qHostInfo` query from the debugger.
+///
+/// This does not contain all possible fields, but it contains a few
+/// common ones that are needed to satisfy some debuggers. More may be
+/// added in the future.
+pub struct HostInfoResponse<'a> {
+    /// The triple (e.g. `wasm32-wasi` or `x86_64-unknown-linux-gnu`).
+    pub triple: &'a str,
+    /// The target endianness.
+    pub endianness: Endianness,
+    /// The pointer size.
+    pub ptrsize: usize,
+}
 
 use crate::target::Target;
 
 /// Target Extension - Provide host and process information.
 pub trait ProcessInfo: Target {
-    /// Write the response to `qHostInfo`.
+    /// Write a response to `qHostInfo`.
     ///
-    /// Call `write` one or more times with byte slices that together form
-    /// the response. Each call appends to the output.
-    fn host_info(&self, write: &mut dyn FnMut(&[u8])) -> Result<(), Self::Error>;
+    /// Call `respond` with a `HostInfoResponse` in order to send an
+    /// appropriate response.
+    fn host_info(&self, respond: &mut dyn FnMut(&HostInfoResponse<'_>)) -> Result<(), Self::Error>;
 
     /// Write the response to `qProcessInfo`.
     ///
-    /// Call `write` one or more times with byte slices that together form
-    /// the response. Each call appends to the output.
-    fn process_info(&self, write: &mut dyn FnMut(&[u8])) -> Result<(), Self::Error>;
+    /// Call `respond` with a `ProcessInfoResponse` in order to send an
+    /// appropriate response.
+    fn process_info(
+        &self,
+        respond: &mut dyn FnMut(&ProcessInfoResponse<'_>),
+    ) -> Result<(), Self::Error>;
 }
 
 define_ext!(ProcessInfoOps, ProcessInfo);