tree-ssa-dom: can_infer_simple_equiv fixes [PR108068]

As reported in the PR, tree-ssa-dom.cc uses real_zerop call to find
if a floating point constant is zero and it shouldn't try to infer
equivalences from comparison against it if signed zeros are honored.
This doesn't work at all for decimal types, because real_zerop always
returns false for them (one can have different representations of decimal
zero beyond -0/+0), and it doesn't work for vector compares either,
as real_zerop checks if all elements are zero, while we need to avoid
infering equivalences from comparison against vector constants which have
at least one zero element in it (if signed zeros are honored).
Furthermore, as mentioned by Joseph, for decimal types many other values
aren't singleton.

So, this patch stops infering anything if element mode is decimal, and
otherwise uses instead of real_zerop a new function, real_maybe_zerop,
which will work even for decimal types and for complex or vector will
return true if any element is or might be zero (so it returns true
for anything but constants for now).

2022-12-23  Jakub Jelinek  <jakub@redhat.com>

	PR tree-optimization/108068
	* tree.h (real_maybe_zerop): Declare.
	* tree.cc (real_maybe_zerop): Define.
	* tree-ssa-dom.cc (record_edge_info): Use it instead of
	real_zerop or TREE_CODE (op1) == SSA_NAME || real_zerop.  Always set
	can_infer_simple_equiv to false for decimal floating point types.

	* gcc.dg/dfp/pr108068.c: New test.

diff --git a/gcc/testsuite/gcc.dg/dfp/pr108068.c b/gcc/testsuite/gcc.dg/dfp/pr108068.c
new file mode 100644 (file)
index 0000000..6cbb0fb
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/dfp/pr108068.c
@@ -0,0 +1,14 @@
+/* PR tree-optimization/108068 */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+int
+main ()
+{
+  _Decimal64 x = -1;
+  while (x != 0)
+    x /= 10;
+  double d = x;
+  if (!__builtin_signbit (d))
+    __builtin_abort ();
+}

diff --git a/gcc/tree-ssa-dom.cc b/gcc/tree-ssa-dom.cc
index c9e52d1ee947959063ecca9c7c12ec1d729ca4ce..76834fdbef4341fb8756e917c4e48a9c0975a63f 100644 (file)
--- a/gcc/tree-ssa-dom.cc
+++ b/gcc/tree-ssa-dom.cc
@@ -615,9 +615,9 @@ record_edge_info (basic_block bb)
             {
               tree cond = build2 (code, boolean_type_node, op0, op1);
               tree inverted = invert_truthvalue_loc (loc, cond);
-              bool can_infer_simple_equiv
-                = !(HONOR_SIGNED_ZEROS (op0)
-                    && real_zerop (op0));
+             bool can_infer_simple_equiv
+               = !(HONOR_SIGNED_ZEROS (op0) && real_maybe_zerop (op0))
+                 && !DECIMAL_FLOAT_MODE_P (element_mode (TREE_TYPE (op0)));
              class edge_info *edge_info;
 
              edge_info = new class edge_info (true_edge);
@@ -639,9 +639,9 @@ record_edge_info (basic_block bb)
             {
               tree cond = build2 (code, boolean_type_node, op0, op1);
               tree inverted = invert_truthvalue_loc (loc, cond);
-              bool can_infer_simple_equiv
-                = !(HONOR_SIGNED_ZEROS (op1)
-                    && (TREE_CODE (op1) == SSA_NAME || real_zerop (op1)));
+             bool can_infer_simple_equiv
+               = !(HONOR_SIGNED_ZEROS (op1) && real_maybe_zerop (op1))
+                 && !DECIMAL_FLOAT_MODE_P (element_mode (TREE_TYPE (op1)));
              class edge_info *edge_info;
 
              edge_info = new class edge_info (true_edge);

diff --git a/gcc/tree.cc b/gcc/tree.cc
index 581d4489438e6ed5ee91e38e5af7d7f3c73278ef..6b3273e8997ffc7d7d42397b68851d142e60dbb7 100644 (file)
--- a/gcc/tree.cc
+++ b/gcc/tree.cc
@@ -3180,6 +3180,35 @@ real_minus_onep (const_tree expr)
     }
 }
 
+/* Return true if T could be a floating point zero.  */
+
+bool
+real_maybe_zerop (const_tree expr)
+{
+  switch (TREE_CODE (expr))
+    {
+    case REAL_CST:
+      /* Can't use real_zerop here, as it always returns false for decimal
+        floats.  And can't use TREE_REAL_CST (expr).cl == rvc_zero
+        either, as decimal zeros are rvc_normal.  */
+      return real_equal (&TREE_REAL_CST (expr), &dconst0);
+    case COMPLEX_CST:
+      return (real_maybe_zerop (TREE_REALPART (expr))
+             || real_maybe_zerop (TREE_IMAGPART (expr)));
+    case VECTOR_CST:
+      {
+       unsigned count = vector_cst_encoded_nelts (expr);
+       for (unsigned int i = 0; i < count; ++i)
+         if (real_maybe_zerop (VECTOR_CST_ENCODED_ELT (expr, i)))
+           return true;
+       return false;
+      }
+    default:
+      /* Perhaps for SSA_NAMEs we could query frange.  */
+      return true;
+    }
+}
+
 /* Nonzero if EXP is a constant or a cast of a constant.  */
 
 bool

diff --git a/gcc/tree.h b/gcc/tree.h
index 64a241f51e238458918e14805c48a23c7b640040..7e26e726bc59a24f4eb95cc851b9eee1e66aee18 100644 (file)
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -5497,6 +5497,7 @@ extern bool needs_to_live_in_memory (const_tree);
 extern tree reconstruct_complex_type (tree, tree);
 extern bool real_onep (const_tree);
 extern bool real_minus_onep (const_tree);
+extern bool real_maybe_zerop (const_tree);
 extern void init_ttree (void);
 extern void build_common_tree_nodes (bool);
 extern void build_common_builtin_nodes (void);