Add support for memory maps

src/gdbstub_impl/ext/base.rs

@@ -107,6 +107,10 @@ impl<T: Target, C: Connection> GdbStubImpl<T, C> {
                     res.write_str(";qXfer:features:read+")?;
                 }
 
+                if target.memory_map().is_some() {
+                    res.write_str(";qXfer:memory-map:read+")?;
+                }
+
                 HandlerStatus::Handled
             }
             Base::QStartNoAckMode(_) => {
@@ -143,6 +147,30 @@ impl<T: Target, C: Connection> GdbStubImpl<T, C> {
                 }
                 HandlerStatus::Handled
             }
+            Base::qXferMemoryMapRead(cmd) => {
+                match target.memory_map().map(|ops| ops.memory_map_xml()) {
+                    Some(xml) => {
+                        let xml = xml.trim();
+                        if cmd.offset >= xml.len() {
+                            // no more data
+                            res.write_str("l")?;
+                        } else if cmd.offset + cmd.len >= xml.len() {
+                            // last little bit of data
+                            res.write_str("l")?;
+                            res.write_binary(&xml.as_bytes()[cmd.offset..])?
+                        } else {
+                            // still more data
+                            res.write_str("m")?;
+                            res.write_binary(&xml.as_bytes()[cmd.offset..(cmd.offset + cmd.len)])?
+                        }
+                    }
+                    None => return Err(Error::PacketUnexpected),
+                }
+                // If the target hasn't provided a memory map, then the initial response to
+                // "qSupported" wouldn't have included  "qXfer:features:memory-map", and gdb wouldn't
+                // send this packet unless it was explicitly marked as supported.
+                HandlerStatus::Handled
+            }
 
             // -------------------- "Core" Functionality -------------------- //
             // TODO: Improve the '?' response based on last-sent stop reason.

src/protocol/commands.rs

@@ -177,6 +177,7 @@ commands! {
         "qsThreadInfo" => _qsThreadInfo::qsThreadInfo,
         "qSupported" => _qSupported::qSupported<'a>,
         "qXfer:features:read" => _qXfer_features_read::qXferFeaturesRead,
+        "qXfer:memory-map:read" => _qXfer_memory_map::qXferMemoryMapRead,
         "s" => _s::s<'a>,
         "T" => _t_upcase::T,
         "vCont" => _vCont::vCont<'a>,

src/protocol/commands/_qXfer_memory_map.rs

@@ -0,0 +1,29 @@
+use super::prelude::*;
+
+#[derive(Debug)]
+pub struct qXferMemoryMapRead {
+    pub offset: usize,
+    pub len: usize,
+}
+
+impl<'a> ParseCommand<'a> for qXferMemoryMapRead {
+    fn from_packet(buf: PacketBuf<'a>) -> Option<Self> {
+        let body = buf.into_body();
+
+        if body.is_empty() {
+            return None;
+        }
+
+        let mut body = body.split(|b| *b == b':').skip(1);
+        let annex = body.next()?;
+        if annex != b"" {
+            return None;
+        }
+
+        let mut body = body.next()?.split(|b| *b == b',');
+        let offset = decode_hex(body.next()?).ok()?;
+        let len = decode_hex(body.next()?).ok()?;
+
+        Some(qXferMemoryMapRead { offset, len })
+    }
+}

src/target/ext/memory_map.rs

@@ -0,0 +1,14 @@
+//! Provide a memory map for the target.
+use crate::target::Target;
+
+/// Target Extension - Provide a target memory map.
+pub trait MemoryMap: Target {
+    /// Return the target memory map XML file.
+    ///
+    /// See the [GDB Documentation] for a description of the format.
+    ///
+    /// [GDB Documentation]: https://sourceware.org/gdb/onlinedocs/gdb/Memory-Map-Format.html
+    fn memory_map_xml(&self) -> String;
+}
+
+define_ext!(MemoryMapOps, MemoryMap);

src/target/ext/mod.rs

@@ -256,6 +256,7 @@ macro_rules! define_ext {
 pub mod base;
 pub mod breakpoints;
 pub mod extended_mode;
+pub mod memory_map;
 pub mod monitor_cmd;
 pub mod section_offsets;
 pub mod target_description_xml_override;

src/target/mod.rs

@@ -239,6 +239,12 @@ pub trait Target {
     ) -> Option<ext::target_description_xml_override::TargetDescriptionXmlOverrideOps<Self>> {
         None
     }
+
+    /// Provide a target memory map.
+    #[inline(always)]
+    fn memory_map(&mut self) -> Option<ext::memory_map::MemoryMapOps<Self>> {
+        None
+    }
 }
 
 macro_rules! impl_dyn_target {