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 "winreg.h"
  32 #include "winnls.h"
  33 #include "wine/debug.h"
  34 #include "dbghelp_private.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
  37 WINE_DECLARE_DEBUG_CHANNEL(dbghelp_symt);
  38
  39 static const char* symt_get_tag_str(DWORD tag)
  40 {
  41     switch (tag)
  42     {
  43     case SymTagNull:                    return "SymTagNull";
  44     case SymTagExe:                     return "SymTagExe";
  45     case SymTagCompiland:               return "SymTagCompiland";
  46     case SymTagCompilandDetails:        return "SymTagCompilandDetails";
  47     case SymTagCompilandEnv:            return "SymTagCompilandEnv";
  48     case SymTagFunction:                return "SymTagFunction";
  49     case SymTagBlock:                   return "SymTagBlock";
  50     case SymTagData:                    return "SymTagData";
  51     case SymTagAnnotation:              return "SymTagAnnotation";
  52     case SymTagLabel:                   return "SymTagLabel";
  53     case SymTagPublicSymbol:            return "SymTagPublicSymbol";
  54     case SymTagUDT:                     return "SymTagUDT";
  55     case SymTagEnum:                    return "SymTagEnum";
  56     case SymTagFunctionType:            return "SymTagFunctionType";
  57     case SymTagPointerType:             return "SymTagPointerType";
  58     case SymTagArrayType:               return "SymTagArrayType";
  59     case SymTagBaseType:                return "SymTagBaseType";
  60     case SymTagTypedef:                 return "SymTagTypedef,";
  61     case SymTagBaseClass:               return "SymTagBaseClass";
  62     case SymTagFriend:                  return "SymTagFriend";
  63     case SymTagFunctionArgType:         return "SymTagFunctionArgType,";
  64     case SymTagFuncDebugStart:          return "SymTagFuncDebugStart,";
  65     case SymTagFuncDebugEnd:            return "SymTagFuncDebugEnd";
  66     case SymTagUsingNamespace:          return "SymTagUsingNamespace,";
  67     case SymTagVTableShape:             return "SymTagVTableShape";
  68     case SymTagVTable:                  return "SymTagVTable";
  69     case SymTagCustom:                  return "SymTagCustom";
  70     case SymTagThunk:                   return "SymTagThunk";
  71     case SymTagCustomType:              return "SymTagCustomType";
  72     case SymTagManagedType:             return "SymTagManagedType";
  73     case SymTagDimension:               return "SymTagDimension";
  74     default:                            return "---";
  75     }
  76 }
  77
  78 const char* symt_get_name(const struct symt* sym)
  79 {
  80     switch (sym->tag)
  81     {
  82     /* lexical tree */
  83     case SymTagData:            return ((const struct symt_data*)sym)->hash_elt.name;
  84     case SymTagFunction:        return ((const struct symt_function*)sym)->hash_elt.name;
  85     case SymTagPublicSymbol:    return ((const struct symt_public*)sym)->hash_elt.name;
  86     case SymTagBaseType:        return ((const struct symt_basic*)sym)->hash_elt.name;
  87     case SymTagLabel:           return ((const struct symt_function_point*)sym)->name;
  88     case SymTagThunk:           return ((const struct symt_thunk*)sym)->hash_elt.name;
  89     /* hierarchy tree */
  90     case SymTagEnum:            return ((const struct symt_enum*)sym)->name;
  91     case SymTagTypedef:         return ((const struct symt_typedef*)sym)->hash_elt.name;
  92     case SymTagUDT:             return ((const struct symt_udt*)sym)->hash_elt.name;
  93     default:
  94         FIXME("Unsupported sym-tag %s\n", symt_get_tag_str(sym->tag));
  95         /* fall through */
  96     case SymTagArrayType:
  97     case SymTagPointerType:
  98     case SymTagFunctionType:
  99         return NULL;
 100     }
 101 }
 102
 103 static struct symt* symt_find_type_by_name(struct module* module,
 104                                            enum SymTagEnum sym_tag,
 105                                            const char* typename)
 106 {
 107     void*                       ptr;
 108     struct symt_ht*             type;
 109     struct hash_table_iter      hti;
 110
 111     assert(typename);
 112     assert(module);
 113
 114     hash_table_iter_init(&module->ht_types, &hti, typename);
 115     while ((ptr = hash_table_iter_up(&hti)))
 116     {
 117         type = GET_ENTRY(ptr, struct symt_ht, hash_elt);
 118
 119         if ((sym_tag == SymTagNull || type->symt.tag == sym_tag) &&
 120             type->hash_elt.name && !strcmp(type->hash_elt.name, typename))
 121             return &type->symt;
 122     }
 123     SetLastError(ERROR_INVALID_NAME); /* FIXME ?? */
 124     return NULL;
 125 }
 126
 127 static void symt_add_type(struct module* module, struct symt* symt)
 128 {
 129     struct symt**       p;
 130     p = vector_add(&module->vtypes, &module->pool);
 131     assert(p);
 132     *p = symt;
 133 }
 134
 135 struct symt_basic* symt_new_basic(struct module* module, enum BasicType bt,
 136                                   const char* typename, unsigned size)
 137 {
 138     struct symt_basic*          sym;
 139
 140     if (typename)
 141     {
 142         sym = (struct symt_basic*)symt_find_type_by_name(module, SymTagBaseType,
 143                                                          typename);
 144         if (sym && sym->bt == bt && sym->size == size)
 145             return sym;
 146     }
 147     if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
 148     {
 149         sym->symt.tag = SymTagBaseType;
 150         if (typename)
 151         {
 152             sym->hash_elt.name = pool_strdup(&module->pool, typename);
 153             hash_table_add(&module->ht_types, &sym->hash_elt);
 154         } else sym->hash_elt.name = NULL;
 155         sym->bt = bt;
 156         sym->size = size;
 157         symt_add_type(module, &sym->symt);
 158     }
 159     return sym;
 160 }
 161
 162 struct symt_udt* symt_new_udt(struct module* module, const char* typename,
 163                               unsigned size, enum UdtKind kind)
 164 {
 165     struct symt_udt*            sym;
 166
 167     TRACE_(dbghelp_symt)("Adding udt %s:%s\n", module->module_name, 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         p = NULL;
 219         while ((p = vector_iter_up(&udt_type->vchildren, p)))
 220         {
 221             m = (struct symt_data*)*p;
 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 {
 248     struct symt_enum*   sym;
 249
 250     if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
 251     {
 252         sym->symt.tag            = SymTagEnum;
 253         sym->name = (typename) ? pool_strdup(&module->pool, typename) : NULL;
 254         vector_init(&sym->vchildren, sizeof(struct symt*), 8);
 255     }
 256     return sym;
 257 }
 258
 259 BOOL symt_add_enum_element(struct module* module, struct symt_enum* enum_type,
 260                            const char* name, int value)
 261 {
 262     struct symt_data*   e;
 263     struct symt**       p;
 264
 265     assert(enum_type->symt.tag == SymTagEnum);
 266     e = pool_alloc(&module->pool, sizeof(*e));
 267     if (e == NULL) return FALSE;
 268
 269     e->symt.tag = SymTagData;
 270     e->hash_elt.name = pool_strdup(&module->pool, name);
 271     e->hash_elt.next = NULL;
 272     e->kind = DataIsConstant;
 273     e->container = &enum_type->symt;
 274     /* CV defines the underlying type for the enumeration */
 275     e->type = &symt_new_basic(module, btInt, "int", 4)->symt;
 276     e->u.value.n1.n2.vt = VT_I4;
 277     e->u.value.n1.n2.n3.lVal = value;
 278
 279     p = vector_add(&enum_type->vchildren, &module->pool);
 280     if (!p) return FALSE; /* FIXME we leak e */
 281     *p = &e->symt;
 282
 283     return TRUE;
 284 }
 285
 286 struct symt_array* symt_new_array(struct module* module, int min, int max,
 287                                   struct symt* base, struct symt* index)
 288 {
 289     struct symt_array*  sym;
 290
 291     if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
 292     {
 293         sym->symt.tag   = SymTagArrayType;
 294         sym->start      = min;
 295         sym->end        = max;
 296         sym->base_type  = base;
 297         sym->index_type = index;
 298         symt_add_type(module, &sym->symt);
 299     }
 300     return sym;
 301 }
 302
 303 struct symt_function_signature* symt_new_function_signature(struct module* module,
 304                                                             struct symt* ret_type,
 305                                                             enum CV_call_e call_conv)
 306 {
 307     struct symt_function_signature*     sym;
 308
 309     if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
 310     {
 311         sym->symt.tag = SymTagFunctionType;
 312         sym->rettype  = ret_type;
 313         vector_init(&sym->vchildren, sizeof(struct symt*), 4);
 314         sym->call_conv = call_conv;
 315         symt_add_type(module, &sym->symt);
 316     }
 317     return sym;
 318 }
 319
 320 BOOL symt_add_function_signature_parameter(struct module* module,
 321                                            struct symt_function_signature* sig_type,
 322                                            struct symt* param)
 323 {
 324     struct symt**                       p;
 325     struct symt_function_arg_type*      arg;
 326
 327     assert(sig_type->symt.tag == SymTagFunctionType);
 328     arg = pool_alloc(&module->pool, sizeof(*arg));
 329     if (!arg) return FALSE;
 330     arg->symt.tag = SymTagFunctionArgType;
 331     arg->arg_type = param;
 332     arg->container = &sig_type->symt;
 333     p = vector_add(&sig_type->vchildren, &module->pool);
 334     if (!p) return FALSE; /* FIXME we leak arg */
 335     *p = &arg->symt;
 336
 337     return TRUE;
 338 }
 339
 340 struct symt_pointer* symt_new_pointer(struct module* module, struct symt* ref_type)
 341 {
 342     struct symt_pointer*        sym;
 343
 344     if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
 345     {
 346         sym->symt.tag = SymTagPointerType;
 347         sym->pointsto = ref_type;
 348         symt_add_type(module, &sym->symt);
 349     }
 350     return sym;
 351 }
 352
 353 struct symt_typedef* symt_new_typedef(struct module* module, struct symt* ref,
 354                                       const char* name)
 355 {
 356     struct symt_typedef* sym;
 357
 358     if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
 359     {
 360         sym->symt.tag = SymTagTypedef;
 361         sym->type     = ref;
 362         sym->hash_elt.name = pool_strdup(&module->pool, name);
 363         hash_table_add(&module->ht_types, &sym->hash_elt);
 364         symt_add_type(module, &sym->symt);
 365     }
 366     return sym;
 367 }
 368
 369 /******************************************************************
 370  *              SymEnumTypes (DBGHELP.@)
 371  *
 372  */
 373 BOOL WINAPI SymEnumTypes(HANDLE hProcess, ULONG64 BaseOfDll,
 374                          PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
 375                          PVOID UserContext)
 376 {
 377     struct module_pair  pair;
 378     char                buffer[sizeof(SYMBOL_INFO) + 256];
 379     SYMBOL_INFO*        sym_info = (SYMBOL_INFO*)buffer;
 380     const char*         tmp;
 381     struct symt*        type;
 382     void*               pos = NULL;
 383     DWORD64             size;
 384
 385     TRACE("(%p %s %p %p)\n",
 386           hProcess, wine_dbgstr_longlong(BaseOfDll), EnumSymbolsCallback,
 387           UserContext);
 388
 389     if (!(pair.pcs = process_find_by_handle(hProcess))) return FALSE;
 390     pair.requested = module_find_by_addr(pair.pcs, BaseOfDll, DMT_UNKNOWN);
 391     if (!module_get_debug(&pair)) return FALSE;
 392
 393     sym_info->SizeOfStruct = sizeof(SYMBOL_INFO);
 394     sym_info->MaxNameLen = sizeof(buffer) - sizeof(SYMBOL_INFO);
 395
 396     while ((pos = vector_iter_up(&pair.effective->vtypes, pos)))
 397     {
 398         type = *(struct symt**)pos;
 399         sym_info->TypeIndex = (DWORD)type;
 400         sym_info->info = 0; /* FIXME */
 401         symt_get_info(type, TI_GET_LENGTH, &size);
 402         sym_info->Size = size;
 403         sym_info->ModBase = pair.requested->module.BaseOfImage;
 404         sym_info->Flags = 0; /* FIXME */
 405         sym_info->Value = 0; /* FIXME */
 406         sym_info->Address = 0; /* FIXME */
 407         sym_info->Register = 0; /* FIXME */
 408         sym_info->Scope = 0; /* FIXME */
 409         sym_info->Tag = type->tag;
 410         tmp = symt_get_name(type);
 411         if (tmp)
 412         {
 413             sym_info->NameLen = min(strlen(tmp),sym_info->MaxNameLen-1);
 414             memcpy(sym_info->Name, tmp, sym_info->NameLen);
 415             sym_info->Name[sym_info->NameLen] = '\0';
 416         }
 417         else
 418            sym_info->Name[sym_info->NameLen = 0] = '\0';
 419         if (!EnumSymbolsCallback(sym_info, sym_info->Size, UserContext)) break;
 420     }
 421     return TRUE;
 422 }
 423
 424 struct enum_types_AtoW
 425 {
 426     char                                buffer[sizeof(SYMBOL_INFOW) + 256 * sizeof(WCHAR)];
 427     void*                               user;
 428     PSYM_ENUMERATESYMBOLS_CALLBACKW     callback;
 429 };
 430
 431 BOOL CALLBACK enum_types_AtoW(PSYMBOL_INFO si, ULONG addr, PVOID _et)
 432 {
 433     struct enum_types_AtoW*     et = _et;
 434     SYMBOL_INFOW*               siW = (SYMBOL_INFOW*)et->buffer;
 435
 436     copy_symbolW(siW, si);
 437     return et->callback(siW, addr, et->user);
 438 }
 439
 440 /******************************************************************
 441  *              SymEnumTypesW (DBGHELP.@)
 442  *
 443  */
 444 BOOL WINAPI SymEnumTypesW(HANDLE hProcess, ULONG64 BaseOfDll,
 445                           PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
 446                           PVOID UserContext)
 447 {
 448     struct enum_types_AtoW     et;
 449
 450     et.callback = EnumSymbolsCallback;
 451     et.user = UserContext;
 452
 453     return SymEnumTypes(hProcess, BaseOfDll, enum_types_AtoW, &et);
 454 }
 455
 456 /******************************************************************
 457  *              symt_get_info
 458  *
 459  * Retrieves inforamtion about a symt (either symbol or type)
 460  */
 461 BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req,
 462                    void* pInfo)
 463 {
 464     unsigned            len;
 465
 466     if (!type) return FALSE;
 467
 468 /* helper to typecast pInfo to its expected type (_t) */
 469 #define X(_t) (*((_t*)pInfo))
 470
 471     switch (req)
 472     {
 473     case TI_FINDCHILDREN:
 474         {
 475             const struct vector*        v;
 476             struct symt**               pt;
 477             unsigned                    i;
 478             TI_FINDCHILDREN_PARAMS*     tifp = pInfo;
 479
 480             switch (type->tag)
 481             {
 482             case SymTagUDT:          v = &((const struct symt_udt*)type)->vchildren; break;
 483             case SymTagEnum:         v = &((const struct symt_enum*)type)->vchildren; break;
 484             case SymTagFunctionType: v = &((const struct symt_function_signature*)type)->vchildren; break;
 485             case SymTagFunction:     v = &((const struct symt_function*)type)->vchildren; break;
 486             default:
 487                 FIXME("Unsupported sym-tag %s for find-children\n",
 488                       symt_get_tag_str(type->tag));
 489                 return FALSE;
 490             }
 491             for (i = 0; i < tifp->Count; i++)
 492             {
 493                 if (!(pt = vector_at(v, tifp->Start + i))) return FALSE;
 494                 tifp->ChildId[i] = (DWORD)*pt;
 495             }
 496         }
 497         break;
 498
 499     case TI_GET_ADDRESS:
 500         switch (type->tag)
 501         {
 502         case SymTagData:
 503             switch (((const struct symt_data*)type)->kind)
 504             {
 505             case DataIsGlobal:
 506             case DataIsFileStatic:
 507                 X(ULONG64) = ((const struct symt_data*)type)->u.var.offset;
 508                 break;
 509             default: return FALSE;
 510             }
 511             break;
 512         case SymTagFunction:
 513             X(ULONG64) = ((const struct symt_function*)type)->address;
 514             break;
 515         case SymTagPublicSymbol:
 516             X(ULONG64) = ((const struct symt_public*)type)->address;
 517             break;
 518         case SymTagFuncDebugStart:
 519         case SymTagFuncDebugEnd:
 520         case SymTagLabel:
 521             X(ULONG64) = ((const struct symt_function_point*)type)->parent->address +
 522                 ((const struct symt_function_point*)type)->loc.offset;
 523             break;
 524         case SymTagThunk:
 525             X(ULONG64) = ((const struct symt_thunk*)type)->address;
 526             break;
 527         case SymTagCompiland:
 528             X(ULONG64) = ((const struct symt_compiland*)type)->address;
 529             break;
 530         default:
 531             FIXME("Unsupported sym-tag %s for get-address\n",
 532                   symt_get_tag_str(type->tag));
 533             return FALSE;
 534         }
 535         break;
 536
 537     case TI_GET_BASETYPE:
 538         switch (type->tag)
 539         {
 540         case SymTagBaseType:
 541             X(DWORD) = ((const struct symt_basic*)type)->bt;
 542             break;
 543         case SymTagEnum:
 544             X(DWORD) = btInt;
 545             break;
 546         default:
 547             return FALSE;
 548         }
 549         break;
 550
 551     case TI_GET_BITPOSITION:
 552         if (type->tag == SymTagData &&
 553             ((const struct symt_data*)type)->kind == DataIsMember &&
 554             ((const struct symt_data*)type)->u.member.length != 0)
 555             X(DWORD) = ((const struct symt_data*)type)->u.member.offset & 7;
 556         else return FALSE;
 557         break;
 558
 559     case TI_GET_CHILDRENCOUNT:
 560         switch (type->tag)
 561         {
 562         case SymTagUDT:
 563             X(DWORD) = vector_length(&((const struct symt_udt*)type)->vchildren);
 564             break;
 565         case SymTagEnum:
 566             X(DWORD) = vector_length(&((const struct symt_enum*)type)->vchildren);
 567             break;
 568         case SymTagFunctionType:
 569             X(DWORD) = vector_length(&((const struct symt_function_signature*)type)->vchildren);
 570             break;
 571         case SymTagFunction:
 572             X(DWORD) = vector_length(&((const struct symt_function*)type)->vchildren);
 573             break;
 574         case SymTagPointerType: /* MS does it that way */
 575         case SymTagArrayType: /* MS does it that way */
 576         case SymTagThunk: /* MS does it that way */
 577             X(DWORD) = 0;
 578             break;
 579         default:
 580             FIXME("Unsupported sym-tag %s for get-children-count\n",
 581                   symt_get_tag_str(type->tag));
 582             /* fall through */
 583         case SymTagData:
 584         case SymTagPublicSymbol:
 585         case SymTagBaseType:
 586             return FALSE;
 587         }
 588         break;
 589
 590     case TI_GET_COUNT:
 591         switch (type->tag)
 592         {
 593         case SymTagArrayType:
 594             X(DWORD) = ((const struct symt_array*)type)->end -
 595                 ((const struct symt_array*)type)->start + 1;
 596             break;
 597         case SymTagFunctionType:
 598             /* this seems to be wrong for (future) C++ methods, where 'this' parameter
 599              * should be included in this value (and not in GET_CHILDREN_COUNT)
 600              */
 601             X(DWORD) = vector_length(&((const struct symt_function_signature*)type)->vchildren);
 602             break;
 603         default: return FALSE;
 604         }
 605         break;
 606
 607     case TI_GET_DATAKIND:
 608         if (type->tag != SymTagData) return FALSE;
 609         X(DWORD) = ((const struct symt_data*)type)->kind;
 610         break;
 611
 612     case TI_GET_LENGTH:
 613         switch (type->tag)
 614         {
 615         case SymTagBaseType:
 616             X(DWORD64) = ((const struct symt_basic*)type)->size;
 617             break;
 618         case SymTagFunction:
 619             X(DWORD64) = ((const struct symt_function*)type)->size;
 620             break;
 621         case SymTagPointerType:
 622             X(DWORD64) = sizeof(void*);
 623             break;
 624         case SymTagUDT:
 625             X(DWORD64) = ((const struct symt_udt*)type)->size;
 626             break;
 627         case SymTagEnum:
 628             X(DWORD64) = sizeof(int); /* FIXME: should be size of base-type of enum !!! */
 629             break;
 630         case SymTagData:
 631             if (((const struct symt_data*)type)->kind != DataIsMember ||
 632                 !((const struct symt_data*)type)->u.member.length)
 633                 return FALSE;
 634             X(DWORD64) = ((const struct symt_data*)type)->u.member.length;
 635             break;
 636         case SymTagArrayType:
 637             if (!symt_get_info(((const struct symt_array*)type)->base_type,
 638                                TI_GET_LENGTH, pInfo))
 639                 return FALSE;
 640             X(DWORD64) *= ((const struct symt_array*)type)->end -
 641                 ((const struct symt_array*)type)->start + 1;
 642             break;
 643         case SymTagPublicSymbol:
 644             X(DWORD64) = ((const struct symt_public*)type)->size;
 645             break;
 646         case SymTagTypedef:
 647             return symt_get_info(((const struct symt_typedef*)type)->type, TI_GET_LENGTH, pInfo);
 648         case SymTagThunk:
 649             X(DWORD64) = ((const struct symt_thunk*)type)->size;
 650             break;
 651         default:
 652             FIXME("Unsupported sym-tag %s for get-length\n",
 653                   symt_get_tag_str(type->tag));
 654             /* fall through */
 655         case SymTagFunctionType:
 656             return 0;
 657         }
 658         break;
 659
 660     case TI_GET_LEXICALPARENT:
 661         switch (type->tag)
 662         {
 663         case SymTagBlock:
 664             X(DWORD) = (DWORD)((const struct symt_block*)type)->container;
 665             break;
 666         case SymTagData:
 667             X(DWORD) = (DWORD)((const struct symt_data*)type)->container;
 668             break;
 669         case SymTagFunction:
 670             X(DWORD) = (DWORD)((const struct symt_function*)type)->container;
 671             break;
 672         case SymTagThunk:
 673             X(DWORD) = (DWORD)((const struct symt_thunk*)type)->container;
 674             break;
 675         case SymTagFunctionArgType:
 676             X(DWORD) = (DWORD)((const struct symt_function_arg_type*)type)->container;
 677             break;
 678         default:
 679             FIXME("Unsupported sym-tag %s for get-lexical-parent\n",
 680                   symt_get_tag_str(type->tag));
 681             return FALSE;
 682         }
 683         break;
 684
 685     case TI_GET_NESTED:
 686         switch (type->tag)
 687         {
 688         case SymTagUDT:
 689         case SymTagEnum:
 690             X(DWORD) = 0;
 691             break;
 692         default:
 693             return FALSE;
 694         }
 695         break;
 696
 697     case TI_GET_OFFSET:
 698         switch (type->tag)
 699         {
 700         case SymTagData:
 701             switch (((const struct symt_data*)type)->kind)
 702             {
 703             case DataIsParam:
 704             case DataIsLocal:
 705                 X(ULONG) = ((const struct symt_data*)type)->u.var.offset;
 706                 break;
 707             case DataIsMember:
 708                 X(ULONG) = ((const struct symt_data*)type)->u.member.offset >> 3;
 709                 break;
 710             default:
 711                 FIXME("Unknown kind (%u) for get-offset\n",
 712                       ((const struct symt_data*)type)->kind);
 713                 return FALSE;
 714             }
 715             break;
 716         default:
 717             FIXME("Unsupported sym-tag %s for get-offset\n",
 718                   symt_get_tag_str(type->tag));
 719             return FALSE;
 720         }
 721         break;
 722
 723     case TI_GET_SYMNAME:
 724         {
 725             const char* name = symt_get_name(type);
 726             if (!name) return FALSE;
 727             len = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0);
 728             X(WCHAR*) = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 729             if (!X(WCHAR*)) return FALSE;
 730             MultiByteToWideChar(CP_ACP, 0, name, -1, X(WCHAR*), len);
 731         }
 732         break;
 733
 734     case TI_GET_SYMTAG:
 735         X(DWORD) = type->tag;
 736         break;
 737
 738     case TI_GET_TYPE:
 739     case TI_GET_TYPEID:
 740         switch (type->tag)
 741         {
 742             /* hierarchical => hierarchical */
 743         case SymTagArrayType:
 744             X(DWORD) = (DWORD)((const struct symt_array*)type)->base_type;
 745             break;
 746         case SymTagPointerType:
 747             X(DWORD) = (DWORD)((const struct symt_pointer*)type)->pointsto;
 748             break;
 749         case SymTagFunctionType:
 750             X(DWORD) = (DWORD)((const struct symt_function_signature*)type)->rettype;
 751             break;
 752         case SymTagTypedef:
 753             X(DWORD) = (DWORD)((const struct symt_typedef*)type)->type;
 754             break;
 755             /* lexical => hierarchical */
 756         case SymTagData:
 757             X(DWORD) = (DWORD)((const struct symt_data*)type)->type;
 758             break;
 759         case SymTagFunction:
 760             X(DWORD) = (DWORD)((const struct symt_function*)type)->type;
 761             break;
 762             /* FIXME: should also work for enums */
 763         case SymTagFunctionArgType:
 764             X(DWORD) = (DWORD)((const struct symt_function_arg_type*)type)->arg_type;
 765             break;
 766         default:
 767             FIXME("Unsupported sym-tag %s for get-type\n",
 768                   symt_get_tag_str(type->tag));
 769         case SymTagPublicSymbol:
 770         case SymTagThunk:
 771             return FALSE;
 772         }
 773         break;
 774
 775     case TI_GET_UDTKIND:
 776         if (type->tag != SymTagUDT) return FALSE;
 777         X(DWORD) = ((const struct symt_udt*)type)->kind;
 778         break;
 779
 780     case TI_GET_VALUE:
 781         if (type->tag != SymTagData || ((const struct symt_data*)type)->kind != DataIsConstant)
 782             return FALSE;
 783         X(VARIANT) = ((const struct symt_data*)type)->u.value;
 784         break;
 785
 786     case TI_GET_CALLING_CONVENTION:
 787         if (type->tag != SymTagFunctionType) return FALSE;
 788         if (((const struct symt_function_signature*)type)->call_conv == -1)
 789         {
 790             FIXME("No support for calling convention for this signature\n");
 791             X(DWORD) = CV_CALL_FAR_C; /* FIXME */
 792         }
 793         else X(DWORD) = ((const struct symt_function_signature*)type)->call_conv;
 794         break;
 795     case TI_GET_ARRAYINDEXTYPEID:
 796         if (type->tag != SymTagArrayType) return FALSE;
 797         X(DWORD) = (DWORD)((const struct symt_array*)type)->index_type;
 798         break;
 799
 800 #undef X
 801
 802     case TI_GET_ADDRESSOFFSET:
 803     case TI_GET_CLASSPARENTID:
 804     case TI_GET_SYMINDEX:
 805     case TI_GET_THISADJUST:
 806     case TI_GET_VIRTUALBASECLASS:
 807     case TI_GET_VIRTUALBASEPOINTEROFFSET:
 808     case TI_GET_VIRTUALTABLESHAPEID:
 809     case TI_IS_EQUIV_TO:
 810         FIXME("Unsupported GetInfo request (%u)\n", req);
 811         return FALSE;
 812     default:
 813         FIXME("Unknown GetInfo request (%u)\n", req);
 814         return FALSE;
 815     }
 816
 817     return TRUE;
 818 }
 819
 820 /******************************************************************
 821  *              SymGetTypeInfo (DBGHELP.@)
 822  *
 823  */
 824 BOOL WINAPI SymGetTypeInfo(HANDLE hProcess, DWORD64 ModBase,
 825                            ULONG TypeId, IMAGEHLP_SYMBOL_TYPE_INFO GetType,
 826                            PVOID pInfo)
 827 {
 828     struct module_pair  pair;
 829
 830     pair.pcs = process_find_by_handle(hProcess);
 831     if (!pair.pcs) return FALSE;
 832
 833     pair.requested = module_find_by_addr(pair.pcs, ModBase, DMT_UNKNOWN);
 834     if (!module_get_debug(&pair))
 835     {
 836         FIXME("Someone didn't properly set ModBase (%s)\n", wine_dbgstr_longlong(ModBase));
 837         return FALSE;
 838     }
 839
 840     return symt_get_info((struct symt*)TypeId, GetType, pInfo);
 841 }
 842
 843 /******************************************************************
 844  *              SymGetTypeFromName (DBGHELP.@)
 845  *
 846  */
 847 BOOL WINAPI SymGetTypeFromName(HANDLE hProcess, ULONG64 BaseOfDll,
 848                                PCSTR Name, PSYMBOL_INFO Symbol)
 849 {
 850     struct process*     pcs = process_find_by_handle(hProcess);
 851     struct module*      module;
 852     struct symt*        type;
 853
 854     if (!pcs) return FALSE;
 855     module = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN);
 856     if (!module) return FALSE;
 857     type = symt_find_type_by_name(module, SymTagNull, Name);
 858     if (!type) return FALSE;
 859     Symbol->TypeIndex = (DWORD)type;
 860
 861     return TRUE;
 862 }