480 lines
13 KiB
C
480 lines
13 KiB
C
|
/* -*- 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>
|
||
|
|
#include <sys/stat.h>
|
||
|
|
#include "debugger.h"
|
||
|
|
#include "winbase.h"
|
||
|
|
#include "winreg.h"
|
||
|
|
#include "debugtools.h"
|
||
|
|
#include "options.h"
|
||
|
|
|
||
|
|
#ifdef DBG_need_heap
|
||
|
|
HANDLE dbg_heap = 0;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
DEFAULT_DEBUG_CHANNEL(winedbg);
|
||
|
|
|
||
|
|
WINE_DBG_PROCESS* DEBUG_CurrProcess = NULL;
|
||
|
|
WINE_DBG_THREAD* DEBUG_CurrThread = NULL;
|
||
|
|
CONTEXT DEBUG_context;
|
||
|
|
|
||
|
|
static WINE_DBG_PROCESS* proc = NULL;
|
||
|
|
|
||
|
|
static WINE_DBG_PROCESS* DEBUG_GetProcess(DWORD pid)
|
||
|
|
{
|
||
|
|
WINE_DBG_PROCESS* p;
|
||
|
|
|
||
|
|
for (p = proc; p; p = p->next)
|
||
|
|
if (p->pid == pid) break;
|
||
|
|
return p;
|
||
|
|
}
|
||
|
|
|
||
|
|
static WINE_DBG_PROCESS* DEBUG_AddProcess(DWORD pid, HANDLE h)
|
||
|
|
{
|
||
|
|
WINE_DBG_PROCESS* p = DBG_alloc(sizeof(WINE_DBG_PROCESS));
|
||
|
|
if (!p)
|
||
|
|
return NULL;
|
||
|
|
p->handle = h;
|
||
|
|
p->pid = pid;
|
||
|
|
p->threads = NULL;
|
||
|
|
|
||
|
|
p->next = proc;
|
||
|
|
p->prev = NULL;
|
||
|
|
if (proc) proc->prev = p;
|
||
|
|
proc = p;
|
||
|
|
return p;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void DEBUG_DelThread(WINE_DBG_THREAD* p);
|
||
|
|
|
||
|
|
static void DEBUG_DelProcess(WINE_DBG_PROCESS* p)
|
||
|
|
{
|
||
|
|
if (p->threads != NULL) {
|
||
|
|
ERR("Shouldn't happen\n");
|
||
|
|
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)
|
||
|
|
{
|
||
|
|
#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();
|
||
|
|
|
||
|
|
/*
|
||
|
|
* In some cases we can read the stabs information directly
|
||
|
|
* from the executable. If this is the case, we don't need
|
||
|
|
* to bother with trying to read a symbol file, as the stabs
|
||
|
|
* also have line number and local variable information.
|
||
|
|
* As long as gcc is used for the compiler, stabs will
|
||
|
|
* be the default. On SVr4, DWARF could be used, but we
|
||
|
|
* don't grok that yet, and in this case we fall back to using
|
||
|
|
* the wine.sym file.
|
||
|
|
*/
|
||
|
|
if( DEBUG_ReadExecutableDbgInfo() == FALSE )
|
||
|
|
{
|
||
|
|
char* symfilename = "wine.sym";
|
||
|
|
struct stat statbuf;
|
||
|
|
HKEY hWineConf, hkey;
|
||
|
|
DWORD count;
|
||
|
|
char symbolTableFile[256];
|
||
|
|
|
||
|
|
if (-1 == stat(symfilename, &statbuf) )
|
||
|
|
symfilename = LIBDIR "wine.sym";
|
||
|
|
|
||
|
|
strcpy(symbolTableFile, symfilename);
|
||
|
|
if (!RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config", &hWineConf)) {
|
||
|
|
if (!RegOpenKeyA(hWineConf, "wine", &hkey)) {
|
||
|
|
count = sizeof(symbolTableFile);
|
||
|
|
RegQueryValueA(hkey, "SymbolTableFile", symbolTableFile, &count);
|
||
|
|
RegCloseKey(hkey);
|
||
|
|
}
|
||
|
|
RegCloseKey(hWineConf);
|
||
|
|
}
|
||
|
|
DEBUG_ReadSymbolTable(symbolTableFile);
|
||
|
|
}
|
||
|
|
DEBUG_LoadEntryPoints(NULL);
|
||
|
|
DEBUG_ProcessDeferredDebug();
|
||
|
|
}
|
||
|
|
|
||
|
|
static BOOL DEBUG_ProcessGetString(char* buffer, int size,
|
||
|
|
HANDLE hp, LPVOID addr)
|
||
|
|
{
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
|
||
|
|
static WINE_DBG_THREAD* DEBUG_GetThread(WINE_DBG_PROCESS* p, DWORD tid)
|
||
|
|
{
|
||
|
|
WINE_DBG_THREAD* t;
|
||
|
|
|
||
|
|
for (t = p->threads; t; t = t->next)
|
||
|
|
if (t->tid == tid) break;
|
||
|
|
return t;
|
||
|
|
}
|
||
|
|
|
||
|
|
static WINE_DBG_THREAD* DEBUG_AddThread(WINE_DBG_PROCESS* p, DWORD tid,
|
||
|
|
HANDLE h, LPVOID start, LPVOID teb)
|
||
|
|
{
|
||
|
|
WINE_DBG_THREAD* t = DBG_alloc(sizeof(WINE_DBG_THREAD));
|
||
|
|
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;
|
||
|
|
|
||
|
|
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 (!Options.debug) return;
|
||
|
|
|
||
|
|
if (DEBUG_CurrThread->start) {
|
||
|
|
DBG_ADDR addr;
|
||
|
|
|
||
|
|
DEBUG_SetBreakpoints(FALSE);
|
||
|
|
addr.seg = 0;
|
||
|
|
addr.off = (DWORD)DEBUG_CurrThread->start;
|
||
|
|
DEBUG_AddBreakpoint(&addr);
|
||
|
|
DEBUG_SetBreakpoints(TRUE);
|
||
|
|
} else {
|
||
|
|
DEBUG_CurrThread->wait_for_first_exception = 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void DEBUG_DelThread(WINE_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;
|
||
|
|
DBG_free(t);
|
||
|
|
}
|
||
|
|
|
||
|
|
static BOOL DEBUG_HandleException( EXCEPTION_RECORD *rec, BOOL first_chance, BOOL force )
|
||
|
|
{
|
||
|
|
BOOL is_debug = FALSE;
|
||
|
|
BOOL ret;
|
||
|
|
|
||
|
|
if (first_chance && !Options.debug && !force ) return 0; /* pass to app first */
|
||
|
|
|
||
|
|
switch (rec->ExceptionCode)
|
||
|
|
{
|
||
|
|
case EXCEPTION_BREAKPOINT:
|
||
|
|
case EXCEPTION_SINGLE_STEP:
|
||
|
|
is_debug = TRUE;
|
||
|
|
break;
|
||
|
|
case CONTROL_C_EXIT:
|
||
|
|
if (!Options.debug) DEBUG_Exit(0);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!is_debug)
|
||
|
|
{
|
||
|
|
/* print some infos */
|
||
|
|
fprintf( stderr, "%s: ",
|
||
|
|
first_chance ? "First chance exception" : "Unhandled exception" );
|
||
|
|
switch(rec->ExceptionCode)
|
||
|
|
{
|
||
|
|
case EXCEPTION_INT_DIVIDE_BY_ZERO:
|
||
|
|
fprintf( stderr, "divide by zero" );
|
||
|
|
break;
|
||
|
|
case EXCEPTION_INT_OVERFLOW:
|
||
|
|
fprintf( stderr, "overflow" );
|
||
|
|
break;
|
||
|
|
case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
|
||
|
|
fprintf( stderr, "array bounds " );
|
||
|
|
break;
|
||
|
|
case EXCEPTION_ILLEGAL_INSTRUCTION:
|
||
|
|
fprintf( stderr, "illegal instruction" );
|
||
|
|
break;
|
||
|
|
case EXCEPTION_STACK_OVERFLOW:
|
||
|
|
fprintf( stderr, "stack overflow" );
|
||
|
|
break;
|
||
|
|
case EXCEPTION_PRIV_INSTRUCTION:
|
||
|
|
fprintf( stderr, "priviledged instruction" );
|
||
|
|
break;
|
||
|
|
case EXCEPTION_ACCESS_VIOLATION:
|
||
|
|
if (rec->NumberParameters == 2)
|
||
|
|
fprintf( stderr, "page fault on %s access to 0x%08lx",
|
||
|
|
rec->ExceptionInformation[0] ? "write" : "read",
|
||
|
|
rec->ExceptionInformation[1] );
|
||
|
|
else
|
||
|
|
fprintf( stderr, "page fault" );
|
||
|
|
break;
|
||
|
|
case EXCEPTION_DATATYPE_MISALIGNMENT:
|
||
|
|
fprintf( stderr, "Alignment" );
|
||
|
|
break;
|
||
|
|
case CONTROL_C_EXIT:
|
||
|
|
fprintf( stderr, "^C" );
|
||
|
|
break;
|
||
|
|
case EXCEPTION_CRITICAL_SECTION_WAIT:
|
||
|
|
fprintf( stderr, "critical section %08lx wait failed",
|
||
|
|
rec->ExceptionInformation[0] );
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
fprintf( stderr, "%08lx", rec->ExceptionCode );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#if 1
|
||
|
|
fprintf(stderr, "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);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
ret = DEBUG_Main( is_debug, force );
|
||
|
|
#if 1
|
||
|
|
fprintf(stderr, "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);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
static DWORD CALLBACK DEBUG_MainLoop(LPVOID pid)
|
||
|
|
{
|
||
|
|
DEBUG_EVENT de;
|
||
|
|
char buffer[256];
|
||
|
|
DWORD cont;
|
||
|
|
|
||
|
|
TRACE("WineDbg started on pid %ld\n", (DWORD)pid);
|
||
|
|
|
||
|
|
if (!DebugActiveProcess((DWORD)pid))
|
||
|
|
TRACE("Can't debug process %ld: %ld\n", (DWORD)pid, GetLastError());
|
||
|
|
|
||
|
|
while (WaitForDebugEvent(&de, INFINITE)) {
|
||
|
|
cont = 0L;
|
||
|
|
|
||
|
|
if ((DEBUG_CurrProcess = DEBUG_GetProcess(de.dwProcessId)) != NULL)
|
||
|
|
DEBUG_CurrThread = DEBUG_GetThread(DEBUG_CurrProcess, de.dwThreadId);
|
||
|
|
else
|
||
|
|
DEBUG_CurrThread = NULL;
|
||
|
|
|
||
|
|
switch (de.dwDebugEventCode) {
|
||
|
|
case EXCEPTION_DEBUG_EVENT:
|
||
|
|
if (!DEBUG_CurrThread) break;
|
||
|
|
|
||
|
|
TRACE("%08lx:%08lx: exception code=%08lx %d\n",
|
||
|
|
de.dwProcessId, de.dwThreadId,
|
||
|
|
de.u.Exception.ExceptionRecord.ExceptionCode,
|
||
|
|
DEBUG_CurrThread->wait_for_first_exception);
|
||
|
|
|
||
|
|
DEBUG_context.ContextFlags = CONTEXT_CONTROL|CONTEXT_INTEGER|CONTEXT_SEGMENTS|CONTEXT_DEBUG_REGISTERS;
|
||
|
|
if (!GetThreadContext(DEBUG_CurrThread->handle, &DEBUG_context)) {
|
||
|
|
WARN("Can't get thread's context\n");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
TRACE("%p:%p\n", de.u.Exception.ExceptionRecord.ExceptionAddress,
|
||
|
|
(void*)DEBUG_context.Eip);
|
||
|
|
|
||
|
|
cont = DEBUG_HandleException(&de.u.Exception.ExceptionRecord,
|
||
|
|
de.u.Exception.dwFirstChance,
|
||
|
|
DEBUG_CurrThread->wait_for_first_exception);
|
||
|
|
|
||
|
|
if (DEBUG_CurrThread->wait_for_first_exception) {
|
||
|
|
DEBUG_CurrThread->wait_for_first_exception = 0;
|
||
|
|
#ifdef __i386__
|
||
|
|
DEBUG_context.Eip--;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
SetThreadContext(DEBUG_CurrThread->handle, &DEBUG_context);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case CREATE_THREAD_DEBUG_EVENT:
|
||
|
|
TRACE("%08lx:%08lx: create thread D @%p\n", de.dwProcessId, de.dwThreadId,
|
||
|
|
de.u.CreateThread.lpStartAddress);
|
||
|
|
|
||
|
|
if (DEBUG_CurrProcess == NULL) {
|
||
|
|
ERR("Unknown process\n");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (DEBUG_GetThread(DEBUG_CurrProcess, de.dwThreadId) != NULL) {
|
||
|
|
TRACE("Thread already listed, skipping\n");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
DEBUG_CurrThread = DEBUG_AddThread(DEBUG_CurrProcess,
|
||
|
|
de.dwThreadId,
|
||
|
|
de.u.CreateThread.hThread,
|
||
|
|
de.u.CreateThread.lpStartAddress,
|
||
|
|
de.u.CreateThread.lpThreadLocalBase);
|
||
|
|
if (!DEBUG_CurrThread) {
|
||
|
|
ERR("Couldn't create thread\n");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
DEBUG_InitCurrThread();
|
||
|
|
break;
|
||
|
|
|
||
|
|
case CREATE_PROCESS_DEBUG_EVENT:
|
||
|
|
DEBUG_ProcessGetString(buffer, sizeof(buffer),
|
||
|
|
de.u.CreateProcessInfo.hProcess,
|
||
|
|
de.u.LoadDll.lpImageName);
|
||
|
|
|
||
|
|
/* FIXME unicode ? de.u.CreateProcessInfo.fUnicode */
|
||
|
|
TRACE("%08lx:%08lx: create process %s @%p\n",
|
||
|
|
de.dwProcessId, de.dwThreadId,
|
||
|
|
buffer,
|
||
|
|
de.u.CreateProcessInfo.lpStartAddress);
|
||
|
|
|
||
|
|
if (DEBUG_GetProcess(de.dwProcessId) != NULL) {
|
||
|
|
TRACE("Skipping already defined process\n");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
DEBUG_CurrProcess = DEBUG_AddProcess(de.dwProcessId,
|
||
|
|
de.u.CreateProcessInfo.hProcess);
|
||
|
|
if (DEBUG_CurrProcess == NULL) {
|
||
|
|
ERR("Unknown process\n");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
TRACE("%08lx:%08lx: create thread I @%p\n", de.dwProcessId, de.dwThreadId,
|
||
|
|
de.u.CreateProcessInfo.lpStartAddress);
|
||
|
|
|
||
|
|
DEBUG_CurrThread = DEBUG_AddThread(DEBUG_CurrProcess,
|
||
|
|
de.dwThreadId,
|
||
|
|
de.u.CreateProcessInfo.hThread,
|
||
|
|
de.u.CreateProcessInfo.lpStartAddress,
|
||
|
|
de.u.CreateProcessInfo.lpThreadLocalBase);
|
||
|
|
if (!DEBUG_CurrThread) {
|
||
|
|
ERR("Couldn't create thread\n");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
DEBUG_InitCurrProcess();
|
||
|
|
DEBUG_InitCurrThread();
|
||
|
|
break;
|
||
|
|
|
||
|
|
case EXIT_THREAD_DEBUG_EVENT:
|
||
|
|
TRACE("%08lx:%08lx: exit thread (%ld)\n",
|
||
|
|
de.dwProcessId, de.dwThreadId, de.u.ExitThread.dwExitCode);
|
||
|
|
|
||
|
|
if (DEBUG_CurrThread == NULL) {
|
||
|
|
ERR("Unknown thread\n");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
/* FIXME: remove break point set on thread startup */
|
||
|
|
DEBUG_DelThread(DEBUG_CurrThread);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case EXIT_PROCESS_DEBUG_EVENT:
|
||
|
|
TRACE("%08lx:%08lx: exit process (%ld)\n",
|
||
|
|
de.dwProcessId, de.dwThreadId, de.u.ExitProcess.dwExitCode);
|
||
|
|
|
||
|
|
if (DEBUG_CurrProcess == NULL) {
|
||
|
|
ERR("Unknown process\n");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
/* kill last thread */
|
||
|
|
DEBUG_DelThread(DEBUG_CurrProcess->threads);
|
||
|
|
/* FIXME: remove break point set on thread startup */
|
||
|
|
DEBUG_DelProcess(DEBUG_CurrProcess);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case LOAD_DLL_DEBUG_EVENT:
|
||
|
|
if (DEBUG_CurrThread == NULL) {
|
||
|
|
ERR("Unknown thread\n");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
DEBUG_ProcessGetString(buffer, sizeof(buffer),
|
||
|
|
DEBUG_CurrThread->process->handle,
|
||
|
|
de.u.LoadDll.lpImageName);
|
||
|
|
|
||
|
|
/* FIXME unicode: de.u.LoadDll.fUnicode */
|
||
|
|
TRACE("%08lx:%08lx: loads DLL %s @%p\n", de.dwProcessId, de.dwThreadId,
|
||
|
|
buffer, de.u.LoadDll.lpBaseOfDll);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case UNLOAD_DLL_DEBUG_EVENT:
|
||
|
|
TRACE("%08lx:%08lx: unload DLL @%p\n", de.dwProcessId, de.dwThreadId,
|
||
|
|
de.u.UnloadDll.lpBaseOfDll);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case OUTPUT_DEBUG_STRING_EVENT:
|
||
|
|
if (DEBUG_CurrThread == NULL) {
|
||
|
|
ERR("Unknown thread\n");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
DEBUG_ProcessGetString(buffer, sizeof(buffer),
|
||
|
|
DEBUG_CurrThread->process->handle,
|
||
|
|
de.u.DebugString.lpDebugStringData);
|
||
|
|
|
||
|
|
|
||
|
|
/* fixme unicode de.u.DebugString.fUnicode ? */
|
||
|
|
TRACE("%08lx:%08lx: output debug string (%s)\n",
|
||
|
|
de.dwProcessId, de.dwThreadId,
|
||
|
|
buffer);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case RIP_EVENT:
|
||
|
|
TRACE("%08lx:%08lx: rip error=%ld type=%ld\n",
|
||
|
|
de.dwProcessId, de.dwThreadId, de.u.RipInfo.dwError,
|
||
|
|
de.u.RipInfo.dwType);
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
TRACE("%08lx:%08lx: unknown event (%ld)\n",
|
||
|
|
de.dwProcessId, de.dwThreadId, de.dwDebugEventCode);
|
||
|
|
}
|
||
|
|
ContinueDebugEvent(de.dwProcessId, de.dwThreadId, cont);
|
||
|
|
}
|
||
|
|
|
||
|
|
TRACE("WineDbg terminated on pid %ld\n", (DWORD)pid);
|
||
|
|
|
||
|
|
return 0L;
|
||
|
|
}
|
||
|
|
|
||
|
|
#include "thread.h"
|
||
|
|
#include "process.h"
|
||
|
|
|
||
|
|
void DEBUG_StartDebugger(DWORD pid)
|
||
|
|
{
|
||
|
|
if (Options.debug)
|
||
|
|
CreateThread(NULL, 0, DEBUG_MainLoop, (LPVOID)pid, 0, NULL);
|
||
|
|
}
|
||
|
|
|