2015-10-20 Richard Biener <rguenther@suse.de>

	    Naveen H.S  <Naveen.Hurugalawadi@caviumnetworks.com>

	* fold-const.c (fold_binary_loc) : Move (-A) * (-B) -> A * B
	to match.pd.
	Move (a * (1 << b)) is (a << b) to match.pd.
	Move convert (C1/X)*C2 into (C1*C2)/X to match.pd.
	Move ~X & X, (X == 0) & X, and !X & X are zero to match.pd.
	Move X & ~X , X & (X == 0), and X & !X are zero to match.pd.

	* match.pd (mult:c @0 (convert? (lshift integer_onep@1 @2))):
	New simplifier.
	(mult (rdiv:s REAL_CST@0 @1) REAL_CST@2): New simplifier.
	(bit_and:c (convert? @0) (convert? (bit_not @0))): New simplifier.
	(bit_ior (bit_and:s @0 (bit_not:s @1)) (bit_and:s (bit_not:s @0) @1))
	: New simplifier.
	(mult:c (convert1? (negate @0)) (convert2? negate_expr_p@1)):
	New simplifier.
	(match (logical_inverted_value @0) (truth_not @0)) : New Predicate.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@229107 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 77f659b..1c80d94 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,23 @@
+2015-10-21  Richard Biener  <rguenther@suse.de>
+           Naveen H.S  <Naveen.Hurugalawadi@caviumnetworks.com>
+
+       * fold-const.c (fold_binary_loc) : Move (-A) * (-B) -> A * B
+       to match.pd.
+       Move (a * (1 << b)) is (a << b) to match.pd.
+       Move convert (C1/X)*C2 into (C1*C2)/X to match.pd.
+       Move ~X & X, (X == 0) & X, and !X & X are zero to match.pd.
+       Move X & ~X , X & (X == 0), and X & !X are zero to match.pd.
+
+       * match.pd (mult:c @0 (convert? (lshift integer_onep@1 @2))):
+       New simplifier.
+       (mult (rdiv:s REAL_CST@0 @1) REAL_CST@2): New simplifier.
+       (bit_and:c (convert? @0) (convert? (bit_not @0))): New simplifier.
+       (bit_ior (bit_and:s @0 (bit_not:s @1)) (bit_and:s (bit_not:s @0) @1))
+       : New simplifier.
+       (mult:c (convert1? (negate @0)) (convert2? negate_expr_p@1)):
+       New simplifier.
+       (match (logical_inverted_value @0) (truth_not @0)) : New Predicate.
+
 2015-10-21  Gregor Richards  <gregor.richards@uwaterloo.ca>
            Szabolcs Nagy  <szabolcs.nagy@arm.com>
            Alan Modra  <amodra@gmail.com>

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index de45a2c..1e7fbb4 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -9803,20 +9803,6 @@ fold_binary_loc (location_t loc,
       goto associate;
 
     case MULT_EXPR:
-      /* (-A) * (-B) -> A * B  */
-      if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
-       return fold_build2_loc (loc, MULT_EXPR, type,
-                           fold_convert_loc (loc, type,
-                                             TREE_OPERAND (arg0, 0)),
-                           fold_convert_loc (loc, type,
-                                             negate_expr (arg1)));
-      if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
-       return fold_build2_loc (loc, MULT_EXPR, type,
-                           fold_convert_loc (loc, type,
-                                             negate_expr (arg0)),
-                           fold_convert_loc (loc, type,
-                                             TREE_OPERAND (arg1, 0)));
-
       if (! FLOAT_TYPE_P (type))
        {
          /* Transform x * -C into -x * C if x is easily negatable.  */
@@ -9830,16 +9816,6 @@ fold_binary_loc (location_t loc,
                                                  negate_expr (arg0)),
                                tem);
 
-         /* (a * (1 << b)) is (a << b)  */
-         if (TREE_CODE (arg1) == LSHIFT_EXPR
-             && integer_onep (TREE_OPERAND (arg1, 0)))
-           return fold_build2_loc (loc, LSHIFT_EXPR, type, op0,
-                               TREE_OPERAND (arg1, 1));
-         if (TREE_CODE (arg0) == LSHIFT_EXPR
-             && integer_onep (TREE_OPERAND (arg0, 0)))
-           return fold_build2_loc (loc, LSHIFT_EXPR, type, op1,
-                               TREE_OPERAND (arg0, 1));
-
          /* (A + A) * C -> A * 2 * C  */
          if (TREE_CODE (arg0) == PLUS_EXPR
              && TREE_CODE (arg1) == INTEGER_CST
@@ -9882,21 +9858,6 @@ fold_binary_loc (location_t loc,
        }
       else
        {
-         /* Convert (C1/X)*C2 into (C1*C2)/X.  This transformation may change
-             the result for floating point types due to rounding so it is applied
-             only if -fassociative-math was specify.  */
-         if (flag_associative_math
-             && TREE_CODE (arg0) == RDIV_EXPR
-             && TREE_CODE (arg1) == REAL_CST
-             && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST)
-           {
-             tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
-                                     arg1);
-             if (tem)
-               return fold_build2_loc (loc, RDIV_EXPR, type, tem,
-                                   TREE_OPERAND (arg0, 1));
-           }
-
           /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y.  */
          if (operand_equal_p (arg0, arg1, 0))
            {
@@ -10053,22 +10014,6 @@ fold_binary_loc (location_t loc,
       goto bit_rotate;
 
     case BIT_AND_EXPR:
-      /* ~X & X, (X == 0) & X, and !X & X are always zero.  */
-      if ((TREE_CODE (arg0) == BIT_NOT_EXPR
-          || TREE_CODE (arg0) == TRUTH_NOT_EXPR
-          || (TREE_CODE (arg0) == EQ_EXPR
-              && integer_zerop (TREE_OPERAND (arg0, 1))))
-         && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
-       return omit_one_operand_loc (loc, type, integer_zero_node, arg1);
-
-      /* X & ~X , X & (X == 0), and X & !X are always zero.  */
-      if ((TREE_CODE (arg1) == BIT_NOT_EXPR
-          || TREE_CODE (arg1) == TRUTH_NOT_EXPR
-          || (TREE_CODE (arg1) == EQ_EXPR
-              && integer_zerop (TREE_OPERAND (arg1, 1))))
-         && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
-       return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
-
       /* Fold (X ^ 1) & 1 as (X & 1) == 0.  */
       if (TREE_CODE (arg0) == BIT_XOR_EXPR
          && INTEGRAL_TYPE_P (type)

diff --git a/gcc/match.pd b/gcc/match.pd
index 98f4b2c..83dc7ad 100644 (file)
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -325,6 +325,27 @@ along with GCC; see the file COPYING3.  If not see
     (if (real_isinteger (&TREE_REAL_CST (@1), &n) && (n & 1) == 0)
      (pows @0 @1))))))
 
+/* Fold (a * (1 << b)) into (a << b)  */
+(simplify
+ (mult:c @0 (convert? (lshift integer_onep@1 @2)))
+  (if (! FLOAT_TYPE_P (type)
+       && tree_nop_conversion_p (type, TREE_TYPE (@1)))
+   (lshift @0 @2)))
+
+/* Fold (C1/X)*C2 into (C1*C2)/X.  */
+(simplify
+ (mult (rdiv:s REAL_CST@0 @1) REAL_CST@2)
+  (if (flag_associative_math)
+   (with
+    { tree tem = const_binop (MULT_EXPR, type, @0, @2); }
+    (if (tem)
+     (rdiv { tem; } @1)))))
+
+/* Simplify ~X & X as zero.  */
+(simplify
+ (bit_and:c (convert? @0) (convert? (bit_not @0)))
+  { build_zero_cst (type); })
+
 /* X % Y is smaller than Y.  */
 (for cmp (lt ge)
  (simplify
@@ -544,6 +565,13 @@ along with GCC; see the file COPYING3.  If not see
 (match negate_expr_p
  VECTOR_CST
  (if (FLOAT_TYPE_P (TREE_TYPE (type)) || TYPE_OVERFLOW_WRAPS (type))))
+
+/* (-A) * (-B) -> A * B  */
+(simplify
+ (mult:c (convert1? (negate @0)) (convert2? negate_expr_p@1))
+  (if (tree_nop_conversion_p (type, TREE_TYPE (@0))
+       && tree_nop_conversion_p (type, TREE_TYPE (@1)))
+   (mult (convert @0) (convert (negate @1)))))
  
 /* -(A + B) -> (-B) - A.  */
 (simplify
@@ -630,6 +658,8 @@ along with GCC; see the file COPYING3.  If not see
   (truth_not @0))
 
 (match (logical_inverted_value @0)
+ (truth_not @0))
+(match (logical_inverted_value @0)
  (bit_not truth_valued_p@0))
 (match (logical_inverted_value @0)
  (eq @0 integer_zerop))