On Sat, Jul 4, 2015 at 4:34 PM, Marc Glisse <marc.gli...@inria.fr> wrote:
> Hello,
>
> these are just some minor changes. I believe I had already promised a build_
> function to match integer_each_onep.
>
> Bootstrap+testsuite on powerpc64le-unknown-linux-gnu (it looks like
> *-match.c takes about 10 minutes to compile in stage2 these days).
Ouch. I have some changes to the code generation in the queue which
also supports a more natural "if" structure (else and elif). Eventually
that helps a bit but I suppose the main issue is simply from the large
functions. They can be split quite easily I think, but passing down
all relevant state might turn out to be tricky unless we start using
nested functions here ... (and IIRC those are not supported in C++)
Richard.
> 2015-07-06 Marc Glisse <marc.gli...@inria.fr>
>
> * match.pd: Remove element_mode inside HONOR_*.
> (~ (-A) -> A - 1, ~ (A - 1) -> -A): Handle complex types.
> (~X | X -> -1, ~X ^ X -> -1): Merge.
> * tree.c (build_each_one_cst): New function.
> * tree.h (build_each_one_cst): Likewise.
>
> --
> Marc Glisse
> Index: match.pd
> ===================================================================
> --- match.pd (revision 225411)
> +++ match.pd (working copy)
> @@ -101,7 +101,7 @@
> negative value by 0 gives -0, not +0. */
> (simplify
> (mult @0 real_zerop@1)
> - (if (!HONOR_NANS (type) && !HONOR_SIGNED_ZEROS (element_mode (type)))
> + (if (!HONOR_NANS (type) && !HONOR_SIGNED_ZEROS (type))
> @1))
>
> /* In IEEE floating point, x*1 is not equivalent to x for snans.
> @@ -108,8 +108,8 @@
> Likewise for complex arithmetic with signed zeros. */
> (simplify
> (mult @0 real_onep)
> - (if (!HONOR_SNANS (element_mode (type))
> - && (!HONOR_SIGNED_ZEROS (element_mode (type))
> + (if (!HONOR_SNANS (type)
> + && (!HONOR_SIGNED_ZEROS (type)
> || !COMPLEX_FLOAT_TYPE_P (type)))
> (non_lvalue @0)))
>
> @@ -116,8 +116,8 @@
> /* Transform x * -1.0 into -x. */
> (simplify
> (mult @0 real_minus_onep)
> - (if (!HONOR_SNANS (element_mode (type))
> - && (!HONOR_SIGNED_ZEROS (element_mode (type))
> + (if (!HONOR_SNANS (type)
> + && (!HONOR_SIGNED_ZEROS (type)
> || !COMPLEX_FLOAT_TYPE_P (type)))
> (negate @0)))
>
> @@ -165,7 +165,7 @@
> (rdiv @0 @0)
> (if (FLOAT_TYPE_P (type)
> && ! HONOR_NANS (type)
> - && ! HONOR_INFINITIES (element_mode (type)))
> + && ! HONOR_INFINITIES (type))
> { build_one_cst (type); }))
>
> /* Optimize -A / A to -1.0 if we don't care about
> @@ -174,19 +174,19 @@
> (rdiv:c @0 (negate @0))
> (if (FLOAT_TYPE_P (type)
> && ! HONOR_NANS (type)
> - && ! HONOR_INFINITIES (element_mode (type)))
> + && ! HONOR_INFINITIES (type))
> { build_minus_one_cst (type); }))
>
> /* In IEEE floating point, x/1 is not equivalent to x for snans. */
> (simplify
> (rdiv @0 real_onep)
> - (if (!HONOR_SNANS (element_mode (type)))
> + (if (!HONOR_SNANS (type))
> (non_lvalue @0)))
>
> /* In IEEE floating point, x/-1 is not equivalent to -x for snans. */
> (simplify
> (rdiv @0 real_minus_onep)
> - (if (!HONOR_SNANS (element_mode (type)))
> + (if (!HONOR_SNANS (type))
> (negate @0)))
>
> /* If ARG1 is a constant, we can convert this to a multiply by the
> @@ -297,9 +297,10 @@
> @1)
>
> /* ~x | x -> -1 */
Please also adjust this comment. Ok with that change.
Thanks,
Richard.
> -(simplify
> - (bit_ior:c (convert? @0) (convert? (bit_not @0)))
> - (convert { build_all_ones_cst (TREE_TYPE (@0)); }))
> +(for op (bit_ior bit_xor plus)
> + (simplify
> + (op:c (convert? @0) (convert? (bit_not @0)))
> + (convert { build_all_ones_cst (TREE_TYPE (@0)); })))
>
> /* x ^ x -> 0 */
> (simplify
> @@ -311,11 +312,6 @@
> (bit_xor @0 integer_all_onesp@1)
> (bit_not @0))
>
> -/* ~X ^ X is -1. */
> -(simplify
> - (bit_xor:c (bit_not @0) @0)
> - { build_all_ones_cst (type); })
> -
> /* x & ~0 -> x */
> (simplify
> (bit_and @0 integer_all_onesp)
> @@ -603,11 +599,11 @@
> (simplify
> (bit_not (convert? (negate @0)))
> (if (tree_nop_conversion_p (type, TREE_TYPE (@0)))
> - (convert (minus @0 { build_one_cst (TREE_TYPE (@0)); }))))
> + (convert (minus @0 { build_each_one_cst (TREE_TYPE (@0)); }))))
>
> /* Convert ~ (A - 1) or ~ (A + -1) to -A. */
> (simplify
> - (bit_not (convert? (minus @0 integer_onep)))
> + (bit_not (convert? (minus @0 integer_each_onep)))
> (if (tree_nop_conversion_p (type, TREE_TYPE (@0)))
> (convert (negate @0))))
> (simplify
> Index: tree.c
> ===================================================================
> --- tree.c (revision 225411)
> +++ tree.c (working copy)
> @@ -1968,6 +1968,21 @@
> return t;
> }
>
> +/* Return the constant 1 in type TYPE. If TYPE has several elements, each
> + element is set to 1. In particular, this is 1 + i for complex types.
> */
> +
> +tree
> +build_each_one_cst (tree type)
> +{
> + if (TREE_CODE (type) == COMPLEX_TYPE)
> + {
> + tree scalar = build_one_cst (TREE_TYPE (type));
> + return build_complex (type, scalar, scalar);
> + }
> + else
> + return build_one_cst (type);
> +}
> +
> /* Return a constant of arithmetic type TYPE which is the
> multiplicative identity of the set TYPE. */
>
> Index: tree.h
> ===================================================================
> --- tree.h (revision 225411)
> +++ tree.h (working copy)
> @@ -3772,6 +3772,7 @@
> extern tree build_constructor_va (tree, int, ...);
> extern tree build_real_from_int_cst (tree, const_tree);
> extern tree build_complex (tree, tree, tree);
> +extern tree build_each_one_cst (tree);
> extern tree build_one_cst (tree);
> extern tree build_minus_one_cst (tree);
> extern tree build_all_ones_cst (tree);
>
