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);
71 /* FIXME: NUMDBGV should be made variable */
72 struct dbg_lvalue lvalue
;
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 */
85 static BOOL CALLBACK
sgv_cb(SYMBOL_INFO
* sym
, ULONG size
, void* ctx
)
87 struct sgv_data
* sgv
= (struct sgv_data
*)ctx
;
90 unsigned cookie
= DLV_TARGET
, insp
;
92 if (sym
->Flags
& SYMFLAG_REGISTER
)
94 const struct dbg_internal_var
* div
;
96 if (dbg_curr_frame
!= 0)
98 dbg_printf(" %s (register): << cannot display, not in correct frame\n",
102 for (div
= dbg_context_vars
; div
->name
&& div
->val
!= sym
->Register
; div
++);
105 dbg_printf(" %s (register): couldn't find register %lu\n",
106 sym
->Name
, sym
->Register
);
109 addr
= (ULONG64
)(DWORD_PTR
)div
->pval
;
112 else if (sym
->Flags
& SYMFLAG_FRAMEREL
)
115 struct dbg_type type
;
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
;
122 else if (sym
->Flags
& SYMFLAG_THUNK
)
124 if (!sgv
->do_thunks
) return TRUE
;
130 il
.SizeOfStruct
= sizeof(il
);
131 SymGetLineFromAddr(dbg_curr_process
->handle
, sym
->Address
, NULL
, &il
);
132 if (sgv
->filename
&& strcmp(sgv
->filename
, il
.FileName
))
134 WINE_FIXME("File name mismatch (%s / %s)\n", sgv
->filename
, il
.FileName
);
138 if (sgv
->lineno
== -1)
141 !symbol_get_debug_start(sym
->ModBase
, sym
->TypeIndex
, &addr
))
149 if (sgv
->lineno
== il
.LineNumber
)
154 } while (SymGetLineNext(dbg_curr_process
->handle
, &il
));
157 WINE_FIXME("No line (%d) found for %s (setting to symbol)\n",
158 sgv
->lineno
, sgv
->name
);
164 if (sgv
->num
>= NUMDBGV
)
166 dbg_printf("Too many addresses for symbol '%s', limiting the first %d\n",
170 WINE_TRACE("==> %s %s%s%s%s%s%s\n",
172 (sym
->Flags
& SYMFLAG_FUNCTION
) ? "func " : "",
173 (sym
->Flags
& SYMFLAG_FRAMEREL
) ? "framerel " : "",
174 (sym
->Flags
& SYMFLAG_REGISTER
) ? "register " : "",
175 (sym
->Flags
& SYMFLAG_REGREL
) ? "regrel " : "",
176 (sym
->Flags
& SYMFLAG_PARAMETER
) ? "param " : "",
177 (sym
->Flags
& SYMFLAG_THUNK
) ? "thunk " : "");
179 /* always keep the thunks at end of the array */
181 if (sgv
->num_thunks
&& !(sym
->Flags
& SYMFLAG_THUNK
))
183 insp
-= sgv
->num_thunks
;
184 memmove(&sgv
->syms
[insp
+ 1], &sgv
->syms
[insp
],
185 sizeof(sgv
->syms
[0]) * sgv
->num_thunks
);
187 sgv
->syms
[insp
].lvalue
.cookie
= cookie
;
188 sgv
->syms
[insp
].lvalue
.addr
.Mode
= AddrModeFlat
;
189 sgv
->syms
[insp
].lvalue
.addr
.Offset
= addr
;
190 sgv
->syms
[insp
].lvalue
.type
.module
= sym
->ModBase
;
191 sgv
->syms
[insp
].lvalue
.type
.id
= sym
->TypeIndex
;
192 types_get_info(&sgv
->syms
[insp
].lvalue
.type
, TI_GET_TYPE
,
193 &sgv
->syms
[insp
].lvalue
.type
.id
);
194 sgv
->syms
[insp
].flags
= sym
->Flags
;
200 /***********************************************************************
203 * Get the address of a named symbol.
205 * sglv_found: if the symbol is found
206 * sglv_unknown: if the symbol isn't found
207 * sglv_aborted: some error occurred (likely, many symbols of same name exist,
208 * and user didn't pick one of them)
210 enum sym_get_lval
symbol_get_lvalue(const char* name
, const int lineno
,
211 struct dbg_lvalue
* rtn
, BOOL bp_disp
)
215 char tmp
[sizeof(SYMBOL_INFO
) + 256];
216 SYMBOL_INFO
* si
= (SYMBOL_INFO
*)tmp
;
220 if (strlen(name
) + 4 > sizeof(buffer
))
222 WINE_WARN("Too long symbol (%s)\n", name
);
228 sgv
.name
= &buffer
[2];
231 sgv
.bp_disp
= bp_disp
? TRUE
: FALSE
;
232 sgv
.do_thunks
= DBG_IVAR(AlwaysShowThunks
);
236 strcpy(&buffer
[2], name
);
238 /* this is a wine specific options to return also ELF modules in the
241 SymSetOptions((opt
= SymGetOptions()) | 0x40000000);
242 if (!SymEnumSymbols(dbg_curr_process
->handle
, 0, buffer
, sgv_cb
, (void*)&sgv
))
248 if (!sgv
.num
&& (name
[0] != '_'))
251 strcpy(&buffer
[3], name
);
252 if (!SymEnumSymbols(dbg_curr_process
->handle
, 0, buffer
, sgv_cb
, (void*)&sgv
))
260 /* now grab local symbols */
261 si
->SizeOfStruct
= sizeof(*si
);
262 si
->MaxNameLen
= 256;
263 if (stack_get_frame(si
, &sgv
.ihsf
) && sgv
.num
< NUMDBGV
)
265 if (SymSetContext(dbg_curr_process
->handle
, &sgv
.ihsf
, NULL
))
266 SymEnumSymbols(dbg_curr_process
->handle
, 0, name
, sgv_cb
, (void*)&sgv
);
271 dbg_printf("No symbols found for %s\n", name
);
275 if (dbg_interactiveP
)
277 if (sgv
.num
- sgv
.num_thunks
> 1 || /* many symbols non thunks (and showing only non thunks) */
278 (sgv
.num
> 1 && DBG_IVAR(AlwaysShowThunks
)) || /* many symbols (showing symbols & thunks) */
279 (sgv
.num
== sgv
.num_thunks
&& sgv
.num_thunks
> 1))
281 dbg_printf("Many symbols with name '%s', "
282 "choose the one you want (<cr> to abort):\n", name
);
283 for (i
= 0; i
< sgv
.num
; i
++)
285 if (sgv
.num
- sgv
.num_thunks
> 1 && (sgv
.syms
[i
].flags
& SYMFLAG_THUNK
) && !DBG_IVAR(AlwaysShowThunks
))
287 dbg_printf("[%d]: ", i
+ 1);
288 if (sgv
.syms
[i
].flags
& SYMFLAG_LOCAL
)
290 dbg_printf("local variable %sof %s\n",
291 sgv
.syms
[i
].flags
& SYMFLAG_REGISTER
? "(in a register) " : "",
294 else if (sgv
.syms
[i
].flags
& SYMFLAG_PARAMETER
)
296 dbg_printf("parameter %sof %s\n",
297 sgv
.syms
[i
].flags
& SYMFLAG_REGISTER
? "(in a register) " : "",
300 else if (sgv
.syms
[i
].flags
& SYMFLAG_THUNK
)
302 print_address(&sgv
.syms
[i
].lvalue
.addr
, TRUE
);
303 /* FIXME: should display where the thunks points to */
304 dbg_printf(" thunk %s\n", name
);
308 print_address(&sgv
.syms
[i
].lvalue
.addr
, TRUE
);
315 if (input_read_line("=> ", buffer
, sizeof(buffer
)))
317 if (buffer
[0] == '\0') return sglv_aborted
;
319 if (i
< 1 || i
> sgv
.num
)
320 dbg_printf("Invalid choice %d\n", i
);
322 } while (i
< 1 || i
> sgv
.num
);
324 /* The array is 0-based, but the choices are 1..n,
325 * so we have to subtract one before returning.
332 /* FIXME: could display the list of non-picked up symbols */
334 dbg_printf("More than one symbol named %s, picking the first one\n", name
);
336 *rtn
= sgv
.syms
[i
].lvalue
;
340 BOOL
symbol_is_local(const char* name
)
343 char tmp
[sizeof(SYMBOL_INFO
) + 256];
344 SYMBOL_INFO
* si
= (SYMBOL_INFO
*)tmp
;
352 sgv
.do_thunks
= FALSE
;
354 si
->SizeOfStruct
= sizeof(*si
);
355 si
->MaxNameLen
= 256;
356 if (stack_get_frame(si
, &sgv
.ihsf
) &&
357 SymSetContext(dbg_curr_process
->handle
, &sgv
.ihsf
, NULL
))
358 SymEnumSymbols(dbg_curr_process
->handle
, 0, name
, sgv_cb
, (void*)&sgv
);
362 /***********************************************************************
363 * symbol_read_symtable
365 * Read a symbol file into the hash table.
367 void symbol_read_symtable(const char* filename
, unsigned long offset
)
369 dbg_printf("No longer supported\n");
372 /* FIXME: have to implement SymAddSymbol in dbghelp, but likely we'll need to link
373 * this with an already loaded module !!
382 if (!(symbolfile
= fopen(filename
, "r")))
384 WINE_WARN("Unable to open symbol table %s\n", filename
);
388 dbg_printf("Reading symbols from file %s\n", filename
);
392 fgets(buffer
, sizeof(buffer
), symbolfile
);
393 if (feof(symbolfile
)) break;
395 /* Strip any text after a # sign (i.e. comments) */
396 cpnt
= strchr(buffer
, '#');
397 if (cpnt
) *cpnt
= '\0';
399 /* Quietly ignore any lines that have just whitespace */
400 for (cpnt
= buffer
; *cpnt
; cpnt
++)
402 if (*cpnt
!= ' ' && *cpnt
!= '\t') break;
404 if (!*cpnt
|| *cpnt
== '\n') continue;
406 if (sscanf(buffer
, "%lx %c %s", &addr
, &type
, name
) == 3)
408 if (value
.addr
.off
+ offset
< value
.addr
.off
)
409 WINE_WARN("Address wrap around\n");
410 value
.addr
.off
+= offset
;
411 SymAddSymbol(current_process
->handle
, BaseOfDll
,
419 /***********************************************************************
420 * symbol_get_function_line_status
422 * Find the symbol nearest to a given address.
424 enum dbg_line_status
symbol_get_function_line_status(const ADDRESS
* addr
)
429 DWORD lin
= (DWORD
)memory_to_linear_addr(addr
);
430 char buffer
[sizeof(SYMBOL_INFO
) + 256];
431 SYMBOL_INFO
* sym
= (SYMBOL_INFO
*)buffer
;
432 struct dbg_type type
;
434 il
.SizeOfStruct
= sizeof(il
);
435 sym
->SizeOfStruct
= sizeof(SYMBOL_INFO
);
436 sym
->MaxNameLen
= sizeof(buffer
) - sizeof(SYMBOL_INFO
);
438 /* do we have some info for lin address ? */
439 if (!SymFromAddr(dbg_curr_process
->handle
, lin
, NULL
, sym
))
440 return dbg_no_line_info
;
445 /* FIXME: so far dbghelp doesn't return the 16 <=> 32 thunks
446 * and furthermore, we no longer take care of them !!!
448 return dbg_in_a_thunk
;
450 case SymTagPublicSymbol
: break;
452 WINE_FIXME("Unexpected sym-tag 0x%08lx\n", sym
->Tag
);
454 return dbg_no_line_info
;
456 /* we should have a function now */
457 if (!SymGetLineFromAddr(dbg_curr_process
->handle
, lin
, &disp
, &il
))
458 return dbg_no_line_info
;
460 if (symbol_get_debug_start(sym
->ModBase
, sym
->TypeIndex
, &start
) && lin
< start
)
461 return dbg_not_on_a_line_number
;
462 type
.module
= sym
->ModBase
;
463 type
.id
= sym
->TypeIndex
;
464 if (!types_get_info(&type
, TI_GET_LENGTH
, &size
) || size
== 0)
466 if (il
.FileName
&& il
.FileName
[0] && disp
< size
)
467 return (disp
== 0) ? dbg_on_a_line_number
: dbg_not_on_a_line_number
;
469 return dbg_no_line_info
;
472 /***********************************************************************
475 * Find the symbol nearest to a given address.
476 * Returns sourcefile name and line number in a format that the listing
477 * handler can deal with.
479 BOOL
symbol_get_line(const char* filename
, const char* name
, IMAGEHLP_LINE
* line
)
487 sgv
.name
= &buffer
[2];
488 sgv
.filename
= filename
;
491 sgv
.do_thunks
= FALSE
;
495 strcpy(&buffer
[2], name
);
497 /* this is a wine specific options to return also ELF modules in the
500 SymSetOptions((opt
= SymGetOptions()) | 0x40000000);
501 if (!SymEnumSymbols(dbg_curr_process
->handle
, 0, buffer
, sgv_cb
, (void*)&sgv
))
507 if (!sgv
.num
&& (name
[0] != '_'))
510 strcpy(&buffer
[3], name
);
511 if (!SymEnumSymbols(dbg_curr_process
->handle
, 0, buffer
, sgv_cb
, (void*)&sgv
))
522 if (filename
) dbg_printf("No such function %s in %s\n", name
, filename
);
523 else dbg_printf("No such function %s\n", name
);
526 WINE_FIXME("Several found, returning first (may not be what you want)...\n");
528 return SymGetLineFromAddr(dbg_curr_process
->handle
,
529 (DWORD
)memory_to_linear_addr(&sgv
.syms
[0].lvalue
.addr
),
535 static BOOL CALLBACK
info_locals_cb(SYMBOL_INFO
* sym
, ULONG size
, void* ctx
)
538 const char* explain
= NULL
;
540 struct dbg_type type
;
543 type
.module
= sym
->ModBase
;
544 type
.id
= sym
->TypeIndex
;
545 types_get_info(&type
, TI_GET_TYPE
, &type
.id
);
546 types_print_type(&type
, FALSE
);
548 if (sym
->Flags
& SYMFLAG_LOCAL
) explain
= "local";
549 else if (sym
->Flags
& SYMFLAG_PARAMETER
) explain
= "parameter";
550 else if (sym
->Flags
& SYMFLAG_REGISTER
) explain
= buf
;
552 if (sym
->Flags
& SYMFLAG_REGISTER
)
554 const struct dbg_internal_var
* div
;
556 if (dbg_curr_frame
!= 0)
558 dbg_printf(" %s (register): << cannot display, not in correct frame\n",
562 for (div
= dbg_context_vars
; div
->name
; div
++)
564 if (div
->val
== sym
->Register
)
567 sprintf(buf
, "local in register %s", div
->name
);
572 else if (sym
->Flags
& SYMFLAG_FRAMEREL
)
574 type
.id
= sym
->TypeIndex
;
575 types_get_info(&type
, TI_GET_OFFSET
, &v
);
576 v
+= ((IMAGEHLP_STACK_FRAME
*)ctx
)->FrameOffset
;
578 dbg_read_memory_verbose((void*)v
, &val
, sizeof(val
));
580 dbg_printf(" %s = 0x%8.8lx (%s)\n", sym
->Name
, val
, explain
);
585 int symbol_info_locals(void)
587 IMAGEHLP_STACK_FRAME ihsf
;
588 char buffer
[sizeof(SYMBOL_INFO
) + 256];
589 SYMBOL_INFO
* si
= (SYMBOL_INFO
*)buffer
;
591 si
->SizeOfStruct
= sizeof(*si
);
592 si
->MaxNameLen
= 256;
593 if (stack_get_frame(si
, &ihsf
))
595 dbg_printf("%s:\n", si
->Name
);
596 if (SymSetContext(dbg_curr_process
->handle
, &ihsf
, NULL
))
597 SymEnumSymbols(dbg_curr_process
->handle
, 0, NULL
, info_locals_cb
, &ihsf
);
602 static BOOL CALLBACK
symbols_info_cb(SYMBOL_INFO
* sym
, ULONG size
, void* ctx
)
604 struct dbg_type type
;
607 mi
.SizeOfStruct
= sizeof(mi
);
609 if (!SymGetModuleInfo(dbg_curr_process
->handle
, sym
->ModBase
, &mi
))
610 mi
.ModuleName
[0] = '\0';
613 size_t len
= strlen(mi
.ModuleName
);
614 if (len
> 5 && !strcmp(mi
.ModuleName
+ len
- 5, "<elf>"))
615 mi
.ModuleName
[len
- 5] = '\0';
618 dbg_printf("%08lx: %s!%s", (ULONG_PTR
)sym
->Address
, mi
.ModuleName
, sym
->Name
);
619 type
.id
= sym
->TypeIndex
;
620 type
.module
= sym
->ModBase
;
622 if (sym
->TypeIndex
!= dbg_itype_none
&& sym
->TypeIndex
!= 0 &&
623 types_get_info(&type
, TI_GET_TYPE
, &type
.id
))
626 types_print_type(&type
, FALSE
);
632 void symbol_info(const char* str
)
637 if (strlen(str
) + 3 >= sizeof(buffer
))
639 dbg_printf("Symbol too long (%s)\n", str
);
644 strcpy(&buffer
[2], str
);
645 /* this is a wine specific options to return also ELF modules in the
648 SymSetOptions((opt
= SymGetOptions()) | 0x40000000);
649 SymEnumSymbols(dbg_curr_process
->handle
, 0, buffer
, symbols_info_cb
, NULL
);