From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2153) id EB0DB386183D; Thu, 15 Feb 2024 08:53:20 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org EB0DB386183D DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1707987200; bh=erG+DVTvcgOcAwaKmTHfTFBO/FSOXnqeI1HRsVrfAAQ=; h=From:To:Subject:Date:From; b=bPrl/9b3Afsq7sPLuwzz+ewmUIglpSd7ZhamwvMjjPvnoUJbJ2OWqQTrMtzQAt0CR BVDOZS+zZwybESuN3wfbXVuQXCPtYtgwlJXeVoMaCzoyHY3Bg5NB//TSky5O/QBXKK iw0gE2Ec5F1i5/Mz7h3voYKDnII/t9Qy/Kbzesuw= MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset="utf-8" From: Jakub Jelinek To: gcc-cvs@gcc.gnu.org Subject: [gcc r14-8995] lower-bitint: Ensure we don't get coalescing ICEs for (ab) SSA_NAMEs used in mul/div/mod [PR113567] X-Act-Checkin: gcc X-Git-Author: Jakub Jelinek X-Git-Refname: refs/heads/master X-Git-Oldrev: 52ac4c6be8664e9dab5b90e7c64df03985791893 X-Git-Newrev: baa40971d1600672f3a1abf688905a70cf655c92 Message-Id: <20240215085320.EB0DB386183D@sourceware.org> Date: Thu, 15 Feb 2024 08:53:20 +0000 (GMT) List-Id: https://gcc.gnu.org/g:baa40971d1600672f3a1abf688905a70cf655c92 commit r14-8995-gbaa40971d1600672f3a1abf688905a70cf655c92 Author: Jakub Jelinek Date: Thu Feb 15 09:52:47 2024 +0100 lower-bitint: Ensure we don't get coalescing ICEs for (ab) SSA_NAMEs used in mul/div/mod [PR113567] The build_bitint_stmt_ssa_conflicts hook has a special case for multiplication, division and modulo, where to ensure there is no overlap between lhs and rhs1/rhs2 arrays we make the lhs conflict with the operands. On the following testcase, we have # a_1(ab) = PHI lab: a_3(ab) = a_1(ab) % 3; before lowering and this special case causes a_3(ab) and a_1(ab) to conflict, but the PHI requires them not to conflict, so we ICE because we can't find some partitioning that will work. The following patch fixes this by special casing such statements before the partitioning, force the inputs of the multiplication/division which have large/huge _BitInt (ab) lhs into new non-(ab) SSA_NAMEs initialized right before the multiplication/division. This allows the partitioning to work then, as it has the possibility to use a different partition for the */% operands. 2024-02-15 Jakub Jelinek PR tree-optimization/113567 * gimple-lower-bitint.cc (gimple_lower_bitint): For large/huge _BitInt multiplication, division or modulo with SSA_NAME_OCCURS_IN_ABNORMAL_PHI lhs and at least one of rhs1 and rhs2 force the affected inputs into a new SSA_NAME. * gcc.dg/bitint-90.c: New test. Diff: --- gcc/gimple-lower-bitint.cc | 41 ++++++++++++++++++++++++++++++++++++++++ gcc/testsuite/gcc.dg/bitint-90.c | 23 ++++++++++++++++++++++ 2 files changed, 64 insertions(+) diff --git a/gcc/gimple-lower-bitint.cc b/gcc/gimple-lower-bitint.cc index 0d132bf7b6c4..13b9b205df79 100644 --- a/gcc/gimple-lower-bitint.cc +++ b/gcc/gimple-lower-bitint.cc @@ -5973,6 +5973,47 @@ gimple_lower_bitint (void) { default: break; + case MULT_EXPR: + case TRUNC_DIV_EXPR: + case TRUNC_MOD_EXPR: + if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (s)) + { + location_t loc = gimple_location (stmt); + gsi = gsi_for_stmt (stmt); + tree rhs1 = gimple_assign_rhs1 (stmt); + tree rhs2 = gimple_assign_rhs2 (stmt); + /* For multiplication and division with (ab) + lhs and one or both operands force the operands + into new SSA_NAMEs to avoid coalescing failures. */ + if (TREE_CODE (rhs1) == SSA_NAME + && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs1)) + { + first_large_huge = 0; + tree t = make_ssa_name (TREE_TYPE (rhs1)); + g = gimple_build_assign (t, SSA_NAME, rhs1); + gsi_insert_before (&gsi, g, GSI_SAME_STMT); + gimple_set_location (g, loc); + gimple_assign_set_rhs1 (stmt, t); + if (rhs1 == rhs2) + { + gimple_assign_set_rhs2 (stmt, t); + rhs2 = t; + } + update_stmt (stmt); + } + if (TREE_CODE (rhs2) == SSA_NAME + && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs2)) + { + first_large_huge = 0; + tree t = make_ssa_name (TREE_TYPE (rhs2)); + g = gimple_build_assign (t, SSA_NAME, rhs2); + gsi_insert_before (&gsi, g, GSI_SAME_STMT); + gimple_set_location (g, loc); + gimple_assign_set_rhs2 (stmt, t); + update_stmt (stmt); + } + } + break; case LROTATE_EXPR: case RROTATE_EXPR: { diff --git a/gcc/testsuite/gcc.dg/bitint-90.c b/gcc/testsuite/gcc.dg/bitint-90.c new file mode 100644 index 000000000000..22df2a5cfba9 --- /dev/null +++ b/gcc/testsuite/gcc.dg/bitint-90.c @@ -0,0 +1,23 @@ +/* PR tree-optimization/113567 */ +/* { dg-do compile { target bitint } } */ +/* { dg-options "-O2" } */ + +#if __BITINT_MAXWIDTH__ >= 129 +_BitInt(129) v; + +void +foo (_BitInt(129) a, int i) +{ + __label__ l1, l2; + i &= 1; + void *p[] = { &&l1, &&l2 }; +l1: + a %= 3; + v = a; + i = !i; + goto *(p[i]); +l2:; +} +#else +int i; +#endif