From 31dee93e849d79a91f280faf16941806e3cb3c6b Mon Sep 17 00:00:00 2001 From: polaris- Date: Wed, 2 Sep 2015 08:56:38 -0400 Subject: Implement gdbstub --- src/core/CMakeLists.txt | 2 + src/core/arm/dyncom/arm_dyncom_interpreter.cpp | 41 +- src/core/arm/skyeye_common/armstate.cpp | 35 + src/core/arm/skyeye_common/armstate.h | 2 + src/core/core.cpp | 17 + src/core/gdbstub/gdbstub.cpp | 940 +++++++++++++++++++++++++ src/core/gdbstub/gdbstub.h | 89 +++ src/core/settings.h | 5 + src/core/system.cpp | 6 + 9 files changed, 1128 insertions(+), 9 deletions(-) create mode 100644 src/core/gdbstub/gdbstub.cpp create mode 100644 src/core/gdbstub/gdbstub.h (limited to 'src/core') diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index c17290b9b..861b711c7 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -22,6 +22,7 @@ set(SRCS file_sys/archive_systemsavedata.cpp file_sys/disk_archive.cpp file_sys/ivfc_archive.cpp + gdbstub/gdbstub.cpp hle/config_mem.cpp hle/hle.cpp hle/applets/applet.cpp @@ -149,6 +150,7 @@ set(HEADERS file_sys/disk_archive.h file_sys/file_backend.h file_sys/ivfc_archive.h + gdbstub/gdbstub.h hle/config_mem.h hle/function_wrappers.h hle/hle.h diff --git a/src/core/arm/dyncom/arm_dyncom_interpreter.cpp b/src/core/arm/dyncom/arm_dyncom_interpreter.cpp index fbd6f94f9..8293f4c60 100644 --- a/src/core/arm/dyncom/arm_dyncom_interpreter.cpp +++ b/src/core/arm/dyncom/arm_dyncom_interpreter.cpp @@ -23,6 +23,8 @@ #include "core/arm/skyeye_common/armsupp.h" #include "core/arm/skyeye_common/vfp/vfp.h" +#include "core/gdbstub/gdbstub.h" + Common::Profiling::TimingCategory profile_execute("DynCom::Execute"); Common::Profiling::TimingCategory profile_decode("DynCom::Decode"); @@ -3548,6 +3550,7 @@ static int InterpreterTranslate(ARMul_State* cpu, int& bb_start, u32 addr) { CITRA_IGNORE_EXIT(-1); } inst_base = arm_instruction_trans[idx](inst, idx); + translated: phys_addr += inst_size; @@ -3580,6 +3583,8 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) { Common::Profiling::ScopeTimer timer_execute(profile_execute); MICROPROFILE_SCOPE(DynCom_Execute); + int breakpoint_offset = -1; + #undef RM #undef RS @@ -3604,15 +3609,27 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) { #define INC_PC(l) ptr += sizeof(arm_inst) + l #define INC_PC_STUB ptr += sizeof(arm_inst) +#define GDB_BP_CHECK \ + cpu->Cpsr &= ~(1 << 5); \ + cpu->Cpsr |= cpu->TFlag << 5; \ + if (GDBStub::g_server_enabled) { \ + if (GDBStub::IsMemoryBreak() || PC == breakpoint_offset) { \ + GDBStub::Break(); \ + goto END; \ + } \ + } + // GCC and Clang have a C++ extension to support a lookup table of labels. Otherwise, fallback to a // clunky switch statement. #if defined __GNUC__ || defined __clang__ #define GOTO_NEXT_INST \ + GDB_BP_CHECK; \ if (num_instrs >= cpu->NumInstrsToExecute) goto END; \ num_instrs++; \ goto *InstLabel[inst_base->idx] #else #define GOTO_NEXT_INST \ + GDB_BP_CHECK; \ if (num_instrs >= cpu->NumInstrsToExecute) goto END; \ num_instrs++; \ switch(inst_base->idx) { \ @@ -3878,6 +3895,7 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) { unsigned int addr; unsigned int num_instrs = 0; + int ptr; LOAD_NZCVT; @@ -3903,6 +3921,11 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) { goto END; } + // Find breakpoint if one exists within the block + if (GDBStub::g_server_enabled && GDBStub::IsConnected()) { + breakpoint_offset = GDBStub::GetNextBreakpointFromAddress(cpu->Reg[15], GDBStub::BreakpointType::Execute); + } + inst_base = (arm_inst *)&inst_buf[ptr]; GOTO_NEXT_INST; } @@ -4454,7 +4477,7 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) { ldst_inst* inst_cream = (ldst_inst*)inst_base->component; inst_cream->get_addr(cpu, inst_cream->inst, addr); - cpu->Reg[BITS(inst_cream->inst, 12, 15)] = Memory::Read8(addr); + cpu->Reg[BITS(inst_cream->inst, 12, 15)] = cpu->ReadMemory8(addr); if (BITS(inst_cream->inst, 12, 15) == 15) { INC_PC(sizeof(ldst_inst)); @@ -4472,7 +4495,7 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) { ldst_inst* inst_cream = (ldst_inst*)inst_base->component; inst_cream->get_addr(cpu, inst_cream->inst, addr); - cpu->Reg[BITS(inst_cream->inst, 12, 15)] = Memory::Read8(addr); + cpu->Reg[BITS(inst_cream->inst, 12, 15)] = cpu->ReadMemory8(addr); if (BITS(inst_cream->inst, 12, 15) == 15) { INC_PC(sizeof(ldst_inst)); @@ -4531,7 +4554,7 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) { cpu->SetExclusiveMemoryAddress(read_addr); - RD = Memory::Read8(read_addr); + RD = cpu->ReadMemory8(read_addr); if (inst_cream->Rd == 15) { INC_PC(sizeof(generic_arm_inst)); goto DISPATCH; @@ -4604,7 +4627,7 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) { if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) { ldst_inst* inst_cream = (ldst_inst*)inst_base->component; inst_cream->get_addr(cpu, inst_cream->inst, addr); - unsigned int value = Memory::Read8(addr); + unsigned int value = cpu->ReadMemory8(addr); if (BIT(value, 7)) { value |= 0xffffff00; } @@ -6027,7 +6050,7 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) { ldst_inst* inst_cream = (ldst_inst*)inst_base->component; inst_cream->get_addr(cpu, inst_cream->inst, addr); unsigned int value = cpu->Reg[BITS(inst_cream->inst, 12, 15)] & 0xff; - Memory::Write8(addr, value); + cpu->WriteMemory8(addr, value); } cpu->Reg[15] += cpu->GetInstructionSize(); INC_PC(sizeof(ldst_inst)); @@ -6040,7 +6063,7 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) { ldst_inst* inst_cream = (ldst_inst*)inst_base->component; inst_cream->get_addr(cpu, inst_cream->inst, addr); unsigned int value = cpu->Reg[BITS(inst_cream->inst, 12, 15)] & 0xff; - Memory::Write8(addr, value); + cpu->WriteMemory8(addr, value); } cpu->Reg[15] += cpu->GetInstructionSize(); INC_PC(sizeof(ldst_inst)); @@ -6091,7 +6114,7 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) { if (cpu->IsExclusiveMemoryAccess(write_addr)) { cpu->UnsetExclusiveMemoryAddress(); - Memory::Write8(write_addr, cpu->Reg[inst_cream->Rm]); + cpu->WriteMemory8(write_addr, cpu->Reg[inst_cream->Rm]); RD = 0; } else { // Failed to write due to mutex access @@ -6250,8 +6273,8 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) { if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) { swp_inst* inst_cream = (swp_inst*)inst_base->component; addr = RN; - unsigned int value = Memory::Read8(addr); - Memory::Write8(addr, (RM & 0xFF)); + unsigned int value = cpu->ReadMemory8(addr); + cpu->WriteMemory8(addr, (RM & 0xFF)); RD = value; } cpu->Reg[15] += cpu->GetInstructionSize(); diff --git a/src/core/arm/skyeye_common/armstate.cpp b/src/core/arm/skyeye_common/armstate.cpp index 0491717dc..2d814345a 100644 --- a/src/core/arm/skyeye_common/armstate.cpp +++ b/src/core/arm/skyeye_common/armstate.cpp @@ -7,6 +7,7 @@ #include "core/memory.h" #include "core/arm/skyeye_common/armstate.h" #include "core/arm/skyeye_common/vfp/vfp.h" +#include "core/gdbstub/gdbstub.h" ARMul_State::ARMul_State(PrivilegeMode initial_mode) { @@ -185,8 +186,25 @@ void ARMul_State::ResetMPCoreCP15Registers() CP15[CP15_TLB_DEBUG_CONTROL] = 0x00000000; } +static void CheckMemoryBreakpoint(u32 address, GDBStub::BreakpointType type) +{ + if (GDBStub::g_server_enabled && GDBStub::CheckBreakpoint(address, type)) { + LOG_DEBUG(Debug, "Found memory breakpoint @ %08x", address); + GDBStub::Break(true); + } +} + +u8 ARMul_State::ReadMemory8(u32 address) const +{ + CheckMemoryBreakpoint(address, GDBStub::BreakpointType::Read); + + return Memory::Read8(address); +} + u16 ARMul_State::ReadMemory16(u32 address) const { + CheckMemoryBreakpoint(address, GDBStub::BreakpointType::Read); + u16 data = Memory::Read16(address); if (InBigEndianMode()) @@ -197,6 +215,8 @@ u16 ARMul_State::ReadMemory16(u32 address) const u32 ARMul_State::ReadMemory32(u32 address) const { + CheckMemoryBreakpoint(address, GDBStub::BreakpointType::Read); + u32 data = Memory::Read32(address); if (InBigEndianMode()) @@ -207,6 +227,8 @@ u32 ARMul_State::ReadMemory32(u32 address) const u64 ARMul_State::ReadMemory64(u32 address) const { + CheckMemoryBreakpoint(address, GDBStub::BreakpointType::Read); + u64 data = Memory::Read64(address); if (InBigEndianMode()) @@ -215,8 +237,17 @@ u64 ARMul_State::ReadMemory64(u32 address) const return data; } +void ARMul_State::WriteMemory8(u32 address, u8 data) +{ + CheckMemoryBreakpoint(address, GDBStub::BreakpointType::Write); + + Memory::Write8(address, data); +} + void ARMul_State::WriteMemory16(u32 address, u16 data) { + CheckMemoryBreakpoint(address, GDBStub::BreakpointType::Write); + if (InBigEndianMode()) data = Common::swap16(data); @@ -225,6 +256,8 @@ void ARMul_State::WriteMemory16(u32 address, u16 data) void ARMul_State::WriteMemory32(u32 address, u32 data) { + CheckMemoryBreakpoint(address, GDBStub::BreakpointType::Write); + if (InBigEndianMode()) data = Common::swap32(data); @@ -233,6 +266,8 @@ void ARMul_State::WriteMemory32(u32 address, u32 data) void ARMul_State::WriteMemory64(u32 address, u64 data) { + CheckMemoryBreakpoint(address, GDBStub::BreakpointType::Write); + if (InBigEndianMode()) data = Common::swap64(data); diff --git a/src/core/arm/skyeye_common/armstate.h b/src/core/arm/skyeye_common/armstate.h index ceb159d14..98dad9b1f 100644 --- a/src/core/arm/skyeye_common/armstate.h +++ b/src/core/arm/skyeye_common/armstate.h @@ -153,9 +153,11 @@ public: // Reads/writes data in big/little endian format based on the // state of the E (endian) bit in the APSR. + u8 ReadMemory8(u32 address) const; u16 ReadMemory16(u32 address) const; u32 ReadMemory32(u32 address) const; u64 ReadMemory64(u32 address) const; + void WriteMemory8(u32 address, u8 data); void WriteMemory16(u32 address, u16 data); void WriteMemory32(u32 address, u32 data); void WriteMemory64(u32 address, u64 data); diff --git a/src/core/core.cpp b/src/core/core.cpp index dddc16708..219b03af4 100644 --- a/src/core/core.cpp +++ b/src/core/core.cpp @@ -13,6 +13,8 @@ #include "core/hle/kernel/thread.h" #include "core/hw/hw.h" +#include "core/gdbstub/gdbstub.h" + namespace Core { ARM_Interface* g_app_core = nullptr; ///< ARM11 application core @@ -20,6 +22,21 @@ ARM_Interface* g_sys_core = nullptr; ///< ARM11 system (OS) core /// Run the core CPU loop void RunLoop(int tight_loop) { + if (GDBStub::g_server_enabled) { + GDBStub::HandlePacket(); + + // If the loop is halted and we want to step, use a tiny (1) number of instructions to execute. + // Otherwise get out of the loop function. + if (GDBStub::GetCpuHaltFlag()) { + if (GDBStub::GetCpuStepFlag()) { + GDBStub::SetCpuStepFlag(false); + tight_loop = 1; + } else { + return; + } + } + } + // If we don't have a currently active thread then don't execute instructions, // instead advance to the next event and try to yield to the next thread if (Kernel::GetCurrentThread() == nullptr) { diff --git a/src/core/gdbstub/gdbstub.cpp b/src/core/gdbstub/gdbstub.cpp new file mode 100644 index 000000000..ced1c54f5 --- /dev/null +++ b/src/core/gdbstub/gdbstub.cpp @@ -0,0 +1,940 @@ +// Copyright 2013 Dolphin Emulator Project +// Licensed under GPLv2+ +// Refer to the license.txt file included. + +// Originally written by Sven Peter for anergistic. + +#include +#include +#include +#include +#include +#include +#include + +#ifdef _MSC_VER +#include +#include +#include +#include +#include +#define SHUT_RDWR 2 +#else +#include +#include +#include +#include +#include +#endif + +#include "common/logging/log.h" +#include "common/string_util.h" +#include +#include "core/core.h" +#include "core/memory.h" +#include "gdbstub.h" + +const int GDB_BUFFER_SIZE = 10000; + +const char GDB_STUB_START = '$'; +const char GDB_STUB_END = '#'; +const char GDB_STUB_ACK = '+'; +const char GDB_STUB_NACK = '-'; + +#ifndef SIGTRAP +const u32 SIGTRAP = 5; +#endif + +#ifndef SIGTERM +const u32 SIGTERM = 15; +#endif + +#ifndef MSG_WAITALL +const u32 MSG_WAITALL = 8; +#endif + +const u32 R0_REGISTER = 0; +const u32 R15_REGISTER = 15; +const u32 CSPR_REGISTER = 25; + +namespace GDBStub { + +static int gdbserver_socket = -1; + +static u8 command_buffer[GDB_BUFFER_SIZE]; +static u32 command_length; + +static u32 latest_signal = 0; +static u32 send_signal = 0; +static u32 step_break = 0; +static bool memory_break = false; + +// Binding to a port within the reserved ports range (0-1023) requires root permissions, +// so default to a port outside of that range. +static u16 gdbstub_port = 24689; + +static bool halt_loop = true; +static bool step_loop = false; +std::atomic g_server_enabled(false); + +#ifdef _WIN32 +WSADATA InitData; +#endif + +struct Breakpoint { + bool active; + PAddr addr; + u32 len; +}; + +static std::map breakpoints_execute; +static std::map breakpoints_read; +static std::map breakpoints_write; + +/** + * Turns hex string character into the equivalent byte. + * + * @param hex Input hex character to be turned into byte. + */ +static u8 HexCharToValue(u8 hex) { + if (hex >= '0' && hex <= '9') { + return hex - '0'; + } else if (hex >= 'a' && hex <= 'f') { + return hex - 'a' + 0xA; + } else if (hex >= 'A' && hex <= 'F') { + return hex - 'A' + 0xA; + } + + LOG_ERROR(Debug_GDBStub, "Invalid nibble: %c (%02x)\n", hex, hex); + return 0; +} + +/** + * Turn nibble of byte into hex string character. + * + * @param n Nibble to be turned into hex character. + */ +static u8 NibbleToHex(u8 n) { + n &= 0xF; + if (n < 0xA) { + return '0' + n; + } else { + return 'A' + n - 0xA; + } +} + +/** + * Converts input array of u8 bytes into their equivalent hex string characters. + * + * @param dest Pointer to buffer to store output hex string characters. + * @param src Pointer to array of u8 bytes. + * @param len Length of src array. + */ +static void MemToHex(u8* dest, u8* src, u32 len) { + while (len-- > 0) { + u8 tmp = *src++; + *dest++ = NibbleToHex(tmp >> 4); + *dest++ = NibbleToHex(tmp); + } +} + +/** + * Converts input hex string characters into an array of equivalent of u8 bytes. + * + * @param dest Pointer to buffer to store u8 bytes. + * @param src Pointer to array of output hex string characters. + * @param len Length of src array. + */ +static void HexToMem(u8* dest, u8* src, u32 len) { + while (len-- > 0) { + *dest++ = (HexCharToValue(src[0]) << 4) | HexCharToValue(src[1]); + src += 2; + } +} + +/** + * Convert a u32 into a hex string. + * + * @param dest Pointer to buffer to store output hex string characters. + */ +static void IntToHex(u8* dest, u32 v) { + for (int i = 0; i < 8; i += 2) { + dest[i + 1] = NibbleToHex(v >> (4 * i)); + dest[i] = NibbleToHex(v >> (4 * (i + 1))); + } +} + +/** + * Convert a hex string into a u32. + * + * @param src Pointer to hex string. + */ +static u32 HexToInt(u8* src) { + u32 output = 0; + + for (int i = 0; i < 8; i += 2) { + output = (output << 4) | HexCharToValue(src[7 - i - 1]); + output = (output << 4) | HexCharToValue(src[7 - i]); + } + + return output; +} + +/// Read a byte from the gdb client. +static u8 ReadByte() { + u8 c; + size_t received_size = recv(gdbserver_socket, reinterpret_cast(&c), 1, MSG_WAITALL); + if (received_size != 1) { + LOG_ERROR(Debug_GDBStub, "recv failed : %ld", received_size); + Deinit(); + } + + return c; +} + +/// Calculate the checksum of the current command buffer. +static u8 CalculateChecksum(u8 *buffer, u32 length) { + return static_cast(std::accumulate(buffer, buffer + length, 0, std::plus())); +} + +/** + * Get the list of breakpoints for a given breakpoint type. + * + * @param type Type of breakpoint list. + */ +static std::map& GetBreakpointList(BreakpointType type) { + switch (type) { + case BreakpointType::Execute: + return breakpoints_execute; + case BreakpointType::Read: + return breakpoints_read; + case BreakpointType::Write: + return breakpoints_write; + default: + return breakpoints_read; + } +} + +/** + * Remove the breakpoint from the given address of the specified type. + * + * @param type Type of breakpoint. + * @param addr Address of breakpoint. + */ +static void RemoveBreakpoint(BreakpointType type, PAddr addr) { + std::map& p = GetBreakpointList(type); + + auto bp = p.find(addr); + if (bp != p.end()) { + LOG_DEBUG(Debug_GDBStub, "gdb: removed a breakpoint: %08x bytes at %08x of type %d\n", bp->second.len, bp->second.addr, type); + p.erase(addr); + } +} + +PAddr GetNextBreakpointFromAddress(PAddr addr, BreakpointType type) { + std::map& p = GetBreakpointList(type); + auto next_breakpoint = p.lower_bound(addr); + u32 breakpoint = -1; + + if (next_breakpoint != p.end()) + breakpoint = next_breakpoint->first; + + return breakpoint; +} + +bool CheckBreakpoint(PAddr addr, BreakpointType type) { + if (!IsConnected()) { + return false; + } + + std::map& p = GetBreakpointList(type); + + auto bp = p.find(addr); + if (bp != p.end()) { + u32 len = bp->second.len; + + // IDA Pro defaults to 4-byte breakpoints for all non-hardware breakpoints + // no matter if it's a 4-byte or 2-byte instruction. When you execute a + // Thumb instruction with a 4-byte breakpoint set, it will set a breakpoint on + // two instructions instead of the single instruction you placed the breakpoint + // on. So, as a way to make sure that execution breakpoints are only breaking + // on the instruction that was specified, set the length of an execution + // breakpoint to 1. This should be fine since the CPU should never begin executing + // an instruction anywhere except the beginning of the instruction. + if (type == BreakpointType::Execute) { + len = 1; + } + + if (bp->second.active && (addr >= bp->second.addr && addr < bp->second.addr + len)) { + LOG_DEBUG(Debug_GDBStub, "Found breakpoint type %d @ %08x, range: %08x - %08x (%d bytes)\n", type, addr, bp->second.addr, bp->second.addr + len, len); + return true; + } + } + + return false; +} + +/** + * Send packet to gdb client. + * + * @param packet Packet to be sent to client. + */ +static void SendPacket(const char packet) { + size_t sent_size = send(gdbserver_socket, &packet, 1, 0); + if (sent_size != 1) { + LOG_ERROR(Debug_GDBStub, "send failed"); + } +} + +/** + * Send reply to gdb client. + * + * @param reply Reply to be sent to client. + */ +static void SendReply(const char* reply) { + if (!IsConnected()) { + return; + } + + memset(command_buffer, 0, sizeof(command_buffer)); + + command_length = strlen(reply); + if (command_length + 4 > sizeof(command_buffer)) { + LOG_ERROR(Debug_GDBStub, "command_buffer overflow in SendReply"); + } + + memcpy(command_buffer + 1, reply, command_length); + + u8 checksum = CalculateChecksum(command_buffer, command_length + 1); + command_buffer[0] = GDB_STUB_START; + command_buffer[command_length + 1] = GDB_STUB_END; + command_buffer[command_length + 2] = NibbleToHex(checksum >> 4); + command_buffer[command_length + 3] = NibbleToHex(checksum); + + u8* ptr = command_buffer; + u32 left = command_length + 4; + while (left > 0) { + int sent_size = send(gdbserver_socket, reinterpret_cast(ptr), left, 0); + if (sent_size < 0) { + LOG_ERROR(Debug_GDBStub, "gdb: send failed"); + return Deinit(); + } + + left -= sent_size; + ptr += sent_size; + } +} + +/// Handle query command from gdb client. +static void HandleQuery() { + LOG_DEBUG(Debug_GDBStub, "gdb: query '%s'\n", command_buffer + 1); + + if (!strcmp(reinterpret_cast(command_buffer + 1), "TStatus")) { + SendReply("T0"); + } else { + SendReply(""); + } +} + +/// Handle set thread command from gdb client. +static void HandleSetThread() { + if (memcmp(command_buffer, "Hg0", 3) == 0 || + memcmp(command_buffer, "Hc-1", 4) == 0 || + memcmp(command_buffer, "Hc0", 4) == 0 || + memcmp(command_buffer, "Hc1", 4) == 0) { + return SendReply("OK"); + } + + SendReply("E01"); +} + +/// Create and send signal packet. +static void HandleSignal() { + std::string buffer = Common::StringFromFormat("T%02x%02x:%08x;%02x:%08x;", latest_signal, 15, htonl(Core::g_app_core->GetPC()), 13, htonl(Core::g_app_core->GetReg(13))); + + LOG_DEBUG(Debug_GDBStub, "Response: %s", buffer.c_str()); + + SendReply(buffer.c_str()); +} + +/** + * Set signal and send packet to client through HandleSignal if signal flag is set using SendSignal. + * + * @param signal Signal to be sent to client. + */ +int SendSignal(u32 signal) { + if (gdbserver_socket == -1) { + return 1; + } + + latest_signal = signal; + + if (send_signal) { + HandleSignal(); + send_signal = 0; + } + + return 0; +} + +/// Read command from gdb client. +static void ReadCommand() { + command_length = 0; + memset(command_buffer, 0, sizeof(command_buffer)); + + u8 c = ReadByte(); + if (c == '+') { + //ignore ack + return; + } else if (c == 0x03) { + LOG_INFO(Debug_GDBStub, "gdb: found break command\n"); + halt_loop = true; + send_signal = 1; + SendSignal(SIGTRAP); + return; + } else if (c != GDB_STUB_START) { + LOG_DEBUG(Debug_GDBStub, "gdb: read invalid byte %02x\n", c); + return; + } + + while ((c = ReadByte()) != GDB_STUB_END) { + command_buffer[command_length++] = c; + if (command_length == sizeof(command_buffer)) { + LOG_ERROR(Debug_GDBStub, "gdb: command_buffer overflow\n"); + SendPacket(GDB_STUB_NACK); + return; + } + } + + u8 checksum_received = HexCharToValue(ReadByte()) << 4; + checksum_received |= HexCharToValue(ReadByte()); + + u8 checksum_calculated = CalculateChecksum(command_buffer, command_length); + + if (checksum_received != checksum_calculated) { + LOG_ERROR(Debug_GDBStub, "gdb: invalid checksum: calculated %02x and read %02x for $%s# (length: %d)\n", + checksum_calculated, checksum_received, command_buffer, command_length); + + command_length = 0; + + SendPacket(GDB_STUB_NACK); + return; + } + + SendPacket(GDB_STUB_ACK); +} + +/// Check if there is data to be read from the gdb client. +static bool IsDataAvailable() { + if (!IsConnected()) { + return false; + } + + fd_set fd_socket; + + FD_ZERO(&fd_socket); + FD_SET(gdbserver_socket, &fd_socket); + + struct timeval t; + t.tv_sec = 0; + t.tv_usec = 0; + + if (select(gdbserver_socket + 1, &fd_socket, nullptr, nullptr, &t) < 0) { + LOG_ERROR(Debug_GDBStub, "select failed"); + return false; + } + + return FD_ISSET(gdbserver_socket, &fd_socket); +} + +/// Send requested register to gdb client. +static void ReadRegister() { + static u8 reply[64]; + memset(reply, 0, sizeof(reply)); + + u32 id = HexCharToValue(command_buffer[1]); + if (command_buffer[2] != '\0') { + id <<= 4; + id |= HexCharToValue(command_buffer[2]); + } + + if (id >= R0_REGISTER && id <= R15_REGISTER) { + IntToHex(reply, Core::g_app_core->GetReg(id)); + } else if (id == CSPR_REGISTER) { + IntToHex(reply, Core::g_app_core->GetCPSR()); + } else { + return SendReply("E01"); + } + + SendReply(reinterpret_cast(reply)); +} + +/// Send all registers to the gdb client. +static void ReadRegisters() { + static u8 buffer[GDB_BUFFER_SIZE - 4]; + memset(buffer, 0, sizeof(buffer)); + + u8* bufptr = buffer; + for (int i = 0; i <= CSPR_REGISTER; i++) { + if (i <= R15_REGISTER) { + IntToHex(bufptr + i * 8, Core::g_app_core->GetReg(i)); + } else if (i == CSPR_REGISTER) { + IntToHex(bufptr + i * 8, Core::g_app_core->GetCPSR()); + } else { + IntToHex(bufptr + i * 8, 0); + IntToHex(bufptr + (i + 1) * 8, 0); + i++; // These registers seem to be all 64bit instead of 32bit, so skip two instead of one + } + } + + SendReply(reinterpret_cast(buffer)); +} + +/// Modify data of register specified by gdb client. +static void WriteRegister() { + u8* buffer_ptr = command_buffer + 3; + + u32 id = HexCharToValue(command_buffer[1]); + if (command_buffer[2] != '=') { + ++buffer_ptr; + id <<= 4; + id |= HexCharToValue(command_buffer[2]); + } + + if (id >= R0_REGISTER && id <= R15_REGISTER) { + Core::g_app_core->SetReg(id, HexToInt(buffer_ptr)); + } else if (id == CSPR_REGISTER) { + Core::g_app_core->SetCPSR(HexToInt(buffer_ptr)); + } else { + return SendReply("E01"); + } + + SendReply("OK"); +} + +/// Modify all registers with data received from the client. +static void WriteRegisters() { + u8* buffer_ptr = command_buffer + 1; + + if (command_buffer[0] != 'G') + return SendReply("E01"); + + for (int i = 0; i <= CSPR_REGISTER; i++) { + if (i <= R15_REGISTER) { + Core::g_app_core->SetReg(i, HexToInt(buffer_ptr + i * 8)); + } else if (i == CSPR_REGISTER) { + Core::g_app_core->SetCPSR(HexToInt(buffer_ptr + i * 8)); + } else { + i++; // These registers seem to be all 64bit instead of 32bit, so skip two instead of one + } + } + + SendReply("OK"); +} + +/// Read location in memory specified by gdb client. +static void ReadMemory() { + static u8 reply[GDB_BUFFER_SIZE - 4]; + + int i = 1; + PAddr addr = 0; + while (command_buffer[i] != ',') { + addr = (addr << 4) | HexCharToValue(command_buffer[i++]); + } + i++; + + u32 len = 0; + while (i < command_length) { + len = (len << 4) | HexCharToValue(command_buffer[i++]); + } + + if (len * 2 > sizeof(reply)) { + SendReply("E01"); + } + + u8* data = Memory::GetPointer(addr); + if (!data) { + return SendReply("E0"); + } + + MemToHex(reply, data, len); + reply[len * 2] = '\0'; + SendReply(reinterpret_cast(reply)); +} + +/// Modify location in memory with data received from the gdb client. +static void WriteMemory() { + int i = 1; + PAddr addr = 0; + while (command_buffer[i] != ',') { + addr = (addr << 4) | HexCharToValue(command_buffer[i++]); + } + i++; + + u32 len = 0; + while (command_buffer[i] != ':') { + len = (len << 4) | HexCharToValue(command_buffer[i++]); + } + + u8* dst = Memory::GetPointer(addr); + if (!dst) { + return SendReply("E00"); + } + + HexToMem(dst, command_buffer + i + 1, len); + SendReply("OK"); +} + +void Break(bool is_memory_break) { + if (!halt_loop) { + halt_loop = true; + send_signal = 1; + SendSignal(SIGTRAP); + } + + memory_break = is_memory_break; +} + +/// Tell the CPU that it should perform a single step. +static void Step() { + step_loop = true; + halt_loop = true; + send_signal = 1; + step_break = 1; + SendSignal(SIGTRAP); +} + +bool IsMemoryBreak() { + if (IsConnected()) { + return false; + } + + return memory_break; +} + +/// Tell the CPU to continue executing. +static void Continue() { + memory_break = false; + step_break = 0; + step_loop = false; + halt_loop = false; +} + +/** + * Commit breakpoint to list of breakpoints. + * + * @param type Type of breakpoint. + * @param addr Address of breakpoint. + * @param len Length of breakpoint. + */ +bool CommitBreakpoint(BreakpointType type, PAddr addr, u32 len) { + std::map& p = GetBreakpointList(type); + + Breakpoint breakpoint; + breakpoint.active = true; + breakpoint.addr = addr; + breakpoint.len = len; + p.insert({ addr, breakpoint }); + + LOG_DEBUG(Debug_GDBStub, "gdb: added %d breakpoint: %08x bytes at %08x\n", type, breakpoint.len, breakpoint.addr); + + return true; +} + +/// Handle add breakpoint command from gdb client. +static void AddBreakpoint() { + BreakpointType type; + + u8 type_id = HexCharToValue(command_buffer[1]); + switch (type_id) { + case 0: + case 1: + type = BreakpointType::Execute; + break; + case 2: + type = BreakpointType::Write; + break; + case 3: + type = BreakpointType::Read; + break; + case 4: + type = BreakpointType::Access; + break; + default: + return SendReply("E01"); + } + + int i = 3; + PAddr addr = 0; + while (command_buffer[i] != ',') { + addr = addr << 4 | HexCharToValue(command_buffer[i++]); + } + i++; + + u32 len = 0; + while (i < command_length) { + len = len << 4 | HexCharToValue(command_buffer[i++]); + } + + if (type == BreakpointType::Access) { + // Access is made up of Read and Write types, so add both breakpoints + type = BreakpointType::Read; + + if (!CommitBreakpoint(type, addr, len)) { + return SendReply("E02"); + } + + type = BreakpointType::Write; + } + + if (!CommitBreakpoint(type, addr, len)) { + return SendReply("E02"); + } + + SendReply("OK"); +} + +/// Handle remove breakpoint command from gdb client. +static void RemoveBreakpoint() { + BreakpointType type; + + u8 type_id = HexCharToValue(command_buffer[1]); + switch (type_id) { + case 0: + case 1: + type = BreakpointType::Execute; + break; + case 2: + type = BreakpointType::Write; + break; + case 3: + type = BreakpointType::Read; + break; + case 4: + type = BreakpointType::Access; + break; + default: + return SendReply("E01"); + } + + int i = 3; + PAddr addr = 0; + while (command_buffer[i] != ',') { + addr = (addr << 4) | HexCharToValue(command_buffer[i++]); + } + i++; + + u32 len = 0; + while (i < command_length) { + len = (len << 4) | HexCharToValue(command_buffer[i++]); + } + + if (type == BreakpointType::Access) { + // Access is made up of Read and Write types, so add both breakpoints + type = BreakpointType::Read; + RemoveBreakpoint(type, addr); + + type = BreakpointType::Write; + } + + RemoveBreakpoint(type, addr); + SendReply("OK"); +} + +void HandlePacket() { + if (!IsConnected()) { + return; + } + + if (!IsDataAvailable()) { + return; + } + + ReadCommand(); + if (command_length == 0) { + return; + } + + LOG_DEBUG(Debug_GDBStub, "Packet: %s", command_buffer); + + switch (command_buffer[0]) { + case 'q': + HandleQuery(); + break; + case 'H': + HandleSetThread(); + break; + case '?': + HandleSignal(); + break; + case 'k': + Deinit(); + LOG_INFO(Debug_GDBStub, "killed by gdb"); + return; + case 'g': + ReadRegisters(); + break; + case 'G': + WriteRegisters(); + break; + case 'p': + ReadRegister(); + break; + case 'P': + WriteRegister(); + break; + case 'm': + ReadMemory(); + break; + case 'M': + WriteMemory(); + break; + case 's': + Step(); + return; + case 'C': + case 'c': + Continue(); + return; + case 'z': + RemoveBreakpoint(); + break; + case 'Z': + AddBreakpoint(); + break; + default: + SendReply(""); + break; + } +} + +void SetServerPort(u16 port) { + gdbstub_port = port; +} + +void ToggleServer(bool status) { + if (status) { + g_server_enabled = status; + + // Start server + if (!IsConnected() && Core::g_sys_core != nullptr) { + Init(); + } + } + else { + // Stop server + if (IsConnected()) { + Deinit(); + } + + g_server_enabled = status; + } +} + +void Init(u16 port) { + if (!g_server_enabled) { + // Set the halt loop to false in case the user enabled the gdbstub mid-execution. + // This way the CPU can still execute normally. + halt_loop = false; + step_loop = false; + return; + } + + // Setup initial gdbstub status + halt_loop = true; + step_loop = false; + + breakpoints_execute.clear(); + breakpoints_read.clear(); + breakpoints_write.clear(); + + // Start gdb server + LOG_INFO(Debug_GDBStub, "Starting GDB server on port %d...", port); + + sockaddr_in saddr_server = {}; + saddr_server.sin_family = AF_INET; + saddr_server.sin_port = htons(port); + saddr_server.sin_addr.s_addr = INADDR_ANY; + +#ifdef _WIN32 + WSAStartup(MAKEWORD(2, 2), &InitData); +#endif + + int tmpsock = socket(PF_INET, SOCK_STREAM, 0); + if (tmpsock == -1) { + LOG_ERROR(Debug_GDBStub, "Failed to create gdb socket"); + } + + const sockaddr* server_addr = reinterpret_cast(&saddr_server); + socklen_t server_addrlen = sizeof(saddr_server); + if (bind(tmpsock, server_addr, server_addrlen) < 0) { + LOG_ERROR(Debug_GDBStub, "Failed to bind gdb socket"); + } + + if (listen(tmpsock, 1) < 0) { + LOG_ERROR(Debug_GDBStub, "Failed to listen to gdb socket"); + } + + // Wait for gdb to connect + LOG_INFO(Debug_GDBStub, "Waiting for gdb to connect...\n"); + sockaddr_in saddr_client; + sockaddr* client_addr = reinterpret_cast(&saddr_client); + socklen_t client_addrlen = sizeof(saddr_client); + gdbserver_socket = accept(tmpsock, client_addr, &client_addrlen); + if (gdbserver_socket < 0) { + // In the case that we couldn't start the server for whatever reason, just start CPU execution like normal. + halt_loop = false; + step_loop = false; + + LOG_ERROR(Debug_GDBStub, "Failed to accept gdb client"); + } + else { + LOG_INFO(Debug_GDBStub, "Client connected.\n"); + saddr_client.sin_addr.s_addr = ntohl(saddr_client.sin_addr.s_addr); + } + + // Clean up temporary socket if it's still alive at this point. + if (tmpsock != -1) { + shutdown(tmpsock, SHUT_RDWR); + } +} + +void Init() { + Init(gdbstub_port); +} + +void Deinit() { + if (!g_server_enabled) { + return; + } + + LOG_INFO(Debug_GDBStub, "Stopping GDB ..."); + if (gdbserver_socket != -1) { + shutdown(gdbserver_socket, SHUT_RDWR); + gdbserver_socket = -1; + } + +#ifdef _WIN32 + WSACleanup(); +#endif + + LOG_INFO(Debug_GDBStub, "GDB stopped."); +} + +bool IsConnected() { + return g_server_enabled && gdbserver_socket != -1; +} + +bool GetCpuHaltFlag() { + return halt_loop; +} + +bool GetCpuStepFlag() { + return step_loop; +} + +void SetCpuStepFlag(bool is_step) { + step_loop = is_step; +} + +}; diff --git a/src/core/gdbstub/gdbstub.h b/src/core/gdbstub/gdbstub.h new file mode 100644 index 000000000..11ff823c3 --- /dev/null +++ b/src/core/gdbstub/gdbstub.h @@ -0,0 +1,89 @@ +// Copyright 2013 Dolphin Emulator Project +// Licensed under GPLv2+ +// Refer to the license.txt file included. + +// Originally written by Sven Peter for anergistic. + +#pragma once +#include + +namespace GDBStub { + +/// Breakpoint Method +enum class BreakpointType { + None, ///< None + Execute, ///< Execution Breakpoint + Read, ///< Read Breakpoint + Write, ///< Write Breakpoint + Access ///< Access (R/W) Breakpoint +}; + +/// If set to false, the server will never be started and no gdbstub-related functions will be executed. +extern std::atomic g_server_enabled; + +/** + * Set the port the gdbstub should use to listen for connections. + * + * @param port Port to listen for connection + */ +void SetServerPort(u16 port); + +/** + * Set the g_server_enabled flag and start or stop the server if possible. + * + * @param status Set the server to enabled or disabled. + */ +void ToggleServer(bool status); + +/// Start the gdbstub server. +void Init(); + +/// Stop gdbstub server. +void Deinit(); + +/// Returns true if there is an active socket connection. +bool IsConnected(); + +/** + * Signal to the gdbstub server that it should halt CPU execution. + * + * @param is_memory_break If true, the break resulted from a memory breakpoint. + */ +void Break(bool is_memory_break = false); + +/// Determine if there was a memory breakpoint. +bool IsMemoryBreak(); + +/// Read and handle packet from gdb client. +void HandlePacket(); + +/** + * Get the nearest breakpoint of the specified type at the given address. + * + * @param addr Address to search from. + * @param type Type of breakpoint. + */ +PAddr GetNextBreakpointFromAddress(u32 addr, GDBStub::BreakpointType type); + +/** + * Check if a breakpoint of the specified type exists at the given address. + * + * @param addr Address of breakpoint. + * @param type Type of breakpoint. + */ +bool CheckBreakpoint(u32 addr, GDBStub::BreakpointType type); + +// If set to true, the CPU will halt at the beginning of the next CPU loop. +bool GetCpuHaltFlag(); + +// If set to true and the CPU is halted, the CPU will step one instruction. +bool GetCpuStepFlag(); + +/** + * When set to true, the CPU will step one instruction when the CPU is halted next. + * + * @param is_step + */ +void SetCpuStepFlag(bool is_step); + +} diff --git a/src/core/settings.h b/src/core/settings.h index 0b05e5bee..97ddcdff9 100644 --- a/src/core/settings.h +++ b/src/core/settings.h @@ -6,6 +6,7 @@ #include #include +#include namespace Settings { @@ -60,6 +61,10 @@ struct Values { float bg_blue; std::string log_filter; + + // Debugging + bool use_gdbstub; + u16 gdbstub_port; } extern values; } diff --git a/src/core/system.cpp b/src/core/system.cpp index 3cd84bf5e..421fc48a7 100644 --- a/src/core/system.cpp +++ b/src/core/system.cpp @@ -12,6 +12,8 @@ #include "video_core/video_core.h" +#include "core/gdbstub/gdbstub.h" + namespace System { void Init(EmuWindow* emu_window) { @@ -22,9 +24,13 @@ void Init(EmuWindow* emu_window) { Kernel::Init(); HLE::Init(); VideoCore::Init(emu_window); + + GDBStub::Init(); } void Shutdown() { + GDBStub::Deinit(); + VideoCore::Shutdown(); HLE::Shutdown(); Kernel::Shutdown(); -- cgit v1.2.3 From 42928659e8d4ff4edffc36acabe3d9040dbc1326 Mon Sep 17 00:00:00 2001 From: polaris- Date: Sun, 4 Oct 2015 11:22:31 -0400 Subject: Use BreakpointAddress struct instead of passing address directly --- src/core/arm/dyncom/arm_dyncom_interpreter.cpp | 6 +++--- src/core/gdbstub/gdbstub.cpp | 13 +++++++++---- src/core/gdbstub/gdbstub.h | 7 ++++++- 3 files changed, 18 insertions(+), 8 deletions(-) (limited to 'src/core') diff --git a/src/core/arm/dyncom/arm_dyncom_interpreter.cpp b/src/core/arm/dyncom/arm_dyncom_interpreter.cpp index 8293f4c60..88be27ab2 100644 --- a/src/core/arm/dyncom/arm_dyncom_interpreter.cpp +++ b/src/core/arm/dyncom/arm_dyncom_interpreter.cpp @@ -3583,7 +3583,7 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) { Common::Profiling::ScopeTimer timer_execute(profile_execute); MICROPROFILE_SCOPE(DynCom_Execute); - int breakpoint_offset = -1; + GDBStub::BreakpointAddress breakpoint_data; #undef RM #undef RS @@ -3613,7 +3613,7 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) { cpu->Cpsr &= ~(1 << 5); \ cpu->Cpsr |= cpu->TFlag << 5; \ if (GDBStub::g_server_enabled) { \ - if (GDBStub::IsMemoryBreak() || PC == breakpoint_offset) { \ + if (GDBStub::IsMemoryBreak() || (breakpoint_data.type != GDBStub::BreakpointType::None && PC == breakpoint_data.address)) { \ GDBStub::Break(); \ goto END; \ } \ @@ -3923,7 +3923,7 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) { // Find breakpoint if one exists within the block if (GDBStub::g_server_enabled && GDBStub::IsConnected()) { - breakpoint_offset = GDBStub::GetNextBreakpointFromAddress(cpu->Reg[15], GDBStub::BreakpointType::Execute); + breakpoint_data = GDBStub::GetNextBreakpointFromAddress(cpu->Reg[15], GDBStub::BreakpointType::Execute); } inst_base = (arm_inst *)&inst_buf[ptr]; diff --git a/src/core/gdbstub/gdbstub.cpp b/src/core/gdbstub/gdbstub.cpp index ced1c54f5..25ce63b29 100644 --- a/src/core/gdbstub/gdbstub.cpp +++ b/src/core/gdbstub/gdbstub.cpp @@ -231,13 +231,18 @@ static void RemoveBreakpoint(BreakpointType type, PAddr addr) { } } -PAddr GetNextBreakpointFromAddress(PAddr addr, BreakpointType type) { +BreakpointAddress GetNextBreakpointFromAddress(PAddr addr, BreakpointType type) { std::map& p = GetBreakpointList(type); auto next_breakpoint = p.lower_bound(addr); - u32 breakpoint = -1; + BreakpointAddress breakpoint; - if (next_breakpoint != p.end()) - breakpoint = next_breakpoint->first; + if (next_breakpoint != p.end()) { + breakpoint.address = next_breakpoint->first; + breakpoint.type = type; + } else { + breakpoint.address = 0; + breakpoint.type = BreakpointType::None; + } return breakpoint; } diff --git a/src/core/gdbstub/gdbstub.h b/src/core/gdbstub/gdbstub.h index 11ff823c3..da238f349 100644 --- a/src/core/gdbstub/gdbstub.h +++ b/src/core/gdbstub/gdbstub.h @@ -18,6 +18,11 @@ enum class BreakpointType { Access ///< Access (R/W) Breakpoint }; +struct BreakpointAddress { + PAddr address; + BreakpointType type; +}; + /// If set to false, the server will never be started and no gdbstub-related functions will be executed. extern std::atomic g_server_enabled; @@ -63,7 +68,7 @@ void HandlePacket(); * @param addr Address to search from. * @param type Type of breakpoint. */ -PAddr GetNextBreakpointFromAddress(u32 addr, GDBStub::BreakpointType type); +BreakpointAddress GetNextBreakpointFromAddress(u32 addr, GDBStub::BreakpointType type); /** * Check if a breakpoint of the specified type exists at the given address. -- cgit v1.2.3 From 2b7316a379103edf4d22893e0f4432e6415eabfa Mon Sep 17 00:00:00 2001 From: polaris- Date: Sun, 11 Oct 2015 20:07:58 -0400 Subject: Remove unnecessary new lines, changed Deinit to Shutdown --- src/core/arm/dyncom/arm_dyncom_interpreter.cpp | 1 - src/core/gdbstub/gdbstub.cpp | 10 +++++----- src/core/gdbstub/gdbstub.h | 2 +- src/core/system.cpp | 4 +--- 4 files changed, 7 insertions(+), 10 deletions(-) (limited to 'src/core') diff --git a/src/core/arm/dyncom/arm_dyncom_interpreter.cpp b/src/core/arm/dyncom/arm_dyncom_interpreter.cpp index 88be27ab2..96c88c83a 100644 --- a/src/core/arm/dyncom/arm_dyncom_interpreter.cpp +++ b/src/core/arm/dyncom/arm_dyncom_interpreter.cpp @@ -3895,7 +3895,6 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) { unsigned int addr; unsigned int num_instrs = 0; - int ptr; LOAD_NZCVT; diff --git a/src/core/gdbstub/gdbstub.cpp b/src/core/gdbstub/gdbstub.cpp index 25ce63b29..15e6f36a0 100644 --- a/src/core/gdbstub/gdbstub.cpp +++ b/src/core/gdbstub/gdbstub.cpp @@ -186,7 +186,7 @@ static u8 ReadByte() { size_t received_size = recv(gdbserver_socket, reinterpret_cast(&c), 1, MSG_WAITALL); if (received_size != 1) { LOG_ERROR(Debug_GDBStub, "recv failed : %ld", received_size); - Deinit(); + Shutdown(); } return c; @@ -322,7 +322,7 @@ static void SendReply(const char* reply) { int sent_size = send(gdbserver_socket, reinterpret_cast(ptr), left, 0); if (sent_size < 0) { LOG_ERROR(Debug_GDBStub, "gdb: send failed"); - return Deinit(); + return Shutdown(); } left -= sent_size; @@ -773,7 +773,7 @@ void HandlePacket() { HandleSignal(); break; case 'k': - Deinit(); + Shutdown(); LOG_INFO(Debug_GDBStub, "killed by gdb"); return; case 'g': @@ -829,7 +829,7 @@ void ToggleServer(bool status) { else { // Stop server if (IsConnected()) { - Deinit(); + Shutdown(); } g_server_enabled = status; @@ -908,7 +908,7 @@ void Init() { Init(gdbstub_port); } -void Deinit() { +void Shutdown() { if (!g_server_enabled) { return; } diff --git a/src/core/gdbstub/gdbstub.h b/src/core/gdbstub/gdbstub.h index da238f349..aff705a32 100644 --- a/src/core/gdbstub/gdbstub.h +++ b/src/core/gdbstub/gdbstub.h @@ -44,7 +44,7 @@ void ToggleServer(bool status); void Init(); /// Stop gdbstub server. -void Deinit(); +void Shutdown(); /// Returns true if there is an active socket connection. bool IsConnected(); diff --git a/src/core/system.cpp b/src/core/system.cpp index 421fc48a7..7e9c56538 100644 --- a/src/core/system.cpp +++ b/src/core/system.cpp @@ -24,13 +24,11 @@ void Init(EmuWindow* emu_window) { Kernel::Init(); HLE::Init(); VideoCore::Init(emu_window); - GDBStub::Init(); } void Shutdown() { - GDBStub::Deinit(); - + GDBStub::Shutdown(); VideoCore::Shutdown(); HLE::Shutdown(); Kernel::Shutdown(); -- cgit v1.2.3 From 9f66580d7e353b96690690f776d557f1c9028b37 Mon Sep 17 00:00:00 2001 From: polaris- Date: Wed, 21 Oct 2015 06:49:49 -0400 Subject: Fix buffer overflow comments --- src/core/gdbstub/gdbstub.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'src/core') diff --git a/src/core/gdbstub/gdbstub.cpp b/src/core/gdbstub/gdbstub.cpp index 15e6f36a0..0d586ca10 100644 --- a/src/core/gdbstub/gdbstub.cpp +++ b/src/core/gdbstub/gdbstub.cpp @@ -306,6 +306,7 @@ static void SendReply(const char* reply) { command_length = strlen(reply); if (command_length + 4 > sizeof(command_buffer)) { LOG_ERROR(Debug_GDBStub, "command_buffer overflow in SendReply"); + return; } memcpy(command_buffer + 1, reply, command_length); @@ -403,12 +404,12 @@ static void ReadCommand() { } while ((c = ReadByte()) != GDB_STUB_END) { - command_buffer[command_length++] = c; - if (command_length == sizeof(command_buffer)) { + if (command_length >= sizeof(command_buffer)) { LOG_ERROR(Debug_GDBStub, "gdb: command_buffer overflow\n"); SendPacket(GDB_STUB_NACK); return; } + command_buffer[command_length++] = c; } u8 checksum_received = HexCharToValue(ReadByte()) << 4; -- cgit v1.2.3 From 53aa55fcaa6491d2cc0836e25f9303f7ba4126f3 Mon Sep 17 00:00:00 2001 From: polaris- Date: Wed, 21 Oct 2015 07:14:43 -0400 Subject: Try to add support for VFP registers --- src/core/gdbstub/gdbstub.cpp | 25 +++++++++++++++++++++---- 1 file changed, 21 insertions(+), 4 deletions(-) (limited to 'src/core') diff --git a/src/core/gdbstub/gdbstub.cpp b/src/core/gdbstub/gdbstub.cpp index 0d586ca10..a6977302c 100644 --- a/src/core/gdbstub/gdbstub.cpp +++ b/src/core/gdbstub/gdbstub.cpp @@ -56,6 +56,7 @@ const u32 MSG_WAITALL = 8; const u32 R0_REGISTER = 0; const u32 R15_REGISTER = 15; const u32 CSPR_REGISTER = 25; +const u32 FPSCR_REGISTER = 58; namespace GDBStub { @@ -468,6 +469,10 @@ static void ReadRegister() { IntToHex(reply, Core::g_app_core->GetReg(id)); } else if (id == CSPR_REGISTER) { IntToHex(reply, Core::g_app_core->GetCPSR()); + } else if (id > CSPR_REGISTER && id < FPSCR_REGISTER) { + IntToHex(reply, Core::g_app_core->GetVFPReg(id - CSPR_REGISTER - 1)); // VFP registers should start at 26, so one after CSPR_REGISTER + } else if (id == FPSCR_REGISTER) { + IntToHex(reply, Core::g_app_core->GetVFPSystemReg(VFP_FPSCR)); // Get FPSCR } else { return SendReply("E01"); } @@ -481,15 +486,19 @@ static void ReadRegisters() { memset(buffer, 0, sizeof(buffer)); u8* bufptr = buffer; - for (int i = 0; i <= CSPR_REGISTER; i++) { + for (int i = 0; i <= FPSCR_REGISTER; i++) { if (i <= R15_REGISTER) { IntToHex(bufptr + i * 8, Core::g_app_core->GetReg(i)); } else if (i == CSPR_REGISTER) { IntToHex(bufptr + i * 8, Core::g_app_core->GetCPSR()); - } else { + } else if (i < CSPR_REGISTER) { IntToHex(bufptr + i * 8, 0); IntToHex(bufptr + (i + 1) * 8, 0); i++; // These registers seem to be all 64bit instead of 32bit, so skip two instead of one + } else if (i > CSPR_REGISTER && i < FPSCR_REGISTER) { + IntToHex(bufptr + i * 8, Core::g_app_core->GetVFPReg(i - CSPR_REGISTER - 1)); + } else if (i == FPSCR_REGISTER) { + IntToHex(bufptr + i * 8, Core::g_app_core->GetVFPSystemReg(VFP_FPSCR)); } } @@ -511,6 +520,10 @@ static void WriteRegister() { Core::g_app_core->SetReg(id, HexToInt(buffer_ptr)); } else if (id == CSPR_REGISTER) { Core::g_app_core->SetCPSR(HexToInt(buffer_ptr)); + } else if (id > CSPR_REGISTER && id < FPSCR_REGISTER) { + Core::g_app_core->SetVFPReg(id - CSPR_REGISTER - 1, HexToInt(buffer_ptr)); + } else if (id == FPSCR_REGISTER) { + Core::g_app_core->SetVFPSystemReg(VFP_FPSCR, HexToInt(buffer_ptr)); } else { return SendReply("E01"); } @@ -525,13 +538,17 @@ static void WriteRegisters() { if (command_buffer[0] != 'G') return SendReply("E01"); - for (int i = 0; i <= CSPR_REGISTER; i++) { + for (int i = 0; i <= FPSCR_REGISTER; i++) { if (i <= R15_REGISTER) { Core::g_app_core->SetReg(i, HexToInt(buffer_ptr + i * 8)); } else if (i == CSPR_REGISTER) { Core::g_app_core->SetCPSR(HexToInt(buffer_ptr + i * 8)); - } else { + } else if (i < CSPR_REGISTER) { i++; // These registers seem to be all 64bit instead of 32bit, so skip two instead of one + } else if (i > CSPR_REGISTER && i < FPSCR_REGISTER) { + Core::g_app_core->SetVFPReg(i - CSPR_REGISTER - 1, HexToInt(buffer_ptr + i * 8)); + } else if (i == FPSCR_REGISTER) { + Core::g_app_core->SetVFPSystemReg(VFP_FPSCR, HexToInt(buffer_ptr + i * 8)); } } -- cgit v1.2.3 From 8a0d848646661c28a03c4659caf64e38fc92c127 Mon Sep 17 00:00:00 2001 From: polaris- Date: Wed, 21 Oct 2015 07:19:03 -0400 Subject: Pad responses to gdb for VFP registers --- src/core/gdbstub/gdbstub.cpp | 3 +++ 1 file changed, 3 insertions(+) (limited to 'src/core') diff --git a/src/core/gdbstub/gdbstub.cpp b/src/core/gdbstub/gdbstub.cpp index a6977302c..7d8e9e3fb 100644 --- a/src/core/gdbstub/gdbstub.cpp +++ b/src/core/gdbstub/gdbstub.cpp @@ -473,6 +473,7 @@ static void ReadRegister() { IntToHex(reply, Core::g_app_core->GetVFPReg(id - CSPR_REGISTER - 1)); // VFP registers should start at 26, so one after CSPR_REGISTER } else if (id == FPSCR_REGISTER) { IntToHex(reply, Core::g_app_core->GetVFPSystemReg(VFP_FPSCR)); // Get FPSCR + IntToHex(reply + 8, 0); } else { return SendReply("E01"); } @@ -497,6 +498,8 @@ static void ReadRegisters() { i++; // These registers seem to be all 64bit instead of 32bit, so skip two instead of one } else if (i > CSPR_REGISTER && i < FPSCR_REGISTER) { IntToHex(bufptr + i * 8, Core::g_app_core->GetVFPReg(i - CSPR_REGISTER - 1)); + IntToHex(bufptr + (i + 1) * 8, 0); + i++; } else if (i == FPSCR_REGISTER) { IntToHex(bufptr + i * 8, Core::g_app_core->GetVFPSystemReg(VFP_FPSCR)); } -- cgit v1.2.3 From d7e346239bbbd6fbd28bdbe087966b0c994594a1 Mon Sep 17 00:00:00 2001 From: polaris- Date: Wed, 21 Oct 2015 07:28:36 -0400 Subject: Update register read loops to go with last commit --- src/core/gdbstub/gdbstub.cpp | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) (limited to 'src/core') diff --git a/src/core/gdbstub/gdbstub.cpp b/src/core/gdbstub/gdbstub.cpp index 7d8e9e3fb..e7fed68f7 100644 --- a/src/core/gdbstub/gdbstub.cpp +++ b/src/core/gdbstub/gdbstub.cpp @@ -57,6 +57,7 @@ const u32 R0_REGISTER = 0; const u32 R15_REGISTER = 15; const u32 CSPR_REGISTER = 25; const u32 FPSCR_REGISTER = 58; +const u32 MAX_REGISTERS = 90; namespace GDBStub { @@ -487,7 +488,7 @@ static void ReadRegisters() { memset(buffer, 0, sizeof(buffer)); u8* bufptr = buffer; - for (int i = 0; i <= FPSCR_REGISTER; i++) { + for (int i = 0; i <= MAX_REGISTERS; i++) { if (i <= R15_REGISTER) { IntToHex(bufptr + i * 8, Core::g_app_core->GetReg(i)); } else if (i == CSPR_REGISTER) { @@ -496,11 +497,11 @@ static void ReadRegisters() { IntToHex(bufptr + i * 8, 0); IntToHex(bufptr + (i + 1) * 8, 0); i++; // These registers seem to be all 64bit instead of 32bit, so skip two instead of one - } else if (i > CSPR_REGISTER && i < FPSCR_REGISTER) { + } else if (i > CSPR_REGISTER && i < MAX_REGISTERS) { IntToHex(bufptr + i * 8, Core::g_app_core->GetVFPReg(i - CSPR_REGISTER - 1)); IntToHex(bufptr + (i + 1) * 8, 0); i++; - } else if (i == FPSCR_REGISTER) { + } else if (i == MAX_REGISTERS) { IntToHex(bufptr + i * 8, Core::g_app_core->GetVFPSystemReg(VFP_FPSCR)); } } @@ -541,16 +542,16 @@ static void WriteRegisters() { if (command_buffer[0] != 'G') return SendReply("E01"); - for (int i = 0; i <= FPSCR_REGISTER; i++) { + for (int i = 0; i <= MAX_REGISTERS; i++) { if (i <= R15_REGISTER) { Core::g_app_core->SetReg(i, HexToInt(buffer_ptr + i * 8)); } else if (i == CSPR_REGISTER) { Core::g_app_core->SetCPSR(HexToInt(buffer_ptr + i * 8)); } else if (i < CSPR_REGISTER) { i++; // These registers seem to be all 64bit instead of 32bit, so skip two instead of one - } else if (i > CSPR_REGISTER && i < FPSCR_REGISTER) { + } else if (i > CSPR_REGISTER && i < MAX_REGISTERS) { Core::g_app_core->SetVFPReg(i - CSPR_REGISTER - 1, HexToInt(buffer_ptr + i * 8)); - } else if (i == FPSCR_REGISTER) { + } else if (i == MAX_REGISTERS) { Core::g_app_core->SetVFPSystemReg(VFP_FPSCR, HexToInt(buffer_ptr + i * 8)); } } -- cgit v1.2.3 From d1f73c424ff90d0de22bcd20d04b6ebef3a86645 Mon Sep 17 00:00:00 2001 From: polaris- Date: Wed, 21 Oct 2015 07:45:35 -0400 Subject: Add a register variable to loops --- src/core/gdbstub/gdbstub.cpp | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) (limited to 'src/core') diff --git a/src/core/gdbstub/gdbstub.cpp b/src/core/gdbstub/gdbstub.cpp index e7fed68f7..6c21b5998 100644 --- a/src/core/gdbstub/gdbstub.cpp +++ b/src/core/gdbstub/gdbstub.cpp @@ -488,17 +488,18 @@ static void ReadRegisters() { memset(buffer, 0, sizeof(buffer)); u8* bufptr = buffer; - for (int i = 0; i <= MAX_REGISTERS; i++) { + for (int i = 0, reg = 0; i <= MAX_REGISTERS; i++, reg++) { if (i <= R15_REGISTER) { - IntToHex(bufptr + i * 8, Core::g_app_core->GetReg(i)); + IntToHex(bufptr + i * 8, Core::g_app_core->GetReg(reg)); } else if (i == CSPR_REGISTER) { IntToHex(bufptr + i * 8, Core::g_app_core->GetCPSR()); } else if (i < CSPR_REGISTER) { IntToHex(bufptr + i * 8, 0); IntToHex(bufptr + (i + 1) * 8, 0); i++; // These registers seem to be all 64bit instead of 32bit, so skip two instead of one + reg++; } else if (i > CSPR_REGISTER && i < MAX_REGISTERS) { - IntToHex(bufptr + i * 8, Core::g_app_core->GetVFPReg(i - CSPR_REGISTER - 1)); + IntToHex(bufptr + i * 8, Core::g_app_core->GetVFPReg(reg - CSPR_REGISTER - 1)); IntToHex(bufptr + (i + 1) * 8, 0); i++; } else if (i == MAX_REGISTERS) { @@ -542,15 +543,17 @@ static void WriteRegisters() { if (command_buffer[0] != 'G') return SendReply("E01"); - for (int i = 0; i <= MAX_REGISTERS; i++) { + for (int i = 0, reg = 0; i <= MAX_REGISTERS; i++, reg++) { if (i <= R15_REGISTER) { - Core::g_app_core->SetReg(i, HexToInt(buffer_ptr + i * 8)); + Core::g_app_core->SetReg(reg, HexToInt(buffer_ptr + i * 8)); } else if (i == CSPR_REGISTER) { Core::g_app_core->SetCPSR(HexToInt(buffer_ptr + i * 8)); } else if (i < CSPR_REGISTER) { i++; // These registers seem to be all 64bit instead of 32bit, so skip two instead of one + reg++; } else if (i > CSPR_REGISTER && i < MAX_REGISTERS) { - Core::g_app_core->SetVFPReg(i - CSPR_REGISTER - 1, HexToInt(buffer_ptr + i * 8)); + Core::g_app_core->SetVFPReg(reg - CSPR_REGISTER - 1, HexToInt(buffer_ptr + i * 8)); + i++; // Skip padding } else if (i == MAX_REGISTERS) { Core::g_app_core->SetVFPSystemReg(VFP_FPSCR, HexToInt(buffer_ptr + i * 8)); } -- cgit v1.2.3 From a5ab8accc21e73be9564bebde4d3b20b38d85b6e Mon Sep 17 00:00:00 2001 From: polaris- Date: Wed, 21 Oct 2015 22:19:55 -0400 Subject: Handle changes pointed out in comments on PR --- src/core/gdbstub/gdbstub.cpp | 95 ++++++++++++++++---------------------------- 1 file changed, 34 insertions(+), 61 deletions(-) (limited to 'src/core') diff --git a/src/core/gdbstub/gdbstub.cpp b/src/core/gdbstub/gdbstub.cpp index 6c21b5998..6f9c8fa29 100644 --- a/src/core/gdbstub/gdbstub.cpp +++ b/src/core/gdbstub/gdbstub.cpp @@ -20,18 +20,18 @@ #include #define SHUT_RDWR 2 #else +#include #include #include #include #include -#include #endif #include "common/logging/log.h" #include "common/string_util.h" -#include #include "core/core.h" #include "core/memory.h" +#include "core/arm/arm_interface.h" #include "gdbstub.h" const int GDB_BUFFER_SIZE = 10000; @@ -67,8 +67,7 @@ static u8 command_buffer[GDB_BUFFER_SIZE]; static u32 command_length; static u32 latest_signal = 0; -static u32 send_signal = 0; -static u32 step_break = 0; +static bool step_break = false; static bool memory_break = false; // Binding to a port within the reserved ports range (0-1023) requires root permissions, @@ -356,33 +355,21 @@ static void HandleSetThread() { SendReply("E01"); } -/// Create and send signal packet. -static void HandleSignal() { - std::string buffer = Common::StringFromFormat("T%02x%02x:%08x;%02x:%08x;", latest_signal, 15, htonl(Core::g_app_core->GetPC()), 13, htonl(Core::g_app_core->GetReg(13))); - - LOG_DEBUG(Debug_GDBStub, "Response: %s", buffer.c_str()); - - SendReply(buffer.c_str()); -} - /** - * Set signal and send packet to client through HandleSignal if signal flag is set using SendSignal. + * Send signal packet to client. * * @param signal Signal to be sent to client. */ -int SendSignal(u32 signal) { +void SendSignal(u32 signal) { if (gdbserver_socket == -1) { - return 1; + return; } latest_signal = signal; - if (send_signal) { - HandleSignal(); - send_signal = 0; - } - - return 0; + std::string buffer = Common::StringFromFormat("T%02x%02x:%08x;%02x:%08x;", latest_signal, 15, htonl(Core::g_app_core->GetPC()), 13, htonl(Core::g_app_core->GetReg(13))); + LOG_DEBUG(Debug_GDBStub, "Response: %s", buffer.c_str()); + SendReply(buffer.c_str()); } /// Read command from gdb client. @@ -397,7 +384,6 @@ static void ReadCommand() { } else if (c == 0x03) { LOG_INFO(Debug_GDBStub, "gdb: found break command\n"); halt_loop = true; - send_signal = 1; SendSignal(SIGTRAP); return; } else if (c != GDB_STUB_START) { @@ -566,17 +552,14 @@ static void WriteRegisters() { static void ReadMemory() { static u8 reply[GDB_BUFFER_SIZE - 4]; - int i = 1; + auto start_offset = command_buffer+1; + auto addr_pos = std::find(start_offset, command_buffer+command_length, ','); PAddr addr = 0; - while (command_buffer[i] != ',') { - addr = (addr << 4) | HexCharToValue(command_buffer[i++]); - } - i++; + HexToMem((u8*)&addr, start_offset, (addr_pos - start_offset) / 2); + start_offset = addr_pos+1; u32 len = 0; - while (i < command_length) { - len = (len << 4) | HexCharToValue(command_buffer[i++]); - } + HexToMem((u8*)&len, start_offset, ((command_buffer + command_length) - start_offset) / 2); if (len * 2 > sizeof(reply)) { SendReply("E01"); @@ -594,31 +577,28 @@ static void ReadMemory() { /// Modify location in memory with data received from the gdb client. static void WriteMemory() { - int i = 1; + auto start_offset = command_buffer+1; + auto addr_pos = std::find(start_offset, command_buffer+command_length, ','); PAddr addr = 0; - while (command_buffer[i] != ',') { - addr = (addr << 4) | HexCharToValue(command_buffer[i++]); - } - i++; + HexToMem((u8*)&addr, start_offset, (addr_pos - start_offset) / 2); + start_offset = addr_pos+1; + auto len_pos = std::find(start_offset, command_buffer+command_length, ':'); u32 len = 0; - while (command_buffer[i] != ':') { - len = (len << 4) | HexCharToValue(command_buffer[i++]); - } + HexToMem((u8*)&len, start_offset, (len_pos - start_offset) / 2); u8* dst = Memory::GetPointer(addr); if (!dst) { return SendReply("E00"); } - HexToMem(dst, command_buffer + i + 1, len); + HexToMem(dst, len_pos + 1, len); SendReply("OK"); } void Break(bool is_memory_break) { if (!halt_loop) { halt_loop = true; - send_signal = 1; SendSignal(SIGTRAP); } @@ -629,8 +609,7 @@ void Break(bool is_memory_break) { static void Step() { step_loop = true; halt_loop = true; - send_signal = 1; - step_break = 1; + step_break = true; SendSignal(SIGTRAP); } @@ -645,7 +624,7 @@ bool IsMemoryBreak() { /// Tell the CPU to continue executing. static void Continue() { memory_break = false; - step_break = 0; + step_break = false; step_loop = false; halt_loop = false; } @@ -694,17 +673,14 @@ static void AddBreakpoint() { return SendReply("E01"); } - int i = 3; + auto start_offset = command_buffer+3; + auto addr_pos = std::find(start_offset, command_buffer+command_length, ','); PAddr addr = 0; - while (command_buffer[i] != ',') { - addr = addr << 4 | HexCharToValue(command_buffer[i++]); - } - i++; + HexToMem((u8*)&addr, start_offset, (addr_pos - start_offset) / 2); + start_offset = addr_pos+1; u32 len = 0; - while (i < command_length) { - len = len << 4 | HexCharToValue(command_buffer[i++]); - } + HexToMem((u8*)&len, start_offset, ((command_buffer + command_length) - start_offset) / 2); if (type == BreakpointType::Access) { // Access is made up of Read and Write types, so add both breakpoints @@ -747,17 +723,14 @@ static void RemoveBreakpoint() { return SendReply("E01"); } - int i = 3; + auto start_offset = command_buffer+3; + auto addr_pos = std::find(start_offset, command_buffer+command_length, ','); PAddr addr = 0; - while (command_buffer[i] != ',') { - addr = (addr << 4) | HexCharToValue(command_buffer[i++]); - } - i++; + HexToMem((u8*)&addr, start_offset, (addr_pos - start_offset) / 2); + start_offset = addr_pos+1; u32 len = 0; - while (i < command_length) { - len = (len << 4) | HexCharToValue(command_buffer[i++]); - } + HexToMem((u8*)&len, start_offset, ((command_buffer + command_length) - start_offset) / 2); if (type == BreakpointType::Access) { // Access is made up of Read and Write types, so add both breakpoints @@ -795,7 +768,7 @@ void HandlePacket() { HandleSetThread(); break; case '?': - HandleSignal(); + SendSignal(latest_signal); break; case 'k': Shutdown(); -- cgit v1.2.3 From 45ed9e7e5e9709ac6e27402a9000b13a30bc80bf Mon Sep 17 00:00:00 2001 From: polaris- Date: Thu, 22 Oct 2015 00:19:44 -0400 Subject: Use CHAR_BIT instead of 8 --- src/core/gdbstub/gdbstub.cpp | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) (limited to 'src/core') diff --git a/src/core/gdbstub/gdbstub.cpp b/src/core/gdbstub/gdbstub.cpp index 6f9c8fa29..b226b431a 100644 --- a/src/core/gdbstub/gdbstub.cpp +++ b/src/core/gdbstub/gdbstub.cpp @@ -476,20 +476,20 @@ static void ReadRegisters() { u8* bufptr = buffer; for (int i = 0, reg = 0; i <= MAX_REGISTERS; i++, reg++) { if (i <= R15_REGISTER) { - IntToHex(bufptr + i * 8, Core::g_app_core->GetReg(reg)); + IntToHex(bufptr + i * CHAR_BIT, Core::g_app_core->GetReg(reg)); } else if (i == CSPR_REGISTER) { - IntToHex(bufptr + i * 8, Core::g_app_core->GetCPSR()); + IntToHex(bufptr + i * CHAR_BIT, Core::g_app_core->GetCPSR()); } else if (i < CSPR_REGISTER) { - IntToHex(bufptr + i * 8, 0); - IntToHex(bufptr + (i + 1) * 8, 0); + IntToHex(bufptr + i * CHAR_BIT, 0); + IntToHex(bufptr + (i + 1) * CHAR_BIT, 0); i++; // These registers seem to be all 64bit instead of 32bit, so skip two instead of one reg++; } else if (i > CSPR_REGISTER && i < MAX_REGISTERS) { - IntToHex(bufptr + i * 8, Core::g_app_core->GetVFPReg(reg - CSPR_REGISTER - 1)); - IntToHex(bufptr + (i + 1) * 8, 0); + IntToHex(bufptr + i * CHAR_BIT, Core::g_app_core->GetVFPReg(reg - CSPR_REGISTER - 1)); + IntToHex(bufptr + (i + 1) * CHAR_BIT, 0); i++; } else if (i == MAX_REGISTERS) { - IntToHex(bufptr + i * 8, Core::g_app_core->GetVFPSystemReg(VFP_FPSCR)); + IntToHex(bufptr + i * CHAR_BIT, Core::g_app_core->GetVFPSystemReg(VFP_FPSCR)); } } @@ -531,17 +531,17 @@ static void WriteRegisters() { for (int i = 0, reg = 0; i <= MAX_REGISTERS; i++, reg++) { if (i <= R15_REGISTER) { - Core::g_app_core->SetReg(reg, HexToInt(buffer_ptr + i * 8)); + Core::g_app_core->SetReg(reg, HexToInt(buffer_ptr + i * CHAR_BIT)); } else if (i == CSPR_REGISTER) { - Core::g_app_core->SetCPSR(HexToInt(buffer_ptr + i * 8)); + Core::g_app_core->SetCPSR(HexToInt(buffer_ptr + i * CHAR_BIT)); } else if (i < CSPR_REGISTER) { i++; // These registers seem to be all 64bit instead of 32bit, so skip two instead of one reg++; } else if (i > CSPR_REGISTER && i < MAX_REGISTERS) { - Core::g_app_core->SetVFPReg(reg - CSPR_REGISTER - 1, HexToInt(buffer_ptr + i * 8)); + Core::g_app_core->SetVFPReg(reg - CSPR_REGISTER - 1, HexToInt(buffer_ptr + i * CHAR_BIT)); i++; // Skip padding } else if (i == MAX_REGISTERS) { - Core::g_app_core->SetVFPSystemReg(VFP_FPSCR, HexToInt(buffer_ptr + i * 8)); + Core::g_app_core->SetVFPSystemReg(VFP_FPSCR, HexToInt(buffer_ptr + i * CHAR_BIT)); } } -- cgit v1.2.3 From a7eb6a4045c2fa2b9b674ddc6c749c1cb7532b9d Mon Sep 17 00:00:00 2001 From: polaris- Date: Thu, 22 Oct 2015 00:31:49 -0400 Subject: Add some headers so TravisCI will hopefully work --- src/core/gdbstub/gdbstub.cpp | 2 ++ 1 file changed, 2 insertions(+) (limited to 'src/core') diff --git a/src/core/gdbstub/gdbstub.cpp b/src/core/gdbstub/gdbstub.cpp index b226b431a..5568df21b 100644 --- a/src/core/gdbstub/gdbstub.cpp +++ b/src/core/gdbstub/gdbstub.cpp @@ -4,11 +4,13 @@ // Originally written by Sven Peter for anergistic. +#include #include #include #include #include #include +#include #include #include -- cgit v1.2.3 From b6422038b57c32c9842d8da506d40cc6872a1546 Mon Sep 17 00:00:00 2001 From: polaris- Date: Thu, 29 Oct 2015 06:17:29 -0400 Subject: Change headers --- src/core/gdbstub/gdbstub.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/core') diff --git a/src/core/gdbstub/gdbstub.cpp b/src/core/gdbstub/gdbstub.cpp index 5568df21b..e37a2efd7 100644 --- a/src/core/gdbstub/gdbstub.cpp +++ b/src/core/gdbstub/gdbstub.cpp @@ -5,12 +5,12 @@ // Originally written by Sven Peter for anergistic. #include +#include #include #include #include #include #include -#include #include #include @@ -34,7 +34,7 @@ #include "core/core.h" #include "core/memory.h" #include "core/arm/arm_interface.h" -#include "gdbstub.h" +#include "core/gdbstub/gdbstub.h" const int GDB_BUFFER_SIZE = 10000; -- cgit v1.2.3 From bcea9599100a0df945629cd50be066ae9dabf89f Mon Sep 17 00:00:00 2001 From: polaris- Date: Tue, 3 Nov 2015 21:50:53 -0500 Subject: Fix bug with reading addresses and lengths --- src/core/gdbstub/gdbstub.cpp | 100 ++++++++++++++++++++++++------------------- 1 file changed, 55 insertions(+), 45 deletions(-) (limited to 'src/core') diff --git a/src/core/gdbstub/gdbstub.cpp b/src/core/gdbstub/gdbstub.cpp index e37a2efd7..003ce4167 100644 --- a/src/core/gdbstub/gdbstub.cpp +++ b/src/core/gdbstub/gdbstub.cpp @@ -126,6 +126,22 @@ static u8 NibbleToHex(u8 n) { } } +/** +* Converts input hex string characters into an array of equivalent of u8 bytes. +* +* @param dest Pointer to buffer to store u8 bytes. +* @param src Pointer to array of output hex string characters. +* @param len Length of src array. +*/ +static u32 HexToInt(u8* src, u32 len) { + u32 output = 0; + while (len-- > 0) { + output = (output << 4) | HexCharToValue(src[0]); + src++; + } + return output; +} + /** * Converts input array of u8 bytes into their equivalent hex string characters. * @@ -133,7 +149,7 @@ static u8 NibbleToHex(u8 n) { * @param src Pointer to array of u8 bytes. * @param len Length of src array. */ -static void MemToHex(u8* dest, u8* src, u32 len) { +static void MemToGdbHex(u8* dest, u8* src, u32 len) { while (len-- > 0) { u8 tmp = *src++; *dest++ = NibbleToHex(tmp >> 4); @@ -142,13 +158,13 @@ static void MemToHex(u8* dest, u8* src, u32 len) { } /** - * Converts input hex string characters into an array of equivalent of u8 bytes. + * Converts input gdb-formatted hex string characters into an array of equivalent of u8 bytes. * * @param dest Pointer to buffer to store u8 bytes. * @param src Pointer to array of output hex string characters. * @param len Length of src array. */ -static void HexToMem(u8* dest, u8* src, u32 len) { +static void GdbHexToMem(u8* dest, u8* src, u32 len) { while (len-- > 0) { *dest++ = (HexCharToValue(src[0]) << 4) | HexCharToValue(src[1]); src += 2; @@ -156,11 +172,11 @@ static void HexToMem(u8* dest, u8* src, u32 len) { } /** - * Convert a u32 into a hex string. + * Convert a u32 into a gdb-formatted hex string. * * @param dest Pointer to buffer to store output hex string characters. */ -static void IntToHex(u8* dest, u32 v) { +static void IntToGdbHex(u8* dest, u32 v) { for (int i = 0; i < 8; i += 2) { dest[i + 1] = NibbleToHex(v >> (4 * i)); dest[i] = NibbleToHex(v >> (4 * (i + 1))); @@ -168,11 +184,11 @@ static void IntToHex(u8* dest, u32 v) { } /** - * Convert a hex string into a u32. + * Convert a gdb-formatted hex string into a u32. * * @param src Pointer to hex string. */ -static u32 HexToInt(u8* src) { +static u32 GdbHexToInt(u8* src) { u32 output = 0; for (int i = 0; i < 8; i += 2) { @@ -455,14 +471,14 @@ static void ReadRegister() { } if (id >= R0_REGISTER && id <= R15_REGISTER) { - IntToHex(reply, Core::g_app_core->GetReg(id)); + IntToGdbHex(reply, Core::g_app_core->GetReg(id)); } else if (id == CSPR_REGISTER) { - IntToHex(reply, Core::g_app_core->GetCPSR()); + IntToGdbHex(reply, Core::g_app_core->GetCPSR()); } else if (id > CSPR_REGISTER && id < FPSCR_REGISTER) { - IntToHex(reply, Core::g_app_core->GetVFPReg(id - CSPR_REGISTER - 1)); // VFP registers should start at 26, so one after CSPR_REGISTER + IntToGdbHex(reply, Core::g_app_core->GetVFPReg(id - CSPR_REGISTER - 1)); // VFP registers should start at 26, so one after CSPR_REGISTER } else if (id == FPSCR_REGISTER) { - IntToHex(reply, Core::g_app_core->GetVFPSystemReg(VFP_FPSCR)); // Get FPSCR - IntToHex(reply + 8, 0); + IntToGdbHex(reply, Core::g_app_core->GetVFPSystemReg(VFP_FPSCR)); // Get FPSCR + IntToGdbHex(reply + 8, 0); } else { return SendReply("E01"); } @@ -478,20 +494,20 @@ static void ReadRegisters() { u8* bufptr = buffer; for (int i = 0, reg = 0; i <= MAX_REGISTERS; i++, reg++) { if (i <= R15_REGISTER) { - IntToHex(bufptr + i * CHAR_BIT, Core::g_app_core->GetReg(reg)); + IntToGdbHex(bufptr + i * CHAR_BIT, Core::g_app_core->GetReg(reg)); } else if (i == CSPR_REGISTER) { - IntToHex(bufptr + i * CHAR_BIT, Core::g_app_core->GetCPSR()); + IntToGdbHex(bufptr + i * CHAR_BIT, Core::g_app_core->GetCPSR()); } else if (i < CSPR_REGISTER) { - IntToHex(bufptr + i * CHAR_BIT, 0); - IntToHex(bufptr + (i + 1) * CHAR_BIT, 0); + IntToGdbHex(bufptr + i * CHAR_BIT, 0); + IntToGdbHex(bufptr + (i + 1) * CHAR_BIT, 0); i++; // These registers seem to be all 64bit instead of 32bit, so skip two instead of one reg++; } else if (i > CSPR_REGISTER && i < MAX_REGISTERS) { - IntToHex(bufptr + i * CHAR_BIT, Core::g_app_core->GetVFPReg(reg - CSPR_REGISTER - 1)); - IntToHex(bufptr + (i + 1) * CHAR_BIT, 0); + IntToGdbHex(bufptr + i * CHAR_BIT, Core::g_app_core->GetVFPReg(reg - CSPR_REGISTER - 1)); + IntToGdbHex(bufptr + (i + 1) * CHAR_BIT, 0); i++; } else if (i == MAX_REGISTERS) { - IntToHex(bufptr + i * CHAR_BIT, Core::g_app_core->GetVFPSystemReg(VFP_FPSCR)); + IntToGdbHex(bufptr + i * CHAR_BIT, Core::g_app_core->GetVFPSystemReg(VFP_FPSCR)); } } @@ -510,13 +526,13 @@ static void WriteRegister() { } if (id >= R0_REGISTER && id <= R15_REGISTER) { - Core::g_app_core->SetReg(id, HexToInt(buffer_ptr)); + Core::g_app_core->SetReg(id, GdbHexToInt(buffer_ptr)); } else if (id == CSPR_REGISTER) { - Core::g_app_core->SetCPSR(HexToInt(buffer_ptr)); + Core::g_app_core->SetCPSR(GdbHexToInt(buffer_ptr)); } else if (id > CSPR_REGISTER && id < FPSCR_REGISTER) { - Core::g_app_core->SetVFPReg(id - CSPR_REGISTER - 1, HexToInt(buffer_ptr)); + Core::g_app_core->SetVFPReg(id - CSPR_REGISTER - 1, GdbHexToInt(buffer_ptr)); } else if (id == FPSCR_REGISTER) { - Core::g_app_core->SetVFPSystemReg(VFP_FPSCR, HexToInt(buffer_ptr)); + Core::g_app_core->SetVFPSystemReg(VFP_FPSCR, GdbHexToInt(buffer_ptr)); } else { return SendReply("E01"); } @@ -533,17 +549,17 @@ static void WriteRegisters() { for (int i = 0, reg = 0; i <= MAX_REGISTERS; i++, reg++) { if (i <= R15_REGISTER) { - Core::g_app_core->SetReg(reg, HexToInt(buffer_ptr + i * CHAR_BIT)); + Core::g_app_core->SetReg(reg, GdbHexToInt(buffer_ptr + i * CHAR_BIT)); } else if (i == CSPR_REGISTER) { - Core::g_app_core->SetCPSR(HexToInt(buffer_ptr + i * CHAR_BIT)); + Core::g_app_core->SetCPSR(GdbHexToInt(buffer_ptr + i * CHAR_BIT)); } else if (i < CSPR_REGISTER) { i++; // These registers seem to be all 64bit instead of 32bit, so skip two instead of one reg++; } else if (i > CSPR_REGISTER && i < MAX_REGISTERS) { - Core::g_app_core->SetVFPReg(reg - CSPR_REGISTER - 1, HexToInt(buffer_ptr + i * CHAR_BIT)); + Core::g_app_core->SetVFPReg(reg - CSPR_REGISTER - 1, GdbHexToInt(buffer_ptr + i * CHAR_BIT)); i++; // Skip padding } else if (i == MAX_REGISTERS) { - Core::g_app_core->SetVFPSystemReg(VFP_FPSCR, HexToInt(buffer_ptr + i * CHAR_BIT)); + Core::g_app_core->SetVFPSystemReg(VFP_FPSCR, GdbHexToInt(buffer_ptr + i * CHAR_BIT)); } } @@ -556,12 +572,12 @@ static void ReadMemory() { auto start_offset = command_buffer+1; auto addr_pos = std::find(start_offset, command_buffer+command_length, ','); - PAddr addr = 0; - HexToMem((u8*)&addr, start_offset, (addr_pos - start_offset) / 2); + PAddr addr = HexToInt(start_offset, addr_pos - start_offset); start_offset = addr_pos+1; - u32 len = 0; - HexToMem((u8*)&len, start_offset, ((command_buffer + command_length) - start_offset) / 2); + u32 len = HexToInt(start_offset, (command_buffer + command_length) - start_offset); + + LOG_DEBUG(Debug_GDBStub, "gdb: addr: %08x len: %08x\n", addr, len); if (len * 2 > sizeof(reply)) { SendReply("E01"); @@ -572,7 +588,7 @@ static void ReadMemory() { return SendReply("E0"); } - MemToHex(reply, data, len); + MemToGdbHex(reply, data, len); reply[len * 2] = '\0'; SendReply(reinterpret_cast(reply)); } @@ -581,20 +597,18 @@ static void ReadMemory() { static void WriteMemory() { auto start_offset = command_buffer+1; auto addr_pos = std::find(start_offset, command_buffer+command_length, ','); - PAddr addr = 0; - HexToMem((u8*)&addr, start_offset, (addr_pos - start_offset) / 2); + PAddr addr = HexToInt(start_offset, addr_pos - start_offset); start_offset = addr_pos+1; auto len_pos = std::find(start_offset, command_buffer+command_length, ':'); - u32 len = 0; - HexToMem((u8*)&len, start_offset, (len_pos - start_offset) / 2); + u32 len = HexToInt(start_offset, len_pos - start_offset); u8* dst = Memory::GetPointer(addr); if (!dst) { return SendReply("E00"); } - HexToMem(dst, len_pos + 1, len); + GdbHexToMem(dst, len_pos + 1, len); SendReply("OK"); } @@ -677,12 +691,10 @@ static void AddBreakpoint() { auto start_offset = command_buffer+3; auto addr_pos = std::find(start_offset, command_buffer+command_length, ','); - PAddr addr = 0; - HexToMem((u8*)&addr, start_offset, (addr_pos - start_offset) / 2); + PAddr addr = HexToInt(start_offset, addr_pos - start_offset); start_offset = addr_pos+1; - u32 len = 0; - HexToMem((u8*)&len, start_offset, ((command_buffer + command_length) - start_offset) / 2); + u32 len = HexToInt(start_offset, (command_buffer + command_length) - start_offset); if (type == BreakpointType::Access) { // Access is made up of Read and Write types, so add both breakpoints @@ -727,12 +739,10 @@ static void RemoveBreakpoint() { auto start_offset = command_buffer+3; auto addr_pos = std::find(start_offset, command_buffer+command_length, ','); - PAddr addr = 0; - HexToMem((u8*)&addr, start_offset, (addr_pos - start_offset) / 2); + PAddr addr = HexToInt(start_offset, addr_pos - start_offset); start_offset = addr_pos+1; - u32 len = 0; - HexToMem((u8*)&len, start_offset, ((command_buffer + command_length) - start_offset) / 2); + u32 len = HexToInt(start_offset, (command_buffer + command_length) - start_offset); if (type == BreakpointType::Access) { // Access is made up of Read and Write types, so add both breakpoints -- cgit v1.2.3