wine/programs/winedbg/info.c
2005-02-14 11:04:15 +00:00

736 lines
24 KiB
C

/*
* Wine debugger utility routines
*
* Copyright 1993 Eric Youngdale
* Copyright 1995 Alexandre Julliard
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "config.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include "debugger.h"
#include "wingdi.h"
#include "winuser.h"
#include "tlhelp32.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
/***********************************************************************
* print_help
*
* Implementation of the 'help' command.
*/
void print_help(void)
{
int i = 0;
static const char * const helptext[] =
{
"The commands accepted by the Wine debugger are a reasonable",
"subset of the commands that gdb accepts.",
"The commands currently are:",
" help quit",
" break [*<addr>] watch *<addr>",
" delete break bpnum disable bpnum",
" enable bpnum condition <bpnum> [<expr>]",
" finish cont [N]",
" step [N] next [N]",
" stepi [N] nexti [N]",
" x <addr> print <expr>",
" display <expr> undisplay <disnum>",
" local display <expr> delete display <disnum>",
" enable display <disnum> disable display <disnum>",
" bt [<tid>|all] frame <n>",
" up down",
" list <lines> disassemble [<addr>][,<addr>]",
" show dir dir <path>",
" set <reg> = <expr> set *<addr> = <expr>",
" mode [16,32,vm86] pass",
" whatis info (see 'help info' for options)",
"The 'x' command accepts repeat counts and formats (including 'i') in the",
"same way that gdb does.\n",
"The following are examples of legal expressions:",
" $eax $eax+0x3 0x1000 ($eip + 256) *$eax *($esp + 3)",
" Also, a nm format symbol table can be read from a file using the",
" symbolfile command.", /* Symbols can also be defined individually with",
" the define command.", */
"",
NULL
};
while (helptext[i]) dbg_printf("%s\n", helptext[i++]);
}
/***********************************************************************
* info_help
*
* Implementation of the 'help info' command.
*/
void info_help(void)
{
int i = 0;
static const char * const infotext[] =
{
"The info commands allow you to get assorted bits of interesting stuff",
"to be displayed. The options are:",
" info break Displays information about breakpoints",
" info class <name> Displays information about window class <name>",
" info display Shows auto-display expressions in use",
" info except <pid> Shows exception handler chain (in a given process)",
" info locals Displays values of all local vars for current frame",
" info maps <pid> Shows virtual mappings (in a given process)",
" info process Shows all running processes",
" info reg Displays values in all registers at top of stack",
" info segments <pid> Displays information about all known segments",
" info share Displays all loaded modules",
" info share <addr> Displays internal module state",
" info stack Dumps information about top of stack",
" info symbol <sym> Displays information about a given symbol",
" info thread Shows all running threads",
" info wnd <handle> Displays internal window state",
"",
NULL
};
while (infotext[i]) dbg_printf("%s\n", infotext[i++]);
}
static const char* get_symtype_str(SYM_TYPE st)
{
switch (st)
{
case -1: return "\\";
default:
case SymNone: return "--none--";
case SymCoff: return "COFF";
case SymCv: return "CodeView";
case SymPdb: return "PDB";
case SymExport: return "Export";
case SymDeferred: return "Deferred";
case SymSym: return "Sym";
case SymDia: return "DIA";
case NumSymTypes: return "Stabs";
}
}
struct info_module
{
IMAGEHLP_MODULE* mi;
unsigned num_alloc;
unsigned num_used;
};
static void module_print_info(const IMAGEHLP_MODULE* mi, SYM_TYPE st)
{
dbg_printf("0x%08lx-%08lx\t%-16s%s\n",
mi->BaseOfImage, mi->BaseOfImage + mi->ImageSize,
get_symtype_str(st), mi->ModuleName);
}
static int module_compare(const void* p1, const void* p2)
{
return (char*)(((const IMAGEHLP_MODULE*)p1)->BaseOfImage) -
(char*)(((const IMAGEHLP_MODULE*)p2)->BaseOfImage);
}
static inline BOOL module_is_container(const IMAGEHLP_MODULE* wmod_cntnr,
const IMAGEHLP_MODULE* wmod_child)
{
return wmod_cntnr->BaseOfImage <= wmod_child->BaseOfImage &&
(DWORD)wmod_cntnr->BaseOfImage + wmod_cntnr->ImageSize >=
(DWORD)wmod_child->BaseOfImage + wmod_child->ImageSize;
}
static BOOL CALLBACK info_mod_cb(PSTR mod_name, DWORD base, void* ctx)
{
struct info_module* im = (struct info_module*)ctx;
if (im->num_used + 1 > im->num_alloc)
{
im->num_alloc += 16;
im->mi = dbg_heap_realloc(im->mi, im->num_alloc * sizeof(*im->mi));
}
im->mi[im->num_used].SizeOfStruct = sizeof(im->mi[im->num_used]);
if (SymGetModuleInfo(dbg_curr_process->handle, base, &im->mi[im->num_used]))
{
im->num_used++;
}
return TRUE;
}
/***********************************************************************
* info_win32_module
*
* Display information about a given module (DLL or EXE), or about all modules
*/
void info_win32_module(DWORD base)
{
if (!dbg_curr_process || !dbg_curr_thread)
{
dbg_printf("Cannot get info on module while no process is loaded\n");
return;
}
if (base)
{
IMAGEHLP_MODULE mi;
mi.SizeOfStruct = sizeof(mi);
if (!SymGetModuleInfo(dbg_curr_process->handle, base, &mi))
{
dbg_printf("'0x%08lx' is not a valid module address\n", base);
return;
}
module_print_info(&mi, mi.SymType);
}
else
{
struct info_module im;
int i, j;
DWORD opt;
im.mi = NULL;
im.num_alloc = im.num_used = 0;
/* this is a wine specific options to return also ELF modules in the
* enumeration
*/
SymSetOptions((opt = SymGetOptions()) | 0x40000000);
SymEnumerateModules(dbg_curr_process->handle, info_mod_cb, (void*)&im);
SymSetOptions(opt);
qsort(im.mi, im.num_used, sizeof(im.mi[0]), module_compare);
dbg_printf("Module\tAddress\t\t\tDebug info\tName (%d modules)\n", im.num_used);
for (i = 0; i < im.num_used; i++)
{
if (strstr(im.mi[i].ModuleName, "<elf>"))
{
dbg_printf("ELF\t");
module_print_info(&im.mi[i], (im.mi[i].SymType == SymDia) ? NumSymTypes : im.mi[i].SymType);
/* print all modules embedded in this one */
for (j = 0; j < im.num_used; j++)
{
if (!strstr(im.mi[j].ModuleName, "<elf>") && module_is_container(&im.mi[i], &im.mi[j]))
{
dbg_printf(" \\-PE\t");
module_print_info(&im.mi[j], -1);
}
}
}
else
{
/* check module is not embedded in another module */
for (j = 0; j < im.num_used; j++)
{
if (strstr(im.mi[j].ModuleName, "<elf>") && module_is_container(&im.mi[j], &im.mi[i]))
break;
}
if (j < im.num_used) continue;
if (strstr(im.mi[i].ModuleName, ".so") || strchr(im.mi[i].ModuleName, '<'))
dbg_printf("ELF\t");
else
dbg_printf("PE\t");
module_print_info(&im.mi[i], im.mi[i].SymType);
}
}
HeapFree(GetProcessHeap(), 0, im.mi);
}
}
struct class_walker
{
ATOM* table;
int used;
int alloc;
};
static void class_walker(HWND hWnd, struct class_walker* cw)
{
char clsName[128];
int i;
ATOM atom;
HWND child;
if (!GetClassName(hWnd, clsName, sizeof(clsName)))
return;
if ((atom = FindAtom(clsName)) == 0)
return;
for (i = 0; i < cw->used; i++)
{
if (cw->table[i] == atom)
break;
}
if (i == cw->used)
{
if (cw->used >= cw->alloc)
{
cw->alloc += 16;
cw->table = dbg_heap_realloc(cw->table, cw->alloc * sizeof(ATOM));
}
cw->table[cw->used++] = atom;
info_win32_class(hWnd, clsName);
}
do
{
if ((child = GetWindow(hWnd, GW_CHILD)) != 0)
class_walker(child, cw);
} while ((hWnd = GetWindow(hWnd, GW_HWNDNEXT)) != 0);
}
void info_win32_class(HWND hWnd, const char* name)
{
WNDCLASSEXA wca;
HINSTANCE hInst = hWnd ? (HINSTANCE)GetWindowLong(hWnd, GWL_HINSTANCE) : 0;
if (!name)
{
struct class_walker cw;
cw.table = NULL;
cw.used = cw.alloc = 0;
class_walker(GetDesktopWindow(), &cw);
HeapFree(GetProcessHeap(), 0, cw.table);
return;
}
if (!GetClassInfoEx(hInst, name, &wca))
{
dbg_printf("Cannot find class '%s'\n", name);
return;
}
dbg_printf("Class '%s':\n", name);
dbg_printf("style=0x%08x wndProc=0x%08lx\n"
"inst=%p icon=%p cursor=%p bkgnd=%p\n"
"clsExtra=%d winExtra=%d\n",
wca.style, (DWORD)wca.lpfnWndProc, wca.hInstance,
wca.hIcon, wca.hCursor, wca.hbrBackground,
wca.cbClsExtra, wca.cbWndExtra);
if (hWnd && wca.cbClsExtra)
{
int i;
WORD w;
dbg_printf("Extra bytes:");
for (i = 0; i < wca.cbClsExtra / 2; i++)
{
w = GetClassWord(hWnd, i * 2);
/* FIXME: depends on i386 endian-ity */
dbg_printf(" %02x %02x", HIBYTE(w), LOBYTE(w));
}
dbg_printf("\n");
}
dbg_printf("\n");
/* FIXME:
* + print #windows (or even list of windows...)
* + print extra bytes => this requires a window handle on this very class...
*/
}
static void info_window(HWND hWnd, int indent)
{
char clsName[128];
char wndName[128];
HWND child;
do
{
if (!GetClassName(hWnd, clsName, sizeof(clsName)))
strcpy(clsName, "-- Unknown --");
if (!GetWindowText(hWnd, wndName, sizeof(wndName)))
strcpy(wndName, "-- Empty --");
dbg_printf("%*s%08x%*s %-17.17s %08lx %08lx %08lx %.14s\n",
indent, "", (UINT)hWnd, 12 - indent, "",
clsName, GetWindowLong(hWnd, GWL_STYLE),
GetWindowLong(hWnd, GWL_WNDPROC),
GetWindowThreadProcessId(hWnd, NULL), wndName);
if ((child = GetWindow(hWnd, GW_CHILD)) != 0)
info_window(child, indent + 1);
} while ((hWnd = GetWindow(hWnd, GW_HWNDNEXT)) != 0);
}
void info_win32_window(HWND hWnd, BOOL detailed)
{
char clsName[128];
char wndName[128];
RECT clientRect;
RECT windowRect;
int i;
WORD w;
if (!IsWindow(hWnd)) hWnd = GetDesktopWindow();
if (!detailed)
{
dbg_printf("%-20.20s %-17.17s %-8.8s %-8.8s %-8.8s %s\n",
"Window handle", "Class Name", "Style", "WndProc", "Thread", "Text");
info_window(hWnd, 0);
return;
}
if (!GetClassName(hWnd, clsName, sizeof(clsName)))
strcpy(clsName, "-- Unknown --");
if (!GetWindowText(hWnd, wndName, sizeof(wndName)))
strcpy(wndName, "-- Empty --");
if (!GetClientRect(hWnd, &clientRect) ||
!MapWindowPoints(hWnd, 0, (LPPOINT) &clientRect, 2))
SetRectEmpty(&clientRect);
if (!GetWindowRect(hWnd, &windowRect))
SetRectEmpty(&windowRect);
/* FIXME missing fields: hmemTaskQ, hrgnUpdate, dce, flags, pProp, scroll */
dbg_printf("next=%p child=%p parent=%p owner=%p class='%s'\n"
"inst=%p active=%p idmenu=%08lx\n"
"style=0x%08lx exstyle=0x%08lx wndproc=0x%08lx text='%s'\n"
"client=%ld,%ld-%ld,%ld window=%ld,%ld-%ld,%ld sysmenu=%p\n",
GetWindow(hWnd, GW_HWNDNEXT),
GetWindow(hWnd, GW_CHILD),
GetParent(hWnd),
GetWindow(hWnd, GW_OWNER),
clsName,
(HINSTANCE)GetWindowLong(hWnd, GWL_HINSTANCE),
GetLastActivePopup(hWnd),
GetWindowLong(hWnd, GWL_ID),
GetWindowLong(hWnd, GWL_STYLE),
GetWindowLong(hWnd, GWL_EXSTYLE),
GetWindowLong(hWnd, GWL_WNDPROC),
wndName,
clientRect.left, clientRect.top, clientRect.right, clientRect.bottom,
windowRect.left, windowRect.top, windowRect.right, windowRect.bottom,
GetSystemMenu(hWnd, FALSE));
if (GetClassLong(hWnd, GCL_CBWNDEXTRA))
{
dbg_printf("Extra bytes:");
for (i = 0; i < GetClassLong(hWnd, GCL_CBWNDEXTRA) / 2; i++)
{
w = GetWindowWord(hWnd, i * 2);
/* FIXME: depends on i386 endian-ity */
dbg_printf(" %02x %02x", HIBYTE(w), LOBYTE(w));
}
dbg_printf("\n");
}
dbg_printf("\n");
}
void info_win32_processes(void)
{
HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (snap != INVALID_HANDLE_VALUE)
{
PROCESSENTRY32 entry;
DWORD current = dbg_curr_process ? dbg_curr_process->pid : 0;
BOOL ok;
entry.dwSize = sizeof(entry);
ok = Process32First(snap, &entry);
dbg_printf(" %-8.8s %-8.8s %-8.8s %s (all id:s are in hex)\n",
"pid", "threads", "parent", "executable");
while (ok)
{
if (entry.th32ProcessID != GetCurrentProcessId())
dbg_printf("%c%08lx %-8ld %08lx '%s'\n",
(entry.th32ProcessID == current) ? '>' : ' ',
entry.th32ProcessID, entry.cntThreads,
entry.th32ParentProcessID, entry.szExeFile);
ok = Process32Next(snap, &entry);
}
CloseHandle(snap);
}
}
void info_win32_threads(void)
{
HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
if (snap != INVALID_HANDLE_VALUE)
{
THREADENTRY32 entry;
BOOL ok;
DWORD lastProcessId = 0;
entry.dwSize = sizeof(entry);
ok = Thread32First(snap, &entry);
dbg_printf("%-8.8s %-8.8s %s (all id:s are in hex)\n",
"process", "tid", "prio");
while (ok)
{
if (entry.th32OwnerProcessID != GetCurrentProcessId())
{
/* FIXME: this assumes that, in the snapshot, all threads of a same process are
* listed sequentially, which is not specified in the doc (Wine's implementation
* does it)
*/
if (entry.th32OwnerProcessID != lastProcessId)
{
struct dbg_process* p = dbg_get_process(entry.th32OwnerProcessID);
dbg_printf("%08lx%s %s\n",
entry.th32OwnerProcessID, p ? " (D)" : "", p ? p->imageName : "");
lastProcessId = entry.th32OwnerProcessID;
}
dbg_printf("\t%08lx %4ld%s\n",
entry.th32ThreadID, entry.tpBasePri,
(entry.th32ThreadID == dbg_curr_tid) ? " <==" : "");
}
ok = Thread32Next(snap, &entry);
}
CloseHandle(snap);
}
}
/***********************************************************************
* info_win32_exceptions
*
* Get info on the exception frames of a given thread.
*/
void info_win32_exceptions(DWORD tid)
{
struct dbg_thread* thread;
void* next_frame;
if (!dbg_curr_process || !dbg_curr_thread)
{
dbg_printf("Cannot get info on exceptions while no process is loaded\n");
return;
}
dbg_printf("Exception frames:\n");
if (tid == dbg_curr_tid) thread = dbg_curr_thread;
else
{
thread = dbg_get_thread(dbg_curr_process, tid);
if (!thread)
{
dbg_printf("Unknown thread id (0x%08lx) in current process\n", tid);
return;
}
if (SuspendThread(thread->handle) == -1)
{
dbg_printf("Can't suspend thread id (0x%08lx)\n", tid);
return;
}
}
if (!dbg_read_memory(thread->teb, &next_frame, sizeof(next_frame)))
{
dbg_printf("Can't read TEB:except_frame\n");
return;
}
while (next_frame != (void*)-1)
{
EXCEPTION_REGISTRATION_RECORD frame;
dbg_printf("%p: ", next_frame);
if (!dbg_read_memory(next_frame, &frame, sizeof(frame)))
{
dbg_printf("Invalid frame address\n");
break;
}
dbg_printf("prev=%p handler=%p\n", frame.Prev, frame.Handler);
next_frame = frame.Prev;
}
if (tid != dbg_curr_tid) ResumeThread(thread->handle);
}
void info_win32_segments(DWORD start, int length)
{
char flags[3];
DWORD i;
LDT_ENTRY le;
if (length == -1) length = (8192 - start);
for (i = start; i < start + length; i++)
{
if (!GetThreadSelectorEntry(dbg_curr_thread->handle, (i << 3) | 7, &le))
continue;
if (le.HighWord.Bits.Type & 0x08)
{
flags[0] = (le.HighWord.Bits.Type & 0x2) ? 'r' : '-';
flags[1] = '-';
flags[2] = 'x';
}
else
{
flags[0] = 'r';
flags[1] = (le.HighWord.Bits.Type & 0x2) ? 'w' : '-';
flags[2] = '-';
}
dbg_printf("%04lx: sel=%04lx base=%08x limit=%08x %d-bit %c%c%c\n",
i, (i << 3) | 7,
(le.HighWord.Bits.BaseHi << 24) +
(le.HighWord.Bits.BaseMid << 16) + le.BaseLow,
((le.HighWord.Bits.LimitHi << 8) + le.LimitLow) <<
(le.HighWord.Bits.Granularity ? 12 : 0),
le.HighWord.Bits.Default_Big ? 32 : 16,
flags[0], flags[1], flags[2]);
}
}
void info_win32_virtual(DWORD pid)
{
MEMORY_BASIC_INFORMATION mbi;
char* addr = 0;
const char* state;
const char* type;
char prot[3+1];
HANDLE hProc;
if (pid == dbg_curr_pid)
{
if (dbg_curr_process == NULL)
{
dbg_printf("Cannot look at mapping of current process, while no process is loaded\n");
return;
}
hProc = dbg_curr_process->handle;
}
else
{
hProc = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);
if (hProc == NULL)
{
dbg_printf("Cannot open process <%lu>\n", pid);
return;
}
}
dbg_printf("Address Size State Type RWX\n");
while (VirtualQueryEx(hProc, addr, &mbi, sizeof(mbi)) >= sizeof(mbi))
{
switch (mbi.State)
{
case MEM_COMMIT: state = "commit "; break;
case MEM_FREE: state = "free "; break;
case MEM_RESERVE: state = "reserve"; break;
default: state = "??? "; break;
}
if (mbi.State != MEM_FREE)
{
switch (mbi.Type)
{
case MEM_IMAGE: type = "image "; break;
case MEM_MAPPED: type = "mapped "; break;
case MEM_PRIVATE: type = "private"; break;
case 0: type = " "; break;
default: type = "??? "; break;
}
memset(prot, ' ' , sizeof(prot) - 1);
prot[sizeof(prot) - 1] = '\0';
if (mbi.AllocationProtect & (PAGE_READONLY|PAGE_READWRITE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE))
prot[0] = 'R';
if (mbi.AllocationProtect & (PAGE_READWRITE|PAGE_EXECUTE_READWRITE))
prot[1] = 'W';
if (mbi.AllocationProtect & (PAGE_WRITECOPY|PAGE_EXECUTE_WRITECOPY))
prot[1] = 'C';
if (mbi.AllocationProtect & (PAGE_EXECUTE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE))
prot[2] = 'X';
}
else
{
type = "";
prot[0] = '\0';
}
dbg_printf("%08lx %08lx %s %s %s\n",
(DWORD)addr, (DWORD)addr + mbi.RegionSize - 1, state, type, prot);
if (addr + mbi.RegionSize < addr) /* wrap around ? */
break;
addr += mbi.RegionSize;
}
if (pid != dbg_curr_pid) CloseHandle(hProc);
}
struct dll_option_layout
{
void* next;
void* prev;
char* const* channels;
int nb_channels;
};
void info_wine_dbg_channel(BOOL turn_on, const char* chnl, const char* name)
{
struct dbg_lvalue lvalue;
struct dll_option_layout dol;
int i;
char* str;
unsigned char buffer[32];
unsigned char mask;
int done = 0;
BOOL bAll;
void* addr;
if (!dbg_curr_process || !dbg_curr_thread)
{
dbg_printf("Cannot set/get debug channels while no process is loaded\n");
return;
}
if (symbol_get_lvalue("first_dll", -1, &lvalue, FALSE) != sglv_found)
{
return;
}
addr = memory_to_linear_addr(&lvalue.addr);
if (!chnl) mask = 15;
else if (!strcmp(chnl, "fixme")) mask = 1;
else if (!strcmp(chnl, "err")) mask = 2;
else if (!strcmp(chnl, "warn")) mask = 4;
else if (!strcmp(chnl, "trace")) mask = 8;
else { dbg_printf("Unknown channel %s\n", chnl); return; }
bAll = !strcmp("all", name);
while (addr && dbg_read_memory(addr, &dol, sizeof(dol)))
{
for (i = 0; i < dol.nb_channels; i++)
{
if (dbg_read_memory(dol.channels + i, &str, sizeof(str)) &&
dbg_read_memory(str, buffer, sizeof(buffer)) &&
(!strcmp(buffer + 1, name) || bAll))
{
if (turn_on) buffer[0] |= mask; else buffer[0] &= ~mask;
if (dbg_write_memory(str, buffer, 1)) done++;
}
}
addr = dol.next;
}
if (!done) dbg_printf("Unable to find debug channel %s\n", name);
else WINE_TRACE("Changed %d channel instances\n", done);
}