From fb4b3c127f7c390358d7f4cadd2f58de116fec48 Mon Sep 17 00:00:00 2001 From: Liam Date: Mon, 30 May 2022 19:35:01 -0400 Subject: core/debugger: Implement new GDB stub debugger --- src/core/debugger/debugger.cpp | 259 +++++++++++++++++++++ src/core/debugger/debugger.h | 46 ++++ src/core/debugger/debugger_interface.h | 74 ++++++ src/core/debugger/gdbstub.cpp | 382 +++++++++++++++++++++++++++++++ src/core/debugger/gdbstub.h | 47 ++++ src/core/debugger/gdbstub_arch.cpp | 406 +++++++++++++++++++++++++++++++++ src/core/debugger/gdbstub_arch.h | 67 ++++++ 7 files changed, 1281 insertions(+) create mode 100644 src/core/debugger/debugger.cpp create mode 100644 src/core/debugger/debugger.h create mode 100644 src/core/debugger/debugger_interface.h create mode 100644 src/core/debugger/gdbstub.cpp create mode 100644 src/core/debugger/gdbstub.h create mode 100644 src/core/debugger/gdbstub_arch.cpp create mode 100644 src/core/debugger/gdbstub_arch.h (limited to 'src/core/debugger') diff --git a/src/core/debugger/debugger.cpp b/src/core/debugger/debugger.cpp new file mode 100644 index 000000000..7a2012d3c --- /dev/null +++ b/src/core/debugger/debugger.cpp @@ -0,0 +1,259 @@ +// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include +#include + +#include +#include + +#include "common/logging/log.h" +#include "common/thread.h" +#include "core/core.h" +#include "core/debugger/debugger.h" +#include "core/debugger/debugger_interface.h" +#include "core/debugger/gdbstub.h" +#include "core/hle/kernel/global_scheduler_context.h" + +template +static void AsyncReceiveInto(Readable& r, Buffer& buffer, Callback&& c) { + static_assert(std::is_trivial_v); + auto boost_buffer{boost::asio::buffer(&buffer, sizeof(Buffer))}; + r.async_read_some(boost_buffer, [&](const boost::system::error_code& error, size_t bytes_read) { + if (!error.failed()) { + const u8* buffer_start = reinterpret_cast(&buffer); + std::span received_data{buffer_start, buffer_start + bytes_read}; + c(received_data); + } + + AsyncReceiveInto(r, buffer, c); + }); +} + +template +static std::span ReceiveInto(Readable& r, Buffer& buffer) { + static_assert(std::is_trivial_v); + auto boost_buffer{boost::asio::buffer(&buffer, sizeof(Buffer))}; + size_t bytes_read = r.read_some(boost_buffer); + const u8* buffer_start = reinterpret_cast(&buffer); + std::span received_data{buffer_start, buffer_start + bytes_read}; + return received_data; +} + +namespace Core { + +class DebuggerImpl : public DebuggerBackend { +public: + explicit DebuggerImpl(Core::System& system_, u16 port) + : system{system_}, signal_pipe{io_context}, client_socket{io_context} { + frontend = std::make_unique(*this, system); + InitializeServer(port); + } + + ~DebuggerImpl() { + ShutdownServer(); + } + + bool NotifyThreadStopped(Kernel::KThread* thread) { + std::scoped_lock lk{connection_lock}; + + if (stopped) { + // Do not notify the debugger about another event. + // It should be ignored. + return false; + } + stopped = true; + + signal_pipe.write_some(boost::asio::buffer(&thread, sizeof(thread))); + return true; + } + + std::span ReadFromClient() override { + return ReceiveInto(client_socket, client_data); + } + + void WriteToClient(std::span data) override { + client_socket.write_some(boost::asio::buffer(data.data(), data.size_bytes())); + } + + void SetActiveThread(Kernel::KThread* thread) override { + active_thread = thread; + } + + Kernel::KThread* GetActiveThread() override { + return active_thread; + } + + bool IsStepping() const { + return stepping; + } + +private: + void InitializeServer(u16 port) { + using boost::asio::ip::tcp; + + LOG_INFO(Debug_GDBStub, "Starting server on port {}...", port); + + // Initialize the listening socket and accept a new client. + tcp::endpoint endpoint{boost::asio::ip::address_v4::loopback(), port}; + tcp::acceptor acceptor{io_context, endpoint}; + client_socket = acceptor.accept(); + + // Run the connection thread. + connection_thread = std::jthread([&](std::stop_token stop_token) { + try { + ThreadLoop(stop_token); + } catch (const std::exception& ex) { + LOG_CRITICAL(Debug_GDBStub, "Stopping server: {}", ex.what()); + } + + client_socket.shutdown(client_socket.shutdown_both); + client_socket.close(); + }); + } + + void ShutdownServer() { + connection_thread.request_stop(); + io_context.stop(); + connection_thread.join(); + } + + void ThreadLoop(std::stop_token stop_token) { + Common::SetCurrentThreadName("yuzu:Debugger"); + + // Set up the client signals for new data. + AsyncReceiveInto(signal_pipe, active_thread, [&](auto d) { PipeData(d); }); + AsyncReceiveInto(client_socket, client_data, [&](auto d) { ClientData(d); }); + + // Stop the emulated CPU. + AllCoreStop(); + + // Set the active thread. + active_thread = ThreadList()[0]; + active_thread->Resume(Kernel::SuspendType::Debug); + + // Set up the frontend. + frontend->Connected(); + + // Main event loop. + while (!stop_token.stop_requested() && io_context.run()) { + } + } + + void PipeData(std::span data) { + AllCoreStop(); + active_thread->Resume(Kernel::SuspendType::Debug); + frontend->Stopped(active_thread); + } + + void ClientData(std::span data) { + const auto actions{frontend->ClientData(data)}; + for (const auto action : actions) { + switch (action) { + case DebuggerAction::Interrupt: { + { + std::scoped_lock lk{connection_lock}; + stopped = true; + } + AllCoreStop(); + active_thread = ThreadList()[0]; + active_thread->Resume(Kernel::SuspendType::Debug); + frontend->Stopped(active_thread); + break; + } + case DebuggerAction::Continue: + stepping = false; + ResumeInactiveThreads(); + AllCoreResume(); + break; + case DebuggerAction::StepThread: + stepping = true; + SuspendInactiveThreads(); + AllCoreResume(); + break; + case DebuggerAction::ShutdownEmulation: { + // Suspend all threads and release any locks held + active_thread->RequestSuspend(Kernel::SuspendType::Debug); + SuspendInactiveThreads(); + AllCoreResume(); + + // Spawn another thread that will exit after shutdown, + // to avoid a deadlock + Core::System* system_ref{&system}; + std::thread t([system_ref] { system_ref->Exit(); }); + t.detach(); + break; + } + } + } + } + + void AllCoreStop() { + if (!suspend) { + suspend = system.StallCPU(); + } + } + + void AllCoreResume() { + stopped = false; + system.UnstallCPU(); + suspend.reset(); + } + + void SuspendInactiveThreads() { + for (auto* thread : ThreadList()) { + if (thread != active_thread) { + thread->RequestSuspend(Kernel::SuspendType::Debug); + } + } + } + + void ResumeInactiveThreads() { + for (auto* thread : ThreadList()) { + if (thread != active_thread) { + thread->Resume(Kernel::SuspendType::Debug); + } + } + } + + const std::vector& ThreadList() { + return system.GlobalSchedulerContext().GetThreadList(); + } + +private: + System& system; + std::unique_ptr frontend; + + std::jthread connection_thread; + std::mutex connection_lock; + boost::asio::io_context io_context; + boost::process::async_pipe signal_pipe; + boost::asio::ip::tcp::socket client_socket; + std::optional> suspend; + + Kernel::KThread* active_thread; + bool stopped; + bool stepping; + + std::array client_data; +}; + +Debugger::Debugger(Core::System& system, u16 port) { + try { + impl = std::make_unique(system, port); + } catch (const std::exception& ex) { + LOG_CRITICAL(Debug_GDBStub, "Failed to initialize debugger: {}", ex.what()); + } +} + +Debugger::~Debugger() = default; + +bool Debugger::NotifyThreadStopped(Kernel::KThread* thread) { + return impl && impl->NotifyThreadStopped(thread); +} + +bool Debugger::IsStepping() const { + return impl && impl->IsStepping(); +} + +} // namespace Core diff --git a/src/core/debugger/debugger.h b/src/core/debugger/debugger.h new file mode 100644 index 000000000..7acd11815 --- /dev/null +++ b/src/core/debugger/debugger.h @@ -0,0 +1,46 @@ +// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include + +#include "common/common_types.h" + +namespace Kernel { +class KThread; +} + +namespace Core { +class System; + +class DebuggerImpl; + +class Debugger { +public: + /** + * Blocks and waits for a connection on localhost, port `server_port`. + * Does not create the debugger if the port is already in use. + */ + explicit Debugger(Core::System& system, u16 server_port); + ~Debugger(); + + /** + * Notify the debugger that the given thread is stopped + * (due to a breakpoint, or due to stopping after a successful step). + * + * The debugger will asynchronously halt emulation after the notification has + * occurred. If another thread attempts to notify before emulation has stopped, + * it is ignored and this method will return false. Otherwise it will return true. + */ + bool NotifyThreadStopped(Kernel::KThread* thread); + + /** + * Returns whether a step is in progress. + */ + bool IsStepping() const; + +private: + std::unique_ptr impl; +}; +} // namespace Core diff --git a/src/core/debugger/debugger_interface.h b/src/core/debugger/debugger_interface.h new file mode 100644 index 000000000..0b357fcb5 --- /dev/null +++ b/src/core/debugger/debugger_interface.h @@ -0,0 +1,74 @@ +// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include +#include +#include + +#include "common/common_types.h" + +namespace Kernel { +class KThread; +} + +namespace Core { + +enum class DebuggerAction { + Interrupt, // Stop emulation as soon as possible. + Continue, // Resume emulation. + StepThread, // Step the currently-active thread. + ShutdownEmulation, // Shut down the emulator. +}; + +class DebuggerBackend { +public: + /** + * Can be invoked from a callback to synchronously wait for more data. + * Will return as soon as least one byte is received. Reads up to 4096 bytes. + */ + virtual std::span ReadFromClient() = 0; + + /** + * Can be invoked from a callback to write data to the client. + * Returns immediately after the data is sent. + */ + virtual void WriteToClient(std::span data) = 0; + + /** + * Gets the currently active thread when the debugger is stopped. + */ + virtual Kernel::KThread* GetActiveThread() = 0; + + /** + * Sets the currently active thread when the debugger is stopped. + */ + virtual void SetActiveThread(Kernel::KThread* thread) = 0; +}; + +class DebuggerFrontend { +public: + explicit DebuggerFrontend(DebuggerBackend& backend_) : backend{backend_} {} + + /** + * Called after the client has successfully connected to the port. + */ + virtual void Connected() = 0; + + /** + * Called when emulation has stopped. + */ + virtual void Stopped(Kernel::KThread* thread) = 0; + + /** + * Called when new data is asynchronously received on the client socket. + * A list of actions to perform is returned. + */ + [[nodiscard]] virtual std::vector ClientData(std::span data) = 0; + +protected: + DebuggerBackend& backend; +}; + +} // namespace Core diff --git a/src/core/debugger/gdbstub.cpp b/src/core/debugger/gdbstub.cpp new file mode 100644 index 000000000..718c45952 --- /dev/null +++ b/src/core/debugger/gdbstub.cpp @@ -0,0 +1,382 @@ +// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include +#include +#include +#include + +#include +#include + +#include "common/hex_util.h" +#include "common/logging/log.h" +#include "common/scope_exit.h" +#include "core/arm/arm_interface.h" +#include "core/core.h" +#include "core/debugger/gdbstub.h" +#include "core/debugger/gdbstub_arch.h" +#include "core/hle/kernel/k_page_table.h" +#include "core/hle/kernel/k_process.h" +#include "core/hle/kernel/k_thread.h" +#include "core/loader/loader.h" +#include "core/memory.h" + +namespace Core { + +constexpr char GDB_STUB_START = '$'; +constexpr char GDB_STUB_END = '#'; +constexpr char GDB_STUB_ACK = '+'; +constexpr char GDB_STUB_NACK = '-'; +constexpr char GDB_STUB_INT3 = 0x03; +constexpr int GDB_STUB_SIGTRAP = 5; + +constexpr char GDB_STUB_REPLY_ERR[] = "E01"; +constexpr char GDB_STUB_REPLY_OK[] = "OK"; +constexpr char GDB_STUB_REPLY_EMPTY[] = ""; + +GDBStub::GDBStub(DebuggerBackend& backend_, Core::System& system_) + : DebuggerFrontend(backend_), system{system_} { + if (system.CurrentProcess()->Is64BitProcess()) { + arch = std::make_unique(); + } else { + arch = std::make_unique(); + } +} + +GDBStub::~GDBStub() = default; + +void GDBStub::Connected() {} + +void GDBStub::Stopped(Kernel::KThread* thread) { + SendReply(arch->ThreadStatus(thread, GDB_STUB_SIGTRAP)); +} + +std::vector GDBStub::ClientData(std::span data) { + std::vector actions; + current_command.insert(current_command.end(), data.begin(), data.end()); + + while (current_command.size() != 0) { + ProcessData(actions); + } + + return actions; +} + +void GDBStub::ProcessData(std::vector& actions) { + const char c{current_command[0]}; + + // Acknowledgement + if (c == GDB_STUB_ACK || c == GDB_STUB_NACK) { + current_command.erase(current_command.begin()); + return; + } + + // Interrupt + if (c == GDB_STUB_INT3) { + LOG_INFO(Debug_GDBStub, "Received interrupt"); + current_command.erase(current_command.begin()); + actions.push_back(DebuggerAction::Interrupt); + SendStatus(GDB_STUB_ACK); + return; + } + + // Otherwise, require the data to be the start of a command + if (c != GDB_STUB_START) { + LOG_ERROR(Debug_GDBStub, "Invalid command buffer contents: {}", current_command.data()); + current_command.clear(); + SendStatus(GDB_STUB_NACK); + return; + } + + // Continue reading until command is complete + while (CommandEnd() == current_command.end()) { + const auto new_data{backend.ReadFromClient()}; + current_command.insert(current_command.end(), new_data.begin(), new_data.end()); + } + + // Execute and respond to GDB + const auto command{DetachCommand()}; + + if (command) { + SendStatus(GDB_STUB_ACK); + ExecuteCommand(*command, actions); + } else { + SendStatus(GDB_STUB_NACK); + } +} + +void GDBStub::ExecuteCommand(std::string_view packet, std::vector& actions) { + LOG_TRACE(Debug_GDBStub, "Executing command: {}", packet); + + if (packet.length() == 0) { + SendReply(GDB_STUB_REPLY_ERR); + return; + } + + std::string_view command{packet.substr(1, packet.size())}; + + switch (packet[0]) { + case 'H': { + Kernel::KThread* thread{nullptr}; + s64 thread_id{strtoll(command.data() + 1, nullptr, 16)}; + if (thread_id >= 1) { + thread = GetThreadByID(thread_id); + } + + if (thread) { + SendReply(GDB_STUB_REPLY_OK); + backend.SetActiveThread(thread); + } else { + SendReply(GDB_STUB_REPLY_ERR); + } + break; + } + case 'T': { + s64 thread_id{strtoll(command.data(), nullptr, 16)}; + if (GetThreadByID(thread_id)) { + SendReply(GDB_STUB_REPLY_OK); + } else { + SendReply(GDB_STUB_REPLY_ERR); + } + break; + } + case 'q': + HandleQuery(command); + break; + case '?': + SendReply(arch->ThreadStatus(backend.GetActiveThread(), GDB_STUB_SIGTRAP)); + break; + case 'k': + LOG_INFO(Debug_GDBStub, "Shutting down emulation"); + actions.push_back(DebuggerAction::ShutdownEmulation); + break; + case 'g': + SendReply(arch->ReadRegisters(backend.GetActiveThread())); + break; + case 'G': + arch->WriteRegisters(backend.GetActiveThread(), command); + SendReply(GDB_STUB_REPLY_OK); + break; + case 'p': { + const size_t reg{static_cast(strtoll(command.data(), nullptr, 16))}; + SendReply(arch->RegRead(backend.GetActiveThread(), reg)); + break; + } + case 'P': { + const auto sep{std::find(command.begin(), command.end(), '=') - command.begin() + 1}; + const size_t reg{static_cast(strtoll(command.data(), nullptr, 16))}; + arch->RegWrite(backend.GetActiveThread(), reg, std::string_view(command).substr(sep)); + break; + } + case 'm': { + const auto sep{std::find(command.begin(), command.end(), ',') - command.begin() + 1}; + const size_t addr{static_cast(strtoll(command.data(), nullptr, 16))}; + const size_t size{static_cast(strtoll(command.data() + sep, nullptr, 16))}; + + if (system.Memory().IsValidVirtualAddressRange(addr, size)) { + std::vector mem(size); + system.Memory().ReadBlock(addr, mem.data(), size); + + SendReply(Common::HexToString(mem)); + } else { + SendReply(GDB_STUB_REPLY_ERR); + } + break; + } + case 'M': { + const auto size_sep{std::find(command.begin(), command.end(), ',') - command.begin() + 1}; + const auto mem_sep{std::find(command.begin(), command.end(), ':') - command.begin() + 1}; + + const size_t addr{static_cast(strtoll(command.data(), nullptr, 16))}; + const size_t size{static_cast(strtoll(command.data() + size_sep, nullptr, 16))}; + + const auto mem_substr{std::string_view(command).substr(mem_sep)}; + const auto mem{Common::HexStringToVector(mem_substr, false)}; + + if (system.Memory().IsValidVirtualAddressRange(addr, size)) { + system.Memory().WriteBlock(addr, mem.data(), size); + system.InvalidateCpuInstructionCacheRange(addr, size); + SendReply(GDB_STUB_REPLY_OK); + } else { + SendReply(GDB_STUB_REPLY_ERR); + } + break; + } + case 's': + actions.push_back(DebuggerAction::StepThread); + break; + case 'C': + case 'c': + actions.push_back(DebuggerAction::Continue); + break; + case 'Z': { + const auto addr_sep{std::find(command.begin(), command.end(), ',') - command.begin() + 1}; + const size_t addr{static_cast(strtoll(command.data() + addr_sep, nullptr, 16))}; + + if (system.Memory().IsValidVirtualAddress(addr)) { + replaced_instructions[addr] = system.Memory().Read32(addr); + system.Memory().Write32(addr, arch->BreakpointInstruction()); + system.InvalidateCpuInstructionCacheRange(addr, sizeof(u32)); + + SendReply(GDB_STUB_REPLY_OK); + } else { + SendReply(GDB_STUB_REPLY_ERR); + } + break; + } + case 'z': { + const auto addr_sep{std::find(command.begin(), command.end(), ',') - command.begin() + 1}; + const size_t addr{static_cast(strtoll(command.data() + addr_sep, nullptr, 16))}; + + const auto orig_insn{replaced_instructions.find(addr)}; + if (system.Memory().IsValidVirtualAddress(addr) && + orig_insn != replaced_instructions.end()) { + system.Memory().Write32(addr, orig_insn->second); + system.InvalidateCpuInstructionCacheRange(addr, sizeof(u32)); + replaced_instructions.erase(addr); + + SendReply(GDB_STUB_REPLY_OK); + } else { + SendReply(GDB_STUB_REPLY_ERR); + } + break; + } + default: + SendReply(GDB_STUB_REPLY_EMPTY); + break; + } +} + +void GDBStub::HandleQuery(std::string_view command) { + if (command.starts_with("TStatus")) { + // no tracepoint support + SendReply("T0"); + } else if (command.starts_with("Supported")) { + SendReply("PacketSize=4000;qXfer:features:read+;qXfer:threads:read+;qXfer:libraries:read+"); + } else if (command.starts_with("Xfer:features:read:target.xml:")) { + const auto offset{command.substr(30)}; + const auto amount{command.substr(command.find(',') + 1)}; + + const auto offset_val{static_cast(strtoll(offset.data(), nullptr, 16))}; + const auto amount_val{static_cast(strtoll(amount.data(), nullptr, 16))}; + const auto target_xml{arch->GetTargetXML()}; + + if (offset_val + amount_val > target_xml.size()) { + SendReply("l" + target_xml.substr(offset_val)); + } else { + SendReply("m" + target_xml.substr(offset_val, amount_val)); + } + } else if (command.starts_with("Offsets")) { + Loader::AppLoader::Modules modules; + system.GetAppLoader().ReadNSOModules(modules); + + const auto main = std::find_if(modules.begin(), modules.end(), + [](const auto& key) { return key.second == "main"; }); + if (main != modules.end()) { + SendReply(fmt::format("TextSeg={:x}", main->first)); + } else { + SendReply(fmt::format("TextSeg={:x}", + system.CurrentProcess()->PageTable().GetCodeRegionStart())); + } + } else if (command.starts_with("fThreadInfo")) { + // beginning of list + const auto& threads = system.GlobalSchedulerContext().GetThreadList(); + std::vector thread_ids; + for (const auto& thread : threads) { + thread_ids.push_back(fmt::format("{:x}", thread->GetThreadID())); + } + SendReply(fmt::format("m{}", fmt::join(thread_ids, ","))); + } else if (command.starts_with("sThreadInfo")) { + // end of list + SendReply("l"); + } else if (command.starts_with("Xfer:threads:read")) { + std::string buffer; + buffer += R"(l)"; + buffer += ""; + + const auto& threads = system.GlobalSchedulerContext().GetThreadList(); + for (const auto& thread : threads) { + buffer += + fmt::format(R"()", + thread->GetThreadID(), thread->GetActiveCore(), thread->GetThreadID()); + } + + buffer += ""; + SendReply(buffer); + } else { + SendReply(GDB_STUB_REPLY_EMPTY); + } +} + +Kernel::KThread* GDBStub::GetThreadByID(u64 thread_id) { + const auto& threads{system.GlobalSchedulerContext().GetThreadList()}; + for (auto* thread : threads) { + if (thread->GetThreadID() == thread_id) { + return thread; + } + } + + return nullptr; +} + +std::vector::const_iterator GDBStub::CommandEnd() const { + // Find the end marker + const auto end{std::find(current_command.begin(), current_command.end(), GDB_STUB_END)}; + + // Require the checksum to be present + return std::min(end + 2, current_command.end()); +} + +std::optional GDBStub::DetachCommand() { + // Slice the string part from the beginning to the end marker + const auto end{CommandEnd()}; + + // Extract possible command data + std::string data(current_command.data(), end - current_command.begin() + 1); + + // Shift over the remaining contents + current_command.erase(current_command.begin(), end + 1); + + // Validate received command + if (data[0] != GDB_STUB_START) { + LOG_ERROR(Debug_GDBStub, "Invalid start data: {}", data[0]); + return std::nullopt; + } + + u8 calculated = CalculateChecksum(std::string_view(data).substr(1, data.size() - 4)); + u8 received = static_cast(strtoll(data.data() + data.size() - 2, nullptr, 16)); + + // Verify checksum + if (calculated != received) { + LOG_ERROR(Debug_GDBStub, "Checksum mismatch: calculated {:02x}, received {:02x}", + calculated, received); + return std::nullopt; + } + + return data.substr(1, data.size() - 4); +} + +u8 GDBStub::CalculateChecksum(std::string_view data) { + return static_cast( + std::accumulate(data.begin(), data.end(), u8{0}, [](u8 lhs, u8 rhs) { return lhs + rhs; })); +} + +void GDBStub::SendReply(std::string_view data) { + const auto output{ + fmt::format("{}{}{}{:02x}", GDB_STUB_START, data, GDB_STUB_END, CalculateChecksum(data))}; + LOG_TRACE(Debug_GDBStub, "Writing reply: {}", output); + + // C++ string support is complete rubbish + const u8* output_begin = reinterpret_cast(output.data()); + const u8* output_end = output_begin + output.size(); + backend.WriteToClient(std::span(output_begin, output_end)); +} + +void GDBStub::SendStatus(char status) { + std::array buf = {static_cast(status)}; + LOG_TRACE(Debug_GDBStub, "Writing status: {}", status); + backend.WriteToClient(buf); +} + +} // namespace Core diff --git a/src/core/debugger/gdbstub.h b/src/core/debugger/gdbstub.h new file mode 100644 index 000000000..b93a3a511 --- /dev/null +++ b/src/core/debugger/gdbstub.h @@ -0,0 +1,47 @@ +// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include +#include +#include +#include +#include + +#include "core/debugger/debugger_interface.h" +#include "core/debugger/gdbstub_arch.h" + +namespace Core { + +class System; + +class GDBStub : public DebuggerFrontend { +public: + explicit GDBStub(DebuggerBackend& backend, Core::System& system); + ~GDBStub(); + + void Connected() override; + void Stopped(Kernel::KThread* thread) override; + std::vector ClientData(std::span data) override; + +private: + void ProcessData(std::vector& actions); + void ExecuteCommand(std::string_view packet, std::vector& actions); + void HandleQuery(std::string_view command); + std::vector::const_iterator CommandEnd() const; + std::optional DetachCommand(); + Kernel::KThread* GetThreadByID(u64 thread_id); + + static u8 CalculateChecksum(std::string_view data); + void SendReply(std::string_view data); + void SendStatus(char status); + +private: + Core::System& system; + std::unique_ptr arch; + std::vector current_command; + std::map replaced_instructions; +}; + +} // namespace Core diff --git a/src/core/debugger/gdbstub_arch.cpp b/src/core/debugger/gdbstub_arch.cpp new file mode 100644 index 000000000..99e3893a9 --- /dev/null +++ b/src/core/debugger/gdbstub_arch.cpp @@ -0,0 +1,406 @@ +// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "common/hex_util.h" +#include "core/debugger/gdbstub_arch.h" +#include "core/hle/kernel/k_thread.h" + +namespace Core { + +template +static T HexToValue(std::string_view hex) { + static_assert(std::is_trivially_copyable_v); + T value{}; + const auto mem{Common::HexStringToVector(hex, false)}; + std::memcpy(&value, mem.data(), std::min(mem.size(), sizeof(T))); + return value; +} + +template +static std::string ValueToHex(const T value) { + static_assert(std::is_trivially_copyable_v); + std::array mem{}; + std::memcpy(mem.data(), &value, sizeof(T)); + return Common::HexToString(mem); +} + +template +static T GetSIMDRegister(const std::array& simd_regs, size_t offset) { + static_assert(std::is_trivially_copyable_v); + T value{}; + std::memcpy(&value, reinterpret_cast(simd_regs.data()) + sizeof(T) * offset, + sizeof(T)); + return value; +} + +template +static void PutSIMDRegister(std::array& simd_regs, size_t offset, const T value) { + static_assert(std::is_trivially_copyable_v); + std::memcpy(reinterpret_cast(simd_regs.data()) + sizeof(T) * offset, &value, sizeof(T)); +} + +// For sample XML files see the GDB source /gdb/features +// This XML defines what the registers are for this specific ARM device +std::string GDBStubA64::GetTargetXML() const { + constexpr const char* target_xml = + R"( + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +)"; + + return target_xml; +} + +std::string GDBStubA64::RegRead(const Kernel::KThread* thread, size_t id) const { + if (!thread) { + return ""; + } + + const auto& context{thread->GetContext64()}; + const auto& gprs{context.cpu_registers}; + const auto& fprs{context.vector_registers}; + + if (id <= SP_REGISTER) { + return ValueToHex(gprs[id]); + } else if (id == PC_REGISTER) { + return ValueToHex(context.pc); + } else if (id == PSTATE_REGISTER) { + return ValueToHex(context.pstate); + } else if (id >= Q0_REGISTER && id < FPCR_REGISTER) { + return ValueToHex(fprs[id - Q0_REGISTER]); + } else if (id == FPCR_REGISTER) { + return ValueToHex(context.fpcr); + } else if (id == FPSR_REGISTER) { + return ValueToHex(context.fpsr); + } else { + return ""; + } +} + +void GDBStubA64::RegWrite(Kernel::KThread* thread, size_t id, std::string_view value) const { + if (!thread) { + return; + } + + auto& context{thread->GetContext64()}; + + if (id <= SP_REGISTER) { + context.cpu_registers[id] = HexToValue(value); + } else if (id == PC_REGISTER) { + context.pc = HexToValue(value); + } else if (id == PSTATE_REGISTER) { + context.pstate = HexToValue(value); + } else if (id >= Q0_REGISTER && id < FPCR_REGISTER) { + context.vector_registers[id - Q0_REGISTER] = HexToValue(value); + } else if (id == FPCR_REGISTER) { + context.fpcr = HexToValue(value); + } else if (id == FPSR_REGISTER) { + context.fpsr = HexToValue(value); + } +} + +std::string GDBStubA64::ReadRegisters(const Kernel::KThread* thread) const { + std::string output; + + for (size_t reg = 0; reg <= FPCR_REGISTER; reg++) { + output += RegRead(thread, reg); + } + + return output; +} + +void GDBStubA64::WriteRegisters(Kernel::KThread* thread, std::string_view register_data) const { + for (size_t i = 0, reg = 0; reg <= FPCR_REGISTER; reg++) { + if (reg <= SP_REGISTER || reg == PC_REGISTER) { + RegWrite(thread, reg, register_data.substr(i, 16)); + i += 16; + } else if (reg == PSTATE_REGISTER || reg == FPCR_REGISTER || reg == FPSR_REGISTER) { + RegWrite(thread, reg, register_data.substr(i, 8)); + i += 8; + } else if (reg >= Q0_REGISTER && reg < FPCR_REGISTER) { + RegWrite(thread, reg, register_data.substr(i, 32)); + i += 32; + } + } +} + +std::string GDBStubA64::ThreadStatus(const Kernel::KThread* thread, u8 signal) const { + return fmt::format("T{:02x}{:02x}:{};{:02x}:{};{:02x}:{};thread:{:x};", signal, PC_REGISTER, + RegRead(thread, PC_REGISTER), SP_REGISTER, RegRead(thread, SP_REGISTER), + LR_REGISTER, RegRead(thread, LR_REGISTER), thread->GetThreadID()); +} + +u32 GDBStubA64::BreakpointInstruction() const { + // A64: brk #0 + return 0xd4200000; +} + +std::string GDBStubA32::GetTargetXML() const { + constexpr const char* target_xml = + R"( + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +)"; + + return target_xml; +} + +std::string GDBStubA32::RegRead(const Kernel::KThread* thread, size_t id) const { + if (!thread) { + return ""; + } + + const auto& context{thread->GetContext32()}; + const auto& gprs{context.cpu_registers}; + const auto& fprs{context.extension_registers}; + + if (id <= PC_REGISTER) { + return ValueToHex(gprs[id]); + } else if (id == CPSR_REGISTER) { + return ValueToHex(context.cpsr); + } else if (id >= D0_REGISTER && id < Q0_REGISTER) { + const u64 dN{GetSIMDRegister(fprs, id - D0_REGISTER)}; + return ValueToHex(dN); + } else if (id >= Q0_REGISTER && id < FPSCR_REGISTER) { + const u128 qN{GetSIMDRegister(fprs, id - Q0_REGISTER)}; + return ValueToHex(qN); + } else if (id == FPSCR_REGISTER) { + return ValueToHex(context.fpscr); + } else { + return ""; + } +} + +void GDBStubA32::RegWrite(Kernel::KThread* thread, size_t id, std::string_view value) const { + if (!thread) { + return; + } + + auto& context{thread->GetContext32()}; + auto& fprs{context.extension_registers}; + + if (id <= PC_REGISTER) { + context.cpu_registers[id] = HexToValue(value); + } else if (id == CPSR_REGISTER) { + context.cpsr = HexToValue(value); + } else if (id >= D0_REGISTER && id < Q0_REGISTER) { + PutSIMDRegister(fprs, id - D0_REGISTER, HexToValue(value)); + } else if (id >= Q0_REGISTER && id < FPSCR_REGISTER) { + PutSIMDRegister(fprs, id - Q0_REGISTER, HexToValue(value)); + } else if (id == FPSCR_REGISTER) { + context.fpscr = HexToValue(value); + } +} + +std::string GDBStubA32::ReadRegisters(const Kernel::KThread* thread) const { + std::string output; + + for (size_t reg = 0; reg <= FPSCR_REGISTER; reg++) { + const bool gpr{reg <= PC_REGISTER}; + const bool dfpr{reg >= D0_REGISTER && reg < Q0_REGISTER}; + const bool qfpr{reg >= Q0_REGISTER && reg < FPSCR_REGISTER}; + + if (!(gpr || dfpr || qfpr || reg == CPSR_REGISTER || reg == FPSCR_REGISTER)) { + continue; + } + + output += RegRead(thread, reg); + } + + return output; +} + +void GDBStubA32::WriteRegisters(Kernel::KThread* thread, std::string_view register_data) const { + for (size_t i = 0, reg = 0; reg <= FPSCR_REGISTER; reg++) { + const bool gpr{reg <= PC_REGISTER}; + const bool dfpr{reg >= D0_REGISTER && reg < Q0_REGISTER}; + const bool qfpr{reg >= Q0_REGISTER && reg < FPSCR_REGISTER}; + + if (gpr || reg == CPSR_REGISTER || reg == FPSCR_REGISTER) { + RegWrite(thread, reg, register_data.substr(i, 8)); + i += 8; + } else if (dfpr) { + RegWrite(thread, reg, register_data.substr(i, 16)); + i += 16; + } else if (qfpr) { + RegWrite(thread, reg, register_data.substr(i, 32)); + i += 32; + } + + if (reg == PC_REGISTER) { + reg = CPSR_REGISTER - 1; + } else if (reg == CPSR_REGISTER) { + reg = D0_REGISTER - 1; + } + } +} + +std::string GDBStubA32::ThreadStatus(const Kernel::KThread* thread, u8 signal) const { + return fmt::format("T{:02x}{:02x}:{};{:02x}:{};{:02x}:{};thread:{:x};", signal, PC_REGISTER, + RegRead(thread, PC_REGISTER), SP_REGISTER, RegRead(thread, SP_REGISTER), + LR_REGISTER, RegRead(thread, LR_REGISTER), thread->GetThreadID()); +} + +u32 GDBStubA32::BreakpointInstruction() const { + // A32: trap + // T32: trap + b #4 + return 0xe7ffdefe; +} + +} // namespace Core diff --git a/src/core/debugger/gdbstub_arch.h b/src/core/debugger/gdbstub_arch.h new file mode 100644 index 000000000..e943848e5 --- /dev/null +++ b/src/core/debugger/gdbstub_arch.h @@ -0,0 +1,67 @@ +// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include + +#include "common/common_types.h" + +namespace Kernel { +class KThread; +} + +namespace Core { + +class GDBStubArch { +public: + virtual std::string GetTargetXML() const = 0; + virtual std::string RegRead(const Kernel::KThread* thread, size_t id) const = 0; + virtual void RegWrite(Kernel::KThread* thread, size_t id, std::string_view value) const = 0; + virtual std::string ReadRegisters(const Kernel::KThread* thread) const = 0; + virtual void WriteRegisters(Kernel::KThread* thread, std::string_view register_data) const = 0; + virtual std::string ThreadStatus(const Kernel::KThread* thread, u8 signal) const = 0; + virtual u32 BreakpointInstruction() const = 0; +}; + +class GDBStubA64 final : public GDBStubArch { +public: + std::string GetTargetXML() const override; + std::string RegRead(const Kernel::KThread* thread, size_t id) const override; + void RegWrite(Kernel::KThread* thread, size_t id, std::string_view value) const override; + std::string ReadRegisters(const Kernel::KThread* thread) const override; + void WriteRegisters(Kernel::KThread* thread, std::string_view register_data) const override; + std::string ThreadStatus(const Kernel::KThread* thread, u8 signal) const override; + u32 BreakpointInstruction() const override; + +private: + static constexpr u32 LR_REGISTER = 30; + static constexpr u32 SP_REGISTER = 31; + static constexpr u32 PC_REGISTER = 32; + static constexpr u32 PSTATE_REGISTER = 33; + static constexpr u32 Q0_REGISTER = 34; + static constexpr u32 FPCR_REGISTER = 66; + static constexpr u32 FPSR_REGISTER = 67; +}; + +class GDBStubA32 final : public GDBStubArch { +public: + std::string GetTargetXML() const override; + std::string RegRead(const Kernel::KThread* thread, size_t id) const override; + void RegWrite(Kernel::KThread* thread, size_t id, std::string_view value) const override; + std::string ReadRegisters(const Kernel::KThread* thread) const override; + void WriteRegisters(Kernel::KThread* thread, std::string_view register_data) const override; + std::string ThreadStatus(const Kernel::KThread* thread, u8 signal) const override; + u32 BreakpointInstruction() const override; + +private: + static constexpr u32 SP_REGISTER = 13; + static constexpr u32 LR_REGISTER = 14; + static constexpr u32 PC_REGISTER = 15; + static constexpr u32 CPSR_REGISTER = 25; + static constexpr u32 D0_REGISTER = 32; + static constexpr u32 Q0_REGISTER = 64; + static constexpr u32 FPSCR_REGISTER = 80; +}; + +} // namespace Core -- cgit v1.2.3