From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1585) id 253E23857829; Mon, 14 Mar 2022 10:39:03 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 253E23857829 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable From: Luis Machado To: gdb-cvs@sourceware.org Subject: [binutils-gdb] [aarch64/arm] Properly extract the return value returned in memory X-Act-Checkin: binutils-gdb X-Git-Author: Luis Machado X-Git-Refname: refs/heads/master X-Git-Oldrev: d4661bf0e978da6e8b8a9cb792c9e82bfab403f0 X-Git-Newrev: bab22d0640914384d467e09c3e796585fd08e7c6 Message-Id: <20220314103903.253E23857829@sourceware.org> Date: Mon, 14 Mar 2022 10:39:03 +0000 (GMT) X-BeenThere: gdb-cvs@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Mon, 14 Mar 2022 10:39:03 -0000 https://sourceware.org/git/gitweb.cgi?p=3Dbinutils-gdb.git;h=3Dbab22d064091= 4384d467e09c3e796585fd08e7c6 commit bab22d0640914384d467e09c3e796585fd08e7c6 Author: Luis Machado Date: Tue Jan 4 14:06:36 2022 -0300 [aarch64/arm] Properly extract the return value returned in memory =20 When running gdb.cp/non-trivial-retval.exp, the following shows up for both aarch64-linux and armhf-linux: =20 Breakpoint 3, f1 (i1=3D23, i2=3D100) at src/gdb/testsuite/gdb.cp/non-tr= ivial-retval.cc:35 35 A a; (gdb) finish Run till exit from #0 f1 (i1=3D23, i2=3D100) at src/gdb/testsuite/gdb.= cp/non-trivial-retval.cc:35 main () at /src/gdb/testsuite/gdb.cp/non-trivial-retval.cc:163 163 B b =3D f2 (i1, i2); Value returned is $6 =3D {a =3D -11952} (gdb) =20 The return value should be {a =3D 123} instead. This happens because the backends don't extract the return value from the correct location. GDB = should fetch a pointer to the memory location from X8 for aarch64 and r0 for a= rmhf. =20 With the patch, gdb.cp/non-trivial-retval.exp has full passes on aarch64-linux and armhf-linux on Ubuntu 20.04/18.04. =20 The problem only shows up with the "finish" command. The "call" command works correctly and displays the correct return value. =20 This is also related to PR gdb/28681 (https://sourceware.org/bugzilla/show_bug.cgi?id=3D28681) and fixes FAI= L's in gdb.ada/mi_var_array.exp. =20 A new testcase is provided, and it exercises GDB's ability to "finish" a function that returns a large struct (> 16 bytes) and display the contents of this struct correctly. This has always been incorrect for these backends, but no testcase exercised this particular scenario. Diff: --- gdb/aarch64-tdep.c | 21 ++++++++++-- gdb/arm-tdep.c | 32 ++++++++++++++++-- gdb/testsuite/gdb.base/retval-large-struct.c | 45 ++++++++++++++++++++++= ++++ gdb/testsuite/gdb.base/retval-large-struct.exp | 37 +++++++++++++++++++++ 4 files changed, 130 insertions(+), 5 deletions(-) diff --git a/gdb/aarch64-tdep.c b/gdb/aarch64-tdep.c index b3efb3ebaff..3f3a65240c0 100644 --- a/gdb/aarch64-tdep.c +++ b/gdb/aarch64-tdep.c @@ -2362,7 +2362,8 @@ aarch64_return_in_memory (struct gdbarch *gdbarch, st= ruct type *type) return 0; } =20 - if (TYPE_LENGTH (type) > 16) + if (TYPE_LENGTH (type) > 16 + || !language_pass_by_reference (type).trivially_copyable) { /* PCS B.6 Aggregates larger than 16 bytes are passed by invisible reference. */ @@ -2474,8 +2475,24 @@ aarch64_return_value (struct gdbarch *gdbarch, struc= t value *func_value, { if (aarch64_return_in_memory (gdbarch, valtype)) { + /* From the AAPCS64's Result Return section: + + "Otherwise, the caller shall reserve a block of memory of + sufficient size and alignment to hold the result. The address + of the memory block shall be passed as an additional argument to + the function in x8. */ + aarch64_debug_printf ("return value in memory"); - return RETURN_VALUE_STRUCT_CONVENTION; + + if (readbuf) + { + CORE_ADDR addr; + + regcache->cooked_read (AARCH64_STRUCT_RETURN_REGNUM, &addr); + read_memory (addr, readbuf, TYPE_LENGTH (valtype)); + } + + return RETURN_VALUE_ABI_RETURNS_ADDRESS; } } =20 diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c index d36856e1f3b..8e245648f23 100644 --- a/gdb/arm-tdep.c +++ b/gdb/arm-tdep.c @@ -8075,7 +8075,8 @@ arm_return_in_memory (struct gdbarch *gdbarch, struct= type *type) { /* The AAPCS says all aggregates not larger than a word are returned in a register. */ - if (TYPE_LENGTH (type) <=3D ARM_INT_REGISTER_SIZE) + if (TYPE_LENGTH (type) <=3D ARM_INT_REGISTER_SIZE + && language_pass_by_reference (type).trivially_copyable) return 0; =20 return 1; @@ -8086,7 +8087,8 @@ arm_return_in_memory (struct gdbarch *gdbarch, struct= type *type) =20 /* All aggregate types that won't fit in a register must be returned in memory. */ - if (TYPE_LENGTH (type) > ARM_INT_REGISTER_SIZE) + if (TYPE_LENGTH (type) > ARM_INT_REGISTER_SIZE + || !language_pass_by_reference (type).trivially_copyable) return 1; =20 /* In the ARM ABI, "integer" like aggregate types are returned in @@ -8307,9 +8309,33 @@ arm_return_value (struct gdbarch *gdbarch, struct va= lue *function, || valtype->code () =3D=3D TYPE_CODE_UNION || valtype->code () =3D=3D TYPE_CODE_ARRAY) { + /* From the AAPCS document: + + Result return: + + A Composite Type larger than 4 bytes, or whose size cannot be + determined statically by both caller and callee, is stored in memory + at an address passed as an extra argument when the function was + called (Parameter Passing, rule A.4). The memory to be used for the + result may be modified at any point during the function call. + + Parameter Passing: + + A.4: If the subroutine is a function that returns a result in memory, + then the address for the result is placed in r0 and the NCRN is set + to r1. */ if (tdep->struct_return =3D=3D pcc_struct_return || arm_return_in_memory (gdbarch, valtype)) - return RETURN_VALUE_STRUCT_CONVENTION; + { + if (readbuf) + { + CORE_ADDR addr; + + regcache->cooked_read (ARM_A1_REGNUM, &addr); + read_memory (addr, readbuf, TYPE_LENGTH (valtype)); + } + return RETURN_VALUE_ABI_RETURNS_ADDRESS; + } } else if (valtype->code () =3D=3D TYPE_CODE_COMPLEX) { diff --git a/gdb/testsuite/gdb.base/retval-large-struct.c b/gdb/testsuite/g= db.base/retval-large-struct.c new file mode 100644 index 00000000000..ae459741220 --- /dev/null +++ b/gdb/testsuite/gdb.base/retval-large-struct.c @@ -0,0 +1,45 @@ +/* This testcase is part of GDB, the GNU debugger. + + Copyright 2022 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . = */ + +struct big_struct_t +{ + int int_array[5]; + double double_array[5]; + char char_array[5]; +}; + +struct big_struct_t big_struct =3D +{ + {1, 2, 3, 4, 5}, + {3.25, 5.0, 6.25, 1.325, -1.95}, + "abcde" +}; + +struct big_struct_t return_large_struct (void) +{ + return big_struct; +} + +int +main (int argc, char **argv) +{ + struct big_struct_t test_struct; + + test_struct =3D return_large_struct (); + + return 0; +} diff --git a/gdb/testsuite/gdb.base/retval-large-struct.exp b/gdb/testsuite= /gdb.base/retval-large-struct.exp new file mode 100644 index 00000000000..11bc4d5fbdf --- /dev/null +++ b/gdb/testsuite/gdb.base/retval-large-struct.exp @@ -0,0 +1,37 @@ +# Copyright 2022 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# This file is part of the gdb testsuite +# +# Test if "finish" behaves correctly when a function returns a +# large (> 16 bytes) struct. + +standard_testfile + +if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} { + return -1 +} + +if {![runto_main]} { + return -1 +} + +set pattern ".* =3D \\{int_array =3D \\{1, 2, 3, 4, 5\\}, double_array =3D= \\{3.25, 5, 6.25, 1.325, -1.95\\}, char_array =3D \"abcde\"\\}" + +gdb_test "p return_large_struct ()" $pattern + +gdb_breakpoint "return_large_struct" +gdb_continue_to_breakpoint "Break in print_large_struct" +gdb_test "finish" $pattern "finish from return_large_struct"