[gcc r14-9424] bitint: Avoid rewriting large/huge _BitInt vars into SSA after bitint lowering [PR114278]

[Jakub Jelinek via Gcc-cvs]

https://gcc.gnu.org/g:dbe5ccda4dbbd064c703cd3ab2a58ea40f08dd1a

commit r14-9424-gdbe5ccda4dbbd064c703cd3ab2a58ea40f08dd1a
Author: Jakub Jelinek <ja...@redhat.com>
Date:   Mon Mar 11 11:00:54 2024 +0100

    bitint: Avoid rewriting large/huge _BitInt vars into SSA after bitint 
lowering [PR114278]
    
    The following testcase ICEs, because update-address-taken subpass of
    fre5 rewrites
      _BitInt(128) b;
      vector(16) unsigned char _3;
    
      <bb 2> [local count: 1073741824]:
      _3 = MEM <vector(16) unsigned char> [(char * {ref-all})p_2(D)];
      MEM <vector(16) unsigned char> [(char * {ref-all})&b] = _3;
      b ={v} {CLOBBER(eos)};
    to
      _BitInt(128) b;
      vector(16) unsigned char _3;
    
      <bb 2> [local count: 1073741824]:
      _3 = MEM <vector(16) unsigned char> [(char * {ref-all})p_2(D)];
      b_5 = VIEW_CONVERT_EXPR<_BitInt(128)>(_3);
    but we can't have large/huge _BitInt vars in SSA form after the bitint
    lowering except for function arguments loaded from memory, as expansion
    isn't able to deal with those, it relies on bitint lowering to lower
    those operations.
    The following patch fixes that by setting DECL_NOT_GIMPLE_REG_P for
    large/huge _BitInt vars after bitint lowering, such that we don't
    rewrite them into SSA form.
    
    2024-03-11  Jakub Jelinek  <ja...@redhat.com>
    
            PR tree-optimization/114278
            * tree-ssa.cc (maybe_optimize_var): If large/huge _BitInt vars are 
no
            longer addressable, set DECL_NOT_GIMPLE_REG_P on them.
    
            * gcc.dg/bitint-99.c: New test.

Diff:
---
 gcc/testsuite/gcc.dg/bitint-99.c | 26 ++++++++++++++++++++++++++
 gcc/tree-ssa.cc                  | 14 ++++++++++++++
 2 files changed, 40 insertions(+)

diff --git a/gcc/testsuite/gcc.dg/bitint-99.c b/gcc/testsuite/gcc.dg/bitint-99.c
new file mode 100644
index 00000000000..a0aa446087d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/bitint-99.c
@@ -0,0 +1,26 @@
+/* PR tree-optimization/114278 */
+/* { dg-do compile { target bitint } } */
+/* { dg-options "-O2 -fno-tree-dce -fno-tree-dse -fno-tree-ccp" } */
+/* { dg-additional-options "-mavx2" { target i?86-*-* x86_64-*-* } } */
+
+void
+foo (void *p)
+{
+  _BitInt(64) b = *(_BitInt(64) *) __builtin_memmove (&b, p, sizeof 
(_BitInt(64)));
+}
+
+#if __BITINT_MAXWIDTH__ >= 128
+void
+bar (void *p)
+{
+  _BitInt(128) b = *(_BitInt(128) *) __builtin_memmove (&b, p, sizeof 
(_BitInt(128)));
+}
+#endif
+
+#if __BITINT_MAXWIDTH__ >= 256
+void
+baz (void *p)
+{
+  _BitInt(256) b = *(_BitInt(256) *) __builtin_memmove (&b, p, sizeof 
(_BitInt(256)));
+}
+#endif
diff --git a/gcc/tree-ssa.cc b/gcc/tree-ssa.cc
index 16f42a6022a..27ab9cfac82 100644
--- a/gcc/tree-ssa.cc
+++ b/gcc/tree-ssa.cc
@@ -1785,6 +1785,20 @@ maybe_optimize_var (tree var, bitmap addresses_taken, 
bitmap not_reg_needs,
              fprintf (dump_file, "\n");
            }
        }
+      else if (TREE_CODE (TREE_TYPE (var)) == BITINT_TYPE
+              && (cfun->curr_properties & PROP_gimple_lbitint) != 0
+              && TYPE_PRECISION (TREE_TYPE (var)) > MAX_FIXED_MODE_SIZE)
+       {
+         /* Don't rewrite large/huge _BitInt vars after _BitInt lowering
+            into SSA form.  */
+         DECL_NOT_GIMPLE_REG_P (var) = 1;
+         if (dump_file)
+           {
+             fprintf (dump_file, "_BitInt var after its lowering: ");
+             print_generic_expr (dump_file, var);
+             fprintf (dump_file, "\n");
+           }
+       }
       else if (DECL_NOT_GIMPLE_REG_P (var))
        {
          maybe_reg = true;