On Mon, Jun 29, 2015 at 09:36:59AM +0200, Richard Biener wrote:
> > Anything wrong with this?
> >
> > +/* X - (X / Y) * Y is the same as X % Y. */
> > +(simplify
> > + (minus (convert? @0) (convert? (mult (trunc_div @0 @1) @1)))
> > + (if (INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
> > + (convert (trunc_mod @0 @1))))
That looks awfully similar to a variant I also tried (but I remember
having convert1? and convert2? in it). Not sure what was wrong with
that one; certainly yours seems to work fine.
Not sure whether we need some tree_nop_conversion_p in it. Perhaps not.
> Yes. Eventually even (convert? (mult (convert1? (trunc_div ...)?
> Of course with matching @0 between the two operands of the minus
> you constrain types quite a bit.
I'm starting to dislike this whole convert business ;).
> I'd say just single-step through fold and see what types it get
> present when folding a - (unsigned) ((a / b) * b).
I did that. The whole expression has type "unsigned int", arg0
is "a" of type int and arg1 is "(a / b) * b" of type int.
The following version is what Marc suggests.
Bootstrapped/regtested on x86_64-linux, ok for trunk?
2015-06-29 Marek Polacek <pola...@redhat.com>
Marc Glisse <marc.gli...@inria.fr>
* fold-const.c (fold_binary_loc): Move X - (X / Y) * Y -> X % Y to ...
* match.pd: ... pattern here.
diff --git gcc/fold-const.c gcc/fold-const.c
index 6f12dd0..01e3983 100644
--- gcc/fold-const.c
+++ gcc/fold-const.c
@@ -10509,19 +10509,6 @@ fold_binary_loc (location_t loc,
fold_convert_loc (loc, type,
TREE_OPERAND (arg0, 0)));
- /* X - (X / Y) * Y is X % Y. */
- if ((INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
- && TREE_CODE (arg1) == MULT_EXPR
- && TREE_CODE (TREE_OPERAND (arg1, 0)) == TRUNC_DIV_EXPR
- && operand_equal_p (arg0,
- TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0)
- && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg1, 0), 1),
- TREE_OPERAND (arg1, 1), 0))
- return
- fold_convert_loc (loc, type,
- fold_build2_loc (loc, TRUNC_MOD_EXPR, TREE_TYPE
(arg0),
- arg0, TREE_OPERAND (arg1, 1)));
-
if (! FLOAT_TYPE_P (type))
{
/* Fold A - (A & B) into ~B & A. */
diff --git gcc/match.pd gcc/match.pd
index b2f8429..2bc158b 100644
--- gcc/match.pd
+++ gcc/match.pd
@@ -238,6 +238,12 @@ along with GCC; see the file COPYING3. If not see
&& tree_nop_conversion_p (type, TREE_TYPE (@1)))
(trunc_mod @0 (convert @1))))
+/* X - (X / Y) * Y is the same as X % Y. */
+(simplify
+ (minus (convert? @0) (convert? (mult (trunc_div @0 @1) @1)))
+ (if (INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
+ (convert (trunc_mod @0 @1))))
+
/* Optimize TRUNC_MOD_EXPR by a power of two into a BIT_AND_EXPR,
i.e. "X % C" into "X & (C - 1)", if X and C are positive.
Also optimize A % (C << N) where C is a power of 2,
Marek
