?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update German resources.
[wine/multimedia.git] / dlls / dbghelp / symbol.c
blob2b15df3f81c43216d0e019f69c8c3e69ef3eac7e
1 /*
2 * File symbol.c - management of symbols (lexical tree)
3 *
4 * Copyright (C) 1993, Eric Youngdale.
5 * 2004, Eric Pouech
6 *
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.
11 *
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.
16 *
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
20 */
21
22 #define NONAMELESSUNION
23 #define NONAMELESSSTRUCT
24
25 #include "config.h"
26
27 #include <stdlib.h>
28 #include <stdio.h>
29 #include <string.h>
30 #include <limits.h>
31 #include <sys/types.h>
32 #include <assert.h>
33 #ifdef HAVE_REGEX_H
34 # include <regex.h>
35 #endif
36
37 #include "wine/debug.h"
38 #include "dbghelp_private.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
41 WINE_DECLARE_DEBUG_CHANNEL(dbghelp_symt);
42
43 struct line_info
44 {
45 unsigned long is_first : 1,
46 is_last : 1,
47 is_source_file : 1,
48 line_number;
49 union
50 {
51 unsigned long pc_offset; /* if is_source_file isn't set */
52 unsigned source_file; /* if is_source_file is set */
53 } u;
54 };
55
56 inline static int cmp_addr(ULONG64 a1, ULONG64 a2)
57 {
58 if (a1 > a2) return 1;
59 if (a1 < a2) return -1;
60 return 0;
61 }
62
63 inline static int cmp_sorttab_addr(const struct module* module, int idx, ULONG64 addr)
64 {
65 ULONG64 ref;
66
67 symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_ADDRESS, &ref);
68 return cmp_addr(ref, addr);
69 }
70
71 int symt_cmp_addr(const void* p1, const void* p2)
72 {
73 const struct symt* sym1 = *(const struct symt* const *)p1;
74 const struct symt* sym2 = *(const struct symt* const *)p2;
75 ULONG64 a1, a2;
76
77 symt_get_info(sym1, TI_GET_ADDRESS, &a1);
78 symt_get_info(sym2, TI_GET_ADDRESS, &a2);
79 return cmp_addr(a1, a2);
80 }
81
82 static inline void re_append(char** mask, unsigned* len, char ch)
83 {
84 *mask = HeapReAlloc(GetProcessHeap(), 0, *mask, ++(*len));
85 (*mask)[*len - 2] = ch;
86 }
87
88 /* transforms a dbghelp's regular expression into a POSIX one
89 * Here are the valid dbghelp reg ex characters:
90 * * 0 or more characters
91 * ? a single character
92 * [] list
93 * # 0 or more of preceding char
94 * + 1 or more of preceding char
95 * escapes \ on #, ?, [, ], *, +. don't work on -
96 */
97 static void compile_regex(const char* str, int numchar, regex_t* re)
98 {
99 char* mask = HeapAlloc(GetProcessHeap(), 0, 1);
100 unsigned len = 1;
101 BOOL in_escape = FALSE;
102
103 re_append(&mask, &len, '^');
104
105 while (*str && numchar--)
106 {
107 /* FIXME: this shouldn't be valid on '-' */
108 if (in_escape)
109 {
110 re_append(&mask, &len, '\\');
111 re_append(&mask, &len, *str);
112 in_escape = FALSE;
113 }
114 else switch (*str)
115 {
116 case '\\': in_escape = TRUE; break;
117 case '*': re_append(&mask, &len, '.'); re_append(&mask, &len, '*'); break;
118 case '?': re_append(&mask, &len, '.'); break;
119 case '#': re_append(&mask, &len, '*'); break;
120 /* escape some valid characters in dbghelp reg exp:s */
121 case '$': re_append(&mask, &len, '\\'); re_append(&mask, &len, '$'); break;
122 /* +, [, ], - are the same in dbghelp & POSIX, use them as any other char */
123 default: re_append(&mask, &len, *str); break;
124 }
125 str++;
126 }
127 if (in_escape)
128 {
129 re_append(&mask, &len, '\\');
130 re_append(&mask, &len, '\\');
131 }
132 re_append(&mask, &len, '$');
133 mask[len - 1] = '\0';
134 if (regcomp(re, mask, REG_NOSUB)) FIXME("Couldn't compile %s\n", mask);
135 HeapFree(GetProcessHeap(), 0, mask);
136 }
137
138 struct symt_compiland* symt_new_compiland(struct module* module, const char* name)
139 {
140 struct symt_compiland* sym;
141
142 TRACE_(dbghelp_symt)("Adding compiland symbol %s:%s\n",
143 module->module.ModuleName, name);
144 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
145 {
146 sym->symt.tag = SymTagCompiland;
147 sym->source = source_new(module, name);
148 vector_init(&sym->vchildren, sizeof(struct symt*), 32);
149 }
150 return sym;
151 }
152
153 struct symt_public* symt_new_public(struct module* module,
154 struct symt_compiland* compiland,
155 const char* name,
156 unsigned long address, unsigned size,
157 BOOL in_code, BOOL is_func)
158 {
159 struct symt_public* sym;
160 struct symt** p;
161
162 TRACE_(dbghelp_symt)("Adding public symbol %s:%s @%lx\n",
163 module->module.ModuleName, name, address);
164 if ((dbghelp_options & SYMOPT_AUTO_PUBLICS) &&
165 symt_find_nearest(module, address) != -1)
166 return NULL;
167 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
168 {
169 sym->symt.tag = SymTagPublicSymbol;
170 sym->hash_elt.name = pool_strdup(&module->pool, name);
171 hash_table_add(&module->ht_symbols, &sym->hash_elt);
172 module->sortlist_valid = FALSE;
173 sym->container = compiland ? &compiland->symt : NULL;
174 sym->address = address;
175 sym->size = size;
176 sym->in_code = in_code;
177 sym->is_function = is_func;
178 if (compiland)
179 {
180 p = vector_add(&compiland->vchildren, &module->pool);
181 *p = &sym->symt;
182 }
183 }
184 return sym;
185 }
186
187 struct symt_data* symt_new_global_variable(struct module* module,
188 struct symt_compiland* compiland,
189 const char* name, unsigned is_static,
190 unsigned long addr, unsigned long size,
191 struct symt* type)
192 {
193 struct symt_data* sym;
194 struct symt** p;
195 DWORD tsz;
196
197 TRACE_(dbghelp_symt)("Adding global symbol %s:%s @%lx %p\n",
198 module->module.ModuleName, name, addr, type);
199 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
200 {
201 sym->symt.tag = SymTagData;
202 sym->hash_elt.name = pool_strdup(&module->pool, name);
203 hash_table_add(&module->ht_symbols, &sym->hash_elt);
204 module->sortlist_valid = FALSE;
205 sym->kind = is_static ? DataIsFileStatic : DataIsGlobal;
206 sym->container = compiland ? &compiland->symt : NULL;
207 sym->type = type;
208 sym->u.address = addr;
209 if (type && size && symt_get_info(type, TI_GET_LENGTH, &tsz))
210 {
211 if (tsz != size)
212 FIXME("Size mismatch for %s.%s between type (%lu) and src (%lu)\n",
213 module->module.ModuleName, name, tsz, size);
214 }
215 if (compiland)
216 {
217 p = vector_add(&compiland->vchildren, &module->pool);
218 *p = &sym->symt;
219 }
220 }
221 return sym;
222 }
223
224 struct symt_function* symt_new_function(struct module* module,
225 struct symt_compiland* compiland,
226 const char* name,
227 unsigned long addr, unsigned long size,
228 struct symt* sig_type)
229 {
230 struct symt_function* sym;
231 struct symt** p;
232
233 TRACE_(dbghelp_symt)("Adding global function %s:%s @%lx-%lx\n",
234 module->module.ModuleName, name, addr, addr + size - 1);
235
236 assert(!sig_type || sig_type->tag == SymTagFunctionType);
237 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
238 {
239 sym->symt.tag = SymTagFunction;
240 sym->hash_elt.name = pool_strdup(&module->pool, name);
241 hash_table_add(&module->ht_symbols, &sym->hash_elt);
242 module->sortlist_valid = FALSE;
243 sym->container = &compiland->symt;
244 sym->address = addr;
245 sym->type = sig_type;
246 sym->size = size;
247 vector_init(&sym->vlines, sizeof(struct line_info), 64);
248 vector_init(&sym->vchildren, sizeof(struct symt*), 8);
249 if (compiland)
250 {
251 p = vector_add(&compiland->vchildren, &module->pool);
252 *p = &sym->symt;
253 }
254 }
255 return sym;
256 }
257
258 void symt_add_func_line(struct module* module, struct symt_function* func,
259 unsigned source_idx, int line_num, unsigned long offset)
260 {
261 struct line_info* dli;
262 BOOL last_matches = FALSE;
263
264 if (func == NULL || !(dbghelp_options & SYMOPT_LOAD_LINES)) return;
265
266 TRACE_(dbghelp_symt)("(%p)%s:%lx %s:%u\n",
267 func, func->hash_elt.name, offset,
268 source_get(module, source_idx), line_num);
269
270 assert(func->symt.tag == SymTagFunction);
271
272 dli = NULL;
273 while ((dli = vector_iter_down(&func->vlines, dli)))
274 {
275 if (dli->is_source_file)
276 {
277 last_matches = (source_idx == dli->u.source_file);
278 break;
279 }
280 }
281
282 if (!last_matches)
283 {
284 /* we shouldn't have line changes on first line of function */
285 dli = vector_add(&func->vlines, &module->pool);
286 dli->is_source_file = 1;
287 dli->is_first = dli->is_last = 0;
288 dli->line_number = 0;
289 dli->u.source_file = source_idx;
290 }
291 dli = vector_add(&func->vlines, &module->pool);
292 dli->is_source_file = 0;
293 dli->is_first = dli->is_last = 0;
294 dli->line_number = line_num;
295 dli->u.pc_offset = func->address + offset;
296 }
297
298 struct symt_data* symt_add_func_local(struct module* module,
299 struct symt_function* func,
300 int regno, int offset,
301 struct symt_block* block,
302 struct symt* type, const char* name)
303 {
304 struct symt_data* locsym;
305 struct symt** p;
306
307 assert(func);
308 assert(func->symt.tag == SymTagFunction);
309
310 TRACE_(dbghelp_symt)("Adding local symbol (%s:%s): %s %p\n",
311 module->module.ModuleName, func->hash_elt.name,
312 name, type);
313 locsym = pool_alloc(&module->pool, sizeof(*locsym));
314 locsym->symt.tag = SymTagData;
315 locsym->hash_elt.name = pool_strdup(&module->pool, name);
316 locsym->hash_elt.next = NULL;
317 locsym->kind = (offset < 0) ? DataIsParam : DataIsLocal;
318 locsym->container = &block->symt;
319 locsym->type = type;
320 if (regno)
321 {
322 locsym->u.s.reg_id = regno;
323 locsym->u.s.offset = 0;
324 locsym->u.s.length = 0;
325 }
326 else
327 {
328 locsym->u.s.reg_id = 0;
329 locsym->u.s.offset = offset * 8;
330 locsym->u.s.length = 0;
331 }
332 if (block)
333 p = vector_add(&block->vchildren, &module->pool);
334 else
335 p = vector_add(&func->vchildren, &module->pool);
336 *p = &locsym->symt;
337 return locsym;
338 }
339
340 struct symt_block* symt_open_func_block(struct module* module,
341 struct symt_function* func,
342 struct symt_block* parent_block,
343 unsigned pc, unsigned len)
344 {
345 struct symt_block* block;
346 struct symt** p;
347
348 assert(func);
349 assert(func->symt.tag == SymTagFunction);
350
351 assert(!parent_block || parent_block->symt.tag == SymTagBlock);
352 block = pool_alloc(&module->pool, sizeof(*block));
353 block->symt.tag = SymTagBlock;
354 block->address = func->address + pc;
355 block->size = len;
356 block->container = parent_block ? &parent_block->symt : &func->symt;
357 vector_init(&block->vchildren, sizeof(struct symt*), 4);
358 if (parent_block)
359 p = vector_add(&parent_block->vchildren, &module->pool);
360 else
361 p = vector_add(&func->vchildren, &module->pool);
362 *p = &block->symt;
363
364 return block;
365 }
366
367 struct symt_block* symt_close_func_block(struct module* module,
368 struct symt_function* func,
369 struct symt_block* block, unsigned pc)
370 {
371 assert(func->symt.tag == SymTagFunction);
372
373 if (pc) block->size = func->address + pc - block->address;
374 return (block->container->tag == SymTagBlock) ?
375 GET_ENTRY(block->container, struct symt_block, symt) : NULL;
376 }
377
378 struct symt_function_point* symt_add_function_point(struct module* module,
379 struct symt_function* func,
380 enum SymTagEnum point,
381 unsigned offset, const char* name)
382 {
383 struct symt_function_point* sym;
384 struct symt** p;
385
386 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
387 {
388 sym->symt.tag = point;
389 sym->parent = func;
390 sym->offset = offset;
391 sym->name = name ? pool_strdup(&module->pool, name) : NULL;
392 p = vector_add(&func->vchildren, &module->pool);
393 *p = &sym->symt;
394 }
395 return sym;
396 }
397
398 BOOL symt_normalize_function(struct module* module, struct symt_function* func)
399 {
400 unsigned len;
401 struct line_info* dli;
402
403 assert(func);
404 /* We aren't adding any more locals or line numbers to this function.
405 * Free any spare memory that we might have allocated.
406 */
407 assert(func->symt.tag == SymTagFunction);
408
409 /* EPP vector_pool_normalize(&func->vlines, &module->pool); */
410 /* EPP vector_pool_normalize(&func->vchildren, &module->pool); */
411
412 len = vector_length(&func->vlines);
413 if (len--)
414 {
415 dli = vector_at(&func->vlines, 0); dli->is_first = 1;
416 dli = vector_at(&func->vlines, len); dli->is_last = 1;
417 }
418 return TRUE;
419 }
420
421 struct symt_thunk* symt_new_thunk(struct module* module,
422 struct symt_compiland* compiland,
423 const char* name, THUNK_ORDINAL ord,
424 unsigned long addr, unsigned long size)
425 {
426 struct symt_thunk* sym;
427
428 TRACE_(dbghelp_symt)("Adding global thunk %s:%s @%lx-%lx\n",
429 module->module.ModuleName, name, addr, addr + size - 1);
430
431 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
432 {
433 sym->symt.tag = SymTagThunk;
434 sym->hash_elt.name = pool_strdup(&module->pool, name);
435 hash_table_add(&module->ht_symbols, &sym->hash_elt);
436 module->sortlist_valid = FALSE;
437 sym->container = &compiland->symt;
438 sym->address = addr;
439 sym->size = size;
440 sym->ordinal = ord;
441 if (compiland)
442 {
443 struct symt** p;
444 p = vector_add(&compiland->vchildren, &module->pool);
445 *p = &sym->symt;
446 }
447 }
448 return sym;
449 }
450
451 /* expect sym_info->MaxNameLen to be set before being called */
452 static void symt_fill_sym_info(const struct module* module,
453 const struct symt* sym, SYMBOL_INFO* sym_info)
454 {
455 const char* name;
456
457 sym_info->TypeIndex = (DWORD)sym;
458 sym_info->info = 0; /* TBD */
459 symt_get_info(sym, TI_GET_LENGTH, &sym_info->Size);
460 sym_info->ModBase = module->module.BaseOfImage;
461 sym_info->Flags = 0;
462 switch (sym->tag)
463 {
464 case SymTagData:
465 {
466 const struct symt_data* data = (const struct symt_data*)sym;
467 switch (data->kind)
468 {
469 case DataIsLocal:
470 case DataIsParam:
471 if (data->u.s.reg_id)
472 {
473 sym_info->Flags |= SYMFLAG_LOCAL | SYMFLAG_REGISTER;
474 sym_info->Register = data->u.s.reg_id;
475 sym_info->Address = 0;
476 }
477 else
478 {
479 if (data->u.s.offset < 0)
480 sym_info->Flags |= SYMFLAG_LOCAL | SYMFLAG_FRAMEREL;
481 else
482 sym_info->Flags |= SYMFLAG_PARAMETER | SYMFLAG_FRAMEREL;
483 /* FIXME: needed ? moreover, it's i386 dependent !!! */
484 sym_info->Register = CV_REG_EBP;
485 sym_info->Address = data->u.s.offset;
486 }
487 break;
488 case DataIsGlobal:
489 case DataIsFileStatic:
490 symt_get_info(sym, TI_GET_ADDRESS, &sym_info->Address);
491 sym_info->Register = 0;
492 break;
493 case DataIsConstant:
494 sym_info->Flags |= SYMFLAG_VALUEPRESENT;
495 switch (data->u.value.n1.n2.vt)
496 {
497 case VT_I4: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.lVal; break;
498 case VT_I2: sym_info->Value = (ULONG)(long)data->u.value.n1.n2.n3.iVal; break;
499 case VT_I1: sym_info->Value = (ULONG)(long)data->u.value.n1.n2.n3.cVal; break;
500 case VT_UI4: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.ulVal; break;
501 case VT_UI2: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.uiVal; break;
502 case VT_UI1: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.bVal; break;
503 default:
504 FIXME("Unsupported variant type (%u)\n", data->u.value.n1.n2.vt);
505 }
506 break;
507 default:
508 FIXME("Unhandled kind (%u) in sym data\n", data->kind);
509 }
510 }
511 break;
512 case SymTagPublicSymbol:
513 sym_info->Flags |= SYMFLAG_EXPORT;
514 symt_get_info(sym, TI_GET_ADDRESS, &sym_info->Address);
515 break;
516 case SymTagFunction:
517 sym_info->Flags |= SYMFLAG_FUNCTION;
518 symt_get_info(sym, TI_GET_ADDRESS, &sym_info->Address);
519 break;
520 case SymTagThunk:
521 sym_info->Flags |= SYMFLAG_THUNK;
522 symt_get_info(sym, TI_GET_ADDRESS, &sym_info->Address);
523 break;
524 default:
525 symt_get_info(sym, TI_GET_ADDRESS, &sym_info->Address);
526 sym_info->Register = 0;
527 break;
528 }
529 sym_info->Scope = 0; /* FIXME */
530 sym_info->Tag = sym->tag;
531 name = symt_get_name(sym);
532 if (sym_info->MaxNameLen)
533 {
534 if (sym->tag != SymTagPublicSymbol || !(dbghelp_options & SYMOPT_UNDNAME) ||
535 (sym_info->NameLen = UnDecorateSymbolName(sym_info->Name, sym_info->Name,
536 sym_info->MaxNameLen, UNDNAME_COMPLETE) == 0))
537 {
538 sym_info->NameLen = min(strlen(name), sym_info->MaxNameLen - 1);
539 strncpy(sym_info->Name, name, sym_info->NameLen);
540 sym_info->Name[sym_info->NameLen] = '\0';
541 }
542 }
543 TRACE_(dbghelp_symt)("%p => %s %lu %s\n",
544 sym, sym_info->Name, sym_info->Size,
545 wine_dbgstr_longlong(sym_info->Address));
546 }
547
548 static BOOL symt_enum_module(struct module* module, regex_t* regex,
549 PSYM_ENUMERATESYMBOLS_CALLBACK cb, PVOID user)
550 {
551 char buffer[sizeof(SYMBOL_INFO) + 256];
552 SYMBOL_INFO* sym_info = (SYMBOL_INFO*)buffer;
553 void* ptr;
554 struct symt_ht* sym = NULL;
555 struct hash_table_iter hti;
556
557 hash_table_iter_init(&module->ht_symbols, &hti, NULL);
558 while ((ptr = hash_table_iter_up(&hti)))
559 {
560 sym = GET_ENTRY(ptr, struct symt_ht, hash_elt);
561 if (sym->hash_elt.name &&
562 regexec(regex, sym->hash_elt.name, 0, NULL, 0) == 0)
563 {
564 sym_info->SizeOfStruct = sizeof(SYMBOL_INFO);
565 sym_info->MaxNameLen = sizeof(buffer) - sizeof(SYMBOL_INFO);
566 symt_fill_sym_info(module, &sym->symt, sym_info);
567 if (!cb(sym_info, sym_info->Size, user)) return TRUE;
568 }
569 }
570 return FALSE;
571 }
572
573 /***********************************************************************
574 * resort_symbols
575 *
576 * Rebuild sorted list of symbols for a module.
577 */
578 static BOOL resort_symbols(struct module* module)
579 {
580 int nsym = 0;
581 void* ptr;
582 struct symt_ht* sym;
583 struct hash_table_iter hti;
584
585 hash_table_iter_init(&module->ht_symbols, &hti, NULL);
586 while ((ptr = hash_table_iter_up(&hti)))
587 nsym++;
588
589 if (!(module->module.NumSyms = nsym)) return FALSE;
590
591 if (module->addr_sorttab)
592 module->addr_sorttab = HeapReAlloc(GetProcessHeap(), 0,
593 module->addr_sorttab,
594 nsym * sizeof(struct symt_ht*));
595 else
596 module->addr_sorttab = HeapAlloc(GetProcessHeap(), 0,
597 nsym * sizeof(struct symt_ht*));
598 if (!module->addr_sorttab) return FALSE;
599
600 nsym = 0;
601 hash_table_iter_init(&module->ht_symbols, &hti, NULL);
602 while ((ptr = hash_table_iter_up(&hti)))
603 {
604 sym = GET_ENTRY(ptr, struct symt_ht, hash_elt);
605 assert(sym);
606 module->addr_sorttab[nsym++] = sym;
607 }
608
609 qsort(module->addr_sorttab, nsym, sizeof(struct symt_ht*), symt_cmp_addr);
610 return module->sortlist_valid = TRUE;
611 }
612
613 /* assume addr is in module */
614 int symt_find_nearest(struct module* module, DWORD addr)
615 {
616 int mid, high, low;
617 ULONG64 ref_addr;
618 DWORD ref_size;
619
620 if (!module->sortlist_valid || !module->addr_sorttab)
621 {
622 if (!resort_symbols(module)) return -1;
623 }
624
625 /*
626 * Binary search to find closest symbol.
627 */
628 low = 0;
629 high = module->module.NumSyms;
630
631 symt_get_info(&module->addr_sorttab[0]->symt, TI_GET_ADDRESS, &ref_addr);
632 if (addr < ref_addr) return -1;
633 if (high)
634 {
635 symt_get_info(&module->addr_sorttab[high - 1]->symt, TI_GET_ADDRESS, &ref_addr);
636 if (!symt_get_info(&module->addr_sorttab[high - 1]->symt, TI_GET_LENGTH, &ref_size) || !ref_size)
637 ref_size = 0x1000; /* arbitrary value */
638 if (addr >= ref_addr + ref_size) return -1;
639 }
640
641 while (high > low + 1)
642 {
643 mid = (high + low) / 2;
644 if (cmp_sorttab_addr(module, mid, addr) < 0)
645 low = mid;
646 else
647 high = mid;
648 }
649 if (low != high && high != module->module.NumSyms &&
650 cmp_sorttab_addr(module, high, addr) <= 0)
651 low = high;
652
653 /* If found symbol is a public symbol, check if there are any other entries that
654 * might also have the same address, but would get better information
655 */
656 if (module->addr_sorttab[low]->symt.tag == SymTagPublicSymbol)
657 {
658 symt_get_info(&module->addr_sorttab[low]->symt, TI_GET_ADDRESS, &ref_addr);
659 if (low > 0 &&
660 module->addr_sorttab[low - 1]->symt.tag != SymTagPublicSymbol &&
661 !cmp_sorttab_addr(module, low - 1, ref_addr))
662 low--;
663 else if (low < module->module.NumSyms - 1 &&
664 module->addr_sorttab[low + 1]->symt.tag != SymTagPublicSymbol &&
665 !cmp_sorttab_addr(module, low + 1, ref_addr))
666 low++;
667 }
668 /* finally check that we fit into the found symbol */
669 symt_get_info(&module->addr_sorttab[low]->symt, TI_GET_ADDRESS, &ref_addr);
670 if (addr < ref_addr) return -1;
671 if (!symt_get_info(&module->addr_sorttab[high - 1]->symt, TI_GET_LENGTH, &ref_size) || !ref_size)
672 ref_size = 0x1000; /* arbitrary value */
673 if (addr >= ref_addr + ref_size) return -1;
674
675 return low;
676 }
677
678 static BOOL symt_enum_locals_helper(struct process* pcs, struct module* module,
679 regex_t* preg, PSYM_ENUMERATESYMBOLS_CALLBACK cb,
680 PVOID user, SYMBOL_INFO* sym_info,
681 struct vector* v)
682 {
683 struct symt** plsym = NULL;
684 struct symt* lsym = NULL;
685 DWORD pc = pcs->ctx_frame.InstructionOffset;
686
687 while ((plsym = vector_iter_up(v, plsym)))
688 {
689 lsym = *plsym;
690 switch (lsym->tag)
691 {
692 case SymTagBlock:
693 {
694 struct symt_block* block = (struct symt_block*)lsym;
695 if (pc < block->address || block->address + block->size <= pc)
696 continue;
697 if (!symt_enum_locals_helper(pcs, module, preg, cb, user,
698 sym_info, &block->vchildren))
699 return FALSE;
700 }
701 break;
702 case SymTagData:
703 if (regexec(preg, symt_get_name(lsym), 0, NULL, 0) == 0)
704 {
705 symt_fill_sym_info(module, lsym, sym_info);
706 if (!cb(sym_info, sym_info->Size, user))
707 return FALSE;
708 }
709 break;
710 case SymTagLabel:
711 case SymTagFuncDebugStart:
712 case SymTagFuncDebugEnd:
713 break;
714 default:
715 FIXME("Unknown type: %u (%x)\n", lsym->tag, lsym->tag);
716 assert(0);
717 }
718 }
719 return TRUE;
720 }
721
722 static BOOL symt_enum_locals(struct process* pcs, const char* mask,
723 PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
724 PVOID UserContext)
725 {
726 struct module* module;
727 struct symt_ht* sym;
728 char buffer[sizeof(SYMBOL_INFO) + 256];
729 SYMBOL_INFO* sym_info = (SYMBOL_INFO*)buffer;
730 DWORD pc = pcs->ctx_frame.InstructionOffset;
731 int idx;
732
733 sym_info->SizeOfStruct = sizeof(*sym_info);
734 sym_info->MaxNameLen = sizeof(buffer) - sizeof(SYMBOL_INFO);
735
736 module = module_find_by_addr(pcs, pc, DMT_UNKNOWN);
737 if (!(module = module_get_debug(pcs, module))) return FALSE;
738 if ((idx = symt_find_nearest(module, pc)) == -1) return FALSE;
739
740 sym = module->addr_sorttab[idx];
741 if (sym->symt.tag == SymTagFunction)
742 {
743 BOOL ret;
744 regex_t preg;
745
746 compile_regex(mask ? mask : "*", -1, &preg);
747 ret = symt_enum_locals_helper(pcs, module, &preg, EnumSymbolsCallback,
748 UserContext, sym_info,
749 &((struct symt_function*)sym)->vchildren);
750 regfree(&preg);
751 return ret;
752
753 }
754 symt_fill_sym_info(module, &sym->symt, sym_info);
755 return EnumSymbolsCallback(sym_info, sym_info->Size, UserContext);
756 }
757
758 /******************************************************************
759 * SymEnumSymbols (DBGHELP.@)
760 *
761 * cases BaseOfDll = 0
762 * !foo fails always (despite what MSDN states)
763 * RE1!RE2 looks up all modules matching RE1, and in all these modules, lookup RE2
764 * no ! in Mask, lookup in local Context
765 * cases BaseOfDll != 0
766 * !foo fails always (despite what MSDN states)
767 * RE1!RE2 gets RE2 from BaseOfDll (whatever RE1 is)
768 */
769 BOOL WINAPI SymEnumSymbols(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR Mask,
770 PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
771 PVOID UserContext)
772 {
773 struct process* pcs = process_find_by_handle(hProcess);
774 struct module* module;
775 struct module* dbg_module;
776 const char* bang;
777 regex_t mod_regex, sym_regex;
778
779 TRACE("(%p %s %s %p %p)\n",
780 hProcess, wine_dbgstr_longlong(BaseOfDll), debugstr_a(Mask),
781 EnumSymbolsCallback, UserContext);
782
783 if (!pcs) return FALSE;
784
785 if (BaseOfDll == 0)
786 {
787 /* do local variables ? */
788 if (!Mask || !(bang = strchr(Mask, '!')))
789 return symt_enum_locals(pcs, Mask, EnumSymbolsCallback, UserContext);
790
791 if (bang == Mask) return FALSE;
792
793 compile_regex(Mask, bang - Mask, &mod_regex);
794 compile_regex(bang + 1, -1, &sym_regex);
795
796 for (module = pcs->lmodules; module; module = module->next)
797 {
798 if (module->type == DMT_PE && (dbg_module = module_get_debug(pcs, module)))
799 {
800 if (regexec(&mod_regex, module->module.ModuleName, 0, NULL, 0) == 0 &&
801 symt_enum_module(dbg_module, &sym_regex,
802 EnumSymbolsCallback, UserContext))
803 break;
804 }
805 }
806 /* not found in PE modules, retry on the ELF ones
807 */
808 if (!module && (dbghelp_options & SYMOPT_WINE_WITH_ELF_MODULES))
809 {
810 for (module = pcs->lmodules; module; module = module->next)
811 {
812 if (module->type == DMT_ELF &&
813 !module_get_containee(pcs, module) &&
814 (dbg_module = module_get_debug(pcs, module)))
815 {
816 if (regexec(&mod_regex, module->module.ModuleName, 0, NULL, 0) == 0 &&
817 symt_enum_module(dbg_module, &sym_regex, EnumSymbolsCallback, UserContext))
818 break;
819 }
820 }
821 }
822 regfree(&mod_regex);
823 regfree(&sym_regex);
824 return TRUE;
825 }
826 module = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN);
827 if (!(module = module_get_debug(pcs, module)))
828 return FALSE;
829
830 /* we always ignore module name from Mask when BaseOfDll is defined */
831 if (Mask && (bang = strchr(Mask, '!')))
832 {
833 if (bang == Mask) return FALSE;
834 Mask = bang + 1;
835 }
836
837 compile_regex(Mask ? Mask : "*", -1, &sym_regex);
838 symt_enum_module(module, &sym_regex, EnumSymbolsCallback, UserContext);
839 regfree(&sym_regex);
840
841 return TRUE;
842 }
843
844 struct sym_enumerate
845 {
846 void* ctx;
847 PSYM_ENUMSYMBOLS_CALLBACK cb;
848 };
849
850 static BOOL CALLBACK sym_enumerate_cb(PSYMBOL_INFO syminfo, ULONG size, void* ctx)
851 {
852 struct sym_enumerate* se = (struct sym_enumerate*)ctx;
853 return (se->cb)(syminfo->Name, syminfo->Address, syminfo->Size, se->ctx);
854 }
855
856 /***********************************************************************
857 * SymEnumerateSymbols (DBGHELP.@)
858 */
859 BOOL WINAPI SymEnumerateSymbols(HANDLE hProcess, DWORD BaseOfDll,
860 PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback,
861 PVOID UserContext)
862 {
863 struct sym_enumerate se;
864
865 se.ctx = UserContext;
866 se.cb = EnumSymbolsCallback;
867
868 return SymEnumSymbols(hProcess, BaseOfDll, NULL, sym_enumerate_cb, &se);
869 }
870
871 /******************************************************************
872 * SymFromAddr (DBGHELP.@)
873 *
874 */
875 BOOL WINAPI SymFromAddr(HANDLE hProcess, DWORD64 Address,
876 DWORD64* Displacement, PSYMBOL_INFO Symbol)
877 {
878 struct process* pcs = process_find_by_handle(hProcess);
879 struct module* module;
880 struct symt_ht* sym;
881 int idx;
882
883 if (!pcs) return FALSE;
884 module = module_find_by_addr(pcs, Address, DMT_UNKNOWN);
885 if (!(module = module_get_debug(pcs, module))) return FALSE;
886 if ((idx = symt_find_nearest(module, Address)) == -1) return FALSE;
887
888 sym = module->addr_sorttab[idx];
889
890 symt_fill_sym_info(module, &sym->symt, Symbol);
891 if (Displacement) *Displacement = Address - Symbol->Address;
892 return TRUE;
893 }
894
895 /******************************************************************
896 * SymGetSymFromAddr (DBGHELP.@)
897 *
898 */
899 BOOL WINAPI SymGetSymFromAddr(HANDLE hProcess, DWORD Address,
900 PDWORD Displacement, PIMAGEHLP_SYMBOL Symbol)
901 {
902 char buffer[sizeof(SYMBOL_INFO) + 256];
903 SYMBOL_INFO*si = (SYMBOL_INFO*)buffer;
904 size_t len;
905 DWORD64 Displacement64;
906
907 if (Symbol->SizeOfStruct < sizeof(*Symbol)) return FALSE;
908 si->SizeOfStruct = sizeof(*si);
909 si->MaxNameLen = 256;
910 if (!SymFromAddr(hProcess, Address, &Displacement64, si))
911 return FALSE;
912
913 if (Displacement)
914 *Displacement = Displacement64;
915 Symbol->Address = si->Address;
916 Symbol->Size = si->Size;
917 Symbol->Flags = si->Flags;
918 len = min(Symbol->MaxNameLength, si->MaxNameLen);
919 strncpy(Symbol->Name, si->Name, len);
920 Symbol->Name[len - 1] = '\0';
921 return TRUE;
922 }
923
924 /******************************************************************
925 * SymFromName (DBGHELP.@)
926 *
927 */
928 BOOL WINAPI SymFromName(HANDLE hProcess, LPSTR Name, PSYMBOL_INFO Symbol)
929 {
930 struct process* pcs = process_find_by_handle(hProcess);
931 struct module* module;
932 struct hash_table_iter hti;
933 void* ptr;
934 struct symt_ht* sym = NULL;
935 const char* name;
936
937 TRACE("(%p, %s, %p)\n", hProcess, Name, Symbol);
938 if (!pcs) return FALSE;
939 if (Symbol->SizeOfStruct < sizeof(*Symbol)) return FALSE;
940 name = strchr(Name, '!');
941 if (name)
942 {
943 char tmp[128];
944 assert(name - Name < sizeof(tmp));
945 memcpy(tmp, Name, name - Name);
946 tmp[name - Name] = '\0';
947 module = module_find_by_name(pcs, tmp, DMT_UNKNOWN);
948 if (!module) return FALSE;
949 Name = (char*)(name + 1);
950 }
951 else module = pcs->lmodules;
952
953 /* FIXME: Name could be made out of a regular expression */
954 for (; module; module = (name) ? NULL : module->next)
955 {
956 if (module->module.SymType == SymNone) continue;
957 if (module->module.SymType == SymDeferred)
958 {
959 struct module* xmodule = module_get_debug(pcs, module);
960 if (!xmodule || xmodule != module) continue;
961 }
962 hash_table_iter_init(&module->ht_symbols, &hti, Name);
963 while ((ptr = hash_table_iter_up(&hti)))
964 {
965 sym = GET_ENTRY(ptr, struct symt_ht, hash_elt);
966
967 if (!strcmp(sym->hash_elt.name, Name))
968 {
969 symt_fill_sym_info(module, &sym->symt, Symbol);
970 return TRUE;
971 }
972 }
973 }
974 return FALSE;
975 }
976
977 /***********************************************************************
978 * SymGetSymFromName (DBGHELP.@)
979 */
980 BOOL WINAPI SymGetSymFromName(HANDLE hProcess, LPSTR Name, PIMAGEHLP_SYMBOL Symbol)
981 {
982 char buffer[sizeof(SYMBOL_INFO) + 256];
983 SYMBOL_INFO*si = (SYMBOL_INFO*)buffer;
984 size_t len;
985
986 if (Symbol->SizeOfStruct < sizeof(*Symbol)) return FALSE;
987 si->SizeOfStruct = sizeof(*si);
988 si->MaxNameLen = 256;
989 if (!SymFromName(hProcess, Name, si)) return FALSE;
990
991 Symbol->Address = si->Address;
992 Symbol->Size = si->Size;
993 Symbol->Flags = si->Flags;
994 len = min(Symbol->MaxNameLength, si->MaxNameLen);
995 strncpy(Symbol->Name, si->Name, len);
996 Symbol->Name[len - 1] = '\0';
997 return TRUE;
998 }
999
1000 /******************************************************************
1001 * sym_fill_func_line_info
1002 *
1003 * fills information about a file
1004 */
1005 BOOL symt_fill_func_line_info(struct module* module, struct symt_function* func,
1006 DWORD addr, IMAGEHLP_LINE* line)
1007 {
1008 struct line_info* dli = NULL;
1009 BOOL found = FALSE;
1010
1011 assert(func->symt.tag == SymTagFunction);
1012
1013 while ((dli = vector_iter_down(&func->vlines, dli)))
1014 {
1015 if (!dli->is_source_file)
1016 {
1017 if (found || dli->u.pc_offset > addr) continue;
1018 line->LineNumber = dli->line_number;
1019 line->Address = dli->u.pc_offset;
1020 line->Key = dli;
1021 found = TRUE;
1022 continue;
1023 }
1024 if (found)
1025 {
1026 line->FileName = (char*)source_get(module, dli->u.source_file);
1027 return TRUE;
1028 }
1029 }
1030 return FALSE;
1031 }
1032
1033 /***********************************************************************
1034 * SymGetSymNext (DBGHELP.@)
1035 */
1036 BOOL WINAPI SymGetSymNext(HANDLE hProcess, PIMAGEHLP_SYMBOL Symbol)
1037 {
1038 /* algo:
1039 * get module from Symbol.Address
1040 * get index in module.addr_sorttab of Symbol.Address
1041 * increment index
1042 * if out of module bounds, move to next module in process address space
1043 */
1044 FIXME("(%p, %p): stub\n", hProcess, Symbol);
1045 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1046 return FALSE;
1047 }
1048
1049 /***********************************************************************
1050 * SymGetSymPrev (DBGHELP.@)
1051 */
1052
1053 BOOL WINAPI SymGetSymPrev(HANDLE hProcess, PIMAGEHLP_SYMBOL Symbol)
1054 {
1055 FIXME("(%p, %p): stub\n", hProcess, Symbol);
1056 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1057 return FALSE;
1058 }
1059
1060 /******************************************************************
1061 * SymGetLineFromAddr (DBGHELP.@)
1062 *
1063 */
1064 BOOL WINAPI SymGetLineFromAddr(HANDLE hProcess, DWORD dwAddr,
1065 PDWORD pdwDisplacement, PIMAGEHLP_LINE Line)
1066 {
1067 struct process* pcs = process_find_by_handle(hProcess);
1068 struct module* module;
1069 int idx;
1070
1071 TRACE("%p %08lx %p %p\n", hProcess, dwAddr, pdwDisplacement, Line);
1072
1073 if (Line->SizeOfStruct < sizeof(*Line)) return FALSE;
1074
1075 if (!pcs) return FALSE;
1076 module = module_find_by_addr(pcs, dwAddr, DMT_UNKNOWN);
1077 if (!(module = module_get_debug(pcs, module))) return FALSE;
1078 if ((idx = symt_find_nearest(module, dwAddr)) == -1) return FALSE;
1079
1080 if (module->addr_sorttab[idx]->symt.tag != SymTagFunction) return FALSE;
1081 if (!symt_fill_func_line_info(module,
1082 (struct symt_function*)module->addr_sorttab[idx],
1083 dwAddr, Line)) return FALSE;
1084 if (pdwDisplacement) *pdwDisplacement = dwAddr - Line->Address;
1085 return TRUE;
1086 }
1087
1088 /******************************************************************
1089 * SymGetLinePrev (DBGHELP.@)
1090 *
1091 */
1092 BOOL WINAPI SymGetLinePrev(HANDLE hProcess, PIMAGEHLP_LINE Line)
1093 {
1094 struct process* pcs = process_find_by_handle(hProcess);
1095 struct module* module;
1096 struct line_info* li;
1097 BOOL in_search = FALSE;
1098
1099 TRACE("(%p %p)\n", hProcess, Line);
1100
1101 if (Line->SizeOfStruct < sizeof(*Line)) return FALSE;
1102
1103 if (!pcs) return FALSE;
1104 module = module_find_by_addr(pcs, Line->Address, DMT_UNKNOWN);
1105 if (!(module = module_get_debug(pcs, module))) return FALSE;
1106
1107 if (Line->Key == 0) return FALSE;
1108 li = (struct line_info*)Line->Key;
1109 /* things are a bit complicated because when we encounter a DLIT_SOURCEFILE
1110 * element we have to go back until we find the prev one to get the real
1111 * source file name for the DLIT_OFFSET element just before
1112 * the first DLIT_SOURCEFILE
1113 */
1114 while (!li->is_first)
1115 {
1116 li--;
1117 if (!li->is_source_file)
1118 {
1119 Line->LineNumber = li->line_number;
1120 Line->Address = li->u.pc_offset;
1121 Line->Key = li;
1122 if (!in_search) return TRUE;
1123 }
1124 else
1125 {
1126 if (in_search)
1127 {
1128 Line->FileName = (char*)source_get(module, li->u.source_file);
1129 return TRUE;
1130 }
1131 in_search = TRUE;
1132 }
1133 }
1134 SetLastError(ERROR_NO_MORE_ITEMS); /* FIXME */
1135 return FALSE;
1136 }
1137
1138 BOOL symt_get_func_line_next(struct module* module, PIMAGEHLP_LINE line)
1139 {
1140 struct line_info* li;
1141
1142 if (line->Key == 0) return FALSE;
1143 li = (struct line_info*)line->Key;
1144 while (!li->is_last)
1145 {
1146 li++;
1147 if (!li->is_source_file)
1148 {
1149 line->LineNumber = li->line_number;
1150 line->Address = li->u.pc_offset;
1151 line->Key = li;
1152 return TRUE;
1153 }
1154 line->FileName = (char*)source_get(module, li->u.source_file);
1155 }
1156 return FALSE;
1157 }
1158
1159 /******************************************************************
1160 * SymGetLineNext (DBGHELP.@)
1161 *
1162 */
1163 BOOL WINAPI SymGetLineNext(HANDLE hProcess, PIMAGEHLP_LINE Line)
1164 {
1165 struct process* pcs = process_find_by_handle(hProcess);
1166 struct module* module;
1167
1168 TRACE("(%p %p)\n", hProcess, Line);
1169
1170 if (Line->SizeOfStruct < sizeof(*Line)) return FALSE;
1171 if (!pcs) return FALSE;
1172 module = module_find_by_addr(pcs, Line->Address, DMT_UNKNOWN);
1173 if (!(module = module_get_debug(pcs, module))) return FALSE;
1174
1175 if (symt_get_func_line_next(module, Line)) return TRUE;
1176 SetLastError(ERROR_NO_MORE_ITEMS); /* FIXME */
1177 return FALSE;
1178 }
1179
1180 /***********************************************************************
1181 * SymFunctionTableAccess (DBGHELP.@)
1182 */
1183 PVOID WINAPI SymFunctionTableAccess(HANDLE hProcess, DWORD AddrBase)
1184 {
1185 FIXME("(%p, 0x%08lx): stub\n", hProcess, AddrBase);
1186 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1187 return FALSE;
1188 }
1189
1190 /***********************************************************************
1191 * SymUnDName (DBGHELP.@)
1192 */
1193 BOOL WINAPI SymUnDName(PIMAGEHLP_SYMBOL sym, LPSTR UnDecName, DWORD UnDecNameLength)
1194 {
1195 TRACE("(%p %s %lu): stub\n", sym, UnDecName, UnDecNameLength);
1196 return UnDecorateSymbolName(sym->Name, UnDecName, UnDecNameLength,
1197 UNDNAME_COMPLETE) != 0;
1198 }
1199
1200 static void* und_alloc(size_t len) { return HeapAlloc(GetProcessHeap(), 0, len); }
1201 static void und_free (void* ptr) { HeapFree(GetProcessHeap(), 0, ptr); }
1202
1203 /***********************************************************************
1204 * UnDecorateSymbolName (DBGHELP.@)
1205 */
1206 DWORD WINAPI UnDecorateSymbolName(LPCSTR DecoratedName, LPSTR UnDecoratedName,
1207 DWORD UndecoratedLength, DWORD Flags)
1208 {
1209 /* undocumented from msvcrt */
1210 static char* (*p_undname)(char*, const char*, int, void* (*)(size_t), void (*)(void*), unsigned short);
1211 static WCHAR szMsvcrt[] = {'m','s','v','c','r','t','.','d','l','l',0};
1212
1213 TRACE("(%s, %p, %ld, 0x%08lx): stub\n",
1214 debugstr_a(DecoratedName), UnDecoratedName, UndecoratedLength, Flags);
1215
1216 if (!p_undname)
1217 {
1218 if (!hMsvcrt) hMsvcrt = LoadLibraryW(szMsvcrt);
1219 if (hMsvcrt) p_undname = (void*)GetProcAddress(hMsvcrt, "__unDName");
1220 if (!p_undname) return 0;
1221 }
1222
1223 if (!UnDecoratedName) return 0;
1224 if (!p_undname(UnDecoratedName, DecoratedName, UndecoratedLength,
1225 und_alloc, und_free, Flags))
1226 return 0;
1227 return strlen(UnDecoratedName);
1228 }
Maarten's multimedia branch