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 #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 "winnls.h"
  32 #include "wine/debug.h"
  33 #include "dbghelp_private.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
  36 WINE_DECLARE_DEBUG_CHANNEL(dbghelp_symt);
  37
  38 static const char* symt_get_tag_str(DWORD tag)
  39 {
  40     switch (tag)
  41     {
  42     case SymTagNull:                    return "SymTagNull";
  43     case SymTagExe:                     return "SymTagExe";
  44     case SymTagCompiland:               return "SymTagCompiland";
  45     case SymTagCompilandDetails:        return "SymTagCompilandDetails";
  46     case SymTagCompilandEnv:            return "SymTagCompilandEnv";
  47     case SymTagFunction:                return "SymTagFunction";
  48     case SymTagBlock:                   return "SymTagBlock";
  49     case SymTagData:                    return "SymTagData";
  50     case SymTagAnnotation:              return "SymTagAnnotation";
  51     case SymTagLabel:                   return "SymTagLabel";
  52     case SymTagPublicSymbol:            return "SymTagPublicSymbol";
  53     case SymTagUDT:                     return "SymTagUDT";
  54     case SymTagEnum:                    return "SymTagEnum";
  55     case SymTagFunctionType:            return "SymTagFunctionType";
  56     case SymTagPointerType:             return "SymTagPointerType";
  57     case SymTagArrayType:               return "SymTagArrayType";
  58     case SymTagBaseType:                return "SymTagBaseType";
  59     case SymTagTypedef:                 return "SymTagTypedef,";
  60     case SymTagBaseClass:               return "SymTagBaseClass";
  61     case SymTagFriend:                  return "SymTagFriend";
  62     case SymTagFunctionArgType:         return "SymTagFunctionArgType,";
  63     case SymTagFuncDebugStart:          return "SymTagFuncDebugStart,";
  64     case SymTagFuncDebugEnd:            return "SymTagFuncDebugEnd";
  65     case SymTagUsingNamespace:          return "SymTagUsingNamespace,";
  66     case SymTagVTableShape:             return "SymTagVTableShape";
  67     case SymTagVTable:                  return "SymTagVTable";
  68     case SymTagCustom:                  return "SymTagCustom";
  69     case SymTagThunk:                   return "SymTagThunk";
  70     case SymTagCustomType:              return "SymTagCustomType";
  71     case SymTagManagedType:             return "SymTagManagedType";
  72     case SymTagDimension:               return "SymTagDimension";
  73     default:                            return "---";
  74     }
  75 }
  76
  77 const char* symt_get_name(const struct symt* sym)
  78 {
  79     switch (sym->tag)
  80     {
  81     /* lexical tree */
  82     case SymTagData:            return ((const struct symt_data*)sym)->hash_elt.name;
  83     case SymTagFunction:        return ((const struct symt_function*)sym)->hash_elt.name;
  84     case SymTagPublicSymbol:    return ((const struct symt_public*)sym)->hash_elt.name;
  85     case SymTagBaseType:        return ((const struct symt_basic*)sym)->hash_elt.name;
  86     case SymTagLabel:           return ((const struct symt_hierarchy_point*)sym)->hash_elt.name;
  87     case SymTagThunk:           return ((const struct symt_thunk*)sym)->hash_elt.name;
  88     /* hierarchy tree */
  89     case SymTagEnum:            return ((const struct symt_enum*)sym)->name;
  90     case SymTagTypedef:         return ((const struct symt_typedef*)sym)->hash_elt.name;
  91     case SymTagUDT:             return ((const struct symt_udt*)sym)->hash_elt.name;
  92     default:
  93         FIXME("Unsupported sym-tag %s\n", symt_get_tag_str(sym->tag));
  94         /* fall through */
  95     case SymTagArrayType:
  96     case SymTagPointerType:
  97     case SymTagFunctionType:
  98         return NULL;
  99     }
 100 }
 101
 102 static struct symt* symt_find_type_by_name(const struct module* module,
 103                                            enum SymTagEnum sym_tag,
 104                                            const char* typename)
 105 {
 106     void*                       ptr;
 107     struct symt_ht*             type;
 108     struct hash_table_iter      hti;
 109
 110     assert(typename);
 111     assert(module);
 112
 113     hash_table_iter_init(&module->ht_types, &hti, typename);
 114     while ((ptr = hash_table_iter_up(&hti)))
 115     {
 116         type = GET_ENTRY(ptr, struct symt_ht, hash_elt);
 117
 118         if ((sym_tag == SymTagNull || type->symt.tag == sym_tag) &&
 119             type->hash_elt.name && !strcmp(type->hash_elt.name, typename))
 120             return &type->symt;
 121     }
 122     SetLastError(ERROR_INVALID_NAME); /* FIXME ?? */
 123     return NULL;
 124 }
 125
 126 static void symt_add_type(struct module* module, struct symt* symt)
 127 {
 128     struct symt**       p;
 129     p = vector_add(&module->vtypes, &module->pool);
 130     assert(p);
 131     *p = symt;
 132 }
 133
 134 struct symt_basic* symt_new_basic(struct module* module, enum BasicType bt,
 135                                   const char* typename, unsigned size)
 136 {
 137     struct symt_basic*          sym;
 138
 139     if (typename)
 140     {
 141         sym = (struct symt_basic*)symt_find_type_by_name(module, SymTagBaseType,
 142                                                          typename);
 143         if (sym && sym->bt == bt && sym->size == size)
 144             return sym;
 145     }
 146     if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
 147     {
 148         sym->symt.tag = SymTagBaseType;
 149         if (typename)
 150         {
 151             sym->hash_elt.name = pool_strdup(&module->pool, typename);
 152             hash_table_add(&module->ht_types, &sym->hash_elt);
 153         } else sym->hash_elt.name = NULL;
 154         sym->bt = bt;
 155         sym->size = size;
 156         symt_add_type(module, &sym->symt);
 157     }
 158     return sym;
 159 }
 160
 161 struct symt_udt* symt_new_udt(struct module* module, const char* typename,
 162                               unsigned size, enum UdtKind kind)
 163 {
 164     struct symt_udt*            sym;
 165
 166     TRACE_(dbghelp_symt)("Adding udt %s:%s\n",
 167                          debugstr_w(module->module.ModuleName), typename);
 168     if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
 169     {
 170         sym->symt.tag = SymTagUDT;
 171         sym->kind     = kind;
 172         sym->size     = size;
 173         if (typename)
 174         {
 175             sym->hash_elt.name = pool_strdup(&module->pool, typename);
 176             hash_table_add(&module->ht_types, &sym->hash_elt);
 177         } else sym->hash_elt.name = NULL;
 178         vector_init(&sym->vchildren, sizeof(struct symt*), 8);
 179         symt_add_type(module, &sym->symt);
 180     }
 181     return sym;
 182 }
 183
 184 BOOL symt_set_udt_size(struct module* module, struct symt_udt* udt, unsigned size)
 185 {
 186     assert(udt->symt.tag == SymTagUDT);
 187     if (vector_length(&udt->vchildren) != 0)
 188     {
 189         if (udt->size != size)
 190             FIXME_(dbghelp_symt)("Changing size for %s from %u to %u\n",
 191                                  udt->hash_elt.name, udt->size, size);
 192         return TRUE;
 193     }
 194     udt->size = size;
 195     return TRUE;
 196 }
 197
 198 /******************************************************************
 199  *              symt_add_udt_element
 200  *
 201  * add an element to a udt (struct, class, union)
 202  * the size & offset parameters are expressed in bits (not bytes) so that
 203  * we can mix in the single call bytes aligned elements (regular fields) and
 204  * the others (bit fields)
 205  */
 206 BOOL symt_add_udt_element(struct module* module, struct symt_udt* udt_type,
 207                           const char* name, struct symt* elt_type,
 208                           unsigned offset, unsigned size)
 209 {
 210     struct symt_data*   m;
 211     struct symt**       p;
 212
 213     assert(udt_type->symt.tag == SymTagUDT);
 214
 215     TRACE_(dbghelp_symt)("Adding %s to UDT %s\n", name, udt_type->hash_elt.name);
 216     if (name)
 217     {
 218         int    i;
 219         for (i=0; i<vector_length(&udt_type->vchildren); i++)
 220         {
 221             m = *(struct symt_data**)vector_at(&udt_type->vchildren, i);
 222             assert(m);
 223             assert(m->symt.tag == SymTagData);
 224             if (strcmp(m->hash_elt.name, name) == 0)
 225                 return TRUE;
 226         }
 227     }
 228
 229     if ((m = pool_alloc(&module->pool, sizeof(*m))) == NULL) return FALSE;
 230     memset(m, 0, sizeof(*m));
 231     m->symt.tag      = SymTagData;
 232     m->hash_elt.name = name ? pool_strdup(&module->pool, name) : "";
 233     m->hash_elt.next = NULL;
 234
 235     m->kind            = DataIsMember;
 236     m->container       = &udt_type->symt;
 237     m->type            = elt_type;
 238     m->u.member.offset = offset;
 239     m->u.member.length = ((offset & 7) || (size & 7)) ? size : 0;
 240     p = vector_add(&udt_type->vchildren, &module->pool);
 241     *p = &m->symt;
 242
 243     return TRUE;
 244 }
 245
 246 struct symt_enum* symt_new_enum(struct module* module, const char* typename,
 247                                 struct symt* basetype)
 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         sym->base_type           = basetype;
 256         vector_init(&sym->vchildren, sizeof(struct symt*), 8);
 257     }
 258     return sym;
 259 }
 260
 261 BOOL symt_add_enum_element(struct module* module, struct symt_enum* enum_type,
 262                            const char* name, int value)
 263 {
 264     struct symt_data*   e;
 265     struct symt**       p;
 266
 267     assert(enum_type->symt.tag == SymTagEnum);
 268     e = pool_alloc(&module->pool, sizeof(*e));
 269     if (e == NULL) return FALSE;
 270
 271     e->symt.tag = SymTagData;
 272     e->hash_elt.name = pool_strdup(&module->pool, name);
 273     e->hash_elt.next = NULL;
 274     e->kind = DataIsConstant;
 275     e->container = &enum_type->symt;
 276     e->type = enum_type->base_type;
 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     DWORD64             size;
 384     int                 i;
 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     for (i=0; i<vector_length(&pair.effective->vtypes); i++)
 398     {
 399         type = *(struct symt**)vector_at(&pair.effective->vtypes, i);
 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 information 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             if (!symt_get_info(((const struct symt_hierarchy_point*)type)->parent,
 523                                req, pInfo))
 524                 return FALSE;
 525             X(ULONG64) += ((const struct symt_hierarchy_point*)type)->loc.offset;
 526             break;
 527         case SymTagThunk:
 528             X(ULONG64) = ((const struct symt_thunk*)type)->address;
 529             break;
 530         case SymTagCompiland:
 531             X(ULONG64) = ((const struct symt_compiland*)type)->address;
 532             break;
 533         default:
 534             FIXME("Unsupported sym-tag %s for get-address\n",
 535                   symt_get_tag_str(type->tag));
 536             return FALSE;
 537         }
 538         break;
 539
 540     case TI_GET_BASETYPE:
 541         switch (type->tag)
 542         {
 543         case SymTagBaseType:
 544             X(DWORD) = ((const struct symt_basic*)type)->bt;
 545             break;
 546         case SymTagEnum:
 547             X(DWORD) = btInt;
 548             break;
 549         default:
 550             return FALSE;
 551         }
 552         break;
 553
 554     case TI_GET_BITPOSITION:
 555         if (type->tag == SymTagData &&
 556             ((const struct symt_data*)type)->kind == DataIsMember &&
 557             ((const struct symt_data*)type)->u.member.length != 0)
 558             X(DWORD) = ((const struct symt_data*)type)->u.member.offset & 7;
 559         else return FALSE;
 560         break;
 561
 562     case TI_GET_CHILDRENCOUNT:
 563         switch (type->tag)
 564         {
 565         case SymTagUDT:
 566             X(DWORD) = vector_length(&((const struct symt_udt*)type)->vchildren);
 567             break;
 568         case SymTagEnum:
 569             X(DWORD) = vector_length(&((const struct symt_enum*)type)->vchildren);
 570             break;
 571         case SymTagFunctionType:
 572             X(DWORD) = vector_length(&((const struct symt_function_signature*)type)->vchildren);
 573             break;
 574         case SymTagFunction:
 575             X(DWORD) = vector_length(&((const struct symt_function*)type)->vchildren);
 576             break;
 577         case SymTagPointerType: /* MS does it that way */
 578         case SymTagArrayType: /* MS does it that way */
 579         case SymTagThunk: /* MS does it that way */
 580             X(DWORD) = 0;
 581             break;
 582         default:
 583             FIXME("Unsupported sym-tag %s for get-children-count\n",
 584                   symt_get_tag_str(type->tag));
 585             /* fall through */
 586         case SymTagData:
 587         case SymTagPublicSymbol:
 588         case SymTagBaseType:
 589             return FALSE;
 590         }
 591         break;
 592
 593     case TI_GET_COUNT:
 594         switch (type->tag)
 595         {
 596         case SymTagArrayType:
 597             X(DWORD) = ((const struct symt_array*)type)->end -
 598                 ((const struct symt_array*)type)->start + 1;
 599             break;
 600         case SymTagFunctionType:
 601             /* this seems to be wrong for (future) C++ methods, where 'this' parameter
 602              * should be included in this value (and not in GET_CHILDREN_COUNT)
 603              */
 604             X(DWORD) = vector_length(&((const struct symt_function_signature*)type)->vchildren);
 605             break;
 606         default: return FALSE;
 607         }
 608         break;
 609
 610     case TI_GET_DATAKIND:
 611         if (type->tag != SymTagData) return FALSE;
 612         X(DWORD) = ((const struct symt_data*)type)->kind;
 613         break;
 614
 615     case TI_GET_LENGTH:
 616         switch (type->tag)
 617         {
 618         case SymTagBaseType:
 619             X(DWORD64) = ((const struct symt_basic*)type)->size;
 620             break;
 621         case SymTagFunction:
 622             X(DWORD64) = ((const struct symt_function*)type)->size;
 623             break;
 624         case SymTagPointerType:
 625             X(DWORD64) = sizeof(void*);
 626             break;
 627         case SymTagUDT:
 628             X(DWORD64) = ((const struct symt_udt*)type)->size;
 629             break;
 630         case SymTagEnum:
 631             X(DWORD64) = sizeof(int); /* FIXME: should be size of base-type of enum !!! */
 632             break;
 633         case SymTagData:
 634             if (((const struct symt_data*)type)->kind != DataIsMember ||
 635                 !((const struct symt_data*)type)->u.member.length)
 636                 return FALSE;
 637             X(DWORD64) = ((const struct symt_data*)type)->u.member.length;
 638             break;
 639         case SymTagArrayType:
 640             if (!symt_get_info(((const struct symt_array*)type)->base_type,
 641                                TI_GET_LENGTH, pInfo))
 642                 return FALSE;
 643             X(DWORD64) *= ((const struct symt_array*)type)->end -
 644                 ((const struct symt_array*)type)->start + 1;
 645             break;
 646         case SymTagPublicSymbol:
 647             X(DWORD64) = ((const struct symt_public*)type)->size;
 648             break;
 649         case SymTagTypedef:
 650             return symt_get_info(((const struct symt_typedef*)type)->type, TI_GET_LENGTH, pInfo);
 651         case SymTagThunk:
 652             X(DWORD64) = ((const struct symt_thunk*)type)->size;
 653             break;
 654         case SymTagLabel:
 655             X(DWORD64) = 0;
 656             break;
 657         default:
 658             FIXME("Unsupported sym-tag %s for get-length\n",
 659                   symt_get_tag_str(type->tag));
 660             /* fall through */
 661         case SymTagFunctionType:
 662             return 0;
 663         }
 664         break;
 665
 666     case TI_GET_LEXICALPARENT:
 667         switch (type->tag)
 668         {
 669         case SymTagBlock:
 670             X(DWORD) = (DWORD)((const struct symt_block*)type)->container;
 671             break;
 672         case SymTagData:
 673             X(DWORD) = (DWORD)((const struct symt_data*)type)->container;
 674             break;
 675         case SymTagFunction:
 676             X(DWORD) = (DWORD)((const struct symt_function*)type)->container;
 677             break;
 678         case SymTagThunk:
 679             X(DWORD) = (DWORD)((const struct symt_thunk*)type)->container;
 680             break;
 681         case SymTagFunctionArgType:
 682             X(DWORD) = (DWORD)((const struct symt_function_arg_type*)type)->container;
 683             break;
 684         default:
 685             FIXME("Unsupported sym-tag %s for get-lexical-parent\n",
 686                   symt_get_tag_str(type->tag));
 687             return FALSE;
 688         }
 689         break;
 690
 691     case TI_GET_NESTED:
 692         switch (type->tag)
 693         {
 694         case SymTagUDT:
 695         case SymTagEnum:
 696             X(DWORD) = 0;
 697             break;
 698         default:
 699             return FALSE;
 700         }
 701         break;
 702
 703     case TI_GET_OFFSET:
 704         switch (type->tag)
 705         {
 706         case SymTagData:
 707             switch (((const struct symt_data*)type)->kind)
 708             {
 709             case DataIsParam:
 710             case DataIsLocal:
 711                 X(ULONG) = ((const struct symt_data*)type)->u.var.offset;
 712                 break;
 713             case DataIsMember:
 714                 X(ULONG) = ((const struct symt_data*)type)->u.member.offset >> 3;
 715                 break;
 716             default:
 717                 FIXME("Unknown kind (%u) for get-offset\n",
 718                       ((const struct symt_data*)type)->kind);
 719                 return FALSE;
 720             }
 721             break;
 722         default:
 723             FIXME("Unsupported sym-tag %s for get-offset\n",
 724                   symt_get_tag_str(type->tag));
 725             return FALSE;
 726         }
 727         break;
 728
 729     case TI_GET_SYMNAME:
 730         {
 731             const char* name = symt_get_name(type);
 732             if (!name) return FALSE;
 733             len = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0);
 734             X(WCHAR*) = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 735             if (!X(WCHAR*)) return FALSE;
 736             MultiByteToWideChar(CP_ACP, 0, name, -1, X(WCHAR*), len);
 737         }
 738         break;
 739
 740     case TI_GET_SYMTAG:
 741         X(DWORD) = type->tag;
 742         break;
 743
 744     case TI_GET_TYPE:
 745     case TI_GET_TYPEID:
 746         switch (type->tag)
 747         {
 748             /* hierarchical => hierarchical */
 749         case SymTagArrayType:
 750             X(DWORD) = (DWORD)((const struct symt_array*)type)->base_type;
 751             break;
 752         case SymTagPointerType:
 753             X(DWORD) = (DWORD)((const struct symt_pointer*)type)->pointsto;
 754             break;
 755         case SymTagFunctionType:
 756             X(DWORD) = (DWORD)((const struct symt_function_signature*)type)->rettype;
 757             break;
 758         case SymTagTypedef:
 759             X(DWORD) = (DWORD)((const struct symt_typedef*)type)->type;
 760             break;
 761             /* lexical => hierarchical */
 762         case SymTagData:
 763             X(DWORD) = (DWORD)((const struct symt_data*)type)->type;
 764             break;
 765         case SymTagFunction:
 766             X(DWORD) = (DWORD)((const struct symt_function*)type)->type;
 767             break;
 768         case SymTagEnum:
 769             X(DWORD) = (DWORD)((const struct symt_enum*)type)->base_type;
 770             break;
 771         case SymTagFunctionArgType:
 772             X(DWORD) = (DWORD)((const struct symt_function_arg_type*)type)->arg_type;
 773             break;
 774         default:
 775             FIXME("Unsupported sym-tag %s for get-type\n",
 776                   symt_get_tag_str(type->tag));
 777         case SymTagPublicSymbol:
 778         case SymTagThunk:
 779         case SymTagLabel:
 780             return FALSE;
 781         }
 782         break;
 783
 784     case TI_GET_UDTKIND:
 785         if (type->tag != SymTagUDT) return FALSE;
 786         X(DWORD) = ((const struct symt_udt*)type)->kind;
 787         break;
 788
 789     case TI_GET_VALUE:
 790         if (type->tag != SymTagData || ((const struct symt_data*)type)->kind != DataIsConstant)
 791             return FALSE;
 792         X(VARIANT) = ((const struct symt_data*)type)->u.value;
 793         break;
 794
 795     case TI_GET_CALLING_CONVENTION:
 796         if (type->tag != SymTagFunctionType) return FALSE;
 797         if (((const struct symt_function_signature*)type)->call_conv == -1)
 798         {
 799             FIXME("No support for calling convention for this signature\n");
 800             X(DWORD) = CV_CALL_FAR_C; /* FIXME */
 801         }
 802         else X(DWORD) = ((const struct symt_function_signature*)type)->call_conv;
 803         break;
 804     case TI_GET_ARRAYINDEXTYPEID:
 805         if (type->tag != SymTagArrayType) return FALSE;
 806         X(DWORD) = (DWORD)((const struct symt_array*)type)->index_type;
 807         break;
 808
 809     case TI_GET_CLASSPARENTID:
 810         /* FIXME: we don't support properly C++ for now, pretend this symbol doesn't
 811          * belong to a parent class
 812          */
 813         return FALSE;
 814
 815 #undef X
 816
 817     case TI_GET_ADDRESSOFFSET:
 818     case TI_GET_SYMINDEX:
 819     case TI_GET_THISADJUST:
 820     case TI_GET_VIRTUALBASECLASS:
 821     case TI_GET_VIRTUALBASEPOINTEROFFSET:
 822     case TI_GET_VIRTUALTABLESHAPEID:
 823     case TI_IS_EQUIV_TO:
 824         FIXME("Unsupported GetInfo request (%u)\n", req);
 825         return FALSE;
 826     default:
 827         FIXME("Unknown GetInfo request (%u)\n", req);
 828         return FALSE;
 829     }
 830
 831     return TRUE;
 832 }
 833
 834 /******************************************************************
 835  *              SymGetTypeInfo (DBGHELP.@)
 836  *
 837  */
 838 BOOL WINAPI SymGetTypeInfo(HANDLE hProcess, DWORD64 ModBase,
 839                            ULONG TypeId, IMAGEHLP_SYMBOL_TYPE_INFO GetType,
 840                            PVOID pInfo)
 841 {
 842     struct module_pair  pair;
 843
 844     pair.pcs = process_find_by_handle(hProcess);
 845     if (!pair.pcs) return FALSE;
 846
 847     pair.requested = module_find_by_addr(pair.pcs, ModBase, DMT_UNKNOWN);
 848     if (!module_get_debug(&pair))
 849     {
 850         FIXME("Someone didn't properly set ModBase (%s)\n", wine_dbgstr_longlong(ModBase));
 851         return FALSE;
 852     }
 853
 854     return symt_get_info((struct symt*)TypeId, GetType, pInfo);
 855 }
 856
 857 /******************************************************************
 858  *              SymGetTypeFromName (DBGHELP.@)
 859  *
 860  */
 861 BOOL WINAPI SymGetTypeFromName(HANDLE hProcess, ULONG64 BaseOfDll,
 862                                PCSTR Name, PSYMBOL_INFO Symbol)
 863 {
 864     struct process*     pcs = process_find_by_handle(hProcess);
 865     struct module*      module;
 866     struct symt*        type;
 867
 868     if (!pcs) return FALSE;
 869     module = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN);
 870     if (!module) return FALSE;
 871     type = symt_find_type_by_name(module, SymTagNull, Name);
 872     if (!type) return FALSE;
 873     Symbol->TypeIndex = (DWORD)type;
 874
 875     return TRUE;
 876 }