[PATCH] [Ada/funcalls] do not coerce fat pointers on the stack

[Joel Brobecker <brobecker at adacore dot com>]

When one of the parameter values in a subprogram calls is an array
whose value does not come from inferior memory, the debugger first
copies the array value in inferior memory.  Up to now, the memory
used to hold that copy was taken from the stack (just below the SP),
but this is causing problems on SPARC v9.

For instance, assuming a function called `Debug' that takes one string
as a parameters, and stores a copy of that string in a global buffer
called `Buffer', I tried the following:

    (gdb) call debug("hello")
    (gdb) p pck.buffer
    $1 = "["ff"]["ff"]["ff"]["ff"]["7f"]", ' ' <repeats 15 times>

I expected:

    (gdb) call debug("hello")
    (gdb) print pck.buffer
    $1 = "hello", ' ' <repeats 15 times>

The approach is not working on sparc64 because the memory allocated
for the fat pointer is located below the current frame (because of
the BIAS area), and ends up being overwritten during a call to memmove.

So the immediate fix is to follow what C does with arrays and strings,
which is allocate memory on the heap.

gdb/ChangeLog:

        * ada-lang.c: #include "value.h".
        (ensure_lval): Delete advance declaration.  Remove gdbarch and sp
        arguments.  Implement using value_allocate_space_in_inferior
        instead of allocating memory from the stack.
        (make_array_descriptor): Remove gdbarch and sp parameters.  Update
        calls to ensure_lval.
        (ada_convert_actual): Remove gdbarch and sp parameters.  Update
        calls to make_array_descriptor and ensure_lval.
        * ada-lang.h (ada_convert_actual): Update declaration.
        * infcall.c (value_arg_coerce): Update call to ada_convert_actual.

Tested on x86_64-linux. Also tested on sparc64-solaris with AdaCore's
testsuite.

Checked in.

---
 gdb/ChangeLog  |   13 +++++++++++
 gdb/ada-lang.c |   62 ++++++++++++++++---------------------------------------
 gdb/ada-lang.h |    4 +--
 gdb/infcall.c  |    2 +-
 4 files changed, 33 insertions(+), 48 deletions(-)

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 7f331ac..dda9cca 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,16 @@
+2010-10-04  Joel Brobecker  <brobecker@adacore.com>
+
+	* ada-lang.c: #include "value.h".
+	(ensure_lval): Delete advance declaration.  Remove gdbarch and sp
+	arguments.  Implement using value_allocate_space_in_inferior
+	instead of allocating memory from the stack.
+	(make_array_descriptor): Remove gdbarch and sp parameters.  Update
+	calls to ensure_lval.
+	(ada_convert_actual): Remove gdbarch and sp parameters.  Update
+	calls to make_array_descriptor and ensure_lval.
+	* ada-lang.h (ada_convert_actual): Update declaration.
+	* infcall.c (value_arg_coerce): Update call to ada_convert_actual.
+
 2010-10-04  Doug Evans  <dje@google.com>
 
 	* python/python.c (_initialize_python): Define new function
diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 668b2e2..09619de 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -59,6 +59,7 @@
 #include "stack.h"
 
 #include "psymtab.h"
+#include "value.h"
 
 /* Define whether or not the C operator '/' truncates towards zero for
    differently signed operands (truncation direction is undefined in C). 
@@ -102,11 +103,7 @@ static int ada_type_match (struct type *, struct type *, int);
 
 static int ada_args_match (struct symbol *, struct value **, int);
 
-static struct value *ensure_lval (struct value *,
-				  struct gdbarch *, CORE_ADDR *);
-
-static struct value *make_array_descriptor (struct type *, struct value *,
-                                            struct gdbarch *, CORE_ADDR *);
+static struct value *make_array_descriptor (struct type *, struct value *);
 
 static void ada_add_block_symbols (struct obstack *,
                                    struct block *, const char *,
@@ -3928,43 +3925,22 @@ parse_old_style_renaming (struct type *type,
                                 /* Evaluation: Function Calls */
 
 /* Return an lvalue containing the value VAL.  This is the identity on
-   lvalues, and otherwise has the side-effect of pushing a copy of VAL 
-   on the stack, using and updating *SP as the stack pointer, and 
-   returning an lvalue whose value_address points to the copy.  */
+   lvalues, and otherwise has the side-effect of allocating memory
+   in the inferior where a copy of the value contents is copied.  */
 
 static struct value *
-ensure_lval (struct value *val, struct gdbarch *gdbarch, CORE_ADDR *sp)
+ensure_lval (struct value *val)
 {
-  if (! VALUE_LVAL (val))
+  if (VALUE_LVAL (val) == not_lval
+      || VALUE_LVAL (val) == lval_internalvar)
     {
       int len = TYPE_LENGTH (ada_check_typedef (value_type (val)));
+      const CORE_ADDR addr =
+        value_as_long (value_allocate_space_in_inferior (len));
 
-      /* The following is taken from the structure-return code in
-	 call_function_by_hand. FIXME: Therefore, some refactoring seems 
-	 indicated. */
-      if (gdbarch_inner_than (gdbarch, 1, 2))
-	{
-	  /* Stack grows downward.  Align SP and value_address (val) after
-	     reserving sufficient space. */
-	  *sp -= len;
-	  if (gdbarch_frame_align_p (gdbarch))
-	    *sp = gdbarch_frame_align (gdbarch, *sp);
-	  set_value_address (val, *sp);
-	}
-      else
-	{
-	  /* Stack grows upward.  Align the frame, allocate space, and
-	     then again, re-align the frame. */
-	  if (gdbarch_frame_align_p (gdbarch))
-	    *sp = gdbarch_frame_align (gdbarch, *sp);
-	  set_value_address (val, *sp);
-	  *sp += len;
-	  if (gdbarch_frame_align_p (gdbarch))
-	    *sp = gdbarch_frame_align (gdbarch, *sp);
-	}
+      set_value_address (val, addr);
       VALUE_LVAL (val) = lval_memory;
-
-      write_memory (value_address (val), value_contents (val), len);
+      write_memory (addr, value_contents (val), len);
     }
 
   return val;
@@ -3976,8 +3952,7 @@ ensure_lval (struct value *val, struct gdbarch *gdbarch, CORE_ADDR *sp)
    values not residing in memory, updating it as needed.  */
 
 struct value *
-ada_convert_actual (struct value *actual, struct type *formal_type0,
-                    struct gdbarch *gdbarch, CORE_ADDR *sp)
+ada_convert_actual (struct value *actual, struct type *formal_type0)
 {
   struct type *actual_type = ada_check_typedef (value_type (actual));
   struct type *formal_type = ada_check_typedef (formal_type0);
@@ -3990,7 +3965,7 @@ ada_convert_actual (struct value *actual, struct type *formal_type0,
 
   if (ada_is_array_descriptor_type (formal_target)
       && TYPE_CODE (actual_target) == TYPE_CODE_ARRAY)
-    return make_array_descriptor (formal_type, actual, gdbarch, sp);
+    return make_array_descriptor (formal_type, actual);
   else if (TYPE_CODE (formal_type) == TYPE_CODE_PTR
 	   || TYPE_CODE (formal_type) == TYPE_CODE_REF)
     {
@@ -4010,7 +3985,7 @@ ada_convert_actual (struct value *actual, struct type *formal_type0,
               memcpy ((char *) value_contents_raw (val),
                       (char *) value_contents (actual),
                       TYPE_LENGTH (actual_type));
-              actual = ensure_lval (val, gdbarch, sp);
+              actual = ensure_lval (val);
             }
           result = value_addr (actual);
         }
@@ -4051,8 +4026,7 @@ value_pointer (struct value *value, struct type *type)
    representing a pointer to this descriptor.  */
 
 static struct value *
-make_array_descriptor (struct type *type, struct value *arr,
-		       struct gdbarch *gdbarch, CORE_ADDR *sp)
+make_array_descriptor (struct type *type, struct value *arr)
 {
   struct type *bounds_type = desc_bounds_type (type);
   struct type *desc_type = desc_base_type (type);
@@ -4074,11 +4048,11 @@ make_array_descriptor (struct type *type, struct value *arr,
                             desc_bound_bitsize (bounds_type, i, 1));
     }
 
-  bounds = ensure_lval (bounds, gdbarch, sp);
+  bounds = ensure_lval (bounds);
 
   modify_general_field (value_type (descriptor),
 			value_contents_writeable (descriptor),
-                        value_pointer (ensure_lval (arr, gdbarch, sp),
+                        value_pointer (ensure_lval (arr),
                                        TYPE_FIELD_TYPE (desc_type, 0)),
                         fat_pntr_data_bitpos (desc_type),
                         fat_pntr_data_bitsize (desc_type));
@@ -4090,7 +4064,7 @@ make_array_descriptor (struct type *type, struct value *arr,
                         fat_pntr_bounds_bitpos (desc_type),
                         fat_pntr_bounds_bitsize (desc_type));
 
-  descriptor = ensure_lval (descriptor, gdbarch, sp);
+  descriptor = ensure_lval (descriptor);
 
   if (TYPE_CODE (type) == TYPE_CODE_PTR)
     return value_addr (descriptor);
diff --git a/gdb/ada-lang.h b/gdb/ada-lang.h
index 935c2e1..cbd0f06 100644
--- a/gdb/ada-lang.h
+++ b/gdb/ada-lang.h
@@ -181,9 +181,7 @@ extern void ada_printstr (struct ui_file *, struct type *, const gdb_byte *,
 			  const struct value_print_options *);
 
 struct value *ada_convert_actual (struct value *actual,
-                                  struct type *formal_type0,
-				  struct gdbarch *gdbarch,
-                                  CORE_ADDR *sp);
+                                  struct type *formal_type0);
 
 extern struct value *ada_value_subscript (struct value *, int,
                                           struct value **);
diff --git a/gdb/infcall.c b/gdb/infcall.c
index 0c9a3af..7f60e56 100644
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -143,7 +143,7 @@ value_arg_coerce (struct gdbarch *gdbarch, struct value *arg,
 
   /* Perform any Ada-specific coercion first.  */
   if (current_language->la_language == language_ada)
-    arg = ada_convert_actual (arg, type, gdbarch, sp);
+    arg = ada_convert_actual (arg, type);
 
   /* Force the value to the target if we will need its address.  At
      this point, we could allocate arguments on the stack instead of
-- 
1.7.1