2000-03-08 17:44:54 +01:00
|
|
|
/* -*- tab-width: 8; c-basic-offset: 4 -*- */
|
|
|
|
|
|
|
|
/* Wine internal debugger
|
|
|
|
* Interface to Windows debugger API
|
|
|
|
* Eric Pouech (c) 2000
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdio.h>
|
2000-04-13 21:31:58 +02:00
|
|
|
#include <string.h>
|
2000-03-08 17:44:54 +01:00
|
|
|
#include "debugger.h"
|
2000-03-26 15:37:39 +02:00
|
|
|
|
|
|
|
#include "thread.h"
|
|
|
|
#include "process.h"
|
2000-05-03 19:48:21 +02:00
|
|
|
#include "wincon.h"
|
2000-03-26 15:37:39 +02:00
|
|
|
#include "wingdi.h"
|
|
|
|
#include "winuser.h"
|
|
|
|
|
2000-03-08 17:44:54 +01:00
|
|
|
#include "winreg.h"
|
|
|
|
|
|
|
|
#ifdef DBG_need_heap
|
|
|
|
HANDLE dbg_heap = 0;
|
|
|
|
#endif
|
|
|
|
|
2000-03-26 15:37:39 +02:00
|
|
|
DBG_PROCESS* DEBUG_CurrProcess = NULL;
|
|
|
|
DBG_THREAD* DEBUG_CurrThread = NULL;
|
|
|
|
CONTEXT DEBUG_context;
|
2000-03-08 17:44:54 +01:00
|
|
|
|
2000-03-26 15:37:39 +02:00
|
|
|
static DBG_PROCESS* proc = NULL;
|
2000-04-30 14:21:15 +02:00
|
|
|
DBG_INTVAR DEBUG_IntVars[DBG_IV_LAST];
|
2000-04-13 21:31:58 +02:00
|
|
|
|
2000-04-30 14:21:15 +02:00
|
|
|
void DEBUG_Output(int chn, const char* buffer, int len)
|
|
|
|
{
|
|
|
|
if (DBG_IVAR(ConChannelMask) & chn)
|
|
|
|
WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buffer, len, NULL, NULL);
|
|
|
|
if (DBG_IVAR(StdChannelMask) & chn)
|
|
|
|
fwrite(buffer, len, 1, stderr);
|
|
|
|
}
|
2000-04-13 21:31:58 +02:00
|
|
|
|
|
|
|
int DEBUG_Printf(int chn, const char* format, ...)
|
|
|
|
{
|
|
|
|
char buf[1024];
|
|
|
|
va_list valist;
|
2000-04-30 14:21:15 +02:00
|
|
|
int len;
|
2000-04-13 21:31:58 +02:00
|
|
|
|
|
|
|
va_start(valist, format);
|
2000-05-05 20:14:34 +02:00
|
|
|
len = wvsnprintf(buf, sizeof(buf), format, valist);
|
2000-04-13 21:31:58 +02:00
|
|
|
va_end(valist);
|
2000-05-05 20:14:34 +02:00
|
|
|
|
|
|
|
if (len <= -1) {
|
|
|
|
len = sizeof(buf) - 1;
|
|
|
|
buf[len] = 0;
|
|
|
|
buf[len - 1] = buf[len - 2] = buf[len - 3] = '.';
|
|
|
|
}
|
2000-04-30 14:21:15 +02:00
|
|
|
DEBUG_Output(chn, buf, len);
|
|
|
|
return len;
|
2000-04-13 21:31:58 +02:00
|
|
|
}
|
2000-03-26 15:37:39 +02:00
|
|
|
|
2000-04-30 14:21:15 +02:00
|
|
|
static BOOL DEBUG_IntVarsRW(int read)
|
2000-03-26 15:37:39 +02:00
|
|
|
{
|
|
|
|
HKEY hkey;
|
2000-04-30 14:21:15 +02:00
|
|
|
DWORD type = REG_DWORD;
|
2000-03-26 15:37:39 +02:00
|
|
|
DWORD val;
|
|
|
|
DWORD count = sizeof(val);
|
2000-04-30 14:21:15 +02:00
|
|
|
int i;
|
|
|
|
DBG_INTVAR* div = DEBUG_IntVars;
|
|
|
|
|
|
|
|
if (read) {
|
|
|
|
/* initializes internal vars table */
|
|
|
|
#define INTERNAL_VAR(_var,_val,_ref,_typ) \
|
|
|
|
div->val = _val; div->name = #_var; div->pval = _ref; \
|
|
|
|
div->type = _typ; div++;
|
2000-04-13 21:31:58 +02:00
|
|
|
#include "intvar.h"
|
|
|
|
#undef INTERNAL_VAR
|
2000-04-30 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
2000-05-01 16:22:02 +02:00
|
|
|
if (RegOpenKey(HKEY_CURRENT_USER, "Software\\Wine\\WineDbg", &hkey) &&
|
|
|
|
RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\WineDbg", &hkey)) {
|
|
|
|
/* since the IVars are not yet setup, DEBUG_Printf doesn't work,
|
|
|
|
* so don't use it */
|
|
|
|
fprintf(stderr, "Cannot create WineDbg key in registry\n");
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < DBG_IV_LAST; i++) {
|
|
|
|
if (read) {
|
|
|
|
if (!DEBUG_IntVars[i].pval) {
|
|
|
|
if (!RegQueryValueEx(hkey, DEBUG_IntVars[i].name, 0,
|
|
|
|
&type, (LPSTR)&val, &count))
|
|
|
|
DEBUG_IntVars[i].val = val;
|
|
|
|
DEBUG_IntVars[i].pval = &DEBUG_IntVars[i].val;
|
2000-04-30 14:21:15 +02:00
|
|
|
} else {
|
2000-05-01 16:22:02 +02:00
|
|
|
*DEBUG_IntVars[i].pval = 0;
|
2000-04-30 14:21:15 +02:00
|
|
|
}
|
2000-05-01 16:22:02 +02:00
|
|
|
} else {
|
|
|
|
/* FIXME: type should be infered from basic type -if any- of intvar */
|
|
|
|
if (DEBUG_IntVars[i].pval == &DEBUG_IntVars[i].val)
|
|
|
|
RegSetValueEx(hkey, DEBUG_IntVars[i].name, 0,
|
|
|
|
type, (LPCVOID)DEBUG_IntVars[i].pval, count);
|
2000-04-30 14:21:15 +02:00
|
|
|
}
|
2000-03-26 15:37:39 +02:00
|
|
|
}
|
2000-05-01 16:22:02 +02:00
|
|
|
RegCloseKey(hkey);
|
2000-03-26 15:37:39 +02:00
|
|
|
return TRUE;
|
|
|
|
}
|
2000-04-30 14:21:15 +02:00
|
|
|
|
|
|
|
DBG_INTVAR* DEBUG_GetIntVar(const char* name)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < DBG_IV_LAST; i++) {
|
|
|
|
if (!strcmp(DEBUG_IntVars[i].name, name))
|
|
|
|
return &DEBUG_IntVars[i];
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
2000-03-26 15:37:39 +02:00
|
|
|
|
|
|
|
static WINE_EXCEPTION_FILTER(wine_dbg)
|
|
|
|
{
|
2000-05-05 20:14:34 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_MESG, "\nwine_dbg: Exception (%lx) inside debugger, continuing...\n", GetExceptionCode());
|
2000-03-26 15:37:39 +02:00
|
|
|
DEBUG_ExternalDebugger();
|
|
|
|
return EXCEPTION_EXECUTE_HANDLER;
|
|
|
|
}
|
2000-03-08 17:44:54 +01:00
|
|
|
|
2000-03-26 15:37:39 +02:00
|
|
|
static DBG_PROCESS* DEBUG_GetProcess(DWORD pid)
|
2000-03-08 17:44:54 +01:00
|
|
|
{
|
2000-03-26 15:37:39 +02:00
|
|
|
DBG_PROCESS* p;
|
2000-03-08 17:44:54 +01:00
|
|
|
|
|
|
|
for (p = proc; p; p = p->next)
|
|
|
|
if (p->pid == pid) break;
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2000-03-26 15:37:39 +02:00
|
|
|
static DBG_PROCESS* DEBUG_AddProcess(DWORD pid, HANDLE h)
|
2000-03-08 17:44:54 +01:00
|
|
|
{
|
2000-03-26 15:37:39 +02:00
|
|
|
DBG_PROCESS* p = DBG_alloc(sizeof(DBG_PROCESS));
|
2000-03-08 17:44:54 +01:00
|
|
|
if (!p)
|
|
|
|
return NULL;
|
|
|
|
p->handle = h;
|
|
|
|
p->pid = pid;
|
|
|
|
p->threads = NULL;
|
2000-03-26 15:37:39 +02:00
|
|
|
p->num_threads = 0;
|
2000-05-05 20:14:34 +02:00
|
|
|
p->continue_on_first_exception = FALSE;
|
2000-03-26 15:37:39 +02:00
|
|
|
p->modules = NULL;
|
|
|
|
p->next_index = 0;
|
2000-05-05 20:14:34 +02:00
|
|
|
p->dbg_hdr_addr = 0;
|
2000-03-08 17:44:54 +01:00
|
|
|
|
|
|
|
p->next = proc;
|
|
|
|
p->prev = NULL;
|
|
|
|
if (proc) proc->prev = p;
|
|
|
|
proc = p;
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2000-03-26 15:37:39 +02:00
|
|
|
static void DEBUG_DelThread(DBG_THREAD* p);
|
2000-03-08 17:44:54 +01:00
|
|
|
|
2000-03-26 15:37:39 +02:00
|
|
|
static void DEBUG_DelProcess(DBG_PROCESS* p)
|
2000-03-08 17:44:54 +01:00
|
|
|
{
|
|
|
|
if (p->threads != NULL) {
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_ERR, "Shouldn't happen\n");
|
2000-03-08 17:44:54 +01:00
|
|
|
while (p->threads) DEBUG_DelThread(p->threads);
|
|
|
|
}
|
|
|
|
if (p->prev) p->prev->next = p->next;
|
|
|
|
if (p->next) p->next->prev = p->prev;
|
|
|
|
if (p == proc) proc = p->next;
|
|
|
|
DBG_free(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void DEBUG_InitCurrProcess(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2000-03-10 23:25:07 +01:00
|
|
|
static BOOL DEBUG_ProcessGetString(char* buffer, int size, HANDLE hp, LPSTR addr)
|
|
|
|
{
|
|
|
|
DWORD sz;
|
|
|
|
*(WCHAR*)buffer = 0;
|
|
|
|
return (addr && ReadProcessMemory(hp, addr, buffer, size, &sz));
|
|
|
|
}
|
|
|
|
|
|
|
|
static BOOL DEBUG_ProcessGetStringIndirect(char* buffer, int size, HANDLE hp, LPVOID addr)
|
2000-03-08 17:44:54 +01:00
|
|
|
{
|
|
|
|
LPVOID ad;
|
|
|
|
DWORD sz;
|
|
|
|
|
|
|
|
if ( addr
|
|
|
|
&& ReadProcessMemory(hp, addr, &ad, sizeof(ad), &sz)
|
|
|
|
&& sz == sizeof(ad)
|
|
|
|
&& ad
|
|
|
|
&& ReadProcessMemory(hp, ad, buffer, size, &sz))
|
|
|
|
return TRUE;
|
|
|
|
*(WCHAR*)buffer = 0;
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2000-03-26 15:37:39 +02:00
|
|
|
static DBG_THREAD* DEBUG_GetThread(DBG_PROCESS* p, DWORD tid)
|
2000-03-08 17:44:54 +01:00
|
|
|
{
|
2000-03-26 15:37:39 +02:00
|
|
|
DBG_THREAD* t;
|
2000-03-08 17:44:54 +01:00
|
|
|
|
|
|
|
for (t = p->threads; t; t = t->next)
|
|
|
|
if (t->tid == tid) break;
|
|
|
|
return t;
|
|
|
|
}
|
|
|
|
|
2000-03-26 15:37:39 +02:00
|
|
|
static DBG_THREAD* DEBUG_AddThread(DBG_PROCESS* p, DWORD tid,
|
|
|
|
HANDLE h, LPVOID start, LPVOID teb)
|
2000-03-08 17:44:54 +01:00
|
|
|
{
|
2000-03-26 15:37:39 +02:00
|
|
|
DBG_THREAD* t = DBG_alloc(sizeof(DBG_THREAD));
|
2000-03-08 17:44:54 +01:00
|
|
|
if (!t)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
t->handle = h;
|
|
|
|
t->tid = tid;
|
|
|
|
t->start = start;
|
|
|
|
t->teb = teb;
|
|
|
|
t->process = p;
|
|
|
|
t->wait_for_first_exception = 0;
|
|
|
|
t->dbg_exec_mode = EXEC_CONT;
|
|
|
|
t->dbg_exec_count = 0;
|
2000-03-26 15:37:39 +02:00
|
|
|
|
|
|
|
p->num_threads++;
|
2000-03-08 17:44:54 +01:00
|
|
|
t->next = p->threads;
|
|
|
|
t->prev = NULL;
|
|
|
|
if (p->threads) p->threads->prev = t;
|
|
|
|
p->threads = t;
|
|
|
|
|
|
|
|
return t;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void DEBUG_InitCurrThread(void)
|
|
|
|
{
|
|
|
|
if (DEBUG_CurrThread->start) {
|
2000-04-13 21:31:58 +02:00
|
|
|
if (DEBUG_CurrThread->process->num_threads == 1 ||
|
|
|
|
DBG_IVAR(BreakAllThreadsStartup)) {
|
2000-03-26 15:37:39 +02:00
|
|
|
DBG_VALUE value;
|
|
|
|
|
|
|
|
DEBUG_SetBreakpoints(FALSE);
|
|
|
|
value.type = NULL;
|
|
|
|
value.cookie = DV_TARGET;
|
|
|
|
value.addr.seg = 0;
|
|
|
|
value.addr.off = (DWORD)DEBUG_CurrThread->start;
|
2000-05-05 20:14:34 +02:00
|
|
|
DEBUG_AddBreakpoint(&value, NULL);
|
2000-03-26 15:37:39 +02:00
|
|
|
DEBUG_SetBreakpoints(TRUE);
|
|
|
|
}
|
2000-03-08 17:44:54 +01:00
|
|
|
} else {
|
|
|
|
DEBUG_CurrThread->wait_for_first_exception = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-03-26 15:37:39 +02:00
|
|
|
static void DEBUG_DelThread(DBG_THREAD* t)
|
2000-03-08 17:44:54 +01:00
|
|
|
{
|
|
|
|
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;
|
2000-03-26 15:37:39 +02:00
|
|
|
t->process->num_threads--;
|
2000-03-08 17:44:54 +01:00
|
|
|
DBG_free(t);
|
|
|
|
}
|
|
|
|
|
|
|
|
static BOOL DEBUG_HandleException( EXCEPTION_RECORD *rec, BOOL first_chance, BOOL force )
|
|
|
|
{
|
|
|
|
BOOL is_debug = FALSE;
|
|
|
|
BOOL ret;
|
|
|
|
|
2000-04-13 21:31:58 +02:00
|
|
|
/* FIXME: need for a configuration var ? */
|
|
|
|
/* pass to app first ??? */
|
|
|
|
/* if (first_chance && !force) return 0; */
|
2000-03-08 17:44:54 +01:00
|
|
|
|
|
|
|
switch (rec->ExceptionCode)
|
|
|
|
{
|
|
|
|
case EXCEPTION_BREAKPOINT:
|
|
|
|
case EXCEPTION_SINGLE_STEP:
|
|
|
|
is_debug = TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!is_debug)
|
|
|
|
{
|
|
|
|
/* print some infos */
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf( DBG_CHN_MESG, "%s: ",
|
|
|
|
first_chance ? "First chance exception" : "Unhandled exception" );
|
2000-05-05 20:14:34 +02:00
|
|
|
switch (rec->ExceptionCode)
|
2000-03-08 17:44:54 +01:00
|
|
|
{
|
|
|
|
case EXCEPTION_INT_DIVIDE_BY_ZERO:
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf( DBG_CHN_MESG, "divide by zero" );
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
case EXCEPTION_INT_OVERFLOW:
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf( DBG_CHN_MESG, "overflow" );
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf( DBG_CHN_MESG, "array bounds " );
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
case EXCEPTION_ILLEGAL_INSTRUCTION:
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf( DBG_CHN_MESG, "illegal instruction" );
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
case EXCEPTION_STACK_OVERFLOW:
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf( DBG_CHN_MESG, "stack overflow" );
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
case EXCEPTION_PRIV_INSTRUCTION:
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf( DBG_CHN_MESG, "priviledged instruction" );
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
case EXCEPTION_ACCESS_VIOLATION:
|
|
|
|
if (rec->NumberParameters == 2)
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf( DBG_CHN_MESG, "page fault on %s access to 0x%08lx",
|
|
|
|
rec->ExceptionInformation[0] ? "write" : "read",
|
|
|
|
rec->ExceptionInformation[1] );
|
2000-03-08 17:44:54 +01:00
|
|
|
else
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf( DBG_CHN_MESG, "page fault" );
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
case EXCEPTION_DATATYPE_MISALIGNMENT:
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf( DBG_CHN_MESG, "Alignment" );
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
case CONTROL_C_EXIT:
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf( DBG_CHN_MESG, "^C" );
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
case EXCEPTION_CRITICAL_SECTION_WAIT:
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf( DBG_CHN_MESG, "critical section %08lx wait failed",
|
|
|
|
rec->ExceptionInformation[0] );
|
2000-04-30 14:21:15 +02:00
|
|
|
if (!DBG_IVAR(BreakOnCritSectTimeOut))
|
|
|
|
return DBG_CONTINUE;
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
default:
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf( DBG_CHN_MESG, "%08lx", rec->ExceptionCode );
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
}
|
2000-05-05 20:14:34 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_MESG, "\n");
|
2000-03-08 17:44:54 +01:00
|
|
|
}
|
|
|
|
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_TRACE,
|
|
|
|
"Entering debugger PC=%lx EFL=%08lx mode=%d count=%d\n",
|
|
|
|
DEBUG_context.Eip, DEBUG_context.EFlags,
|
|
|
|
DEBUG_CurrThread->dbg_exec_mode, DEBUG_CurrThread->dbg_exec_count);
|
2000-03-08 17:44:54 +01:00
|
|
|
|
2000-03-09 19:45:43 +01:00
|
|
|
ret = DEBUG_Main( is_debug, force, rec->ExceptionCode );
|
2000-04-13 21:31:58 +02:00
|
|
|
|
|
|
|
DEBUG_Printf(DBG_CHN_TRACE,
|
|
|
|
"Exiting debugger PC=%lx EFL=%08lx mode=%d count=%d\n",
|
|
|
|
DEBUG_context.Eip, DEBUG_context.EFlags,
|
|
|
|
DEBUG_CurrThread->dbg_exec_mode, DEBUG_CurrThread->dbg_exec_count);
|
2000-03-08 17:44:54 +01:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2000-04-13 21:31:58 +02:00
|
|
|
static BOOL DEBUG_HandleDebugEvent(DEBUG_EVENT* de, LPDWORD cont)
|
2000-03-08 17:44:54 +01:00
|
|
|
{
|
|
|
|
char buffer[256];
|
2000-04-13 21:31:58 +02:00
|
|
|
BOOL ret;
|
2000-03-26 15:37:39 +02:00
|
|
|
|
|
|
|
__TRY {
|
2000-04-13 21:31:58 +02:00
|
|
|
ret = TRUE;
|
|
|
|
*cont = 0L;
|
2000-03-26 15:37:39 +02:00
|
|
|
|
|
|
|
if ((DEBUG_CurrProcess = DEBUG_GetProcess(de->dwProcessId)) != NULL)
|
|
|
|
DEBUG_CurrThread = DEBUG_GetThread(DEBUG_CurrProcess, de->dwThreadId);
|
2000-03-08 17:44:54 +01:00
|
|
|
else
|
|
|
|
DEBUG_CurrThread = NULL;
|
2000-03-26 15:37:39 +02:00
|
|
|
|
|
|
|
switch (de->dwDebugEventCode) {
|
2000-03-08 17:44:54 +01:00
|
|
|
case EXCEPTION_DEBUG_EVENT:
|
2000-04-13 21:31:58 +02:00
|
|
|
if (!DEBUG_CurrThread) {
|
|
|
|
DEBUG_Printf(DBG_CHN_ERR, "%08lx:%08lx: not a registered process or thread (perhaps a 16 bit one ?)\n",
|
|
|
|
de->dwProcessId, de->dwThreadId);
|
|
|
|
break;
|
|
|
|
}
|
2000-03-26 15:37:39 +02:00
|
|
|
|
2000-05-05 20:14:34 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: exception code=%08lx\n",
|
2000-04-13 21:31:58 +02:00
|
|
|
de->dwProcessId, de->dwThreadId,
|
2000-05-05 20:14:34 +02:00
|
|
|
de->u.Exception.ExceptionRecord.ExceptionCode);
|
|
|
|
|
|
|
|
if (DEBUG_CurrProcess->continue_on_first_exception) {
|
|
|
|
DEBUG_CurrProcess->continue_on_first_exception = FALSE;
|
|
|
|
if (!DBG_IVAR(BreakOnAttach)) {
|
|
|
|
*cont = DBG_CONTINUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-03-08 17:44:54 +01:00
|
|
|
DEBUG_context.ContextFlags = CONTEXT_CONTROL|CONTEXT_INTEGER|CONTEXT_SEGMENTS|CONTEXT_DEBUG_REGISTERS;
|
|
|
|
if (!GetThreadContext(DEBUG_CurrThread->handle, &DEBUG_context)) {
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_WARN, "Can't get thread's context\n");
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
}
|
2000-03-26 15:37:39 +02:00
|
|
|
|
2000-04-13 21:31:58 +02:00
|
|
|
*cont = DEBUG_HandleException(&de->u.Exception.ExceptionRecord,
|
|
|
|
de->u.Exception.dwFirstChance,
|
|
|
|
DEBUG_CurrThread->wait_for_first_exception);
|
|
|
|
if (DEBUG_CurrThread->dbg_exec_mode == EXEC_KILL) {
|
|
|
|
ret = FALSE;
|
|
|
|
} else {
|
2000-03-08 17:44:54 +01:00
|
|
|
DEBUG_CurrThread->wait_for_first_exception = 0;
|
2000-04-13 21:31:58 +02:00
|
|
|
SetThreadContext(DEBUG_CurrThread->handle, &DEBUG_context);
|
2000-03-08 17:44:54 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CREATE_THREAD_DEBUG_EVENT:
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: create thread D @%p\n", de->dwProcessId, de->dwThreadId,
|
|
|
|
de->u.CreateThread.lpStartAddress);
|
2000-03-08 17:44:54 +01:00
|
|
|
|
|
|
|
if (DEBUG_CurrProcess == NULL) {
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_ERR, "Unknown process\n");
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
}
|
2000-03-26 15:37:39 +02:00
|
|
|
if (DEBUG_GetThread(DEBUG_CurrProcess, de->dwThreadId) != NULL) {
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_TRACE, "Thread already listed, skipping\n");
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
}
|
2000-03-26 15:37:39 +02:00
|
|
|
|
2000-03-08 17:44:54 +01:00
|
|
|
DEBUG_CurrThread = DEBUG_AddThread(DEBUG_CurrProcess,
|
2000-03-26 15:37:39 +02:00
|
|
|
de->dwThreadId,
|
|
|
|
de->u.CreateThread.hThread,
|
|
|
|
de->u.CreateThread.lpStartAddress,
|
|
|
|
de->u.CreateThread.lpThreadLocalBase);
|
2000-03-08 17:44:54 +01:00
|
|
|
if (!DEBUG_CurrThread) {
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_ERR, "Couldn't create thread\n");
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
DEBUG_InitCurrThread();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CREATE_PROCESS_DEBUG_EVENT:
|
2000-03-10 23:25:07 +01:00
|
|
|
DEBUG_ProcessGetStringIndirect(buffer, sizeof(buffer),
|
2000-03-26 15:37:39 +02:00
|
|
|
de->u.CreateProcessInfo.hProcess,
|
2000-04-13 21:31:58 +02:00
|
|
|
de->u.CreateProcessInfo.lpImageName);
|
2000-03-08 17:44:54 +01:00
|
|
|
|
2000-03-26 15:37:39 +02:00
|
|
|
/* FIXME unicode ? de->u.CreateProcessInfo.fUnicode */
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: create process %s @%p (%ld<%ld>)\n",
|
|
|
|
de->dwProcessId, de->dwThreadId,
|
|
|
|
buffer,
|
|
|
|
de->u.CreateProcessInfo.lpStartAddress,
|
|
|
|
de->u.CreateProcessInfo.dwDebugInfoFileOffset,
|
|
|
|
de->u.CreateProcessInfo.nDebugInfoSize);
|
2000-03-08 17:44:54 +01:00
|
|
|
|
2000-05-05 20:14:34 +02:00
|
|
|
if ((DEBUG_CurrProcess = DEBUG_GetProcess(de->dwProcessId)) != NULL) {
|
|
|
|
if (DEBUG_CurrProcess->handle) {
|
|
|
|
DEBUG_Printf(DBG_CHN_ERR, "Skipping already defined process\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
DEBUG_CurrProcess->handle = de->u.CreateProcessInfo.hProcess;
|
|
|
|
} else {
|
|
|
|
DEBUG_CurrProcess = DEBUG_AddProcess(de->dwProcessId,
|
|
|
|
de->u.CreateProcessInfo.hProcess);
|
|
|
|
if (DEBUG_CurrProcess == NULL) {
|
|
|
|
DEBUG_Printf(DBG_CHN_ERR, "Unknown process\n");
|
|
|
|
break;
|
|
|
|
}
|
2000-03-08 17:44:54 +01:00
|
|
|
}
|
|
|
|
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: create thread I @%p\n",
|
|
|
|
de->dwProcessId, de->dwThreadId,
|
|
|
|
de->u.CreateProcessInfo.lpStartAddress);
|
2000-03-08 17:44:54 +01:00
|
|
|
|
|
|
|
DEBUG_CurrThread = DEBUG_AddThread(DEBUG_CurrProcess,
|
2000-03-26 15:37:39 +02:00
|
|
|
de->dwThreadId,
|
|
|
|
de->u.CreateProcessInfo.hThread,
|
|
|
|
de->u.CreateProcessInfo.lpStartAddress,
|
|
|
|
de->u.CreateProcessInfo.lpThreadLocalBase);
|
2000-03-08 17:44:54 +01:00
|
|
|
if (!DEBUG_CurrThread) {
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_ERR, "Couldn't create thread\n");
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
DEBUG_InitCurrProcess();
|
|
|
|
DEBUG_InitCurrThread();
|
2000-03-15 20:57:20 +01:00
|
|
|
/* so far, process name is not set */
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_LoadModule32("<Debugged process>", de->u.CreateProcessInfo.hFile,
|
|
|
|
(DWORD)de->u.CreateProcessInfo.lpBaseOfImage);
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case EXIT_THREAD_DEBUG_EVENT:
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: exit thread (%ld)\n",
|
|
|
|
de->dwProcessId, de->dwThreadId, de->u.ExitThread.dwExitCode);
|
2000-03-26 15:37:39 +02:00
|
|
|
|
2000-03-08 17:44:54 +01:00
|
|
|
if (DEBUG_CurrThread == NULL) {
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_ERR, "Unknown thread\n");
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* FIXME: remove break point set on thread startup */
|
|
|
|
DEBUG_DelThread(DEBUG_CurrThread);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case EXIT_PROCESS_DEBUG_EVENT:
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: exit process (%ld)\n",
|
|
|
|
de->dwProcessId, de->dwThreadId, de->u.ExitProcess.dwExitCode);
|
2000-03-26 15:37:39 +02:00
|
|
|
|
2000-03-08 17:44:54 +01:00
|
|
|
if (DEBUG_CurrProcess == NULL) {
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_ERR, "Unknown process\n");
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
}
|
2000-04-13 21:31:58 +02:00
|
|
|
/* just in case */
|
|
|
|
DEBUG_SetBreakpoints(FALSE);
|
2000-03-08 17:44:54 +01:00
|
|
|
/* kill last thread */
|
|
|
|
DEBUG_DelThread(DEBUG_CurrProcess->threads);
|
|
|
|
DEBUG_DelProcess(DEBUG_CurrProcess);
|
2000-04-13 21:31:58 +02:00
|
|
|
ret = FALSE;
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case LOAD_DLL_DEBUG_EVENT:
|
|
|
|
if (DEBUG_CurrThread == NULL) {
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_ERR, "Unknown thread\n");
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
}
|
2000-03-10 23:25:07 +01:00
|
|
|
DEBUG_ProcessGetStringIndirect(buffer, sizeof(buffer),
|
|
|
|
DEBUG_CurrThread->process->handle,
|
2000-03-26 15:37:39 +02:00
|
|
|
de->u.LoadDll.lpImageName);
|
2000-03-08 17:44:54 +01:00
|
|
|
|
2000-03-26 15:37:39 +02:00
|
|
|
/* FIXME unicode: de->u.LoadDll.fUnicode */
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: loads DLL %s @%p (%ld<%ld>)\n",
|
|
|
|
de->dwProcessId, de->dwThreadId,
|
|
|
|
buffer, de->u.LoadDll.lpBaseOfDll,
|
|
|
|
de->u.LoadDll.dwDebugInfoFileOffset,
|
|
|
|
de->u.LoadDll.nDebugInfoSize);
|
|
|
|
CharUpper(buffer);
|
|
|
|
DEBUG_LoadModule32(buffer, de->u.LoadDll.hFile, (DWORD)de->u.LoadDll.lpBaseOfDll);
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case UNLOAD_DLL_DEBUG_EVENT:
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: unload DLL @%p\n", de->dwProcessId, de->dwThreadId,
|
|
|
|
de->u.UnloadDll.lpBaseOfDll);
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case OUTPUT_DEBUG_STRING_EVENT:
|
|
|
|
if (DEBUG_CurrThread == NULL) {
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_ERR, "Unknown thread\n");
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
}
|
2000-03-26 15:37:39 +02:00
|
|
|
|
2000-03-08 17:44:54 +01:00
|
|
|
DEBUG_ProcessGetString(buffer, sizeof(buffer),
|
|
|
|
DEBUG_CurrThread->process->handle,
|
2000-03-26 15:37:39 +02:00
|
|
|
de->u.DebugString.lpDebugStringData);
|
2000-03-08 17:44:54 +01:00
|
|
|
|
2000-03-26 15:37:39 +02:00
|
|
|
/* fixme unicode de->u.DebugString.fUnicode ? */
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: output debug string (%s)\n",
|
|
|
|
de->dwProcessId, de->dwThreadId, buffer);
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case RIP_EVENT:
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: rip error=%ld type=%ld\n",
|
|
|
|
de->dwProcessId, de->dwThreadId, de->u.RipInfo.dwError,
|
|
|
|
de->u.RipInfo.dwType);
|
2000-03-08 17:44:54 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: unknown event (%ld)\n",
|
|
|
|
de->dwProcessId, de->dwThreadId, de->dwDebugEventCode);
|
2000-03-08 17:44:54 +01:00
|
|
|
}
|
2000-03-26 15:37:39 +02:00
|
|
|
|
|
|
|
} __EXCEPT(wine_dbg) {
|
2000-04-13 21:31:58 +02:00
|
|
|
*cont = 0;
|
|
|
|
ret = TRUE;
|
2000-03-26 15:37:39 +02:00
|
|
|
}
|
|
|
|
__ENDTRY;
|
|
|
|
|
2000-04-13 21:31:58 +02:00
|
|
|
return ret;
|
2000-03-26 15:37:39 +02:00
|
|
|
}
|
|
|
|
|
2000-04-30 14:21:15 +02:00
|
|
|
static DWORD DEBUG_MainLoop(DWORD pid)
|
2000-03-26 15:37:39 +02:00
|
|
|
{
|
|
|
|
DEBUG_EVENT de;
|
|
|
|
DWORD cont;
|
2000-04-13 21:31:58 +02:00
|
|
|
BOOL ret = TRUE;
|
2000-03-26 15:37:39 +02:00
|
|
|
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_MESG, " on pid %ld\n", pid);
|
|
|
|
|
|
|
|
while (ret && WaitForDebugEvent(&de, INFINITE)) {
|
|
|
|
ret = DEBUG_HandleDebugEvent(&de, &cont);
|
2000-03-08 17:44:54 +01:00
|
|
|
ContinueDebugEvent(de.dwProcessId, de.dwThreadId, cont);
|
|
|
|
}
|
|
|
|
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_MESG, "WineDbg terminated on pid %ld\n", pid);
|
2000-04-30 14:21:15 +02:00
|
|
|
|
|
|
|
return 0;
|
2000-03-08 17:44:54 +01:00
|
|
|
}
|
|
|
|
|
2000-04-30 14:21:15 +02:00
|
|
|
int DEBUG_main(int argc, char** argv)
|
2000-03-09 19:45:43 +01:00
|
|
|
{
|
2000-04-30 14:21:15 +02:00
|
|
|
DWORD pid = 0, retv = 0;
|
|
|
|
|
|
|
|
#ifdef DBG_need_heap
|
|
|
|
/* Initialize the debugger heap. */
|
|
|
|
dbg_heap = HeapCreate(HEAP_NO_SERIALIZE, 0x1000, 0x8000000); /* 128MB */
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Initialize the type handling stuff. */
|
|
|
|
DEBUG_InitTypes();
|
|
|
|
DEBUG_InitCVDataTypes();
|
|
|
|
|
2000-05-05 20:14:34 +02:00
|
|
|
/* Initialize internal vars (types must be initialized before) */
|
2000-05-01 16:22:02 +02:00
|
|
|
if (!DEBUG_IntVarsRW(TRUE)) return -1;
|
2000-03-08 17:44:54 +01:00
|
|
|
|
2000-04-13 21:31:58 +02:00
|
|
|
/* keep it as a guiexe for now, so that Wine won't touch the Unix stdin,
|
|
|
|
* stdout and stderr streams
|
|
|
|
*/
|
2000-04-30 14:21:15 +02:00
|
|
|
if (DBG_IVAR(UseXTerm)) {
|
2000-04-13 21:31:58 +02:00
|
|
|
COORD pos;
|
|
|
|
|
|
|
|
/* This is a hack: it forces creation of an xterm, not done by default */
|
2000-05-03 19:48:21 +02:00
|
|
|
pos.X = 0; pos.Y = 1;
|
2000-04-13 21:31:58 +02:00
|
|
|
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
|
|
|
|
}
|
2000-03-08 17:44:54 +01:00
|
|
|
|
2000-04-13 21:31:58 +02:00
|
|
|
DEBUG_Printf(DBG_CHN_MESG, "Starting WineDbg... ");
|
2000-04-30 14:21:15 +02:00
|
|
|
if (argc == 3) {
|
|
|
|
HANDLE hEvent;
|
2000-04-13 21:31:58 +02:00
|
|
|
|
2000-04-30 14:21:15 +02:00
|
|
|
if ((pid = atoi(argv[1])) != 0 && (hEvent = atoi(argv[2])) != 0) {
|
2000-05-05 20:14:34 +02:00
|
|
|
if (!(DEBUG_CurrProcess = DEBUG_AddProcess(pid, 0))) goto leave;
|
|
|
|
DEBUG_CurrProcess->continue_on_first_exception = TRUE;
|
|
|
|
|
2000-04-13 21:31:58 +02:00
|
|
|
if (!DebugActiveProcess(pid)) {
|
|
|
|
DEBUG_Printf(DBG_CHN_ERR, "Can't attach process %ld: %ld\n",
|
|
|
|
pid, GetLastError());
|
2000-04-30 14:21:15 +02:00
|
|
|
SetEvent(hEvent);
|
|
|
|
goto leave;
|
2000-04-13 21:31:58 +02:00
|
|
|
}
|
|
|
|
SetEvent(hEvent);
|
2000-04-30 14:21:15 +02:00
|
|
|
} else {
|
|
|
|
pid = 0;
|
2000-04-13 21:31:58 +02:00
|
|
|
}
|
2000-03-09 19:45:43 +01:00
|
|
|
}
|
2000-04-30 14:21:15 +02:00
|
|
|
|
|
|
|
if (pid == 0) {
|
2000-04-13 21:31:58 +02:00
|
|
|
PROCESS_INFORMATION info;
|
|
|
|
STARTUPINFOA startup;
|
2000-03-09 19:45:43 +01:00
|
|
|
|
2000-04-13 21:31:58 +02:00
|
|
|
memset(&startup, 0, sizeof(startup));
|
|
|
|
startup.cb = sizeof(startup);
|
|
|
|
startup.dwFlags = STARTF_USESHOWWINDOW;
|
|
|
|
startup.wShowWindow = SW_SHOWNORMAL;
|
2000-03-09 19:45:43 +01:00
|
|
|
|
2000-04-30 14:21:15 +02:00
|
|
|
if (!CreateProcess(NULL, argv[1], NULL, NULL,
|
|
|
|
FALSE, DEBUG_PROCESS, NULL, NULL, &startup, &info)) {
|
|
|
|
DEBUG_Printf(DBG_CHN_MESG, "Couldn't start process '%s'\n", argv[1]);
|
|
|
|
goto leave;
|
2000-03-09 19:45:43 +01:00
|
|
|
}
|
2000-04-30 14:21:15 +02:00
|
|
|
pid = info.dwProcessId;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pid) retv = DEBUG_MainLoop(pid);
|
|
|
|
leave:
|
|
|
|
/* saves modified variables */
|
|
|
|
DEBUG_IntVarsRW(FALSE);
|
|
|
|
|
|
|
|
return retv;
|
2000-03-09 19:45:43 +01:00
|
|
|
}
|
2000-04-13 21:31:58 +02:00
|
|
|
|
2000-04-30 14:21:15 +02:00
|
|
|
|