[gentoo-commits] proj/gcc-patches:master commit in: 15.0.0/gentoo/

["Sam James" <sam@gentoo.org>]

commit:     deff508dad5c6dc413e6d7e81ac1c3f53c6ecace
Author:     Sam James <sam <AT> gentoo <DOT> org>
AuthorDate: Fri Mar 21 17:20:45 2025 +0000
Commit:     Sam James <sam <AT> gentoo <DOT> org>
CommitDate: Fri Mar 21 17:20:45 2025 +0000
URL:        https://gitweb.gentoo.org/proj/gcc-patches.git/commit/?id=deff508d

15.0.0: update neon miscompilation patch

Signed-off-by: Sam James <sam <AT> gentoo.org>

 15.0.0/gentoo/79_all_PR117811-arm-neon-shift.patch | 172 ++++++++++++++-------
 1 file changed, 119 insertions(+), 53 deletions(-)

diff --git a/15.0.0/gentoo/79_all_PR117811-arm-neon-shift.patch b/15.0.0/gentoo/79_all_PR117811-arm-neon-shift.patch
index f2bb73a..5a78653 100644
--- a/15.0.0/gentoo/79_all_PR117811-arm-neon-shift.patch
+++ b/15.0.0/gentoo/79_all_PR117811-arm-neon-shift.patch
@@ -1,77 +1,146 @@
-https://gcc.gnu.org/bugzilla/show_bug.cgi?id=117811#c20
+https://inbox.sourceware.org/gcc-patches/20250321094756.1044263-1-rearnsha@arm.com/
 
-From 5256e5419d07f7313fe661901b9a4821b3d47764 Mon Sep 17 00:00:00 2001
-From: Andrew Pinski <quic_apinski@quicinc.com>
-Date: Wed, 19 Mar 2025 16:02:12 -0700
-Subject: [PATCH] Fix expand_binop_directly in some cases [PR117811]
+From db60414d7b3f596214547fc9a7c74fcb38248527 Mon Sep 17 00:00:00 2001
+Message-ID: <db60414d7b3f596214547fc9a7c74fcb38248527.1742577601.git.sam@gentoo.org>
+From: Richard Earnshaw <rearnsha@arm.com>
+Date: Fri, 21 Mar 2025 09:47:56 +0000
+Subject: [PATCH] opcodes: fix wrong code in expand_binop_directly [PR117811]
 
-The problem here is that when dealing with adding the equal note,
-we decide to call expand_binop directly but before we do that we
-call delete_insns_since with the last argument. The problem is that
-deletes too much and falls over. So instead we need to delete only
-up to what was done at the point of the call to expand_binop_directly
+If expand_binop_directly fails to add a REG_EQUAL note it tries to
+unwind and restart.  But it can unwind too far if expand_binop changed
+some of the operands before calling it.  We don't need to unwind that
+far anyway since we should end up taking exactly the same route next
+time, just without a target rtx.
 
-Bootstrapped and tested on x86_64-linux-gnu.  Also Christophe Lyon tested
-it on arm-linux-gnueabihf.
-
-	PR middle-end/117811
+To fix this we remove LAST from the argument list and let the callers
+(all in expand_binop) do their own unwinding if the call fails.
+Instead we unwind just as far as the entry to expand_binop_directly
+and recurse within this function instead of all the way back up.
 
 gcc/ChangeLog:
 
-	* optabs.cc (expand_binop_directly): Delete only what was done
-	since the entry before calling expand_binop.
-
-gcc/testsuite/ChangeLog:
+	PR middle-end/117811
+	* optabs.cc (expand_binop_directly): Remove LAST as an argument,
+	instead record the last insn on entry.  Only delete insns if
+	we need to restart and restart by calling ourself, not expand_binop.
+	(expand_binop): Update callers to expand_binop_directly.  If it
+	fails to expand the operation, delete back to LAST.
 
-	* c-c++-common/torture/pr117811-1.c: New test.
+gcc/testsuite:
 
-Signed-off-by: Andrew Pinski <quic_apinski@quicinc.com>
+PR middle-end/117811
+	* gcc.dg/torture/pr117811.c: New test.
 ---
- gcc/optabs.cc                                 |  3 +-
- .../c-c++-common/torture/pr117811-1.c         | 32 +++++++++++++++++++
- 2 files changed, 34 insertions(+), 1 deletion(-)
- create mode 100644 gcc/testsuite/c-c++-common/torture/pr117811-1.c
+ gcc/optabs.cc                           | 24 +++++++++++-----------
+ gcc/testsuite/gcc.dg/torture/pr117811.c | 27 +++++++++++++++++++++++++
+ 2 files changed, 39 insertions(+), 12 deletions(-)
+ create mode 100644 gcc/testsuite/gcc.dg/torture/pr117811.c
 
 diff --git a/gcc/optabs.cc b/gcc/optabs.cc
-index 36f2e6af8b5..366df985147 100644
+index 36f2e6af8b5c..0a14b1eef8a5 100644
 --- a/gcc/optabs.cc
 +++ b/gcc/optabs.cc
-@@ -1380,6 +1380,7 @@ expand_binop_directly (enum insn_code icode, machine_mode mode, optab binoptab,
+@@ -1369,8 +1369,7 @@ avoid_expensive_constant (machine_mode mode, optab binoptab,
+ static rtx
+ expand_binop_directly (enum insn_code icode, machine_mode mode, optab binoptab,
+ 		       rtx op0, rtx op1,
+-		       rtx target, int unsignedp, enum optab_methods methods,
+-		       rtx_insn *last)
++		       rtx target, int unsignedp, enum optab_methods methods)
+ {
+   machine_mode xmode0 = insn_data[(int) icode].operand[1].mode;
+   machine_mode xmode1 = insn_data[(int) icode].operand[2].mode;
+@@ -1380,6 +1379,7 @@ expand_binop_directly (enum insn_code icode, machine_mode mode, optab binoptab,
    rtx_insn *pat;
    rtx xop0 = op0, xop1 = op1;
    bool canonicalize_op1 = false;
-+  rtx_insn *entry_last = get_last_insn ();
++  rtx_insn *last = get_last_insn ();
  
    /* If it is a commutative operator and the modes would match
       if we would swap the operands, we can save the conversions.  */
-@@ -1466,7 +1467,7 @@ expand_binop_directly (enum insn_code icode, machine_mode mode, optab binoptab,
- 			       optab_to_code (binoptab),
+@@ -1444,10 +1444,7 @@ expand_binop_directly (enum insn_code icode, machine_mode mode, optab binoptab,
+       tmp_mode = insn_data[(int) icode].operand[0].mode;
+       if (VECTOR_MODE_P (mode)
+ 	  && maybe_ne (GET_MODE_NUNITS (tmp_mode), 2 * GET_MODE_NUNITS (mode)))
+-	{
+-	  delete_insns_since (last);
+-	  return NULL_RTX;
+-	}
++	return NULL_RTX;
+     }
+   else
+     tmp_mode = mode;
+@@ -1467,14 +1464,14 @@ expand_binop_directly (enum insn_code icode, machine_mode mode, optab binoptab,
  			       ops[1].value, ops[2].value, mode0))
  	{
--	  delete_insns_since (last);
-+	  delete_insns_since (entry_last);
- 	  return expand_binop (mode, binoptab, op0, op1, NULL_RTX,
- 			       unsignedp, methods);
+ 	  delete_insns_since (last);
+-	  return expand_binop (mode, binoptab, op0, op1, NULL_RTX,
+-			       unsignedp, methods);
++	  return expand_binop_directly (icode, mode, binoptab, op0, op1,
++					NULL_RTX, unsignedp, methods);
+ 	}
+ 
+       emit_insn (pat);
+       return ops[0].value;
+     }
+-  delete_insns_since (last);
++
+   return NULL_RTX;
+ }
+ 
+@@ -1543,9 +1540,10 @@ expand_binop (machine_mode mode, optab binoptab, rtx op0, rtx op1,
+       if (icode != CODE_FOR_nothing)
+ 	{
+ 	  temp = expand_binop_directly (icode, mode, binoptab, op0, op1,
+-					target, unsignedp, methods, last);
++					target, unsignedp, methods);
+ 	  if (temp)
+ 	    return temp;
++	  delete_insns_since (last);
+ 	}
+     }
+ 
+@@ -1571,9 +1569,10 @@ expand_binop (machine_mode mode, optab binoptab, rtx op0, rtx op1,
+ 			       NULL_RTX, unsignedp, OPTAB_DIRECT);
+ 
+       temp = expand_binop_directly (icode, int_mode, otheroptab, op0, newop1,
+-				    target, unsignedp, methods, last);
++				    target, unsignedp, methods);
+       if (temp)
+ 	return temp;
++      delete_insns_since (last);
+     }
+ 
+   /* If this is a multiply, see if we can do a widening operation that
+@@ -1637,9 +1636,10 @@ expand_binop (machine_mode mode, optab binoptab, rtx op0, rtx op1,
+ 	  if (vop1)
+ 	    {
+ 	      temp = expand_binop_directly (icode, mode, otheroptab, op0, vop1,
+-					    target, unsignedp, methods, last);
++					    target, unsignedp, methods);
+ 	      if (temp)
+ 		return temp;
++	      delete_insns_since (last);
+ 	    }
  	}
-diff --git a/gcc/testsuite/c-c++-common/torture/pr117811-1.c b/gcc/testsuite/c-c++-common/torture/pr117811-1.c
+     }
+diff --git a/gcc/testsuite/gcc.dg/torture/pr117811.c b/gcc/testsuite/gcc.dg/torture/pr117811.c
 new file mode 100644
-index 00000000000..a0558cbd0ae
+index 000000000000..13d7e1347807
 --- /dev/null
-+++ b/gcc/testsuite/c-c++-common/torture/pr117811-1.c
-@@ -0,0 +1,32 @@
++++ b/gcc/testsuite/gcc.dg/torture/pr117811.c
+@@ -0,0 +1,27 @@
 +/* { dg-do run } */
 +
-+/* PR middle-end/117811 */
-+/* Tests that right shift on vectors work. */
++#include <string.h>
 +
-+typedef int v4 __attribute__((vector_size(4*sizeof(int))));
++typedef int v4 __attribute__((vector_size (4 * sizeof (int))));
 +
-+void buggy_shift( v4 *vec, int shift ) __attribute__((noipa));
-+void buggy_shift( v4 *vec, int shift )
++void __attribute__((noclone,noinline)) do_shift (v4 *vec, int shift)
 +{
 +  v4 t = *vec;
 +
-+  if ( shift > 0 )
++  if (shift > 0)
 +  {
 +    t = t >> shift;
 +  }
@@ -79,18 +148,15 @@ index 00000000000..a0558cbd0ae
 +  *vec = t;
 +}
 +
-+int main()
++int main ()
 +{
-+  v4 v = {0x0<<4, 0x1<<4, 2<<4, 3<<4};
-+  v4 r = {0x0, 0x1, 2, 3};
-+  int shift = 4;
-+  buggy_shift(&v, shift);
-+  for(int i = 0; i < 4; i++)
-+    if (v[i] != r[i])
-+      __builtin_abort();
++  v4 vec =  {0x1000000, 0x2000, 0x300, 0x40};
++  v4 vec2 = {0x100000,  0x200,  0x30,  0x4};
++  do_shift (&vec, 4);
++  if (memcmp (&vec, &vec2, sizeof (v4)) != 0)
++    __builtin_abort ();
 +  return 0;
 +}
-+
 -- 
-2.43.0
+2.49.0