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_PTR 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 = (ULONG64)*pval + sym->Address;
90 else if (sym->Flags & SYMFLAG_VALUEPRESENT)
95 type.module = sym->ModBase;
98 if (!types_get_info(&type, TI_GET_VALUE, &v))
100 if (buffer) snprintf(buffer, sz, "Couldn't get full value information for %s", sym->Name);
103 else if (v.n1.n2.vt & VT_BYREF)
105 /* FIXME: this won't work for pointers or arrays, as we don't always
106 * know, if the value to be dereferenced lies in debuggee or
107 * debugger address space.
109 if (sym->Tag == SymTagPointerType || sym->Tag == SymTagArrayType)
111 if (buffer) snprintf(buffer, sz, "Couldn't dereference pointer for const value for %s", sym->Name);
114 /* this is likely Wine's dbghelp which passes const values by reference
115 * (object is managed by dbghelp, hence in debugger address space)
117 lvalue->cookie = DLV_HOST;
118 lvalue->addr.Offset = (DWORD_PTR)sym->Value;
122 DWORD* pdw = (DWORD*)lexeme_alloc_size(sizeof(*pdw));
123 lvalue->cookie = DLV_HOST;
124 lvalue->addr.Offset = (DWORD_PTR)pdw;
128 else if (sym->Flags & SYMFLAG_LOCAL)
130 lvalue->cookie = DLV_TARGET;
131 lvalue->addr.Offset = base + sym->Address;
133 else if (sym->Flags & SYMFLAG_TLSREL)
135 PROCESS_BASIC_INFORMATION pbi;
136 THREAD_BASIC_INFORMATION tbi;
139 PEB_LDR_DATA ldr_data;
140 PLIST_ENTRY head, current;
141 LDR_MODULE ldr_module;
142 unsigned tlsindex = -1;
144 if (NtQueryInformationProcess(dbg_curr_process->handle, ProcessBasicInformation,
145 &pbi, sizeof(pbi), NULL) ||
146 NtQueryInformationThread(dbg_curr_thread->handle, ThreadBasicInformation,
147 &tbi, sizeof(tbi), NULL))
150 if (buffer) snprintf(buffer, sz, "Cannot read TLS address\n");
153 addr = (DWORD_PTR)&(((TEB*)tbi.TebBaseAddress)->ThreadLocalStoragePointer);
154 if (!dbg_read_memory((void*)addr, &addr, sizeof(addr)) ||
155 !dbg_read_memory(pbi.PebBaseAddress, &peb, sizeof(peb)) ||
156 !dbg_read_memory(peb.LdrData, &ldr_data, sizeof(ldr_data)))
158 current = ldr_data.InLoadOrderModuleList.Flink;
159 head = &((PEB_LDR_DATA*)peb.LdrData)->InLoadOrderModuleList;
162 if (!dbg_read_memory(CONTAINING_RECORD(current, LDR_MODULE, InLoadOrderModuleList),
163 &ldr_module, sizeof(ldr_module))) goto tls_error;
164 if ((DWORD_PTR)ldr_module.BaseAddress == sym->ModBase)
166 tlsindex = ldr_module.TlsIndex;
169 current = ldr_module.InLoadOrderModuleList.Flink;
170 } while (current != head);
172 addr += tlsindex * sizeof(DWORD_PTR);
173 if (!dbg_read_memory((void*)addr, &addr, sizeof(addr))) goto tls_error;
174 lvalue->cookie = DLV_TARGET;
175 lvalue->addr.Offset = addr + sym->Address;
179 lvalue->cookie = DLV_TARGET;
180 lvalue->addr.Offset = sym->Address;
182 lvalue->addr.Mode = AddrModeFlat;
183 lvalue->type.module = sym->ModBase;
184 lvalue->type.id = sym->TypeIndex;
194 /* FIXME: NUMDBGV should be made variable */
195 struct dbg_lvalue lvalue;
198 } syms[NUMDBGV]; /* out : will be filled in with various found symbols */
199 int num; /* out : number of found symbols */
200 int num_thunks; /* out : number of thunks found */
201 const char* name; /* in : name of symbol to look up */
202 unsigned do_thunks : 1; /* in : whether we return thunks tags */
203 ULONG64 frame_offset; /* in : frame for local & parameter variables look up */
206 static BOOL CALLBACK sgv_cb(PSYMBOL_INFO sym, ULONG size, PVOID ctx)
208 struct sgv_data* sgv = ctx;
212 if (sym->Flags & SYMFLAG_THUNK)
214 if (!sgv->do_thunks) return TRUE;
218 if (sgv->num >= NUMDBGV)
220 dbg_printf("Too many addresses for symbol '%s', limiting the first %d\n",
224 WINE_TRACE("==> %s %s%s%s%s%s%s%s%s\n",
226 (sym->Flags & SYMFLAG_FUNCTION) ? "func " : "",
227 (sym->Flags & SYMFLAG_FRAMEREL) ? "framerel " : "",
228 (sym->Flags & SYMFLAG_TLSREL) ? "tlsrel " : "",
229 (sym->Flags & SYMFLAG_REGISTER) ? "register " : "",
230 (sym->Flags & SYMFLAG_REGREL) ? "regrel " : "",
231 (sym->Flags & SYMFLAG_PARAMETER) ? "param " : "",
232 (sym->Flags & SYMFLAG_LOCAL) ? "local " : "",
233 (sym->Flags & SYMFLAG_THUNK) ? "thunk " : "");
235 /* always keep the thunks at end of the array */
237 if (sgv->num_thunks && !(sym->Flags & SYMFLAG_THUNK))
239 insp -= sgv->num_thunks;
240 memmove(&sgv->syms[insp + 1], &sgv->syms[insp],
241 sizeof(sgv->syms[0]) * sgv->num_thunks);
243 if (!fill_sym_lvalue(sym, sgv->frame_offset, &sgv->syms[insp].lvalue, tmp, sizeof(tmp)))
245 dbg_printf("%s: %s\n", sym->Name, tmp);
248 sgv->syms[insp].flags = sym->Flags;
249 sgv->syms[insp].sym_info = sym->info;
255 enum sym_get_lval symbol_picker_interactive(const char* name, const struct sgv_data* sgv,
256 struct dbg_lvalue* rtn)
261 if (!dbg_interactiveP)
263 dbg_printf("More than one symbol named %s, picking the first one\n", name);
264 *rtn = sgv->syms[0].lvalue;
268 dbg_printf("Many symbols with name '%s', "
269 "choose the one you want (<cr> to abort):\n", name);
270 for (i = 0; i < sgv->num; i++)
272 if (sgv->num - sgv->num_thunks > 1 && (sgv->syms[i].flags & SYMFLAG_THUNK) && !DBG_IVAR(AlwaysShowThunks))
274 dbg_printf("[%d]: ", i + 1);
275 if (sgv->syms[i].flags & (SYMFLAG_LOCAL | SYMFLAG_PARAMETER))
277 dbg_printf("%s %sof %s\n",
278 sgv->syms[i].flags & SYMFLAG_PARAMETER ? "Parameter" : "Local variable",
279 sgv->syms[i].flags & (SYMFLAG_REGISTER|SYMFLAG_REGREL) ? "(in a register) " : "",
282 else if (sgv->syms[i].flags & SYMFLAG_THUNK)
284 print_address(&sgv->syms[i].lvalue.addr, TRUE);
285 /* FIXME: should display where the thunks points to */
286 dbg_printf(" thunk %s\n", name);
290 print_address(&sgv->syms[i].lvalue.addr, TRUE);
297 if (input_read_line("=> ", buffer, sizeof(buffer)))
299 if (buffer[0] == '\0') return sglv_aborted;
301 if (i < 1 || i > sgv->num)
302 dbg_printf("Invalid choice %d\n", i);
304 else return sglv_aborted;
305 } while (i < 1 || i > sgv->num);
307 /* The array is 0-based, but the choices are 1..n,
308 * so we have to subtract one before returning.
310 *rtn = sgv->syms[i - 1].lvalue;
314 enum sym_get_lval symbol_picker_scoped(const char* name, const struct sgv_data* sgv,
315 struct dbg_lvalue* rtn)
320 for (i = 0; i < sgv->num; i++)
322 if (sgv->num - sgv->num_thunks > 1 && (sgv->syms[i].flags & SYMFLAG_THUNK) && !DBG_IVAR(AlwaysShowThunks))
324 if (sgv->syms[i].flags & (SYMFLAG_LOCAL | SYMFLAG_PARAMETER))
330 /* FIXME: several locals with same name... which one to pick ?? */
331 dbg_printf("Several local variables/parameters for %s, aborting\n", name);
338 *rtn = sgv->syms[local].lvalue;
341 /* no locals found, multiple globals... abort for now */
342 dbg_printf("Several global variables for %s, aborting\n", name);
346 symbol_picker_t symbol_current_picker = symbol_picker_interactive;
348 /***********************************************************************
351 * Get the address of a named symbol.
353 * sglv_found: if the symbol is found
354 * sglv_unknown: if the symbol isn't found
355 * sglv_aborted: some error occurred (likely, many symbols of same name exist,
356 * and user didn't pick one of them)
358 enum sym_get_lval symbol_get_lvalue(const char* name, const int lineno,
359 struct dbg_lvalue* rtn, BOOL bp_disp)
365 IMAGEHLP_STACK_FRAME ihsf;
367 if (strlen(name) + 4 > sizeof(buffer))
369 WINE_WARN("Too long symbol (%s)\n", name);
375 sgv.name = &buffer[2];
376 sgv.do_thunks = DBG_IVAR(AlwaysShowThunks);
378 if (strchr(name, '!'))
380 strcpy(buffer, name);
386 strcpy(&buffer[2], name);
389 /* this is a wine specific options to return also ELF modules in the
392 SymSetOptions((opt = SymGetOptions()) | 0x40000000);
393 SymEnumSymbols(dbg_curr_process->handle, 0, buffer, sgv_cb, (void*)&sgv);
397 const char* ptr = strchr(name, '!');
398 if ((ptr && ptr[1] != '_') || (!ptr && *name != '_'))
402 int offset = ptr - name;
403 memcpy(buffer, name, offset + 1);
404 buffer[offset + 1] = '_';
405 strcpy(&buffer[offset + 2], ptr + 1);
412 strcpy(&buffer[3], name);
414 SymEnumSymbols(dbg_curr_process->handle, 0, buffer, sgv_cb, (void*)&sgv);
419 /* now grab local symbols */
420 if (stack_get_current_frame(&ihsf) && sgv.num < NUMDBGV)
422 sgv.frame_offset = ihsf.FrameOffset;
423 SymEnumSymbols(dbg_curr_process->handle, 0, name, sgv_cb, (void*)&sgv);
428 dbg_printf("No symbols found for %s\n", name);
432 /* recompute potential offsets for functions (linenumber, skip prolog) */
433 for (i = 0; i < sgv.num; i++)
435 if (sgv.syms[i].flags & (SYMFLAG_REGISTER|SYMFLAG_REGREL|SYMFLAG_LOCAL|SYMFLAG_THUNK))
440 struct dbg_type type;
443 type.module = sgv.syms[i].lvalue.type.module;
444 type.id = sgv.syms[i].sym_info;
445 if (bp_disp && symbol_get_debug_start(&type, &addr))
446 sgv.syms[i].lvalue.addr.Offset = addr;
454 il.SizeOfStruct = sizeof(il);
455 SymGetLineFromAddr64(dbg_curr_process->handle,
456 (DWORD_PTR)memory_to_linear_addr(&sgv.syms[i].lvalue.addr),
460 if (lineno == il.LineNumber)
462 sgv.syms[i].lvalue.addr.Offset = il.Address;
466 } while (SymGetLineNext64(dbg_curr_process->handle, &il));
468 WINE_FIXME("No line (%d) found for %s (setting to symbol start)\n",
473 if (sgv.num - sgv.num_thunks > 1 || /* many symbols non thunks (and showing only non thunks) */
474 (sgv.num > 1 && DBG_IVAR(AlwaysShowThunks)) || /* many symbols (showing symbols & thunks) */
475 (sgv.num == sgv.num_thunks && sgv.num_thunks > 1))
477 return symbol_current_picker(name, &sgv, rtn);
479 /* first symbol is the one we want:
480 * - only one symbol found,
481 * - or many symbols but only one non thunk when AlwaysShowThunks is FALSE
483 *rtn = sgv.syms[0].lvalue;
487 BOOL symbol_is_local(const char* name)
490 IMAGEHLP_STACK_FRAME ihsf;
495 sgv.do_thunks = FALSE;
497 if (stack_get_current_frame(&ihsf))
499 sgv.frame_offset = ihsf.FrameOffset;
500 SymEnumSymbols(dbg_curr_process->handle, 0, name, sgv_cb, (void*)&sgv);
505 /***********************************************************************
506 * symbol_read_symtable
508 * Read a symbol file into the hash table.
510 void symbol_read_symtable(const char* filename, unsigned long offset)
512 dbg_printf("No longer supported\n");
515 /* FIXME: have to implement SymAddSymbol in dbghelp, but likely we'll need to link
516 * this with an already loaded module !!
525 if (!(symbolfile = fopen(filename, "r")))
527 WINE_WARN("Unable to open symbol table %s\n", filename);
531 dbg_printf("Reading symbols from file %s\n", filename);
535 fgets(buffer, sizeof(buffer), symbolfile);
536 if (feof(symbolfile)) break;
538 /* Strip any text after a # sign (i.e. comments) */
539 cpnt = strchr(buffer, '#');
540 if (cpnt) *cpnt = '\0';
542 /* Quietly ignore any lines that have just whitespace */
543 for (cpnt = buffer; *cpnt; cpnt++)
545 if (*cpnt != ' ' && *cpnt != '\t') break;
547 if (!*cpnt || *cpnt == '\n') continue;
549 if (sscanf(buffer, "%lx %c %s", &addr, &type, name) == 3)
551 if (value.addr.off + offset < value.addr.off)
552 WINE_WARN("Address wrap around\n");
553 value.addr.off += offset;
554 SymAddSymbol(current_process->handle, BaseOfDll,
562 /***********************************************************************
563 * symbol_get_function_line_status
565 * Find the symbol nearest to a given address.
567 enum dbg_line_status symbol_get_function_line_status(const ADDRESS64* addr)
571 ULONG64 disp64, start;
572 DWORD_PTR lin = (DWORD_PTR)memory_to_linear_addr(addr);
573 char buffer[sizeof(SYMBOL_INFO) + 256];
574 SYMBOL_INFO* sym = (SYMBOL_INFO*)buffer;
575 struct dbg_type func;
577 il.SizeOfStruct = sizeof(il);
578 sym->SizeOfStruct = sizeof(SYMBOL_INFO);
579 sym->MaxNameLen = sizeof(buffer) - sizeof(SYMBOL_INFO);
581 /* do we have some info for lin address ? */
582 if (!SymFromAddr(dbg_curr_process->handle, lin, &disp64, sym))
585 /* some compilers insert thunks in their code without debug info associated
586 * take care of this situation
588 if (be_cpu->is_jump((void*)lin, &jumpee))
589 return symbol_get_function_line_status(&jumpee);
590 return dbg_no_line_info;
596 /* FIXME: so far dbghelp doesn't return the 16 <=> 32 thunks
597 * and furthermore, we no longer take care of them !!!
599 return dbg_in_a_thunk;
601 case SymTagPublicSymbol: break;
603 WINE_FIXME("Unexpected sym-tag 0x%08x\n", sym->Tag);
605 return dbg_no_line_info;
607 /* we should have a function now */
608 if (!SymGetLineFromAddr64(dbg_curr_process->handle, lin, &disp, &il))
609 return dbg_no_line_info;
611 func.module = sym->ModBase;
614 if (symbol_get_debug_start(&func, &start) && lin < start)
615 return dbg_not_on_a_line_number;
617 if (!sym->Size) sym->Size = 0x100000;
618 if (il.FileName && il.FileName[0] && disp < sym->Size)
619 return (disp == 0) ? dbg_on_a_line_number : dbg_not_on_a_line_number;
621 return dbg_no_line_info;
624 /***********************************************************************
627 * Find the symbol nearest to a given address.
628 * Returns sourcefile name and line number in a format that the listing
629 * handler can deal with.
631 BOOL symbol_get_line(const char* filename, const char* name,
632 IMAGEHLP_LINE64* line)
637 unsigned i, found = FALSE;
642 sgv.name = &buffer[2];
643 sgv.do_thunks = FALSE;
647 strcpy(&buffer[2], name);
649 /* this is a wine specific options to return also ELF modules in the
652 SymSetOptions((opt = SymGetOptions()) | 0x40000000);
653 if (!SymEnumSymbols(dbg_curr_process->handle, 0, buffer, sgv_cb, (void*)&sgv))
659 if (!sgv.num && (name[0] != '_'))
662 strcpy(&buffer[3], name);
663 if (!SymEnumSymbols(dbg_curr_process->handle, 0, buffer, sgv_cb, (void*)&sgv))
671 for (i = 0; i < sgv.num; i++)
673 DWORD_PTR linear = (DWORD_PTR)memory_to_linear_addr(&sgv.syms[i].lvalue.addr);
675 il.SizeOfStruct = sizeof(il);
676 if (!SymGetLineFromAddr64(dbg_curr_process->handle, linear, &disp, &il))
678 if (filename && strcmp(il.FileName, filename)) continue;
681 WINE_FIXME("Several found, returning first (may not be what you want)...\n");
689 if (filename) dbg_printf("No such function %s in %s\n", name, filename);
690 else dbg_printf("No such function %s\n", name);
696 /******************************************************************
700 * <name>=<value> in non detailed form
701 * <name>=<value> (local|pmt <where>) in detailed form
702 * Note <value> can be an error message in case of error
704 void symbol_print_local(const SYMBOL_INFO* sym, DWORD_PTR base, BOOL detailed)
706 struct dbg_lvalue lvalue;
709 dbg_printf("%s=", sym->Name);
711 if (fill_sym_lvalue(sym, base, &lvalue, buffer, sizeof(buffer)))
713 print_value(&lvalue, 0, 1);
715 dbg_printf(" (%s%s)",
716 (sym->Flags & SYMFLAG_PARAMETER) ? "parameter" : "local",
721 dbg_printf("%s", buffer);
724 (sym->Flags & SYMFLAG_PARAMETER) ? "parameter" : "local");
728 static BOOL CALLBACK info_locals_cb(PSYMBOL_INFO sym, ULONG size, PVOID ctx)
730 struct dbg_type type;
733 type.module = sym->ModBase;
734 type.id = sym->TypeIndex;
735 types_print_type(&type, FALSE);
738 symbol_print_local(sym, (DWORD_PTR)ctx, TRUE);
744 int symbol_info_locals(void)
746 IMAGEHLP_STACK_FRAME ihsf;
749 stack_get_current_frame(&ihsf);
750 addr.Mode = AddrModeFlat;
751 addr.Offset = ihsf.InstructionOffset;
752 print_address(&addr, FALSE);
753 dbg_printf(": (%08lx)\n", (DWORD_PTR)ihsf.FrameOffset);
754 SymEnumSymbols(dbg_curr_process->handle, 0, NULL, info_locals_cb, (void*)(DWORD_PTR)ihsf.FrameOffset);
760 static BOOL CALLBACK symbols_info_cb(PSYMBOL_INFO sym, ULONG size, PVOID ctx)
762 struct dbg_type type;
765 mi.SizeOfStruct = sizeof(mi);
767 if (!SymGetModuleInfo(dbg_curr_process->handle, sym->ModBase, &mi))
768 mi.ModuleName[0] = '\0';
771 size_t len = strlen(mi.ModuleName);
772 if (len > 5 && !strcmp(mi.ModuleName + len - 5, "<elf>"))
773 mi.ModuleName[len - 5] = '\0';
776 dbg_printf("%08lx: %s!%s", (ULONG_PTR)sym->Address, mi.ModuleName, sym->Name);
777 type.id = sym->TypeIndex;
778 type.module = sym->ModBase;
780 if (sym->TypeIndex != dbg_itype_none && sym->TypeIndex != 0)
783 types_print_type(&type, FALSE);
789 void symbol_info(const char* str)
794 if (strlen(str) + 3 >= sizeof(buffer))
796 dbg_printf("Symbol too long (%s)\n", str);
801 strcpy(&buffer[2], str);
802 /* this is a wine specific options to return also ELF modules in the
805 SymSetOptions((opt = SymGetOptions()) | 0x40000000);
806 SymEnumSymbols(dbg_curr_process->handle, 0, buffer, symbols_info_cb, NULL);