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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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.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     p = NULL;
 217     while ((p = vector_iter_up(&udt_type->vchildren, p)))
 218     {
 219         m = (struct symt_data*)*p;
 220         assert(m);
 221         assert(m->symt.tag == SymTagData);
 222         if (m->hash_elt.name[0] == name[0] && strcmp(m->hash_elt.name, name) == 0)
 223             return TRUE;
 224     }
 225
 226     if ((m = pool_alloc(&module->pool, sizeof(*m))) == NULL) return FALSE;
 227     memset(m, 0, sizeof(*m));
 228     m->symt.tag      = SymTagData;
 229     m->hash_elt.name = pool_strdup(&module->pool, name);
 230     m->hash_elt.next = NULL;
 231
 232     m->kind          = DataIsMember;
 233     m->container     = &udt_type->symt;
 234     m->type          = elt_type;
 235     m->u.s.offset    = offset;
 236     m->u.s.length    = ((offset & 7) || (size & 7)) ? size : 0;
 237     m->u.s.reg_id    = 0;
 238     p = vector_add(&udt_type->vchildren, &module->pool);
 239     *p = &m->symt;
 240
 241     return TRUE;
 242 }
 243
 244 struct symt_enum* symt_new_enum(struct module* module, const char* typename)
 245 {
 246     struct symt_enum*   sym;
 247
 248     if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
 249     {
 250         sym->symt.tag            = SymTagEnum;
 251         sym->name = (typename) ? pool_strdup(&module->pool, typename) : NULL;
 252         vector_init(&sym->vchildren, sizeof(struct symt*), 8);
 253     }
 254     return sym;
 255 }
 256
 257 BOOL symt_add_enum_element(struct module* module, struct symt_enum* enum_type,
 258                            const char* name, int value)
 259 {
 260     struct symt_data*   e;
 261     struct symt**       p;
 262
 263     assert(enum_type->symt.tag == SymTagEnum);
 264     e = pool_alloc(&module->pool, sizeof(*e));
 265     if (e == NULL) return FALSE;
 266
 267     e->symt.tag = SymTagData;
 268     e->hash_elt.name = pool_strdup(&module->pool, name);
 269     e->hash_elt.next = NULL;
 270     e->kind = DataIsConstant;
 271     e->container = &enum_type->symt;
 272     /* CV defines the underlying type for the enumeration */
 273     e->type = &symt_new_basic(module, btInt, "int", 4)->symt;
 274     e->u.value.n1.n2.vt = VT_I4;
 275     e->u.value.n1.n2.n3.lVal = value;
 276
 277     p = vector_add(&enum_type->vchildren, &module->pool);
 278     if (!p) return FALSE; /* FIXME we leak e */
 279     *p = &e->symt;
 280
 281     return TRUE;
 282 }
 283
 284 struct symt_array* symt_new_array(struct module* module, int min, int max,
 285                                   struct symt* base)
 286 {
 287     struct symt_array*  sym;
 288
 289     if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
 290     {
 291         sym->symt.tag  = SymTagArrayType;
 292         sym->start     = min;
 293         sym->end       = max;
 294         sym->basetype  = base;
 295         symt_add_type(module, &sym->symt);
 296     }
 297     return sym;
 298 }
 299
 300 struct symt_function_signature* symt_new_function_signature(struct module* module,
 301                                                             struct symt* ret_type)
 302 {
 303     struct symt_function_signature*     sym;
 304
 305     if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
 306     {
 307         sym->symt.tag = SymTagFunctionType;
 308         sym->rettype  = ret_type;
 309         vector_init(&sym->vchildren, sizeof(struct symt*), 4);
 310         symt_add_type(module, &sym->symt);
 311     }
 312     return sym;
 313 }
 314
 315 BOOL symt_add_function_signature_parameter(struct module* module,
 316                                            struct symt_function_signature* sig_type,
 317                                            struct symt* param)
 318 {
 319     struct symt**       p;
 320
 321     assert(sig_type->symt.tag == SymTagFunctionType);
 322     p = vector_add(&sig_type->vchildren, &module->pool);
 323     if (!p) return FALSE; /* FIXME we leak e */
 324     *p = param;
 325
 326     return TRUE;
 327 }
 328
 329 struct symt_pointer* symt_new_pointer(struct module* module, struct symt* ref_type)
 330 {
 331     struct symt_pointer*        sym;
 332
 333     if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
 334     {
 335         sym->symt.tag = SymTagPointerType;
 336         sym->pointsto = ref_type;
 337         symt_add_type(module, &sym->symt);
 338     }
 339     return sym;
 340 }
 341
 342 struct symt_typedef* symt_new_typedef(struct module* module, struct symt* ref,
 343                                       const char* name)
 344 {
 345     struct symt_typedef* sym;
 346
 347     if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
 348     {
 349         sym->symt.tag = SymTagTypedef;
 350         sym->type     = ref;
 351         sym->hash_elt.name = pool_strdup(&module->pool, name);
 352         hash_table_add(&module->ht_types, &sym->hash_elt);
 353         symt_add_type(module, &sym->symt);
 354     }
 355     return sym;
 356 }
 357
 358 /******************************************************************
 359  *              SymEnumTypes (DBGHELP.@)
 360  *
 361  */
 362 BOOL WINAPI SymEnumTypes(HANDLE hProcess, unsigned long BaseOfDll,
 363                          PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
 364                          void* UserContext)
 365 {
 366     struct process*     pcs;
 367     struct module*      module;
 368     char                buffer[sizeof(SYMBOL_INFO) + 256];
 369     SYMBOL_INFO*        sym_info = (SYMBOL_INFO*)buffer;
 370     const char*         tmp;
 371     struct symt*        type;
 372     void*               pos = NULL;
 373
 374     TRACE("(%p %08lx %p %p)\n",
 375           hProcess, BaseOfDll, EnumSymbolsCallback, UserContext);
 376
 377     if (!(pcs = process_find_by_handle(hProcess))) return FALSE;
 378     module = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN);
 379     if (!(module = module_get_debug(pcs, module))) return FALSE;
 380
 381     sym_info->SizeOfStruct = sizeof(SYMBOL_INFO);
 382     sym_info->MaxNameLen = sizeof(buffer) - sizeof(SYMBOL_INFO);
 383
 384     while ((pos = vector_iter_up(&module->vtypes, pos)))
 385     {
 386         type = *(struct symt**)pos;
 387         sym_info->TypeIndex = (DWORD)type;
 388         sym_info->info = 0; /* FIXME */
 389         symt_get_info(type, TI_GET_LENGTH, &sym_info->Size);
 390         sym_info->ModBase = module->module.BaseOfImage;
 391         sym_info->Flags = 0; /* FIXME */
 392         sym_info->Value = 0; /* FIXME */
 393         sym_info->Address = 0; /* FIXME */
 394         sym_info->Register = 0; /* FIXME */
 395         sym_info->Scope = 0; /* FIXME */
 396         sym_info->Tag = type->tag;
 397         tmp = symt_get_name(type);
 398         if (tmp)
 399         {
 400             sym_info->NameLen = strlen(tmp) + 1;
 401             strncpy(sym_info->Name, tmp, min(sym_info->NameLen, sym_info->MaxNameLen));
 402             sym_info->Name[sym_info->MaxNameLen - 1] = '\0';
 403         }
 404         else sym_info->Name[sym_info->NameLen = 0] = '\0';
 405         if (!EnumSymbolsCallback(sym_info, sym_info->Size, UserContext)) break;
 406     }
 407     return TRUE;
 408 }
 409
 410 /******************************************************************
 411  *              symt_get_info
 412  *
 413  * Retrieves inforamtion about a symt (either symbol or type)
 414  */
 415 BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req,
 416                    void* pInfo)
 417 {
 418     unsigned            len;
 419
 420     if (!type) return FALSE;
 421
 422 /* helper to typecast pInfo to its expected type (_t) */
 423 #define X(_t) (*((_t*)pInfo))
 424
 425     switch (req)
 426     {
 427     case TI_FINDCHILDREN:
 428         {
 429             const struct vector*        v;
 430             struct symt**               pt;
 431             unsigned                    i;
 432             TI_FINDCHILDREN_PARAMS*     tifp = pInfo;
 433
 434             switch (type->tag)
 435             {
 436             case SymTagUDT:          v = &((const struct symt_udt*)type)->vchildren; break;
 437             case SymTagEnum:         v = &((const struct symt_enum*)type)->vchildren; break;
 438             case SymTagFunctionType: v = &((const struct symt_function_signature*)type)->vchildren; break;
 439             case SymTagFunction:     v = &((const struct symt_function*)type)->vchildren; break;
 440             default:
 441                 FIXME("Unsupported sym-tag %s for find-children\n",
 442                       symt_get_tag_str(type->tag));
 443                 return FALSE;
 444             }
 445             for (i = 0; i < tifp->Count; i++)
 446             {
 447                 if (!(pt = vector_at(v, tifp->Start + i))) return FALSE;
 448                 tifp->ChildId[i] = (DWORD)*pt;
 449             }
 450         }
 451         break;
 452
 453     case TI_GET_ADDRESS:
 454         switch (type->tag)
 455         {
 456         case SymTagData:
 457             switch (((const struct symt_data*)type)->kind)
 458             {
 459             case DataIsGlobal:
 460             case DataIsFileStatic:
 461                 X(DWORD) = ((const struct symt_data*)type)->u.address;
 462                 break;
 463             default: return FALSE;
 464             }
 465             break;
 466         case SymTagFunction:
 467             X(DWORD) = ((const struct symt_function*)type)->address;
 468             break;
 469         case SymTagPublicSymbol:
 470             X(DWORD) = ((const struct symt_public*)type)->address;
 471             break;
 472         case SymTagFuncDebugStart:
 473         case SymTagFuncDebugEnd:
 474         case SymTagLabel:
 475             X(DWORD) = ((const struct symt_function_point*)type)->parent->address +
 476                 ((const struct symt_function_point*)type)->offset;
 477             break;
 478         case SymTagThunk:
 479             X(DWORD) = ((const struct symt_thunk*)type)->address;
 480             break;
 481         default:
 482             FIXME("Unsupported sym-tag %s for get-address\n",
 483                   symt_get_tag_str(type->tag));
 484             return FALSE;
 485         }
 486         break;
 487
 488     case TI_GET_BASETYPE:
 489         switch (type->tag)
 490         {
 491         case SymTagBaseType:
 492             X(DWORD) = ((const struct symt_basic*)type)->bt;
 493             break;
 494         case SymTagEnum:
 495             X(DWORD) = btInt;
 496             break;
 497         default:
 498             return FALSE;
 499         }
 500         break;
 501
 502     case TI_GET_BITPOSITION:
 503         if (type->tag != SymTagData ||
 504             ((const struct symt_data*)type)->kind != DataIsMember ||
 505             ((const struct symt_data*)type)->u.s.length == 0)
 506             return FALSE;
 507         X(DWORD) = ((const struct symt_data*)type)->u.s.offset & 7;
 508         break;
 509
 510     case TI_GET_CHILDRENCOUNT:
 511         switch (type->tag)
 512         {
 513         case SymTagUDT:
 514             X(DWORD) = vector_length(&((const struct symt_udt*)type)->vchildren);
 515             break;
 516         case SymTagEnum:
 517             X(DWORD) = vector_length(&((const struct symt_enum*)type)->vchildren);
 518             break;
 519         case SymTagFunctionType:
 520             X(DWORD) = vector_length(&((const struct symt_function_signature*)type)->vchildren);
 521             break;
 522         case SymTagFunction:
 523             X(DWORD) = vector_length(&((const struct symt_function*)type)->vchildren);
 524             break;
 525         case SymTagPointerType: /* MS does it that way */
 526         case SymTagArrayType: /* MS does it that way */
 527         case SymTagThunk: /* MS does it that way */
 528             X(DWORD) = 0;
 529             break;
 530         default:
 531             FIXME("Unsupported sym-tag %s for get-children-count\n",
 532                   symt_get_tag_str(type->tag));
 533             /* fall through */
 534         case SymTagData:
 535         case SymTagPublicSymbol:
 536         case SymTagBaseType:
 537             return FALSE;
 538         }
 539         break;
 540
 541     case TI_GET_COUNT:
 542         /* it seems that FunctionType also react to GET_COUNT (same value as
 543          * GET_CHILDREN_COUNT ?, except for C++ methods, where it seems to
 544          * also include 'this' (GET_CHILDREN_COUNT+1)
 545          */
 546         if (type->tag != SymTagArrayType) return FALSE;
 547         X(DWORD) = ((const struct symt_array*)type)->end -
 548             ((const struct symt_array*)type)->start + 1;
 549         break;
 550
 551     case TI_GET_DATAKIND:
 552         if (type->tag != SymTagData) return FALSE;
 553         X(DWORD) = ((const struct symt_data*)type)->kind;
 554         break;
 555
 556     case TI_GET_LENGTH:
 557         switch (type->tag)
 558         {
 559         case SymTagBaseType:
 560             X(DWORD) = ((const struct symt_basic*)type)->size;
 561             break;
 562         case SymTagFunction:
 563             X(DWORD) = ((const struct symt_function*)type)->size;
 564             break;
 565         case SymTagPointerType:
 566             X(DWORD) = sizeof(void*);
 567             break;
 568         case SymTagUDT:
 569             X(DWORD) = ((const struct symt_udt*)type)->size;
 570             break;
 571         case SymTagEnum:
 572             X(DWORD) = sizeof(int); /* FIXME: should be size of base-type of enum !!! */
 573             break;
 574         case SymTagData:
 575             if (((const struct symt_data*)type)->kind != DataIsMember ||
 576                 !((const struct symt_data*)type)->u.s.length)
 577                 return FALSE;
 578             X(DWORD) = ((const struct symt_data*)type)->u.s.length;
 579             break;
 580         case SymTagArrayType:
 581             if (!symt_get_info(((const struct symt_array*)type)->basetype,
 582                                TI_GET_LENGTH, pInfo))
 583                 return FALSE;
 584             X(DWORD) *= ((const struct symt_array*)type)->end -
 585                 ((const struct symt_array*)type)->start + 1;
 586             break;
 587         case SymTagPublicSymbol:
 588             X(DWORD) = ((const struct symt_public*)type)->size;
 589             break;
 590         case SymTagTypedef:
 591             return symt_get_info(((const struct symt_typedef*)type)->type, TI_GET_LENGTH, pInfo);
 592             break;
 593         case SymTagThunk:
 594             X(DWORD) = ((const struct symt_thunk*)type)->size;
 595             break;
 596         default:
 597             FIXME("Unsupported sym-tag %s for get-length\n",
 598                   symt_get_tag_str(type->tag));
 599             /* fall through */
 600         case SymTagFunctionType:
 601             return 0;
 602         }
 603         break;
 604
 605     case TI_GET_LEXICALPARENT:
 606         switch (type->tag)
 607         {
 608         case SymTagBlock:
 609             X(DWORD) = (DWORD)((const struct symt_block*)type)->container;
 610             break;
 611         case SymTagData:
 612             X(DWORD) = (DWORD)((const struct symt_data*)type)->container;
 613             break;
 614         case SymTagFunction:
 615             X(DWORD) = (DWORD)((const struct symt_function*)type)->container;
 616             break;
 617         case SymTagThunk:
 618             X(DWORD) = (DWORD)((const struct symt_thunk*)type)->container;
 619             break;
 620         default:
 621             FIXME("Unsupported sym-tag %s for get-lexical-parent\n",
 622                   symt_get_tag_str(type->tag));
 623             return FALSE;
 624         }
 625         break;
 626
 627     case TI_GET_NESTED:
 628         switch (type->tag)
 629         {
 630         case SymTagUDT:
 631         case SymTagEnum:
 632             X(DWORD) = 0;
 633             break;
 634         default:
 635             return FALSE;
 636         }
 637         break;
 638
 639     case TI_GET_OFFSET:
 640         switch (type->tag)
 641         {
 642         case SymTagData:
 643             switch (((const struct symt_data*)type)->kind)
 644             {
 645             case DataIsParam:
 646             case DataIsLocal:
 647             case DataIsMember:
 648                 X(ULONG) = ((const struct symt_data*)type)->u.s.offset >> 3;
 649                 break;
 650             default:
 651                 FIXME("Unknown kind (%u) for get-offset\n",
 652                       ((const struct symt_data*)type)->kind);
 653                 return FALSE;
 654             }
 655             break;
 656         default:
 657             FIXME("Unsupported sym-tag %s for get-offset\n",
 658                   symt_get_tag_str(type->tag));
 659             return FALSE;
 660         }
 661         break;
 662
 663     case TI_GET_SYMNAME:
 664         {
 665             const char* name = symt_get_name(type);
 666             if (!name) return FALSE;
 667             len = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0);
 668             X(WCHAR*) = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 669             if (!X(WCHAR*)) return FALSE;
 670             MultiByteToWideChar(CP_ACP, 0, name, -1, X(WCHAR*), len);
 671         }
 672         break;
 673
 674     case TI_GET_SYMTAG:
 675         X(DWORD) = type->tag;
 676         break;
 677
 678     case TI_GET_TYPE:
 679     case TI_GET_TYPEID:
 680         switch (type->tag)
 681         {
 682             /* hierarchical => hierarchical */
 683         case SymTagArrayType:
 684             X(DWORD) = (DWORD)((const struct symt_array*)type)->basetype;
 685             break;
 686         case SymTagPointerType:
 687             X(DWORD) = (DWORD)((const struct symt_pointer*)type)->pointsto;
 688             break;
 689         case SymTagFunctionType:
 690             X(DWORD) = (DWORD)((const struct symt_function_signature*)type)->rettype;
 691             break;
 692         case SymTagTypedef:
 693             X(DWORD) = (DWORD)((const struct symt_typedef*)type)->type;
 694             break;
 695             /* lexical => hierarchical */
 696         case SymTagData:
 697             X(DWORD) = (DWORD)((const struct symt_data*)type)->type;
 698             break;
 699         case SymTagFunction:
 700             X(DWORD) = (DWORD)((const struct symt_function*)type)->type;
 701             break;
 702             /* FIXME: should also work for enums and FunctionArgType */
 703         default:
 704             FIXME("Unsupported sym-tag %s for get-type\n",
 705                   symt_get_tag_str(type->tag));
 706         case SymTagThunk:
 707             return FALSE;
 708         }
 709         break;
 710
 711     case TI_GET_UDTKIND:
 712         if (type->tag != SymTagUDT) return FALSE;
 713         X(DWORD) = ((const struct symt_udt*)type)->kind;
 714         break;
 715
 716     case TI_GET_VALUE:
 717         if (type->tag != SymTagData || ((const struct symt_data*)type)->kind != DataIsConstant)
 718             return FALSE;
 719         X(VARIANT) = ((const struct symt_data*)type)->u.value;
 720         break;
 721
 722 #undef X
 723
 724     case TI_GET_ADDRESSOFFSET:
 725     case TI_GET_ARRAYINDEXTYPEID:
 726     case TI_GET_CALLING_CONVENTION:
 727     case TI_GET_CLASSPARENTID:
 728     case TI_GET_SYMINDEX:
 729     case TI_GET_THISADJUST:
 730     case TI_GET_VIRTUALBASECLASS:
 731     case TI_GET_VIRTUALBASEPOINTEROFFSET:
 732     case TI_GET_VIRTUALTABLESHAPEID:
 733     case TI_IS_EQUIV_TO:
 734         FIXME("Unsupported GetInfo request (%u)\n", req);
 735         return FALSE;
 736     }
 737
 738     return TRUE;
 739 }
 740
 741 /******************************************************************
 742  *              SymGetTypeInfo (DBGHELP.@)
 743  *
 744  */
 745 BOOL WINAPI SymGetTypeInfo(HANDLE hProcess, unsigned long ModBase,
 746                            ULONG TypeId, IMAGEHLP_SYMBOL_TYPE_INFO GetType,
 747                            PVOID pInfo)
 748 {
 749     struct process*     pcs = process_find_by_handle(hProcess);
 750     struct module*      module;
 751
 752     if (!pcs) return FALSE;
 753
 754     module = module_find_by_addr(pcs, ModBase, DMT_UNKNOWN);
 755     if (!(module = module_get_debug(pcs, module)))
 756     {
 757         FIXME("Someone didn't properly set ModBase (0x%08lx)\n", ModBase);
 758         return FALSE;
 759     }
 760
 761     return symt_get_info((struct symt*)TypeId, GetType, pInfo);
 762 }
 763
 764 /******************************************************************
 765  *              SymGetTypeFromName (DBGHELP.@)
 766  *
 767  */
 768 BOOL WINAPI SymGetTypeFromName(HANDLE hProcess, unsigned long BaseOfDll,
 769                                LPSTR Name, PSYMBOL_INFO Symbol)
 770 {
 771     struct process*     pcs = process_find_by_handle(hProcess);
 772     struct module*      module;
 773     struct symt*        type;
 774
 775     if (!pcs) return FALSE;
 776     module = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN);
 777     if (!module) return FALSE;
 778     type = symt_find_type_by_name(module, SymTagNull, Name);
 779     if (!type) return FALSE;
 780     Symbol->TypeIndex = (DWORD)type;
 781
 782     return TRUE;
 783 }