debugger/info.c

   1 /*
   2  * Wine debugger utility routines
   3  *
   4  * Copyright 1993 Eric Youngdale
   5  * Copyright 1995 Alexandre Julliard
   6  */
   7
   8 #include "config.h"
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include "winbase.h"
  12 #include "wingdi.h"
  13 #include "winuser.h"
  14 #include "toolhelp.h"
  15 #include "tlhelp32.h"
  16 #include "debugger.h"
  17 #include "expr.h"
  18
  19 /***********************************************************************
  20  *           DEBUG_PrintBasic
  21  *
  22  * Implementation of the 'print' command.
  23  */
  24 void DEBUG_PrintBasic( const DBG_VALUE* value, int count, char format )
  25 {
  26   char        * default_format;
  27   long long int res;
  28
  29   assert(value->cookie == DV_TARGET || value->cookie == DV_HOST);
  30   if( value->type == NULL )
  31     {
  32       DEBUG_Printf(DBG_CHN_MESG, "Unable to evaluate expression\n");
  33       return;
  34     }
  35
  36   default_format = NULL;
  37   res = DEBUG_GetExprValue(value, &default_format);
  38
  39   switch(format)
  40     {
  41     case 'x':
  42       if (value->addr.seg)
  43         {
  44           DEBUG_nchar += DEBUG_Printf( DBG_CHN_MESG, "0x%04lx", (long unsigned int) res );
  45         }
  46       else
  47         {
  48           DEBUG_nchar += DEBUG_Printf( DBG_CHN_MESG, "0x%08lx", (long unsigned int) res );
  49         }
  50       break;
  51
  52     case 'd':
  53       DEBUG_nchar += DEBUG_Printf( DBG_CHN_MESG, "%ld\n", (long int) res );
  54       break;
  55
  56     case 'c':
  57       DEBUG_nchar += DEBUG_Printf( DBG_CHN_MESG, "%d = '%c'",
  58                                    (char)(res & 0xff), (char)(res & 0xff) );
  59       break;
  60
  61     case 'i':
  62     case 's':
  63     case 'w':
  64     case 'b':
  65       DEBUG_Printf( DBG_CHN_MESG, "Format specifier '%c' is meaningless in 'print' command\n", format );
  66     case 0:
  67       if( default_format != NULL )
  68         {
  69           if (strstr(default_format, "%S") == NULL)
  70             {
  71                DEBUG_nchar += DEBUG_Printf( DBG_CHN_MESG, default_format, res );
  72             }
  73           else
  74             {
  75                char*    ptr;
  76                int      state = 0;
  77
  78                /* FIXME: simplistic implementation for default_format being
  79                 * foo%Sbar => will print foo, then string then bar
  80                 */
  81                for (ptr = default_format; *ptr; ptr++)
  82                {
  83                   if (*ptr == '%') state++;
  84                   else if (state == 1)
  85                     {
  86                        if (*ptr == 'S')
  87                          {
  88                             char        ch;
  89                             char*       str = (char*)(long)res;
  90
  91                             for (; DEBUG_READ_MEM(str, &ch, 1) && ch; str++) {
  92                                DEBUG_Output(DBG_CHN_MESG, &ch, 1);
  93                                DEBUG_nchar++;
  94                             }
  95                          }
  96                        else
  97                          {
  98                             /* shouldn't happen */
  99                             DEBUG_Printf(DBG_CHN_MESG, "%%%c", *ptr);
 100                             DEBUG_nchar += 2;
 101                          }
 102                        state = 0;
 103                     }
 104                   else
 105                     {
 106                        DEBUG_Output(DBG_CHN_MESG, ptr, 1);
 107                        DEBUG_nchar++;
 108                     }
 109                }
 110             }
 111         }
 112       break;
 113     }
 114 }
 115
 116
 117 /***********************************************************************
 118  *           DEBUG_PrintAddress
 119  *
 120  * Print an 16- or 32-bit address, with the nearest symbol if any.
 121  */
 122 struct symbol_info
 123 DEBUG_PrintAddress( const DBG_ADDR *addr, enum dbg_mode mode, int flag )
 124 {
 125     struct symbol_info rtn;
 126
 127     const char *name = DEBUG_FindNearestSymbol( addr, flag, &rtn.sym, 0,
 128                                                 &rtn.list );
 129
 130     if (addr->seg) DEBUG_Printf( DBG_CHN_MESG, "0x%04lx:", addr->seg&0xFFFF );
 131     if (mode != MODE_32) DEBUG_Printf( DBG_CHN_MESG, "0x%04lx", addr->off );
 132     else DEBUG_Printf( DBG_CHN_MESG, "0x%08lx", addr->off );
 133     if (name) DEBUG_Printf( DBG_CHN_MESG, " (%s)", name );
 134     return rtn;
 135 }
 136 /***********************************************************************
 137  *           DEBUG_PrintAddressAndArgs
 138  *
 139  * Print an 16- or 32-bit address, with the nearest symbol if any.
 140  * Similar to DEBUG_PrintAddress, but we print the arguments to
 141  * each function (if known).  This is useful in a backtrace.
 142  */
 143 struct symbol_info
 144 DEBUG_PrintAddressAndArgs( const DBG_ADDR *addr, enum dbg_mode mode,
 145                            unsigned int ebp, int flag )
 146 {
 147     struct symbol_info rtn;
 148
 149     const char *name = DEBUG_FindNearestSymbol( addr, flag, &rtn.sym, ebp,
 150                                                 &rtn.list );
 151
 152     if (addr->seg) DEBUG_Printf( DBG_CHN_MESG, "0x%04lx:", addr->seg );
 153     if (mode != MODE_32) DEBUG_Printf( DBG_CHN_MESG, "0x%04lx", addr->off );
 154     else DEBUG_Printf( DBG_CHN_MESG, "0x%08lx", addr->off );
 155     if (name) DEBUG_Printf( DBG_CHN_MESG, " (%s)", name );
 156
 157     return rtn;
 158 }
 159
 160
 161 /***********************************************************************
 162  *           DEBUG_Help
 163  *
 164  * Implementation of the 'help' command.
 165  */
 166 void DEBUG_Help(void)
 167 {
 168     int i = 0;
 169     static const char * const helptext[] =
 170 {
 171 "The commands accepted by the Wine debugger are a reasonable",
 172 "subset of the commands that gdb accepts.",
 173 "The commands currently are:",
 174 "  help                                   quit",
 175 "  break [*<addr>]                        delete break bpnum",
 176 "  disable bpnum                          enable bpnum",
 177 "  condition <bpnum> [<expr>]             pass",
 178 "  bt                                     cont [N]",
 179 "  step [N]                               next [N]",
 180 "  stepi [N]                              nexti [N]",
 181 "  x <addr>                               print <expr>",
 182 "  set <reg> = <expr>                     set *<addr> = <expr>",
 183 "  up                                     down",
 184 "  list <lines>                           disassemble [<addr>][,<addr>]",
 185 "  frame <n>                              finish",
 186 "  show dir                               dir <path>",
 187 "  display <expr>                         undisplay <disnum>",
 188 "  delete display <disnum>                debugmsg <class>[-+]<type>\n",
 189 "  mode [16,32,vm86]                      walk [wnd,class,queue,module,",
 190 "  whatis                                       process,modref <pid>]",
 191 "  info (see 'help info' for options)\n",
 192
 193 "The 'x' command accepts repeat counts and formats (including 'i') in the",
 194 "same way that gdb does.\n",
 195
 196 " The following are examples of legal expressions:",
 197 " $eax     $eax+0x3   0x1000   ($eip + 256)  *$eax   *($esp + 3)",
 198 " Also, a nm format symbol table can be read from a file using the",
 199 " symbolfile command.  Symbols can also be defined individually with",
 200 " the define command.",
 201 "",
 202 NULL
 203 };
 204
 205     while(helptext[i]) DEBUG_Printf(DBG_CHN_MESG,"%s\n", helptext[i++]);
 206 }
 207
 208
 209 /***********************************************************************
 210  *           DEBUG_HelpInfo
 211  *
 212  * Implementation of the 'help info' command.
 213  */
 214 void DEBUG_HelpInfo(void)
 215 {
 216     int i = 0;
 217     static const char * const infotext[] =
 218 {
 219 "The info commands allow you to get assorted bits of interesting stuff",
 220 "to be displayed.  The options are:",
 221 "  info break           Dumps information about breakpoints",
 222 "  info display         Shows auto-display expressions in use",
 223 "  info locals          Displays values of all local vars for current frame",
 224 "  info maps            Dumps all virtual memory mappings",
 225 "  info module <handle> Displays internal module state",
 226 "  info queue <handle>  Displays internal queue state",
 227 "  info reg             Displays values in all registers at top of stack",
 228 "  info segments        Dumps information about all known segments",
 229 "  info share           Dumps information about shared libraries",
 230 "  info stack           Dumps information about top of stack",
 231 "  info wnd <handle>    Displays internal window state",
 232 "",
 233 NULL
 234 };
 235
 236     while(infotext[i]) DEBUG_Printf(DBG_CHN_MESG,"%s\n", infotext[i++]);
 237 }
 238
 239 /* FIXME: merge InfoClass and InfoClass2 */
 240 void DEBUG_InfoClass(const char* name)
 241 {
 242    WNDCLASSEXA  wca;
 243
 244    if (!GetClassInfoEx(0, name, &wca)) {
 245       DEBUG_Printf(DBG_CHN_MESG, "Cannot find class '%s'\n", name);
 246       return;
 247    }
 248
 249    DEBUG_Printf(DBG_CHN_MESG,  "Class '%s':\n", name);
 250    DEBUG_Printf(DBG_CHN_MESG,
 251                 "style=%08x  wndProc=%08lx\n"
 252                 "inst=%p  icon=%p  cursor=%p  bkgnd=%p\n"
 253                 "clsExtra=%d  winExtra=%d\n",
 254                 wca.style, (DWORD)wca.lpfnWndProc, wca.hInstance,
 255                 wca.hIcon, wca.hCursor, wca.hbrBackground,
 256                 wca.cbClsExtra, wca.cbWndExtra);
 257
 258    /* FIXME:
 259     * + print #windows (or even list of windows...)
 260     * + print extra bytes => this requires a window handle on this very class...
 261     */
 262 }
 263
 264 static  void DEBUG_InfoClass2(HWND hWnd, const char* name)
 265 {
 266    WNDCLASSEXA  wca;
 267
 268    if (!GetClassInfoEx((HINSTANCE)GetWindowLong(hWnd, GWL_HINSTANCE), name, &wca)) {
 269       DEBUG_Printf(DBG_CHN_MESG, "Cannot find class '%s'\n", name);
 270       return;
 271    }
 272
 273    DEBUG_Printf(DBG_CHN_MESG,  "Class '%s':\n", name);
 274    DEBUG_Printf(DBG_CHN_MESG,
 275                 "style=%08x  wndProc=%08lx\n"
 276                 "inst=%p  icon=%p  cursor=%p  bkgnd=%p\n"
 277                 "clsExtra=%d  winExtra=%d\n",
 278                 wca.style, (DWORD)wca.lpfnWndProc, wca.hInstance,
 279                 wca.hIcon, wca.hCursor, wca.hbrBackground,
 280                 wca.cbClsExtra, wca.cbWndExtra);
 281
 282    if (wca.cbClsExtra) {
 283       int               i;
 284       WORD              w;
 285
 286       DEBUG_Printf(DBG_CHN_MESG,  "Extra bytes:" );
 287       for (i = 0; i < wca.cbClsExtra / 2; i++) {
 288          w = GetClassWord(hWnd, i * 2);
 289          /* FIXME: depends on i386 endian-ity */
 290          DEBUG_Printf(DBG_CHN_MESG,  " %02x", HIBYTE(w));
 291          DEBUG_Printf(DBG_CHN_MESG,  " %02x", LOBYTE(w));
 292       }
 293       DEBUG_Printf(DBG_CHN_MESG,  "\n" );
 294     }
 295     DEBUG_Printf(DBG_CHN_MESG,  "\n" );
 296 }
 297
 298 struct class_walker {
 299    ATOM*        table;
 300    int          used;
 301    int          alloc;
 302 };
 303
 304 static  void DEBUG_WalkClassesHelper(HWND hWnd, struct class_walker* cw)
 305 {
 306    char clsName[128];
 307    int  i;
 308    ATOM atom;
 309    HWND child;
 310
 311    if (!GetClassName(hWnd, clsName, sizeof(clsName)))
 312       return;
 313    if ((atom = FindAtom(clsName)) == 0)
 314       return;
 315
 316    for (i = 0; i < cw->used; i++) {
 317       if (cw->table[i] == atom)
 318          break;
 319    }
 320    if (i == cw->used) {
 321       if (cw->used >= cw->alloc) {
 322          cw->alloc += 16;
 323          cw->table = DBG_realloc(cw->table, cw->alloc * sizeof(ATOM));
 324       }
 325       cw->table[cw->used++] = atom;
 326       DEBUG_InfoClass2(hWnd, clsName);
 327    }
 328    do {
 329       if ((child = GetWindow(hWnd, GW_CHILD)) != 0)
 330          DEBUG_WalkClassesHelper(child, cw);
 331    } while ((hWnd = GetWindow(hWnd, GW_HWNDNEXT)) != 0);
 332 }
 333
 334 void DEBUG_WalkClasses(void)
 335 {
 336    struct class_walker cw;
 337
 338    cw.table = NULL;
 339    cw.used = cw.alloc = 0;
 340    DEBUG_WalkClassesHelper(GetDesktopWindow(), &cw);
 341    DBG_free(cw.table);
 342 }
 343
 344 void DEBUG_DumpQueue(DWORD q)
 345 {
 346    DEBUG_Printf(DBG_CHN_MESG, "No longer doing info queue '0x%08lx'\n", q);
 347 }
 348
 349 void DEBUG_WalkQueues(void)
 350 {
 351    DEBUG_Printf(DBG_CHN_MESG, "No longer walking queues list\n");
 352 }
 353
 354 void DEBUG_InfoWindow(HWND hWnd)
 355 {
 356    char clsName[128];
 357    char wndName[128];
 358    RECT clientRect;
 359    RECT windowRect;
 360    int  i;
 361    WORD w;
 362
 363    if (!GetClassName(hWnd, clsName, sizeof(clsName)))
 364        strcpy(clsName, "-- Unknown --");
 365    if (!GetWindowText(hWnd, wndName, sizeof(wndName)))
 366       strcpy(wndName, "-- Empty --");
 367    if (!GetClientRect(hWnd, &clientRect))
 368       SetRectEmpty(&clientRect);
 369    if (!GetWindowRect(hWnd, &windowRect))
 370       SetRectEmpty(&windowRect);
 371
 372    /* FIXME missing fields: hmemTaskQ, hrgnUpdate, dce, flags, pProp, scroll */
 373    DEBUG_Printf(DBG_CHN_MESG,
 374                 "next=%p  child=%p  parent=%p  owner=%p  class='%s'\n"
 375                 "inst=%p  active=%p  idmenu=%08lx\n"
 376                 "style=%08lx  exstyle=%08lx  wndproc=%08lx  text='%s'\n"
 377                 "client=%d,%d-%d,%d  window=%d,%d-%d,%d sysmenu=%p\n",
 378                 GetWindow(hWnd, GW_HWNDNEXT),
 379                 GetWindow(hWnd, GW_CHILD),
 380                 GetParent(hWnd),
 381                 GetWindow(hWnd, GW_OWNER),
 382                 clsName,
 383                 (HINSTANCE)GetWindowLong(hWnd, GWL_HINSTANCE),
 384                 GetLastActivePopup(hWnd),
 385                 GetWindowLong(hWnd, GWL_ID),
 386                 GetWindowLong(hWnd, GWL_STYLE),
 387                 GetWindowLong(hWnd, GWL_EXSTYLE),
 388                 GetWindowLong(hWnd, GWL_WNDPROC),
 389                 wndName,
 390                 clientRect.left, clientRect.top, clientRect.right, clientRect.bottom,
 391                 windowRect.left, windowRect.top, windowRect.right, windowRect.bottom,
 392                 GetSystemMenu(hWnd, FALSE));
 393
 394     if (GetClassLong(hWnd, GCL_CBWNDEXTRA)) {
 395         DEBUG_Printf(DBG_CHN_MESG,  "Extra bytes:" );
 396         for (i = 0; i < GetClassLong(hWnd, GCL_CBWNDEXTRA) / 2; i++) {
 397            w = GetWindowWord(hWnd, i * 2);
 398            /* FIXME: depends on i386 endian-ity */
 399            DEBUG_Printf(DBG_CHN_MESG,  " %02x", HIBYTE(w));
 400            DEBUG_Printf(DBG_CHN_MESG,  " %02x", LOBYTE(w));
 401         }
 402         DEBUG_Printf(DBG_CHN_MESG, "\n");
 403     }
 404     DEBUG_Printf(DBG_CHN_MESG, "\n");
 405 }
 406
 407 void DEBUG_WalkWindows(HWND hWnd, int indent)
 408 {
 409    char clsName[128];
 410    char wndName[128];
 411    HWND child;
 412
 413    if (!IsWindow(hWnd))
 414       hWnd = GetDesktopWindow();
 415
 416     if (!indent)  /* first time around */
 417        DEBUG_Printf(DBG_CHN_MESG,
 418                     "%-16.16s %-17.17s %-8.8s %s\n",
 419                     "hwnd", "Class Name", " Style", " WndProc Text");
 420
 421     do {
 422        if (!GetClassName(hWnd, clsName, sizeof(clsName)))
 423           strcpy(clsName, "-- Unknown --");
 424        if (!GetWindowText(hWnd, wndName, sizeof(wndName)))
 425           strcpy(wndName, "-- Empty --");
 426
 427        /* FIXME: missing hmemTaskQ */
 428        DEBUG_Printf(DBG_CHN_MESG, "%*s%04x%*s", indent, "", (UINT)hWnd, 13-indent,"");
 429        DEBUG_Printf(DBG_CHN_MESG, "%-17.17s %08lx %08lx %.14s\n",
 430                     clsName, GetWindowLong(hWnd, GWL_STYLE),
 431                     GetWindowLong(hWnd, GWL_WNDPROC), wndName);
 432
 433        if ((child = GetWindow(hWnd, GW_CHILD)) != 0)
 434           DEBUG_WalkWindows(child, indent + 1 );
 435     } while ((hWnd = GetWindow(hWnd, GW_HWNDNEXT)) != 0);
 436 }
 437
 438 void DEBUG_WalkProcess(void)
 439 {
 440     HANDLE snap = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
 441     if (snap != INVALID_HANDLE_VALUE)
 442     {
 443         PROCESSENTRY32 entry;
 444         DWORD current = DEBUG_CurrProcess ? DEBUG_CurrProcess->pid : 0;
 445         BOOL ok;
 446
 447                   entry.dwSize = sizeof(entry);
 448                   ok = Process32First( snap, &entry );
 449
 450         DEBUG_Printf(DBG_CHN_MESG, "%-8.8s %-8.8s %-8.8s %s\n",
 451                      "pid", "threads", "parent", "exe" );
 452         while (ok)
 453         {
 454             if (entry.th32ProcessID != GetCurrentProcessId())
 455                 DEBUG_Printf(DBG_CHN_MESG, "%08lx %8ld %08lx '%s'%s\n",
 456                              entry.th32ProcessID, entry.cntThreads,
 457                              entry.th32ParentProcessID, entry.szExeFile,
 458                              (entry.th32ProcessID == current) ? " <==" : "" );
 459             ok = Process32Next( snap, &entry );
 460         }
 461         CloseHandle( snap );
 462     }
 463 }
 464
 465 void DEBUG_WalkThreads(void)
 466 {
 467     HANDLE snap = CreateToolhelp32Snapshot( TH32CS_SNAPTHREAD, 0 );
 468     if (snap != INVALID_HANDLE_VALUE)
 469     {
 470         THREADENTRY32 entry;
 471         DWORD current = DEBUG_CurrThread ? DEBUG_CurrThread->tid : 0;
 472         BOOL ok;
 473
 474                   entry.dwSize = sizeof(entry);
 475                   ok = Thread32First( snap, &entry );
 476
 477         DEBUG_Printf(DBG_CHN_MESG, "%-8.8s %-8.8s %s\n",
 478                      "tid", "process", "prio" );
 479         while (ok)
 480         {
 481             if (entry.th32OwnerProcessID != GetCurrentProcessId())
 482                 DEBUG_Printf(DBG_CHN_MESG, "%08lx %08lx %4ld%s\n",
 483                              entry.th32ThreadID, entry.th32OwnerProcessID,
 484                              entry.tpBasePri, (entry.th32ThreadID == current) ? " <==" : "" );
 485             ok = Thread32Next( snap, &entry );
 486         }
 487         CloseHandle( snap );
 488     }
 489 }
 490
 491 void DEBUG_WalkModref(DWORD p)
 492 {
 493    DEBUG_Printf(DBG_CHN_MESG, "No longer walking module references list\n");
 494 }
 495
 496 void DEBUG_InfoSegments(DWORD start, int length)
 497 {
 498     char        flags[3];
 499     DWORD       i;
 500     LDT_ENTRY   le;
 501
 502     if (length == -1) length = (8192 - start);
 503
 504     for (i = start; i < start + length; i++)
 505     {
 506        if (!GetThreadSelectorEntry(DEBUG_CurrThread->handle, (i << 3)|7, &le))
 507           continue;
 508
 509         if (le.HighWord.Bits.Type & 0x08)
 510         {
 511             flags[0] = (le.HighWord.Bits.Type & 0x2) ? 'r' : '-';
 512             flags[1] = '-';
 513             flags[2] = 'x';
 514         }
 515         else
 516         {
 517             flags[0] = 'r';
 518             flags[1] = (le.HighWord.Bits.Type & 0x2) ? 'w' : '-';
 519             flags[2] = '-';
 520         }
 521         DEBUG_Printf(DBG_CHN_MESG,
 522                      "%04lx: sel=%04lx base=%08x limit=%08x %d-bit %c%c%c\n",
 523                      i, (i<<3)|7,
 524                      (le.HighWord.Bits.BaseHi << 24) +
 525                      (le.HighWord.Bits.BaseMid << 16) + le.BaseLow,
 526                      ((le.HighWord.Bits.LimitHi << 8) + le.LimitLow) <<
 527                      (le.HighWord.Bits.Granularity ? 12 : 0),
 528                      le.HighWord.Bits.Default_Big ? 32 : 16,
 529                      flags[0], flags[1], flags[2] );
 530     }
 531 }
 532
 533 void DEBUG_InfoVirtual(void)
 534 {
 535    DEBUG_Printf(DBG_CHN_MESG, "No longer providing virtual mapping information\n");
 536 }