Toolchain/binutils-gdb
1
0
Fork 0
forked from Imagelibrary/binutils-gdb
Code Pull Requests Activity

[Ada] Enhance type printing for arrays with variable-sized elements

Browse Source 
This change is relevant only for standard DWARF (as opposed to the GNAT
encodings extensions): at the time of writing it only makes a difference
with GCC patches that are to be integrated: see the patch series
submission at
<https://gcc.gnu.org/ml/gcc-patches/2015-07/msg01353.html>.

Given the following Ada declarations:

   subtype Small_Int is Natural range 0 .. 100;
   type R_Type (L : Small_Int := 0) is record
      S : String (1 .. L);
   end record;
   type A_Type is array (Natural range <>) of R_Type;

   A : A_Type := (1 => (L => 0, S => ""),
                  2 => (L => 2, S => "ab"));

Before this change, we would get the following GDB session:

    (gdb) ptype a
    type = array (1 .. 2) of foo.r_type <packed: 838-bit elements>

This is wrong: "a" is not a packed array.  This output comes from the
fact that, because R_Type has a dynamic size (with a maximum), the
compiler has to describe in the debugging information the size allocated
for each array element (i.e. the stride, in DWARF parlance: see
DW_AT_byte_stride).  Ada type printing currently assumes that arrays
with a stride are packed, hence the above output.

In practice, GNAT never performs bit-packing for arrays that contain
variable-sized elements.  Leveraging this fact, this patch enhances type
printing so that ptype does not pretend that arrays are packed when they
have a stride and they contain dynamic elements.  After this change, we
get the following expected output:

    (gdb) ptype a
    type = array (1 .. 2) of foo.r_type

gdb/ChangeLog:

	* ada-typeprint.c (print_array_type): Do not describe arrays as
	packed when they embed dynamic elements.

gdb/testsuite/ChangeLog:

	* gdb.ada/array_of_variable_length.exp: New testcase.
	* gdb.ada/array_of_variable_length/foo.adb: New file.
	* gdb.ada/array_of_variable_length/pck.adb: New file.
	* gdb.ada/array_of_variable_length/pck.ads: New file.

Tested on x86_64-linux, no regression.
This commit is contained in:
Pierre-Marie de Rodat
2015-09-15 11:56:03 +02:00
parent b326e5870e
commit bfca584fae
7 changed files with 140 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
gdb/ada-typeprint.c
View File

@@ -386,6 +386,7 @@ print_array_type (struct type *type, struct ui_file *stream, int show,
{
int bitsize;
int n_indices;
struct type *elt_type = NULL;
if (ada_is_constrained_packed_array_type (type))
type = ada_coerce_to_simple_array_type (type);
@@ -448,11 +449,15 @@ print_array_type (struct type *type, struct ui_file *stream, int show,
fprintf_filtered (stream, "%s<>", i == i0 ? "" : ", ");
}
elt_type = ada_array_element_type (type, n_indices);
fprintf_filtered (stream, ") of ");
wrap_here ("");
ada_print_type (ada_array_element_type (type, n_indices), "", stream,
show == 0 ? 0 : show - 1, level + 1, flags);
if (bitsize > 0)
ada_print_type (elt_type, "", stream, show == 0 ? 0 : show - 1, level + 1,
flags);
/* Arrays with variable-length elements are never bit-packed in practice but
compilers have to describe their stride so that we can properly fetch
individual elements. Do not say the array is packed in this case. */
if (bitsize > 0 && !is_dynamic_type (elt_type))
fprintf_filtered (stream, " <packed: %d-bit elements>", bitsize);
}