2 * Generate hash tables for Wine debugger symbols
4 * Copyright (C) 1993, Eric Youngdale.
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 type
.module
= mod_base
;
46 if (!types_get_info(&type
, TI_GET_CHILDRENCOUNT
, &count
)) return FALSE
;
50 fcp
->Count
= min(count
, 256);
51 if (types_get_info(&type
, TI_FINDCHILDREN
, fcp
))
53 for (i
= 0; i
< min(fcp
->Count
, count
); i
++)
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
);
60 count
-= min(count
, 256);
72 /* FIXME: NUMDBGV should be made variable */
73 struct dbg_lvalue lvalue
;
75 } syms
[NUMDBGV
]; /* out : will be filled in with various found symbols */
76 int num
; /* out : number of found symbols */
77 int num_thunks
; /* out : number of thunks found */
78 const char* name
; /* in : name of symbol to look up */
79 const char* filename
; /* in (opt): filename where to look up symbol */
80 int lineno
; /* in (opt): line number in filename where to look up symbol */
81 unsigned bp_disp
: 1, /* in : whether if we take into account func address or func first displayable insn */
82 do_thunks
: 1; /* in : whether we return thunks tags */
83 ULONG64 frame_offset
; /* in : frame for local & parameter variables look up */
86 static BOOL CALLBACK
sgv_cb(SYMBOL_INFO
* sym
, ULONG size
, void* ctx
)
88 struct sgv_data
* sgv
= (struct sgv_data
*)ctx
;
91 unsigned cookie
= DLV_TARGET
, insp
;
93 if (sym
->Flags
& SYMFLAG_REGISTER
)
95 const struct dbg_internal_var
* div
;
97 if (dbg_curr_thread
->curr_frame
!= 0)
99 dbg_printf(" %s (register): << cannot display, not in correct frame\n",
103 for (div
= dbg_context_vars
; div
->name
&& div
->val
!= sym
->Register
; div
++);
106 dbg_printf(" %s (register): couldn't find register %lu\n",
107 sym
->Name
, sym
->Register
);
110 addr
= (ULONG64
)(DWORD_PTR
)div
->pval
;
113 else if (sym
->Flags
& SYMFLAG_LOCAL
) /* covers both local & parameters */
115 addr
= sgv
->frame_offset
+ sym
->Address
;
117 else if (sym
->Flags
& SYMFLAG_THUNK
)
119 if (!sgv
->do_thunks
) return TRUE
;
126 il
.SizeOfStruct
= sizeof(il
);
127 SymGetLineFromAddr(dbg_curr_process
->handle
, sym
->Address
, &disp
, &il
);
128 if (sgv
->filename
&& strcmp(sgv
->filename
, il
.FileName
))
130 WINE_FIXME("File name mismatch (%s / %s)\n", sgv
->filename
, il
.FileName
);
134 if (sgv
->lineno
== -1)
137 !symbol_get_debug_start(sym
->ModBase
, sym
->TypeIndex
, &addr
))
145 if (sgv
->lineno
== il
.LineNumber
)
150 } while (SymGetLineNext(dbg_curr_process
->handle
, &il
));
153 WINE_FIXME("No line (%d) found for %s (setting to symbol)\n",
154 sgv
->lineno
, sgv
->name
);
160 if (sgv
->num
>= NUMDBGV
)
162 dbg_printf("Too many addresses for symbol '%s', limiting the first %d\n",
166 WINE_TRACE("==> %s %s%s%s%s%s%s%s\n",
168 (sym
->Flags
& SYMFLAG_FUNCTION
) ? "func " : "",
169 (sym
->Flags
& SYMFLAG_FRAMEREL
) ? "framerel " : "",
170 (sym
->Flags
& SYMFLAG_REGISTER
) ? "register " : "",
171 (sym
->Flags
& SYMFLAG_REGREL
) ? "regrel " : "",
172 (sym
->Flags
& SYMFLAG_PARAMETER
) ? "param " : "",
173 (sym
->Flags
& SYMFLAG_LOCAL
) ? "local " : "",
174 (sym
->Flags
& SYMFLAG_THUNK
) ? "thunk " : "");
176 /* always keep the thunks at end of the array */
178 if (sgv
->num_thunks
&& !(sym
->Flags
& SYMFLAG_THUNK
))
180 insp
-= sgv
->num_thunks
;
181 memmove(&sgv
->syms
[insp
+ 1], &sgv
->syms
[insp
],
182 sizeof(sgv
->syms
[0]) * sgv
->num_thunks
);
184 sgv
->syms
[insp
].lvalue
.cookie
= cookie
;
185 sgv
->syms
[insp
].lvalue
.addr
.Mode
= AddrModeFlat
;
186 sgv
->syms
[insp
].lvalue
.addr
.Offset
= addr
;
187 sgv
->syms
[insp
].lvalue
.type
.module
= sym
->ModBase
;
188 sgv
->syms
[insp
].lvalue
.type
.id
= sym
->TypeIndex
;
189 types_get_info(&sgv
->syms
[insp
].lvalue
.type
, TI_GET_TYPE
,
190 &sgv
->syms
[insp
].lvalue
.type
.id
);
191 sgv
->syms
[insp
].flags
= sym
->Flags
;
197 /***********************************************************************
200 * Get the address of a named symbol.
202 * sglv_found: if the symbol is found
203 * sglv_unknown: if the symbol isn't found
204 * sglv_aborted: some error occurred (likely, many symbols of same name exist,
205 * and user didn't pick one of them)
207 enum sym_get_lval
symbol_get_lvalue(const char* name
, const int lineno
,
208 struct dbg_lvalue
* rtn
, BOOL bp_disp
)
214 IMAGEHLP_STACK_FRAME ihsf
;
216 if (strlen(name
) + 4 > sizeof(buffer
))
218 WINE_WARN("Too long symbol (%s)\n", name
);
224 sgv
.name
= &buffer
[2];
227 sgv
.bp_disp
= bp_disp
? TRUE
: FALSE
;
228 sgv
.do_thunks
= DBG_IVAR(AlwaysShowThunks
);
230 if (strchr(name
, '!'))
232 strcpy(buffer
, name
);
238 strcpy(&buffer
[2], name
);
241 /* this is a wine specific options to return also ELF modules in the
244 SymSetOptions((opt
= SymGetOptions()) | 0x40000000);
245 if (!SymEnumSymbols(dbg_curr_process
->handle
, 0, buffer
, sgv_cb
, (void*)&sgv
))
251 if (!sgv
.num
&& (name
[0] != '_'))
253 char* ptr
= strchr(name
, '!');
257 memmove(ptr
+ 1, ptr
, strlen(ptr
));
265 strcpy(&buffer
[3], name
);
267 if (!SymEnumSymbols(dbg_curr_process
->handle
, 0, buffer
, sgv_cb
, (void*)&sgv
))
275 /* now grab local symbols */
276 if (stack_get_current_frame(&ihsf
) && sgv
.num
< NUMDBGV
)
278 sgv
.frame_offset
= ihsf
.FrameOffset
;
279 SymEnumSymbols(dbg_curr_process
->handle
, 0, name
, sgv_cb
, (void*)&sgv
);
284 dbg_printf("No symbols found for %s\n", name
);
288 if (dbg_interactiveP
)
290 if (sgv
.num
- sgv
.num_thunks
> 1 || /* many symbols non thunks (and showing only non thunks) */
291 (sgv
.num
> 1 && DBG_IVAR(AlwaysShowThunks
)) || /* many symbols (showing symbols & thunks) */
292 (sgv
.num
== sgv
.num_thunks
&& sgv
.num_thunks
> 1))
294 dbg_printf("Many symbols with name '%s', "
295 "choose the one you want (<cr> to abort):\n", name
);
296 for (i
= 0; i
< sgv
.num
; i
++)
298 if (sgv
.num
- sgv
.num_thunks
> 1 && (sgv
.syms
[i
].flags
& SYMFLAG_THUNK
) && !DBG_IVAR(AlwaysShowThunks
))
300 dbg_printf("[%d]: ", i
+ 1);
301 if (sgv
.syms
[i
].flags
& SYMFLAG_LOCAL
)
303 dbg_printf("%s %sof %s\n",
304 sgv
.syms
[i
].flags
& SYMFLAG_PARAMETER
? "Parameter" : "Local variable",
305 sgv
.syms
[i
].flags
& (SYMFLAG_REGISTER
|SYMFLAG_REGREL
) ? "(in a register) " : "",
308 else if (sgv
.syms
[i
].flags
& SYMFLAG_THUNK
)
310 print_address(&sgv
.syms
[i
].lvalue
.addr
, TRUE
);
311 /* FIXME: should display where the thunks points to */
312 dbg_printf(" thunk %s\n", name
);
316 print_address(&sgv
.syms
[i
].lvalue
.addr
, TRUE
);
323 if (input_read_line("=> ", buffer
, sizeof(buffer
)))
325 if (buffer
[0] == '\0') return sglv_aborted
;
327 if (i
< 1 || i
> sgv
.num
)
328 dbg_printf("Invalid choice %d\n", i
);
330 } while (i
< 1 || i
> sgv
.num
);
332 /* The array is 0-based, but the choices are 1..n,
333 * so we have to subtract one before returning.
340 /* FIXME: could display the list of non-picked up symbols */
342 dbg_printf("More than one symbol named %s, picking the first one\n", name
);
344 *rtn
= sgv
.syms
[i
].lvalue
;
348 BOOL
symbol_is_local(const char* name
)
351 IMAGEHLP_STACK_FRAME ihsf
;
359 sgv
.do_thunks
= FALSE
;
361 if (stack_get_current_frame(&ihsf
))
363 sgv
.frame_offset
= ihsf
.FrameOffset
;
364 SymEnumSymbols(dbg_curr_process
->handle
, 0, name
, sgv_cb
, (void*)&sgv
);
369 /***********************************************************************
370 * symbol_read_symtable
372 * Read a symbol file into the hash table.
374 void symbol_read_symtable(const char* filename
, unsigned long offset
)
376 dbg_printf("No longer supported\n");
379 /* FIXME: have to implement SymAddSymbol in dbghelp, but likely we'll need to link
380 * this with an already loaded module !!
389 if (!(symbolfile
= fopen(filename
, "r")))
391 WINE_WARN("Unable to open symbol table %s\n", filename
);
395 dbg_printf("Reading symbols from file %s\n", filename
);
399 fgets(buffer
, sizeof(buffer
), symbolfile
);
400 if (feof(symbolfile
)) break;
402 /* Strip any text after a # sign (i.e. comments) */
403 cpnt
= strchr(buffer
, '#');
404 if (cpnt
) *cpnt
= '\0';
406 /* Quietly ignore any lines that have just whitespace */
407 for (cpnt
= buffer
; *cpnt
; cpnt
++)
409 if (*cpnt
!= ' ' && *cpnt
!= '\t') break;
411 if (!*cpnt
|| *cpnt
== '\n') continue;
413 if (sscanf(buffer
, "%lx %c %s", &addr
, &type
, name
) == 3)
415 if (value
.addr
.off
+ offset
< value
.addr
.off
)
416 WINE_WARN("Address wrap around\n");
417 value
.addr
.off
+= offset
;
418 SymAddSymbol(current_process
->handle
, BaseOfDll
,
426 /***********************************************************************
427 * symbol_get_function_line_status
429 * Find the symbol nearest to a given address.
431 enum dbg_line_status
symbol_get_function_line_status(const ADDRESS
* addr
)
435 ULONG64 disp64
, start
, size
;
436 DWORD lin
= (DWORD
)memory_to_linear_addr(addr
);
437 char buffer
[sizeof(SYMBOL_INFO
) + 256];
438 SYMBOL_INFO
* sym
= (SYMBOL_INFO
*)buffer
;
439 struct dbg_type type
;
441 il
.SizeOfStruct
= sizeof(il
);
442 sym
->SizeOfStruct
= sizeof(SYMBOL_INFO
);
443 sym
->MaxNameLen
= sizeof(buffer
) - sizeof(SYMBOL_INFO
);
445 /* do we have some info for lin address ? */
446 if (!SymFromAddr(dbg_curr_process
->handle
, lin
, &disp64
, sym
))
447 return dbg_no_line_info
;
452 /* FIXME: so far dbghelp doesn't return the 16 <=> 32 thunks
453 * and furthermore, we no longer take care of them !!!
455 return dbg_in_a_thunk
;
457 case SymTagPublicSymbol
: break;
459 WINE_FIXME("Unexpected sym-tag 0x%08lx\n", sym
->Tag
);
461 return dbg_no_line_info
;
463 /* we should have a function now */
464 if (!SymGetLineFromAddr(dbg_curr_process
->handle
, lin
, &disp
, &il
))
465 return dbg_no_line_info
;
467 if (symbol_get_debug_start(sym
->ModBase
, sym
->TypeIndex
, &start
) && lin
< start
)
468 return dbg_not_on_a_line_number
;
469 type
.module
= sym
->ModBase
;
470 type
.id
= sym
->TypeIndex
;
471 if (!types_get_info(&type
, TI_GET_LENGTH
, &size
) || size
== 0)
473 if (il
.FileName
&& il
.FileName
[0] && disp
< size
)
474 return (disp
== 0) ? dbg_on_a_line_number
: dbg_not_on_a_line_number
;
476 return dbg_no_line_info
;
479 /***********************************************************************
482 * Find the symbol nearest to a given address.
483 * Returns sourcefile name and line number in a format that the listing
484 * handler can deal with.
486 BOOL
symbol_get_line(const char* filename
, const char* name
, IMAGEHLP_LINE
* line
)
494 sgv
.name
= &buffer
[2];
495 sgv
.filename
= filename
;
498 sgv
.do_thunks
= FALSE
;
502 strcpy(&buffer
[2], name
);
504 /* this is a wine specific options to return also ELF modules in the
507 SymSetOptions((opt
= SymGetOptions()) | 0x40000000);
508 if (!SymEnumSymbols(dbg_curr_process
->handle
, 0, buffer
, sgv_cb
, (void*)&sgv
))
514 if (!sgv
.num
&& (name
[0] != '_'))
517 strcpy(&buffer
[3], name
);
518 if (!SymEnumSymbols(dbg_curr_process
->handle
, 0, buffer
, sgv_cb
, (void*)&sgv
))
529 if (filename
) dbg_printf("No such function %s in %s\n", name
, filename
);
530 else dbg_printf("No such function %s\n", name
);
533 WINE_FIXME("Several found, returning first (may not be what you want)...\n");
535 return SymGetLineFromAddr(dbg_curr_process
->handle
,
536 (DWORD
)memory_to_linear_addr(&sgv
.syms
[0].lvalue
.addr
),
542 static BOOL CALLBACK
info_locals_cb(SYMBOL_INFO
* sym
, ULONG size
, void* ctx
)
545 const char* explain
= NULL
;
547 struct dbg_type type
;
550 type
.module
= sym
->ModBase
;
551 type
.id
= sym
->TypeIndex
;
552 types_get_info(&type
, TI_GET_TYPE
, &type
.id
);
553 types_print_type(&type
, FALSE
);
555 if (sym
->Flags
& SYMFLAG_PARAMETER
) explain
= "parameter";
556 else if (sym
->Flags
& SYMFLAG_LOCAL
) explain
= "local";
557 else if (sym
->Flags
& SYMFLAG_REGISTER
) explain
= buf
;
559 if (sym
->Flags
& SYMFLAG_REGISTER
)
561 const struct dbg_internal_var
* div
;
563 if (dbg_curr_thread
->curr_frame
!= 0)
565 dbg_printf(" %s (register): << cannot display, not in correct frame\n",
569 for (div
= dbg_context_vars
; div
->name
; div
++)
571 if (div
->val
== sym
->Register
)
574 sprintf(buf
, "local in register %s", div
->name
);
579 else if (sym
->Flags
& SYMFLAG_LOCAL
)
581 type
.id
= sym
->TypeIndex
;
582 v
= ((IMAGEHLP_STACK_FRAME
*)ctx
)->FrameOffset
+ sym
->Address
;
584 if (!dbg_read_memory((void*)v
, &val
, sizeof(val
)))
586 dbg_printf(" %s (%s) *** cannot read value at 0x%08lx\n", sym
->Name
, explain
, v
);
590 dbg_printf(" %s = 0x%8.8lx (%s)\n", sym
->Name
, val
, explain
);
595 int symbol_info_locals(void)
597 IMAGEHLP_STACK_FRAME ihsf
;
600 stack_get_current_frame(&ihsf
);
601 addr
.Mode
= AddrModeFlat
;
602 addr
.Offset
= ihsf
.InstructionOffset
;
603 print_address(&addr
, FALSE
);
604 dbg_printf(": (%08lx)\n", (DWORD_PTR
)ihsf
.FrameOffset
);
605 SymEnumSymbols(dbg_curr_process
->handle
, 0, NULL
, info_locals_cb
, (void*)(DWORD_PTR
)ihsf
.FrameOffset
);
611 static BOOL CALLBACK
symbols_info_cb(SYMBOL_INFO
* sym
, ULONG size
, void* ctx
)
613 struct dbg_type type
;
616 mi
.SizeOfStruct
= sizeof(mi
);
618 if (!SymGetModuleInfo(dbg_curr_process
->handle
, sym
->ModBase
, &mi
))
619 mi
.ModuleName
[0] = '\0';
622 size_t len
= strlen(mi
.ModuleName
);
623 if (len
> 5 && !strcmp(mi
.ModuleName
+ len
- 5, "<elf>"))
624 mi
.ModuleName
[len
- 5] = '\0';
627 dbg_printf("%08lx: %s!%s", (ULONG_PTR
)sym
->Address
, mi
.ModuleName
, sym
->Name
);
628 type
.id
= sym
->TypeIndex
;
629 type
.module
= sym
->ModBase
;
631 if (sym
->TypeIndex
!= dbg_itype_none
&& sym
->TypeIndex
!= 0 &&
632 types_get_info(&type
, TI_GET_TYPE
, &type
.id
))
635 types_print_type(&type
, FALSE
);
641 void symbol_info(const char* str
)
646 if (strlen(str
) + 3 >= sizeof(buffer
))
648 dbg_printf("Symbol too long (%s)\n", str
);
653 strcpy(&buffer
[2], str
);
654 /* this is a wine specific options to return also ELF modules in the
657 SymSetOptions((opt
= SymGetOptions()) | 0x40000000);
658 SymEnumSymbols(dbg_curr_process
->handle
, 0, buffer
, symbols_info_cb
, NULL
);