?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msvcrt: Remove non-needed function declarations from msvcrt.h.
[wine.git] / dlls / dbghelp / symbol.c
blob706d088aec0aa61e7b5671b1e5b27e3a9543fd4c
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #define NONAMELESSUNION
23
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <string.h>
27 #include <limits.h>
28 #include <sys/types.h>
29 #include <assert.h>
30
31 #include "wine/debug.h"
32 #include "dbghelp_private.h"
33 #include "winnls.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
36 WINE_DECLARE_DEBUG_CHANNEL(dbghelp_symt);
37
38 static const WCHAR starW[] = {'*','\0'};
39
40 static inline int cmp_addr(ULONG64 a1, ULONG64 a2)
41 {
42 if (a1 > a2) return 1;
43 if (a1 < a2) return -1;
44 return 0;
45 }
46
47 static inline int cmp_sorttab_addr(struct module* module, int idx, ULONG64 addr)
48 {
49 ULONG64 ref;
50 symt_get_address(&module->addr_sorttab[idx]->symt, &ref);
51 return cmp_addr(ref, addr);
52 }
53
54 int __cdecl symt_cmp_addr(const void* p1, const void* p2)
55 {
56 const struct symt* sym1 = *(const struct symt* const *)p1;
57 const struct symt* sym2 = *(const struct symt* const *)p2;
58 ULONG64 a1, a2;
59
60 symt_get_address(sym1, &a1);
61 symt_get_address(sym2, &a2);
62 return cmp_addr(a1, a2);
63 }
64
65 DWORD symt_ptr2index(struct module* module, const struct symt* sym)
66 {
67 #ifdef _WIN64
68 const struct symt** c;
69 int len = vector_length(&module->vsymt), i;
70
71 /* FIXME: this is inefficient */
72 for (i = 0; i < len; i++)
73 {
74 if (*(struct symt**)vector_at(&module->vsymt, i) == sym)
75 return i + 1;
76 }
77 /* not found */
78 c = vector_add(&module->vsymt, &module->pool);
79 if (c) *c = sym;
80 return len + 1;
81 #else
82 return (DWORD)sym;
83 #endif
84 }
85
86 struct symt* symt_index2ptr(struct module* module, DWORD id)
87 {
88 #ifdef _WIN64
89 if (!id-- || id >= vector_length(&module->vsymt)) return NULL;
90 return *(struct symt**)vector_at(&module->vsymt, id);
91 #else
92 return (struct symt*)id;
93 #endif
94 }
95
96 static BOOL symt_grow_sorttab(struct module* module, unsigned sz)
97 {
98 struct symt_ht** new;
99 unsigned int size;
100
101 if (sz <= module->sorttab_size) return TRUE;
102 if (module->addr_sorttab)
103 {
104 size = module->sorttab_size * 2;
105 new = HeapReAlloc(GetProcessHeap(), 0, module->addr_sorttab,
106 size * sizeof(struct symt_ht*));
107 }
108 else
109 {
110 size = 64;
111 new = HeapAlloc(GetProcessHeap(), 0, size * sizeof(struct symt_ht*));
112 }
113 if (!new) return FALSE;
114 module->sorttab_size = size;
115 module->addr_sorttab = new;
116 return TRUE;
117 }
118
119 static void symt_add_module_ht(struct module* module, struct symt_ht* ht)
120 {
121 ULONG64 addr;
122
123 hash_table_add(&module->ht_symbols, &ht->hash_elt);
124 /* Don't store in sorttab a symbol without address, they are of
125 * no use here (e.g. constant values)
126 */
127 if (symt_get_address(&ht->symt, &addr) &&
128 symt_grow_sorttab(module, module->num_symbols + 1))
129 {
130 module->addr_sorttab[module->num_symbols++] = ht;
131 module->sortlist_valid = FALSE;
132 }
133 }
134
135 static WCHAR* file_regex(const char* srcfile)
136 {
137 WCHAR* mask;
138 WCHAR* p;
139
140 if (!srcfile || !*srcfile)
141 {
142 if (!(p = mask = HeapAlloc(GetProcessHeap(), 0, 3 * sizeof(WCHAR)))) return NULL;
143 *p++ = '?';
144 *p++ = '#';
145 }
146 else
147 {
148 DWORD sz = MultiByteToWideChar(CP_ACP, 0, srcfile, -1, NULL, 0);
149 WCHAR* srcfileW;
150
151 /* FIXME: we use here the largest conversion for every char... could be optimized */
152 p = mask = HeapAlloc(GetProcessHeap(), 0, (5 * strlen(srcfile) + 1 + sz) * sizeof(WCHAR));
153 if (!mask) return NULL;
154 srcfileW = mask + 5 * strlen(srcfile) + 1;
155 MultiByteToWideChar(CP_ACP, 0, srcfile, -1, srcfileW, sz);
156
157 while (*srcfileW)
158 {
159 switch (*srcfileW)
160 {
161 case '\\':
162 case '/':
163 *p++ = '[';
164 *p++ = '\\';
165 *p++ = '\\';
166 *p++ = '/';
167 *p++ = ']';
168 break;
169 case '.':
170 *p++ = '?';
171 break;
172 default:
173 *p++ = *srcfileW;
174 break;
175 }
176 srcfileW++;
177 }
178 }
179 *p = 0;
180 return mask;
181 }
182
183 struct symt_compiland* symt_new_compiland(struct module* module,
184 ULONG_PTR address, unsigned src_idx)
185 {
186 struct symt_compiland* sym;
187
188 TRACE_(dbghelp_symt)("Adding compiland symbol %s:%s\n",
189 debugstr_w(module->module.ModuleName), source_get(module, src_idx));
190 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
191 {
192 sym->symt.tag = SymTagCompiland;
193 sym->address = address;
194 sym->source = src_idx;
195 vector_init(&sym->vchildren, sizeof(struct symt*), 32);
196 }
197 return sym;
198 }
199
200 struct symt_public* symt_new_public(struct module* module,
201 struct symt_compiland* compiland,
202 const char* name,
203 BOOL is_function,
204 ULONG_PTR address, unsigned size)
205 {
206 struct symt_public* sym;
207 struct symt** p;
208
209 TRACE_(dbghelp_symt)("Adding public symbol %s:%s @%lx\n",
210 debugstr_w(module->module.ModuleName), name, address);
211 if ((dbghelp_options & SYMOPT_AUTO_PUBLICS) &&
212 symt_find_nearest(module, address) != NULL)
213 return NULL;
214 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
215 {
216 sym->symt.tag = SymTagPublicSymbol;
217 sym->hash_elt.name = pool_strdup(&module->pool, name);
218 sym->container = compiland ? &compiland->symt : NULL;
219 sym->is_function = is_function;
220 sym->address = address;
221 sym->size = size;
222 symt_add_module_ht(module, (struct symt_ht*)sym);
223 if (compiland)
224 {
225 p = vector_add(&compiland->vchildren, &module->pool);
226 *p = &sym->symt;
227 }
228 }
229 return sym;
230 }
231
232 struct symt_data* symt_new_global_variable(struct module* module,
233 struct symt_compiland* compiland,
234 const char* name, unsigned is_static,
235 struct location loc, ULONG_PTR size,
236 struct symt* type)
237 {
238 struct symt_data* sym;
239 struct symt** p;
240 DWORD64 tsz;
241
242 TRACE_(dbghelp_symt)("Adding global symbol %s:%s %d@%lx %p\n",
243 debugstr_w(module->module.ModuleName), name, loc.kind, loc.offset, type);
244 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
245 {
246 sym->symt.tag = SymTagData;
247 sym->hash_elt.name = pool_strdup(&module->pool, name);
248 sym->kind = is_static ? DataIsFileStatic : DataIsGlobal;
249 sym->container = compiland ? &compiland->symt : NULL;
250 sym->type = type;
251 sym->u.var = loc;
252 if (type && size && symt_get_info(module, type, TI_GET_LENGTH, &tsz))
253 {
254 if (tsz != size)
255 FIXME("Size mismatch for %s.%s between type (%s) and src (%lu)\n",
256 debugstr_w(module->module.ModuleName), name,
257 wine_dbgstr_longlong(tsz), size);
258 }
259 symt_add_module_ht(module, (struct symt_ht*)sym);
260 if (compiland)
261 {
262 p = vector_add(&compiland->vchildren, &module->pool);
263 *p = &sym->symt;
264 }
265 }
266 return sym;
267 }
268
269 struct symt_function* symt_new_function(struct module* module,
270 struct symt_compiland* compiland,
271 const char* name,
272 ULONG_PTR addr, ULONG_PTR size,
273 struct symt* sig_type)
274 {
275 struct symt_function* sym;
276 struct symt** p;
277
278 TRACE_(dbghelp_symt)("Adding global function %s:%s @%lx-%lx\n",
279 debugstr_w(module->module.ModuleName), name, addr, addr + size - 1);
280
281 assert(!sig_type || sig_type->tag == SymTagFunctionType);
282 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
283 {
284 sym->symt.tag = SymTagFunction;
285 sym->hash_elt.name = pool_strdup(&module->pool, name);
286 sym->container = &compiland->symt;
287 sym->address = addr;
288 sym->type = sig_type;
289 sym->size = size;
290 vector_init(&sym->vlines, sizeof(struct line_info), 64);
291 vector_init(&sym->vchildren, sizeof(struct symt*), 8);
292 symt_add_module_ht(module, (struct symt_ht*)sym);
293 if (compiland)
294 {
295 p = vector_add(&compiland->vchildren, &module->pool);
296 *p = &sym->symt;
297 }
298 }
299 return sym;
300 }
301
302 void symt_add_func_line(struct module* module, struct symt_function* func,
303 unsigned source_idx, int line_num, ULONG_PTR offset)
304 {
305 struct line_info* dli;
306 BOOL last_matches = FALSE;
307 int i;
308
309 if (func == NULL || !(dbghelp_options & SYMOPT_LOAD_LINES)) return;
310
311 TRACE_(dbghelp_symt)("(%p)%s:%lx %s:%u\n",
312 func, func->hash_elt.name, offset,
313 source_get(module, source_idx), line_num);
314
315 assert(func->symt.tag == SymTagFunction);
316
317 for (i=vector_length(&func->vlines)-1; i>=0; i--)
318 {
319 dli = vector_at(&func->vlines, i);
320 if (dli->is_source_file)
321 {
322 last_matches = (source_idx == dli->u.source_file);
323 break;
324 }
325 }
326
327 if (!last_matches)
328 {
329 /* we shouldn't have line changes on first line of function */
330 dli = vector_add(&func->vlines, &module->pool);
331 dli->is_source_file = 1;
332 dli->is_first = dli->is_last = 0;
333 dli->line_number = 0;
334 dli->u.source_file = source_idx;
335 }
336 dli = vector_add(&func->vlines, &module->pool);
337 dli->is_source_file = 0;
338 dli->is_first = dli->is_last = 0;
339 dli->line_number = line_num;
340 dli->u.pc_offset = func->address + offset;
341 }
342
343 /******************************************************************
344 * symt_add_func_local
345 *
346 * Adds a new local/parameter to a given function:
347 * In any cases, dt tells whether it's a local variable or a parameter
348 * If regno it's not 0:
349 * - then variable is stored in a register
350 * - otherwise, value is referenced by register + offset
351 * Otherwise, the variable is stored on the stack:
352 * - offset is then the offset from the frame register
353 */
354 struct symt_data* symt_add_func_local(struct module* module,
355 struct symt_function* func,
356 enum DataKind dt,
357 const struct location* loc,
358 struct symt_block* block,
359 struct symt* type, const char* name)
360 {
361 struct symt_data* locsym;
362 struct symt** p;
363
364 TRACE_(dbghelp_symt)("Adding local symbol (%s:%s): %s %p\n",
365 debugstr_w(module->module.ModuleName), func->hash_elt.name,
366 name, type);
367
368 assert(func);
369 assert(func->symt.tag == SymTagFunction);
370 assert(dt == DataIsParam || dt == DataIsLocal);
371
372 locsym = pool_alloc(&module->pool, sizeof(*locsym));
373 locsym->symt.tag = SymTagData;
374 locsym->hash_elt.name = pool_strdup(&module->pool, name);
375 locsym->hash_elt.next = NULL;
376 locsym->kind = dt;
377 locsym->container = block ? &block->symt : &func->symt;
378 locsym->type = type;
379 locsym->u.var = *loc;
380 if (block)
381 p = vector_add(&block->vchildren, &module->pool);
382 else
383 p = vector_add(&func->vchildren, &module->pool);
384 *p = &locsym->symt;
385 return locsym;
386 }
387
388
389 struct symt_block* symt_open_func_block(struct module* module,
390 struct symt_function* func,
391 struct symt_block* parent_block,
392 unsigned pc, unsigned len)
393 {
394 struct symt_block* block;
395 struct symt** p;
396
397 assert(func);
398 assert(func->symt.tag == SymTagFunction);
399
400 assert(!parent_block || parent_block->symt.tag == SymTagBlock);
401 block = pool_alloc(&module->pool, sizeof(*block));
402 block->symt.tag = SymTagBlock;
403 block->address = func->address + pc;
404 block->size = len;
405 block->container = parent_block ? &parent_block->symt : &func->symt;
406 vector_init(&block->vchildren, sizeof(struct symt*), 4);
407 if (parent_block)
408 p = vector_add(&parent_block->vchildren, &module->pool);
409 else
410 p = vector_add(&func->vchildren, &module->pool);
411 *p = &block->symt;
412
413 return block;
414 }
415
416 struct symt_block* symt_close_func_block(struct module* module,
417 const struct symt_function* func,
418 struct symt_block* block, unsigned pc)
419 {
420 assert(func);
421 assert(func->symt.tag == SymTagFunction);
422
423 if (pc) block->size = func->address + pc - block->address;
424 return (block->container->tag == SymTagBlock) ?
425 CONTAINING_RECORD(block->container, struct symt_block, symt) : NULL;
426 }
427
428 struct symt_hierarchy_point* symt_add_function_point(struct module* module,
429 struct symt_function* func,
430 enum SymTagEnum point,
431 const struct location* loc,
432 const char* name)
433 {
434 struct symt_hierarchy_point*sym;
435 struct symt** p;
436
437 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
438 {
439 sym->symt.tag = point;
440 sym->parent = &func->symt;
441 sym->loc = *loc;
442 sym->hash_elt.name = name ? pool_strdup(&module->pool, name) : NULL;
443 p = vector_add(&func->vchildren, &module->pool);
444 *p = &sym->symt;
445 }
446 return sym;
447 }
448
449 BOOL symt_normalize_function(struct module* module, const struct symt_function* func)
450 {
451 unsigned len;
452 struct line_info* dli;
453
454 assert(func);
455 /* We aren't adding any more locals or line numbers to this function.
456 * Free any spare memory that we might have allocated.
457 */
458 assert(func->symt.tag == SymTagFunction);
459
460 /* EPP vector_pool_normalize(&func->vlines, &module->pool); */
461 /* EPP vector_pool_normalize(&func->vchildren, &module->pool); */
462
463 len = vector_length(&func->vlines);
464 if (len--)
465 {
466 dli = vector_at(&func->vlines, 0); dli->is_first = 1;
467 dli = vector_at(&func->vlines, len); dli->is_last = 1;
468 }
469 return TRUE;
470 }
471
472 struct symt_thunk* symt_new_thunk(struct module* module,
473 struct symt_compiland* compiland,
474 const char* name, THUNK_ORDINAL ord,
475 ULONG_PTR addr, ULONG_PTR size)
476 {
477 struct symt_thunk* sym;
478
479 TRACE_(dbghelp_symt)("Adding global thunk %s:%s @%lx-%lx\n",
480 debugstr_w(module->module.ModuleName), name, addr, addr + size - 1);
481
482 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
483 {
484 sym->symt.tag = SymTagThunk;
485 sym->hash_elt.name = pool_strdup(&module->pool, name);
486 sym->container = &compiland->symt;
487 sym->address = addr;
488 sym->size = size;
489 sym->ordinal = ord;
490 symt_add_module_ht(module, (struct symt_ht*)sym);
491 if (compiland)
492 {
493 struct symt** p;
494 p = vector_add(&compiland->vchildren, &module->pool);
495 *p = &sym->symt;
496 }
497 }
498 return sym;
499 }
500
501 struct symt_data* symt_new_constant(struct module* module,
502 struct symt_compiland* compiland,
503 const char* name, struct symt* type,
504 const VARIANT* v)
505 {
506 struct symt_data* sym;
507
508 TRACE_(dbghelp_symt)("Adding constant value %s:%s\n",
509 debugstr_w(module->module.ModuleName), name);
510
511 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
512 {
513 sym->symt.tag = SymTagData;
514 sym->hash_elt.name = pool_strdup(&module->pool, name);
515 sym->kind = DataIsConstant;
516 sym->container = compiland ? &compiland->symt : NULL;
517 sym->type = type;
518 sym->u.value = *v;
519 symt_add_module_ht(module, (struct symt_ht*)sym);
520 if (compiland)
521 {
522 struct symt** p;
523 p = vector_add(&compiland->vchildren, &module->pool);
524 *p = &sym->symt;
525 }
526 }
527 return sym;
528 }
529
530 struct symt_hierarchy_point* symt_new_label(struct module* module,
531 struct symt_compiland* compiland,
532 const char* name, ULONG_PTR address)
533 {
534 struct symt_hierarchy_point* sym;
535
536 TRACE_(dbghelp_symt)("Adding global label value %s:%s\n",
537 debugstr_w(module->module.ModuleName), name);
538
539 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
540 {
541 sym->symt.tag = SymTagLabel;
542 sym->hash_elt.name = pool_strdup(&module->pool, name);
543 sym->loc.kind = loc_absolute;
544 sym->loc.offset = address;
545 sym->parent = compiland ? &compiland->symt : NULL;
546 symt_add_module_ht(module, (struct symt_ht*)sym);
547 if (compiland)
548 {
549 struct symt** p;
550 p = vector_add(&compiland->vchildren, &module->pool);
551 *p = &sym->symt;
552 }
553 }
554 return sym;
555 }
556
557 /* expect sym_info->MaxNameLen to be set before being called */
558 static void symt_fill_sym_info(struct module_pair* pair,
559 const struct symt_function* func,
560 const struct symt* sym, SYMBOL_INFO* sym_info)
561 {
562 const char* name;
563 DWORD64 size;
564
565 if (!symt_get_info(pair->effective, sym, TI_GET_TYPE, &sym_info->TypeIndex))
566 sym_info->TypeIndex = 0;
567 sym_info->Index = symt_ptr2index(pair->effective, sym);
568 sym_info->Reserved[0] = sym_info->Reserved[1] = 0;
569 if (!symt_get_info(pair->effective, sym, TI_GET_LENGTH, &size) &&
570 (!sym_info->TypeIndex ||
571 !symt_get_info(pair->effective, symt_index2ptr(pair->effective, sym_info->TypeIndex),
572 TI_GET_LENGTH, &size)))
573 size = 0;
574 sym_info->Size = (DWORD)size;
575 sym_info->ModBase = pair->requested->module.BaseOfImage;
576 sym_info->Flags = 0;
577 sym_info->Value = 0;
578
579 switch (sym->tag)
580 {
581 case SymTagData:
582 {
583 const struct symt_data* data = (const struct symt_data*)sym;
584 switch (data->kind)
585 {
586 case DataIsParam:
587 sym_info->Flags |= SYMFLAG_PARAMETER;
588 /* fall through */
589 case DataIsLocal:
590 sym_info->Flags |= SYMFLAG_LOCAL;
591 {
592 struct location loc = data->u.var;
593
594 if (loc.kind >= loc_user)
595 {
596 unsigned i;
597 struct module_format* modfmt;
598
599 for (i = 0; i < DFI_LAST; i++)
600 {
601 modfmt = pair->effective->format_info[i];
602 if (modfmt && modfmt->loc_compute)
603 {
604 modfmt->loc_compute(pair->pcs, modfmt, func, &loc);
605 break;
606 }
607 }
608 }
609 switch (loc.kind)
610 {
611 case loc_error:
612 /* for now we report error cases as a negative register number */
613 /* fall through */
614 case loc_register:
615 sym_info->Flags |= SYMFLAG_REGISTER;
616 sym_info->Register = loc.reg;
617 sym_info->Address = 0;
618 break;
619 case loc_regrel:
620 sym_info->Flags |= SYMFLAG_REGREL;
621 sym_info->Register = loc.reg;
622 if (loc.reg == CV_REG_NONE || (int)loc.reg < 0 /* error */)
623 FIXME("suspicious register value %x\n", loc.reg);
624 sym_info->Address = loc.offset;
625 break;
626 case loc_absolute:
627 sym_info->Flags |= SYMFLAG_VALUEPRESENT;
628 sym_info->Value = loc.offset;
629 break;
630 default:
631 FIXME("Shouldn't happen (kind=%d), debug reader backend is broken\n", loc.kind);
632 assert(0);
633 }
634 }
635 break;
636 case DataIsGlobal:
637 case DataIsFileStatic:
638 switch (data->u.var.kind)
639 {
640 case loc_tlsrel:
641 sym_info->Flags |= SYMFLAG_TLSREL;
642 /* fall through */
643 case loc_absolute:
644 symt_get_address(sym, &sym_info->Address);
645 sym_info->Register = 0;
646 break;
647 default:
648 FIXME("Shouldn't happen (kind=%d), debug reader backend is broken\n", data->u.var.kind);
649 assert(0);
650 }
651 break;
652 case DataIsConstant:
653 sym_info->Flags |= SYMFLAG_VALUEPRESENT;
654 switch (data->u.value.n1.n2.vt)
655 {
656 case VT_I4: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.lVal; break;
657 case VT_I2: sym_info->Value = (ULONG)(LONG_PTR)data->u.value.n1.n2.n3.iVal; break;
658 case VT_I1: sym_info->Value = (ULONG)(LONG_PTR)data->u.value.n1.n2.n3.cVal; break;
659 case VT_UI4: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.ulVal; break;
660 case VT_UI2: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.uiVal; break;
661 case VT_UI1: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.bVal; break;
662 case VT_I1 | VT_BYREF: sym_info->Value = (ULONG64)(DWORD_PTR)data->u.value.n1.n2.n3.byref; break;
663 case VT_EMPTY: sym_info->Value = 0; break;
664 default:
665 FIXME("Unsupported variant type (%u)\n", data->u.value.n1.n2.vt);
666 sym_info->Value = 0;
667 break;
668 }
669 break;
670 default:
671 FIXME("Unhandled kind (%u) in sym data\n", data->kind);
672 }
673 }
674 break;
675 case SymTagPublicSymbol:
676 {
677 const struct symt_public* pub = (const struct symt_public*)sym;
678 if (pub->is_function)
679 sym_info->Flags |= SYMFLAG_PUBLIC_CODE;
680 else
681 sym_info->Flags |= SYMFLAG_EXPORT;
682 symt_get_address(sym, &sym_info->Address);
683 }
684 break;
685 case SymTagFunction:
686 symt_get_address(sym, &sym_info->Address);
687 break;
688 case SymTagThunk:
689 sym_info->Flags |= SYMFLAG_THUNK;
690 symt_get_address(sym, &sym_info->Address);
691 break;
692 default:
693 symt_get_address(sym, &sym_info->Address);
694 sym_info->Register = 0;
695 break;
696 }
697 sym_info->Scope = 0; /* FIXME */
698 sym_info->Tag = sym->tag;
699 name = symt_get_name(sym);
700 if (sym_info->MaxNameLen)
701 {
702 if (sym->tag != SymTagPublicSymbol || !(dbghelp_options & SYMOPT_UNDNAME) ||
703 ((sym_info->NameLen = UnDecorateSymbolName(name, sym_info->Name,
704 sym_info->MaxNameLen, UNDNAME_NAME_ONLY)) == 0))
705 {
706 sym_info->NameLen = min(strlen(name), sym_info->MaxNameLen - 1);
707 memcpy(sym_info->Name, name, sym_info->NameLen);
708 sym_info->Name[sym_info->NameLen] = '\0';
709 }
710 }
711 TRACE_(dbghelp_symt)("%p => %s %u %s\n",
712 sym, sym_info->Name, sym_info->Size,
713 wine_dbgstr_longlong(sym_info->Address));
714 }
715
716 struct sym_enum
717 {
718 PSYM_ENUMERATESYMBOLS_CALLBACK cb;
719 PVOID user;
720 SYMBOL_INFO* sym_info;
721 DWORD index;
722 DWORD tag;
723 DWORD64 addr;
724 char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
725 };
726
727 static BOOL send_symbol(const struct sym_enum* se, struct module_pair* pair,
728 const struct symt_function* func, const struct symt* sym)
729 {
730 symt_fill_sym_info(pair, func, sym, se->sym_info);
731 if (se->index && se->sym_info->Index != se->index) return FALSE;
732 if (se->tag && se->sym_info->Tag != se->tag) return FALSE;
733 if (se->addr && !(se->addr >= se->sym_info->Address && se->addr < se->sym_info->Address + se->sym_info->Size)) return FALSE;
734 return !se->cb(se->sym_info, se->sym_info->Size, se->user);
735 }
736
737 static BOOL symt_enum_module(struct module_pair* pair, const WCHAR* match,
738 const struct sym_enum* se)
739 {
740 void* ptr;
741 struct symt_ht* sym = NULL;
742 struct hash_table_iter hti;
743 WCHAR* nameW;
744 BOOL ret;
745
746 hash_table_iter_init(&pair->effective->ht_symbols, &hti, NULL);
747 while ((ptr = hash_table_iter_up(&hti)))
748 {
749 sym = CONTAINING_RECORD(ptr, struct symt_ht, hash_elt);
750 nameW = symt_get_nameW(&sym->symt);
751 ret = SymMatchStringW(nameW, match, FALSE);
752 HeapFree(GetProcessHeap(), 0, nameW);
753 if (ret)
754 {
755 se->sym_info->SizeOfStruct = sizeof(SYMBOL_INFO);
756 se->sym_info->MaxNameLen = sizeof(se->buffer) - sizeof(SYMBOL_INFO);
757 if (send_symbol(se, pair, NULL, &sym->symt)) return TRUE;
758 }
759 }
760 return FALSE;
761 }
762
763 static inline unsigned where_to_insert(struct module* module, unsigned high, const struct symt_ht* elt)
764 {
765 unsigned low = 0, mid = high / 2;
766 ULONG64 addr;
767
768 if (!high) return 0;
769 symt_get_address(&elt->symt, &addr);
770 do
771 {
772 switch (cmp_sorttab_addr(module, mid, addr))
773 {
774 case 0: return mid;
775 case -1: low = mid + 1; break;
776 case 1: high = mid; break;
777 }
778 mid = low + (high - low) / 2;
779 } while (low < high);
780 return mid;
781 }
782
783 /***********************************************************************
784 * resort_symbols
785 *
786 * Rebuild sorted list of symbols for a module.
787 */
788 static BOOL resort_symbols(struct module* module)
789 {
790 int delta;
791
792 if (!(module->module.NumSyms = module->num_symbols))
793 return FALSE;
794
795 /* we know that set from 0 up to num_sorttab is already sorted
796 * so sort the remaining (new) symbols, and merge the two sets
797 * (unless the first set is empty)
798 */
799 delta = module->num_symbols - module->num_sorttab;
800 qsort(&module->addr_sorttab[module->num_sorttab], delta, sizeof(struct symt_ht*), symt_cmp_addr);
801 if (module->num_sorttab)
802 {
803 int i, ins_idx = module->num_sorttab, prev_ins_idx;
804 static struct symt_ht** tmp;
805 static unsigned num_tmp;
806
807 if (num_tmp < delta)
808 {
809 static struct symt_ht** new;
810 if (tmp)
811 new = HeapReAlloc(GetProcessHeap(), 0, tmp, delta * sizeof(struct symt_ht*));
812 else
813 new = HeapAlloc(GetProcessHeap(), 0, delta * sizeof(struct symt_ht*));
814 if (!new)
815 {
816 module->num_sorttab = 0;
817 return resort_symbols(module);
818 }
819 tmp = new;
820 num_tmp = delta;
821 }
822 memcpy(tmp, &module->addr_sorttab[module->num_sorttab], delta * sizeof(struct symt_ht*));
823 qsort(tmp, delta, sizeof(struct symt_ht*), symt_cmp_addr);
824
825 for (i = delta - 1; i >= 0; i--)
826 {
827 prev_ins_idx = ins_idx;
828 ins_idx = where_to_insert(module, ins_idx, tmp[i]);
829 memmove(&module->addr_sorttab[ins_idx + i + 1],
830 &module->addr_sorttab[ins_idx],
831 (prev_ins_idx - ins_idx) * sizeof(struct symt_ht*));
832 module->addr_sorttab[ins_idx + i] = tmp[i];
833 }
834 }
835 module->num_sorttab = module->num_symbols;
836 return module->sortlist_valid = TRUE;
837 }
838
839 static void symt_get_length(struct module* module, const struct symt* symt, ULONG64* size)
840 {
841 DWORD type_index;
842
843 if (symt_get_info(module, symt, TI_GET_LENGTH, size) && *size)
844 return;
845
846 if (symt_get_info(module, symt, TI_GET_TYPE, &type_index) &&
847 symt_get_info(module, symt_index2ptr(module, type_index), TI_GET_LENGTH, size)) return;
848 *size = 0x1000; /* arbitrary value */
849 }
850
851 /* needed by symt_find_nearest */
852 static int symt_get_best_at(struct module* module, int idx_sorttab)
853 {
854 ULONG64 ref_addr;
855 int idx_sorttab_orig = idx_sorttab;
856 if (module->addr_sorttab[idx_sorttab]->symt.tag == SymTagPublicSymbol)
857 {
858 symt_get_address(&module->addr_sorttab[idx_sorttab]->symt, &ref_addr);
859 while (idx_sorttab > 0 &&
860 module->addr_sorttab[idx_sorttab]->symt.tag == SymTagPublicSymbol &&
861 !cmp_sorttab_addr(module, idx_sorttab - 1, ref_addr))
862 idx_sorttab--;
863 if (module->addr_sorttab[idx_sorttab]->symt.tag == SymTagPublicSymbol)
864 {
865 idx_sorttab = idx_sorttab_orig;
866 while (idx_sorttab < module->num_sorttab - 1 &&
867 module->addr_sorttab[idx_sorttab]->symt.tag == SymTagPublicSymbol &&
868 !cmp_sorttab_addr(module, idx_sorttab + 1, ref_addr))
869 idx_sorttab++;
870 }
871 /* if no better symbol was found restore the original */
872 if (module->addr_sorttab[idx_sorttab]->symt.tag == SymTagPublicSymbol)
873 idx_sorttab = idx_sorttab_orig;
874 }
875 return idx_sorttab;
876 }
877
878 /* assume addr is in module */
879 struct symt_ht* symt_find_nearest(struct module* module, DWORD_PTR addr)
880 {
881 int mid, high, low;
882 ULONG64 ref_addr, ref_size;
883
884 if (!module->sortlist_valid || !module->addr_sorttab)
885 {
886 if (!resort_symbols(module)) return NULL;
887 }
888
889 /*
890 * Binary search to find closest symbol.
891 */
892 low = 0;
893 high = module->num_sorttab;
894
895 symt_get_address(&module->addr_sorttab[0]->symt, &ref_addr);
896 if (addr <= ref_addr)
897 {
898 low = symt_get_best_at(module, 0);
899 return module->addr_sorttab[low];
900 }
901
902 if (high)
903 {
904 symt_get_address(&module->addr_sorttab[high - 1]->symt, &ref_addr);
905 symt_get_length(module, &module->addr_sorttab[high - 1]->symt, &ref_size);
906 if (addr >= ref_addr + ref_size) return NULL;
907 }
908
909 while (high > low + 1)
910 {
911 mid = (high + low) / 2;
912 if (cmp_sorttab_addr(module, mid, addr) < 0)
913 low = mid;
914 else
915 high = mid;
916 }
917 if (low != high && high != module->num_sorttab &&
918 cmp_sorttab_addr(module, high, addr) <= 0)
919 low = high;
920
921 /* If found symbol is a public symbol, check if there are any other entries that
922 * might also have the same address, but would get better information
923 */
924 low = symt_get_best_at(module, low);
925
926 return module->addr_sorttab[low];
927 }
928
929 static BOOL symt_enum_locals_helper(struct module_pair* pair,
930 const WCHAR* match, const struct sym_enum* se,
931 struct symt_function* func, const struct vector* v)
932 {
933 struct symt* lsym = NULL;
934 DWORD pc = pair->pcs->ctx_frame.InstructionOffset;
935 unsigned int i;
936 WCHAR* nameW;
937 BOOL ret;
938
939 for (i=0; i<vector_length(v); i++)
940 {
941 lsym = *(struct symt**)vector_at(v, i);
942 switch (lsym->tag)
943 {
944 case SymTagBlock:
945 {
946 struct symt_block* block = (struct symt_block*)lsym;
947 if (pc < block->address || block->address + block->size <= pc)
948 continue;
949 if (!symt_enum_locals_helper(pair, match, se, func, &block->vchildren))
950 return FALSE;
951 }
952 break;
953 case SymTagData:
954 nameW = symt_get_nameW(lsym);
955 ret = SymMatchStringW(nameW, match,
956 !(dbghelp_options & SYMOPT_CASE_INSENSITIVE));
957 HeapFree(GetProcessHeap(), 0, nameW);
958 if (ret)
959 {
960 if (send_symbol(se, pair, func, lsym)) return FALSE;
961 }
962 break;
963 case SymTagLabel:
964 case SymTagFuncDebugStart:
965 case SymTagFuncDebugEnd:
966 case SymTagCustom:
967 break;
968 default:
969 FIXME("Unknown type: %u (%x)\n", lsym->tag, lsym->tag);
970 assert(0);
971 }
972 }
973 return TRUE;
974 }
975
976 static BOOL symt_enum_locals(struct process* pcs, const WCHAR* mask,
977 const struct sym_enum* se)
978 {
979 struct module_pair pair;
980 struct symt_ht* sym;
981 DWORD_PTR pc = pcs->ctx_frame.InstructionOffset;
982
983 se->sym_info->SizeOfStruct = sizeof(*se->sym_info);
984 se->sym_info->MaxNameLen = sizeof(se->buffer) - sizeof(SYMBOL_INFO);
985
986 pair.pcs = pcs;
987 pair.requested = module_find_by_addr(pair.pcs, pc, DMT_UNKNOWN);
988 if (!module_get_debug(&pair)) return FALSE;
989 if ((sym = symt_find_nearest(pair.effective, pc)) == NULL) return FALSE;
990
991 if (sym->symt.tag == SymTagFunction)
992 {
993 return symt_enum_locals_helper(&pair, mask ? mask : starW, se, (struct symt_function*)sym,
994 &((struct symt_function*)sym)->vchildren);
995 }
996 return FALSE;
997 }
998
999 /******************************************************************
1000 * copy_symbolW
1001 *
1002 * Helper for transforming an ANSI symbol info into a UNICODE one.
1003 * Assume that MaxNameLen is the same for both version (A & W).
1004 */
1005 void copy_symbolW(SYMBOL_INFOW* siw, const SYMBOL_INFO* si)
1006 {
1007 siw->SizeOfStruct = si->SizeOfStruct;
1008 siw->TypeIndex = si->TypeIndex;
1009 siw->Reserved[0] = si->Reserved[0];
1010 siw->Reserved[1] = si->Reserved[1];
1011 siw->Index = si->Index;
1012 siw->Size = si->Size;
1013 siw->ModBase = si->ModBase;
1014 siw->Flags = si->Flags;
1015 siw->Value = si->Value;
1016 siw->Address = si->Address;
1017 siw->Register = si->Register;
1018 siw->Scope = si->Scope;
1019 siw->Tag = si->Tag;
1020 siw->NameLen = si->NameLen;
1021 siw->MaxNameLen = si->MaxNameLen;
1022 MultiByteToWideChar(CP_ACP, 0, si->Name, -1, siw->Name, siw->MaxNameLen);
1023 }
1024
1025 /******************************************************************
1026 * sym_enum
1027 *
1028 * Core routine for most of the enumeration of symbols
1029 */
1030 static BOOL sym_enum(HANDLE hProcess, ULONG64 BaseOfDll, PCWSTR Mask,
1031 const struct sym_enum* se)
1032 {
1033 struct module_pair pair;
1034 const WCHAR* bang;
1035 WCHAR* mod;
1036
1037 pair.pcs = process_find_by_handle(hProcess);
1038 if (!pair.pcs) return FALSE;
1039 if (BaseOfDll == 0)
1040 {
1041 /* do local variables ? */
1042 if (!Mask || !(bang = wcschr(Mask, '!')))
1043 return symt_enum_locals(pair.pcs, Mask, se);
1044
1045 if (bang == Mask) return FALSE;
1046
1047 mod = HeapAlloc(GetProcessHeap(), 0, (bang - Mask + 1) * sizeof(WCHAR));
1048 if (!mod) return FALSE;
1049 memcpy(mod, Mask, (bang - Mask) * sizeof(WCHAR));
1050 mod[bang - Mask] = 0;
1051
1052 for (pair.requested = pair.pcs->lmodules; pair.requested; pair.requested = pair.requested->next)
1053 {
1054 if (pair.requested->type == DMT_PE && module_get_debug(&pair))
1055 {
1056 if (SymMatchStringW(pair.requested->module.ModuleName, mod, FALSE) &&
1057 symt_enum_module(&pair, bang + 1, se))
1058 break;
1059 }
1060 }
1061 /* not found in PE modules, retry on the ELF ones
1062 */
1063 if (!pair.requested && dbghelp_opt_native)
1064 {
1065 for (pair.requested = pair.pcs->lmodules; pair.requested; pair.requested = pair.requested->next)
1066 {
1067 if ((pair.requested->type == DMT_ELF || pair.requested->type == DMT_MACHO) &&
1068 !module_get_containee(pair.pcs, pair.requested) &&
1069 module_get_debug(&pair))
1070 {
1071 if (SymMatchStringW(pair.requested->module.ModuleName, mod, FALSE) &&
1072 symt_enum_module(&pair, bang + 1, se))
1073 break;
1074 }
1075 }
1076 }
1077 HeapFree(GetProcessHeap(), 0, mod);
1078 return TRUE;
1079 }
1080 pair.requested = module_find_by_addr(pair.pcs, BaseOfDll, DMT_UNKNOWN);
1081 if (!module_get_debug(&pair))
1082 return FALSE;
1083
1084 /* we always ignore module name from Mask when BaseOfDll is defined */
1085 if (Mask && (bang = wcschr(Mask, '!')))
1086 {
1087 if (bang == Mask) return FALSE;
1088 Mask = bang + 1;
1089 }
1090
1091 symt_enum_module(&pair, Mask ? Mask : starW, se);
1092
1093 return TRUE;
1094 }
1095
1096 static inline BOOL doSymEnumSymbols(HANDLE hProcess, ULONG64 BaseOfDll, PCWSTR Mask,
1097 PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
1098 PVOID UserContext)
1099 {
1100 struct sym_enum se;
1101
1102 se.cb = EnumSymbolsCallback;
1103 se.user = UserContext;
1104 se.index = 0;
1105 se.tag = 0;
1106 se.addr = 0;
1107 se.sym_info = (PSYMBOL_INFO)se.buffer;
1108
1109 return sym_enum(hProcess, BaseOfDll, Mask, &se);
1110 }
1111
1112 /******************************************************************
1113 * SymEnumSymbols (DBGHELP.@)
1114 *
1115 * cases BaseOfDll = 0
1116 * !foo fails always (despite what MSDN states)
1117 * RE1!RE2 looks up all modules matching RE1, and in all these modules, lookup RE2
1118 * no ! in Mask, lookup in local Context
1119 * cases BaseOfDll != 0
1120 * !foo fails always (despite what MSDN states)
1121 * RE1!RE2 gets RE2 from BaseOfDll (whatever RE1 is)
1122 */
1123 BOOL WINAPI SymEnumSymbols(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR Mask,
1124 PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
1125 PVOID UserContext)
1126 {
1127 BOOL ret;
1128 PWSTR maskW = NULL;
1129
1130 TRACE("(%p %s %s %p %p)\n",
1131 hProcess, wine_dbgstr_longlong(BaseOfDll), debugstr_a(Mask),
1132 EnumSymbolsCallback, UserContext);
1133
1134 if (Mask)
1135 {
1136 DWORD sz = MultiByteToWideChar(CP_ACP, 0, Mask, -1, NULL, 0);
1137 if (!(maskW = HeapAlloc(GetProcessHeap(), 0, sz * sizeof(WCHAR))))
1138 return FALSE;
1139 MultiByteToWideChar(CP_ACP, 0, Mask, -1, maskW, sz);
1140 }
1141 ret = doSymEnumSymbols(hProcess, BaseOfDll, maskW, EnumSymbolsCallback, UserContext);
1142 HeapFree(GetProcessHeap(), 0, maskW);
1143 return ret;
1144 }
1145
1146 struct sym_enumW
1147 {
1148 PSYM_ENUMERATESYMBOLS_CALLBACKW cb;
1149 void* ctx;
1150 PSYMBOL_INFOW sym_info;
1151 char buffer[sizeof(SYMBOL_INFOW) + MAX_SYM_NAME];
1152
1153 };
1154
1155 static BOOL CALLBACK sym_enumW(PSYMBOL_INFO si, ULONG size, PVOID ctx)
1156 {
1157 struct sym_enumW* sew = ctx;
1158
1159 copy_symbolW(sew->sym_info, si);
1160
1161 return (sew->cb)(sew->sym_info, size, sew->ctx);
1162 }
1163
1164 /******************************************************************
1165 * SymEnumSymbolsW (DBGHELP.@)
1166 *
1167 */
1168 BOOL WINAPI SymEnumSymbolsW(HANDLE hProcess, ULONG64 BaseOfDll, PCWSTR Mask,
1169 PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
1170 PVOID UserContext)
1171 {
1172 struct sym_enumW sew;
1173
1174 sew.ctx = UserContext;
1175 sew.cb = EnumSymbolsCallback;
1176 sew.sym_info = (PSYMBOL_INFOW)sew.buffer;
1177
1178 return doSymEnumSymbols(hProcess, BaseOfDll, Mask, sym_enumW, &sew);
1179 }
1180
1181 struct sym_enumerate
1182 {
1183 void* ctx;
1184 PSYM_ENUMSYMBOLS_CALLBACK cb;
1185 };
1186
1187 static BOOL CALLBACK sym_enumerate_cb(PSYMBOL_INFO syminfo, ULONG size, void* ctx)
1188 {
1189 struct sym_enumerate* se = ctx;
1190 return (se->cb)(syminfo->Name, syminfo->Address, syminfo->Size, se->ctx);
1191 }
1192
1193 /***********************************************************************
1194 * SymEnumerateSymbols (DBGHELP.@)
1195 */
1196 BOOL WINAPI SymEnumerateSymbols(HANDLE hProcess, DWORD BaseOfDll,
1197 PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback,
1198 PVOID UserContext)
1199 {
1200 struct sym_enumerate se;
1201
1202 se.ctx = UserContext;
1203 se.cb = EnumSymbolsCallback;
1204
1205 return SymEnumSymbols(hProcess, BaseOfDll, NULL, sym_enumerate_cb, &se);
1206 }
1207
1208 struct sym_enumerate64
1209 {
1210 void* ctx;
1211 PSYM_ENUMSYMBOLS_CALLBACK64 cb;
1212 };
1213
1214 static BOOL CALLBACK sym_enumerate_cb64(PSYMBOL_INFO syminfo, ULONG size, void* ctx)
1215 {
1216 struct sym_enumerate64* se = ctx;
1217 return (se->cb)(syminfo->Name, syminfo->Address, syminfo->Size, se->ctx);
1218 }
1219
1220 /***********************************************************************
1221 * SymEnumerateSymbols64 (DBGHELP.@)
1222 */
1223 BOOL WINAPI SymEnumerateSymbols64(HANDLE hProcess, DWORD64 BaseOfDll,
1224 PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback,
1225 PVOID UserContext)
1226 {
1227 struct sym_enumerate64 se;
1228
1229 se.ctx = UserContext;
1230 se.cb = EnumSymbolsCallback;
1231
1232 return SymEnumSymbols(hProcess, BaseOfDll, NULL, sym_enumerate_cb64, &se);
1233 }
1234
1235 /******************************************************************
1236 * SymFromAddr (DBGHELP.@)
1237 *
1238 */
1239 BOOL WINAPI SymFromAddr(HANDLE hProcess, DWORD64 Address,
1240 DWORD64* Displacement, PSYMBOL_INFO Symbol)
1241 {
1242 struct module_pair pair;
1243 struct symt_ht* sym;
1244
1245 pair.pcs = process_find_by_handle(hProcess);
1246 if (!pair.pcs) return FALSE;
1247 pair.requested = module_find_by_addr(pair.pcs, Address, DMT_UNKNOWN);
1248 if (!module_get_debug(&pair)) return FALSE;
1249 if ((sym = symt_find_nearest(pair.effective, Address)) == NULL) return FALSE;
1250
1251 symt_fill_sym_info(&pair, NULL, &sym->symt, Symbol);
1252 if (Displacement)
1253 *Displacement = (Address >= Symbol->Address) ? (Address - Symbol->Address) : (DWORD64)-1;
1254 return TRUE;
1255 }
1256
1257 /******************************************************************
1258 * SymFromAddrW (DBGHELP.@)
1259 *
1260 */
1261 BOOL WINAPI SymFromAddrW(HANDLE hProcess, DWORD64 Address,
1262 DWORD64* Displacement, PSYMBOL_INFOW Symbol)
1263 {
1264 PSYMBOL_INFO si;
1265 unsigned len;
1266 BOOL ret;
1267
1268 len = sizeof(*si) + Symbol->MaxNameLen * sizeof(WCHAR);
1269 si = HeapAlloc(GetProcessHeap(), 0, len);
1270 if (!si) return FALSE;
1271
1272 si->SizeOfStruct = sizeof(*si);
1273 si->MaxNameLen = Symbol->MaxNameLen;
1274 if ((ret = SymFromAddr(hProcess, Address, Displacement, si)))
1275 {
1276 copy_symbolW(Symbol, si);
1277 }
1278 HeapFree(GetProcessHeap(), 0, si);
1279 return ret;
1280 }
1281
1282 /******************************************************************
1283 * SymGetSymFromAddr (DBGHELP.@)
1284 *
1285 */
1286 BOOL WINAPI SymGetSymFromAddr(HANDLE hProcess, DWORD Address,
1287 PDWORD Displacement, PIMAGEHLP_SYMBOL Symbol)
1288 {
1289 char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
1290 SYMBOL_INFO*si = (SYMBOL_INFO*)buffer;
1291 size_t len;
1292 DWORD64 Displacement64;
1293
1294 if (Symbol->SizeOfStruct < sizeof(*Symbol)) return FALSE;
1295 si->SizeOfStruct = sizeof(*si);
1296 si->MaxNameLen = MAX_SYM_NAME;
1297 if (!SymFromAddr(hProcess, Address, &Displacement64, si))
1298 return FALSE;
1299
1300 if (Displacement)
1301 *Displacement = Displacement64;
1302 Symbol->Address = si->Address;
1303 Symbol->Size = si->Size;
1304 Symbol->Flags = si->Flags;
1305 len = min(Symbol->MaxNameLength, si->MaxNameLen);
1306 lstrcpynA(Symbol->Name, si->Name, len);
1307 return TRUE;
1308 }
1309
1310 /******************************************************************
1311 * SymGetSymFromAddr64 (DBGHELP.@)
1312 *
1313 */
1314 BOOL WINAPI SymGetSymFromAddr64(HANDLE hProcess, DWORD64 Address,
1315 PDWORD64 Displacement, PIMAGEHLP_SYMBOL64 Symbol)
1316 {
1317 char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
1318 SYMBOL_INFO*si = (SYMBOL_INFO*)buffer;
1319 size_t len;
1320 DWORD64 Displacement64;
1321
1322 if (Symbol->SizeOfStruct < sizeof(*Symbol)) return FALSE;
1323 si->SizeOfStruct = sizeof(*si);
1324 si->MaxNameLen = MAX_SYM_NAME;
1325 if (!SymFromAddr(hProcess, Address, &Displacement64, si))
1326 return FALSE;
1327
1328 if (Displacement)
1329 *Displacement = Displacement64;
1330 Symbol->Address = si->Address;
1331 Symbol->Size = si->Size;
1332 Symbol->Flags = si->Flags;
1333 len = min(Symbol->MaxNameLength, si->MaxNameLen);
1334 lstrcpynA(Symbol->Name, si->Name, len);
1335 return TRUE;
1336 }
1337
1338 static BOOL find_name(struct process* pcs, struct module* module, const char* name,
1339 SYMBOL_INFO* symbol)
1340 {
1341 struct hash_table_iter hti;
1342 void* ptr;
1343 struct symt_ht* sym = NULL;
1344 struct module_pair pair;
1345
1346 pair.pcs = pcs;
1347 if (!(pair.requested = module)) return FALSE;
1348 if (!module_get_debug(&pair)) return FALSE;
1349
1350 hash_table_iter_init(&pair.effective->ht_symbols, &hti, name);
1351 while ((ptr = hash_table_iter_up(&hti)))
1352 {
1353 sym = CONTAINING_RECORD(ptr, struct symt_ht, hash_elt);
1354
1355 if (!strcmp(sym->hash_elt.name, name))
1356 {
1357 symt_fill_sym_info(&pair, NULL, &sym->symt, symbol);
1358 return TRUE;
1359 }
1360 }
1361 return FALSE;
1362
1363 }
1364 /******************************************************************
1365 * SymFromName (DBGHELP.@)
1366 *
1367 */
1368 BOOL WINAPI SymFromName(HANDLE hProcess, PCSTR Name, PSYMBOL_INFO Symbol)
1369 {
1370 struct process* pcs = process_find_by_handle(hProcess);
1371 struct module* module;
1372 const char* name;
1373
1374 TRACE("(%p, %s, %p)\n", hProcess, Name, Symbol);
1375 if (!pcs) return FALSE;
1376 if (Symbol->SizeOfStruct < sizeof(*Symbol)) return FALSE;
1377 name = strchr(Name, '!');
1378 if (name)
1379 {
1380 char tmp[128];
1381 assert(name - Name < sizeof(tmp));
1382 memcpy(tmp, Name, name - Name);
1383 tmp[name - Name] = '\0';
1384 module = module_find_by_nameA(pcs, tmp);
1385 return find_name(pcs, module, name + 1, Symbol);
1386 }
1387 for (module = pcs->lmodules; module; module = module->next)
1388 {
1389 if (module->type == DMT_PE && find_name(pcs, module, Name, Symbol))
1390 return TRUE;
1391 }
1392 /* not found in PE modules, retry on the ELF ones
1393 */
1394 if (dbghelp_opt_native)
1395 {
1396 for (module = pcs->lmodules; module; module = module->next)
1397 {
1398 if ((module->type == DMT_ELF || module->type == DMT_MACHO) &&
1399 !module_get_containee(pcs, module) &&
1400 find_name(pcs, module, Name, Symbol))
1401 return TRUE;
1402 }
1403 }
1404 return FALSE;
1405 }
1406
1407 /***********************************************************************
1408 * SymGetSymFromName64 (DBGHELP.@)
1409 */
1410 BOOL WINAPI SymGetSymFromName64(HANDLE hProcess, PCSTR Name, PIMAGEHLP_SYMBOL64 Symbol)
1411 {
1412 char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
1413 SYMBOL_INFO*si = (SYMBOL_INFO*)buffer;
1414 size_t len;
1415
1416 if (Symbol->SizeOfStruct < sizeof(*Symbol)) return FALSE;
1417 si->SizeOfStruct = sizeof(*si);
1418 si->MaxNameLen = MAX_SYM_NAME;
1419 if (!SymFromName(hProcess, Name, si)) return FALSE;
1420
1421 Symbol->Address = si->Address;
1422 Symbol->Size = si->Size;
1423 Symbol->Flags = si->Flags;
1424 len = min(Symbol->MaxNameLength, si->MaxNameLen);
1425 lstrcpynA(Symbol->Name, si->Name, len);
1426 return TRUE;
1427 }
1428
1429 /***********************************************************************
1430 * SymGetSymFromName (DBGHELP.@)
1431 */
1432 BOOL WINAPI SymGetSymFromName(HANDLE hProcess, PCSTR Name, PIMAGEHLP_SYMBOL Symbol)
1433 {
1434 char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
1435 SYMBOL_INFO*si = (SYMBOL_INFO*)buffer;
1436 size_t len;
1437
1438 if (Symbol->SizeOfStruct < sizeof(*Symbol)) return FALSE;
1439 si->SizeOfStruct = sizeof(*si);
1440 si->MaxNameLen = MAX_SYM_NAME;
1441 if (!SymFromName(hProcess, Name, si)) return FALSE;
1442
1443 Symbol->Address = si->Address;
1444 Symbol->Size = si->Size;
1445 Symbol->Flags = si->Flags;
1446 len = min(Symbol->MaxNameLength, si->MaxNameLen);
1447 lstrcpynA(Symbol->Name, si->Name, len);
1448 return TRUE;
1449 }
1450
1451 /******************************************************************
1452 * sym_fill_func_line_info
1453 *
1454 * fills information about a file
1455 */
1456 BOOL symt_fill_func_line_info(const struct module* module, const struct symt_function* func,
1457 DWORD64 addr, IMAGEHLP_LINE64* line)
1458 {
1459 struct line_info* dli = NULL;
1460 BOOL found = FALSE;
1461 int i;
1462
1463 assert(func->symt.tag == SymTagFunction);
1464
1465 for (i=vector_length(&func->vlines)-1; i>=0; i--)
1466 {
1467 dli = vector_at(&func->vlines, i);
1468 if (!dli->is_source_file)
1469 {
1470 if (found || dli->u.pc_offset > addr) continue;
1471 line->LineNumber = dli->line_number;
1472 line->Address = dli->u.pc_offset;
1473 line->Key = dli;
1474 found = TRUE;
1475 continue;
1476 }
1477 if (found)
1478 {
1479 if (dbghelp_opt_native)
1480 {
1481 /* Return native file paths when using winedbg */
1482 line->FileName = (char*)source_get(module, dli->u.source_file);
1483 }
1484 else
1485 {
1486 WCHAR *dospath = wine_get_dos_file_name(source_get(module, dli->u.source_file));
1487 DWORD len = WideCharToMultiByte(CP_ACP, 0, dospath, -1, NULL, 0, NULL, NULL);
1488 line->FileName = fetch_buffer(module->process, len);
1489 WideCharToMultiByte(CP_ACP, 0, dospath, -1, line->FileName, len, NULL, NULL);
1490 HeapFree( GetProcessHeap(), 0, dospath );
1491 }
1492 return TRUE;
1493 }
1494 }
1495 return FALSE;
1496 }
1497
1498 /***********************************************************************
1499 * SymGetSymNext64 (DBGHELP.@)
1500 */
1501 BOOL WINAPI SymGetSymNext64(HANDLE hProcess, PIMAGEHLP_SYMBOL64 Symbol)
1502 {
1503 /* algo:
1504 * get module from Symbol.Address
1505 * get index in module.addr_sorttab of Symbol.Address
1506 * increment index
1507 * if out of module bounds, move to next module in process address space
1508 */
1509 FIXME("(%p, %p): stub\n", hProcess, Symbol);
1510 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1511 return FALSE;
1512 }
1513
1514 /***********************************************************************
1515 * SymGetSymNext (DBGHELP.@)
1516 */
1517 BOOL WINAPI SymGetSymNext(HANDLE hProcess, PIMAGEHLP_SYMBOL Symbol)
1518 {
1519 FIXME("(%p, %p): stub\n", hProcess, Symbol);
1520 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1521 return FALSE;
1522 }
1523
1524 /***********************************************************************
1525 * SymGetSymPrev64 (DBGHELP.@)
1526 */
1527 BOOL WINAPI SymGetSymPrev64(HANDLE hProcess, PIMAGEHLP_SYMBOL64 Symbol)
1528 {
1529 FIXME("(%p, %p): stub\n", hProcess, Symbol);
1530 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1531 return FALSE;
1532 }
1533
1534 /***********************************************************************
1535 * SymGetSymPrev (DBGHELP.@)
1536 */
1537 BOOL WINAPI SymGetSymPrev(HANDLE hProcess, PIMAGEHLP_SYMBOL Symbol)
1538 {
1539 FIXME("(%p, %p): stub\n", hProcess, Symbol);
1540 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1541 return FALSE;
1542 }
1543
1544 /******************************************************************
1545 * copy_line_64_from_32 (internal)
1546 *
1547 */
1548 static void copy_line_64_from_32(IMAGEHLP_LINE64* l64, const IMAGEHLP_LINE* l32)
1549
1550 {
1551 l64->Key = l32->Key;
1552 l64->LineNumber = l32->LineNumber;
1553 l64->FileName = l32->FileName;
1554 l64->Address = l32->Address;
1555 }
1556
1557 /******************************************************************
1558 * copy_line_W64_from_32 (internal)
1559 *
1560 */
1561 static void copy_line_W64_from_64(struct process* pcs, IMAGEHLP_LINEW64* l64w, const IMAGEHLP_LINE64* l64)
1562 {
1563 unsigned len;
1564
1565 l64w->Key = l64->Key;
1566 l64w->LineNumber = l64->LineNumber;
1567 len = MultiByteToWideChar(CP_ACP, 0, l64->FileName, -1, NULL, 0);
1568 if ((l64w->FileName = fetch_buffer(pcs, len * sizeof(WCHAR))))
1569 MultiByteToWideChar(CP_ACP, 0, l64->FileName, -1, l64w->FileName, len);
1570 l64w->Address = l64->Address;
1571 }
1572
1573 /******************************************************************
1574 * copy_line_32_from_64 (internal)
1575 *
1576 */
1577 static void copy_line_32_from_64(IMAGEHLP_LINE* l32, const IMAGEHLP_LINE64* l64)
1578
1579 {
1580 l32->Key = l64->Key;
1581 l32->LineNumber = l64->LineNumber;
1582 l32->FileName = l64->FileName;
1583 l32->Address = l64->Address;
1584 }
1585
1586 /******************************************************************
1587 * SymGetLineFromAddr (DBGHELP.@)
1588 *
1589 */
1590 BOOL WINAPI SymGetLineFromAddr(HANDLE hProcess, DWORD dwAddr,
1591 PDWORD pdwDisplacement, PIMAGEHLP_LINE Line)
1592 {
1593 IMAGEHLP_LINE64 il64;
1594
1595 il64.SizeOfStruct = sizeof(il64);
1596 if (!SymGetLineFromAddr64(hProcess, dwAddr, pdwDisplacement, &il64))
1597 return FALSE;
1598 copy_line_32_from_64(Line, &il64);
1599 return TRUE;
1600 }
1601
1602 /******************************************************************
1603 * SymGetLineFromAddr64 (DBGHELP.@)
1604 *
1605 */
1606 BOOL WINAPI SymGetLineFromAddr64(HANDLE hProcess, DWORD64 dwAddr,
1607 PDWORD pdwDisplacement, PIMAGEHLP_LINE64 Line)
1608 {
1609 struct module_pair pair;
1610 struct symt_ht* symt;
1611
1612 TRACE("%p %s %p %p\n", hProcess, wine_dbgstr_longlong(dwAddr), pdwDisplacement, Line);
1613
1614 if (Line->SizeOfStruct < sizeof(*Line)) return FALSE;
1615
1616 pair.pcs = process_find_by_handle(hProcess);
1617 if (!pair.pcs) return FALSE;
1618 pair.requested = module_find_by_addr(pair.pcs, dwAddr, DMT_UNKNOWN);
1619 if (!module_get_debug(&pair)) return FALSE;
1620 if ((symt = symt_find_nearest(pair.effective, dwAddr)) == NULL) return FALSE;
1621
1622 if (symt->symt.tag != SymTagFunction) return FALSE;
1623 if (!symt_fill_func_line_info(pair.effective, (struct symt_function*)symt,
1624 dwAddr, Line)) return FALSE;
1625 *pdwDisplacement = dwAddr - Line->Address;
1626 return TRUE;
1627 }
1628
1629 /******************************************************************
1630 * SymGetLineFromAddrW64 (DBGHELP.@)
1631 *
1632 */
1633 BOOL WINAPI SymGetLineFromAddrW64(HANDLE hProcess, DWORD64 dwAddr,
1634 PDWORD pdwDisplacement, PIMAGEHLP_LINEW64 Line)
1635 {
1636 IMAGEHLP_LINE64 il64;
1637
1638 il64.SizeOfStruct = sizeof(il64);
1639 if (!SymGetLineFromAddr64(hProcess, dwAddr, pdwDisplacement, &il64))
1640 return FALSE;
1641 copy_line_W64_from_64(process_find_by_handle(hProcess), Line, &il64);
1642 return TRUE;
1643 }
1644
1645 /******************************************************************
1646 * SymGetLinePrev64 (DBGHELP.@)
1647 *
1648 */
1649 BOOL WINAPI SymGetLinePrev64(HANDLE hProcess, PIMAGEHLP_LINE64 Line)
1650 {
1651 struct module_pair pair;
1652 struct line_info* li;
1653 BOOL in_search = FALSE;
1654
1655 TRACE("(%p %p)\n", hProcess, Line);
1656
1657 if (Line->SizeOfStruct < sizeof(*Line)) return FALSE;
1658
1659 pair.pcs = process_find_by_handle(hProcess);
1660 if (!pair.pcs) return FALSE;
1661 pair.requested = module_find_by_addr(pair.pcs, Line->Address, DMT_UNKNOWN);
1662 if (!module_get_debug(&pair)) return FALSE;
1663
1664 if (Line->Key == 0) return FALSE;
1665 li = Line->Key;
1666 /* things are a bit complicated because when we encounter a DLIT_SOURCEFILE
1667 * element we have to go back until we find the prev one to get the real
1668 * source file name for the DLIT_OFFSET element just before
1669 * the first DLIT_SOURCEFILE
1670 */
1671 while (!li->is_first)
1672 {
1673 li--;
1674 if (!li->is_source_file)
1675 {
1676 Line->LineNumber = li->line_number;
1677 Line->Address = li->u.pc_offset;
1678 Line->Key = li;
1679 if (!in_search) return TRUE;
1680 }
1681 else
1682 {
1683 if (in_search)
1684 {
1685 Line->FileName = (char*)source_get(pair.effective, li->u.source_file);
1686 return TRUE;
1687 }
1688 in_search = TRUE;
1689 }
1690 }
1691 SetLastError(ERROR_NO_MORE_ITEMS); /* FIXME */
1692 return FALSE;
1693 }
1694
1695 /******************************************************************
1696 * SymGetLinePrev (DBGHELP.@)
1697 *
1698 */
1699 BOOL WINAPI SymGetLinePrev(HANDLE hProcess, PIMAGEHLP_LINE Line)
1700 {
1701 IMAGEHLP_LINE64 line64;
1702
1703 line64.SizeOfStruct = sizeof(line64);
1704 copy_line_64_from_32(&line64, Line);
1705 if (!SymGetLinePrev64(hProcess, &line64)) return FALSE;
1706 copy_line_32_from_64(Line, &line64);
1707 return TRUE;
1708 }
1709
1710 BOOL symt_get_func_line_next(const struct module* module, PIMAGEHLP_LINE64 line)
1711 {
1712 struct line_info* li;
1713
1714 if (line->Key == 0) return FALSE;
1715 li = line->Key;
1716 while (!li->is_last)
1717 {
1718 li++;
1719 if (!li->is_source_file)
1720 {
1721 line->LineNumber = li->line_number;
1722 line->Address = li->u.pc_offset;
1723 line->Key = li;
1724 return TRUE;
1725 }
1726 line->FileName = (char*)source_get(module, li->u.source_file);
1727 }
1728 return FALSE;
1729 }
1730
1731 /******************************************************************
1732 * SymGetLineNext64 (DBGHELP.@)
1733 *
1734 */
1735 BOOL WINAPI SymGetLineNext64(HANDLE hProcess, PIMAGEHLP_LINE64 Line)
1736 {
1737 struct module_pair pair;
1738
1739 TRACE("(%p %p)\n", hProcess, Line);
1740
1741 if (Line->SizeOfStruct < sizeof(*Line)) return FALSE;
1742 pair.pcs = process_find_by_handle(hProcess);
1743 if (!pair.pcs) return FALSE;
1744 pair.requested = module_find_by_addr(pair.pcs, Line->Address, DMT_UNKNOWN);
1745 if (!module_get_debug(&pair)) return FALSE;
1746
1747 if (symt_get_func_line_next(pair.effective, Line)) return TRUE;
1748 SetLastError(ERROR_NO_MORE_ITEMS); /* FIXME */
1749 return FALSE;
1750 }
1751
1752 /******************************************************************
1753 * SymGetLineNext (DBGHELP.@)
1754 *
1755 */
1756 BOOL WINAPI SymGetLineNext(HANDLE hProcess, PIMAGEHLP_LINE Line)
1757 {
1758 IMAGEHLP_LINE64 line64;
1759
1760 line64.SizeOfStruct = sizeof(line64);
1761 copy_line_64_from_32(&line64, Line);
1762 if (!SymGetLineNext64(hProcess, &line64)) return FALSE;
1763 copy_line_32_from_64(Line, &line64);
1764 return TRUE;
1765 }
1766
1767 /***********************************************************************
1768 * SymUnDName (DBGHELP.@)
1769 */
1770 BOOL WINAPI SymUnDName(PIMAGEHLP_SYMBOL sym, PSTR UnDecName, DWORD UnDecNameLength)
1771 {
1772 return UnDecorateSymbolName(sym->Name, UnDecName, UnDecNameLength,
1773 UNDNAME_COMPLETE) != 0;
1774 }
1775
1776 /***********************************************************************
1777 * SymUnDName64 (DBGHELP.@)
1778 */
1779 BOOL WINAPI SymUnDName64(PIMAGEHLP_SYMBOL64 sym, PSTR UnDecName, DWORD UnDecNameLength)
1780 {
1781 return UnDecorateSymbolName(sym->Name, UnDecName, UnDecNameLength,
1782 UNDNAME_COMPLETE) != 0;
1783 }
1784
1785 static void * CDECL und_alloc(size_t len) { return HeapAlloc(GetProcessHeap(), 0, len); }
1786 static void CDECL und_free (void* ptr) { HeapFree(GetProcessHeap(), 0, ptr); }
1787
1788 static char *und_name(char *buffer, const char *mangled, int buflen, unsigned short flags)
1789 {
1790 /* undocumented from msvcrt */
1791 static HANDLE hMsvcrt;
1792 static char* (CDECL *p_undname)(char*, const char*, int, void* (CDECL*)(size_t), void (CDECL*)(void*), unsigned short);
1793 static const WCHAR szMsvcrt[] = {'m','s','v','c','r','t','.','d','l','l',0};
1794
1795 if (!p_undname)
1796 {
1797 if (!hMsvcrt) hMsvcrt = LoadLibraryW(szMsvcrt);
1798 if (hMsvcrt) p_undname = (void*)GetProcAddress(hMsvcrt, "__unDName");
1799 if (!p_undname) return NULL;
1800 }
1801
1802 return p_undname(buffer, mangled, buflen, und_alloc, und_free, flags);
1803 }
1804
1805 /***********************************************************************
1806 * UnDecorateSymbolName (DBGHELP.@)
1807 */
1808 DWORD WINAPI UnDecorateSymbolName(const char *decorated_name, char *undecorated_name,
1809 DWORD undecorated_length, DWORD flags)
1810 {
1811 TRACE("(%s, %p, %d, 0x%08x)\n",
1812 debugstr_a(decorated_name), undecorated_name, undecorated_length, flags);
1813
1814 if (!undecorated_name || !undecorated_length)
1815 return 0;
1816 if (!und_name(undecorated_name, decorated_name, undecorated_length, flags))
1817 return 0;
1818 return strlen(undecorated_name);
1819 }
1820
1821 /***********************************************************************
1822 * UnDecorateSymbolNameW (DBGHELP.@)
1823 */
1824 DWORD WINAPI UnDecorateSymbolNameW(const WCHAR *decorated_name, WCHAR *undecorated_name,
1825 DWORD undecorated_length, DWORD flags)
1826 {
1827 char *buf, *ptr;
1828 int len, ret = 0;
1829
1830 TRACE("(%s, %p, %d, 0x%08x)\n",
1831 debugstr_w(decorated_name), undecorated_name, undecorated_length, flags);
1832
1833 if (!undecorated_name || !undecorated_length)
1834 return 0;
1835
1836 len = WideCharToMultiByte(CP_ACP, 0, decorated_name, -1, NULL, 0, NULL, NULL);
1837 if ((buf = HeapAlloc(GetProcessHeap(), 0, len)))
1838 {
1839 WideCharToMultiByte(CP_ACP, 0, decorated_name, -1, buf, len, NULL, NULL);
1840 if ((ptr = und_name(NULL, buf, 0, flags)))
1841 {
1842 MultiByteToWideChar(CP_ACP, 0, ptr, -1, undecorated_name, undecorated_length);
1843 undecorated_name[undecorated_length - 1] = 0;
1844 ret = lstrlenW(undecorated_name);
1845 und_free(ptr);
1846 }
1847 HeapFree(GetProcessHeap(), 0, buf);
1848 }
1849
1850 return ret;
1851 }
1852
1853 #define WILDCHAR(x) (-(x))
1854
1855 static int re_fetch_char(const WCHAR** re)
1856 {
1857 switch (**re)
1858 {
1859 case '\\': (*re)++; return *(*re)++;
1860 case '*': case '[': case '?': case '+': case '#': case ']': return WILDCHAR(*(*re)++);
1861 default: return *(*re)++;
1862 }
1863 }
1864
1865 static inline int re_match_char(WCHAR ch1, WCHAR ch2, BOOL _case)
1866 {
1867 return _case ? ch1 - ch2 : towupper(ch1) - towupper(ch2);
1868 }
1869
1870 static const WCHAR* re_match_one(const WCHAR* string, const WCHAR* elt, BOOL _case)
1871 {
1872 int ch1, prev = 0;
1873 unsigned state = 0;
1874
1875 switch (ch1 = re_fetch_char(&elt))
1876 {
1877 default:
1878 return (ch1 >= 0 && re_match_char(*string, ch1, _case) == 0) ? ++string : NULL;
1879 case WILDCHAR('?'): return *string ? ++string : NULL;
1880 case WILDCHAR('*'): assert(0);
1881 case WILDCHAR('['): break;
1882 }
1883
1884 for (;;)
1885 {
1886 ch1 = re_fetch_char(&elt);
1887 if (ch1 == WILDCHAR(']')) return NULL;
1888 if (state == 1 && ch1 == '-') state = 2;
1889 else
1890 {
1891 if (re_match_char(*string, ch1, _case) == 0) return ++string;
1892 switch (state)
1893 {
1894 case 0:
1895 state = 1;
1896 prev = ch1;
1897 break;
1898 case 1:
1899 state = 0;
1900 break;
1901 case 2:
1902 if (prev >= 0 && ch1 >= 0 && re_match_char(prev, *string, _case) <= 0 &&
1903 re_match_char(*string, ch1, _case) <= 0)
1904 return ++string;
1905 state = 0;
1906 break;
1907 }
1908 }
1909 }
1910 }
1911
1912 /******************************************************************
1913 * re_match_multi
1914 *
1915 * match a substring of *pstring according to *pre regular expression
1916 * pstring and pre are only updated in case of successful match
1917 */
1918 static BOOL re_match_multi(const WCHAR** pstring, const WCHAR** pre, BOOL _case)
1919 {
1920 const WCHAR* re_end = *pre;
1921 const WCHAR* string_end = *pstring;
1922 const WCHAR* re_beg;
1923 const WCHAR* string_beg;
1924 const WCHAR* next;
1925 int ch;
1926
1927 while (*re_end && *string_end)
1928 {
1929 string_beg = string_end;
1930 re_beg = re_end;
1931 switch (ch = re_fetch_char(&re_end))
1932 {
1933 case WILDCHAR(']'): case WILDCHAR('+'): case WILDCHAR('#'): return FALSE;
1934 case WILDCHAR('*'):
1935 /* transform '*' into '?#' */
1936 {static const WCHAR qmW[] = {'?',0}; re_beg = qmW;}
1937 goto closure;
1938 case WILDCHAR('['):
1939 do
1940 {
1941 if (!(ch = re_fetch_char(&re_end))) return FALSE;
1942 } while (ch != WILDCHAR(']'));
1943 /* fall through */
1944 case WILDCHAR('?'):
1945 default:
1946 break;
1947 }
1948
1949 switch (*re_end)
1950 {
1951 case '+':
1952 if (!(next = re_match_one(string_end, re_beg, _case))) return FALSE;
1953 string_beg++;
1954 /* fall through */
1955 case '#':
1956 re_end++;
1957 closure:
1958 while ((next = re_match_one(string_end, re_beg, _case))) string_end = next;
1959 for ( ; string_end >= string_beg; string_end--)
1960 {
1961 if (re_match_multi(&string_end, &re_end, _case)) goto found;
1962 }
1963 return FALSE;
1964 default:
1965 if (!(next = re_match_one(string_end, re_beg, _case))) return FALSE;
1966 string_end = next;
1967 }
1968 }
1969
1970 if (*re_end || *string_end) return FALSE;
1971
1972 found:
1973 *pre = re_end;
1974 *pstring = string_end;
1975 return TRUE;
1976 }
1977
1978 /******************************************************************
1979 * SymMatchStringA (DBGHELP.@)
1980 *
1981 */
1982 BOOL WINAPI SymMatchStringA(PCSTR string, PCSTR re, BOOL _case)
1983 {
1984 WCHAR* strW;
1985 WCHAR* reW;
1986 BOOL ret = FALSE;
1987 DWORD sz;
1988
1989 if (!string || !re)
1990 {
1991 SetLastError(ERROR_INVALID_HANDLE);
1992 return FALSE;
1993 }
1994 TRACE("%s %s %c\n", string, re, _case ? 'Y' : 'N');
1995
1996 sz = MultiByteToWideChar(CP_ACP, 0, string, -1, NULL, 0);
1997 if ((strW = HeapAlloc(GetProcessHeap(), 0, sz * sizeof(WCHAR))))
1998 MultiByteToWideChar(CP_ACP, 0, string, -1, strW, sz);
1999 sz = MultiByteToWideChar(CP_ACP, 0, re, -1, NULL, 0);
2000 if ((reW = HeapAlloc(GetProcessHeap(), 0, sz * sizeof(WCHAR))))
2001 MultiByteToWideChar(CP_ACP, 0, re, -1, reW, sz);
2002
2003 if (strW && reW)
2004 ret = SymMatchStringW(strW, reW, _case);
2005 HeapFree(GetProcessHeap(), 0, strW);
2006 HeapFree(GetProcessHeap(), 0, reW);
2007 return ret;
2008 }
2009
2010 /******************************************************************
2011 * SymMatchStringW (DBGHELP.@)
2012 *
2013 */
2014 BOOL WINAPI SymMatchStringW(PCWSTR string, PCWSTR re, BOOL _case)
2015 {
2016 TRACE("%s %s %c\n", debugstr_w(string), debugstr_w(re), _case ? 'Y' : 'N');
2017
2018 if (!string || !re)
2019 {
2020 SetLastError(ERROR_INVALID_HANDLE);
2021 return FALSE;
2022 }
2023 return re_match_multi(&string, &re, _case);
2024 }
2025
2026 static inline BOOL doSymSearch(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index,
2027 DWORD SymTag, PCWSTR Mask, DWORD64 Address,
2028 PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
2029 PVOID UserContext, DWORD Options)
2030 {
2031 struct sym_enum se;
2032
2033 if (Options != SYMSEARCH_GLOBALSONLY)
2034 {
2035 FIXME("Unsupported searching with options (%x)\n", Options);
2036 SetLastError(ERROR_INVALID_PARAMETER);
2037 return FALSE;
2038 }
2039
2040 se.cb = EnumSymbolsCallback;
2041 se.user = UserContext;
2042 se.index = Index;
2043 se.tag = SymTag;
2044 se.addr = Address;
2045 se.sym_info = (PSYMBOL_INFO)se.buffer;
2046
2047 return sym_enum(hProcess, BaseOfDll, Mask, &se);
2048 }
2049
2050 /******************************************************************
2051 * SymSearch (DBGHELP.@)
2052 */
2053 BOOL WINAPI SymSearch(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index,
2054 DWORD SymTag, PCSTR Mask, DWORD64 Address,
2055 PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
2056 PVOID UserContext, DWORD Options)
2057 {
2058 LPWSTR maskW = NULL;
2059 BOOLEAN ret;
2060
2061 TRACE("(%p %s %u %u %s %s %p %p %x)\n",
2062 hProcess, wine_dbgstr_longlong(BaseOfDll), Index, SymTag, Mask,
2063 wine_dbgstr_longlong(Address), EnumSymbolsCallback,
2064 UserContext, Options);
2065
2066 if (Mask)
2067 {
2068 DWORD sz = MultiByteToWideChar(CP_ACP, 0, Mask, -1, NULL, 0);
2069
2070 if (!(maskW = HeapAlloc(GetProcessHeap(), 0, sz * sizeof(WCHAR))))
2071 return FALSE;
2072 MultiByteToWideChar(CP_ACP, 0, Mask, -1, maskW, sz);
2073 }
2074 ret = doSymSearch(hProcess, BaseOfDll, Index, SymTag, maskW, Address,
2075 EnumSymbolsCallback, UserContext, Options);
2076 HeapFree(GetProcessHeap(), 0, maskW);
2077 return ret;
2078 }
2079
2080 /******************************************************************
2081 * SymSearchW (DBGHELP.@)
2082 */
2083 BOOL WINAPI SymSearchW(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index,
2084 DWORD SymTag, PCWSTR Mask, DWORD64 Address,
2085 PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
2086 PVOID UserContext, DWORD Options)
2087 {
2088 struct sym_enumW sew;
2089
2090 TRACE("(%p %s %u %u %s %s %p %p %x)\n",
2091 hProcess, wine_dbgstr_longlong(BaseOfDll), Index, SymTag, debugstr_w(Mask),
2092 wine_dbgstr_longlong(Address), EnumSymbolsCallback,
2093 UserContext, Options);
2094
2095 sew.ctx = UserContext;
2096 sew.cb = EnumSymbolsCallback;
2097 sew.sym_info = (PSYMBOL_INFOW)sew.buffer;
2098
2099 return doSymSearch(hProcess, BaseOfDll, Index, SymTag, Mask, Address,
2100 sym_enumW, &sew, Options);
2101 }
2102
2103 /******************************************************************
2104 * SymAddSymbol (DBGHELP.@)
2105 *
2106 */
2107 BOOL WINAPI SymAddSymbol(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR name,
2108 DWORD64 addr, DWORD size, DWORD flags)
2109 {
2110 WCHAR nameW[MAX_SYM_NAME];
2111
2112 MultiByteToWideChar(CP_ACP, 0, name, -1, nameW, ARRAY_SIZE(nameW));
2113 return SymAddSymbolW(hProcess, BaseOfDll, nameW, addr, size, flags);
2114 }
2115
2116 /******************************************************************
2117 * SymAddSymbolW (DBGHELP.@)
2118 *
2119 */
2120 BOOL WINAPI SymAddSymbolW(HANDLE hProcess, ULONG64 BaseOfDll, PCWSTR name,
2121 DWORD64 addr, DWORD size, DWORD flags)
2122 {
2123 struct module_pair pair;
2124
2125 TRACE("(%p %s %s %u)\n", hProcess, wine_dbgstr_w(name), wine_dbgstr_longlong(addr), size);
2126
2127 pair.pcs = process_find_by_handle(hProcess);
2128 if (!pair.pcs) return FALSE;
2129 pair.requested = module_find_by_addr(pair.pcs, BaseOfDll, DMT_UNKNOWN);
2130 if (!module_get_debug(&pair)) return FALSE;
2131
2132 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2133 return FALSE;
2134 }
2135
2136 /******************************************************************
2137 * SymSetScopeFromAddr (DBGHELP.@)
2138 */
2139 BOOL WINAPI SymSetScopeFromAddr(HANDLE hProcess, ULONG64 addr)
2140 {
2141 struct process* pcs;
2142
2143 FIXME("(%p %s): stub\n", hProcess, wine_dbgstr_longlong(addr));
2144
2145 if (!(pcs = process_find_by_handle(hProcess))) return FALSE;
2146 return TRUE;
2147 }
2148
2149 /******************************************************************
2150 * SymEnumLines (DBGHELP.@)
2151 *
2152 */
2153 BOOL WINAPI SymEnumLines(HANDLE hProcess, ULONG64 base, PCSTR compiland,
2154 PCSTR srcfile, PSYM_ENUMLINES_CALLBACK cb, PVOID user)
2155 {
2156 struct module_pair pair;
2157 struct hash_table_iter hti;
2158 struct symt_ht* sym;
2159 WCHAR* srcmask;
2160 struct line_info* dli;
2161 void* ptr;
2162 SRCCODEINFO sci;
2163 const char* file;
2164
2165 if (!cb) return FALSE;
2166 if (!(dbghelp_options & SYMOPT_LOAD_LINES)) return TRUE;
2167
2168 pair.pcs = process_find_by_handle(hProcess);
2169 if (!pair.pcs) return FALSE;
2170 if (compiland) FIXME("Unsupported yet (filtering on compiland %s)\n", compiland);
2171 pair.requested = module_find_by_addr(pair.pcs, base, DMT_UNKNOWN);
2172 if (!module_get_debug(&pair)) return FALSE;
2173 if (!(srcmask = file_regex(srcfile))) return FALSE;
2174
2175 sci.SizeOfStruct = sizeof(sci);
2176 sci.ModBase = base;
2177
2178 hash_table_iter_init(&pair.effective->ht_symbols, &hti, NULL);
2179 while ((ptr = hash_table_iter_up(&hti)))
2180 {
2181 unsigned int i;
2182
2183 sym = CONTAINING_RECORD(ptr, struct symt_ht, hash_elt);
2184 if (sym->symt.tag != SymTagFunction) continue;
2185
2186 sci.FileName[0] = '\0';
2187 for (i=0; i<vector_length(&((struct symt_function*)sym)->vlines); i++)
2188 {
2189 dli = vector_at(&((struct symt_function*)sym)->vlines, i);
2190 if (dli->is_source_file)
2191 {
2192 file = source_get(pair.effective, dli->u.source_file);
2193 if (!file) sci.FileName[0] = '\0';
2194 else
2195 {
2196 DWORD sz = MultiByteToWideChar(CP_ACP, 0, file, -1, NULL, 0);
2197 WCHAR* fileW;
2198
2199 if ((fileW = HeapAlloc(GetProcessHeap(), 0, sz * sizeof(WCHAR))))
2200 MultiByteToWideChar(CP_ACP, 0, file, -1, fileW, sz);
2201 if (SymMatchStringW(fileW, srcmask, FALSE))
2202 strcpy(sci.FileName, file);
2203 else
2204 sci.FileName[0] = '\0';
2205 HeapFree(GetProcessHeap(), 0, fileW);
2206 }
2207 }
2208 else if (sci.FileName[0])
2209 {
2210 sci.Key = dli;
2211 sci.Obj[0] = '\0'; /* FIXME */
2212 sci.LineNumber = dli->line_number;
2213 sci.Address = dli->u.pc_offset;
2214 if (!cb(&sci, user)) break;
2215 }
2216 }
2217 }
2218 HeapFree(GetProcessHeap(), 0, srcmask);
2219 return TRUE;
2220 }
2221
2222 BOOL WINAPI SymGetLineFromName(HANDLE hProcess, PCSTR ModuleName, PCSTR FileName,
2223 DWORD dwLineNumber, PLONG plDisplacement, PIMAGEHLP_LINE Line)
2224 {
2225 FIXME("(%p) (%s, %s, %d %p %p): stub\n", hProcess, ModuleName, FileName,
2226 dwLineNumber, plDisplacement, Line);
2227 return FALSE;
2228 }
2229
2230 BOOL WINAPI SymGetLineFromName64(HANDLE hProcess, PCSTR ModuleName, PCSTR FileName,
2231 DWORD dwLineNumber, PLONG lpDisplacement, PIMAGEHLP_LINE64 Line)
2232 {
2233 FIXME("(%p) (%s, %s, %d %p %p): stub\n", hProcess, ModuleName, FileName,
2234 dwLineNumber, lpDisplacement, Line);
2235 return FALSE;
2236 }
2237
2238 BOOL WINAPI SymGetLineFromNameW64(HANDLE hProcess, PCWSTR ModuleName, PCWSTR FileName,
2239 DWORD dwLineNumber, PLONG plDisplacement, PIMAGEHLP_LINEW64 Line)
2240 {
2241 FIXME("(%p) (%s, %s, %d %p %p): stub\n", hProcess, debugstr_w(ModuleName), debugstr_w(FileName),
2242 dwLineNumber, plDisplacement, Line);
2243 return FALSE;
2244 }
2245
2246 /******************************************************************
2247 * SymFromIndex (DBGHELP.@)
2248 *
2249 */
2250 BOOL WINAPI SymFromIndex(HANDLE hProcess, ULONG64 BaseOfDll, DWORD index, PSYMBOL_INFO symbol)
2251 {
2252 FIXME("hProcess = %p, BaseOfDll = %s, index = %d, symbol = %p\n",
2253 hProcess, wine_dbgstr_longlong(BaseOfDll), index, symbol);
2254
2255 return FALSE;
2256 }
2257
2258 /******************************************************************
2259 * SymFromIndexW (DBGHELP.@)
2260 *
2261 */
2262 BOOL WINAPI SymFromIndexW(HANDLE hProcess, ULONG64 BaseOfDll, DWORD index, PSYMBOL_INFOW symbol)
2263 {
2264 FIXME("hProcess = %p, BaseOfDll = %s, index = %d, symbol = %p\n",
2265 hProcess, wine_dbgstr_longlong(BaseOfDll), index, symbol);
2266
2267 return FALSE;
2268 }
2269
2270 /******************************************************************
2271 * SymSetHomeDirectory (DBGHELP.@)
2272 *
2273 */
2274 PCHAR WINAPI SymSetHomeDirectory(HANDLE hProcess, PCSTR dir)
2275 {
2276 FIXME("(%p, %s): stub\n", hProcess, dir);
2277
2278 return NULL;
2279 }
2280
2281 /******************************************************************
2282 * SymSetHomeDirectoryW (DBGHELP.@)
2283 *
2284 */
2285 PWSTR WINAPI SymSetHomeDirectoryW(HANDLE hProcess, PCWSTR dir)
2286 {
2287 FIXME("(%p, %s): stub\n", hProcess, debugstr_w(dir));
2288
2289 return NULL;
2290 }
Windows API implementation