Re: [PATCH] Move A - (A & B) -> ~B & A

[Marc Glisse <marc.glisse@inria.fr>]

On Fri, 17 Jul 2015, Marek Polacek wrote:

> On Fri, Jul 17, 2015 at 02:23:50PM +0200, Richard Biener wrote:
>>> +/* Fold A - (A & B) into ~B & A.  */
>>> +(simplify
>>> + (minus (convert? @0) (convert? (bit_and:c @0 @1)))
>>
>> I think you want :s on the bit_and and its convert?
>
> Ok, I keep forgetting about this :(.
>
>> Are you sure you don't need to check for a nop conversion here?
>
> I thought I didn't need it here, and couldn't find a testcase which
> would break without tree_nop_conversion_p checks, but that doesn't mean
> much.  So for extra safety I put the checks there.

I believe you were right that we don't need the checks, it should also be 
valid for narrowing / extending conversions.

Note that the equivalent "(X & Y) ^ Y as ~X & Y" does not have the 
optional converts.

> Bootstrapped/regtested on x86_64-linux, ok for trunk?
>
> 2015-07-17  Marek Polacek  <polacek@redhat.com>
>
> 	* fold-const.c (fold_binary_loc): Move A - (A & B) into ~B & A ...
> 	* match.pd: ... here.
>
> 	* gcc.dg/fold-minus-7.c: New test.
>
> diff --git gcc/fold-const.c gcc/fold-const.c
> index 93dd29d..fa321f4 100644
> --- gcc/fold-const.c
> +++ gcc/fold-const.c
> @@ -9777,30 +9777,6 @@ fold_binary_loc (location_t loc,
>
>       if (! FLOAT_TYPE_P (type))
> 	{
> -	  /* Fold A - (A & B) into ~B & A.  */
> -	  if (!TREE_SIDE_EFFECTS (arg0)
> -	      && TREE_CODE (arg1) == BIT_AND_EXPR)
> -	    {
> -	      if (operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0))
> -		{
> -		  tree arg10 = fold_convert_loc (loc, type,
> -						 TREE_OPERAND (arg1, 0));
> -		  return fold_build2_loc (loc, BIT_AND_EXPR, type,
> -				      fold_build1_loc (loc, BIT_NOT_EXPR,
> -						   type, arg10),
> -				      fold_convert_loc (loc, type, arg0));
> -		}
> -	      if (operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
> -		{
> -		  tree arg11 = fold_convert_loc (loc,
> -						 type, TREE_OPERAND (arg1, 1));
> -		  return fold_build2_loc (loc, BIT_AND_EXPR, type,
> -				      fold_build1_loc (loc, BIT_NOT_EXPR,
> -						   type, arg11),
> -				      fold_convert_loc (loc, type, arg0));
> -		}
> -	    }
> -
> 	  /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
> 	     any power of 2 minus 1.  */
> 	  if (TREE_CODE (arg0) == BIT_AND_EXPR
> diff --git gcc/match.pd gcc/match.pd
> index c335ada..700a692 100644
> --- gcc/match.pd
> +++ gcc/match.pd
> @@ -662,6 +662,12 @@ along with GCC; see the file COPYING3.  If not see
>  (bit_ior:c (bit_and:cs @0 (bit_not @2)) (bit_and:cs @1 @2))
>  (bit_xor (bit_and (bit_xor @0 @1) @2) @0))
>
> +/* Fold A - (A & B) into ~B & A.  */
> +(simplify
> + (minus (convert? @0) (convert?:s (bit_and:cs @0 @1)))
> + (if (tree_nop_conversion_p (type, TREE_TYPE (@0))
> +      && tree_nop_conversion_p (type, TREE_TYPE (@1)))
> +  (convert (bit_and (bit_not @1) @0))))
>
> /* Associate (p +p off1) +p off2 as (p +p (off1 + off2)).  */
> (simplify
> diff --git gcc/testsuite/gcc.dg/fold-minus-7.c gcc/testsuite/gcc.dg/fold-minus-7.c
> index e69de29..7a49faa 100644
> --- gcc/testsuite/gcc.dg/fold-minus-7.c
> +++ gcc/testsuite/gcc.dg/fold-minus-7.c
> @@ -0,0 +1,36 @@
> +/* { dg-do compile } */
> +/* { dg-options "-O -fdump-tree-cddce1" } */
> +
> +int
> +f1 (int a, int b)
> +{
> +  int tem = a & b;
> +  return a - tem;
> +}
> +
> +int
> +f2 (int a, int b)
> +{
> +  int tem = b & a;
> +  return a - tem;
> +}
> +
> +int
> +f3 (unsigned int a, int b)
> +{
> +  return a - (a & b);
> +}
> +
> +int
> +f4 (int a, unsigned int b)
> +{
> +  return a - (a & b);
> +}
> +
> +int
> +f5 (int a, int b)
> +{
> +  return a - (unsigned) (b & a);
> +}
> +
> +/* { dg-final { scan-tree-dump-not " - " "cddce1" } } */
>
> 	Marek
>

-- 
Marc Glisse