Signed-off-by: Zebediah Figura z.figura12@gmail.com --- programs/winedbg/gdbproxy.c | 324 ++++++++++++++------------------------------ 1 file changed, 99 insertions(+), 225 deletions(-)
diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c index b8387fe..61a9e12 100644 --- a/programs/winedbg/gdbproxy.c +++ b/programs/winedbg/gdbproxy.c @@ -63,14 +63,9 @@ #include "windef.h" #include "winbase.h" #include "tlhelp32.h" +#include "wine/debug.h"
-#define GDBPXY_TRC_LOWLEVEL 0x01 -#define GDBPXY_TRC_PACKET 0x02 -#define GDBPXY_TRC_COMMAND 0x04 -#define GDBPXY_TRC_COMMAND_ERROR 0x08 -#define GDBPXY_TRC_WIN32_EVENT 0x10 -#define GDBPXY_TRC_WIN32_ERROR 0x20 -#define GDBPXY_TRC_COMMAND_FIXME 0x80 +WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
struct gdb_context { @@ -91,7 +86,6 @@ struct gdb_context /* generic GDB thread information */ struct dbg_thread* exec_thread; /* thread used in step & continue */ struct dbg_thread* other_thread; /* thread to be used in any other operation */ - unsigned trace; /* current Win32 trap env */ unsigned last_sig; BOOL in_trap; @@ -234,7 +228,7 @@ static inline DWORD64 cpu_register(struct gdb_context *gdbctx, case 4: return *(DWORD*)cpu_register_ptr(gdbctx, ctx, idx); case 8: return *(DWORD64*)cpu_register_ptr(gdbctx, ctx, idx); default: - fprintf(stderr, "got unexpected size: %u\n", + ERR("got unexpected size: %u\n", (unsigned)gdbctx->process->be_cpu->gdb_register_map[idx].ctx_length); assert(0); return 0; @@ -280,8 +274,7 @@ static BOOL fetch_context(struct gdb_context *gdbctx, HANDLE h, dbg_ctx_t *ctx) { if (!gdbctx->process->be_cpu->get_context(h, ctx)) { - if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) - fprintf(stderr, "Can't get thread's context\n"); + ERR("Failed to get context, error %u\n", GetLastError()); return FALSE; } return TRUE; @@ -360,12 +353,11 @@ static BOOL handle_exception(struct gdb_context* gdbctx, EXCEPTION_DEBUG_INFO* e } } else - fprintf(stderr, "Cannot set name of thread %04x\n", threadname->dwThreadID); + ERR("Cannot set name of thread %04x\n", threadname->dwThreadID); return DBG_CONTINUE; } default: - if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) - fprintf(stderr, "Unhandled exception code 0x%08x\n", rec->ExceptionCode); + fprintf(stderr, "Unhandled exception code 0x%08x\n", rec->ExceptionCode); gdbctx->last_sig = SIGABRT; ret = TRUE; break; @@ -394,8 +386,7 @@ static void handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de) u.buffer, ARRAY_SIZE(u.buffer)); dbg_set_process_name(gdbctx->process, u.buffer);
- if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) - fprintf(stderr, "%04x:%04x: create process '%s'/%p @%p (%u<%u>)\n", + fprintf(stderr, "%04x:%04x: create process '%s'/%p @%p (%u<%u>)\n", de->dwProcessId, de->dwThreadId, dbg_W2A(u.buffer, -1), de->u.CreateProcessInfo.lpImageName, @@ -405,12 +396,10 @@ static void handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de)
/* de->u.CreateProcessInfo.lpStartAddress; */ if (!dbg_init(gdbctx->process->handle, u.buffer, TRUE)) - fprintf(stderr, "Couldn't initiate DbgHelp\n"); + ERR("Couldn't initiate DbgHelp\n");
- if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) - fprintf(stderr, "%04x:%04x: create thread I @%p\n", - de->dwProcessId, de->dwThreadId, - de->u.CreateProcessInfo.lpStartAddress); + fprintf(stderr, "%04x:%04x: create thread I @%p\n", de->dwProcessId, + de->dwThreadId, de->u.CreateProcessInfo.lpStartAddress);
assert(dbg_curr_thread == NULL); /* shouldn't be there */ dbg_add_thread(gdbctx->process, de->dwThreadId, @@ -424,31 +413,27 @@ static void handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de) de->u.LoadDll.lpImageName, de->u.LoadDll.fUnicode, u.buffer, ARRAY_SIZE(u.buffer)); - if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) - fprintf(stderr, "%04x:%04x: loads DLL %s @%p (%u<%u>)\n", - de->dwProcessId, de->dwThreadId, - dbg_W2A(u.buffer, -1), - de->u.LoadDll.lpBaseOfDll, - de->u.LoadDll.dwDebugInfoFileOffset, - de->u.LoadDll.nDebugInfoSize); + fprintf(stderr, "%04x:%04x: loads DLL %s @%p (%u<%u>)\n", + de->dwProcessId, de->dwThreadId, + dbg_W2A(u.buffer, -1), + de->u.LoadDll.lpBaseOfDll, + de->u.LoadDll.dwDebugInfoFileOffset, + de->u.LoadDll.nDebugInfoSize); dbg_load_module(gdbctx->process->handle, de->u.LoadDll.hFile, u.buffer, (DWORD_PTR)de->u.LoadDll.lpBaseOfDll, 0); break;
case UNLOAD_DLL_DEBUG_EVENT: - if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) - fprintf(stderr, "%08x:%08x: unload DLL @%p\n", - de->dwProcessId, de->dwThreadId, de->u.UnloadDll.lpBaseOfDll); + fprintf(stderr, "%08x:%08x: unload DLL @%p\n", + de->dwProcessId, de->dwThreadId, de->u.UnloadDll.lpBaseOfDll); SymUnloadModule(gdbctx->process->handle, (DWORD_PTR)de->u.UnloadDll.lpBaseOfDll); break;
case EXCEPTION_DEBUG_EVENT: assert(dbg_curr_thread); - if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) - fprintf(stderr, "%08x:%08x: exception code=0x%08x\n", - de->dwProcessId, de->dwThreadId, - de->u.Exception.ExceptionRecord.ExceptionCode); + fprintf(stderr, "%08x:%08x: exception code=0x%08x\n", de->dwProcessId, + de->dwThreadId, de->u.Exception.ExceptionRecord.ExceptionCode);
if (fetch_context(gdbctx, dbg_curr_thread->handle, &gdbctx->context)) { @@ -457,9 +442,8 @@ static void handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de) break;
case CREATE_THREAD_DEBUG_EVENT: - if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) - fprintf(stderr, "%08x:%08x: create thread D @%p\n", - de->dwProcessId, de->dwThreadId, de->u.CreateThread.lpStartAddress); + fprintf(stderr, "%08x:%08x: create thread D @%p\n", de->dwProcessId, + de->dwThreadId, de->u.CreateThread.lpStartAddress);
dbg_add_thread(gdbctx->process, de->dwThreadId, @@ -468,9 +452,8 @@ static void handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de) break;
case EXIT_THREAD_DEBUG_EVENT: - if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) - fprintf(stderr, "%08x:%08x: exit thread (%u)\n", - de->dwProcessId, de->dwThreadId, de->u.ExitThread.dwExitCode); + fprintf(stderr, "%08x:%08x: exit thread (%u)\n", + de->dwProcessId, de->dwThreadId, de->u.ExitThread.dwExitCode);
assert(dbg_curr_thread); if (dbg_curr_thread == gdbctx->exec_thread) gdbctx->exec_thread = NULL; @@ -479,9 +462,8 @@ static void handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de) break;
case EXIT_PROCESS_DEBUG_EVENT: - if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) - fprintf(stderr, "%08x:%08x: exit process (%u)\n", - de->dwProcessId, de->dwThreadId, de->u.ExitProcess.dwExitCode); + fprintf(stderr, "%08x:%08x: exit process (%u)\n", + de->dwProcessId, de->dwThreadId, de->u.ExitProcess.dwExitCode);
dbg_del_process(gdbctx->process); gdbctx->process = NULL; @@ -495,22 +477,18 @@ static void handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de) memory_get_string(gdbctx->process, de->u.DebugString.lpDebugStringData, TRUE, de->u.DebugString.fUnicode, u.bufferA, sizeof(u.bufferA)); - if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) - fprintf(stderr, "%08x:%08x: output debug string (%s)\n", - de->dwProcessId, de->dwThreadId, u.bufferA); + fprintf(stderr, "%08x:%08x: output debug string (%s)\n", + de->dwProcessId, de->dwThreadId, debugstr_a(u.bufferA)); break;
case RIP_EVENT: - if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) - fprintf(stderr, "%08x:%08x: rip error=%u type=%u\n", - de->dwProcessId, de->dwThreadId, de->u.RipInfo.dwError, - de->u.RipInfo.dwType); + fprintf(stderr, "%08x:%08x: rip error=%u type=%u\n", de->dwProcessId, + de->dwThreadId, de->u.RipInfo.dwError, de->u.RipInfo.dwType); break;
default: - if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) - fprintf(stderr, "%08x:%08x: unknown event (%u)\n", - de->dwProcessId, de->dwThreadId, de->dwDebugEventCode); + FIXME("%08x:%08x: unknown event (%u)\n", + de->dwProcessId, de->dwThreadId, de->dwDebugEventCode); } }
@@ -519,15 +497,14 @@ static void resume_debuggee(struct gdb_context* gdbctx, DWORD cont) if (dbg_curr_thread) { if (!gdbctx->process->be_cpu->set_context(dbg_curr_thread->handle, &gdbctx->context)) - if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) - fprintf(stderr, "Cannot set context on thread %04x\n", dbg_curr_thread->tid); + ERR("Failed to set context for thread %04x, error %u\n", + dbg_curr_thread->tid, GetLastError()); if (!ContinueDebugEvent(gdbctx->process->pid, dbg_curr_thread->tid, cont)) - if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) - fprintf(stderr, "Cannot continue on %04x (%x)\n", - dbg_curr_thread->tid, cont); + ERR("Failed to continue thread %04x, error %u\n", + dbg_curr_thread->tid, GetLastError()); } - else if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) - fprintf(stderr, "Cannot find last thread\n"); + else + ERR("Cannot find last thread\n"); }
@@ -539,16 +516,15 @@ static void resume_debuggee_thread(struct gdb_context* gdbctx, DWORD cont, unsig if(dbg_curr_thread->tid == threadid){ /* Windows debug and GDB don't seem to work well here, windows only likes ContinueDebugEvent being used on the reporter of the event */ if (!gdbctx->process->be_cpu->set_context(dbg_curr_thread->handle, &gdbctx->context)) - if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) - fprintf(stderr, "Cannot set context on thread %04x\n", dbg_curr_thread->tid); + ERR("Failed to set context for thread %04x, error %u\n", + dbg_curr_thread->tid, GetLastError()); if (!ContinueDebugEvent(gdbctx->process->pid, dbg_curr_thread->tid, cont)) - if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) - fprintf(stderr, "Cannot continue on %04x (%x)\n", - dbg_curr_thread->tid, cont); + ERR("Failed to continue thread %04x, error %u\n", + dbg_curr_thread->tid, GetLastError()); } } - else if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) - fprintf(stderr, "Cannot find last thread\n"); + else + ERR("Cannot find last thread\n"); }
static BOOL check_for_interrupt(struct gdb_context* gdbctx) @@ -564,20 +540,16 @@ static BOOL check_for_interrupt(struct gdb_context* gdbctx) if ((ret = poll(&pollfd, 1, 0)) == 1) { ret = read(gdbctx->sock, &pkt, 1); if (ret != 1) { - if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) { - fprintf(stderr, "read failed\n"); - } + ERR("read failed\n"); return FALSE; } if (pkt != '\003') { - if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) { - fprintf(stderr, "Unexpected break packet (%c/0x%X)\n", pkt, pkt); - } + ERR("Unexpected break packet %#02x\n", pkt); return FALSE; } return TRUE; } else if (ret == -1) { - fprintf(stderr, "poll failed\n"); + ERR("poll failed\n"); } return FALSE; } @@ -595,9 +567,7 @@ static void wait_for_debuggee(struct gdb_context* gdbctx) { if (check_for_interrupt(gdbctx)) { if (!DebugBreakProcess(gdbctx->process->handle)) { - if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) { - fprintf(stderr, "Failed to break into debugee\n"); - } + ERR("Failed to break into debugee\n"); break; } WaitForDebugEvent(&de, INFINITE); @@ -794,9 +764,6 @@ static void packet_reply_close(struct gdb_context* gdbctx) packet_reply_catc(gdbctx, '#'); cksum = checksum(&gdbctx->out_buf[gdbctx->out_curr_packet], plen); packet_reply_hex_to(gdbctx, &cksum, 1); - if (gdbctx->trace & GDBPXY_TRC_PACKET) - fprintf(stderr, "Reply : %*.*s\n", - plen, plen, &gdbctx->out_buf[gdbctx->out_curr_packet]); gdbctx->out_curr_packet = -1; }
@@ -914,9 +881,8 @@ static enum packet_return packet_continue(struct gdb_context* gdbctx) /* FIXME: add support for address in packet */ assert(gdbctx->in_packet_len == 0); if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread) - if (gdbctx->trace & GDBPXY_TRC_COMMAND_FIXME) - fprintf(stderr, "NIY: cont on %04x, while last thread is %04x\n", - gdbctx->exec_thread->tid, dbg_curr_thread->tid); + FIXME("Can't continue thread %04x while on thread %04x\n", + gdbctx->exec_thread->tid, dbg_curr_thread->tid); resume_debuggee(gdbctx, DBG_CONTINUE); wait_for_debuggee(gdbctx); return packet_reply_status(gdbctx); @@ -965,13 +931,6 @@ static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx) return packet_done; }
- /* This may not be the 'fastest' code in the world. but it should be nice and easy to debug. - (as it's run when people are debugging break points I'm sure they won't notice the extra 100 cycles anyway) - now if only gdb talked XML.... */ -#if 0 /* handy for debugging */ - fprintf(stderr, "no, but can we find a default packet %.*s %d\n", gdbctx->in_packet_len, gdbctx->in_packet, gdbctx->in_packet_len); -#endif - /* go through the packet and identify where all the actions start at */ for (i = 4; i < gdbctx->in_packet_len - 1; i++) { @@ -1019,9 +978,8 @@ static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx) * that remains is to apply the actions to the threads and the default action to any threads * left */ if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread) - if (gdbctx->trace & GDBPXY_TRC_COMMAND_FIXME) - fprintf(stderr, "NIY: cont on %04x, while last thread is %04x\n", - gdbctx->exec_thread->tid, dbg_curr_thread->tid); + FIXME("Can't continue thread %04x while on thread %04x\n", + gdbctx->exec_thread->tid, dbg_curr_thread->tid);
/* deal with the threaded stuff first */ for (i = 0; i < actions ; i++) @@ -1054,8 +1012,7 @@ static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx) case 'C': /* continue sig */ hex_from(&sig, gdbctx->in_packet + actionIndex[i] + 2, 1); /* cannot change signals on the fly */ - if (gdbctx->trace & GDBPXY_TRC_COMMAND) - fprintf(stderr, "sigs: %u %u\n", sig, gdbctx->last_sig); + TRACE("sigs: %u %u\n", sig, gdbctx->last_sig); if (sig != gdbctx->last_sig) return packet_error; resume_debuggee_thread(gdbctx, DBG_EXCEPTION_NOT_HANDLED, threadID); @@ -1097,8 +1054,7 @@ static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx) case 'C': /* continue sig */ hex_from(&sig, gdbctx->in_packet + actionIndex[defaultAction] + 2, 1); /* cannot change signals on the fly */ - if (gdbctx->trace & GDBPXY_TRC_COMMAND) - fprintf(stderr, "sigs: %u %u\n", sig, gdbctx->last_sig); + TRACE("sigs: %u %u\n", sig, gdbctx->last_sig); if (sig != gdbctx->last_sig) return packet_error; resume_debuggee_thread(gdbctx, DBG_EXCEPTION_NOT_HANDLED, threadID); @@ -1143,9 +1099,8 @@ static enum packet_return packet_verbose(struct gdb_context* gdbctx) gdbctx->in_packet[klen] == ':' || gdbctx->in_packet[klen] == '?') { - if (gdbctx->trace & GDBPXY_TRC_COMMAND) - fprintf(stderr, "trying to process a verbose packet %*.*s\n", - gdbctx->in_packet_len, gdbctx->in_packet_len, gdbctx->in_packet); + TRACE("Trying to process verbose packet %s\n", + debugstr_an(gdbctx->in_packet, gdbctx->in_packet_len)); for (i = 0; i < ARRAY_SIZE(verbose_details); i++) { if (klen == verbose_details[i].len && @@ -1159,9 +1114,8 @@ static enum packet_return packet_verbose(struct gdb_context* gdbctx) } }
- if (gdbctx->trace & GDBPXY_TRC_COMMAND_FIXME) - fprintf(stderr, "No support for verbose packet %*.*s\n", - gdbctx->in_packet_len, gdbctx->in_packet_len, gdbctx->in_packet); + WARN("No support for verbose packet %s\n", + debugstr_an(gdbctx->in_packet, gdbctx->in_packet_len)); return packet_error; }
@@ -1172,13 +1126,11 @@ static enum packet_return packet_continue_signal(struct gdb_context* gdbctx) /* FIXME: add support for address in packet */ assert(gdbctx->in_packet_len == 2); if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread) - if (gdbctx->trace & GDBPXY_TRC_COMMAND_FIXME) - fprintf(stderr, "NIY: cont/sig on %04x, while last thread is %04x\n", - gdbctx->exec_thread->tid, dbg_curr_thread->tid); + FIXME("Can't continue thread %04x while on thread %04x\n", + gdbctx->exec_thread->tid, dbg_curr_thread->tid); hex_from(&sig, gdbctx->in_packet, 1); /* cannot change signals on the fly */ - if (gdbctx->trace & GDBPXY_TRC_COMMAND) - fprintf(stderr, "sigs: %u %u\n", sig, gdbctx->last_sig); + TRACE("sigs: %u %u\n", sig, gdbctx->last_sig); if (sig != gdbctx->last_sig) return packet_error; resume_debuggee(gdbctx, DBG_EXCEPTION_NOT_HANDLED); @@ -1236,8 +1188,8 @@ static enum packet_return packet_write_registers(struct gdb_context* gdbctx) if (pctx != &gdbctx->context && !gdbctx->process->be_cpu->set_context(gdbctx->other_thread->handle, pctx)) { - if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) - fprintf(stderr, "Cannot set context on thread %04x\n", gdbctx->other_thread->tid); + ERR("Failed to set context for tid %04x, error %u\n", + gdbctx->other_thread->tid, GetLastError()); return packet_error; } return packet_ok; @@ -1271,10 +1223,8 @@ static enum packet_return packet_thread(struct gdb_context* gdbctx) thread = strtol(gdbctx->in_packet + 1, &end, 16); if (end == NULL || end > gdbctx->in_packet + gdbctx->in_packet_len) { - if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) - fprintf(stderr, "Cannot get threadid %*.*s\n", - gdbctx->in_packet_len - 1, gdbctx->in_packet_len - 1, - gdbctx->in_packet + 1); + ERR("Failed to parse %s\n", + debugstr_an(gdbctx->in_packet, gdbctx->in_packet_len)); return packet_error; } if (gdbctx->in_packet[0] == 'c') @@ -1283,8 +1233,7 @@ static enum packet_return packet_thread(struct gdb_context* gdbctx) gdbctx->other_thread = dbg_get_thread(gdbctx->process, thread); return packet_ok; default: - if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) - fprintf(stderr, "Unknown thread sub-command %c\n", gdbctx->in_packet[0]); + FIXME("Unknown thread sub-command %c\n", gdbctx->in_packet[0]); return packet_error; } } @@ -1300,8 +1249,7 @@ static enum packet_return packet_read_memory(struct gdb_context* gdbctx) /* FIXME:check in_packet_len for reading %p,%x */ if (sscanf(gdbctx->in_packet, "%p,%x", &addr, &len) != 2) return packet_error; if (len <= 0) return packet_error; - if (gdbctx->trace & GDBPXY_TRC_COMMAND) - fprintf(stderr, "Read mem at %p for %u bytes\n", addr, len); + TRACE("Read %u bytes at %p\n", len, addr); for (nread = 0; nread < len; nread += r, addr += r) { blk_len = min(sizeof(buffer), len - nread); @@ -1332,28 +1280,23 @@ static enum packet_return packet_write_memory(struct gdb_context* gdbctx) ptr = memchr(gdbctx->in_packet, ':', gdbctx->in_packet_len); if (ptr == NULL) { - if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) - fprintf(stderr, "Cannot find ':' in %*.*s\n", - gdbctx->in_packet_len, gdbctx->in_packet_len, gdbctx->in_packet); + ERR("Cannot find ':' in %s\n", debugstr_an(gdbctx->in_packet, gdbctx->in_packet_len)); return packet_error; } *ptr++ = '\0';
if (sscanf(gdbctx->in_packet, "%p,%x", &addr, &len) != 2) { - if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) - fprintf(stderr, "Cannot scan addr,len in %s\n", gdbctx->in_packet); + ERR("Failed to parse %s\n", debugstr_a(gdbctx->in_packet)); return packet_error; } if (ptr - gdbctx->in_packet + len * 2 != gdbctx->in_packet_len) { - if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) - fprintf(stderr, "Wrong sizes %u <> %u\n", - (int)(ptr - gdbctx->in_packet) + len * 2, gdbctx->in_packet_len); + ERR("Length %u does not match packet length %u\n", + (int)(ptr - gdbctx->in_packet) + len * 2, gdbctx->in_packet_len); return packet_error; } - if (gdbctx->trace & GDBPXY_TRC_COMMAND) - fprintf(stderr, "Write %u bytes at %p\n", len, addr); + TRACE("Write %u bytes at %p\n", len, addr); while (len > 0) { blk_len = min(sizeof(buffer), len); @@ -1378,8 +1321,7 @@ static enum packet_return packet_read_register(struct gdb_context* gdbctx) reg = hex_to_int(gdbctx->in_packet, gdbctx->in_packet_len); if (reg >= gdbctx->process->be_cpu->gdb_num_regs) { - if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) - fprintf(stderr, "Register out of bounds %x\n", reg); + FIXME("Unhandled register %u\n", reg); return packet_error; } if (dbg_curr_thread != gdbctx->other_thread && gdbctx->other_thread) @@ -1387,14 +1329,9 @@ static enum packet_return packet_read_register(struct gdb_context* gdbctx) if (!fetch_context(gdbctx, gdbctx->other_thread->handle, pctx = &ctx)) return packet_error; } - if (gdbctx->trace & GDBPXY_TRC_COMMAND) - { - if (gdbctx->process->be_cpu->gdb_register_map[reg].ctx_length <= sizeof(DWORD64)) - fprintf(stderr, "Read register %x => %08x%08x\n", reg, - (unsigned)(cpu_register(gdbctx, pctx, reg) >> 32), (unsigned)cpu_register(gdbctx, pctx, reg)); - else - fprintf(stderr, "Read register %x\n", reg); - } + + TRACE("%u => %s\n", reg, wine_dbgstr_longlong(cpu_register(gdbctx, pctx, reg))); + packet_reply_open(gdbctx); packet_reply_register_hex_to(gdbctx, reg); packet_reply_close(gdbctx); @@ -1413,18 +1350,16 @@ static enum packet_return packet_write_register(struct gdb_context* gdbctx) reg = strtoul(gdbctx->in_packet, &ptr, 16); if (ptr == NULL || reg >= gdbctx->process->be_cpu->gdb_num_regs || *ptr++ != '=') { - if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) - fprintf(stderr, "Invalid register index %s\n", gdbctx->in_packet); + FIXME("Unhandled register %s\n", + debugstr_an(gdbctx->in_packet, gdbctx->in_packet_len)); /* FIXME: if just the reg is above cpu_num_regs, don't tell gdb * it wouldn't matter too much, and it fakes our support for all regs */ return (ptr == NULL) ? packet_error : packet_ok; } - if (gdbctx->trace & GDBPXY_TRC_COMMAND) - { - int len = gdbctx->in_packet_len - (ptr - gdbctx->in_packet); - fprintf(stderr, "Writing reg %u <= %*.*s\n", reg, len, len, ptr); - } + + TRACE("%u <= %s\n", reg, + debugstr_an(ptr, (int)(gdbctx->in_packet_len - (ptr - gdbctx->in_packet))));
if (dbg_curr_thread != gdbctx->other_thread && gdbctx->other_thread) { @@ -1436,8 +1371,8 @@ static enum packet_return packet_write_register(struct gdb_context* gdbctx) if (pctx != &gdbctx->context && !gdbctx->process->be_cpu->set_context(gdbctx->other_thread->handle, pctx)) { - if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) - fprintf(stderr, "Cannot set context for thread %04x\n", gdbctx->other_thread->tid); + ERR("Failed to set context for tid %04x, error %u\n", + gdbctx->other_thread->tid, GetLastError()); return packet_error; }
@@ -1601,32 +1536,6 @@ static void packet_query_monitor_mem(struct gdb_context* gdbctx, int len, const packet_reply(gdbctx, "OK", 2); }
-static void packet_query_monitor_trace(struct gdb_context* gdbctx, - int len, const char* str) -{ - char buffer[128]; - - if (len == 0) - { - snprintf(buffer, sizeof(buffer), "trace=%x\n", gdbctx->trace); - } - else if (len >= 2 && str[0] == '=') - { - unsigned val = atoi(&str[1]); - snprintf(buffer, sizeof(buffer), "trace: %x => %x\n", gdbctx->trace, val); - gdbctx->trace = val; - } - else - { - /* FIXME: ugly but can use error packet here */ - packet_reply_cat(gdbctx, "E00"); - return; - } - packet_reply_open(gdbctx); - packet_reply_hex_to_str(gdbctx, buffer); - packet_reply_close(gdbctx); -} - struct query_detail { int with_arg; @@ -1640,7 +1549,6 @@ struct query_detail {0, "proc", 4, packet_query_monitor_process}, {0, "process", 7, packet_query_monitor_process}, {0, "mem", 3, packet_query_monitor_mem}, - {1, "trace", 5, packet_query_monitor_trace}, {0, NULL, 0, NULL}, };
@@ -1799,9 +1707,7 @@ static enum packet_return packet_query(struct gdb_context* gdbctx) return packet_reply(gdbctx, target_xml, -1); break; } - if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) - fprintf(stderr, "Unknown or malformed query %*.*s\n", - gdbctx->in_packet_len, gdbctx->in_packet_len, gdbctx->in_packet); + ERR("Unhandled query %s\n", debugstr_an(gdbctx->in_packet, gdbctx->in_packet_len)); return packet_error; }
@@ -1810,9 +1716,8 @@ static enum packet_return packet_step(struct gdb_context* gdbctx) /* FIXME: add support for address in packet */ assert(gdbctx->in_packet_len == 0); if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread) - if (gdbctx->trace & GDBPXY_TRC_COMMAND_FIXME) - fprintf(stderr, "NIY: step on %04x, while last thread is %04x\n", - gdbctx->exec_thread->tid, dbg_curr_thread->tid); + FIXME("Can't single-step thread %04x while on thread %04x\n", + gdbctx->exec_thread->tid, dbg_curr_thread->tid); gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE); resume_debuggee(gdbctx, DBG_CONTINUE); wait_for_debuggee(gdbctx); @@ -1902,17 +1807,13 @@ static BOOL extract_packets(struct gdb_context* gdbctx)
while ((ret & packet_last_f) == 0) { - if (gdbctx->in_len && (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)) - fprintf(stderr, "In-buf: %*.*s\n", - gdbctx->in_len, gdbctx->in_len, gdbctx->in_buf); + TRACE("Packet: %s\n", debugstr_an(gdbctx->in_buf, gdbctx->in_len)); ptr = memchr(gdbctx->in_buf, '$', gdbctx->in_len); if (ptr == NULL) return FALSE; if (ptr != gdbctx->in_buf) { int glen = ptr - gdbctx->in_buf; /* garbage len */ - if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL) - fprintf(stderr, "Removing garbage: %*.*s\n", - glen, glen, gdbctx->in_buf); + WARN("Removing garbage: %s\n", debugstr_an(gdbctx->in_buf, glen)); gdbctx->in_len -= glen; memmove(gdbctx->in_buf, ptr, gdbctx->in_len); } @@ -1939,20 +1840,11 @@ static BOOL extract_packets(struct gdb_context* gdbctx) if (packet_entries[i].key == gdbctx->in_buf[1]) break; } if (i == ARRAY_SIZE(packet_entries)) - { - if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) - fprintf(stderr, "Unknown packet request %*.*s\n", - plen, plen, &gdbctx->in_buf[1]); - } + WARN("Unhandled packet %s\n", debugstr_an(&gdbctx->in_buf[1], plen)); else { gdbctx->in_packet = gdbctx->in_buf + 2; gdbctx->in_packet_len = plen - 1; - if (gdbctx->trace & GDBPXY_TRC_PACKET) - fprintf(stderr, "Packet: %c%*.*s\n", - gdbctx->in_buf[1], - gdbctx->in_packet_len, gdbctx->in_packet_len, - gdbctx->in_packet); ret = (packet_entries[i].handler)(gdbctx); } switch (ret & ~packet_last_f) @@ -1961,9 +1853,7 @@ static BOOL extract_packets(struct gdb_context* gdbctx) case packet_ok: packet_reply(gdbctx, "OK", 2); break; case packet_done: break; } - if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL) - fprintf(stderr, "Reply-full: %*.*s\n", - gdbctx->out_len, gdbctx->out_len, gdbctx->out_buf); + TRACE("Reply: %s\n", debugstr_an(gdbctx->out_buf, gdbctx->out_len)); i = write(gdbctx->sock, gdbctx->out_buf, gdbctx->out_len); assert(i == gdbctx->out_len); /* if this fails, we'll have to use POLLOUT... @@ -1984,15 +1874,13 @@ static BOOL extract_packets(struct gdb_context* gdbctx) * This would allow us to send the reply with the '+' character (Ack of * the command) way sooner than we do now. */ - if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL) - fprintf(stderr, "Dropping packet, I was too slow to respond\n"); + ERR("Dropping packet; I was too slow to respond\n"); } } else { write(gdbctx->sock, "+", 1); - if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL) - fprintf(stderr, "Dropping packet, invalid checksum %d <> %d\n", in_cksum, loc_cksum); + ERR("Dropping packet; invalid checksum %d <> %d\n", in_cksum, loc_cksum); } gdbctx->in_len -= plen + 4; memmove(gdbctx->in_buf, end + 3, gdbctx->in_len); @@ -2011,18 +1899,12 @@ static int fetch_data(struct gdb_context* gdbctx) if (gdbctx->in_len + STEP > gdbctx->in_buf_alloc) gdbctx->in_buf = packet_realloc(gdbctx->in_buf, gdbctx->in_buf_alloc += STEP); #undef STEP - if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL) - fprintf(stderr, "%d %d %*.*s\n", - gdbctx->in_len, gdbctx->in_buf_alloc, - gdbctx->in_len, gdbctx->in_len, gdbctx->in_buf); len = read(gdbctx->sock, gdbctx->in_buf + gdbctx->in_len, gdbctx->in_buf_alloc - gdbctx->in_len); if (len <= 0) break; gdbctx->in_len += len; assert(gdbctx->in_len <= gdbctx->in_buf_alloc); if (len < gdbctx->in_buf_alloc - gdbctx->in_len) break; } - if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL) - fprintf(stderr, "=> %d\n", gdbctx->in_len - in_len); return gdbctx->in_len - in_len; }
@@ -2045,7 +1927,6 @@ static BOOL gdb_exec(const char* wine_path, unsigned port, unsigned flags) if ((f = fdopen(fd, "w+")) == NULL) return FALSE; fprintf(f, "file %s\n", wine_path); fprintf(f, "target remote localhost:%d\n", ntohs(port)); - fprintf(f, "monitor trace=%d\n", GDBPXY_TRC_COMMAND_FIXME); fprintf(f, "set prompt Wine-gdb>\ \n"); /* gdb 5.1 seems to require it, won't hurt anyway */ fprintf(f, "sharedlibrary\n"); @@ -2080,8 +1961,7 @@ static BOOL gdb_startup(struct gdb_context* gdbctx, DEBUG_EVENT* de, unsigned fl /* step 1: create socket for gdb connection request */ if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) { - if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL) - fprintf(stderr, "Can't create socket"); + ERR("Failed to create socket: %s\n", strerror(errno)); return FALSE; }
@@ -2108,7 +1988,7 @@ static BOOL gdb_startup(struct gdb_context* gdbctx, DEBUG_EVENT* de, unsigned fl switch (fork()) { case -1: /* error in parent... */ - fprintf(stderr, "Cannot create gdb\n"); + ERR("Failed to start gdb: fork: %s\n", strerror(errno)); goto cleanup; default: /* in parent... success */ signal(SIGINT, SIG_IGN); @@ -2134,8 +2014,7 @@ static BOOL gdb_startup(struct gdb_context* gdbctx, DEBUG_EVENT* de, unsigned fl if (gdbctx->sock == -1) break; ret = TRUE; - if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL) - fprintf(stderr, "Connected on %d\n", gdbctx->sock); + TRACE("connected on %d\n", gdbctx->sock); /* don't keep our small packets too long: send them ASAP back to GDB * without this, GDB really crawls */ @@ -2143,12 +2022,10 @@ static BOOL gdb_startup(struct gdb_context* gdbctx, DEBUG_EVENT* de, unsigned fl } break; case 0: - if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL) - fprintf(stderr, "Poll for cnx failed (timeout)\n"); + ERR("Timed out connecting to gdb\n"); break; case -1: - if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL) - fprintf(stderr, "Poll for cnx failed (error)\n"); + ERR("Failed to connect to gdb: poll: %s\n", strerror(errno)); break; default: assert(0); @@ -2176,7 +2053,6 @@ static BOOL gdb_init_context(struct gdb_context* gdbctx, unsigned flags, unsigne gdbctx->exec_thread = gdbctx->other_thread = NULL; gdbctx->last_sig = 0; gdbctx->in_trap = FALSE; - gdbctx->trace = /*GDBPXY_TRC_PACKET | GDBPXY_TRC_COMMAND |*/ GDBPXY_TRC_COMMAND_ERROR | GDBPXY_TRC_COMMAND_FIXME | GDBPXY_TRC_WIN32_EVENT; gdbctx->process = NULL; for (i = 0; i < ARRAY_SIZE(gdbctx->wine_segs); i++) gdbctx->wine_segs[i] = 0; @@ -2221,8 +2097,7 @@ static int gdb_remote(unsigned flags, unsigned port) /* got something */ if (pollfd.revents & (POLLHUP | POLLERR)) { - if (gdbctx.trace & GDBPXY_TRC_LOWLEVEL) - fprintf(stderr, "Gdb hung up\n"); + ERR("gdb hung up\n"); /* kill also debuggee process - questionnable - */ detach_debuggee(&gdbctx, TRUE); doLoop = FALSE; @@ -2237,8 +2112,7 @@ static int gdb_remote(unsigned flags, unsigned port) /* timeout, should never happen (infinite timeout) */ break; case -1: - if (gdbctx.trace & GDBPXY_TRC_LOWLEVEL) - fprintf(stderr, "Poll failed\n"); + ERR("poll failed: %s\n", strerror(errno)); doLoop = FALSE; break; }