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

[Pierre-Marie de Rodat <derodat at adacore dot com>]

On 01/13/2016 01:17 PM, Richard Biener wrote:
> I wonder if you can construct a guality testcase that passes with and
> fails without
> the patch?

Iâve tried to first look at how guality testcases are written (thanks 
for your answers on IRC, by the way :-)) and then how I could write a 
testcase for my fix. It seems there are two ways: match patterns in the 
assembly file or evaluate an expression in GDB.

I already have the testcase I used during development: itâs written in 
Ada, to build with -O2. The way it checks the fix is to see if GDB 
manages to put a breakpoint on the Child2 symbol before executing the 
program (it cannot before my fix and it can afterwards). Oh, and it 
requires a fairly recent GDB version (7.10 looks good).

I managed to get a similar GNU C99 reproducer (itâs attached): the 
debugging information has the pattern that exhibits the bugfix. Namely: 
while the âparentâ function is inlined, the âchildâ function (which is 
in a block inside âparentâ) is not. So GDB relies on the 
DW_TAG_abstract_origin in the inlined block to refer to the abstract 
block that contains the DIE that materializes âchildâ.

However, it looks like there is no way in GDB to refer to C nested 
functions when they are not in the current scope:
> $ gcc -g -O2 -std=gnu99 nested_fun.c nested_fun_helpers.c
> $ gdb -n -q ./a.out
> (gdb) ptype child
> No symbol "child" in current context.
> (gdb) ptype nested_fun.parent.child
> No symbol "nested_fun" in current context.

On the other hand, this works with the Ada testcase:
> (gdb) ptype nested_fun.parent.child
> type = (false, true)

So Iâm not sure what to do next: should I do a fragile testcase based on 
scanning the assembly file? (it could break with an optimizer change) 
create a guality testsuite for Ada?

> Anyway, the patch looks ok to me but please give others a chance to chime in.

Sure. Thank you for reviewing!

--
Pierre-Marie de Rodat

/* { dg-do run } */
/* { dg-options "-O2 -g -std=gnu99" } */

extern void *create (const char *);
extern void destroy (void *);
extern void do_nothing (char);

struct string
{
  const char *data;
  int lb;
  int ub;
};

int
main (void)
{
  void *o1 = create ("foo");

  void
  parent (void)
  {
    {
      void *o2 = create ("bar");

      int
      child (struct string s)
      {
	int i = s.lb;

	if (s.lb <= s.ub)
	  while (1)
	    {
	      char c = s.data[i - s.lb];
	      do_nothing (c);
	      if (c == 'o')
		return 1;
	      if (i == s.ub)
		break;
	      ++i;
	    }
	return 0;
      }

      int r;

      r = child ((struct string) {"baz", 1, 3});
      r = child ((struct string) {"qux", 2, 4});
      r = child ((struct string) {"foobar", 1, 6});
    }

    do_nothing (0);
  }

  /* { dg-final { gdb-test 56 "type:main::parent::child" "int (struct string)" } } */
  parent ();
  return 0;
}

void *
create (const char *s)
{
  return 0;
}

void
destroy (void *o)
{
  return;
}

void
do_nothing (char c)
{
  return;
}