Hi,
Thanks for the review and comments.
>> I thought we were mostly using the 'convert?'
>> and tree_nop_conversion_p on integers
Done. Cleared all instances of convert which are not required.
However, I am still confused about the use of "convert" in match
and simplify.
>> So all patterns looking at arg[01] are handling nop-conversions on their
>> outermost operands while those looking at op[01] do not.
These patterns are looking at arg[01] rather than op[01] ?
Am really sorry, If I am repeating the same thing over and over.
>> That would probably also work for exact_div.
Done.
>> Don't you want to require that @1 is INTEGER_CST? And then you could use
>> const_binop, or even wi::add.
Done. The fold-const part did not specify it as INTEGER_CST.
Although it was obvious from the PLUS_EXPR.
However, just wanted to retain as per fold-const.
Please find attached the modified patch with all review comments addressed.
Regression tested on X86_64 without any extra failures.
Thanks,
Naveen
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index ee9b349..88dbbdd 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -10163,54 +10163,9 @@ fold_binary_loc (location_t loc,
return fold_build2_loc (loc, RDIV_EXPR, type,
negate_expr (arg0),
TREE_OPERAND (arg1, 0));
-
- /* Convert A/B/C to A/(B*C). */
- if (flag_reciprocal_math
- && TREE_CODE (arg0) == RDIV_EXPR)
- return fold_build2_loc (loc, RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
- fold_build2_loc (loc, MULT_EXPR, type,
- TREE_OPERAND (arg0, 1), arg1));
-
- /* Convert A/(B/C) to (A/B)*C. */
- if (flag_reciprocal_math
- && TREE_CODE (arg1) == RDIV_EXPR)
- return fold_build2_loc (loc, MULT_EXPR, type,
- fold_build2_loc (loc, RDIV_EXPR, type, arg0,
- TREE_OPERAND (arg1, 0)),
- TREE_OPERAND (arg1, 1));
-
- /* Convert C1/(X*C2) into (C1/C2)/X. */
- if (flag_reciprocal_math
- && TREE_CODE (arg1) == MULT_EXPR
- && TREE_CODE (arg0) == REAL_CST
- && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
- {
- tree tem = const_binop (RDIV_EXPR, arg0,
- TREE_OPERAND (arg1, 1));
- if (tem)
- return fold_build2_loc (loc, RDIV_EXPR, type, tem,
- TREE_OPERAND (arg1, 0));
- }
-
return NULL_TREE;
case TRUNC_DIV_EXPR:
- /* Optimize (X & (-A)) / A where A is a power of 2,
- to X >> log2(A) */
- if (TREE_CODE (arg0) == BIT_AND_EXPR
- && !TYPE_UNSIGNED (type) && TREE_CODE (arg1) == INTEGER_CST
- && integer_pow2p (arg1) && tree_int_cst_sgn (arg1) > 0)
- {
- tree sum = fold_binary_loc (loc, PLUS_EXPR, TREE_TYPE (arg1),
- arg1, TREE_OPERAND (arg0, 1));
- if (sum && integer_zerop (sum)) {
- tree pow2 = build_int_cst (integer_type_node,
- wi::exact_log2 (arg1));
- return fold_build2_loc (loc, RSHIFT_EXPR, type,
- TREE_OPERAND (arg0, 0), pow2);
- }
- }
-
/* Fall through */
case FLOOR_DIV_EXPR:
diff --git a/gcc/match.pd b/gcc/match.pd
index f6c5c07..020f575 100644
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -247,6 +247,27 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
(if (!HONOR_SNANS (type))
(negate @0)))
+/* Convert (A/B)/C to A/(B*C) */
+(simplify
+ (rdiv (rdiv @0 @1) @2)
+ (if (flag_reciprocal_math)
+ (rdiv @0 (mult @1 @2))))
+
+/* Convert A/(B/C) to (A/B)*C */
+(simplify
+ (rdiv @0 (rdiv @1 @2))
+ (if (flag_reciprocal_math)
+ (mult (rdiv @0 @1) @2)))
+
+/* Optimize (X & (-A)) / A where A is a power of 2, to X >> log2(A) */
+(for div (exact_div trunc_div)
+ (simplify
+ (div (bit_and @0 INTEGER_CST@1) INTEGER_CST@2)
+ (if (!TYPE_UNSIGNED (type) && integer_pow2p (@2)
+ && tree_int_cst_sgn (@2) > 0
+ && wi::add (@2, @1) == 0)
+ (rshift @0 { build_int_cst (integer_type_node, wi::exact_log2 (@2)); }))))
+
/* If ARG1 is a constant, we can convert this to a multiply by the
reciprocal. This does not have the same rounding properties,
so only do this if -freciprocal-math. We can actually
@@ -464,6 +485,15 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
(if (tem)
(rdiv { tem; } @1)))))
+/* Convert C1/(X*C2) into (C1/C2)/X */
+(simplify
+ (rdiv (REAL_CST@0) (mult @1 REAL_CST@2))
+ (if (flag_reciprocal_math)
+ (with
+ { tree tem = const_binop (RDIV_EXPR, type, @0, @2); }
+ (if (tem)
+ (rdiv { tem; } @1)))))
+
/* Simplify ~X & X as zero. */
(simplify
(bit_and:c (convert? @0) (convert? (bit_not @0)))
