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