1 /* Wine internal debugger
2 * Interface to Windows debugger API
3 * Copyright 2000-2004 Eric Pouech
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include "wine/port.h"
29 #include "wine/exception.h"
30 #include "wine/library.h"
32 #include "wine/debug.h"
37 * + ensure that all commands work as expected in minidump reload function
38 * (and reenable parser usager)
40 * + we always assume the stack grows as on i386 (ie downwards)
42 * + enable back the limited output (depth of structure printing and number of
44 * + make the output as close as possible to what gdb does
45 * - symbol management:
46 * + symbol table loading is broken
47 * + in symbol_get_lvalue, we don't do any scoping (as C does) between local and
48 * global vars (we may need this to force some display for example). A solution
49 * would be always to return arrays with: local vars, global vars, thunks
51 * + some bits of internal types are missing (like type casts and the address
53 * + the type for an enum's value is always inferred as int (winedbg & dbghelp)
54 * + most of the code implies that sizeof(void*) = sizeof(int)
55 * + all computations should be made on long long
56 * o expr computations are in int:s
57 * o bitfield size is on a 4-bytes
58 * + array_index and deref should be the same function (or should share the same
61 * + set a better fix for gdb (proxy mode) than the step-mode hack
62 * + implement function call in debuggee
63 * + trampoline management is broken when getting 16 <=> 32 thunk destination
65 * + thunking of delayed imports doesn't work as expected (ie, when stepping,
66 * it currently stops at first insn with line number during the library
67 * loading). We should identify this (__wine_delay_import) and set a
68 * breakpoint instead of single stepping the library loading.
69 * + it's wrong to copy thread->step_over_bp into process->bp[0] (when
70 * we have a multi-thread debuggee). complete fix must include storing all
71 * thread's step-over bp in process-wide bp array, and not to handle bp
72 * when we have the wrong thread running into that bp
73 * + code in CREATE_PROCESS debug event doesn't work on Windows, as we cannot
74 * get the name of the main module this way. We should rewrite all this code
75 * and store in struct dbg_process as early as possible (before process
76 * creation or attachment), the name of the main module
78 * + define a better way to enable the wine extensions (either DBG SDK function
79 * in dbghelp, or TLS variable, or environment variable or ...)
80 * + audit all files to ensure that we check all potential return values from
81 * every function call to catch the errors
82 * + BTW check also whether the exception mechanism is the best way to return
83 * errors (or find a proper fix for MinGW port)
84 * + use Wine standard list mechanism for all list handling
87 WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
89 struct dbg_process* dbg_curr_process = NULL;
90 struct dbg_thread* dbg_curr_thread = NULL;
94 BOOL dbg_interactiveP = FALSE;
96 static struct dbg_process* dbg_process_list = NULL;
98 struct dbg_internal_var dbg_internal_vars[DBG_IV_LAST];
99 const struct dbg_internal_var* dbg_context_vars;
100 static HANDLE dbg_houtput;
102 void dbg_outputA(const char* buffer, int len)
104 static char line_buff[4096];
105 static unsigned int line_pos;
111 unsigned int count = min( len, sizeof(line_buff) - line_pos );
112 memcpy( line_buff + line_pos, buffer, count );
116 for (i = line_pos; i > 0; i--) if (line_buff[i-1] == '\n') break;
117 if (!i) /* no newline found */
119 if (len > 0) i = line_pos; /* buffer is full, flush anyway */
122 WriteFile(dbg_houtput, line_buff, i, &w, NULL);
123 memmove( line_buff, line_buff + i, line_pos - i );
128 void dbg_outputW(const WCHAR* buffer, int len)
133 /* do a serious Unicode to ANSI conversion
134 * FIXME: should CP_ACP be GetConsoleCP()?
136 newlen = WideCharToMultiByte(CP_ACP, 0, buffer, len, NULL, 0, NULL, NULL);
139 if (!(ansi = HeapAlloc(GetProcessHeap(), 0, newlen))) return;
140 WideCharToMultiByte(CP_ACP, 0, buffer, len, ansi, newlen, NULL, NULL);
141 dbg_outputA(ansi, newlen);
142 HeapFree(GetProcessHeap(), 0, ansi);
146 int dbg_printf(const char* format, ...)
148 static char buf[4*1024];
152 va_start(valist, format);
153 len = vsnprintf(buf, sizeof(buf), format, valist);
156 if (len <= -1 || len >= sizeof(buf))
158 len = sizeof(buf) - 1;
160 buf[len - 1] = buf[len - 2] = buf[len - 3] = '.';
162 dbg_outputA(buf, len);
166 static unsigned dbg_load_internal_vars(void)
169 DWORD type = REG_DWORD;
171 DWORD count = sizeof(val);
173 struct dbg_internal_var* div = dbg_internal_vars;
175 /* initializes internal vars table */
176 #define INTERNAL_VAR(_var,_val,_ref,_tid) \
177 div->val = _val; div->name = #_var; div->pval = _ref; \
178 div->typeid = _tid; div++;
182 /* @@ Wine registry key: HKCU\Software\Wine\WineDbg */
183 if (RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\WineDbg", &hkey))
185 WINE_ERR("Cannot create WineDbg key in registry\n");
189 for (i = 0; i < DBG_IV_LAST; i++)
191 if (!dbg_internal_vars[i].pval)
193 if (!RegQueryValueEx(hkey, dbg_internal_vars[i].name, 0,
194 &type, (LPBYTE)&val, &count))
195 dbg_internal_vars[i].val = val;
196 dbg_internal_vars[i].pval = &dbg_internal_vars[i].val;
200 /* set up the debug variables for the CPU context */
201 dbg_context_vars = be_cpu->init_registers(&dbg_context);
205 static unsigned dbg_save_internal_vars(void)
210 /* @@ Wine registry key: HKCU\Software\Wine\WineDbg */
211 if (RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\WineDbg", &hkey))
213 WINE_ERR("Cannot create WineDbg key in registry\n");
217 for (i = 0; i < DBG_IV_LAST; i++)
219 /* FIXME: type should be infered from basic type -if any- of intvar */
220 if (dbg_internal_vars[i].pval == &dbg_internal_vars[i].val)
221 RegSetValueEx(hkey, dbg_internal_vars[i].name, 0,
222 REG_DWORD, (const void*)dbg_internal_vars[i].pval,
223 sizeof(*dbg_internal_vars[i].pval));
229 const struct dbg_internal_var* dbg_get_internal_var(const char* name)
231 const struct dbg_internal_var* div;
233 for (div = &dbg_internal_vars[DBG_IV_LAST - 1]; div >= dbg_internal_vars; div--)
235 if (!strcmp(div->name, name)) return div;
237 for (div = dbg_context_vars; div->name; div++)
239 if (!strcasecmp(div->name, name)) return div;
245 struct dbg_process* dbg_get_process(DWORD pid)
247 struct dbg_process* p;
249 for (p = dbg_process_list; p; p = p->next)
250 if (p->pid == pid) break;
254 struct dbg_process* dbg_get_process_h(HANDLE h)
256 struct dbg_process* p;
258 for (p = dbg_process_list; p; p = p->next)
259 if (p->handle == h) break;
263 struct dbg_process* dbg_add_process(const struct be_process_io* pio, DWORD pid, HANDLE h)
265 struct dbg_process* p;
267 if ((p = dbg_get_process(pid)))
271 WINE_ERR("Process (%lu) is already defined\n", pid);
282 if (!(p = HeapAlloc(GetProcessHeap(), 0, sizeof(struct dbg_process)))) return NULL;
289 p->continue_on_first_exception = FALSE;
290 p->next_bp = 1; /* breakpoint 0 is reserved for step-over */
291 memset(p->bp, 0, sizeof(p->bp));
292 p->delayed_bp = NULL;
293 p->num_delayed_bp = 0;
295 p->next = dbg_process_list;
297 if (dbg_process_list) dbg_process_list->prev = p;
298 dbg_process_list = p;
302 void dbg_set_process_name(struct dbg_process* p, const char* imageName)
304 assert(p->imageName == NULL);
307 char* tmp = HeapAlloc(GetProcessHeap(), 0, strlen(imageName) + 1);
308 if (tmp) p->imageName = strcpy(tmp, imageName);
312 void dbg_del_process(struct dbg_process* p)
316 while (p->threads) dbg_del_thread(p->threads);
318 for (i = 0; i < p->num_delayed_bp; i++)
319 if (p->delayed_bp[i].is_symbol)
320 HeapFree(GetProcessHeap(), 0, p->delayed_bp[i].u.symbol.name);
322 HeapFree(GetProcessHeap(), 0, p->delayed_bp);
323 if (p->prev) p->prev->next = p->next;
324 if (p->next) p->next->prev = p->prev;
325 if (p == dbg_process_list) dbg_process_list = p->next;
326 if (p == dbg_curr_process) dbg_curr_process = NULL;
327 HeapFree(GetProcessHeap(), 0, (char*)p->imageName);
328 HeapFree(GetProcessHeap(), 0, p);
331 struct mod_loader_info
334 IMAGEHLP_MODULE* imh_mod;
337 static BOOL CALLBACK mod_loader_cb(PSTR mod_name, DWORD base, void* ctx)
339 struct mod_loader_info* mli = (struct mod_loader_info*)ctx;
341 if (!strcmp(mod_name, "<wine-loader>"))
343 if (SymGetModuleInfo(mli->handle, base, mli->imh_mod))
344 return FALSE; /* stop enum */
349 BOOL dbg_get_debuggee_info(HANDLE hProcess, IMAGEHLP_MODULE* imh_mod)
351 struct mod_loader_info mli;
354 /* this will resynchronize builtin dbghelp's internal ELF module list */
355 SymLoadModule(hProcess, 0, 0, 0, 0, 0);
356 mli.handle = hProcess;
357 mli.imh_mod = imh_mod;
358 imh_mod->SizeOfStruct = sizeof(*imh_mod);
359 imh_mod->BaseOfImage = 0;
360 /* this is a wine specific options to return also ELF modules in the
363 SymSetOptions((opt = SymGetOptions()) | 0x40000000);
364 SymEnumerateModules(hProcess, mod_loader_cb, (void*)&mli);
367 return imh_mod->BaseOfImage != 0;
370 struct dbg_thread* dbg_get_thread(struct dbg_process* p, DWORD tid)
372 struct dbg_thread* t;
375 for (t = p->threads; t; t = t->next)
376 if (t->tid == tid) break;
380 struct dbg_thread* dbg_add_thread(struct dbg_process* p, DWORD tid,
383 struct dbg_thread* t = HeapAlloc(GetProcessHeap(), 0, sizeof(struct dbg_thread));
392 t->exec_mode = dbg_exec_cont;
394 t->step_over_bp.enabled = FALSE;
395 t->step_over_bp.refcount = 0;
396 t->stopped_xpoint = -1;
397 t->in_exception = FALSE;
401 t->addr_mode = AddrModeFlat;
403 snprintf(t->name, sizeof(t->name), "0x%08lx", tid);
405 t->next = p->threads;
407 if (p->threads) p->threads->prev = t;
413 void dbg_del_thread(struct dbg_thread* t)
415 HeapFree(GetProcessHeap(), 0, t->frames);
416 if (t->prev) t->prev->next = t->next;
417 if (t->next) t->next->prev = t->prev;
418 if (t == t->process->threads) t->process->threads = t->next;
419 if (t == dbg_curr_thread) dbg_curr_thread = NULL;
420 HeapFree(GetProcessHeap(), 0, t);
423 BOOL dbg_interrupt_debuggee(void)
425 if (!dbg_process_list) return FALSE;
426 /* FIXME: since we likely have a single process, signal the first process
429 if (dbg_process_list->next) dbg_printf("Ctrl-C: only stopping the first process\n");
430 else dbg_printf("Ctrl-C: stopping debuggee\n");
431 dbg_process_list->continue_on_first_exception = FALSE;
432 return DebugBreakProcess(dbg_process_list->handle);
435 static BOOL WINAPI ctrl_c_handler(DWORD dwCtrlType)
437 if (dwCtrlType == CTRL_C_EVENT)
439 return dbg_interrupt_debuggee();
444 static void dbg_init_console(void)
446 /* set our control-C handler */
447 SetConsoleCtrlHandler(ctrl_c_handler, TRUE);
449 /* set our own title */
450 SetConsoleTitle("Wine Debugger");
453 static int dbg_winedbg_usage(BOOL advanced)
457 dbg_printf("Usage:\n"
458 " winedbg cmdline launch process 'cmdline' (as if you were starting\n"
459 " it with wine) and run WineDbg on it\n"
460 " winedbg <num> attach to running process of pid <num> and run\n"
462 " winedbg --gdb cmdline launch process 'cmdline' (as if you were starting\n"
463 " wine) and run gdb (proxied) on it\n"
464 " winedbg --gdb <num> attach to running process of pid <num> and run\n"
465 " gdb (proxied) on it\n"
466 " winedbg file.mdmp reload the minidump file.mdmp into memory and run\n"
468 " winedbg --help prints advanced options\n");
471 dbg_printf("Usage:\n\twinedbg [ [ --gdb ] [ prog-name [ prog-args ] | <num> | file.mdmp | --help ]\n");
475 struct backend_cpu* be_cpu;
477 extern struct backend_cpu be_i386;
479 extern struct backend_cpu be_ppc;
481 extern struct backend_cpu be_alpha;
486 int main(int argc, char** argv)
489 HANDLE hFile = INVALID_HANDLE_VALUE;
501 /* Initialize the output */
502 dbg_houtput = GetStdHandle(STD_OUTPUT_HANDLE);
504 /* Initialize internal vars */
505 if (!dbg_load_internal_vars()) return -1;
507 /* as we don't care about exec name */
510 if (argc && !strcmp(argv[0], "--help"))
511 return dbg_winedbg_usage(TRUE);
513 if (argc && !strcmp(argv[0], "--gdb"))
515 retv = gdb_main(argc, argv);
516 if (retv == -1) dbg_winedbg_usage(FALSE);
521 SymSetOptions((SymGetOptions() & ~(SYMOPT_UNDNAME)) |
522 SYMOPT_LOAD_LINES | SYMOPT_DEFERRED_LOADS | SYMOPT_AUTO_PUBLICS);
524 if (argc && (!strcmp(argv[0], "--auto") || !strcmp(argv[0], "--minidump")))
526 /* force some internal variables */
527 DBG_IVAR(BreakOnDllLoad) = 0;
528 dbg_houtput = GetStdHandle(STD_ERROR_HANDLE);
529 switch (dbg_active_auto(argc, argv))
531 case start_ok: return 0;
532 case start_error_parse: return dbg_winedbg_usage(FALSE);
533 case start_error_init: return -1;
537 while (argc > 0 && argv[0][0] == '-')
539 if (!strcmp(argv[0], "--command"))
542 hFile = parser_generate_command_file(argv[0], NULL);
543 if (hFile == INVALID_HANDLE_VALUE)
545 dbg_printf("Couldn't open temp file (%lu)\n", GetLastError());
551 if (!strcmp(argv[0], "--file"))
554 hFile = CreateFileA(argv[0], GENERIC_READ|DELETE, 0,
555 NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
556 if (hFile == INVALID_HANDLE_VALUE)
558 dbg_printf("Couldn't open file %s (%lu)\n", argv[0], GetLastError());
564 if (!strcmp(argv[0], "--"))
569 return dbg_winedbg_usage(FALSE);
571 if (!argc) ds = start_ok;
572 else if ((ds = dbg_active_attach(argc, argv)) == start_error_parse &&
573 (ds = minidump_reload(argc, argv)) == start_error_parse)
574 ds = dbg_active_launch(argc, argv);
577 case start_ok: break;
578 case start_error_parse: return dbg_winedbg_usage(FALSE);
579 case start_error_init: return -1;
582 dbg_interactiveP = TRUE;
583 parser_handle(hFile);
585 while (dbg_process_list)
586 dbg_process_list->process_io->close_process(dbg_process_list, TRUE);
588 dbg_save_internal_vars();