Add valaddr support in dynamic property resolution.
This is the second part of enhancing the debugger to print the value of arrays of records whose size is variable when only standard DWARF info is available (no GNAT encoding). For instance: subtype Small_Type is Integer range 0 .. 10; type Record_Type (I : Small_Type := 0) is record S : String (1 .. I); end record; type Array_Type is array (Integer range <>) of Record_Type; A1 : Array_Type := (1 => (I => 0, S => <>), 2 => (I => 1, S => "A"), 3 => (I => 2, S => "AB")); Currently, GDB prints the following output: (gdb) p a1 $1 = ( The error happens while the ada-valprint module is trying to print the value of an element of our array. Because of the fact that the array's element (type Record_Type) has a variant size, the DWARF info for our array provide the array's stride: <1><749>: Abbrev Number: 10 (DW_TAG_array_type) <74a> DW_AT_name : (indirect string, offset: 0xb6d): pck__T18s <74e> DW_AT_byte_stride : 16 <74f> DW_AT_type : <0x6ea> And because our array has a stride, ada-valprint treats it the same way as packed arrays (see ada-valprint.c::ada_val_print_array): if (TYPE_FIELD_BITSIZE (type, 0) > 0) val_print_packed_array_elements (type, valaddr, offset_aligned, 0, stream, recurse, original_value, options); The first thing that we should notice in the call above is that the "valaddr" buffer and the associated offset (OFFSET_ALIGNED) is passed, but that the corresponding array's address is not. This can be explained by looking inside val_print_packed_array_elements, where we see that the function unpacks each element of our array from the buffer alone (ada_value_primitive_packed_val), and then prints the resulting artificial value instead: v0 = ada_value_primitive_packed_val (NULL, valaddr + offset, (i0 * bitsize) / HOST_CHAR_BIT, (i0 * bitsize) % HOST_CHAR_BIT, bitsize, elttype); [...] val_print (elttype, value_contents_for_printing (v0), value_embedded_offset (v0), 0, stream, recurse + 1, v0, &opts, current_language); Of particular interest, here, is the fact that we call val_print with a null address, which is OK, since we're providing a buffer instead (value_contents_for_printing). Also, providing an address might not always possible, since packing could place elements at boundaries that are not byte-aligned. Things go south when val_print tries to see if there is a pretty-printer that could be applied. In particular, one of the first things that the Python pretty-printer does is to create a value using our buffer, and the given address, which in this case is null (see call to value_from_contents_and_address in gdbpy_apply_val_pretty_printer). value_from_contents_and_address, in turn immediately tries to resolve the type, using the given address, which is null. But, because our array element is a record containing an array whose bound is the value of one of its elements (the "s" component), the debugging info for the array's upper bound is a reference... <3><71a>: Abbrev Number: 7 (DW_TAG_subrange_type) <71b> DW_AT_type : <0x724> <71f> DW_AT_upper_bound : <0x703> ... to component "i" of our record... <2><703>: Abbrev Number: 5 (DW_TAG_member) <704> DW_AT_name : i <706> DW_AT_decl_file : 2 <707> DW_AT_decl_line : 6 <708> DW_AT_type : <0x6d1> <70c> DW_AT_data_member_location: 0 ... where that component is located at offset 0 of the start of the record. dwarf2_evaluate_property correctly determines the offset where to load the value of the bound from, but then tries to read that value from inferior memory using the address that was given, which is null. See case PROP_ADDR_OFFSET in dwarf2_evaluate_property: val = value_at (baton->offset_info.type, pinfo->addr + baton->offset_info.offset); This triggers a memory error, which then causes the printing to terminate. Since there are going to be situations where providing an address alone is not going to be sufficient (packed arrays where array elements are not stored at byte boundaries), this patch fixes the issue by enhancing the type resolution to take both address and data. This follows the same principle as the val_print module, where both address and buffer ("valaddr") can be passed as arguments. If the data has already been fetched from inferior memory (or provided by the debugging info in some form -- Eg a constant), then use that data instead of reading it from inferior memory. Note that this should also be a good step towards being able to handle dynamic types whose value is stored outside of inferior memory (Eg: in a register). With this patch, GDB isn't able to print all of A1, but does perform a little better: (gdb) p a1 $1 = ((i => 0, s => , (i => 1, s => , (i => 2, s => ) There is another issue which is independent of this one, and will therefore be patched separately. gdb/ChangeLog: * dwarf2loc.h (struct property_addr_info): Add "valaddr" field. * dwarf2loc.c (dwarf2_evaluate_property): Add handling of pinfo->valaddr. * gdbtypes.h (resolve_dynamic_type): Add "valaddr" parameter. * gdbtypes.c (resolve_dynamic_struct): Set pinfo.valaddr. (resolve_dynamic_type_internal): Set pinfo.valaddr. Add handling of addr_stack->valaddr. (resolve_dynamic_type): Add "valaddr" parameter. Set pinfo.valaddr field. * ada-lang.c (ada_discrete_type_high_bound): Update call to resolve_dynamic_type. (ada_discrete_type_low_bound): Likewise. * findvar.c (default_read_var_value): Likewise. * value.c (value_from_contents_and_address): Likewise.
This commit is contained in:
parent
75ea58593b
commit
c334512419
@ -1,3 +1,20 @@
|
||||
2015-05-05 Joel Brobecker <brobecker@adacore.com>
|
||||
|
||||
* dwarf2loc.h (struct property_addr_info): Add "valaddr" field.
|
||||
* dwarf2loc.c (dwarf2_evaluate_property): Add handling of
|
||||
pinfo->valaddr.
|
||||
* gdbtypes.h (resolve_dynamic_type): Add "valaddr" parameter.
|
||||
* gdbtypes.c (resolve_dynamic_struct): Set pinfo.valaddr.
|
||||
(resolve_dynamic_type_internal): Set pinfo.valaddr.
|
||||
Add handling of addr_stack->valaddr.
|
||||
(resolve_dynamic_type): Add "valaddr" parameter.
|
||||
Set pinfo.valaddr field.
|
||||
* ada-lang.c (ada_discrete_type_high_bound): Update call to
|
||||
resolve_dynamic_type.
|
||||
(ada_discrete_type_low_bound): Likewise.
|
||||
* findvar.c (default_read_var_value): Likewise.
|
||||
* value.c (value_from_contents_and_address): Likewise.
|
||||
|
||||
2015-05-05 Joel Brobecker <brobecker@adacore.com>
|
||||
|
||||
* gdbtypes.c (resolve_dynamic_array): Use
|
||||
|
@ -794,7 +794,7 @@ min_of_type (struct type *t)
|
||||
LONGEST
|
||||
ada_discrete_type_high_bound (struct type *type)
|
||||
{
|
||||
type = resolve_dynamic_type (type, 0);
|
||||
type = resolve_dynamic_type (type, NULL, 0);
|
||||
switch (TYPE_CODE (type))
|
||||
{
|
||||
case TYPE_CODE_RANGE:
|
||||
@ -815,7 +815,7 @@ ada_discrete_type_high_bound (struct type *type)
|
||||
LONGEST
|
||||
ada_discrete_type_low_bound (struct type *type)
|
||||
{
|
||||
type = resolve_dynamic_type (type, 0);
|
||||
type = resolve_dynamic_type (type, NULL, 0);
|
||||
switch (TYPE_CODE (type))
|
||||
{
|
||||
case TYPE_CODE_RANGE:
|
||||
|
@ -2526,8 +2526,13 @@ dwarf2_evaluate_property (const struct dynamic_prop *prop,
|
||||
break;
|
||||
if (pinfo == NULL)
|
||||
error (_("cannot find reference address for offset property"));
|
||||
val = value_at (baton->offset_info.type,
|
||||
pinfo->addr + baton->offset_info.offset);
|
||||
if (pinfo->valaddr != NULL)
|
||||
val = value_from_contents
|
||||
(baton->offset_info.type,
|
||||
pinfo->valaddr + baton->offset_info.offset);
|
||||
else
|
||||
val = value_at (baton->offset_info.type,
|
||||
pinfo->addr + baton->offset_info.offset);
|
||||
*value = value_as_address (val);
|
||||
return 1;
|
||||
}
|
||||
|
@ -111,6 +111,9 @@ struct property_addr_info
|
||||
being resolved. */
|
||||
struct type *type;
|
||||
|
||||
/* If not NULL, a buffer containing the object's value. */
|
||||
const gdb_byte *valaddr;
|
||||
|
||||
/* The address of that object. */
|
||||
CORE_ADDR addr;
|
||||
|
||||
|
@ -438,7 +438,7 @@ default_read_var_value (struct symbol *var, struct frame_info *frame)
|
||||
if (is_dynamic_type (type))
|
||||
{
|
||||
/* Value is a constant byte-sequence and needs no memory access. */
|
||||
type = resolve_dynamic_type (type, /* Unused address. */ 0);
|
||||
type = resolve_dynamic_type (type, NULL, /* Unused address. */ 0);
|
||||
}
|
||||
/* Put the constant back in target format. */
|
||||
v = allocate_value (type);
|
||||
@ -470,7 +470,7 @@ default_read_var_value (struct symbol *var, struct frame_info *frame)
|
||||
if (is_dynamic_type (type))
|
||||
{
|
||||
/* Value is a constant byte-sequence and needs no memory access. */
|
||||
type = resolve_dynamic_type (type, /* Unused address. */ 0);
|
||||
type = resolve_dynamic_type (type, NULL, /* Unused address. */ 0);
|
||||
}
|
||||
v = allocate_value (type);
|
||||
memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var),
|
||||
|
@ -1984,6 +1984,7 @@ resolve_dynamic_struct (struct type *type,
|
||||
" (invalid location kind)"));
|
||||
|
||||
pinfo.type = check_typedef (TYPE_FIELD_TYPE (type, i));
|
||||
pinfo.valaddr = addr_stack->valaddr;
|
||||
pinfo.addr = addr_stack->addr;
|
||||
pinfo.next = addr_stack;
|
||||
|
||||
@ -2054,7 +2055,11 @@ resolve_dynamic_type_internal (struct type *type,
|
||||
struct property_addr_info pinfo;
|
||||
|
||||
pinfo.type = check_typedef (TYPE_TARGET_TYPE (type));
|
||||
pinfo.addr = read_memory_typed_address (addr_stack->addr, type);
|
||||
pinfo.valaddr = NULL;
|
||||
if (addr_stack->valaddr != NULL)
|
||||
pinfo.addr = extract_typed_address (addr_stack->valaddr, type);
|
||||
else
|
||||
pinfo.addr = read_memory_typed_address (addr_stack->addr, type);
|
||||
pinfo.next = addr_stack;
|
||||
|
||||
resolved_type = copy_type (type);
|
||||
@ -2096,9 +2101,11 @@ resolve_dynamic_type_internal (struct type *type,
|
||||
/* See gdbtypes.h */
|
||||
|
||||
struct type *
|
||||
resolve_dynamic_type (struct type *type, CORE_ADDR addr)
|
||||
resolve_dynamic_type (struct type *type, const gdb_byte *valaddr,
|
||||
CORE_ADDR addr)
|
||||
{
|
||||
struct property_addr_info pinfo = {check_typedef (type), addr, NULL};
|
||||
struct property_addr_info pinfo
|
||||
= {check_typedef (type), valaddr, addr, NULL};
|
||||
|
||||
return resolve_dynamic_type_internal (type, &pinfo, 1);
|
||||
}
|
||||
|
@ -1791,7 +1791,9 @@ extern void get_signed_type_minmax (struct type *, LONGEST *, LONGEST *);
|
||||
ADDR specifies the location of the variable the type is bound to.
|
||||
If TYPE has no dynamic properties return TYPE; otherwise a new type with
|
||||
static properties is returned. */
|
||||
extern struct type *resolve_dynamic_type (struct type *type, CORE_ADDR addr);
|
||||
extern struct type *resolve_dynamic_type (struct type *type,
|
||||
const gdb_byte *valaddr,
|
||||
CORE_ADDR addr);
|
||||
|
||||
/* * Predicate if the type has dynamic values, which are not resolved yet. */
|
||||
extern int is_dynamic_type (struct type *type);
|
||||
|
@ -3509,7 +3509,7 @@ value_from_contents_and_address (struct type *type,
|
||||
const gdb_byte *valaddr,
|
||||
CORE_ADDR address)
|
||||
{
|
||||
struct type *resolved_type = resolve_dynamic_type (type, address);
|
||||
struct type *resolved_type = resolve_dynamic_type (type, valaddr, address);
|
||||
struct type *resolved_type_no_typedef = check_typedef (resolved_type);
|
||||
struct value *v;
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user