2 * Generate hash tables for Wine debugger symbols
4 * Copyright (C) 1993, Eric Youngdale.
5 * 2004-2005, Eric Pouech.
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.
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.
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
22 #define NONAMELESSUNION
23 #define NONAMELESSSTRUCT
31 #include "wine/debug.h"
33 WINE_DEFAULT_DEBUG_CHANNEL(winedbg
);
35 static BOOL
symbol_get_debug_start(const struct dbg_type
* func
, ULONG64
* start
)
38 char buffer
[sizeof(TI_FINDCHILDREN_PARAMS
) + 256 * sizeof(DWORD
)];
39 TI_FINDCHILDREN_PARAMS
* fcp
= (TI_FINDCHILDREN_PARAMS
*)buffer
;
41 struct dbg_type child
;
43 if (!func
->id
) return FALSE
; /* native dbghelp not always fills the info field */
45 if (!types_get_info(func
, TI_GET_CHILDRENCOUNT
, &count
)) return FALSE
;
49 fcp
->Count
= min(count
, 256);
50 if (types_get_info(func
, TI_FINDCHILDREN
, fcp
))
52 for (i
= 0; i
< min(fcp
->Count
, count
); i
++)
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
);
60 count
-= min(count
, 256);
68 static BOOL
fill_sym_lvalue(const SYMBOL_INFO
* sym
, ULONG base
,
69 struct dbg_lvalue
* lvalue
, char* buffer
, size_t sz
)
71 if (buffer
) buffer
[0] = '\0';
72 if (sym
->Flags
& SYMFLAG_REGISTER
)
76 if (!memory_get_register(sym
->Register
, &pval
, buffer
, sz
))
78 lvalue
->cookie
= DLV_HOST
;
79 lvalue
->addr
.Offset
= (DWORD_PTR
)pval
;
81 else if (sym
->Flags
& SYMFLAG_REGREL
)
85 if (!memory_get_register(sym
->Register
, &pval
, buffer
, sz
))
87 lvalue
->cookie
= DLV_TARGET
;
88 lvalue
->addr
.Offset
= (ULONG
)((ULONG64
)*pval
+ sym
->Address
);
90 else if (sym
->Flags
& SYMFLAG_VALUEPRESENT
)
96 type
.module
= sym
->ModBase
;
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
103 if (!types_get_info(&type
, TI_GET_VALUE
, &v
) || (v
.n1
.n2
.vt
& VT_BYREF
))
105 snprintf(buffer
, sz
, "Couldn't dereference pointer for const value");
108 pdw
= (DWORD
*)lexeme_alloc_size(sizeof(*pdw
));
109 lvalue
->cookie
= DLV_HOST
;
110 lvalue
->addr
.Offset
= (ULONG
)(DWORD_PTR
)pdw
;
113 else if (sym
->Flags
& SYMFLAG_LOCAL
)
115 lvalue
->cookie
= DLV_TARGET
;
116 lvalue
->addr
.Offset
= base
+ sym
->Address
;
120 lvalue
->cookie
= DLV_TARGET
;
121 lvalue
->addr
.Offset
= sym
->Address
;
123 lvalue
->addr
.Mode
= AddrModeFlat
;
124 lvalue
->type
.module
= sym
->ModBase
;
125 lvalue
->type
.id
= sym
->TypeIndex
;
135 /* FIXME: NUMDBGV should be made variable */
136 struct dbg_lvalue lvalue
;
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 */
147 static BOOL CALLBACK
sgv_cb(SYMBOL_INFO
* sym
, ULONG size
, void* ctx
)
149 struct sgv_data
* sgv
= (struct sgv_data
*)ctx
;
153 if (sym
->Flags
& SYMFLAG_THUNK
)
155 if (!sgv
->do_thunks
) return TRUE
;
159 if (sgv
->num
>= NUMDBGV
)
161 dbg_printf("Too many addresses for symbol '%s', limiting the first %d\n",
165 WINE_TRACE("==> %s %s%s%s%s%s%s%s\n",
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 " : "");
175 /* always keep the thunks at end of the array */
177 if (sgv
->num_thunks
&& !(sym
->Flags
& SYMFLAG_THUNK
))
179 insp
-= sgv
->num_thunks
;
180 memmove(&sgv
->syms
[insp
+ 1], &sgv
->syms
[insp
],
181 sizeof(sgv
->syms
[0]) * sgv
->num_thunks
);
183 if (!fill_sym_lvalue(sym
, sgv
->frame_offset
, &sgv
->syms
[insp
].lvalue
, tmp
, sizeof(tmp
)))
185 dbg_printf("%s: %s\n", sym
->Name
, tmp
);
188 sgv
->syms
[insp
].flags
= sym
->Flags
;
189 sgv
->syms
[insp
].sym_info
= sym
->info
;
195 /***********************************************************************
198 * Get the address of a named symbol.
200 * sglv_found: if the symbol is found
201 * sglv_unknown: if the symbol isn't found
202 * sglv_aborted: some error occurred (likely, many symbols of same name exist,
203 * and user didn't pick one of them)
205 enum sym_get_lval
symbol_get_lvalue(const char* name
, const int lineno
,
206 struct dbg_lvalue
* rtn
, BOOL bp_disp
)
212 IMAGEHLP_STACK_FRAME ihsf
;
214 if (strlen(name
) + 4 > sizeof(buffer
))
216 WINE_WARN("Too long symbol (%s)\n", name
);
222 sgv
.name
= &buffer
[2];
223 sgv
.do_thunks
= DBG_IVAR(AlwaysShowThunks
);
225 if (strchr(name
, '!'))
227 strcpy(buffer
, name
);
233 strcpy(&buffer
[2], name
);
236 /* this is a wine specific options to return also ELF modules in the
239 SymSetOptions((opt
= SymGetOptions()) | 0x40000000);
240 SymEnumSymbols(dbg_curr_process
->handle
, 0, buffer
, sgv_cb
, (void*)&sgv
);
244 const char* ptr
= strchr(name
, '!');
245 if ((ptr
&& ptr
[1] != '_') || (!ptr
&& *name
!= '_'))
249 int offset
= ptr
- name
;
250 memcpy(buffer
, name
, offset
+ 1);
251 buffer
[offset
+ 1] = '_';
252 strcpy(&buffer
[offset
+ 2], ptr
+ 1);
259 strcpy(&buffer
[3], name
);
261 SymEnumSymbols(dbg_curr_process
->handle
, 0, buffer
, sgv_cb
, (void*)&sgv
);
266 /* now grab local symbols */
267 if (stack_get_current_frame(&ihsf
) && sgv
.num
< NUMDBGV
)
269 sgv
.frame_offset
= ihsf
.FrameOffset
;
270 SymEnumSymbols(dbg_curr_process
->handle
, 0, name
, sgv_cb
, (void*)&sgv
);
275 dbg_printf("No symbols found for %s\n", name
);
279 /* recompute potential offsets for functions (linenumber, skip prolog) */
280 for (i
= 0; i
< sgv
.num
; i
++)
282 if (sgv
.syms
[i
].flags
& (SYMFLAG_REGISTER
|SYMFLAG_REGREL
|SYMFLAG_LOCAL
|SYMFLAG_THUNK
))
287 struct dbg_type type
;
290 type
.module
= sgv
.syms
[i
].lvalue
.type
.module
;
291 type
.id
= sgv
.syms
[i
].sym_info
;
292 if (bp_disp
&& symbol_get_debug_start(&type
, &addr
))
293 sgv
.syms
[i
].lvalue
.addr
.Offset
= addr
;
301 il
.SizeOfStruct
= sizeof(il
);
302 SymGetLineFromAddr(dbg_curr_process
->handle
,
303 (DWORD
)memory_to_linear_addr(&sgv
.syms
[i
].lvalue
.addr
),
307 if (lineno
== il
.LineNumber
)
309 sgv
.syms
[i
].lvalue
.addr
.Offset
= il
.Address
;
313 } while (SymGetLineNext(dbg_curr_process
->handle
, &il
));
315 WINE_FIXME("No line (%d) found for %s (setting to symbol start)\n",
321 if (dbg_interactiveP
)
323 if (sgv
.num
- sgv
.num_thunks
> 1 || /* many symbols non thunks (and showing only non thunks) */
324 (sgv
.num
> 1 && DBG_IVAR(AlwaysShowThunks
)) || /* many symbols (showing symbols & thunks) */
325 (sgv
.num
== sgv
.num_thunks
&& sgv
.num_thunks
> 1))
327 dbg_printf("Many symbols with name '%s', "
328 "choose the one you want (<cr> to abort):\n", name
);
329 for (i
= 0; i
< sgv
.num
; i
++)
331 if (sgv
.num
- sgv
.num_thunks
> 1 && (sgv
.syms
[i
].flags
& SYMFLAG_THUNK
) && !DBG_IVAR(AlwaysShowThunks
))
333 dbg_printf("[%d]: ", i
+ 1);
334 if (sgv
.syms
[i
].flags
& SYMFLAG_LOCAL
)
336 dbg_printf("%s %sof %s\n",
337 sgv
.syms
[i
].flags
& SYMFLAG_PARAMETER
? "Parameter" : "Local variable",
338 sgv
.syms
[i
].flags
& (SYMFLAG_REGISTER
|SYMFLAG_REGREL
) ? "(in a register) " : "",
341 else if (sgv
.syms
[i
].flags
& SYMFLAG_THUNK
)
343 print_address(&sgv
.syms
[i
].lvalue
.addr
, TRUE
);
344 /* FIXME: should display where the thunks points to */
345 dbg_printf(" thunk %s\n", name
);
349 print_address(&sgv
.syms
[i
].lvalue
.addr
, TRUE
);
356 if (input_read_line("=> ", buffer
, sizeof(buffer
)))
358 if (buffer
[0] == '\0') return sglv_aborted
;
360 if (i
< 1 || i
> sgv
.num
)
361 dbg_printf("Invalid choice %d\n", i
);
363 } while (i
< 1 || i
> sgv
.num
);
365 /* The array is 0-based, but the choices are 1..n,
366 * so we have to subtract one before returning.
373 /* FIXME: could display the list of non-picked up symbols */
375 dbg_printf("More than one symbol named %s, picking the first one\n", name
);
377 *rtn
= sgv
.syms
[i
].lvalue
;
381 BOOL
symbol_is_local(const char* name
)
384 IMAGEHLP_STACK_FRAME ihsf
;
389 sgv
.do_thunks
= FALSE
;
391 if (stack_get_current_frame(&ihsf
))
393 sgv
.frame_offset
= ihsf
.FrameOffset
;
394 SymEnumSymbols(dbg_curr_process
->handle
, 0, name
, sgv_cb
, (void*)&sgv
);
399 /***********************************************************************
400 * symbol_read_symtable
402 * Read a symbol file into the hash table.
404 void symbol_read_symtable(const char* filename
, unsigned long offset
)
406 dbg_printf("No longer supported\n");
409 /* FIXME: have to implement SymAddSymbol in dbghelp, but likely we'll need to link
410 * this with an already loaded module !!
419 if (!(symbolfile
= fopen(filename
, "r")))
421 WINE_WARN("Unable to open symbol table %s\n", filename
);
425 dbg_printf("Reading symbols from file %s\n", filename
);
429 fgets(buffer
, sizeof(buffer
), symbolfile
);
430 if (feof(symbolfile
)) break;
432 /* Strip any text after a # sign (i.e. comments) */
433 cpnt
= strchr(buffer
, '#');
434 if (cpnt
) *cpnt
= '\0';
436 /* Quietly ignore any lines that have just whitespace */
437 for (cpnt
= buffer
; *cpnt
; cpnt
++)
439 if (*cpnt
!= ' ' && *cpnt
!= '\t') break;
441 if (!*cpnt
|| *cpnt
== '\n') continue;
443 if (sscanf(buffer
, "%lx %c %s", &addr
, &type
, name
) == 3)
445 if (value
.addr
.off
+ offset
< value
.addr
.off
)
446 WINE_WARN("Address wrap around\n");
447 value
.addr
.off
+= offset
;
448 SymAddSymbol(current_process
->handle
, BaseOfDll
,
456 /***********************************************************************
457 * symbol_get_function_line_status
459 * Find the symbol nearest to a given address.
461 enum dbg_line_status
symbol_get_function_line_status(const ADDRESS64
* addr
)
465 ULONG64 disp64
, start
;
466 DWORD lin
= (DWORD
)memory_to_linear_addr(addr
);
467 char buffer
[sizeof(SYMBOL_INFO
) + 256];
468 SYMBOL_INFO
* sym
= (SYMBOL_INFO
*)buffer
;
469 struct dbg_type func
;
471 il
.SizeOfStruct
= sizeof(il
);
472 sym
->SizeOfStruct
= sizeof(SYMBOL_INFO
);
473 sym
->MaxNameLen
= sizeof(buffer
) - sizeof(SYMBOL_INFO
);
475 /* do we have some info for lin address ? */
476 if (!SymFromAddr(dbg_curr_process
->handle
, lin
, &disp64
, sym
))
477 return dbg_no_line_info
;
482 /* FIXME: so far dbghelp doesn't return the 16 <=> 32 thunks
483 * and furthermore, we no longer take care of them !!!
485 return dbg_in_a_thunk
;
487 case SymTagPublicSymbol
: break;
489 WINE_FIXME("Unexpected sym-tag 0x%08x\n", sym
->Tag
);
491 return dbg_no_line_info
;
493 /* we should have a function now */
494 if (!SymGetLineFromAddr(dbg_curr_process
->handle
, lin
, &disp
, &il
))
495 return dbg_no_line_info
;
497 func
.module
= sym
->ModBase
;
500 if (symbol_get_debug_start(&func
, &start
) && lin
< start
)
501 return dbg_not_on_a_line_number
;
503 if (!sym
->Size
) sym
->Size
= 0x100000;
504 if (il
.FileName
&& il
.FileName
[0] && disp
< sym
->Size
)
505 return (disp
== 0) ? dbg_on_a_line_number
: dbg_not_on_a_line_number
;
507 return dbg_no_line_info
;
510 /***********************************************************************
513 * Find the symbol nearest to a given address.
514 * Returns sourcefile name and line number in a format that the listing
515 * handler can deal with.
517 BOOL
symbol_get_line(const char* filename
, const char* name
, IMAGEHLP_LINE
* line
)
521 DWORD opt
, disp
, linear
;
522 unsigned i
, found
= FALSE
;
527 sgv
.name
= &buffer
[2];
528 sgv
.do_thunks
= FALSE
;
532 strcpy(&buffer
[2], name
);
534 /* this is a wine specific options to return also ELF modules in the
537 SymSetOptions((opt
= SymGetOptions()) | 0x40000000);
538 if (!SymEnumSymbols(dbg_curr_process
->handle
, 0, buffer
, sgv_cb
, (void*)&sgv
))
544 if (!sgv
.num
&& (name
[0] != '_'))
547 strcpy(&buffer
[3], name
);
548 if (!SymEnumSymbols(dbg_curr_process
->handle
, 0, buffer
, sgv_cb
, (void*)&sgv
))
556 for (i
= 0; i
< sgv
.num
; i
++)
558 linear
= (DWORD
)memory_to_linear_addr(&sgv
.syms
[i
].lvalue
.addr
);
560 il
.SizeOfStruct
= sizeof(il
);
561 if (!SymGetLineFromAddr(dbg_curr_process
->handle
, linear
, &disp
, &il
))
563 if (filename
&& strcmp(line
->FileName
, filename
)) continue;
566 WINE_FIXME("Several found, returning first (may not be what you want)...\n");
574 if (filename
) dbg_printf("No such function %s in %s\n", name
, filename
);
575 else dbg_printf("No such function %s\n", name
);
581 /******************************************************************
585 * <name>=<value> in non detailed form
586 * <name>=<value> (local|pmt <where>) in detailed form
587 * Note <value> can be an error message in case of error
589 void symbol_print_local(const SYMBOL_INFO
* sym
, ULONG base
,
592 struct dbg_lvalue lvalue
;
595 dbg_printf("%s=", sym
->Name
);
597 if (fill_sym_lvalue(sym
, base
, &lvalue
, buffer
, sizeof(buffer
)))
599 print_value(&lvalue
, 'x', 1);
601 dbg_printf(" (%s%s)",
602 (sym
->Flags
& SYMFLAG_PARAMETER
) ? "parameter" : "local",
610 (sym
->Flags
& SYMFLAG_PARAMETER
) ? "parameter" : "local");
614 static BOOL CALLBACK
info_locals_cb(SYMBOL_INFO
* sym
, ULONG size
, void* ctx
)
616 struct dbg_type type
;
619 type
.module
= sym
->ModBase
;
620 type
.id
= sym
->TypeIndex
;
621 types_print_type(&type
, FALSE
);
624 symbol_print_local(sym
, (ULONG
)ctx
, TRUE
);
630 int symbol_info_locals(void)
632 IMAGEHLP_STACK_FRAME ihsf
;
635 stack_get_current_frame(&ihsf
);
636 addr
.Mode
= AddrModeFlat
;
637 addr
.Offset
= ihsf
.InstructionOffset
;
638 print_address(&addr
, FALSE
);
639 dbg_printf(": (%08lx)\n", (DWORD_PTR
)ihsf
.FrameOffset
);
640 SymEnumSymbols(dbg_curr_process
->handle
, 0, NULL
, info_locals_cb
, (void*)(DWORD_PTR
)ihsf
.FrameOffset
);
646 static BOOL CALLBACK
symbols_info_cb(SYMBOL_INFO
* sym
, ULONG size
, void* ctx
)
648 struct dbg_type type
;
651 mi
.SizeOfStruct
= sizeof(mi
);
653 if (!SymGetModuleInfo(dbg_curr_process
->handle
, sym
->ModBase
, &mi
))
654 mi
.ModuleName
[0] = '\0';
657 size_t len
= strlen(mi
.ModuleName
);
658 if (len
> 5 && !strcmp(mi
.ModuleName
+ len
- 5, "<elf>"))
659 mi
.ModuleName
[len
- 5] = '\0';
662 dbg_printf("%08lx: %s!%s", (ULONG_PTR
)sym
->Address
, mi
.ModuleName
, sym
->Name
);
663 type
.id
= sym
->TypeIndex
;
664 type
.module
= sym
->ModBase
;
666 if (sym
->TypeIndex
!= dbg_itype_none
&& sym
->TypeIndex
!= 0)
669 types_print_type(&type
, FALSE
);
675 void symbol_info(const char* str
)
680 if (strlen(str
) + 3 >= sizeof(buffer
))
682 dbg_printf("Symbol too long (%s)\n", str
);
687 strcpy(&buffer
[2], str
);
688 /* this is a wine specific options to return also ELF modules in the
691 SymSetOptions((opt
= SymGetOptions()) | 0x40000000);
692 SymEnumSymbols(dbg_curr_process
->handle
, 0, buffer
, symbols_info_cb
, NULL
);