From ddb87a81ac5b031da67fb251b2c11a94e9834ae3 Mon Sep 17 00:00:00 2001 From: Joel Brobecker Date: Mon, 5 Jan 2015 18:39:02 +0400 Subject: [PATCH] gdb/DWARF: dynamic subrange type of dynamic subrange type. Consider the following code: type Record_Type (N : Integer) is record A : Array_Type (1 .. N); end record; [...] R : Record_Type := Get (10); Trying to print the bounds of the array R.A yielded: (gdb) p r.a'last $4 = cannot find reference address for offset property A slightly different example, but from the same cause: (gdb) ptype r type = record n: integer; a: array (cannot find reference address for offset property Looking at the debugging info, "A" is described as... .uleb128 0x11 # (DIE (0x181) DW_TAG_member) .ascii "a\0" # DW_AT_name .long 0x15d # DW_AT_type [...] ... which is an array... .uleb128 0x12 # (DIE (0x15d) DW_TAG_array_type) .long .LASF18 # DW_AT_name: "foo__record_type__T4b" .long 0x194 # DW_AT_type .long 0x174 # DW_AT_sibling ... whose bounds are described as: .uleb128 0x13 # (DIE (0x16a) DW_TAG_subrange_type) .long 0x174 # DW_AT_type .long 0x153 # DW_AT_upper_bound .byte 0 # end of children of DIE 0x15d We can see above that the range has an implict lower value of 1, and an upper value which is a reference 0x153="n". All Good. But looking at the array's subrange subtype, we see... .uleb128 0x14 # (DIE (0x174) DW_TAG_subrange_type) .long 0x153 # DW_AT_upper_bound .long .LASF19 # DW_AT_name: "foo__record_type__T3b" .long 0x18d # DW_AT_type ... another subrange type whose bounds are exactly described the same way. So we have a subrange of a subrange, both with one bound that's dynamic. What happens in the case above is that GDB's resolution of "R.A" yields a array whose index type has static bounds. However, the subtype of the array's index type was left untouched, so, when taking the subtype of the array's subrange type, we were left with the unresolved subrange type, triggering the error above. gdb/ChangeLog: * gdbtypes.c (is_dynamic_type_internal) : Return nonzero if the type's subtype is dynamic. (resolve_dynamic_range): Also resolve the range's subtype. Tested on x86_64-linux, no regression. --- gdb/ChangeLog | 6 ++++++ gdb/gdbtypes.c | 17 ++++++++++++++--- 2 files changed, 20 insertions(+), 3 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index db4e0b146dc..205d124a637 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,9 @@ +2015-01-29 Joel Brobecker + + * gdbtypes.c (is_dynamic_type_internal) : Return + nonzero if the type's subtype is dynamic. + (resolve_dynamic_range): Also resolve the range's subtype. + 2015-01-29 Joel Brobecker (tiny patch) * symfile.c (unmap_overlay_command): Initialize sec to NULL. diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index 6d3c084b60b..22b6ce4eb8c 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -1650,7 +1650,15 @@ is_dynamic_type_internal (struct type *type, int top_level) switch (TYPE_CODE (type)) { case TYPE_CODE_RANGE: - return !has_static_range (TYPE_RANGE_DATA (type)); + { + /* A range type is obviously dynamic if it has at least one + dynamic bound. But also consider the range type to be + dynamic when its subtype is dynamic, even if the bounds + of the range type are static. It allows us to assume that + the subtype of a static range type is also static. */ + return (!has_static_range (TYPE_RANGE_DATA (type)) + || is_dynamic_type_internal (TYPE_TARGET_TYPE (type), 0)); + } case TYPE_CODE_ARRAY: { @@ -1698,7 +1706,7 @@ static struct type * resolve_dynamic_range (struct type *dyn_range_type, CORE_ADDR addr) { CORE_ADDR value; - struct type *static_range_type; + struct type *static_range_type, *static_target_type; const struct dynamic_prop *prop; const struct dwarf2_locexpr_baton *baton; struct dynamic_prop low_bound, high_bound; @@ -1733,8 +1741,11 @@ resolve_dynamic_range (struct type *dyn_range_type, CORE_ADDR addr) high_bound.data.const_val = 0; } + static_target_type + = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (dyn_range_type), + addr, 0); static_range_type = create_range_type (copy_type (dyn_range_type), - TYPE_TARGET_TYPE (dyn_range_type), + static_target_type, &low_bound, &high_bound); TYPE_RANGE_DATA (static_range_type)->flag_bound_evaluated = 1; return static_range_type; -- 2.30.2