gdb: More cleanup changes

- Move the message handler into its debugger class part,
- Move all message types into one file and collapse 3 of the ones with no data into a generic, stateless message with a single property being its type,
- Add an Fpscr helper property on IExecutionContext along with a comment about what Fpscr is (similar to the other registers in there)
- Moved the Rcmd helpers (such as GetRegisters, GetMinidump, etc) into a dedicated Debugger class part,
- Fixed the double-collection (ToArray being called twice) in GetThreadUids & GetThread in KProcess

assets/locales.json

@@ -3629,7 +3629,7 @@
         "he_IL": "ממשק קלאסי (הפעלה מחדש דרושה)",
         "it_IT": "Interfaccia classica (Riavvio necessario)",
         "ja_JP": "クラシックインターフェース（再起動必要）",
-        "ko_KR": "클래식 인터페이스 (재시작 필요)",
+        "ko_KR": "클래식 인터페이스(다시 시작 필요)",
         "no_NO": "Klassisk grensesnitt (Krever omstart)",
         "pl_PL": "Klasyczny interfejs (Wymaga restartu)",
         "pt_BR": "Interface Clássica (Reinício necessário)",

src/Ryujinx.Cpu/IExecutionContext.cs

@@ -42,6 +42,11 @@ namespace Ryujinx.Cpu
         /// </summary>
         uint Fpsr { get; set; }
 
+        /// <summary>
+        /// Floating-point Status and Control Register.
+        /// </summary>
+        uint Fpscr => Fpsr | Fpcr;
+
         /// <summary>
         /// Indicates whenever the CPU is running 64-bit (AArch64 mode) or 32-bit (AArch32 mode) code.
         /// </summary>

src/Ryujinx.HLE/Debugger/BreakpointManager.cs

@@ -1,9 +1,6 @@
-using Ryujinx.Common;
 using Ryujinx.Common.Logging;
-using Ryujinx.HLE.HOS.Kernel.Threading;
 using Ryujinx.Memory;
 using System.Collections.Concurrent;
-using System.Linq;
 
 namespace Ryujinx.HLE.Debugger
 {
@@ -11,12 +8,9 @@ namespace Ryujinx.HLE.Debugger
     {
         public byte[] OriginalData { get; }
 
-        public bool IsStep { get; }
-
-        public Breakpoint(byte[] originalData, bool isStep)
+        public Breakpoint(byte[] originalData)
         {
             OriginalData = originalData;
-            IsStep = isStep;
         }
     }
 
@@ -28,9 +22,9 @@ namespace Ryujinx.HLE.Debugger
         private readonly Debugger _debugger;
         private readonly ConcurrentDictionary<ulong, Breakpoint> _breakpoints = new();
 
-        private static readonly byte[] _aarch64BreakInstruction = { 0x00, 0x00, 0x20, 0xD4 }; // BRK #0
-        private static readonly byte[] _aarch32BreakInstruction = { 0xFE, 0xDE, 0xFF, 0xE7 }; // TRAP
-        private static readonly byte[] _aarch32ThumbBreakInstruction = { 0x80, 0xB6 };
+        private static readonly byte[] _aarch64BreakInstruction = [0x00, 0x00, 0x20, 0xD4]; // BRK #0
+        private static readonly byte[] _aarch32BreakInstruction = [0xFE, 0xDE, 0xFF, 0xE7]; // TRAP
+        private static readonly byte[] _aarch32ThumbBreakInstruction = [0x80, 0xB6];
 
         public BreakpointManager(Debugger debugger)
         {
@@ -44,7 +38,7 @@ namespace Ryujinx.HLE.Debugger
         /// <param name="length">The length of the instruction to replace.</param>
         /// <param name="isStep">Indicates if this is a single-step breakpoint.</param>
         /// <returns>True if the breakpoint was set successfully; otherwise, false.</returns>
-        public bool SetBreakPoint(ulong address, ulong length, bool isStep = false)
+        public bool SetBreakPoint(ulong address, ulong length)
         {
             if (_breakpoints.ContainsKey(address))
             {
@@ -71,7 +65,7 @@ namespace Ryujinx.HLE.Debugger
                 return false;
             }
 
-            var breakpoint = new Breakpoint(originalInstruction, isStep);
+            var breakpoint = new Breakpoint(originalInstruction);
             if (_breakpoints.TryAdd(address, breakpoint))
             {
                 Logger.Debug?.Print(LogClass.GdbStub, $"Breakpoint set at 0x{address:X16}");
@@ -124,33 +118,9 @@ namespace Ryujinx.HLE.Debugger
             Logger.Debug?.Print(LogClass.GdbStub, "All breakpoints cleared.");
         }
 
-        /// <summary>
-        /// Clears all currently set single-step software breakpoints.
-        /// </summary>
-        public void ClearAllStepBreakpoints()
-        {
-            var stepBreakpoints = _breakpoints.Where(p => p.Value.IsStep).ToList();
-
-            if (stepBreakpoints.Count == 0)
-            {
-                return;
-            }
-
-            foreach (var bp in stepBreakpoints)
-            {
-                if (_breakpoints.TryRemove(bp.Key, out Breakpoint removedBreakpoint))
-                {
-                    WriteMemory(bp.Key, removedBreakpoint.OriginalData);
-                }
-            }
-
-            Logger.Debug?.Print(LogClass.GdbStub, "All step breakpoints cleared.");
-        }
-
-        
         private byte[] GetBreakInstruction(ulong length)
         {
-            if (_debugger.IsProcessAarch32)
+            if (_debugger.IsProcess32Bit)
             {
                 if (length == 2)
                 {

src/Ryujinx.HLE/Debugger/Debugger.MainThread.cs

@@ -0,0 +1,115 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.Debugger.Gdb;
+using System.IO;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+
+namespace Ryujinx.HLE.Debugger
+{
+    public partial class Debugger
+    {
+        private void DebuggerThreadMain()
+        {
+            IPEndPoint endpoint = new(IPAddress.Any, GdbStubPort);
+            _listenerSocket = new TcpListener(endpoint);
+            _listenerSocket.Start();
+            Logger.Notice.Print(LogClass.GdbStub, $"Currently waiting on {endpoint} for GDB client");
+
+            while (!_shuttingDown)
+            {
+                try
+                {
+                    _clientSocket = _listenerSocket.AcceptSocket();
+                }
+                catch (SocketException)
+                {
+                    return;
+                }
+
+                // If the user connects before the application is running, wait for the application to start.
+                int retries = 10;
+                while ((DebugProcess == null || GetThreads().Length == 0) && retries-- > 0)
+                {
+                    Thread.Sleep(200);
+                }
+
+                if (DebugProcess == null || GetThreads().Length == 0)
+                {
+                    Logger.Warning?.Print(LogClass.GdbStub,
+                        "Application is not running, cannot accept GDB client connection");
+                    _clientSocket.Close();
+                    continue;
+                }
+
+                _clientSocket.NoDelay = true;
+                _readStream = new NetworkStream(_clientSocket, System.IO.FileAccess.Read);
+                _writeStream = new NetworkStream(_clientSocket, System.IO.FileAccess.Write);
+                _commands = new GdbCommands(_listenerSocket, _clientSocket, _readStream, _writeStream, this);
+                _commandProcessor = _commands.CreateProcessor();
+
+                Logger.Notice.Print(LogClass.GdbStub, "GDB client connected");
+
+                while (true)
+                {
+                    try
+                    {
+                        switch (_readStream.ReadByte())
+                        {
+                            case -1:
+                                goto EndOfLoop;
+                            case '+':
+                                continue;
+                            case '-':
+                                Logger.Notice.Print(LogClass.GdbStub, "NACK received!");
+                                continue;
+                            case '\x03':
+                                _messages.Add(StatelessMessage.BreakIn);
+                                break;
+                            case '$':
+                                string cmd = string.Empty;
+                                while (true)
+                                {
+                                    int x = _readStream.ReadByte();
+                                    if (x == -1)
+                                        goto EndOfLoop;
+                                    if (x == '#')
+                                        break;
+                                    cmd += (char)x;
+                                }
+
+                                string checksum = $"{(char)_readStream.ReadByte()}{(char)_readStream.ReadByte()}";
+                                if (checksum == $"{Helpers.CalculateChecksum(cmd):x2}")
+                                {
+                                    _messages.Add(new CommandMessage(cmd));
+                                }
+                                else
+                                {
+                                    _messages.Add(StatelessMessage.SendNack);
+                                }
+
+                                break;
+                        }
+                    }
+                    catch (IOException)
+                    {
+                        goto EndOfLoop;
+                    }
+                }
+
+                EndOfLoop:
+                Logger.Notice.Print(LogClass.GdbStub, "GDB client lost connection");
+                _readStream.Close();
+                _readStream = null;
+                _writeStream.Close();
+                _writeStream = null;
+                _clientSocket.Close();
+                _clientSocket = null;
+                _commandProcessor = null;
+                _commands = null;
+
+                BreakpointManager.ClearAll();
+            }
+        }
+    }
+}

src/Ryujinx.HLE/Debugger/Debugger.MessageHandler.cs

@@ -0,0 +1,58 @@
+using Ryujinx.Common.Logging;
+using System;
+using System.IO;
+
+namespace Ryujinx.HLE.Debugger
+{
+    public partial class Debugger
+    {
+        private void MessageHandlerMain()
+        {
+            while (!_shuttingDown)
+            {
+                try
+                {
+                    switch (_messages.Take())
+                    {
+                        case StatelessMessage { Type: MessageType.BreakIn }:
+                            Logger.Notice.Print(LogClass.GdbStub, "Break-in requested");
+                            _commands.Interrupt();
+                            break;
+
+                        case StatelessMessage { Type: MessageType.SendNack }:
+                            _writeStream.WriteByte((byte)'-');
+                            break;
+
+                        case StatelessMessage { Type: MessageType.Kill }:
+                            return;
+
+                        case CommandMessage { Command: { } cmd }:
+                            Logger.Debug?.Print(LogClass.GdbStub, $"Received Command: {cmd}");
+                            _writeStream.WriteByte((byte)'+');
+                            _commandProcessor.Process(cmd);
+                            break;
+
+                        case ThreadBreakMessage { Context: { } ctx }:
+                            DebugProcess.DebugStop();
+                            GThread = CThread = ctx.ThreadUid;
+                            _breakHandlerEvent.Set();
+                            _commandProcessor.Reply($"T05thread:{ctx.ThreadUid:x};");
+                            break;
+                    }
+                }
+                catch (IOException e)
+                {
+                    Logger.Error?.Print(LogClass.GdbStub, "Error while processing GDB messages", e);
+                }
+                catch (NullReferenceException e)
+                {
+                    Logger.Error?.Print(LogClass.GdbStub, "Error while processing GDB messages", e);
+                }
+                catch (ObjectDisposedException e)
+                {
+                    Logger.Error?.Print(LogClass.GdbStub, "Error while processing GDB messages", e);
+                }
+            }
+        }
+    }
+}

src/Ryujinx.HLE/Debugger/Debugger.Rcmd.cs

@@ -0,0 +1,103 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Kernel.Process;
+using System;
+using System.Text;
+
+namespace Ryujinx.HLE.Debugger
+{
+    public partial class Debugger
+    {
+        public string GetStackTrace()
+        {
+            if (GThread == null)
+                return "No thread selected\n";
+
+            return Process?.Debugger?.GetGuestStackTrace(DebugProcess.GetThread(GThread.Value)) ?? "No application process found\n"; 
+        }
+
+        public string GetRegisters()
+        {
+            if (GThread == null)
+                return "No thread selected\n";
+
+            return Process?.Debugger?.GetCpuRegisterPrintout(DebugProcess.GetThread(GThread.Value)) ?? "No application process found\n";
+        }
+
+        public string GetMinidump()
+        {
+            var response = new StringBuilder();
+            response.AppendLine("=== Begin Minidump ===\n");
+            response.AppendLine(GetProcessInfo());
+
+            foreach (var thread in GetThreads())
+            {
+                response.AppendLine($"=== Thread {thread.ThreadUid} ===");
+                try
+                {
+                    string stackTrace = Process.Debugger.GetGuestStackTrace(thread);
+                    response.AppendLine(stackTrace);
+                }
+                catch (Exception e)
+                {
+                    response.AppendLine($"[Error getting stack trace: {e.Message}]");
+                }
+
+                try
+                {
+                    string registers = Process.Debugger.GetCpuRegisterPrintout(thread);
+                    response.AppendLine(registers);
+                }
+                catch (Exception e)
+                {
+                    response.AppendLine($"[Error getting registers: {e.Message}]");
+                }
+            }
+
+            response.AppendLine("=== End Minidump ===");
+
+            Logger.Info?.Print(LogClass.GdbStub, response.ToString());
+            return response.ToString();
+        }
+
+        public string GetProcessInfo()
+        {
+            try
+            {
+                if (Process is not { } kProcess)
+                    return "No application process found\n";
+
+                var sb = new StringBuilder();
+
+                sb.AppendLine($"Program Id:  0x{kProcess.TitleId:x16}");
+                sb.AppendLine($"Application: {(kProcess.IsApplication ? 1 : 0)}");
+                sb.AppendLine("Layout:");
+                sb.AppendLine(
+                    $"  Alias: 0x{kProcess.MemoryManager.AliasRegionStart:x10} - 0x{kProcess.MemoryManager.AliasRegionEnd - 1:x10}");
+                sb.AppendLine(
+                    $"  Heap:  0x{kProcess.MemoryManager.HeapRegionStart:x10} - 0x{kProcess.MemoryManager.HeapRegionEnd - 1:x10}");
+                sb.AppendLine(
+                    $"  Aslr:  0x{kProcess.MemoryManager.AslrRegionStart:x10} - 0x{kProcess.MemoryManager.AslrRegionEnd - 1:x10}");
+                sb.AppendLine(
+                    $"  Stack: 0x{kProcess.MemoryManager.StackRegionStart:x10} - 0x{kProcess.MemoryManager.StackRegionEnd - 1:x10}");
+
+                sb.AppendLine("Modules:");
+                var debugger = kProcess.Debugger;
+                if (debugger != null)
+                {
+                    foreach (HleProcessDebugger.Image image in debugger.GetLoadedImages())
+                    {
+                        ulong endAddress = image.BaseAddress + image.Size - 1;
+                        sb.AppendLine($"  0x{image.BaseAddress:x10} - 0x{endAddress:x10} {image.Name}");
+                    }
+                }
+
+                return sb.ToString();
+            }
+            catch (Exception e)
+            {
+                Logger.Error?.Print(LogClass.GdbStub, $"Error getting process info: {e.Message}");
+                return $"Error getting process info: {e.Message}\n";
+            }
+        }
+    }
+}

src/Ryujinx.HLE/Debugger/Debugger.cs

@@ -6,37 +6,39 @@ using System;
 using System.Collections.Concurrent;
 using System.IO;
 using System.Linq;
-using System.Net;
 using System.Net.Sockets;
 using System.Text;
 using System.Threading;
 using IExecutionContext = Ryujinx.Cpu.IExecutionContext;
-using static Ryujinx.HLE.Debugger.Helpers;
+
 
 namespace Ryujinx.HLE.Debugger
 {
-    public class Debugger : IDisposable
+    public partial class Debugger : IDisposable
     {
         internal Switch Device { get; private set; }
 
         public ushort GdbStubPort { get; private set; }
 
-        private TcpListener ListenerSocket;
-        private Socket ClientSocket = null;
-        private NetworkStream ReadStream = null;
-        private NetworkStream WriteStream = null;
-        private BlockingCollection<IMessage> Messages = new(1);
-        private Thread DebuggerThread;
-        private Thread MessageHandlerThread;
-        private bool _shuttingDown = false;
-        private ManualResetEventSlim _breakHandlerEvent = new(false);
+        private readonly BlockingCollection<IMessage> _messages = new(1);
+        private readonly Thread _debuggerThread;
+        private readonly Thread _messageHandlerThread;
 
-        private GdbCommandProcessor CommandProcessor = null;
+        private TcpListener _listenerSocket;
+        private Socket _clientSocket;
+        private NetworkStream _readStream;
+        private NetworkStream _writeStream;
+
+        private GdbCommandProcessor _commandProcessor;
+        private GdbCommands _commands;
+
+        private bool _shuttingDown;
+        private readonly ManualResetEventSlim _breakHandlerEvent = new(false);
 
         internal ulong? CThread;
         internal ulong? GThread;
 
-        internal BreakpointManager BreakpointManager;
+        public readonly BreakpointManager BreakpointManager;
 
         public Debugger(Switch device, ushort port)
         {
@@ -45,273 +47,34 @@ namespace Ryujinx.HLE.Debugger
 
             ARMeilleure.Optimizations.EnableDebugging = true;
 
-            DebuggerThread = new Thread(DebuggerThreadMain);
-            DebuggerThread.Start();
-            MessageHandlerThread = new Thread(MessageHandlerMain);
-            MessageHandlerThread.Start();
+            _debuggerThread = new Thread(DebuggerThreadMain);
+            _debuggerThread.Start();
+            _messageHandlerThread = new Thread(MessageHandlerMain);
+            _messageHandlerThread.Start();
             BreakpointManager = new BreakpointManager(this);
         }
 
         internal KProcess Process => Device.System?.DebugGetApplicationProcess();
         internal IDebuggableProcess DebugProcess => Device.System?.DebugGetApplicationProcessDebugInterface();
 
-        internal KThread[] GetThreads() =>
-            DebugProcess.GetThreadUids().Select(x => DebugProcess.GetThread(x)).ToArray();
+        internal KThread[] GetThreads() => DebugProcess.ThreadUids.Select(DebugProcess.GetThread).ToArray();
 
-        internal bool IsProcessAarch32 => DebugProcess.GetThread(GThread.Value).Context.IsAarch32;
+        internal bool IsProcess32Bit => DebugProcess.GetThread(GThread.Value).Context.IsAarch32;
+        
+        internal bool WriteRegister(IExecutionContext ctx, int registerId, StringStream ss) =>
+            IsProcess32Bit
+                ? ctx.WriteRegister32(registerId, ss)
+                : ctx.WriteRegister64(registerId, ss);
 
-        private void MessageHandlerMain()
-        {
-            while (!_shuttingDown)
-            {
-                IMessage msg = Messages.Take();
-                try
-                {
-                    switch (msg)
-                    {
-                        case BreakInMessage:
-                            Logger.Notice.Print(LogClass.GdbStub, "Break-in requested");
-                            CommandProcessor.Commands.CommandInterrupt();
-                            break;
-
-                        case SendNackMessage:
-                            WriteStream.WriteByte((byte)'-');
-                            break;
-
-                        case CommandMessage { Command: var cmd }:
-                            Logger.Debug?.Print(LogClass.GdbStub, $"Received Command: {cmd}");
-                            WriteStream.WriteByte((byte)'+');
-                            CommandProcessor.Process(cmd);
-                            break;
-
-                        case ThreadBreakMessage { Context: var ctx }:
-                            DebugProcess.DebugStop();
-                            GThread = CThread = ctx.ThreadUid;
-                            _breakHandlerEvent.Set();
-                            CommandProcessor.Commands.Reply($"T05thread:{ctx.ThreadUid:x};");
-                            break;
-
-                        case KillMessage:
-                            return;
-                    }
-                }
-                catch (IOException e)
-                {
-                    Logger.Error?.Print(LogClass.GdbStub, "Error while processing GDB messages", e);
-                }
-                catch (NullReferenceException e)
-                {
-                    Logger.Error?.Print(LogClass.GdbStub, "Error while processing GDB messages", e);
-                }
-            }
-        }
-
-        public string GetStackTrace()
-        {
-            if (GThread == null)
-                return "No thread selected\n";
-
-            if (Process == null)
-                return "No application process found\n";
-
-            return Process.Debugger.GetGuestStackTrace(DebugProcess.GetThread(GThread.Value));
-        }
-
-        public string GetRegisters()
-        {
-            if (GThread == null)
-                return "No thread selected\n";
-
-            if (Process == null)
-                return "No application process found\n";
-
-            return Process.Debugger.GetCpuRegisterPrintout(DebugProcess.GetThread(GThread.Value));
-        }
-
-        public string GetMinidump()
-        {
-            var response = new StringBuilder();
-            response.AppendLine("=== Begin Minidump ===\n");
-            response.AppendLine(GetProcessInfo());
-
-            foreach (var thread in GetThreads())
-            {
-                response.AppendLine($"=== Thread {thread.ThreadUid} ===");
-                try
-                {
-                    string stackTrace = Process.Debugger.GetGuestStackTrace(thread);
-                    response.AppendLine(stackTrace);
-                }
-                catch (Exception e)
-                {
-                    response.AppendLine($"[Error getting stack trace: {e.Message}]");
-                }
-
-                try
-                {
-                    string registers = Process.Debugger.GetCpuRegisterPrintout(thread);
-                    response.AppendLine(registers);
-                }
-                catch (Exception e)
-                {
-                    response.AppendLine($"[Error getting registers: {e.Message}]");
-                }
-            }
-
-            response.AppendLine("=== End Minidump ===");
-
-            Logger.Info?.Print(LogClass.GdbStub, response.ToString());
-            return response.ToString();
-        }
-
-        public string GetProcessInfo()
-        {
-            try
-            {
-                if (Process == null)
-                    return "No application process found\n";
-
-                KProcess kProcess = Process;
-
-                var sb = new StringBuilder();
-
-                sb.AppendLine($"Program Id:  0x{kProcess.TitleId:x16}");
-                sb.AppendLine($"Application: {(kProcess.IsApplication ? 1 : 0)}");
-                sb.AppendLine("Layout:");
-                sb.AppendLine(
-                    $"  Alias: 0x{kProcess.MemoryManager.AliasRegionStart:x10} - 0x{kProcess.MemoryManager.AliasRegionEnd - 1:x10}");
-                sb.AppendLine(
-                    $"  Heap:  0x{kProcess.MemoryManager.HeapRegionStart:x10} - 0x{kProcess.MemoryManager.HeapRegionEnd - 1:x10}");
-                sb.AppendLine(
-                    $"  Aslr:  0x{kProcess.MemoryManager.AslrRegionStart:x10} - 0x{kProcess.MemoryManager.AslrRegionEnd - 1:x10}");
-                sb.AppendLine(
-                    $"  Stack: 0x{kProcess.MemoryManager.StackRegionStart:x10} - 0x{kProcess.MemoryManager.StackRegionEnd - 1:x10}");
-
-                sb.AppendLine("Modules:");
-                var debugger = kProcess.Debugger;
-                if (debugger != null)
-                {
-                    var images = debugger.GetLoadedImages();
-                    for (int i = 0; i < images.Count; i++)
-                    {
-                        var image = images[i];
-                        ulong endAddress = image.BaseAddress + image.Size - 1;
-                        string name = image.Name;
-                        sb.AppendLine($"  0x{image.BaseAddress:x10} - 0x{endAddress:x10} {name}");
-                    }
-                }
-
-                return sb.ToString();
-            }
-            catch (Exception e)
-            {
-                Logger.Error?.Print(LogClass.GdbStub, $"Error getting process info: {e.Message}");
-                return $"Error getting process info: {e.Message}\n";
-            }
-        }
-
-        private void DebuggerThreadMain()
-        {
-            var endpoint = new IPEndPoint(IPAddress.Any, GdbStubPort);
-            ListenerSocket = new TcpListener(endpoint);
-            ListenerSocket.Start();
-            Logger.Notice.Print(LogClass.GdbStub, $"Currently waiting on {endpoint} for GDB client");
-
-            while (!_shuttingDown)
-            {
-                try
-                {
-                    ClientSocket = ListenerSocket.AcceptSocket();
-                }
-                catch (SocketException)
-                {
-                    return;
-                }
-
-                // If the user connects before the application is running, wait for the application to start.
-                int retries = 10;
-                while ((DebugProcess == null || GetThreads().Length == 0) && retries-- > 0)
-                {
-                    Thread.Sleep(200);
-                }
-
-                if (DebugProcess == null || GetThreads().Length == 0)
-                {
-                    Logger.Warning?.Print(LogClass.GdbStub,
-                        "Application is not running, cannot accept GDB client connection");
-                    ClientSocket.Close();
-                    continue;
-                }
-
-                ClientSocket.NoDelay = true;
-                ReadStream = new NetworkStream(ClientSocket, System.IO.FileAccess.Read);
-                WriteStream = new NetworkStream(ClientSocket, System.IO.FileAccess.Write);
-                CommandProcessor = new GdbCommandProcessor(ListenerSocket, ClientSocket, ReadStream, WriteStream, this);
-                Logger.Notice.Print(LogClass.GdbStub, "GDB client connected");
-
-                while (true)
-                {
-                    try
-                    {
-                        switch (ReadStream.ReadByte())
-                        {
-                            case -1:
-                                goto EndOfLoop;
-                            case '+':
-                                continue;
-                            case '-':
-                                Logger.Notice.Print(LogClass.GdbStub, "NACK received!");
-                                continue;
-                            case '\x03':
-                                Messages.Add(new BreakInMessage());
-                                break;
-                            case '$':
-                                string cmd = "";
-                                while (true)
-                                {
-                                    int x = ReadStream.ReadByte();
-                                    if (x == -1)
-                                        goto EndOfLoop;
-                                    if (x == '#')
-                                        break;
-                                    cmd += (char)x;
-                                }
-
-                                string checksum = $"{(char)ReadStream.ReadByte()}{(char)ReadStream.ReadByte()}";
-                                if (checksum == $"{CalculateChecksum(cmd):x2}")
-                                {
-                                    Messages.Add(new CommandMessage(cmd));
-                                }
-                                else
-                                {
-                                    Messages.Add(new SendNackMessage());
-                                }
-
-                                break;
-                        }
-                    }
-                    catch (IOException)
-                    {
-                        goto EndOfLoop;
-                    }
-                }
-
-                EndOfLoop:
-                Logger.Notice.Print(LogClass.GdbStub, "GDB client lost connection");
-                ReadStream.Close();
-                ReadStream = null;
-                WriteStream.Close();
-                WriteStream = null;
-                ClientSocket.Close();
-                ClientSocket = null;
-
-                BreakpointManager.ClearAll();
-            }
-        }
+        internal string ReadRegister(IExecutionContext ctx, int registerId) =>
+            IsProcess32Bit
+                ? ctx.ReadRegister32(registerId)
+                : ctx.ReadRegister64(registerId);
 
         public void Dispose()
         {
             Dispose(true);
+            GC.SuppressFinalize(this);
         }
 
         protected virtual void Dispose(bool disposing)
@@ -320,15 +83,15 @@ namespace Ryujinx.HLE.Debugger
             {
                 _shuttingDown = true;
 
-                ListenerSocket.Stop();
-                ClientSocket?.Shutdown(SocketShutdown.Both);
-                ClientSocket?.Close();
-                ReadStream?.Close();
-                WriteStream?.Close();
-                DebuggerThread.Join();
-                Messages.Add(new KillMessage());
-                MessageHandlerThread.Join();
-                Messages.Dispose();
+                _listenerSocket.Stop();
+                _clientSocket?.Shutdown(SocketShutdown.Both);
+                _clientSocket?.Close();
+                _readStream?.Close();
+                _writeStream?.Close();
+                _debuggerThread.Join();
+                _messages.Add(StatelessMessage.Kill);
+                _messageHandlerThread.Join();
+                _messages.Dispose();
                 _breakHandlerEvent.Dispose();
             }
         }
@@ -338,7 +101,7 @@ namespace Ryujinx.HLE.Debugger
             DebugProcess.DebugInterruptHandler(ctx);
 
             _breakHandlerEvent.Reset();
-            Messages.Add(new ThreadBreakMessage(ctx, address, imm));
+            _messages.Add(new ThreadBreakMessage(ctx, address, imm));
             // Messages.Add can block, so we log it after adding the message to make sure user can see the log at the same time GDB receives the break message
             Logger.Notice.Print(LogClass.GdbStub, $"Break hit on thread {ctx.ThreadUid} at pc {address:x016}");
             // Wait for the process to stop before returning to avoid BreakHandler being called multiple times from the same breakpoint

src/Ryujinx.HLE/Debugger/Gdb/CommandProcessor.cs

@@ -1,7 +1,8 @@
+using Gommon;
 using Ryujinx.Common;
 using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Kernel.Threading;
 using System.Linq;
-using System.Net.Sockets;
 using System.Text;
 
 namespace Ryujinx.HLE.Debugger.Gdb
@@ -10,13 +11,41 @@ namespace Ryujinx.HLE.Debugger.Gdb
     {
         public readonly GdbCommands Commands;
 
-        public GdbCommandProcessor(TcpListener listenerSocket, Socket clientSocket, NetworkStream readStream, NetworkStream writeStream, Debugger debugger)
+        private Debugger Debugger => Commands.Debugger;
+        private BreakpointManager BreakpointManager => Commands.Debugger.BreakpointManager;
+        private IDebuggableProcess DebugProcess => Commands.Debugger.DebugProcess;
+
+        public GdbCommandProcessor(GdbCommands commands)
         {
-            Commands = new GdbCommands(listenerSocket, clientSocket, readStream, writeStream, debugger);
+            Commands = commands;
         }
-        
-        private string previousThreadListXml = "";
-        
+
+        public void Reply(string cmd)
+        {
+            Logger.Debug?.Print(LogClass.GdbStub, $"Reply: {cmd}");
+            Commands.WriteStream.Write(Encoding.ASCII.GetBytes($"${cmd}#{Helpers.CalculateChecksum(cmd):x2}"));
+        }
+
+        public void ReplyOK() => Reply("OK");
+
+        public void ReplyError() => Reply("E01");
+
+        public void Reply(bool success)
+        {
+            if (success)
+                ReplyOK();
+            else ReplyError();
+        }
+
+        public void Reply(bool success, string cmd)
+        {
+            if (success)
+                Reply(cmd);
+            else ReplyError();
+        }
+
+        private string _previousThreadListXml = string.Empty;
+
         public void Process(string cmd)
         {
             StringStream ss = new(cmd);
@@ -24,143 +53,132 @@ namespace Ryujinx.HLE.Debugger.Gdb
             switch (ss.ReadChar())
             {
                 case '!':
-                    if (!ss.IsEmpty())
+                    if (!ss.IsEmpty)
                     {
                         goto unknownCommand;
                     }
 
                     // Enable extended mode
-                    Commands.ReplyOK();
+                    ReplyOK();
                     break;
                 case '?':
-                    if (!ss.IsEmpty())
+                    if (!ss.IsEmpty)
                     {
                         goto unknownCommand;
                     }
 
-                    Commands.CommandQuery();
+                    Commands.Query();
                     break;
                 case 'c':
-                    Commands.CommandContinue(ss.IsEmpty() ? null : ss.ReadRemainingAsHex());
+                    Commands.Continue(ss.IsEmpty ? null : ss.ReadRemainingAsHex());
                     break;
                 case 'D':
-                    if (!ss.IsEmpty())
+                    if (!ss.IsEmpty)
                     {
                         goto unknownCommand;
                     }
 
-                    Commands.CommandDetach();
+                    Commands.Detach();
                     break;
                 case 'g':
-                    if (!ss.IsEmpty())
+                    if (!ss.IsEmpty)
                     {
                         goto unknownCommand;
                     }
 
-                    Commands.CommandReadRegisters();
+                    Commands.ReadRegisters();
                     break;
                 case 'G':
-                    Commands.CommandWriteRegisters(ss);
+                    Commands.WriteRegisters(ss);
                     break;
                 case 'H':
                     {
                         char op = ss.ReadChar();
                         ulong? threadId = ss.ReadRemainingAsThreadUid();
-                        Commands.CommandSetThread(op, threadId);
+                        Commands.SetThread(op, threadId);
                         break;
                     }
                 case 'k':
                     Logger.Notice.Print(LogClass.GdbStub, "Kill request received, detach instead");
-                    Commands.Reply("");
-                    Commands.CommandDetach();
+                    Reply(string.Empty);
+                    Commands.Detach();
                     break;
                 case 'm':
                     {
                         ulong addr = ss.ReadUntilAsHex(',');
                         ulong len = ss.ReadRemainingAsHex();
-                        Commands.CommandReadMemory(addr, len);
+                        Commands.ReadMemory(addr, len);
                         break;
                     }
                 case 'M':
                     {
                         ulong addr = ss.ReadUntilAsHex(',');
                         ulong len = ss.ReadUntilAsHex(':');
-                        Commands.CommandWriteMemory(addr, len, ss);
+                        Commands.WriteMemory(addr, len, ss);
                         break;
                     }
                 case 'p':
                     {
                         ulong gdbRegId = ss.ReadRemainingAsHex();
-                        Commands.CommandReadRegister((int)gdbRegId);
+                        Commands.ReadRegister((int)gdbRegId);
                         break;
                     }
                 case 'P':
                     {
                         ulong gdbRegId = ss.ReadUntilAsHex('=');
-                        Commands.CommandWriteRegister((int)gdbRegId, ss);
+                        Commands.WriteRegister((int)gdbRegId, ss);
                         break;
                     }
                 case 'q':
                     if (ss.ConsumeRemaining("GDBServerVersion"))
                     {
-                        Commands.Reply($"name:Ryujinx;version:{ReleaseInformation.Version};");
+                        Reply($"name:Ryujinx;version:{ReleaseInformation.Version};");
                         break;
                     }
 
                     if (ss.ConsumeRemaining("HostInfo"))
                     {
-                        if (Commands.Debugger.IsProcessAarch32)
-                        {
-                            Commands.Reply(
-                                $"triple:{Helpers.ToHex("arm-unknown-linux-android")};endian:little;ptrsize:4;hostname:{Helpers.ToHex("Ryujinx")};");
-                        }
-                        else
-                        {
-                            Commands.Reply(
-                                $"triple:{Helpers.ToHex("aarch64-unknown-linux-android")};endian:little;ptrsize:8;hostname:{Helpers.ToHex("Ryujinx")};");
-                        }
+                        Reply(
+                            Debugger.IsProcess32Bit
+                                ? $"triple:{Helpers.ToHex("arm-unknown-linux-android")};endian:little;ptrsize:4;hostname:{Helpers.ToHex("Ryujinx")};"
+                                : $"triple:{Helpers.ToHex("aarch64-unknown-linux-android")};endian:little;ptrsize:8;hostname:{Helpers.ToHex("Ryujinx")};");
 
                         break;
                     }
 
                     if (ss.ConsumeRemaining("ProcessInfo"))
                     {
-                        if (Commands.Debugger.IsProcessAarch32)
-                        {
-                            Commands.Reply(
-                                $"pid:1;cputype:12;cpusubtype:0;triple:{Helpers.ToHex("arm-unknown-linux-android")};ostype:unknown;vendor:none;endian:little;ptrsize:4;");
-                        }
-                        else
-                        {
-                            Commands.Reply(
-                                $"pid:1;cputype:100000c;cpusubtype:0;triple:{Helpers.ToHex("aarch64-unknown-linux-android")};ostype:unknown;vendor:none;endian:little;ptrsize:8;");
-                        }
+                        Reply(
+                            Debugger.IsProcess32Bit
+                                ? $"pid:1;cputype:12;cpusubtype:0;triple:{Helpers.ToHex("arm-unknown-linux-android")};ostype:unknown;vendor:none;endian:little;ptrsize:4;"
+                                : $"pid:1;cputype:100000c;cpusubtype:0;triple:{Helpers.ToHex("aarch64-unknown-linux-android")};ostype:unknown;vendor:none;endian:little;ptrsize:8;");
 
                         break;
                     }
 
                     if (ss.ConsumePrefix("Supported:") || ss.ConsumeRemaining("Supported"))
                     {
-                        Commands.Reply("PacketSize=10000;qXfer:features:read+;qXfer:threads:read+;vContSupported+");
+                        Reply("PacketSize=10000;qXfer:features:read+;qXfer:threads:read+;vContSupported+");
                         break;
                     }
 
                     if (ss.ConsumePrefix("Rcmd,"))
                     {
                         string hexCommand = ss.ReadRemaining();
-                        Commands.HandleQRcmdCommand(hexCommand);
+                        Commands.Q_Rcmd(hexCommand);
                         break;
                     }
 
                     if (ss.ConsumeRemaining("fThreadInfo"))
                     {
-                        Commands. Reply($"m{string.Join(",", Commands.Debugger.DebugProcess.GetThreadUids().Select(x => $"{x:x}"))}");
+                        Reply(
+                            $"m{Debugger.DebugProcess.ThreadUids.Select(x => $"{x:x}").JoinToString(",")}");
                         break;
                     }
 
                     if (ss.ConsumeRemaining("sThreadInfo"))
                     {
-                        Commands.Reply("l");
+                        Reply("l");
                         break;
                     }
 
@@ -169,15 +187,14 @@ namespace Ryujinx.HLE.Debugger.Gdb
                         ulong? threadId = ss.ReadRemainingAsThreadUid();
                         if (threadId == null)
                         {
-                            Commands.ReplyError();
+                            ReplyError();
                             break;
                         }
 
-                        Commands.Reply(Helpers.ToHex(
-                            Commands.Debugger.DebugProcess.IsThreadPaused(
-                                Commands.Debugger.DebugProcess.GetThread(threadId.Value))
-                                ? "Paused"
-                                : "Running"
+                        Reply(Helpers.ToHex(
+                                DebugProcess.IsThreadPaused(DebugProcess.GetThread(threadId.Value))
+                                    ? "Paused"
+                                    : "Running"
                             )
                         );
 
@@ -190,32 +207,32 @@ namespace Ryujinx.HLE.Debugger.Gdb
                         ulong offset = ss.ReadUntilAsHex(',');
                         ulong len = ss.ReadRemainingAsHex();
 
-                        var data = "";
+                        string data;
                         if (offset > 0)
                         {
-                            data = previousThreadListXml;
+                            data = _previousThreadListXml;
                         }
                         else
                         {
-                            previousThreadListXml = data = GetThreadListXml();
+                            _previousThreadListXml = data = GetThreadListXml();
                         }
 
                         if (offset >= (ulong)data.Length)
                         {
-                            Commands.Reply("l");
+                            Reply("l");
                             break;
                         }
 
                         if (len >= (ulong)data.Length - offset)
                         {
-                            Commands.Reply("l" + Helpers.ToBinaryFormat(data.Substring((int)offset)));
-                            break;
+                            Reply("l" + Helpers.ToBinaryFormat(data[(int)offset..]));
                         }
                         else
                         {
-                            Commands.Reply("m" + Helpers.ToBinaryFormat(data.Substring((int)offset, (int)len)));
-                            break;
+                            Reply("m" + Helpers.ToBinaryFormat(data.Substring((int)offset, (int)len)));
                         }
+
+                        break;
                     }
 
                     if (ss.ConsumePrefix("Xfer:features:read:"))
@@ -226,46 +243,43 @@ namespace Ryujinx.HLE.Debugger.Gdb
 
                         if (feature == "target.xml")
                         {
-                            feature = Commands.Debugger.IsProcessAarch32 ? "target32.xml" : "target64.xml";
+                            feature = Debugger.IsProcess32Bit ? "target32.xml" : "target64.xml";
                         }
 
-                        string data;
-                        if (RegisterInformation.Features.TryGetValue(feature, out data))
+                        if (!RegisterInformation.Features.TryGetValue(feature, out string data))
                         {
-                            if (offset >= (ulong)data.Length)
-                            {
-                                Commands.Reply("l");
-                                break;
-                            }
+                            Reply("E00"); // Invalid annex
+                            break;
+                        }
 
-                            if (len >= (ulong)data.Length - offset)
-                            {
-                                Commands.Reply("l" + Helpers.ToBinaryFormat(data.Substring((int)offset)));
-                                break;
-                            }
-                            else
-                            {
-                                Commands.Reply("m" + Helpers.ToBinaryFormat(data.Substring((int)offset, (int)len)));
-                                break;
-                            }
+                        if (offset >= (ulong)data.Length)
+                        {
+                            Reply("l");
+                            break;
+                        }
+
+                        if (len >= (ulong)data.Length - offset)
+                        {
+                            Reply("l" + Helpers.ToBinaryFormat(data[(int)offset..]));
                         }
                         else
                         {
-                            Commands.Reply("E00"); // Invalid annex
-                            break;
+                            Reply("m" + Helpers.ToBinaryFormat(data.Substring((int)offset, (int)len)));
                         }
+
+                        break;
                     }
 
                     goto unknownCommand;
                 case 'Q':
                     goto unknownCommand;
                 case 's':
-                    Commands.CommandStep(ss.IsEmpty() ? null : ss.ReadRemainingAsHex());
+                    Commands.Step(ss.IsEmpty ? null : ss.ReadRemainingAsHex());
                     break;
                 case 'T':
                     {
                         ulong? threadId = ss.ReadRemainingAsThreadUid();
-                        Commands.CommandIsAlive(threadId);
+                        Commands.IsAlive(threadId);
                         break;
                     }
                 case 'v':
@@ -273,13 +287,13 @@ namespace Ryujinx.HLE.Debugger.Gdb
                     {
                         if (ss.ConsumeRemaining("?"))
                         {
-                            Commands.Reply("vCont;c;C;s;S");
+                            Reply("vCont;c;C;s;S");
                             break;
                         }
 
                         if (ss.ConsumePrefix(";"))
                         {
-                            Commands.HandleVContCommand(ss);
+                            Commands.VCont(ss);
                             break;
                         }
 
@@ -288,7 +302,7 @@ namespace Ryujinx.HLE.Debugger.Gdb
 
                     if (ss.ConsumeRemaining("MustReplyEmpty"))
                     {
-                        Commands.Reply("");
+                        Reply(string.Empty);
                         break;
                     }
 
@@ -303,29 +317,29 @@ namespace Ryujinx.HLE.Debugger.Gdb
                         if (extra.Length > 0)
                         {
                             Logger.Notice.Print(LogClass.GdbStub, $"Unsupported Z command extra data: {extra}");
-                            Commands.ReplyError();
+                            ReplyError();
                             return;
                         }
 
                         switch (type)
                         {
                             case "0": // Software breakpoint
-                                if (!Commands.Debugger.BreakpointManager.SetBreakPoint(addr, len, false))
+                                if (!BreakpointManager.SetBreakPoint(addr, len))
                                 {
-                                    Commands.ReplyError();
+                                    ReplyError();
                                     return;
                                 }
 
-                                Commands.ReplyOK();
+                                ReplyOK();
                                 return;
+                            // ReSharper disable RedundantCaseLabel
                             case "1": // Hardware breakpoint
                             case "2": // Write watchpoint
                             case "3": // Read watchpoint
                             case "4": // Access watchpoint
-                                Commands.ReplyError();
-                                return;
+                            // ReSharper restore RedundantCaseLabel
                             default:
-                                Commands. ReplyError();
+                                ReplyError();
                                 return;
                         }
                     }
@@ -340,50 +354,50 @@ namespace Ryujinx.HLE.Debugger.Gdb
                         if (extra.Length > 0)
                         {
                             Logger.Notice.Print(LogClass.GdbStub, $"Unsupported z command extra data: {extra}");
-                            Commands.ReplyError();
+                            ReplyError();
                             return;
                         }
 
                         switch (type)
                         {
                             case "0": // Software breakpoint
-                                if (!Commands.Debugger.BreakpointManager.ClearBreakPoint(addr, len))
+                                if (!BreakpointManager.ClearBreakPoint(addr, len))
                                 {
-                                    Commands.ReplyError();
+                                    ReplyError();
                                     return;
                                 }
 
-                                Commands.ReplyOK();
+                                ReplyOK();
                                 return;
+                            // ReSharper disable RedundantCaseLabel
                             case "1": // Hardware breakpoint
                             case "2": // Write watchpoint
                             case "3": // Read watchpoint
                             case "4": // Access watchpoint
-                                Commands.ReplyError();
-                                return;
+                            // ReSharper restore RedundantCaseLabel
                             default:
-                                Commands.ReplyError();
+                                ReplyError();
                                 return;
                         }
                     }
                 default:
                     unknownCommand:
                     Logger.Notice.Print(LogClass.GdbStub, $"Unknown command: {cmd}");
-                    Commands.Reply("");
+                    Reply(string.Empty);
                     break;
             }
         }
 
         private string GetThreadListXml()
         {
-            var sb = new StringBuilder();
+            StringBuilder sb = new();
             sb.Append("<?xml version=\"1.0\"?><threads>\n");
 
-            foreach (var thread in Commands.Debugger.GetThreads())
+            foreach (KThread thread in Debugger.GetThreads())
             {
                 string threadName = System.Security.SecurityElement.Escape(thread.GetThreadName());
                 sb.Append(
-                    $"<thread id=\"{thread.ThreadUid:x}\" name=\"{threadName}\">{(Commands.Debugger.DebugProcess.IsThreadPaused(thread) ? "Paused" : "Running")}</thread>\n");
+                    $"<thread id=\"{thread.ThreadUid:x}\" name=\"{threadName}\">{(DebugProcess.IsThreadPaused(thread) ? "Paused" : "Running")}</thread>\n");
             }
 
             sb.Append("</threads>");

src/Ryujinx.HLE/Debugger/Gdb/Commands.cs

@@ -1,10 +1,11 @@
 using Ryujinx.Common.Logging;
+using Ryujinx.Cpu;
+using Ryujinx.HLE.HOS.Kernel.Threading;
 using Ryujinx.Memory;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Net.Sockets;
-using System.Text;
 
 namespace Ryujinx.HLE.Debugger.Gdb
 {
@@ -15,59 +16,66 @@ namespace Ryujinx.HLE.Debugger.Gdb
 
         public readonly Debugger Debugger;
 
-        private readonly TcpListener _listenerSocket;
-        private readonly Socket _clientSocket;
-        private readonly NetworkStream _readStream;
-        private readonly NetworkStream _writeStream;
-        
+        public GdbCommandProcessor Processor { get; private set; }
+
+        internal readonly TcpListener ListenerSocket;
+        internal readonly Socket ClientSocket;
+        internal readonly NetworkStream ReadStream;
+        internal readonly NetworkStream WriteStream;
+
 
         public GdbCommands(TcpListener listenerSocket, Socket clientSocket, NetworkStream readStream,
             NetworkStream writeStream, Debugger debugger)
         {
-            _listenerSocket = listenerSocket;
-            _clientSocket = clientSocket;
-            _readStream = readStream;
-            _writeStream = writeStream;
+            ListenerSocket = listenerSocket;
+            ClientSocket = clientSocket;
+            ReadStream = readStream;
+            WriteStream = writeStream;
             Debugger = debugger;
         }
 
-        public void Reply(string cmd)
+        public void SetProcessor(GdbCommandProcessor commandProcessor)
         {
-            Logger.Debug?.Print(LogClass.GdbStub, $"Reply: {cmd}");
-            _writeStream.Write(Encoding.ASCII.GetBytes($"${cmd}#{Helpers.CalculateChecksum(cmd):x2}"));
+            if (Processor != null) return;
+
+            Processor = commandProcessor;
+        }
+        
+        public GdbCommandProcessor CreateProcessor()
+        {
+            if (Processor != null) 
+                return Processor;
+
+            return Processor = new GdbCommandProcessor(this);
         }
 
-        public void ReplyOK() => Reply("OK");
-
-        public void ReplyError() => Reply("E01");
-
-        internal void CommandQuery()
+        internal void Query()
         {
             // GDB is performing initial contact. Stop everything.
             Debugger.DebugProcess.DebugStop();
-            Debugger.GThread = Debugger.CThread = Debugger.DebugProcess.GetThreadUids().First();
-            Reply($"T05thread:{Debugger.CThread:x};");
+            Debugger.GThread = Debugger.CThread = Debugger.DebugProcess.ThreadUids.First();
+            Processor.Reply($"T05thread:{Debugger.CThread:x};");
         }
 
-        internal void CommandInterrupt()
+        internal void Interrupt()
         {
             // GDB is requesting an interrupt. Stop everything.
             Debugger.DebugProcess.DebugStop();
             if (Debugger.GThread == null || Debugger.GetThreads().All(x => x.ThreadUid != Debugger.GThread.Value))
             {
-                Debugger.GThread = Debugger.CThread = Debugger.DebugProcess.GetThreadUids().First();
+                Debugger.GThread = Debugger.CThread = Debugger.DebugProcess.ThreadUids.First();
             }
 
-            Reply($"T02thread:{Debugger.GThread:x};");
+            Processor.Reply($"T02thread:{Debugger.GThread:x};");
         }
 
-        internal void CommandContinue(ulong? newPc)
+        internal void Continue(ulong? newPc)
         {
             if (newPc.HasValue)
             {
                 if (Debugger.CThread == null)
                 {
-                    ReplyError();
+                    Processor.ReplyError();
                     return;
                 }
 
@@ -77,56 +85,56 @@ namespace Ryujinx.HLE.Debugger.Gdb
             Debugger.DebugProcess.DebugContinue();
         }
 
-        internal void CommandDetach()
+        internal void Detach()
         {
             Debugger.BreakpointManager.ClearAll();
-            CommandContinue(null);
+            Continue(null);
         }
 
-        internal void CommandReadRegisters()
+        internal void ReadRegisters()
         {
             if (Debugger.GThread == null)
             {
-                ReplyError();
+                Processor.ReplyError();
                 return;
             }
 
-            var ctx = Debugger.DebugProcess.GetThread(Debugger.GThread.Value).Context;
-            string registers = "";
-            if (Debugger.IsProcessAarch32)
+            IExecutionContext ctx = Debugger.DebugProcess.GetThread(Debugger.GThread.Value).Context;
+            string registers = string.Empty;
+            if (Debugger.IsProcess32Bit)
             {
                 for (int i = 0; i < GdbRegisterCount32; i++)
                 {
-                    registers += GdbRegisters.Read32(ctx, i);
+                    registers += ctx.ReadRegister32(i);
                 }
             }
             else
             {
                 for (int i = 0; i < GdbRegisterCount64; i++)
                 {
-                    registers += GdbRegisters.Read64(ctx, i);
+                    registers += ctx.ReadRegister64(i);
                 }
             }
 
-            Reply(registers);
+            Processor.Reply(registers);
         }
 
-        internal void CommandWriteRegisters(StringStream ss)
+        internal void WriteRegisters(StringStream ss)
         {
             if (Debugger.GThread == null)
             {
-                ReplyError();
+                Processor.ReplyError();
                 return;
             }
 
-            var ctx = Debugger.DebugProcess.GetThread(Debugger.GThread.Value).Context;
-            if (Debugger.IsProcessAarch32)
+            IExecutionContext ctx = Debugger.DebugProcess.GetThread(Debugger.GThread.Value).Context;
+            if (Debugger.IsProcess32Bit)
             {
                 for (int i = 0; i < GdbRegisterCount32; i++)
                 {
-                    if (!GdbRegisters.Write32(ctx, i, ss))
+                    if (!ctx.WriteRegister32(i, ss))
                     {
-                        ReplyError();
+                        Processor.ReplyError();
                         return;
                     }
                 }
@@ -135,32 +143,25 @@ namespace Ryujinx.HLE.Debugger.Gdb
             {
                 for (int i = 0; i < GdbRegisterCount64; i++)
                 {
-                    if (!GdbRegisters.Write64(ctx, i, ss))
+                    if (!ctx.WriteRegister64(i, ss))
                     {
-                        ReplyError();
+                        Processor.ReplyError();
                         return;
                     }
                 }
             }
 
-            if (ss.IsEmpty())
-            {
-                ReplyOK();
-            }
-            else
-            {
-                ReplyError();
-            }
+            Processor.Reply(ss.IsEmpty);
         }
 
-        internal void CommandSetThread(char op, ulong? threadId)
+        internal void SetThread(char op, ulong? threadId)
         {
             if (threadId is 0 or null)
             {
-                var threads = Debugger.GetThreads();
+                KThread[] threads = Debugger.GetThreads();
                 if (threads.Length == 0)
                 {
-                    ReplyError();
+                    Processor.ReplyError();
                     return;
                 }
 
@@ -169,7 +170,7 @@ namespace Ryujinx.HLE.Debugger.Gdb
 
             if (Debugger.DebugProcess.GetThread(threadId.Value) == null)
             {
-                ReplyError();
+                Processor.ReplyError();
                 return;
             }
 
@@ -177,36 +178,36 @@ namespace Ryujinx.HLE.Debugger.Gdb
             {
                 case 'c':
                     Debugger.CThread = threadId;
-                    ReplyOK();
+                    Processor.ReplyOK();
                     return;
                 case 'g':
                     Debugger.GThread = threadId;
-                    ReplyOK();
+                    Processor.ReplyOK();
                     return;
                 default:
-                    ReplyError();
+                    Processor.ReplyError();
                     return;
             }
         }
 
-        internal void CommandReadMemory(ulong addr, ulong len)
+        internal void ReadMemory(ulong addr, ulong len)
         {
             try
             {
                 var data = new byte[len];
                 Debugger.DebugProcess.CpuMemory.Read(addr, data);
-                Reply(Helpers.ToHex(data));
+                Processor.Reply(Helpers.ToHex(data));
             }
             catch (InvalidMemoryRegionException)
             {
                 // InvalidAccessHandler will show an error message, we log it again to tell user the error is from GDB (which can be ignored)
                 // TODO: Do not let InvalidAccessHandler show the error message
                 Logger.Notice.Print(LogClass.GdbStub, $"GDB failed to read memory at 0x{addr:X16}");
-                ReplyError();
+                Processor.ReplyError();
             }
         }
 
-        internal void CommandWriteMemory(ulong addr, ulong len, StringStream ss)
+        internal void WriteMemory(ulong addr, ulong len, StringStream ss)
         {
             try
             {
@@ -218,92 +219,50 @@ namespace Ryujinx.HLE.Debugger.Gdb
 
                 Debugger.DebugProcess.CpuMemory.Write(addr, data);
                 Debugger.DebugProcess.InvalidateCacheRegion(addr, len);
-                ReplyOK();
+                Processor.ReplyOK();
             }
             catch (InvalidMemoryRegionException)
             {
-                ReplyError();
+                Processor.ReplyError();
             }
         }
 
-        internal void CommandReadRegister(int gdbRegId)
+        internal void ReadRegister(int gdbRegId)
         {
             if (Debugger.GThread == null)
             {
-                ReplyError();
+                Processor.ReplyError();
                 return;
             }
 
-            var ctx = Debugger.DebugProcess.GetThread(Debugger.GThread.Value).Context;
-            string result;
-            if (Debugger.IsProcessAarch32)
-            {
-                result = GdbRegisters.Read32(ctx, gdbRegId);
-                if (result != null)
-                {
-                    Reply(result);
-                }
-                else
-                {
-                    ReplyError();
-                }
-            }
-            else
-            {
-                result = GdbRegisters.Read64(ctx, gdbRegId);
-                if (result != null)
-                {
-                    Reply(result);
-                }
-                else
-                {
-                    ReplyError();
-                }
-            }
+            IExecutionContext ctx = Debugger.DebugProcess.GetThread(Debugger.GThread.Value).Context;
+            string result = Debugger.ReadRegister(ctx, gdbRegId);
+
+            Processor.Reply(result != null, result);
         }
 
-        internal void CommandWriteRegister(int gdbRegId, StringStream ss)
+        internal void WriteRegister(int gdbRegId, StringStream ss)
         {
             if (Debugger.GThread == null)
             {
-                ReplyError();
+                Processor.ReplyError();
                 return;
             }
 
-            var ctx = Debugger.DebugProcess.GetThread(Debugger.GThread.Value).Context;
-            if (Debugger.IsProcessAarch32)
-            {
-                if (GdbRegisters.Write32(ctx, gdbRegId, ss) && ss.IsEmpty())
-                {
-                    ReplyOK();
-                }
-                else
-                {
-                    ReplyError();
-                }
-            }
-            else
-            {
-                if (GdbRegisters.Write64(ctx, gdbRegId, ss) && ss.IsEmpty())
-                {
-                    ReplyOK();
-                }
-                else
-                {
-                    ReplyError();
-                }
-            }
+            IExecutionContext ctx = Debugger.DebugProcess.GetThread(Debugger.GThread.Value).Context;
+            
+            Processor.Reply(Debugger.WriteRegister(ctx, gdbRegId, ss) && ss.IsEmpty);
         }
 
-        internal void CommandStep(ulong? newPc)
+        internal void Step(ulong? newPc)
         {
             if (Debugger.CThread == null)
             {
-                ReplyError();
+                Processor.ReplyError();
                 return;
             }
 
-            var thread = Debugger.DebugProcess.GetThread(Debugger.CThread.Value);
+            KThread thread = Debugger.DebugProcess.GetThread(Debugger.CThread.Value);
 
             if (newPc.HasValue)
             {
@@ -312,24 +271,24 @@ namespace Ryujinx.HLE.Debugger.Gdb
 
             if (!Debugger.DebugProcess.DebugStep(thread))
             {
-                ReplyError();
+                Processor.ReplyError();
             }
             else
             {
                 Debugger.GThread = Debugger.CThread = thread.ThreadUid;
-                Reply($"T05thread:{thread.ThreadUid:x};");
+                Processor.Reply($"T05thread:{thread.ThreadUid:x};");
             }
         }
 
-        internal void CommandIsAlive(ulong? threadId)
+        internal void IsAlive(ulong? threadId)
         {
             if (Debugger.GetThreads().Any(x => x.ThreadUid == threadId))
             {
-                ReplyOK();
+                Processor.ReplyOK();
             }
             else
             {
-                Reply("E00");
+                Processor.Reply("E00");
             }
         }
 
@@ -341,14 +300,14 @@ namespace Ryujinx.HLE.Debugger.Gdb
             Step
         }
 
-        record VContPendingAction(VContAction Action, ushort? Signal = null);
+        record VContPendingAction(VContAction Action/*, ushort? Signal = null*/);
 
-        internal void HandleVContCommand(StringStream ss)
+        internal void VCont(StringStream ss)
         {
             string[] rawActions = ss.ReadRemaining().Split(';', StringSplitOptions.RemoveEmptyEntries);
 
-            var threadActionMap = new Dictionary<ulong, VContPendingAction>();
-            foreach (var thread in Debugger.GetThreads())
+            Dictionary<ulong, VContPendingAction> threadActionMap = new();
+            foreach (KThread thread in Debugger.GetThreads())
             {
                 threadActionMap[thread.ThreadUid] = new VContPendingAction(VContAction.None);
             }
@@ -358,8 +317,8 @@ namespace Ryujinx.HLE.Debugger.Gdb
             // For each inferior thread, the *leftmost* action with a matching thread-id is applied.
             for (int i = rawActions.Length - 1; i >= 0; i--)
             {
-                var rawAction = rawActions[i];
-                var stream = new StringStream(rawAction);
+                string rawAction = rawActions[i];
+                StringStream stream = new(rawAction);
 
                 char cmd = stream.ReadChar();
                 VContAction action = cmd switch
@@ -371,10 +330,12 @@ namespace Ryujinx.HLE.Debugger.Gdb
                 };
 
                 // Note: We don't support signals yet.
-                ushort? signal = null;
+                //ushort? signal = null;
                 if (cmd is 'C' or 'S')
                 {
-                    signal = (ushort)stream.ReadLengthAsHex(2);
+                    /*signal = (ushort)*/stream.ReadLengthAsHex(2);
+                    // we still call the read length method even if we have signals commented
+                    // since that method advances the underlying string position
                 }
 
                 ulong? threadId = null;
@@ -387,14 +348,14 @@ namespace Ryujinx.HLE.Debugger.Gdb
                 {
                     if (threadActionMap.ContainsKey(threadId.Value))
                     {
-                        threadActionMap[threadId.Value] = new VContPendingAction(action, signal);
+                        threadActionMap[threadId.Value] = new VContPendingAction(action/*, signal*/);
                     }
                 }
                 else
                 {
-                    foreach (var row in threadActionMap.ToList())
+                    foreach (ulong thread in threadActionMap.Keys)
                     {
-                        threadActionMap[row.Key] = new VContPendingAction(action, signal);
+                        threadActionMap[thread] = new VContPendingAction(action/*, signal*/);
                     }
 
                     if (action == VContAction.Continue)
@@ -411,11 +372,11 @@ namespace Ryujinx.HLE.Debugger.Gdb
 
             bool hasError = false;
 
-            foreach (var (threadUid, action) in threadActionMap)
+            foreach ((ulong threadUid, VContPendingAction action) in threadActionMap)
             {
                 if (action.Action == VContAction.Step)
                 {
-                    var thread = Debugger.DebugProcess.GetThread(threadUid);
+                    KThread thread = Debugger.DebugProcess.GetThread(threadUid);
                     if (!Debugger.DebugProcess.DebugStep(thread))
                     {
                         hasError = true;
@@ -432,7 +393,7 @@ namespace Ryujinx.HLE.Debugger.Gdb
             }
             else if (defaultAction == VContAction.None)
             {
-                foreach (var (threadUid, action) in threadActionMap)
+                foreach ((ulong threadUid, VContPendingAction action) in threadActionMap)
                 {
                     if (action.Action == VContAction.Continue)
                     {
@@ -441,26 +402,19 @@ namespace Ryujinx.HLE.Debugger.Gdb
                 }
             }
 
-            if (hasError)
-            {
-                ReplyError();
-            }
-            else
-            {
-                ReplyOK();
-            }
+            Processor.Reply(!hasError);
 
-            foreach (var (threadUid, action) in threadActionMap)
+            foreach ((ulong threadUid, VContPendingAction action) in threadActionMap)
             {
                 if (action.Action == VContAction.Step)
                 {
                     Debugger.GThread = Debugger.CThread = threadUid;
-                    Reply($"T05thread:{threadUid:x};");
+                    Processor.Reply($"T05thread:{threadUid:x};");
                 }
             }
         }
-        
-        internal void HandleQRcmdCommand(string hexCommand)
+
+        internal void Q_Rcmd(string hexCommand)
         {
             try
             {
@@ -477,12 +431,12 @@ namespace Ryujinx.HLE.Debugger.Gdb
                     _ => $"Unknown command: {command}\n"
                 };
 
-                Reply(Helpers.ToHex(response));
+                Processor.Reply(Helpers.ToHex(response));
             }
             catch (Exception e)
             {
                 Logger.Error?.Print(LogClass.GdbStub, $"Error processing Rcmd: {e.Message}");
-                ReplyError();
+                Processor.ReplyError();
             }
         }
     }

src/Ryujinx.HLE/Debugger/Gdb/Registers.cs

@@ -9,69 +9,60 @@ namespace Ryujinx.HLE.Debugger.Gdb
         /*
         FPCR = FPSR & ~FpcrMask
         All of FPCR's bits are reserved in FPCR and vice versa,
-        see ARM's documentation. 
+        see ARM's documentation.
         */
         private const uint FpcrMask = 0xfc1fffff;
-        
-        public static string Read64(IExecutionContext state, int gdbRegId)
-        {
-            switch (gdbRegId)
-            {
-                case >= 0 and <= 31:
-                    return Helpers.ToHex(BitConverter.GetBytes(state.GetX(gdbRegId)));
-                case 32:
-                    return Helpers.ToHex(BitConverter.GetBytes(state.DebugPc));
-                case 33:
-                    return Helpers.ToHex(BitConverter.GetBytes(state.Pstate));
-                case >= 34 and <= 65:
-                    return Helpers.ToHex(state.GetV(gdbRegId - 34).ToArray());
-                case 66:
-                    return Helpers.ToHex(BitConverter.GetBytes((uint)state.Fpsr));
-                case 67:
-                    return Helpers.ToHex(BitConverter.GetBytes((uint)state.Fpcr));
-                default:
-                    return null;
-            }
-        }
 
-        public static bool Write64(IExecutionContext state, int gdbRegId, StringStream ss)
+        public static string ReadRegister64(this IExecutionContext state, int registerId) =>
+            registerId switch
+            {
+                >= 0 and <= 31 => Helpers.ToHex(BitConverter.GetBytes(state.GetX(registerId))),
+                32 => Helpers.ToHex(BitConverter.GetBytes(state.DebugPc)),
+                33 => Helpers.ToHex(BitConverter.GetBytes(state.Pstate)),
+                >= 34 and <= 65 => Helpers.ToHex(state.GetV(registerId - 34).ToArray()),
+                66 => Helpers.ToHex(BitConverter.GetBytes((uint)state.Fpsr)),
+                67 => Helpers.ToHex(BitConverter.GetBytes((uint)state.Fpcr)),
+                _ => null
+            };
+
+        public static bool WriteRegister64(this IExecutionContext state, int registerId, StringStream ss)
         {
-            switch (gdbRegId)
+            switch (registerId)
             {
                 case >= 0 and <= 31:
                     {
-                        ulong value = ss.ReadLengthAsLEHex(16);
-                        state.SetX(gdbRegId, value);
+                        ulong value = ss.ReadLengthAsLittleEndianHex(16);
+                        state.SetX(registerId, value);
                         return true;
                     }
                 case 32:
                     {
-                        ulong value = ss.ReadLengthAsLEHex(16);
+                        ulong value = ss.ReadLengthAsLittleEndianHex(16);
                         state.DebugPc = value;
                         return true;
                     }
                 case 33:
                     {
-                        ulong value = ss.ReadLengthAsLEHex(8);
+                        ulong value = ss.ReadLengthAsLittleEndianHex(8);
                         state.Pstate = (uint)value;
                         return true;
                     }
                 case >= 34 and <= 65:
                     {
-                        ulong value0 = ss.ReadLengthAsLEHex(16);
-                        ulong value1 = ss.ReadLengthAsLEHex(16);
-                        state.SetV(gdbRegId - 34, new V128(value0, value1));
+                        ulong value0 = ss.ReadLengthAsLittleEndianHex(16);
+                        ulong value1 = ss.ReadLengthAsLittleEndianHex(16);
+                        state.SetV(registerId - 34, new V128(value0, value1));
                         return true;
                     }
                 case 66:
                     {
-                        ulong value = ss.ReadLengthAsLEHex(8);
+                        ulong value = ss.ReadLengthAsLittleEndianHex(8);
                         state.Fpsr = (uint)value;
                         return true;
                     }
                 case 67:
                     {
-                        ulong value = ss.ReadLengthAsLEHex(8);
+                        ulong value = ss.ReadLengthAsLittleEndianHex(8);
                         state.Fpcr = (uint)value;
                         return true;
                     }
@@ -80,65 +71,64 @@ namespace Ryujinx.HLE.Debugger.Gdb
             }
         }
 
-        public static string Read32(IExecutionContext state, int gdbRegId)
+        public static string ReadRegister32(this IExecutionContext state, int registerId)
         {
-            switch (gdbRegId)
+            switch (registerId)
             {
                 case >= 0 and <= 14:
-                    return Helpers.ToHex(BitConverter.GetBytes((uint)state.GetX(gdbRegId)));
+                    return Helpers.ToHex(BitConverter.GetBytes((uint)state.GetX(registerId)));
                 case 15:
                     return Helpers.ToHex(BitConverter.GetBytes((uint)state.DebugPc));
                 case 16:
-                    return Helpers.ToHex(BitConverter.GetBytes((uint)state.Pstate));
+                    return Helpers.ToHex(BitConverter.GetBytes(state.Pstate));
                 case >= 17 and <= 32:
-                    return Helpers.ToHex(state.GetV(gdbRegId - 17).ToArray());
+                    return Helpers.ToHex(state.GetV(registerId - 17).ToArray());
                 case >= 33 and <= 64:
-                    int reg = (gdbRegId - 33);
+                    int reg = (registerId - 33);
                     int n = reg / 2;
                     int shift = reg % 2;
                     ulong value = state.GetV(n).Extract<ulong>(shift);
                     return Helpers.ToHex(BitConverter.GetBytes(value));
                 case 65:
-                    uint fpscr = (uint)state.Fpsr | (uint)state.Fpcr;
-                    return Helpers.ToHex(BitConverter.GetBytes(fpscr));
+                    return Helpers.ToHex(BitConverter.GetBytes(state.Fpscr));
                 default:
                     return null;
             }
         }
 
-        public static bool Write32(IExecutionContext state, int gdbRegId, StringStream ss)
+        public static bool WriteRegister32(this IExecutionContext state, int registerId, StringStream ss)
         {
-            switch (gdbRegId)
+            switch (registerId)
             {
                 case >= 0 and <= 14:
                     {
-                        ulong value = ss.ReadLengthAsLEHex(8);
-                        state.SetX(gdbRegId, value);
+                        ulong value = ss.ReadLengthAsLittleEndianHex(8);
+                        state.SetX(registerId, value);
                         return true;
                     }
                 case 15:
                     {
-                        ulong value = ss.ReadLengthAsLEHex(8);
+                        ulong value = ss.ReadLengthAsLittleEndianHex(8);
                         state.DebugPc = value;
                         return true;
                     }
                 case 16:
                     {
-                        ulong value = ss.ReadLengthAsLEHex(8);
+                        ulong value = ss.ReadLengthAsLittleEndianHex(8);
                         state.Pstate = (uint)value;
                         return true;
                     }
                 case >= 17 and <= 32:
                     {
-                        ulong value0 = ss.ReadLengthAsLEHex(16);
-                        ulong value1 = ss.ReadLengthAsLEHex(16);
-                        state.SetV(gdbRegId - 17, new V128(value0, value1));
+                        ulong value0 = ss.ReadLengthAsLittleEndianHex(16);
+                        ulong value1 = ss.ReadLengthAsLittleEndianHex(16);
+                        state.SetV(registerId - 17, new V128(value0, value1));
                         return true;
                     }
                 case >= 33 and <= 64:
                     {
-                        ulong value = ss.ReadLengthAsLEHex(16);
-                        int regId = (gdbRegId - 33);
+                        ulong value = ss.ReadLengthAsLittleEndianHex(16);
+                        int regId = (registerId - 33);
                         int regNum = regId / 2;
                         int shift = regId % 2;
                         V128 reg = state.GetV(regNum);
@@ -147,7 +137,7 @@ namespace Ryujinx.HLE.Debugger.Gdb
                     }
                 case 65:
                     {
-                        ulong value = ss.ReadLengthAsLEHex(8);
+                        ulong value = ss.ReadLengthAsLittleEndianHex(8);
                         state.Fpsr = (uint)value & FpcrMask;
                         state.Fpcr = (uint)value & ~FpcrMask;
                         return true;

src/Ryujinx.HLE/Debugger/Helpers.cs

@@ -43,7 +43,7 @@ namespace Ryujinx.HLE.Debugger
                     (byte)'$' => "}\x04",
                     (byte)'*' => "}\x0a",
                     (byte)'}' => "}\x5d",
-                    _ => Convert.ToChar(x).ToString(),
+                    _ => Convert.ToChar(x).ToString()
                 }
             ).JoinToString(string.Empty);
     }

src/Ryujinx.HLE/Debugger/IDebuggableProcess.cs

@@ -11,11 +11,11 @@ namespace Ryujinx.HLE.Debugger
         void DebugContinue(KThread thread);
         bool DebugStep(KThread thread);
         KThread GetThread(ulong threadUid);
-        DebugState GetDebugState();
         bool IsThreadPaused(KThread thread);
-        ulong[] GetThreadUids();
         public void DebugInterruptHandler(IExecutionContext ctx);
         IVirtualMemoryManager CpuMemory { get; }
+        ulong[] ThreadUids { get; }
+        DebugState DebugState { get; }
         void InvalidateCacheRegion(ulong address, ulong size);
     }
 }

src/Ryujinx.HLE/Debugger/IMessage.cs

@@ -0,0 +1,47 @@
+using Ryujinx.Cpu;
+
+namespace Ryujinx.HLE.Debugger
+{
+    /// <summary>
+    ///     Marker interface for debugger messages.
+    /// </summary>
+    interface IMessage;
+
+    public enum MessageType
+    {
+        Kill,
+        BreakIn,
+        SendNack
+    }
+
+    record struct StatelessMessage(MessageType Type) : IMessage
+    {
+        public static StatelessMessage Kill => new(MessageType.Kill);
+        public static StatelessMessage BreakIn => new(MessageType.BreakIn);
+        public static StatelessMessage SendNack => new(MessageType.SendNack);
+    }
+
+    struct CommandMessage : IMessage
+    {
+        public readonly string Command;
+
+        public CommandMessage(string cmd)
+        {
+            Command = cmd;
+        }
+    }
+    
+    public class ThreadBreakMessage : IMessage
+    {
+        public IExecutionContext Context { get; }
+        public ulong Address { get; }
+        public int Opcode { get; }
+
+        public ThreadBreakMessage(IExecutionContext context, ulong address, int opcode)
+        {
+            Context = context;
+            Address = address;
+            Opcode = opcode;
+        }
+    }
+}

src/Ryujinx.HLE/Debugger/Message/BreakInMessage.cs

@@ -1,6 +0,0 @@
-namespace Ryujinx.HLE.Debugger
-{
-    struct BreakInMessage : IMessage
-    {
-    }
-}

src/Ryujinx.HLE/Debugger/Message/CommandMessage.cs

@@ -1,12 +0,0 @@
-namespace Ryujinx.HLE.Debugger
-{
-    struct CommandMessage : IMessage
-    {
-        public string Command;
-
-        public CommandMessage(string cmd)
-        {
-            Command = cmd;
-        }
-    }
-}

src/Ryujinx.HLE/Debugger/Message/IMessage.cs

@@ -1,6 +0,0 @@
-namespace Ryujinx.HLE.Debugger
-{
-    interface IMessage
-    {
-    }
-}

src/Ryujinx.HLE/Debugger/Message/KillMessage.cs

@@ -1,6 +0,0 @@
-namespace Ryujinx.HLE.Debugger
-{
-    struct KillMessage : IMessage
-    {
-    }
-}

src/Ryujinx.HLE/Debugger/Message/SendNackMessage.cs

@@ -1,6 +0,0 @@
-namespace Ryujinx.HLE.Debugger
-{
-    struct SendNackMessage : IMessage
-    {
-    }
-}

src/Ryujinx.HLE/Debugger/Message/ThreadBreakMessage.cs

@@ -1,18 +0,0 @@
-using IExecutionContext = Ryujinx.Cpu.IExecutionContext;
-
-namespace Ryujinx.HLE.Debugger
-{
-    public class ThreadBreakMessage : IMessage
-    {
-        public IExecutionContext Context { get; }
-        public ulong Address { get; }
-        public int Opcode { get; }
-
-        public ThreadBreakMessage(IExecutionContext context, ulong address, int opcode)
-        {
-            Context = context;
-            Address = address;
-            Opcode = opcode;
-        }
-    }
-}

src/Ryujinx.HLE/Debugger/RegisterInformation.cs

@@ -17,12 +17,9 @@ namespace Ryujinx.HLE.Debugger
 
         private static string GetEmbeddedResourceContent(string resourceName)
         {
-            Stream stream = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("Ryujinx.HLE.Debugger.GdbXml." + resourceName);
-            StreamReader reader = new StreamReader(stream);
-            string result = reader.ReadToEnd();
-            reader.Dispose();
-            stream.Dispose();
-            return result;
+            using Stream stream = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("Ryujinx.HLE.Debugger.Gdb.Xml." + resourceName);
+            using StreamReader reader = new(stream);
+            return reader.ReadToEnd();
         }
     }
 }

src/Ryujinx.HLE/Debugger/StringStream.cs

@@ -5,63 +5,56 @@ namespace Ryujinx.HLE.Debugger
 {
     internal class StringStream
     {
-        private readonly string Data;
-        private int Position;
+        private readonly string _data;
+        private int _position;
 
         public StringStream(string s)
         {
-            Data = s;
+            _data = s;
         }
+        
+        public bool IsEmpty => _position >= _data.Length;
 
-        public char ReadChar()
-        {
-            return Data[Position++];
-        }
+        public char ReadChar() => _data[_position++];
 
         public string ReadUntil(char needle)
         {
-            int needlePos = Data.IndexOf(needle, Position);
+            int needlePos = _data.IndexOf(needle, _position);
 
             if (needlePos == -1)
             {
-                needlePos = Data.Length;
+                needlePos = _data.Length;
             }
 
-            string result = Data.Substring(Position, needlePos - Position);
-            Position = needlePos + 1;
+            string result = _data.Substring(_position, needlePos - _position);
+            _position = needlePos + 1;
             return result;
         }
 
         public string ReadLength(int len)
         {
-            string result = Data.Substring(Position, len);
-            Position += len;
+            string result = _data.Substring(_position, len);
+            _position += len;
             return result;
         }
 
         public string ReadRemaining()
         {
-            string result = Data.Substring(Position);
-            Position = Data.Length;
+            string result = _data[_position..];
+            _position = _data.Length;
             return result;
         }
 
-        public ulong ReadRemainingAsHex()
-        {
-            return ulong.Parse(ReadRemaining(), NumberStyles.HexNumber);
-        }
+        public ulong ReadRemainingAsHex() 
+            => ulong.Parse(ReadRemaining(), NumberStyles.HexNumber);
 
-        public ulong ReadUntilAsHex(char needle)
-        {
-            return ulong.Parse(ReadUntil(needle), NumberStyles.HexNumber);
-        }
+        public ulong ReadUntilAsHex(char needle) 
+            => ulong.Parse(ReadUntil(needle), NumberStyles.HexNumber);
 
-        public ulong ReadLengthAsHex(int len)
-        {
-            return ulong.Parse(ReadLength(len), NumberStyles.HexNumber);
-        }
+        public ulong ReadLengthAsHex(int len) 
+            => ulong.Parse(ReadLength(len), NumberStyles.HexNumber);
 
-        public ulong ReadLengthAsLEHex(int len)
+        public ulong ReadLengthAsLittleEndianHex(int len)
         {
             Debug.Assert(len % 2 == 0);
 
@@ -83,9 +76,9 @@ namespace Ryujinx.HLE.Debugger
 
         public bool ConsumePrefix(string prefix)
         {
-            if (Data.Substring(Position).StartsWith(prefix))
+            if (_data[_position..].StartsWith(prefix))
             {
-                Position += prefix.Length;
+                _position += prefix.Length;
                 return true;
             }
             return false;
@@ -93,17 +86,12 @@ namespace Ryujinx.HLE.Debugger
 
         public bool ConsumeRemaining(string match)
         {
-            if (Data.Substring(Position) == match)
+            if (_data[_position..] == match)
             {
-                Position += match.Length;
+                _position += match.Length;
                 return true;
             }
             return false;
         }
-
-        public bool IsEmpty()
-        {
-            return Position >= Data.Length;
-        }
     }
 }

src/Ryujinx.HLE/HOS/Kernel/Process/KProcess.cs

@@ -1092,7 +1092,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
             MemoryManager = new KPageTable(KernelContext, CpuMemory, Context.AddressSpaceSize);
         }
 
-        private bool InvalidAccessHandler(ulong va)
+        private static bool InvalidAccessHandler(ulong va)
         {
             KernelStatic.GetCurrentThread()?.PrintGuestStackTrace();
             KernelStatic.GetCurrentThread()?.PrintGuestRegisterPrintout();
@@ -1104,7 +1104,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
             return false;
         }
 
-        private void UndefinedInstructionHandler(IExecutionContext context, ulong address, int opCode)
+        private static void UndefinedInstructionHandler(IExecutionContext context, ulong address, int opCode)
         {
             KernelStatic.GetCurrentThread().PrintGuestStackTrace();
             KernelStatic.GetCurrentThread()?.PrintGuestRegisterPrintout();
@@ -1208,16 +1208,16 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
 
         private class DebuggerInterface : IDebuggableProcess
         {
-            private Barrier StepBarrier;
+            private readonly Barrier _stepBarrier;
             private readonly KProcess _parent;
             private readonly KernelContext _kernelContext;
-            private KThread steppingThread;
+            private KThread _steppingThread;
 
             public DebuggerInterface(KProcess p)
             {
                 _parent = p;
                 _kernelContext = p.KernelContext;
-                StepBarrier = new(2);
+                _stepBarrier = new(2);
             }
 
             public void DebugStop()
@@ -1285,7 +1285,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
                 }
                 
                 _kernelContext.CriticalSection.Enter();
-                steppingThread = target;
+                _steppingThread = target;
                 bool waiting = target.MutexOwner != null || target.WaitingSync || target.WaitingInArbitration;
                 target.Context.RequestDebugStep();
                 if (waiting)
@@ -1305,14 +1305,14 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
                 _kernelContext.CriticalSection.Leave();
 
                 bool stepTimedOut = false;
-                if (!StepBarrier.SignalAndWait(TimeSpan.FromMilliseconds(2000)))
+                if (!_stepBarrier.SignalAndWait(TimeSpan.FromMilliseconds(2000)))
                 {
                     Logger.Warning?.Print(LogClass.Kernel, $"Failed to step thread {target.ThreadUid} in time.");
                     stepTimedOut = true;
                 }
 
                 _kernelContext.CriticalSection.Enter();
-                steppingThread = null;
+                _steppingThread = null;
                 if (waiting)
                 {
                     lock (_parent._threadingLock)
@@ -1334,26 +1334,28 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
                     return false;
                 }
 
-                StepBarrier.SignalAndWait();
+                _stepBarrier.SignalAndWait();
                 return true;
             }
 
-            public DebugState GetDebugState()
-            {
-                return (DebugState)_parent.debugState;
-            }
+            public DebugState DebugState => (DebugState)_parent.debugState;
 
             public bool IsThreadPaused(KThread target)
             {
                 return (target.SchedFlags & ThreadSchedState.ThreadPauseFlag) != 0;
             }
 
-            public ulong[] GetThreadUids()
+            public ulong[] ThreadUids
             {
-                lock (_parent._threadingLock)
+                get
                 {
-                    var threads = _parent._threads.Where(x => !x.TerminationRequested).ToArray();
-                    return threads.Select(x => x.ThreadUid).ToArray();
+                    lock (_parent._threadingLock)
+                    {
+                        return _parent._threads
+                            .Where(x => !x.TerminationRequested)
+                            .Select(x => x.ThreadUid)
+                            .ToArray();
+                    }
                 }
             }
 
@@ -1361,25 +1363,25 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
             {
                 lock (_parent._threadingLock)
                 {
-                    var threads = _parent._threads.Where(x => !x.TerminationRequested).ToArray();
-                    return threads.FirstOrDefault(x => x.ThreadUid == threadUid);
+                    return _parent._threads.Where(x => !x.TerminationRequested)
+                        .FirstOrDefault(x => x.ThreadUid == threadUid);
                 }
             }
 
             public void DebugInterruptHandler(IExecutionContext ctx)
             {
                 _kernelContext.CriticalSection.Enter();
-                bool stepping = steppingThread != null;
+                bool stepping = _steppingThread != null;
                 _kernelContext.CriticalSection.Leave();
                 if (stepping)
                 {
-                    StepBarrier.SignalAndWait();
-                    StepBarrier.SignalAndWait();
+                    _stepBarrier.SignalAndWait();
+                    _stepBarrier.SignalAndWait();
                 }
                 _parent.InterruptHandler(ctx);
             }
 
-            public IVirtualMemoryManager CpuMemory { get { return _parent.CpuMemory; } }
+            public IVirtualMemoryManager CpuMemory => _parent.CpuMemory;
 
             public void InvalidateCacheRegion(ulong address, ulong size)
             {

src/Ryujinx.HLE/HOS/Kernel/Process/ProcessCreationFlags.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Diagnostics.CodeAnalysis;
 
 namespace Ryujinx.HLE.HOS.Kernel.Process
 {

src/Ryujinx.HLE/HOS/Kernel/Process/ProcessExecutionContext.cs

@@ -1,6 +1,5 @@
 using ARMeilleure.State;
 using Ryujinx.Cpu;
-using System.Threading;
 
 namespace Ryujinx.HLE.HOS.Kernel.Process
 {

src/Ryujinx.HLE/HOS/Kernel/Threading/KScheduler.cs

@@ -293,7 +293,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
             KThread currentThread = KernelStatic.GetCurrentThread();
             KThread selectedThread = _state.SelectedThread;
 
-            if (!currentThread.IsThreadNamed && currentThread.GetThreadName() != "")
+            if (!currentThread.IsThreadNamed && string.IsNullOrEmpty(currentThread.GetThreadName()))
             {
                 currentThread.HostThread.Name = $"<{currentThread.GetThreadName()}>";
                 currentThread.IsThreadNamed = true;

src/Ryujinx.HLE/HOS/Kernel/Threading/KThread.cs

@@ -1,7 +1,6 @@
 using ARMeilleure.State;
 using Ryujinx.Common.Logging;
 using Ryujinx.Cpu;
-using Ryujinx.HLE.Debugger;
 using Ryujinx.HLE.HOS.Kernel.Common;
 using Ryujinx.HLE.HOS.Kernel.Process;
 using Ryujinx.HLE.HOS.Kernel.SupervisorCall;

src/Ryujinx.HLE/HOS/Services/Account/Acc/AccountService/ManagerServer.cs

@@ -7,7 +7,6 @@ using System;
 using System.Collections.Generic;
 using System.Security.Claims;
 using System.Security.Cryptography;
-using System.Security.Principal;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;

src/Ryujinx.HLE/HOS/Services/Loader/ResultCode.cs

@@ -1,5 +1,3 @@
-using System.Diagnostics.CodeAnalysis;
-
 namespace Ryujinx.HLE.HOS.Services.Loader
 {
     enum ResultCode

src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocket.cs

@@ -2,7 +2,6 @@ using Ryujinx.Common.Logging;
 using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Proxy;
 using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types;
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
 using System.Net;
 using System.Net.Sockets;

src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/WSAError.cs

@@ -1,5 +1,3 @@
-using System.Diagnostics.CodeAnalysis;
-
 namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
 {
     enum WsaError

src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSocketOption.cs

@@ -1,5 +1,3 @@
-using System.Diagnostics.CodeAnalysis;
-
 namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types
 {
     enum BsdSocketOption

src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/LinuxError.cs

@@ -1,5 +1,3 @@
-using System.Diagnostics.CodeAnalysis;
-
 namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types
 {
     enum LinuxError

src/Ryujinx.HLE/HOS/Services/SurfaceFlinger/Status.cs

@@ -1,5 +1,3 @@
-using System.Diagnostics.CodeAnalysis;
-
 namespace Ryujinx.HLE.HOS.Services.SurfaceFlinger
 {
     enum Status

src/Ryujinx.HLE/HOS/Services/SurfaceFlinger/SurfaceFlinger.cs

@@ -2,7 +2,6 @@ using Ryujinx.Common;
 using Ryujinx.Common.Configuration;
 using Ryujinx.Common.Logging;
 using Ryujinx.Common.PreciseSleep;
-using Ryujinx.Cpu;
 using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.Gpu;
 using Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvMap;

src/Ryujinx.HLE/HOS/Services/SurfaceFlinger/Types/Color/ColorFormat.cs

@@ -1,5 +1,3 @@
-using System.Diagnostics.CodeAnalysis;
-
 namespace Ryujinx.HLE.HOS.Services.SurfaceFlinger
 {
     enum ColorFormat : ulong

src/Ryujinx.HLE/HOS/Services/Time/ResultCode.cs

@@ -1,5 +1,3 @@
-using System.Diagnostics.CodeAnalysis;
-
 namespace Ryujinx.HLE.HOS.Services.Time
 {
     public enum ResultCode

src/Ryujinx.HLE/Loaders/Elf/ElfDynamicTag.cs

@@ -1,5 +1,3 @@
-using System.Diagnostics.CodeAnalysis;
-
 namespace Ryujinx.HLE.Loaders.Elf
 {
     enum ElfDynamicTag

src/Ryujinx.HLE/Loaders/Processes/Extensions/FileSystemExtensions.cs

@@ -9,7 +9,6 @@ using Ryujinx.Common.Logging;
 using Ryujinx.Graphics.Gpu;
 using Ryujinx.HLE.Loaders.Executables;
 using Ryujinx.Memory;
-using System;
 using System.Linq;
 using static Ryujinx.HLE.HOS.ModLoader;
 

src/Ryujinx.HLE/Loaders/Processes/ProcessResult.cs

@@ -6,7 +6,6 @@ using Ryujinx.Cpu;
 using Ryujinx.HLE.HOS.SystemState;
 using Ryujinx.HLE.Loaders.Processes.Extensions;
 using Ryujinx.Horizon.Common;
-using System;
 
 namespace Ryujinx.HLE.Loaders.Processes
 {

src/Ryujinx.HLE/Switch.cs

@@ -14,7 +14,6 @@ using Ryujinx.HLE.Loaders.Processes;
 using Ryujinx.HLE.UI;
 using Ryujinx.Memory;
 using System;
-using System.Threading;
 
 namespace Ryujinx.HLE
 {

src/Ryujinx.HLE/UI/Input/NpadReader.cs

@@ -1,4 +1,3 @@
-using Ryujinx.Common.Memory;
 using Ryujinx.HLE.HOS.Services.Hid.Types.SharedMemory.Common;
 using Ryujinx.HLE.HOS.Services.Hid.Types.SharedMemory.Npad;
 using System;