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