type.c 29.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * File types.c - management of types (hierarchical tree)
 *
 * Copyright (C) 1997, Eric Youngdale.
 *               2004, Eric Pouech.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * 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 22 23
 *
 * Note: This really doesn't do much at the moment, but it forms the framework
 * upon which full support for datatype handling will eventually be built.
 */
24 25 26

#define NONAMELESSUNION

27 28 29 30 31 32 33 34 35 36 37 38
#include "config.h"
#include <stdlib.h>
#include <stdarg.h>
#include <assert.h>

#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "wine/debug.h"
#include "dbghelp_private.h"

WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
39
WINE_DECLARE_DEBUG_CHANNEL(dbghelp_symt);
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

static const char* symt_get_tag_str(DWORD tag)
{
    switch (tag)
    {
    case SymTagNull:                    return "SymTagNull";
    case SymTagExe:                     return "SymTagExe";
    case SymTagCompiland:               return "SymTagCompiland";
    case SymTagCompilandDetails:        return "SymTagCompilandDetails";
    case SymTagCompilandEnv:            return "SymTagCompilandEnv";
    case SymTagFunction:                return "SymTagFunction";
    case SymTagBlock:                   return "SymTagBlock";
    case SymTagData:                    return "SymTagData";
    case SymTagAnnotation:              return "SymTagAnnotation";
    case SymTagLabel:                   return "SymTagLabel";
    case SymTagPublicSymbol:            return "SymTagPublicSymbol";
    case SymTagUDT:                     return "SymTagUDT";
    case SymTagEnum:                    return "SymTagEnum";
    case SymTagFunctionType:            return "SymTagFunctionType";
    case SymTagPointerType:             return "SymTagPointerType";
    case SymTagArrayType:               return "SymTagArrayType";
    case SymTagBaseType:                return "SymTagBaseType";
    case SymTagTypedef:                 return "SymTagTypedef,";
    case SymTagBaseClass:               return "SymTagBaseClass";
    case SymTagFriend:                  return "SymTagFriend";
    case SymTagFunctionArgType:         return "SymTagFunctionArgType,";
    case SymTagFuncDebugStart:          return "SymTagFuncDebugStart,";
    case SymTagFuncDebugEnd:            return "SymTagFuncDebugEnd";
    case SymTagUsingNamespace:          return "SymTagUsingNamespace,";
    case SymTagVTableShape:             return "SymTagVTableShape";
    case SymTagVTable:                  return "SymTagVTable";
    case SymTagCustom:                  return "SymTagCustom";
    case SymTagThunk:                   return "SymTagThunk";
    case SymTagCustomType:              return "SymTagCustomType";
    case SymTagManagedType:             return "SymTagManagedType";
    case SymTagDimension:               return "SymTagDimension";
    default:                            return "---";
    }
}

const char* symt_get_name(const struct symt* sym)
{
    switch (sym->tag)
    {
    /* lexical tree */
85 86 87 88
    case SymTagData:            return ((const struct symt_data*)sym)->hash_elt.name;
    case SymTagFunction:        return ((const struct symt_function*)sym)->hash_elt.name;
    case SymTagPublicSymbol:    return ((const struct symt_public*)sym)->hash_elt.name;
    case SymTagBaseType:        return ((const struct symt_basic*)sym)->hash_elt.name;
89
    case SymTagLabel:           return ((const struct symt_hierarchy_point*)sym)->hash_elt.name;
90
    case SymTagThunk:           return ((const struct symt_thunk*)sym)->hash_elt.name;
91
    /* hierarchy tree */
92 93 94
    case SymTagEnum:            return ((const struct symt_enum*)sym)->name;
    case SymTagTypedef:         return ((const struct symt_typedef*)sym)->hash_elt.name;
    case SymTagUDT:             return ((const struct symt_udt*)sym)->hash_elt.name;
95 96 97 98 99 100 101 102 103 104
    default:
        FIXME("Unsupported sym-tag %s\n", symt_get_tag_str(sym->tag));
        /* fall through */
    case SymTagArrayType:
    case SymTagPointerType:
    case SymTagFunctionType:
        return NULL;
    }
}

105
static struct symt* symt_find_type_by_name(const struct module* module,
106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
                                           enum SymTagEnum sym_tag, 
                                           const char* typename)
{
    void*                       ptr;
    struct symt_ht*             type;
    struct hash_table_iter      hti;

    assert(typename);
    assert(module);

    hash_table_iter_init(&module->ht_types, &hti, typename);
    while ((ptr = hash_table_iter_up(&hti)))
    {
        type = GET_ENTRY(ptr, struct symt_ht, hash_elt);

        if ((sym_tag == SymTagNull || type->symt.tag == sym_tag) &&
            type->hash_elt.name && !strcmp(type->hash_elt.name, typename))
            return &type->symt;
    }
    SetLastError(ERROR_INVALID_NAME); /* FIXME ?? */
    return NULL;
}

129 130 131 132 133 134 135 136
static void symt_add_type(struct module* module, struct symt* symt)
{
    struct symt**       p;
    p = vector_add(&module->vtypes, &module->pool);
    assert(p);
    *p = symt;
}

137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
struct symt_basic* symt_new_basic(struct module* module, enum BasicType bt, 
                                  const char* typename, unsigned size)
{
    struct symt_basic*          sym;

    if (typename)
    {
        sym = (struct symt_basic*)symt_find_type_by_name(module, SymTagBaseType,
                                                         typename);
        if (sym && sym->bt == bt && sym->size == size)
            return sym;
    }
    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag = SymTagBaseType;
        if (typename)
        {
            sym->hash_elt.name = pool_strdup(&module->pool, typename);
            hash_table_add(&module->ht_types, &sym->hash_elt);
        } else sym->hash_elt.name = NULL;
        sym->bt = bt;
        sym->size = size;
159
        symt_add_type(module, &sym->symt);
160 161 162 163 164 165 166 167 168
    }
    return sym;
}

struct symt_udt* symt_new_udt(struct module* module, const char* typename, 
                              unsigned size, enum UdtKind kind)
{
    struct symt_udt*            sym;

169 170
    TRACE_(dbghelp_symt)("Adding udt %s:%s\n",
                         debugstr_w(module->module.ModuleName), typename);
171 172 173 174 175 176 177 178 179 180 181
    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag = SymTagUDT;
        sym->kind     = kind;
        sym->size     = size;
        if (typename)
        {
            sym->hash_elt.name = pool_strdup(&module->pool, typename);
            hash_table_add(&module->ht_types, &sym->hash_elt);
        } else sym->hash_elt.name = NULL;
        vector_init(&sym->vchildren, sizeof(struct symt*), 8);
182
        symt_add_type(module, &sym->symt);
183 184 185 186 187 188 189 190 191 192
    }
    return sym;
}

BOOL symt_set_udt_size(struct module* module, struct symt_udt* udt, unsigned size)
{
    assert(udt->symt.tag == SymTagUDT);
    if (vector_length(&udt->vchildren) != 0)
    {
        if (udt->size != size)
193 194
            FIXME_(dbghelp_symt)("Changing size for %s from %u to %u\n", 
                                 udt->hash_elt.name, udt->size, size);
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
        return TRUE;
    }
    udt->size = size;
    return TRUE;
}

/******************************************************************
 *		symt_add_udt_element
 *
 * add an element to a udt (struct, class, union)
 * the size & offset parameters are expressed in bits (not bytes) so that
 * we can mix in the single call bytes aligned elements (regular fields) and
 * the others (bit fields)
 */
BOOL symt_add_udt_element(struct module* module, struct symt_udt* udt_type,
                          const char* name, struct symt* elt_type,
                          unsigned offset, unsigned size)
{
    struct symt_data*   m;
    struct symt**       p;

    assert(udt_type->symt.tag == SymTagUDT);

218
    TRACE_(dbghelp_symt)("Adding %s to UDT %s\n", name, udt_type->hash_elt.name);
219
    if (name)
220
    {
221
        unsigned int    i;
222
        for (i=0; i<vector_length(&udt_type->vchildren); i++)
223
        {
224
            m = *(struct symt_data**)vector_at(&udt_type->vchildren, i);
225 226 227 228 229
            assert(m);
            assert(m->symt.tag == SymTagData);
            if (strcmp(m->hash_elt.name, name) == 0)
                return TRUE;
        }
230 231 232 233 234
    }

    if ((m = pool_alloc(&module->pool, sizeof(*m))) == NULL) return FALSE;
    memset(m, 0, sizeof(*m));
    m->symt.tag      = SymTagData;
235
    m->hash_elt.name = name ? pool_strdup(&module->pool, name) : "";
236 237
    m->hash_elt.next = NULL;

238 239 240 241 242
    m->kind            = DataIsMember;
    m->container       = &udt_type->symt;
    m->type            = elt_type;
    m->u.member.offset = offset;
    m->u.member.length = ((offset & 7) || (size & 7)) ? size : 0;
243 244 245 246 247 248
    p = vector_add(&udt_type->vchildren, &module->pool);
    *p = &m->symt;

    return TRUE;
}

249 250
struct symt_enum* symt_new_enum(struct module* module, const char* typename,
                                struct symt* basetype)
251 252 253 254 255 256
{
    struct symt_enum*   sym;

    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag            = SymTagEnum;
257
        sym->name = (typename) ? pool_strdup(&module->pool, typename) : NULL;
258
        sym->base_type           = basetype;
259 260 261 262 263 264
        vector_init(&sym->vchildren, sizeof(struct symt*), 8);
    }
    return sym;
}

BOOL symt_add_enum_element(struct module* module, struct symt_enum* enum_type,
265
                           const char* name, int value)
266 267 268 269 270 271 272 273 274 275 276 277 278
{
    struct symt_data*   e;
    struct symt**       p;

    assert(enum_type->symt.tag == SymTagEnum);
    e = pool_alloc(&module->pool, sizeof(*e));
    if (e == NULL) return FALSE;

    e->symt.tag = SymTagData;
    e->hash_elt.name = pool_strdup(&module->pool, name);
    e->hash_elt.next = NULL;
    e->kind = DataIsConstant;
    e->container = &enum_type->symt;
279
    e->type = enum_type->base_type;
280 281
    e->u.value.n1.n2.vt = VT_I4;
    e->u.value.n1.n2.n3.lVal = value;
282 283 284 285 286 287 288 289 290

    p = vector_add(&enum_type->vchildren, &module->pool);
    if (!p) return FALSE; /* FIXME we leak e */
    *p = &e->symt;

    return TRUE;
}

struct symt_array* symt_new_array(struct module* module, int min, int max, 
291
                                  struct symt* base, struct symt* index)
292 293 294 295 296
{
    struct symt_array*  sym;

    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
297 298 299 300 301
        sym->symt.tag   = SymTagArrayType;
        sym->start      = min;
        sym->end        = max;
        sym->base_type  = base;
        sym->index_type = index;
302
        symt_add_type(module, &sym->symt);
303 304 305 306 307
    }
    return sym;
}

struct symt_function_signature* symt_new_function_signature(struct module* module, 
308 309
                                                            struct symt* ret_type,
                                                            enum CV_call_e call_conv)
310
{
311
    struct symt_function_signature*     sym;
312 313 314 315 316

    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag = SymTagFunctionType;
        sym->rettype  = ret_type;
317
        vector_init(&sym->vchildren, sizeof(struct symt*), 4);
318
        sym->call_conv = call_conv;
319
        symt_add_type(module, &sym->symt);
320 321 322 323
    }
    return sym;
}

324 325 326 327
BOOL symt_add_function_signature_parameter(struct module* module,
                                           struct symt_function_signature* sig_type,
                                           struct symt* param)
{
328 329
    struct symt**                       p;
    struct symt_function_arg_type*      arg;
330 331

    assert(sig_type->symt.tag == SymTagFunctionType);
332 333 334 335 336
    arg = pool_alloc(&module->pool, sizeof(*arg));
    if (!arg) return FALSE;
    arg->symt.tag = SymTagFunctionArgType;
    arg->arg_type = param;
    arg->container = &sig_type->symt;
337
    p = vector_add(&sig_type->vchildren, &module->pool);
338 339
    if (!p) return FALSE; /* FIXME we leak arg */
    *p = &arg->symt;
340 341 342 343

    return TRUE;
}

344 345 346 347 348 349 350 351
struct symt_pointer* symt_new_pointer(struct module* module, struct symt* ref_type)
{
    struct symt_pointer*        sym;

    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag = SymTagPointerType;
        sym->pointsto = ref_type;
352
        symt_add_type(module, &sym->symt);
353 354 355 356
    }
    return sym;
}

357 358 359 360 361 362 363 364 365 366 367
struct symt_typedef* symt_new_typedef(struct module* module, struct symt* ref, 
                                      const char* name)
{
    struct symt_typedef* sym;

    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag = SymTagTypedef;
        sym->type     = ref;
        sym->hash_elt.name = pool_strdup(&module->pool, name);
        hash_table_add(&module->ht_types, &sym->hash_elt);
368
        symt_add_type(module, &sym->symt);
369 370 371 372
    }
    return sym;
}

373 374 375 376
/******************************************************************
 *		SymEnumTypes (DBGHELP.@)
 *
 */
377
BOOL WINAPI SymEnumTypes(HANDLE hProcess, ULONG64 BaseOfDll,
378
                         PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
379
                         PVOID UserContext)
380
{
Eric Pouech's avatar
Eric Pouech committed
381
    struct module_pair  pair;
382 383 384 385
    char                buffer[sizeof(SYMBOL_INFO) + 256];
    SYMBOL_INFO*        sym_info = (SYMBOL_INFO*)buffer;
    const char*         tmp;
    struct symt*        type;
386
    DWORD64             size;
387
    unsigned int        i;
388

389 390 391
    TRACE("(%p %s %p %p)\n",
          hProcess, wine_dbgstr_longlong(BaseOfDll), EnumSymbolsCallback,
          UserContext);
392

393 394 395
    if (!(pair.pcs = process_find_by_handle(hProcess))) return FALSE;
    pair.requested = module_find_by_addr(pair.pcs, BaseOfDll, DMT_UNKNOWN);
    if (!module_get_debug(&pair)) return FALSE;
396 397 398 399

    sym_info->SizeOfStruct = sizeof(SYMBOL_INFO);
    sym_info->MaxNameLen = sizeof(buffer) - sizeof(SYMBOL_INFO);

400
    for (i=0; i<vector_length(&pair.effective->vtypes); i++)
401
    {
402
        type = *(struct symt**)vector_at(&pair.effective->vtypes, i);
403 404
        sym_info->TypeIndex = (DWORD)type;
        sym_info->info = 0; /* FIXME */
405 406
        symt_get_info(type, TI_GET_LENGTH, &size);
        sym_info->Size = size;
Eric Pouech's avatar
Eric Pouech committed
407
        sym_info->ModBase = pair.requested->module.BaseOfImage;
408 409 410 411 412
        sym_info->Flags = 0; /* FIXME */
        sym_info->Value = 0; /* FIXME */
        sym_info->Address = 0; /* FIXME */
        sym_info->Register = 0; /* FIXME */
        sym_info->Scope = 0; /* FIXME */
413 414 415 416
        sym_info->Tag = type->tag;
        tmp = symt_get_name(type);
        if (tmp)
        {
417 418 419 420 421 422
            sym_info->NameLen = min(strlen(tmp),sym_info->MaxNameLen-1);
            memcpy(sym_info->Name, tmp, sym_info->NameLen);
            sym_info->Name[sym_info->NameLen] = '\0';
        }
        else
           sym_info->Name[sym_info->NameLen = 0] = '\0';
423 424 425 426 427
        if (!EnumSymbolsCallback(sym_info, sym_info->Size, UserContext)) break;
    }
    return TRUE;
}

428 429 430 431 432 433 434
struct enum_types_AtoW
{
    char                                buffer[sizeof(SYMBOL_INFOW) + 256 * sizeof(WCHAR)];
    void*                               user;
    PSYM_ENUMERATESYMBOLS_CALLBACKW     callback;
};

435
static BOOL CALLBACK enum_types_AtoW(PSYMBOL_INFO si, ULONG addr, PVOID _et)
436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459
{
    struct enum_types_AtoW*     et = _et;
    SYMBOL_INFOW*               siW = (SYMBOL_INFOW*)et->buffer;

    copy_symbolW(siW, si);
    return et->callback(siW, addr, et->user);
}

/******************************************************************
 *		SymEnumTypesW (DBGHELP.@)
 *
 */
BOOL WINAPI SymEnumTypesW(HANDLE hProcess, ULONG64 BaseOfDll,
                          PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
                          PVOID UserContext)
{
    struct enum_types_AtoW     et;

    et.callback = EnumSymbolsCallback;
    et.user = UserContext;

    return SymEnumTypes(hProcess, BaseOfDll, enum_types_AtoW, &et);
}

460 461 462
/******************************************************************
 *		symt_get_info
 *
463
 * Retrieves information about a symt (either symbol or type)
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485
 */
BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req, 
                   void* pInfo)
{
    unsigned            len;

    if (!type) return FALSE;

/* helper to typecast pInfo to its expected type (_t) */
#define X(_t) (*((_t*)pInfo))

    switch (req)
    {
    case TI_FINDCHILDREN:
        {
            const struct vector*        v;
            struct symt**               pt;
            unsigned                    i;
            TI_FINDCHILDREN_PARAMS*     tifp = pInfo;

            switch (type->tag)
            {
486 487 488 489
            case SymTagUDT:          v = &((const struct symt_udt*)type)->vchildren; break;
            case SymTagEnum:         v = &((const struct symt_enum*)type)->vchildren; break;
            case SymTagFunctionType: v = &((const struct symt_function_signature*)type)->vchildren; break;
            case SymTagFunction:     v = &((const struct symt_function*)type)->vchildren; break;
490
            default:
491 492
                FIXME("Unsupported sym-tag %s for find-children\n", 
                      symt_get_tag_str(type->tag));
493 494 495 496 497 498 499 500 501 502 503 504 505 506
                return FALSE;
            }
            for (i = 0; i < tifp->Count; i++)
            {
                if (!(pt = vector_at(v, tifp->Start + i))) return FALSE;
                tifp->ChildId[i] = (DWORD)*pt;
            }
        }
        break;

    case TI_GET_ADDRESS:
        switch (type->tag)
        {
        case SymTagData:
507
            switch (((const struct symt_data*)type)->kind)
508 509 510
            {
            case DataIsGlobal:
            case DataIsFileStatic:
511
                X(ULONG64) = ((const struct symt_data*)type)->u.var.offset;
512 513 514 515 516
                break;
            default: return FALSE;
            }
            break;
        case SymTagFunction:
517
            X(ULONG64) = ((const struct symt_function*)type)->address;
518 519
            break;
        case SymTagPublicSymbol:
520
            X(ULONG64) = ((const struct symt_public*)type)->address;
521
            break;
522 523 524
        case SymTagFuncDebugStart:
        case SymTagFuncDebugEnd:
        case SymTagLabel:
525 526 527 528
            if (!symt_get_info(((const struct symt_hierarchy_point*)type)->parent,
                               req, pInfo))
                return FALSE;
            X(ULONG64) += ((const struct symt_hierarchy_point*)type)->loc.offset;
529 530
            break;
        case SymTagThunk:
531
            X(ULONG64) = ((const struct symt_thunk*)type)->address;
532
            break;
533 534 535
        case SymTagCompiland:
            X(ULONG64) = ((const struct symt_compiland*)type)->address;
            break;
536
        default:
537 538
            FIXME("Unsupported sym-tag %s for get-address\n", 
                  symt_get_tag_str(type->tag));
539 540 541 542 543
            return FALSE;
        }
        break;

    case TI_GET_BASETYPE:
544 545 546
        switch (type->tag)
        {
        case SymTagBaseType:
547
            X(DWORD) = ((const struct symt_basic*)type)->bt;
548 549 550 551 552 553 554
            break;
        case SymTagEnum:
            X(DWORD) = btInt;
            break;
        default:
            return FALSE;
        }
555 556 557
        break;

    case TI_GET_BITPOSITION:
558 559 560 561 562
        if (type->tag == SymTagData &&
            ((const struct symt_data*)type)->kind == DataIsMember &&
            ((const struct symt_data*)type)->u.member.length != 0)
            X(DWORD) = ((const struct symt_data*)type)->u.member.offset & 7;
        else return FALSE;
563 564 565 566 567 568
        break;

    case TI_GET_CHILDRENCOUNT:
        switch (type->tag)
        {
        case SymTagUDT:
569
            X(DWORD) = vector_length(&((const struct symt_udt*)type)->vchildren);
570 571
            break;
        case SymTagEnum:
572
            X(DWORD) = vector_length(&((const struct symt_enum*)type)->vchildren);
573
            break;
574
        case SymTagFunctionType:
575
            X(DWORD) = vector_length(&((const struct symt_function_signature*)type)->vchildren);
576 577
            break;
        case SymTagFunction:
578
            X(DWORD) = vector_length(&((const struct symt_function*)type)->vchildren);
579 580 581
            break;
        case SymTagPointerType: /* MS does it that way */
        case SymTagArrayType: /* MS does it that way */
582
        case SymTagThunk: /* MS does it that way */
583 584
            X(DWORD) = 0;
            break;
585
        default:
586 587
            FIXME("Unsupported sym-tag %s for get-children-count\n", 
                  symt_get_tag_str(type->tag));
588
            /* fall through */
589
        case SymTagData:
590 591 592 593 594 595 596
        case SymTagPublicSymbol:
        case SymTagBaseType:
            return FALSE;
        }
        break;

    case TI_GET_COUNT:
597 598 599 600 601 602 603 604 605 606 607 608 609 610
        switch (type->tag)
        {
        case SymTagArrayType:
            X(DWORD) = ((const struct symt_array*)type)->end - 
                ((const struct symt_array*)type)->start + 1;
            break;
        case SymTagFunctionType:
            /* this seems to be wrong for (future) C++ methods, where 'this' parameter
             * should be included in this value (and not in GET_CHILDREN_COUNT)
             */
            X(DWORD) = vector_length(&((const struct symt_function_signature*)type)->vchildren);
            break;
        default: return FALSE;
        }
611 612 613 614
        break;

    case TI_GET_DATAKIND:
        if (type->tag != SymTagData) return FALSE;
615
        X(DWORD) = ((const struct symt_data*)type)->kind;
616 617 618 619 620 621
        break;

    case TI_GET_LENGTH:
        switch (type->tag)
        {
        case SymTagBaseType:
622
            X(DWORD64) = ((const struct symt_basic*)type)->size;
623 624
            break;
        case SymTagFunction:
625
            X(DWORD64) = ((const struct symt_function*)type)->size;
626 627
            break;
        case SymTagPointerType:
628
            X(DWORD64) = sizeof(void*);
629 630
            break;
        case SymTagUDT:
631
            X(DWORD64) = ((const struct symt_udt*)type)->size;
632 633
            break;
        case SymTagEnum:
634
            X(DWORD64) = sizeof(int); /* FIXME: should be size of base-type of enum !!! */
635 636
            break;
        case SymTagData:
637
            if (((const struct symt_data*)type)->kind != DataIsMember ||
638
                !((const struct symt_data*)type)->u.member.length)
639
                return FALSE;
640
            X(DWORD64) = ((const struct symt_data*)type)->u.member.length;
641 642
            break;
        case SymTagArrayType:   
643
            if (!symt_get_info(((const struct symt_array*)type)->base_type, 
644 645
                               TI_GET_LENGTH, pInfo))
                return FALSE;
646
            X(DWORD64) *= ((const struct symt_array*)type)->end - 
647
                ((const struct symt_array*)type)->start + 1;
648 649
            break;
        case SymTagPublicSymbol:
650
            X(DWORD64) = ((const struct symt_public*)type)->size;
651
            break;
652
        case SymTagTypedef:
653 654
            return symt_get_info(((const struct symt_typedef*)type)->type, TI_GET_LENGTH, pInfo);
        case SymTagThunk:
655
            X(DWORD64) = ((const struct symt_thunk*)type)->size;
656
            break;
657 658 659
        case SymTagLabel:
            X(DWORD64) = 0;
            break;
660
        default:
661 662
            FIXME("Unsupported sym-tag %s for get-length\n", 
                  symt_get_tag_str(type->tag));
663 664
            /* fall through */
        case SymTagFunctionType:
665 666 667 668 669 670 671 672
            return 0;
        }
        break;

    case TI_GET_LEXICALPARENT:
        switch (type->tag)
        {
        case SymTagBlock:
673
            X(DWORD) = (DWORD)((const struct symt_block*)type)->container;
674 675
            break;
        case SymTagData:
676 677 678 679 680 681 682
            X(DWORD) = (DWORD)((const struct symt_data*)type)->container;
            break;
        case SymTagFunction:
            X(DWORD) = (DWORD)((const struct symt_function*)type)->container;
            break;
        case SymTagThunk:
            X(DWORD) = (DWORD)((const struct symt_thunk*)type)->container;
683
            break;
684 685 686
        case SymTagFunctionArgType:
            X(DWORD) = (DWORD)((const struct symt_function_arg_type*)type)->container;
            break;
687
        default:
688 689 690 691 692 693 694 695 696 697 698 699 700 701
            FIXME("Unsupported sym-tag %s for get-lexical-parent\n", 
                  symt_get_tag_str(type->tag));
            return FALSE;
        }
        break;

    case TI_GET_NESTED:
        switch (type->tag)
        {
        case SymTagUDT:
        case SymTagEnum:
            X(DWORD) = 0;
            break;
        default:
702 703 704 705 706 707 708 709
            return FALSE;
        }
        break;

    case TI_GET_OFFSET:
        switch (type->tag)
        {
        case SymTagData:
710
            switch (((const struct symt_data*)type)->kind)
711
            {
712 713
            case DataIsParam:
            case DataIsLocal:
714 715
                X(ULONG) = ((const struct symt_data*)type)->u.var.offset; 
                break;
716
            case DataIsMember:
717
                X(ULONG) = ((const struct symt_data*)type)->u.member.offset >> 3; 
718 719
                break;
            default:
720
                FIXME("Unknown kind (%u) for get-offset\n",     
721
                      ((const struct symt_data*)type)->kind);
722
                return FALSE;
723 724 725
            }
            break;
        default:
726 727
            FIXME("Unsupported sym-tag %s for get-offset\n", 
                  symt_get_tag_str(type->tag));
728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
            return FALSE;
        }
        break;

    case TI_GET_SYMNAME:
        {
            const char* name = symt_get_name(type);
            if (!name) return FALSE;
            len = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0);
            X(WCHAR*) = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
            if (!X(WCHAR*)) return FALSE;
            MultiByteToWideChar(CP_ACP, 0, name, -1, X(WCHAR*), len);
        }
        break;

    case TI_GET_SYMTAG:
        X(DWORD) = type->tag;
        break;

    case TI_GET_TYPE:
748
    case TI_GET_TYPEID:
749 750
        switch (type->tag)
        {
751
            /* hierarchical => hierarchical */
752
        case SymTagArrayType:
753
            X(DWORD) = (DWORD)((const struct symt_array*)type)->base_type;
754 755
            break;
        case SymTagPointerType:
756
            X(DWORD) = (DWORD)((const struct symt_pointer*)type)->pointsto;
757 758
            break;
        case SymTagFunctionType:
759
            X(DWORD) = (DWORD)((const struct symt_function_signature*)type)->rettype;
760
            break;
761
        case SymTagTypedef:
762
            X(DWORD) = (DWORD)((const struct symt_typedef*)type)->type;
763 764
            break;
            /* lexical => hierarchical */
765
        case SymTagData:
766
            X(DWORD) = (DWORD)((const struct symt_data*)type)->type; 
767
            break;
768
        case SymTagFunction:
769
            X(DWORD) = (DWORD)((const struct symt_function*)type)->type;
770
            break;
771 772 773
        case SymTagEnum:
            X(DWORD) = (DWORD)((const struct symt_enum*)type)->base_type;
            break;
774 775 776
        case SymTagFunctionArgType:
            X(DWORD) = (DWORD)((const struct symt_function_arg_type*)type)->arg_type;
            break;
777
        default:
778 779
            FIXME("Unsupported sym-tag %s for get-type\n", 
                  symt_get_tag_str(type->tag));
780
        case SymTagPublicSymbol:
781
        case SymTagThunk:
782
        case SymTagLabel:
783 784 785 786 787 788
            return FALSE;
        }
        break;

    case TI_GET_UDTKIND:
        if (type->tag != SymTagUDT) return FALSE;
789
        X(DWORD) = ((const struct symt_udt*)type)->kind;
790 791
        break;

792
    case TI_GET_VALUE:
793
        if (type->tag != SymTagData || ((const struct symt_data*)type)->kind != DataIsConstant)
794
            return FALSE;
795
        X(VARIANT) = ((const struct symt_data*)type)->u.value;
796 797
        break;

798 799 800 801 802 803 804 805 806
    case TI_GET_CALLING_CONVENTION:
        if (type->tag != SymTagFunctionType) return FALSE;
        if (((const struct symt_function_signature*)type)->call_conv == -1)
        {
            FIXME("No support for calling convention for this signature\n");
            X(DWORD) = CV_CALL_FAR_C; /* FIXME */
        }
        else X(DWORD) = ((const struct symt_function_signature*)type)->call_conv;
        break;
807 808 809 810
    case TI_GET_ARRAYINDEXTYPEID:
        if (type->tag != SymTagArrayType) return FALSE;
        X(DWORD) = (DWORD)((const struct symt_array*)type)->index_type;
        break;
811

812 813 814 815 816 817
    case TI_GET_CLASSPARENTID:
        /* FIXME: we don't support properly C++ for now, pretend this symbol doesn't
         * belong to a parent class
         */
        return FALSE;

818 819 820 821 822 823 824 825 826 827 828
#undef X

    case TI_GET_ADDRESSOFFSET:
    case TI_GET_SYMINDEX:
    case TI_GET_THISADJUST:
    case TI_GET_VIRTUALBASECLASS:
    case TI_GET_VIRTUALBASEPOINTEROFFSET:
    case TI_GET_VIRTUALTABLESHAPEID:
    case TI_IS_EQUIV_TO:
        FIXME("Unsupported GetInfo request (%u)\n", req);
        return FALSE;
829 830 831
    default:
        FIXME("Unknown GetInfo request (%u)\n", req);
        return FALSE;
832 833 834 835 836 837 838 839 840
    }

    return TRUE;
}

/******************************************************************
 *		SymGetTypeInfo (DBGHELP.@)
 *
 */
841
BOOL WINAPI SymGetTypeInfo(HANDLE hProcess, DWORD64 ModBase,
842 843 844
                           ULONG TypeId, IMAGEHLP_SYMBOL_TYPE_INFO GetType,
                           PVOID pInfo)
{
Eric Pouech's avatar
Eric Pouech committed
845
    struct module_pair  pair;
846

847 848
    pair.pcs = process_find_by_handle(hProcess);
    if (!pair.pcs) return FALSE;
849

850 851
    pair.requested = module_find_by_addr(pair.pcs, ModBase, DMT_UNKNOWN);
    if (!module_get_debug(&pair))
852
    {
853
        FIXME("Someone didn't properly set ModBase (%s)\n", wine_dbgstr_longlong(ModBase));
854 855
        return FALSE;
    }
856 857 858 859 860 861 862 863

    return symt_get_info((struct symt*)TypeId, GetType, pInfo);
}

/******************************************************************
 *		SymGetTypeFromName (DBGHELP.@)
 *
 */
864
BOOL WINAPI SymGetTypeFromName(HANDLE hProcess, ULONG64 BaseOfDll,
865
                               PCSTR Name, PSYMBOL_INFO Symbol)
866 867 868 869 870 871 872 873 874 875 876 877 878 879
{
    struct process*     pcs = process_find_by_handle(hProcess);
    struct module*      module;
    struct symt*        type;

    if (!pcs) return FALSE;
    module = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN);
    if (!module) return FALSE;
    type = symt_find_type_by_name(module, SymTagNull, Name);
    if (!type) return FALSE;
    Symbol->TypeIndex = (DWORD)type;

    return TRUE;
}