On Wed, Sep 20, 2017 at 2:18 PM, Richard Sandiford
<richard.sandif...@linaro.org> wrote:
> natch.pd tries to reassociate two bit operations if both of them have
> constant operands. However, with the polynomial integers added later,
> there's no guarantee that a bit operation on two integers can be folded
> at compile time. This means that the pattern can trigger for operations
> on three constants, and as things stood could endlessly oscillate
> between the two associations.
>
> This patch keeps the existing pattern for the normal case of a
> non-constant first operand. When all three operands are constant it
> tries to find a pair of constants that do fold. If none do, it keeps
> the original expression as-was.
>
> Tested on aarch64-linux-gnu, x86_64-linux-gnu and powerpc64le-linus-gnu.
> OK to install?
Hmm, is the complication with trying variants necessary or could we simply do
if (!CONSTANT_CLASS_P (@0))
(bitop @0 (bitop @1 @2))
and be done with it?
> Richard
>
>
> 2017-09-20 Richard Sandiford <richard.sandif...@linaro.org>
> Alan Hayward <alan.hayw...@arm.com>
> David Sherwood <david.sherw...@arm.com>
>
> gcc/
> * match.pd: Handle bit operations involving three constants
> and try to fold one pair.
>
> Index: gcc/match.pd
> ===================================================================
> --- gcc/match.pd 2017-09-16 21:38:21.106513157 +0100
> +++ gcc/match.pd 2017-09-20 13:17:10.552389270 +0100
> @@ -1017,7 +1017,14 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
> (for bitop (bit_and bit_ior bit_xor)
> (simplify
> (bitop (bitop @0 CONSTANT_CLASS_P@1) CONSTANT_CLASS_P@2)
> - (bitop @0 (bitop @1 @2))))
> + (if (!CONSTANT_CLASS_P (@0))
> + (bitop @0 (bitop @1 @2))
> + (with { tree cst1 = const_binop (bitop, type, @0, @2); }
> + (if (cst1)
> + (bitop @1 { cst1; })
> + (with { tree cst2 = const_binop (bitop, type, @1, @2); }
> + (if (cst2)
> + (bitop @0 { cst2; }))))))))
>
> /* Try simple folding for X op !X, and X op X with the help
> of the truth_valued_p and logical_inverted_value predicates. */
