From 0a8f32b8fc399b3fc2da1449d92de22da83d3853 Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Wed, 21 Oct 2015 02:22:04 +0000 Subject: [PATCH] fold-const.c (fold_binary_loc): Move (-A) * (-B) -> A * B to match.pd. 2015-10-20 Richard Biener Naveen H.S * 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. Co-Authored-By: Naveen H.S From-SVN: r229107 --- gcc/ChangeLog | 20 ++++++++++++++++++ gcc/fold-const.c | 55 ------------------------------------------------ gcc/match.pd | 30 ++++++++++++++++++++++++++ 3 files changed, 50 insertions(+), 55 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 77f659bc220..1c80d9478fd 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,23 @@ +2015-10-21 Richard Biener + Naveen H.S + + * 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 Szabolcs Nagy Alan Modra diff --git a/gcc/fold-const.c b/gcc/fold-const.c index de45a2cf477..1e7fbb4aaf5 100644 --- 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 98f4b2cbc35..83dc7ad53d1 100644 --- 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 @@ -629,6 +657,8 @@ along with GCC; see the file COPYING3. If not see (match truth_valued_p (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) -- 2.30.2