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 = <ref> 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) <TYPE_CODE_RANGE>: 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.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index db4e0b146dce077460fe5b7c2c8143163927b919..205d124a637be00f9a662dd72df4ca54097a7083 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,9 @@
+2015-01-29  Joel Brobecker  <brobecker@adacore.com>
+
+       * gdbtypes.c (is_dynamic_type_internal) <TYPE_CODE_RANGE>: Return
+       nonzero if the type's subtype is dynamic.
+       (resolve_dynamic_range): Also resolve the range's subtype.
+
 2015-01-29  Joel Brobecker  <brobecker@adacore.com>  (tiny patch)
 
        * symfile.c (unmap_overlay_command): Initialize sec to NULL.

diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 6d3c084b60be449ee9e11d67ebd40f8d84cf2cf1..22b6ce4eb8c56daf356d2b7f66d65e2b18f451ae 100644 (file)
--- 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;