fold-const.c (fold): Reassociate also (x - mult) + mult and (mult - x) + mult.

	* fold-const.c (fold): Reassociate also (x - mult) + mult and
	(mult - x) + mult.  Cast operands of expression after applying
	distributive law to the correct types.  Apply distributive law
	to a * c - b * c for all non-float types.

From-SVN: r90000

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 51cf826969409f8346389afd17323fcf4652cbbd..f1234bacec6a7ebed651b67def7aaac38d098578 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,10 @@
+2004-11-02  Zdenek Dvorak  <dvorakz@suse.cz>
+
+       * fold-const.c (fold): Reassociate also (x - mult) + mult and
+       (mult - x) + mult.  Cast operands of expression after applying
+       distributive law to the correct types.  Apply distributive law
+       to a * c - b * c for all non-float types.
+
 2004-11-02  Geoffrey Keating  <geoffk@apple.com>
 
        * configure.ac: Don't clear STMP_FIXINC or STMP_FIXPROTO just

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 00892f4abb027ec46505abc352e571be18cea88f..01054d192bd9821400ef6347c81ea23e2118f24f 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -6586,17 +6586,21 @@ fold (tree expr)
          /* Reassociate (plus (plus (mult) (foo)) (mult)) as
             (plus (plus (mult) (mult)) (foo)) so that we can
             take advantage of the factoring cases below.  */
-         if ((TREE_CODE (arg0) == PLUS_EXPR
+         if (((TREE_CODE (arg0) == PLUS_EXPR
+               || TREE_CODE (arg0) == MINUS_EXPR)
               && TREE_CODE (arg1) == MULT_EXPR)
-             || (TREE_CODE (arg1) == PLUS_EXPR
+             || ((TREE_CODE (arg1) == PLUS_EXPR
+                  || TREE_CODE (arg1) == MINUS_EXPR)
                  && TREE_CODE (arg0) == MULT_EXPR))
            {
              tree parg0, parg1, parg, marg;
+             enum tree_code pcode;
 
-             if (TREE_CODE (arg0) == PLUS_EXPR)
+             if (TREE_CODE (arg1) == MULT_EXPR)
                parg = arg0, marg = arg1;
              else
                parg = arg1, marg = arg0;
+             pcode = TREE_CODE (parg);
              parg0 = TREE_OPERAND (parg, 0);
              parg1 = TREE_OPERAND (parg, 1);
              STRIP_NOPS (parg0);
@@ -6604,7 +6608,7 @@ fold (tree expr)
 
              if (TREE_CODE (parg0) == MULT_EXPR
                  && TREE_CODE (parg1) != MULT_EXPR)
-               return fold (build2 (PLUS_EXPR, type,
+               return fold (build2 (pcode, type,
                                     fold (build2 (PLUS_EXPR, type,
                                                   fold_convert (type, parg0),
                                                   fold_convert (type, marg))),
@@ -6612,10 +6616,11 @@ fold (tree expr)
              if (TREE_CODE (parg0) != MULT_EXPR
                  && TREE_CODE (parg1) == MULT_EXPR)
                return fold (build2 (PLUS_EXPR, type,
-                                    fold (build2 (PLUS_EXPR, type,
-                                                  fold_convert (type, parg1),
-                                                  fold_convert (type, marg))),
-                                    fold_convert (type, parg0)));
+                                    fold_convert (type, parg0),
+                                    fold (build2 (pcode, type,
+                                                  fold_convert (type, marg),
+                                                  fold_convert (type,
+                                                                parg1)))));
            }
 
          if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR)
@@ -6677,7 +6682,8 @@ fold (tree expr)
              if (same)
                return fold (build2 (MULT_EXPR, type,
                                     fold (build2 (PLUS_EXPR, type,
-                                                  alt0, alt1)),
+                                                  fold_convert (type, alt0),
+                                                  fold_convert (type, alt1))),
                                     same));
            }
 
@@ -7084,7 +7090,7 @@ fold (tree expr)
 
       if (TREE_CODE (arg0) == MULT_EXPR
          && TREE_CODE (arg1) == MULT_EXPR
-         && (INTEGRAL_TYPE_P (type) || flag_unsafe_math_optimizations))
+         && (!FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations))
        {
           /* (A * C) - (B * C) -> (A-B) * C.  */
          if (operand_equal_p (TREE_OPERAND (arg0, 1),