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

PR 17892.
OKed by Roger Sayle.

From-SVN: r88950

4 files changed, 49 insertions, 1 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index a605027..4e3bba7 100644
--- 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
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 827f91d..a99f03d 100644
--- 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 5d545bd..4ab3613 100644
--- 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))
 	    {