[PATCH 3/3] programs/winedbg: rework printing of pointer values
Eric Pouech
eric.pouech at gmail.com
Thu Feb 17 07:04:27 CST 2022
mainly, no longer using %p to print pointer values as
%p represents debugger's pointer size but we do want
debuggee's pointer size instead
Signed-off-by: Eric Pouech <eric.pouech at gmail.com>
---
programs/winedbg/be_i386.c | 8 +++++--
programs/winedbg/be_x86_64.c | 9 +++++---
programs/winedbg/break.c | 14 +++++--------
programs/winedbg/debugger.h | 2 --
programs/winedbg/gdbproxy.c | 9 +++++---
programs/winedbg/info.c | 17 ++++++++-------
programs/winedbg/memory.c | 45 +++++++----------------------------------
programs/winedbg/tgt_active.c | 41 ++++++++++++++++++++-----------------
programs/winedbg/winedbg.c | 3 ++-
9 files changed, 64 insertions(+), 84 deletions(-)
diff --git a/programs/winedbg/be_i386.c b/programs/winedbg/be_i386.c
index ab86f9ec647..840339b250d 100644
--- a/programs/winedbg/be_i386.c
+++ b/programs/winedbg/be_i386.c
@@ -507,7 +507,8 @@ static BOOL be_i386_is_func_call(const void* insn, ADDRESS64* callee)
/* FIXME: we only support the 32 bit far calls for now */
if (operand_size != 32)
{
- WINE_FIXME("Unsupported yet call insn (0xFF 0x%02x) with 16 bit operand-size at %p\n", ch, insn);
+ WINE_FIXME("Unsupported yet call insn (0xFF 0x%02x) with 16 bit operand-size at %#.*Ix\n",
+ ch, ADDRSIZE, (DWORD_PTR)insn);
return FALSE;
}
switch (ch & 0xC7) /* keep Mod R/M only (skip reg) */
@@ -515,7 +516,8 @@ static BOOL be_i386_is_func_call(const void* insn, ADDRESS64* callee)
case 0x04:
case 0x44:
case 0x84:
- WINE_FIXME("Unsupported yet call insn (0xFF 0x%02x) (SIB bytes) at %p\n", ch, insn);
+ WINE_FIXME("Unsupported yet call insn (0xFF 0x%02x) (SIB bytes) at %#.*Ix\n",
+ ch, ADDRSIZE, (DWORD_PTR)insn);
return FALSE;
case 0x05: /* addr32 */
if ((ch & 0x38) == 0x10 || /* call */
@@ -739,7 +741,7 @@ static BOOL be_i386_remove_Xpoint(HANDLE hProcess, const struct be_process_io* p
if (size != 0) return FALSE;
if (!pio->read(hProcess, addr, &ch, 1, &sz) || sz != 1) return FALSE;
if (ch != (unsigned char)0xCC)
- WINE_FIXME("Cannot get back %02x instead of 0xCC at %p\n", ch, addr);
+ WINE_FIXME("Cannot get back %02x instead of 0xCC at %#.*Ix\n", ch, ADDRSIZE, (DWORD_PTR)addr);
ch = (unsigned char)val;
if (!pio->write(hProcess, addr, &ch, 1, &sz) || sz != 1) return FALSE;
break;
diff --git a/programs/winedbg/be_x86_64.c b/programs/winedbg/be_x86_64.c
index a01bbf86575..0fb77d0c940 100644
--- a/programs/winedbg/be_x86_64.c
+++ b/programs/winedbg/be_x86_64.c
@@ -502,7 +502,8 @@ static BOOL be_x86_64_is_func_call(const void* insn, ADDRESS64* callee)
callee->Offset = dst;
return TRUE;
}
- WINE_FIXME("Unsupported yet call insn (0xFF 0x%02x) at %p\n", ch, insn);
+ WINE_FIXME("Unsupported yet call insn (0xFF 0x%02x) at %#.*Ix\n",
+ ch, ADDRSIZE, (DWORD_PTR)insn);
return FALSE;
default:
switch (f_rm(ch))
@@ -526,7 +527,8 @@ static BOOL be_x86_64_is_func_call(const void* insn, ADDRESS64* callee)
return TRUE;
}
else
- WINE_FIXME("Unsupported yet call insn (rex=0x%02x 0xFF 0x%02x) at %p\n", rex, ch, insn);
+ WINE_FIXME("Unsupported yet call insn (rex=0x%02x 0xFF 0x%02x) at %#.*Ix\n",
+ rex, ch, ADDRSIZE, (DWORD_PTR)insn);
return FALSE;
default:
@@ -661,7 +663,8 @@ static BOOL be_x86_64_remove_Xpoint(HANDLE hProcess, const struct be_process_io*
if (size != 0) return FALSE;
if (!pio->read(hProcess, addr, &ch, 1, &sz) || sz != 1) return FALSE;
if (ch != (unsigned char)0xCC)
- WINE_FIXME("Cannot get back %02x instead of 0xCC at %p\n", ch, addr);
+ WINE_FIXME("Cannot get back %02x instead of 0xCC at %#.*Ix\n",
+ ch, ADDRSIZE, (DWORD_PTR)addr);
ch = (unsigned char)val;
if (!pio->write(hProcess, addr, &ch, 1, &sz) || sz != 1) return FALSE;
break;
diff --git a/programs/winedbg/break.c b/programs/winedbg/break.c
index 27a11a00d33..09bdea8ed40 100644
--- a/programs/winedbg/break.c
+++ b/programs/winedbg/break.c
@@ -348,7 +348,6 @@ void break_check_delayed_bp(void)
struct dbg_lvalue lvalue;
int i;
struct dbg_delayed_bp* dbp = dbg_curr_process->delayed_bp;
- char hexbuf[MAX_OFFSET_TO_STR_LEN];
for (i = 0; i < dbg_curr_process->num_delayed_bp; i++)
{
@@ -363,9 +362,8 @@ void break_check_delayed_bp(void)
lvalue.addr = dbp[i].u.addr;
WINE_TRACE("trying to add delayed %s-bp\n", dbp[i].is_symbol ? "S" : "A");
if (!dbp[i].is_symbol)
- WINE_TRACE("\t%04x:%s\n",
- dbp[i].u.addr.Segment,
- memory_offset_to_string(hexbuf, dbp[i].u.addr.Offset, 0));
+ WINE_TRACE("\t%04x:%#.*I64x\n",
+ dbp[i].u.addr.Segment, ADDRSIZE, dbp[i].u.addr.Offset);
else
WINE_TRACE("\t'%s' @ %d\n",
dbp[i].u.symbol.name, dbp[i].u.symbol.lineno);
@@ -908,15 +906,15 @@ void break_restart_execution(int count)
if ((mode == EXEC_STEP_OVER || mode == EXEC_STEPI_OVER)
&& status == dbg_in_a_thunk)
{
- WINE_WARN("Not stepping into trampoline at %p (no lines)\n",
- memory_to_linear_addr(&callee));
+ WINE_WARN("Not stepping into trampoline at %#.*Ix (no lines)\n",
+ ADDRSIZE, (DWORD_PTR)memory_to_linear_addr(&callee));
mode = EXEC_STEP_OVER_TRAMPOLINE;
}
#endif
if (mode == dbg_exec_step_into_line && status == dbg_no_line_info)
{
- WINE_WARN("Not stepping into function at %p (no lines)\n",
- memory_to_linear_addr(&callee));
+ WINE_WARN("Not stepping into function at %#.*Ix (no lines)\n",
+ ADDRSIZE, (DWORD_PTR)memory_to_linear_addr(&callee));
mode = dbg_exec_step_over_line;
}
}
diff --git a/programs/winedbg/debugger.h b/programs/winedbg/debugger.h
index 2ea1dc5a25f..f40cacf2b56 100644
--- a/programs/winedbg/debugger.h
+++ b/programs/winedbg/debugger.h
@@ -407,8 +407,6 @@ extern BOOL memory_get_string_indirect(struct dbg_process* pcs, void
extern BOOL memory_get_register(DWORD regno, struct dbg_lvalue* value, char* buffer, int len);
extern void memory_disassemble(const struct dbg_lvalue*, const struct dbg_lvalue*, int instruction_count);
extern BOOL memory_disasm_one_insn(ADDRESS64* addr);
-#define MAX_OFFSET_TO_STR_LEN 19
-extern char* memory_offset_to_string(char *str, DWORD64 offset, unsigned mode);
extern void print_bare_address(const ADDRESS64* addr);
extern void print_address(const ADDRESS64* addr, BOOLEAN with_line);
extern void print_basic(const struct dbg_lvalue* value, char format);
diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c
index e7f9ddaf226..38485a155d1 100644
--- a/programs/winedbg/gdbproxy.c
+++ b/programs/winedbg/gdbproxy.c
@@ -126,7 +126,8 @@ static void gdbctx_delete_xpoint(struct gdb_context *gdbctx, struct dbg_thread *
struct backend_cpu *cpu = process->be_cpu;
if (!cpu->remove_Xpoint(process->handle, process->process_io, ctx, x->type, x->addr, x->value, x->size))
- ERR("%04lx:%04lx: Couldn't remove breakpoint at:%p/%x type:%d\n", process->pid, thread ? thread->tid : ~0, x->addr, x->size, x->type);
+ ERR("%04lx:%04lx: Couldn't remove breakpoint at:%#.*Ix/%x type:%d\n",
+ process->pid, thread ? thread->tid : ~0, ADDRSIZE, (DWORD_PTR)x->addr, x->size, x->type);
list_remove(&x->entry);
HeapFree(GetProcessHeap(), 0, x);
@@ -142,13 +143,15 @@ static void gdbctx_insert_xpoint(struct gdb_context *gdbctx, struct dbg_thread *
if (!cpu->insert_Xpoint(process->handle, process->process_io, ctx, type, addr, &value, size))
{
- ERR("%04lx:%04lx: Couldn't insert breakpoint at:%p/%x type:%d\n", process->pid, thread->tid, addr, size, type);
+ ERR("%04lx:%04lx: Couldn't insert breakpoint at:%#.*Ix/%x type:%d\n",
+ process->pid, thread->tid, ADDRSIZE, (DWORD_PTR)addr, size, type);
return;
}
if (!(x = HeapAlloc(GetProcessHeap(), 0, sizeof(struct gdb_xpoint))))
{
- ERR("%04lx:%04lx: Couldn't allocate memory for breakpoint at:%p/%x type:%d\n", process->pid, thread->tid, addr, size, type);
+ ERR("%04lx:%04lx: Couldn't allocate memory for breakpoint at:%#.*Ix/%x type:%d\n",
+ process->pid, thread->tid, ADDRSIZE, (DWORD_PTR)addr, size, type);
return;
}
diff --git a/programs/winedbg/info.c b/programs/winedbg/info.c
index 3ac00df911d..04b56fc6a77 100644
--- a/programs/winedbg/info.c
+++ b/programs/winedbg/info.c
@@ -677,13 +677,14 @@ void info_win32_frame_exceptions(DWORD tid)
{
EXCEPTION_REGISTRATION_RECORD frame;
- dbg_printf("%p: ", next_frame);
+ dbg_printf("%#.*Ix: ", ADDRSIZE, (DWORD_PTR)next_frame);
if (!dbg_read_memory(next_frame, &frame, sizeof(frame)))
{
dbg_printf("Invalid frame address\n");
break;
}
- dbg_printf("prev=%p handler=%p\n", frame.Prev, frame.Handler);
+ dbg_printf("prev=%#.*Ix handler=%#.*Ix\n",
+ ADDRSIZE, (DWORD_PTR)frame.Prev, ADDRSIZE, (DWORD_PTR)frame.Handler);
next_frame = frame.Prev;
}
@@ -852,7 +853,6 @@ void info_win32_exception(void)
{
const EXCEPTION_RECORD* rec;
ADDRESS64 addr;
- char hexbuf[MAX_OFFSET_TO_STR_LEN];
if (!dbg_curr_thread->in_exception)
{
@@ -964,9 +964,10 @@ void info_win32_exception(void)
dbg_printf("C++ exception(object = 0x%0*Ix, type = 0x%0*Ix)",
ADDRWIDTH, rec->ExceptionInformation[1], ADDRWIDTH, rec->ExceptionInformation[2]);
else if(rec->NumberParameters == 4 && rec->ExceptionInformation[0] == EXCEPTION_WINE_CXX_FRAME_MAGIC)
- dbg_printf("C++ exception(object = %p, type = %p, base = %p)",
- (void*)rec->ExceptionInformation[1], (void*)rec->ExceptionInformation[2],
- (void*)rec->ExceptionInformation[3]);
+ dbg_printf("C++ exception(object = %#.*Ix, type = %#.*Ix base = %#.*Ix)",
+ ADDRSIZE, rec->ExceptionInformation[1],
+ ADDRSIZE, rec->ExceptionInformation[2],
+ ADDRSIZE, rec->ExceptionInformation[3]);
else
dbg_printf("C++ exception with strange parameter count %ld or magic 0x%0*Ix",
rec->NumberParameters, ADDRWIDTH, rec->ExceptionInformation[0]);
@@ -981,9 +982,9 @@ void info_win32_exception(void)
switch (addr.Mode)
{
case AddrModeFlat:
- dbg_printf(" in %ld-bit code (%s)",
+ dbg_printf(" in %ld-bit code (%#.*I64x)",
dbg_curr_process->be_cpu->pointer_size * 8,
- memory_offset_to_string(hexbuf, addr.Offset, 0));
+ ADDRSIZE, addr.Offset);
break;
case AddrModeReal:
dbg_printf(" in vm86 code (%04x:%04x)", addr.Segment, (unsigned) addr.Offset);
diff --git a/programs/winedbg/memory.c b/programs/winedbg/memory.c
index d0698bff5a9..59c98e4b5fb 100644
--- a/programs/winedbg/memory.c
+++ b/programs/winedbg/memory.c
@@ -432,32 +432,6 @@ BOOL memory_get_string_indirect(struct dbg_process* pcs, void* addr, BOOL unicod
return FALSE;
}
-/*
- * Convert an address offset to hex string. If mode == 32, treat offset as
- * 32 bits (discard upper 32 bits), if mode == 64 use all 64 bits, if mode == 0
- * treat as either 32 or 64 bits, depending on whether we're running as
- * Wine32 or Wine64.
- */
-char* memory_offset_to_string(char *str, DWORD64 offset, unsigned mode)
-{
- if (mode != 32 && mode != 64)
- {
-#ifdef _WIN64
- mode = 64;
-#else
- mode = 32;
-#endif
- }
-
- if (mode == 32)
- sprintf(str, "0x%08x", (unsigned int) offset);
- else
- sprintf(str, "0x%08x%08x", (unsigned int)(offset >> 32),
- (unsigned int)offset);
-
- return str;
-}
-
static void dbg_print_sdecimal(dbg_lgint_t sv)
{
dbg_printf("%I64d", sv);
@@ -538,8 +512,8 @@ static void print_typed_basic(const struct dbg_lvalue* lvalue)
case SymTagPointerType:
if (!types_array_index(lvalue, 0, &sub_lvalue))
{
- dbg_printf("Internal symbol error: unable to access memory location %p",
- memory_to_linear_addr(&lvalue->addr));
+ dbg_printf("Internal symbol error: unable to access memory location %#.*Ix",
+ ADDRSIZE, (DWORD_PTR)memory_to_linear_addr(&lvalue->addr));
break;
}
val_ptr = memory_to_linear_addr(&sub_lvalue.addr);
@@ -556,16 +530,16 @@ static void print_typed_basic(const struct dbg_lvalue* lvalue)
size64 == 2, buffer, sizeof(buffer)))
dbg_printf("\"%s\"", buffer);
else
- dbg_printf("*** invalid address %p ***", val_ptr);
+ dbg_printf("*** invalid address %#.*Ix ***", ADDRSIZE, (DWORD_PTR)val_ptr);
break;
}
}
- dbg_printf("%p", val_ptr);
+ dbg_printf("%#.*Ix", ADDRSIZE, (DWORD_PTR)val_ptr);
break;
case SymTagArrayType:
case SymTagUDT:
if (!memory_read_value(lvalue, sizeof(val_ptr), &val_ptr)) return;
- dbg_printf("%p", val_ptr);
+ dbg_printf("%#.*Ix", ADDRSIZE, (DWORD_PTR)val_ptr);
break;
case SymTagEnum:
{
@@ -680,20 +654,17 @@ void print_basic(const struct dbg_lvalue* lvalue, char format)
void print_bare_address(const ADDRESS64* addr)
{
- char hexbuf[MAX_OFFSET_TO_STR_LEN];
-
switch (addr->Mode)
{
- case AddrModeFlat:
- dbg_printf("%s", memory_offset_to_string(hexbuf, addr->Offset, 0));
+ case AddrModeFlat:
+ dbg_printf("%#.*I64x", ADDRSIZE, addr->Offset);
break;
case AddrModeReal:
case AddrMode1616:
dbg_printf("0x%04x:0x%04x", addr->Segment, (unsigned) addr->Offset);
break;
case AddrMode1632:
- dbg_printf("0x%04x:%s", addr->Segment,
- memory_offset_to_string(hexbuf, addr->Offset, 32));
+ dbg_printf("0x%04x:%u", addr->Segment, (unsigned) addr->Offset);
break;
default:
dbg_printf("Unknown mode %x", addr->Mode);
diff --git a/programs/winedbg/tgt_active.c b/programs/winedbg/tgt_active.c
index 8c365a1e55d..c29f29e2639 100644
--- a/programs/winedbg/tgt_active.c
+++ b/programs/winedbg/tgt_active.c
@@ -373,11 +373,11 @@ static unsigned dbg_handle_debug_event(DEBUG_EVENT* de)
swprintf(u.buffer, ARRAY_SIZE(u.buffer), L"Process_%08x", dbg_curr_pid);
}
- WINE_TRACE("%04lx:%04lx: create process '%s'/%p @%p (%lu<%lu>)\n",
+ WINE_TRACE("%04lx:%04lx: create process '%s'/%#.*Ix @%#.*Ix (%lu<%lu>)\n",
de->dwProcessId, de->dwThreadId,
wine_dbgstr_w(u.buffer),
- de->u.CreateProcessInfo.lpImageName,
- de->u.CreateProcessInfo.lpStartAddress,
+ ADDRSIZE, (DWORD_PTR)de->u.CreateProcessInfo.lpImageName,
+ ADDRSIZE, (DWORD_PTR)de->u.CreateProcessInfo.lpStartAddress,
de->u.CreateProcessInfo.dwDebugInfoFileOffset,
de->u.CreateProcessInfo.nDebugInfoSize);
dbg_set_process_name(dbg_curr_process, u.buffer);
@@ -388,8 +388,9 @@ static unsigned dbg_handle_debug_event(DEBUG_EVENT* de)
(DWORD_PTR)de->u.CreateProcessInfo.lpBaseOfImage, 0))
dbg_printf("couldn't load main module (%lu)\n", GetLastError());
- WINE_TRACE("%04lx:%04lx: create thread I @%p\n",
- de->dwProcessId, de->dwThreadId, de->u.CreateProcessInfo.lpStartAddress);
+ WINE_TRACE("%04lx:%04lx: create thread I @%#.*Ix\n",
+ de->dwProcessId, de->dwThreadId,
+ ADDRSIZE, (DWORD_PTR)de->u.CreateProcessInfo.lpStartAddress);
dbg_curr_thread = dbg_add_thread(dbg_curr_process,
de->dwThreadId,
@@ -418,8 +419,9 @@ static unsigned dbg_handle_debug_event(DEBUG_EVENT* de)
break;
case CREATE_THREAD_DEBUG_EVENT:
- WINE_TRACE("%04lx:%04lx: create thread D @%p\n",
- de->dwProcessId, de->dwThreadId, de->u.CreateThread.lpStartAddress);
+ WINE_TRACE("%04lx:%04lx: create thread D @%#.*Ix\n",
+ de->dwProcessId, de->dwThreadId,
+ ADDRSIZE, (DWORD_PTR)de->u.CreateThread.lpStartAddress);
if (dbg_curr_process == NULL)
{
@@ -466,9 +468,10 @@ static unsigned dbg_handle_debug_event(DEBUG_EVENT* de)
fetch_module_name(de->u.LoadDll.lpImageName, de->u.LoadDll.lpBaseOfDll,
u.buffer, ARRAY_SIZE(u.buffer));
- WINE_TRACE("%04lx:%04lx: loads DLL %s @%p (%lu<%lu>)\n",
+ WINE_TRACE("%04lx:%04lx: loads DLL %s @%#.*Ix (%lu<%lu>)\n",
de->dwProcessId, de->dwThreadId,
- wine_dbgstr_w(u.buffer), de->u.LoadDll.lpBaseOfDll,
+ wine_dbgstr_w(u.buffer),
+ ADDRSIZE, (DWORD_PTR)de->u.LoadDll.lpBaseOfDll,
de->u.LoadDll.dwDebugInfoFileOffset,
de->u.LoadDll.nDebugInfoSize);
dbg_load_module(dbg_curr_process->handle, de->u.LoadDll.hFile, u.buffer,
@@ -478,16 +481,17 @@ static unsigned dbg_handle_debug_event(DEBUG_EVENT* de)
break_set_xpoints(TRUE);
if (DBG_IVAR(BreakOnDllLoad))
{
- dbg_printf("Stopping on DLL %s loading at %p\n",
- dbg_W2A(u.buffer, -1), de->u.LoadDll.lpBaseOfDll);
+ dbg_printf("Stopping on DLL %s loading at %#.*Ix\n",
+ dbg_W2A(u.buffer, -1),
+ ADDRSIZE, (DWORD_PTR)de->u.LoadDll.lpBaseOfDll);
if (dbg_fetch_context()) cont = 0;
}
break;
case UNLOAD_DLL_DEBUG_EVENT:
- WINE_TRACE("%04lx:%04lx: unload DLL @%p\n",
+ WINE_TRACE("%04lx:%04lx: unload DLL @%#.*Ix\n",
de->dwProcessId, de->dwThreadId,
- de->u.UnloadDll.lpBaseOfDll);
+ ADDRSIZE, (DWORD_PTR)de->u.UnloadDll.lpBaseOfDll);
break_delete_xpoints_from_module((DWORD_PTR)de->u.UnloadDll.lpBaseOfDll);
SymUnloadModule64(dbg_curr_process->handle, (DWORD_PTR)de->u.UnloadDll.lpBaseOfDll);
break;
@@ -526,12 +530,11 @@ static void dbg_resume_debuggee(DWORD cont)
if (dbg_curr_thread->in_exception)
{
ADDRESS64 addr;
- char hexbuf[MAX_OFFSET_TO_STR_LEN];
dbg_exception_epilog();
memory_get_current_pc(&addr);
- WINE_TRACE("Exiting debugger PC=%s mode=%d count=%d\n",
- memory_offset_to_string(hexbuf, addr.Offset, 0),
+ WINE_TRACE("Exiting debugger PC=%#.*I64x mode=%d count=%d\n",
+ ADDRSIZE, addr.Offset,
dbg_curr_thread->exec_mode,
dbg_curr_thread->exec_count);
if (dbg_curr_thread)
@@ -559,7 +562,7 @@ static void wait_exception(void)
void dbg_wait_next_exception(DWORD cont, int count, int mode)
{
ADDRESS64 addr;
- char hexbuf[MAX_OFFSET_TO_STR_LEN];
+
if (cont == DBG_CONTINUE)
{
@@ -572,8 +575,8 @@ void dbg_wait_next_exception(DWORD cont, int count, int mode)
if (!dbg_curr_process) return;
memory_get_current_pc(&addr);
- WINE_TRACE("Entering debugger PC=%s mode=%d count=%d\n",
- memory_offset_to_string(hexbuf, addr.Offset, 0),
+ WINE_TRACE("Entering debugger PC=%#.*I64x mode=%d count=%d\n",
+ ADDRSIZE, addr.Offset,
dbg_curr_thread->exec_mode,
dbg_curr_thread->exec_count);
}
diff --git a/programs/winedbg/winedbg.c b/programs/winedbg/winedbg.c
index 95318eeb2f1..638efc6e901 100644
--- a/programs/winedbg/winedbg.c
+++ b/programs/winedbg/winedbg.c
@@ -584,7 +584,8 @@ void dbg_start_interactive(const char* filename, HANDLE hFile)
static LONG CALLBACK top_filter( EXCEPTION_POINTERS *ptr )
{
- dbg_printf( "winedbg: Internal crash at %p\n", ptr->ExceptionRecord->ExceptionAddress );
+ dbg_printf( "winedbg: Internal crash at %#.*Ix\n",
+ ADDRSIZE, (DWORD_PTR)ptr->ExceptionRecord->ExceptionAddress );
return EXCEPTION_EXECUTE_HANDLER;
}
More information about the wine-devel
mailing list