fold_real_zero_addition_p for vectors

Message ID alpine.DEB.2.02.1906082227520.18468@grove.saclay.inria.fr
State New
Headers show
Series
  • fold_real_zero_addition_p for vectors
Related show

Commit Message

Marc Glisse June 8, 2019, 8:44 p.m.
Hello,

this small tweak of fold_real_zero_addition_p lets it handle vectors as 
well.

Bootstrap and regtest on x86_64-pc-linux-gnu.

2019-06-10  Marc Glisse  <marc.glisse@inria.fr>

 	PR tree-optimization/62041
 	* fold-const.c (fold_real_zero_addition_p): Handle vectors.

-- 
Marc Glisse

Comments

Richard Biener June 11, 2019, 12:37 p.m. | #1
On Sat, Jun 8, 2019 at 10:44 PM Marc Glisse <marc.glisse@inria.fr> wrote:
>

> Hello,

>

> this small tweak of fold_real_zero_addition_p lets it handle vectors as

> well.

>

> Bootstrap and regtest on x86_64-pc-linux-gnu.


OK.

Thanks,
Richard.

> 2019-06-10  Marc Glisse  <marc.glisse@inria.fr>

>

>         PR tree-optimization/62041

>         * fold-const.c (fold_real_zero_addition_p): Handle vectors.

>

> --

> Marc Glisse

Patch

Index: gcc/fold-const.c
===================================================================
--- gcc/fold-const.c	(revision 272076)
+++ gcc/fold-const.c	(working copy)
@@ -6715,40 +6715,45 @@  fold_binary_op_with_conditional_arg (loc
    X - 0 is not the same as X because 0 - 0 is -0.  In other rounding
    modes, X + 0 is not the same as X because -0 + 0 is 0.  */
 
 bool
 fold_real_zero_addition_p (const_tree type, const_tree addend, int negate)
 {
   if (!real_zerop (addend))
     return false;
 
   /* Don't allow the fold with -fsignaling-nans.  */
-  if (HONOR_SNANS (element_mode (type)))
+  if (HONOR_SNANS (type))
     return false;
 
   /* Allow the fold if zeros aren't signed, or their sign isn't important.  */
-  if (!HONOR_SIGNED_ZEROS (element_mode (type)))
+  if (!HONOR_SIGNED_ZEROS (type))
     return true;
 
+  /* There is no case that is safe for all rounding modes.  */
+  if (HONOR_SIGN_DEPENDENT_ROUNDING (type))
+    return false;
+
   /* In a vector or complex, we would need to check the sign of all zeros.  */
-  if (TREE_CODE (addend) != REAL_CST)
+  if (TREE_CODE (addend) == VECTOR_CST)
+    addend = uniform_vector_p (addend);
+  if (!addend || TREE_CODE (addend) != REAL_CST)
     return false;
 
   /* Treat x + -0 as x - 0 and x - -0 as x + 0.  */
   if (REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend)))
     negate = !negate;
 
   /* The mode has signed zeros, and we have to honor their sign.
      In this situation, there is only one case we can return true for.
-     X - 0 is the same as X unless rounding towards -infinity is
-     supported.  */
-  return negate && !HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type));
+     X - 0 is the same as X with default rounding.  */
+  return negate;
 }
 
 /* Subroutine of match.pd that optimizes comparisons of a division by
    a nonzero integer constant against an integer constant, i.e.
    X/C1 op C2.
 
    CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
    GE_EXPR or LE_EXPR.  ARG01 and ARG1 must be a INTEGER_CST.  */
 
 enum tree_code