This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [PATCH] DWARF: add abstract origin links on lexical blocks DIEs


On Tue, Jan 12, 2016 at 6:05 PM, Pierre-Marie de Rodat
<derodat@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
>


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]