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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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(DWORD mod_base
, DWORD
typeid, ULONG64
* start
)
38 char buffer
[sizeof(TI_FINDCHILDREN_PARAMS
) + 256 * sizeof(DWORD
)];
39 TI_FINDCHILDREN_PARAMS
* fcp
= (TI_FINDCHILDREN_PARAMS
*)buffer
;
43 if (!typeid) return FALSE
; /* native dbghelp not always fills the info field */
44 type
.module
= mod_base
;
47 if (!types_get_info(&type
, TI_GET_CHILDRENCOUNT
, &count
)) return FALSE
;
51 fcp
->Count
= min(count
, 256);
52 if (types_get_info(&type
, TI_FINDCHILDREN
, fcp
))
54 for (i
= 0; i
< min(fcp
->Count
, count
); i
++)
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
);
61 count
-= min(count
, 256);
73 /* FIXME: NUMDBGV should be made variable */
74 struct dbg_lvalue lvalue
;
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 */
87 static BOOL CALLBACK
sgv_cb(SYMBOL_INFO
* sym
, ULONG size
, void* ctx
)
89 struct sgv_data
* sgv
= (struct sgv_data
*)ctx
;
92 unsigned cookie
= DLV_TARGET
, insp
;
94 if (sym
->Flags
& SYMFLAG_REGISTER
)
98 if (!memory_get_register(sym
->Register
, &val
, tmp
, sizeof(tmp
)))
100 dbg_printf(" %s (register): %s\n", sym
->Name
, tmp
);
103 addr
= (ULONG64
)(DWORD_PTR
)val
;
106 else if (sym
->Flags
& SYMFLAG_LOCAL
) /* covers both local & parameters */
108 addr
= sgv
->frame_offset
+ sym
->Address
;
110 else if (sym
->Flags
& SYMFLAG_THUNK
)
112 if (!sgv
->do_thunks
) return TRUE
;
119 il
.SizeOfStruct
= sizeof(il
);
120 SymGetLineFromAddr(dbg_curr_process
->handle
, sym
->Address
, &disp
, &il
);
121 if (sgv
->filename
&& strcmp(sgv
->filename
, il
.FileName
))
123 WINE_FIXME("File name mismatch (%s / %s)\n", sgv
->filename
, il
.FileName
);
127 if (sgv
->lineno
== -1)
130 !symbol_get_debug_start(sym
->ModBase
, sym
->info
, &addr
))
138 if (sgv
->lineno
== il
.LineNumber
)
143 } while (SymGetLineNext(dbg_curr_process
->handle
, &il
));
146 WINE_FIXME("No line (%d) found for %s (setting to symbol)\n",
147 sgv
->lineno
, sgv
->name
);
153 if (sgv
->num
>= NUMDBGV
)
155 dbg_printf("Too many addresses for symbol '%s', limiting the first %d\n",
159 WINE_TRACE("==> %s %s%s%s%s%s%s%s\n",
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 " : "");
169 /* always keep the thunks at end of the array */
171 if (sgv
->num_thunks
&& !(sym
->Flags
& SYMFLAG_THUNK
))
173 insp
-= sgv
->num_thunks
;
174 memmove(&sgv
->syms
[insp
+ 1], &sgv
->syms
[insp
],
175 sizeof(sgv
->syms
[0]) * sgv
->num_thunks
);
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
;
188 /***********************************************************************
191 * Get the address of a named symbol.
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)
198 enum sym_get_lval
symbol_get_lvalue(const char* name
, const int lineno
,
199 struct dbg_lvalue
* rtn
, BOOL bp_disp
)
205 IMAGEHLP_STACK_FRAME ihsf
;
207 if (strlen(name
) + 4 > sizeof(buffer
))
209 WINE_WARN("Too long symbol (%s)\n", name
);
215 sgv
.name
= &buffer
[2];
218 sgv
.bp_disp
= bp_disp
? TRUE
: FALSE
;
219 sgv
.do_thunks
= DBG_IVAR(AlwaysShowThunks
);
221 if (strchr(name
, '!'))
223 strcpy(buffer
, name
);
229 strcpy(&buffer
[2], name
);
232 /* this is a wine specific options to return also ELF modules in the
235 SymSetOptions((opt
= SymGetOptions()) | 0x40000000);
236 if (!SymEnumSymbols(dbg_curr_process
->handle
, 0, buffer
, sgv_cb
, (void*)&sgv
))
242 if (!sgv
.num
&& (name
[0] != '_'))
244 char* ptr
= strchr(name
, '!');
248 memmove(ptr
+ 1, ptr
, strlen(ptr
));
256 strcpy(&buffer
[3], name
);
258 if (!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 if (dbg_interactiveP
)
281 if (sgv
.num
- sgv
.num_thunks
> 1 || /* many symbols non thunks (and showing only non thunks) */
282 (sgv
.num
> 1 && DBG_IVAR(AlwaysShowThunks
)) || /* many symbols (showing symbols & thunks) */
283 (sgv
.num
== sgv
.num_thunks
&& sgv
.num_thunks
> 1))
285 dbg_printf("Many symbols with name '%s', "
286 "choose the one you want (<cr> to abort):\n", name
);
287 for (i
= 0; i
< sgv
.num
; i
++)
289 if (sgv
.num
- sgv
.num_thunks
> 1 && (sgv
.syms
[i
].flags
& SYMFLAG_THUNK
) && !DBG_IVAR(AlwaysShowThunks
))
291 dbg_printf("[%d]: ", i
+ 1);
292 if (sgv
.syms
[i
].flags
& SYMFLAG_LOCAL
)
294 dbg_printf("%s %sof %s\n",
295 sgv
.syms
[i
].flags
& SYMFLAG_PARAMETER
? "Parameter" : "Local variable",
296 sgv
.syms
[i
].flags
& (SYMFLAG_REGISTER
|SYMFLAG_REGREL
) ? "(in a register) " : "",
299 else if (sgv
.syms
[i
].flags
& SYMFLAG_THUNK
)
301 print_address(&sgv
.syms
[i
].lvalue
.addr
, TRUE
);
302 /* FIXME: should display where the thunks points to */
303 dbg_printf(" thunk %s\n", name
);
307 print_address(&sgv
.syms
[i
].lvalue
.addr
, TRUE
);
314 if (input_read_line("=> ", buffer
, sizeof(buffer
)))
316 if (buffer
[0] == '\0') return sglv_aborted
;
318 if (i
< 1 || i
> sgv
.num
)
319 dbg_printf("Invalid choice %d\n", i
);
321 } while (i
< 1 || i
> sgv
.num
);
323 /* The array is 0-based, but the choices are 1..n,
324 * so we have to subtract one before returning.
331 /* FIXME: could display the list of non-picked up symbols */
333 dbg_printf("More than one symbol named %s, picking the first one\n", name
);
335 *rtn
= sgv
.syms
[i
].lvalue
;
339 BOOL
symbol_is_local(const char* name
)
342 IMAGEHLP_STACK_FRAME ihsf
;
350 sgv
.do_thunks
= FALSE
;
352 if (stack_get_current_frame(&ihsf
))
354 sgv
.frame_offset
= ihsf
.FrameOffset
;
355 SymEnumSymbols(dbg_curr_process
->handle
, 0, name
, sgv_cb
, (void*)&sgv
);
360 /***********************************************************************
361 * symbol_read_symtable
363 * Read a symbol file into the hash table.
365 void symbol_read_symtable(const char* filename
, unsigned long offset
)
367 dbg_printf("No longer supported\n");
370 /* FIXME: have to implement SymAddSymbol in dbghelp, but likely we'll need to link
371 * this with an already loaded module !!
380 if (!(symbolfile
= fopen(filename
, "r")))
382 WINE_WARN("Unable to open symbol table %s\n", filename
);
386 dbg_printf("Reading symbols from file %s\n", filename
);
390 fgets(buffer
, sizeof(buffer
), symbolfile
);
391 if (feof(symbolfile
)) break;
393 /* Strip any text after a # sign (i.e. comments) */
394 cpnt
= strchr(buffer
, '#');
395 if (cpnt
) *cpnt
= '\0';
397 /* Quietly ignore any lines that have just whitespace */
398 for (cpnt
= buffer
; *cpnt
; cpnt
++)
400 if (*cpnt
!= ' ' && *cpnt
!= '\t') break;
402 if (!*cpnt
|| *cpnt
== '\n') continue;
404 if (sscanf(buffer
, "%lx %c %s", &addr
, &type
, name
) == 3)
406 if (value
.addr
.off
+ offset
< value
.addr
.off
)
407 WINE_WARN("Address wrap around\n");
408 value
.addr
.off
+= offset
;
409 SymAddSymbol(current_process
->handle
, BaseOfDll
,
417 /***********************************************************************
418 * symbol_get_function_line_status
420 * Find the symbol nearest to a given address.
422 enum dbg_line_status
symbol_get_function_line_status(const ADDRESS
* addr
)
426 ULONG64 disp64
, start
;
427 DWORD lin
= (DWORD
)memory_to_linear_addr(addr
);
428 char buffer
[sizeof(SYMBOL_INFO
) + 256];
429 SYMBOL_INFO
* sym
= (SYMBOL_INFO
*)buffer
;
431 il
.SizeOfStruct
= sizeof(il
);
432 sym
->SizeOfStruct
= sizeof(SYMBOL_INFO
);
433 sym
->MaxNameLen
= sizeof(buffer
) - sizeof(SYMBOL_INFO
);
435 /* do we have some info for lin address ? */
436 if (!SymFromAddr(dbg_curr_process
->handle
, lin
, &disp64
, sym
))
437 return dbg_no_line_info
;
442 /* FIXME: so far dbghelp doesn't return the 16 <=> 32 thunks
443 * and furthermore, we no longer take care of them !!!
445 return dbg_in_a_thunk
;
447 case SymTagPublicSymbol
: break;
449 WINE_FIXME("Unexpected sym-tag 0x%08lx\n", sym
->Tag
);
451 return dbg_no_line_info
;
453 /* we should have a function now */
454 if (!SymGetLineFromAddr(dbg_curr_process
->handle
, lin
, &disp
, &il
))
455 return dbg_no_line_info
;
457 if (symbol_get_debug_start(sym
->ModBase
, sym
->info
, &start
) && lin
< start
)
458 return dbg_not_on_a_line_number
;
459 if (!sym
->Size
) sym
->Size
= 0x100000;
460 if (il
.FileName
&& il
.FileName
[0] && disp
< sym
->Size
)
461 return (disp
== 0) ? dbg_on_a_line_number
: dbg_not_on_a_line_number
;
463 return dbg_no_line_info
;
466 /***********************************************************************
469 * Find the symbol nearest to a given address.
470 * Returns sourcefile name and line number in a format that the listing
471 * handler can deal with.
473 BOOL
symbol_get_line(const char* filename
, const char* name
, IMAGEHLP_LINE
* line
)
481 sgv
.name
= &buffer
[2];
482 sgv
.filename
= filename
;
485 sgv
.do_thunks
= FALSE
;
489 strcpy(&buffer
[2], name
);
491 /* this is a wine specific options to return also ELF modules in the
494 SymSetOptions((opt
= SymGetOptions()) | 0x40000000);
495 if (!SymEnumSymbols(dbg_curr_process
->handle
, 0, buffer
, sgv_cb
, (void*)&sgv
))
501 if (!sgv
.num
&& (name
[0] != '_'))
504 strcpy(&buffer
[3], name
);
505 if (!SymEnumSymbols(dbg_curr_process
->handle
, 0, buffer
, sgv_cb
, (void*)&sgv
))
516 if (filename
) dbg_printf("No such function %s in %s\n", name
, filename
);
517 else dbg_printf("No such function %s\n", name
);
520 WINE_FIXME("Several found, returning first (may not be what you want)...\n");
522 return SymGetLineFromAddr(dbg_curr_process
->handle
,
523 (DWORD
)memory_to_linear_addr(&sgv
.syms
[0].lvalue
.addr
),
529 static BOOL CALLBACK
info_locals_cb(SYMBOL_INFO
* sym
, ULONG size
, void* ctx
)
533 struct dbg_type type
;
536 type
.module
= sym
->ModBase
;
537 type
.id
= sym
->TypeIndex
;
538 types_print_type(&type
, FALSE
);
542 if (sym
->Flags
& SYMFLAG_REGISTER
)
546 if (!memory_get_register(sym
->Register
, &pval
, tmp
, sizeof(tmp
)))
548 dbg_printf(" %s (register): %s\n", sym
->Name
, tmp
);
551 sprintf(buf
, " in register %s", tmp
);
554 else if (sym
->Flags
& SYMFLAG_LOCAL
)
556 type
.id
= sym
->TypeIndex
;
557 v
= (ULONG
)ctx
+ sym
->Address
;
559 if (!dbg_read_memory((void*)v
, &val
, sizeof(val
)))
561 dbg_printf(" %s (%s) *** cannot read at 0x%08lx\n",
562 sym
->Name
, (sym
->Flags
& SYMFLAG_PARAMETER
) ? "parameter" : "local",
567 dbg_printf(" %s = 0x%8.8lx (%s%s)\n", sym
->Name
, val
,
568 (sym
->Flags
& SYMFLAG_PARAMETER
) ? "parameter" : "local", buf
);
573 int symbol_info_locals(void)
575 IMAGEHLP_STACK_FRAME ihsf
;
578 stack_get_current_frame(&ihsf
);
579 addr
.Mode
= AddrModeFlat
;
580 addr
.Offset
= ihsf
.InstructionOffset
;
581 print_address(&addr
, FALSE
);
582 dbg_printf(": (%08lx)\n", (DWORD_PTR
)ihsf
.FrameOffset
);
583 SymEnumSymbols(dbg_curr_process
->handle
, 0, NULL
, info_locals_cb
, (void*)(DWORD_PTR
)ihsf
.FrameOffset
);
589 static BOOL CALLBACK
symbols_info_cb(SYMBOL_INFO
* sym
, ULONG size
, void* ctx
)
591 struct dbg_type type
;
594 mi
.SizeOfStruct
= sizeof(mi
);
596 if (!SymGetModuleInfo(dbg_curr_process
->handle
, sym
->ModBase
, &mi
))
597 mi
.ModuleName
[0] = '\0';
600 size_t len
= strlen(mi
.ModuleName
);
601 if (len
> 5 && !strcmp(mi
.ModuleName
+ len
- 5, "<elf>"))
602 mi
.ModuleName
[len
- 5] = '\0';
605 dbg_printf("%08lx: %s!%s", (ULONG_PTR
)sym
->Address
, mi
.ModuleName
, sym
->Name
);
606 type
.id
= sym
->TypeIndex
;
607 type
.module
= sym
->ModBase
;
609 if (sym
->TypeIndex
!= dbg_itype_none
&& sym
->TypeIndex
!= 0)
612 types_print_type(&type
, FALSE
);
618 void symbol_info(const char* str
)
623 if (strlen(str
) + 3 >= sizeof(buffer
))
625 dbg_printf("Symbol too long (%s)\n", str
);
630 strcpy(&buffer
[2], str
);
631 /* this is a wine specific options to return also ELF modules in the
634 SymSetOptions((opt
= SymGetOptions()) | 0x40000000);
635 SymEnumSymbols(dbg_curr_process
->handle
, 0, buffer
, symbols_info_cb
, NULL
);