re PR tree-optimization/17892 (gcc-4.0 should not reassociate floating point add...

PR 17892.
OKed by Roger Sayle.

From-SVN: r88950

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index a6050279f9f7ecbe1df751dd85408761e9fb76dd..4e3bba79196f6e40fdfa51d904b2c659139cea1b 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,11 @@
+2004-10-12  Fariborz Jahanian <fjahanian@apple.com>
+
+       PR 17892
+       * tree-ssa-dom.c (unsafe_associative_fp_binop): New function.
+       (simplify_rhs_and_lookup_avail_expr): Disallow associativity
+       and constant folding of floating point MULT_EXPR/PLUS_EXPR 
+       expressions.
+
 2004-10-12  Ulrich Weigand  <uweigand@de.ibm.com>
 
        * config/s390/s390.c (s390_va_start): Use build_va_arg_indirect_ref.

diff --git a/gcc/testsuite/gcc.c-torture/execute/ieee/unsafe-fp-assoc.c b/gcc/testsuite/gcc.c-torture/execute/ieee/unsafe-fp-assoc.c
new file mode 100644 (file)
index 0000000..d67fef0
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/ieee/unsafe-fp-assoc.c
@@ -0,0 +1,19 @@
+#include <float.h>
+
+extern void abort(void);
+
+static const double C = DBL_MAX;
+
+double foo(double x)
+{
+        return ( ( (x * C) * C ) * C);
+}
+
+int main ()
+{
+  double d = foo (0.0);
+  if (d != 0.0)
+   abort ();
+
+  return 0;
+}

diff --git a/gcc/tree-outof-ssa.c b/gcc/tree-outof-ssa.c
index 827f91d151106d7bf86965f0139751e77bce4e42..a99f03d0121aaec630a4d704e433d3efa0226bac 100644 (file)
--- a/gcc/tree-outof-ssa.c
+++ b/gcc/tree-outof-ssa.c
@@ -1634,12 +1634,20 @@ find_replaceable_in_bb (temp_expr_table_p tab, basic_block bb)
   var_map map = tab->map;
   value_expr_p p;
   ssa_op_iter iter;
+  bitmap_iterator bi;
 
   for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
     {
       stmt = bsi_stmt (bsi);
       ann = stmt_ann (stmt);
 
+      if (TREE_CODE (stmt) == ASM_EXPR && ASM_VOLATILE_P (stmt))
+       {
+         /* Volatile ASM_EXPRs kill all current expressions.  */
+         EXECUTE_IF_SET_IN_BITMAP ((tab->partition_in_use), 0, partition, bi)
+           kill_expr (tab, partition, false);
+         continue;
+       }
       /* Determine if this stmt finishes an existing expression.  */
       FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_USE)
        {

diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
index 5d545bd2a26c4d5a2cf7b115abe486eddb4608f7..4ab36138f653c37b2ffaa5e864695ce715703484 100644 (file)
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -266,6 +266,7 @@ static void restore_currdefs_to_original_value (void);
 static void register_definitions_for_stmt (tree);
 static edge single_incoming_edge_ignoring_loop_edges (basic_block);
 static void restore_nonzero_vars_to_original_value (void);
+static inline bool unsafe_associative_fp_binop (tree);
 
 /* Local version of fold that doesn't introduce cruft.  */
 
@@ -1549,6 +1550,18 @@ record_equality (tree x, tree y)
   record_const_or_copy_1 (x, y, prev_x);
 }
 
+/* Return true, if it is ok to do folding of an associative expression.
+   EXP is the tree for the associative expression.  */ 
+
+static inline bool
+unsafe_associative_fp_binop (tree exp)
+{
+  enum tree_code code = TREE_CODE (exp);
+  return !(!flag_unsafe_math_optimizations
+           && (code == MULT_EXPR || code == PLUS_EXPR)
+           && FLOAT_TYPE_P (TREE_TYPE (exp)));
+}
+
 /* STMT is a MODIFY_EXPR for which we were unable to find RHS in the
    hash tables.  Try to simplify the RHS using whatever equivalences
    we may have recorded.
@@ -1608,7 +1621,7 @@ simplify_rhs_and_lookup_avail_expr (struct dom_walk_data *walk_data,
          tree rhs_def_rhs = TREE_OPERAND (rhs_def_stmt, 1);
          enum tree_code rhs_def_code = TREE_CODE (rhs_def_rhs);
 
-         if (rhs_code == rhs_def_code
+         if ((rhs_code == rhs_def_code && unsafe_associative_fp_binop (rhs))
              || (rhs_code == PLUS_EXPR && rhs_def_code == MINUS_EXPR)
              || (rhs_code == MINUS_EXPR && rhs_def_code == PLUS_EXPR))
            {