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