inliner: Don't emit copy stmts for empty type parameters [PR103989]

Message ID 20220113091052.GS2646553@tucnak
State New
Headers show
Series
  • inliner: Don't emit copy stmts for empty type parameters [PR103989]
Related show

Commit Message

liuhongt via Gcc-patches Jan. 13, 2022, 9:10 a.m.
Hi!

The following patch avoids emitting a parameter copy statement when inlining
if the parameter has empty type.  E.g. the gimplifier does something similar
(except that it needs to evaluate side-effects if any, which isn't the case
here):
  /* For empty types only gimplify the left hand side and right hand
     side as statements and throw away the assignment.  Do this after
     gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
     types properly.  */
  if (is_empty_type (TREE_TYPE (*from_p))
      && !want_value
      /* Don't do this for calls that return addressable types, expand_call
         relies on those having a lhs.  */
      && !(TREE_ADDRESSABLE (TREE_TYPE (*from_p))
           && TREE_CODE (*from_p) == CALL_EXPR))
    {
      gimplify_stmt (from_p, pre_p);
      gimplify_stmt (to_p, pre_p);
      *expr_p = NULL_TREE;
      return GS_ALL_DONE;
    }
Unfortunately, this patch doesn't cure the uninit warnings in that PR,
but I think is desirable anyway.

Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk?

2022-01-13  Jakub Jelinek  <jakub@redhat.com>

	PR tree-optimization/103989
	* tree-inline.c (setup_one_parameter): Don't copy parms with
	empty type.


	Jakub

Comments

liuhongt via Gcc-patches Jan. 13, 2022, 9:54 a.m. | #1
On Thu, 13 Jan 2022, Jakub Jelinek wrote:

> Hi!

> 

> The following patch avoids emitting a parameter copy statement when inlining

> if the parameter has empty type.  E.g. the gimplifier does something similar

> (except that it needs to evaluate side-effects if any, which isn't the case

> here):

>   /* For empty types only gimplify the left hand side and right hand

>      side as statements and throw away the assignment.  Do this after

>      gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable

>      types properly.  */

>   if (is_empty_type (TREE_TYPE (*from_p))

>       && !want_value

>       /* Don't do this for calls that return addressable types, expand_call

>          relies on those having a lhs.  */

>       && !(TREE_ADDRESSABLE (TREE_TYPE (*from_p))

>            && TREE_CODE (*from_p) == CALL_EXPR))

>     {

>       gimplify_stmt (from_p, pre_p);

>       gimplify_stmt (to_p, pre_p);

>       *expr_p = NULL_TREE;

>       return GS_ALL_DONE;

>     }

> Unfortunately, this patch doesn't cure the uninit warnings in that PR,

> but I think is desirable anyway.

> 

> Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk?


Hmm, but not emitting the initialization might cause even more such
warnings for the case where the passed in argument _is_ initialized
(or not visible as not, like when being a function parameter itself)?

Otherwise sure, it's the same what the gimplifier does.

I wonder if instead uninit warning should simply ignore uses of
"empty" typed variables?

OK.

Thanks,
Richard.

> 2022-01-13  Jakub Jelinek  <jakub@redhat.com>

> 

> 	PR tree-optimization/103989

> 	* tree-inline.c (setup_one_parameter): Don't copy parms with

> 	empty type.

> 

> --- gcc/tree-inline.c.jj	2022-01-11 23:11:23.422275652 +0100

> +++ gcc/tree-inline.c	2022-01-12 18:37:44.119950128 +0100

> @@ -3608,7 +3608,7 @@ setup_one_parameter (copy_body_data *id,

>  	      init_stmt = gimple_build_assign (def, rhs);

>  	    }

>  	}

> -      else

> +      else if (!is_empty_type (TREE_TYPE (var)))

>          init_stmt = gimple_build_assign (var, rhs);

>  

>        if (bb && init_stmt)

> 

> 	Jakub

> 

> 


-- 
Richard Biener <rguenther@suse.de>
SUSE Software Solutions Germany GmbH, Maxfeldstrasse 5, 90409 Nuernberg,
Germany; GF: Ivo Totev; HRB 36809 (AG Nuernberg)
liuhongt via Gcc-patches Jan. 13, 2022, 10:08 a.m. | #2
On Thu, Jan 13, 2022 at 10:54:15AM +0100, Richard Biener wrote:
> > The following patch avoids emitting a parameter copy statement when inlining

> > if the parameter has empty type.  E.g. the gimplifier does something similar

> > (except that it needs to evaluate side-effects if any, which isn't the case

> > here):

> >   /* For empty types only gimplify the left hand side and right hand

> >      side as statements and throw away the assignment.  Do this after

> >      gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable

> >      types properly.  */

> >   if (is_empty_type (TREE_TYPE (*from_p))

> >       && !want_value

> >       /* Don't do this for calls that return addressable types, expand_call

> >          relies on those having a lhs.  */

> >       && !(TREE_ADDRESSABLE (TREE_TYPE (*from_p))

> >            && TREE_CODE (*from_p) == CALL_EXPR))

> >     {

> >       gimplify_stmt (from_p, pre_p);

> >       gimplify_stmt (to_p, pre_p);

> >       *expr_p = NULL_TREE;

> >       return GS_ALL_DONE;

> >     }

> > Unfortunately, this patch doesn't cure the uninit warnings in that PR,

> > but I think is desirable anyway.

> > 

> > Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk?

> 

> Hmm, but not emitting the initialization might cause even more such

> warnings for the case where the passed in argument _is_ initialized

> (or not visible as not, like when being a function parameter itself)?


Most of the time it won't be initialized either, but sure, there
can be some cases like when a larger struct is initialized with memset
and then we pass a field from that as an argument.

> Otherwise sure, it's the same what the gimplifier does.

> 

> I wonder if instead uninit warning should simply ignore uses of

> "empty" typed variables?


Apparently it does already:
  /* Avoid warning about empty types such as structs with no members.
     The first_field() test is important for C++ where the predicate
     alone isn't always sufficient.  */
  tree rhstype = TREE_TYPE (rhs);
  if (POINTER_TYPE_P (rhstype))
    rhstype = TREE_TYPE (rhstype);
  if (is_empty_type (rhstype))
    return NULL_TREE;
Though, the above
  if (POINTER_TYPE_P (rhstype))
    rhstype = TREE_TYPE (rhstype);
is just extremely suspicious, either we care about what type rhs has,
or it is dereferenced and it must be a pointer type and we care about
what it points to, but the simple fact whether rhs has a pointer type
or some other type shouldn't change what we test is_empty_type on.

When I was briefly looking at the assignment on which it actually warned,
it actually looked not empty type related.

	Jakub

Patch

--- gcc/tree-inline.c.jj	2022-01-11 23:11:23.422275652 +0100
+++ gcc/tree-inline.c	2022-01-12 18:37:44.119950128 +0100
@@ -3608,7 +3608,7 @@  setup_one_parameter (copy_body_data *id,
 	      init_stmt = gimple_build_assign (def, rhs);
 	    }
 	}
-      else
+      else if (!is_empty_type (TREE_TYPE (var)))
         init_stmt = gimple_build_assign (var, rhs);
 
       if (bb && init_stmt)