aarch64: Fix return register handling in untyped_call

While working on another patch, I hit a problem with the aarch64
expansion of untyped_call.  The expander emits the usual:

  (set (mem ...) (reg resN))

instructions to store the result registers to memory, but it didn't
say in RTL where those resN results came from.  This eventually led
to a failure of gcc.dg/torture/stackalign/builtin-return-2.c,
via regrename.

This patch turns the untyped call from a plain call to a call_value,
to represent that the call returns (or might return) a useful value.
The patch also uses a PARALLEL return rtx to represent all the possible
return registers.

gcc/
	* config/aarch64/aarch64.md (untyped_call): Emit a call_value
	rather than a call.  List each possible destination register
	in the call pattern.

1 files changed, 19 insertions, 1 deletions

diff --git a/gcc/config/aarch64/aarch64.md b/gcc/config/aarch64/aarch64.md
index 01cf989..6f7827b 100644
--- a/gcc/config/aarch64/aarch64.md
+++ b/gcc/config/aarch64/aarch64.md
@@ -1170,9 +1170,27 @@
 {
   int i;
 
+  /* Generate a PARALLEL that contains all of the register results.
+     The offsets are somewhat arbitrary, since we don't know the
+     actual return type.  The main thing we need to avoid is having
+     overlapping byte ranges, since those might give the impression
+     that two registers are known to have data in common.  */
+  rtvec rets = rtvec_alloc (XVECLEN (operands[2], 0));
+  poly_int64 offset = 0;
+  for (i = 0; i < XVECLEN (operands[2], 0); i++)
+    {
+      rtx reg = SET_SRC (XVECEXP (operands[2], 0, i));
+      gcc_assert (REG_P (reg));
+      rtx offset_rtx = gen_int_mode (offset, Pmode);
+      rtx piece = gen_rtx_EXPR_LIST (VOIDmode, reg, offset_rtx);
+      RTVEC_ELT (rets, i) = piece;
+      offset += GET_MODE_SIZE (GET_MODE (reg));
+    }
+  rtx ret = gen_rtx_PARALLEL (VOIDmode, rets);
+
   /* Untyped calls always use the default ABI.  It's only possible to use
      ABI variants if we know the type of the target function.  */
-  emit_call_insn (gen_call (operands[0], const0_rtx, const0_rtx));
+  emit_call_insn (gen_call_value (ret, operands[0], const0_rtx, const0_rtx));
 
   for (i = 0; i < XVECLEN (operands[2], 0); i++)
     {