RFA: better gimplification of compound literals

[Richard Guenther]

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" } } */