Skip to content

W
wine-cw
Commit 14462bbe authored by Eric Pouech's avatar Eric Pouech Committed by Alexandre Julliard
Browse files
Options

dbghelp: Let symt_basic be trans-module and nameless.

Rationale: - native doesn't report names for SymTagBaseType objects => so remove typename for sym_basic - since symt_basic becomes pretty simple, it's possible to share the object across all modules loaded in dbghelp (simplicity, memory usage reduction) - removed dwarf basic types cache in dwarf.c as we now have a generic one Signed-off-by: 's avatarEric Pouech <eric.pouech@gmail.com> Signed-off-by: 's avatarAlexandre Julliard <julliard@winehq.org>
parent 6eb18ae6
Hide whitespace changes
Inline Side-by-side
Showing with 87 additions and 104 deletions
dlls/dbghelp/dbghelp_private.h
View file @ 14462bbe
...@@ -336,7 +336,6 @@ struct symt_array ...@@ -336,7 +336,6 @@ struct symt_array
struct symt_basic struct symt_basic
{ {
struct symt symt; struct symt symt;
struct hash_table_elt hash_elt;
enum BasicType bt; enum BasicType bt;
ULONG_PTR size; ULONG_PTR size;
}; };
...@@ -901,8 +900,7 @@ extern void symt_init_basic(struct module* module) DECLSPEC_HIDDEN; ...@@ -901,8 +900,7 @@ extern void symt_init_basic(struct module* module) DECLSPEC_HIDDEN;
extern BOOL symt_get_info(struct module* module, const struct symt* type, extern BOOL symt_get_info(struct module* module, const struct symt* type,
IMAGEHLP_SYMBOL_TYPE_INFO req, void* pInfo) DECLSPEC_HIDDEN; IMAGEHLP_SYMBOL_TYPE_INFO req, void* pInfo) DECLSPEC_HIDDEN;
extern struct symt_basic* extern struct symt_basic*
symt_new_basic(struct module* module, enum BasicType, symt_get_basic(enum BasicType, unsigned size) DECLSPEC_HIDDEN;
const char* typename, unsigned size) DECLSPEC_HIDDEN;
extern struct symt_udt* extern struct symt_udt*
symt_new_udt(struct module* module, const char* typename, symt_new_udt(struct module* module, const char* typename,
unsigned size, enum UdtKind kind) DECLSPEC_HIDDEN; unsigned size, enum UdtKind kind) DECLSPEC_HIDDEN;
......
dlls/dbghelp/dwarf.c
View file @ 14462bbe
...@@ -162,11 +162,6 @@ typedef struct dwarf2_traverse_context_s ...@@ -162,11 +162,6 @@ typedef struct dwarf2_traverse_context_s
const unsigned char* end_data; const unsigned char* end_data;
} dwarf2_traverse_context_t; } dwarf2_traverse_context_t;
/* symt_cache indexes */
#define sc_void 0
#define sc_unknown 1
#define sc_num 2
typedef struct dwarf2_cuhead_s typedef struct dwarf2_cuhead_s
{ {
unsigned char word_size; /* size of a word on target machine */ unsigned char word_size; /* size of a word on target machine */
...@@ -180,7 +175,6 @@ typedef struct dwarf2_parse_module_context_s ...@@ -180,7 +175,6 @@ typedef struct dwarf2_parse_module_context_s
const dwarf2_section_t* sections; const dwarf2_section_t* sections;
struct module* module; struct module* module;
const struct elf_thunk_area*thunks; const struct elf_thunk_area*thunks;
struct symt* symt_cache[sc_num]; /* void, unknown */
struct vector unit_contexts; struct vector unit_contexts;
struct dwarf2_dwz_alternate_s* dwz; struct dwarf2_dwz_alternate_s* dwz;
DWORD cu_versions; DWORD cu_versions;
...@@ -1138,14 +1132,14 @@ static struct symt* dwarf2_lookup_type(const dwarf2_debug_info_t* di) ...@@ -1138,14 +1132,14 @@ static struct symt* dwarf2_lookup_type(const dwarf2_debug_info_t* di)
if (!dwarf2_find_attribute(di, DW_AT_type, &attr)) if (!dwarf2_find_attribute(di, DW_AT_type, &attr))
/* this is only valid if current language of CU is C or C++ */ /* this is only valid if current language of CU is C or C++ */
return di->unit_ctx->module_ctx->symt_cache[sc_void]; return &symt_get_basic(btVoid, 0)->symt;
if (!(type = dwarf2_jump_to_debug_info(&attr))) if (!(type = dwarf2_jump_to_debug_info(&attr)))
return di->unit_ctx->module_ctx->symt_cache[sc_unknown]; return &symt_get_basic(btNoType, 0)->symt;
if (type == di) if (type == di)
{ {
FIXME("Reference to itself\n"); FIXME("Reference to itself\n");
return di->unit_ctx->module_ctx->symt_cache[sc_unknown]; return &symt_get_basic(btNoType, 0)->symt;
} }
if (!type->symt) if (!type->symt)
{ {
...@@ -1154,7 +1148,7 @@ static struct symt* dwarf2_lookup_type(const dwarf2_debug_info_t* di) ...@@ -1154,7 +1148,7 @@ static struct symt* dwarf2_lookup_type(const dwarf2_debug_info_t* di)
if (!type->symt) if (!type->symt)
{ {
FIXME("Unable to load forward reference for tag %Ix\n", type->abbrev->tag); FIXME("Unable to load forward reference for tag %Ix\n", type->abbrev->tag);
return di->unit_ctx->module_ctx->symt_cache[sc_unknown]; return &symt_get_basic(btNoType, 0)->symt;
} }
} }
return type->symt; return type->symt;
...@@ -1484,7 +1478,7 @@ static struct symt* dwarf2_parse_base_type(dwarf2_debug_info_t* di) ...@@ -1484,7 +1478,7 @@ static struct symt* dwarf2_parse_base_type(dwarf2_debug_info_t* di)
case DW_ATE_unsigned_char: bt = btChar; break; case DW_ATE_unsigned_char: bt = btChar; break;
default: bt = btNoType; break; default: bt = btNoType; break;
} }
di->symt = &symt_new_basic(di->unit_ctx->module_ctx->module, bt, name.u.string, size.u.uvalue)->symt; di->symt = &symt_get_basic(bt, size.u.uvalue)->symt;
if (dwarf2_get_di_children(di)) FIXME("Unsupported children\n"); if (dwarf2_get_di_children(di)) FIXME("Unsupported children\n");
return di->symt; return di->symt;
...@@ -1566,14 +1560,14 @@ static struct symt* dwarf2_parse_array_type(dwarf2_debug_info_t* di) ...@@ -1566,14 +1560,14 @@ static struct symt* dwarf2_parse_array_type(dwarf2_debug_info_t* di)
{ {
/* fake an array with unknown size */ /* fake an array with unknown size */
/* FIXME: int4 even on 64bit machines??? */ /* FIXME: int4 even on 64bit machines??? */
idx_type = &symt_new_basic(di->unit_ctx->module_ctx->module, btInt, "int", 4)->symt; idx_type = &symt_get_basic(btInt, 4)->symt;
min.u.uvalue = 0; min.u.uvalue = 0;
cnt.u.uvalue = 0; cnt.u.uvalue = 0;
} }
else for (i = 0; i < vector_length(children); i++) else for (i = 0; i < vector_length(children); i++)
{ {
child = *(dwarf2_debug_info_t**)vector_at(children, i); child = *(dwarf2_debug_info_t**)vector_at(children, i);
if (child->symt == di->unit_ctx->module_ctx->symt_cache[sc_unknown]) continue; if (child->symt == &symt_get_basic(btNoType, 0)->symt) continue;
switch (child->abbrev->tag) switch (child->abbrev->tag)
{ {
case DW_TAG_subrange_type: case DW_TAG_subrange_type:
...@@ -1665,19 +1659,18 @@ static struct symt* dwarf2_parse_restrict_type(dwarf2_debug_info_t* di) ...@@ -1665,19 +1659,18 @@ static struct symt* dwarf2_parse_restrict_type(dwarf2_debug_info_t* di)
static struct symt* dwarf2_parse_unspecified_type(dwarf2_debug_info_t* di) static struct symt* dwarf2_parse_unspecified_type(dwarf2_debug_info_t* di)
{ {
struct attribute name; struct attribute name;
struct attribute size; struct symt* basic;
struct symt_basic *basic;
TRACE("%s\n", dwarf2_debug_di(di)); TRACE("%s\n", dwarf2_debug_di(di));
if (di->symt) return di->symt; if (di->symt) return di->symt;
if (!dwarf2_find_attribute(di, DW_AT_name, &name)) basic = &symt_get_basic(btVoid, 0)->symt;
name.u.string = "void"; if (dwarf2_find_attribute(di, DW_AT_name, &name))
size.u.uvalue = di->unit_ctx->module_ctx->module->cpu->word_size; /* define the missing type as a typedef to void... */
di->symt = &symt_new_typedef(di->unit_ctx->module_ctx->module, basic, name.u.string)->symt;
basic = symt_new_basic(di->unit_ctx->module_ctx->module, btVoid, name.u.string, size.u.uvalue); else /* or use void if it doesn't even have a name */
di->symt = &basic->symt; di->symt = basic;
if (dwarf2_get_di_children(di)) FIXME("Unsupported children\n"); if (dwarf2_get_di_children(di)) FIXME("Unsupported children\n");
return di->symt; return di->symt;
...@@ -1878,10 +1871,10 @@ static struct symt* dwarf2_parse_enumeration_type(dwarf2_debug_info_t* di) ...@@ -1878,10 +1871,10 @@ static struct symt* dwarf2_parse_enumeration_type(dwarf2_debug_info_t* di)
switch (size.u.uvalue) /* FIXME: that's wrong */ switch (size.u.uvalue) /* FIXME: that's wrong */
{ {
case 1: basetype = symt_new_basic(di->unit_ctx->module_ctx->module, btInt, "char", 1); break; case 1: basetype = symt_get_basic(btInt, 1); break;
case 2: basetype = symt_new_basic(di->unit_ctx->module_ctx->module, btInt, "short", 2); break; case 2: basetype = symt_get_basic(btInt, 2); break;
default: default:
case 4: basetype = symt_new_basic(di->unit_ctx->module_ctx->module, btInt, "int", 4); break; case 4: basetype = symt_get_basic(btInt, 4); break;
} }
type = &basetype->symt; type = &basetype->symt;
} }
...@@ -2457,7 +2450,7 @@ static void dwarf2_parse_namespace(dwarf2_debug_info_t* di) ...@@ -2457,7 +2450,7 @@ static void dwarf2_parse_namespace(dwarf2_debug_info_t* di)
TRACE("%s\n", dwarf2_debug_di(di)); TRACE("%s\n", dwarf2_debug_di(di));
di->symt = di->unit_ctx->module_ctx->symt_cache[sc_void]; di->symt = &symt_get_basic(btVoid, 0)->symt;
children = dwarf2_get_di_children(di); children = dwarf2_get_di_children(di);
if (children) for (i = 0; i < vector_length(children); i++) if (children) for (i = 0; i < vector_length(children); i++)
...@@ -4071,9 +4064,6 @@ static BOOL dwarf2_load_CU_module(dwarf2_parse_module_context_t* module_ctx, str ...@@ -4071,9 +4064,6 @@ static BOOL dwarf2_load_CU_module(dwarf2_parse_module_context_t* module_ctx, str
module_ctx->module = module; module_ctx->module = module;
module_ctx->thunks = thunks; module_ctx->thunks = thunks;
module_ctx->load_offset = load_offset; module_ctx->load_offset = load_offset;
memset(module_ctx->symt_cache, 0, sizeof(module_ctx->symt_cache));
module_ctx->symt_cache[sc_void] = &symt_new_basic(module_ctx->module, btVoid, "void", 0)->symt;
module_ctx->symt_cache[sc_unknown] = &symt_new_basic(module_ctx->module, btNoType, "# unknown", 0)->symt;
vector_init(&module_ctx->unit_contexts, sizeof(dwarf2_parse_context_t), 16); vector_init(&module_ctx->unit_contexts, sizeof(dwarf2_parse_context_t), 16);
module_ctx->cu_versions = 0; module_ctx->cu_versions = 0;
......
dlls/dbghelp/msc.c
View file @ 14462bbe
...@@ -157,34 +157,34 @@ static void codeview_init_basic_types(struct module* module) ...@@ -157,34 +157,34 @@ static void codeview_init_basic_types(struct module* module)
*/ */
cv_basic_types[T_NOTYPE] = NULL; cv_basic_types[T_NOTYPE] = NULL;
cv_basic_types[T_ABS] = NULL; cv_basic_types[T_ABS] = NULL;
cv_basic_types[T_VOID] = &symt_new_basic(module, btVoid, "void", 0)->symt; cv_basic_types[T_VOID] = &symt_get_basic(btVoid, 0)->symt; /* void */
cv_basic_types[T_CHAR] = &symt_new_basic(module, btChar, "char", 1)->symt; cv_basic_types[T_CHAR] = &symt_get_basic(btChar, 1)->symt; /* char */
cv_basic_types[T_SHORT] = &symt_new_basic(module, btInt, "short int", 2)->symt; cv_basic_types[T_SHORT] = &symt_get_basic(btInt, 2)->symt; /* short int */
cv_basic_types[T_LONG] = &symt_new_basic(module, btInt, "long int", 4)->symt; cv_basic_types[T_LONG] = &symt_get_basic(btInt, 4)->symt; /* long int */
cv_basic_types[T_QUAD] = &symt_new_basic(module, btInt, "long long int", 8)->symt; cv_basic_types[T_QUAD] = &symt_get_basic(btInt, 8)->symt; /* long long int */
cv_basic_types[T_UCHAR] = &symt_new_basic(module, btUInt, "unsigned char", 1)->symt; cv_basic_types[T_UCHAR] = &symt_get_basic(btUInt, 1)->symt; /* unsigned char */
cv_basic_types[T_USHORT] = &symt_new_basic(module, btUInt, "unsigned short", 2)->symt; cv_basic_types[T_USHORT] = &symt_get_basic(btUInt, 2)->symt; /* unsigned short */
cv_basic_types[T_ULONG] = &symt_new_basic(module, btUInt, "unsigned long", 4)->symt; cv_basic_types[T_ULONG] = &symt_get_basic(btUInt, 4)->symt; /* unsigned long */
cv_basic_types[T_UQUAD] = &symt_new_basic(module, btUInt, "unsigned long long", 8)->symt; cv_basic_types[T_UQUAD] = &symt_get_basic(btUInt, 8)->symt; /* unsigned long long */
cv_basic_types[T_BOOL08] = &symt_new_basic(module, btBool, "BOOL08", 1)->symt; cv_basic_types[T_BOOL08] = &symt_get_basic(btBool, 1)->symt; /* BOOL08 */
cv_basic_types[T_BOOL16] = &symt_new_basic(module, btBool, "BOOL16", 2)->symt; cv_basic_types[T_BOOL16] = &symt_get_basic(btBool, 2)->symt; /* BOOL16 */
cv_basic_types[T_BOOL32] = &symt_new_basic(module, btBool, "BOOL32", 4)->symt; cv_basic_types[T_BOOL32] = &symt_get_basic(btBool, 4)->symt; /* BOOL32 */
cv_basic_types[T_BOOL64] = &symt_new_basic(module, btBool, "BOOL64", 8)->symt; cv_basic_types[T_BOOL64] = &symt_get_basic(btBool, 8)->symt; /* BOOL64 */
cv_basic_types[T_REAL32] = &symt_new_basic(module, btFloat, "float", 4)->symt; cv_basic_types[T_REAL32] = &symt_get_basic(btFloat, 4)->symt; /* float */
cv_basic_types[T_REAL64] = &symt_new_basic(module, btFloat, "double", 8)->symt; cv_basic_types[T_REAL64] = &symt_get_basic(btFloat, 8)->symt; /* double */
cv_basic_types[T_REAL80] = &symt_new_basic(module, btFloat, "long double", 10)->symt; cv_basic_types[T_REAL80] = &symt_get_basic(btFloat, 10)->symt; /* long double */
cv_basic_types[T_RCHAR] = &symt_new_basic(module, btInt, "signed char", 1)->symt; cv_basic_types[T_RCHAR] = &symt_get_basic(btInt, 1)->symt; /* signed char */
cv_basic_types[T_WCHAR] = &symt_new_basic(module, btWChar, "wchar_t", 2)->symt; cv_basic_types[T_WCHAR] = &symt_get_basic(btWChar, 2)->symt; /* char8_t */
cv_basic_types[T_CHAR16] = &symt_new_basic(module, btChar16,"char16_t", 2)->symt; cv_basic_types[T_CHAR16] = &symt_get_basic(btChar16, 2)->symt; /* char16_t */
cv_basic_types[T_CHAR32] = &symt_new_basic(module, btChar32,"char32_t", 4)->symt; cv_basic_types[T_CHAR32] = &symt_get_basic(btChar32, 4)->symt; /* char32_t */
cv_basic_types[T_CHAR8] = &symt_new_basic(module, btChar8, "char8_t", 1)->symt; cv_basic_types[T_CHAR8] = &symt_get_basic(btChar8, 1)->symt; /* char8_t */
cv_basic_types[T_INT2] = &symt_new_basic(module, btInt, "INT2", 2)->symt; cv_basic_types[T_INT2] = &symt_get_basic(btInt, 2)->symt; /* INT2 */
cv_basic_types[T_UINT2] = &symt_new_basic(module, btUInt, "UINT2", 2)->symt; cv_basic_types[T_UINT2] = &symt_get_basic(btUInt, 2)->symt; /* UINT2 */
cv_basic_types[T_INT4] = &symt_new_basic(module, btInt, "INT4", 4)->symt; cv_basic_types[T_INT4] = &symt_get_basic(btInt, 4)->symt; /* INT4 */
cv_basic_types[T_UINT4] = &symt_new_basic(module, btUInt, "UINT4", 4)->symt; cv_basic_types[T_UINT4] = &symt_get_basic(btUInt, 4)->symt; /* UINT4 */
cv_basic_types[T_INT8] = &symt_new_basic(module, btInt, "INT8", 8)->symt; cv_basic_types[T_INT8] = &symt_get_basic(btInt, 8)->symt; /* INT8 */
cv_basic_types[T_UINT8] = &symt_new_basic(module, btUInt, "UINT8", 8)->symt; cv_basic_types[T_UINT8] = &symt_get_basic(btUInt, 8)->symt; /* UINT8 */
cv_basic_types[T_HRESULT]= &symt_new_basic(module, btUInt, "HRESULT", 4)->symt; cv_basic_types[T_HRESULT]= &symt_get_basic(btUInt, 4)->symt; /* HRESULT */
cv_basic_types[T_32PVOID] = &symt_new_pointer(module, cv_basic_types[T_VOID], 4)->symt; cv_basic_types[T_32PVOID] = &symt_new_pointer(module, cv_basic_types[T_VOID], 4)->symt;
cv_basic_types[T_32PCHAR] = &symt_new_pointer(module, cv_basic_types[T_CHAR], 4)->symt; cv_basic_types[T_32PCHAR] = &symt_new_pointer(module, cv_basic_types[T_CHAR], 4)->symt;
......
dlls/dbghelp/stabs.c
View file @ 14462bbe
...@@ -322,31 +322,31 @@ static int stabs_get_basic(struct ParseTypedefData* ptd, unsigned basic, struct ...@@ -322,31 +322,31 @@ static int stabs_get_basic(struct ParseTypedefData* ptd, unsigned basic, struct
{ {
switch (basic) switch (basic)
{ {
case 1: stabs_basic[basic] = symt_new_basic(ptd->module, btInt, "int", 4); break; case 1: stabs_basic[basic] = symt_get_basic(btInt, 4); break; /* int */
case 2: stabs_basic[basic] = symt_new_basic(ptd->module, btChar, "char", 1); break; case 2: stabs_basic[basic] = symt_get_basic(btChar, 1); break; /* char */
case 3: stabs_basic[basic] = symt_new_basic(ptd->module, btInt, "short int", 2); break; case 3: stabs_basic[basic] = symt_get_basic(btInt, 2); break; /* short int */
case 4: stabs_basic[basic] = symt_new_basic(ptd->module, btInt, "long int", 4); break; case 4: stabs_basic[basic] = symt_get_basic(btInt, 4); break; /* long int */
case 5: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt, "unsigned char", 1); break; case 5: stabs_basic[basic] = symt_get_basic(btUInt, 1); break; /* unsigned char */
case 6: stabs_basic[basic] = symt_new_basic(ptd->module, btInt, "signed char", 1); break; case 6: stabs_basic[basic] = symt_get_basic(btInt, 1); break; /* signed char */
case 7: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt, "unsigned short int", 2); break; case 7: stabs_basic[basic] = symt_get_basic(btUInt, 2); break; /* unsigned short int */
case 8: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt, "unsigned int", 4); break; case 8: stabs_basic[basic] = symt_get_basic(btUInt, 4); break; /* unsigned int */
case 9: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt, "unsigned", 2); break; case 9: stabs_basic[basic] = symt_get_basic(btUInt, 2); break; /* unsigned */
case 10: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt, "unsigned long int", 2); break; case 10: stabs_basic[basic] = symt_get_basic(btUInt, 2); break; /* unsigned long int */
case 11: stabs_basic[basic] = symt_new_basic(ptd->module, btVoid, "void", 0); break; case 11: stabs_basic[basic] = symt_get_basic(btVoid, 0); break; /* void */
case 12: stabs_basic[basic] = symt_new_basic(ptd->module, btFloat, "float", 4); break; case 12: stabs_basic[basic] = symt_get_basic(btFloat, 4); break; /* float */
case 13: stabs_basic[basic] = symt_new_basic(ptd->module, btFloat, "double", 8); break; case 13: stabs_basic[basic] = symt_get_basic(btFloat, 8); break; /* double */
case 14: stabs_basic[basic] = symt_new_basic(ptd->module, btFloat, "long double", 12); break; case 14: stabs_basic[basic] = symt_get_basic(btFloat, 2); break; /* long double", */
case 15: stabs_basic[basic] = symt_new_basic(ptd->module, btInt, "integer", 4); break; case 15: stabs_basic[basic] = symt_get_basic(btInt, 4); break; /* integer */
case 16: stabs_basic[basic] = symt_new_basic(ptd->module, btBool, "bool", 1); break; case 16: stabs_basic[basic] = symt_get_basic(btBool, 1); break; /* bool */
/* case 17: short real */ /* case 17: short real */
/* case 18: real */ /* case 18: real */
case 25: stabs_basic[basic] = symt_new_basic(ptd->module, btComplex, "float complex", 8); break; case 25: stabs_basic[basic] = symt_get_basic(btComplex, 8); break; /* float complex */
case 26: stabs_basic[basic] = symt_new_basic(ptd->module, btComplex, "double complex", 16); break; case 26: stabs_basic[basic] = symt_get_basic(btComplex, 6); break; /* double complex", */
case 30: stabs_basic[basic] = symt_new_basic(ptd->module, btWChar, "wchar_t", 2); break; case 30: stabs_basic[basic] = symt_get_basic(btWChar, 2); break; /* wchar_t */
case 31: stabs_basic[basic] = symt_new_basic(ptd->module, btInt, "long long int", 8); break; case 31: stabs_basic[basic] = symt_get_basic(btInt, 8); break; /* long long int */
case 32: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt, "long long unsigned", 8); break; case 32: stabs_basic[basic] = symt_get_basic(btUInt, 8); break; /* long long unsigned */
/* starting at 35 are wine extensions (especially for R implementation) */ /* starting at 35 are wine extensions (especially for R implementation) */
case 35: stabs_basic[basic] = symt_new_basic(ptd->module, btComplex, "long double complex", 24); break; case 35: stabs_basic[basic] = symt_get_basic(btComplex, 4); break; /* long double complex", */
default: PTS_ABORTIF(ptd, 1); default: PTS_ABORTIF(ptd, 1);
} }
} }
...@@ -541,7 +541,7 @@ static int stabs_pts_read_range(struct ParseTypedefData* ptd, const char* typena ...@@ -541,7 +541,7 @@ static int stabs_pts_read_range(struct ParseTypedefData* ptd, const char* typena
} }
else PTS_ABORTIF(ptd, 1); else PTS_ABORTIF(ptd, 1);
*dt = &symt_new_basic(ptd->module, bt, typename, size)->symt; *dt = &symt_get_basic(bt, size)->symt;
return 0; return 0;
} }
...@@ -967,7 +967,7 @@ static int stabs_pts_read_type_def(struct ParseTypedefData* ptd, const char* typ ...@@ -967,7 +967,7 @@ static int stabs_pts_read_type_def(struct ParseTypedefData* ptd, const char* typ
*/ */
if (!new_dt && typename) if (!new_dt && typename)
{ {
new_dt = &symt_new_basic(ptd->module, btVoid, typename, 0)->symt; new_dt = &symt_get_basic(btVoid, 0)->symt;
PTS_ABORTIF(ptd, strcmp(typename, "void")); PTS_ABORTIF(ptd, strcmp(typename, "void"));
} }
} }
......
dlls/dbghelp/type.c
View file @ 14462bbe
...@@ -97,7 +97,6 @@ const char* symt_get_name(const struct symt* sym) ...@@ -97,7 +97,6 @@ const char* symt_get_name(const struct symt* sym)
case SymTagFunction: return ((const struct symt_function*)sym)->hash_elt.name; case SymTagFunction: return ((const struct symt_function*)sym)->hash_elt.name;
case SymTagInlineSite: return ((const struct symt_inlinesite*)sym)->func.hash_elt.name; case SymTagInlineSite: return ((const struct symt_inlinesite*)sym)->func.hash_elt.name;
case SymTagPublicSymbol: return ((const struct symt_public*)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 SymTagLabel: return ((const struct symt_hierarchy_point*)sym)->hash_elt.name;
case SymTagThunk: return ((const struct symt_thunk*)sym)->hash_elt.name; case SymTagThunk: return ((const struct symt_thunk*)sym)->hash_elt.name;
case SymTagCustom: return ((const struct symt_custom*)sym)->hash_elt.name; case SymTagCustom: return ((const struct symt_custom*)sym)->hash_elt.name;
...@@ -110,6 +109,7 @@ const char* symt_get_name(const struct symt* sym) ...@@ -110,6 +109,7 @@ const char* symt_get_name(const struct symt* sym)
default: default:
FIXME("Unsupported sym-tag %s\n", symt_get_tag_str(sym->tag)); FIXME("Unsupported sym-tag %s\n", symt_get_tag_str(sym->tag));
/* fall through */ /* fall through */
case SymTagBaseType:
case SymTagArrayType: case SymTagArrayType:
case SymTagPointerType: case SymTagPointerType:
case SymTagFunctionType: case SymTagFunctionType:
...@@ -224,31 +224,26 @@ static void symt_add_type(struct module* module, struct symt* symt) ...@@ -224,31 +224,26 @@ static void symt_add_type(struct module* module, struct symt* symt)
*p = symt; *p = symt;
} }
struct symt_basic* symt_new_basic(struct module* module, enum BasicType bt, struct symt_basic* symt_get_basic(enum BasicType bt, unsigned size)
const char* typename, unsigned size)
{ {
struct symt_basic* sym; static struct symt_basic cache[32] = { { {SymTagBaseType}, btNoType, 0 } };
int i;
if (typename) if (bt == btNoType) return &cache[0];
{ for (i = 1; i < ARRAY_SIZE(cache); i++)
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 (cache[i].bt == btNoType) /* empty slot, create new entry */
if (typename)
{ {
sym->hash_elt.name = pool_strdup(&module->pool, typename); cache[i].symt.tag = SymTagBaseType;
hash_table_add(&module->ht_types, &sym->hash_elt); cache[i].bt = bt;
} else sym->hash_elt.name = NULL; cache[i].size = size;
sym->bt = bt; return &cache[i];
sym->size = size; }
symt_add_type(module, &sym->symt); if (cache[i].bt == bt && cache[i].size == size)
return &cache[i];
} }
return sym; FIXME("Too few slots in basic types cache\n");
return &cache[0];
} }
struct symt_udt* symt_new_udt(struct module* module, const char* typename, struct symt_udt* symt_new_udt(struct module* module, const char* typename,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment