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