From: Eric Pouech eric.pouech@gmail.com
typically what a C compiler does... - get rid of struct type_expr_t - enabling back typecasts (and rewriting the typecast to fit the type parsing scheme)
Signed-off-by: Eric Pouech eric.pouech@gmail.com --- programs/winedbg/dbg.y | 14 ++-- programs/winedbg/debug.l | 9 ++- programs/winedbg/debugger.h | 34 +++------- programs/winedbg/expr.c | 125 +++++++++++++++--------------------- programs/winedbg/stack.c | 8 +-- programs/winedbg/types.c | 85 +++++++++++++----------- 6 files changed, 130 insertions(+), 145 deletions(-)
diff --git a/programs/winedbg/dbg.y b/programs/winedbg/dbg.y index 748d16e96c5..6faa196e052 100644 --- a/programs/winedbg/dbg.y +++ b/programs/winedbg/dbg.y @@ -44,7 +44,7 @@ static void parser(const char*); dbg_lgint_t integer; IMAGEHLP_LINE64 listing; struct expr* expression; - struct type_expr_t type; + struct dbg_type type; struct list_string* strings; }
@@ -57,6 +57,7 @@ static void parser(const char*); %token tSTEPI tNEXTI tFINISH tSHOW tDIR tWHATIS tSOURCE %token <string> tPATH tIDENTIFIER tSTRING tINTVAR %token <integer> tNUM tFORMAT +%token <type> tTYPEDEF %token tSYMBOLFILE tRUN tATTACH tDETACH tKILL tMAINTENANCE tTYPE tMINIDUMP %token tNOPROCESS
@@ -346,11 +347,12 @@ type_expr: | tFLOAT { if (!types_find_basic(L"float", $1, &$$)) YYERROR; } | tDOUBLE { if (!types_find_basic(L"double", $1, &$$)) YYERROR; } | tLONG tDOUBLE { if (!types_find_basic(L"long double", $1, &$$)) YYERROR; } - | type_expr '*' { $$ = $1; $$.deref_count++; } - | tCLASS identifier { $$.type = type_expr_udt_class; $$.deref_count = 0; $$.u.name = $2; } - | tSTRUCT identifier { $$.type = type_expr_udt_struct; $$.deref_count = 0; $$.u.name = $2; } - | tUNION identifier { $$.type = type_expr_udt_union; $$.deref_count = 0; $$.u.name = $2; } - | tENUM identifier { $$.type = type_expr_enumeration; $$.deref_count = 0; $$.u.name = $2; } + | tTYPEDEF { $$ = $1; } + | type_expr '*' { if (!types_find_pointer(&$1, &$$)) {yyerror("Cannot find pointer type\n"); YYERROR; } } + | tCLASS identifier { if (!types_find_type($2, SymTagUDT, &$$)) {yyerror("Unknown type\n"); YYERROR; } } + | tSTRUCT identifier { if (!types_find_type($2, SymTagUDT, &$$)) {yyerror("Unknown type\n"); YYERROR; } } + | tUNION identifier { if (!types_find_type($2, SymTagUDT, &$$)) {yyerror("Unknown type\n"); YYERROR; } } + | tENUM identifier { if (!types_find_type($2, SymTagEnum, &$$)) {yyerror("Unknown type\n"); YYERROR; } } ;
expr_lvalue: diff --git a/programs/winedbg/debug.l b/programs/winedbg/debug.l index 90dd4dfac11..1f8040ff976 100644 --- a/programs/winedbg/debug.l +++ b/programs/winedbg/debug.l @@ -100,6 +100,13 @@ static char* unescape_string(const char* str) return ret; }
+static int resolve_identifier(const char* id, DBG_STYPE* lval) +{ + if (types_find_type(id, SymTagTypedef, &lval->type)) return tTYPEDEF; + lval->string = lexeme_alloc(id); + return tIDENTIFIER; +} + #define YY_INPUT(buf,result,max_size) \ (result = input_lex_read_buffer(buf, max_size))
@@ -258,7 +265,7 @@ union { return tUNION; } enum { return tENUM; } all { return tALL; }
-{MODULE_IDENTIFIER}?{SCOPED_IDENTIFIER}*{IDENTIFIER} { dbg_lval.string = lexeme_alloc(yytext); return tIDENTIFIER; } +{MODULE_IDENTIFIER}?{SCOPED_IDENTIFIER}*{IDENTIFIER} { return resolve_identifier(yytext, &dbg_lval); } "$"{IDENTIFIER} { dbg_lval.string = lexeme_alloc(yytext+1); return tINTVAR; }
<PATH_EXPECTED,PATH_ACCEPTED>{PATHNAME} { dbg_lval.string = lexeme_alloc(yytext); return tPATH; } diff --git a/programs/winedbg/debugger.h b/programs/winedbg/debugger.h index bde912eaee5..d5c5934cceb 100644 --- a/programs/winedbg/debugger.h +++ b/programs/winedbg/debugger.h @@ -150,14 +150,15 @@ static inline void init_lvalue(struct dbg_lvalue* lv, BOOL in_debuggee, void* ad lv->type.id = dbg_itype_none; }
-static inline void init_lvalue_in_debugger(struct dbg_lvalue* lv, enum dbg_internal_types it, void* addr) +static inline void init_lvalue_in_debugger(struct dbg_lvalue* lv, DWORD_PTR module, + enum dbg_internal_types it, void* addr) { lv->in_debuggee = 0; lv->bitstart = 0; lv->bitlen = 0; lv->addr.Mode = AddrModeFlat; lv->addr.Offset = (DWORD_PTR)addr; - lv->type.module = 0; + lv->type.module = module; lv->type.id = it; }
@@ -310,26 +311,6 @@ struct dbg_internal_var
enum sym_get_lval {sglv_found, sglv_unknown, sglv_aborted};
-enum type_expr_e -{ - type_expr_type_id, - type_expr_udt_class, - type_expr_udt_struct, - type_expr_udt_union, - type_expr_enumeration -}; - -struct type_expr_t -{ - enum type_expr_e type; - unsigned deref_count; - union - { - struct dbg_type type; - const char* name; - } u; -}; - enum dbg_start {start_ok, start_error_parse, start_error_init};
/* break.c */ @@ -385,7 +366,7 @@ extern struct expr* expr_alloc_unary_op(int oper, struct expr*); extern struct expr* expr_alloc_pstruct(struct expr*, const char* element); extern struct expr* expr_alloc_struct(struct expr*, const char* element); extern struct expr* WINAPIV expr_alloc_func_call(const char*, int nargs, ...); -extern struct expr* expr_alloc_typecast(struct type_expr_t*, struct expr*); +extern struct expr* expr_alloc_typecast(struct dbg_type*, struct expr*); extern struct dbg_lvalue expr_eval(struct expr*); extern struct expr* expr_clone(const struct expr* exp, BOOL *local_binding); extern BOOL expr_free(struct expr* exp); @@ -510,12 +491,13 @@ extern BOOL types_udt_find_element(struct dbg_lvalue* value, const c extern BOOL types_array_index(const struct dbg_lvalue* value, int index, struct dbg_lvalue* result); extern BOOL types_get_info(const struct dbg_type*, IMAGEHLP_SYMBOL_TYPE_INFO, void*); extern BOOL types_get_real_type(struct dbg_type* type, DWORD* tag); -extern struct dbg_type types_find_pointer(const struct dbg_type* type); -extern struct dbg_type types_find_type(DWORD64 linear, const char* name, enum SymTagEnum tag); +extern BOOL types_find_pointer(const struct dbg_type* type, struct dbg_type* outtype); +extern BOOL types_find_type(const char* name, enum SymTagEnum tag, struct dbg_type* outtype); extern BOOL types_compare(const struct dbg_type, const struct dbg_type, BOOL* equal); extern BOOL types_is_integral_type(const struct dbg_lvalue*); extern BOOL types_is_float_type(const struct dbg_lvalue*); -extern BOOL types_find_basic(const WCHAR*, const char*, struct type_expr_t* type); +extern BOOL types_is_pointer_type(const struct dbg_lvalue*); +extern BOOL types_find_basic(const WCHAR*, const char*, struct dbg_type* type);
/* winedbg.c */ #ifdef __GNUC__ diff --git a/programs/winedbg/expr.c b/programs/winedbg/expr.c index 5d9ef30ad13..9a927338ba8 100644 --- a/programs/winedbg/expr.c +++ b/programs/winedbg/expr.c @@ -75,8 +75,9 @@ struct expr
struct { - struct type_expr_t cast_to; + struct dbg_type cast_to; struct expr* expr; + dbg_lgint_t result; } cast;
struct @@ -128,14 +129,14 @@ void expr_free_all(void) next_expr_free = 0; }
-struct expr* expr_alloc_typecast(struct type_expr_t* tet, struct expr* exp) +struct expr* expr_alloc_typecast(struct dbg_type* type, struct expr* exp) { struct expr* ex;
ex = expr_alloc();
ex->type = EXPR_TYPE_CAST; - ex->un.cast.cast_to = *tet; + ex->un.cast.cast_to = *type; ex->un.cast.expr = exp; return ex; } @@ -272,75 +273,74 @@ struct expr* WINAPIV expr_alloc_func_call(const char* funcname, int nargs, ...) struct dbg_lvalue expr_eval(struct expr* exp) { struct dbg_lvalue rtn; - int i; struct dbg_lvalue exp1; struct dbg_lvalue exp2; DWORD64 scale1, scale2, scale3; struct dbg_type type1, type2; DWORD tag; const struct dbg_internal_var* div; + BOOL ret;
- init_lvalue_in_debugger(&rtn, dbg_itype_none, NULL); + init_lvalue_in_debugger(&rtn, 0, dbg_itype_none, NULL);
switch (exp->type) { case EXPR_TYPE_CAST: - /* this is really brute force, we simply change the type... without - * checking if this is right or not - */ - rtn = expr_eval(exp->un.cast.expr); - switch (exp->un.cast.cast_to.type) + exp1 = expr_eval(exp->un.cast.expr); + if (exp1.type.id == dbg_itype_none) + RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL); + rtn = exp1; + rtn.type = exp->un.cast.cast_to; + init_lvalue_in_debugger(&rtn, exp->un.cast.cast_to.module, exp->un.cast.cast_to.id, &exp->un.cast.result); + if (types_is_float_type(&exp1)) { - case type_expr_type_id: - if (exp->un.cast.cast_to.u.type.id == dbg_itype_none) + double dbl; + ret = memory_fetch_float(&exp1, &dbl); + if (ret) { - dbg_printf("Can't cast to unknown type\n"); - RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL); + if (types_is_float_type(&rtn)) + ret = memory_store_float(&rtn, &dbl); + else if (types_is_integral_type(&rtn)) + ret = memory_store_integer(&rtn, (dbg_lgint_t)dbl); + else + ret = FALSE; } - rtn.type = exp->un.cast.cast_to.u.type; - break; - case type_expr_udt_class: - case type_expr_udt_struct: - case type_expr_udt_union: - rtn.type = types_find_type(rtn.type.module, exp->un.cast.cast_to.u.name, - SymTagUDT); - if (rtn.type.id == dbg_itype_none) - { - dbg_printf("Can't cast to UDT %s\n", exp->un.cast.cast_to.u.name); - RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL); - } - break; - case type_expr_enumeration: - rtn.type = types_find_type(rtn.type.module, exp->un.cast.cast_to.u.name, - SymTagEnum); - if (rtn.type.id == dbg_itype_none) - { - dbg_printf("Can't cast to enumeration %s\n", exp->un.cast.cast_to.u.name); - RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL); - } - break; - default: - dbg_printf("Unsupported cast type %u\n", exp->un.cast.cast_to.type); - RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL); } - for (i = 0; i < exp->un.cast.cast_to.deref_count; i++) + else if (types_is_integral_type(&exp1)) { - rtn.type = types_find_pointer(&rtn.type); - if (rtn.type.id == dbg_itype_none) + dbg_lgint_t val = types_extract_as_integer(&exp1); + if (types_is_float_type(&rtn)) { - dbg_printf("Cannot find pointer type\n"); - RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL); + double dbl = val; + ret = memory_store_float(&rtn, &dbl); } + else if (types_is_integral_type(&rtn) || types_is_pointer_type(&rtn)) + ret = memory_store_integer(&rtn, val); + else + ret = FALSE; + } + else if (types_is_pointer_type(&exp1)) + { + dbg_lgint_t val = types_extract_as_integer(&exp1); + + if (types_is_integral_type(&rtn) || types_is_pointer_type(&rtn)) + ret = memory_store_integer(&rtn, val); + else + ret = FALSE; } + else + ret = FALSE; + if (!ret) + RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL); break; case EXPR_TYPE_STRING: - init_lvalue_in_debugger(&rtn, dbg_itype_astring, &exp->un.string.str); + init_lvalue_in_debugger(&rtn, 0, dbg_itype_astring, &exp->un.string.str); break; case EXPR_TYPE_U_CONST: - init_lvalue_in_debugger(&rtn, dbg_itype_lguint, &exp->un.u_const.value); + init_lvalue_in_debugger(&rtn, 0, dbg_itype_lguint, &exp->un.u_const.value); break; case EXPR_TYPE_S_CONST: - init_lvalue_in_debugger(&rtn, dbg_itype_lgint, &exp->un.s_const.value); + init_lvalue_in_debugger(&rtn, 0, dbg_itype_lgint, &exp->un.s_const.value); break; case EXPR_TYPE_SYMBOL: switch (symbol_get_lvalue(exp->un.symbol.name, -1, &rtn, FALSE)) @@ -440,7 +440,7 @@ struct dbg_lvalue expr_eval(struct expr* exp) */ exp->un.call.result = 0; #endif - init_lvalue_in_debugger(&rtn, dbg_itype_none, &exp->un.call.result); + init_lvalue_in_debugger(&rtn, 0, dbg_itype_none, &exp->un.call.result); /* get return type from function signature type */ /* FIXME rtn.type.module should be set to function's module... */ types_get_info(&rtn.type, TI_GET_TYPE, &rtn.type.id); @@ -448,14 +448,14 @@ struct dbg_lvalue expr_eval(struct expr* exp) case EXPR_TYPE_INTVAR: if (!(div = dbg_get_internal_var(exp->un.intvar.name))) RaiseException(DEBUG_STATUS_NO_SYMBOL, 0, 0, NULL); - init_lvalue_in_debugger(&rtn, div->typeid, div->pval); + init_lvalue_in_debugger(&rtn, 0, div->typeid, div->pval); break; case EXPR_TYPE_BINOP: exp1 = expr_eval(exp->un.binop.exp1); exp2 = expr_eval(exp->un.binop.exp2); if (exp1.type.id == dbg_itype_none || exp2.type.id == dbg_itype_none) RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL); - init_lvalue_in_debugger(&rtn, dbg_itype_lgint, &exp->un.binop.result); + init_lvalue_in_debugger(&rtn, 0, dbg_itype_lgint, &exp->un.binop.result); type1 = exp1.type; type2 = exp2.type; switch (exp->un.binop.binop_type) @@ -584,7 +584,7 @@ struct dbg_lvalue expr_eval(struct expr* exp) case EXPR_TYPE_UNOP: exp1 = expr_eval(exp->un.unop.exp1); if (exp1.type.id == dbg_itype_none) RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL); - init_lvalue_in_debugger(&rtn, dbg_itype_lgint, &exp->un.unop.result); + init_lvalue_in_debugger(&rtn, 0, dbg_itype_lgint, &exp->un.unop.result); switch (exp->un.unop.unop_type) { case EXP_OP_NEG: @@ -610,8 +610,7 @@ struct dbg_lvalue expr_eval(struct expr* exp) if (exp1.addr.Mode != AddrModeFlat) RaiseException(DEBUG_STATUS_CANT_DEREF, 0, 0, NULL); exp->un.unop.result = (ULONG_PTR)memory_to_linear_addr(&exp1.addr); - rtn.type = types_find_pointer(&exp1.type); - if (rtn.type.id == dbg_itype_none) + if (!types_find_pointer(&exp1.type, &rtn.type)) RaiseException(DEBUG_STATUS_CANT_DEREF, 0, 0, NULL); break; default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL); @@ -629,30 +628,12 @@ struct dbg_lvalue expr_eval(struct expr* exp) BOOL expr_print(const struct expr* exp) { int i; - struct dbg_type type;
switch (exp->type) { case EXPR_TYPE_CAST: - WINE_FIXME("No longer supported (missing module base)\n"); dbg_printf("(("); - switch (exp->un.cast.cast_to.type) - { - case type_expr_type_id: - type.module = 0; - type.id = exp->un.cast.cast_to.type; - types_print_type(&type, FALSE); break; - case type_expr_udt_class: - dbg_printf("class %s", exp->un.cast.cast_to.u.name); break; - case type_expr_udt_struct: - dbg_printf("struct %s", exp->un.cast.cast_to.u.name); break; - case type_expr_udt_union: - dbg_printf("union %s", exp->un.cast.cast_to.u.name); break; - case type_expr_enumeration: - dbg_printf("enum %s", exp->un.cast.cast_to.u.name); break; - } - for (i = 0; i < exp->un.cast.cast_to.deref_count; i++) - dbg_printf("*"); + types_print_type(&exp->un.cast.cast_to, FALSE); dbg_printf(")"); expr_print(exp->un.cast.expr); dbg_printf(")"); diff --git a/programs/winedbg/stack.c b/programs/winedbg/stack.c index 50932e14ddd..01a86108d6e 100644 --- a/programs/winedbg/stack.c +++ b/programs/winedbg/stack.c @@ -103,7 +103,7 @@ BOOL stack_get_register_frame(const struct dbg_internal_var* div, struct dbg_lva struct dbg_frame* currfrm = stack_get_curr_frame(); if (currfrm == NULL) return FALSE; if (currfrm->is_ctx_valid) - init_lvalue_in_debugger(lvalue, div->typeid, + init_lvalue_in_debugger(lvalue, 0, div->typeid, (char*)&currfrm->context + (DWORD_PTR)div->pval); else { @@ -116,13 +116,13 @@ BOOL stack_get_register_frame(const struct dbg_internal_var* div, struct dbg_lva switch (kind) { case be_cpu_addr_pc: - init_lvalue_in_debugger(lvalue, itype, &currfrm->linear_pc); + init_lvalue_in_debugger(lvalue, 0, itype, &currfrm->linear_pc); break; case be_cpu_addr_stack: - init_lvalue_in_debugger(lvalue, itype, &currfrm->linear_stack); + init_lvalue_in_debugger(lvalue, 0, itype, &currfrm->linear_stack); break; case be_cpu_addr_frame: - init_lvalue_in_debugger(lvalue, itype, &currfrm->linear_frame); + init_lvalue_in_debugger(lvalue, 0, itype, &currfrm->linear_frame); break; } } diff --git a/programs/winedbg/types.c b/programs/winedbg/types.c index f9860bd12c1..b8f29058162 100644 --- a/programs/winedbg/types.c +++ b/programs/winedbg/types.c @@ -300,7 +300,8 @@ BOOL types_array_index(const struct dbg_lvalue* lvalue, int index, struct dbg_lv } break; default: - assert(FALSE); + FIXME("unexpected tag %lx\n", tag); + return FALSE; } /* * Get the base type, so we know how much to index by. @@ -332,13 +333,9 @@ BOOL types_array_index(const struct dbg_lvalue* lvalue, int index, struct dbg_lv
struct type_find_t { - ULONG result; /* out: the found type */ enum SymTagEnum tag; /* in: the tag to look for */ - union - { - ULONG typeid; /* when tag is SymTagUDT */ - const char* name; /* when tag is SymTagPointerType */ - } u; + 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) @@ -353,18 +350,18 @@ static BOOL CALLBACK types_cb(PSYMBOL_INFO sym, ULONG size, void* _user) switch (user->tag) { case SymTagUDT: - if (!strcmp(user->u.name, sym->Name)) - { - user->result = sym->TypeIndex; - ret = FALSE; - } + 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 == user->u.typeid) + if (types_get_info(&type, TI_GET_TYPE, &type_id) && type_id == user->ptr_typeid) { - user->result = sym->TypeIndex; + user->type = type; ret = FALSE; } break; @@ -380,18 +377,17 @@ static BOOL CALLBACK types_cb(PSYMBOL_INFO sym, ULONG size, void* _user) * Should look up in module based at linear whether (typeid*) exists * Otherwise, we could create it locally */ -struct dbg_type types_find_pointer(const struct dbg_type* type) +BOOL types_find_pointer(const struct dbg_type* type, struct dbg_type* outtype) { struct type_find_t f; - struct dbg_type ret;
- f.result = dbg_itype_none; + f.type.id = dbg_itype_none; f.tag = SymTagPointerType; - f.u.typeid = type->id; - SymEnumTypes(dbg_curr_process->handle, type->module, types_cb, &f); - ret.module = type->module; - ret.id = f.result; - return ret; + f.ptr_typeid = type->id; + if (!SymEnumTypes(dbg_curr_process->handle, type->module, types_cb, &f) || f.type.id == dbg_itype_none) + return FALSE; + *outtype = f.type; + return TRUE; }
/****************************************************************** @@ -400,19 +396,29 @@ struct dbg_type types_find_pointer(const struct dbg_type* type) * Should look up in the module based at linear address whether a type * named 'name' and with the correct tag exists */ -struct dbg_type types_find_type(DWORD64 linear, const char* name, enum SymTagEnum tag) - +BOOL types_find_type(const char* name, enum SymTagEnum tag, struct dbg_type* outtype) { struct type_find_t f; - struct dbg_type ret; + char* str = NULL; + BOOL ret;
- f.result = dbg_itype_none; + 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; - f.u.name = name; - SymEnumTypes(dbg_curr_process->handle, linear, types_cb, &f); - ret.module = linear; - ret.id = f.result; - return ret; + 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; }
/*********************************************************************** @@ -916,7 +922,7 @@ static BOOL CALLBACK enum_mod_cb(const char* module, DWORD64 base, void* user) return TRUE; }
-BOOL types_find_basic(const WCHAR* name, const char* mod, struct type_expr_t* type) +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}; @@ -928,15 +934,13 @@ BOOL types_find_basic(const WCHAR* name, const char* mod, struct typ SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, opt); if (!ret || mbn.base == 0) return FALSE; - type->type = type_expr_type_id; - type->deref_count = 0; model = get_data_model(mbn.base); for (; model->name; model++) { if (!wcscmp(name, model->name)) { - type->u.type.module = 0; - type->u.type.id = model->itype; + type->module = 0; + type->id = model->itype; return TRUE; } } @@ -1238,3 +1242,12 @@ BOOL types_is_float_type(const struct dbg_lvalue* lv) !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); +}