commit: d48b81be598d22b4c80bea061776cb58518b3f58 Author: Sam James <sam <AT> gentoo <DOT> org> AuthorDate: Wed Mar 29 01:50:21 2023 +0000 Commit: Sam James <sam <AT> gentoo <DOT> org> CommitDate: Wed Mar 29 01:50:27 2023 +0000 URL: https://gitweb.gentoo.org/repo/gentoo.git/commit/?id=d48b81be
sys-devel/gcc: backport opencv ICE fix for 13 I've decided that for now I'll just put these temporary already-on-master patches in files/ given I'd have to re-cut the patchset repeatedly otherwise (have to add it, cut a patchset, then delete it from git immediately so 9999 doesn't break, but then I'm in trouble if I want to backport another patch before the next snapshot). Closes: https://bugs.gentoo.org/903505 Signed-off-by: Sam James <sam <AT> gentoo.org> ...R109265_PR109274_PR109325_range_def_chain.patch | 219 +++++++++++++++++++++ sys-devel/gcc/gcc-13.0.1_pre20230326-r1.ebuild | 57 ++++++ 2 files changed, 276 insertions(+) diff --git a/sys-devel/gcc/files/gcc-13.0.1_pre20230326-76_all_all_PR109265_PR109274_PR109325_range_def_chain.patch b/sys-devel/gcc/files/gcc-13.0.1_pre20230326-76_all_all_PR109265_PR109274_PR109325_range_def_chain.patch new file mode 100644 index 000000000000..bd66ce422cff --- /dev/null +++ b/sys-devel/gcc/files/gcc-13.0.1_pre20230326-76_all_all_PR109265_PR109274_PR109325_range_def_chain.patch @@ -0,0 +1,219 @@ +https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109265 +https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109274 +https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109325 +https://bugs.gentoo.org/903505 +https://gcc.gnu.org/git/gitweb.cgi?p=gcc.git;h=dd63bba0c8dc3a6ae06cfdc084bca7c68b8bbd39 + +From dd63bba0c8dc3a6ae06cfdc084bca7c68b8bbd39 Mon Sep 17 00:00:00 2001 +From: Andrew MacLeod <[email protected]> +Date: Fri, 24 Mar 2023 11:21:20 -0400 +Subject: [PATCH] Fix compute_operand when op1 == op2 symbolically. + +First, class value_relation should not sanitize records. just create +what is asked. + +Second., if there is not a relation record, compute_operand was +creating one for op1 == op2 if op1 and op2 were the same symbol. This +is not the correct way to communicate the information, as that record +will continue to be passed along the GORI unwind chain. + +Instead, simply pass that information locally to the opX_range routine +for only the current statement. + + PR tree-optimization/109265 + PR tree-optimization/109274 + gcc/ + * gimple-range-gori.cc (gori_compute::compute_operand_range): Do + not create a relation record is op1 and op2 are the same symbol. + (gori_compute::compute_operand1_range): Pass op1 == op2 to the + handler for this stmt, but create a new record only if this statement + generates a relation based on the ranges. + (gori_compute::compute_operand2_range): Ditto. + * value-relation.h (value_relation::set_relation): Always create the + record that is requested. + + gcc/testsuite/ + * gcc.dg/pr109274.c: New. + * gfortran.dg/pr109265.f90: New. +--- a/gcc/gimple-range-gori.cc ++++ b/gcc/gimple-range-gori.cc +@@ -623,21 +623,6 @@ gori_compute::compute_operand_range (vrange &r, gimple *stmt, + tree op1 = gimple_range_ssa_p (handler.operand1 ()); + tree op2 = gimple_range_ssa_p (handler.operand2 ()); + +- // If there is a relation, use it instead of any passed in. This will allow +- // multiple relations to be processed in compound logicals. +- if (op1 && op2) +- { +- relation_kind k = handler.op1_op2_relation (lhs); +- // If there is no relation, and op1 == op2, create a relation. +- if (!vrel_ptr && k == VREL_VARYING && op1 == op2) +- k = VREL_EQ; +- if (k != VREL_VARYING) +- { +- vrel.set_relation (k, op1, op2); +- vrel_ptr = &vrel; +- } +- } +- + // Handle end of lookup first. + if (op1 == name) + return compute_operand1_range (r, handler, lhs, name, src, vrel_ptr); +@@ -1093,6 +1078,7 @@ gori_compute::compute_operand1_range (vrange &r, + const vrange &lhs, tree name, + fur_source &src, value_relation *rel) + { ++ value_relation local_rel; + gimple *stmt = handler.stmt (); + tree op1 = handler.operand1 (); + tree op2 = handler.operand2 (); +@@ -1101,6 +1087,7 @@ gori_compute::compute_operand1_range (vrange &r, + relation_trio trio; + if (rel) + trio = rel->create_trio (lhs_name, op1, op2); ++ relation_kind op_op = trio.op1_op2 (); + + Value_Range op1_range (TREE_TYPE (op1)); + Value_Range tmp (TREE_TYPE (op1)); +@@ -1113,10 +1100,26 @@ gori_compute::compute_operand1_range (vrange &r, + if (op2) + { + src.get_operand (op2_range, op2); +- relation_kind op_op = trio.op1_op2 (); ++ ++ // If there is a relation betwen op1 and op2, use it instead. ++ // This allows multiple relations to be processed in compound logicals. ++ if (gimple_range_ssa_p (op1) && gimple_range_ssa_p (op2)) ++ { ++ relation_kind k = handler.op1_op2_relation (lhs); ++ if (k != VREL_VARYING) ++ { ++ op_op = k; ++ local_rel.set_relation (op_op, op1, op2); ++ rel = &local_rel; ++ } ++ } ++ + if (op_op != VREL_VARYING) + refine_using_relation (op1, op1_range, op2, op2_range, src, op_op); + ++ // If op1 == op2, create a new trio for just this call. ++ if (op1 == op2 && gimple_range_ssa_p (op1)) ++ trio = relation_trio (trio.lhs_op1 (), trio.lhs_op2 (), VREL_EQ); + if (!handler.calc_op1 (tmp, lhs, op2_range, trio)) + return false; + } +@@ -1185,6 +1188,7 @@ gori_compute::compute_operand2_range (vrange &r, + const vrange &lhs, tree name, + fur_source &src, value_relation *rel) + { ++ value_relation local_rel; + gimple *stmt = handler.stmt (); + tree op1 = handler.operand1 (); + tree op2 = handler.operand2 (); +@@ -1201,9 +1205,26 @@ gori_compute::compute_operand2_range (vrange &r, + if (rel) + trio = rel->create_trio (lhs_name, op1, op2); + relation_kind op_op = trio.op1_op2 (); ++ ++ // If there is a relation betwen op1 and op2, use it instead. ++ // This allows multiple relations to be processed in compound logicals. ++ if (gimple_range_ssa_p (op1) && gimple_range_ssa_p (op2)) ++ { ++ relation_kind k = handler.op1_op2_relation (lhs); ++ if (k != VREL_VARYING) ++ { ++ op_op = k; ++ local_rel.set_relation (op_op, op1, op2); ++ rel = &local_rel; ++ } ++ } ++ + if (op_op != VREL_VARYING) + refine_using_relation (op1, op1_range, op2, op2_range, src, op_op); + ++ // If op1 == op2, create a new trio for this stmt. ++ if (op1 == op2 && gimple_range_ssa_p (op1)) ++ trio = relation_trio (trio.lhs_op1 (), trio.lhs_op2 (), VREL_EQ); + // Intersect with range for op2 based on lhs and op1. + if (!handler.calc_op2 (tmp, lhs, op1_range, trio)) + return false; +--- /dev/null ++++ b/gcc/testsuite/gcc.dg/pr109274.c +@@ -0,0 +1,16 @@ ++/* PR tree-optimization/109274 */ ++/* { dg-do compile } */ ++/* { dg-options "-O2 " } */ ++ ++float a, b, c; ++int d; ++float bar (void); ++ ++void ++foo (void) ++{ ++ a = 0 * -(2.0f * c); ++ d = a != a ? 0 : bar (); ++ b = c; ++} ++ +--- /dev/null ++++ b/gcc/testsuite/gfortran.dg/pr109265.f90 +@@ -0,0 +1,39 @@ ++! PR tree-optimization/109265 ++! { dg-do compile } ++! { dg-options "-O3 -w" } ++ ++module pr109265 ++ integer, parameter :: r8 = selected_real_kind (12) ++contains ++ subroutine foo (b, c, d, e, f) ++ implicit none ++ logical :: b ++ real (kind = r8) :: c, d, e, f, i ++ if (b) then ++ c = bar (c * d, e) ++ i = bar (f, c) ++ call baz (i) ++ call baz (-i) ++ end if ++ end subroutine foo ++ function bar (a, b) ++ implicit none ++ real (kind = r8) :: bar ++ real (kind = r8) :: a, b ++ bar = a + b ++ end function bar ++ subroutine baz (b) ++ implicit none ++ real (kind = r8) :: b, d, e, f, g, h, i ++ d = b ++ i = 0 ++ e = d ++ f = d ++ g = d ++ 10 continue ++ if ((e.eq.d) .and. (f.eq.d) .and. (g.eq.d) .and. (h.eq.d)) then ++ h = i ++ goto 10 ++ end if ++ end subroutine baz ++end module pr109265 +--- a/gcc/value-relation.h ++++ b/gcc/value-relation.h +@@ -445,13 +445,6 @@ value_relation::set_relation (relation_kind r, tree n1, tree n2) + { + gcc_checking_assert (TREE_CODE (n1) == SSA_NAME + && TREE_CODE (n2) == SSA_NAME); +- if (n1 == n2 && r != VREL_EQ) +- { +- related = VREL_VARYING; +- name1 = NULL_TREE; +- name2 = NULL_TREE; +- return; +- } + related = r; + name1 = n1; + name2 = n2; +-- +2.31.1 diff --git a/sys-devel/gcc/gcc-13.0.1_pre20230326-r1.ebuild b/sys-devel/gcc/gcc-13.0.1_pre20230326-r1.ebuild new file mode 100644 index 000000000000..f3595ae7bc43 --- /dev/null +++ b/sys-devel/gcc/gcc-13.0.1_pre20230326-r1.ebuild @@ -0,0 +1,57 @@ +# Copyright 1999-2023 Gentoo Authors +# Distributed under the terms of the GNU General Public License v2 + +EAPI=8 + +TOOLCHAIN_PATCH_DEV="sam" +PATCH_VER="9" +PATCH_GCC_VER="13.1.0" +MUSL_VER="1" +MUSL_GCC_VER="13.1.0" + +if [[ $(ver_cut 3) == 9999 ]] ; then + MY_PV_2=$(ver_cut 2) + MY_PV_3=$(($(ver_cut 3) - 9998)) + if [[ ${MY_PV_2} == 0 ]] ; then + MY_PV_2=0 + MY_PV_3=0 + else + MY_PV_2=$(($(ver_cut 2) - 1)) + fi + + # e.g. 12.2.9999 -> 12.1.1 + TOOLCHAIN_GCC_PV=$(ver_cut 1).${MY_PV_2}.${MY_PV_3} +fi + +inherit toolchain +# Needs to be after inherit (for now?), bug #830908 +EGIT_BRANCH=master + +# Don't keyword live ebuilds +if ! tc_is_live && [[ -z ${TOOLCHAIN_USE_GIT_PATCHES} ]] ; then +# KEYWORDS="~alpha ~amd64 ~arm ~arm64 ~hppa ~ia64 ~loong ~m68k ~mips ~ppc ~ppc64 ~riscv ~s390 ~sparc ~x86" + KEYWORDS="~loong" +fi + +if [[ ${CATEGORY} != cross-* ]] ; then + # Technically only if USE=hardened *too* right now, but no point in complicating it further. + # If GCC is enabling CET by default, we need glibc to be built with support for it. + # bug #830454 + RDEPEND="elibc_glibc? ( sys-libs/glibc[cet(-)?] )" + DEPEND="${RDEPEND}" + BDEPEND=">=${CATEGORY}/binutils-2.30[cet(-)?]" +fi + +src_prepare() { + local p upstreamed_patches=( + # add them here + ) + for p in "${upstreamed_patches[@]}"; do + rm -v "${WORKDIR}/patch/${p}" || die + done + + toolchain_src_prepare + + eapply "${FILESDIR}"/${P}-76_all_all_PR109265_PR109274_PR109325_range_def_chain.patch + eapply_user +}
