?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dbghelp: Pretend mach-o is present in case of failure.
[wine.git] / programs / winedbg / info.c
blobd95b286454aca5b52dad9930025946d1f442b12c
1 /*
2 * Wine debugger utility routines
3 *
4 * Copyright 1993 Eric Youngdale
5 * Copyright 1995 Alexandre Julliard
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include <stdlib.h>
23 #include <stdio.h>
24 #include <string.h>
25 #include <stdarg.h>
26
27 #include "debugger.h"
28 #include "wingdi.h"
29 #include "winuser.h"
30 #include "tlhelp32.h"
31 #include "wine/debug.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
34
35 /***********************************************************************
36 * print_help
37 *
38 * Implementation of the 'help' command.
39 */
40 void print_help(void)
41 {
42 int i = 0;
43 static const char * const helptext[] =
44 {
45 "The commands accepted by the Wine debugger are a reasonable",
46 "subset of the commands that gdb accepts.",
47 "The commands currently are:",
48 " help quit",
49 " attach <wpid> detach",
50 " break [*<addr>] watch | rwatch *<addr>",
51 " delete break bpnum disable bpnum",
52 " enable bpnum condition <bpnum> [<expr>]",
53 " finish cont [N]",
54 " step [N] next [N]",
55 " stepi [N] nexti [N]",
56 " x <addr> print <expr>",
57 " display <expr> undisplay <disnum>",
58 " local display <expr> delete display <disnum>",
59 " enable display <disnum> disable display <disnum>",
60 " bt [<tid>|all] frame <n>",
61 " up down",
62 " list <lines> disassemble [<addr>][,<addr>]",
63 " show dir dir <path>",
64 " set <reg> = <expr> set *<addr> = <expr>",
65 " pass whatis",
66 " info (see 'help info' for options) thread <tid>",
67
68 "The 'x' command accepts repeat counts and formats (including 'i') in the",
69 "same way that gdb does.\n",
70
71 "The following are examples of legal expressions:",
72 " $eax $eax+0x3 0x1000 ($eip + 256) *$eax *($esp + 3)",
73 " Also, a nm format symbol table can be read from a file using the",
74 " symbolfile command.", /* Symbols can also be defined individually with",
75 " the define command.", */
76 "",
77 NULL
78 };
79
80 while (helptext[i]) dbg_printf("%s\n", helptext[i++]);
81 }
82
83
84 /***********************************************************************
85 * info_help
86 *
87 * Implementation of the 'help info' command.
88 */
89 void info_help(void)
90 {
91 int i = 0;
92 static const char * const infotext[] =
93 {
94 "The info commands allow you to get assorted bits of interesting stuff",
95 "to be displayed. The options are:",
96 " info break Displays information about breakpoints",
97 " info class <name> Displays information about window class <name>",
98 " info display Shows auto-display expressions in use",
99 " info except <pid> Shows exception handler chain (in a given process)",
100 " info locals Displays values of all local vars for current frame",
101 " info maps <pid> Shows virtual mappings (in a given process)",
102 " info process Shows all running processes",
103 " info reg Displays values of the general registers at top of stack",
104 " info all-reg Displays the general and floating point registers",
105 " info segments <pid> Displays information about all known segments",
106 " info share Displays all loaded modules",
107 " info share <addr> Displays internal module state",
108 " info stack [<len>] Dumps information about top of stack, up to len words",
109 " info symbol <sym> Displays information about a given symbol",
110 " info thread Shows all running threads",
111 " info wnd <handle> Displays internal window state",
112 "",
113 NULL
114 };
115
116 while (infotext[i]) dbg_printf("%s\n", infotext[i++]);
117 }
118
119 struct info_module
120 {
121 IMAGEHLP_MODULEW64 mi;
122 struct dhext_module_information ext_module_info;
123 char name[64];
124 };
125
126 struct info_modules
127 {
128 struct info_module *modules;
129 unsigned num_alloc;
130 unsigned num_used;
131 };
132
133 static const char* get_module_type(const struct info_module* im, BOOL is_embedded)
134 {
135 switch (im->ext_module_info.type)
136 {
137 case DMT_ELF: return "ELF";
138 case DMT_MACHO: return "Mach-O";
139 case DMT_PE: return !is_embedded && im->ext_module_info.is_wine_builtin ? "PE-Wine" : "PE";
140 default: return "----";
141 }
142 }
143
144 static const char* get_symtype_str(const struct info_module* im)
145 {
146 switch (im->mi.SymType)
147 {
148 default:
149 case SymNone: return "--none--";
150 case SymCoff: return "COFF";
151 case SymCv: return "CodeView";
152 case SymPdb: return "PDB";
153 case SymExport: return "Export";
154 case SymDeferred: return "Deferred";
155 case SymSym: return "Sym";
156 case SymDia:
157 if (im->ext_module_info.debug_format_bitmask)
158 {
159 static char tmp[64];
160 tmp[0] = '\0';
161 if (im->ext_module_info.debug_format_bitmask & DHEXT_FORMAT_STABS) strcpy(tmp, "stabs");
162 if (im->ext_module_info.debug_format_bitmask & (DHEXT_FORMAT_DWARF2 | DHEXT_FORMAT_DWARF3 | DHEXT_FORMAT_DWARF4 | DHEXT_FORMAT_DWARF5))
163 {
164 if (tmp[0]) strcat(tmp, ", ");
165 strcat(tmp, "Dwarf");
166 if (im->ext_module_info.debug_format_bitmask & DHEXT_FORMAT_DWARF2) strcat(tmp, "-2");
167 if (im->ext_module_info.debug_format_bitmask & DHEXT_FORMAT_DWARF3) strcat(tmp, "-3");
168 if (im->ext_module_info.debug_format_bitmask & DHEXT_FORMAT_DWARF4) strcat(tmp, "-4");
169 if (im->ext_module_info.debug_format_bitmask & DHEXT_FORMAT_DWARF5) strcat(tmp, "-5");
170 }
171 return tmp;
172 }
173 return "DIA";
174 }
175 }
176
177 static const char* get_machine_str(DWORD machine)
178 {
179 static char tmp[32];
180 switch (machine)
181 {
182 case IMAGE_FILE_MACHINE_AMD64: return "x86_64";
183 case IMAGE_FILE_MACHINE_I386: return "i386";
184 case IMAGE_FILE_MACHINE_ARM64: return "arm64";
185 case IMAGE_FILE_MACHINE_ARM:
186 case IMAGE_FILE_MACHINE_ARMNT: return "arm";
187 default: sprintf(tmp, "<%lx>", machine); return tmp;
188 }
189 }
190
191 static void module_print_info(const struct info_module *module, BOOL is_embedded, BOOL multi_machine)
192 {
193 char buffer[9];
194 snprintf(buffer, sizeof(buffer), "%s%s%s",
195 is_embedded ? " \\-" : "",
196 get_module_type(module, is_embedded),
197 module->ext_module_info.has_file_image ? "" : "^");
198
199 if (multi_machine)
200 dbg_printf("%-8s%16I64x-%16I64x %-16s%-16s%s\n",
201 buffer,
202 module->mi.BaseOfImage,
203 module->mi.BaseOfImage + module->mi.ImageSize,
204 get_machine_str(module->mi.MachineType),
205 is_embedded ? "\\" : get_symtype_str(module), module->name);
206 else
207 dbg_printf("%-8s%*I64x-%*I64x %-16s%s\n",
208 buffer,
209 ADDRWIDTH, module->mi.BaseOfImage,
210 ADDRWIDTH, module->mi.BaseOfImage + module->mi.ImageSize,
211 is_embedded ? "\\" : get_symtype_str(module), module->name);
212 }
213
214 static int __cdecl module_compare(const void* p1, const void* p2)
215 {
216 struct info_module *left = (struct info_module *)p1;
217 struct info_module *right = (struct info_module *)p2;
218 LONGLONG val = left->mi.BaseOfImage - right->mi.BaseOfImage;
219
220 if (val < 0) return -1;
221 else if (val > 0) return 1;
222 else return 0;
223 }
224
225 static inline BOOL module_is_container(const struct info_module *wmod_cntnr,
226 const struct info_module *wmod_child)
227 {
228 return (wmod_cntnr->ext_module_info.type == DMT_ELF || wmod_cntnr->ext_module_info.type == DMT_MACHO) &&
229 (wmod_child->ext_module_info.type == DMT_PE) &&
230 wmod_cntnr->mi.BaseOfImage <= wmod_child->mi.BaseOfImage &&
231 wmod_cntnr->mi.BaseOfImage + wmod_cntnr->mi.ImageSize >=
232 wmod_child->mi.BaseOfImage + wmod_child->mi.ImageSize;
233 }
234
235 static BOOL CALLBACK info_mod_cb(PCSTR mod_name, DWORD64 base, PVOID ctx)
236 {
237 struct info_modules *im = ctx;
238
239 if (im->num_used + 1 > im->num_alloc)
240 {
241 struct info_module* new = realloc(im->modules, (im->num_alloc + 16) * sizeof(*im->modules));
242 if (!new) return FALSE; /* stop enumeration in case of OOM */
243 im->num_alloc += 16;
244 im->modules = new;
245 }
246 im->modules[im->num_used].mi.SizeOfStruct = sizeof(im->modules[im->num_used].mi);
247 if (SymGetModuleInfoW64(dbg_curr_process->handle, base, &im->modules[im->num_used].mi) &&
248 wine_get_module_information(dbg_curr_process->handle, base, &im->modules[im->num_used].ext_module_info,
249 sizeof(im->modules[im->num_used].ext_module_info)))
250 {
251 const int dst_len = sizeof(im->modules[im->num_used].name);
252 lstrcpynA(im->modules[im->num_used].name, mod_name, dst_len - 1);
253 im->modules[im->num_used].name[dst_len - 1] = 0;
254 im->num_used++;
255 }
256 return TRUE;
257 }
258
259 /***********************************************************************
260 * info_win32_module
261 *
262 * Display information about a given module (DLL or EXE), or about all modules
263 */
264 void info_win32_module(DWORD64 base, BOOL multi_machine)
265 {
266 struct info_modules im;
267 UINT i, j, num_printed = 0;
268 BOOL opt;
269 DWORD machine;
270 BOOL has_missing_filename = FALSE;
271
272 if (!dbg_curr_process)
273 {
274 dbg_printf("Cannot get info on module while no process is loaded\n");
275 return;
276 }
277
278 im.modules = NULL;
279 im.num_alloc = im.num_used = 0;
280
281 /* this is a wine specific options to return also ELF modules in the
282 * enumeration
283 */
284 opt = SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, TRUE);
285 SymEnumerateModules64(dbg_curr_process->handle, info_mod_cb, &im);
286 SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, opt);
287
288 if (!im.num_used) return;
289
290 qsort(im.modules, im.num_used, sizeof(im.modules[0]), module_compare);
291 machine = im.modules[0].mi.MachineType;
292
293 if (multi_machine)
294 dbg_printf("%-8s%-40s%-16s%-16sName (%d modules)\n", "Module", "Address", "Machine", "Debug info", im.num_used);
295 else
296 {
297 unsigned same_machine = 0;
298 for (i = 0; i < im.num_used; i++)
299 if (machine == im.modules[i].mi.MachineType) same_machine++;
300 dbg_printf("%-8s%-*s%-16sName (%d modules",
301 "Module", ADDRWIDTH == 16 ? 40 : 24, "Address", "Debug info", same_machine);
302 if (same_machine != im.num_used)
303 dbg_printf(", %u for wow64 not listed", im.num_used - same_machine);
304 dbg_printf(")\n");
305 }
306
307 for (i = 0; i < im.num_used; i++)
308 {
309 if (base &&
310 (base < im.modules[i].mi.BaseOfImage || base >= im.modules[i].mi.BaseOfImage + im.modules[i].mi.ImageSize))
311 continue;
312 if (!multi_machine && machine != im.modules[i].mi.MachineType) continue;
313 if (!im.modules[i].ext_module_info.has_file_image) has_missing_filename = TRUE;
314 if (im.modules[i].ext_module_info.type == DMT_ELF || im.modules[i].ext_module_info.type == DMT_MACHO)
315 {
316 module_print_info(&im.modules[i], FALSE, multi_machine);
317 /* print all modules embedded in this one */
318 for (j = 0; j < im.num_used; j++)
319 {
320 if (module_is_container(&im.modules[i], &im.modules[j]))
321 module_print_info(&im.modules[j], TRUE, multi_machine);
322 }
323 }
324 else
325 {
326 /* check module is not embedded in another module */
327 for (j = 0; j < im.num_used; j++)
328 {
329 if (module_is_container(&im.modules[j], &im.modules[i]))
330 break;
331 }
332 if (j < im.num_used) continue;
333 module_print_info(&im.modules[i], FALSE, multi_machine);
334 }
335 num_printed++;
336 }
337 free(im.modules);
338
339 if (base && !num_printed)
340 dbg_printf("'0x%0*I64x' is not a valid module address\n", ADDRWIDTH, base);
341 if (has_missing_filename)
342 dbg_printf("^ denotes modules for which image file couldn't be found\n");
343 }
344
345 struct class_walker
346 {
347 ATOM* table;
348 int used;
349 int alloc;
350 };
351
352 static void class_walker(HWND hWnd, struct class_walker* cw)
353 {
354 char clsName[128];
355 int i;
356 ATOM atom;
357 HWND child;
358
359 if (!GetClassNameA(hWnd, clsName, sizeof(clsName)))
360 return;
361 if ((atom = FindAtomA(clsName)) == 0)
362 return;
363
364 for (i = 0; i < cw->used; i++)
365 {
366 if (cw->table[i] == atom)
367 break;
368 }
369 if (i == cw->used)
370 {
371 if (cw->used >= cw->alloc)
372 {
373 ATOM* new = realloc(cw->table, (cw->alloc + 16) * sizeof(ATOM));
374 if (!new) return;
375 cw->alloc += 16;
376 cw->table = new;
377 }
378 cw->table[cw->used++] = atom;
379 info_win32_class(hWnd, clsName);
380 }
381 do
382 {
383 if ((child = GetWindow(hWnd, GW_CHILD)) != 0)
384 class_walker(child, cw);
385 } while ((hWnd = GetWindow(hWnd, GW_HWNDNEXT)) != 0);
386 }
387
388 void info_win32_class(HWND hWnd, const char* name)
389 {
390 WNDCLASSEXA wca;
391 HINSTANCE hInst = hWnd ? (HINSTANCE)GetWindowLongPtrW(hWnd, GWLP_HINSTANCE) : 0;
392
393 if (!name)
394 {
395 struct class_walker cw;
396
397 cw.table = NULL;
398 cw.used = cw.alloc = 0;
399 class_walker(GetDesktopWindow(), &cw);
400 free(cw.table);
401 return;
402 }
403
404 if (!GetClassInfoExA(hInst, name, &wca))
405 {
406 dbg_printf("Cannot find class '%s'\n", name);
407 return;
408 }
409
410 dbg_printf("Class '%s':\n", name);
411 dbg_printf("style=0x%08x wndProc=%p\n"
412 "inst=%p icon=%p cursor=%p bkgnd=%p\n"
413 "clsExtra=%d winExtra=%d\n",
414 wca.style, wca.lpfnWndProc, wca.hInstance,
415 wca.hIcon, wca.hCursor, wca.hbrBackground,
416 wca.cbClsExtra, wca.cbWndExtra);
417
418 if (hWnd && wca.cbClsExtra)
419 {
420 int i;
421 WORD w;
422
423 dbg_printf("Extra bytes:");
424 for (i = 0; i < wca.cbClsExtra / 2; i++)
425 {
426 w = GetClassWord(hWnd, i * 2);
427 /* FIXME: depends on i386 endian-ity */
428 dbg_printf(" %02x %02x", HIBYTE(w), LOBYTE(w));
429 }
430 dbg_printf("\n");
431 }
432 dbg_printf("\n");
433 /* FIXME:
434 * + print #windows (or even list of windows...)
435 * + print extra bytes => this requires a window handle on this very class...
436 */
437 }
438
439 static void info_window(HWND hWnd, int indent)
440 {
441 char clsName[128];
442 char wndName[128];
443 HWND child;
444
445 do
446 {
447 if (!GetClassNameA(hWnd, clsName, sizeof(clsName)))
448 strcpy(clsName, "-- Unknown --");
449 if (!GetWindowTextA(hWnd, wndName, sizeof(wndName)))
450 strcpy(wndName, "-- Empty --");
451
452 dbg_printf("%*s%08Ix%*s %-17.17s %08lx %0*Ix %08lx %.14s\n",
453 indent, "", (DWORD_PTR)hWnd, 12 - indent, "",
454 clsName, GetWindowLongW(hWnd, GWL_STYLE),
455 ADDRWIDTH, (ULONG_PTR)GetWindowLongPtrW(hWnd, GWLP_WNDPROC),
456 GetWindowThreadProcessId(hWnd, NULL), wndName);
457
458 if ((child = GetWindow(hWnd, GW_CHILD)) != 0)
459 info_window(child, indent + 1);
460 } while ((hWnd = GetWindow(hWnd, GW_HWNDNEXT)) != 0);
461 }
462
463 void info_win32_window(HWND hWnd, BOOL detailed)
464 {
465 char clsName[128];
466 char wndName[128];
467 RECT clientRect;
468 RECT windowRect;
469 WORD w;
470
471 if (!IsWindow(hWnd)) hWnd = GetDesktopWindow();
472
473 if (!detailed)
474 {
475 dbg_printf("%-20.20s %-17.17s %-8.8s %-*.*s %-8.8s %s\n",
476 "Window handle", "Class Name", "Style",
477 ADDRWIDTH, ADDRWIDTH, "WndProc", "Thread", "Text");
478 info_window(hWnd, 0);
479 return;
480 }
481
482 if (!GetClassNameA(hWnd, clsName, sizeof(clsName)))
483 strcpy(clsName, "-- Unknown --");
484 if (!GetWindowTextA(hWnd, wndName, sizeof(wndName)))
485 strcpy(wndName, "-- Empty --");
486 if (!GetClientRect(hWnd, &clientRect) ||
487 !MapWindowPoints(hWnd, 0, (LPPOINT) &clientRect, 2))
488 SetRectEmpty(&clientRect);
489 if (!GetWindowRect(hWnd, &windowRect))
490 SetRectEmpty(&windowRect);
491
492 /* FIXME missing fields: hmemTaskQ, hrgnUpdate, dce, flags, pProp, scroll */
493 dbg_printf("next=%p child=%p parent=%p owner=%p class='%s'\n"
494 "inst=%p active=%p idmenu=%08Ix\n"
495 "style=0x%08lx exstyle=0x%08lx wndproc=%p text='%s'\n"
496 "client=%ld,%ld-%ld,%ld window=%ld,%ld-%ld,%ld sysmenu=%p\n",
497 GetWindow(hWnd, GW_HWNDNEXT),
498 GetWindow(hWnd, GW_CHILD),
499 GetParent(hWnd),
500 GetWindow(hWnd, GW_OWNER),
501 clsName,
502 (HINSTANCE)GetWindowLongPtrW(hWnd, GWLP_HINSTANCE),
503 GetLastActivePopup(hWnd),
504 (ULONG_PTR)GetWindowLongPtrW(hWnd, GWLP_ID),
505 GetWindowLongW(hWnd, GWL_STYLE),
506 GetWindowLongW(hWnd, GWL_EXSTYLE),
507 (void*)GetWindowLongPtrW(hWnd, GWLP_WNDPROC),
508 wndName,
509 clientRect.left, clientRect.top, clientRect.right, clientRect.bottom,
510 windowRect.left, windowRect.top, windowRect.right, windowRect.bottom,
511 GetSystemMenu(hWnd, FALSE));
512
513 if (GetClassLongW(hWnd, GCL_CBWNDEXTRA))
514 {
515 UINT i;
516
517 dbg_printf("Extra bytes:");
518 for (i = 0; i < GetClassLongW(hWnd, GCL_CBWNDEXTRA) / 2; i++)
519 {
520 w = GetWindowWord(hWnd, i * 2);
521 /* FIXME: depends on i386 endian-ity */
522 dbg_printf(" %02x %02x", HIBYTE(w), LOBYTE(w));
523 }
524 dbg_printf("\n");
525 }
526 dbg_printf("\n");
527 }
528
529 struct dump_proc_entry
530 {
531 PROCESSENTRY32 proc;
532 unsigned children; /* index in dump_proc.entries of first child */
533 unsigned sibling; /* index in dump_proc.entries of next sibling */
534 };
535
536 struct dump_proc
537 {
538 struct dump_proc_entry*entries;
539 unsigned count;
540 unsigned alloc;
541 };
542
543 static unsigned get_parent(const struct dump_proc* dp, unsigned idx)
544 {
545 unsigned i;
546
547 for (i = 0; i < dp->count; i++)
548 {
549 if (i != idx && dp->entries[i].proc.th32ProcessID == dp->entries[idx].proc.th32ParentProcessID)
550 return i;
551 }
552 return -1;
553 }
554
555 static void dump_proc_info(const struct dump_proc* dp, unsigned idx, unsigned depth)
556 {
557 struct dump_proc_entry* dpe;
558 char info;
559 for ( ; idx != -1; idx = dp->entries[idx].sibling)
560 {
561 assert(idx < dp->count);
562 dpe = &dp->entries[idx];
563 if (dbg_curr_process && dpe->proc.th32ProcessID == dbg_curr_process->pid)
564 info = '>';
565 else if (dpe->proc.th32ProcessID == GetCurrentProcessId())
566 info = '=';
567 else
568 info = ' ';
569 dbg_printf("%c%08lx %-8ld ", info, dpe->proc.th32ProcessID, dpe->proc.cntThreads);
570 if (depth)
571 {
572 unsigned i;
573 for (i = 3 * (depth - 1); i > 0; i--) dbg_printf(" ");
574 dbg_printf("\\_ ");
575 }
576 dbg_printf("'%s'\n", dpe->proc.szExeFile);
577 dump_proc_info(dp, dpe->children, depth + 1);
578 }
579 }
580
581 void info_win32_processes(void)
582 {
583 HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
584 if (snap != INVALID_HANDLE_VALUE)
585 {
586 struct dump_proc dp;
587 unsigned i, first = -1;
588 BOOL ok;
589
590 dp.count = 0;
591 dp.alloc = 16;
592 dp.entries = malloc(sizeof(*dp.entries) * dp.alloc);
593 if (!dp.entries)
594 {
595 CloseHandle(snap);
596 return;
597 }
598 dp.entries[dp.count].proc.dwSize = sizeof(dp.entries[dp.count].proc);
599 ok = Process32First(snap, &dp.entries[dp.count].proc);
600
601 /* fetch all process information into dp */
602 while (ok)
603 {
604 dp.entries[dp.count++].children = -1;
605 if (dp.count >= dp.alloc)
606 {
607 struct dump_proc_entry* new = realloc(dp.entries, sizeof(*dp.entries) * (dp.alloc * 2));
608 if (!new)
609 {
610 CloseHandle(snap);
611 free(dp.entries);
612 return;
613 }
614 dp.alloc *= 2;
615 dp.entries = new;
616 }
617 dp.entries[dp.count].proc.dwSize = sizeof(dp.entries[dp.count].proc);
618 ok = Process32Next(snap, &dp.entries[dp.count].proc);
619 }
620 CloseHandle(snap);
621 /* chain the siblings wrt. their parent */
622 for (i = 0; i < dp.count; i++)
623 {
624 unsigned parent = get_parent(&dp, i);
625 unsigned *chain = parent == -1 ? &first : &dp.entries[parent].children;
626 dp.entries[i].sibling = *chain;
627 *chain = i;
628 }
629 dbg_printf(" %-8.8s %-8.8s %s (all id:s are in hex)\n", "pid", "threads", "executable");
630 dump_proc_info(&dp, first, 0);
631 free(dp.entries);
632 }
633 }
634
635 static BOOL get_process_name(DWORD pid, PROCESSENTRY32W* entry)
636 {
637 BOOL ret = FALSE;
638 HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
639
640 if (snap != INVALID_HANDLE_VALUE)
641 {
642 entry->dwSize = sizeof(*entry);
643 if (Process32FirstW(snap, entry))
644 while (!(ret = (entry->th32ProcessID == pid)) &&
645 Process32NextW(snap, entry));
646 CloseHandle(snap);
647 }
648 return ret;
649 }
650
651 WCHAR* fetch_thread_description(DWORD tid)
652 {
653 static HRESULT (WINAPI *my_GetThreadDescription)(HANDLE, PWSTR*) = NULL;
654 static BOOL resolved = FALSE;
655 HANDLE h;
656 WCHAR* desc = NULL;
657
658 if (!resolved)
659 {
660 HMODULE kernelbase = GetModuleHandleA("kernelbase.dll");
661 if (kernelbase)
662 my_GetThreadDescription = (void *)GetProcAddress(kernelbase, "GetThreadDescription");
663 resolved = TRUE;
664 }
665
666 if (!my_GetThreadDescription)
667 return NULL;
668
669 h = OpenThread(THREAD_QUERY_LIMITED_INFORMATION, FALSE, tid);
670 if (!h)
671 return NULL;
672
673 my_GetThreadDescription(h, &desc);
674 CloseHandle(h);
675
676 if (desc && desc[0] == '\0')
677 {
678 LocalFree(desc);
679 return NULL;
680 }
681 return desc;
682 }
683
684 void info_win32_threads(void)
685 {
686 HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
687 if (snap != INVALID_HANDLE_VALUE)
688 {
689 THREADENTRY32 entry;
690 BOOL ok;
691 DWORD lastProcessId = 0;
692 struct dbg_process* p = NULL;
693 struct dbg_thread* t = NULL;
694 WCHAR *description;
695
696 entry.dwSize = sizeof(entry);
697 ok = Thread32First(snap, &entry);
698
699 dbg_printf("%-8.8s %-8.8s %s %s (all IDs are in hex)\n",
700 "process", "tid", "prio", "name");
701 while (ok)
702 {
703 if (entry.th32OwnerProcessID != GetCurrentProcessId())
704 {
705 /* FIXME: this assumes that, in the snapshot, all threads of a same process are
706 * listed sequentially, which is not specified in the doc (Wine's implementation
707 * does it)
708 */
709 if (entry.th32OwnerProcessID != lastProcessId)
710 {
711 PROCESSENTRY32W pcs_entry;
712 const WCHAR* exename;
713
714 p = dbg_get_process(entry.th32OwnerProcessID);
715 if (p)
716 exename = p->imageName;
717 else if (get_process_name(entry.th32OwnerProcessID, &pcs_entry))
718 exename = pcs_entry.szExeFile;
719 else
720 exename = L"";
721
722 dbg_printf("%08lx%s %ls\n",
723 entry.th32OwnerProcessID, p ? " (D)" : "", exename);
724 lastProcessId = entry.th32OwnerProcessID;
725 }
726 dbg_printf("\t%08lx %4ld%s ",
727 entry.th32ThreadID, entry.tpBasePri,
728 (entry.th32ThreadID == dbg_curr_tid) ? " <==" : " ");
729
730 if ((description = fetch_thread_description(entry.th32ThreadID)))
731 {
732 dbg_printf("%ls\n", description);
733 LocalFree(description);
734 }
735 else
736 {
737 t = dbg_get_thread(p, entry.th32ThreadID);
738 dbg_printf("%s\n", t ? t->name : "");
739 }
740 }
741 ok = Thread32Next(snap, &entry);
742 }
743
744 CloseHandle(snap);
745 }
746 }
747
748 /***********************************************************************
749 * info_win32_frame_exceptions
750 *
751 * Get info on the exception frames of a given thread.
752 */
753 void info_win32_frame_exceptions(DWORD tid)
754 {
755 struct dbg_thread* thread;
756 void* next_frame;
757
758 if (!dbg_curr_process || !dbg_curr_thread)
759 {
760 dbg_printf("Cannot get info on exceptions while no process is loaded\n");
761 return;
762 }
763
764 dbg_printf("Exception frames:\n");
765
766 if (tid == dbg_curr_tid) thread = dbg_curr_thread;
767 else
768 {
769 thread = dbg_get_thread(dbg_curr_process, tid);
770
771 if (!thread)
772 {
773 dbg_printf("Unknown thread id (%04lx) in current process\n", tid);
774 return;
775 }
776 if (SuspendThread(thread->handle) == -1)
777 {
778 dbg_printf("Can't suspend thread id (%04lx)\n", tid);
779 return;
780 }
781 }
782
783 if (!dbg_read_memory(thread->teb, &next_frame, sizeof(next_frame)))
784 {
785 dbg_printf("Can't read TEB:except_frame\n");
786 return;
787 }
788
789 while (next_frame != (void*)-1)
790 {
791 EXCEPTION_REGISTRATION_RECORD frame;
792
793 dbg_printf("%p: ", next_frame);
794 if (!dbg_read_memory(next_frame, &frame, sizeof(frame)))
795 {
796 dbg_printf("Invalid frame address\n");
797 break;
798 }
799 dbg_printf("prev=%p handler=%p\n", frame.Prev, frame.Handler);
800 next_frame = frame.Prev;
801 }
802
803 if (tid != dbg_curr_tid) ResumeThread(thread->handle);
804 }
805
806 void info_win32_segments(DWORD start, int length)
807 {
808 char flags[3];
809 DWORD i;
810 LDT_ENTRY le;
811
812 if (length == -1) length = (8192 - start);
813
814 for (i = start; i < start + length; i++)
815 {
816 if (!dbg_curr_process->process_io->get_selector(dbg_curr_thread->handle, (i << 3) | 7, &le))
817 continue;
818
819 if (le.HighWord.Bits.Type & 0x08)
820 {
821 flags[0] = (le.HighWord.Bits.Type & 0x2) ? 'r' : '-';
822 flags[1] = '-';
823 flags[2] = 'x';
824 }
825 else
826 {
827 flags[0] = 'r';
828 flags[1] = (le.HighWord.Bits.Type & 0x2) ? 'w' : '-';
829 flags[2] = '-';
830 }
831 dbg_printf("%04lx: sel=%04lx base=%08x limit=%08x %d-bit %c%c%c\n",
832 i, (i << 3) | 7,
833 (le.HighWord.Bits.BaseHi << 24) +
834 (le.HighWord.Bits.BaseMid << 16) + le.BaseLow,
835 ((le.HighWord.Bits.LimitHi << 8) + le.LimitLow) <<
836 (le.HighWord.Bits.Granularity ? 12 : 0),
837 le.HighWord.Bits.Default_Big ? 32 : 16,
838 flags[0], flags[1], flags[2]);
839 }
840 }
841
842 void info_win32_virtual(DWORD pid)
843 {
844 MEMORY_BASIC_INFORMATION mbi;
845 char* addr = 0;
846 const char* state;
847 const char* type;
848 char prot[3+1];
849 HANDLE hProc;
850
851 if (pid == dbg_curr_pid)
852 {
853 if (dbg_curr_process == NULL)
854 {
855 dbg_printf("Cannot look at mapping of current process, while no process is loaded\n");
856 return;
857 }
858 hProc = dbg_curr_process->handle;
859 }
860 else
861 {
862 hProc = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);
863 if (hProc == NULL)
864 {
865 dbg_printf("Cannot open process <%04lx>\n", pid);
866 return;
867 }
868 }
869
870 dbg_printf("Address End State Type RWX\n");
871
872 while (VirtualQueryEx(hProc, addr, &mbi, sizeof(mbi)) >= sizeof(mbi))
873 {
874 switch (mbi.State)
875 {
876 case MEM_COMMIT: state = "commit "; break;
877 case MEM_FREE: state = "free "; break;
878 case MEM_RESERVE: state = "reserve"; break;
879 default: state = "??? "; break;
880 }
881 if (mbi.State != MEM_FREE)
882 {
883 switch (mbi.Type)
884 {
885 case MEM_IMAGE: type = "image "; break;
886 case MEM_MAPPED: type = "mapped "; break;
887 case MEM_PRIVATE: type = "private"; break;
888 case 0: type = " "; break;
889 default: type = "??? "; break;
890 }
891 memset(prot, ' ' , sizeof(prot) - 1);
892 prot[sizeof(prot) - 1] = '\0';
893 if (mbi.AllocationProtect & (PAGE_READONLY|PAGE_READWRITE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE|PAGE_WRITECOPY|PAGE_EXECUTE_WRITECOPY))
894 prot[0] = 'R';
895 if (mbi.AllocationProtect & (PAGE_READWRITE|PAGE_EXECUTE_READWRITE))
896 prot[1] = 'W';
897 if (mbi.AllocationProtect & (PAGE_WRITECOPY|PAGE_EXECUTE_WRITECOPY))
898 prot[1] = 'C';
899 if (mbi.AllocationProtect & (PAGE_EXECUTE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE|PAGE_EXECUTE_WRITECOPY))
900 prot[2] = 'X';
901 }
902 else
903 {
904 type = "";
905 prot[0] = '\0';
906 }
907 dbg_printf("%0*Ix %0*Ix %s %s %s\n",
908 ADDRWIDTH, (DWORD_PTR)addr, ADDRWIDTH, (DWORD_PTR)addr + mbi.RegionSize - 1, state, type, prot);
909 if (addr + mbi.RegionSize < addr) /* wrap around ? */
910 break;
911 addr += mbi.RegionSize;
912 }
913 if (pid != dbg_curr_pid) CloseHandle(hProc);
914 }
915
916 void info_wine_dbg_channel(BOOL turn_on, const char* cls, const char* name)
917 {
918 struct dbg_lvalue lvalue;
919 struct __wine_debug_channel channel;
920 unsigned char mask;
921 int done = 0;
922 BOOL bAll;
923 void* addr;
924
925 if (!dbg_curr_process || !dbg_curr_thread)
926 {
927 dbg_printf("Cannot set/get debug channels while no process is loaded\n");
928 return;
929 }
930
931 if (symbol_get_lvalue("debug_options", -1, &lvalue, FALSE) != sglv_found)
932 {
933 return;
934 }
935 addr = memory_to_linear_addr(&lvalue.addr);
936
937 if (!cls) mask = ~0;
938 else if (!strcmp(cls, "fixme")) mask = (1 << __WINE_DBCL_FIXME);
939 else if (!strcmp(cls, "err")) mask = (1 << __WINE_DBCL_ERR);
940 else if (!strcmp(cls, "warn")) mask = (1 << __WINE_DBCL_WARN);
941 else if (!strcmp(cls, "trace")) mask = (1 << __WINE_DBCL_TRACE);
942 else
943 {
944 dbg_printf("Unknown debug class %s\n", cls);
945 return;
946 }
947
948 bAll = !strcmp("all", name);
949 while (addr && dbg_read_memory(addr, &channel, sizeof(channel)))
950 {
951 if (!channel.name[0]) break;
952 if (bAll || !strcmp( channel.name, name ))
953 {
954 if (turn_on) channel.flags |= mask;
955 else channel.flags &= ~mask;
956 if (dbg_write_memory(addr, &channel, sizeof(channel))) done++;
957 }
958 addr = (struct __wine_debug_channel *)addr + 1;
959 }
960 if (!done) dbg_printf("Unable to find debug channel %s\n", name);
961 else WINE_TRACE("Changed %d channel instances\n", done);
962 }
963
964 void info_win32_exception(void)
965 {
966 const EXCEPTION_RECORD* rec;
967 ADDRESS64 addr;
968 char hexbuf[MAX_OFFSET_TO_STR_LEN];
969
970 if (!dbg_curr_thread->in_exception)
971 {
972 dbg_printf("Thread isn't in an exception\n");
973 return;
974 }
975 rec = &dbg_curr_thread->excpt_record;
976 memory_get_current_pc(&addr);
977
978 /* print some infos */
979 dbg_printf("%s: ",
980 dbg_curr_thread->first_chance ? "First chance exception" : "Unhandled exception");
981 switch (rec->ExceptionCode)
982 {
983 case EXCEPTION_BREAKPOINT:
984 dbg_printf("breakpoint");
985 break;
986 case EXCEPTION_SINGLE_STEP:
987 dbg_printf("single step");
988 break;
989 case EXCEPTION_INT_DIVIDE_BY_ZERO:
990 dbg_printf("divide by zero");
991 break;
992 case EXCEPTION_INT_OVERFLOW:
993 dbg_printf("overflow");
994 break;
995 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
996 dbg_printf("array bounds");
997 break;
998 case EXCEPTION_ILLEGAL_INSTRUCTION:
999 dbg_printf("illegal instruction");
1000 break;
1001 case EXCEPTION_STACK_OVERFLOW:
1002 dbg_printf("stack overflow");
1003 break;
1004 case EXCEPTION_PRIV_INSTRUCTION:
1005 dbg_printf("privileged instruction");
1006 break;
1007 case EXCEPTION_ACCESS_VIOLATION:
1008 if (rec->NumberParameters == 2)
1009 dbg_printf("page fault on %s access to 0x%0*Ix",
1010 rec->ExceptionInformation[0] == EXCEPTION_WRITE_FAULT ? "write" :
1011 rec->ExceptionInformation[0] == EXCEPTION_EXECUTE_FAULT ? "execute" : "read",
1012 ADDRWIDTH, rec->ExceptionInformation[1]);
1013 else
1014 dbg_printf("page fault");
1015 break;
1016 case EXCEPTION_DATATYPE_MISALIGNMENT:
1017 dbg_printf("Alignment");
1018 break;
1019 case DBG_CONTROL_C:
1020 dbg_printf("^C");
1021 break;
1022 case CONTROL_C_EXIT:
1023 dbg_printf("^C");
1024 break;
1025 case STATUS_POSSIBLE_DEADLOCK:
1026 {
1027 ADDRESS64 recaddr;
1028
1029 recaddr.Mode = AddrModeFlat;
1030 recaddr.Offset = rec->ExceptionInformation[0];
1031
1032 dbg_printf("wait failed on critical section ");
1033 print_address(&recaddr, FALSE);
1034 }
1035 break;
1036 case EXCEPTION_WINE_STUB:
1037 {
1038 char dll[64], name[256];
1039 memory_get_string(dbg_curr_process,
1040 (void*)rec->ExceptionInformation[0], TRUE, FALSE,
1041 dll, sizeof(dll));
1042 if (HIWORD(rec->ExceptionInformation[1]))
1043 memory_get_string(dbg_curr_process,
1044 (void*)rec->ExceptionInformation[1], TRUE, FALSE,
1045 name, sizeof(name));
1046 else
1047 sprintf( name, "%Id", rec->ExceptionInformation[1] );
1048 dbg_printf("unimplemented function %s.%s called", dll, name);
1049 }
1050 break;
1051 case EXCEPTION_WINE_ASSERTION:
1052 dbg_printf("assertion failed");
1053 break;
1054 case EXCEPTION_FLT_DENORMAL_OPERAND:
1055 dbg_printf("denormal float operand");
1056 break;
1057 case EXCEPTION_FLT_DIVIDE_BY_ZERO:
1058 dbg_printf("divide by zero");
1059 break;
1060 case EXCEPTION_FLT_INEXACT_RESULT:
1061 dbg_printf("inexact float result");
1062 break;
1063 case EXCEPTION_FLT_INVALID_OPERATION:
1064 dbg_printf("invalid float operation");
1065 break;
1066 case EXCEPTION_FLT_OVERFLOW:
1067 dbg_printf("floating point overflow");
1068 break;
1069 case EXCEPTION_FLT_UNDERFLOW:
1070 dbg_printf("floating point underflow");
1071 break;
1072 case EXCEPTION_FLT_STACK_CHECK:
1073 dbg_printf("floating point stack check");
1074 break;
1075 case EXCEPTION_WINE_CXX_EXCEPTION:
1076 if(rec->NumberParameters == 3 && rec->ExceptionInformation[0] == EXCEPTION_WINE_CXX_FRAME_MAGIC)
1077 dbg_printf("C++ exception(object = 0x%0*Ix, type = 0x%0*Ix)",
1078 ADDRWIDTH, rec->ExceptionInformation[1], ADDRWIDTH, rec->ExceptionInformation[2]);
1079 else if(rec->NumberParameters == 4 && rec->ExceptionInformation[0] == EXCEPTION_WINE_CXX_FRAME_MAGIC)
1080 dbg_printf("C++ exception(object = %p, type = %p, base = %p)",
1081 (void*)rec->ExceptionInformation[1], (void*)rec->ExceptionInformation[2],
1082 (void*)rec->ExceptionInformation[3]);
1083 else
1084 dbg_printf("C++ exception with strange parameter count %ld or magic 0x%0*Ix",
1085 rec->NumberParameters, ADDRWIDTH, rec->ExceptionInformation[0]);
1086 break;
1087 default:
1088 dbg_printf("0x%08lx", rec->ExceptionCode);
1089 break;
1090 }
1091 if (rec->ExceptionFlags & EH_STACK_INVALID)
1092 dbg_printf(", invalid program stack");
1093
1094 switch (addr.Mode)
1095 {
1096 case AddrModeFlat:
1097 dbg_printf(" in %s%ld-bit code (%s)",
1098 dbg_curr_process->is_wow64 ? "wow64 " : "",
1099 dbg_curr_process->be_cpu->pointer_size * 8,
1100 memory_offset_to_string(hexbuf, addr.Offset, 0));
1101 break;
1102 case AddrModeReal:
1103 dbg_printf(" in vm86 code (%04x:%04x)", addr.Segment, (unsigned) addr.Offset);
1104 break;
1105 case AddrMode1616:
1106 dbg_printf(" in 16-bit code (%04x:%04x)", addr.Segment, (unsigned) addr.Offset);
1107 break;
1108 case AddrMode1632:
1109 dbg_printf(" in segmented 32-bit code (%04x:%08x)", addr.Segment, (unsigned) addr.Offset);
1110 break;
1111 default: dbg_printf(" bad address");
1112 }
1113 dbg_printf(".\n");
1114 }
1115
1116 static const struct
1117 {
1118 int type;
1119 int platform;
1120 int major;
1121 int minor;
1122 const char *str;
1123 }
1124 version_table[] =
1125 {
1126 { 0, VER_PLATFORM_WIN32s, 2, 0, "2.0" },
1127 { 0, VER_PLATFORM_WIN32s, 3, 0, "3.0" },
1128 { 0, VER_PLATFORM_WIN32s, 3, 10, "3.1" },
1129 { 0, VER_PLATFORM_WIN32_WINDOWS, 4, 0, "95" },
1130 { 0, VER_PLATFORM_WIN32_WINDOWS, 4, 10, "98" },
1131 { 0, VER_PLATFORM_WIN32_WINDOWS, 4, 90, "ME" },
1132 { VER_NT_WORKSTATION, VER_PLATFORM_WIN32_NT, 3, 51, "NT 3.51" },
1133 { VER_NT_WORKSTATION, VER_PLATFORM_WIN32_NT, 4, 0, "NT 4.0" },
1134 { VER_NT_WORKSTATION, VER_PLATFORM_WIN32_NT, 5, 0, "2000" },
1135 { VER_NT_WORKSTATION, VER_PLATFORM_WIN32_NT, 5, 1, "XP" },
1136 { VER_NT_WORKSTATION, VER_PLATFORM_WIN32_NT, 5, 2, "XP" },
1137 { VER_NT_SERVER, VER_PLATFORM_WIN32_NT, 5, 2, "Server 2003" },
1138 { VER_NT_WORKSTATION, VER_PLATFORM_WIN32_NT, 6, 0, "Vista" },
1139 { VER_NT_SERVER, VER_PLATFORM_WIN32_NT, 6, 0, "Server 2008" },
1140 { VER_NT_WORKSTATION, VER_PLATFORM_WIN32_NT, 6, 1, "7" },
1141 { VER_NT_SERVER, VER_PLATFORM_WIN32_NT, 6, 1, "Server 2008 R2" },
1142 { VER_NT_WORKSTATION, VER_PLATFORM_WIN32_NT, 6, 2, "8" },
1143 { VER_NT_SERVER, VER_PLATFORM_WIN32_NT, 6, 2, "Server 2012" },
1144 { VER_NT_WORKSTATION, VER_PLATFORM_WIN32_NT, 6, 3, "8.1" },
1145 { VER_NT_SERVER, VER_PLATFORM_WIN32_NT, 6, 3, "Server 2012 R2" },
1146 { VER_NT_WORKSTATION, VER_PLATFORM_WIN32_NT, 10, 0, "10" },
1147 };
1148
1149 static const char *get_windows_version(void)
1150 {
1151 RTL_OSVERSIONINFOEXW info = { sizeof(RTL_OSVERSIONINFOEXW) };
1152 static char str[64];
1153 int i;
1154
1155 RtlGetVersion( &info );
1156
1157 for (i = 0; i < ARRAY_SIZE(version_table); i++)
1158 {
1159 if (version_table[i].type == info.wProductType &&
1160 version_table[i].platform == info.dwPlatformId &&
1161 version_table[i].major == info.dwMajorVersion &&
1162 version_table[i].minor == info.dwMinorVersion)
1163 {
1164 return version_table[i].str;
1165 }
1166 }
1167
1168 snprintf( str, sizeof(str), "%ld.%ld (%d)", info.dwMajorVersion,
1169 info.dwMinorVersion, info.wProductType );
1170 return str;
1171 }
1172
1173 static BOOL is_guest(USHORT native, USHORT guest)
1174 {
1175 BOOLEAN supported;
1176
1177 return native != guest && !RtlWow64IsWowGuestMachineSupported(guest, &supported) && supported;
1178 }
1179
1180 void info_win32_system(void)
1181 {
1182 USHORT current, native;
1183 int i, count;
1184
1185 const char *(CDECL *wine_get_build_id)(void);
1186 void (CDECL *wine_get_host_version)( const char **sysname, const char **release );
1187
1188 static USHORT guest_machines[] =
1189 {
1190 IMAGE_FILE_MACHINE_I386, IMAGE_FILE_MACHINE_ARM, IMAGE_FILE_MACHINE_ARMNT,
1191 };
1192
1193 wine_get_build_id = (void *)GetProcAddress(GetModuleHandleA("ntdll.dll"), "wine_get_build_id");
1194 wine_get_host_version = (void *)GetProcAddress(GetModuleHandleA("ntdll.dll"), "wine_get_host_version");
1195
1196 RtlWow64GetProcessMachines( GetCurrentProcess(), &current, &native );
1197
1198 dbg_printf( "System information:\n" );
1199 if (wine_get_build_id) dbg_printf( " Wine build: %s\n", wine_get_build_id() );
1200 dbg_printf( " Platform: %s", get_machine_str(native));
1201 for (count = i = 0; i < ARRAY_SIZE(guest_machines); i++)
1202 {
1203 if (is_guest(native, guest_machines[i]))
1204 {
1205 if (!count++) dbg_printf(" (guest:");
1206 dbg_printf(" %s", get_machine_str(guest_machines[i]));
1207 }
1208 }
1209 dbg_printf("%s\n", count ? ")" : "");
1210
1211 dbg_printf( " Version: Windows %s\n", get_windows_version() );
1212 if (wine_get_host_version)
1213 {
1214 const char *sysname, *release;
1215 wine_get_host_version( &sysname, &release );
1216 dbg_printf( " Host system: %s\n", sysname );
1217 dbg_printf( " Host version: %s\n", release );
1218 }
1219 }
Windows API implementation