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

   1 /*
   2  * Wine debugger - back-end for an active target
   3  *
   4  * Copyright 2000-2006 Eric Pouech
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include <stdarg.h>
  27
  28 #include "debugger.h"
  29 #include "psapi.h"
  30 #include "winternl.h"
  31 #include "wine/debug.h"
  32 #include "wine/exception.h"
  33 #include "wine/unicode.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
  36
  37 static char*            dbg_last_cmd_line;
  38 static struct be_process_io be_process_active_io;
  39
  40 static void dbg_init_current_process(void)
  41 {
  42 }
  43
  44 static void dbg_init_current_thread(void* start)
  45 {
  46     if (start)
  47     {
  48         if (dbg_curr_process->threads &&
  49             !dbg_curr_process->threads->next && /* first thread ? */
  50             DBG_IVAR(BreakAllThreadsStartup))
  51         {
  52             ADDRESS64   addr;
  53
  54             break_set_xpoints(FALSE);
  55             addr.Mode   = AddrModeFlat;
  56             addr.Offset = (DWORD_PTR)start;
  57             break_add_break(&addr, TRUE, TRUE);
  58             break_set_xpoints(TRUE);
  59         }
  60     }
  61 }
  62
  63 static unsigned dbg_handle_debug_event(DEBUG_EVENT* de);
  64
  65 /******************************************************************
  66  *              dbg_attach_debuggee
  67  *
  68  * Sets the debuggee to <pid>
  69  * cofe instructs winedbg what to do when first exception is received
  70  * (break=FALSE, continue=TRUE)
  71  * wfe is set to TRUE if dbg_attach_debuggee should also proceed with all debug events
  72  * until the first exception is received (aka: attach to an already running process)
  73  */
  74 BOOL dbg_attach_debuggee(DWORD pid, BOOL cofe)
  75 {
  76     if (!(dbg_curr_process = dbg_add_process(&be_process_active_io, pid, 0))) return FALSE;
  77
  78     if (!DebugActiveProcess(pid))
  79     {
  80         dbg_printf("Can't attach process %04x: error %u\n", pid, GetLastError());
  81         dbg_del_process(dbg_curr_process);
  82         return FALSE;
  83     }
  84     dbg_curr_process->continue_on_first_exception = cofe;
  85
  86     SetEnvironmentVariableA("DBGHELP_NOLIVE", NULL);
  87
  88     dbg_curr_process->active_debuggee = TRUE;
  89     return TRUE;
  90 }
  91
  92 static unsigned dbg_fetch_context(void)
  93 {
  94     dbg_context.ContextFlags = CONTEXT_CONTROL
  95         | CONTEXT_INTEGER | CONTEXT_FLOATING_POINT
  96 #ifdef CONTEXT_SEGMENTS
  97         | CONTEXT_SEGMENTS
  98 #endif
  99 #ifdef CONTEXT_DEBUG_REGISTERS
 100         | CONTEXT_DEBUG_REGISTERS
 101 #endif
 102         ;
 103     if (!GetThreadContext(dbg_curr_thread->handle, &dbg_context))
 104     {
 105         WINE_WARN("Can't get thread's context\n");
 106         return FALSE;
 107     }
 108     return TRUE;
 109 }
 110
 111 /***********************************************************************
 112  *              dbg_exception_prolog
 113  *
 114  * Examine exception and decide if interactive mode is entered(return TRUE)
 115  * or exception is silently continued(return FALSE)
 116  * is_debug means the exception is a breakpoint or single step exception
 117  */
 118 static unsigned dbg_exception_prolog(BOOL is_debug, BOOL first_chance, const EXCEPTION_RECORD* rec)
 119 {
 120     ADDRESS64   addr;
 121     BOOL        is_break;
 122     char        hexbuf[MAX_OFFSET_TO_STR_LEN];
 123
 124     memory_get_current_pc(&addr);
 125     break_suspend_execution();
 126     dbg_curr_thread->excpt_record = *rec;
 127     dbg_curr_thread->in_exception = TRUE;
 128
 129     if (!is_debug)
 130     {
 131         switch (addr.Mode)
 132         {
 133         case AddrModeFlat:
 134             dbg_printf(" in 32-bit code (%s)",
 135                        memory_offset_to_string(hexbuf, addr.Offset, 0));
 136             break;
 137         case AddrModeReal:
 138             dbg_printf(" in vm86 code (%04x:%04x)", addr.Segment, (unsigned) addr.Offset);
 139             break;
 140         case AddrMode1616:
 141             dbg_printf(" in 16-bit code (%04x:%04x)", addr.Segment, (unsigned) addr.Offset);
 142             break;
 143         case AddrMode1632:
 144             dbg_printf(" in 32-bit code (%04x:%08lx)", addr.Segment, (unsigned long) addr.Offset);
 145             break;
 146         default: dbg_printf(" bad address");
 147         }
 148         dbg_printf(".\n");
 149     }
 150
 151     /* this will resynchronize builtin dbghelp's internal ELF module list */
 152     SymLoadModule(dbg_curr_process->handle, 0, 0, 0, 0, 0);
 153
 154     if (is_debug) break_adjust_pc(&addr, rec->ExceptionCode, first_chance, &is_break);
 155     /*
 156      * Do a quiet backtrace so that we have an idea of what the situation
 157      * is WRT the source files.
 158      */
 159     stack_fetch_frames();
 160
 161     if (is_debug && !is_break && break_should_continue(&addr, rec->ExceptionCode))
 162         return FALSE;
 163
 164     if (addr.Mode != dbg_curr_thread->addr_mode)
 165     {
 166         const char* name = NULL;
 167
 168         switch (addr.Mode)
 169         {
 170         case AddrMode1616: name = "16 bit";     break;
 171         case AddrMode1632: name = "32 bit";     break;
 172         case AddrModeReal: name = "vm86";       break;
 173         case AddrModeFlat: name = "32 bit";     break;
 174         }
 175
 176         dbg_printf("In %s mode.\n", name);
 177         dbg_curr_thread->addr_mode = addr.Mode;
 178     }
 179     display_print();
 180
 181     if (!is_debug)
 182     {
 183         /* This is a real crash, dump some info */
 184         be_cpu->print_context(dbg_curr_thread->handle, &dbg_context, 0);
 185         stack_info();
 186         be_cpu->print_segment_info(dbg_curr_thread->handle, &dbg_context);
 187         stack_backtrace(dbg_curr_tid);
 188     }
 189     else
 190     {
 191         static char*        last_name;
 192         static char*        last_file;
 193
 194         char                buffer[sizeof(SYMBOL_INFO) + 256];
 195         SYMBOL_INFO*        si = (SYMBOL_INFO*)buffer;
 196         void*               lin = memory_to_linear_addr(&addr);
 197         DWORD64             disp64;
 198         IMAGEHLP_LINE       il;
 199         DWORD               disp;
 200
 201         si->SizeOfStruct = sizeof(*si);
 202         si->MaxNameLen   = 256;
 203         il.SizeOfStruct = sizeof(il);
 204         if (SymFromAddr(dbg_curr_process->handle, (DWORD_PTR)lin, &disp64, si) &&
 205             SymGetLineFromAddr(dbg_curr_process->handle, (DWORD_PTR)lin, &disp, &il))
 206         {
 207             if ((!last_name || strcmp(last_name, si->Name)) ||
 208                 (!last_file || strcmp(last_file, il.FileName)))
 209             {
 210                 HeapFree(GetProcessHeap(), 0, last_name);
 211                 HeapFree(GetProcessHeap(), 0, last_file);
 212                 last_name = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(si->Name) + 1), si->Name);
 213                 last_file = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(il.FileName) + 1), il.FileName);
 214                 dbg_printf("%s () at %s:%u\n", last_name, last_file, il.LineNumber);
 215             }
 216         }
 217     }
 218     if (!is_debug || is_break ||
 219         dbg_curr_thread->exec_mode == dbg_exec_step_over_insn ||
 220         dbg_curr_thread->exec_mode == dbg_exec_step_into_insn)
 221     {
 222         ADDRESS64 tmp = addr;
 223         /* Show where we crashed */
 224         memory_disasm_one_insn(&tmp);
 225     }
 226     source_list_from_addr(&addr, 0);
 227
 228     return TRUE;
 229 }
 230
 231 static void dbg_exception_epilog(void)
 232 {
 233     break_restart_execution(dbg_curr_thread->exec_count);
 234     /*
 235      * This will have gotten absorbed into the breakpoint info
 236      * if it was used.  Otherwise it would have been ignored.
 237      * In any case, we don't mess with it any more.
 238      */
 239     if (dbg_curr_thread->exec_mode == dbg_exec_cont)
 240         dbg_curr_thread->exec_count = 0;
 241     dbg_curr_thread->in_exception = FALSE;
 242 }
 243
 244 static DWORD dbg_handle_exception(const EXCEPTION_RECORD* rec, BOOL first_chance)
 245 {
 246     BOOL                is_debug = FALSE;
 247     THREADNAME_INFO*    pThreadName;
 248     struct dbg_thread*  pThread;
 249
 250     assert(dbg_curr_thread);
 251
 252     WINE_TRACE("exception=%x first_chance=%c\n",
 253                rec->ExceptionCode, first_chance ? 'Y' : 'N');
 254
 255     switch (rec->ExceptionCode)
 256     {
 257     case EXCEPTION_BREAKPOINT:
 258     case EXCEPTION_SINGLE_STEP:
 259         is_debug = TRUE;
 260         break;
 261     case EXCEPTION_NAME_THREAD:
 262         pThreadName = (THREADNAME_INFO*)(rec->ExceptionInformation);
 263         if (pThreadName->dwThreadID == -1)
 264             pThread = dbg_curr_thread;
 265         else
 266             pThread = dbg_get_thread(dbg_curr_process, pThreadName->dwThreadID);
 267         if(!pThread)
 268         {
 269             dbg_printf("Thread ID=%04x not in our list of threads -> can't rename\n", pThreadName->dwThreadID);
 270             return DBG_CONTINUE;
 271         }
 272         if (dbg_read_memory(pThreadName->szName, pThread->name, 9))
 273             dbg_printf("Thread ID=%04x renamed using MS VC6 extension (name==\"%s\")\n",
 274                        pThread->tid, pThread->name);
 275         return DBG_CONTINUE;
 276     }
 277
 278     if (first_chance && !is_debug && !DBG_IVAR(BreakOnFirstChance) &&
 279         !(rec->ExceptionFlags & EH_STACK_INVALID))
 280     {
 281         /* pass exception to program except for debug exceptions */
 282         return DBG_EXCEPTION_NOT_HANDLED;
 283     }
 284
 285     if (!is_debug)
 286     {
 287         /* print some infos */
 288         dbg_printf("%s: ",
 289                    first_chance ? "First chance exception" : "Unhandled exception");
 290         switch (rec->ExceptionCode)
 291         {
 292         case EXCEPTION_INT_DIVIDE_BY_ZERO:
 293             dbg_printf("divide by zero");
 294             break;
 295         case EXCEPTION_INT_OVERFLOW:
 296             dbg_printf("overflow");
 297             break;
 298         case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
 299             dbg_printf("array bounds");
 300             break;
 301         case EXCEPTION_ILLEGAL_INSTRUCTION:
 302             dbg_printf("illegal instruction");
 303             break;
 304         case EXCEPTION_STACK_OVERFLOW:
 305             dbg_printf("stack overflow");
 306             break;
 307         case EXCEPTION_PRIV_INSTRUCTION:
 308             dbg_printf("privileged instruction");
 309             break;
 310         case EXCEPTION_ACCESS_VIOLATION:
 311             if (rec->NumberParameters == 2)
 312                 dbg_printf("page fault on %s access to 0x%08lx",
 313                            rec->ExceptionInformation[0] == EXCEPTION_WRITE_FAULT ? "write" :
 314                            rec->ExceptionInformation[0] == EXCEPTION_EXECUTE_FAULT ? "execute" : "read",
 315                            rec->ExceptionInformation[1]);
 316             else
 317                 dbg_printf("page fault");
 318             break;
 319         case EXCEPTION_DATATYPE_MISALIGNMENT:
 320             dbg_printf("Alignment");
 321             break;
 322         case DBG_CONTROL_C:
 323             dbg_printf("^C");
 324             break;
 325         case CONTROL_C_EXIT:
 326             dbg_printf("^C");
 327             break;
 328         case STATUS_POSSIBLE_DEADLOCK:
 329         {
 330             ADDRESS64       addr;
 331
 332             addr.Mode   = AddrModeFlat;
 333             addr.Offset = rec->ExceptionInformation[0];
 334
 335             dbg_printf("wait failed on critical section ");
 336             print_address(&addr, FALSE);
 337         }
 338         if (!DBG_IVAR(BreakOnCritSectTimeOut))
 339         {
 340             dbg_printf("\n");
 341             return DBG_EXCEPTION_NOT_HANDLED;
 342         }
 343         break;
 344         case EXCEPTION_WINE_STUB:
 345         {
 346             char dll[32], name[64];
 347             memory_get_string(dbg_curr_process,
 348                               (void*)rec->ExceptionInformation[0], TRUE, FALSE,
 349                               dll, sizeof(dll));
 350             if (HIWORD(rec->ExceptionInformation[1]))
 351                 memory_get_string(dbg_curr_process,
 352                                   (void*)rec->ExceptionInformation[1], TRUE, FALSE,
 353                                   name, sizeof(name));
 354             else
 355                 sprintf( name, "%ld", rec->ExceptionInformation[1] );
 356             dbg_printf("unimplemented function %s.%s called", dll, name);
 357         }
 358         break;
 359         case EXCEPTION_WINE_ASSERTION:
 360             dbg_printf("assertion failed");
 361             break;
 362         case EXCEPTION_VM86_INTx:
 363             dbg_printf("interrupt %02lx in vm86 mode", rec->ExceptionInformation[0]);
 364             break;
 365         case EXCEPTION_VM86_STI:
 366             dbg_printf("sti in vm86 mode");
 367             break;
 368         case EXCEPTION_VM86_PICRETURN:
 369             dbg_printf("PIC return in vm86 mode");
 370             break;
 371         case EXCEPTION_FLT_DENORMAL_OPERAND:
 372             dbg_printf("denormal float operand");
 373             break;
 374         case EXCEPTION_FLT_DIVIDE_BY_ZERO:
 375             dbg_printf("divide by zero");
 376             break;
 377         case EXCEPTION_FLT_INEXACT_RESULT:
 378             dbg_printf("inexact float result");
 379             break;
 380         case EXCEPTION_FLT_INVALID_OPERATION:
 381             dbg_printf("invalid float operation");
 382             break;
 383         case EXCEPTION_FLT_OVERFLOW:
 384             dbg_printf("floating point overflow");
 385             break;
 386         case EXCEPTION_FLT_UNDERFLOW:
 387             dbg_printf("floating point underflow");
 388             break;
 389         case EXCEPTION_FLT_STACK_CHECK:
 390             dbg_printf("floating point stack check");
 391             break;
 392         case CXX_EXCEPTION:
 393             if(rec->NumberParameters == 3 && rec->ExceptionInformation[0] == CXX_FRAME_MAGIC)
 394                 dbg_printf("C++ exception(object = 0x%08lx, type = 0x%08lx)",
 395                            rec->ExceptionInformation[1], rec->ExceptionInformation[2]);
 396             else
 397                 dbg_printf("C++ exception with strange parameter count %d or magic 0x%08lx",
 398                            rec->NumberParameters, rec->ExceptionInformation[0]);
 399             break;
 400         default:
 401             dbg_printf("0x%08x", rec->ExceptionCode);
 402             break;
 403         }
 404     }
 405     if( (rec->ExceptionFlags & EH_STACK_INVALID) ) {
 406         dbg_printf( ", invalid program stack" );
 407     }
 408
 409     if (dbg_exception_prolog(is_debug, first_chance, rec))
 410     {
 411         dbg_interactiveP = TRUE;
 412         return 0;
 413     }
 414     dbg_exception_epilog();
 415
 416     return DBG_CONTINUE;
 417 }
 418
 419 static BOOL tgt_process_active_close_process(struct dbg_process* pcs, BOOL kill);
 420
 421 static void fetch_module_name(void* name_addr, BOOL unicode, void* mod_addr,
 422                               WCHAR* buffer, size_t bufsz, BOOL is_pcs)
 423 {
 424     static WCHAR        pcspid[] = {'P','r','o','c','e','s','s','_','%','0','8','x',0};
 425     static WCHAR        dlladdr[] = {'D','L','L','_','%','0','8','l','x',0};
 426
 427     memory_get_string_indirect(dbg_curr_process, name_addr, unicode, buffer, bufsz);
 428     if (!buffer[0] &&
 429         !GetModuleFileNameExW(dbg_curr_process->handle, mod_addr, buffer, bufsz))
 430     {
 431         if (is_pcs)
 432         {
 433             HMODULE h;
 434             WORD (WINAPI *gpif)(HANDLE, LPWSTR, DWORD);
 435
 436             /* On Windows, when we get the process creation debug event for a process
 437              * created by winedbg, the modules' list is not initialized yet. Hence,
 438              * GetModuleFileNameExA (on the main module) will generate an error.
 439              * Psapi (starting on XP) provides GetProcessImageFileName() which should
 440              * give us the expected result
 441              */
 442             if (!(h = GetModuleHandleA("psapi")) ||
 443                 !(gpif = (void*)GetProcAddress(h, "GetProcessImageFileNameW")) ||
 444                 !(gpif)(dbg_curr_process->handle, buffer, bufsz))
 445                 snprintfW(buffer, bufsz, pcspid, dbg_curr_pid);
 446         }
 447         else
 448             snprintfW(buffer, bufsz, dlladdr, (unsigned long)mod_addr);
 449     }
 450 }
 451
 452 static unsigned dbg_handle_debug_event(DEBUG_EVENT* de)
 453 {
 454     union {
 455         char    bufferA[256];
 456         WCHAR   buffer[256];
 457     } u;
 458     DWORD       cont = DBG_CONTINUE;
 459
 460     dbg_curr_pid = de->dwProcessId;
 461     dbg_curr_tid = de->dwThreadId;
 462
 463     if ((dbg_curr_process = dbg_get_process(de->dwProcessId)) != NULL)
 464         dbg_curr_thread = dbg_get_thread(dbg_curr_process, de->dwThreadId);
 465     else
 466         dbg_curr_thread = NULL;
 467
 468     switch (de->dwDebugEventCode)
 469     {
 470     case EXCEPTION_DEBUG_EVENT:
 471         if (!dbg_curr_thread)
 472         {
 473             WINE_ERR("%04x:%04x: not a registered process or thread (perhaps a 16 bit one ?)\n",
 474                      de->dwProcessId, de->dwThreadId);
 475             break;
 476         }
 477
 478         WINE_TRACE("%04x:%04x: exception code=%08x\n",
 479                    de->dwProcessId, de->dwThreadId,
 480                    de->u.Exception.ExceptionRecord.ExceptionCode);
 481
 482         if (dbg_curr_process->continue_on_first_exception)
 483         {
 484             dbg_curr_process->continue_on_first_exception = FALSE;
 485             if (!DBG_IVAR(BreakOnAttach)) break;
 486         }
 487         if (dbg_fetch_context())
 488         {
 489             cont = dbg_handle_exception(&de->u.Exception.ExceptionRecord,
 490                                         de->u.Exception.dwFirstChance);
 491             if (cont && dbg_curr_thread)
 492             {
 493                 SetThreadContext(dbg_curr_thread->handle, &dbg_context);
 494             }
 495         }
 496         break;
 497
 498     case CREATE_PROCESS_DEBUG_EVENT:
 499         dbg_curr_process = dbg_add_process(&be_process_active_io, de->dwProcessId,
 500                                            de->u.CreateProcessInfo.hProcess);
 501         if (dbg_curr_process == NULL)
 502         {
 503             WINE_ERR("Couldn't create process\n");
 504             break;
 505         }
 506         fetch_module_name(de->u.CreateProcessInfo.lpImageName,
 507                           de->u.CreateProcessInfo.fUnicode,
 508                           de->u.CreateProcessInfo.lpBaseOfImage,
 509                           u.buffer, sizeof(u.buffer) / sizeof(WCHAR), TRUE);
 510
 511         WINE_TRACE("%04x:%04x: create process '%s'/%p @%p (%u<%u>)\n",
 512                    de->dwProcessId, de->dwThreadId,
 513                    wine_dbgstr_w(u.buffer),
 514                    de->u.CreateProcessInfo.lpImageName,
 515                    de->u.CreateProcessInfo.lpStartAddress,
 516                    de->u.CreateProcessInfo.dwDebugInfoFileOffset,
 517                    de->u.CreateProcessInfo.nDebugInfoSize);
 518         dbg_set_process_name(dbg_curr_process, u.buffer);
 519
 520         if (!dbg_init(dbg_curr_process->handle, u.buffer, FALSE))
 521             dbg_printf("Couldn't initiate DbgHelp\n");
 522         if (!dbg_load_module(dbg_curr_process->handle, de->u.CreateProcessInfo.hFile, u.buffer,
 523                              (DWORD_PTR)de->u.CreateProcessInfo.lpBaseOfImage, 0))
 524             dbg_printf("couldn't load main module (%u)\n", GetLastError());
 525
 526         WINE_TRACE("%04x:%04x: create thread I @%p\n",
 527                    de->dwProcessId, de->dwThreadId, de->u.CreateProcessInfo.lpStartAddress);
 528
 529         dbg_curr_thread = dbg_add_thread(dbg_curr_process,
 530                                          de->dwThreadId,
 531                                          de->u.CreateProcessInfo.hThread,
 532                                          de->u.CreateProcessInfo.lpThreadLocalBase);
 533         if (!dbg_curr_thread)
 534         {
 535             WINE_ERR("Couldn't create thread\n");
 536             break;
 537         }
 538         dbg_init_current_process();
 539         dbg_init_current_thread(de->u.CreateProcessInfo.lpStartAddress);
 540         break;
 541
 542     case EXIT_PROCESS_DEBUG_EVENT:
 543         WINE_TRACE("%04x:%04x: exit process (%d)\n",
 544                    de->dwProcessId, de->dwThreadId, de->u.ExitProcess.dwExitCode);
 545
 546         if (dbg_curr_process == NULL)
 547         {
 548             WINE_ERR("Unknown process\n");
 549             break;
 550         }
 551         tgt_process_active_close_process(dbg_curr_process, FALSE);
 552         dbg_printf("Process of pid=%04x has terminated\n", de->dwProcessId);
 553         break;
 554
 555     case CREATE_THREAD_DEBUG_EVENT:
 556         WINE_TRACE("%04x:%04x: create thread D @%p\n",
 557                    de->dwProcessId, de->dwThreadId, de->u.CreateThread.lpStartAddress);
 558
 559         if (dbg_curr_process == NULL)
 560         {
 561             WINE_ERR("Unknown process\n");
 562             break;
 563         }
 564         if (dbg_get_thread(dbg_curr_process, de->dwThreadId) != NULL)
 565         {
 566             WINE_TRACE("Thread already listed, skipping\n");
 567             break;
 568         }
 569
 570         dbg_curr_thread = dbg_add_thread(dbg_curr_process,
 571                                          de->dwThreadId,
 572                                          de->u.CreateThread.hThread,
 573                                          de->u.CreateThread.lpThreadLocalBase);
 574         if (!dbg_curr_thread)
 575         {
 576             WINE_ERR("Couldn't create thread\n");
 577             break;
 578         }
 579         dbg_init_current_thread(de->u.CreateThread.lpStartAddress);
 580         break;
 581
 582     case EXIT_THREAD_DEBUG_EVENT:
 583         WINE_TRACE("%04x:%04x: exit thread (%d)\n",
 584                    de->dwProcessId, de->dwThreadId, de->u.ExitThread.dwExitCode);
 585
 586         if (dbg_curr_thread == NULL)
 587         {
 588             WINE_ERR("Unknown thread\n");
 589             break;
 590         }
 591         /* FIXME: remove break point set on thread startup */
 592         dbg_del_thread(dbg_curr_thread);
 593         break;
 594
 595     case LOAD_DLL_DEBUG_EVENT:
 596         if (dbg_curr_thread == NULL)
 597         {
 598             WINE_ERR("Unknown thread\n");
 599             break;
 600         }
 601         fetch_module_name(de->u.LoadDll.lpImageName,
 602                           de->u.LoadDll.fUnicode,
 603                           de->u.LoadDll.lpBaseOfDll,
 604                           u.buffer, sizeof(u.buffer) / sizeof(WCHAR), FALSE);
 605
 606         WINE_TRACE("%04x:%04x: loads DLL %s @%p (%u<%u>)\n",
 607                    de->dwProcessId, de->dwThreadId,
 608                    wine_dbgstr_w(u.buffer), de->u.LoadDll.lpBaseOfDll,
 609                    de->u.LoadDll.dwDebugInfoFileOffset,
 610                    de->u.LoadDll.nDebugInfoSize);
 611         dbg_load_module(dbg_curr_process->handle, de->u.LoadDll.hFile, u.buffer,
 612                         (DWORD_PTR)de->u.LoadDll.lpBaseOfDll, 0);
 613         break_set_xpoints(FALSE);
 614         break_check_delayed_bp();
 615         break_set_xpoints(TRUE);
 616         if (DBG_IVAR(BreakOnDllLoad))
 617         {
 618             dbg_printf("Stopping on DLL %s loading at 0x%08lx\n",
 619                        dbg_W2A(u.buffer, -1), (unsigned long)de->u.LoadDll.lpBaseOfDll);
 620             if (dbg_fetch_context()) cont = 0;
 621         }
 622         break;
 623
 624     case UNLOAD_DLL_DEBUG_EVENT:
 625         WINE_TRACE("%04x:%04x: unload DLL @%p\n",
 626                    de->dwProcessId, de->dwThreadId,
 627                    de->u.UnloadDll.lpBaseOfDll);
 628         break_delete_xpoints_from_module((unsigned long)de->u.UnloadDll.lpBaseOfDll);
 629         SymUnloadModule(dbg_curr_process->handle,
 630                         (unsigned long)de->u.UnloadDll.lpBaseOfDll);
 631         break;
 632
 633     case OUTPUT_DEBUG_STRING_EVENT:
 634         if (dbg_curr_thread == NULL)
 635         {
 636             WINE_ERR("Unknown thread\n");
 637             break;
 638         }
 639
 640         memory_get_string(dbg_curr_process,
 641                           de->u.DebugString.lpDebugStringData, TRUE,
 642                           de->u.DebugString.fUnicode, u.bufferA, sizeof(u.bufferA));
 643         WINE_TRACE("%04x:%04x: output debug string (%s)\n",
 644                    de->dwProcessId, de->dwThreadId, u.bufferA);
 645         break;
 646
 647     case RIP_EVENT:
 648         WINE_TRACE("%04x:%04x: rip error=%u type=%u\n",
 649                    de->dwProcessId, de->dwThreadId, de->u.RipInfo.dwError,
 650                    de->u.RipInfo.dwType);
 651         break;
 652
 653     default:
 654         WINE_TRACE("%04x:%04x: unknown event (%x)\n",
 655                    de->dwProcessId, de->dwThreadId, de->dwDebugEventCode);
 656     }
 657     if (!cont) return TRUE;  /* stop execution */
 658     ContinueDebugEvent(de->dwProcessId, de->dwThreadId, cont);
 659     return FALSE;  /* continue execution */
 660 }
 661
 662 static void dbg_resume_debuggee(DWORD cont)
 663 {
 664     if (dbg_curr_thread->in_exception)
 665     {
 666         ADDRESS64       addr;
 667         char            hexbuf[MAX_OFFSET_TO_STR_LEN];
 668
 669         dbg_exception_epilog();
 670         memory_get_current_pc(&addr);
 671         WINE_TRACE("Exiting debugger      PC=%s mode=%d count=%d\n",
 672                    memory_offset_to_string(hexbuf, addr.Offset, 0),
 673                    dbg_curr_thread->exec_mode,
 674                    dbg_curr_thread->exec_count);
 675         if (dbg_curr_thread)
 676         {
 677             if (!SetThreadContext(dbg_curr_thread->handle, &dbg_context))
 678                 dbg_printf("Cannot set ctx on %04x\n", dbg_curr_tid);
 679         }
 680     }
 681     dbg_interactiveP = FALSE;
 682     if (!ContinueDebugEvent(dbg_curr_pid, dbg_curr_tid, cont))
 683         dbg_printf("Cannot continue on %04x (%08x)\n", dbg_curr_tid, cont);
 684 }
 685
 686 static void wait_exception(void)
 687 {
 688     DEBUG_EVENT         de;
 689
 690     while (dbg_num_processes() && WaitForDebugEvent(&de, INFINITE))
 691     {
 692         if (dbg_handle_debug_event(&de)) break;
 693     }
 694     dbg_interactiveP = TRUE;
 695 }
 696
 697 void dbg_wait_next_exception(DWORD cont, int count, int mode)
 698 {
 699     ADDRESS64           addr;
 700     char                hexbuf[MAX_OFFSET_TO_STR_LEN];
 701
 702     if (cont == DBG_CONTINUE)
 703     {
 704         dbg_curr_thread->exec_count = count;
 705         dbg_curr_thread->exec_mode = mode;
 706     }
 707     dbg_resume_debuggee(cont);
 708
 709     wait_exception();
 710     if (!dbg_curr_process) return;
 711
 712     memory_get_current_pc(&addr);
 713     WINE_TRACE("Entering debugger     PC=%s mode=%d count=%d\n",
 714                memory_offset_to_string(hexbuf, addr.Offset, 0),
 715                dbg_curr_thread->exec_mode,
 716                dbg_curr_thread->exec_count);
 717 }
 718
 719 void     dbg_active_wait_for_first_exception(void)
 720 {
 721     dbg_interactiveP = FALSE;
 722     /* wait for first exception */
 723     wait_exception();
 724 }
 725
 726 static  unsigned dbg_start_debuggee(LPSTR cmdLine)
 727 {
 728     PROCESS_INFORMATION info;
 729     STARTUPINFOA        startup, current;
 730     DWORD               flags;
 731
 732     GetStartupInfoA(&current);
 733
 734     memset(&startup, 0, sizeof(startup));
 735     startup.cb = sizeof(startup);
 736     startup.dwFlags = STARTF_USESHOWWINDOW;
 737
 738     startup.wShowWindow = (current.dwFlags & STARTF_USESHOWWINDOW) ?
 739         current.wShowWindow : SW_SHOWNORMAL;
 740
 741     /* FIXME: shouldn't need the CREATE_NEW_CONSOLE, but as usual CUI:s need it
 742      * while GUI:s don't
 743      */
 744     flags = DEBUG_PROCESS | CREATE_NEW_CONSOLE;
 745     if (!DBG_IVAR(AlsoDebugProcChild)) flags |= DEBUG_ONLY_THIS_PROCESS;
 746
 747     if (!CreateProcess(NULL, cmdLine, NULL, NULL, FALSE, flags,
 748                        NULL, NULL, &startup, &info))
 749     {
 750         dbg_printf("Couldn't start process '%s'\n", cmdLine);
 751         return FALSE;
 752     }
 753     if (!info.dwProcessId)
 754     {
 755         /* this happens when the program being run is not a Wine binary
 756          * (for example, a shell wrapper around a WineLib app)
 757          */
 758         /* Current fix: list running processes and let the user attach
 759          * to one of them (sic)
 760          * FIXME: implement a real fix => grab the process (from the
 761          * running processes) from its name
 762          */
 763         dbg_printf("Debuggee has been started (%s)\n"
 764                    "But WineDbg isn't attached to it. Maybe you're trying to debug a winelib wrapper ??\n"
 765                    "Try to attach to one of those processes:\n", cmdLine);
 766         /* FIXME: (HACK) we need some time before the wrapper executes the winelib app */
 767         Sleep(100);
 768         info_win32_processes();
 769         return TRUE;
 770     }
 771     dbg_curr_pid = info.dwProcessId;
 772     if (!(dbg_curr_process = dbg_add_process(&be_process_active_io, dbg_curr_pid, 0))) return FALSE;
 773     dbg_curr_process->active_debuggee = TRUE;
 774
 775     return TRUE;
 776 }
 777
 778 void    dbg_run_debuggee(const char* args)
 779 {
 780     if (args)
 781     {
 782         WINE_FIXME("Re-running current program with %s as args is broken\n", args);
 783         return;
 784     }
 785     else
 786     {
 787         if (!dbg_last_cmd_line)
 788         {
 789             dbg_printf("Cannot find previously used command line.\n");
 790             return;
 791         }
 792         dbg_start_debuggee(dbg_last_cmd_line);
 793         dbg_active_wait_for_first_exception();
 794         source_list_from_addr(NULL, 0);
 795     }
 796 }
 797
 798 static BOOL     str2int(const char* str, DWORD* val)
 799 {
 800     char*   ptr;
 801
 802     *val = strtol(str, &ptr, 10);
 803     return str < ptr && !*ptr;
 804 }
 805
 806
 807 /******************************************************************
 808  *              dbg_active_attach
 809  *
 810  * Tries to attach to a running process
 811  * Handles the <pid> or <pid> <evt> forms
 812  */
 813 enum dbg_start  dbg_active_attach(int argc, char* argv[])
 814 {
 815     DWORD       pid, evt;
 816
 817     /* try the form <myself> pid */
 818     if (argc == 1 && str2int(argv[0], &pid) && pid != 0)
 819     {
 820         if (!dbg_attach_debuggee(pid, FALSE))
 821             return start_error_init;
 822     }
 823     /* try the form <myself> pid evt (Win32 JIT debugger) */
 824     else if (argc == 2 && str2int(argv[0], &pid) && pid != 0 &&
 825              str2int(argv[1], &evt) && evt != 0)
 826     {
 827         if (!dbg_attach_debuggee(pid, TRUE))
 828         {
 829             /* don't care about result */
 830             SetEvent((HANDLE)evt);
 831             return start_error_init;
 832         }
 833         if (!SetEvent((HANDLE)evt))
 834         {
 835             WINE_ERR("Invalid event handle: %x\n", evt);
 836             return start_error_init;
 837         }
 838         CloseHandle((HANDLE)evt);
 839     }
 840     else return start_error_parse;
 841
 842     dbg_curr_pid = pid;
 843     return start_ok;
 844 }
 845
 846 /******************************************************************
 847  *              dbg_active_launch
 848  *
 849  * Launches a debuggee (with its arguments) from argc/argv
 850  */
 851 enum dbg_start    dbg_active_launch(int argc, char* argv[])
 852 {
 853     int         i, len;
 854     LPSTR       cmd_line;
 855
 856     if (argc == 0) return start_error_parse;
 857
 858     if (!(cmd_line = HeapAlloc(GetProcessHeap(), 0, len = 1)))
 859     {
 860     oom_leave:
 861         dbg_printf("Out of memory\n");
 862         return start_error_init;
 863     }
 864     cmd_line[0] = '\0';
 865
 866     for (i = 0; i < argc; i++)
 867     {
 868         len += strlen(argv[i]) + 1;
 869         if (!(cmd_line = HeapReAlloc(GetProcessHeap(), 0, cmd_line, len)))
 870             goto oom_leave;
 871         strcat(cmd_line, argv[i]);
 872         cmd_line[len - 2] = ' ';
 873         cmd_line[len - 1] = '\0';
 874     }
 875
 876     if (!dbg_start_debuggee(cmd_line))
 877     {
 878         HeapFree(GetProcessHeap(), 0, cmd_line);
 879         return start_error_init;
 880     }
 881     HeapFree(GetProcessHeap(), 0, dbg_last_cmd_line);
 882     dbg_last_cmd_line = cmd_line;
 883     return start_ok;
 884 }
 885
 886 /******************************************************************
 887  *              dbg_active_auto
 888  *
 889  * Starts (<pid> or <pid> <evt>) in automatic mode
 890  */
 891 enum dbg_start dbg_active_auto(int argc, char* argv[])
 892 {
 893     HANDLE              hFile;
 894     enum dbg_start      ds = start_error_parse;
 895
 896     if (!strcmp(argv[0], "--auto"))
 897     {
 898         /* auto mode */
 899         argc--; argv++;
 900         ds = dbg_active_attach(argc, argv);
 901         if (ds != start_ok) return ds;
 902         hFile = parser_generate_command_file("echo Modules:", "info share",
 903                                              "echo Threads:", "info threads",
 904                                              "backtrace", "detach", NULL);
 905     }
 906     else if (!strcmp(argv[0], "--minidump"))
 907     {
 908         const char*     file = NULL;
 909         char            tmp[8 + 1 + MAX_PATH]; /* minidump <file> */
 910
 911         argc--; argv++;
 912         /* hard stuff now ; we can get things like:
 913          * --minidump <pid>                     1 arg
 914          * --minidump <pid> <evt>               2 args
 915          * --minidump <file> <pid>              2 args
 916          * --minidump <file> <pid> <evt>        3 args
 917          */
 918         switch (argc)
 919         {
 920         case 1:
 921             ds = dbg_active_attach(argc, argv);
 922             break;
 923         case 2:
 924             if ((ds = dbg_active_attach(argc, argv)) != start_ok)
 925             {
 926                 file = argv[0];
 927                 ds = dbg_active_attach(argc - 1, argv + 1);
 928             }
 929             break;
 930         case 3:
 931             file = argv[0];
 932             ds = dbg_active_attach(argc - 1, argv + 1);
 933             break;
 934         default:
 935             return start_error_parse;
 936         }
 937         if (ds != start_ok) return ds;
 938         memcpy(tmp, "minidump \"", 10);
 939         if (!file)
 940         {
 941             char        path[MAX_PATH];
 942
 943             GetTempPath(sizeof(path), path);
 944             GetTempFileName(path, "WD", 0, tmp + 10);
 945         }
 946         else strcpy(tmp + 10, file);
 947         strcat(tmp, "\"");
 948         if (!file)
 949         {
 950             /* FIXME: should generate unix name as well */
 951             dbg_printf("Capturing program state in %s\n", tmp + 9);
 952         }
 953         hFile = parser_generate_command_file(tmp, "detach", NULL);
 954     }
 955     else return start_error_parse;
 956     if (hFile == INVALID_HANDLE_VALUE) return start_error_parse;
 957
 958     if (dbg_curr_process->active_debuggee)
 959         dbg_active_wait_for_first_exception();
 960
 961     dbg_interactiveP = TRUE;
 962     parser_handle(hFile);
 963
 964     return start_ok;
 965 }
 966
 967 static BOOL tgt_process_active_close_process(struct dbg_process* pcs, BOOL kill)
 968 {
 969     if (pcs == dbg_curr_process)
 970     {
 971         /* remove all set breakpoints in debuggee code */
 972         break_set_xpoints(FALSE);
 973         /* needed for single stepping (ugly).
 974          * should this be handled inside the server ???
 975          */
 976         be_cpu->single_step(&dbg_context, FALSE);
 977         if (dbg_curr_thread->in_exception)
 978         {
 979             SetThreadContext(dbg_curr_thread->handle, &dbg_context);
 980             ContinueDebugEvent(dbg_curr_pid, dbg_curr_tid, DBG_CONTINUE);
 981         }
 982     }
 983     if (kill)
 984     {
 985         TerminateProcess(pcs->handle, 0);
 986     }
 987     else
 988     {
 989         if (!DebugActiveProcessStop(pcs->pid)) return FALSE;
 990     }
 991     SymCleanup(pcs->handle);
 992     dbg_del_process(pcs);
 993
 994     return TRUE;
 995 }
 996
 997 static struct be_process_io be_process_active_io =
 998 {
 999     tgt_process_active_close_process,
1000     ReadProcessMemory,
1001     WriteProcessMemory,
1002     GetThreadSelectorEntry,
1003 };