Update GDB Remote Support from 5.3 to 6.8

[mesheets]

BrickEmu currently works with GDB 5.3, and that GDB version cannot currently be built together along with the rest of the GNU Legacy Toolchain.

While GDB 6.8 can be built together with the rest of the GNU Legacy Toolchain, BrickEmu remote support (in remote.c) is incompatible with GDB 6.8.

In the file debugger.c that is part of an emulator for the h8300-hitachi-coff architecture, preserve the existing source file structure and h8300-hitachi-coff targeting (including adding Target Description XML for the h8300-hitachi-coff target) while updating BrickEmu's existing remote support targeting GDB 5.3 for compatibility with GDB 6.8. Make an updated version of this source file available for download while also describing each of the changes. At a minimum, updates should include the following:

• Support for 'qSupported' packet - GDB 6.8 uses feature negotiation
• Support for 'qTStatus' packet - For tracepoint status queries
• Support for 'vCont' packet - New continue/step format
• Better handling of 'vMustReplyEmpty' - For unknown packets
• Support for 'qOffsets' packet - For section offsets
• Improved register handling - GDB 6.8 expects proper XML feature descriptions
• feature negotiation (qSupported)
• modern stop replies (T...)
• vCont execution packets
• thread-awareness
• no-ack mode
• proper packet parsing / checksum / resend
• structured query handling
• Proper packet send + checksum
• qSupported negotiation
• ? stop-reason reply (Txx)
• c, s, and vCont handling
• Register + memory read/write
• Breakpoint packets (Z/z)
• Clean packet parsing loop
• qXfer (XML register descriptions for h8300-hitachi-coff)
• multi-thread (multiprocess)
• async / non-stop mode
• watchpoints
• file I/O

References

• GDB documentation on Predefined Target Types that are part of the Target Description Format

[mesheets]

Overview from Microsoft Copilot using GPT Open AI:

Introduction

Between GDB 5.3 (≈2002) and GDB 6.8 (2008), the Remote Serial Protocol (RSP) evolved from a relatively simple, mostly synchronous command/response protocol into a significantly more feature‑negotiated, extensible, multi‑thread/multi‑process–aware protocol. The changes were incremental over multiple 6.x releases, but by 6.8 the protocol had gained several major capabilities.

Below is a structured, detailed comparison of the key changes.

---

1. Baseline: what GDB 5.3-era RSP looked like

Around the GDB 5.3 timeframe, the protocol had these characteristics:

Core properties

• Simple packet format:

  $packet-data#checksum
  

• Acknowledgment-based reliability (+ / -). [developer.apple.com]
• Primarily single-threaded and single-process oriented
• Command set limited to:
  • register read/write (g, G)
  • memory read/write (m, M)
  • continue/step (c, s)
  • breakpoints (Z/z introduced earlier in 5.x timeframe)

Compatibility assumptions

• No formal feature negotiation
• Clients probed support implicitly:
  • Unknown packets → empty reply ($#00) [developer.apple.com]
• Stub and GDB had to be tightly matched

Notable legacy removal (before 5.x but still relevant)

• Earlier protocol had sequence IDs in packets, but:
  • They were removed before/around 5.0 and explicitly disallowed in later packets. [developer.apple.com]

👉 In short:
GDB 5.3 used a minimal, statically-defined protocol with weak extensibility.

---

2. Major architectural shift in 6.x: feature negotiation (qSupported)

Introduction of capability negotiation

One of the most important changes (arrived during 6.x series):

qSupported packet

• Allows GDB and stub to exchange feature flags during connection setup
• Supports forms like:
  • feature+ (supported)
  • feature- (not supported)
  • feature=value [wiki.ing-poetter.de]

Impact

• Eliminated guesswork and trial probing
• Enabled safe protocol evolution
• Reduced round trips and improved startup performance [wiki.ing-poetter.de]

Examples of negotiated features

• PacketSize
• multiprocess
• xmlRegisters
• qXfer:*
• vContSupported
• QStartNoAckMode

👉 This is the single biggest conceptual change from 5.3 → 6.8.

---

3. Extended remote mode and persistence

! (extended mode)

• Introduced/improved across 6.x
• Keeps server alive after program exit
• Enables:
  • restarting programs (R packet)
  • long-lived debug sessions [sourceware.org]

Difference from 5.3

• Earlier protocol: mostly one-shot sessions
• 6.8: supports persistent debugging servers (e.g., gdbserver)

---

4. Thread and multiprocess awareness

4.1 Thread-aware protocol

• Packets gain thread-id fields
• Thread ID format standardized as hex identifiers [sourceware.org]

4.2 Multiprocess extensions

• Enabled via qSupported:multiprocess+
• Thread IDs expand to:

  p<pid>.<tid>
  

• Allows distinguishing:
  • processes AND threads simultaneously [sourceware.org]

Difference vs 5.3

• 5.3: effectively single-threaded semantics
• 6.8: multi-thread + multi-process protocol support

---

5. New execution-control model: vCont

Before (5.3)

• Stepping and running:
  • c (continue)
  • s (step)

After (6.x → 6.8)

vCont packet family

• Supports composite execution control
• Example:

  vCont;c:thread1;s:thread2
  

Benefits

• Control multiple threads simultaneously
• Express complex execution actions in one packet

👉 Enabled only if negotiated (vContSupported).

---

6. Generalized query/set packets (q / Q)

Expansion in 6.x

• Structured namespace of packets:
  • qXXX = query
  • QXXX = set

Examples

• qC → current thread
• qCRC → memory checksum
• QAllow → allowed operations [zeuthen.desy.de]

Difference

• 5.3: limited ad-hoc queries
• 6.8: extensible query framework

---

7. Bulk data and structured transfers (qXfer)

Introduced during 6.x

• Supports transferring structured data in chunks:
  • XML target descriptions
  • memory maps
  • thread lists

Example:

• qXfer:features:read
• qXfer:memory-map:read

Benefits

• Removes need for hard-coded register layouts
• Enables dynamic target discovery

---

8. XML target descriptions (register discovery)

Feature: xmlRegisters

• Target sends register layouts as XML
• GDB dynamically adapts

Before (5.3)

• Register layout:
  • hardcoded
  • architecture-specific

After (6.8)

• Fully runtime-discoverable

---

9. No-acknowledgment mode (QStartNoAckMode)

New in 6.x

• Disable +/- ACK traffic after negotiation

Benefit

• Greatly improves performance over high-latency links

---

10. Improved stop-reply and event reporting

Enhancements

• Richer stop replies (signal + metadata)
• Support for:
  • thread ID in stop reply
  • breakpoint/watchpoint reasons

Result

• Better debugger UI and behavior

---

11. Additional protocol extensions introduced by 6.8 timeframe

By GDB 6.8, the protocol also included:

• File-I/O remote extension
• Host I/O packets
• Library list reporting
• Tracepoint support
• Non-stop / async groundwork (partially evolving)

[sourceware.org]

---

12. Summary of key differences

Area	GDB 5.3	GDB 6.8
Capability negotiation	None	qSupported
Execution control	c, s	vCont (multi-thread aware)
Thread support	Minimal	Full thread IDs
Multiprocess	No	Yes (multiprocess)
Data transfer	Ad-hoc	qXfer structured
Register layout	Static	XML (xmlRegisters)
Session model	Short-lived	Persistent (!, R)
Extensibility	Weak	Strong, namespaced
Performance	ACK-heavy	No-ack mode
Feature discovery	Trial-and-error	Explicit negotiation

---

13. Big-picture interpretation

The transition from 5.3 → 6.8 represents a fundamental redesign philosophy:

GDB 5.3

• Static protocol
• Tight coupling between debugger and stub
• Minimal abstraction

GDB 6.8

• Negotiated, extensible protocol
• Dynamic capability discovery
• Designed for:
  • heterogeneous targets
  • embedded systems
  • remote OS debugging

---

✅ In one sentence:
Between GDB 5.3 and 6.8, the remote protocol evolved from a simple, fixed command set into a modular, feature-negotiated, multi-threaded, and extensible debugging protocol suitable for modern heterogeneous systems.

[mesheets]

Project Analysis from Microsoft Copilot using GPT Open AI:

The current debugger.c is a minimal GDB 5.3-era RSP stub. It lacks virtually all features required by GDB 6.x (especially 6.8), including:

• feature negotiation (qSupported)
• modern stop replies (T...)
• vCont execution packets
• thread-awareness
• no-ack mode
• proper packet parsing / checksum / resend
• structured query handling

---

✅ Key Improvements to Implement

• Proper packet send + checksum
• qSupported negotiation
• ? stop-reason reply (Txx)
• c, s, and vCont handling
• Register + memory read/write
• Breakpoint packets (Z/z)
• Clean packet parsing loop

⚠️ Known Limitations (still fine for 6.8)

• qXfer (XML register descriptions)
• multi-thread (multiprocess)
• async / non-stop mode
• watchpoints
• file I/O