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