?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
include: Specify calling convention explicitly in idl files where needed.
[wine/hramrach.git] / programs / winedbg / info.c
bloba09af5d167ead42361b2e00241a330e2915d7aa5
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 "config.h"
23
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <string.h>
27 #include <stdarg.h>
28
29 #include "debugger.h"
30 #include "wingdi.h"
31 #include "winuser.h"
32 #include "tlhelp32.h"
33 #include "wine/debug.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
36
37 /***********************************************************************
38 * print_help
39 *
40 * Implementation of the 'help' command.
41 */
42 void print_help(void)
43 {
44 int i = 0;
45 static const char * const helptext[] =
46 {
47 "The commands accepted by the Wine debugger are a reasonable",
48 "subset of the commands that gdb accepts.",
49 "The commands currently are:",
50 " help quit",
51 " break [*<addr>] watch *<addr>",
52 " delete break bpnum disable bpnum",
53 " enable bpnum condition <bpnum> [<expr>]",
54 " finish cont [N]",
55 " step [N] next [N]",
56 " stepi [N] nexti [N]",
57 " x <addr> print <expr>",
58 " display <expr> undisplay <disnum>",
59 " local display <expr> delete display <disnum>",
60 " enable display <disnum> disable display <disnum>",
61 " bt [<tid>|all] frame <n>",
62 " up down",
63 " list <lines> disassemble [<addr>][,<addr>]",
64 " show dir dir <path>",
65 " set <reg> = <expr> set *<addr> = <expr>",
66 " pass whatis",
67 " info (see 'help info' for options)",
68
69 "The 'x' command accepts repeat counts and formats (including 'i') in the",
70 "same way that gdb does.\n",
71
72 "The following are examples of legal expressions:",
73 " $eax $eax+0x3 0x1000 ($eip + 256) *$eax *($esp + 3)",
74 " Also, a nm format symbol table can be read from a file using the",
75 " symbolfile command.", /* Symbols can also be defined individually with",
76 " the define command.", */
77 "",
78 NULL
79 };
80
81 while (helptext[i]) dbg_printf("%s\n", helptext[i++]);
82 }
83
84
85 /***********************************************************************
86 * info_help
87 *
88 * Implementation of the 'help info' command.
89 */
90 void info_help(void)
91 {
92 int i = 0;
93 static const char * const infotext[] =
94 {
95 "The info commands allow you to get assorted bits of interesting stuff",
96 "to be displayed. The options are:",
97 " info break Displays information about breakpoints",
98 " info class <name> Displays information about window class <name>",
99 " info display Shows auto-display expressions in use",
100 " info except <pid> Shows exception handler chain (in a given process)",
101 " info locals Displays values of all local vars for current frame",
102 " info maps <pid> Shows virtual mappings (in a given process)",
103 " info process Shows all running processes",
104 " info reg Displays values of the general registers at top of stack",
105 " info all-reg Displays the general and floating point registers",
106 " info segments <pid> Displays information about all known segments",
107 " info share Displays all loaded modules",
108 " info share <addr> Displays internal module state",
109 " info stack [<len>] Dumps information about top of stack, up to len words",
110 " info symbol <sym> Displays information about a given symbol",
111 " info thread Shows all running threads",
112 " info wnd <handle> Displays internal window state",
113 "",
114 NULL
115 };
116
117 while (infotext[i]) dbg_printf("%s\n", infotext[i++]);
118 }
119
120 static const char* get_symtype_str(const IMAGEHLP_MODULE64* mi)
121 {
122 switch (mi->SymType)
123 {
124 default:
125 case SymNone: return "--none--";
126 case SymCoff: return "COFF";
127 case SymCv: return "CodeView";
128 case SymPdb: return "PDB";
129 case SymExport: return "Export";
130 case SymDeferred: return "Deferred";
131 case SymSym: return "Sym";
132 case SymDia:
133 switch (mi->CVSig)
134 {
135 case 'S' | ('T' << 8) | ('A' << 16) | ('B' << 24):
136 return "Stabs";
137 case 'D' | ('W' << 8) | ('A' << 16) | ('R' << 24):
138 return "Dwarf";
139 default:
140 return "DIA";
141
142 }
143 }
144 }
145
146 struct info_module
147 {
148 IMAGEHLP_MODULE64* mi;
149 unsigned num_alloc;
150 unsigned num_used;
151 };
152
153 static void module_print_info(const IMAGEHLP_MODULE64* mi, BOOL is_embedded)
154 {
155 dbg_printf("%*.*s-%*.*s\t%-16s%s\n",
156 ADDRWIDTH, ADDRWIDTH, wine_dbgstr_longlong(mi->BaseOfImage),
157 ADDRWIDTH, ADDRWIDTH, wine_dbgstr_longlong(mi->BaseOfImage + mi->ImageSize),
158 is_embedded ? "\\" : get_symtype_str(mi), mi->ModuleName);
159 }
160
161 static int module_compare(const void* p1, const void* p2)
162 {
163 LONGLONG val = ((const IMAGEHLP_MODULE64*)p1)->BaseOfImage -
164 ((const IMAGEHLP_MODULE64*)p2)->BaseOfImage;
165 if (val < 0) return -1;
166 else if (val > 0) return 1;
167 else return 0;
168 }
169
170 static inline BOOL module_is_container(const IMAGEHLP_MODULE64* wmod_cntnr,
171 const IMAGEHLP_MODULE64* wmod_child)
172 {
173 return wmod_cntnr->BaseOfImage <= wmod_child->BaseOfImage &&
174 wmod_cntnr->BaseOfImage + wmod_cntnr->ImageSize >=
175 wmod_child->BaseOfImage + wmod_child->ImageSize;
176 }
177
178 static BOOL CALLBACK info_mod_cb(PCSTR mod_name, DWORD64 base, PVOID ctx)
179 {
180 struct info_module* im = ctx;
181
182 if (im->num_used + 1 > im->num_alloc)
183 {
184 im->num_alloc += 16;
185 im->mi = dbg_heap_realloc(im->mi, im->num_alloc * sizeof(*im->mi));
186 }
187 im->mi[im->num_used].SizeOfStruct = sizeof(im->mi[im->num_used]);
188 if (SymGetModuleInfo64(dbg_curr_process->handle, base, &im->mi[im->num_used]))
189 {
190 im->num_used++;
191 }
192 return TRUE;
193 }
194
195 /***********************************************************************
196 * info_win32_module
197 *
198 * Display information about a given module (DLL or EXE), or about all modules
199 */
200 void info_win32_module(DWORD64 base)
201 {
202 struct info_module im;
203 UINT i, j, num_printed = 0;
204 DWORD opt;
205
206 if (!dbg_curr_process)
207 {
208 dbg_printf("Cannot get info on module while no process is loaded\n");
209 return;
210 }
211
212 im.mi = NULL;
213 im.num_alloc = im.num_used = 0;
214
215 /* this is a wine specific options to return also ELF modules in the
216 * enumeration
217 */
218 SymSetOptions((opt = SymGetOptions()) | 0x40000000);
219 SymEnumerateModules64(dbg_curr_process->handle, info_mod_cb, (void*)&im);
220 SymSetOptions(opt);
221
222 qsort(im.mi, im.num_used, sizeof(im.mi[0]), module_compare);
223
224 dbg_printf("Module\tAddress\t\t\t%sDebug info\tName (%d modules)\n",
225 ADDRWIDTH == 16 ? "\t\t" : "", im.num_used);
226
227 for (i = 0; i < im.num_used; i++)
228 {
229 if (base &&
230 (base < im.mi[i].BaseOfImage || base >= im.mi[i].BaseOfImage + im.mi[i].ImageSize))
231 continue;
232 if (strstr(im.mi[i].ModuleName, "<elf>"))
233 {
234 dbg_printf("ELF\t");
235 module_print_info(&im.mi[i], FALSE);
236 /* print all modules embedded in this one */
237 for (j = 0; j < im.num_used; j++)
238 {
239 if (!strstr(im.mi[j].ModuleName, "<elf>") && module_is_container(&im.mi[i], &im.mi[j]))
240 {
241 dbg_printf(" \\-PE\t");
242 module_print_info(&im.mi[j], TRUE);
243 }
244 }
245 }
246 else
247 {
248 /* check module is not embedded in another module */
249 for (j = 0; j < im.num_used; j++)
250 {
251 if (strstr(im.mi[j].ModuleName, "<elf>") && module_is_container(&im.mi[j], &im.mi[i]))
252 break;
253 }
254 if (j < im.num_used) continue;
255 if (strstr(im.mi[i].ModuleName, ".so") || strchr(im.mi[i].ModuleName, '<'))
256 dbg_printf("ELF\t");
257 else
258 dbg_printf("PE\t");
259 module_print_info(&im.mi[i], FALSE);
260 }
261 num_printed++;
262 }
263 HeapFree(GetProcessHeap(), 0, im.mi);
264
265 if (base && !num_printed)
266 dbg_printf("'0x%x%08x' is not a valid module address\n", (DWORD)(base >> 32), (DWORD)base);
267 }
268
269 struct class_walker
270 {
271 ATOM* table;
272 int used;
273 int alloc;
274 };
275
276 static void class_walker(HWND hWnd, struct class_walker* cw)
277 {
278 char clsName[128];
279 int i;
280 ATOM atom;
281 HWND child;
282
283 if (!GetClassNameA(hWnd, clsName, sizeof(clsName)))
284 return;
285 if ((atom = FindAtomA(clsName)) == 0)
286 return;
287
288 for (i = 0; i < cw->used; i++)
289 {
290 if (cw->table[i] == atom)
291 break;
292 }
293 if (i == cw->used)
294 {
295 if (cw->used >= cw->alloc)
296 {
297 cw->alloc += 16;
298 cw->table = dbg_heap_realloc(cw->table, cw->alloc * sizeof(ATOM));
299 }
300 cw->table[cw->used++] = atom;
301 info_win32_class(hWnd, clsName);
302 }
303 do
304 {
305 if ((child = GetWindow(hWnd, GW_CHILD)) != 0)
306 class_walker(child, cw);
307 } while ((hWnd = GetWindow(hWnd, GW_HWNDNEXT)) != 0);
308 }
309
310 void info_win32_class(HWND hWnd, const char* name)
311 {
312 WNDCLASSEXA wca;
313 HINSTANCE hInst = hWnd ? (HINSTANCE)GetWindowLongPtrW(hWnd, GWLP_HINSTANCE) : 0;
314
315 if (!name)
316 {
317 struct class_walker cw;
318
319 cw.table = NULL;
320 cw.used = cw.alloc = 0;
321 class_walker(GetDesktopWindow(), &cw);
322 HeapFree(GetProcessHeap(), 0, cw.table);
323 return;
324 }
325
326 if (!GetClassInfoExA(hInst, name, &wca))
327 {
328 dbg_printf("Cannot find class '%s'\n", name);
329 return;
330 }
331
332 dbg_printf("Class '%s':\n", name);
333 dbg_printf("style=0x%08x wndProc=%p\n"
334 "inst=%p icon=%p cursor=%p bkgnd=%p\n"
335 "clsExtra=%d winExtra=%d\n",
336 wca.style, wca.lpfnWndProc, wca.hInstance,
337 wca.hIcon, wca.hCursor, wca.hbrBackground,
338 wca.cbClsExtra, wca.cbWndExtra);
339
340 if (hWnd && wca.cbClsExtra)
341 {
342 int i;
343 WORD w;
344
345 dbg_printf("Extra bytes:");
346 for (i = 0; i < wca.cbClsExtra / 2; i++)
347 {
348 w = GetClassWord(hWnd, i * 2);
349 /* FIXME: depends on i386 endian-ity */
350 dbg_printf(" %02x %02x", HIBYTE(w), LOBYTE(w));
351 }
352 dbg_printf("\n");
353 }
354 dbg_printf("\n");
355 /* FIXME:
356 * + print #windows (or even list of windows...)
357 * + print extra bytes => this requires a window handle on this very class...
358 */
359 }
360
361 static void info_window(HWND hWnd, int indent)
362 {
363 char clsName[128];
364 char wndName[128];
365 HWND child;
366
367 do
368 {
369 if (!GetClassNameA(hWnd, clsName, sizeof(clsName)))
370 strcpy(clsName, "-- Unknown --");
371 if (!GetWindowTextA(hWnd, wndName, sizeof(wndName)))
372 strcpy(wndName, "-- Empty --");
373
374 dbg_printf("%*s%08lx%*s %-17.17s %08x %0*lx %08x %.14s\n",
375 indent, "", (DWORD_PTR)hWnd, 12 - indent, "",
376 clsName, GetWindowLongW(hWnd, GWL_STYLE),
377 ADDRWIDTH, (ULONG_PTR)GetWindowLongPtrW(hWnd, GWLP_WNDPROC),
378 GetWindowThreadProcessId(hWnd, NULL), wndName);
379
380 if ((child = GetWindow(hWnd, GW_CHILD)) != 0)
381 info_window(child, indent + 1);
382 } while ((hWnd = GetWindow(hWnd, GW_HWNDNEXT)) != 0);
383 }
384
385 void info_win32_window(HWND hWnd, BOOL detailed)
386 {
387 char clsName[128];
388 char wndName[128];
389 RECT clientRect;
390 RECT windowRect;
391 WORD w;
392
393 if (!IsWindow(hWnd)) hWnd = GetDesktopWindow();
394
395 if (!detailed)
396 {
397 dbg_printf("%-20.20s %-17.17s %-8.8s %-*.*s %-8.8s %s\n",
398 "Window handle", "Class Name", "Style",
399 ADDRWIDTH, ADDRWIDTH, "WndProc", "Thread", "Text");
400 info_window(hWnd, 0);
401 return;
402 }
403
404 if (!GetClassNameA(hWnd, clsName, sizeof(clsName)))
405 strcpy(clsName, "-- Unknown --");
406 if (!GetWindowTextA(hWnd, wndName, sizeof(wndName)))
407 strcpy(wndName, "-- Empty --");
408 if (!GetClientRect(hWnd, &clientRect) ||
409 !MapWindowPoints(hWnd, 0, (LPPOINT) &clientRect, 2))
410 SetRectEmpty(&clientRect);
411 if (!GetWindowRect(hWnd, &windowRect))
412 SetRectEmpty(&windowRect);
413
414 /* FIXME missing fields: hmemTaskQ, hrgnUpdate, dce, flags, pProp, scroll */
415 dbg_printf("next=%p child=%p parent=%p owner=%p class='%s'\n"
416 "inst=%p active=%p idmenu=%08lx\n"
417 "style=0x%08x exstyle=0x%08x wndproc=%p text='%s'\n"
418 "client=%d,%d-%d,%d window=%d,%d-%d,%d sysmenu=%p\n",
419 GetWindow(hWnd, GW_HWNDNEXT),
420 GetWindow(hWnd, GW_CHILD),
421 GetParent(hWnd),
422 GetWindow(hWnd, GW_OWNER),
423 clsName,
424 (HINSTANCE)GetWindowLongPtrW(hWnd, GWLP_HINSTANCE),
425 GetLastActivePopup(hWnd),
426 (ULONG_PTR)GetWindowLongPtrW(hWnd, GWLP_ID),
427 GetWindowLongW(hWnd, GWL_STYLE),
428 GetWindowLongW(hWnd, GWL_EXSTYLE),
429 (void*)GetWindowLongPtrW(hWnd, GWLP_WNDPROC),
430 wndName,
431 clientRect.left, clientRect.top, clientRect.right, clientRect.bottom,
432 windowRect.left, windowRect.top, windowRect.right, windowRect.bottom,
433 GetSystemMenu(hWnd, FALSE));
434
435 if (GetClassLongW(hWnd, GCL_CBWNDEXTRA))
436 {
437 UINT i;
438
439 dbg_printf("Extra bytes:");
440 for (i = 0; i < GetClassLongW(hWnd, GCL_CBWNDEXTRA) / 2; i++)
441 {
442 w = GetWindowWord(hWnd, i * 2);
443 /* FIXME: depends on i386 endian-ity */
444 dbg_printf(" %02x %02x", HIBYTE(w), LOBYTE(w));
445 }
446 dbg_printf("\n");
447 }
448 dbg_printf("\n");
449 }
450
451 void info_win32_processes(void)
452 {
453 HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
454 if (snap != INVALID_HANDLE_VALUE)
455 {
456 PROCESSENTRY32 entry;
457 DWORD current = dbg_curr_process ? dbg_curr_process->pid : 0;
458 BOOL ok;
459
460 entry.dwSize = sizeof(entry);
461 ok = Process32First(snap, &entry);
462
463 dbg_printf(" %-8.8s %-8.8s %-8.8s %s (all id:s are in hex)\n",
464 "pid", "threads", "parent", "executable");
465 while (ok)
466 {
467 if (entry.th32ProcessID != GetCurrentProcessId())
468 dbg_printf("%c%08x %-8d %08x '%s'\n",
469 (entry.th32ProcessID == current) ? '>' : ' ',
470 entry.th32ProcessID, entry.cntThreads,
471 entry.th32ParentProcessID, entry.szExeFile);
472 ok = Process32Next(snap, &entry);
473 }
474 CloseHandle(snap);
475 }
476 }
477
478 static BOOL get_process_name(DWORD pid, PROCESSENTRY32* entry)
479 {
480 BOOL ret = FALSE;
481 HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
482
483 if (snap != INVALID_HANDLE_VALUE)
484 {
485 entry->dwSize = sizeof(*entry);
486 if (Process32First(snap, entry))
487 while (!(ret = (entry->th32ProcessID == pid)) &&
488 Process32Next(snap, entry));
489 CloseHandle(snap);
490 }
491 return ret;
492 }
493
494 void info_win32_threads(void)
495 {
496 HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
497 if (snap != INVALID_HANDLE_VALUE)
498 {
499 THREADENTRY32 entry;
500 BOOL ok;
501 DWORD lastProcessId = 0;
502
503 entry.dwSize = sizeof(entry);
504 ok = Thread32First(snap, &entry);
505
506 dbg_printf("%-8.8s %-8.8s %s (all id:s are in hex)\n",
507 "process", "tid", "prio");
508 while (ok)
509 {
510 if (entry.th32OwnerProcessID != GetCurrentProcessId())
511 {
512 /* FIXME: this assumes that, in the snapshot, all threads of a same process are
513 * listed sequentially, which is not specified in the doc (Wine's implementation
514 * does it)
515 */
516 if (entry.th32OwnerProcessID != lastProcessId)
517 {
518 struct dbg_process* p = dbg_get_process(entry.th32OwnerProcessID);
519 PROCESSENTRY32 pcs_entry;
520 const char* exename;
521
522 if (p)
523 exename = dbg_W2A(p->imageName, -1);
524 else if (get_process_name(entry.th32OwnerProcessID, &pcs_entry))
525 exename = pcs_entry.szExeFile;
526 else
527 exename = "";
528
529 dbg_printf("%08x%s %s\n",
530 entry.th32OwnerProcessID, p ? " (D)" : "", exename);
531 lastProcessId = entry.th32OwnerProcessID;
532 }
533 dbg_printf("\t%08x %4d%s\n",
534 entry.th32ThreadID, entry.tpBasePri,
535 (entry.th32ThreadID == dbg_curr_tid) ? " <==" : "");
536
537 }
538 ok = Thread32Next(snap, &entry);
539 }
540
541 CloseHandle(snap);
542 }
543 }
544
545 /***********************************************************************
546 * info_win32_exceptions
547 *
548 * Get info on the exception frames of a given thread.
549 */
550 void info_win32_exceptions(DWORD tid)
551 {
552 struct dbg_thread* thread;
553 void* next_frame;
554
555 if (!dbg_curr_process || !dbg_curr_thread)
556 {
557 dbg_printf("Cannot get info on exceptions while no process is loaded\n");
558 return;
559 }
560
561 dbg_printf("Exception frames:\n");
562
563 if (tid == dbg_curr_tid) thread = dbg_curr_thread;
564 else
565 {
566 thread = dbg_get_thread(dbg_curr_process, tid);
567
568 if (!thread)
569 {
570 dbg_printf("Unknown thread id (%04x) in current process\n", tid);
571 return;
572 }
573 if (SuspendThread(thread->handle) == -1)
574 {
575 dbg_printf("Can't suspend thread id (%04x)\n", tid);
576 return;
577 }
578 }
579
580 if (!dbg_read_memory(thread->teb, &next_frame, sizeof(next_frame)))
581 {
582 dbg_printf("Can't read TEB:except_frame\n");
583 return;
584 }
585
586 while (next_frame != (void*)-1)
587 {
588 EXCEPTION_REGISTRATION_RECORD frame;
589
590 dbg_printf("%p: ", next_frame);
591 if (!dbg_read_memory(next_frame, &frame, sizeof(frame)))
592 {
593 dbg_printf("Invalid frame address\n");
594 break;
595 }
596 dbg_printf("prev=%p handler=%p\n", frame.Prev, frame.Handler);
597 next_frame = frame.Prev;
598 }
599
600 if (tid != dbg_curr_tid) ResumeThread(thread->handle);
601 }
602
603 void info_win32_segments(DWORD start, int length)
604 {
605 char flags[3];
606 DWORD i;
607 LDT_ENTRY le;
608
609 if (length == -1) length = (8192 - start);
610
611 for (i = start; i < start + length; i++)
612 {
613 if (!dbg_curr_process->process_io->get_selector(dbg_curr_thread->handle, (i << 3) | 7, &le))
614 continue;
615
616 if (le.HighWord.Bits.Type & 0x08)
617 {
618 flags[0] = (le.HighWord.Bits.Type & 0x2) ? 'r' : '-';
619 flags[1] = '-';
620 flags[2] = 'x';
621 }
622 else
623 {
624 flags[0] = 'r';
625 flags[1] = (le.HighWord.Bits.Type & 0x2) ? 'w' : '-';
626 flags[2] = '-';
627 }
628 dbg_printf("%04x: sel=%04x base=%08x limit=%08x %d-bit %c%c%c\n",
629 i, (i << 3) | 7,
630 (le.HighWord.Bits.BaseHi << 24) +
631 (le.HighWord.Bits.BaseMid << 16) + le.BaseLow,
632 ((le.HighWord.Bits.LimitHi << 8) + le.LimitLow) <<
633 (le.HighWord.Bits.Granularity ? 12 : 0),
634 le.HighWord.Bits.Default_Big ? 32 : 16,
635 flags[0], flags[1], flags[2]);
636 }
637 }
638
639 void info_win32_virtual(DWORD pid)
640 {
641 MEMORY_BASIC_INFORMATION mbi;
642 char* addr = 0;
643 const char* state;
644 const char* type;
645 char prot[3+1];
646 HANDLE hProc;
647
648 if (pid == dbg_curr_pid)
649 {
650 if (dbg_curr_process == NULL)
651 {
652 dbg_printf("Cannot look at mapping of current process, while no process is loaded\n");
653 return;
654 }
655 hProc = dbg_curr_process->handle;
656 }
657 else
658 {
659 hProc = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);
660 if (hProc == NULL)
661 {
662 dbg_printf("Cannot open process <%04x>\n", pid);
663 return;
664 }
665 }
666
667 dbg_printf("Address End State Type RWX\n");
668
669 while (VirtualQueryEx(hProc, addr, &mbi, sizeof(mbi)) >= sizeof(mbi))
670 {
671 switch (mbi.State)
672 {
673 case MEM_COMMIT: state = "commit "; break;
674 case MEM_FREE: state = "free "; break;
675 case MEM_RESERVE: state = "reserve"; break;
676 default: state = "??? "; break;
677 }
678 if (mbi.State != MEM_FREE)
679 {
680 switch (mbi.Type)
681 {
682 case MEM_IMAGE: type = "image "; break;
683 case MEM_MAPPED: type = "mapped "; break;
684 case MEM_PRIVATE: type = "private"; break;
685 case 0: type = " "; break;
686 default: type = "??? "; break;
687 }
688 memset(prot, ' ' , sizeof(prot) - 1);
689 prot[sizeof(prot) - 1] = '\0';
690 if (mbi.AllocationProtect & (PAGE_READONLY|PAGE_READWRITE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE))
691 prot[0] = 'R';
692 if (mbi.AllocationProtect & (PAGE_READWRITE|PAGE_EXECUTE_READWRITE))
693 prot[1] = 'W';
694 if (mbi.AllocationProtect & (PAGE_WRITECOPY|PAGE_EXECUTE_WRITECOPY))
695 prot[1] = 'C';
696 if (mbi.AllocationProtect & (PAGE_EXECUTE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE))
697 prot[2] = 'X';
698 }
699 else
700 {
701 type = "";
702 prot[0] = '\0';
703 }
704 dbg_printf("%08lx %08lx %s %s %s\n",
705 (DWORD_PTR)addr, (DWORD_PTR)addr + mbi.RegionSize - 1, state, type, prot);
706 if (addr + mbi.RegionSize < addr) /* wrap around ? */
707 break;
708 addr += mbi.RegionSize;
709 }
710 if (pid != dbg_curr_pid) CloseHandle(hProc);
711 }
712
713 void info_wine_dbg_channel(BOOL turn_on, const char* cls, const char* name)
714 {
715 struct dbg_lvalue lvalue;
716 struct __wine_debug_channel channel;
717 unsigned char mask;
718 int done = 0;
719 BOOL bAll;
720 void* addr;
721
722 if (!dbg_curr_process || !dbg_curr_thread)
723 {
724 dbg_printf("Cannot set/get debug channels while no process is loaded\n");
725 return;
726 }
727
728 if (symbol_get_lvalue("debug_options", -1, &lvalue, FALSE) != sglv_found)
729 {
730 return;
731 }
732 addr = memory_to_linear_addr(&lvalue.addr);
733
734 if (!cls) mask = ~0;
735 else if (!strcmp(cls, "fixme")) mask = (1 << __WINE_DBCL_FIXME);
736 else if (!strcmp(cls, "err")) mask = (1 << __WINE_DBCL_ERR);
737 else if (!strcmp(cls, "warn")) mask = (1 << __WINE_DBCL_WARN);
738 else if (!strcmp(cls, "trace")) mask = (1 << __WINE_DBCL_TRACE);
739 else
740 {
741 dbg_printf("Unknown debug class %s\n", cls);
742 return;
743 }
744
745 bAll = !strcmp("all", name);
746 while (addr && dbg_read_memory(addr, &channel, sizeof(channel)))
747 {
748 if (!channel.name[0]) break;
749 if (bAll || !strcmp( channel.name, name ))
750 {
751 if (turn_on) channel.flags |= mask;
752 else channel.flags &= ~mask;
753 if (dbg_write_memory(addr, &channel, sizeof(channel))) done++;
754 }
755 addr = (struct __wine_debug_channel *)addr + 1;
756 }
757 if (!done) dbg_printf("Unable to find debug channel %s\n", name);
758 else WINE_TRACE("Changed %d channel instances\n", done);
759 }
an attempt at megring old patches into wine