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