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