2 * Wine debugger - back-end for an active target
4 * Copyright 2000-2006 Eric Pouech
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.
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.
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
32 #include "wine/debug.h"
33 #include "wine/exception.h"
34 #include "wine/unicode.h"
36 WINE_DEFAULT_DEBUG_CHANNEL(winedbg
);
38 static char* dbg_last_cmd_line
;
39 static struct be_process_io be_process_active_io
;
41 static void dbg_init_current_process(void)
45 static void dbg_init_current_thread(void* start
)
49 if (list_count(&dbg_curr_process
->threads
) == 1 /* first thread ? */ &&
50 DBG_IVAR(BreakAllThreadsStartup
))
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
);
63 static unsigned dbg_handle_debug_event(DEBUG_EVENT
* de
);
65 /******************************************************************
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)
74 BOOL
dbg_attach_debuggee(DWORD pid
, BOOL cofe
)
76 if (!(dbg_curr_process
= dbg_add_process(&be_process_active_io
, pid
, 0))) return FALSE
;
78 if (!DebugActiveProcess(pid
))
80 dbg_printf("Can't attach process %04x: error %u\n", pid
, GetLastError());
81 dbg_del_process(dbg_curr_process
);
84 dbg_curr_process
->continue_on_first_exception
= cofe
;
86 SetEnvironmentVariableA("DBGHELP_NOLIVE", NULL
);
88 dbg_curr_process
->active_debuggee
= TRUE
;
92 static unsigned dbg_fetch_context(void)
94 if (!dbg_curr_process
->be_cpu
->get_context(dbg_curr_thread
->handle
, &dbg_context
))
96 WINE_WARN("Can't get thread's context\n");
102 /***********************************************************************
103 * dbg_exception_prolog
105 * Examine exception and decide if interactive mode is entered(return TRUE)
106 * or exception is silently continued(return FALSE)
107 * is_debug means the exception is a breakpoint or single step exception
109 static BOOL
dbg_exception_prolog(BOOL is_debug
, const EXCEPTION_RECORD
* rec
)
114 memory_get_current_pc(&addr
);
115 break_suspend_execution();
117 /* this will resynchronize builtin dbghelp's internal ELF module list */
118 SymLoadModule(dbg_curr_process
->handle
, 0, 0, 0, 0, 0);
120 if (is_debug
) break_adjust_pc(&addr
, rec
->ExceptionCode
, dbg_curr_thread
->first_chance
, &is_break
);
122 * Do a quiet backtrace so that we have an idea of what the situation
123 * is WRT the source files.
125 stack_fetch_frames(&dbg_context
);
127 if (is_debug
&& !is_break
&& break_should_continue(&addr
, rec
->ExceptionCode
))
130 if (addr
.Mode
!= dbg_curr_thread
->addr_mode
)
132 const char* name
= NULL
;
136 case AddrMode1616
: name
= "16 bit"; break;
137 case AddrMode1632
: name
= "segmented 32 bit"; break;
138 case AddrModeReal
: name
= "vm86"; break;
139 case AddrModeFlat
: name
= dbg_curr_process
->be_cpu
->pointer_size
== 4
140 ? "32 bit" : "64 bit"; break;
142 dbg_printf("In %s mode.\n", name
);
143 dbg_curr_thread
->addr_mode
= addr
.Mode
;
149 /* This is a real crash, dump some info */
150 dbg_curr_process
->be_cpu
->print_context(dbg_curr_thread
->handle
, &dbg_context
, 0);
152 dbg_curr_process
->be_cpu
->print_segment_info(dbg_curr_thread
->handle
, &dbg_context
);
153 stack_backtrace(dbg_curr_tid
);
157 static char* last_name
;
158 static char* last_file
;
160 char buffer
[sizeof(SYMBOL_INFO
) + 256];
161 SYMBOL_INFO
* si
= (SYMBOL_INFO
*)buffer
;
162 void* lin
= memory_to_linear_addr(&addr
);
167 si
->SizeOfStruct
= sizeof(*si
);
168 si
->MaxNameLen
= 256;
169 il
.SizeOfStruct
= sizeof(il
);
170 if (SymFromAddr(dbg_curr_process
->handle
, (DWORD_PTR
)lin
, &disp64
, si
) &&
171 SymGetLineFromAddr64(dbg_curr_process
->handle
, (DWORD_PTR
)lin
, &disp
, &il
))
173 if ((!last_name
|| strcmp(last_name
, si
->Name
)) ||
174 (!last_file
|| strcmp(last_file
, il
.FileName
)))
176 HeapFree(GetProcessHeap(), 0, last_name
);
177 HeapFree(GetProcessHeap(), 0, last_file
);
178 last_name
= strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(si
->Name
) + 1), si
->Name
);
179 last_file
= strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(il
.FileName
) + 1), il
.FileName
);
180 dbg_printf("%s () at %s:%u\n", last_name
, last_file
, il
.LineNumber
);
184 if (!is_debug
|| is_break
||
185 dbg_curr_thread
->exec_mode
== dbg_exec_step_over_insn
||
186 dbg_curr_thread
->exec_mode
== dbg_exec_step_into_insn
)
188 ADDRESS64 tmp
= addr
;
189 /* Show where we crashed */
190 memory_disasm_one_insn(&tmp
);
192 source_list_from_addr(&addr
, 0);
197 static void dbg_exception_epilog(void)
199 break_restart_execution(dbg_curr_thread
->exec_count
);
201 * This will have gotten absorbed into the breakpoint info
202 * if it was used. Otherwise it would have been ignored.
203 * In any case, we don't mess with it any more.
205 if (dbg_curr_thread
->exec_mode
== dbg_exec_cont
)
206 dbg_curr_thread
->exec_count
= 0;
207 dbg_curr_thread
->in_exception
= FALSE
;
210 static DWORD
dbg_handle_exception(const EXCEPTION_RECORD
* rec
, BOOL first_chance
)
212 BOOL is_debug
= FALSE
;
213 const THREADNAME_INFO
* pThreadName
;
214 struct dbg_thread
* pThread
;
216 assert(dbg_curr_thread
);
218 WINE_TRACE("exception=%x first_chance=%c\n",
219 rec
->ExceptionCode
, first_chance
? 'Y' : 'N');
221 switch (rec
->ExceptionCode
)
223 case EXCEPTION_BREAKPOINT
:
224 case EXCEPTION_SINGLE_STEP
:
227 case EXCEPTION_NAME_THREAD
:
228 pThreadName
= (const THREADNAME_INFO
*)(rec
->ExceptionInformation
);
229 if (pThreadName
->dwThreadID
== -1)
230 pThread
= dbg_curr_thread
;
232 pThread
= dbg_get_thread(dbg_curr_process
, pThreadName
->dwThreadID
);
235 dbg_printf("Thread ID=%04x not in our list of threads -> can't rename\n", pThreadName
->dwThreadID
);
238 if (dbg_read_memory(pThreadName
->szName
, pThread
->name
, 9))
239 dbg_printf("Thread ID=%04x renamed using MS VC6 extension (name==\"%.9s\")\n",
240 pThread
->tid
, pThread
->name
);
244 if (first_chance
&& !is_debug
&& !DBG_IVAR(BreakOnFirstChance
) &&
245 !(rec
->ExceptionFlags
& EH_STACK_INVALID
))
247 /* pass exception to program except for debug exceptions */
248 return DBG_EXCEPTION_NOT_HANDLED
;
251 dbg_curr_thread
->excpt_record
= *rec
;
252 dbg_curr_thread
->in_exception
= TRUE
;
253 dbg_curr_thread
->first_chance
= first_chance
;
255 if (!is_debug
) info_win32_exception();
257 if (rec
->ExceptionCode
== STATUS_POSSIBLE_DEADLOCK
&& !DBG_IVAR(BreakOnCritSectTimeOut
))
259 dbg_curr_thread
->in_exception
= FALSE
;
260 return DBG_EXCEPTION_NOT_HANDLED
;
263 if (dbg_exception_prolog(is_debug
, rec
))
265 dbg_interactiveP
= TRUE
;
268 dbg_exception_epilog();
273 static BOOL
tgt_process_active_close_process(struct dbg_process
* pcs
, BOOL kill
);
275 static void fetch_module_name(void* name_addr
, BOOL unicode
, void* mod_addr
,
276 WCHAR
* buffer
, size_t bufsz
, BOOL is_pcs
)
278 static const WCHAR pcspid
[] = {'P','r','o','c','e','s','s','_','%','0','8','x',0};
279 static const WCHAR dlladdr
[] = {'D','L','L','_','%','0','8','l','x',0};
281 memory_get_string_indirect(dbg_curr_process
, name_addr
, unicode
, buffer
, bufsz
);
283 !GetModuleFileNameExW(dbg_curr_process
->handle
, mod_addr
, buffer
, bufsz
))
288 WORD (WINAPI
*gpif
)(HANDLE
, LPWSTR
, DWORD
);
290 /* On Windows, when we get the process creation debug event for a process
291 * created by winedbg, the modules' list is not initialized yet. Hence,
292 * GetModuleFileNameExA (on the main module) will generate an error.
293 * Psapi (starting on XP) provides GetProcessImageFileName() which should
294 * give us the expected result
296 if (!(h
= GetModuleHandleA("psapi")) ||
297 !(gpif
= (void*)GetProcAddress(h
, "GetProcessImageFileNameW")) ||
298 !(gpif
)(dbg_curr_process
->handle
, buffer
, bufsz
))
299 snprintfW(buffer
, bufsz
, pcspid
, dbg_curr_pid
);
302 snprintfW(buffer
, bufsz
, dlladdr
, (unsigned long)mod_addr
);
306 static unsigned dbg_handle_debug_event(DEBUG_EVENT
* de
)
312 DWORD cont
= DBG_CONTINUE
;
314 dbg_curr_pid
= de
->dwProcessId
;
315 dbg_curr_tid
= de
->dwThreadId
;
317 if ((dbg_curr_process
= dbg_get_process(de
->dwProcessId
)) != NULL
)
318 dbg_curr_thread
= dbg_get_thread(dbg_curr_process
, de
->dwThreadId
);
320 dbg_curr_thread
= NULL
;
322 switch (de
->dwDebugEventCode
)
324 case EXCEPTION_DEBUG_EVENT
:
325 if (!dbg_curr_thread
)
327 WINE_ERR("%04x:%04x: not a registered process or thread (perhaps a 16 bit one ?)\n",
328 de
->dwProcessId
, de
->dwThreadId
);
332 WINE_TRACE("%04x:%04x: exception code=%08x\n",
333 de
->dwProcessId
, de
->dwThreadId
,
334 de
->u
.Exception
.ExceptionRecord
.ExceptionCode
);
336 if (dbg_curr_process
->continue_on_first_exception
)
338 dbg_curr_process
->continue_on_first_exception
= FALSE
;
339 if (!DBG_IVAR(BreakOnAttach
)) break;
341 if (dbg_fetch_context())
343 cont
= dbg_handle_exception(&de
->u
.Exception
.ExceptionRecord
,
344 de
->u
.Exception
.dwFirstChance
);
345 if (cont
&& dbg_curr_thread
)
347 dbg_curr_process
->be_cpu
->set_context(dbg_curr_thread
->handle
, &dbg_context
);
352 case CREATE_PROCESS_DEBUG_EVENT
:
353 dbg_curr_process
= dbg_add_process(&be_process_active_io
, de
->dwProcessId
,
354 de
->u
.CreateProcessInfo
.hProcess
);
355 if (dbg_curr_process
== NULL
)
357 WINE_ERR("Couldn't create process\n");
360 fetch_module_name(de
->u
.CreateProcessInfo
.lpImageName
,
361 de
->u
.CreateProcessInfo
.fUnicode
,
362 de
->u
.CreateProcessInfo
.lpBaseOfImage
,
363 u
.buffer
, ARRAY_SIZE(u
.buffer
), TRUE
);
365 WINE_TRACE("%04x:%04x: create process '%s'/%p @%p (%u<%u>)\n",
366 de
->dwProcessId
, de
->dwThreadId
,
367 wine_dbgstr_w(u
.buffer
),
368 de
->u
.CreateProcessInfo
.lpImageName
,
369 de
->u
.CreateProcessInfo
.lpStartAddress
,
370 de
->u
.CreateProcessInfo
.dwDebugInfoFileOffset
,
371 de
->u
.CreateProcessInfo
.nDebugInfoSize
);
372 dbg_set_process_name(dbg_curr_process
, u
.buffer
);
374 if (!dbg_init(dbg_curr_process
->handle
, u
.buffer
, FALSE
))
375 dbg_printf("Couldn't initiate DbgHelp\n");
376 if (!dbg_load_module(dbg_curr_process
->handle
, de
->u
.CreateProcessInfo
.hFile
, u
.buffer
,
377 (DWORD_PTR
)de
->u
.CreateProcessInfo
.lpBaseOfImage
, 0))
378 dbg_printf("couldn't load main module (%u)\n", GetLastError());
380 WINE_TRACE("%04x:%04x: create thread I @%p\n",
381 de
->dwProcessId
, de
->dwThreadId
, de
->u
.CreateProcessInfo
.lpStartAddress
);
383 dbg_curr_thread
= dbg_add_thread(dbg_curr_process
,
385 de
->u
.CreateProcessInfo
.hThread
,
386 de
->u
.CreateProcessInfo
.lpThreadLocalBase
);
387 if (!dbg_curr_thread
)
389 WINE_ERR("Couldn't create thread\n");
392 dbg_init_current_process();
393 dbg_init_current_thread(de
->u
.CreateProcessInfo
.lpStartAddress
);
396 case EXIT_PROCESS_DEBUG_EVENT
:
397 WINE_TRACE("%04x:%04x: exit process (%d)\n",
398 de
->dwProcessId
, de
->dwThreadId
, de
->u
.ExitProcess
.dwExitCode
);
400 if (dbg_curr_process
== NULL
)
402 WINE_ERR("Unknown process\n");
405 tgt_process_active_close_process(dbg_curr_process
, FALSE
);
406 dbg_printf("Process of pid=%04x has terminated\n", de
->dwProcessId
);
409 case CREATE_THREAD_DEBUG_EVENT
:
410 WINE_TRACE("%04x:%04x: create thread D @%p\n",
411 de
->dwProcessId
, de
->dwThreadId
, de
->u
.CreateThread
.lpStartAddress
);
413 if (dbg_curr_process
== NULL
)
415 WINE_ERR("Unknown process\n");
418 if (dbg_get_thread(dbg_curr_process
, de
->dwThreadId
) != NULL
)
420 WINE_TRACE("Thread already listed, skipping\n");
424 dbg_curr_thread
= dbg_add_thread(dbg_curr_process
,
426 de
->u
.CreateThread
.hThread
,
427 de
->u
.CreateThread
.lpThreadLocalBase
);
428 if (!dbg_curr_thread
)
430 WINE_ERR("Couldn't create thread\n");
433 dbg_init_current_thread(de
->u
.CreateThread
.lpStartAddress
);
436 case EXIT_THREAD_DEBUG_EVENT
:
437 WINE_TRACE("%04x:%04x: exit thread (%d)\n",
438 de
->dwProcessId
, de
->dwThreadId
, de
->u
.ExitThread
.dwExitCode
);
440 if (dbg_curr_thread
== NULL
)
442 WINE_ERR("Unknown thread\n");
445 /* FIXME: remove break point set on thread startup */
446 dbg_del_thread(dbg_curr_thread
);
449 case LOAD_DLL_DEBUG_EVENT
:
450 if (dbg_curr_thread
== NULL
)
452 WINE_ERR("Unknown thread\n");
455 fetch_module_name(de
->u
.LoadDll
.lpImageName
,
456 de
->u
.LoadDll
.fUnicode
,
457 de
->u
.LoadDll
.lpBaseOfDll
,
458 u
.buffer
, ARRAY_SIZE(u
.buffer
), FALSE
);
460 WINE_TRACE("%04x:%04x: loads DLL %s @%p (%u<%u>)\n",
461 de
->dwProcessId
, de
->dwThreadId
,
462 wine_dbgstr_w(u
.buffer
), de
->u
.LoadDll
.lpBaseOfDll
,
463 de
->u
.LoadDll
.dwDebugInfoFileOffset
,
464 de
->u
.LoadDll
.nDebugInfoSize
);
465 dbg_load_module(dbg_curr_process
->handle
, de
->u
.LoadDll
.hFile
, u
.buffer
,
466 (DWORD_PTR
)de
->u
.LoadDll
.lpBaseOfDll
, 0);
467 break_set_xpoints(FALSE
);
468 break_check_delayed_bp();
469 break_set_xpoints(TRUE
);
470 if (DBG_IVAR(BreakOnDllLoad
))
472 dbg_printf("Stopping on DLL %s loading at %p\n",
473 dbg_W2A(u
.buffer
, -1), de
->u
.LoadDll
.lpBaseOfDll
);
474 if (dbg_fetch_context()) cont
= 0;
478 case UNLOAD_DLL_DEBUG_EVENT
:
479 WINE_TRACE("%04x:%04x: unload DLL @%p\n",
480 de
->dwProcessId
, de
->dwThreadId
,
481 de
->u
.UnloadDll
.lpBaseOfDll
);
482 break_delete_xpoints_from_module((DWORD_PTR
)de
->u
.UnloadDll
.lpBaseOfDll
);
483 SymUnloadModule64(dbg_curr_process
->handle
, (DWORD_PTR
)de
->u
.UnloadDll
.lpBaseOfDll
);
486 case OUTPUT_DEBUG_STRING_EVENT
:
487 if (dbg_curr_thread
== NULL
)
489 WINE_ERR("Unknown thread\n");
493 memory_get_string(dbg_curr_process
,
494 de
->u
.DebugString
.lpDebugStringData
, TRUE
,
495 de
->u
.DebugString
.fUnicode
, u
.bufferA
, sizeof(u
.bufferA
));
496 WINE_TRACE("%04x:%04x: output debug string (%s)\n",
497 de
->dwProcessId
, de
->dwThreadId
, u
.bufferA
);
501 WINE_TRACE("%04x:%04x: rip error=%u type=%u\n",
502 de
->dwProcessId
, de
->dwThreadId
, de
->u
.RipInfo
.dwError
,
503 de
->u
.RipInfo
.dwType
);
507 WINE_TRACE("%04x:%04x: unknown event (%x)\n",
508 de
->dwProcessId
, de
->dwThreadId
, de
->dwDebugEventCode
);
510 if (!cont
) return TRUE
; /* stop execution */
511 ContinueDebugEvent(de
->dwProcessId
, de
->dwThreadId
, cont
);
512 return FALSE
; /* continue execution */
515 static void dbg_resume_debuggee(DWORD cont
)
517 if (dbg_curr_thread
->in_exception
)
520 char hexbuf
[MAX_OFFSET_TO_STR_LEN
];
522 dbg_exception_epilog();
523 memory_get_current_pc(&addr
);
524 WINE_TRACE("Exiting debugger PC=%s mode=%d count=%d\n",
525 memory_offset_to_string(hexbuf
, addr
.Offset
, 0),
526 dbg_curr_thread
->exec_mode
,
527 dbg_curr_thread
->exec_count
);
530 if (!dbg_curr_process
->be_cpu
->set_context(dbg_curr_thread
->handle
, &dbg_context
))
531 dbg_printf("Cannot set ctx on %04lx\n", dbg_curr_tid
);
534 dbg_interactiveP
= FALSE
;
535 if (!ContinueDebugEvent(dbg_curr_pid
, dbg_curr_tid
, cont
))
536 dbg_printf("Cannot continue on %04lx (%08x)\n", dbg_curr_tid
, cont
);
539 static void wait_exception(void)
543 while (dbg_num_processes() && WaitForDebugEvent(&de
, INFINITE
))
545 if (dbg_handle_debug_event(&de
)) break;
547 dbg_interactiveP
= TRUE
;
550 void dbg_wait_next_exception(DWORD cont
, int count
, int mode
)
553 char hexbuf
[MAX_OFFSET_TO_STR_LEN
];
555 if (cont
== DBG_CONTINUE
)
557 dbg_curr_thread
->exec_count
= count
;
558 dbg_curr_thread
->exec_mode
= mode
;
560 dbg_resume_debuggee(cont
);
563 if (!dbg_curr_process
) return;
565 memory_get_current_pc(&addr
);
566 WINE_TRACE("Entering debugger PC=%s mode=%d count=%d\n",
567 memory_offset_to_string(hexbuf
, addr
.Offset
, 0),
568 dbg_curr_thread
->exec_mode
,
569 dbg_curr_thread
->exec_count
);
572 void dbg_active_wait_for_first_exception(void)
574 dbg_interactiveP
= FALSE
;
575 /* wait for first exception */
579 static BOOL
dbg_start_debuggee(LPSTR cmdLine
)
581 PROCESS_INFORMATION info
;
582 STARTUPINFOA startup
, current
;
585 GetStartupInfoA(¤t
);
587 memset(&startup
, 0, sizeof(startup
));
588 startup
.cb
= sizeof(startup
);
589 startup
.dwFlags
= STARTF_USESHOWWINDOW
;
591 startup
.wShowWindow
= (current
.dwFlags
& STARTF_USESHOWWINDOW
) ?
592 current
.wShowWindow
: SW_SHOWNORMAL
;
594 /* FIXME: shouldn't need the CREATE_NEW_CONSOLE, but as usual CUIs need it
597 flags
= DEBUG_PROCESS
| CREATE_NEW_CONSOLE
;
598 if (!DBG_IVAR(AlsoDebugProcChild
)) flags
|= DEBUG_ONLY_THIS_PROCESS
;
600 if (!CreateProcessA(NULL
, cmdLine
, NULL
, NULL
, FALSE
, flags
,
601 NULL
, NULL
, &startup
, &info
))
603 dbg_printf("Couldn't start process '%s'\n", cmdLine
);
606 if (!info
.dwProcessId
)
608 /* this happens when the program being run is not a Wine binary
609 * (for example, a shell wrapper around a WineLib app)
611 /* Current fix: list running processes and let the user attach
612 * to one of them (sic)
613 * FIXME: implement a real fix => grab the process (from the
614 * running processes) from its name
616 dbg_printf("Debuggee has been started (%s)\n"
617 "But WineDbg isn't attached to it. Maybe you're trying to debug a winelib wrapper ??\n"
618 "Try to attach to one of those processes:\n", cmdLine
);
619 /* FIXME: (HACK) we need some time before the wrapper executes the winelib app */
621 info_win32_processes();
624 dbg_curr_pid
= info
.dwProcessId
;
625 if (!(dbg_curr_process
= dbg_add_process(&be_process_active_io
, dbg_curr_pid
, 0))) return FALSE
;
626 dbg_curr_process
->active_debuggee
= TRUE
;
631 void dbg_run_debuggee(const char* args
)
635 WINE_FIXME("Re-running current program with %s as args is broken\n", wine_dbgstr_a(args
));
640 if (!dbg_last_cmd_line
)
642 dbg_printf("Cannot find previously used command line.\n");
645 dbg_start_debuggee(dbg_last_cmd_line
);
646 dbg_active_wait_for_first_exception();
647 source_list_from_addr(NULL
, 0);
651 static BOOL
str2int(const char* str
, DWORD_PTR
* val
)
655 *val
= strtol(str
, &ptr
, 10);
656 return str
< ptr
&& !*ptr
;
659 static HANDLE
create_temp_file(void)
661 static const WCHAR prefixW
[] = {'w','d','b',0};
662 WCHAR path
[MAX_PATH
], name
[MAX_PATH
];
664 if (!GetTempPathW( MAX_PATH
, path
) || !GetTempFileNameW( path
, prefixW
, 0, name
))
665 return INVALID_HANDLE_VALUE
;
666 return CreateFileW( name
, GENERIC_READ
|GENERIC_WRITE
|DELETE
, FILE_SHARE_DELETE
,
667 NULL
, CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
| FILE_FLAG_DELETE_ON_CLOSE
, 0 );
680 { 0, VER_PLATFORM_WIN32s
, 2, 0, "2.0" },
681 { 0, VER_PLATFORM_WIN32s
, 3, 0, "3.0" },
682 { 0, VER_PLATFORM_WIN32s
, 3, 10, "3.1" },
683 { 0, VER_PLATFORM_WIN32_WINDOWS
, 4, 0, "95" },
684 { 0, VER_PLATFORM_WIN32_WINDOWS
, 4, 10, "98" },
685 { 0, VER_PLATFORM_WIN32_WINDOWS
, 4, 90, "ME" },
686 { VER_NT_WORKSTATION
, VER_PLATFORM_WIN32_NT
, 3, 51, "NT 3.51" },
687 { VER_NT_WORKSTATION
, VER_PLATFORM_WIN32_NT
, 4, 0, "NT 4.0" },
688 { VER_NT_WORKSTATION
, VER_PLATFORM_WIN32_NT
, 5, 0, "2000" },
689 { VER_NT_WORKSTATION
, VER_PLATFORM_WIN32_NT
, 5, 1, "XP" },
690 { VER_NT_WORKSTATION
, VER_PLATFORM_WIN32_NT
, 5, 2, "XP" },
691 { VER_NT_SERVER
, VER_PLATFORM_WIN32_NT
, 5, 2, "Server 2003" },
692 { VER_NT_WORKSTATION
, VER_PLATFORM_WIN32_NT
, 6, 0, "Vista" },
693 { VER_NT_SERVER
, VER_PLATFORM_WIN32_NT
, 6, 0, "Server 2008" },
694 { VER_NT_WORKSTATION
, VER_PLATFORM_WIN32_NT
, 6, 1, "7" },
695 { VER_NT_SERVER
, VER_PLATFORM_WIN32_NT
, 6, 1, "Server 2008 R2" },
696 { VER_NT_WORKSTATION
, VER_PLATFORM_WIN32_NT
, 6, 2, "8" },
697 { VER_NT_SERVER
, VER_PLATFORM_WIN32_NT
, 6, 2, "Server 2012" },
698 { VER_NT_WORKSTATION
, VER_PLATFORM_WIN32_NT
, 6, 3, "8.1" },
699 { VER_NT_SERVER
, VER_PLATFORM_WIN32_NT
, 6, 3, "Server 2012 R2" },
700 { VER_NT_WORKSTATION
, VER_PLATFORM_WIN32_NT
, 10, 0, "10" },
703 static const char *get_windows_version(void)
705 OSVERSIONINFOEXW info
= { sizeof(OSVERSIONINFOEXW
) };
709 GetVersionExW( (OSVERSIONINFOW
*)&info
);
711 for (i
= 0; i
< ARRAY_SIZE(version_table
); i
++)
713 if (version_table
[i
].type
== info
.wProductType
&&
714 version_table
[i
].platform
== info
.dwPlatformId
&&
715 version_table
[i
].major
== info
.dwMajorVersion
&&
716 version_table
[i
].minor
== info
.dwMinorVersion
)
718 return version_table
[i
].str
;
722 snprintf( str
, sizeof(str
), "%d.%d (%d)", info
.dwMajorVersion
,
723 info
.dwMinorVersion
, info
.wProductType
);
727 static void output_system_info(void)
730 static const char platform
[] = "i386";
731 #elif defined(__x86_64__)
732 static const char platform
[] = "x86_64";
733 #elif defined(__powerpc__)
734 static const char platform
[] = "powerpc";
735 #elif defined(__arm__)
736 static const char platform
[] = "arm";
737 #elif defined(__aarch64__)
738 static const char platform
[] = "arm64";
743 const char *(CDECL
*wine_get_build_id
)(void);
744 void (CDECL
*wine_get_host_version
)( const char **sysname
, const char **release
);
747 wine_get_build_id
= (void *)GetProcAddress(GetModuleHandleA("ntdll.dll"), "wine_get_build_id");
748 wine_get_host_version
= (void *)GetProcAddress(GetModuleHandleA("ntdll.dll"), "wine_get_host_version");
749 if (!IsWow64Process( dbg_curr_process
->handle
, &is_wow64
)) is_wow64
= FALSE
;
751 dbg_printf( "System information:\n" );
752 if (wine_get_build_id
) dbg_printf( " Wine build: %s\n", wine_get_build_id() );
753 dbg_printf( " Platform: %s%s\n", platform
, is_wow64
? " (WOW64)" : "" );
754 dbg_printf( " Version: Windows %s\n", get_windows_version() );
755 if (wine_get_host_version
)
757 const char *sysname
, *release
;
758 wine_get_host_version( &sysname
, &release
);
759 dbg_printf( " Host system: %s\n", sysname
);
760 dbg_printf( " Host version: %s\n", release
);
764 /******************************************************************
767 * Tries to attach to a running process
768 * Handles the <pid> or <pid> <evt> forms
770 enum dbg_start
dbg_active_attach(int argc
, char* argv
[])
774 /* try the form <myself> pid */
775 if (argc
== 1 && str2int(argv
[0], &pid
) && pid
!= 0)
777 if (!dbg_attach_debuggee(pid
, FALSE
))
778 return start_error_init
;
780 /* try the form <myself> pid evt (Win32 JIT debugger) */
781 else if (argc
== 2 && str2int(argv
[0], &pid
) && pid
!= 0 &&
782 str2int(argv
[1], &evt
) && evt
!= 0)
784 if (!dbg_attach_debuggee(pid
, TRUE
))
786 /* don't care about result */
787 SetEvent((HANDLE
)evt
);
788 return start_error_init
;
790 if (!SetEvent((HANDLE
)evt
))
792 WINE_ERR("Invalid event handle: %lx\n", evt
);
793 return start_error_init
;
795 CloseHandle((HANDLE
)evt
);
797 else return start_error_parse
;
803 /******************************************************************
806 * Launches a debuggee (with its arguments) from argc/argv
808 enum dbg_start
dbg_active_launch(int argc
, char* argv
[])
813 if (argc
== 0) return start_error_parse
;
815 if (!(cmd_line
= HeapAlloc(GetProcessHeap(), 0, len
= 1)))
818 dbg_printf("Out of memory\n");
819 return start_error_init
;
823 for (i
= 0; i
< argc
; i
++)
825 len
+= strlen(argv
[i
]) + 1;
826 if (!(cmd_line
= HeapReAlloc(GetProcessHeap(), 0, cmd_line
, len
)))
828 strcat(cmd_line
, argv
[i
]);
829 cmd_line
[len
- 2] = ' ';
830 cmd_line
[len
- 1] = '\0';
833 if (!dbg_start_debuggee(cmd_line
))
835 HeapFree(GetProcessHeap(), 0, cmd_line
);
836 return start_error_init
;
838 HeapFree(GetProcessHeap(), 0, dbg_last_cmd_line
);
839 dbg_last_cmd_line
= cmd_line
;
843 /******************************************************************
846 * Starts (<pid> or <pid> <evt>) in automatic mode
848 enum dbg_start
dbg_active_auto(int argc
, char* argv
[])
850 HANDLE thread
= 0, event
= 0, input
, output
= INVALID_HANDLE_VALUE
;
851 enum dbg_start ds
= start_error_parse
;
853 DBG_IVAR(BreakOnDllLoad
) = 0;
857 ds
= dbg_active_attach(argc
, argv
);
858 if (ds
!= start_ok
) {
859 msgbox_res_id(NULL
, IDS_INVALID_PARAMS
, IDS_AUTO_CAPTION
, MB_OK
);
863 switch (display_crash_dialog())
868 dbg_start_interactive(INVALID_HANDLE_VALUE
);
871 event
= CreateEventW( NULL
, TRUE
, FALSE
, NULL
);
872 if (event
) thread
= display_crash_details( event
);
873 if (thread
) dbg_houtput
= output
= create_temp_file();
877 input
= parser_generate_command_file("echo Modules:", "info share",
878 "echo Threads:", "info threads", NULL
);
879 if (input
== INVALID_HANDLE_VALUE
) return start_error_parse
;
881 if (dbg_curr_process
->active_debuggee
)
882 dbg_active_wait_for_first_exception();
884 dbg_interactiveP
= TRUE
;
885 parser_handle(input
);
886 output_system_info();
888 if (output
!= INVALID_HANDLE_VALUE
)
891 WaitForSingleObject( thread
, INFINITE
);
892 CloseHandle( output
);
893 CloseHandle( thread
);
894 CloseHandle( event
);
897 CloseHandle( input
);
898 dbg_curr_process
->process_io
->close_process(dbg_curr_process
, TRUE
);
902 /******************************************************************
903 * dbg_active_minidump
905 * Starts (<pid> or <pid> <evt>) in minidump mode
907 enum dbg_start
dbg_active_minidump(int argc
, char* argv
[])
910 enum dbg_start ds
= start_error_parse
;
911 const char* file
= NULL
;
912 char tmp
[8 + 1 + 2 + MAX_PATH
]; /* minidump "<file>" */
914 dbg_houtput
= GetStdHandle(STD_ERROR_HANDLE
);
915 DBG_IVAR(BreakOnDllLoad
) = 0;
918 /* hard stuff now ; we can get things like:
919 * --minidump <pid> 1 arg
920 * --minidump <pid> <evt> 2 args
921 * --minidump <file> <pid> 2 args
922 * --minidump <file> <pid> <evt> 3 args
927 ds
= dbg_active_attach(argc
, argv
);
930 if ((ds
= dbg_active_attach(argc
, argv
)) != start_ok
)
933 ds
= dbg_active_attach(argc
- 1, argv
+ 1);
938 ds
= dbg_active_attach(argc
- 1, argv
+ 1);
941 return start_error_parse
;
943 if (ds
!= start_ok
) return ds
;
944 memcpy(tmp
, "minidump \"", 10);
949 GetTempPathA(sizeof(path
), path
);
950 GetTempFileNameA(path
, "WD", 0, tmp
+ 10);
952 else strcpy(tmp
+ 10, file
);
956 /* FIXME: should generate unix name as well */
957 dbg_printf("Capturing program state in %s\n", tmp
+ 9);
959 hFile
= parser_generate_command_file(tmp
, "detach", NULL
);
960 if (hFile
== INVALID_HANDLE_VALUE
) return start_error_parse
;
962 if (dbg_curr_process
->active_debuggee
)
963 dbg_active_wait_for_first_exception();
965 dbg_interactiveP
= TRUE
;
966 parser_handle(hFile
);
971 static BOOL
tgt_process_active_close_process(struct dbg_process
* pcs
, BOOL kill
)
977 if (pcs
== dbg_curr_process
&& dbg_curr_thread
->in_exception
)
978 exit_code
= dbg_curr_thread
->excpt_record
.ExceptionCode
;
980 TerminateProcess(pcs
->handle
, exit_code
);
982 else if (pcs
== dbg_curr_process
)
984 /* remove all set breakpoints in debuggee code */
985 break_set_xpoints(FALSE
);
986 /* needed for single stepping (ugly).
987 * should this be handled inside the server ???
989 dbg_curr_process
->be_cpu
->single_step(&dbg_context
, FALSE
);
990 if (dbg_curr_thread
->in_exception
)
992 dbg_curr_process
->be_cpu
->set_context(dbg_curr_thread
->handle
, &dbg_context
);
993 ContinueDebugEvent(dbg_curr_pid
, dbg_curr_tid
, DBG_CONTINUE
);
999 if (!DebugActiveProcessStop(pcs
->pid
)) return FALSE
;
1001 SymCleanup(pcs
->handle
);
1002 dbg_del_process(pcs
);
1007 static BOOL
tgt_process_active_read(HANDLE hProcess
, const void* addr
,
1008 void* buffer
, SIZE_T len
, SIZE_T
* rlen
)
1010 return ReadProcessMemory( hProcess
, addr
, buffer
, len
, rlen
);
1013 static BOOL
tgt_process_active_write(HANDLE hProcess
, void* addr
,
1014 const void* buffer
, SIZE_T len
, SIZE_T
* wlen
)
1016 return WriteProcessMemory( hProcess
, addr
, buffer
, len
, wlen
);
1019 static BOOL
tgt_process_active_get_selector(HANDLE hThread
, DWORD sel
, LDT_ENTRY
* le
)
1021 return GetThreadSelectorEntry( hThread
, sel
, le
);
1024 static struct be_process_io be_process_active_io
=
1026 tgt_process_active_close_process
,
1027 tgt_process_active_read
,
1028 tgt_process_active_write
,
1029 tgt_process_active_get_selector