git.oblomov.eu Git - wine/blob - dlls/dbghelp/type.c

   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 }