wine-commits June 2006

wine-commits@winehq.org

3 participants
854 discussions

Eric Pouech : dbghelp: dwarf: Properly handle function formal parameters.
by Alexandre Julliard 20 Jun '06

20 Jun '06

Module: wine Branch: refs/heads/master Commit: 7476f8c84035fcc186cb5f09b8c2bd2e9b849cbd URL: http://source.winehq.org/git/?p=wine.git;a=commit;h=7476f8c84035fcc186cb5f0… Author: Eric Pouech <eric.pouech(a)wanadoo.fr> Date: Sun Jun 18 21:32:00 2006 +0200 dbghelp: dwarf: Properly handle function formal parameters. --- dlls/dbghelp/dwarf.c | 82 +++++++++++++++++++++++++++++++++++++++++++++----- 1 files changed, 74 insertions(+), 8 deletions(-) diff --git a/dlls/dbghelp/dwarf.c b/dlls/dbghelp/dwarf.c index adde41d..33338c1 100644 --- a/dlls/dbghelp/dwarf.c +++ b/dlls/dbghelp/dwarf.c @@ -59,6 +59,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_dwarf * o unspecified parameters * o inlined functions * o line numbers + * o Debug{Start|End}Point * - Udt * o proper types loading (addresses, bitfield, nesting) */ @@ -955,20 +956,85 @@ static void dwarf2_parse_variable(dwarf2 if (di->abbrev->have_child) FIXME("Unsupported children\n"); } +static unsigned dwarf2_map_register(int regno) +{ + unsigned reg; + + switch (regno) + { + case -1: + /* FIXME: this is a dirty hack */ + case -2: reg = 0; break; + case 0: reg = CV_REG_EAX; break; + case 1: reg = CV_REG_ECX; break; + case 2: reg = CV_REG_EDX; break; + case 3: reg = CV_REG_EBX; break; + case 4: reg = CV_REG_ESP; break; + case 5: reg = CV_REG_EBP; break; + case 6: reg = CV_REG_ESI; break; + case 7: reg = CV_REG_EDI; break; + case 8: reg = CV_REG_EIP; break; + case 9: reg = CV_REG_EFLAGS; break; + case 10: reg = CV_REG_CS; break; + case 11: reg = CV_REG_SS; break; + case 12: reg = CV_REG_DS; break; + case 13: reg = CV_REG_ES; break; + case 14: reg = CV_REG_FS; break; + case 15: reg = CV_REG_GS; break; + case 16: case 17: case 18: case 19: + case 20: case 21: case 22: case 23: + reg = CV_REG_ST0 + regno - 16; break; + case 24: reg = CV_REG_CTRL; break; + case 25: reg = CV_REG_STAT; break; + case 26: reg = CV_REG_TAG; break; +/* +reg: fiseg 27 +reg: fioff 28 +reg: foseg 29 +reg: fooff 30 +reg: fop 31 +*/ + case 32: case 33: case 34: case 35: + case 36: case 37: case 38: case 39: + reg = CV_REG_XMM0 + regno - 32; break; + case 40: reg = CV_REG_MXCSR; break; + default: + FIXME("Don't know how to map register %d\n", regno); + return 0; + } + return reg; +} + static void dwarf2_parse_subprogram_parameter(dwarf2_parse_context_t* ctx, - dwarf2_debug_info_t* di, - struct symt_function_signature* sig_type) + struct symt_function* func, + struct symt_block* block, + dwarf2_debug_info_t* di) { struct symt* param_type; - union attribute name; + union attribute loc; TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); param_type = dwarf2_lookup_type(ctx, di); - dwarf2_find_name(ctx, di, &name, "parameter"); - /* DW_AT_location */ - if (sig_type) symt_add_function_signature_parameter(ctx->module, sig_type, param_type); - /* FIXME: add variable to func_type */ + if (dwarf2_find_attribute(di, DW_AT_location, &loc)) + { + union attribute name; + unsigned long offset; + int in_reg; + + dwarf2_find_name(ctx, di, &name, "parameter"); + offset = dwarf2_compute_location(ctx, loc.block, &in_reg); + TRACE("found parameter %s/%ld (reg=%d) at %s\n", + name.string, offset, in_reg, dwarf2_debug_ctx(ctx)); + symt_add_func_local(ctx->module, func, + DataIsParam, dwarf2_map_register(in_reg), offset, + block, param_type, name.string); + } + if (func && func->type) + symt_add_function_signature_parameter(ctx->module, + (struct symt_function_signature*)func->type, + param_type); + if (di->abbrev->have_child) FIXME("Unsupported children\n"); } @@ -1137,7 +1203,7 @@ static struct symt* dwarf2_parse_subprog switch (child->abbrev->tag) { case DW_TAG_formal_parameter: - dwarf2_parse_subprogram_parameter(ctx, child, sig_type); + dwarf2_parse_subprogram_parameter(ctx, func, NULL, child); break; case DW_TAG_lexical_block: dwarf2_parse_subprogram_block(ctx, child, func);

1 0

Eric Pouech : dbghelp: Storage of func locals & parameters.
by Alexandre Julliard 20 Jun '06

20 Jun '06

Module: wine Branch: refs/heads/master Commit: cff41cf9f203629aa5efd3dafe23c06b1a9d7b8e URL: http://source.winehq.org/git/?p=wine.git;a=commit;h=cff41cf9f203629aa5efd3d… Author: Eric Pouech <eric.pouech(a)wanadoo.fr> Date: Sun Jun 18 21:31:55 2006 +0200 dbghelp: Storage of func locals & parameters. - added the ability to tell to add_func_local whether we're adding a local variable or a parameter (and removed the black magic we were using) - we can now address variables defined as an offset to a register --- dlls/dbghelp/dbghelp_private.h | 2 +- dlls/dbghelp/msc.c | 26 +++++++++++++++++--------- dlls/dbghelp/stabs.c | 18 +++++++++++------- dlls/dbghelp/symbol.c | 39 ++++++++++++++++----------------------- 4 files changed, 45 insertions(+), 40 deletions(-) Diff: http://source.winehq.org/git/?p=wine.git;a=commitdiff;h=cff41cf9f203629aa5e…

1 0

Eric Pouech : dbghelp: Dwarf & global symbols.
by Alexandre Julliard 20 Jun '06

20 Jun '06

Module: wine Branch: refs/heads/master Commit: df179e9bf189fbc33e42c7ac3bc55e346b3b7db9 URL: http://source.winehq.org/git/?p=wine.git;a=commit;h=df179e9bf189fbc33e42c7a… Author: Eric Pouech <eric.pouech(a)wanadoo.fr> Date: Sun Jun 18 21:31:52 2006 +0200 dbghelp: Dwarf & global symbols. Offset the addresses for global symbols (func & variables) by the base image of the corresponding module. --- dlls/dbghelp/dwarf.c | 3 ++- 1 files changed, 2 insertions(+), 1 deletions(-) diff --git a/dlls/dbghelp/dwarf.c b/dlls/dbghelp/dwarf.c index 4cffd0a..adde41d 100644 --- a/dlls/dbghelp/dwarf.c +++ b/dlls/dbghelp/dwarf.c @@ -1120,7 +1120,8 @@ static struct symt* dwarf2_parse_subprog if (!is_decl.uvalue) { func = symt_new_function(ctx->module, compiland, name.string, - low_pc.uvalue, high_pc.uvalue - low_pc.uvalue, + ctx->module->module.BaseOfImage + low_pc.uvalue, + high_pc.uvalue - low_pc.uvalue, &sig_type->symt); di->symt = &func->symt; }

1 0

Eric Pouech : dbghelp: dwarf: Added support for function labels.
by Alexandre Julliard 20 Jun '06

20 Jun '06

Module: wine Branch: refs/heads/master Commit: 686237e043236f97759b26be1516c6f082761840 URL: http://source.winehq.org/git/?p=wine.git;a=commit;h=686237e043236f97759b26b… Author: Eric Pouech <eric.pouech(a)wanadoo.fr> Date: Sun Jun 18 21:31:49 2006 +0200 dbghelp: dwarf: Added support for function labels. --- dlls/dbghelp/dwarf.c | 24 ++++++++++++++++++++++++ 1 files changed, 24 insertions(+), 0 deletions(-) diff --git a/dlls/dbghelp/dwarf.c b/dlls/dbghelp/dwarf.c index f0d4ea0..4cffd0a 100644 --- a/dlls/dbghelp/dwarf.c +++ b/dlls/dbghelp/dwarf.c @@ -972,6 +972,22 @@ static void dwarf2_parse_subprogram_para if (di->abbrev->have_child) FIXME("Unsupported children\n"); } +static void dwarf2_parse_subprogram_label(dwarf2_parse_context_t* ctx, + struct symt_function* func, + dwarf2_debug_info_t* di) +{ + union attribute name; + union attribute low_pc; + + TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); + + if (!dwarf2_find_attribute(di, DW_AT_low_pc, &low_pc)) low_pc.uvalue = 0; + dwarf2_find_name(ctx, di, &name, "label"); + + symt_add_function_point(ctx->module, func, SymTagLabel, + ctx->module->module.BaseOfImage + low_pc.uvalue, name.string); +} + static void dwarf2_parse_subprogram_block(dwarf2_parse_context_t* ctx, dwarf2_debug_info_t* di, struct symt_function* func); @@ -1015,6 +1031,11 @@ static void dwarf2_parse_inlined_subrout /* FIXME */ dwarf2_parse_inlined_subroutine(ctx, child); break; + case DW_TAG_label: + /* FIXME + * dwarf2_parse_subprogram_label(ctx, func, child); + */ + break; default: FIXME("Unhandled Tag type 0x%lx at %s, for %s\n", child->abbrev->tag, dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); @@ -1131,6 +1152,9 @@ static struct symt* dwarf2_parse_subprog * skip it for now */ break; + case DW_TAG_label: + dwarf2_parse_subprogram_label(ctx, func, child); + break; case DW_TAG_class_type: case DW_TAG_structure_type: case DW_TAG_union_type:

1 0

Eric Pouech : dbghelp: Proper support for nested types definitions ( even in C).
by Alexandre Julliard 20 Jun '06

20 Jun '06

Module: wine Branch: refs/heads/master Commit: 6cee154b23361112dc162624e75b6d669f0a05d6 URL: http://source.winehq.org/git/?p=wine.git;a=commit;h=6cee154b23361112dc16262… Author: Eric Pouech <eric.pouech(a)wanadoo.fr> Date: Sun Jun 18 21:31:46 2006 +0200 dbghelp: Proper support for nested types definitions (even in C). --- dlls/dbghelp/dwarf.c | 9 +++++++++ 1 files changed, 9 insertions(+), 0 deletions(-) diff --git a/dlls/dbghelp/dwarf.c b/dlls/dbghelp/dwarf.c index 19dc812..f0d4ea0 100644 --- a/dlls/dbghelp/dwarf.c +++ b/dlls/dbghelp/dwarf.c @@ -58,7 +58,11 @@ WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_dwarf * o local variables * o unspecified parameters * o inlined functions + * o line numbers + * - Udt + * o proper types loading (addresses, bitfield, nesting) */ + #if 0 static void dump(const void* ptr, unsigned len) { @@ -865,6 +869,11 @@ static struct symt* dwarf2_parse_udt_typ case DW_TAG_enumeration_type: dwarf2_parse_enumeration_type(ctx, child); break; + case DW_TAG_structure_type: + case DW_TAG_class_type: + case DW_TAG_union_type: + /* FIXME: we need to handle nested udt definitions */ + break; default: FIXME("Unhandled Tag type 0x%lx at %s, for %s\n", child->abbrev->tag, dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));

1 0

Eric Pouech : dbghelp: Dwarf - function scheme.
by Alexandre Julliard 20 Jun '06

20 Jun '06

Module: wine Branch: refs/heads/master Commit: 468956f4cd739680ed64a84bb5e70b083199d99f URL: http://source.winehq.org/git/?p=wine.git;a=commit;h=468956f4cd739680ed64a84… Author: Eric Pouech <eric.pouech(a)wanadoo.fr> Date: Sun Jun 18 21:31:43 2006 +0200 dbghelp: Dwarf - function scheme. - various fixes to follow better the functions definition (nesting, subroutines...) - don't directly parse types referenced by a subprogram, they'll be loaded anyway when needed --- dlls/dbghelp/dwarf.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++++-- 1 files changed, 52 insertions(+), 2 deletions(-) diff --git a/dlls/dbghelp/dwarf.c b/dlls/dbghelp/dwarf.c index 60c86f2..19dc812 100644 --- a/dlls/dbghelp/dwarf.c +++ b/dlls/dbghelp/dwarf.c @@ -53,6 +53,12 @@ #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_dwarf); +/* FIXME: + * - Functions: + * o local variables + * o unspecified parameters + * o inlined functions + */ #if 0 static void dump(const void* ptr, unsigned len) { @@ -957,6 +963,10 @@ static void dwarf2_parse_subprogram_para if (di->abbrev->have_child) FIXME("Unsupported children\n"); } +static void dwarf2_parse_subprogram_block(dwarf2_parse_context_t* ctx, + dwarf2_debug_info_t* di, + struct symt_function* func); + static void dwarf2_parse_inlined_subroutine(dwarf2_parse_context_t* ctx, dwarf2_debug_info_t* di) { @@ -987,6 +997,15 @@ static void dwarf2_parse_inlined_subrout case DW_TAG_variable: dwarf2_parse_variable(ctx, child); break; + case DW_TAG_lexical_block: + /* FIXME: + dwarf2_parse_subprogram_block(ctx, child, func); + */ + break; + case DW_TAG_inlined_subroutine: + /* FIXME */ + dwarf2_parse_inlined_subroutine(ctx, child); + break; default: FIXME("Unhandled Tag type 0x%lx at %s, for %s\n", child->abbrev->tag, dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); @@ -997,7 +1016,6 @@ static void dwarf2_parse_inlined_subrout static void dwarf2_parse_subprogram_block(dwarf2_parse_context_t* ctx, dwarf2_debug_info_t* di, - struct symt_function_signature* sig_type, struct symt_function* func) { TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); @@ -1021,6 +1039,20 @@ static void dwarf2_parse_subprogram_bloc case DW_TAG_variable: dwarf2_parse_variable(ctx, child); break; + case DW_TAG_lexical_block: + dwarf2_parse_subprogram_block(ctx, child, func); + break; + case DW_TAG_subprogram: + /* FIXME: likely a declaration (to be checked) + * skip it for now + */ + break; + case DW_TAG_class_type: + case DW_TAG_structure_type: + case DW_TAG_union_type: + case DW_TAG_enumeration_type: + /* the type referred to will be loaded when we need it, so skip it */ + break; default: FIXME("Unhandled Tag type 0x%lx at %s, for %s\n", child->abbrev->tag, dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); @@ -1077,11 +1109,29 @@ static struct symt* dwarf2_parse_subprog dwarf2_parse_subprogram_parameter(ctx, child, sig_type); break; case DW_TAG_lexical_block: - dwarf2_parse_subprogram_block(ctx, child, sig_type, func); + dwarf2_parse_subprogram_block(ctx, child, func); break; case DW_TAG_variable: dwarf2_parse_variable(ctx, child); break; + case DW_TAG_inlined_subroutine: + dwarf2_parse_inlined_subroutine(ctx, child); + break; + case DW_TAG_subprogram: + /* FIXME: likely a declaration (to be checked) + * skip it for now + */ + break; + case DW_TAG_class_type: + case DW_TAG_structure_type: + case DW_TAG_union_type: + case DW_TAG_enumeration_type: + case DW_TAG_typedef: + /* the type referred to will be loaded when we need it, so skip it */ + break; + case DW_TAG_unspecified_parameters: + /* FIXME: no support in dbghelp's internals so far */ + break; default: FIXME("Unhandled Tag type 0x%lx at %s, for %s\n", child->abbrev->tag, dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));

1 0

Eric Pouech : dbghelp: Dwarf & locations.
by Alexandre Julliard 20 Jun '06

20 Jun '06

Module: wine Branch: refs/heads/master Commit: ae67326863246fc19e30cb3e8a3c4bd4562a9eae URL: http://source.winehq.org/git/?p=wine.git;a=commit;h=ae67326863246fc19e30cb3… Author: Eric Pouech <eric.pouech(a)wanadoo.fr> Date: Sun Jun 18 21:31:39 2006 +0200 dbghelp: Dwarf & locations. - put back the block attribute parsing - added dwarf2_compute_location to properly decode a location (at least starting it) --- dlls/dbghelp/dwarf.c | 146 ++++++++++++++++++++++++++++++++++++++++---------- 1 files changed, 118 insertions(+), 28 deletions(-) diff --git a/dlls/dbghelp/dwarf.c b/dlls/dbghelp/dwarf.c index 6c354b7..60c86f2 100644 --- a/dlls/dbghelp/dwarf.c +++ b/dlls/dbghelp/dwarf.c @@ -113,11 +113,18 @@ typedef struct dwarf2_abbrev_entry_s dwarf2_abbrev_entry_attr_t* attrs; } dwarf2_abbrev_entry_t; +struct dwarf2_block +{ + unsigned size; + const unsigned char* ptr; +}; + union attribute { unsigned long uvalue; long svalue; const char* string; + struct dwarf2_block* block; }; typedef struct dwarf2_debug_info_s @@ -391,23 +398,31 @@ static void dwarf2_parse_attr_into_di(dw TRACE("strp<%s>\n", attr->string); break; case DW_FORM_block: - attr->uvalue = dwarf2_leb128_as_unsigned(ctx); - ctx->data += attr->uvalue; + attr->block = pool_alloc(&ctx->pool, sizeof(struct dwarf2_block)); + attr->block->size = dwarf2_leb128_as_unsigned(ctx); + attr->block->ptr = ctx->data; + ctx->data += attr->block->size; break; case DW_FORM_block1: - attr->uvalue = dwarf2_parse_byte(ctx); - ctx->data += attr->uvalue; + attr->block = pool_alloc(&ctx->pool, sizeof(struct dwarf2_block)); + attr->block->size = dwarf2_parse_byte(ctx); + attr->block->ptr = ctx->data; + ctx->data += attr->block->size; break; case DW_FORM_block2: - attr->uvalue = dwarf2_parse_u2(ctx); - ctx->data += attr->uvalue; + attr->block = pool_alloc(&ctx->pool, sizeof(struct dwarf2_block)); + attr->block->size = dwarf2_parse_u2(ctx); + attr->block->ptr = ctx->data; + ctx->data += attr->block->size; break; case DW_FORM_block4: - attr->uvalue = dwarf2_parse_u4(ctx); - ctx->data += attr->uvalue; + attr->block = pool_alloc(&ctx->pool, sizeof(struct dwarf2_block)); + attr->block->size = dwarf2_parse_u4(ctx); + attr->block->ptr = ctx->data; + ctx->data += attr->block->size; break; default: @@ -450,6 +465,96 @@ static void dwarf2_find_name(dwarf2_pars static void dwarf2_load_one_entry(dwarf2_parse_context_t*, dwarf2_debug_info_t*, struct symt_compiland*); +#define Wine_DW_no_register -1 +#define Wine_DW_frame_register -2 + +static unsigned long dwarf2_compute_location(dwarf2_parse_context_t* ctx, + struct dwarf2_block* block, + int* in_register) +{ + unsigned long loc[64]; + unsigned stk; + + if (in_register) *in_register = Wine_DW_no_register; + loc[stk = 0] = 0; + + if (block->size) + { + /* FIXME: would require better definition of contexts */ + dwarf2_parse_context_t lctx; + unsigned char op; + BOOL piece_found = FALSE; + + lctx.data = block->ptr; + lctx.end_data = block->ptr + block->size; + lctx.word_size = ctx->word_size; + + while (lctx.data < lctx.end_data) + { + op = dwarf2_parse_byte(&lctx); + switch (op) + { + case DW_OP_addr: loc[++stk] = dwarf2_parse_addr(&lctx); break; + case DW_OP_const1u: loc[++stk] = dwarf2_parse_byte(&lctx); break; + case DW_OP_const1s: loc[++stk] = (long)(char)dwarf2_parse_byte(&lctx); break; + case DW_OP_const2u: loc[++stk] = dwarf2_parse_u2(&lctx); break; + case DW_OP_const2s: loc[++stk] = (long)(short)dwarf2_parse_u2(&lctx); break; + case DW_OP_const4u: loc[++stk] = dwarf2_parse_u4(&lctx); break; + case DW_OP_const4s: loc[++stk] = dwarf2_parse_u4(&lctx); break; + case DW_OP_constu: loc[++stk] = dwarf2_leb128_as_unsigned(&lctx); break; + case DW_OP_consts: loc[++stk] = dwarf2_leb128_as_signed(&lctx); break; + case DW_OP_plus_uconst: + loc[stk] += dwarf2_leb128_as_unsigned(&lctx); break; + case DW_OP_reg0: case DW_OP_reg1: case DW_OP_reg2: case DW_OP_reg3: + case DW_OP_reg4: case DW_OP_reg5: case DW_OP_reg6: case DW_OP_reg7: + case DW_OP_reg8: case DW_OP_reg9: case DW_OP_reg10: case DW_OP_reg11: + case DW_OP_reg12: case DW_OP_reg13: case DW_OP_reg14: case DW_OP_reg15: + case DW_OP_reg16: case DW_OP_reg17: case DW_OP_reg18: case DW_OP_reg19: + case DW_OP_reg20: case DW_OP_reg21: case DW_OP_reg22: case DW_OP_reg23: + case DW_OP_reg24: case DW_OP_reg25: case DW_OP_reg26: case DW_OP_reg27: + case DW_OP_reg28: case DW_OP_reg29: case DW_OP_reg30: case DW_OP_reg31: + if (in_register) + { + /* dbghelp APIs don't know how to cope with this anyway + * (for example 'long long' stored in two registers) + * FIXME: We should tell winedbg how to deal with it (sigh) + */ + if (!piece_found || (op - DW_OP_reg0 != *in_register + 1)) + { + if (*in_register != Wine_DW_no_register) + FIXME("Only supporting one reg (%d -> %d)\n", + *in_register, op - DW_OP_reg0); + *in_register = op - DW_OP_reg0; + } + } + else FIXME("Found register, while not expecting it\n"); + break; + case DW_OP_fbreg: + if (in_register) + { + if (*in_register != Wine_DW_no_register) + FIXME("Only supporting one reg (%d -> -2)\n", *in_register); + *in_register = Wine_DW_frame_register; + } + else FIXME("Found register, while not expecting it\n"); + loc[++stk] = dwarf2_leb128_as_signed(&lctx); + break; + case DW_OP_piece: + { + unsigned sz = dwarf2_leb128_as_unsigned(&lctx); + WARN("Not handling OP_piece directly (size=%d)\n", sz); + piece_found = TRUE; + } + break; + default: + FIXME("Unhandled attr op: %x\n", op); + return loc[stk]; + } + } + } + return loc[stk]; +} + static struct symt* dwarf2_lookup_type(dwarf2_parse_context_t* ctx, const dwarf2_debug_info_t* di) { @@ -699,8 +804,8 @@ static void dwarf2_parse_udt_member(dwar { struct symt* elt_type; union attribute name; -/* union attribute loc; */ - unsigned long offset; + union attribute loc; + unsigned long offset = 0; assert(parent); @@ -708,27 +813,12 @@ static void dwarf2_parse_udt_member(dwar dwarf2_find_name(ctx, di, &name, "udt_member"); elt_type = dwarf2_lookup_type(ctx, di); -#if 0 if (dwarf2_find_attribute(di, DW_AT_data_member_location, &loc)) { - TRACE("found member_location at %s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_attr(attr)); - if (loc.uvalue) { - unsigned char op = dwarf2_parse_byte(ctx); - --uvalue; - switch (op) { - case DW_OP_plus_uconst: - offset = dwarf2_leb128_as_unsigned(ctx); - break; - default: - WARN("Unhandled attr op at %s, for %s, op:%u\n", dwarf2_debug_ctx(ctx), dwarf2_debug_attr(attr), op); - ctx->data += uvalue; - } - TRACE("found offset:%lu\n", offset); - } + TRACE("found member_location at %s\n", dwarf2_debug_ctx(ctx)); + offset = dwarf2_compute_location(ctx, loc.block, NULL); + TRACE("found offset:%lu\n", offset); } -#endif - FIXME("still to be implemented proper member location\n"); - offset = 0; symt_add_udt_element(ctx->module, parent, name.string, elt_type, offset, 0);

1 0

Eric Pouech : dbghelp: Dwarf compiland.
by Alexandre Julliard 20 Jun '06

20 Jun '06

Module: wine Branch: refs/heads/master Commit: 6d61cc0c7b13ef0c0fb310abac7469c7696d8141 URL: http://source.winehq.org/git/?p=wine.git;a=commit;h=6d61cc0c7b13ef0c0fb310a… Author: Eric Pouech <eric.pouech(a)wanadoo.fr> Date: Sun Jun 18 21:31:32 2006 +0200 dbghelp: Dwarf compiland. - rewrote all entities loading to make use of new dwarf2_debug_info_t scheme - commented out the location parsing which is an ugly hack --- dlls/dbghelp/dwarf.c | 1670 ++++++++++++++------------------------------------ 1 files changed, 455 insertions(+), 1215 deletions(-) Diff: http://source.winehq.org/git/?p=wine.git;a=commitdiff;h=6d61cc0c7b13ef0c0fb…

1 0

Eric Pouech : dbghelp: Dwarf & new scheme.
by Alexandre Julliard 20 Jun '06

20 Jun '06

Module: wine Branch: refs/heads/master Commit: ec8328d1b14c75e7464b9566d74eef0b4caeb44e URL: http://source.winehq.org/git/?p=wine.git;a=commit;h=ec8328d1b14c75e7464b956… Author: Eric Pouech <eric.pouech(a)wanadoo.fr> Date: Sun Jun 18 21:31:27 2006 +0200 dbghelp: Dwarf & new scheme. - add some helpers for the rewrite - module is now part of the dwarf2_parse_context --- dlls/dbghelp/dwarf.c | 192 +++++++++++++++++++++++++++++--------------------- 1 files changed, 111 insertions(+), 81 deletions(-) Diff: http://source.winehq.org/git/?p=wine.git;a=commitdiff;h=ec8328d1b14c75e7464…

1 0

Eric Pouech : dbghelp: Dwarf & type references.
by Alexandre Julliard 20 Jun '06

20 Jun '06

Module: wine Branch: refs/heads/master Commit: 2301d1a3d09c25fe578ab3d73a50149e3e4d1bc8 URL: http://source.winehq.org/git/?p=wine.git;a=commit;h=2301d1a3d09c25fe578ab3d… Author: Eric Pouech <eric.pouech(a)wanadoo.fr> Date: Sun Jun 18 21:31:24 2006 +0200 dbghelp: Dwarf & type references. Removed unused type references scheme that we'll implement using a different scheme in next patches. --- dlls/dbghelp/dwarf.c | 72 +++++++++----------------------------------------- 1 files changed, 13 insertions(+), 59 deletions(-) diff --git a/dlls/dbghelp/dwarf.c b/dlls/dbghelp/dwarf.c index 9dc0b7e..34d5aac 100644 --- a/dlls/dbghelp/dwarf.c +++ b/dlls/dbghelp/dwarf.c @@ -620,12 +620,6 @@ static struct symt* dwarf2_find_symt_by_ return NULL; } -static struct symt* dwarf2_add_symt_ref(struct module* module, unsigned long ref, struct symt* symt) -{ - if (NULL != symt) return NULL; - return NULL; -} - /****************************************************************** * dwarf2_read_one_debug_info * @@ -1108,10 +1102,7 @@ static void dwarf2_parse_udt_members(str dwarf2_parse_udt_member(module, entry, ctx, symt); break; case DW_TAG_enumeration_type: - { - struct symt_enum* symt = dwarf2_parse_enumeration_type(module, entry, ctx); - dwarf2_add_symt_ref(module, entry_ref, &symt->symt); - } + dwarf2_parse_enumeration_type(module, entry, ctx); break; default: { @@ -1695,70 +1686,37 @@ static void dwarf2_parse_compiland_conte switch (entry->tag) { case DW_TAG_typedef: - { - struct symt_typedef* symt = dwarf2_parse_typedef(module, entry, ctx); - dwarf2_add_symt_ref(module, entry_ref, &symt->symt); - } + dwarf2_parse_typedef(module, entry, ctx); break; case DW_TAG_base_type: - { - struct symt_basic* symt = dwarf2_parse_base_type(module, entry, ctx); - dwarf2_add_symt_ref(module, entry_ref, &symt->symt); - } + dwarf2_parse_base_type(module, entry, ctx); break; case DW_TAG_pointer_type: - { - struct symt_pointer* symt = dwarf2_parse_pointer_type(module, entry, ctx); - dwarf2_add_symt_ref(module, entry_ref, &symt->symt); - } + dwarf2_parse_pointer_type(module, entry, ctx); break; case DW_TAG_class_type: - { - struct symt_udt* symt = dwarf2_parse_udt_type(module, entry, ctx, UdtClass); - if (NULL != symt) dwarf2_add_symt_ref(module, entry_ref, &symt->symt); - } + dwarf2_parse_udt_type(module, entry, ctx, UdtClass); break; case DW_TAG_structure_type: - { - struct symt_udt* symt = dwarf2_parse_udt_type(module, entry, ctx, UdtStruct); - if (NULL != symt) dwarf2_add_symt_ref(module, entry_ref, &symt->symt); - } + dwarf2_parse_udt_type(module, entry, ctx, UdtStruct); break; case DW_TAG_union_type: - { - struct symt_udt* symt = dwarf2_parse_udt_type(module, entry, ctx, UdtUnion); - if (NULL != symt) dwarf2_add_symt_ref(module, entry_ref, &symt->symt); - } + dwarf2_parse_udt_type(module, entry, ctx, UdtUnion); break; case DW_TAG_array_type: - { - struct symt_array* symt = dwarf2_parse_array_type(module, entry, ctx); - dwarf2_add_symt_ref(module, entry_ref, &symt->symt); - } + dwarf2_parse_array_type(module, entry, ctx); break; case DW_TAG_const_type: - { - struct symt* symt = dwarf2_parse_const_type(module, entry, ctx); - dwarf2_add_symt_ref(module, entry_ref, symt); - } + dwarf2_parse_const_type(module, entry, ctx); break; case DW_TAG_reference_type: - { - struct symt* symt = dwarf2_parse_reference_type(module, entry, ctx); - dwarf2_add_symt_ref(module, entry_ref, symt); - } + dwarf2_parse_reference_type(module, entry, ctx); break; case DW_TAG_enumeration_type: - { - struct symt_enum* symt = dwarf2_parse_enumeration_type(module, entry, ctx); - dwarf2_add_symt_ref(module, entry_ref, &symt->symt); - } + dwarf2_parse_enumeration_type(module, entry, ctx); break; case DW_TAG_subprogram: - { - struct symt_function* symt = dwarf2_parse_subprogram(module, entry, ctx, compiland); - if (NULL != symt) dwarf2_add_symt_ref(module, entry_ref, &symt->symt); - } + dwarf2_parse_subprogram(module, entry, ctx, compiland); break; default: @@ -1882,11 +1840,7 @@ BOOL dwarf2_parse(struct module* module, switch (entry->tag) { case DW_TAG_compile_unit: - { - struct symt_compiland* symt = dwarf2_parse_compiland(module, entry, &ctx); - dwarf2_add_symt_ref(module, entry_ref, &symt->symt); - compiland = symt; - } + compiland = dwarf2_parse_compiland(module, entry, &ctx); break; default: {

1 0

← Newer
1
...
25
26
27
28
29
30
31
...
86
Older →

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-commits June 2006