system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-10-31 11:43:31 +00:00
Code Issues Projects Releases Packages Wiki Activity
wine/programs/winedbg/winedbg.c
Eric Pouech 926f66186f - fixed breakpoint enabled/disabled state management 
- fixed recursion in type printing
- now all type-id are stored with the base address of the module which
  defines the type (struct dbg_type takes care of this pairing)
- fixed a couple of bugs in display handling
- fixed strings print and examination
2004-08-22 22:35:36 +00:00

1246 lines
38 KiB
C
Raw Blame History

/* Wine internal debugger
* Interface to Windows debugger API
* Copyright 2000-2004 Eric Pouech
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "config.h"
#include "wine/port.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "debugger.h"
#include "winternl.h"
#include "wine/exception.h"
#include "wine/library.h"
#include "wine/debug.h"
/* TODO list:
*
* - minidump
* + allow winedbg in automatic mode to create a minidump (or add another option
* for that)
* + set a mode where winedbg would start (postmortem debugging) from a minidump
* - CPU adherence
* + we always assume the stack grows has an i386 (ie downwards)
* - UI
* + enable back the limited output (depth of structure printing and number of
* lines)
* + make the output as close as possible to what gdb does
* - symbol management:
* + symbol table loading is broken
* + in symbol_get_lvalue, we don't do any scoping (as C does) between local and
* global vars (we may need this to force some display for example). A solution
* would be always to return arrays with: local vars, global vars, thunks
* - type management:
* + some bits of internal types are missing (like type casts and the address
* operator)
* + the type for an enum's value is always inferred as int (winedbg & dbghelp)
* + most of the code implies that sizeof(void*) = sizeof(int)
* + all computations should be made on long long
* o expr computations are in int:s
* o bitfield size is on a 4-bytes
* + some bits of internal types are missing (like type casts and the address
* operator)
* - execution:
* + display: we shouldn't need to tell whether a display is local or not. This
* should be automatically guessed by checking whether the variables that are
* references are local or not
* + set a better fix for gdb (proxy mode) than the step-mode hack
* + implement function call in debuggee
* + trampoline management is broken when getting 16 <=> 32 thunk destination
* address
* + thunking of delayed imports doesn't work as expected (ie, when stepping,
* it currently stops at first insn with line number during the library
* loading). We should identify this (__wine_delay_import) and set a
* breakpoint instead of single stepping the library loading.
* + Ctrl-C (in debugger) doesn't work if we've attached to the debuggee (but
* works if winedbg started the debuggee)
*/
WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
struct dbg_process* dbg_curr_process = NULL;
struct dbg_thread* dbg_curr_thread = NULL;
DWORD dbg_curr_tid;
DWORD dbg_curr_pid;
CONTEXT dbg_context;
int dbg_curr_frame = 0;
BOOL dbg_interactiveP = FALSE;
static unsigned dbg_in_exception = FALSE;
static char* dbg_last_cmd_line = NULL;
static struct dbg_process* dbg_process_list = NULL;
static enum {none_mode = 0, winedbg_mode, automatic_mode, gdb_mode} dbg_action_mode;
struct dbg_internal_var dbg_internal_vars[DBG_IV_LAST];
const struct dbg_internal_var* dbg_context_vars;
static HANDLE dbg_houtput;
void dbg_outputA(const char* buffer, int len)
{
WriteFile(dbg_houtput, buffer, len, NULL, NULL);
}
void dbg_outputW(const WCHAR* buffer, int len)
{
char* ansi = NULL;
int newlen;
/* do a serious Unicode to ANSI conversion
* FIXME: should CP_ACP be GetConsoleCP()?
*/
newlen = WideCharToMultiByte(CP_ACP, 0, buffer, len, NULL, 0, NULL, NULL);
if (newlen)
{
if (!(ansi = HeapAlloc(GetProcessHeap(), 0, newlen))) return;
WideCharToMultiByte(CP_ACP, 0, buffer, len, ansi, newlen, NULL, NULL);
dbg_outputA(ansi, newlen);
HeapFree(GetProcessHeap(), 0, ansi);
}
}
int dbg_printf(const char* format, ...)
{
static char buf[4*1024];
va_list valist;
int len;
va_start(valist, format);
len = vsnprintf(buf, sizeof(buf), format, valist);
va_end(valist);
if (len <= -1 || len >= sizeof(buf))
{
len = sizeof(buf) - 1;
buf[len] = 0;
buf[len - 1] = buf[len - 2] = buf[len - 3] = '.';
}
dbg_outputA(buf, len);
return len;
}
static unsigned dbg_load_internal_vars(void)
{
HKEY hkey;
DWORD type = REG_DWORD;
DWORD val;
DWORD count = sizeof(val);
int i;
struct dbg_internal_var* div = dbg_internal_vars;
/* initializes internal vars table */
#define INTERNAL_VAR(_var,_val,_ref,_tid) \
div->val = _val; div->name = #_var; div->pval = _ref; \
div->typeid = _tid; div++;
#include "intvar.h"
#undef INTERNAL_VAR
if (RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\WineDbg", &hkey))
{
WINE_ERR("Cannot create WineDbg key in registry\n");
return FALSE;
}
for (i = 0; i < DBG_IV_LAST; i++)
{
if (!dbg_internal_vars[i].pval)
{
if (!RegQueryValueEx(hkey, dbg_internal_vars[i].name, 0,
&type, (LPSTR)&val, &count))
dbg_internal_vars[i].val = val;
dbg_internal_vars[i].pval = &dbg_internal_vars[i].val;
}
}
RegCloseKey(hkey);
/* set up the debug variables for the CPU context */
dbg_context_vars = be_cpu->init_registers(&dbg_context);
return TRUE;
}
static unsigned dbg_save_internal_vars(void)
{
HKEY hkey;
int i;
if (RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\WineDbg", &hkey))
{
WINE_ERR("Cannot create WineDbg key in registry\n");
return FALSE;
}
for (i = 0; i < DBG_IV_LAST; i++)
{
/* FIXME: type should be infered from basic type -if any- of intvar */
if (dbg_internal_vars[i].pval == &dbg_internal_vars[i].val)
RegSetValueEx(hkey, dbg_internal_vars[i].name, 0,
REG_DWORD, (const void*)dbg_internal_vars[i].pval,
sizeof(*dbg_internal_vars[i].pval));
}
RegCloseKey(hkey);
return TRUE;
}
const struct dbg_internal_var* dbg_get_internal_var(const char* name)
{
const struct dbg_internal_var* div;
for (div = &dbg_internal_vars[DBG_IV_LAST - 1]; div >= dbg_internal_vars; div--)
{
if (!strcmp(div->name, name)) return div;
}
for (div = dbg_context_vars; div->name; div++)
{
if (!strcasecmp(div->name, name)) return div;
}
return NULL;
}
struct dbg_process* dbg_get_process(DWORD pid)
{
struct dbg_process* p;
for (p = dbg_process_list; p; p = p->next)
if (p->pid == pid) break;
return p;
}
struct dbg_process* dbg_add_process(DWORD pid, HANDLE h, const char* imageName)
{
struct dbg_process* p;
if ((p = dbg_get_process(pid)))
{
if (p->handle != 0)
{
WINE_ERR("Process (%lu) is already defined\n", pid);
}
else
{
p->handle = h;
p->imageName = imageName ? strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(imageName) + 1), imageName) : NULL;
}
return p;
}
if (!(p = HeapAlloc(GetProcessHeap(), 0, sizeof(struct dbg_process)))) return NULL;
p->handle = h;
p->pid = pid;
p->imageName = imageName ? strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(imageName) + 1), imageName) : NULL;
p->threads = NULL;
p->continue_on_first_exception = FALSE;
p->next_bp = 1; /* breakpoint 0 is reserved for step-over */
memset(p->bp, 0, sizeof(p->bp));
p->delayed_bp = NULL;
p->num_delayed_bp = 0;
p->next = dbg_process_list;
p->prev = NULL;
if (dbg_process_list) dbg_process_list->prev = p;
dbg_process_list = p;
return p;
}
void dbg_del_process(struct dbg_process* p)
{
int i;
while (p->threads) dbg_del_thread(p->threads);
for (i = 0; i < p->num_delayed_bp; i++)
if (p->delayed_bp[i].is_symbol)
HeapFree(GetProcessHeap(), 0, p->delayed_bp[i].u.symbol.name);
HeapFree(GetProcessHeap(), 0, p->delayed_bp);
if (p->prev) p->prev->next = p->next;
if (p->next) p->next->prev = p->prev;
if (p == dbg_process_list) dbg_process_list = p->next;
if (p == dbg_curr_process) dbg_curr_process = NULL;
HeapFree(GetProcessHeap(), 0, (char*)p->imageName);
HeapFree(GetProcessHeap(), 0, p);
}
static void dbg_init_current_process(void)
{
}
struct mod_loader_info
{
HANDLE handle;
IMAGEHLP_MODULE* imh_mod;
};
static BOOL CALLBACK mod_loader_cb(PSTR mod_name, DWORD base, void* ctx)
{
struct mod_loader_info* mli = (struct mod_loader_info*)ctx;
if (!strcmp(mod_name, "<wine-loader>"))
{
if (SymGetModuleInfo(mli->handle, base, mli->imh_mod))
return FALSE; /* stop enum */
}
return TRUE;
}
BOOL dbg_get_debuggee_info(HANDLE hProcess, IMAGEHLP_MODULE* imh_mod)
{
struct mod_loader_info mli;
DWORD opt;
/* this will resynchronize builtin dbghelp's internal ELF module list */
SymLoadModule(hProcess, 0, 0, 0, 0, 0);
mli.handle = hProcess;
mli.imh_mod = imh_mod;
imh_mod->SizeOfStruct = sizeof(*imh_mod);
imh_mod->BaseOfImage = 0;
/* this is a wine specific options to return also ELF modules in the
* enumeration
*/
SymSetOptions((opt = SymGetOptions()) | 0x40000000);
SymEnumerateModules(hProcess, mod_loader_cb, (void*)&mli);
SymSetOptions(opt);
return imh_mod->BaseOfImage != 0;
}
struct dbg_thread* dbg_get_thread(struct dbg_process* p, DWORD tid)
{
struct dbg_thread* t;
if (!p) return NULL;
for (t = p->threads; t; t = t->next)
if (t->tid == tid) break;
return t;
}
struct dbg_thread* dbg_add_thread(struct dbg_process* p, DWORD tid,
HANDLE h, void* teb)
{
struct dbg_thread* t = HeapAlloc(GetProcessHeap(), 0, sizeof(struct dbg_thread));
if (!t)
return NULL;
t->handle = h;
t->tid = tid;
t->teb = teb;
t->process = p;
t->wait_for_first_exception = 0;
t->exec_mode = dbg_exec_cont;
t->exec_count = 0;
t->step_over_bp.enabled = FALSE;
t->step_over_bp.refcount = 0;
snprintf(t->name, sizeof(t->name), "0x%08lx", tid);
t->next = p->threads;
t->prev = NULL;
if (p->threads) p->threads->prev = t;
p->threads = t;
return t;
}
static void dbg_init_current_thread(void* start)
{
if (start)
{
if (dbg_curr_process->threads &&
!dbg_curr_process->threads->next && /* first thread ? */
DBG_IVAR(BreakAllThreadsStartup))
{
ADDRESS addr;
break_set_xpoints(FALSE);
addr.Mode = AddrModeFlat;
addr.Offset = (DWORD)start;
break_add_break(&addr, TRUE);
break_set_xpoints(TRUE);
}
}
else
{
dbg_curr_thread->wait_for_first_exception = 1;
}
}
void dbg_del_thread(struct dbg_thread* t)
{
if (t->prev) t->prev->next = t->next;
if (t->next) t->next->prev = t->prev;
if (t == t->process->threads) t->process->threads = t->next;
if (t == dbg_curr_thread) dbg_curr_thread = NULL;
HeapFree(GetProcessHeap(), 0, t);
}
static unsigned dbg_handle_debug_event(DEBUG_EVENT* de);
/******************************************************************
* dbg_attach_debuggee
*
* Sets the debuggee to <pid>
* cofe instructs winedbg what to do when first exception is received
* (break=FALSE, continue=TRUE)
* wfe is set to TRUE if dbg_attach_debuggee should also proceed with all debug events
* until the first exception is received (aka: attach to an already running process)
*/
BOOL dbg_attach_debuggee(DWORD pid, BOOL cofe, BOOL wfe)
{
DEBUG_EVENT de;
if (!(dbg_curr_process = dbg_add_process(pid, 0, NULL))) return FALSE;
if (!DebugActiveProcess(pid))
{
dbg_printf("Can't attach process %lx: error %ld\n", pid, GetLastError());
dbg_del_process(dbg_curr_process);
return FALSE;
}
dbg_curr_process->continue_on_first_exception = cofe;
if (wfe) /* shall we proceed all debug events until we get an exception ? */
{
dbg_interactiveP = FALSE;
while (dbg_curr_process && WaitForDebugEvent(&de, INFINITE))
{
if (dbg_handle_debug_event(&de)) break;
}
if (dbg_curr_process) dbg_interactiveP = TRUE;
}
return TRUE;
}
BOOL dbg_detach_debuggee(void)
{
/* remove all set breakpoints in debuggee code */
break_set_xpoints(FALSE);
/* needed for single stepping (ugly).
* should this be handled inside the server ???
*/
be_cpu->single_step(&dbg_context, FALSE);
SetThreadContext(dbg_curr_thread->handle, &dbg_context);
if (dbg_in_exception)
ContinueDebugEvent(dbg_curr_pid, dbg_curr_tid, DBG_CONTINUE);
if (!DebugActiveProcessStop(dbg_curr_pid)) return FALSE;
dbg_del_process(dbg_curr_process);
return TRUE;
}
static unsigned dbg_fetch_context(void)
{
dbg_context.ContextFlags = CONTEXT_CONTROL
| CONTEXT_INTEGER
#ifdef CONTEXT_SEGMENTS
| CONTEXT_SEGMENTS
#endif
#ifdef CONTEXT_DEBUG_REGISTERS
| CONTEXT_DEBUG_REGISTERS
#endif
;
if (!GetThreadContext(dbg_curr_thread->handle, &dbg_context))
{
WINE_WARN("Can't get thread's context\n");
return FALSE;
}
return TRUE;
}
static unsigned dbg_exception_prolog(BOOL is_debug, BOOL force, DWORD code)
{
ADDRESS addr;
dbg_in_exception = TRUE;
memory_get_current_pc(&addr);
break_suspend_execution();
if (!is_debug)
{
switch (addr.Mode)
{
case AddrModeFlat: dbg_printf(" in 32-bit code (0x%08lx)", addr.Offset); break;
case AddrModeReal: dbg_printf(" in vm86 code (%04x:%04lx)", addr.Segment, addr.Offset); break;
case AddrMode1616: dbg_printf(" in 16-bit code (%04x:%04lx)", addr.Segment, addr.Offset); break;
default: dbg_printf(" bad address");
}
dbg_printf(".\n");
}
/* this will resynchronize builtin dbghelp's internal ELF module list */
SymLoadModule(dbg_curr_process->handle, 0, 0, 0, 0, 0);
/*
* Do a quiet backtrace so that we have an idea of what the situation
* is WRT the source files.
*/
stack_backtrace(dbg_curr_tid, FALSE);
if (!force && is_debug &&
break_should_continue(&addr, code, &dbg_curr_thread->exec_count))
return FALSE;
if (addr.Mode != dbg_curr_thread->addr_mode)
{
const char* name = NULL;
switch (addr.Mode)
{
case AddrMode1616: name = "16 bit"; break;
case AddrMode1632: name = "X?X??X"; break;
case AddrModeReal: name = "vm86"; break;
case AddrModeFlat: name = "32 bit"; break;
}
dbg_printf("In %s mode.\n", name);
dbg_curr_thread->addr_mode = addr.Mode;
}
display_print();
if (!is_debug && !force)
{
/* This is a real crash, dump some info */
be_cpu->print_context(dbg_curr_thread->handle, &dbg_context);
stack_info();
be_cpu->print_segment_info(dbg_curr_thread->handle, &dbg_context);
stack_backtrace(dbg_curr_tid, TRUE);
}
if (!is_debug ||
dbg_curr_thread->exec_mode == dbg_exec_step_over_insn ||
dbg_curr_thread->exec_mode == dbg_exec_step_into_insn)
{
/* Show where we crashed */
dbg_curr_frame = 0;
memory_disasm_one_insn(&addr);
source_list_from_addr(&addr, 0);
}
return TRUE;
}
static void dbg_exception_epilog(void)
{
break_restart_execution(dbg_curr_thread->exec_count);
/*
* This will have gotten absorbed into the breakpoint info
* if it was used. Otherwise it would have been ignored.
* In any case, we don't mess with it any more.
*/
if (dbg_curr_thread->exec_mode == dbg_exec_cont)
dbg_curr_thread->exec_count = 0;
dbg_in_exception = FALSE;
}
static DWORD dbg_handle_exception(EXCEPTION_RECORD* rec, BOOL first_chance,
BOOL force)
{
BOOL is_debug = FALSE;
THREADNAME_INFO* pThreadName;
struct dbg_thread* pThread;
assert(dbg_curr_thread);
switch (rec->ExceptionCode)
{
case EXCEPTION_BREAKPOINT:
case EXCEPTION_SINGLE_STEP:
is_debug = TRUE;
break;
case EXCEPTION_NAME_THREAD:
pThreadName = (THREADNAME_INFO*)(rec->ExceptionInformation);
if (pThreadName->dwThreadID == -1)
pThread = dbg_curr_thread;
else
pThread = dbg_get_thread(dbg_curr_process, pThreadName->dwThreadID);
if (dbg_read_memory(pThreadName->szName, pThread->name, 9))
dbg_printf("Thread ID=0x%lx renamed using MS VC6 extension (name==\"%s\")\n",
pThread->tid, pThread->name);
return DBG_CONTINUE;
}
if (first_chance && !is_debug && !force && !DBG_IVAR(BreakOnFirstChance))
{
/* pass exception to program except for debug exceptions */
return DBG_EXCEPTION_NOT_HANDLED;
}
if (!is_debug)
{
/* print some infos */
dbg_printf("%s: ",
first_chance ? "First chance exception" : "Unhandled exception");
switch (rec->ExceptionCode)
{
case EXCEPTION_INT_DIVIDE_BY_ZERO:
dbg_printf("divide by zero");
break;
case EXCEPTION_INT_OVERFLOW:
dbg_printf("overflow");
break;
case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
dbg_printf("array bounds");
break;
case EXCEPTION_ILLEGAL_INSTRUCTION:
dbg_printf("illegal instruction");
break;
case EXCEPTION_STACK_OVERFLOW:
dbg_printf("stack overflow");
break;
case EXCEPTION_PRIV_INSTRUCTION:
dbg_printf("privileged instruction");
break;
case EXCEPTION_ACCESS_VIOLATION:
if (rec->NumberParameters == 2)
dbg_printf("page fault on %s access to 0x%08lx",
rec->ExceptionInformation[0] ? "write" : "read",
rec->ExceptionInformation[1]);
else
dbg_printf("page fault");
break;
case EXCEPTION_DATATYPE_MISALIGNMENT:
dbg_printf("Alignment");
break;
case DBG_CONTROL_C:
dbg_printf("^C");
break;
case CONTROL_C_EXIT:
dbg_printf("^C");
break;
case STATUS_POSSIBLE_DEADLOCK:
{
ADDRESS addr;
addr.Mode = AddrModeFlat;
addr.Offset = rec->ExceptionInformation[0];
dbg_printf("wait failed on critical section ");
print_address(&addr, FALSE);
}
if (!DBG_IVAR(BreakOnCritSectTimeOut))
{
dbg_printf("\n");
return DBG_EXCEPTION_NOT_HANDLED;
}
break;
case EXCEPTION_WINE_STUB:
{
char dll[32], name[64];
memory_get_string(dbg_curr_process->handle,
(void*)rec->ExceptionInformation[0], TRUE, FALSE,
dll, sizeof(dll));
memory_get_string(dbg_curr_process->handle,
(void*)rec->ExceptionInformation[1], TRUE, FALSE,
name, sizeof(name));
dbg_printf("unimplemented function %s.%s called", dll, name);
}
break;
case EXCEPTION_WINE_ASSERTION:
dbg_printf("assertion failed");
break;
case EXCEPTION_VM86_INTx:
dbg_printf("interrupt %02lx in vm86 mode", rec->ExceptionInformation[0]);
break;
case EXCEPTION_VM86_STI:
dbg_printf("sti in vm86 mode");
break;
case EXCEPTION_VM86_PICRETURN:
dbg_printf("PIC return in vm86 mode");
break;
case EXCEPTION_FLT_DENORMAL_OPERAND:
dbg_printf("denormal float operand");
break;
case EXCEPTION_FLT_DIVIDE_BY_ZERO:
dbg_printf("divide by zero");
break;
case EXCEPTION_FLT_INEXACT_RESULT:
dbg_printf("inexact float result");
break;
case EXCEPTION_FLT_INVALID_OPERATION:
dbg_printf("invalid float operation");
break;
case EXCEPTION_FLT_OVERFLOW:
dbg_printf("floating pointer overflow");
break;
case EXCEPTION_FLT_UNDERFLOW:
dbg_printf("floating pointer underflow");
break;
case EXCEPTION_FLT_STACK_CHECK:
dbg_printf("floating point stack check");
break;
default:
dbg_printf("0x%08lx", rec->ExceptionCode);
break;
}
}
if (dbg_action_mode == automatic_mode)
{
dbg_exception_prolog(is_debug, FALSE, rec->ExceptionCode);
dbg_exception_epilog();
return 0; /* terminate execution */
}
if (dbg_exception_prolog(is_debug, force, rec->ExceptionCode))
{
dbg_interactiveP = TRUE;
return 0;
}
dbg_exception_epilog();
return DBG_CONTINUE;
}
static unsigned dbg_handle_debug_event(DEBUG_EVENT* de)
{
char buffer[256];
DWORD cont = DBG_CONTINUE;
dbg_curr_pid = de->dwProcessId;
dbg_curr_tid = de->dwThreadId;
if ((dbg_curr_process = dbg_get_process(de->dwProcessId)) != NULL)
dbg_curr_thread = dbg_get_thread(dbg_curr_process, de->dwThreadId);
else
dbg_curr_thread = NULL;
switch (de->dwDebugEventCode)
{
case EXCEPTION_DEBUG_EVENT:
if (!dbg_curr_thread)
{
WINE_ERR("%08lx:%08lx: not a registered process or thread (perhaps a 16 bit one ?)\n",
de->dwProcessId, de->dwThreadId);
break;
}
WINE_TRACE("%08lx:%08lx: exception code=%08lx\n",
de->dwProcessId, de->dwThreadId,
de->u.Exception.ExceptionRecord.ExceptionCode);
if (dbg_curr_process->continue_on_first_exception)
{
dbg_curr_process->continue_on_first_exception = FALSE;
if (!DBG_IVAR(BreakOnAttach)) break;
}
if (dbg_fetch_context())
{
cont = dbg_handle_exception(&de->u.Exception.ExceptionRecord,
de->u.Exception.dwFirstChance,
dbg_curr_thread->wait_for_first_exception);
if (cont && dbg_curr_thread)
{
dbg_curr_thread->wait_for_first_exception = 0;
SetThreadContext(dbg_curr_thread->handle, &dbg_context);
}
}
break;
case CREATE_PROCESS_DEBUG_EVENT:
memory_get_string_indirect(de->u.CreateProcessInfo.hProcess,
de->u.CreateProcessInfo.lpImageName,
de->u.CreateProcessInfo.fUnicode,
buffer, sizeof(buffer));
WINE_TRACE("%08lx:%08lx: create process '%s'/%p @%08lx (%ld<%ld>)\n",
de->dwProcessId, de->dwThreadId,
buffer, de->u.CreateProcessInfo.lpImageName,
(unsigned long)(void*)de->u.CreateProcessInfo.lpStartAddress,
de->u.CreateProcessInfo.dwDebugInfoFileOffset,
de->u.CreateProcessInfo.nDebugInfoSize);
dbg_curr_process = dbg_add_process(de->dwProcessId,
de->u.CreateProcessInfo.hProcess,
buffer[0] ? buffer : "<Debugged Process>");
if (dbg_curr_process == NULL)
{
WINE_ERR("Couldn't create process\n");
break;
}
if (!SymInitialize(dbg_curr_process->handle, NULL, TRUE))
dbg_printf("Couldn't initiate DbgHelp\n");
WINE_TRACE("%08lx:%08lx: create thread I @%08lx\n",
de->dwProcessId, de->dwThreadId,
(unsigned long)(void*)de->u.CreateProcessInfo.lpStartAddress);
dbg_curr_thread = dbg_add_thread(dbg_curr_process,
de->dwThreadId,
de->u.CreateProcessInfo.hThread,
de->u.CreateProcessInfo.lpThreadLocalBase);
if (!dbg_curr_thread)
{
WINE_ERR("Couldn't create thread\n");
break;
}
dbg_init_current_process();
dbg_init_current_thread(de->u.CreateProcessInfo.lpStartAddress);
break;
case EXIT_PROCESS_DEBUG_EVENT:
WINE_TRACE("%08lx:%08lx: exit process (%ld)\n",
de->dwProcessId, de->dwThreadId, de->u.ExitProcess.dwExitCode);
if (dbg_curr_process == NULL)
{
WINE_ERR("Unknown process\n");
break;
}
if (!SymCleanup(dbg_curr_process->handle))
dbg_printf("Couldn't initiate DbgHelp\n");
/* just in case */
break_set_xpoints(FALSE);
/* kill last thread */
dbg_del_thread(dbg_curr_process->threads);
dbg_del_process(dbg_curr_process);
dbg_printf("Process of pid=0x%08lx has terminated\n", dbg_curr_pid);
break;
case CREATE_THREAD_DEBUG_EVENT:
WINE_TRACE("%08lx:%08lx: create thread D @%08lx\n",
de->dwProcessId, de->dwThreadId,
(unsigned long)(void*)de->u.CreateThread.lpStartAddress);
if (dbg_curr_process == NULL)
{
WINE_ERR("Unknown process\n");
break;
}
if (dbg_get_thread(dbg_curr_process, de->dwThreadId) != NULL)
{
WINE_TRACE("Thread already listed, skipping\n");
break;
}
dbg_curr_thread = dbg_add_thread(dbg_curr_process,
de->dwThreadId,
de->u.CreateThread.hThread,
de->u.CreateThread.lpThreadLocalBase);
if (!dbg_curr_thread)
{
WINE_ERR("Couldn't create thread\n");
break;
}
dbg_init_current_thread(de->u.CreateThread.lpStartAddress);
break;
case EXIT_THREAD_DEBUG_EVENT:
WINE_TRACE("%08lx:%08lx: exit thread (%ld)\n",
de->dwProcessId, de->dwThreadId, de->u.ExitThread.dwExitCode);
if (dbg_curr_thread == NULL)
{
WINE_ERR("Unknown thread\n");
break;
}
/* FIXME: remove break point set on thread startup */
dbg_del_thread(dbg_curr_thread);
break;
case LOAD_DLL_DEBUG_EVENT:
if (dbg_curr_thread == NULL)
{
WINE_ERR("Unknown thread\n");
break;
}
memory_get_string_indirect(dbg_curr_process->handle,
de->u.LoadDll.lpImageName,
de->u.LoadDll.fUnicode,
buffer, sizeof(buffer));
WINE_TRACE("%08lx:%08lx: loads DLL %s @%08lx (%ld<%ld>)\n",
de->dwProcessId, de->dwThreadId,
buffer, (unsigned long)de->u.LoadDll.lpBaseOfDll,
de->u.LoadDll.dwDebugInfoFileOffset,
de->u.LoadDll.nDebugInfoSize);
_strupr(buffer);
SymLoadModule(dbg_curr_process->handle, de->u.LoadDll.hFile, buffer, NULL,
(unsigned long)de->u.LoadDll.lpBaseOfDll, 0);
break_set_xpoints(FALSE);
break_check_delayed_bp();
break_set_xpoints(TRUE);
if (DBG_IVAR(BreakOnDllLoad))
{
dbg_printf("Stopping on DLL %s loading at 0x%08lx\n",
buffer, (unsigned long)de->u.LoadDll.lpBaseOfDll);
if (dbg_fetch_context()) cont = 0;
}
break;
case UNLOAD_DLL_DEBUG_EVENT:
WINE_TRACE("%08lx:%08lx: unload DLL @%08lx\n",
de->dwProcessId, de->dwThreadId,
(unsigned long)de->u.UnloadDll.lpBaseOfDll);
break_delete_xpoints_from_module((unsigned long)de->u.UnloadDll.lpBaseOfDll);
SymUnloadModule(dbg_curr_process->handle,
(unsigned long)de->u.UnloadDll.lpBaseOfDll);
break;
case OUTPUT_DEBUG_STRING_EVENT:
if (dbg_curr_thread == NULL)
{
WINE_ERR("Unknown thread\n");
break;
}
memory_get_string(dbg_curr_process->handle,
de->u.DebugString.lpDebugStringData, TRUE,
de->u.DebugString.fUnicode, buffer, sizeof(buffer));
WINE_TRACE("%08lx:%08lx: output debug string (%s)\n",
de->dwProcessId, de->dwThreadId, buffer);
break;
case RIP_EVENT:
WINE_TRACE("%08lx:%08lx: rip error=%ld type=%ld\n",
de->dwProcessId, de->dwThreadId, de->u.RipInfo.dwError,
de->u.RipInfo.dwType);
break;
default:
WINE_TRACE("%08lx:%08lx: unknown event (%ld)\n",
de->dwProcessId, de->dwThreadId, de->dwDebugEventCode);
}
if (!cont) return TRUE; /* stop execution */
ContinueDebugEvent(de->dwProcessId, de->dwThreadId, cont);
return FALSE; /* continue execution */
}
static void dbg_resume_debuggee(DWORD cont)
{
if (dbg_in_exception)
{
ADDRESS addr;
dbg_exception_epilog();
memory_get_current_pc(&addr);
WINE_TRACE("Exiting debugger PC=0x%lx mode=%d count=%d\n",
addr.Offset, dbg_curr_thread->exec_mode,
dbg_curr_thread->exec_count);
if (dbg_curr_thread)
{
if (!SetThreadContext(dbg_curr_thread->handle, &dbg_context))
dbg_printf("Cannot set ctx on %lu\n", dbg_curr_tid);
dbg_curr_thread->wait_for_first_exception = 0;
}
}
dbg_interactiveP = FALSE;
if (!ContinueDebugEvent(dbg_curr_pid, dbg_curr_tid, cont))
dbg_printf("Cannot continue on %lu (%lu)\n", dbg_curr_tid, cont);
}
void dbg_wait_next_exception(DWORD cont, int count, int mode)
{
DEBUG_EVENT de;
ADDRESS addr;
if (cont == DBG_CONTINUE)
{
dbg_curr_thread->exec_count = count;
dbg_curr_thread->exec_mode = mode;
}
dbg_resume_debuggee(cont);
while (dbg_curr_process && WaitForDebugEvent(&de, INFINITE))
{
if (dbg_handle_debug_event(&de)) break;
}
if (!dbg_curr_process) return;
dbg_interactiveP = TRUE;
memory_get_current_pc(&addr);
WINE_TRACE("Exiting debugger PC=0x%lx mode=%d count=%d\n",
addr.Offset, dbg_curr_thread->exec_mode,
dbg_curr_thread->exec_count);
}
static DWORD dbg_main_loop(void)
{
DEBUG_EVENT de;
if (dbg_curr_process)
dbg_printf("WineDbg starting on pid 0x%lx\n", dbg_curr_pid);
/* wait for first exception */
while (WaitForDebugEvent(&de, INFINITE))
{
if (dbg_handle_debug_event(&de)) break;
}
switch (dbg_action_mode)
{
case automatic_mode:
/* print some extra information */
dbg_printf("Modules:\n");
info_win32_module(0); /* print all modules */
dbg_printf("Threads:\n");
info_win32_threads();
break;
default:
dbg_interactiveP = TRUE;
if (dbg_curr_process) source_list_from_addr(NULL, 0);
parser(NULL);
}
dbg_printf("WineDbg terminated on pid 0x%lx\n", dbg_curr_pid);
return 0;
}
static unsigned dbg_start_debuggee(LPSTR cmdLine)
{
PROCESS_INFORMATION info;
STARTUPINFOA startup;
memset(&startup, 0, sizeof(startup));
startup.cb = sizeof(startup);
startup.dwFlags = STARTF_USESHOWWINDOW;
startup.wShowWindow = SW_SHOWNORMAL;
/* FIXME: shouldn't need the CREATE_NEW_CONSOLE, but as usual CUI:s need it
* while GUI:s don't
*/
if (!CreateProcess(NULL, cmdLine, NULL, NULL,
FALSE,
DEBUG_PROCESS|DEBUG_ONLY_THIS_PROCESS|CREATE_NEW_CONSOLE,
NULL, NULL, &startup, &info))
{
dbg_printf("Couldn't start process '%s'\n", cmdLine);
return FALSE;
}
dbg_curr_pid = info.dwProcessId;
if (!(dbg_curr_process = dbg_add_process(dbg_curr_pid, 0, NULL))) return FALSE;
return TRUE;
}
void dbg_run_debuggee(const char* args)
{
if (args)
{
WINE_FIXME("Re-running current program with %s as args is broken\n", args);
return;
}
else
{
DEBUG_EVENT de;
if (!dbg_last_cmd_line)
{
dbg_printf("Cannot find previously used command line.\n");
return;
}
dbg_start_debuggee(dbg_last_cmd_line);
while (dbg_curr_process && WaitForDebugEvent(&de, INFINITE))
{
if (dbg_handle_debug_event(&de)) break;
}
source_list_from_addr(NULL, 0);
}
}
BOOL dbg_interrupt_debuggee(void)
{
dbg_printf("Ctrl-C: stopping debuggee\n");
/* FIXME: since we likely have a single process, signal the first process
* in list
*/
if (!dbg_process_list) return FALSE;
dbg_process_list->continue_on_first_exception = FALSE;
return DebugBreakProcess(dbg_process_list);
}
static BOOL WINAPI ctrl_c_handler(DWORD dwCtrlType)
{
if (dwCtrlType == CTRL_C_EVENT)
{
return dbg_interrupt_debuggee();
}
return FALSE;
}
static void dbg_init_console(void)
{
/* set our control-C handler */
SetConsoleCtrlHandler(ctrl_c_handler, TRUE);
/* set our own title */
SetConsoleTitle("Wine Debugger");
}
static int dbg_winedbg_usage(void)
{
dbg_printf("Usage: winedbg [--auto] [--gdb] cmdline\n");
return 1;
}
struct backend_cpu* be_cpu;
#ifdef __i386__
extern struct backend_cpu be_i386;
#elif __powerpc__
extern struct backend_cpu be_ppc;
#else
# error CPU unknown
#endif
int main(int argc, char** argv)
{
DWORD retv = 0;
unsigned gdb_flags = 0;
#ifdef __i386__
be_cpu = &be_i386;
#elif __powerpc__
be_cpu = &be_ppc;
#else
# error CPU unknown
#endif
/* Initialize the output */
dbg_houtput = GetStdHandle(STD_OUTPUT_HANDLE);
/* Initialize internal vars */
if (!dbg_load_internal_vars()) return -1;
/* parse options */
while (argc > 1 && argv[1][0] == '-')
{
if (!strcmp(argv[1], "--command"))
{
argc--; argv++;
arg_command = HeapAlloc(GetProcessHeap(), 0, strlen(argv[1])+2);
strcpy(arg_command, argv[1]);
strcat(arg_command, "\n");
argc--; argv++;
continue;
}
if (!strcmp(argv[1], "--auto"))
{
if (dbg_action_mode != none_mode) return dbg_winedbg_usage();
dbg_action_mode = automatic_mode;
/* force some internal variables */
DBG_IVAR(BreakOnDllLoad) = 0;
argc--; argv++;
dbg_houtput = GetStdHandle(STD_ERROR_HANDLE);
continue;
}
if (!strcmp(argv[1], "--gdb"))
{
if (dbg_action_mode != none_mode) return dbg_winedbg_usage();
dbg_action_mode = gdb_mode;
argc--; argv++;
continue;
}
if (strcmp(argv[1], "--no-start") == 0 && dbg_action_mode == gdb_mode)
{
gdb_flags |= 1;
argc--; argv++; /* as we don't use argv[0] */
continue;
}
if (strcmp(argv[1], "--with-xterm") == 0 && dbg_action_mode == gdb_mode)
{
gdb_flags |= 2;
argc--; argv++; /* as we don't use argv[0] */
continue;
}
return dbg_winedbg_usage();
}
if (dbg_action_mode == none_mode) dbg_action_mode = winedbg_mode;
/* try the form <myself> pid */
if (dbg_curr_pid == 0 && argc == 2)
{
char* ptr;
dbg_curr_pid = strtol(argv[1], &ptr, 10);
if (dbg_curr_pid == 0 || ptr == NULL ||
!dbg_attach_debuggee(dbg_curr_pid, dbg_action_mode != gdb_mode, FALSE))
dbg_curr_pid = 0;
}
/* try the form <myself> pid evt (Win32 JIT debugger) */
if (dbg_curr_pid == 0 && argc == 3)
{
HANDLE hEvent;
DWORD pid;
char* ptr;
if ((pid = strtol(argv[1], &ptr, 10)) != 0 && ptr != NULL &&
(hEvent = (HANDLE)strtol(argv[2], &ptr, 10)) != 0 && ptr != NULL)
{
if (!dbg_attach_debuggee(pid, TRUE, FALSE))
{
/* don't care about result */
SetEvent(hEvent);
goto leave;
}
if (!SetEvent(hEvent))
{
WINE_ERR("Invalid event handle: %p\n", hEvent);
goto leave;
}
CloseHandle(hEvent);
dbg_curr_pid = pid;
}
}
if (dbg_curr_pid == 0 && argc > 1)
{
int i, len;
LPSTR cmdLine;
if (!(cmdLine = HeapAlloc(GetProcessHeap(), 0, len = 1))) goto oom_leave;
cmdLine[0] = '\0';
for (i = 1; i < argc; i++)
{
len += strlen(argv[i]) + 1;
if (!(cmdLine = HeapReAlloc(GetProcessHeap(), 0, cmdLine, len)))
goto oom_leave;
strcat(cmdLine, argv[i]);
cmdLine[len - 2] = ' ';
cmdLine[len - 1] = '\0';
}
if (!dbg_start_debuggee(cmdLine))
{
dbg_printf("Couldn't start process '%s'\n", cmdLine);
goto leave;
}
dbg_last_cmd_line = cmdLine;
}
/* don't save local vars in gdb mode */
if (dbg_action_mode == gdb_mode && dbg_curr_pid)
return gdb_remote(gdb_flags);
dbg_init_console();
SymSetOptions(SymGetOptions() |
SYMOPT_LOAD_LINES | SYMOPT_DEFERRED_LOADS | SYMOPT_AUTO_PUBLICS);
retv = dbg_main_loop();
/* don't save modified variables in auto mode */
if (dbg_action_mode != automatic_mode) dbg_save_internal_vars();
leave:
return retv;
oom_leave:
dbg_printf("Out of memory\n");
return retv;
}
Reference in a new issue View git blame Copy permalink