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