On Tue, Jan 12, 2016 at 6:05 PM, Pierre-Marie de Rodat
<dero...@adacore.com> wrote:
> Hello,
>
> Although the following patch does not fix a regression, I believe it fixes a
> bug visible from a debugger, so I think it’s a valid candidate at this
> stage.
>
> This change tracks from which abstract lexical block concrete ones come from
> in DWARF so that debuggers can inherit the former from the latter. This
> enables debuggers to properly handle the following case:
>
> * function Child2 is nested in a lexical block, itself nested in
> function Child1;
> * function Child1 is inlined into some call site;
> * function Child2 is never inlined.
>
> Here, Child2 is described in DWARF only in the abstract instance of Child1.
> So when debuggers decode Child1's concrete instances, they need to fetch the
> definition for Child2 in the corresponding abstract instance: the
> DW_AT_abstract_origin link on the lexical block that embeds Child1 enables
> them to do that.
>
> Bootstrapped and regtested on x86_64-linux.
> Ok to commit? Thank you in advance!
I wonder if you can construct a guality testcase that passes with and
fails without
the patch?
Anyway, the patch looks ok to me but please give others a chance to chime in.
Thanks,
Richard.
> gcc/ChangeLog:
>
> * dwarf2out.c (add_abstract_origin_attribute): Adjust
> documentation comment. For BLOCK nodes, add a
> DW_AT_abstract_origin attribute that points to the DIE generated
> for the origin BLOCK.
> (gen_lexical_block_die): Call add_abstract_origin_attribute for
> blocks from inlined functions.
> ---
> gcc/dwarf2out.c | 13 ++++++++++---
> 1 file changed, 10 insertions(+), 3 deletions(-)
>
> diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
> index da5524e..a889dbb 100644
> --- a/gcc/dwarf2out.c
> +++ b/gcc/dwarf2out.c
> @@ -18463,15 +18463,16 @@ add_prototyped_attribute (dw_die_ref die, tree
> func_type)
> }
> /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
> - by looking in either the type declaration or object declaration
> - equate table. */
> + by looking in the type declaration, the object declaration equate table
> or
> + the block mapping. */
> static inline dw_die_ref
> add_abstract_origin_attribute (dw_die_ref die, tree origin)
> {
> dw_die_ref origin_die = NULL;
> - if (TREE_CODE (origin) != FUNCTION_DECL)
> + if (TREE_CODE (origin) != FUNCTION_DECL
> + && TREE_CODE (origin) != BLOCK)
> {
> /* We may have gotten separated from the block for the inlined
> function, if we're in an exception handler or some such; make
> @@ -18493,6 +18494,8 @@ add_abstract_origin_attribute (dw_die_ref die, tree
> origin)
> origin_die = lookup_decl_die (origin);
> else if (TYPE_P (origin))
> origin_die = lookup_type_die (origin);
> + else if (TREE_CODE (origin) == BLOCK)
> + origin_die = BLOCK_DIE (origin);
> /* XXX: Functions that are never lowered don't always have correct block
> trees (in the case of java, they simply have no block tree, in some
> other
> @@ -21294,6 +21297,10 @@ gen_lexical_block_die (tree stmt, dw_die_ref
> context_die)
> BLOCK_DIE (stmt) = stmt_die;
> old_die = NULL;
> }
> +
> + tree origin = block_ultimate_origin (stmt);
> + if (origin != NULL_TREE && origin != stmt)
> + add_abstract_origin_attribute (stmt_die, origin);
> }
> if (old_die)
> --
> 2.3.3.199.g52cae64
>
