type.c File Reference

#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"

Include dependency graph for type.c:

Go to the source code of this file.

Classes
struct	enum_types_AtoW

Macros
#define	NONAMELESSUNION
#define	X(_t)   (*((_t*)pInfo))

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (dbghelp)
	WINE_DECLARE_DEBUG_CHANNEL (dbghelp_symt)
static const char *	symt_get_tag_str (DWORD tag)
const char *	symt_get_name (const struct symt *sym)
WCHAR *	symt_get_nameW (const struct symt *sym)
BOOL	symt_get_address (const struct symt *type, ULONG64 *addr)
static struct symt *	symt_find_type_by_name (const struct module *module, enum SymTagEnum sym_tag, const char *typename)
static void	symt_add_type (struct module *module, struct symt *symt)
struct symt_basic *	symt_new_basic (struct module *module, enum BasicType bt, const char *typename, unsigned size)
struct symt_udt *	symt_new_udt (struct module *module, const char *typename, unsigned size, enum UdtKind kind)
BOOL	symt_set_udt_size (struct module *module, struct symt_udt *udt, unsigned size)
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_enum *	symt_new_enum (struct module *module, const char *typename, struct symt *basetype)
BOOL	symt_add_enum_element (struct module *module, struct symt_enum *enum_type, const char *name, int value)
struct symt_array *	symt_new_array (struct module *module, int min, int max, struct symt *base, struct symt *index)
static DWORD	symt_array_count (struct module *module, const struct symt_array *array)
struct symt_function_signature *	symt_new_function_signature (struct module *module, struct symt *ret_type, enum CV_call_e call_conv)
BOOL	symt_add_function_signature_parameter (struct module *module, struct symt_function_signature *sig_type, struct symt *param)
struct symt_pointer *	symt_new_pointer (struct module *module, struct symt *ref_type, ULONG_PTR size)
struct symt_typedef *	symt_new_typedef (struct module *module, struct symt *ref, const char *name)
BOOL WINAPI	SymEnumTypes (HANDLE hProcess, ULONG64 BaseOfDll, PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, PVOID UserContext)
static BOOL CALLBACK	enum_types_AtoW (PSYMBOL_INFO si, ULONG addr, PVOID _et)
BOOL WINAPI	SymEnumTypesW (HANDLE hProcess, ULONG64 BaseOfDll, PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, PVOID UserContext)
BOOL	symt_get_info (struct module *module, const struct symt *type, IMAGEHLP_SYMBOL_TYPE_INFO req, void *pInfo)
BOOL WINAPI	SymGetTypeInfo (HANDLE hProcess, DWORD64 ModBase, ULONG TypeId, IMAGEHLP_SYMBOL_TYPE_INFO GetType, PVOID pInfo)
BOOL WINAPI	SymGetTypeFromName (HANDLE hProcess, ULONG64 BaseOfDll, PCSTR Name, PSYMBOL_INFO Symbol)

Macro Definition Documentation

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 26 of file type.c.

X

#define X

(

_t

)

(*((_t*)pInfo))

Function Documentation

enum_types_AtoW()

static BOOL CALLBACK enum_types_AtoW ( PSYMBOL_INFO  si, ULONG  addr, PVOID  _et  )

static

Definition at line 508 of file type.c.

{
    struct enum_types_AtoW*     et = _et;
    SYMBOL_INFOW*               siW = (SYMBOL_INFOW*)et->buffer;
 
    copy_symbolW(siW, si);
    return et->callback(siW, addr, et->user);
}

SymEnumTypes()

BOOL WINAPI SymEnumTypes	(	HANDLE	hProcess,
		ULONG64	BaseOfDll,
		PSYM_ENUMERATESYMBOLS_CALLBACK	EnumSymbolsCallback,
		PVOID	UserContext
	)

Definition at line 450 of file type.c.

{
    struct module_pair  pair;
    char                buffer[sizeof(SYMBOL_INFO) + 256];
    SYMBOL_INFO*        sym_info = (SYMBOL_INFO*)buffer;
    const char*         tmp;
    struct symt*        type;
    DWORD64             size;
    unsigned int        i;
 
    TRACE("(%p %s %p %p)\n",
          hProcess, wine_dbgstr_longlong(BaseOfDll), EnumSymbolsCallback,
          UserContext);
 
    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;
 
    sym_info->SizeOfStruct = sizeof(SYMBOL_INFO);
    sym_info->MaxNameLen = sizeof(buffer) - sizeof(SYMBOL_INFO);
 
    for (i=0; i<vector_length(&pair.effective->vtypes); i++)
    {
        type = *(struct symt**)vector_at(&pair.effective->vtypes, i);
        sym_info->TypeIndex = symt_ptr2index(pair.effective, type);
        sym_info->Index = 0; /* FIXME */
        symt_get_info(pair.effective, type, TI_GET_LENGTH, &size);
        sym_info->Size = size;
        sym_info->ModBase = pair.requested->module.BaseOfImage;
        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 */
        sym_info->Tag = type->tag;
        tmp = symt_get_name(type);
        if (tmp)
        {
            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';
        if (!EnumSymbolsCallback(sym_info, sym_info->Size, UserContext)) break;
    }
    return TRUE;
}

Referenced by main(), and SymEnumTypesW().

SymEnumTypesW()

BOOL WINAPI SymEnumTypesW	(	HANDLE	hProcess,
		ULONG64	BaseOfDll,
		PSYM_ENUMERATESYMBOLS_CALLBACKW	EnumSymbolsCallback,
		PVOID	UserContext
	)

Definition at line 521 of file type.c.

{
    struct enum_types_AtoW     et;
 
    et.callback = EnumSymbolsCallback;
    et.user = UserContext;
 
    return SymEnumTypes(hProcess, BaseOfDll, enum_types_AtoW, &et);
}

SymGetTypeFromName()

BOOL WINAPI SymGetTypeFromName	(	HANDLE	hProcess,
		ULONG64	BaseOfDll,
		PCSTR	Name,
		PSYMBOL_INFO	Symbol
	)

Definition at line 925 of file type.c.

{
    struct process*     pcs = process_find_by_handle(hProcess);
    struct module_pair  pair;
    struct symt*        type;
 
    if (!pcs) return FALSE;
    pair.requested = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN);
    if (!module_get_debug(&pair)) return FALSE;
    type = symt_find_type_by_name(pair.effective, SymTagNull, Name);
    if (!type) return FALSE;
    Symbol->TypeIndex = symt_ptr2index(pair.effective, type);
 
    return TRUE;
}

SymGetTypeInfo()

BOOL WINAPI SymGetTypeInfo	(	HANDLE	hProcess,
		DWORD64	ModBase,
		ULONG	TypeId,
		IMAGEHLP_SYMBOL_TYPE_INFO	GetType,
		PVOID	pInfo
	)

Definition at line 902 of file type.c.

{
    struct module_pair  pair;
 
    pair.pcs = process_find_by_handle(hProcess);
    if (!pair.pcs) return FALSE;
 
    pair.requested = module_find_by_addr(pair.pcs, ModBase, DMT_UNKNOWN);
    if (!module_get_debug(&pair))
    {
        FIXME("Someone didn't properly set ModBase (%s)\n", wine_dbgstr_longlong(ModBase));
        return FALSE;
    }
 
    return symt_get_info(pair.effective, symt_index2ptr(pair.effective, TypeId), GetType, pInfo);
}

Referenced by DumpArray(), DumpBaseType(), DumpCV(), DumpEnum(), DumpFunction(), DumpPointer(), DumpType(), DumpUDT(), EnumParametersCallback(), and ParseImageSymbols().

symt_add_enum_element()

BOOL symt_add_enum_element	(	struct module *	module,
		struct symt_enum *	enum_type,
		const char *	name,
		int	value
	)

Definition at line 321 of file type.c.

{
    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;
    e->type = enum_type->base_type;
    e->u.value.n1.n2.vt = VT_I4;
    e->u.value.n1.n2.n3.lVal = value;
 
    p = vector_add(&enum_type->vchildren, &module->pool);
    if (!p) return FALSE; /* FIXME we leak e */
    *p = &e->symt;
 
    return TRUE;
}

Referenced by codeview_add_type_enum_field_list(), dwarf2_parse_enumerator(), and stabs_pts_read_enum().

symt_add_function_signature_parameter()

BOOL symt_add_function_signature_parameter	(	struct module *	module,
		struct symt_function_signature *	sig_type,
		struct symt *	param
	)

Definition at line 396 of file type.c.

{
    struct symt**                       p;
    struct symt_function_arg_type*      arg;
 
    assert(sig_type->symt.tag == SymTagFunctionType);
    arg = pool_alloc(&module->pool, sizeof(*arg));
    if (!arg) return FALSE;
    arg->symt.tag = SymTagFunctionArgType;
    arg->arg_type = param;
    arg->container = &sig_type->symt;
    p = vector_add(&sig_type->vchildren, &module->pool);
    if (!p) return FALSE; /* FIXME we leak arg */
    *p = &arg->symt;
 
    return TRUE;
}

Referenced by codeview_add_func_signature_args(), dwarf2_parse_subroutine_type(), dwarf2_parse_variable(), and stabs_parse().

symt_add_type()

static void symt_add_type ( struct module *  module, struct symt *  symt  )

static

Definition at line 186 of file type.c.

{
    struct symt**       p;
    p = vector_add(&module->vtypes, &module->pool);
    assert(p);
    *p = symt;
}

Referenced by symt_new_array(), symt_new_basic(), symt_new_function_signature(), symt_new_pointer(), symt_new_typedef(), and symt_new_udt().

symt_add_udt_element()

BOOL symt_add_udt_element	(	struct module *	module,
		struct symt_udt *	udt_type,
		const char *	name,
		struct symt *	elt_type,
		unsigned	offset,
		unsigned	size
	)

Definition at line 266 of file type.c.

{
    struct symt_data*   m;
    struct symt**       p;
 
    assert(udt_type->symt.tag == SymTagUDT);
 
    TRACE_(dbghelp_symt)("Adding %s to UDT %s\n", name, udt_type->hash_elt.name);
    if (name)
    {
        unsigned int    i;
        for (i=0; i<vector_length(&udt_type->vchildren); i++)
        {
            m = *(struct symt_data**)vector_at(&udt_type->vchildren, i);
            assert(m);
            assert(m->symt.tag == SymTagData);
            if (strcmp(m->hash_elt.name, name) == 0)
                return TRUE;
        }
    }
 
    if ((m = pool_alloc(&module->pool, sizeof(*m))) == NULL) return FALSE;
    memset(m, 0, sizeof(*m));
    m->symt.tag      = SymTagData;
    m->hash_elt.name = name ? pool_strdup(&module->pool, name) : "";
    m->hash_elt.next = NULL;
 
    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;
    p = vector_add(&udt_type->vchildren, &module->pool);
    *p = &m->symt;
 
    return TRUE;
}

Referenced by codeview_add_udt_element(), dwarf2_parse_udt_member(), and stabs_pts_read_aggregate().

symt_array_count()

static DWORD symt_array_count ( struct module *  module, const struct symt_array *  array  )

inlinestatic

Definition at line 364 of file type.c.

{
    if (array->end < 0)
    {
        DWORD64 elem_size;
        /* One could want to also set the array->end field in array, but we won't do it
         * as long as all the get_type() helpers use const objects
         */
        if (symt_get_info(module, array->base_type, TI_GET_LENGTH, &elem_size) && elem_size)
            return -array->end / (DWORD)elem_size;
        return 0;
    }
    return array->end - array->start + 1;
}

Referenced by symt_get_info().

symt_find_type_by_name()

static struct symt * symt_find_type_by_name ( const struct module *  module, enum SymTagEnum  sym_tag, const char *  typename  )

static

Definition at line 162 of file type.c.

{
    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 = CONTAINING_RECORD(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;
}

Referenced by SymGetTypeFromName(), and symt_new_basic().

symt_get_address()

BOOL symt_get_address	(	const struct symt *	type,
		ULONG64 *	addr
	)

Definition at line 121 of file type.c.

{
    switch (type->tag)
    {
    case SymTagData:
        switch (((const struct symt_data*)type)->kind)
        {
        case DataIsGlobal:
        case DataIsFileStatic:
            *addr = ((const struct symt_data*)type)->u.var.offset;
            break;
        default: return FALSE;
        }
        break;
    case SymTagFunction:
        *addr = ((const struct symt_function*)type)->address;
        break;
    case SymTagPublicSymbol:
        *addr = ((const struct symt_public*)type)->address;
        break;
    case SymTagFuncDebugStart:
    case SymTagFuncDebugEnd:
    case SymTagLabel:
        if (!((const struct symt_hierarchy_point*)type)->parent ||
            !symt_get_address(((const struct symt_hierarchy_point*)type)->parent, addr))
            return FALSE;
        *addr += ((const struct symt_hierarchy_point*)type)->loc.offset;
        break;
    case SymTagThunk:
        *addr = ((const struct symt_thunk*)type)->address;
        break;
    case SymTagCompiland:
        *addr = ((const struct symt_compiland*)type)->address;
        break;
    default:
        FIXME("Unsupported sym-tag %s for get-address\n", symt_get_tag_str(type->tag));
        return FALSE;
    }
    return TRUE;
}

Referenced by cmp_sorttab_addr(), coff_process_info(), elf_new_wine_thunks(), macho_finish_stabs(), symt_add_module_ht(), symt_cmp_addr(), symt_fill_sym_info(), symt_find_nearest(), symt_get_address(), symt_get_best_at(), symt_get_info(), and where_to_insert().

symt_get_info()

BOOL symt_get_info	(	struct module *	module,
		const struct symt *	type,
		IMAGEHLP_SYMBOL_TYPE_INFO	req,
		void *	pInfo
	)

Definition at line 538 of file type.c.

{
    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)
            {
            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;
            default:
                FIXME("Unsupported sym-tag %s for find-children\n", 
                      symt_get_tag_str(type->tag));
                return FALSE;
            }
            for (i = 0; i < tifp->Count; i++)
            {
                if (!(pt = vector_at(v, tifp->Start + i))) return FALSE;
                tifp->ChildId[i] = symt_ptr2index(module, *pt);
            }
        }
        break;
 
    case TI_GET_ADDRESS:
        return symt_get_address(type, (ULONG64*)pInfo);
 
    case TI_GET_BASETYPE:
        switch (type->tag)
        {
        case SymTagBaseType:
            X(DWORD) = ((const struct symt_basic*)type)->bt;
            break;
        case SymTagEnum:
            X(DWORD) = btInt;
            break;
        default:
            return FALSE;
        }
        break;
 
    case TI_GET_BITPOSITION:
        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;
        break;
 
    case TI_GET_CHILDRENCOUNT:
        switch (type->tag)
        {
        case SymTagUDT:
            X(DWORD) = vector_length(&((const struct symt_udt*)type)->vchildren);
            break;
        case SymTagEnum:
            X(DWORD) = vector_length(&((const struct symt_enum*)type)->vchildren);
            break;
        case SymTagFunctionType:
            X(DWORD) = vector_length(&((const struct symt_function_signature*)type)->vchildren);
            break;
        case SymTagFunction:
            X(DWORD) = vector_length(&((const struct symt_function*)type)->vchildren);
            break;
        case SymTagPointerType: /* MS does it that way */
        case SymTagArrayType: /* MS does it that way */
        case SymTagThunk: /* MS does it that way */
            X(DWORD) = 0;
            break;
        default:
            FIXME("Unsupported sym-tag %s for get-children-count\n", 
                  symt_get_tag_str(type->tag));
            /* fall through */
        case SymTagData:
        case SymTagPublicSymbol:
        case SymTagBaseType:
            return FALSE;
        }
        break;
 
    case TI_GET_COUNT:
        switch (type->tag)
        {
        case SymTagArrayType:
            X(DWORD) = symt_array_count(module, (const struct symt_array*)type);
            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;
        }
        break;
 
    case TI_GET_DATAKIND:
        if (type->tag != SymTagData) return FALSE;
        X(DWORD) = ((const struct symt_data*)type)->kind;
        break;
 
    case TI_GET_LENGTH:
        switch (type->tag)
        {
        case SymTagBaseType:
            X(DWORD64) = ((const struct symt_basic*)type)->size;
            break;
        case SymTagFunction:
            X(DWORD64) = ((const struct symt_function*)type)->size;
            break;
        case SymTagPointerType:
            X(DWORD64) = ((const struct symt_pointer*)type)->size;
            break;
        case SymTagUDT:
            X(DWORD64) = ((const struct symt_udt*)type)->size;
            break;
        case SymTagEnum:
            X(DWORD64) = sizeof(int); /* FIXME: should be size of base-type of enum !!! */
            break;
        case SymTagData:
            if (((const struct symt_data*)type)->kind != DataIsMember ||
                !((const struct symt_data*)type)->u.member.length)
                return FALSE;
            X(DWORD64) = ((const struct symt_data*)type)->u.member.length;
            break;
        case SymTagArrayType:
            if (!symt_get_info(module, ((const struct symt_array*)type)->base_type,
                               TI_GET_LENGTH, pInfo))
                return FALSE;
            X(DWORD64) *= symt_array_count(module, (const struct symt_array*)type);
            break;
        case SymTagPublicSymbol:
            X(DWORD64) = ((const struct symt_public*)type)->size;
            break;
        case SymTagTypedef:
            return symt_get_info(module, ((const struct symt_typedef*)type)->type, TI_GET_LENGTH, pInfo);
        case SymTagThunk:
            X(DWORD64) = ((const struct symt_thunk*)type)->size;
            break;
        case SymTagLabel:
            X(DWORD64) = 0;
            break;
        default:
            FIXME("Unsupported sym-tag %s for get-length\n", 
                  symt_get_tag_str(type->tag));
            /* fall through */
        case SymTagFunctionType:
            return FALSE;
        }
        break;
 
    case TI_GET_LEXICALPARENT:
        switch (type->tag)
        {
        case SymTagBlock:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_block*)type)->container);
            break;
        case SymTagData:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_data*)type)->container);
            break;
        case SymTagFunction:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_function*)type)->container);
            break;
        case SymTagThunk:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_thunk*)type)->container);
            break;
        case SymTagFunctionArgType:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_function_arg_type*)type)->container);
            break;
        default:
            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:
            return FALSE;
        }
        break;
 
    case TI_GET_OFFSET:
        switch (type->tag)
        {
        case SymTagData:
            switch (((const struct symt_data*)type)->kind)
            {
            case DataIsParam:
            case DataIsLocal:
                X(ULONG) = ((const struct symt_data*)type)->u.var.offset; 
                break;
            case DataIsMember:
                X(ULONG) = ((const struct symt_data*)type)->u.member.offset >> 3; 
                break;
            default:
                FIXME("Unknown kind (%u) for get-offset\n",     
                      ((const struct symt_data*)type)->kind);
                return FALSE;
            }
            break;
        default:
            FIXME("Unsupported sym-tag %s for get-offset\n", 
                  symt_get_tag_str(type->tag));
            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:
    case TI_GET_TYPEID:
        switch (type->tag)
        {
            /* hierarchical => hierarchical */
        case SymTagArrayType:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_array*)type)->base_type);
            break;
        case SymTagPointerType:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_pointer*)type)->pointsto);
            break;
        case SymTagFunctionType:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_function_signature*)type)->rettype);
            break;
        case SymTagTypedef:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_typedef*)type)->type);
            break;
            /* lexical => hierarchical */
        case SymTagData:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_data*)type)->type);
            break;
        case SymTagFunction:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_function*)type)->type);
            break;
        case SymTagEnum:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_enum*)type)->base_type);
            break;
        case SymTagFunctionArgType:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_function_arg_type*)type)->arg_type);
            break;
        default:
            FIXME("Unsupported sym-tag %s for get-type\n", 
                  symt_get_tag_str(type->tag));
        /* fall through */
        case SymTagPublicSymbol:
        case SymTagThunk:
        case SymTagLabel:
            return FALSE;
        }
        break;
 
    case TI_GET_UDTKIND:
        if (type->tag != SymTagUDT) return FALSE;
        X(DWORD) = ((const struct symt_udt*)type)->kind;
        break;
 
    case TI_GET_VALUE:
        if (type->tag != SymTagData) return FALSE;
        switch (((const struct symt_data*)type)->kind)
        {
        case DataIsConstant: X(VARIANT) = ((const struct symt_data*)type)->u.value; break;
        case DataIsLocal:
        case DataIsParam:
            {
                struct location loc = ((const struct symt_data*)type)->u.var;
                unsigned                i;
                struct module_format*   modfmt;
 
                if (loc.kind < loc_user) return FALSE;
                for (i = 0; i < DFI_LAST; i++)
                {
                    modfmt = module->format_info[i];
                    if (modfmt && modfmt->loc_compute)
                    {
                        modfmt->loc_compute(module->process, modfmt,
                                            (const struct symt_function*)((const struct symt_data*)type)->container, &loc);
                        break;
                    }
                }
                if (loc.kind != loc_absolute) return FALSE;
                X(VARIANT).n1.n2.vt = VT_UI4; /* FIXME */
                X(VARIANT).n1.n2.n3.uiVal = loc.offset;
            }
            break;
        default: return FALSE;
        }
        break;
 
    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;
    case TI_GET_ARRAYINDEXTYPEID:
        if (type->tag != SymTagArrayType) return FALSE;
        X(DWORD) = symt_ptr2index(module, ((const struct symt_array*)type)->index_type);
        break;
 
    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;
 
#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;
    default:
        FIXME("Unknown GetInfo request (%u)\n", req);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by codeview_add_udt_element(), dwarf2_parse_udt_member(), macho_finish_stabs(), stabs_pts_read_aggregate(), SymEnumTypes(), SymGetTypeInfo(), symt_array_count(), symt_fill_sym_info(), symt_get_info(), symt_get_length(), and symt_new_global_variable().

symt_get_name()

const char * symt_get_name

(

const struct symt *

sym

)

Definition at line 83 of file type.c.

{
    switch (sym->tag)
    {
    /* lexical tree */
    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;
    case SymTagLabel:           return ((const struct symt_hierarchy_point*)sym)->hash_elt.name;
    case SymTagThunk:           return ((const struct symt_thunk*)sym)->hash_elt.name;
    /* hierarchy tree */
    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;
    default:
        FIXME("Unsupported sym-tag %s\n", symt_get_tag_str(sym->tag));
        /* fall through */
    case SymTagArrayType:
    case SymTagPointerType:
    case SymTagFunctionType:
        return NULL;
    }
}

Referenced by stabs_pts_read_aggregate(), stabs_pts_read_type_def(), SymEnumTypes(), symt_fill_sym_info(), symt_get_info(), and symt_get_nameW().

symt_get_nameW()

WCHAR * symt_get_nameW

(

const struct symt *

sym

)

Definition at line 108 of file type.c.

{
    const char* name = symt_get_name(sym);
    WCHAR* nameW;
    DWORD sz;
 
    if (!name) return NULL;
    sz = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0);
    if ((nameW = HeapAlloc(GetProcessHeap(), 0, sz * sizeof(WCHAR))))
        MultiByteToWideChar(CP_ACP, 0, name, -1, nameW, sz);
    return nameW;
}

Referenced by symt_enum_locals_helper(), and symt_enum_module().

symt_get_tag_str()

static const char * symt_get_tag_str ( DWORD  tag )

static

Definition at line 44 of file type.c.

{
    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 "---";
    }
}

Referenced by symt_get_address(), symt_get_info(), and symt_get_name().

symt_new_array()

struct symt_array * symt_new_array	(	struct module *	module,
		int	min,
		int	max,
		struct symt *	base,
		struct symt *	index
	)

Definition at line 347 of file type.c.

{
    struct symt_array*  sym;
 
    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag   = SymTagArrayType;
        sym->start      = min;
        sym->end        = max;
        sym->base_type  = base;
        sym->index_type = index;
        symt_add_type(module, &sym->symt);
    }
    return sym;
}

Referenced by codeview_add_type_array(), dwarf2_parse_array_type(), and stabs_pts_read_array().

symt_new_basic()

struct symt_basic * symt_new_basic	(	struct module *	module,
		enum BasicType	bt,
		const char *	typename,
		unsigned	size
	)

Definition at line 194 of file type.c.

{
    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;
        symt_add_type(module, &sym->symt);
    }
    return sym;
}

Referenced by codeview_init_basic_types(), dwarf2_parse_base_type(), dwarf2_parse_compilation_unit(), dwarf2_parse_enumeration_type(), dwarf2_parse_unspecified_type(), stabs_get_basic(), stabs_pts_read_range(), and stabs_pts_read_type_def().

symt_new_enum()

struct symt_enum * symt_new_enum	(	struct module *	module,
		const char *	typename,
		struct symt *	basetype
	)

Definition at line 306 of file type.c.

{
    struct symt_enum*   sym;
 
    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag            = SymTagEnum;
        sym->name = (typename) ? pool_strdup(&module->pool, typename) : NULL;
        sym->base_type           = basetype;
        vector_init(&sym->vchildren, sizeof(struct symt*), 8);
    }
    return sym;
}

Referenced by codeview_add_type_enum(), dwarf2_parse_enumeration_type(), and stabs_pts_read_type_def().

symt_new_function_signature()

struct symt_function_signature * symt_new_function_signature	(	struct module *	module,
		struct symt *	ret_type,
		enum CV_call_e	call_conv
	)

Definition at line 379 of file type.c.

{
    struct symt_function_signature*     sym;
 
    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag = SymTagFunctionType;
        sym->rettype  = ret_type;
        vector_init(&sym->vchildren, sizeof(struct symt*), 4);
        sym->call_conv = call_conv;
        symt_add_type(module, &sym->symt);
    }
    return sym;
}

Referenced by codeview_new_func_signature(), dwarf2_parse_subprogram(), dwarf2_parse_subroutine_type(), stabs_parse(), and stabs_pts_read_type_def().

symt_new_pointer()

struct symt_pointer * symt_new_pointer	(	struct module *	module,
		struct symt *	ref_type,
		ULONG_PTR	size
	)

Definition at line 416 of file type.c.

{
    struct symt_pointer*        sym;
 
    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag = SymTagPointerType;
        sym->pointsto = ref_type;
        sym->size     = size;
        symt_add_type(module, &sym->symt);
    }
    return sym;
}

Referenced by codeview_add_type_pointer(), codeview_init_basic_types(), dwarf2_parse_pointer_type(), dwarf2_parse_reference_type(), and stabs_pts_read_type_def().

symt_new_typedef()

struct symt_typedef * symt_new_typedef	(	struct module *	module,
		struct symt *	ref,
		const char *	name
	)

Definition at line 430 of file type.c.

{
    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);
        symt_add_type(module, &sym->symt);
    }
    return sym;
}

Referenced by codeview_snarf(), and dwarf2_parse_typedef().

symt_new_udt()

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

Definition at line 221 of file type.c.

{
    struct symt_udt*            sym;
 
    TRACE_(dbghelp_symt)("Adding udt %s:%s\n",
                         debugstr_w(module->module.ModuleName), typename);
    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);
        symt_add_type(module, &sym->symt);
    }
    return sym;
}

Referenced by codeview_add_type_struct(), codeview_parse_one_type(), dwarf2_parse_udt_type(), and stabs_pts_read_type_def().

symt_set_udt_size()

BOOL symt_set_udt_size	(	struct module *	module,
		struct symt_udt *	udt,
		unsigned	size
	)

Definition at line 244 of file type.c.

{
    assert(udt->symt.tag == SymTagUDT);
    if (vector_length(&udt->vchildren) != 0)
    {
        if (udt->size != size)
            FIXME_(dbghelp_symt)("Changing size for %s from %u to %u\n", 
                                 udt->hash_elt.name, udt->size, size);
        return TRUE;
    }
    udt->size = size;
    return TRUE;
}

Referenced by codeview_add_type_struct(), and stabs_pts_read_aggregate().

WINE_DECLARE_DEBUG_CHANNEL()

WINE_DECLARE_DEBUG_CHANNEL

(

dbghelp_symt

)

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

dbghelp

)