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