Re: Simple reassoc transforms in match.pd

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

On Mon, 26 Jun 2017, Richard Biener wrote:

> On Fri, Jun 23, 2017 at 3:12 PM, Marc Glisse <marc.glisse@inria.fr> wrote:
>> Hello,
>>
>> here are a few simple transformations, mostly useful for types with
>> undefined overflow where we do not have reassoc.
>>
>> I did not name the testcase reassoc-* to leave that namespace to the realloc
>> pass, and -fno-tree-reassoc is just in case someone ever enhances that
>> pass...
>
> You probably saw
>
>  /* (T)(P + A) - (T)(P + B) -> (T)A - (T)B */
>  (for add (plus pointer_plus)
>   (simplify
>    (minus (convert (add @@0 @1))
>     (convert (add @0 @2)))

And

/* X + Z < Y + Z is the same as X < Y when there is no overflow.  */
[...]
/* For equality and subtraction, this is also true with wrapping overflow.  */
(for op (eq ne minus)
  (simplify
   (op (plus:c @0 @2) (plus:c @1 @2))
   (if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (@0))
        && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (@0))
            || TYPE_OVERFLOW_WRAPS (TREE_TYPE (@0))))
    (op @0 @1))))

> as you didn't duplicate its functionality.  It misses a :c in one of
> the adds for the

For some other transform, I was tempted to write
(for op (plus:c minus) ...
i.e. use a different commutativity for different operations, but that's
not supported.

> PLUS_EXPR case though so it might be worth splitting that out near to your
> added cases?  Which then raises the question of handling conversions around
> the inner ops in your patterns?

It is probably possible to merge / generalize some of those transforms 
(although we sometimes do strange assumptions about overflow with pointers 
that may not match with the usual integer case). In this case, I was 
interested in the undefined-overflow case (more precisely the sum of 2 
pointer_diff), and as soon as one operation is done in a wrapping type, 
the result has to be as well (which could still be handled in the same 
transformation).

-- 
Marc Glisse