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