?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
shell32: Create dynamic buffers for expanded enviroment strings to allow for paramete...
[wine/wine-kai.git] / dlls / dbghelp / type.c
blobf967f9a8ec31e964daef2ee2ce077974fbabb2d8
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.ModuleName, 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 p = NULL;
217 while ((p = vector_iter_up(&udt_type->vchildren, p)))
218 {
219 m = (struct symt_data*)*p;
220 assert(m);
221 assert(m->symt.tag == SymTagData);
222 if (m->hash_elt.name[0] == name[0] && strcmp(m->hash_elt.name, name) == 0)
223 return TRUE;
224 }
225
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;
231
232 m->kind = DataIsMember;
233 m->container = &udt_type->symt;
234 m->type = elt_type;
235 m->u.s.offset = offset;
236 m->u.s.length = ((offset & 7) || (size & 7)) ? size : 0;
237 m->u.s.reg_id = 0;
238 p = vector_add(&udt_type->vchildren, &module->pool);
239 *p = &m->symt;
240
241 return TRUE;
242 }
243
244 struct symt_enum* symt_new_enum(struct module* module, const char* typename)
245 {
246 struct symt_enum* sym;
247
248 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
249 {
250 sym->symt.tag = SymTagEnum;
251 sym->name = (typename) ? pool_strdup(&module->pool, typename) : NULL;
252 vector_init(&sym->vchildren, sizeof(struct symt*), 8);
253 }
254 return sym;
255 }
256
257 BOOL symt_add_enum_element(struct module* module, struct symt_enum* enum_type,
258 const char* name, int value)
259 {
260 struct symt_data* e;
261 struct symt** p;
262
263 assert(enum_type->symt.tag == SymTagEnum);
264 e = pool_alloc(&module->pool, sizeof(*e));
265 if (e == NULL) return FALSE;
266
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;
276
277 p = vector_add(&enum_type->vchildren, &module->pool);
278 if (!p) return FALSE; /* FIXME we leak e */
279 *p = &e->symt;
280
281 return TRUE;
282 }
283
284 struct symt_array* symt_new_array(struct module* module, int min, int max,
285 struct symt* base, struct symt* index)
286 {
287 struct symt_array* sym;
288
289 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
290 {
291 sym->symt.tag = SymTagArrayType;
292 sym->start = min;
293 sym->end = max;
294 sym->base_type = base;
295 sym->index_type = index;
296 symt_add_type(module, &sym->symt);
297 }
298 return sym;
299 }
300
301 struct symt_function_signature* symt_new_function_signature(struct module* module,
302 struct symt* ret_type,
303 enum CV_call_e call_conv)
304 {
305 struct symt_function_signature* sym;
306
307 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
308 {
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);
314 }
315 return sym;
316 }
317
318 BOOL symt_add_function_signature_parameter(struct module* module,
319 struct symt_function_signature* sig_type,
320 struct symt* param)
321 {
322 struct symt** p;
323 struct symt_function_arg_type* arg;
324
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 */
333 *p = &arg->symt;
334
335 return TRUE;
336 }
337
338 struct symt_pointer* symt_new_pointer(struct module* module, struct symt* ref_type)
339 {
340 struct symt_pointer* sym;
341
342 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
343 {
344 sym->symt.tag = SymTagPointerType;
345 sym->pointsto = ref_type;
346 symt_add_type(module, &sym->symt);
347 }
348 return sym;
349 }
350
351 struct symt_typedef* symt_new_typedef(struct module* module, struct symt* ref,
352 const char* name)
353 {
354 struct symt_typedef* sym;
355
356 if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
357 {
358 sym->symt.tag = SymTagTypedef;
359 sym->type = ref;
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);
363 }
364 return sym;
365 }
366
367 /******************************************************************
368 * SymEnumTypes (DBGHELP.@)
369 *
370 */
371 BOOL WINAPI SymEnumTypes(HANDLE hProcess, ULONG64 BaseOfDll,
372 PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
373 PVOID UserContext)
374 {
375 struct process* pcs;
376 struct module_pair pair;
377 char buffer[sizeof(SYMBOL_INFO) + 256];
378 SYMBOL_INFO* sym_info = (SYMBOL_INFO*)buffer;
379 const char* tmp;
380 struct symt* type;
381 void* pos = NULL;
382 DWORD64 size;
383
384 TRACE("(%p %s %p %p)\n",
385 hProcess, wine_dbgstr_longlong(BaseOfDll), EnumSymbolsCallback,
386 UserContext);
387
388 if (!(pcs = process_find_by_handle(hProcess))) return FALSE;
389 pair.requested = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN);
390 if (!module_get_debug(pcs, &pair)) return FALSE;
391
392 sym_info->SizeOfStruct = sizeof(SYMBOL_INFO);
393 sym_info->MaxNameLen = sizeof(buffer) - sizeof(SYMBOL_INFO);
394
395 while ((pos = vector_iter_up(&pair.effective->vtypes, pos)))
396 {
397 type = *(struct symt**)pos;
398 sym_info->TypeIndex = (DWORD)type;
399 sym_info->info = 0; /* FIXME */
400 symt_get_info(type, TI_GET_LENGTH, &size);
401 sym_info->Size = size;
402 sym_info->ModBase = pair.requested->module.BaseOfImage;
403 sym_info->Flags = 0; /* FIXME */
404 sym_info->Value = 0; /* FIXME */
405 sym_info->Address = 0; /* FIXME */
406 sym_info->Register = 0; /* FIXME */
407 sym_info->Scope = 0; /* FIXME */
408 sym_info->Tag = type->tag;
409 tmp = symt_get_name(type);
410 if (tmp)
411 {
412 sym_info->NameLen = min(strlen(tmp),sym_info->MaxNameLen-1);
413 memcpy(sym_info->Name, tmp, sym_info->NameLen);
414 sym_info->Name[sym_info->NameLen] = '\0';
415 }
416 else
417 sym_info->Name[sym_info->NameLen = 0] = '\0';
418 if (!EnumSymbolsCallback(sym_info, sym_info->Size, UserContext)) break;
419 }
420 return TRUE;
421 }
422
423 /******************************************************************
424 * symt_get_info
425 *
426 * Retrieves inforamtion about a symt (either symbol or type)
427 */
428 BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req,
429 void* pInfo)
430 {
431 unsigned len;
432
433 if (!type) return FALSE;
434
435 /* helper to typecast pInfo to its expected type (_t) */
436 #define X(_t) (*((_t*)pInfo))
437
438 switch (req)
439 {
440 case TI_FINDCHILDREN:
441 {
442 const struct vector* v;
443 struct symt** pt;
444 unsigned i;
445 TI_FINDCHILDREN_PARAMS* tifp = pInfo;
446
447 switch (type->tag)
448 {
449 case SymTagUDT: v = &((const struct symt_udt*)type)->vchildren; break;
450 case SymTagEnum: v = &((const struct symt_enum*)type)->vchildren; break;
451 case SymTagFunctionType: v = &((const struct symt_function_signature*)type)->vchildren; break;
452 case SymTagFunction: v = &((const struct symt_function*)type)->vchildren; break;
453 default:
454 FIXME("Unsupported sym-tag %s for find-children\n",
455 symt_get_tag_str(type->tag));
456 return FALSE;
457 }
458 for (i = 0; i < tifp->Count; i++)
459 {
460 if (!(pt = vector_at(v, tifp->Start + i))) return FALSE;
461 tifp->ChildId[i] = (DWORD)*pt;
462 }
463 }
464 break;
465
466 case TI_GET_ADDRESS:
467 switch (type->tag)
468 {
469 case SymTagData:
470 switch (((const struct symt_data*)type)->kind)
471 {
472 case DataIsGlobal:
473 case DataIsFileStatic:
474 X(ULONG64) = ((const struct symt_data*)type)->u.address;
475 break;
476 default: return FALSE;
477 }
478 break;
479 case SymTagFunction:
480 X(ULONG64) = ((const struct symt_function*)type)->address;
481 break;
482 case SymTagPublicSymbol:
483 X(ULONG64) = ((const struct symt_public*)type)->address;
484 break;
485 case SymTagFuncDebugStart:
486 case SymTagFuncDebugEnd:
487 case SymTagLabel:
488 X(ULONG64) = ((const struct symt_function_point*)type)->parent->address +
489 ((const struct symt_function_point*)type)->offset;
490 break;
491 case SymTagThunk:
492 X(ULONG64) = ((const struct symt_thunk*)type)->address;
493 break;
494 default:
495 FIXME("Unsupported sym-tag %s for get-address\n",
496 symt_get_tag_str(type->tag));
497 return FALSE;
498 }
499 break;
500
501 case TI_GET_BASETYPE:
502 switch (type->tag)
503 {
504 case SymTagBaseType:
505 X(DWORD) = ((const struct symt_basic*)type)->bt;
506 break;
507 case SymTagEnum:
508 X(DWORD) = btInt;
509 break;
510 default:
511 return FALSE;
512 }
513 break;
514
515 case TI_GET_BITPOSITION:
516 if (type->tag != SymTagData ||
517 ((const struct symt_data*)type)->kind != DataIsMember ||
518 ((const struct symt_data*)type)->u.s.length == 0)
519 return FALSE;
520 X(DWORD) = ((const struct symt_data*)type)->u.s.offset & 7;
521 break;
522
523 case TI_GET_CHILDRENCOUNT:
524 switch (type->tag)
525 {
526 case SymTagUDT:
527 X(DWORD) = vector_length(&((const struct symt_udt*)type)->vchildren);
528 break;
529 case SymTagEnum:
530 X(DWORD) = vector_length(&((const struct symt_enum*)type)->vchildren);
531 break;
532 case SymTagFunctionType:
533 X(DWORD) = vector_length(&((const struct symt_function_signature*)type)->vchildren);
534 break;
535 case SymTagFunction:
536 X(DWORD) = vector_length(&((const struct symt_function*)type)->vchildren);
537 break;
538 case SymTagPointerType: /* MS does it that way */
539 case SymTagArrayType: /* MS does it that way */
540 case SymTagThunk: /* MS does it that way */
541 X(DWORD) = 0;
542 break;
543 default:
544 FIXME("Unsupported sym-tag %s for get-children-count\n",
545 symt_get_tag_str(type->tag));
546 /* fall through */
547 case SymTagData:
548 case SymTagPublicSymbol:
549 case SymTagBaseType:
550 return FALSE;
551 }
552 break;
553
554 case TI_GET_COUNT:
555 switch (type->tag)
556 {
557 case SymTagArrayType:
558 X(DWORD) = ((const struct symt_array*)type)->end -
559 ((const struct symt_array*)type)->start + 1;
560 break;
561 case SymTagFunctionType:
562 /* this seems to be wrong for (future) C++ methods, where 'this' parameter
563 * should be included in this value (and not in GET_CHILDREN_COUNT)
564 */
565 X(DWORD) = vector_length(&((const struct symt_function_signature*)type)->vchildren);
566 break;
567 default: return FALSE;
568 }
569 break;
570
571 case TI_GET_DATAKIND:
572 if (type->tag != SymTagData) return FALSE;
573 X(DWORD) = ((const struct symt_data*)type)->kind;
574 break;
575
576 case TI_GET_LENGTH:
577 switch (type->tag)
578 {
579 case SymTagBaseType:
580 X(DWORD64) = ((const struct symt_basic*)type)->size;
581 break;
582 case SymTagFunction:
583 X(DWORD64) = ((const struct symt_function*)type)->size;
584 break;
585 case SymTagPointerType:
586 X(DWORD64) = sizeof(void*);
587 break;
588 case SymTagUDT:
589 X(DWORD64) = ((const struct symt_udt*)type)->size;
590 break;
591 case SymTagEnum:
592 X(DWORD64) = sizeof(int); /* FIXME: should be size of base-type of enum !!! */
593 break;
594 case SymTagData:
595 if (((const struct symt_data*)type)->kind != DataIsMember ||
596 !((const struct symt_data*)type)->u.s.length)
597 return FALSE;
598 X(DWORD64) = ((const struct symt_data*)type)->u.s.length;
599 break;
600 case SymTagArrayType:
601 if (!symt_get_info(((const struct symt_array*)type)->base_type,
602 TI_GET_LENGTH, pInfo))
603 return FALSE;
604 X(DWORD64) *= ((const struct symt_array*)type)->end -
605 ((const struct symt_array*)type)->start + 1;
606 break;
607 case SymTagPublicSymbol:
608 X(DWORD64) = ((const struct symt_public*)type)->size;
609 break;
610 case SymTagTypedef:
611 return symt_get_info(((const struct symt_typedef*)type)->type, TI_GET_LENGTH, pInfo);
612 case SymTagThunk:
613 X(DWORD64) = ((const struct symt_thunk*)type)->size;
614 break;
615 default:
616 FIXME("Unsupported sym-tag %s for get-length\n",
617 symt_get_tag_str(type->tag));
618 /* fall through */
619 case SymTagFunctionType:
620 return 0;
621 }
622 break;
623
624 case TI_GET_LEXICALPARENT:
625 switch (type->tag)
626 {
627 case SymTagBlock:
628 X(DWORD) = (DWORD)((const struct symt_block*)type)->container;
629 break;
630 case SymTagData:
631 X(DWORD) = (DWORD)((const struct symt_data*)type)->container;
632 break;
633 case SymTagFunction:
634 X(DWORD) = (DWORD)((const struct symt_function*)type)->container;
635 break;
636 case SymTagThunk:
637 X(DWORD) = (DWORD)((const struct symt_thunk*)type)->container;
638 break;
639 case SymTagFunctionArgType:
640 X(DWORD) = (DWORD)((const struct symt_function_arg_type*)type)->container;
641 break;
642 default:
643 FIXME("Unsupported sym-tag %s for get-lexical-parent\n",
644 symt_get_tag_str(type->tag));
645 return FALSE;
646 }
647 break;
648
649 case TI_GET_NESTED:
650 switch (type->tag)
651 {
652 case SymTagUDT:
653 case SymTagEnum:
654 X(DWORD) = 0;
655 break;
656 default:
657 return FALSE;
658 }
659 break;
660
661 case TI_GET_OFFSET:
662 switch (type->tag)
663 {
664 case SymTagData:
665 switch (((const struct symt_data*)type)->kind)
666 {
667 case DataIsParam:
668 case DataIsLocal:
669 case DataIsMember:
670 X(ULONG) = ((const struct symt_data*)type)->u.s.offset >> 3;
671 break;
672 default:
673 FIXME("Unknown kind (%u) for get-offset\n",
674 ((const struct symt_data*)type)->kind);
675 return FALSE;
676 }
677 break;
678 default:
679 FIXME("Unsupported sym-tag %s for get-offset\n",
680 symt_get_tag_str(type->tag));
681 return FALSE;
682 }
683 break;
684
685 case TI_GET_SYMNAME:
686 {
687 const char* name = symt_get_name(type);
688 if (!name) return FALSE;
689 len = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0);
690 X(WCHAR*) = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
691 if (!X(WCHAR*)) return FALSE;
692 MultiByteToWideChar(CP_ACP, 0, name, -1, X(WCHAR*), len);
693 }
694 break;
695
696 case TI_GET_SYMTAG:
697 X(DWORD) = type->tag;
698 break;
699
700 case TI_GET_TYPE:
701 case TI_GET_TYPEID:
702 switch (type->tag)
703 {
704 /* hierarchical => hierarchical */
705 case SymTagArrayType:
706 X(DWORD) = (DWORD)((const struct symt_array*)type)->base_type;
707 break;
708 case SymTagPointerType:
709 X(DWORD) = (DWORD)((const struct symt_pointer*)type)->pointsto;
710 break;
711 case SymTagFunctionType:
712 X(DWORD) = (DWORD)((const struct symt_function_signature*)type)->rettype;
713 break;
714 case SymTagTypedef:
715 X(DWORD) = (DWORD)((const struct symt_typedef*)type)->type;
716 break;
717 /* lexical => hierarchical */
718 case SymTagData:
719 X(DWORD) = (DWORD)((const struct symt_data*)type)->type;
720 break;
721 case SymTagFunction:
722 X(DWORD) = (DWORD)((const struct symt_function*)type)->type;
723 break;
724 /* FIXME: should also work for enums */
725 case SymTagFunctionArgType:
726 X(DWORD) = (DWORD)((const struct symt_function_arg_type*)type)->arg_type;
727 break;
728 default:
729 FIXME("Unsupported sym-tag %s for get-type\n",
730 symt_get_tag_str(type->tag));
731 case SymTagPublicSymbol:
732 case SymTagThunk:
733 return FALSE;
734 }
735 break;
736
737 case TI_GET_UDTKIND:
738 if (type->tag != SymTagUDT) return FALSE;
739 X(DWORD) = ((const struct symt_udt*)type)->kind;
740 break;
741
742 case TI_GET_VALUE:
743 if (type->tag != SymTagData || ((const struct symt_data*)type)->kind != DataIsConstant)
744 return FALSE;
745 X(VARIANT) = ((const struct symt_data*)type)->u.value;
746 break;
747
748 case TI_GET_CALLING_CONVENTION:
749 if (type->tag != SymTagFunctionType) return FALSE;
750 if (((const struct symt_function_signature*)type)->call_conv == -1)
751 {
752 FIXME("No support for calling convention for this signature\n");
753 X(DWORD) = CV_CALL_FAR_C; /* FIXME */
754 }
755 else X(DWORD) = ((const struct symt_function_signature*)type)->call_conv;
756 break;
757 case TI_GET_ARRAYINDEXTYPEID:
758 if (type->tag != SymTagArrayType) return FALSE;
759 X(DWORD) = (DWORD)((const struct symt_array*)type)->index_type;
760 break;
761
762 #undef X
763
764 case TI_GET_ADDRESSOFFSET:
765 case TI_GET_CLASSPARENTID:
766 case TI_GET_SYMINDEX:
767 case TI_GET_THISADJUST:
768 case TI_GET_VIRTUALBASECLASS:
769 case TI_GET_VIRTUALBASEPOINTEROFFSET:
770 case TI_GET_VIRTUALTABLESHAPEID:
771 case TI_IS_EQUIV_TO:
772 FIXME("Unsupported GetInfo request (%u)\n", req);
773 return FALSE;
774 default:
775 FIXME("Unknown GetInfo request (%u)\n", req);
776 return FALSE;
777 }
778
779 return TRUE;
780 }
781
782 /******************************************************************
783 * SymGetTypeInfo (DBGHELP.@)
784 *
785 */
786 BOOL WINAPI SymGetTypeInfo(HANDLE hProcess, DWORD64 ModBase,
787 ULONG TypeId, IMAGEHLP_SYMBOL_TYPE_INFO GetType,
788 PVOID pInfo)
789 {
790 struct process* pcs = process_find_by_handle(hProcess);
791 struct module_pair pair;
792
793 if (!pcs) return FALSE;
794
795 pair.requested = module_find_by_addr(pcs, ModBase, DMT_UNKNOWN);
796 if (!module_get_debug(pcs, &pair))
797 {
798 FIXME("Someone didn't properly set ModBase (%s)\n", wine_dbgstr_longlong(ModBase));
799 return FALSE;
800 }
801
802 return symt_get_info((struct symt*)TypeId, GetType, pInfo);
803 }
804
805 /******************************************************************
806 * SymGetTypeFromName (DBGHELP.@)
807 *
808 */
809 BOOL WINAPI SymGetTypeFromName(HANDLE hProcess, ULONG64 BaseOfDll,
810 PCSTR Name, PSYMBOL_INFO Symbol)
811 {
812 struct process* pcs = process_find_by_handle(hProcess);
813 struct module* module;
814 struct symt* type;
815
816 if (!pcs) return FALSE;
817 module = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN);
818 if (!module) return FALSE;
819 type = symt_find_type_by_name(module, SymTagNull, Name);
820 if (!type) return FALSE;
821 Symbol->TypeIndex = (DWORD)type;
822
823 return TRUE;
824 }
Work in progress by Kai Blin