Re: RFA: better gimplification of compound literals

[Richard Guenther <richard dot guenther at gmail dot com>]

On Wed, Jun 13, 2012 at 1:46 PM, Michael Matz <matz@suse.de> wrote:
> Hi,
>
> On Tue, 12 Jun 2012, Richard Guenther wrote:
>
>> > Ok, I see the C frontend hands us this as
>> >
>> > ?return ?VEC_PERM_EXPR < a , b , <<< Unknown tree: compound_literal_expr
>> > ? ?v4si D.1712 = { 0, 4, 1, 5 }; >>> > ;
>> >
>> > and gimplification in some way fails to gimplify it to { 0, 4, 1, 5 }.
>
> Was a non-implemented optimization. ?If the compound literal value isn't
> used as lvalue and doesn't have its address taken (and generally fits the
> current predicate) we can as well subst it in place instead of going over
> an intermediate statement.
>
> Regstrapping on x86_64-linux in progress. ?Okay if that passes?

Ok.

Thanks,
Richard.

>
> Ciao,
> Michael.
> ---------------------
> ? ? ? ?* gimplify.c (gimplify_compound_literal_expr): Take gimple_test_f
> ? ? ? ?argument, don't emit assign statement if value is directly usable.
> ? ? ? ?(gimplify_expr): Adjust.
>
> testsuite/
> ? ? ? ?* gcc.dg/tree-ssa/vector-4.c: New test.
>
> Index: gimplify.c
> ===================================================================
> --- gimplify.c ?(revision 188500)
> +++ gimplify.c ?(working copy)
> @@ -3796,15 +3796,29 @@ rhs_predicate_for (tree lhs)
>
> ?static enum gimplify_status
> ?gimplify_compound_literal_expr (tree *expr_p, gimple_seq *pre_p,
> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? bool (*gimple_test_f) (tree),
> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?fallback_t fallback)
> ?{
> ? tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p);
> ? tree decl = DECL_EXPR_DECL (decl_s);
> + ?tree init = DECL_INITIAL (decl);
> ? /* Mark the decl as addressable if the compound literal
> ? ? ?expression is addressable now, otherwise it is marked too late
> ? ? ?after we gimplify the initialization expression. ?*/
> ? if (TREE_ADDRESSABLE (*expr_p))
> ? ? TREE_ADDRESSABLE (decl) = 1;
> + ?/* Otherwise, if we don't need an lvalue and have a literal directly
> + ? ? substitute it. ?Check if it matches the gimple predicate, as
> + ? ? otherwise we'd generate a new temporary, and we can as well just
> + ? ? use the decl we already have. ?*/
> + ?else if (!TREE_ADDRESSABLE (decl)
> + ? ? ? ? ?&& init
> + ? ? ? ? ?&& (fallback & fb_lvalue) == 0
> + ? ? ? ? ?&& gimple_test_f (init))
> + ? ?{
> + ? ? ?*expr_p = init;
> + ? ? ?return GS_OK;
> + ? ?}
>
> ? /* Preliminarily mark non-addressed complex variables as eligible
> ? ? ?for promotion to gimple registers. ?We'll transform their uses
> @@ -7118,7 +7132,8 @@ gimplify_expr (tree *expr_p, gimple_seq
> ? ? ? ? ?break;
>
> ? ? ? ?case COMPOUND_LITERAL_EXPR:
> - ? ? ? ? ret = gimplify_compound_literal_expr (expr_p, pre_p, fallback);
> + ? ? ? ? ret = gimplify_compound_literal_expr (expr_p, pre_p,
> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? gimple_test_f, fallback);
> ? ? ? ? ?break;
>
> ? ? ? ?case MODIFY_EXPR:
> Index: testsuite/gcc.dg/tree-ssa/vector-4.c
> ===================================================================
> --- testsuite/gcc.dg/tree-ssa/vector-4.c ? ? ? ?(revision 0)
> +++ testsuite/gcc.dg/tree-ssa/vector-4.c ? ? ? ?(revision 0)
> @@ -0,0 +1,14 @@
> +/* { dg-do compile } */
> +/* { dg-options "-w -O1 -fdump-tree-gimple" } */
> +
> +typedef int v4si __attribute__ ((vector_size (16)));
> +
> +v4si vs (v4si a, v4si b)
> +{
> + ?return __builtin_shuffle (a, b, (v4si) {0, 4, 1, 5});
> +}
> +
> +/* The compound literal should be placed directly in the vec_perm. ?*/
> +/* { dg-final { scan-tree-dump-times "VEC_PERM_EXPR <a, b, { 0, 4, 1, 5 }>;" 1 "gimple"} } */
> +
> +/* { dg-final { cleanup-tree-dump "gimple" } } */