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/[email protected]/ -From 5256e5419d07f7313fe661901b9a4821b3d47764 Mon Sep 17 00:00:00 2001 -From: Andrew Pinski <[email protected]> -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....@gentoo.org> +From: Richard Earnshaw <[email protected]> +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 <[email protected]> +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
