programs/winedbg/symbol.c

   1 /*
   2  * Generate hash tables for Wine debugger symbols
   3  *
   4  * Copyright (C) 1993, Eric Youngdale.
   5  *               2004, Eric Pouech.
   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #define NONAMELESSUNION
  23 #define NONAMELESSSTRUCT
  24
  25 #include "config.h"
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29
  30 #include "debugger.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
  34
  35 static BOOL symbol_get_debug_start(DWORD mod_base, DWORD typeid, DWORD* start)
  36 {
  37     DWORD                       count, tag;
  38     char                        buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)];
  39     TI_FINDCHILDREN_PARAMS*     fcp = (TI_FINDCHILDREN_PARAMS*)buffer;
  40     int                         i;
  41     struct dbg_type             type;
  42
  43     type.module = mod_base;
  44     type.id = typeid;
  45
  46     if (!types_get_info(&type, TI_GET_CHILDRENCOUNT, &count)) return FALSE;
  47     fcp->Start = 0;
  48     while (count)
  49     {
  50         fcp->Count = min(count, 256);
  51         if (types_get_info(&type, TI_FINDCHILDREN, fcp))
  52         {
  53             for (i = 0; i < min(fcp->Count, count); i++)
  54             {
  55                 type.id = fcp->ChildId[i];
  56                 types_get_info(&type, TI_GET_SYMTAG, &tag);
  57                 if (tag != SymTagFuncDebugStart) continue;
  58                 return types_get_info(&type, TI_GET_ADDRESS, start);
  59             }
  60             count -= min(count, 256);
  61             fcp->Start += 256;
  62         }
  63     }
  64     return FALSE;
  65 }
  66
  67 struct sgv_data
  68 {
  69 #define NUMDBGV                 100
  70     struct {
  71         /* FIXME: NUMDBGV should be made variable */
  72         struct dbg_lvalue               lvalue;
  73         DWORD                           flags;
  74     }                           syms[NUMDBGV];  /* out     : will be filled in with various found symbols */
  75     int                         num;            /* out     : number of found symbols */
  76     int                         num_thunks;     /* out     : number of thunks found */
  77     const char*                 name;           /* in      : name of symbol to look up */
  78     const char*                 filename;       /* in (opt): filename where to look up symbol */
  79     int                         lineno;         /* in (opt): line number in filename where to look up symbol */
  80     unsigned                    bp_disp : 1,    /* in      : whether if we take into account func address or func first displayable insn */
  81                                 do_thunks : 1;  /* in      : whether we return thunks tags */
  82     IMAGEHLP_STACK_FRAME        ihsf;           /* in      : frame for local & parameter variables look up */
  83 };
  84
  85 static BOOL CALLBACK sgv_cb(SYMBOL_INFO* sym, ULONG size, void* ctx)
  86 {
  87     struct sgv_data*    sgv = (struct sgv_data*)ctx;
  88     DWORD               addr;
  89     IMAGEHLP_LINE       il;
  90     unsigned            cookie = DLV_TARGET, insp;
  91
  92     if (sym->Flags & SYMFLAG_REGISTER)
  93     {
  94         const struct dbg_internal_var*  div;
  95
  96         if (dbg_curr_frame != 0)
  97         {
  98             dbg_printf(" %s (register): << cannot display, not in correct frame\n",
  99                        sym->Name);
 100             return TRUE;
 101         }
 102         for (div = dbg_context_vars; div->name && div->val != sym->Register; div++);
 103         if (!div->name)
 104         {
 105             dbg_printf(" %s (register): couldn't find register %lu\n",
 106                        sym->Name, sym->Register);
 107             return TRUE;
 108         }
 109         addr = (DWORD)div->pval;
 110         cookie = DLV_HOST;
 111     }
 112     else if (sym->Flags & SYMFLAG_FRAMEREL)
 113     {
 114         ULONG   offset;
 115         struct dbg_type type;
 116
 117         type.module = sym->ModBase;
 118         type.id = sym->TypeIndex;
 119         types_get_info(&type, TI_GET_OFFSET, &offset);
 120         addr = sgv->ihsf.FrameOffset + offset;
 121     }
 122     else if (sym->Flags & SYMFLAG_THUNK)
 123     {
 124         if (!sgv->do_thunks) return TRUE;
 125         sgv->num_thunks++;
 126         addr = sym->Address;
 127     }
 128     else
 129     {
 130         il.SizeOfStruct = sizeof(il);
 131         SymGetLineFromAddr(dbg_curr_process->handle, sym->Address, NULL, &il);
 132         if (sgv->filename && strcmp(sgv->filename, il.FileName))
 133         {
 134             WINE_FIXME("File name mismatch (%s / %s)\n", sgv->filename, il.FileName);
 135             return TRUE;
 136         }
 137
 138         if (sgv->lineno == -1)
 139         {
 140             if (!sgv->bp_disp ||
 141                 !symbol_get_debug_start(sym->ModBase, sym->TypeIndex, &addr))
 142                 addr = sym->Address;
 143         }
 144         else
 145         {
 146             addr = 0;
 147             do
 148             {
 149                 if (sgv->lineno == il.LineNumber)
 150                 {
 151                     addr = il.Address;
 152                     break;
 153                 }
 154             } while (SymGetLineNext(dbg_curr_process->handle, &il));
 155             if (!addr)
 156             {
 157                 WINE_FIXME("No line (%d) found for %s (setting to symbol)\n",
 158                            sgv->lineno, sgv->name);
 159                 addr = sym->Address;
 160             }
 161         }
 162     }
 163
 164     if (sgv->num >= NUMDBGV)
 165     {
 166         dbg_printf("Too many addresses for symbol '%s', limiting the first %d\n",
 167                    sgv->name, NUMDBGV);
 168         return FALSE;
 169     }
 170     WINE_TRACE("==> %s %s%s%s%s%s%s\n",
 171                sym->Name,
 172                (sym->Flags & SYMFLAG_FUNCTION) ? "func " : "",
 173                (sym->Flags & SYMFLAG_FRAMEREL) ? "framerel " : "",
 174                (sym->Flags & SYMFLAG_REGISTER) ? "register " : "",
 175                (sym->Flags & SYMFLAG_REGREL) ? "regrel " : "",
 176                (sym->Flags & SYMFLAG_PARAMETER) ? "param " : "",
 177                (sym->Flags & SYMFLAG_THUNK) ? "thunk " : "");
 178
 179     /* always keep the thunks at end of the array */
 180     insp = sgv->num;
 181     if (sgv->num_thunks && !(sym->Flags & SYMFLAG_THUNK))
 182     {
 183         insp -= sgv->num_thunks;
 184         memmove(&sgv->syms[insp + 1], &sgv->syms[insp],
 185                 sizeof(sgv->syms[0]) * sgv->num_thunks);
 186     }
 187     sgv->syms[insp].lvalue.cookie      = cookie;
 188     sgv->syms[insp].lvalue.addr.Mode   = AddrModeFlat;
 189     sgv->syms[insp].lvalue.addr.Offset = addr;
 190     sgv->syms[insp].lvalue.type.module = sym->ModBase;
 191     sgv->syms[insp].lvalue.type.id = sym->TypeIndex;
 192     types_get_info(&sgv->syms[insp].lvalue.type, TI_GET_TYPE,
 193                    &sgv->syms[insp].lvalue.type.id);
 194     sgv->syms[insp].flags              = sym->Flags;
 195     sgv->num++;
 196
 197     return TRUE;
 198 }
 199
 200 /***********************************************************************
 201  *           symbol_get_lvalue
 202  *
 203  * Get the address of a named symbol.
 204  * Return values:
 205  *      sglv_found:   if the symbol is found
 206  *      sglv_unknown: if the symbol isn't found
 207  *      sglv_aborted: some error occurred (likely, many symbols of same name exist,
 208  *          and user didn't pick one of them)
 209  */
 210 enum sym_get_lval symbol_get_lvalue(const char* name, const int lineno,
 211                                     struct dbg_lvalue* rtn, BOOL bp_disp)
 212 {
 213     struct sgv_data             sgv;
 214     int                         i = 0;
 215     char                        tmp[sizeof(SYMBOL_INFO) + 256];
 216     SYMBOL_INFO*                si = (SYMBOL_INFO*)tmp;
 217     char                        buffer[512];
 218     DWORD                       opt;
 219
 220     if (strlen(name) + 4 > sizeof(buffer))
 221     {
 222         WINE_WARN("Too long symbol (%s)\n", name);
 223         return sglv_unknown;
 224     }
 225
 226     sgv.num        = 0;
 227     sgv.num_thunks = 0;
 228     sgv.name       = &buffer[2];
 229     sgv.filename   = NULL;
 230     sgv.lineno     = lineno;
 231     sgv.bp_disp    = bp_disp ? TRUE : FALSE;
 232     sgv.do_thunks  = DBG_IVAR(AlwaysShowThunks);
 233
 234     buffer[0] = '*';
 235     buffer[1] = '!';
 236     strcpy(&buffer[2], name);
 237
 238     /* this is a wine specific options to return also ELF modules in the
 239      * enumeration
 240      */
 241     SymSetOptions((opt = SymGetOptions()) | 0x40000000);
 242     if (!SymEnumSymbols(dbg_curr_process->handle, 0, buffer, sgv_cb, (void*)&sgv))
 243     {
 244         SymSetOptions(opt);
 245         return sglv_unknown;
 246     }
 247
 248     if (!sgv.num && (name[0] != '_'))
 249     {
 250         buffer[2] = '_';
 251         strcpy(&buffer[3], name);
 252         if (!SymEnumSymbols(dbg_curr_process->handle, 0, buffer, sgv_cb, (void*)&sgv))
 253         {
 254             SymSetOptions(opt);
 255             return sglv_unknown;
 256         }
 257     }
 258     SymSetOptions(opt);
 259
 260     /* now grab local symbols */
 261     si->SizeOfStruct = sizeof(*si);
 262     si->MaxNameLen = 256;
 263     if (stack_get_frame(si, &sgv.ihsf) && sgv.num < NUMDBGV)
 264     {
 265         if (SymSetContext(dbg_curr_process->handle, &sgv.ihsf, NULL))
 266             SymEnumSymbols(dbg_curr_process->handle, 0, name, sgv_cb, (void*)&sgv);
 267     }
 268
 269     if (!sgv.num)
 270     {
 271         dbg_printf("No symbols found for %s\n", name);
 272         return sglv_unknown;
 273     }
 274
 275     if (dbg_interactiveP)
 276     {
 277         if (sgv.num - sgv.num_thunks > 1 || /* many symbols non thunks (and showing only non thunks) */
 278             (sgv.num > 1 && DBG_IVAR(AlwaysShowThunks)) || /* many symbols (showing symbols & thunks) */
 279             (sgv.num == sgv.num_thunks && sgv.num_thunks > 1))
 280         {
 281             dbg_printf("Many symbols with name '%s', "
 282                        "choose the one you want (<cr> to abort):\n", name);
 283             for (i = 0; i < sgv.num; i++)
 284             {
 285                 if (sgv.num - sgv.num_thunks > 1 && (sgv.syms[i].flags & SYMFLAG_THUNK) && !DBG_IVAR(AlwaysShowThunks))
 286                     continue;
 287                 dbg_printf("[%d]: ", i + 1);
 288                 if (sgv.syms[i].flags & SYMFLAG_LOCAL)
 289                 {
 290                     dbg_printf("local variable of %s\n", si->Name);
 291                 }
 292                 else if (sgv.syms[i].flags & SYMFLAG_PARAMETER)
 293                 {
 294                     dbg_printf("parameter of %s\n", si->Name);
 295                 }
 296                 else if (sgv.syms[i].flags & SYMFLAG_THUNK)
 297                 {
 298                     print_address(&sgv.syms[i].lvalue.addr, TRUE);
 299                     /* FIXME: should display where the thunks points to */
 300                     dbg_printf(" thunk %s\n", name);
 301                 }
 302                 else
 303                 {
 304                     print_address(&sgv.syms[i].lvalue.addr, TRUE);
 305                     dbg_printf("\n");
 306                 }
 307             }
 308             do
 309             {
 310                 i = 0;
 311                 if (input_read_line("=> ", buffer, sizeof(buffer)))
 312                 {
 313                     if (buffer[0] == '\0') return sglv_aborted;
 314                     i = atoi(buffer);
 315                     if (i < 1 || i > sgv.num)
 316                         dbg_printf("Invalid choice %d\n", i);
 317                 }
 318             } while (i < 1 || i > sgv.num);
 319
 320             /* The array is 0-based, but the choices are 1..n,
 321              * so we have to subtract one before returning.
 322              */
 323             i--;
 324         }
 325     }
 326     else
 327     {
 328         /* FIXME: could display the list of non-picked up symbols */
 329         if (sgv.num > 1)
 330             dbg_printf("More than one symbol named %s, picking the first one\n", name);
 331     }
 332     *rtn = sgv.syms[i].lvalue;
 333     return sglv_found;
 334 }
 335
 336 /***********************************************************************
 337  *           symbol_read_symtable
 338  *
 339  * Read a symbol file into the hash table.
 340  */
 341 void symbol_read_symtable(const char* filename, unsigned long offset)
 342 {
 343     dbg_printf("No longer supported\n");
 344
 345 #if 0
 346 /* FIXME: have to implement SymAddSymbol in dbghelp, but likely to link this with
 347  * a loaded module !!
 348  */
 349     FILE*       symbolfile;
 350     unsigned    addr;
 351     char        type;
 352     char*       cpnt;
 353     char        buffer[256];
 354     char        name[256];
 355
 356     if (!(symbolfile = fopen(filename, "r")))
 357     {
 358         WINE_WARN("Unable to open symbol table %s\n", filename);
 359         return;
 360     }
 361
 362     dbg_printf("Reading symbols from file %s\n", filename);
 363
 364     while (1)
 365     {
 366         fgets(buffer, sizeof(buffer), symbolfile);
 367         if (feof(symbolfile)) break;
 368
 369         /* Strip any text after a # sign (i.e. comments) */
 370         cpnt = strchr(buffer, '#');
 371         if (cpnt) *cpnt = '\0';
 372
 373         /* Quietly ignore any lines that have just whitespace */
 374         for (cpnt = buffer; *cpnt; cpnt++)
 375         {
 376             if (*cpnt != ' ' && *cpnt != '\t') break;
 377         }
 378         if (!*cpnt || *cpnt == '\n') continue;
 379
 380         if (sscanf(buffer, "%lx %c %s", &addr, &type, name) == 3)
 381         {
 382             if (value.addr.off + offset < value.addr.off)
 383                 WINE_WARN("Address wrap around\n");
 384             value.addr.off += offset;
 385             SymAddSymbol(current_process->handle, BaseOfDll,
 386                          name, addr, 0, 0);
 387         }
 388     }
 389     fclose(symbolfile);
 390 #endif
 391 }
 392
 393 /***********************************************************************
 394  *           symbol_get_function_line_status
 395  *
 396  * Find the symbol nearest to a given address.
 397  */
 398 enum dbg_line_status symbol_get_function_line_status(const ADDRESS* addr)
 399 {
 400     IMAGEHLP_LINE       il;
 401     DWORD               disp, start, size;
 402     DWORD               lin = (DWORD)memory_to_linear_addr(addr);
 403     char                buffer[sizeof(SYMBOL_INFO) + 256];
 404     SYMBOL_INFO*        sym = (SYMBOL_INFO*)buffer;
 405     struct dbg_type     type;
 406
 407     il.SizeOfStruct = sizeof(il);
 408     sym->SizeOfStruct = sizeof(SYMBOL_INFO);
 409     sym->MaxNameLen = sizeof(buffer) - sizeof(SYMBOL_INFO);
 410
 411     /* do we have some info for lin address ? */
 412     if (!SymFromAddr(dbg_curr_process->handle, lin, NULL, sym))
 413         return dbg_no_line_info;
 414
 415     switch (sym->Tag)
 416     {
 417     case SymTagThunk:
 418         /* FIXME: so far dbghelp doesn't return the 16 <=> 32 thunks
 419          * and furthermore, we no longer take care of them !!!
 420          */
 421         return dbg_in_a_thunk;
 422     case SymTagFunction:
 423     case SymTagPublicSymbol: break;
 424     default:
 425         WINE_FIXME("Unexpected sym-tag 0x%08lx\n", sym->Tag);
 426     case SymTagData:
 427         return dbg_no_line_info;
 428     }
 429     /* we should have a function now */
 430     if (!SymGetLineFromAddr(dbg_curr_process->handle, lin, &disp, &il))
 431         return dbg_no_line_info;
 432
 433     if (symbol_get_debug_start(sym->ModBase, sym->TypeIndex, &start) && lin < start)
 434         return dbg_not_on_a_line_number;
 435     type.module = sym->ModBase;
 436     type.id = sym->TypeIndex;
 437     if (!types_get_info(&type, TI_GET_LENGTH, &size) || size == 0)
 438         size = 0x100000;
 439     if (il.FileName && il.FileName[0] && disp < size)
 440         return (disp == 0) ? dbg_on_a_line_number : dbg_not_on_a_line_number;
 441
 442     return dbg_no_line_info;
 443 }
 444
 445 /***********************************************************************
 446  *           symbol_get_line
 447  *
 448  * Find the symbol nearest to a given address.
 449  * Returns sourcefile name and line number in a format that the listing
 450  * handler can deal with.
 451  */
 452 BOOL symbol_get_line(const char* filename, const char* name, IMAGEHLP_LINE* line)
 453 {
 454     struct sgv_data     sgv;
 455     char                buffer[512];
 456     DWORD               opt;
 457
 458     sgv.num        = 0;
 459     sgv.num_thunks = 0;
 460     sgv.name       = &buffer[2];
 461     sgv.filename   = filename;
 462     sgv.lineno     = -1;
 463     sgv.bp_disp    = FALSE;
 464     sgv.do_thunks  = FALSE;
 465
 466     buffer[0] = '*';
 467     buffer[1] = '!';
 468     strcpy(&buffer[2], name);
 469
 470     /* this is a wine specific options to return also ELF modules in the
 471      * enumeration
 472      */
 473     SymSetOptions((opt = SymGetOptions()) | 0x40000000);
 474     if (!SymEnumSymbols(dbg_curr_process->handle, 0, buffer, sgv_cb, (void*)&sgv))
 475     {
 476         SymSetOptions(opt);
 477         return sglv_unknown;
 478     }
 479
 480     if (!sgv.num && (name[0] != '_'))
 481     {
 482         buffer[2] = '_';
 483         strcpy(&buffer[3], name);
 484         if (!SymEnumSymbols(dbg_curr_process->handle, 0, buffer, sgv_cb, (void*)&sgv))
 485         {
 486             SymSetOptions(opt);
 487             return sglv_unknown;
 488         }
 489     }
 490     SymSetOptions(opt);
 491
 492     switch (sgv.num)
 493     {
 494     case 0:
 495         if (filename)   dbg_printf("No such function %s in %s\n", name, filename);
 496         else            dbg_printf("No such function %s\n", name);
 497         return FALSE;
 498     default:
 499         WINE_FIXME("Several found, returning first (may not be what you want)...\n");
 500     case 1:
 501         return SymGetLineFromAddr(dbg_curr_process->handle,
 502                                   (DWORD)memory_to_linear_addr(&sgv.syms[0].lvalue.addr),
 503                                   NULL, line);
 504     }
 505     return TRUE;
 506 }
 507
 508 static BOOL CALLBACK info_locals_cb(SYMBOL_INFO* sym, ULONG size, void* ctx)
 509 {
 510     ULONG               v, val;
 511     const char*         explain = NULL;
 512     char                buf[128];
 513     struct dbg_type     type;
 514
 515     dbg_printf("\t");
 516     type.module = sym->ModBase;
 517     type.id = sym->TypeIndex;
 518     types_get_info(&type, TI_GET_TYPE, &type.id);
 519     types_print_type(&type, FALSE);
 520
 521     if (sym->Flags & SYMFLAG_LOCAL) explain = "local";
 522     else if (sym->Flags & SYMFLAG_PARAMETER) explain = "parameter";
 523     else if (sym->Flags & SYMFLAG_REGISTER) explain = buf;
 524
 525     if (sym->Flags & SYMFLAG_REGISTER)
 526     {
 527         const struct dbg_internal_var*  div;
 528
 529         if (dbg_curr_frame != 0)
 530         {
 531             dbg_printf(" %s (register): << cannot display, not in correct frame\n",
 532                        sym->Name);
 533             return TRUE;
 534         }
 535         for (div = dbg_context_vars; div->name; div++)
 536         {
 537             if (div->val == sym->Register)
 538             {
 539                 val = *div->pval;
 540                 sprintf(buf, "local in register %s", div->name);
 541                 break;
 542             }
 543         }
 544     }
 545     else if (sym->Flags & SYMFLAG_FRAMEREL)
 546     {
 547         type.id = sym->TypeIndex;
 548         types_get_info(&type, TI_GET_OFFSET, &v);
 549         v += ((IMAGEHLP_STACK_FRAME*)ctx)->FrameOffset;
 550
 551         dbg_read_memory_verbose((void*)v, &val, sizeof(val));
 552     }
 553     dbg_printf(" %s = 0x%8.8lx (%s)\n", sym->Name, val, explain);
 554
 555     return TRUE;
 556 }
 557
 558 int symbol_info_locals(void)
 559 {
 560     IMAGEHLP_STACK_FRAME        ihsf;
 561     char                        buffer[sizeof(SYMBOL_INFO) + 256];
 562     SYMBOL_INFO*                si = (SYMBOL_INFO*)buffer;
 563
 564     si->SizeOfStruct = sizeof(*si);
 565     si->MaxNameLen = 256;
 566     if (stack_get_frame(si, &ihsf))
 567     {
 568         dbg_printf("%s:\n", si->Name);
 569         if (SymSetContext(dbg_curr_process->handle, &ihsf, NULL))
 570             SymEnumSymbols(dbg_curr_process->handle, 0, NULL, info_locals_cb, &ihsf);
 571     }
 572     return TRUE;
 573 }
 574
 575 static BOOL CALLBACK symbols_info_cb(SYMBOL_INFO* sym, ULONG size, void* ctx)
 576 {
 577     struct dbg_type     type;
 578
 579     dbg_printf("%08lx: %s (", sym->Address, sym->Name);
 580     if (sym->TypeIndex != dbg_itype_none && sym->TypeIndex != 0 &&
 581         types_get_info(&type, TI_GET_TYPE, &type.id))
 582     {
 583         types_print_type(&type, FALSE);
 584     }
 585     dbg_printf(")\n");
 586     return TRUE;
 587 }
 588
 589 void symbol_info(const char* str)
 590 {
 591     char        buffer[512];
 592     DWORD       opt;
 593
 594     if (strlen(str) + 3 >= sizeof(buffer))
 595     {
 596         dbg_printf("Symbol too long (%s)\n", str);
 597         return;
 598     }
 599     buffer[0] = '*';
 600     buffer[1] = '!';
 601     strcpy(&buffer[2], str);
 602     /* this is a wine specific options to return also ELF modules in the
 603      * enumeration
 604      */
 605     SymSetOptions((opt = SymGetOptions()) | 0x40000000);
 606     SymEnumSymbols(dbg_curr_process->handle, 0, buffer, symbols_info_cb, NULL);
 607     SymSetOptions(opt);
 608 }