2 * File types.c - management of types (hierarchical tree)
4 * Copyright (C) 1997, Eric Youngdale.
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
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.
33 #include "wine/debug.h"
34 #include "dbghelp_private.h"
36 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
37 WINE_DECLARE_DEBUG_CHANNEL(dbghelp_symt);
39 static const char* symt_get_tag_str(DWORD tag)
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 "---";
78 const char* symt_get_name(const struct symt* sym)
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;
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;
94 FIXME("Unsupported sym-tag %s\n", symt_get_tag_str(sym->tag));
97 case SymTagPointerType:
98 case SymTagFunctionType:
103 static struct symt* symt_find_type_by_name(struct module* module,
104 enum SymTagEnum sym_tag,
105 const char* typename)
108 struct symt_ht* type;
109 struct hash_table_iter hti;
114 hash_table_iter_init(&module->ht_types, &hti, typename);
115 while ((ptr = hash_table_iter_up(&hti)))
117 type = GET_ENTRY(ptr, struct symt_ht, hash_elt);
119 if ((sym_tag == SymTagNull || type->symt.tag == sym_tag) &&
120 type->hash_elt.name && !strcmp(type->hash_elt.name, typename))
123 SetLastError(ERROR_INVALID_NAME); /* FIXME ?? */
127 static void symt_add_type(struct module* module, struct symt* symt)
130 p = vector_add(&module->vtypes, &module->pool);
135 struct symt_basic* symt_new_basic(struct module* module, enum BasicType bt,
136 const char* typename, unsigned size)
138 struct symt_basic* sym;
142 sym = (struct symt_basic*)symt_find_type_by_name(module, SymTagBaseType,
144 if (sym && sym->bt == bt && sym->size == size)
147 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
149 sym->symt.tag = SymTagBaseType;
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;
157 symt_add_type(module, &sym->symt);
162 struct symt_udt* symt_new_udt(struct module* module, const char* typename,
163 unsigned size, enum UdtKind kind)
165 struct symt_udt* sym;
167 TRACE_(dbghelp_symt)("Adding udt %s:%s\n", module->module.ModuleName, typename);
168 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
170 sym->symt.tag = SymTagUDT;
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);
184 BOOL symt_set_udt_size(struct module* module, struct symt_udt* udt, unsigned size)
186 assert(udt->symt.tag == SymTagUDT);
187 if (vector_length(&udt->vchildren) != 0)
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);
198 /******************************************************************
199 * symt_add_udt_element
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)
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)
213 assert(udt_type->symt.tag == SymTagUDT);
215 TRACE_(dbghelp_symt)("Adding %s to UDT %s\n", name, udt_type->hash_elt.name);
217 while ((p = vector_iter_up(&udt_type->vchildren, p)))
219 m = (struct symt_data*)*p;
221 assert(m->symt.tag == SymTagData);
222 if (m->hash_elt.name[0] == name[0] && strcmp(m->hash_elt.name, name) == 0)
226 if ((m = pool_alloc(&module->pool, sizeof(*m))) == NULL) return FALSE;
227 memset(m, 0, sizeof(*m));
228 m->symt.tag = SymTagData;
229 m->hash_elt.name = pool_strdup(&module->pool, name);
230 m->hash_elt.next = NULL;
232 m->kind = DataIsMember;
233 m->container = &udt_type->symt;
235 m->u.s.offset = offset;
236 m->u.s.length = ((offset & 7) || (size & 7)) ? size : 0;
238 p = vector_add(&udt_type->vchildren, &module->pool);
244 struct symt_enum* symt_new_enum(struct module* module, const char* typename)
246 struct symt_enum* sym;
248 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
250 sym->symt.tag = SymTagEnum;
251 sym->name = (typename) ? pool_strdup(&module->pool, typename) : NULL;
252 vector_init(&sym->vchildren, sizeof(struct symt*), 8);
257 BOOL symt_add_enum_element(struct module* module, struct symt_enum* enum_type,
258 const char* name, int value)
263 assert(enum_type->symt.tag == SymTagEnum);
264 e = pool_alloc(&module->pool, sizeof(*e));
265 if (e == NULL) return FALSE;
267 e->symt.tag = SymTagData;
268 e->hash_elt.name = pool_strdup(&module->pool, name);
269 e->hash_elt.next = NULL;
270 e->kind = DataIsConstant;
271 e->container = &enum_type->symt;
272 /* CV defines the underlying type for the enumeration */
273 e->type = &symt_new_basic(module, btInt, "int", 4)->symt;
274 e->u.value.n1.n2.vt = VT_I4;
275 e->u.value.n1.n2.n3.lVal = value;
277 p = vector_add(&enum_type->vchildren, &module->pool);
278 if (!p) return FALSE; /* FIXME we leak e */
284 struct symt_array* symt_new_array(struct module* module, int min, int max,
285 struct symt* base, struct symt* index)
287 struct symt_array* sym;
289 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
291 sym->symt.tag = SymTagArrayType;
294 sym->base_type = base;
295 sym->index_type = index;
296 symt_add_type(module, &sym->symt);
301 struct symt_function_signature* symt_new_function_signature(struct module* module,
302 struct symt* ret_type,
303 enum CV_call_e call_conv)
305 struct symt_function_signature* sym;
307 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
309 sym->symt.tag = SymTagFunctionType;
310 sym->rettype = ret_type;
311 vector_init(&sym->vchildren, sizeof(struct symt*), 4);
312 sym->call_conv = call_conv;
313 symt_add_type(module, &sym->symt);
318 BOOL symt_add_function_signature_parameter(struct module* module,
319 struct symt_function_signature* sig_type,
323 struct symt_function_arg_type* arg;
325 assert(sig_type->symt.tag == SymTagFunctionType);
326 arg = pool_alloc(&module->pool, sizeof(*arg));
327 if (!arg) return FALSE;
328 arg->symt.tag = SymTagFunctionArgType;
329 arg->arg_type = param;
330 arg->container = &sig_type->symt;
331 p = vector_add(&sig_type->vchildren, &module->pool);
332 if (!p) return FALSE; /* FIXME we leak arg */
338 struct symt_pointer* symt_new_pointer(struct module* module, struct symt* ref_type)
340 struct symt_pointer* sym;
342 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
344 sym->symt.tag = SymTagPointerType;
345 sym->pointsto = ref_type;
346 symt_add_type(module, &sym->symt);
351 struct symt_typedef* symt_new_typedef(struct module* module, struct symt* ref,
354 struct symt_typedef* sym;
356 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
358 sym->symt.tag = SymTagTypedef;
360 sym->hash_elt.name = pool_strdup(&module->pool, name);
361 hash_table_add(&module->ht_types, &sym->hash_elt);
362 symt_add_type(module, &sym->symt);
367 /******************************************************************
368 * SymEnumTypes (DBGHELP.@)
371 BOOL WINAPI SymEnumTypes(HANDLE hProcess, ULONG64 BaseOfDll,
372 PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
375 struct module_pair pair;
376 char buffer[sizeof(SYMBOL_INFO) + 256];
377 SYMBOL_INFO* sym_info = (SYMBOL_INFO*)buffer;
383 TRACE("(%p %s %p %p)\n",
384 hProcess, wine_dbgstr_longlong(BaseOfDll), EnumSymbolsCallback,
387 if (!(pair.pcs = process_find_by_handle(hProcess))) return FALSE;
388 pair.requested = module_find_by_addr(pair.pcs, BaseOfDll, DMT_UNKNOWN);
389 if (!module_get_debug(&pair)) return FALSE;
391 sym_info->SizeOfStruct = sizeof(SYMBOL_INFO);
392 sym_info->MaxNameLen = sizeof(buffer) - sizeof(SYMBOL_INFO);
394 while ((pos = vector_iter_up(&pair.effective->vtypes, pos)))
396 type = *(struct symt**)pos;
397 sym_info->TypeIndex = (DWORD)type;
398 sym_info->info = 0; /* FIXME */
399 symt_get_info(type, TI_GET_LENGTH, &size);
400 sym_info->Size = size;
401 sym_info->ModBase = pair.requested->module.BaseOfImage;
402 sym_info->Flags = 0; /* FIXME */
403 sym_info->Value = 0; /* FIXME */
404 sym_info->Address = 0; /* FIXME */
405 sym_info->Register = 0; /* FIXME */
406 sym_info->Scope = 0; /* FIXME */
407 sym_info->Tag = type->tag;
408 tmp = symt_get_name(type);
411 sym_info->NameLen = min(strlen(tmp),sym_info->MaxNameLen-1);
412 memcpy(sym_info->Name, tmp, sym_info->NameLen);
413 sym_info->Name[sym_info->NameLen] = '\0';
416 sym_info->Name[sym_info->NameLen = 0] = '\0';
417 if (!EnumSymbolsCallback(sym_info, sym_info->Size, UserContext)) break;
422 /******************************************************************
425 * Retrieves inforamtion about a symt (either symbol or type)
427 BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req,
432 if (!type) return FALSE;
434 /* helper to typecast pInfo to its expected type (_t) */
435 #define X(_t) (*((_t*)pInfo))
439 case TI_FINDCHILDREN:
441 const struct vector* v;
444 TI_FINDCHILDREN_PARAMS* tifp = pInfo;
448 case SymTagUDT: v = &((const struct symt_udt*)type)->vchildren; break;
449 case SymTagEnum: v = &((const struct symt_enum*)type)->vchildren; break;
450 case SymTagFunctionType: v = &((const struct symt_function_signature*)type)->vchildren; break;
451 case SymTagFunction: v = &((const struct symt_function*)type)->vchildren; break;
453 FIXME("Unsupported sym-tag %s for find-children\n",
454 symt_get_tag_str(type->tag));
457 for (i = 0; i < tifp->Count; i++)
459 if (!(pt = vector_at(v, tifp->Start + i))) return FALSE;
460 tifp->ChildId[i] = (DWORD)*pt;
469 switch (((const struct symt_data*)type)->kind)
472 case DataIsFileStatic:
473 X(ULONG64) = ((const struct symt_data*)type)->u.address;
475 default: return FALSE;
479 X(ULONG64) = ((const struct symt_function*)type)->address;
481 case SymTagPublicSymbol:
482 X(ULONG64) = ((const struct symt_public*)type)->address;
484 case SymTagFuncDebugStart:
485 case SymTagFuncDebugEnd:
487 X(ULONG64) = ((const struct symt_function_point*)type)->parent->address +
488 ((const struct symt_function_point*)type)->offset;
491 X(ULONG64) = ((const struct symt_thunk*)type)->address;
493 case SymTagCompiland:
494 X(ULONG64) = ((const struct symt_compiland*)type)->address;
497 FIXME("Unsupported sym-tag %s for get-address\n",
498 symt_get_tag_str(type->tag));
503 case TI_GET_BASETYPE:
507 X(DWORD) = ((const struct symt_basic*)type)->bt;
517 case TI_GET_BITPOSITION:
518 if (type->tag != SymTagData ||
519 ((const struct symt_data*)type)->kind != DataIsMember ||
520 ((const struct symt_data*)type)->u.s.length == 0)
522 X(DWORD) = ((const struct symt_data*)type)->u.s.offset & 7;
525 case TI_GET_CHILDRENCOUNT:
529 X(DWORD) = vector_length(&((const struct symt_udt*)type)->vchildren);
532 X(DWORD) = vector_length(&((const struct symt_enum*)type)->vchildren);
534 case SymTagFunctionType:
535 X(DWORD) = vector_length(&((const struct symt_function_signature*)type)->vchildren);
538 X(DWORD) = vector_length(&((const struct symt_function*)type)->vchildren);
540 case SymTagPointerType: /* MS does it that way */
541 case SymTagArrayType: /* MS does it that way */
542 case SymTagThunk: /* MS does it that way */
546 FIXME("Unsupported sym-tag %s for get-children-count\n",
547 symt_get_tag_str(type->tag));
550 case SymTagPublicSymbol:
559 case SymTagArrayType:
560 X(DWORD) = ((const struct symt_array*)type)->end -
561 ((const struct symt_array*)type)->start + 1;
563 case SymTagFunctionType:
564 /* this seems to be wrong for (future) C++ methods, where 'this' parameter
565 * should be included in this value (and not in GET_CHILDREN_COUNT)
567 X(DWORD) = vector_length(&((const struct symt_function_signature*)type)->vchildren);
569 default: return FALSE;
573 case TI_GET_DATAKIND:
574 if (type->tag != SymTagData) return FALSE;
575 X(DWORD) = ((const struct symt_data*)type)->kind;
582 X(DWORD64) = ((const struct symt_basic*)type)->size;
585 X(DWORD64) = ((const struct symt_function*)type)->size;
587 case SymTagPointerType:
588 X(DWORD64) = sizeof(void*);
591 X(DWORD64) = ((const struct symt_udt*)type)->size;
594 X(DWORD64) = sizeof(int); /* FIXME: should be size of base-type of enum !!! */
597 if (((const struct symt_data*)type)->kind != DataIsMember ||
598 !((const struct symt_data*)type)->u.s.length)
600 X(DWORD64) = ((const struct symt_data*)type)->u.s.length;
602 case SymTagArrayType:
603 if (!symt_get_info(((const struct symt_array*)type)->base_type,
604 TI_GET_LENGTH, pInfo))
606 X(DWORD64) *= ((const struct symt_array*)type)->end -
607 ((const struct symt_array*)type)->start + 1;
609 case SymTagPublicSymbol:
610 X(DWORD64) = ((const struct symt_public*)type)->size;
613 return symt_get_info(((const struct symt_typedef*)type)->type, TI_GET_LENGTH, pInfo);
615 X(DWORD64) = ((const struct symt_thunk*)type)->size;
618 FIXME("Unsupported sym-tag %s for get-length\n",
619 symt_get_tag_str(type->tag));
621 case SymTagFunctionType:
626 case TI_GET_LEXICALPARENT:
630 X(DWORD) = (DWORD)((const struct symt_block*)type)->container;
633 X(DWORD) = (DWORD)((const struct symt_data*)type)->container;
636 X(DWORD) = (DWORD)((const struct symt_function*)type)->container;
639 X(DWORD) = (DWORD)((const struct symt_thunk*)type)->container;
641 case SymTagFunctionArgType:
642 X(DWORD) = (DWORD)((const struct symt_function_arg_type*)type)->container;
645 FIXME("Unsupported sym-tag %s for get-lexical-parent\n",
646 symt_get_tag_str(type->tag));
667 switch (((const struct symt_data*)type)->kind)
672 X(ULONG) = ((const struct symt_data*)type)->u.s.offset >> 3;
675 FIXME("Unknown kind (%u) for get-offset\n",
676 ((const struct symt_data*)type)->kind);
681 FIXME("Unsupported sym-tag %s for get-offset\n",
682 symt_get_tag_str(type->tag));
689 const char* name = symt_get_name(type);
690 if (!name) return FALSE;
691 len = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0);
692 X(WCHAR*) = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
693 if (!X(WCHAR*)) return FALSE;
694 MultiByteToWideChar(CP_ACP, 0, name, -1, X(WCHAR*), len);
699 X(DWORD) = type->tag;
706 /* hierarchical => hierarchical */
707 case SymTagArrayType:
708 X(DWORD) = (DWORD)((const struct symt_array*)type)->base_type;
710 case SymTagPointerType:
711 X(DWORD) = (DWORD)((const struct symt_pointer*)type)->pointsto;
713 case SymTagFunctionType:
714 X(DWORD) = (DWORD)((const struct symt_function_signature*)type)->rettype;
717 X(DWORD) = (DWORD)((const struct symt_typedef*)type)->type;
719 /* lexical => hierarchical */
721 X(DWORD) = (DWORD)((const struct symt_data*)type)->type;
724 X(DWORD) = (DWORD)((const struct symt_function*)type)->type;
726 /* FIXME: should also work for enums */
727 case SymTagFunctionArgType:
728 X(DWORD) = (DWORD)((const struct symt_function_arg_type*)type)->arg_type;
731 FIXME("Unsupported sym-tag %s for get-type\n",
732 symt_get_tag_str(type->tag));
733 case SymTagPublicSymbol:
740 if (type->tag != SymTagUDT) return FALSE;
741 X(DWORD) = ((const struct symt_udt*)type)->kind;
745 if (type->tag != SymTagData || ((const struct symt_data*)type)->kind != DataIsConstant)
747 X(VARIANT) = ((const struct symt_data*)type)->u.value;
750 case TI_GET_CALLING_CONVENTION:
751 if (type->tag != SymTagFunctionType) return FALSE;
752 if (((const struct symt_function_signature*)type)->call_conv == -1)
754 FIXME("No support for calling convention for this signature\n");
755 X(DWORD) = CV_CALL_FAR_C; /* FIXME */
757 else X(DWORD) = ((const struct symt_function_signature*)type)->call_conv;
759 case TI_GET_ARRAYINDEXTYPEID:
760 if (type->tag != SymTagArrayType) return FALSE;
761 X(DWORD) = (DWORD)((const struct symt_array*)type)->index_type;
766 case TI_GET_ADDRESSOFFSET:
767 case TI_GET_CLASSPARENTID:
768 case TI_GET_SYMINDEX:
769 case TI_GET_THISADJUST:
770 case TI_GET_VIRTUALBASECLASS:
771 case TI_GET_VIRTUALBASEPOINTEROFFSET:
772 case TI_GET_VIRTUALTABLESHAPEID:
774 FIXME("Unsupported GetInfo request (%u)\n", req);
777 FIXME("Unknown GetInfo request (%u)\n", req);
784 /******************************************************************
785 * SymGetTypeInfo (DBGHELP.@)
788 BOOL WINAPI SymGetTypeInfo(HANDLE hProcess, DWORD64 ModBase,
789 ULONG TypeId, IMAGEHLP_SYMBOL_TYPE_INFO GetType,
792 struct module_pair pair;
794 pair.pcs = process_find_by_handle(hProcess);
795 if (!pair.pcs) return FALSE;
797 pair.requested = module_find_by_addr(pair.pcs, ModBase, DMT_UNKNOWN);
798 if (!module_get_debug(&pair))
800 FIXME("Someone didn't properly set ModBase (%s)\n", wine_dbgstr_longlong(ModBase));
804 return symt_get_info((struct symt*)TypeId, GetType, pInfo);
807 /******************************************************************
808 * SymGetTypeFromName (DBGHELP.@)
811 BOOL WINAPI SymGetTypeFromName(HANDLE hProcess, ULONG64 BaseOfDll,
812 PCSTR Name, PSYMBOL_INFO Symbol)
814 struct process* pcs = process_find_by_handle(hProcess);
815 struct module* module;
818 if (!pcs) return FALSE;
819 module = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN);
820 if (!module) return FALSE;
821 type = symt_find_type_by_name(module, SymTagNull, Name);
822 if (!type) return FALSE;
823 Symbol->TypeIndex = (DWORD)type;