RISC-V: PR27925 Add support for LP64 and LP64F ABIs return values

The RISC-V Linux kernel is compiled without floating point (the LP64
ABI) and elfutils could not obtain return value locations for
functions in the kernel.  This issue was noticed when Systemtap
generated RISC-V kernel modules for scripts that used $return target
variables in function return probes. This patch adds the needed
support to provide return value information for the LP64 and LP64F
ABIs.

Signed-off-by: William Cohen <wcohen@redhat.com>

diff --git a/backends/ChangeLog b/backends/ChangeLog
index ac0e3187984aa9f1c38aa1788c921a678582fa0a..b48af4e18cf75235f953a57c63a3b242e6593317 100644 (file)
--- a/backends/ChangeLog
+++ b/backends/ChangeLog
@@ -1,3 +1,16 @@
+2021-09-29  William Cohen  <wcohen@redhat.com>
+
+       * riscv_init.c (riscv_return_value_location_lp64f): New function
+       declaration.
+       (riscv_return_value_location_lp64): Likewise.
+       (riscv_init): Set return_value_location based on elf class and
+       ehdr flags.
+       * riscv_retval.c (riscv_return_value_location_lp64d): Renamed to...
+       (riscv_return_value_location_lp64ifd): ...this. Handle single,
+       double, float _Complex and double _Complex cases.
+       (riscv_return_value_location_lp64d): New function.
+       (riscv_return_value_location_lp64f): Likewise.
+
 2021-04-19  Martin Liska  <mliska@suse.cz>
 
        * aarch64_symbol.c (aarch64_data_marker_symbol): Use startswith.

diff --git a/backends/riscv_init.c b/backends/riscv_init.c
index 551e7bb6d34942222a1627e98de91208ef8261af..141e0821718834fe004621613f2b6f9f10d918ad 100644 (file)
--- a/backends/riscv_init.c
+++ b/backends/riscv_init.c
@@ -41,6 +41,12 @@
 extern __typeof (EBLHOOK (return_value_location))
   riscv_return_value_location_lp64d attribute_hidden;
 
+extern __typeof (EBLHOOK (return_value_location))
+    riscv_return_value_location_lp64f attribute_hidden;
+
+extern __typeof (EBLHOOK (return_value_location))
+    riscv_return_value_location_lp64 attribute_hidden;
+
 extern __typeof (EBLHOOK (core_note)) riscv64_core_note attribute_hidden;
 
 Ebl *
@@ -63,10 +69,17 @@ riscv_init (Elf *elf,
     eh->core_note = riscv64_core_note;
   else
     HOOK (eh, core_note);
-  if (eh->class == ELFCLASS64
-      && ((elf->state.elf64.ehdr->e_flags & EF_RISCV_FLOAT_ABI)
-         == EF_RISCV_FLOAT_ABI_DOUBLE))
-    eh->return_value_location = riscv_return_value_location_lp64d;
+  if (eh->class == ELFCLASS64)
+    {
+      if ((elf->state.elf64.ehdr->e_flags & EF_RISCV_FLOAT_ABI)
+          == EF_RISCV_FLOAT_ABI_DOUBLE)
+        eh->return_value_location = riscv_return_value_location_lp64d;
+      else if ((elf->state.elf64.ehdr->e_flags & EF_RISCV_FLOAT_ABI)
+               == EF_RISCV_FLOAT_ABI_SINGLE)
+        eh->return_value_location = riscv_return_value_location_lp64f;
+      else
+        eh->return_value_location = riscv_return_value_location_lp64;
+    }
 
   return eh;
 }

diff --git a/backends/riscv_retval.c b/backends/riscv_retval.c
index 35b6010bf3e3aeaa84eb9fb5f6ef0ece90960d15..347614862f1bb643acccc69905ee1ac8c7debf9a 100644 (file)
--- a/backends/riscv_retval.c
+++ b/backends/riscv_retval.c
@@ -125,8 +125,8 @@ pass_by_flattened_arg (const Dwarf_Op **locp __attribute__ ((unused)),
 }
 
 int
-riscv_return_value_location_lp64d (Dwarf_Die *functypedie,
-                                  const Dwarf_Op **locp)
+riscv_return_value_location_lp64ifd (int fp, Dwarf_Die *functypedie,
+                                     const Dwarf_Op **locp)
 {
   /* Start with the function's type, and get the DW_AT_type attribute,
      which is the type of the return value.  */
@@ -211,10 +211,29 @@ riscv_return_value_location_lp64d (Dwarf_Die *functypedie,
              switch (size)
                {
                case 4: /* single */
-               case 8: /* double */
-                 return pass_in_fpr_lp64d (locp, size);
-
-               case 16: /* quad */
+                  switch (fp)
+                    {
+                    case EF_RISCV_FLOAT_ABI_DOUBLE:
+                    case EF_RISCV_FLOAT_ABI_SINGLE:
+                      return pass_in_fpr_lp64d (locp, size);
+                    case EF_RISCV_FLOAT_ABI_SOFT:
+                      return pass_in_gpr_lp64 (locp, size);
+                    default:
+                      return -2;
+                    }
+                case 8: /* double */
+                  switch (fp)
+                    {
+                    case EF_RISCV_FLOAT_ABI_DOUBLE:
+                      return pass_in_fpr_lp64d (locp, size);
+                    case EF_RISCV_FLOAT_ABI_SINGLE:
+                    case EF_RISCV_FLOAT_ABI_SOFT:
+                      return pass_in_gpr_lp64 (locp, size);
+                    default:
+                      return -2;
+                    }
+
+                case 16: /* quad */
                  return pass_in_gpr_lp64 (locp, size);
 
                default:
@@ -227,12 +246,31 @@ riscv_return_value_location_lp64d (Dwarf_Die *functypedie,
              switch (size)
                {
                case 8: /* float _Complex */
-                 return pass_in_fpr_lp64f (locp, size);
-
-               case 16: /* double _Complex */
-                 return pass_in_fpr_lp64d (locp, size);
-
-               case 32: /* long double _Complex */
+                  switch (fp)
+                    {
+                    case EF_RISCV_FLOAT_ABI_DOUBLE:
+                    case EF_RISCV_FLOAT_ABI_SINGLE:
+                      return pass_in_fpr_lp64f (locp, size);
+                    case EF_RISCV_FLOAT_ABI_SOFT:
+                      /* Double the size so the vals are two registers. */
+                      return pass_in_gpr_lp64 (locp, size * 2);
+                    default:
+                      return -2;
+                    }
+
+                case 16: /* double _Complex */
+                  switch (fp)
+                    {
+                    case EF_RISCV_FLOAT_ABI_DOUBLE:
+                      return pass_in_fpr_lp64d (locp, size);
+                    case EF_RISCV_FLOAT_ABI_SINGLE:
+                    case EF_RISCV_FLOAT_ABI_SOFT:
+                      return pass_in_gpr_lp64 (locp, size);
+                    default:
+                      return -2;
+                    }
+
+                case 32: /* long double _Complex */
                  return pass_by_ref (locp);
 
                default:
@@ -249,3 +287,27 @@ riscv_return_value_location_lp64d (Dwarf_Die *functypedie,
   *locp = NULL;
   return 0;
 }
+
+int
+riscv_return_value_location_lp64d (Dwarf_Die *functypedie,
+                                   const Dwarf_Op **locp)
+{
+  return riscv_return_value_location_lp64ifd (EF_RISCV_FLOAT_ABI_DOUBLE,
+                                              functypedie, locp);
+}
+
+int
+riscv_return_value_location_lp64f (Dwarf_Die *functypedie,
+                                   const Dwarf_Op **locp)
+{
+  return riscv_return_value_location_lp64ifd (EF_RISCV_FLOAT_ABI_SINGLE,
+                                              functypedie, locp);
+}
+
+int
+riscv_return_value_location_lp64 (Dwarf_Die *functypedie,
+                                  const Dwarf_Op **locp)
+{
+  return riscv_return_value_location_lp64ifd (EF_RISCV_FLOAT_ABI_SOFT,
+                                              functypedie, locp);
+}