gdb/fortran: Add support for Fortran array slices at the GDB prompt

This commit brings array slice support to GDB.

WARNING: This patch contains a rather big hack which is limited to
Fortran arrays, this can be seen in gdbtypes.c and f-lang.c.  More
details on this below.

This patch rewrites two areas of GDB's Fortran support, the code to
extract an array slice, and the code to print an array.

After this commit a user can, from the GDB prompt, ask for a slice of
a Fortran array and should get the correct result back.  Slices can
(optionally) have the lower bound, upper bound, and a stride
specified.  Slices can also have a negative stride.

Fortran has the concept of repacking array slices.  Within a compiled
Fortran program if a user passes a non-contiguous array slice to a
function then the compiler may have to repack the slice, this involves
copying the elements of the slice to a new area of memory before the
call, and copying the elements back to the original array after the
call.  Whether repacking occurs will depend on which version of
Fortran is being used, and what type of function is being called.

This commit adds support for both packed, and unpacked array slicing,
with the default being unpacked.

With an unpacked array slice, when the user asks for a slice of an
array GDB creates a new type that accurately describes where the
elements of the slice can be found within the original array, a
value of this type is then returned to the user.  The address of an
element within the slice will be equal to the address of an element
within the original array.

A user can choose to select packed array slices instead using:

  (gdb) set fortran repack-array-slices on|off
  (gdb) show fortran repack-array-slices

With packed array slices GDB creates a new type that reflects how the
elements of the slice would look if they were laid out in contiguous
memory, allocates a value of this type, and then fetches the elements
from the original array and places then into the contents buffer of
the new value.

One benefit of using packed slices over unpacked slices is the memory
usage, taking a small slice of N elements from a large array will
require (in GDB) N * ELEMENT_SIZE bytes of memory, while an unpacked
array will also include all of the "padding" between the
non-contiguous elements.  There are new tests added that highlight
this difference.

There is also a new debugging flag added with this commit that
introduces these commands:

  (gdb) set debug fortran-array-slicing on|off
  (gdb) show debug fortran-array-slicing

This prints information about how the array slices are being built.

As both the repacking, and the array printing requires GDB to walk
through a multi-dimensional Fortran array visiting each element, this
commit adds the file f-array-walk.h, which introduces some
infrastructure to support this process.  This means the array printing
code in f-valprint.c is significantly reduced.

The only slight issue with this commit is the "rather big hack" that I
mentioned above.  This hack allows us to handle one specific case,
array slices with negative strides.  This is something that I don't
believe the current GDB value contents model will allow us to
correctly handle, and rather than rewrite the value contents code
right now, I'm hoping to slip this hack in as a work around.

The problem is that, as I see it, the current value contents model
assumes that an object base address will be the lowest address within
that object, and that the contents of the object start at this base
address and occupy the TYPE_LENGTH bytes after that.

( We do have the embedded_offset, which is used for C++ sub-classes,
such that an object can start at some offset from the content buffer,
however, the assumption that the object then occupies the next
TYPE_LENGTH bytes is still true within GDB. )

The problem is that Fortran arrays with a negative stride don't follow
this pattern.  In this case the base address of the object points to
the element with the highest address, the contents of the array then
start at some offset _before_ the base address, and proceed for one
element _past_ the base address.

As the stride for such an array would be negative then, in theory the
TYPE_LENGTH for this type would also be negative.  However, in many
places a value in GDB will degrade to a pointer + length, and the
length almost always comes from the TYPE_LENGTH.

It is my belief that in order to correctly model this case the value
content handling of GDB will need to be reworked to split apart the
value's content buffer (which is a block of memory with a length), and
the object's in memory base address and length, which could be
negative.

Things are further complicated because arrays with negative strides
like this are always dynamic types.  When a value has a dynamic type
and its base address needs resolving we actually store the address of
the object within the resolved dynamic type, not within the value
object itself.

In short I don't currently see an easy path to cleanly support this
situation within GDB.  And so I believe that leaves two options,
either add a work around, or catch cases where the user tries to make
use of a negative stride, or access an array with a negative stride,
and throw an error.

This patch currently goes with adding a work around, which is that
when we resolve a dynamic Fortran array type, if the stride is
negative, then we adjust the base address to point to the lowest
address required by the array.  The printing and slicing code is aware
of this adjustment and will correctly slice and print Fortran arrays.

Where this hack will show through to the user is if they ask for the
address of an array in their program with a negative array stride, the
address they get from GDB will not match the address that would be
computed within the Fortran program.

gdb/ChangeLog:

	* Makefile.in (HFILES_NO_SRCDIR): Add f-array-walker.h.
	* NEWS: Mention new options.
	* f-array-walker.h: New file.
	* f-lang.c: Include 'gdbcmd.h' and 'f-array-walker.h'.
	(repack_array_slices): New static global.
	(show_repack_array_slices): New function.
	(fortran_array_slicing_debug): New static global.
	(show_fortran_array_slicing_debug): New function.
	(value_f90_subarray): Delete.
	(skip_undetermined_arglist): Delete.
	(class fortran_array_repacker_base_impl): New class.
	(class fortran_lazy_array_repacker_impl): New class.
	(class fortran_array_repacker_impl): New class.
	(fortran_value_subarray): Complete rewrite.
	(set_fortran_list): New static global.
	(show_fortran_list): Likewise.
	(_initialize_f_language): Register new commands.
	(fortran_adjust_dynamic_array_base_address_hack): New function.
	* f-lang.h (fortran_adjust_dynamic_array_base_address_hack):
	Declare.
	* f-valprint.c: Include 'f-array-walker.h'.
	(class fortran_array_printer_impl): New class.
	(f77_print_array_1): Delete.
	(f77_print_array): Delete.
	(fortran_print_array): New.
	(f_value_print_inner): Update to call fortran_print_array.
	* gdbtypes.c: Include 'f-lang.h'.
	(resolve_dynamic_type_internal): Call
	fortran_adjust_dynamic_array_base_address_hack.

gdb/testsuite/ChangeLog:

        * gdb.fortran/array-slices-bad.exp: New file.
        * gdb.fortran/array-slices-bad.f90: New file.
        * gdb.fortran/array-slices-sub-slices.exp: New file.
        * gdb.fortran/array-slices-sub-slices.f90: New file.
        * gdb.fortran/array-slices.exp: Rewrite tests.
        * gdb.fortran/array-slices.f90: Rewrite tests.
        * gdb.fortran/vla-sizeof.exp: Correct expected results.

gdb/doc/ChangeLog:

        * gdb.texinfo (Debugging Output): Document 'set/show debug
        fortran-array-slicing'.
        (Special Fortran Commands): Document 'set/show fortran
        repack-array-slices'.

1 files changed, 93 insertions, 94 deletions

diff --git a/gdb/f-valprint.c b/gdb/f-valprint.c
index 33ac761..d147caa 100644
--- a/gdb/f-valprint.c
+++ b/gdb/f-valprint.c
@@ -35,6 +35,7 @@
 #include "dictionary.h"
 #include "cli/cli-style.h"
 #include "gdbarch.h"
+#include "f-array-walker.h"
 
 static void f77_get_dynamic_length_of_aggregate (struct type *);
 
@@ -100,100 +101,103 @@ f77_get_dynamic_length_of_aggregate (struct type *type)
     * TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type)));
 }
 
-/* Actual function which prints out F77 arrays, Valaddr == address in 
-   the superior.  Address == the address in the inferior.  */
+/* A class used by FORTRAN_PRINT_ARRAY as a specialisation of the array
+   walking template.  This specialisation prints Fortran arrays.  */
 
-static void
-f77_print_array_1 (int nss, int ndimensions, struct type *type,
-		   const gdb_byte *valaddr,
-		   int embedded_offset, CORE_ADDR address,
-		   struct ui_file *stream, int recurse,
-		   const struct value *val,
-		   const struct value_print_options *options,
-		   int *elts)
+class fortran_array_printer_impl : public fortran_array_walker_base_impl
 {
-  struct type *range_type = check_typedef (type)->index_type ();
-  CORE_ADDR addr = address + embedded_offset;
-  LONGEST lowerbound, upperbound;
-  LONGEST i;
-
-  get_discrete_bounds (range_type, &lowerbound, &upperbound);
-
-  if (nss != ndimensions)
-    {
-      struct gdbarch *gdbarch = get_type_arch (type);
-      size_t dim_size = type_length_units (TYPE_TARGET_TYPE (type));
-      int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
-      size_t byte_stride = type->bit_stride () / (unit_size * 8);
-      if (byte_stride == 0)
-	byte_stride = dim_size;
-      size_t offs = 0;
-
-      for (i = lowerbound;
-	   (i < upperbound + 1 && (*elts) < options->print_max);
-	   i++)
-	{
-	  struct value *subarray = value_from_contents_and_address
-	    (TYPE_TARGET_TYPE (type), value_contents_for_printing_const (val)
-	     + offs, addr + offs);
-
-	  fprintf_filtered (stream, "(");
-	  f77_print_array_1 (nss + 1, ndimensions, value_type (subarray),
-			     value_contents_for_printing (subarray),
-			     value_embedded_offset (subarray),
-			     value_address (subarray),
-			     stream, recurse, subarray, options, elts);
-	  offs += byte_stride;
-	  fprintf_filtered (stream, ")");
-
-	  if (i < upperbound)
-	    fprintf_filtered (stream, " ");
-	}
-      if (*elts >= options->print_max && i < upperbound)
-	fprintf_filtered (stream, "...");
-    }
-  else
-    {
-      for (i = lowerbound; i < upperbound + 1 && (*elts) < options->print_max;
-	   i++, (*elts)++)
-	{
-	  struct value *elt = value_subscript ((struct value *)val, i);
-
-	  common_val_print (elt, stream, recurse, options, current_language);
-
-	  if (i != upperbound)
-	    fprintf_filtered (stream, ", ");
-
-	  if ((*elts == options->print_max - 1)
-	      && (i != upperbound))
-	    fprintf_filtered (stream, "...");
-	}
-    }
-}
+public:
+  /* Constructor.  TYPE is the array type being printed, ADDRESS is the
+     address in target memory for the object of TYPE being printed.  VAL is
+     the GDB value (of TYPE) being printed.  STREAM is where to print to,
+     RECOURSE is passed through (and prevents infinite recursion), and
+     OPTIONS are the printing control options.  */
+  explicit fortran_array_printer_impl (struct type *type,
+				       CORE_ADDR address,
+				       struct value *val,
+				       struct ui_file *stream,
+				       int recurse,
+				       const struct value_print_options *options)
+    : m_elts (0),
+      m_val (val),
+      m_stream (stream),
+      m_recurse (recurse),
+      m_options (options)
+  { /* Nothing.  */ }
+
+  /* Called while iterating over the array bounds.  When SHOULD_CONTINUE is
+     false then we must return false, as we have reached the end of the
+     array bounds for this dimension.  However, we also return false if we
+     have printed too many elements (after printing '...').  In all other
+     cases, return true.  */
+  bool continue_walking (bool should_continue)
+  {
+    bool cont = should_continue && (m_elts < m_options->print_max);
+    if (!cont && should_continue)
+      fputs_filtered ("...", m_stream);
+    return cont;
+  }
+
+  /* Called when we start iterating over a dimension.  If it's not the
+     inner most dimension then print an opening '(' character.  */
+  void start_dimension (bool inner_p)
+  {
+    fputs_filtered ("(", m_stream);
+  }
+
+  /* Called when we finish processing a batch of items within a dimension
+     of the array.  Depending on whether this is the inner most dimension
+     or not we print different things, but this is all about adding
+     separators between elements, and dimensions of the array.  */
+  void finish_dimension (bool inner_p, bool last_p)
+  {
+    fputs_filtered (")", m_stream);
+    if (!last_p)
+      fputs_filtered (" ", m_stream);
+  }
+
+  /* Called to process an element of ELT_TYPE at offset ELT_OFF from the
+     start of the parent object.  */
+  void process_element (struct type *elt_type, LONGEST elt_off, bool last_p)
+  {
+    /* Extract the element value from the parent value.  */
+    struct value *e_val
+      = value_from_component (m_val, elt_type, elt_off);
+    common_val_print (e_val, m_stream, m_recurse, m_options, current_language);
+    if (!last_p)
+      fputs_filtered (", ", m_stream);
+    ++m_elts;
+  }
+
+private:
+  /* The number of elements printed so far.  */
+  int m_elts;
+
+  /* The value from which we are printing elements.  */
+  struct value *m_val;
+
+  /* The stream we should print too.  */
+  struct ui_file *m_stream;
+
+  /* The recursion counter, passed through when we print each element.  */
+  int m_recurse;
+
+  /* The print control options.  Gives us the maximum number of elements to
+     print, and is passed through to each element that we print.  */
+  const struct value_print_options *m_options = nullptr;
+};
 
-/* This function gets called to print an F77 array, we set up some 
-   stuff and then immediately call f77_print_array_1().  */
+/* This function gets called to print a Fortran array.  */
 
 static void
-f77_print_array (struct type *type, const gdb_byte *valaddr,
-		 int embedded_offset,
-		 CORE_ADDR address, struct ui_file *stream,
-		 int recurse,
-		 const struct value *val,
-		 const struct value_print_options *options)
+fortran_print_array (struct type *type, CORE_ADDR address,
+		     struct ui_file *stream, int recurse,
+		     const struct value *val,
+		     const struct value_print_options *options)
 {
-  int ndimensions;
-  int elts = 0;
-
-  ndimensions = calc_f77_array_dims (type);
-
-  if (ndimensions > MAX_FORTRAN_DIMS || ndimensions < 0)
-    error (_("\
-Type node corrupt! F77 arrays cannot have %d subscripts (%d Max)"),
-	   ndimensions, MAX_FORTRAN_DIMS);
-
-  f77_print_array_1 (1, ndimensions, type, valaddr, embedded_offset,
-		     address, stream, recurse, val, options, &elts);
+  fortran_array_walker<fortran_array_printer_impl> p
+    (type, address, (struct value *) val, stream, recurse, options);
+  p.walk ();
 }
 
 
@@ -237,12 +241,7 @@ f_language::value_print_inner (struct value *val, struct ui_file *stream,
 
     case TYPE_CODE_ARRAY:
       if (TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_CHAR)
-	{
-	  fprintf_filtered (stream, "(");
-	  f77_print_array (type, valaddr, 0,
-			   address, stream, recurse, val, options);
-	  fprintf_filtered (stream, ")");
-	}
+	fortran_print_array (type, address, stream, recurse, val, options);
       else
 	{
 	  struct type *ch_type = TYPE_TARGET_TYPE (type);