?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dbghelp: Added an ANSI copy of the module name (useful for next patches).
[wine/wine-gecko.git] / dlls / dbghelp / type.c
blob3a36abaacb57756bcdfe078c94d21249f525498c
1 /*
2 * File types.c - management of types (hierarchical tree)
3 *
4 * Copyright (C) 1997, 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 * Note: This really doesn't do much at the moment, but it forms the framework
22 * upon which full support for datatype handling will eventually be built.
23 */
24 #include "config.h"
25 #include <stdlib.h>
26 #include <stdarg.h>
27 #include <assert.h>
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "winreg.h"
32 #include "winnls.h"
33 #include "wine/debug.h"
34 #include "dbghelp_private.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
37 WINE_DECLARE_DEBUG_CHANNEL(dbghelp_symt);
38
39 static const char* symt_get_tag_str(DWORD tag)
40 {
41 switch (tag)
42 {
43 case SymTagNull: return "SymTagNull";
44 case SymTagExe: return "SymTagExe";
45 case SymTagCompiland: return "SymTagCompiland";
46 case SymTagCompilandDetails: return "SymTagCompilandDetails";
47 case SymTagCompilandEnv: return "SymTagCompilandEnv";
48 case SymTagFunction: return "SymTagFunction";
49 case SymTagBlock: return "SymTagBlock";
50 case SymTagData: return "SymTagData";
51 case SymTagAnnotation: return "SymTagAnnotation";
52 case SymTagLabel: return "SymTagLabel";
53 case SymTagPublicSymbol: return "SymTagPublicSymbol";
54 case SymTagUDT: return "SymTagUDT";
55 case SymTagEnum: return "SymTagEnum";
56 case SymTagFunctionType: return "SymTagFunctionType";
57 case SymTagPointerType: return "SymTagPointerType";
58 case SymTagArrayType: return "SymTagArrayType";
59 case SymTagBaseType: return "SymTagBaseType";
60 case SymTagTypedef: return "SymTagTypedef,";
61 case SymTagBaseClass: return "SymTagBaseClass";
62 case SymTagFriend: return "SymTagFriend";
63 case SymTagFunctionArgType: return "SymTagFunctionArgType,";
64 case SymTagFuncDebugStart: return "SymTagFuncDebugStart,";
65 case SymTagFuncDebugEnd: return "SymTagFuncDebugEnd";
66 case SymTagUsingNamespace: return "SymTagUsingNamespace,";
67 case SymTagVTableShape: return "SymTagVTableShape";
68 case SymTagVTable: return "SymTagVTable";
69 case SymTagCustom: return "SymTagCustom";
70 case SymTagThunk: return "SymTagThunk";
71 case SymTagCustomType: return "SymTagCustomType";
72 case SymTagManagedType: return "SymTagManagedType";
73 case SymTagDimension: return "SymTagDimension";
74 default: return "---";
75 }
76 }
77
78 const char* symt_get_name(const struct symt* sym)
79 {
80 switch (sym->tag)
81 {
82 /* lexical tree */
83 case SymTagData: return ((const struct symt_data*)sym)->hash_elt.name;
84 case SymTagFunction: return ((const struct symt_function*)sym)->hash_elt.name;
85 case SymTagPublicSymbol: return ((const struct symt_public*)sym)->hash_elt.name;
86 case SymTagBaseType: return ((const struct symt_basic*)sym)->hash_elt.name;
87 case SymTagLabel: return ((const struct symt_function_point*)sym)->name;
88 case SymTagThunk: return ((const struct symt_thunk*)sym)->hash_elt.name;
89 /* hierarchy tree */
90 case SymTagEnum: return ((const struct symt_enum*)sym)->name;
91 case SymTagTypedef: return ((const struct symt_typedef*)sym)->hash_elt.name;
92 case SymTagUDT: return ((const struct symt_udt*)sym)->hash_elt.name;
93 default:
94 FIXME("Unsupported sym-tag %s\n", symt_get_tag_str(sym->tag));
95 /* fall through */
96 case SymTagArrayType:
97 case SymTagPointerType:
98 case SymTagFunctionType:
99 return NULL;
100 }
101 }
102
103 static struct symt* symt_find_type_by_name(struct module* module,
104 enum SymTagEnum sym_tag,
105 const char* typename)
106 {
107 void* ptr;
108 struct symt_ht* type;
109 struct hash_table_iter hti;
110
111 assert(typename);
112 assert(module);
113
114 hash_table_iter_init(&module->ht_types, &hti, typename);
115 while ((ptr = hash_table_iter_up(&hti)))
116 {
117 type = GET_ENTRY(ptr, struct symt_ht, hash_elt);
118
119 if ((sym_tag == SymTagNull || type->symt.tag == sym_tag) &&
120 type->hash_elt.name && !strcmp(type->hash_elt.name, typename))
121 return &type->symt;
122 }
123 SetLastError(ERROR_INVALID_NAME); /* FIXME ?? */
124 return NULL;
125 }
126
127 static void symt_add_type(struct module* module, struct symt* symt)
128 {
129 struct symt** p;
130 p = vector_add(&module->vtypes, &module->pool);
131 assert(p);
132 *p = symt;
133 }
134
135 struct symt_basic* symt_new_basic(struct module* module, enum BasicType bt,
136 const char* typename, unsigned size)
137 {
138 struct symt_basic* sym;
139
140 if (typename)
141 {
142 sym = (struct symt_basic*)symt_find_type_by_name(module, SymTagBaseType,
143 typename);
144 if (sym && sym->bt == bt && sym->size == size)
145 return sym;
146 }
147 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
148 {
149 sym->symt.tag = SymTagBaseType;
150 if (typename)
151 {
152 sym->hash_elt.name = pool_strdup(&module->pool, typename);
153 hash_table_add(&module->ht_types, &sym->hash_elt);
154 } else sym->hash_elt.name = NULL;
155 sym->bt = bt;
156 sym->size = size;
157 symt_add_type(module, &sym->symt);
158 }
159 return sym;
160 }
161
162 struct symt_udt* symt_new_udt(struct module* module, const char* typename,
163 unsigned size, enum UdtKind kind)
164 {
165 struct symt_udt* sym;
166
167 TRACE_(dbghelp_symt)("Adding udt %s:%s\n", module->module_name, typename);
168 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
169 {
170 sym->symt.tag = SymTagUDT;
171 sym->kind = kind;
172 sym->size = size;
173 if (typename)
174 {
175 sym->hash_elt.name = pool_strdup(&module->pool, typename);
176 hash_table_add(&module->ht_types, &sym->hash_elt);
177 } else sym->hash_elt.name = NULL;
178 vector_init(&sym->vchildren, sizeof(struct symt*), 8);
179 symt_add_type(module, &sym->symt);
180 }
181 return sym;
182 }
183
184 BOOL symt_set_udt_size(struct module* module, struct symt_udt* udt, unsigned size)
185 {
186 assert(udt->symt.tag == SymTagUDT);
187 if (vector_length(&udt->vchildren) != 0)
188 {
189 if (udt->size != size)
190 FIXME_(dbghelp_symt)("Changing size for %s from %u to %u\n",
191 udt->hash_elt.name, udt->size, size);
192 return TRUE;
193 }
194 udt->size = size;
195 return TRUE;
196 }
197
198 /******************************************************************
199 * symt_add_udt_element
200 *
201 * add an element to a udt (struct, class, union)
202 * the size & offset parameters are expressed in bits (not bytes) so that
203 * we can mix in the single call bytes aligned elements (regular fields) and
204 * the others (bit fields)
205 */
206 BOOL symt_add_udt_element(struct module* module, struct symt_udt* udt_type,
207 const char* name, struct symt* elt_type,
208 unsigned offset, unsigned size)
209 {
210 struct symt_data* m;
211 struct symt** p;
212
213 assert(udt_type->symt.tag == SymTagUDT);
214
215 TRACE_(dbghelp_symt)("Adding %s to UDT %s\n", name, udt_type->hash_elt.name);
216 if (name)
217 {
218 p = NULL;
219 while ((p = vector_iter_up(&udt_type->vchildren, p)))
220 {
221 m = (struct symt_data*)*p;
222 assert(m);
223 assert(m->symt.tag == SymTagData);
224 if (strcmp(m->hash_elt.name, name) == 0)
225 return TRUE;
226 }
227 }
228
229 if ((m = pool_alloc(&module->pool, sizeof(*m))) == NULL) return FALSE;
230 memset(m, 0, sizeof(*m));
231 m->symt.tag = SymTagData;
232 m->hash_elt.name = name ? pool_strdup(&module->pool, name) : "";
233 m->hash_elt.next = NULL;
234
235 m->kind = DataIsMember;
236 m->container = &udt_type->symt;
237 m->type = elt_type;
238 m->u.member.offset = offset;
239 m->u.member.length = ((offset & 7) || (size & 7)) ? size : 0;
240 p = vector_add(&udt_type->vchildren, &module->pool);
241 *p = &m->symt;
242
243 return TRUE;
244 }
245
246 struct symt_enum* symt_new_enum(struct module* module, const char* typename)
247 {
248 struct symt_enum* sym;
249
250 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
251 {
252 sym->symt.tag = SymTagEnum;
253 sym->name = (typename) ? pool_strdup(&module->pool, typename) : NULL;
254 vector_init(&sym->vchildren, sizeof(struct symt*), 8);
255 }
256 return sym;
257 }
258
259 BOOL symt_add_enum_element(struct module* module, struct symt_enum* enum_type,
260 const char* name, int value)
261 {
262 struct symt_data* e;
263 struct symt** p;
264
265 assert(enum_type->symt.tag == SymTagEnum);
266 e = pool_alloc(&module->pool, sizeof(*e));
267 if (e == NULL) return FALSE;
268
269 e->symt.tag = SymTagData;
270 e->hash_elt.name = pool_strdup(&module->pool, name);
271 e->hash_elt.next = NULL;
272 e->kind = DataIsConstant;
273 e->container = &enum_type->symt;
274 /* CV defines the underlying type for the enumeration */
275 e->type = &symt_new_basic(module, btInt, "int", 4)->symt;
276 e->u.value.n1.n2.vt = VT_I4;
277 e->u.value.n1.n2.n3.lVal = value;
278
279 p = vector_add(&enum_type->vchildren, &module->pool);
280 if (!p) return FALSE; /* FIXME we leak e */
281 *p = &e->symt;
282
283 return TRUE;
284 }
285
286 struct symt_array* symt_new_array(struct module* module, int min, int max,
287 struct symt* base, struct symt* index)
288 {
289 struct symt_array* sym;
290
291 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
292 {
293 sym->symt.tag = SymTagArrayType;
294 sym->start = min;
295 sym->end = max;
296 sym->base_type = base;
297 sym->index_type = index;
298 symt_add_type(module, &sym->symt);
299 }
300 return sym;
301 }
302
303 struct symt_function_signature* symt_new_function_signature(struct module* module,
304 struct symt* ret_type,
305 enum CV_call_e call_conv)
306 {
307 struct symt_function_signature* sym;
308
309 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
310 {
311 sym->symt.tag = SymTagFunctionType;
312 sym->rettype = ret_type;
313 vector_init(&sym->vchildren, sizeof(struct symt*), 4);
314 sym->call_conv = call_conv;
315 symt_add_type(module, &sym->symt);
316 }
317 return sym;
318 }
319
320 BOOL symt_add_function_signature_parameter(struct module* module,
321 struct symt_function_signature* sig_type,
322 struct symt* param)
323 {
324 struct symt** p;
325 struct symt_function_arg_type* arg;
326
327 assert(sig_type->symt.tag == SymTagFunctionType);
328 arg = pool_alloc(&module->pool, sizeof(*arg));
329 if (!arg) return FALSE;
330 arg->symt.tag = SymTagFunctionArgType;
331 arg->arg_type = param;
332 arg->container = &sig_type->symt;
333 p = vector_add(&sig_type->vchildren, &module->pool);
334 if (!p) return FALSE; /* FIXME we leak arg */
335 *p = &arg->symt;
336
337 return TRUE;
338 }
339
340 struct symt_pointer* symt_new_pointer(struct module* module, struct symt* ref_type)
341 {
342 struct symt_pointer* sym;
343
344 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
345 {
346 sym->symt.tag = SymTagPointerType;
347 sym->pointsto = ref_type;
348 symt_add_type(module, &sym->symt);
349 }
350 return sym;
351 }
352
353 struct symt_typedef* symt_new_typedef(struct module* module, struct symt* ref,
354 const char* name)
355 {
356 struct symt_typedef* sym;
357
358 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
359 {
360 sym->symt.tag = SymTagTypedef;
361 sym->type = ref;
362 sym->hash_elt.name = pool_strdup(&module->pool, name);
363 hash_table_add(&module->ht_types, &sym->hash_elt);
364 symt_add_type(module, &sym->symt);
365 }
366 return sym;
367 }
368
369 /******************************************************************
370 * SymEnumTypes (DBGHELP.@)
371 *
372 */
373 BOOL WINAPI SymEnumTypes(HANDLE hProcess, ULONG64 BaseOfDll,
374 PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
375 PVOID UserContext)
376 {
377 struct module_pair pair;
378 char buffer[sizeof(SYMBOL_INFO) + 256];
379 SYMBOL_INFO* sym_info = (SYMBOL_INFO*)buffer;
380 const char* tmp;
381 struct symt* type;
382 void* pos = NULL;
383 DWORD64 size;
384
385 TRACE("(%p %s %p %p)\n",
386 hProcess, wine_dbgstr_longlong(BaseOfDll), EnumSymbolsCallback,
387 UserContext);
388
389 if (!(pair.pcs = process_find_by_handle(hProcess))) return FALSE;
390 pair.requested = module_find_by_addr(pair.pcs, BaseOfDll, DMT_UNKNOWN);
391 if (!module_get_debug(&pair)) return FALSE;
392
393 sym_info->SizeOfStruct = sizeof(SYMBOL_INFO);
394 sym_info->MaxNameLen = sizeof(buffer) - sizeof(SYMBOL_INFO);
395
396 while ((pos = vector_iter_up(&pair.effective->vtypes, pos)))
397 {
398 type = *(struct symt**)pos;
399 sym_info->TypeIndex = (DWORD)type;
400 sym_info->info = 0; /* FIXME */
401 symt_get_info(type, TI_GET_LENGTH, &size);
402 sym_info->Size = size;
403 sym_info->ModBase = pair.requested->module.BaseOfImage;
404 sym_info->Flags = 0; /* FIXME */
405 sym_info->Value = 0; /* FIXME */
406 sym_info->Address = 0; /* FIXME */
407 sym_info->Register = 0; /* FIXME */
408 sym_info->Scope = 0; /* FIXME */
409 sym_info->Tag = type->tag;
410 tmp = symt_get_name(type);
411 if (tmp)
412 {
413 sym_info->NameLen = min(strlen(tmp),sym_info->MaxNameLen-1);
414 memcpy(sym_info->Name, tmp, sym_info->NameLen);
415 sym_info->Name[sym_info->NameLen] = '\0';
416 }
417 else
418 sym_info->Name[sym_info->NameLen = 0] = '\0';
419 if (!EnumSymbolsCallback(sym_info, sym_info->Size, UserContext)) break;
420 }
421 return TRUE;
422 }
423
424 /******************************************************************
425 * symt_get_info
426 *
427 * Retrieves inforamtion about a symt (either symbol or type)
428 */
429 BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req,
430 void* pInfo)
431 {
432 unsigned len;
433
434 if (!type) return FALSE;
435
436 /* helper to typecast pInfo to its expected type (_t) */
437 #define X(_t) (*((_t*)pInfo))
438
439 switch (req)
440 {
441 case TI_FINDCHILDREN:
442 {
443 const struct vector* v;
444 struct symt** pt;
445 unsigned i;
446 TI_FINDCHILDREN_PARAMS* tifp = pInfo;
447
448 switch (type->tag)
449 {
450 case SymTagUDT: v = &((const struct symt_udt*)type)->vchildren; break;
451 case SymTagEnum: v = &((const struct symt_enum*)type)->vchildren; break;
452 case SymTagFunctionType: v = &((const struct symt_function_signature*)type)->vchildren; break;
453 case SymTagFunction: v = &((const struct symt_function*)type)->vchildren; break;
454 default:
455 FIXME("Unsupported sym-tag %s for find-children\n",
456 symt_get_tag_str(type->tag));
457 return FALSE;
458 }
459 for (i = 0; i < tifp->Count; i++)
460 {
461 if (!(pt = vector_at(v, tifp->Start + i))) return FALSE;
462 tifp->ChildId[i] = (DWORD)*pt;
463 }
464 }
465 break;
466
467 case TI_GET_ADDRESS:
468 switch (type->tag)
469 {
470 case SymTagData:
471 switch (((const struct symt_data*)type)->kind)
472 {
473 case DataIsGlobal:
474 case DataIsFileStatic:
475 X(ULONG64) = ((const struct symt_data*)type)->u.var.offset;
476 break;
477 default: return FALSE;
478 }
479 break;
480 case SymTagFunction:
481 X(ULONG64) = ((const struct symt_function*)type)->address;
482 break;
483 case SymTagPublicSymbol:
484 X(ULONG64) = ((const struct symt_public*)type)->address;
485 break;
486 case SymTagFuncDebugStart:
487 case SymTagFuncDebugEnd:
488 case SymTagLabel:
489 X(ULONG64) = ((const struct symt_function_point*)type)->parent->address +
490 ((const struct symt_function_point*)type)->loc.offset;
491 break;
492 case SymTagThunk:
493 X(ULONG64) = ((const struct symt_thunk*)type)->address;
494 break;
495 case SymTagCompiland:
496 X(ULONG64) = ((const struct symt_compiland*)type)->address;
497 break;
498 default:
499 FIXME("Unsupported sym-tag %s for get-address\n",
500 symt_get_tag_str(type->tag));
501 return FALSE;
502 }
503 break;
504
505 case TI_GET_BASETYPE:
506 switch (type->tag)
507 {
508 case SymTagBaseType:
509 X(DWORD) = ((const struct symt_basic*)type)->bt;
510 break;
511 case SymTagEnum:
512 X(DWORD) = btInt;
513 break;
514 default:
515 return FALSE;
516 }
517 break;
518
519 case TI_GET_BITPOSITION:
520 if (type->tag == SymTagData &&
521 ((const struct symt_data*)type)->kind == DataIsMember &&
522 ((const struct symt_data*)type)->u.member.length != 0)
523 X(DWORD) = ((const struct symt_data*)type)->u.member.offset & 7;
524 else return FALSE;
525 break;
526
527 case TI_GET_CHILDRENCOUNT:
528 switch (type->tag)
529 {
530 case SymTagUDT:
531 X(DWORD) = vector_length(&((const struct symt_udt*)type)->vchildren);
532 break;
533 case SymTagEnum:
534 X(DWORD) = vector_length(&((const struct symt_enum*)type)->vchildren);
535 break;
536 case SymTagFunctionType:
537 X(DWORD) = vector_length(&((const struct symt_function_signature*)type)->vchildren);
538 break;
539 case SymTagFunction:
540 X(DWORD) = vector_length(&((const struct symt_function*)type)->vchildren);
541 break;
542 case SymTagPointerType: /* MS does it that way */
543 case SymTagArrayType: /* MS does it that way */
544 case SymTagThunk: /* MS does it that way */
545 X(DWORD) = 0;
546 break;
547 default:
548 FIXME("Unsupported sym-tag %s for get-children-count\n",
549 symt_get_tag_str(type->tag));
550 /* fall through */
551 case SymTagData:
552 case SymTagPublicSymbol:
553 case SymTagBaseType:
554 return FALSE;
555 }
556 break;
557
558 case TI_GET_COUNT:
559 switch (type->tag)
560 {
561 case SymTagArrayType:
562 X(DWORD) = ((const struct symt_array*)type)->end -
563 ((const struct symt_array*)type)->start + 1;
564 break;
565 case SymTagFunctionType:
566 /* this seems to be wrong for (future) C++ methods, where 'this' parameter
567 * should be included in this value (and not in GET_CHILDREN_COUNT)
568 */
569 X(DWORD) = vector_length(&((const struct symt_function_signature*)type)->vchildren);
570 break;
571 default: return FALSE;
572 }
573 break;
574
575 case TI_GET_DATAKIND:
576 if (type->tag != SymTagData) return FALSE;
577 X(DWORD) = ((const struct symt_data*)type)->kind;
578 break;
579
580 case TI_GET_LENGTH:
581 switch (type->tag)
582 {
583 case SymTagBaseType:
584 X(DWORD64) = ((const struct symt_basic*)type)->size;
585 break;
586 case SymTagFunction:
587 X(DWORD64) = ((const struct symt_function*)type)->size;
588 break;
589 case SymTagPointerType:
590 X(DWORD64) = sizeof(void*);
591 break;
592 case SymTagUDT:
593 X(DWORD64) = ((const struct symt_udt*)type)->size;
594 break;
595 case SymTagEnum:
596 X(DWORD64) = sizeof(int); /* FIXME: should be size of base-type of enum !!! */
597 break;
598 case SymTagData:
599 if (((const struct symt_data*)type)->kind != DataIsMember ||
600 !((const struct symt_data*)type)->u.member.length)
601 return FALSE;
602 X(DWORD64) = ((const struct symt_data*)type)->u.member.length;
603 break;
604 case SymTagArrayType:
605 if (!symt_get_info(((const struct symt_array*)type)->base_type,
606 TI_GET_LENGTH, pInfo))
607 return FALSE;
608 X(DWORD64) *= ((const struct symt_array*)type)->end -
609 ((const struct symt_array*)type)->start + 1;
610 break;
611 case SymTagPublicSymbol:
612 X(DWORD64) = ((const struct symt_public*)type)->size;
613 break;
614 case SymTagTypedef:
615 return symt_get_info(((const struct symt_typedef*)type)->type, TI_GET_LENGTH, pInfo);
616 case SymTagThunk:
617 X(DWORD64) = ((const struct symt_thunk*)type)->size;
618 break;
619 default:
620 FIXME("Unsupported sym-tag %s for get-length\n",
621 symt_get_tag_str(type->tag));
622 /* fall through */
623 case SymTagFunctionType:
624 return 0;
625 }
626 break;
627
628 case TI_GET_LEXICALPARENT:
629 switch (type->tag)
630 {
631 case SymTagBlock:
632 X(DWORD) = (DWORD)((const struct symt_block*)type)->container;
633 break;
634 case SymTagData:
635 X(DWORD) = (DWORD)((const struct symt_data*)type)->container;
636 break;
637 case SymTagFunction:
638 X(DWORD) = (DWORD)((const struct symt_function*)type)->container;
639 break;
640 case SymTagThunk:
641 X(DWORD) = (DWORD)((const struct symt_thunk*)type)->container;
642 break;
643 case SymTagFunctionArgType:
644 X(DWORD) = (DWORD)((const struct symt_function_arg_type*)type)->container;
645 break;
646 default:
647 FIXME("Unsupported sym-tag %s for get-lexical-parent\n",
648 symt_get_tag_str(type->tag));
649 return FALSE;
650 }
651 break;
652
653 case TI_GET_NESTED:
654 switch (type->tag)
655 {
656 case SymTagUDT:
657 case SymTagEnum:
658 X(DWORD) = 0;
659 break;
660 default:
661 return FALSE;
662 }
663 break;
664
665 case TI_GET_OFFSET:
666 switch (type->tag)
667 {
668 case SymTagData:
669 switch (((const struct symt_data*)type)->kind)
670 {
671 case DataIsParam:
672 case DataIsLocal:
673 X(ULONG) = ((const struct symt_data*)type)->u.var.offset;
674 break;
675 case DataIsMember:
676 X(ULONG) = ((const struct symt_data*)type)->u.member.offset >> 3;
677 break;
678 default:
679 FIXME("Unknown kind (%u) for get-offset\n",
680 ((const struct symt_data*)type)->kind);
681 return FALSE;
682 }
683 break;
684 default:
685 FIXME("Unsupported sym-tag %s for get-offset\n",
686 symt_get_tag_str(type->tag));
687 return FALSE;
688 }
689 break;
690
691 case TI_GET_SYMNAME:
692 {
693 const char* name = symt_get_name(type);
694 if (!name) return FALSE;
695 len = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0);
696 X(WCHAR*) = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
697 if (!X(WCHAR*)) return FALSE;
698 MultiByteToWideChar(CP_ACP, 0, name, -1, X(WCHAR*), len);
699 }
700 break;
701
702 case TI_GET_SYMTAG:
703 X(DWORD) = type->tag;
704 break;
705
706 case TI_GET_TYPE:
707 case TI_GET_TYPEID:
708 switch (type->tag)
709 {
710 /* hierarchical => hierarchical */
711 case SymTagArrayType:
712 X(DWORD) = (DWORD)((const struct symt_array*)type)->base_type;
713 break;
714 case SymTagPointerType:
715 X(DWORD) = (DWORD)((const struct symt_pointer*)type)->pointsto;
716 break;
717 case SymTagFunctionType:
718 X(DWORD) = (DWORD)((const struct symt_function_signature*)type)->rettype;
719 break;
720 case SymTagTypedef:
721 X(DWORD) = (DWORD)((const struct symt_typedef*)type)->type;
722 break;
723 /* lexical => hierarchical */
724 case SymTagData:
725 X(DWORD) = (DWORD)((const struct symt_data*)type)->type;
726 break;
727 case SymTagFunction:
728 X(DWORD) = (DWORD)((const struct symt_function*)type)->type;
729 break;
730 /* FIXME: should also work for enums */
731 case SymTagFunctionArgType:
732 X(DWORD) = (DWORD)((const struct symt_function_arg_type*)type)->arg_type;
733 break;
734 default:
735 FIXME("Unsupported sym-tag %s for get-type\n",
736 symt_get_tag_str(type->tag));
737 case SymTagPublicSymbol:
738 case SymTagThunk:
739 return FALSE;
740 }
741 break;
742
743 case TI_GET_UDTKIND:
744 if (type->tag != SymTagUDT) return FALSE;
745 X(DWORD) = ((const struct symt_udt*)type)->kind;
746 break;
747
748 case TI_GET_VALUE:
749 if (type->tag != SymTagData || ((const struct symt_data*)type)->kind != DataIsConstant)
750 return FALSE;
751 X(VARIANT) = ((const struct symt_data*)type)->u.value;
752 break;
753
754 case TI_GET_CALLING_CONVENTION:
755 if (type->tag != SymTagFunctionType) return FALSE;
756 if (((const struct symt_function_signature*)type)->call_conv == -1)
757 {
758 FIXME("No support for calling convention for this signature\n");
759 X(DWORD) = CV_CALL_FAR_C; /* FIXME */
760 }
761 else X(DWORD) = ((const struct symt_function_signature*)type)->call_conv;
762 break;
763 case TI_GET_ARRAYINDEXTYPEID:
764 if (type->tag != SymTagArrayType) return FALSE;
765 X(DWORD) = (DWORD)((const struct symt_array*)type)->index_type;
766 break;
767
768 #undef X
769
770 case TI_GET_ADDRESSOFFSET:
771 case TI_GET_CLASSPARENTID:
772 case TI_GET_SYMINDEX:
773 case TI_GET_THISADJUST:
774 case TI_GET_VIRTUALBASECLASS:
775 case TI_GET_VIRTUALBASEPOINTEROFFSET:
776 case TI_GET_VIRTUALTABLESHAPEID:
777 case TI_IS_EQUIV_TO:
778 FIXME("Unsupported GetInfo request (%u)\n", req);
779 return FALSE;
780 default:
781 FIXME("Unknown GetInfo request (%u)\n", req);
782 return FALSE;
783 }
784
785 return TRUE;
786 }
787
788 /******************************************************************
789 * SymGetTypeInfo (DBGHELP.@)
790 *
791 */
792 BOOL WINAPI SymGetTypeInfo(HANDLE hProcess, DWORD64 ModBase,
793 ULONG TypeId, IMAGEHLP_SYMBOL_TYPE_INFO GetType,
794 PVOID pInfo)
795 {
796 struct module_pair pair;
797
798 pair.pcs = process_find_by_handle(hProcess);
799 if (!pair.pcs) return FALSE;
800
801 pair.requested = module_find_by_addr(pair.pcs, ModBase, DMT_UNKNOWN);
802 if (!module_get_debug(&pair))
803 {
804 FIXME("Someone didn't properly set ModBase (%s)\n", wine_dbgstr_longlong(ModBase));
805 return FALSE;
806 }
807
808 return symt_get_info((struct symt*)TypeId, GetType, pInfo);
809 }
810
811 /******************************************************************
812 * SymGetTypeFromName (DBGHELP.@)
813 *
814 */
815 BOOL WINAPI SymGetTypeFromName(HANDLE hProcess, ULONG64 BaseOfDll,
816 PCSTR Name, PSYMBOL_INFO Symbol)
817 {
818 struct process* pcs = process_find_by_handle(hProcess);
819 struct module* module;
820 struct symt* type;
821
822 if (!pcs) return FALSE;
823 module = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN);
824 if (!module) return FALSE;
825 type = symt_find_type_by_name(module, SymTagNull, Name);
826 if (!type) return FALSE;
827 Symbol->TypeIndex = (DWORD)type;
828
829 return TRUE;
830 }
Wine tree for Wine Gecko development