[RFC] Typed DWARF stack

Hi!

This patch on top of
http://gcc.gnu.org/ml/gcc-patches/2011-03/msg01224.html
and
http://gcc.gnu.org/ml/gcc-patches/2011-03/msg01723.html
implements parts of Cary's typed DWARF stack proposal:
http://www.dwarfstd.org/doc/040408.1.html

As I said in my GCC Summit talk, currently we just give up on
any floating point/_Decimal*/__int128 and for 32-bit targets even
long long expressions, as those can't be represented in DWARF4,
while var-tracking has all that often available.

As we are quickly running out of available extension opcodes
in the GNU namespace (unless we go back to 0xeX range, with
this proposal we have just 7 left and it would be good
to reserve at least one such opcode as multiplexor for new
opcodes (DW_OP_GNU_multiplex whose first operand would be uleb128
extended opcode number followed by its arguments) and perhaps another
one to signal some location expression compression technique using
abbreviation table), I've chosen to add just those that are useful
for GCC and consumers of its debug info right now.
DW_OP_GNU_const{1,2,4,8}_type would allow us to save one byte, but that
doesn't seem worth wasting 4 opcodes in GNU namespace (the standard
has more, so it could add them).  Similarly, as GCC currently
never emits DW_OP_xderef*, I've not added DW_OP_GNU_xderef_type.
And DW_OP_GNU_readonly is something I have no idea how to get out
of var-tracking.  DW_OP_stack_value or DW_OP_implicit_value is
implicitly readonly, and for REGs/MEMs I don't think var-tracking
allows us to find out if changing this REG or MEM is the right way
to change the value of the variable, it is at each spot just
one of possibly more locations holding the value.

The added
DW_OP_GNU_const_type
DW_OP_GNU_regval_type
DW_OP_GNU_deref_type
DW_OP_GNU_convert
match (sans _GNU) what is written in the proposal and one extra
DW_OP_GNU_reinterpret
opcode has been added, which is like DW_OP_GNU_convert (so just one uleb128
argument with base type offset), but it is not a conversion (say
convert a floating point value to integer), but reinterpretation of
the bits (VIEW_CONVERT_EXPR-like, or store one value into a union, read
another value from another union field).

Some small problems on the producer side were caused by the base
type references being uleb128 instead of 4 byte number (in particular,
size of say DW_AT_location block depends on the offset number being
already known, but to compute offset numbers one has to know the sizes;
solved both for these and debug info size reasons by making sure
base types referenced from such ops are present very early in the CU
and can be sized and layed out early - base types shouldn't have
attributes with location expressions anyway - and the earlier they
are in the CU, the smaller the uleb128s are), but having them all
4 byte would be too large, so I actually like them being uleb128s.

On the consumer side I expect if a consumer decides to support these,
it implements the DWARF stack as pairs of some type id (or
encoding/byte size) and union of the supported typed fields.

Attached is also a guality testcase that shows some of what it can
e.g. represent, with the exception of two vars for -m32 in second routine
it actually has a location expression for all vars on both x86_64
and i?86.  If anyone from the debug info consumer crowd is interested,
I could post the assembly files for -m{32,64} -g -dA -O2.

	Jakub
2011-03-25  Jakub Jelinek  <jakub@redhat.com>

	* dwarf2.h (DW_OP_GNU_const_type, DW_OP_GNU_regval_type,
	DW_OP_GNU_deref_type, DW_OP_GNU_convert, DW_OP_GNU_reinterpret): New.

	* dwarf2out.c (get_address_mode): New inline.
	(mem_loc_descriptor): Ad MEM_MODE parameter, adjust recursive calls,
	if not dwarf_strict emit
	DW_OP_GNU_{{const,regval,deref}_type,convert,reinterpret} when
	desirable.  Handle FLOAT_EXTEND, FLOAT_TRUNCATE, FLOAT,
	UNSIGNED_FLOAT, FIX and UNSIGNED_FIX.  Just return NULL for
	FMA, STRICT_LOW_PART, CONST_VECTOR and CONST_FIXED.
	(dwarf2out_frame_debug_cfa_expression, reg_loc_descriptor,
	dw_loc_list_1, cst_pool_loc_descr, loc_list_from_tree): Adjust
	mem_loc_descriptor callers.
	(dwarf_stack_op_name, size_of_loc_descr, output_loc_operands,
	output_loc_operands_raw, hash_loc_operands, compare_loc_operands):
	Handle DW_OP_GNU_const_type, DW_OP_GNU_regval_type,
	DW_OP_GNU_deref_type, DW_OP_GNU_convert and DW_OP_GNU_reinterpret.
	(base_types): New variable.
	(get_base_type_offset, calc_base_type_die_sizes,
	base_type_for_mode, mark_base_types, base_type_cmp,
	move_marked_base_types): New functions.
	(calc_die_sizes): Assert that die_offset is 0 or equal to
	next_die_offset.
	(loc_descriptor): Only handle here lowpart SUBREGs of REG, for
	others defer to mem_loc_descriptor.  Adjust mem_loc_descriptor
	callers.  If not dwarf_strict, call mem_loc_descriptor even for
	non-MODE_INT modes or MODE_INT modes larger than DWARF2_ADDR_SIZE.
	(gen_subprogram_die): Don't give up on call site parameters
	with non-integral or large integral modes.  Adjust
	mem_loc_descriptor callers.
	(prune_unused_types): Call prune_unused_types_mark on base_types
	vector entries.
	(resolve_addr): Call mark_base_types.
	(dwarf2out_finish): Call move_marked_base_types.
	* cfgexpand.c (expand_debug_expr) <case FLOAT_EXPR> Don't use
	unsignedp but TYPE_UNSIGNED on argument to decide when to emit
	UNSIGNED_FLOAT.
/* { dg-do run { target { i?86-*-* x86_64-*-* } } } */
/* { dg-options "-g" } */

typedef __SIZE_TYPE__ size_t;
volatile int vv;
extern void *memcpy (void *, const void *, size_t);

__attribute__((noinline, noclone)) void
f1 (double a, double b, double c, float d, float e, int f, unsigned int g, long long h, unsigned long long i)
{
  double j = d;			/* { dg-final { gdb-test 29 "j" "4" } } */
  long long l;			/* { dg-final { gdb-test 29 "l" "4616189618054758400" } } */
  memcpy (&l, &j, sizeof (l));
  long long m;			/* { dg-final { gdb-test 29 "m" "4613937818241073152" } } */
  memcpy (&m, &c, sizeof (l));
  float n = i;			/* { dg-final { gdb-test 29 "n" "9" } } */
  double o = h;			/* { dg-final { gdb-test 29 "o" "8" } } */
  float p = g;			/* { dg-final { gdb-test 29 "p" "7" } } */
  double q = f;			/* { dg-final { gdb-test 29 "q" "6" } } */
  unsigned long long r = a;	/* { dg-final { gdb-test 29 "r" "1" } } */
  long long s = c;		/* { dg-final { gdb-test 29 "s" "3" } } */
  unsigned t = d;		/* { dg-final { gdb-test 29 "t" "4" } } */
  int u = b;			/* { dg-final { gdb-test 29 "u" "2" } } */
  float v = a;			/* { dg-final { gdb-test 29 "v" "1" } } */
  double w = d / 4.0;		/* { dg-final { gdb-test 29 "w" "1" } } */
  double x = a + b + 1.0;	/* { dg-final { gdb-test 29 "x" "4" } } */
  double y = b + c + 2.0;	/* { dg-final { gdb-test 29 "y" "7" } } */
  float z = d + e + 3.0f;	/* { dg-final { gdb-test 29 "z" "12" } } */
  vv++;
}

__attribute__((noinline, noclone)) void
f2 (double a, double b, double c, float d, float e, int f, unsigned int g, long long h, unsigned long long i)
{
  double j = d;			/* { dg-final { gdb-test 53 "j" "4" } } */
  long long l;			/* { dg-final { gdb-test 53 "l" "4616189618054758400" } } */
  memcpy (&l, &j, sizeof (l));
  long long m;			/* { dg-final { gdb-test 53 "m" "4613937818241073152" } } */
  memcpy (&m, &c, sizeof (l));
  float n = i;			/* { dg-final { gdb-test 53 "n" "9" } } */
  double o = h;			/* { dg-final { gdb-test 53 "o" "8" } } */
  float p = g;			/* { dg-final { gdb-test 53 "p" "7" } } */
  double q = f;			/* { dg-final { gdb-test 53 "q" "6" } } */
  unsigned long long r = a;	/* { dg-final { gdb-test 53 "r" "1" } } */
  long long s = c;		/* { dg-final { gdb-test 53 "s" "3" } } */
  unsigned t = d;		/* { dg-final { gdb-test 53 "t" "4" } } */
  int u = b;			/* { dg-final { gdb-test 53 "u" "2" } } */
  float v = a;			/* { dg-final { gdb-test 53 "v" "1" } } */
  double w = d / 4.0;		/* { dg-final { gdb-test 53 "w" "1" } } */
  double x = a + b - 3 + 1.0e20;/* { dg-final { gdb-test 53 "x" "1e+20" } } */
  double y = b + c * 7.0;	/* { dg-final { gdb-test 53 "y" "23" } } */
  float z = d + e + 3.0f;	/* { dg-final { gdb-test 53 "z" "12" } } */
  vv++;
  vv = a;
  vv = b;
  vv = c;
  vv = d;
  vv = e;
  vv = f;
  vv = g;
  vv = h;
  vv = i;
  vv = j;
}

__attribute__((noinline, noclone)) void
f3 (long long a, int b, long long c, unsigned d)
{
  long long w = (a > d) ? a : d;/* { dg-final { gdb-test 73 "w" "4" } } */
  long long x = a + b + 7;	/* { dg-final { gdb-test 73 "x" "10" } } */
  long long y = c + d + 0x912345678LL;/* { dg-final { gdb-test 73 "y" "38960125567" } } */
  int z = (x + y);		/* { dg-final { gdb-test 73 "z" "305419913" } } */
  vv++;
}

int
main ()
{
  f1 (1.0, 2.0, 3.0, 4.0f, 5.0f, 6, 7, 8, 9);
  f2 (1.0, 2.0, 3.0, 4.0f, 5.0f, 6, 7, 8, 9);
  f3 (1, 2, 3, 4);
  return 0;
}

[RFC] Typed DWARF stack

Commit Message

Comments

Patch