[gcc r14-5818] lower-bitint: Lower FLOAT_EXPR from BITINT_TYPE INTEGER_CST [PR112679]

[gcc r14-5818] lower-bitint: Lower FLOAT_EXPR from BITINT_TYPE INTEGER_CST [PR112679]

[Jakub Jelinek]

https://gcc.gnu.org/g:31669ec1d01c93fb0a63a7053ad314c17fa5a416

commit r14-5818-g31669ec1d01c93fb0a63a7053ad314c17fa5a416
Author: Jakub Jelinek <jakub@redhat.com>
Date:   Fri Nov 24 11:30:30 2023 +0100

    lower-bitint: Lower FLOAT_EXPR from BITINT_TYPE INTEGER_CST [PR112679]
    
    The bitint lowering pass only does something if it sees BITINT_TYPE (medium,
    large, huge) SSA_NAMEs.  In the past I've already ran into one special case
    where the above doesn't work well, if there is a store of medium/large/huge
    BITINT_TYPE INTEGER_CST into memory, there might not be any BITINT_TYPE
    SSA_NAMEs in the function, yet we need to lower.  This has been solved by
    also checking for SSA_NAME_IS_VIRTUAL_OPERAND if at the vdef there isn't
    such a store (the whole intent is make the pass as cheap as possible in the
    currently very likely case that the IL doesn't have any BITINT_TYPEs at
    all).
    And the following testcase shows a similar problem.  With -frounding-math
    we don't fold some of FLOAT_EXPRs with INTEGER_CST operands, and if those
    INTEGER_CSTs are medium/large/huge BITINT_TYPEs, we need to either cast
    the INTEGER_CST to corresponding INTEGER_TYPE (for medium) or lower to
    internal fn call which is later turned into libgcc call (for large/huge).
    The following patch does that, but of course admittedly this discovery
    of stores and FLOAT_EXPRs means we already look through quite a few
    SSA_NAME_DEF_STMTs even when BITINT_TYPEs never appear.
    
    2023-11-23  Jakub Jelinek  <jakub@redhat.com>
    
            PR middle-end/112679
            * gimple-lower-bitint.cc (gimple_lower_bitint): Also stop first loop on
            floating point SSA_NAME set in FLOAT_EXPR assignment from BITINT_TYPE
            INTEGER_CST.  Set has_large_huge for those if that BITINT_TYPE is large
            or huge.  Set kind to such FLOAT_EXPR assignment rhs1 BITINT_TYPE's kind.
    
            * gcc.dg/bitint-42.c: New test.

Diff:
---
 gcc/gimple-lower-bitint.cc       | 43 ++++++++++++++++++++++++++++++++++++++++
 gcc/testsuite/gcc.dg/bitint-42.c |  9 +++++++++
 2 files changed, 52 insertions(+)

diff --git a/gcc/gimple-lower-bitint.cc b/gcc/gimple-lower-bitint.cc
index 1ec2579282c..5024815ed9d 100644
--- a/gcc/gimple-lower-bitint.cc
+++ b/gcc/gimple-lower-bitint.cc
@@ -5635,6 +5635,21 @@ gimple_lower_bitint (void)
 		break;
 	    }
 	}
+      /* Similarly, e.g. with -frounding-math casts from _BitInt INTEGER_CSTs
+	 to floating point types need to be rewritten.  */
+      else if (SCALAR_FLOAT_TYPE_P (type))
+	{
+	  gimple *g = SSA_NAME_DEF_STMT (s);
+	  if (is_gimple_assign (g) && gimple_assign_rhs_code (g) == FLOAT_EXPR)
+	    {
+	      tree t = gimple_assign_rhs1 (g);
+	      if (TREE_CODE (t) == INTEGER_CST
+		  && TREE_CODE (TREE_TYPE (t)) == BITINT_TYPE
+		  && (bitint_precision_kind (TREE_TYPE (t))
+		      != bitint_prec_small))
+		break;
+	    }
+	}
     }
   if (i == num_ssa_names)
     return 0;
@@ -5855,6 +5870,21 @@ gimple_lower_bitint (void)
 		has_large_huge = true;
 	    }
 	}
+      /* Similarly, e.g. with -frounding-math casts from _BitInt INTEGER_CSTs
+	 to floating point types need to be rewritten.  */
+      else if (SCALAR_FLOAT_TYPE_P (type))
+	{
+	  gimple *g = SSA_NAME_DEF_STMT (s);
+	  if (is_gimple_assign (g) && gimple_assign_rhs_code (g) == FLOAT_EXPR)
+	    {
+	      tree t = gimple_assign_rhs1 (g);
+	      if (TREE_CODE (t) == INTEGER_CST
+		  && TREE_CODE (TREE_TYPE (t)) == BITINT_TYPE
+		  && (bitint_precision_kind (TREE_TYPE (t))
+		      >= bitint_prec_large))
+		has_large_huge = true;
+	    }
+	}
     }
   for (i = first_large_huge; i < num_ssa_names; ++i)
     {
@@ -6186,6 +6216,19 @@ gimple_lower_bitint (void)
 		    kind = this_kind;
 		}
 	    }
+	  if (is_gimple_assign (stmt)
+	      && gimple_assign_rhs_code (stmt) == FLOAT_EXPR)
+	    {
+	      t = gimple_assign_rhs1 (stmt);
+	      if (TREE_CODE (TREE_TYPE (t)) == BITINT_TYPE
+		  && TREE_CODE (t) == INTEGER_CST)
+		{
+		  bitint_prec_kind this_kind
+		    = bitint_precision_kind (TREE_TYPE (t));
+		  if (this_kind > kind)
+		    kind = this_kind;
+		}
+	    }
 	  if (is_gimple_call (stmt))
 	    {
 	      t = gimple_call_lhs (stmt);
diff --git a/gcc/testsuite/gcc.dg/bitint-42.c b/gcc/testsuite/gcc.dg/bitint-42.c
new file mode 100644
index 00000000000..9d3090b1943
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/bitint-42.c
@@ -0,0 +1,9 @@
+/* PR middle-end/112679 */
+/* { dg-do compile { target bitint } } */
+/* { dg-options "-frounding-math" } */
+
+float
+foo (void)
+{
+  return 0x353eab28b46b03ea99b84f9736cd8dbe5e986915a0383c3cb381c0da41e31b3621c75fd53262bfcb1b0e6251dbf00f3988784e29b08b65640c263e4d0959832a20e2ff5245be1e60uwb;
+}