programs/winedbg/symbol.c

   1 /*
   2  * Generate hash tables for Wine debugger symbols
   3  *
   4  * Copyright (C) 1993, Eric Youngdale.
   5  *               2004-2005, 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., 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
  26 #include "debugger.h"
  27 #include "wine/debug.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
  30
  31 static BOOL symbol_get_debug_start(const struct dbg_type* func, ULONG64* start)
  32 {
  33     DWORD                       count, tag;
  34     char                        buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)];
  35     TI_FINDCHILDREN_PARAMS*     fcp = (TI_FINDCHILDREN_PARAMS*)buffer;
  36     int                         i;
  37     struct dbg_type             child;
  38
  39     if (!func->id) return FALSE; /* native dbghelp not always fills the info field */
  40
  41     if (!types_get_info(func, TI_GET_CHILDRENCOUNT, &count)) return FALSE;
  42     fcp->Start = 0;
  43     while (count)
  44     {
  45         fcp->Count = min(count, 256);
  46         if (types_get_info(func, TI_FINDCHILDREN, fcp))
  47         {
  48             for (i = 0; i < min(fcp->Count, count); i++)
  49             {
  50                 child.module = func->module;
  51                 child.id = fcp->ChildId[i];
  52                 types_get_info(&child, TI_GET_SYMTAG, &tag);
  53                 if (tag != SymTagFuncDebugStart) continue;
  54                 return types_get_info(&child, TI_GET_ADDRESS, start);
  55             }
  56             count -= min(count, 256);
  57             fcp->Start += 256;
  58             fcp->Start += 256;
  59         }
  60     }
  61     return FALSE;
  62 }
  63
  64 static BOOL fetch_tls_lvalue(const SYMBOL_INFO* sym, struct dbg_lvalue* lvalue)
  65 {
  66     struct dbg_module*        mod = dbg_get_module(dbg_curr_process, sym->ModBase);
  67     unsigned                  tlsindex;
  68     struct dbg_lvalue         lv_teb_tls, lv_index_addr, lv_module_tls;
  69     dbg_lgint_t               teb_tls_addr, index_addr, tls_module_addr;
  70     char*                     teb_tls_storage;
  71
  72     if (!mod || !mod->tls_index_offset || !dbg_curr_thread)
  73         return FALSE;
  74     /* get ThreadLocalStoragePointer offset depending on debuggee bitness */
  75     teb_tls_storage = (char*)dbg_curr_thread->teb;
  76     if (ADDRSIZE == sizeof(void*))
  77         /* debugger and debuggee have same bitness */
  78         teb_tls_storage += offsetof(TEB, ThreadLocalStoragePointer);
  79     else
  80         /* debugger is 64bit, while debuggee is 32bit */
  81         teb_tls_storage += 0x2000 /* TEB64 => TEB32 */ + offsetof(TEB32, ThreadLocalStoragePointer);
  82     init_lvalue(&lv_teb_tls, TRUE, teb_tls_storage);
  83
  84     if (!memory_fetch_integer(&lv_teb_tls, ADDRSIZE, FALSE, &teb_tls_addr))
  85         return FALSE;
  86
  87     init_lvalue(&lv_index_addr, TRUE, (void*)(DWORD_PTR)(sym->ModBase + mod->tls_index_offset));
  88     if (!memory_fetch_integer(&lv_index_addr, ADDRSIZE, FALSE, &index_addr))
  89         return FALSE;
  90
  91     if (!dbg_read_memory((const char*)(DWORD_PTR)index_addr, &tlsindex, sizeof(tlsindex)))
  92         return FALSE;
  93
  94     init_lvalue(&lv_module_tls, TRUE, (void*)(DWORD_PTR)(teb_tls_addr + tlsindex * ADDRSIZE));
  95     if (!memory_fetch_integer(&lv_module_tls, ADDRSIZE, FALSE, &tls_module_addr))
  96         return FALSE;
  97     init_lvalue(lvalue, TRUE, (void*)(DWORD_PTR)(tls_module_addr + sym->Address));
  98     return TRUE;
  99 }
 100
 101 static BOOL fill_sym_lvalue(const SYMBOL_INFO* sym, ULONG_PTR base,
 102                             struct dbg_lvalue* lvalue, char* buffer, size_t sz)
 103 {
 104     if (buffer) buffer[0] = '\0';
 105     if (sym->Flags & SYMFLAG_REGISTER)
 106     {
 107         if (!memory_get_register(sym->Register, lvalue, buffer, sz))
 108             return FALSE;
 109     }
 110     else if (sym->Flags & SYMFLAG_REGREL)
 111     {
 112         size_t  l;
 113
 114         *buffer++ = '['; sz--;
 115         if (!memory_get_register(sym->Register, lvalue, buffer, sz))
 116             return FALSE;
 117         l = strlen(buffer);
 118         sz -= l;
 119         buffer += l;
 120         init_lvalue(lvalue, TRUE, (void*)(DWORD_PTR)(types_extract_as_integer(lvalue) + sym->Address));
 121         if ((LONG64)sym->Address >= 0)
 122             snprintf(buffer, sz, "+%I64d]", sym->Address);
 123         else
 124             snprintf(buffer, sz, "-%I64d]", -(LONG64)sym->Address);
 125     }
 126     else if (sym->Flags & SYMFLAG_VALUEPRESENT)
 127     {
 128         struct dbg_type type;
 129         VARIANT         v;
 130
 131         type.module = sym->ModBase;
 132         type.id = sym->Index;
 133
 134         if (!types_get_info(&type, TI_GET_VALUE, &v))
 135         {
 136             if (buffer) snprintf(buffer, sz, "Couldn't get full value information for %s", sym->Name);
 137             return FALSE;
 138         }
 139         else if (V_ISBYREF(&v))
 140         {
 141             /* FIXME: this won't work for pointers or arrays, as we don't always
 142              * know, if the value to be dereferenced lies in debuggee or
 143              * debugger address space.
 144              */
 145             if (sym->Tag == SymTagPointerType || sym->Tag == SymTagArrayType)
 146             {
 147                 if (buffer) snprintf(buffer, sz, "Couldn't dereference pointer for const value for %s", sym->Name);
 148                 return FALSE;
 149             }
 150             /* this is likely Wine's dbghelp which passes const values by reference
 151              * (object is managed by dbghelp, hence in debugger address space)
 152              */
 153             init_lvalue(lvalue, FALSE, (void*)(DWORD_PTR)sym->Value);
 154         }
 155         else
 156         {
 157             DWORD* pdw = (DWORD*)lexeme_alloc_size(sizeof(*pdw));
 158             init_lvalue(lvalue, FALSE, pdw);
 159             *pdw = sym->Value;
 160         }
 161     }
 162     else if (sym->Flags & SYMFLAG_LOCAL)
 163     {
 164         init_lvalue(lvalue, TRUE, (void*)(DWORD_PTR)(base + sym->Address));
 165     }
 166     else if (sym->Flags & SYMFLAG_TLSREL)
 167     {
 168         if (!fetch_tls_lvalue(sym, lvalue))
 169         {
 170             if (buffer) snprintf(buffer, sz, "Cannot read TLS address\n");
 171             return FALSE;
 172         }
 173     }
 174     else
 175     {
 176         init_lvalue(lvalue, TRUE, (void*)(DWORD_PTR)sym->Address);
 177     }
 178     lvalue->addr.Mode = AddrModeFlat;
 179     lvalue->type.module = sym->ModBase;
 180     lvalue->type.id = sym->TypeIndex;
 181
 182     return TRUE;
 183 }
 184
 185 struct sgv_data
 186 {
 187 #define NUMDBGV                 100
 188     struct
 189     {
 190         /* FIXME: NUMDBGV should be made variable */
 191         struct dbg_lvalue               lvalue;
 192         DWORD                           flags;
 193         DWORD                           sym_info;
 194     }                           syms[NUMDBGV];  /* out     : will be filled in with various found symbols */
 195     int                         num;            /* out     : number of found symbols */
 196     int                         num_thunks;     /* out     : number of thunks found */
 197     const char*                 name;           /* in      : name of symbol to look up */
 198     unsigned                    do_thunks : 1;  /* in      : whether we return thunks tags */
 199     ULONG64                     frame_offset;   /* in      : frame for local & parameter variables look up */
 200 };
 201
 202 static BOOL CALLBACK sgv_cb(PSYMBOL_INFO sym, ULONG size, PVOID ctx)
 203 {
 204     struct sgv_data*    sgv = ctx;
 205     unsigned            insp;
 206     char                tmp[64];
 207
 208     if (sym->Flags & SYMFLAG_THUNK)
 209     {
 210         if (!sgv->do_thunks) return TRUE;
 211         sgv->num_thunks++;
 212     }
 213
 214     if (sgv->num >= NUMDBGV)
 215     {
 216         dbg_printf("Too many addresses for symbol '%s', limiting the first %d\n",
 217                    sgv->name, NUMDBGV);
 218         return FALSE;
 219     }
 220     WINE_TRACE("==> %s %s%s%s%s%s%s%s%s\n",
 221                sym->Name,
 222                (sym->Flags & SYMFLAG_FUNCTION) ? "func " : "",
 223                (sym->Flags & SYMFLAG_FRAMEREL) ? "framerel " : "",
 224                (sym->Flags & SYMFLAG_TLSREL) ? "tlsrel " : "",
 225                (sym->Flags & SYMFLAG_REGISTER) ? "register " : "",
 226                (sym->Flags & SYMFLAG_REGREL) ? "regrel " : "",
 227                (sym->Flags & SYMFLAG_PARAMETER) ? "param " : "",
 228                (sym->Flags & SYMFLAG_LOCAL) ? "local " : "",
 229                (sym->Flags & SYMFLAG_THUNK) ? "thunk " : "");
 230
 231     /* always keep the thunks at end of the array */
 232     insp = sgv->num;
 233     if (sgv->num_thunks && !(sym->Flags & SYMFLAG_THUNK))
 234     {
 235         insp -= sgv->num_thunks;
 236         memmove(&sgv->syms[insp + 1], &sgv->syms[insp],
 237                 sizeof(sgv->syms[0]) * sgv->num_thunks);
 238     }
 239     if (!fill_sym_lvalue(sym, sgv->frame_offset, &sgv->syms[insp].lvalue, tmp, sizeof(tmp)))
 240     {
 241         dbg_printf("%s: %s\n", sym->Name, tmp);
 242         return TRUE;
 243     }
 244     sgv->syms[insp].flags              = sym->Flags;
 245     sgv->syms[insp].sym_info           = sym->Index;
 246     sgv->num++;
 247
 248     return TRUE;
 249 }
 250
 251 enum sym_get_lval symbol_picker_interactive(const char* name, const struct sgv_data* sgv,
 252                                             struct dbg_lvalue* rtn)
 253 {
 254     char        buffer[512];
 255     unsigned    i;
 256
 257     if (!dbg_interactiveP)
 258     {
 259         dbg_printf("More than one symbol named %s, picking the first one\n", name);
 260         *rtn = sgv->syms[0].lvalue;
 261         return sglv_found;
 262     }
 263
 264     dbg_printf("Many symbols with name '%s', "
 265                "choose the one you want (<cr> to abort):\n", name);
 266     for (i = 0; i < sgv->num; i++)
 267     {
 268         if (sgv->num - sgv->num_thunks > 1 && (sgv->syms[i].flags & SYMFLAG_THUNK) && !DBG_IVAR(AlwaysShowThunks))
 269             continue;
 270         dbg_printf("[%d]: ", i + 1);
 271         if (sgv->syms[i].flags & (SYMFLAG_LOCAL | SYMFLAG_PARAMETER))
 272         {
 273             dbg_printf("%s %sof %s\n",
 274                        sgv->syms[i].flags & SYMFLAG_PARAMETER ? "Parameter" : "Local variable",
 275                        sgv->syms[i].flags & (SYMFLAG_REGISTER|SYMFLAG_REGREL) ? "(in a register) " : "",
 276                        name);
 277         }
 278         else if (sgv->syms[i].flags & SYMFLAG_THUNK)
 279         {
 280             print_address(&sgv->syms[i].lvalue.addr, TRUE);
 281             /* FIXME: should display where the thunks points to */
 282             dbg_printf(" thunk %s\n", name);
 283         }
 284         else
 285         {
 286             print_address(&sgv->syms[i].lvalue.addr, TRUE);
 287             dbg_printf("\n");
 288         }
 289     }
 290     do
 291     {
 292         if (input_read_line("=> ", buffer, sizeof(buffer)))
 293         {
 294             if (buffer[0] == '\0') return sglv_aborted;
 295             i = atoi(buffer);
 296             if (i < 1 || i > sgv->num)
 297                 dbg_printf("Invalid choice %d\n", i);
 298         }
 299         else return sglv_aborted;
 300     } while (i < 1 || i > sgv->num);
 301
 302     /* The array is 0-based, but the choices are 1..n,
 303      * so we have to subtract one before returning.
 304      */
 305     *rtn = sgv->syms[i - 1].lvalue;
 306     return sglv_found;
 307 }
 308
 309 enum sym_get_lval symbol_picker_scoped(const char* name, const struct sgv_data* sgv,
 310                                        struct dbg_lvalue* rtn)
 311 {
 312     unsigned i;
 313     int local = -1;
 314
 315     for (i = 0; i < sgv->num; i++)
 316     {
 317         if (sgv->num - sgv->num_thunks > 1 && (sgv->syms[i].flags & SYMFLAG_THUNK) && !DBG_IVAR(AlwaysShowThunks))
 318             continue;
 319         if (sgv->syms[i].flags & (SYMFLAG_LOCAL | SYMFLAG_PARAMETER))
 320         {
 321             if (local == -1)
 322                 local = i;
 323             else
 324             {
 325                 /* FIXME: several locals with same name... which one to pick ?? */
 326                 dbg_printf("Several local variables/parameters for %s, aborting\n", name);
 327                 return sglv_aborted;
 328             }
 329         }
 330     }
 331     if (local != -1)
 332     {
 333         *rtn = sgv->syms[local].lvalue;
 334         return sglv_found;
 335     }
 336     /* no locals found, multiple globals... abort for now */
 337     dbg_printf("Several global variables for %s, aborting\n", name);
 338     return sglv_aborted;
 339 }
 340
 341 symbol_picker_t symbol_current_picker = symbol_picker_interactive;
 342
 343 /***********************************************************************
 344  *           symbol_get_lvalue
 345  *
 346  * Get the address of a named symbol.
 347  * Return values:
 348  *      sglv_found:   if the symbol is found
 349  *      sglv_unknown: if the symbol isn't found
 350  *      sglv_aborted: some error occurred (likely, many symbols of same name exist,
 351  *          and user didn't pick one of them)
 352  */
 353 enum sym_get_lval symbol_get_lvalue(const char* name, const int lineno,
 354                                     struct dbg_lvalue* rtn, BOOL bp_disp)
 355 {
 356     struct sgv_data             sgv;
 357     int                         i;
 358     char                        buffer[512];
 359     BOOL                        opt;
 360     struct dbg_frame*           frm;
 361
 362     if (strlen(name) + 4 > sizeof(buffer))
 363     {
 364         WINE_WARN("Too long symbol (%s)\n", name);
 365         return sglv_unknown;
 366     }
 367
 368     sgv.num        = 0;
 369     sgv.num_thunks = 0;
 370     sgv.name       = &buffer[2];
 371     sgv.do_thunks  = DBG_IVAR(AlwaysShowThunks);
 372
 373     if (strchr(name, '!'))
 374     {
 375         strcpy(buffer, name);
 376     }
 377     else
 378     {
 379         buffer[0] = '*';
 380         buffer[1] = '!';
 381         strcpy(&buffer[2], name);
 382     }
 383
 384     /* this is a wine specific options to return also ELF modules in the
 385      * enumeration
 386      */
 387     opt = SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, TRUE);
 388     SymEnumSymbols(dbg_curr_process->handle, 0, buffer, sgv_cb, (void*)&sgv);
 389
 390     if (!sgv.num)
 391     {
 392         const char*   ptr = strchr(name, '!');
 393         if ((ptr && ptr[1] != '_') || (!ptr && *name != '_'))
 394         {
 395             if (ptr)
 396             {
 397                 int offset = ptr - name;
 398                 memcpy(buffer, name, offset + 1);
 399                 buffer[offset + 1] = '_';
 400                 strcpy(&buffer[offset + 2], ptr + 1);
 401             }
 402             else
 403             {
 404                 buffer[0] = '*';
 405                 buffer[1] = '!';
 406                 buffer[2] = '_';
 407                 strcpy(&buffer[3], name);
 408             }
 409             SymEnumSymbols(dbg_curr_process->handle, 0, buffer, sgv_cb, (void*)&sgv);
 410         }
 411     }
 412     SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, opt);
 413
 414     /* now grab local symbols */
 415     if ((frm = stack_get_curr_frame()) && sgv.num < NUMDBGV && !strchr(name, '!'))
 416     {
 417         sgv.frame_offset = frm->linear_frame;
 418         SymEnumSymbols(dbg_curr_process->handle, 0, name, sgv_cb, (void*)&sgv);
 419     }
 420
 421     if (!sgv.num)
 422     {
 423         dbg_printf("No symbols found for %s\n", name);
 424         return sglv_unknown;
 425     }
 426
 427     /* recompute potential offsets for functions (linenumber, skip prolog) */
 428     for (i = 0; i < sgv.num; i++)
 429     {
 430         if (sgv.syms[i].flags & (SYMFLAG_REGISTER|SYMFLAG_REGREL|SYMFLAG_LOCAL|SYMFLAG_THUNK))
 431             continue;
 432
 433         if (lineno == -1)
 434         {
 435             struct dbg_type     type;
 436             ULONG64             addr;
 437
 438             type.module = sgv.syms[i].lvalue.type.module;
 439             type.id     = sgv.syms[i].sym_info;
 440             if (bp_disp && symbol_get_debug_start(&type, &addr))
 441                 sgv.syms[i].lvalue.addr.Offset = addr;
 442         }
 443         else
 444         {
 445             DWORD               disp;
 446             IMAGEHLP_LINE64     il;
 447             BOOL                found = FALSE;
 448
 449             il.SizeOfStruct = sizeof(il);
 450             SymGetLineFromAddr64(dbg_curr_process->handle,
 451                                  (DWORD_PTR)memory_to_linear_addr(&sgv.syms[i].lvalue.addr),
 452                                  &disp, &il);
 453             do
 454             {
 455                 if (lineno == il.LineNumber)
 456                 {
 457                     sgv.syms[i].lvalue.addr.Offset = il.Address;
 458                     found = TRUE;
 459                     break;
 460                 }
 461             } while (SymGetLineNext64(dbg_curr_process->handle, &il));
 462             if (!found)
 463                 WINE_FIXME("No line (%d) found for %s (setting to symbol start)\n",
 464                            lineno, name);
 465         }
 466     }
 467
 468     if (sgv.num - sgv.num_thunks > 1 || /* many symbols non thunks (and showing only non thunks) */
 469         (sgv.num > 1 && DBG_IVAR(AlwaysShowThunks)) || /* many symbols (showing symbols & thunks) */
 470         (sgv.num == sgv.num_thunks && sgv.num_thunks > 1))
 471     {
 472         return symbol_current_picker(name, &sgv, rtn);
 473     }
 474     /* first symbol is the one we want:
 475      * - only one symbol found,
 476      * - or many symbols but only one non thunk when AlwaysShowThunks is FALSE
 477      */
 478     *rtn = sgv.syms[0].lvalue;
 479     return sglv_found;
 480 }
 481
 482 BOOL symbol_is_local(const char* name)
 483 {
 484     struct sgv_data             sgv;
 485     struct dbg_frame*           frm;
 486
 487     sgv.num        = 0;
 488     sgv.num_thunks = 0;
 489     sgv.name       = name;
 490     sgv.do_thunks  = FALSE;
 491
 492     if ((frm = stack_get_curr_frame()))
 493     {
 494         sgv.frame_offset = frm->linear_frame;
 495         SymEnumSymbols(dbg_curr_process->handle, 0, name, sgv_cb, (void*)&sgv);
 496     }
 497     return sgv.num > 0;
 498 }
 499
 500 /***********************************************************************
 501  *           symbol_read_symtable
 502  *
 503  * Read a symbol file into the hash table.
 504  */
 505 void symbol_read_symtable(const char* filename, ULONG_PTR offset)
 506 {
 507     dbg_printf("No longer supported\n");
 508
 509 #if 0
 510 /* FIXME: have to implement SymAddSymbol in dbghelp, but likely we'll need to link
 511  * this with an already loaded module !!
 512  */
 513     FILE*       symbolfile;
 514     unsigned    addr;
 515     char        type;
 516     char*       cpnt;
 517     char        buffer[256];
 518     char        name[256];
 519
 520     if (!(symbolfile = fopen(filename, "r")))
 521     {
 522         WINE_WARN("Unable to open symbol table %s\n", filename);
 523         return;
 524     }
 525
 526     dbg_printf("Reading symbols from file %s\n", filename);
 527
 528     while (1)
 529     {
 530         fgets(buffer, sizeof(buffer), symbolfile);
 531         if (feof(symbolfile)) break;
 532
 533         /* Strip any text after a # sign (i.e. comments) */
 534         cpnt = strchr(buffer, '#');
 535         if (cpnt) *cpnt = '\0';
 536
 537         /* Quietly ignore any lines that have just whitespace */
 538         for (cpnt = buffer; *cpnt; cpnt++)
 539         {
 540             if (*cpnt != ' ' && *cpnt != '\t') break;
 541         }
 542         if (!*cpnt || *cpnt == '\n') continue;
 543
 544         if (sscanf(buffer, "%lx %c %s", &addr, &type, name) == 3)
 545         {
 546             if (value.addr.off + offset < value.addr.off)
 547                 WINE_WARN("Address wrap around\n");
 548             value.addr.off += offset;
 549             SymAddSymbol(current_process->handle, BaseOfDll,
 550                          name, addr, 0, 0);
 551         }
 552     }
 553     fclose(symbolfile);
 554 #endif
 555 }
 556
 557 /***********************************************************************
 558  *           symbol_get_function_line_status
 559  *
 560  * Find the symbol nearest to a given address.
 561  */
 562 enum dbg_line_status symbol_get_function_line_status(const ADDRESS64* addr)
 563 {
 564     IMAGEHLP_LINE64     il;
 565     DWORD               disp;
 566     ULONG64             disp64, start;
 567     DWORD_PTR           lin = (DWORD_PTR)memory_to_linear_addr(addr);
 568     char                buffer[sizeof(SYMBOL_INFO) + 256];
 569     SYMBOL_INFO*        sym = (SYMBOL_INFO*)buffer;
 570     struct dbg_type     func;
 571
 572     il.SizeOfStruct = sizeof(il);
 573     sym->SizeOfStruct = sizeof(SYMBOL_INFO);
 574     sym->MaxNameLen = sizeof(buffer) - sizeof(SYMBOL_INFO);
 575
 576     /* do we have some info for lin address ? */
 577     if (!SymFromAddr(dbg_curr_process->handle, lin, &disp64, sym))
 578     {
 579         ADDRESS64   jumpee;
 580         /* some compilers insert thunks in their code without debug info associated
 581          * take care of this situation
 582          */
 583         if (dbg_curr_process->be_cpu->is_jump((void*)lin, &jumpee))
 584             return symbol_get_function_line_status(&jumpee);
 585         return dbg_no_line_info;
 586     }
 587
 588     switch (sym->Tag)
 589     {
 590     case SymTagThunk:
 591         /* FIXME: so far dbghelp doesn't return the 16 <=> 32 thunks
 592          * and furthermore, we no longer take care of them !!!
 593          */
 594         return dbg_in_a_thunk;
 595     case SymTagFunction:
 596     case SymTagPublicSymbol: break;
 597     default:
 598         WINE_FIXME("Unexpected sym-tag 0x%08lx\n", sym->Tag);
 599     case SymTagData:
 600         return dbg_no_line_info;
 601     }
 602     /* we should have a function now */
 603     if (!SymGetLineFromAddr64(dbg_curr_process->handle, lin, &disp, &il))
 604         return dbg_no_line_info;
 605
 606     func.module = sym->ModBase;
 607     func.id     = sym->Index;
 608
 609     if (symbol_get_debug_start(&func, &start) && lin < start)
 610         return dbg_not_on_a_line_number;
 611
 612     if (!sym->Size) sym->Size = 0x100000;
 613     if (il.FileName && il.FileName[0] && disp < sym->Size)
 614         return (disp == 0) ? dbg_on_a_line_number : dbg_not_on_a_line_number;
 615
 616     return dbg_no_line_info;
 617 }
 618
 619 /***********************************************************************
 620  *           symbol_get_line
 621  *
 622  * Find the symbol nearest to a given address.
 623  * Returns sourcefile name and line number in a format that the listing
 624  * handler can deal with.
 625  */
 626 BOOL symbol_get_line(const char* filename, const char* name,
 627                      IMAGEHLP_LINE64* line)
 628 {
 629     struct sgv_data     sgv;
 630     char                buffer[512];
 631     DWORD               opt, disp;
 632     unsigned            i;
 633     BOOL                found = FALSE;
 634     IMAGEHLP_LINE64     il;
 635
 636     sgv.num        = 0;
 637     sgv.num_thunks = 0;
 638     sgv.name       = &buffer[2];
 639     sgv.do_thunks  = FALSE;
 640
 641     buffer[0] = '*';
 642     buffer[1] = '!';
 643     strcpy(&buffer[2], name);
 644
 645     /* this is a wine specific options to return also ELF modules in the
 646      * enumeration
 647      */
 648     opt = SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, TRUE);
 649     if (!SymEnumSymbols(dbg_curr_process->handle, 0, buffer, sgv_cb, (void*)&sgv))
 650     {
 651         SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, opt);
 652         return FALSE;
 653     }
 654
 655     if (!sgv.num && (name[0] != '_'))
 656     {
 657         buffer[2] = '_';
 658         strcpy(&buffer[3], name);
 659         if (!SymEnumSymbols(dbg_curr_process->handle, 0, buffer, sgv_cb, (void*)&sgv))
 660         {
 661             SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, opt);
 662             return FALSE;
 663         }
 664     }
 665     SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, opt);
 666
 667     for (i = 0; i < sgv.num; i++)
 668     {
 669         DWORD_PTR linear = (DWORD_PTR)memory_to_linear_addr(&sgv.syms[i].lvalue.addr);
 670
 671         il.SizeOfStruct = sizeof(il);
 672         if (!SymGetLineFromAddr64(dbg_curr_process->handle, linear, &disp, &il))
 673             continue;
 674         if (filename && strcmp(il.FileName, filename)) continue;
 675         if (found)
 676         {
 677             WINE_FIXME("Several found, returning first (may not be what you want)...\n");
 678             break;
 679         }
 680         found = TRUE;
 681         *line = il;
 682     }
 683     if (!found)
 684     {
 685         if (filename)   dbg_printf("No such function %s in %s\n", name, filename);
 686         else            dbg_printf("No such function %s\n", name);
 687         return FALSE;
 688     }
 689     return TRUE;
 690 }
 691
 692 /******************************************************************
 693  *              symbol_print_localvalue
 694  *
 695  * Overall format is:
 696  * <value>                       in non detailed form
 697  * <value> (local|pmt <where>)   in detailed form
 698  * Note <value> can be an error message in case of error
 699  */
 700 void symbol_print_localvalue(const SYMBOL_INFO* sym, DWORD_PTR base, BOOL detailed)
 701 {
 702     struct dbg_lvalue   lvalue;
 703     char                buffer[64];
 704
 705     if (fill_sym_lvalue(sym, base, &lvalue, buffer, sizeof(buffer)))
 706     {
 707         print_value(&lvalue, 0, 1);
 708         if (detailed)
 709             dbg_printf(" (%s %s)",
 710                        (sym->Flags & SYMFLAG_PARAMETER) ? "parameter" : "local",
 711                        buffer);
 712     }
 713     else
 714     {
 715         dbg_printf("%s", buffer);
 716         if (detailed)
 717             dbg_printf(" (%s)",
 718                        (sym->Flags & SYMFLAG_PARAMETER) ? "parameter" : "local");
 719     }
 720 }
 721
 722 static BOOL CALLBACK info_locals_cb(PSYMBOL_INFO sym, ULONG size, PVOID ctx)
 723 {
 724     DWORD len;
 725     WCHAR* nameW;
 726
 727     len = MultiByteToWideChar(CP_ACP, 0, sym->Name, -1, NULL, 0);
 728     nameW = malloc(len * sizeof(WCHAR));
 729     if (nameW)
 730     {
 731         struct dbg_type type;
 732
 733         MultiByteToWideChar(CP_ACP, 0, sym->Name, -1, nameW, len);
 734
 735         type.module = sym->ModBase;
 736         type.id = sym->TypeIndex;
 737
 738         dbg_printf("\t");
 739         types_print_type(&type, FALSE, nameW);
 740         dbg_printf("=");
 741
 742         symbol_print_localvalue(sym, (DWORD_PTR)ctx, TRUE);
 743         dbg_printf("\n");
 744         free(nameW);
 745     }
 746
 747     return TRUE;
 748 }
 749
 750 BOOL symbol_info_locals(void)
 751 {
 752     ADDRESS64                   addr;
 753     struct dbg_frame*           frm;
 754
 755     if (!(frm = stack_get_curr_frame())) return FALSE;
 756
 757     addr.Mode = AddrModeFlat;
 758     addr.Offset = frm->linear_pc;
 759     print_address(&addr, FALSE);
 760     dbg_printf(": (%0*Ix)\n", ADDRWIDTH, frm->linear_frame);
 761     SymEnumSymbols(dbg_curr_process->handle, 0, NULL, info_locals_cb, (void*)frm->linear_frame);
 762
 763     return TRUE;
 764 }
 765
 766 static BOOL CALLBACK symbols_info_cb(PSYMBOL_INFO sym, ULONG size, PVOID ctx)
 767 {
 768     struct dbg_type     type;
 769     IMAGEHLP_MODULE     mi;
 770
 771     mi.SizeOfStruct = sizeof(mi);
 772
 773     if (!SymGetModuleInfo(dbg_curr_process->handle, sym->ModBase, &mi))
 774         mi.ModuleName[0] = '\0';
 775     else
 776     {
 777         size_t  len = strlen(mi.ModuleName);
 778         if (len > 5 && !strcmp(mi.ModuleName + len - 5, "<elf>"))
 779             mi.ModuleName[len - 5] = '\0';
 780     }
 781
 782     dbg_printf("%0*I64x: %s!%s", ADDRWIDTH, sym->Address, mi.ModuleName, sym->Name);
 783     type.id = sym->TypeIndex;
 784     type.module = sym->ModBase;
 785
 786     if (sym->TypeIndex != dbg_itype_none && sym->TypeIndex != 0)
 787     {
 788         dbg_printf(" ");
 789         types_print_type(&type, FALSE, NULL);
 790     }
 791     dbg_printf("\n");
 792     return TRUE;
 793 }
 794
 795 void symbol_info(const char* str)
 796 {
 797     char        buffer[512];
 798     BOOL        opt;
 799
 800     if (strlen(str) + 3 >= sizeof(buffer))
 801     {
 802         dbg_printf("Symbol too long (%s)\n", str);
 803         return;
 804     }
 805     buffer[0] = '*';
 806     buffer[1] = '!';
 807     strcpy(&buffer[2], str);
 808     /* this is a wine specific options to return also ELF modules in the
 809      * enumeration
 810      */
 811     opt = SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, TRUE);
 812     SymEnumSymbols(dbg_curr_process->handle, 0, buffer, symbols_info_cb, NULL);
 813     SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, opt);
 814 }