Skip to content

W
wine-winehq
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
struct symt_basic
{
struct symt symt;
struct hash_table_elt hash_elt;
enum BasicType bt;
ULONG_PTR size;
};
......@@ -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,
IMAGEHLP_SYMBOL_TYPE_INFO req, void* pInfo) DECLSPEC_HIDDEN;
extern struct symt_basic*
symt_new_basic(struct module* module, enum BasicType,
const char* typename, unsigned size) DECLSPEC_HIDDEN;
symt_get_basic(enum BasicType, unsigned size) DECLSPEC_HIDDEN;
extern struct symt_udt*
symt_new_udt(struct module* module, const char* typename,
unsigned size, enum UdtKind kind) DECLSPEC_HIDDEN;
......
dlls/dbghelp/dwarf.c
View file @ 14462bbe
......@@ -162,11 +162,6 @@ typedef struct dwarf2_traverse_context_s
const unsigned char* end_data;
} dwarf2_traverse_context_t;
/* symt_cache indexes */
#define sc_void 0
#define sc_unknown 1
#define sc_num 2
typedef struct dwarf2_cuhead_s
{
unsigned char word_size; /* size of a word on target machine */
......@@ -180,7 +175,6 @@ typedef struct dwarf2_parse_module_context_s
const dwarf2_section_t* sections;
struct module* module;
const struct elf_thunk_area*thunks;
struct symt* symt_cache[sc_num]; /* void, unknown */
struct vector unit_contexts;
struct dwarf2_dwz_alternate_s* dwz;
DWORD cu_versions;
......@@ -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))
/* 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)))
return di->unit_ctx->module_ctx->symt_cache[sc_unknown];
return &symt_get_basic(btNoType, 0)->symt;
if (type == di)
{
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)
{
......@@ -1154,7 +1148,7 @@ static struct symt* dwarf2_lookup_type(const dwarf2_debug_info_t* di)
if (!type->symt)
{
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;
......@@ -1484,7 +1478,7 @@ static struct symt* dwarf2_parse_base_type(dwarf2_debug_info_t* di)
case DW_ATE_unsigned_char: bt = btChar; 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");
return di->symt;
......@@ -1566,14 +1560,14 @@ static struct symt* dwarf2_parse_array_type(dwarf2_debug_info_t* di)
{
/* fake an array with unknown size */
/* 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;
cnt.u.uvalue = 0;
}
else for (i = 0; i < vector_length(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)
{
case DW_TAG_subrange_type:
......@@ -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)
{
struct attribute name;
struct attribute size;
struct symt_basic *basic;
struct symt* basic;
TRACE("%s\n", dwarf2_debug_di(di));
if (di->symt) return di->symt;
if (!dwarf2_find_attribute(di, DW_AT_name, &name))
name.u.string = "void";
size.u.uvalue = di->unit_ctx->module_ctx->module->cpu->word_size;
basic = symt_new_basic(di->unit_ctx->module_ctx->module, btVoid, name.u.string, size.u.uvalue);
di->symt = &basic->symt;
basic = &symt_get_basic(btVoid, 0)->symt;
if (dwarf2_find_attribute(di, DW_AT_name, &name))
/* 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;
else /* or use void if it doesn't even have a name */
di->symt = basic;
if (dwarf2_get_di_children(di)) FIXME("Unsupported children\n");
return di->symt;
......@@ -1878,10 +1871,10 @@ static struct symt* dwarf2_parse_enumeration_type(dwarf2_debug_info_t* di)
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 2: basetype = symt_new_basic(di->unit_ctx->module_ctx->module, btInt, "short", 2); break;
case 1: basetype = symt_get_basic(btInt, 1); break;
case 2: basetype = symt_get_basic(btInt, 2); break;
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;
}
......@@ -2457,7 +2450,7 @@ static void dwarf2_parse_namespace(dwarf2_debug_info_t* 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);
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
module_ctx->module = module;
module_ctx->thunks = thunks;
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);
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)
*/
cv_basic_types[T_NOTYPE] = NULL;
cv_basic_types[T_ABS] = NULL;
cv_basic_types[T_VOID] = &symt_new_basic(module, btVoid, "void", 0)->symt;
cv_basic_types[T_CHAR] = &symt_new_basic(module, btChar, "char", 1)->symt;
cv_basic_types[T_SHORT] = &symt_new_basic(module, btInt, "short int", 2)->symt;
cv_basic_types[T_LONG] = &symt_new_basic(module, btInt, "long int", 4)->symt;
cv_basic_types[T_QUAD] = &symt_new_basic(module, btInt, "long long int", 8)->symt;
cv_basic_types[T_UCHAR] = &symt_new_basic(module, btUInt, "unsigned char", 1)->symt;
cv_basic_types[T_USHORT] = &symt_new_basic(module, btUInt, "unsigned short", 2)->symt;
cv_basic_types[T_ULONG] = &symt_new_basic(module, btUInt, "unsigned long", 4)->symt;
cv_basic_types[T_UQUAD] = &symt_new_basic(module, btUInt, "unsigned long long", 8)->symt;
cv_basic_types[T_BOOL08] = &symt_new_basic(module, btBool, "BOOL08", 1)->symt;
cv_basic_types[T_BOOL16] = &symt_new_basic(module, btBool, "BOOL16", 2)->symt;
cv_basic_types[T_BOOL32] = &symt_new_basic(module, btBool, "BOOL32", 4)->symt;
cv_basic_types[T_BOOL64] = &symt_new_basic(module, btBool, "BOOL64", 8)->symt;
cv_basic_types[T_REAL32] = &symt_new_basic(module, btFloat, "float", 4)->symt;
cv_basic_types[T_REAL64] = &symt_new_basic(module, btFloat, "double", 8)->symt;
cv_basic_types[T_REAL80] = &symt_new_basic(module, btFloat, "long double", 10)->symt;
cv_basic_types[T_RCHAR] = &symt_new_basic(module, btInt, "signed char", 1)->symt;
cv_basic_types[T_WCHAR] = &symt_new_basic(module, btWChar, "wchar_t", 2)->symt;
cv_basic_types[T_CHAR16] = &symt_new_basic(module, btChar16,"char16_t", 2)->symt;
cv_basic_types[T_CHAR32] = &symt_new_basic(module, btChar32,"char32_t", 4)->symt;
cv_basic_types[T_CHAR8] = &symt_new_basic(module, btChar8, "char8_t", 1)->symt;
cv_basic_types[T_INT2] = &symt_new_basic(module, btInt, "INT2", 2)->symt;
cv_basic_types[T_UINT2] = &symt_new_basic(module, btUInt, "UINT2", 2)->symt;
cv_basic_types[T_INT4] = &symt_new_basic(module, btInt, "INT4", 4)->symt;
cv_basic_types[T_UINT4] = &symt_new_basic(module, btUInt, "UINT4", 4)->symt;
cv_basic_types[T_INT8] = &symt_new_basic(module, btInt, "INT8", 8)->symt;
cv_basic_types[T_UINT8] = &symt_new_basic(module, btUInt, "UINT8", 8)->symt;
cv_basic_types[T_HRESULT]= &symt_new_basic(module, btUInt, "HRESULT", 4)->symt;
cv_basic_types[T_VOID] = &symt_get_basic(btVoid, 0)->symt; /* void */
cv_basic_types[T_CHAR] = &symt_get_basic(btChar, 1)->symt; /* char */
cv_basic_types[T_SHORT] = &symt_get_basic(btInt, 2)->symt; /* short int */
cv_basic_types[T_LONG] = &symt_get_basic(btInt, 4)->symt; /* long int */
cv_basic_types[T_QUAD] = &symt_get_basic(btInt, 8)->symt; /* long long int */
cv_basic_types[T_UCHAR] = &symt_get_basic(btUInt, 1)->symt; /* unsigned char */
cv_basic_types[T_USHORT] = &symt_get_basic(btUInt, 2)->symt; /* unsigned short */
cv_basic_types[T_ULONG] = &symt_get_basic(btUInt, 4)->symt; /* unsigned long */
cv_basic_types[T_UQUAD] = &symt_get_basic(btUInt, 8)->symt; /* unsigned long long */
cv_basic_types[T_BOOL08] = &symt_get_basic(btBool, 1)->symt; /* BOOL08 */
cv_basic_types[T_BOOL16] = &symt_get_basic(btBool, 2)->symt; /* BOOL16 */
cv_basic_types[T_BOOL32] = &symt_get_basic(btBool, 4)->symt; /* BOOL32 */
cv_basic_types[T_BOOL64] = &symt_get_basic(btBool, 8)->symt; /* BOOL64 */
cv_basic_types[T_REAL32] = &symt_get_basic(btFloat, 4)->symt; /* float */
cv_basic_types[T_REAL64] = &symt_get_basic(btFloat, 8)->symt; /* double */
cv_basic_types[T_REAL80] = &symt_get_basic(btFloat, 10)->symt; /* long double */
cv_basic_types[T_RCHAR] = &symt_get_basic(btInt, 1)->symt; /* signed char */
cv_basic_types[T_WCHAR] = &symt_get_basic(btWChar, 2)->symt; /* char8_t */
cv_basic_types[T_CHAR16] = &symt_get_basic(btChar16, 2)->symt; /* char16_t */
cv_basic_types[T_CHAR32] = &symt_get_basic(btChar32, 4)->symt; /* char32_t */
cv_basic_types[T_CHAR8] = &symt_get_basic(btChar8, 1)->symt; /* char8_t */
cv_basic_types[T_INT2] = &symt_get_basic(btInt, 2)->symt; /* INT2 */
cv_basic_types[T_UINT2] = &symt_get_basic(btUInt, 2)->symt; /* UINT2 */
cv_basic_types[T_INT4] = &symt_get_basic(btInt, 4)->symt; /* INT4 */
cv_basic_types[T_UINT4] = &symt_get_basic(btUInt, 4)->symt; /* UINT4 */
cv_basic_types[T_INT8] = &symt_get_basic(btInt, 8)->symt; /* INT8 */
cv_basic_types[T_UINT8] = &symt_get_basic(btUInt, 8)->symt; /* UINT8 */
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_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
{
switch (basic)
{
case 1: stabs_basic[basic] = symt_new_basic(ptd->module, btInt, "int", 4); break;
case 2: stabs_basic[basic] = symt_new_basic(ptd->module, btChar, "char", 1); break;
case 3: stabs_basic[basic] = symt_new_basic(ptd->module, btInt, "short int", 2); break;
case 4: stabs_basic[basic] = symt_new_basic(ptd->module, btInt, "long int", 4); break;
case 5: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt, "unsigned char", 1); break;
case 6: stabs_basic[basic] = symt_new_basic(ptd->module, btInt, "signed char", 1); break;
case 7: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt, "unsigned short int", 2); break;
case 8: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt, "unsigned int", 4); break;
case 9: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt, "unsigned", 2); break;
case 10: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt, "unsigned long int", 2); break;
case 11: stabs_basic[basic] = symt_new_basic(ptd->module, btVoid, "void", 0); break;
case 12: stabs_basic[basic] = symt_new_basic(ptd->module, btFloat, "float", 4); break;
case 13: stabs_basic[basic] = symt_new_basic(ptd->module, btFloat, "double", 8); break;
case 14: stabs_basic[basic] = symt_new_basic(ptd->module, btFloat, "long double", 12); break;
case 15: stabs_basic[basic] = symt_new_basic(ptd->module, btInt, "integer", 4); break;
case 16: stabs_basic[basic] = symt_new_basic(ptd->module, btBool, "bool", 1); break;
case 1: stabs_basic[basic] = symt_get_basic(btInt, 4); break; /* int */
case 2: stabs_basic[basic] = symt_get_basic(btChar, 1); break; /* char */
case 3: stabs_basic[basic] = symt_get_basic(btInt, 2); break; /* short int */
case 4: stabs_basic[basic] = symt_get_basic(btInt, 4); break; /* long int */
case 5: stabs_basic[basic] = symt_get_basic(btUInt, 1); break; /* unsigned char */
case 6: stabs_basic[basic] = symt_get_basic(btInt, 1); break; /* signed char */
case 7: stabs_basic[basic] = symt_get_basic(btUInt, 2); break; /* unsigned short int */
case 8: stabs_basic[basic] = symt_get_basic(btUInt, 4); break; /* unsigned int */
case 9: stabs_basic[basic] = symt_get_basic(btUInt, 2); break; /* unsigned */
case 10: stabs_basic[basic] = symt_get_basic(btUInt, 2); break; /* unsigned long int */
case 11: stabs_basic[basic] = symt_get_basic(btVoid, 0); break; /* void */
case 12: stabs_basic[basic] = symt_get_basic(btFloat, 4); break; /* float */
case 13: stabs_basic[basic] = symt_get_basic(btFloat, 8); break; /* double */
case 14: stabs_basic[basic] = symt_get_basic(btFloat, 2); break; /* long double", */
case 15: stabs_basic[basic] = symt_get_basic(btInt, 4); break; /* integer */
case 16: stabs_basic[basic] = symt_get_basic(btBool, 1); break; /* bool */
/* case 17: short real */
/* case 18: real */
case 25: stabs_basic[basic] = symt_new_basic(ptd->module, btComplex, "float complex", 8); break;
case 26: stabs_basic[basic] = symt_new_basic(ptd->module, btComplex, "double complex", 16); break;
case 30: stabs_basic[basic] = symt_new_basic(ptd->module, btWChar, "wchar_t", 2); break;
case 31: stabs_basic[basic] = symt_new_basic(ptd->module, btInt, "long long int", 8); break;
case 32: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt, "long long unsigned", 8); break;
case 25: stabs_basic[basic] = symt_get_basic(btComplex, 8); break; /* float complex */
case 26: stabs_basic[basic] = symt_get_basic(btComplex, 6); break; /* double complex", */
case 30: stabs_basic[basic] = symt_get_basic(btWChar, 2); break; /* wchar_t */
case 31: stabs_basic[basic] = symt_get_basic(btInt, 8); break; /* long long int */
case 32: stabs_basic[basic] = symt_get_basic(btUInt, 8); break; /* long long unsigned */
/* 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);
}
}
......@@ -541,7 +541,7 @@ static int stabs_pts_read_range(struct ParseTypedefData* ptd, const char* typena
}
else PTS_ABORTIF(ptd, 1);
*dt = &symt_new_basic(ptd->module, bt, typename, size)->symt;
*dt = &symt_get_basic(bt, size)->symt;
return 0;
}
......@@ -967,7 +967,7 @@ static int stabs_pts_read_type_def(struct ParseTypedefData* ptd, const char* typ
*/
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"));
}
}
......
dlls/dbghelp/type.c
View file @ 14462bbe
......@@ -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 SymTagInlineSite: return ((const struct symt_inlinesite*)sym)->func.hash_elt.name;
case SymTagPublicSymbol: return ((const struct symt_public*)sym)->hash_elt.name;
case SymTagBaseType: return ((const struct symt_basic*)sym)->hash_elt.name;
case SymTagLabel: return ((const struct symt_hierarchy_point*)sym)->hash_elt.name;
case SymTagThunk: return ((const struct symt_thunk*)sym)->hash_elt.name;
case SymTagCustom: return ((const struct symt_custom*)sym)->hash_elt.name;
......@@ -110,6 +109,7 @@ const char* symt_get_name(const struct symt* sym)
default:
FIXME("Unsupported sym-tag %s\n", symt_get_tag_str(sym->tag));
/* fall through */
case SymTagBaseType:
case SymTagArrayType:
case SymTagPointerType:
case SymTagFunctionType:
......@@ -224,31 +224,26 @@ static void symt_add_type(struct module* module, struct symt* symt)
*p = symt;
}
struct symt_basic* symt_new_basic(struct module* module, enum BasicType bt,
const char* typename, unsigned size)
struct symt_basic* symt_get_basic(enum BasicType bt, unsigned size)
{
struct symt_basic* sym;
static struct symt_basic cache[32] = { { {SymTagBaseType}, btNoType, 0 } };
int i;
if (typename)
{
sym = (struct symt_basic*)symt_find_type_by_name(module, SymTagBaseType,
typename);
if (sym && sym->bt == bt && sym->size == size)
return sym;
}
if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
if (bt == btNoType) return &cache[0];
for (i = 1; i < ARRAY_SIZE(cache); i++)
{
sym->symt.tag = SymTagBaseType;
if (typename)
if (cache[i].bt == btNoType) /* empty slot, create new entry */
{
sym->hash_elt.name = pool_strdup(&module->pool, typename);
hash_table_add(&module->ht_types, &sym->hash_elt);
} else sym->hash_elt.name = NULL;
sym->bt = bt;
sym->size = size;
symt_add_type(module, &sym->symt);
cache[i].symt.tag = SymTagBaseType;
cache[i].bt = bt;
cache[i].size = size;
return &cache[i];
}
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,
......
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