[PATCH] [WineDbg]: allow to specify which format to be used for integers in backtraces

Eric Pouech eric.pouech at orange.fr
Mon Mar 15 15:06:57 CDT 2010


This also reverts setting default format for integers to be hexadecimals.
Gdb uses decimal notation by default for integers, so do we.

A+
---

 programs/winedbg/dbg.y          |   12 ++++++++----
 programs/winedbg/debug.l        |    2 +-
 programs/winedbg/debugger.h     |    4 ++--
 programs/winedbg/memory.c       |   32 ++++++++++----------------------
 programs/winedbg/stack.c        |   32 ++++++++++++++++++++------------
 programs/winedbg/symbol.c       |    6 +++---
 programs/winedbg/tgt_active.c   |    2 +-
 programs/winedbg/tgt_minidump.c |    2 +-
 8 files changed, 46 insertions(+), 46 deletions(-)


diff --git a/programs/winedbg/dbg.y b/programs/winedbg/dbg.y
index 855407f..a5780b2 100644
--- a/programs/winedbg/dbg.y
+++ b/programs/winedbg/dbg.y
@@ -123,9 +123,12 @@ command:
     | tNEXTI tNUM               { dbg_wait_next_exception(DBG_CONTINUE, $2, dbg_exec_step_over_insn); }
     | tFINISH     	       	{ dbg_wait_next_exception(DBG_CONTINUE, 0,  dbg_exec_finish); }
     | tABORT                   	{ abort(); }
-    | tBACKTRACE     	       	{ stack_backtrace(dbg_curr_tid); }
-    | tBACKTRACE tNUM          	{ stack_backtrace($2); }
-    | tBACKTRACE tALL           { stack_backtrace(-1); }
+    | tBACKTRACE     	       	{ stack_backtrace(dbg_curr_tid, 0); }
+    | tBACKTRACE tFORMAT	{ stack_backtrace(dbg_curr_tid, $2); }
+    | tBACKTRACE tNUM          	{ stack_backtrace($2, 0); }
+    | tBACKTRACE tFORMAT tNUM   { stack_backtrace($3, $2); }
+    | tBACKTRACE tALL           { stack_backtrace(-1, 0); }
+    | tBACKTRACE tFORMAT tALL   { stack_backtrace(-1, $2); }
     | tUP     		       	{ stack_set_frame(dbg_curr_thread->curr_frame + 1);  }
     | tUP tNUM     	       	{ stack_set_frame(dbg_curr_thread->curr_frame + $2); }
     | tDOWN     	       	{ stack_set_frame(dbg_curr_thread->curr_frame - 1);  }
@@ -300,7 +303,8 @@ maintenance_command:
 
 noprocess_state:
       tNOPROCESS                 {} /* <CR> shall not barf anything */
-    | tNOPROCESS tBACKTRACE tALL { stack_backtrace(-1); } /* can backtrace all threads with no attached process */
+    | tNOPROCESS tBACKTRACE tALL { stack_backtrace(-1, 0); } /* can backtrace all threads with no attached process */
+    | tNOPROCESS tBACKTRACE tFORMAT tALL { stack_backtrace(-1, $3); } /* can backtrace all threads with no attached process */
     | tNOPROCESS tSTRING         { dbg_printf("No process loaded, cannot execute '%s'\n", $2); }
     ;
 
diff --git a/programs/winedbg/debug.l b/programs/winedbg/debug.l
index 2e87ddb..0d88fed 100644
--- a/programs/winedbg/debug.l
+++ b/programs/winedbg/debug.l
@@ -181,7 +181,7 @@ STRING     \"[^\n"]+\"
 <INITIAL>x				{ BEGIN(FORMAT_EXPECTED); return tEXAM; }
 <INITIAL,NOPROCESS>help|hel|he|"?"	{ BEGIN(HELP_CMD); return tHELP; }
 
-<INITIAL,NOPROCESS>backtrace|backtrac|backtra|backt|back|bac|ba|bt { BEGIN(NOCMD); return tBACKTRACE; }
+<INITIAL,NOPROCESS>backtrace|backtrac|backtra|backt|back|bac|ba|bt { BEGIN(FORMAT_EXPECTED); return tBACKTRACE; }
 <INITIAL,NOPROCESS>where|wher|whe       { BEGIN(NOCMD); return tBACKTRACE; }
 
 <INITIAL>cont|con|co|c   		{ BEGIN(NOCMD); return tCONT; }
diff --git a/programs/winedbg/debugger.h b/programs/winedbg/debugger.h
index 300f48a..b95f641 100644
--- a/programs/winedbg/debugger.h
+++ b/programs/winedbg/debugger.h
@@ -384,7 +384,7 @@ extern void             source_free_files(struct dbg_process* p);
 
   /* stack.c */
 extern void             stack_info(void);
-extern void             stack_backtrace(DWORD threadID);
+extern void             stack_backtrace(DWORD threadID, int fmt);
 extern BOOL             stack_set_frame(int newframe);
 extern BOOL             stack_get_current_frame(IMAGEHLP_STACK_FRAME* ihsf);
 extern BOOL             stack_get_register_current_frame(unsigned regno, DWORD_PTR** pval);
@@ -397,7 +397,7 @@ extern void             symbol_read_symtable(const char* filename, unsigned long
 extern enum dbg_line_status symbol_get_function_line_status(const ADDRESS64* addr);
 extern BOOL             symbol_get_line(const char* filename, const char* func, IMAGEHLP_LINE64* ret);
 extern void             symbol_info(const char* str);
-extern void             symbol_print_local(const SYMBOL_INFO* sym, DWORD_PTR base, BOOL detailed);
+extern void             symbol_print_local(const SYMBOL_INFO* sym, DWORD_PTR base, char format, BOOL detailed);
 extern int              symbol_info_locals(void);
 extern BOOL             symbol_is_local(const char* name);
 struct sgv_data;
diff --git a/programs/winedbg/memory.c b/programs/winedbg/memory.c
index 9554ea4..19bbb1f 100644
--- a/programs/winedbg/memory.c
+++ b/programs/winedbg/memory.c
@@ -338,20 +338,6 @@ static void dbg_print_longlong(LONGLONG sv, BOOL is_signed)
     dbg_printf("%s", ptr);
 }
 
-static void dbg_print_hex(ULONGLONG sv)
-{
-    if (!sv)
-    {
-        dbg_printf("0");
-        return;
-    }
-
-    if (sv >> 32)
-        dbg_printf("0x%lx%08lx", (unsigned long)(sv >> 32), (unsigned long)sv);
-    else
-        dbg_printf("0x%04lx", (unsigned long)sv);
-}
-
 static void print_typed_basic(const struct dbg_lvalue* lvalue)
 {
     LONGLONG            val_int;
@@ -381,12 +367,12 @@ static void print_typed_basic(const struct dbg_lvalue* lvalue)
         case btLong:
             if (!be_cpu->fetch_integer(lvalue, size, TRUE, &val_int)) return;
             if (size == 1) goto print_char;
-            dbg_print_hex(val_int);
+            dbg_print_longlong(val_int, TRUE);
             break;
         case btUInt:
         case btULong:
             if (!be_cpu->fetch_integer(lvalue, size, FALSE, &val_int)) return;
-            dbg_print_hex(val_int);
+            dbg_print_longlong(val_int, FALSE);
             break;
         case btFloat:
             if (!be_cpu->fetch_float(lvalue, size, &val_real)) return;
@@ -526,23 +512,25 @@ void print_basic(const struct dbg_lvalue* lvalue, char format)
     {
         unsigned size;
         LONGLONG res = types_extract_as_longlong(lvalue, &size);
-        DWORD hi;
         WCHAR wch;
 
         /* FIXME: this implies i386 byte ordering */
         switch (format)
         {
         case 'x':
-            hi = (ULONG64)res >> 32;
-            if (size == 8 && hi)
-                dbg_printf("0x%x%08x", hi, (DWORD)res);
+            if (!res) dbg_printf("0");
             else
-                dbg_printf("0x%x", (DWORD)res);
+            {
+                DWORD hi = (ULONG64)res >> 32;
+                if (size == 8 && hi)
+                    dbg_printf("0x%x%08x", hi, (DWORD)res);
+                else
+                    dbg_printf("0x%x", (DWORD)res);
+            }
             return;
 
         case 'd':
             dbg_print_longlong(res, TRUE);
-            dbg_printf("\n");
             return;
 
         case 'c':
diff --git a/programs/winedbg/stack.c b/programs/winedbg/stack.c
index 40e6dae..1ea7ba0 100644
--- a/programs/winedbg/stack.c
+++ b/programs/winedbg/stack.c
@@ -214,6 +214,7 @@ struct sym_enum
 {
     DWORD_PTR   frame;
     BOOL        first;
+    char        format;
 };
 
 static BOOL WINAPI sym_enum_cb(PSYMBOL_INFO sym_info, ULONG size, PVOID user)
@@ -223,12 +224,12 @@ static BOOL WINAPI sym_enum_cb(PSYMBOL_INFO sym_info, ULONG size, PVOID user)
     if (sym_info->Flags & SYMFLAG_PARAMETER)
     {
         if (!se->first) dbg_printf(", "); else se->first = FALSE;
-        symbol_print_local(sym_info, se->frame, FALSE);
+        symbol_print_local(sym_info, se->frame, se->format, FALSE);
     }
     return TRUE;
 }
 
-static void stack_print_addr_and_args(int nf)
+static void stack_print_addr_and_args(int nf, char format)
 {
     char                        buffer[sizeof(SYMBOL_INFO) + 256];
     SYMBOL_INFO*                si = (SYMBOL_INFO*)buffer;
@@ -259,6 +260,7 @@ static void stack_print_addr_and_args(int nf)
         SymSetContext(dbg_curr_process->handle, &ihsf, NULL);
         se.first = TRUE;
         se.frame = ihsf.FrameOffset;
+        se.format = format;
         dbg_printf("(");
         SymEnumSymbols(dbg_curr_process->handle, 0, NULL, sym_enum_cb, &se);
         dbg_printf(")");
@@ -278,7 +280,7 @@ static void stack_print_addr_and_args(int nf)
  *
  * Do a backtrace on the current thread
  */
-static void backtrace(void)
+static void backtrace(char format)
 {
     unsigned                    cf = dbg_curr_thread->curr_frame;
     IMAGEHLP_STACK_FRAME        ihsf;
@@ -291,7 +293,7 @@ static void backtrace(void)
         dbg_printf("%s%d ", 
                    (cf == dbg_curr_thread->curr_frame ? "=>" : "  "),
                    dbg_curr_thread->curr_frame);
-        stack_print_addr_and_args(dbg_curr_thread->curr_frame);
+        stack_print_addr_and_args(dbg_curr_thread->curr_frame, format);
         dbg_printf(" (");
         print_bare_address(&dbg_curr_thread->frames[dbg_curr_thread->curr_frame].addr_frame);
         dbg_printf(")\n");
@@ -309,7 +311,7 @@ static void backtrace(void)
  * Do a backtrace on a thread from its process and its identifier
  * (preserves current thread and context information)
  */
-static void backtrace_tid(struct dbg_process* pcs, DWORD tid)
+static void backtrace_tid(struct dbg_process* pcs, DWORD tid, char format)
 {
     struct dbg_thread*  thread = dbg_curr_thread;
 
@@ -332,7 +334,7 @@ static void backtrace_tid(struct dbg_process* pcs, DWORD tid)
             else
             {
                 stack_fetch_frames();
-                backtrace();
+                backtrace(format);
             }
             ResumeThread(dbg_curr_thread->handle);
         }
@@ -349,7 +351,7 @@ static void backtrace_tid(struct dbg_process* pcs, DWORD tid)
  * Do a backtrace on every running thread in the system (except the debugger)
  * (preserves current process information)
  */
-static void backtrace_all(void)
+static void backtrace_all(char format)
 {
     struct dbg_process* process = dbg_curr_process;
     struct dbg_thread*  thread = dbg_curr_thread;
@@ -394,7 +396,7 @@ static void backtrace_all(void)
             dbg_printf("\nBacktracing for thread %04x in process %04lx (%s):\n",
                        entry.th32ThreadID, dbg_curr_pid,
                        dbg_W2A(dbg_curr_process->imageName, -1));
-            backtrace_tid(dbg_curr_process, entry.th32ThreadID);
+            backtrace_tid(dbg_curr_process, entry.th32ThreadID, format);
         }
         while (Thread32Next(snapshot, &entry));
 
@@ -409,12 +411,18 @@ static void backtrace_all(void)
     dbg_context = ctx;
 }
 
-void stack_backtrace(DWORD tid)
+void stack_backtrace(DWORD tid, int fmt)
 {
+    if (fmt && (fmt >> 8) != 1)
+    {
+        dbg_printf("Count is meaningless in backtrace command\n");
+        return;
+    }
+    fmt &= 0xff;
     /* backtrace every thread in every process except the debugger itself,
      * invoking via "bt all"
      */
-    if (tid == -1) return backtrace_all();
+    if (tid == -1) return backtrace_all(fmt);
 
     if (!dbg_curr_process) 
     {
@@ -424,10 +432,10 @@ void stack_backtrace(DWORD tid)
     
     if (tid == dbg_curr_tid)
     {
-        backtrace();
+        backtrace(fmt);
     }
     else
     {
-        backtrace_tid(dbg_curr_process, tid);
+        backtrace_tid(dbg_curr_process, tid, fmt);
     }
 }
diff --git a/programs/winedbg/symbol.c b/programs/winedbg/symbol.c
index 1e32bc6..9de2413 100644
--- a/programs/winedbg/symbol.c
+++ b/programs/winedbg/symbol.c
@@ -648,7 +648,7 @@ BOOL symbol_get_line(const char* filename, const char* name,
  * <name>=<value> (local|pmt <where>)   in detailed form
  * Note <value> can be an error message in case of error
  */
-void symbol_print_local(const SYMBOL_INFO* sym, DWORD_PTR base, BOOL detailed)
+void symbol_print_local(const SYMBOL_INFO* sym, DWORD_PTR base, char format, BOOL detailed)
 {
     struct dbg_lvalue   lvalue;
     char                buffer[64];
@@ -657,7 +657,7 @@ void symbol_print_local(const SYMBOL_INFO* sym, DWORD_PTR base, BOOL detailed)
 
     if (fill_sym_lvalue(sym, base, &lvalue, buffer, sizeof(buffer)))
     {
-        print_value(&lvalue, 0, 1);
+        print_value(&lvalue, format, 1);
         if (detailed)
             dbg_printf(" (%s%s)",
                        (sym->Flags & SYMFLAG_PARAMETER) ? "parameter" : "local",
@@ -682,7 +682,7 @@ static BOOL CALLBACK info_locals_cb(PSYMBOL_INFO sym, ULONG size, PVOID ctx)
     types_print_type(&type, FALSE);
 
     dbg_printf(" ");
-    symbol_print_local(sym, (DWORD_PTR)ctx, TRUE);
+    symbol_print_local(sym, (DWORD_PTR)ctx, 0, TRUE);
     dbg_printf("\n");
 
     return TRUE;
diff --git a/programs/winedbg/tgt_active.c b/programs/winedbg/tgt_active.c
index 232b2cc..57c254e 100644
--- a/programs/winedbg/tgt_active.c
+++ b/programs/winedbg/tgt_active.c
@@ -185,7 +185,7 @@ static unsigned dbg_exception_prolog(BOOL is_debug, BOOL first_chance, const EXC
 	be_cpu->print_context(dbg_curr_thread->handle, &dbg_context, 0);
 	stack_info();
         be_cpu->print_segment_info(dbg_curr_thread->handle, &dbg_context);
-	stack_backtrace(dbg_curr_tid);
+	stack_backtrace(dbg_curr_tid, 0);
     }
     else
     {
diff --git a/programs/winedbg/tgt_minidump.c b/programs/winedbg/tgt_minidump.c
index 7826b78..abe96e0 100644
--- a/programs/winedbg/tgt_minidump.c
+++ b/programs/winedbg/tgt_minidump.c
@@ -380,7 +380,7 @@ static enum dbg_start minidump_do_reload(struct tgt_process_minidump_data* data)
             be_cpu->print_context(dbg_curr_thread->handle, &dbg_context, 0);
             stack_info();
             be_cpu->print_segment_info(dbg_curr_thread->handle, &dbg_context);
-            stack_backtrace(mes->ThreadId);
+            stack_backtrace(mes->ThreadId, 0);
             source_list_from_addr(&addr, 0);
         }
     }






More information about the wine-patches mailing list