debugger/winedbg.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /* Wine internal debugger
   4  * Interface to Windows debugger API
   5  * Eric Pouech (c) 2000
   6  */
   7
   8 #include <stdlib.h>
   9 #include <stdio.h>
  10 #include <string.h>
  11 #include "debugger.h"
  12
  13 #include "thread.h"
  14 #include "process.h"
  15 #include "wincon.h"
  16 #include "wingdi.h"
  17 #include "winuser.h"
  18
  19 #include "winreg.h"
  20
  21 #ifdef DBG_need_heap
  22 HANDLE dbg_heap = 0;
  23 #endif
  24
  25 DBG_PROCESS*    DEBUG_CurrProcess = NULL;
  26 DBG_THREAD*     DEBUG_CurrThread = NULL;
  27 CONTEXT         DEBUG_context;
  28
  29 static DBG_PROCESS* proc = NULL;
  30 DBG_INTVAR DEBUG_IntVars[DBG_IV_LAST];
  31
  32 void    DEBUG_Output(int chn, const char* buffer, int len)
  33 {
  34     if (DBG_IVAR(ConChannelMask) & chn)
  35         WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buffer, len, NULL, NULL);
  36     if (DBG_IVAR(StdChannelMask) & chn)
  37         fwrite(buffer, len, 1, stderr);
  38 }
  39
  40 int     DEBUG_Printf(int chn, const char* format, ...)
  41 {
  42     char        buf[1024];
  43     va_list     valist;
  44     int         len;
  45
  46     va_start(valist, format);
  47     len = vsprintf(buf, format, valist);
  48     va_end(valist);
  49     DEBUG_Output(chn, buf, len);
  50     return len;
  51 }
  52
  53 static  BOOL DEBUG_IntVarsRW(int read)
  54 {
  55     HKEY        hkey;
  56     DWORD       type = REG_DWORD;
  57     DWORD       val;
  58     DWORD       count = sizeof(val);
  59     int         i;
  60     DBG_INTVAR* div = DEBUG_IntVars;
  61
  62     if (read) {
  63 /* initializes internal vars table */
  64 #define  INTERNAL_VAR(_var,_val,_ref,_typ)                      \
  65         div->val = _val; div->name = #_var; div->pval = _ref;   \
  66         div->type = _typ; div++;
  67 #include "intvar.h"
  68 #undef   INTERNAL_VAR
  69     }
  70
  71     if (RegOpenKey(HKEY_CURRENT_USER, "Software\\Wine\\WineDbg", &hkey) &&
  72         RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\WineDbg", &hkey)) {
  73         /* since the IVars are not yet setup, DEBUG_Printf doesn't work,
  74          * so don't use it */
  75         fprintf(stderr, "Cannot create WineDbg key in registry\n");
  76         return FALSE;
  77     }
  78
  79     for (i = 0; i < DBG_IV_LAST; i++) {
  80         if (read) {
  81             if (!DEBUG_IntVars[i].pval) {
  82                 if (!RegQueryValueEx(hkey, DEBUG_IntVars[i].name, 0,
  83                                      &type, (LPSTR)&val, &count))
  84                     DEBUG_IntVars[i].val = val;
  85                 DEBUG_IntVars[i].pval = &DEBUG_IntVars[i].val;
  86             } else {
  87                 *DEBUG_IntVars[i].pval = 0;
  88             }
  89         } else {
  90             /* FIXME: type should be infered from basic type -if any- of intvar */
  91             if (DEBUG_IntVars[i].pval == &DEBUG_IntVars[i].val)
  92                 RegSetValueEx(hkey, DEBUG_IntVars[i].name, 0,
  93                               type, (LPCVOID)DEBUG_IntVars[i].pval, count);
  94         }
  95     }
  96     RegCloseKey(hkey);
  97     return TRUE;
  98 }
  99
 100 DBG_INTVAR*     DEBUG_GetIntVar(const char* name)
 101 {
 102     int         i;
 103
 104     for (i = 0; i < DBG_IV_LAST; i++) {
 105         if (!strcmp(DEBUG_IntVars[i].name, name))
 106             return &DEBUG_IntVars[i];
 107     }
 108     return NULL;
 109 }
 110
 111 static WINE_EXCEPTION_FILTER(wine_dbg)
 112 {
 113     DEBUG_ExternalDebugger();
 114     DEBUG_Printf(DBG_CHN_MESG, "\nwine_dbg: Exception %lx\n", GetExceptionCode());
 115     return EXCEPTION_EXECUTE_HANDLER;
 116 }
 117
 118 static  DBG_PROCESS*    DEBUG_GetProcess(DWORD pid)
 119 {
 120     DBG_PROCESS*        p;
 121
 122     for (p = proc; p; p = p->next)
 123         if (p->pid == pid) break;
 124     return p;
 125 }
 126
 127 static  DBG_PROCESS*    DEBUG_AddProcess(DWORD pid, HANDLE h)
 128 {
 129     DBG_PROCESS*        p = DBG_alloc(sizeof(DBG_PROCESS));
 130     if (!p)
 131         return NULL;
 132     p->handle = h;
 133     p->pid = pid;
 134     p->threads = NULL;
 135     p->num_threads = 0;
 136     p->modules = NULL;
 137     p->next_index = 0;
 138
 139     p->next = proc;
 140     p->prev = NULL;
 141     if (proc) proc->prev = p;
 142     proc = p;
 143     return p;
 144 }
 145
 146 static  void                    DEBUG_DelThread(DBG_THREAD* p);
 147
 148 static  void                    DEBUG_DelProcess(DBG_PROCESS* p)
 149 {
 150     if (p->threads != NULL) {
 151         DEBUG_Printf(DBG_CHN_ERR, "Shouldn't happen\n");
 152         while (p->threads) DEBUG_DelThread(p->threads);
 153     }
 154     if (p->prev) p->prev->next = p->next;
 155     if (p->next) p->next->prev = p->prev;
 156     if (p == proc) proc = p->next;
 157     DBG_free(p);
 158 }
 159
 160 static  void                    DEBUG_InitCurrProcess(void)
 161 {
 162 }
 163
 164 static BOOL DEBUG_ProcessGetString(char* buffer, int size, HANDLE hp, LPSTR addr)
 165 {
 166     DWORD sz;
 167     *(WCHAR*)buffer = 0;
 168     return (addr && ReadProcessMemory(hp, addr, buffer, size, &sz));
 169 }
 170
 171 static BOOL DEBUG_ProcessGetStringIndirect(char* buffer, int size, HANDLE hp, LPVOID addr)
 172 {
 173     LPVOID      ad;
 174     DWORD       sz;
 175
 176     if (   addr
 177         && ReadProcessMemory(hp, addr, &ad, sizeof(ad), &sz)
 178         && sz == sizeof(ad)
 179         && ad
 180         && ReadProcessMemory(hp, ad, buffer, size, &sz))
 181         return TRUE;
 182     *(WCHAR*)buffer = 0;
 183     return FALSE;
 184 }
 185
 186 static  DBG_THREAD*     DEBUG_GetThread(DBG_PROCESS* p, DWORD tid)
 187 {
 188     DBG_THREAD* t;
 189
 190     for (t = p->threads; t; t = t->next)
 191         if (t->tid == tid) break;
 192     return t;
 193 }
 194
 195 static  DBG_THREAD*     DEBUG_AddThread(DBG_PROCESS* p, DWORD tid,
 196                                         HANDLE h, LPVOID start, LPVOID teb)
 197 {
 198     DBG_THREAD* t = DBG_alloc(sizeof(DBG_THREAD));
 199     if (!t)
 200         return NULL;
 201
 202     t->handle = h;
 203     t->tid = tid;
 204     t->start = start;
 205     t->teb = teb;
 206     t->process = p;
 207     t->wait_for_first_exception = 0;
 208     t->dbg_exec_mode = EXEC_CONT;
 209     t->dbg_exec_count = 0;
 210
 211     p->num_threads++;
 212     t->next = p->threads;
 213     t->prev = NULL;
 214     if (p->threads) p->threads->prev = t;
 215     p->threads = t;
 216
 217     return t;
 218 }
 219
 220 static  void                    DEBUG_InitCurrThread(void)
 221 {
 222     if (DEBUG_CurrThread->start) {
 223         if (DEBUG_CurrThread->process->num_threads == 1 ||
 224             DBG_IVAR(BreakAllThreadsStartup)) {
 225             DBG_VALUE   value;
 226
 227             DEBUG_SetBreakpoints(FALSE);
 228             value.type = NULL;
 229             value.cookie = DV_TARGET;
 230             value.addr.seg = 0;
 231             value.addr.off = (DWORD)DEBUG_CurrThread->start;
 232             DEBUG_AddBreakpoint(&value);
 233             DEBUG_SetBreakpoints(TRUE);
 234         }
 235     } else {
 236         DEBUG_CurrThread->wait_for_first_exception = 1;
 237     }
 238 }
 239
 240 static  void                    DEBUG_DelThread(DBG_THREAD* t)
 241 {
 242     if (t->prev) t->prev->next = t->next;
 243     if (t->next) t->next->prev = t->prev;
 244     if (t == t->process->threads) t->process->threads = t->next;
 245     t->process->num_threads--;
 246     DBG_free(t);
 247 }
 248
 249 static  BOOL    DEBUG_HandleException( EXCEPTION_RECORD *rec, BOOL first_chance, BOOL force )
 250 {
 251     BOOL        is_debug = FALSE;
 252     BOOL        ret;
 253
 254     /* FIXME: need for a configuration var ? */
 255     /* pass to app first ??? */
 256     /* if (first_chance && !force) return 0; */
 257
 258     switch (rec->ExceptionCode)
 259     {
 260     case EXCEPTION_BREAKPOINT:
 261     case EXCEPTION_SINGLE_STEP:
 262         is_debug = TRUE;
 263         break;
 264     }
 265
 266     if (!is_debug)
 267     {
 268         /* print some infos */
 269         DEBUG_Printf( DBG_CHN_MESG, "%s: ",
 270                       first_chance ? "First chance exception" : "Unhandled exception" );
 271         switch(rec->ExceptionCode)
 272         {
 273         case EXCEPTION_INT_DIVIDE_BY_ZERO:
 274             DEBUG_Printf( DBG_CHN_MESG, "divide by zero" );
 275             break;
 276         case EXCEPTION_INT_OVERFLOW:
 277             DEBUG_Printf( DBG_CHN_MESG, "overflow" );
 278             break;
 279         case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
 280             DEBUG_Printf( DBG_CHN_MESG, "array bounds " );
 281             break;
 282         case EXCEPTION_ILLEGAL_INSTRUCTION:
 283             DEBUG_Printf( DBG_CHN_MESG, "illegal instruction" );
 284             break;
 285         case EXCEPTION_STACK_OVERFLOW:
 286             DEBUG_Printf( DBG_CHN_MESG, "stack overflow" );
 287             break;
 288         case EXCEPTION_PRIV_INSTRUCTION:
 289             DEBUG_Printf( DBG_CHN_MESG, "priviledged instruction" );
 290             break;
 291         case EXCEPTION_ACCESS_VIOLATION:
 292             if (rec->NumberParameters == 2)
 293                 DEBUG_Printf( DBG_CHN_MESG, "page fault on %s access to 0x%08lx",
 294                               rec->ExceptionInformation[0] ? "write" : "read",
 295                               rec->ExceptionInformation[1] );
 296             else
 297                 DEBUG_Printf( DBG_CHN_MESG, "page fault" );
 298             break;
 299         case EXCEPTION_DATATYPE_MISALIGNMENT:
 300             DEBUG_Printf( DBG_CHN_MESG, "Alignment" );
 301             break;
 302         case CONTROL_C_EXIT:
 303             DEBUG_Printf( DBG_CHN_MESG, "^C" );
 304             break;
 305         case EXCEPTION_CRITICAL_SECTION_WAIT:
 306             DEBUG_Printf( DBG_CHN_MESG, "critical section %08lx wait failed",
 307                           rec->ExceptionInformation[0] );
 308             if (!DBG_IVAR(BreakOnCritSectTimeOut))
 309                 return DBG_CONTINUE;
 310             break;
 311         default:
 312             DEBUG_Printf( DBG_CHN_MESG, "%08lx", rec->ExceptionCode );
 313             break;
 314         }
 315     }
 316
 317     DEBUG_Printf(DBG_CHN_MESG, "\n");
 318
 319     DEBUG_Printf(DBG_CHN_TRACE,
 320                  "Entering debugger     PC=%lx EFL=%08lx mode=%d count=%d\n",
 321                  DEBUG_context.Eip, DEBUG_context.EFlags,
 322                  DEBUG_CurrThread->dbg_exec_mode, DEBUG_CurrThread->dbg_exec_count);
 323
 324     ret = DEBUG_Main( is_debug, force, rec->ExceptionCode );
 325
 326     DEBUG_Printf(DBG_CHN_TRACE,
 327                  "Exiting debugger      PC=%lx EFL=%08lx mode=%d count=%d\n",
 328                  DEBUG_context.Eip, DEBUG_context.EFlags,
 329                  DEBUG_CurrThread->dbg_exec_mode, DEBUG_CurrThread->dbg_exec_count);
 330
 331     return ret;
 332 }
 333
 334 static  BOOL    DEBUG_HandleDebugEvent(DEBUG_EVENT* de, LPDWORD cont)
 335 {
 336     char                buffer[256];
 337     BOOL                ret;
 338
 339     __TRY {
 340         ret = TRUE;
 341         *cont = 0L;
 342
 343         if ((DEBUG_CurrProcess = DEBUG_GetProcess(de->dwProcessId)) != NULL)
 344             DEBUG_CurrThread = DEBUG_GetThread(DEBUG_CurrProcess, de->dwThreadId);
 345         else
 346             DEBUG_CurrThread = NULL;
 347
 348         switch (de->dwDebugEventCode) {
 349         case EXCEPTION_DEBUG_EVENT:
 350             if (!DEBUG_CurrThread) {
 351                 DEBUG_Printf(DBG_CHN_ERR, "%08lx:%08lx: not a registered process or thread (perhaps a 16 bit one ?)\n",
 352                              de->dwProcessId, de->dwThreadId);
 353                 break;
 354             }
 355
 356             DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: exception code=%08lx %d\n",
 357                          de->dwProcessId, de->dwThreadId,
 358                          de->u.Exception.ExceptionRecord.ExceptionCode,
 359                          DEBUG_CurrThread->wait_for_first_exception);
 360
 361             DEBUG_context.ContextFlags = CONTEXT_CONTROL|CONTEXT_INTEGER|CONTEXT_SEGMENTS|CONTEXT_DEBUG_REGISTERS;
 362             if (!GetThreadContext(DEBUG_CurrThread->handle, &DEBUG_context)) {
 363                 DEBUG_Printf(DBG_CHN_WARN, "Can't get thread's context\n");
 364                 break;
 365             }
 366
 367             DEBUG_Printf(DBG_CHN_TRACE, "%p:%p\n", de->u.Exception.ExceptionRecord.ExceptionAddress,
 368                          (void*)DEBUG_context.Eip);
 369
 370             *cont = DEBUG_HandleException(&de->u.Exception.ExceptionRecord,
 371                                           de->u.Exception.dwFirstChance,
 372                                           DEBUG_CurrThread->wait_for_first_exception);
 373             if (DEBUG_CurrThread->dbg_exec_mode == EXEC_KILL) {
 374                 ret = FALSE;
 375             } else {
 376                 DEBUG_CurrThread->wait_for_first_exception = 0;
 377                 SetThreadContext(DEBUG_CurrThread->handle, &DEBUG_context);
 378             }
 379             break;
 380
 381         case CREATE_THREAD_DEBUG_EVENT:
 382             DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: create thread D @%p\n", de->dwProcessId, de->dwThreadId,
 383                          de->u.CreateThread.lpStartAddress);
 384
 385             if (DEBUG_CurrProcess == NULL) {
 386                 DEBUG_Printf(DBG_CHN_ERR, "Unknown process\n");
 387                 break;
 388             }
 389             if (DEBUG_GetThread(DEBUG_CurrProcess, de->dwThreadId) != NULL) {
 390                 DEBUG_Printf(DBG_CHN_TRACE, "Thread already listed, skipping\n");
 391                 break;
 392             }
 393
 394             DEBUG_CurrThread = DEBUG_AddThread(DEBUG_CurrProcess,
 395                                                de->dwThreadId,
 396                                                de->u.CreateThread.hThread,
 397                                                de->u.CreateThread.lpStartAddress,
 398                                                de->u.CreateThread.lpThreadLocalBase);
 399             if (!DEBUG_CurrThread) {
 400                 DEBUG_Printf(DBG_CHN_ERR, "Couldn't create thread\n");
 401                 break;
 402             }
 403             DEBUG_InitCurrThread();
 404             break;
 405
 406         case CREATE_PROCESS_DEBUG_EVENT:
 407             DEBUG_ProcessGetStringIndirect(buffer, sizeof(buffer),
 408                                            de->u.CreateProcessInfo.hProcess,
 409                                            de->u.CreateProcessInfo.lpImageName);
 410
 411             /* FIXME unicode ? de->u.CreateProcessInfo.fUnicode */
 412             DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: create process %s @%p (%ld<%ld>)\n",
 413                          de->dwProcessId, de->dwThreadId,
 414                          buffer,
 415                          de->u.CreateProcessInfo.lpStartAddress,
 416                          de->u.CreateProcessInfo.dwDebugInfoFileOffset,
 417                          de->u.CreateProcessInfo.nDebugInfoSize);
 418
 419             if (DEBUG_GetProcess(de->dwProcessId) != NULL) {
 420                 DEBUG_Printf(DBG_CHN_TRACE, "Skipping already defined process\n");
 421                 break;
 422             }
 423             DEBUG_CurrProcess = DEBUG_AddProcess(de->dwProcessId,
 424                                                  de->u.CreateProcessInfo.hProcess);
 425             if (DEBUG_CurrProcess == NULL) {
 426                 DEBUG_Printf(DBG_CHN_ERR, "Unknown process\n");
 427                 break;
 428             }
 429
 430             DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: create thread I @%p\n",
 431                          de->dwProcessId, de->dwThreadId,
 432                          de->u.CreateProcessInfo.lpStartAddress);
 433
 434             DEBUG_CurrThread = DEBUG_AddThread(DEBUG_CurrProcess,
 435                                                de->dwThreadId,
 436                                                de->u.CreateProcessInfo.hThread,
 437                                                de->u.CreateProcessInfo.lpStartAddress,
 438                                                de->u.CreateProcessInfo.lpThreadLocalBase);
 439             if (!DEBUG_CurrThread) {
 440                 DEBUG_Printf(DBG_CHN_ERR, "Couldn't create thread\n");
 441                 break;
 442             }
 443
 444             DEBUG_InitCurrProcess();
 445             DEBUG_InitCurrThread();
 446             /* so far, process name is not set */
 447             DEBUG_LoadModule32("<Debugged process>", de->u.CreateProcessInfo.hFile,
 448                                (DWORD)de->u.CreateProcessInfo.lpBaseOfImage);
 449             break;
 450
 451         case EXIT_THREAD_DEBUG_EVENT:
 452             DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: exit thread (%ld)\n",
 453                          de->dwProcessId, de->dwThreadId, de->u.ExitThread.dwExitCode);
 454
 455             if (DEBUG_CurrThread == NULL) {
 456                 DEBUG_Printf(DBG_CHN_ERR, "Unknown thread\n");
 457                 break;
 458             }
 459             /* FIXME: remove break point set on thread startup */
 460             DEBUG_DelThread(DEBUG_CurrThread);
 461             break;
 462
 463         case EXIT_PROCESS_DEBUG_EVENT:
 464             DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: exit process (%ld)\n",
 465                          de->dwProcessId, de->dwThreadId, de->u.ExitProcess.dwExitCode);
 466
 467             if (DEBUG_CurrProcess == NULL) {
 468                 DEBUG_Printf(DBG_CHN_ERR, "Unknown process\n");
 469                 break;
 470             }
 471             /* just in case */
 472             DEBUG_SetBreakpoints(FALSE);
 473             /* kill last thread */
 474             DEBUG_DelThread(DEBUG_CurrProcess->threads);
 475             DEBUG_DelProcess(DEBUG_CurrProcess);
 476             ret = FALSE;
 477             break;
 478
 479         case LOAD_DLL_DEBUG_EVENT:
 480             if (DEBUG_CurrThread == NULL) {
 481                 DEBUG_Printf(DBG_CHN_ERR, "Unknown thread\n");
 482                 break;
 483             }
 484             DEBUG_ProcessGetStringIndirect(buffer, sizeof(buffer),
 485                                            DEBUG_CurrThread->process->handle,
 486                                            de->u.LoadDll.lpImageName);
 487
 488             /* FIXME unicode: de->u.LoadDll.fUnicode */
 489             DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: loads DLL %s @%p (%ld<%ld>)\n",
 490                          de->dwProcessId, de->dwThreadId,
 491                          buffer, de->u.LoadDll.lpBaseOfDll,
 492                          de->u.LoadDll.dwDebugInfoFileOffset,
 493                          de->u.LoadDll.nDebugInfoSize);
 494             CharUpper(buffer);
 495             DEBUG_LoadModule32(buffer, de->u.LoadDll.hFile, (DWORD)de->u.LoadDll.lpBaseOfDll);
 496             break;
 497
 498         case UNLOAD_DLL_DEBUG_EVENT:
 499             DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: unload DLL @%p\n", de->dwProcessId, de->dwThreadId,
 500                          de->u.UnloadDll.lpBaseOfDll);
 501             break;
 502
 503         case OUTPUT_DEBUG_STRING_EVENT:
 504             if (DEBUG_CurrThread == NULL) {
 505                 DEBUG_Printf(DBG_CHN_ERR, "Unknown thread\n");
 506                 break;
 507             }
 508
 509             DEBUG_ProcessGetString(buffer, sizeof(buffer),
 510                                    DEBUG_CurrThread->process->handle,
 511                                    de->u.DebugString.lpDebugStringData);
 512
 513             /* fixme unicode de->u.DebugString.fUnicode ? */
 514             DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: output debug string (%s)\n",
 515                          de->dwProcessId, de->dwThreadId, buffer);
 516             break;
 517
 518         case RIP_EVENT:
 519             DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: rip error=%ld type=%ld\n",
 520                          de->dwProcessId, de->dwThreadId, de->u.RipInfo.dwError,
 521                          de->u.RipInfo.dwType);
 522             break;
 523
 524         default:
 525             DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: unknown event (%ld)\n",
 526                          de->dwProcessId, de->dwThreadId, de->dwDebugEventCode);
 527         }
 528
 529     } __EXCEPT(wine_dbg) {
 530         *cont = 0;
 531         ret = TRUE;
 532     }
 533     __ENDTRY;
 534
 535     return ret;
 536 }
 537
 538 static  DWORD   DEBUG_MainLoop(DWORD pid)
 539 {
 540     DEBUG_EVENT         de;
 541     DWORD               cont;
 542     BOOL                ret = TRUE;
 543
 544     DEBUG_Printf(DBG_CHN_MESG, " on pid %ld\n", pid);
 545
 546     while (ret && WaitForDebugEvent(&de, INFINITE)) {
 547         ret = DEBUG_HandleDebugEvent(&de, &cont);
 548         ContinueDebugEvent(de.dwProcessId, de.dwThreadId, cont);
 549     }
 550
 551     DEBUG_Printf(DBG_CHN_MESG, "WineDbg terminated on pid %ld\n", pid);
 552
 553     return 0;
 554 }
 555
 556 int DEBUG_main(int argc, char** argv)
 557 {
 558     DWORD       pid = 0, retv = 0;
 559
 560 #ifdef DBG_need_heap
 561     /* Initialize the debugger heap. */
 562     dbg_heap = HeapCreate(HEAP_NO_SERIALIZE, 0x1000, 0x8000000); /* 128MB */
 563 #endif
 564
 565     /* Initialize the type handling stuff. */
 566     DEBUG_InitTypes();
 567     DEBUG_InitCVDataTypes();
 568
 569     /* Initialize internal vars */
 570     if (!DEBUG_IntVarsRW(TRUE)) return -1;
 571
 572     /* keep it as a guiexe for now, so that Wine won't touch the Unix stdin,
 573      * stdout and stderr streams
 574      */
 575     if (DBG_IVAR(UseXTerm)) {
 576         COORD           pos;
 577
 578         /* This is a hack: it forces creation of an xterm, not done by default */
 579         pos.X = 0; pos.Y = 1;
 580         SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
 581     }
 582
 583     DEBUG_Printf(DBG_CHN_MESG, "Starting WineDbg... ");
 584     if (argc == 3) {
 585         HANDLE  hEvent;
 586
 587         if ((pid = atoi(argv[1])) != 0 && (hEvent = atoi(argv[2])) != 0) {
 588             if (!DebugActiveProcess(pid)) {
 589                 DEBUG_Printf(DBG_CHN_ERR, "Can't attach process %ld: %ld\n",
 590                              pid, GetLastError());
 591                 SetEvent(hEvent);
 592                 goto leave;
 593             }
 594             SetEvent(hEvent);
 595         } else {
 596             pid = 0;
 597         }
 598     }
 599
 600     if (pid == 0) {
 601         PROCESS_INFORMATION     info;
 602         STARTUPINFOA            startup;
 603
 604         memset(&startup, 0, sizeof(startup));
 605         startup.cb = sizeof(startup);
 606         startup.dwFlags = STARTF_USESHOWWINDOW;
 607         startup.wShowWindow = SW_SHOWNORMAL;
 608
 609         if (!CreateProcess(NULL, argv[1], NULL, NULL,
 610                            FALSE, DEBUG_PROCESS, NULL, NULL, &startup, &info)) {
 611             DEBUG_Printf(DBG_CHN_MESG, "Couldn't start process '%s'\n", argv[1]);
 612             goto leave;
 613         }
 614         pid = info.dwProcessId;
 615     }
 616
 617     if (pid) retv = DEBUG_MainLoop(pid);
 618  leave:
 619     /* saves modified variables */
 620     DEBUG_IntVarsRW(FALSE);
 621
 622     return retv;
 623 }
 624
 625