/*
 * File types.c - datatype handling stuff for internal debugger.
 *
 * Copyright (C) 1997, Eric Youngdale.
 *
 * 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
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 *
 * 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.
 */

#include <stdlib.h>

#include "debugger.h"
#include "wine/debug.h"

WINE_DEFAULT_DEBUG_CHANNEL(winedbg);

/******************************************************************
 *		types_get_real_type
 *
 * Get rid of any potential typedef in the lvalue's type to get
 * to the 'real' type (the one we can work upon).
 */
BOOL types_get_real_type(struct dbg_type* type, DWORD* tag)
{
    if (type->id == dbg_itype_none) return FALSE;
    do
    {
        if (!types_get_info(type, TI_GET_SYMTAG, tag))
            return FALSE;
        if (*tag != SymTagTypedef) return TRUE;
    } while (types_get_info(type, TI_GET_TYPE, type));
    return FALSE;
}

/******************************************************************
 *		types_extract_as_lgint
 *
 * Given a lvalue, try to get an integral (or pointer/address) value
 * out of it
 */
dbg_lgint_t types_extract_as_lgint(const struct dbg_lvalue* lvalue,
                                   unsigned* psize, BOOL *issigned)
{
    dbg_lgint_t         rtn = 0;
    DWORD               tag, bt;
    DWORD64             size;
    struct dbg_type     type = lvalue->type;
    BOOL                s = FALSE;

    if (!types_get_real_type(&type, &tag))
        RaiseException(DEBUG_STATUS_NOT_AN_INTEGER, 0, 0, NULL);

    if (type.id == dbg_itype_segptr)
    {
        return (LONG_PTR)memory_to_linear_addr(&lvalue->addr);
    }
    if (tag != SymTagBaseType && lvalue->bitlen) dbg_printf("Unexpected bitfield on tag %ld\n", tag);

    if (psize) *psize = 0;
    if (issigned) *issigned = FALSE;
    switch (tag)
    {
    case SymTagBaseType:
        if (!types_get_info(&type, TI_GET_LENGTH, &size) ||
            !types_get_info(&type, TI_GET_BASETYPE, &bt))
        {
            WINE_ERR("Couldn't get information\n");
            RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
            return rtn;
        }
        if (size > sizeof(rtn))
        {
            WINE_ERR("Size too large (%I64x)\n", size);
            RaiseException(DEBUG_STATUS_NOT_AN_INTEGER, 0, 0, NULL);
            return rtn;
        }
        switch (bt)
        {
        case btChar:
        case btWChar:
        case btBool:
        case btInt:
        case btLong:
            if (!memory_fetch_integer(lvalue, (unsigned)size, s = TRUE, &rtn))
                RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
            break;
        case btUInt:
        case btULong:
            if (!memory_fetch_integer(lvalue, (unsigned)size, s = FALSE, &rtn))
                RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
            break;
        case btFloat:
            RaiseException(DEBUG_STATUS_NOT_AN_INTEGER, 0, 0, NULL);
        }
        if (psize) *psize = (unsigned)size;
        if (issigned) *issigned = s;
        break;
    case SymTagPointerType:
        if (!types_get_info(&type, TI_GET_LENGTH, &size) ||
            !memory_fetch_integer(lvalue, (unsigned)size, s = FALSE, &rtn))
            RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
        break;
    case SymTagArrayType:
    case SymTagUDT:
        if (!memory_fetch_integer(lvalue, sizeof(unsigned), s = FALSE, &rtn))
            RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
        break;
    case SymTagEnum:
        if (!types_get_info(&type, TI_GET_LENGTH, &size) ||
            !memory_fetch_integer(lvalue, (unsigned)size, s = FALSE, &rtn))
            RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
        break;
    case SymTagFunctionType:
        rtn = (ULONG_PTR)memory_to_linear_addr(&lvalue->addr);
        break;
    default:
        WINE_FIXME("Unsupported tag %lu\n", tag);
        RaiseException(DEBUG_STATUS_NOT_AN_INTEGER, 0, 0, NULL);
    }

    return rtn;
}

/******************************************************************
 *		types_extract_as_integer
 *
 * Given a lvalue, try to get an integral (or pointer/address) value
 * out of it
 */
dbg_lgint_t types_extract_as_integer(const struct dbg_lvalue* lvalue)
{
    return types_extract_as_lgint(lvalue, NULL, NULL);
}

/******************************************************************
 *		types_extract_as_address
 *
 *
 */
void types_extract_as_address(const struct dbg_lvalue* lvalue, ADDRESS64* addr)
{
    if (lvalue->type.id == dbg_itype_segptr && lvalue->type.module == 0)
    {
        *addr = lvalue->addr;
    }
    else
    {
        addr->Mode = AddrModeFlat;
        addr->Offset = types_extract_as_lgint(lvalue, NULL, NULL);
    }
}

BOOL types_store_value(struct dbg_lvalue* lvalue_to, const struct dbg_lvalue* lvalue_from)
{
    if (!lvalue_to->bitlen && !lvalue_from->bitlen)
    {
        BOOL equal;
        if (!types_compare(lvalue_to->type, lvalue_from->type, &equal)) return FALSE;
        if (equal)
            return memory_transfer_value(lvalue_to, lvalue_from);
        if (types_is_float_type(lvalue_from) && types_is_float_type(lvalue_to))
        {
            double d;
            return memory_fetch_float(lvalue_from, &d) &&
                memory_store_float(lvalue_to, &d);
        }
    }
    if (types_is_integral_type(lvalue_from) && types_is_integral_type(lvalue_to))
    {
        /* doing integer conversion (about sign, size) */
        dbg_lgint_t val = types_extract_as_integer(lvalue_from);
        return memory_store_integer(lvalue_to, val);
    }
    dbg_printf("Cannot assign (different types)\n"); return FALSE;
    return FALSE;
}

/******************************************************************
 *		types_get_udt_element_lvalue
 *
 * Implement a structure derefencement
 */
static BOOL types_get_udt_element_lvalue(struct dbg_lvalue* lvalue, const struct dbg_type* type)
{
    DWORD       offset, bitoffset;
    DWORD64     length;

    types_get_info(type, TI_GET_TYPE, &lvalue->type);
    if (!types_get_info(type, TI_GET_OFFSET, &offset)) return FALSE;
    lvalue->addr.Offset += offset;

    if (types_get_info(type, TI_GET_BITPOSITION, &bitoffset))
    {
        types_get_info(type, TI_GET_LENGTH, &length);
        lvalue->bitlen = length;
        lvalue->bitstart = bitoffset;
        if (lvalue->bitlen != length || lvalue->bitstart != bitoffset)
        {
            dbg_printf("too wide bitfields\n"); /* shouldn't happen */
            return FALSE;
        }
    }
    else
        lvalue->bitlen = lvalue->bitstart = 0;

    return TRUE;
}

/******************************************************************
 *		types_udt_find_element
 *
 */
BOOL types_udt_find_element(struct dbg_lvalue* lvalue, const char* name)
{
    DWORD                       tag, count;
    char                        buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)];
    TI_FINDCHILDREN_PARAMS*     fcp = (TI_FINDCHILDREN_PARAMS*)buffer;
    WCHAR*                      ptr;
    char                        tmp[256];
    struct dbg_type             type;

    if (!types_get_real_type(&lvalue->type, &tag) || tag != SymTagUDT)
        return FALSE;

    if (types_get_info(&lvalue->type, TI_GET_CHILDRENCOUNT, &count))
    {
        fcp->Start = 0;
        while (count)
        {
            fcp->Count = min(count, 256);
            if (types_get_info(&lvalue->type, TI_FINDCHILDREN, fcp))
            {
                unsigned i;
                type.module = lvalue->type.module;
                for (i = 0; i < min(fcp->Count, count); i++)
                {
                    type.id = fcp->ChildId[i];
                    if (types_get_info(&type, TI_GET_SYMNAME, &ptr) && ptr)
                    {
                        WideCharToMultiByte(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp), NULL, NULL);
                        HeapFree(GetProcessHeap(), 0, ptr);
                        if (!strcmp(tmp, name))
                            return types_get_udt_element_lvalue(lvalue, &type);
                    }
                }
            }
            count -= min(count, 256);
            fcp->Start += 256;
        }
    }
    return FALSE;
}

/******************************************************************
 *		types_array_index
 *
 * Grab an element from an array
 */
BOOL types_array_index(const struct dbg_lvalue* lvalue, int index, struct dbg_lvalue* result)
{
    struct dbg_type     type = lvalue->type;
    DWORD               tag, count;

    memset(result, 0, sizeof(*result));
    result->type.id = dbg_itype_none;
    result->type.module = 0;

    if (!types_get_real_type(&type, &tag)) return FALSE;
    switch (tag)
    {
    case SymTagArrayType:
        if (!types_get_info(&type, TI_GET_COUNT, &count)) return FALSE;
        if (index < 0 || index >= count) return FALSE;
        result->addr = lvalue->addr;
        break;
    case SymTagPointerType:
        if (!memory_read_value(lvalue, dbg_curr_process->be_cpu->pointer_size, &result->addr.Offset))
            return FALSE;
        result->addr.Mode = AddrModeFlat;
        switch (dbg_curr_process->be_cpu->pointer_size)
        {
        case 4: result->addr.Offset = (DWORD)result->addr.Offset; break;
        case 8: break;
        default: assert(0);
        }
        break;
    default:
        FIXME("unexpected tag %lx\n", tag);
        return FALSE;
    }
    /*
     * Get the base type, so we know how much to index by.
     */
    if (!types_get_info(&type, TI_GET_TYPE, &result->type)) return FALSE;
    if (index)
    {
        DWORD64             length;
        if (!types_get_info(&result->type, TI_GET_LENGTH, &length)) return FALSE;
        result->addr.Offset += index * (DWORD)length;
    }
    /* FIXME: the following statement is not always true (and can lead to buggy behavior).
     * There is no way to tell where the deref:ed value is...
     * For example:
     *	x is a pointer to struct s, x being on the stack
     *		=> lvalue is in debuggee, result is in debugger
     *	x is a pointer to struct s, x being optimized into a reg
     *		=> lvalue is debugger, result is debuggee
     *	x is a pointer to internal variable x
     *	       	=> lvalue is debugger, result is debuggee
     * So we always force debuggee address space, because dereferencing pointers to
     * internal variables is very unlikely. A correct fix would be
     * rather large.
     */
    result->in_debuggee = 1;
    return TRUE;
}

struct type_find_t
{
    enum SymTagEnum     tag;    /* in: the tag to look for */
    struct dbg_type     type;   /* out: the type found */
    ULONG               ptr_typeid; /* in: when tag is SymTagPointerType */
};

static BOOL CALLBACK types_cb(PSYMBOL_INFO sym, ULONG size, void* _user)
{
    struct type_find_t* user = _user;
    BOOL                ret = TRUE;
    struct dbg_type     type, type_id;

    if (sym->Tag == user->tag)
    {
        switch (user->tag)
        {
        case SymTagUDT:
        case SymTagEnum:
        case SymTagTypedef:
            user->type.module = sym->ModBase;
            user->type.id = sym->TypeIndex;
            ret = FALSE;
            break;
        case SymTagPointerType:
            type.module = sym->ModBase;
            type.id = sym->TypeIndex;
            if (types_get_info(&type, TI_GET_TYPE, &type_id) && type_id.id == user->ptr_typeid)
            {
                user->type = type;
                ret = FALSE;
            }
            break;
        default: break;
        }
    }
    return ret;
}

/******************************************************************
 *		types_find_pointer
 *
 * There's no simple API in dbghelp for looking up the pointer type of a given type
 * - SymEnumTypes would do, but it'll enumerate all types, which could be long
 * - and more impacting, there's no guarantee such a type exists
 * Hence, we synthetize inside Winedbg all needed pointer types.
 * That's cumbersome as we end up with dbg_type in different modules between pointer
 * and pointee types.
 */
BOOL types_find_pointer(const struct dbg_type* type, struct dbg_type* outtype)
{
    struct type_find_t  f;
    unsigned i;
    struct dbg_type* new;

    if (!dbg_curr_process) return FALSE;

    /* first lookup if pointer to type exists in module */
    f.type.id = dbg_itype_none;
    f.tag = SymTagPointerType;
    f.ptr_typeid = type->id;
    SymEnumTypes(dbg_curr_process->handle, type->module, types_cb, &f);
    if (f.type.id != dbg_itype_none)
    {
        *outtype = f.type;
        return TRUE;
    }

    /* then look up in synthetized types */
    for (i = 0; i < dbg_curr_process->num_synthetized_types; i++)
        if (!memcmp(type, &dbg_curr_process->synthetized_types[i], sizeof(*type)))
        {
            outtype->module = 0;
            outtype->id = dbg_itype_synthetized + i;
            return TRUE;
        }
    if (dbg_itype_synthetized + dbg_curr_process->num_synthetized_types >= dbg_itype_first)
    {
        /* for now, we don't reuse old slots... */
        FIXME("overflow in pointer types\n");
        return FALSE;
    }
    /* otherwise, synthetize it */
    new = realloc(dbg_curr_process->synthetized_types,
                  (dbg_curr_process->num_synthetized_types + 1) * sizeof(*new));
    if (!new) return FALSE;
    dbg_curr_process->synthetized_types = new;
    dbg_curr_process->synthetized_types[dbg_curr_process->num_synthetized_types] = *type;
    outtype->module = 0;
    outtype->id = dbg_itype_synthetized + dbg_curr_process->num_synthetized_types;
    dbg_curr_process->num_synthetized_types++;

    return TRUE;
}

/******************************************************************
 *		types_find_type
 *
 * Should look up in the module based at linear address whether a type
 * named 'name' and with the correct tag exists
 */
BOOL types_find_type(const char* name, enum SymTagEnum tag, struct dbg_type* outtype)
{
    struct type_find_t  f;
    char* str = NULL;
    BOOL ret;

    if (!strchr(name, '!')) /* no module, lookup across all modules */
    {
        str = malloc(strlen(name) + 3);
        if (!str) return FALSE;
        str[0] = '*';
        str[1] = '!';
        strcpy(str + 2, name);
        name = str;
    }
    f.type.id = dbg_itype_none;
    f.tag = tag;
    ret = SymEnumTypesByName(dbg_curr_process->handle, 0, name, types_cb, &f);
    free(str);
    if (!ret || f.type.id == dbg_itype_none)
        return FALSE;
    *outtype = f.type;
    return TRUE;
}

/***********************************************************************
 *           print_value
 *
 * Implementation of the 'print' command.
 */
void print_value(const struct dbg_lvalue* lvalue, char format, int level)
{
    struct dbg_type     type = lvalue->type;
    struct dbg_lvalue   lvalue_field;
    int		        i;
    DWORD               tag;
    DWORD               count;
    DWORD64             size;

    if (!types_get_real_type(&type, &tag))
    {
        WINE_FIXME("---error\n");
        return;
    }

    if (type.id == dbg_itype_none)
    {
        /* No type, just print the addr value */
        print_bare_address(&lvalue->addr);
        goto leave;
    }

    if (format == 'i' || format == 's' || format == 'w' || format == 'b' || format == 'g')
    {
        dbg_printf("Format specifier '%c' is meaningless in 'print' command\n", format);
        format = '\0';
    }

    switch (tag)
    {
    case SymTagBaseType:
    case SymTagEnum:
    case SymTagPointerType:
        /* FIXME: this in not 100% optimal (as we're going through the typedef handling
         * stuff again
         */
        print_basic(lvalue, format);
        break;
    case SymTagUDT:
        if (types_get_info(&type, TI_GET_CHILDRENCOUNT, &count))
        {
            char                        buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)];
            TI_FINDCHILDREN_PARAMS*     fcp = (TI_FINDCHILDREN_PARAMS*)buffer;
            WCHAR*                      ptr;
            struct dbg_type             sub_type;

            dbg_printf("{");
            fcp->Start = 0;
            while (count)
            {
                fcp->Count = min(count, 256);
                if (types_get_info(&type, TI_FINDCHILDREN, fcp))
                {
                    for (i = 0; i < min(fcp->Count, count); i++)
                    {
                        sub_type.module = type.module;
                        sub_type.id = fcp->ChildId[i];
                        if (!types_get_info(&sub_type, TI_GET_SYMNAME, &ptr) || !ptr) continue;
                        dbg_printf("%ls=", ptr);
                        HeapFree(GetProcessHeap(), 0, ptr);
                        lvalue_field = *lvalue;
                        if (types_get_udt_element_lvalue(&lvalue_field, &sub_type))
                        {
                            print_value(&lvalue_field, format, level + 1);
                        }
                        if (i < min(fcp->Count, count) - 1 || count > 256) dbg_printf(", ");
                    }
                }
                count -= min(count, 256);
                fcp->Start += 256;
            }
            dbg_printf("}");
        }
        break;
    case SymTagArrayType:
        /*
         * Loop over all of the entries, printing stuff as we go.
         */
        count = 1; size = 1;
        types_get_info(&type, TI_GET_COUNT, &count);
        types_get_info(&type, TI_GET_LENGTH, &size);
        lvalue_field = *lvalue;
        types_get_info(&lvalue_field.type, TI_GET_TYPE, &lvalue_field.type);
        types_get_real_type(&lvalue_field.type, &tag);

        if (size == count && tag == SymTagBaseType)
        {
            DWORD       basetype;

            types_get_info(&lvalue_field.type, TI_GET_BASETYPE, &basetype);
            if (basetype == btChar)
            {
                char        buffer[256];
                /*
                 * Special handling for character arrays.
                 */
                unsigned len = min(count, sizeof(buffer));
                memory_get_string(dbg_curr_process,
                                  memory_to_linear_addr(&lvalue->addr),
                                  lvalue->in_debuggee, TRUE, buffer, len);
                dbg_printf("\"%s%s\"", buffer, (len < count) ? "..." : "");
                break;
            }
        }
        dbg_printf("{");
        for (i = 0; i < count; i++)
	{
            print_value(&lvalue_field, format, level + 1);
            lvalue_field.addr.Offset += size / count;
            dbg_printf((i == count - 1) ? "}" : ", ");
	}
        break;
    case SymTagFunctionType:
        dbg_printf("Function ");
        print_bare_address(&lvalue->addr);
        dbg_printf(": ");
        types_print_type(&type, FALSE, NULL);
        break;
    case SymTagTypedef:
        lvalue_field = *lvalue;
        types_get_info(&lvalue->type, TI_GET_TYPE, &lvalue_field.type);
        print_value(&lvalue_field, format, level);
        break;
    default:
        WINE_FIXME("Unknown tag (%lu)\n", tag);
        RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
        break;
    }

leave:

    if (level == 0) dbg_printf("\n");
}

static BOOL CALLBACK print_types_cb(PSYMBOL_INFO sym, ULONG size, void* ctx)
{
    struct dbg_type     type;
    type.module = sym->ModBase;
    type.id = sym->TypeIndex;
    dbg_printf("Mod: %0*Ix ID: %08lx\n", ADDRWIDTH, type.module, type.id);
    types_print_type(&type, TRUE, FALSE);
    dbg_printf("\n");
    return TRUE;
}

static BOOL CALLBACK print_types_mod_cb(PCSTR mod_name, DWORD64 base, PVOID ctx)
{
    return SymEnumTypes(dbg_curr_process->handle, base, print_types_cb, ctx);
}

BOOL print_types(void)
{
    if (!dbg_curr_process)
    {
        dbg_printf("No known process, cannot print types\n");
        return FALSE;
    }
    SymEnumerateModules64(dbg_curr_process->handle, print_types_mod_cb, NULL);
    return FALSE;
}

BOOL types_print_type(const struct dbg_type* type, BOOL details, const WCHAR* varname)
{
    WCHAR*              ptr;
    const WCHAR*        name;
    DWORD               tag, udt, count, bitoffset, bt;
    DWORD64             bitlen;
    struct dbg_type     subtype;
    BOOL                printed = FALSE;

    if (type->id == dbg_itype_none || !types_get_info(type, TI_GET_SYMTAG, &tag))
    {
        dbg_printf("--invalid--<%lxh>--", type->id);
        return FALSE;
    }

    name = (types_get_info(type, TI_GET_SYMNAME, &ptr) && ptr) ? ptr : L"--none--";

    switch (tag)
    {
    case SymTagBaseType:
        dbg_printf("%ls", name);
        if (details && types_get_info(type, TI_GET_LENGTH, &bitlen) && types_get_info(type, TI_GET_BASETYPE, &bt))
        {
            const char* longness = "";
            if (bt == btLong || bt == btULong) longness = " long";
            dbg_printf(": size=%I64d%s", bitlen, longness);
        }
        break;
    case SymTagPointerType:
        types_get_info(type, TI_GET_TYPE, &subtype);
        types_print_type(&subtype, FALSE, NULL);
        dbg_printf("*");
        break;
    case SymTagUDT:
        types_get_info(type, TI_GET_UDTKIND, &udt);
        switch (udt)
        {
        case UdtStruct: dbg_printf("struct %ls", name); break;
        case UdtUnion:  dbg_printf("union %ls", name); break;
        case UdtClass:  dbg_printf("class %ls", name); break;
        default:        WINE_ERR("Unsupported UDT type (%ld) for %ls\n", udt, name); break;
        }
        if (details &&
            types_get_info(type, TI_GET_CHILDRENCOUNT, &count))
        {
            char                        buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)];
            TI_FINDCHILDREN_PARAMS*     fcp = (TI_FINDCHILDREN_PARAMS*)buffer;
            WCHAR*                      ptr;
            int                         i;
            struct dbg_type             type_elt;
            dbg_printf(" {");

            fcp->Start = 0;
            while (count)
            {
                fcp->Count = min(count, 256);
                if (types_get_info(type, TI_FINDCHILDREN, fcp))
                {
                    for (i = 0; i < min(fcp->Count, count); i++)
                    {
                        type_elt.module = type->module;
                        type_elt.id = fcp->ChildId[i];
                        if (!types_get_info(&type_elt, TI_GET_SYMNAME, &ptr) || !ptr) continue;
                        if (!types_get_info(&type_elt, TI_GET_BITPOSITION, &bitoffset) ||
                            !types_get_info(&type_elt, TI_GET_LENGTH, &bitlen))
                            bitlen = ~(DWORD64)0;
                        if (types_get_info(&type_elt, TI_GET_TYPE, &type_elt))
                        {
                            /* print details of embedded UDT:s */
                            types_print_type(&type_elt, types_get_info(&type_elt, TI_GET_UDTKIND, &udt), ptr);
                        }
                        else dbg_printf("<unknown> %ls", ptr);
                        HeapFree(GetProcessHeap(), 0, ptr);
                        if (bitlen != ~(DWORD64)0)
                            dbg_printf(" : %I64u", bitlen);
                        dbg_printf(";");
                        if (i < min(fcp->Count, count) - 1 || count > 256) dbg_printf(" ");
                    }
                }
                count -= min(count, 256);
                fcp->Start += 256;
            }
            dbg_printf("}");
        }
        break;
    case SymTagArrayType:
        if (types_get_info(type, TI_GET_TYPE, &subtype))
        {
            types_print_type(&subtype, FALSE, varname);
            if (types_get_info(type, TI_GET_COUNT, &count))
                dbg_printf("[%ld]", count);
            else
                dbg_printf("[]");
            printed = TRUE;
        }
        break;
    case SymTagEnum:
        dbg_printf("enum %ls", name);
        if (details &&
            types_get_info(type, TI_GET_CHILDRENCOUNT, &count))
        {
            char                        buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)];
            TI_FINDCHILDREN_PARAMS*     fcp = (TI_FINDCHILDREN_PARAMS*)buffer;
            WCHAR*                      ptr;
            int                         i;
            struct dbg_type             type_elt;
            VARIANT                     variant;

            dbg_printf(" {");

            fcp->Start = 0;
            while (count)
            {
                fcp->Count = min(count, 256);
                if (types_get_info(type, TI_FINDCHILDREN, fcp))
                {
                    for (i = 0; i < min(fcp->Count, count); i++)
                    {
                        type_elt.module = type->module;
                        type_elt.id = fcp->ChildId[i];
                        if (!types_get_info(&type_elt, TI_GET_SYMNAME, &ptr) || !ptr) continue;
                        if (!types_get_info(&type_elt, TI_GET_VALUE, &variant) || !ptr) continue;
                        dbg_printf("%ls = ", ptr);
                        switch (V_VT(&variant))
                        {
                        case VT_I1:  dbg_printf("%d",    V_I1(&variant)); break;
                        case VT_I2:  dbg_printf("%d",    V_I2(&variant)); break;
                        case VT_I4:  dbg_printf("%ld",   V_I4(&variant)); break;
                        case VT_I8:  dbg_printf("%I64d", V_I8(&variant)); break;
                        case VT_UI1: dbg_printf("%u",    V_UI1(&variant)); break;
                        case VT_UI2: dbg_printf("%u",    V_UI2(&variant)); break;
                        case VT_UI4: dbg_printf("%lu",   V_UI4(&variant)); break;
                        case VT_UI8: dbg_printf("%I64u", V_UI8(&variant)); break;
                        }
                        HeapFree(GetProcessHeap(), 0, ptr);
                        if (i < min(fcp->Count, count) - 1 || count > 256) dbg_printf(", ");
                    }
                }
                count -= min(count, 256);
                fcp->Start += 256;
            }
            dbg_printf("}");
        }
        break;
    case SymTagFunctionType:
        types_get_info(type, TI_GET_TYPE, &subtype);
        /* is the returned type the same object as function sig itself ? */
        if (subtype.id != type->id)
        {
            types_print_type(&subtype, FALSE, NULL);
        }
        else
        {
            subtype.module = 0;
            dbg_printf("<ret_type=self>");
        }
        dbg_printf(" (*%ls)(", varname ? varname : L"");
        printed = TRUE;
        if (types_get_info(type, TI_GET_CHILDRENCOUNT, &count))
        {
            char                        buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)];
            TI_FINDCHILDREN_PARAMS*     fcp = (TI_FINDCHILDREN_PARAMS*)buffer;
            int                         i;

            fcp->Start = 0;
            if (!count) dbg_printf("void");
            else while (count)
            {
                fcp->Count = min(count, 256);
                if (types_get_info(type, TI_FINDCHILDREN, fcp))
                {
                    for (i = 0; i < min(fcp->Count, count); i++)
                    {
                        subtype.id = fcp->ChildId[i];
                        types_get_info(&subtype, TI_GET_TYPE, &subtype);
                        types_print_type(&subtype, FALSE, NULL);
                        if (i < min(fcp->Count, count) - 1 || count > 256) dbg_printf(", ");
                    }
                }
                count -= min(count, 256);
                fcp->Start += 256;
            }
        }
        dbg_printf(")");
        break;
    case SymTagTypedef:
        if (details && types_get_info(type, TI_GET_TYPE, &subtype))
        {
            dbg_printf("typedef %ls => ", name);
            types_print_type(&subtype, FALSE, NULL);
        }
        else dbg_printf("%ls", name);
        break;
    default:
        WINE_ERR("Unknown type %lu for %ls\n", tag, name);
        break;
    }
    if (varname && !printed) dbg_printf(" %ls", varname);

    if (name == ptr)
        HeapFree(GetProcessHeap(), 0, ptr);
    return TRUE;
}

/* order here must match order in enum dbg_internal_type */
static struct
{
    unsigned char base_type;
    unsigned char byte_size;
}
    basic_types_details[] =
{
    {btVoid,      0},
    {btBool,      1},
    /* chars */
    {btChar,      1},
    {btWChar,     2},
    {btChar8,     1},
    {btChar16,    2},
    {btChar32,    4},
    /* unsigned integers */
    {btUInt,      1},
    {btUInt,      2},
    {btUInt,      4},
    {btUInt,      8},
    {btUInt,     16},
    {btULong,     4},
    {btULong,     8},
    /* signed integers */
    {btInt,       1},
    {btInt,       2},
    {btInt,       4},
    {btInt,       8},
    {btInt,      16},
    {btLong,      4},
    {btLong,      8},
    /* floats */
    {btFloat,     4},
    {btFloat,     8},
    {btFloat,    10},
};

C_ASSERT(ARRAY_SIZE(basic_types_details) == dbg_itype_last - dbg_itype_first);

const struct data_model ilp32_data_model[] =
{
    {dbg_itype_void,                    L"void"},

    {dbg_itype_bool,                    L"bool"},

    {dbg_itype_char,                    L"char"},
    {dbg_itype_wchar,                   L"WCHAR"},
    {dbg_itype_char8,                   L"char8_t"},
    {dbg_itype_char16,                  L"char16_t"},
    {dbg_itype_char32,                  L"char32_t"},

    {dbg_itype_unsigned_int8,           L"unsigned char"},
    {dbg_itype_unsigned_int16,          L"unsigned short int"},
    {dbg_itype_unsigned_int32,          L"unsigned int"},
    {dbg_itype_unsigned_int64,          L"unsigned long long int"},
    {dbg_itype_unsigned_int64,          L"unsigned __int64"},
    {dbg_itype_unsigned_long32,         L"unsigned long int"},

    {dbg_itype_signed_int8,             L"signed char"},
    {dbg_itype_signed_int16,            L"short int"},
    {dbg_itype_signed_int32,            L"int"},
    {dbg_itype_signed_int64,            L"long long int"},
    {dbg_itype_signed_int64,            L"__int64"},
    {dbg_itype_signed_long32,           L"long int"},

    {dbg_itype_short_real,              L"float"},
    {dbg_itype_real,                    L"double"},
    {dbg_itype_long_real,               L"long double"},

    {0,                                 NULL}
};

const struct data_model llp64_data_model[] =
{
    {dbg_itype_void,                    L"void"},

    {dbg_itype_bool,                    L"bool"},

    {dbg_itype_char,                    L"char"},
    {dbg_itype_wchar,                   L"WCHAR"},
    {dbg_itype_char8,                   L"char8_t"},
    {dbg_itype_char16,                  L"char16_t"},
    {dbg_itype_char32,                  L"char32_t"},

    {dbg_itype_unsigned_int8,           L"unsigned char"},
    {dbg_itype_unsigned_int16,          L"unsigned short int"},
    {dbg_itype_unsigned_int32,          L"unsigned int"},
    {dbg_itype_unsigned_int64,          L"unsigned long long int"},
    {dbg_itype_unsigned_int64,          L"unsigned __int64"},
    {dbg_itype_unsigned_int128,         L"unsigned __int128"},

    {dbg_itype_unsigned_long32,         L"unsigned long int"},

    {dbg_itype_signed_int8,             L"signed char"},
    {dbg_itype_signed_int16,            L"short int"},
    {dbg_itype_signed_int32,            L"int"},
    {dbg_itype_signed_int64,            L"long long int"},
    {dbg_itype_signed_int64,            L"__int64"},
    {dbg_itype_signed_int128,           L"__int128"},
    {dbg_itype_signed_long32,           L"long int"},

    {dbg_itype_short_real,              L"float"},
    {dbg_itype_real,                    L"double"},
    {dbg_itype_long_real,               L"long double"},

    {0,                                 NULL}
};

const struct data_model lp64_data_model[] =
{
    {dbg_itype_void,                    L"void"},

    {dbg_itype_bool,                    L"bool"},

    {dbg_itype_char,                    L"char"},
    {dbg_itype_wchar,                   L"WCHAR"},
    {dbg_itype_char8,                   L"char8_t"},
    {dbg_itype_char16,                  L"char16_t"},
    {dbg_itype_char32,                  L"char32_t"},

    {dbg_itype_unsigned_int8,           L"unsigned char"},
    {dbg_itype_unsigned_int16,          L"unsigned short int"},
    {dbg_itype_unsigned_int32,          L"unsigned int"},
    {dbg_itype_unsigned_int64,          L"unsigned long long int"},
    {dbg_itype_unsigned_int64,          L"unsigned __int64"},
    {dbg_itype_unsigned_int128,         L"unsigned __int128"},
    {dbg_itype_unsigned_long64,         L"unsigned long int"}, /* we can't discriminate 'unsigned long' from 'unsigned long long' (on output) */

    {dbg_itype_signed_int8,             L"signed char"},
    {dbg_itype_signed_int16,            L"short int"},
    {dbg_itype_signed_int32,            L"int"},
    {dbg_itype_signed_int64,            L"long long int"},
    {dbg_itype_signed_int64,            L"__int64"},
    {dbg_itype_signed_int128,           L"__int128"},
    {dbg_itype_signed_long64,           L"long int"}, /* we can't discriminate 'long' from 'long long' (on output)*/

    {dbg_itype_short_real,              L"float"},
    {dbg_itype_real,                    L"double"},
    {dbg_itype_long_real,               L"long double"},

    {0,                                 NULL}
};

static const struct data_model* get_data_model(DWORD64 modaddr)
{
    const struct data_model *model;

    if (dbg_curr_process->data_model)
        model = dbg_curr_process->data_model;
    else if (ADDRSIZE == 4) model = ilp32_data_model;
    else
    {
        struct dhext_module_information wmi;

        if (wine_get_module_information(dbg_curr_process->handle, modaddr, &wmi, sizeof(wmi)) &&
            wmi.type != DMT_PE)
            model = lp64_data_model;
        else
            model = llp64_data_model;
    }
    return model;
}

struct mod_by_name
{
    const char* modname;
    ULONG64 base;
};

static BOOL CALLBACK enum_mod_cb(const char* module, DWORD64 base, void* user)
{
    struct mod_by_name* mbn = user;
    if (!mbn->modname) /* lookup data model from main module */
    {
        IMAGEHLP_MODULE64 mi;
        mi.SizeOfStruct = sizeof(mi);
        if (SymGetModuleInfo64(dbg_curr_process->handle, base, &mi))
        {
            size_t len = strlen(mi.ImageName);
            if (len >= 4 && !strcmp(mi.ImageName + len - 4, ".exe"))
            {
                mbn->base = base;
                return FALSE;
            }
        }
    }
    else if (SymMatchStringA(module, mbn->modname, FALSE))
    {
        mbn->base = base;
        return FALSE;
    }
    return TRUE;
}

BOOL             types_find_basic(const WCHAR* name, const char* mod, struct dbg_type* type)
{
    const struct data_model* model;
    struct mod_by_name mbn = {mod, 0};
    DWORD opt;
    BOOL ret;

    opt = SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, TRUE);
    ret = SymEnumerateModules64(dbg_curr_process->handle, enum_mod_cb, &mbn);
    SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, opt);
    if (!ret || mbn.base == 0)
        return FALSE;
    model = get_data_model(mbn.base);
    for (; model->name; model++)
    {
        if (!wcscmp(name, model->name))
        {
            type->module = 0;
            type->id = model->itype;
            return TRUE;
        }
    }
    return FALSE;
}

static BOOL lookup_base_type_in_data_model(DWORD64 module, unsigned bt, unsigned len, WCHAR** pname)
{
    const WCHAR* name = NULL;
    WCHAR tmp[64];
    const struct data_model* model;

    model = get_data_model(module);
    for (; model->name; model++)
    {
        if (model->itype >= dbg_itype_first && model->itype < dbg_itype_last &&
            bt == basic_types_details[model->itype - dbg_itype_first].base_type &&
            len == basic_types_details[model->itype - dbg_itype_first].byte_size)
        {
            name = model->name;
            break;
        }
    }
    if (!name) /* synthetize name */
    {
        WINE_FIXME("Unsupported basic type %u %u\n", bt, len);
        swprintf(tmp, ARRAY_SIZE(tmp), L"bt[%u,%u]", bt, len);
        name = tmp;
    }
    *pname = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(name) + 1) * sizeof(WCHAR));
    if (!*pname) return FALSE;
    lstrcpyW(*pname, name);
    return TRUE;
}

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

/* Wrapper around SymGetTypeInfo
 * - module & type id on input are in dbg_type structure
 * - for TI_GET_TYPE a pointer to a dbg_type is expected for pInfo
 *   (instead of DWORD* for SymGetTypeInfo)
 * - handles also internal types, and synthetized types.
 */
BOOL types_get_info(const struct dbg_type* type, IMAGEHLP_SYMBOL_TYPE_INFO ti, void* pInfo)
{
    if (type->id == dbg_itype_none) return FALSE;
    if (type->module != 0)
    {
        if (ti == TI_GET_SYMNAME)
        {
            DWORD tag, bt;
            DWORD64 len;
            WCHAR* name;
            if (SymGetTypeInfo(dbg_curr_process->handle, type->module, type->id, TI_GET_SYMTAG, &tag) &&
                tag == SymTagBaseType &&
                SymGetTypeInfo(dbg_curr_process->handle, type->module, type->id, TI_GET_BASETYPE, &bt) &&
                SymGetTypeInfo(dbg_curr_process->handle, type->module, type->id, TI_GET_LENGTH, &len) &&
                len == (DWORD)len)
            {
                if (!lookup_base_type_in_data_model(type->module, bt, len, &name)) return FALSE;
                X(WCHAR*) = name;
                return TRUE;
            }
        }
        else if (ti == TI_GET_TYPE)
        {
            struct dbg_type* dt = (struct dbg_type*)pInfo;
            if (!SymGetTypeInfo(dbg_curr_process->handle, type->module, type->id, ti, &dt->id))
                return FALSE;
            dt->module = type->module;
            return TRUE;
        }
        return SymGetTypeInfo(dbg_curr_process->handle, type->module, type->id, ti, pInfo);
    }

    if (type->id >= dbg_itype_synthetized && type->id < dbg_itype_first)
    {
        unsigned i = type->id - dbg_itype_synthetized;
        if (i >= dbg_curr_process->num_synthetized_types) return FALSE;
        switch (ti)
        {
        case TI_GET_SYMTAG:  X(DWORD)   = SymTagPointerType; break;
        case TI_GET_LENGTH:  X(DWORD64) = ADDRSIZE; break;
        case TI_GET_TYPE:    if (dbg_curr_process->synthetized_types[i].module == 0 &&
                                 dbg_curr_process->synthetized_types[i].id == dbg_itype_none) return FALSE;

                             X(struct dbg_type) = dbg_curr_process->synthetized_types[i];
                             break;
        default: WINE_FIXME("unsupported %u for pointer type %d\n", ti, i); return FALSE;
        }
        return TRUE;
    }

    assert(type->id >= dbg_itype_first);

    if (type->id >= dbg_itype_first && type->id < dbg_itype_last)
    {
        switch (ti)
        {
        case TI_GET_SYMTAG:     X(DWORD)   = SymTagBaseType; break;
        case TI_GET_LENGTH:     X(DWORD64) = basic_types_details[type->id - dbg_itype_first].byte_size; break;
        case TI_GET_BASETYPE:   X(DWORD)   = basic_types_details[type->id - dbg_itype_first].base_type; break;
        case TI_GET_SYMNAME:    return lookup_base_type_in_data_model(0, basic_types_details[type->id - dbg_itype_first].base_type,
                                                                      basic_types_details[type->id - dbg_itype_first].byte_size, &X(WCHAR*));
        default: WINE_FIXME("unsupported %u for itype %#lx\n", ti, type->id); return FALSE;
        }
        return TRUE;
    }
    switch (type->id)
    {
    case dbg_itype_lguint:
        switch (ti)
        {
        case TI_GET_SYMTAG:     X(DWORD)   = SymTagBaseType; break;
        case TI_GET_LENGTH:     X(DWORD64) = sizeof(dbg_lguint_t); break;
        case TI_GET_BASETYPE:   X(DWORD)   = btUInt; break;
        default: WINE_FIXME("unsupported %u for lguint_t\n", ti); return FALSE;
        }
        break;
    case dbg_itype_lgint:
        switch (ti)
        {
        case TI_GET_SYMTAG:     X(DWORD)   = SymTagBaseType; break;
        case TI_GET_LENGTH:     X(DWORD64) = sizeof(dbg_lgint_t); break;
        case TI_GET_BASETYPE:   X(DWORD)   = btInt; break;
        default: WINE_FIXME("unsupported %u for lgint_t\n", ti); return FALSE;
        }
        break;
    case dbg_itype_astring:
        switch (ti)
        {
        case TI_GET_SYMTAG:     X(DWORD)   = SymTagPointerType; break;
        case TI_GET_LENGTH:     X(DWORD64) = ADDRSIZE; break;
        case TI_GET_TYPE:       { struct dbg_type* dt = pInfo; dt->id = dbg_itype_char; dt->module = type->module; break; }
        default: WINE_FIXME("unsupported %u for a string\n", ti); return FALSE;
        }
        break;
    case dbg_itype_segptr:
        switch (ti)
        {
        case TI_GET_SYMTAG:     X(DWORD)   = SymTagBaseType; break;
        case TI_GET_LENGTH:     X(DWORD64) = 4; break;
        case TI_GET_BASETYPE:   X(DWORD)   = btInt; break;
        default: WINE_FIXME("unsupported %u for seg-ptr\n", ti); return FALSE;
        }
        break;
    case dbg_itype_m128a:
        switch (ti)
        {
        case TI_GET_SYMTAG:     X(DWORD)   = SymTagBaseType; break;
        case TI_GET_LENGTH:     X(DWORD64) = 16; break;
        case TI_GET_BASETYPE:   X(DWORD)   = btUInt; break;
        default: WINE_FIXME("unsupported %u for XMM register\n", ti); return FALSE;
        }
        break;
    default: WINE_FIXME("unsupported type id 0x%lx\n", type->id); return FALSE;
    }

#undef X
    return TRUE;
}

BOOL types_unload_module(struct dbg_process* pcs, DWORD_PTR linear)
{
    unsigned i;
    if (!pcs) return FALSE;
    for (i = 0; i < pcs->num_synthetized_types; i++)
    {
        if (pcs->synthetized_types[i].module == linear)
        {
            pcs->synthetized_types[i].module = 0;
            pcs->synthetized_types[i].id = dbg_itype_none;
        }
    }
    return TRUE;
}

static BOOL types_compare_name(struct dbg_type type1, struct dbg_type type2, BOOL* equal)
{
    LPWSTR name1, name2;
    BOOL ret;

    if (types_get_info(&type1, TI_GET_SYMNAME, &name1))
    {
        if (types_get_info(&type2, TI_GET_SYMNAME, &name2))
        {
            *equal = !wcscmp(name1, name2);
            ret = TRUE;
            HeapFree(GetProcessHeap(), 0, name2);
        }
        else ret = FALSE;
        HeapFree(GetProcessHeap(), 0, name1);
    }
    else ret = FALSE;
    return ret;
}

static BOOL types_compare_children(struct dbg_type type1, struct dbg_type type2, BOOL* equal, DWORD tag)
{
    DWORD count1, count2, i;
    DWORD* children;
    BOOL ret;

    if (!types_get_info(&type1, TI_GET_CHILDRENCOUNT, &count1) ||
        !types_get_info(&type2, TI_GET_CHILDRENCOUNT, &count2)) return FALSE;
    if (count1 != count2) {*equal = FALSE; return TRUE;}
    if (!count1) return *equal = TRUE;
    if ((children = malloc(sizeof(*children) * 2 * count1)) == NULL) return FALSE;
    if (types_get_info(&type1, TI_FINDCHILDREN, &children[0]) &&
        types_get_info(&type2, TI_FINDCHILDREN, &children[count1]))
    {
        for (i = 0; i < count1; ++i)
        {
            type1.id = children[i];
            type2.id = children[count1 + i];
            switch (tag)
            {
            case SymTagFunctionType: ret = types_compare(type1, type2, equal); break;
            case SymTagUDT:
                /* each child is a SymTagData that describes the member */
                ret = types_compare_name(type1, type2, equal);
                if (ret && *equal)
                {
                    /* compare type of member */
                    ret = types_get_info(&type1, TI_GET_TYPE, &type1) &&
                        types_get_info(&type2, TI_GET_TYPE, &type2);
                    if (ret) ret = types_compare(type1, type2, equal);
                    /* FIXME should compare bitfield info when present */
                }
                break;
            default: ret = FALSE; break;
            }
            if (!ret || !*equal) break;
        }
        if (i == count1) ret = *equal = TRUE;
    }
    else ret = FALSE;

    free(children);
    return ret;
}

BOOL types_compare(struct dbg_type type1, struct dbg_type type2, BOOL* equal)
{
    DWORD           tag1, tag2;
    DWORD64         size1, size2;
    DWORD           bt1, bt2;
    DWORD           count1, count2;
    BOOL            ret;

    do
    {
        if (type1.module == type2.module && type1.id == type2.id)
            return *equal = TRUE;

        if (!types_get_real_type(&type1, &tag1) ||
            !types_get_real_type(&type2, &tag2)) return FALSE;

        if (type1.module == type2.module && type1.id == type2.id)
            return *equal = TRUE;

        if (tag1 != tag2) return !(*equal = FALSE);

        switch (tag1)
        {
        case SymTagBaseType:
            if (!types_get_info(&type1, TI_GET_BASETYPE, &bt1) ||
                !types_get_info(&type2, TI_GET_BASETYPE, &bt2) ||
                !types_get_info(&type1, TI_GET_LENGTH,   &size1) ||
                !types_get_info(&type2, TI_GET_LENGTH,   &size2))
                return FALSE;
            *equal = bt1 == bt2 && size1 == size2;
            return TRUE;
        case SymTagPointerType:
            /* compare sub types */
            break;
        case SymTagUDT:
        case SymTagEnum:
            ret = types_compare_name(type1, type2, equal);
            if (!ret || !*equal) return ret;
            ret = types_compare_children(type1, type2, equal, tag1);
            if (!ret || !*equal) return ret;
            if (tag1 == SymTagUDT) return TRUE;
            /* compare underlying type for enums */
            break;
        case SymTagArrayType:
            if (!types_get_info(&type1, TI_GET_LENGTH, &size1) ||
                !types_get_info(&type2, TI_GET_LENGTH, &size2) ||
                !types_get_info(&type1, TI_GET_COUNT,  &count1) ||
                !types_get_info(&type2, TI_GET_COUNT,  &count2)) return FALSE;
            if (size1 == size2 && count1 == count2)
            {
                struct dbg_type subtype1 = type1, subtype2 = type2;
                if (!types_get_info(&type1, TI_GET_ARRAYINDEXTYPEID, &subtype1.id) ||
                    !types_get_info(&type2, TI_GET_ARRAYINDEXTYPEID, &subtype2.id)) return FALSE;
                if (!types_compare(subtype1, subtype2, equal)) return FALSE;
                if (!*equal) return TRUE;
            }
            else return !(*equal = FALSE);
            /* compare subtypes */
            break;
        case SymTagFunctionType:
            if (!types_compare_children(type1, type2, equal, tag1)) return FALSE;
            if (!*equal) return TRUE;
            /* compare return:ed type */
            break;
        case SymTagFunctionArgType:
            /* compare argument type */
            break;
        default:
            dbg_printf("Unsupported yet tag %ld\n", tag1);
            return FALSE;
        }
    } while (types_get_info(&type1, TI_GET_TYPE, &type1) &&
             types_get_info(&type2, TI_GET_TYPE, &type2));
    return FALSE;
}

static BOOL is_basetype_char(DWORD bt)
{
    return bt == btChar || bt == btWChar || bt == btChar8 || bt == btChar16 || bt == btChar32;
}

static BOOL is_basetype_integer(DWORD bt)
{
    return is_basetype_char(bt) || bt == btInt || bt == btUInt || bt == btLong || bt == btULong;
}

BOOL types_is_integral_type(const struct dbg_lvalue* lv)
{
    struct dbg_type type = lv->type;
    DWORD tag, bt;
    if (lv->bitlen) return TRUE;
    if (!types_get_real_type(&type, &tag) || tag != SymTagBaseType ||
        !types_get_info(&type, TI_GET_BASETYPE, &bt)) return FALSE;
    return is_basetype_integer(bt);
}

BOOL types_is_float_type(const struct dbg_lvalue* lv)
{
    struct dbg_type type = lv->type;
    DWORD tag, bt;
    if (lv->bitlen) return FALSE;
    if (!types_get_real_type(&type, &tag) || tag != SymTagBaseType ||
        !types_get_info(&type, TI_GET_BASETYPE, &bt)) return FALSE;
    return bt == btFloat;
}

BOOL types_is_pointer_type(const struct dbg_lvalue* lv)
{
    struct dbg_type type = lv->type;
    DWORD tag;
    if (lv->bitlen) return FALSE;
    return types_get_real_type(&type, &tag) &&
        (tag == SymTagPointerType || tag == SymTagArrayType || tag == SymTagFunctionType);
}
