git.oblomov.eu Git - wine/blob - programs/winedbg/winedbg.c

   1 /* Wine internal debugger
   2  * Interface to Windows debugger API
   3  * Copyright 2000-2004 Eric Pouech
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 #include "config.h"
  21 #include "wine/port.h"
  22
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include "debugger.h"
  27
  28 #include "winternl.h"
  29 #include "wine/exception.h"
  30 #include "wine/library.h"
  31
  32 #include "wine/debug.h"
  33
  34 /* TODO list:
  35  *
  36  * - minidump
  37  *      + allow winedbg in automatic mode to create a minidump (or add another option
  38  *        for that)
  39  *      + set a mode where winedbg would start (postmortem debugging) from a minidump
  40  * - CPU adherence
  41  *      + we always assume the stack grows has an i386 (ie downwards)
  42  * - UI
  43  *      + enable back the limited output (depth of structure printing and number of
  44  *        lines)
  45  *      + make the output as close as possible to what gdb does
  46  * - symbol management:
  47  *      + symbol table loading is broken
  48  *      + in symbol_get_lvalue, we don't do any scoping (as C does) between local and
  49  *        global vars (we may need this to force some display for example). A solution
  50  *        would be always to return arrays with: local vars, global vars, thunks
  51  * - type management:
  52  *      + some bits of internal types are missing (like type casts and the address
  53  *        operator)
  54  *      + the type for an enum's value is always inferred as int (winedbg & dbghelp)
  55  *      + most of the code implies that sizeof(void*) = sizeof(int)
  56  *      + all computations should be made on long long
  57  *              o expr computations are in int:s
  58  *              o bitfield size is on a 4-bytes
  59  * - execution:
  60  *      + set a better fix for gdb (proxy mode) than the step-mode hack
  61  *      + implement function call in debuggee
  62  *      + trampoline management is broken when getting 16 <=> 32 thunk destination
  63  *        address
  64  *      + thunking of delayed imports doesn't work as expected (ie, when stepping,
  65  *        it currently stops at first insn with line number during the library
  66  *        loading). We should identify this (__wine_delay_import) and set a
  67  *        breakpoint instead of single stepping the library loading.
  68  *      + it's wrong to copy thread->step_over_bp into process->bp[0] (when
  69  *        we have a multi-thread debuggee). complete fix must include storing all
  70  *        thread's step-over bp in process-wide bp array, and not to handle bp
  71  *        when we have the wrong thread running into that bp
  72  */
  73
  74 WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
  75
  76 struct dbg_process*     dbg_curr_process = NULL;
  77 struct dbg_thread*      dbg_curr_thread = NULL;
  78 DWORD                   dbg_curr_tid;
  79 DWORD                   dbg_curr_pid;
  80 CONTEXT                 dbg_context;
  81 int                     dbg_curr_frame = 0;
  82 BOOL                    dbg_interactiveP = FALSE;
  83 static unsigned         dbg_in_exception = FALSE;
  84 static char*            dbg_last_cmd_line = NULL;
  85
  86 static struct dbg_process*      dbg_process_list = NULL;
  87 static enum {none_mode = 0, winedbg_mode, automatic_mode, gdb_mode} dbg_action_mode;
  88
  89 struct dbg_internal_var         dbg_internal_vars[DBG_IV_LAST];
  90 const struct dbg_internal_var*  dbg_context_vars;
  91 static HANDLE                   dbg_houtput;
  92
  93 void    dbg_outputA(const char* buffer, int len)
  94 {
  95     DWORD w;
  96     WriteFile(dbg_houtput, buffer, len, &w, NULL);
  97 }
  98
  99 void    dbg_outputW(const WCHAR* buffer, int len)
 100 {
 101     char* ansi = NULL;
 102     int newlen;
 103
 104     /* do a serious Unicode to ANSI conversion
 105      * FIXME: should CP_ACP be GetConsoleCP()?
 106      */
 107     newlen = WideCharToMultiByte(CP_ACP, 0, buffer, len, NULL, 0, NULL, NULL);
 108     if (newlen)
 109     {
 110         if (!(ansi = HeapAlloc(GetProcessHeap(), 0, newlen))) return;
 111         WideCharToMultiByte(CP_ACP, 0, buffer, len, ansi, newlen, NULL, NULL);
 112         dbg_outputA(ansi, newlen);
 113         HeapFree(GetProcessHeap(), 0, ansi);
 114     }
 115 }
 116
 117 int     dbg_printf(const char* format, ...)
 118 {
 119     static    char      buf[4*1024];
 120     va_list     valist;
 121     int         len;
 122
 123     va_start(valist, format);
 124     len = vsnprintf(buf, sizeof(buf), format, valist);
 125     va_end(valist);
 126
 127     if (len <= -1 || len >= sizeof(buf))
 128     {
 129         len = sizeof(buf) - 1;
 130         buf[len] = 0;
 131         buf[len - 1] = buf[len - 2] = buf[len - 3] = '.';
 132     }
 133     dbg_outputA(buf, len);
 134     return len;
 135 }
 136
 137 static  unsigned dbg_load_internal_vars(void)
 138 {
 139     HKEY                        hkey;
 140     DWORD                       type = REG_DWORD;
 141     DWORD                       val;
 142     DWORD                       count = sizeof(val);
 143     int                         i;
 144     struct dbg_internal_var*    div = dbg_internal_vars;
 145
 146 /* initializes internal vars table */
 147 #define  INTERNAL_VAR(_var,_val,_ref,_tid)                      \
 148         div->val = _val; div->name = #_var; div->pval = _ref;   \
 149         div->typeid = _tid; div++;
 150 #include "intvar.h"
 151 #undef   INTERNAL_VAR
 152
 153     if (RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\WineDbg", &hkey))
 154     {
 155         WINE_ERR("Cannot create WineDbg key in registry\n");
 156         return FALSE;
 157     }
 158
 159     for (i = 0; i < DBG_IV_LAST; i++)
 160     {
 161         if (!dbg_internal_vars[i].pval)
 162         {
 163             if (!RegQueryValueEx(hkey, dbg_internal_vars[i].name, 0,
 164                                  &type, (LPSTR)&val, &count))
 165                 dbg_internal_vars[i].val = val;
 166             dbg_internal_vars[i].pval = &dbg_internal_vars[i].val;
 167         }
 168     }
 169     RegCloseKey(hkey);
 170     /* set up the debug variables for the CPU context */
 171     dbg_context_vars = be_cpu->init_registers(&dbg_context);
 172     return TRUE;
 173 }
 174
 175 static  unsigned dbg_save_internal_vars(void)
 176 {
 177     HKEY                        hkey;
 178     int                         i;
 179
 180     if (RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\WineDbg", &hkey))
 181     {
 182         WINE_ERR("Cannot create WineDbg key in registry\n");
 183         return FALSE;
 184     }
 185
 186     for (i = 0; i < DBG_IV_LAST; i++)
 187     {
 188         /* FIXME: type should be infered from basic type -if any- of intvar */
 189         if (dbg_internal_vars[i].pval == &dbg_internal_vars[i].val)
 190             RegSetValueEx(hkey, dbg_internal_vars[i].name, 0,
 191                           REG_DWORD, (const void*)dbg_internal_vars[i].pval,
 192                           sizeof(*dbg_internal_vars[i].pval));
 193     }
 194     RegCloseKey(hkey);
 195     return TRUE;
 196 }
 197
 198 const struct dbg_internal_var* dbg_get_internal_var(const char* name)
 199 {
 200     const struct dbg_internal_var*      div;
 201
 202     for (div = &dbg_internal_vars[DBG_IV_LAST - 1]; div >= dbg_internal_vars; div--)
 203     {
 204         if (!strcmp(div->name, name)) return div;
 205     }
 206     for (div = dbg_context_vars; div->name; div++)
 207     {
 208         if (!strcasecmp(div->name, name)) return div;
 209     }
 210
 211     return NULL;
 212 }
 213
 214 struct dbg_process*     dbg_get_process(DWORD pid)
 215 {
 216     struct dbg_process* p;
 217
 218     for (p = dbg_process_list; p; p = p->next)
 219         if (p->pid == pid) break;
 220     return p;
 221 }
 222
 223 struct dbg_process*     dbg_add_process(DWORD pid, HANDLE h, const char* imageName)
 224 {
 225     struct dbg_process* p;
 226
 227     if ((p = dbg_get_process(pid)))
 228     {
 229         if (p->handle != 0)
 230         {
 231             WINE_ERR("Process (%lu) is already defined\n", pid);
 232         }
 233         else
 234         {
 235             p->handle = h;
 236             p->imageName = imageName ? strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(imageName) + 1), imageName) : NULL;
 237         }
 238         return p;
 239     }
 240
 241     if (!(p = HeapAlloc(GetProcessHeap(), 0, sizeof(struct dbg_process)))) return NULL;
 242     p->handle = h;
 243     p->pid = pid;
 244     p->imageName = imageName ? strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(imageName) + 1), imageName) : NULL;
 245     p->threads = NULL;
 246     p->continue_on_first_exception = FALSE;
 247     p->next_bp = 1;  /* breakpoint 0 is reserved for step-over */
 248     memset(p->bp, 0, sizeof(p->bp));
 249     p->delayed_bp = NULL;
 250     p->num_delayed_bp = 0;
 251
 252     p->next = dbg_process_list;
 253     p->prev = NULL;
 254     if (dbg_process_list) dbg_process_list->prev = p;
 255     dbg_process_list = p;
 256     return p;
 257 }
 258
 259 void dbg_del_process(struct dbg_process* p)
 260 {
 261     int i;
 262
 263     while (p->threads) dbg_del_thread(p->threads);
 264
 265     for (i = 0; i < p->num_delayed_bp; i++)
 266         if (p->delayed_bp[i].is_symbol)
 267             HeapFree(GetProcessHeap(), 0, p->delayed_bp[i].u.symbol.name);
 268
 269     HeapFree(GetProcessHeap(), 0, p->delayed_bp);
 270     if (p->prev) p->prev->next = p->next;
 271     if (p->next) p->next->prev = p->prev;
 272     if (p == dbg_process_list) dbg_process_list = p->next;
 273     if (p == dbg_curr_process) dbg_curr_process = NULL;
 274     HeapFree(GetProcessHeap(), 0, (char*)p->imageName);
 275     HeapFree(GetProcessHeap(), 0, p);
 276 }
 277
 278 static void dbg_init_current_process(void)
 279 {
 280 }
 281
 282 struct mod_loader_info
 283 {
 284     HANDLE              handle;
 285     IMAGEHLP_MODULE*    imh_mod;
 286 };
 287
 288 static BOOL CALLBACK mod_loader_cb(PSTR mod_name, DWORD base, void* ctx)
 289 {
 290     struct mod_loader_info*     mli = (struct mod_loader_info*)ctx;
 291
 292     if (!strcmp(mod_name, "<wine-loader>"))
 293     {
 294         if (SymGetModuleInfo(mli->handle, base, mli->imh_mod))
 295             return FALSE; /* stop enum */
 296     }
 297     return TRUE;
 298 }
 299
 300 BOOL dbg_get_debuggee_info(HANDLE hProcess, IMAGEHLP_MODULE* imh_mod)
 301 {
 302     struct mod_loader_info  mli;
 303     DWORD                   opt;
 304
 305     /* this will resynchronize builtin dbghelp's internal ELF module list */
 306     SymLoadModule(hProcess, 0, 0, 0, 0, 0);
 307     mli.handle  = hProcess;
 308     mli.imh_mod = imh_mod;
 309     imh_mod->SizeOfStruct = sizeof(*imh_mod);
 310     imh_mod->BaseOfImage = 0;
 311     /* this is a wine specific options to return also ELF modules in the
 312      * enumeration
 313      */
 314     SymSetOptions((opt = SymGetOptions()) | 0x40000000);
 315     SymEnumerateModules(hProcess, mod_loader_cb, (void*)&mli);
 316     SymSetOptions(opt);
 317
 318     return imh_mod->BaseOfImage != 0;
 319 }
 320
 321 struct dbg_thread* dbg_get_thread(struct dbg_process* p, DWORD tid)
 322 {
 323     struct dbg_thread*  t;
 324
 325     if (!p) return NULL;
 326     for (t = p->threads; t; t = t->next)
 327         if (t->tid == tid) break;
 328     return t;
 329 }
 330
 331 struct dbg_thread* dbg_add_thread(struct dbg_process* p, DWORD tid,
 332                                   HANDLE h, void* teb)
 333 {
 334     struct dbg_thread*  t = HeapAlloc(GetProcessHeap(), 0, sizeof(struct dbg_thread));
 335
 336     if (!t)
 337         return NULL;
 338
 339     t->handle = h;
 340     t->tid = tid;
 341     t->teb = teb;
 342     t->process = p;
 343     t->exec_mode = dbg_exec_cont;
 344     t->exec_count = 0;
 345     t->step_over_bp.enabled = FALSE;
 346     t->step_over_bp.refcount = 0;
 347
 348     snprintf(t->name, sizeof(t->name), "0x%08lx", tid);
 349
 350     t->next = p->threads;
 351     t->prev = NULL;
 352     if (p->threads) p->threads->prev = t;
 353     p->threads = t;
 354
 355     return t;
 356 }
 357
 358 static void dbg_init_current_thread(void* start)
 359 {
 360     if (start)
 361     {
 362         if (dbg_curr_process->threads &&
 363             !dbg_curr_process->threads->next && /* first thread ? */
 364             DBG_IVAR(BreakAllThreadsStartup))
 365         {
 366             ADDRESS     addr;
 367
 368             break_set_xpoints(FALSE);
 369             addr.Mode   = AddrModeFlat;
 370             addr.Offset = (DWORD)start;
 371             break_add_break(&addr, TRUE);
 372             break_set_xpoints(TRUE);
 373         }
 374     }
 375 }
 376
 377 void dbg_del_thread(struct dbg_thread* t)
 378 {
 379     if (t->prev) t->prev->next = t->next;
 380     if (t->next) t->next->prev = t->prev;
 381     if (t == t->process->threads) t->process->threads = t->next;
 382     if (t == dbg_curr_thread) dbg_curr_thread = NULL;
 383     HeapFree(GetProcessHeap(), 0, t);
 384 }
 385
 386 static unsigned dbg_handle_debug_event(DEBUG_EVENT* de);
 387
 388 /******************************************************************
 389  *              dbg_attach_debuggee
 390  *
 391  * Sets the debuggee to <pid>
 392  * cofe instructs winedbg what to do when first exception is received
 393  * (break=FALSE, continue=TRUE)
 394  * wfe is set to TRUE if dbg_attach_debuggee should also proceed with all debug events
 395  * until the first exception is received (aka: attach to an already running process)
 396  */
 397 BOOL dbg_attach_debuggee(DWORD pid, BOOL cofe, BOOL wfe)
 398 {
 399     DEBUG_EVENT         de;
 400
 401     if (!(dbg_curr_process = dbg_add_process(pid, 0, NULL))) return FALSE;
 402
 403     if (!DebugActiveProcess(pid))
 404     {
 405         dbg_printf("Can't attach process %lx: error %ld\n", pid, GetLastError());
 406         dbg_del_process(dbg_curr_process);
 407         return FALSE;
 408     }
 409     dbg_curr_process->continue_on_first_exception = cofe;
 410
 411     if (wfe) /* shall we proceed all debug events until we get an exception ? */
 412     {
 413         dbg_interactiveP = FALSE;
 414         while (dbg_curr_process && WaitForDebugEvent(&de, INFINITE))
 415         {
 416             if (dbg_handle_debug_event(&de)) break;
 417         }
 418         if (dbg_curr_process) dbg_interactiveP = TRUE;
 419     }
 420     return TRUE;
 421 }
 422
 423 BOOL dbg_detach_debuggee(void)
 424 {
 425     /* remove all set breakpoints in debuggee code */
 426     break_set_xpoints(FALSE);
 427     /* needed for single stepping (ugly).
 428      * should this be handled inside the server ???
 429      */
 430     be_cpu->single_step(&dbg_context, FALSE);
 431     SetThreadContext(dbg_curr_thread->handle, &dbg_context);
 432     if (dbg_in_exception)
 433         ContinueDebugEvent(dbg_curr_pid, dbg_curr_tid, DBG_CONTINUE);
 434     if (!DebugActiveProcessStop(dbg_curr_pid)) return FALSE;
 435     dbg_del_process(dbg_curr_process);
 436
 437     return TRUE;
 438 }
 439
 440 static unsigned dbg_fetch_context(void)
 441 {
 442     dbg_context.ContextFlags = CONTEXT_CONTROL
 443         | CONTEXT_INTEGER
 444 #ifdef CONTEXT_SEGMENTS
 445         | CONTEXT_SEGMENTS
 446 #endif
 447 #ifdef CONTEXT_DEBUG_REGISTERS
 448         | CONTEXT_DEBUG_REGISTERS
 449 #endif
 450         ;
 451     if (!GetThreadContext(dbg_curr_thread->handle, &dbg_context))
 452     {
 453         WINE_WARN("Can't get thread's context\n");
 454         return FALSE;
 455     }
 456     return TRUE;
 457 }
 458
 459 static unsigned dbg_exception_prolog(BOOL is_debug, DWORD code)
 460 {
 461     ADDRESS     addr;
 462     BOOL        is_break;
 463
 464     dbg_in_exception = TRUE;
 465     memory_get_current_pc(&addr);
 466     break_suspend_execution();
 467
 468     if (!is_debug)
 469     {
 470         switch (addr.Mode)
 471         {
 472         case AddrModeFlat: dbg_printf(" in 32-bit code (0x%08lx)", addr.Offset); break;
 473         case AddrModeReal: dbg_printf(" in vm86 code (%04x:%04lx)", addr.Segment, addr.Offset); break;
 474         case AddrMode1616: dbg_printf(" in 16-bit code (%04x:%04lx)", addr.Segment, addr.Offset); break;
 475         default: dbg_printf(" bad address");
 476         }
 477         dbg_printf(".\n");
 478     }
 479
 480     /* this will resynchronize builtin dbghelp's internal ELF module list */
 481     SymLoadModule(dbg_curr_process->handle, 0, 0, 0, 0, 0);
 482
 483     /*
 484      * Do a quiet backtrace so that we have an idea of what the situation
 485      * is WRT the source files.
 486      */
 487     stack_backtrace(dbg_curr_tid, FALSE);
 488     if (is_debug &&
 489         break_should_continue(&addr, code, &dbg_curr_thread->exec_count, &is_break))
 490         return FALSE;
 491
 492     if (addr.Mode != dbg_curr_thread->addr_mode)
 493     {
 494         const char* name = NULL;
 495
 496         switch (addr.Mode)
 497         {
 498         case AddrMode1616: name = "16 bit";     break;
 499         case AddrMode1632: name = "X?X??X";     break;
 500         case AddrModeReal: name = "vm86";       break;
 501         case AddrModeFlat: name = "32 bit";     break;
 502         }
 503
 504         dbg_printf("In %s mode.\n", name);
 505         dbg_curr_thread->addr_mode = addr.Mode;
 506     }
 507     display_print();
 508
 509     if (!is_debug)
 510     {
 511         /* This is a real crash, dump some info */
 512         be_cpu->print_context(dbg_curr_thread->handle, &dbg_context);
 513         stack_info();
 514         be_cpu->print_segment_info(dbg_curr_thread->handle, &dbg_context);
 515         stack_backtrace(dbg_curr_tid, TRUE);
 516     }
 517     if (!is_debug || is_break ||
 518         dbg_curr_thread->exec_mode == dbg_exec_step_over_insn ||
 519         dbg_curr_thread->exec_mode == dbg_exec_step_into_insn)
 520     {
 521         ADDRESS tmp = addr;
 522         /* Show where we crashed */
 523         dbg_curr_frame = 0;
 524         memory_disasm_one_insn(&tmp);
 525     }
 526     source_list_from_addr(&addr, 0);
 527
 528     return TRUE;
 529 }
 530
 531 static void dbg_exception_epilog(void)
 532 {
 533     break_restart_execution(dbg_curr_thread->exec_count);
 534     /*
 535      * This will have gotten absorbed into the breakpoint info
 536      * if it was used.  Otherwise it would have been ignored.
 537      * In any case, we don't mess with it any more.
 538      */
 539     if (dbg_curr_thread->exec_mode == dbg_exec_cont)
 540         dbg_curr_thread->exec_count = 0;
 541     dbg_in_exception = FALSE;
 542 }
 543
 544 static DWORD dbg_handle_exception(EXCEPTION_RECORD* rec, BOOL first_chance)
 545 {
 546     BOOL                is_debug = FALSE;
 547     THREADNAME_INFO*    pThreadName;
 548     struct dbg_thread*  pThread;
 549
 550     assert(dbg_curr_thread);
 551
 552     WINE_TRACE("exception=%lx first_chance=%c\n",
 553                rec->ExceptionCode, first_chance ? 'Y' : 'N');
 554
 555     switch (rec->ExceptionCode)
 556     {
 557     case EXCEPTION_BREAKPOINT:
 558     case EXCEPTION_SINGLE_STEP:
 559         is_debug = TRUE;
 560         break;
 561     case EXCEPTION_NAME_THREAD:
 562         pThreadName = (THREADNAME_INFO*)(rec->ExceptionInformation);
 563         if (pThreadName->dwThreadID == -1)
 564             pThread = dbg_curr_thread;
 565         else
 566             pThread = dbg_get_thread(dbg_curr_process, pThreadName->dwThreadID);
 567
 568         if (dbg_read_memory(pThreadName->szName, pThread->name, 9))
 569             dbg_printf("Thread ID=0x%lx renamed using MS VC6 extension (name==\"%s\")\n",
 570                        pThread->tid, pThread->name);
 571         return DBG_CONTINUE;
 572     }
 573
 574     if (first_chance && !is_debug && !DBG_IVAR(BreakOnFirstChance))
 575     {
 576         /* pass exception to program except for debug exceptions */
 577         return DBG_EXCEPTION_NOT_HANDLED;
 578     }
 579
 580     if (!is_debug)
 581     {
 582         /* print some infos */
 583         dbg_printf("%s: ",
 584                    first_chance ? "First chance exception" : "Unhandled exception");
 585         switch (rec->ExceptionCode)
 586         {
 587         case EXCEPTION_INT_DIVIDE_BY_ZERO:
 588             dbg_printf("divide by zero");
 589             break;
 590         case EXCEPTION_INT_OVERFLOW:
 591             dbg_printf("overflow");
 592             break;
 593         case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
 594             dbg_printf("array bounds");
 595             break;
 596         case EXCEPTION_ILLEGAL_INSTRUCTION:
 597             dbg_printf("illegal instruction");
 598             break;
 599         case EXCEPTION_STACK_OVERFLOW:
 600             dbg_printf("stack overflow");
 601             break;
 602         case EXCEPTION_PRIV_INSTRUCTION:
 603             dbg_printf("privileged instruction");
 604             break;
 605         case EXCEPTION_ACCESS_VIOLATION:
 606             if (rec->NumberParameters == 2)
 607                 dbg_printf("page fault on %s access to 0x%08lx",
 608                            rec->ExceptionInformation[0] ? "write" : "read",
 609                            rec->ExceptionInformation[1]);
 610             else
 611                 dbg_printf("page fault");
 612             break;
 613         case EXCEPTION_DATATYPE_MISALIGNMENT:
 614             dbg_printf("Alignment");
 615             break;
 616         case DBG_CONTROL_C:
 617             dbg_printf("^C");
 618             break;
 619         case CONTROL_C_EXIT:
 620             dbg_printf("^C");
 621             break;
 622         case STATUS_POSSIBLE_DEADLOCK:
 623         {
 624             ADDRESS         addr;
 625
 626             addr.Mode   = AddrModeFlat;
 627             addr.Offset = rec->ExceptionInformation[0];
 628
 629             dbg_printf("wait failed on critical section ");
 630             print_address(&addr, FALSE);
 631         }
 632         if (!DBG_IVAR(BreakOnCritSectTimeOut))
 633         {
 634             dbg_printf("\n");
 635             return DBG_EXCEPTION_NOT_HANDLED;
 636         }
 637         break;
 638         case EXCEPTION_WINE_STUB:
 639         {
 640             char dll[32], name[64];
 641             memory_get_string(dbg_curr_process->handle,
 642                               (void*)rec->ExceptionInformation[0], TRUE, FALSE,
 643                               dll, sizeof(dll));
 644             if (HIWORD(rec->ExceptionInformation[1]))
 645                 memory_get_string(dbg_curr_process->handle,
 646                                   (void*)rec->ExceptionInformation[1], TRUE, FALSE,
 647                                   name, sizeof(name));
 648             else
 649                 sprintf( name, "%ld", rec->ExceptionInformation[1] );
 650             dbg_printf("unimplemented function %s.%s called", dll, name);
 651         }
 652         break;
 653         case EXCEPTION_WINE_ASSERTION:
 654             dbg_printf("assertion failed");
 655             break;
 656         case EXCEPTION_VM86_INTx:
 657             dbg_printf("interrupt %02lx in vm86 mode", rec->ExceptionInformation[0]);
 658             break;
 659         case EXCEPTION_VM86_STI:
 660             dbg_printf("sti in vm86 mode");
 661             break;
 662         case EXCEPTION_VM86_PICRETURN:
 663             dbg_printf("PIC return in vm86 mode");
 664             break;
 665         case EXCEPTION_FLT_DENORMAL_OPERAND:
 666             dbg_printf("denormal float operand");
 667             break;
 668         case EXCEPTION_FLT_DIVIDE_BY_ZERO:
 669             dbg_printf("divide by zero");
 670             break;
 671         case EXCEPTION_FLT_INEXACT_RESULT:
 672             dbg_printf("inexact float result");
 673             break;
 674         case EXCEPTION_FLT_INVALID_OPERATION:
 675             dbg_printf("invalid float operation");
 676             break;
 677         case EXCEPTION_FLT_OVERFLOW:
 678             dbg_printf("floating pointer overflow");
 679             break;
 680         case EXCEPTION_FLT_UNDERFLOW:
 681             dbg_printf("floating pointer underflow");
 682             break;
 683         case EXCEPTION_FLT_STACK_CHECK:
 684             dbg_printf("floating point stack check");
 685             break;
 686         default:
 687             dbg_printf("0x%08lx", rec->ExceptionCode);
 688             break;
 689         }
 690     }
 691
 692     if (dbg_action_mode == automatic_mode)
 693     {
 694         dbg_exception_prolog(is_debug, rec->ExceptionCode);
 695         dbg_exception_epilog();
 696         return 0;  /* terminate execution */
 697     }
 698
 699     if (dbg_exception_prolog(is_debug, rec->ExceptionCode))
 700     {
 701         dbg_interactiveP = TRUE;
 702         return 0;
 703     }
 704     dbg_exception_epilog();
 705
 706     return DBG_CONTINUE;
 707 }
 708
 709 static unsigned dbg_handle_debug_event(DEBUG_EVENT* de)
 710 {
 711     char        buffer[256];
 712     DWORD       cont = DBG_CONTINUE;
 713
 714     dbg_curr_pid = de->dwProcessId;
 715     dbg_curr_tid = de->dwThreadId;
 716
 717     if ((dbg_curr_process = dbg_get_process(de->dwProcessId)) != NULL)
 718         dbg_curr_thread = dbg_get_thread(dbg_curr_process, de->dwThreadId);
 719     else
 720         dbg_curr_thread = NULL;
 721
 722     switch (de->dwDebugEventCode)
 723     {
 724     case EXCEPTION_DEBUG_EVENT:
 725         if (!dbg_curr_thread)
 726         {
 727             WINE_ERR("%08lx:%08lx: not a registered process or thread (perhaps a 16 bit one ?)\n",
 728                      de->dwProcessId, de->dwThreadId);
 729             break;
 730         }
 731
 732         WINE_TRACE("%08lx:%08lx: exception code=%08lx\n",
 733                    de->dwProcessId, de->dwThreadId,
 734                    de->u.Exception.ExceptionRecord.ExceptionCode);
 735
 736         if (dbg_curr_process->continue_on_first_exception)
 737         {
 738             dbg_curr_process->continue_on_first_exception = FALSE;
 739             if (!DBG_IVAR(BreakOnAttach)) break;
 740         }
 741         if (dbg_fetch_context())
 742         {
 743             cont = dbg_handle_exception(&de->u.Exception.ExceptionRecord,
 744                                         de->u.Exception.dwFirstChance);
 745             if (cont && dbg_curr_thread)
 746             {
 747                 SetThreadContext(dbg_curr_thread->handle, &dbg_context);
 748             }
 749         }
 750         break;
 751
 752     case CREATE_PROCESS_DEBUG_EVENT:
 753         memory_get_string_indirect(de->u.CreateProcessInfo.hProcess,
 754                                    de->u.CreateProcessInfo.lpImageName,
 755                                    de->u.CreateProcessInfo.fUnicode,
 756                                    buffer, sizeof(buffer));
 757         WINE_TRACE("%08lx:%08lx: create process '%s'/%p @%08lx (%ld<%ld>)\n",
 758                    de->dwProcessId, de->dwThreadId,
 759                    buffer, de->u.CreateProcessInfo.lpImageName,
 760                    (unsigned long)(void*)de->u.CreateProcessInfo.lpStartAddress,
 761                    de->u.CreateProcessInfo.dwDebugInfoFileOffset,
 762                    de->u.CreateProcessInfo.nDebugInfoSize);
 763
 764         dbg_curr_process = dbg_add_process(de->dwProcessId,
 765                                            de->u.CreateProcessInfo.hProcess,
 766                                            buffer[0] ? buffer : "<Debugged Process>");
 767         if (dbg_curr_process == NULL)
 768         {
 769             WINE_ERR("Couldn't create process\n");
 770             break;
 771         }
 772         if (!SymInitialize(dbg_curr_process->handle, NULL, TRUE))
 773             dbg_printf("Couldn't initiate DbgHelp\n");
 774
 775         WINE_TRACE("%08lx:%08lx: create thread I @%08lx\n",
 776                    de->dwProcessId, de->dwThreadId,
 777                    (unsigned long)(void*)de->u.CreateProcessInfo.lpStartAddress);
 778
 779         dbg_curr_thread = dbg_add_thread(dbg_curr_process,
 780                                          de->dwThreadId,
 781                                          de->u.CreateProcessInfo.hThread,
 782                                          de->u.CreateProcessInfo.lpThreadLocalBase);
 783         if (!dbg_curr_thread)
 784         {
 785             WINE_ERR("Couldn't create thread\n");
 786             break;
 787         }
 788         dbg_init_current_process();
 789         dbg_init_current_thread(de->u.CreateProcessInfo.lpStartAddress);
 790         break;
 791
 792     case EXIT_PROCESS_DEBUG_EVENT:
 793         WINE_TRACE("%08lx:%08lx: exit process (%ld)\n",
 794                    de->dwProcessId, de->dwThreadId, de->u.ExitProcess.dwExitCode);
 795
 796         if (dbg_curr_process == NULL)
 797         {
 798             WINE_ERR("Unknown process\n");
 799             break;
 800         }
 801         if (!SymCleanup(dbg_curr_process->handle))
 802             dbg_printf("Couldn't initiate DbgHelp\n");
 803         /* just in case */
 804         break_set_xpoints(FALSE);
 805         /* kill last thread */
 806         dbg_del_thread(dbg_curr_process->threads);
 807         dbg_del_process(dbg_curr_process);
 808
 809         dbg_printf("Process of pid=0x%08lx has terminated\n", dbg_curr_pid);
 810         break;
 811
 812     case CREATE_THREAD_DEBUG_EVENT:
 813         WINE_TRACE("%08lx:%08lx: create thread D @%08lx\n",
 814                    de->dwProcessId, de->dwThreadId,
 815                    (unsigned long)(void*)de->u.CreateThread.lpStartAddress);
 816
 817         if (dbg_curr_process == NULL)
 818         {
 819             WINE_ERR("Unknown process\n");
 820             break;
 821         }
 822         if (dbg_get_thread(dbg_curr_process, de->dwThreadId) != NULL)
 823         {
 824             WINE_TRACE("Thread already listed, skipping\n");
 825             break;
 826         }
 827
 828         dbg_curr_thread = dbg_add_thread(dbg_curr_process,
 829                                          de->dwThreadId,
 830                                          de->u.CreateThread.hThread,
 831                                          de->u.CreateThread.lpThreadLocalBase);
 832         if (!dbg_curr_thread)
 833         {
 834             WINE_ERR("Couldn't create thread\n");
 835             break;
 836         }
 837         dbg_init_current_thread(de->u.CreateThread.lpStartAddress);
 838         break;
 839
 840     case EXIT_THREAD_DEBUG_EVENT:
 841         WINE_TRACE("%08lx:%08lx: exit thread (%ld)\n",
 842                    de->dwProcessId, de->dwThreadId, de->u.ExitThread.dwExitCode);
 843
 844         if (dbg_curr_thread == NULL)
 845         {
 846             WINE_ERR("Unknown thread\n");
 847             break;
 848         }
 849         /* FIXME: remove break point set on thread startup */
 850         dbg_del_thread(dbg_curr_thread);
 851         break;
 852
 853     case LOAD_DLL_DEBUG_EVENT:
 854         if (dbg_curr_thread == NULL)
 855         {
 856             WINE_ERR("Unknown thread\n");
 857             break;
 858         }
 859         memory_get_string_indirect(dbg_curr_process->handle,
 860                                    de->u.LoadDll.lpImageName,
 861                                    de->u.LoadDll.fUnicode,
 862                                    buffer, sizeof(buffer));
 863
 864         WINE_TRACE("%08lx:%08lx: loads DLL %s @%08lx (%ld<%ld>)\n",
 865                    de->dwProcessId, de->dwThreadId,
 866                    buffer, (unsigned long)de->u.LoadDll.lpBaseOfDll,
 867                    de->u.LoadDll.dwDebugInfoFileOffset,
 868                    de->u.LoadDll.nDebugInfoSize);
 869         _strupr(buffer);
 870         SymLoadModule(dbg_curr_process->handle, de->u.LoadDll.hFile, buffer, NULL,
 871                       (unsigned long)de->u.LoadDll.lpBaseOfDll, 0);
 872         break_set_xpoints(FALSE);
 873         break_check_delayed_bp();
 874         break_set_xpoints(TRUE);
 875         if (DBG_IVAR(BreakOnDllLoad))
 876         {
 877             dbg_printf("Stopping on DLL %s loading at 0x%08lx\n",
 878                        buffer, (unsigned long)de->u.LoadDll.lpBaseOfDll);
 879             if (dbg_fetch_context()) cont = 0;
 880         }
 881         break;
 882
 883     case UNLOAD_DLL_DEBUG_EVENT:
 884         WINE_TRACE("%08lx:%08lx: unload DLL @%08lx\n",
 885                    de->dwProcessId, de->dwThreadId,
 886                    (unsigned long)de->u.UnloadDll.lpBaseOfDll);
 887         break_delete_xpoints_from_module((unsigned long)de->u.UnloadDll.lpBaseOfDll);
 888         SymUnloadModule(dbg_curr_process->handle,
 889                         (unsigned long)de->u.UnloadDll.lpBaseOfDll);
 890         break;
 891
 892     case OUTPUT_DEBUG_STRING_EVENT:
 893         if (dbg_curr_thread == NULL)
 894         {
 895             WINE_ERR("Unknown thread\n");
 896             break;
 897         }
 898
 899         memory_get_string(dbg_curr_process->handle,
 900                           de->u.DebugString.lpDebugStringData, TRUE,
 901                           de->u.DebugString.fUnicode, buffer, sizeof(buffer));
 902         WINE_TRACE("%08lx:%08lx: output debug string (%s)\n",
 903                    de->dwProcessId, de->dwThreadId, buffer);
 904         break;
 905
 906     case RIP_EVENT:
 907         WINE_TRACE("%08lx:%08lx: rip error=%ld type=%ld\n",
 908                    de->dwProcessId, de->dwThreadId, de->u.RipInfo.dwError,
 909                    de->u.RipInfo.dwType);
 910         break;
 911
 912     default:
 913         WINE_TRACE("%08lx:%08lx: unknown event (%ld)\n",
 914                    de->dwProcessId, de->dwThreadId, de->dwDebugEventCode);
 915     }
 916     if (!cont) return TRUE;  /* stop execution */
 917     ContinueDebugEvent(de->dwProcessId, de->dwThreadId, cont);
 918     return FALSE;  /* continue execution */
 919 }
 920
 921 static void dbg_resume_debuggee(DWORD cont)
 922 {
 923     if (dbg_in_exception)
 924     {
 925         ADDRESS         addr;
 926
 927         dbg_exception_epilog();
 928         memory_get_current_pc(&addr);
 929         WINE_TRACE("Exiting debugger      PC=0x%lx mode=%d count=%d\n",
 930                    addr.Offset, dbg_curr_thread->exec_mode,
 931                    dbg_curr_thread->exec_count);
 932         if (dbg_curr_thread)
 933         {
 934             if (!SetThreadContext(dbg_curr_thread->handle, &dbg_context))
 935                 dbg_printf("Cannot set ctx on %lu\n", dbg_curr_tid);
 936         }
 937     }
 938     dbg_interactiveP = FALSE;
 939     if (!ContinueDebugEvent(dbg_curr_pid, dbg_curr_tid, cont))
 940         dbg_printf("Cannot continue on %lu (%lu)\n", dbg_curr_tid, cont);
 941 }
 942
 943 void dbg_wait_next_exception(DWORD cont, int count, int mode)
 944 {
 945     DEBUG_EVENT         de;
 946     ADDRESS             addr;
 947
 948     if (cont == DBG_CONTINUE)
 949     {
 950         dbg_curr_thread->exec_count = count;
 951         dbg_curr_thread->exec_mode = mode;
 952     }
 953     dbg_resume_debuggee(cont);
 954
 955     while (dbg_curr_process && WaitForDebugEvent(&de, INFINITE))
 956     {
 957         if (dbg_handle_debug_event(&de)) break;
 958     }
 959     if (!dbg_curr_process) return;
 960     dbg_interactiveP = TRUE;
 961
 962     memory_get_current_pc(&addr);
 963     WINE_TRACE("Entering debugger     PC=0x%lx mode=%d count=%d\n",
 964                addr.Offset, dbg_curr_thread->exec_mode,
 965                dbg_curr_thread->exec_count);
 966 }
 967
 968 static  unsigned        dbg_main_loop(void)
 969 {
 970     DEBUG_EVENT         de;
 971
 972     if (dbg_curr_process)
 973         dbg_printf("WineDbg starting on pid 0x%lx\n", dbg_curr_pid);
 974
 975     /* wait for first exception */
 976     while (WaitForDebugEvent(&de, INFINITE))
 977     {
 978         if (dbg_handle_debug_event(&de)) break;
 979     }
 980     switch (dbg_action_mode)
 981     {
 982     case automatic_mode:
 983         /* print some extra information */
 984         dbg_printf("Modules:\n");
 985         info_win32_module(0); /* print all modules */
 986         dbg_printf("Threads:\n");
 987         info_win32_threads();
 988         break;
 989     default:
 990         dbg_interactiveP = TRUE;
 991         parser(NULL);
 992     }
 993     dbg_printf("WineDbg terminated on pid 0x%lx\n", dbg_curr_pid);
 994
 995     return 0;
 996 }
 997
 998 static  unsigned dbg_start_debuggee(LPSTR cmdLine)
 999 {
1000     PROCESS_INFORMATION info;
1001     STARTUPINFOA        startup;
1002
1003     memset(&startup, 0, sizeof(startup));
1004     startup.cb = sizeof(startup);
1005     startup.dwFlags = STARTF_USESHOWWINDOW;
1006     startup.wShowWindow = SW_SHOWNORMAL;
1007
1008     /* FIXME: shouldn't need the CREATE_NEW_CONSOLE, but as usual CUI:s need it
1009      * while GUI:s don't
1010      */
1011     if (!CreateProcess(NULL, cmdLine, NULL, NULL,
1012                        FALSE,
1013                        DEBUG_PROCESS|DEBUG_ONLY_THIS_PROCESS|CREATE_NEW_CONSOLE,
1014                        NULL, NULL, &startup, &info))
1015     {
1016         dbg_printf("Couldn't start process '%s'\n", cmdLine);
1017         return FALSE;
1018     }
1019     if (!info.dwProcessId)
1020     {
1021         /* this happens when the program being run is not a Wine binary
1022          * (for example, a shell wrapper around a WineLib app)
1023          */
1024         /* Current fix: list running processes and let the user attach
1025          * to one of them (sic)
1026          * FIXME: implement a real fix => grab the process (from the
1027          * running processes) from its name
1028          */
1029         dbg_printf("Debuggee has been started (%s)\n"
1030                    "But WineDbg isn't attached to it. Maybe you're trying to debug a winelib wrapper ??\n"
1031                    "Try to attach to one of those processes:\n", cmdLine);
1032         /* FIXME: (HACK) we need some time before the wrapper executes the winelib app */
1033         Sleep(100);
1034         info_win32_processes();
1035         return TRUE;
1036     }
1037     dbg_curr_pid = info.dwProcessId;
1038     if (!(dbg_curr_process = dbg_add_process(dbg_curr_pid, 0, NULL))) return FALSE;
1039
1040     return TRUE;
1041 }
1042
1043 void    dbg_run_debuggee(const char* args)
1044 {
1045     if (args)
1046     {
1047         WINE_FIXME("Re-running current program with %s as args is broken\n", args);
1048         return;
1049     }
1050     else
1051     {
1052         DEBUG_EVENT     de;
1053
1054         if (!dbg_last_cmd_line)
1055         {
1056             dbg_printf("Cannot find previously used command line.\n");
1057             return;
1058         }
1059         dbg_start_debuggee(dbg_last_cmd_line);
1060         while (dbg_curr_process && WaitForDebugEvent(&de, INFINITE))
1061         {
1062             if (dbg_handle_debug_event(&de)) break;
1063         }
1064         source_list_from_addr(NULL, 0);
1065     }
1066 }
1067
1068 BOOL dbg_interrupt_debuggee(void)
1069 {
1070     if (!dbg_process_list) return FALSE;
1071     /* FIXME: since we likely have a single process, signal the first process
1072      * in list
1073      */
1074     if (dbg_process_list->next) dbg_printf("Ctrl-C: only stopping the first process\n");
1075     else dbg_printf("Ctrl-C: stopping debuggee\n");
1076     dbg_process_list->continue_on_first_exception = FALSE;
1077     return DebugBreakProcess(dbg_process_list->handle);
1078 }
1079
1080 static BOOL WINAPI ctrl_c_handler(DWORD dwCtrlType)
1081 {
1082     if (dwCtrlType == CTRL_C_EVENT)
1083     {
1084         return dbg_interrupt_debuggee();
1085     }
1086     return FALSE;
1087 }
1088
1089 static void dbg_init_console(void)
1090 {
1091     /* set our control-C handler */
1092     SetConsoleCtrlHandler(ctrl_c_handler, TRUE);
1093
1094     /* set our own title */
1095     SetConsoleTitle("Wine Debugger");
1096 }
1097
1098 static int dbg_winedbg_usage(void)
1099 {
1100     dbg_printf("Usage: winedbg [--auto] [--gdb] cmdline\n");
1101     return 1;
1102 }
1103
1104 struct backend_cpu* be_cpu;
1105 #ifdef __i386__
1106 extern struct backend_cpu be_i386;
1107 #elif __powerpc__
1108 extern struct backend_cpu be_ppc;
1109 #elif __ALPHA__
1110 extern struct backend_cpu be_alpha;
1111 #else
1112 # error CPU unknown
1113 #endif
1114
1115 int main(int argc, char** argv)
1116 {
1117     DWORD       retv = 0;
1118     unsigned    gdb_flags = 0;
1119
1120 #ifdef __i386__
1121     be_cpu = &be_i386;
1122 #elif __powerpc__
1123     be_cpu = &be_ppc;
1124 #elif __ALPHA__
1125     be_cpu = &be_alpha;
1126 #else
1127 # error CPU unknown
1128 #endif
1129     /* Initialize the output */
1130     dbg_houtput = GetStdHandle(STD_OUTPUT_HANDLE);
1131
1132     /* Initialize internal vars */
1133     if (!dbg_load_internal_vars()) return -1;
1134
1135     /* parse options */
1136     while (argc > 1 && argv[1][0] == '-')
1137     {
1138         if (!strcmp(argv[1], "--command"))
1139         {
1140             argc--; argv++;
1141             arg_command = HeapAlloc(GetProcessHeap(), 0, strlen(argv[1])+2);
1142             strcpy(arg_command, argv[1]);
1143             strcat(arg_command, "\n");
1144             argc--; argv++;
1145             continue;
1146         }
1147         if (!strcmp(argv[1], "--auto"))
1148         {
1149             if (dbg_action_mode != none_mode) return dbg_winedbg_usage();
1150             dbg_action_mode = automatic_mode;
1151             /* force some internal variables */
1152             DBG_IVAR(BreakOnDllLoad) = 0;
1153             argc--; argv++;
1154             dbg_houtput = GetStdHandle(STD_ERROR_HANDLE);
1155             continue;
1156         }
1157         if (!strcmp(argv[1], "--gdb"))
1158         {
1159             if (dbg_action_mode != none_mode) return dbg_winedbg_usage();
1160             dbg_action_mode = gdb_mode;
1161             argc--; argv++;
1162             continue;
1163         }
1164         if (strcmp(argv[1], "--no-start") == 0 && dbg_action_mode == gdb_mode)
1165         {
1166             gdb_flags |= 1;
1167             argc--; argv++; /* as we don't use argv[0] */
1168             continue;
1169         }
1170         if (strcmp(argv[1], "--with-xterm") == 0 && dbg_action_mode == gdb_mode)
1171         {
1172             gdb_flags |= 2;
1173             argc--; argv++; /* as we don't use argv[0] */
1174             continue;
1175         }
1176         return dbg_winedbg_usage();
1177     }
1178
1179     if (dbg_action_mode == none_mode) dbg_action_mode = winedbg_mode;
1180
1181     /* try the form <myself> pid */
1182     if (dbg_curr_pid == 0 && argc == 2)
1183     {
1184         char*   ptr;
1185
1186         dbg_curr_pid = strtol(argv[1], &ptr, 10);
1187         if (dbg_curr_pid == 0 || ptr != argv[1] + strlen(argv[1]) ||
1188             !dbg_attach_debuggee(dbg_curr_pid, dbg_action_mode != gdb_mode, FALSE))
1189             dbg_curr_pid = 0;
1190     }
1191
1192     /* try the form <myself> pid evt (Win32 JIT debugger) */
1193     if (dbg_curr_pid == 0 && argc == 3)
1194     {
1195         HANDLE  hEvent;
1196         DWORD   pid;
1197         char*   ptr;
1198
1199         if ((pid = strtol(argv[1], &ptr, 10)) != 0 && ptr != NULL &&
1200             (hEvent = (HANDLE)strtol(argv[2], &ptr, 10)) != 0 && ptr != NULL)
1201         {
1202             if (!dbg_attach_debuggee(pid, TRUE, FALSE))
1203             {
1204                 /* don't care about result */
1205                 SetEvent(hEvent);
1206                 goto leave;
1207             }
1208             if (!SetEvent(hEvent))
1209             {
1210                 WINE_ERR("Invalid event handle: %p\n", hEvent);
1211                 goto leave;
1212             }
1213             CloseHandle(hEvent);
1214             dbg_curr_pid = pid;
1215         }
1216     }
1217
1218     if (dbg_curr_pid == 0 && argc > 1)
1219     {
1220         int     i, len;
1221         LPSTR   cmdLine;
1222
1223         if (!(cmdLine = HeapAlloc(GetProcessHeap(), 0, len = 1))) goto oom_leave;
1224         cmdLine[0] = '\0';
1225
1226         for (i = 1; i < argc; i++)
1227         {
1228             len += strlen(argv[i]) + 1;
1229             if (!(cmdLine = HeapReAlloc(GetProcessHeap(), 0, cmdLine, len)))
1230                 goto oom_leave;
1231             strcat(cmdLine, argv[i]);
1232             cmdLine[len - 2] = ' ';
1233             cmdLine[len - 1] = '\0';
1234         }
1235
1236         if (!dbg_start_debuggee(cmdLine))
1237         {
1238             dbg_printf("Couldn't start process '%s'\n", cmdLine);
1239             goto leave;
1240         }
1241         dbg_last_cmd_line = cmdLine;
1242     }
1243     /* don't save local vars in gdb mode */
1244     if (dbg_action_mode == gdb_mode && dbg_curr_pid)
1245         return gdb_remote(gdb_flags);
1246
1247     dbg_init_console();
1248
1249     SymSetOptions(SymGetOptions() |
1250                   SYMOPT_LOAD_LINES | SYMOPT_DEFERRED_LOADS | SYMOPT_AUTO_PUBLICS);
1251
1252     retv = dbg_main_loop();
1253     /* don't save modified variables in auto mode */
1254     if (dbg_action_mode != automatic_mode) dbg_save_internal_vars();
1255
1256 leave:
1257     return retv;
1258
1259 oom_leave:
1260     dbg_printf("Out of memory\n");
1261     return retv;
1262 }