aboutsummaryrefslogtreecommitdiff
path: root/gdb/f-lang.h
diff options
context:
space:
mode:
authorRichard Bunt <richard.bunt@arm.com>2019-03-06 08:23:00 +0000
committerRichard Bunt <richard.bunt@arm.com>2019-03-06 08:24:12 +0000
commitaa3cfbda2f2af71044949b5692ce51cafb023d13 (patch)
tree1cba99e017e03ebdd44207d76fb7d23f0e179fcd /gdb/f-lang.h
parent2d0d5fc6f085dedd7988b29e58fdc4dc2081472e (diff)
downloadgdb-aa3cfbda2f2af71044949b5692ce51cafb023d13.zip
gdb-aa3cfbda2f2af71044949b5692ce51cafb023d13.tar.gz
gdb-aa3cfbda2f2af71044949b5692ce51cafb023d13.tar.bz2
Fortran function calls with arguments
Prior to this patch, calling functions on the inferior with arguments and then using these arguments within a function resulted in an invalid memory access. This is because Fortran arguments are typically passed as pointers to values. It is possible to call Fortran functions, but memory must be allocated in the inferior, so a pointer can be passed to the function, and the language must be set to C to enable C-style casting. This is cumbersome and not a pleasant debug experience. This patch implements the GNU Fortran argument passing conventions with caveats. Firstly, it does not handle the VALUE attribute as there is insufficient DWARF information to determine when this is the case. Secondly, functions with optional parameters can only be called with all parameters present. Both these cases are marked as KFAILS in the test. Since the GNU Fortran argument passing convention has been implemented, there is no guarantee that this patch will work correctly, in all cases, with other compilers. Despite these limitations, this patch improves the ease with which functions can be called in many cases, without taking away the existing approach of calling with the language set to C. Regression tested on x86_64, aarch64 and POWER9 with GCC 7.3.0. Regression tested with Ada on x86_64. Regression tested with native-extended-gdbserver target board. gdb/ChangeLog: * eval.c (evaluate_subexp_standard): Call Fortran argument wrapping logic. * f-lang.c (struct value): A value which can be passed into a Fortran function call. (fortran_argument_convert): Wrap Fortran arguments in a pointer where appropriate. (struct type): Value ready for a Fortran function call. (fortran_preserve_arg_pointer): Undo check_typedef, the pointer is needed. * f-lang.h (fortran_argument_convert): Declaration. (fortran_preserve_arg_pointer): Declaration. * infcall.c (value_arg_coerce): Call Fortran argument logic. gdb/testsuite/ChangeLog: * gdb.fortran/function-calls.exp: New file. * gdb.fortran/function-calls.f90: New test.
Diffstat (limited to 'gdb/f-lang.h')
-rw-r--r--gdb/f-lang.h33
1 files changed, 33 insertions, 0 deletions
diff --git a/gdb/f-lang.h b/gdb/f-lang.h
index a4ae6a7..5afafb1 100644
--- a/gdb/f-lang.h
+++ b/gdb/f-lang.h
@@ -82,4 +82,37 @@ struct builtin_f_type
/* Return the Fortran type table for the specified architecture. */
extern const struct builtin_f_type *builtin_f_type (struct gdbarch *gdbarch);
+/* Ensures that function argument VALUE is in the appropriate form to
+ pass to a Fortran function. Returns a possibly new value that should
+ be used instead of VALUE.
+
+ When IS_ARTIFICIAL is true this indicates an artificial argument,
+ e.g. hidden string lengths which the GNU Fortran argument passing
+ convention specifies as being passed by value.
+
+ When IS_ARTIFICIAL is false, the argument is passed by pointer. If the
+ value is already in target memory then return a value that is a pointer
+ to VALUE. If VALUE is not in memory (e.g. an integer literal), allocate
+ space in the target, copy VALUE in, and return a pointer to the in
+ memory copy. */
+
+extern struct value *fortran_argument_convert (struct value *value,
+ bool is_artificial);
+
+/* Ensures that function argument TYPE is appropriate to inform the debugger
+ that ARG should be passed as a pointer. Returns the potentially updated
+ argument type.
+
+ If ARG is of type pointer then the type of ARG is returned, otherwise
+ TYPE is returned untouched.
+
+ This function exists to augment the types of Fortran function call
+ parameters to be pointers to the reported value, when the corresponding ARG
+ has also been wrapped in a pointer (by fortran_argument_convert). This
+ informs the debugger that these arguments should be passed as a pointer
+ rather than as the pointed to type. */
+
+extern struct type *fortran_preserve_arg_pointer (struct value *arg,
+ struct type *type);
+
#endif /* F_LANG_H */