This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: Simple reassoc transforms in match.pd
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