Re: [PATCH] ipa-sra: Allow IPA-SRA in presence of returns which will be removed

[Martin Jambor <mjambor@suse.cz>]

Hello

and ping.

Thanks,

Martin


On Fri, Aug 18 2023, Martin Jambor wrote:
> Hi,
>
> testing on 32bit arm revealed that even the simplest case of PR 110378
> was still not resolved there because destructors were returning this
> pointer.  Needless to say, the return value of those destructors often
> is just not used, which IPA-SRA can already detect in time.  Since
> such enhancement seems generally useful, here it is.
>
> The patch simply adds two flag to respective summaries to mark down
> situations when it encounters either a simple direct use of a default
> definition SSA_NAME of a parameter, which means that the parameter may
> still be split when return value is removed, and when any derived use
> of it is returned, allowing for complete removal in that case, instead
> of discarding it as a candidate for removal or splitting like we do
> now.  The IPA phase then simply checks that we indeed plan to remove
> the return value before allowing any transformation to be considered
> in such cases.
>
> Bootstrapped, LTO-bootstrapped and tested on x86_64-linux.  OK for
> master?
>
> Thanks,
>
> Martin
>
>
> gcc/ChangeLog:
>
> 2023-08-18  Martin Jambor  <mjambor@suse.cz>
>
> 	PR ipa/110378
> 	* ipa-param-manipulation.cc
> 	(ipa_param_body_adjustments::mark_dead_statements): Verify that any
> 	return uses of PARAM will be removed.
> 	(ipa_param_body_adjustments::mark_clobbers_dead): Likewise.
> 	* ipa-sra.cc (isra_param_desc): New fields
> 	remove_only_when_retval_removed and split_only_when_retval_removed.
> 	(struct gensum_param_desc): Likewise.  Fix comment long line.
> 	(ipa_sra_function_summaries::duplicate): Copy the new flags.
> 	(dump_gensum_param_descriptor): Dump the new flags.
> 	(dump_isra_param_descriptor): Likewise.
> 	(isra_track_scalar_value_uses): New parameter desc.  Set its flag
> 	remove_only_when_retval_removed when encountering a simple return.
> 	(isra_track_scalar_param_local_uses): Replace parameter call_uses_p
> 	with desc.  Pass it to isra_track_scalar_value_uses and set its
> 	call_uses.
> 	(ptr_parm_has_nonarg_uses): Accept parameter descriptor as a
> 	parameter.  If there is a direct return use, mark any..
> 	(create_parameter_descriptors): Pass the whole parameter descriptor to
> 	isra_track_scalar_param_local_uses and ptr_parm_has_nonarg_uses.
> 	(process_scan_results): Copy the new flags.
> 	(isra_write_node_summary): Stream the new flags.
> 	(isra_read_node_info): Likewise.
> 	(adjust_parameter_descriptions): Check that transformations
> 	requring return removal only happen when return value is removed.
> 	Restructure main loop.  Adjust dump message.
>
> gcc/testsuite/ChangeLog:
>
> 2023-08-18  Martin Jambor  <mjambor@suse.cz>
>
> 	PR ipa/110378
> 	* gcc.dg/ipa/ipa-sra-32.c: New test.
> 	* gcc.dg/ipa/pr110378-4.c: Likewise.
> 	* gcc.dg/ipa/ipa-sra-4.c: Use a return value.
> ---
>  gcc/ipa-param-manipulation.cc         |   7 +-
>  gcc/ipa-sra.cc                        | 247 +++++++++++++++++---------
>  gcc/testsuite/gcc.dg/ipa/ipa-sra-32.c |  30 ++++
>  gcc/testsuite/gcc.dg/ipa/ipa-sra-4.c  |   4 +-
>  gcc/testsuite/gcc.dg/ipa/pr110378-4.c |  50 ++++++
>  5 files changed, 251 insertions(+), 87 deletions(-)
>  create mode 100644 gcc/testsuite/gcc.dg/ipa/ipa-sra-32.c
>  create mode 100644 gcc/testsuite/gcc.dg/ipa/pr110378-4.c
>
> diff --git a/gcc/ipa-param-manipulation.cc b/gcc/ipa-param-manipulation.cc
> index 4a185ddbdf4..ae52f17b2c9 100644
> --- a/gcc/ipa-param-manipulation.cc
> +++ b/gcc/ipa-param-manipulation.cc
> @@ -1163,6 +1163,8 @@ ipa_param_body_adjustments::mark_dead_statements (tree dead_param,
>  		    stack.safe_push (lhs);
>  		}
>  	    }
> +	  else if (gimple_code (stmt) == GIMPLE_RETURN)
> +	    gcc_assert (m_adjustments && m_adjustments->m_skip_return);
>  	  else
>  	    /* IPA-SRA does not analyze other types of statements.  */
>  	    gcc_unreachable ();
> @@ -1182,7 +1184,8 @@ ipa_param_body_adjustments::mark_dead_statements (tree dead_param,
>  }
>  
>  /* Put all clobbers of of dereference of default definition of PARAM into
> -   m_dead_stmts.  */
> +   m_dead_stmts.  If there are returns among uses of the default definition of
> +   PARAM, verify they will be stripped off the return value.  */
>  
>  void
>  ipa_param_body_adjustments::mark_clobbers_dead (tree param)
> @@ -1200,6 +1203,8 @@ ipa_param_body_adjustments::mark_clobbers_dead (tree param)
>       gimple *stmt = USE_STMT (use_p);
>       if (gimple_clobber_p (stmt))
>         m_dead_stmts.add (stmt);
> +     else if (gimple_code (stmt) == GIMPLE_RETURN)
> +       gcc_assert (m_adjustments && m_adjustments->m_skip_return);
>     }
>  }
>  
> diff --git a/gcc/ipa-sra.cc b/gcc/ipa-sra.cc
> index edba364f56e..817f29ea62f 100644
> --- a/gcc/ipa-sra.cc
> +++ b/gcc/ipa-sra.cc
> @@ -185,6 +185,13 @@ struct GTY(()) isra_param_desc
>    unsigned split_candidate : 1;
>    /* Is this a parameter passing stuff by reference?  */
>    unsigned by_ref : 1;
> +  /* If set, this parameter can only be a candidate for removal if the function
> +     is going to loose its return value.  */
> +  unsigned remove_only_when_retval_removed : 1;
> +  /* If set, this parameter can only be a candidate for splitting if the
> +     function is going to loose its return value.  Can only be meaningfully set
> +     for by_ref parameters.  */
> +  unsigned split_only_when_retval_removed : 1;
>    /* Parameter hint set during IPA analysis when there is a caller which does
>       not construct the argument just to pass it to calls.  Only meaningful for
>       by_ref parameters.  */
> @@ -206,7 +213,8 @@ struct gensum_param_desc
>    /* Number of accesses in the access tree rooted in field accesses.  */
>    unsigned access_count;
>  
> -  /* If the below is non-zero, this is the number of uses as actual arguments.  */
> +  /* If the below is non-zero, this is the number of uses as actual
> +     arguments.  */
>    int call_uses;
>    /* Number of times this parameter has been directly passed to.  */
>    unsigned ptr_pt_count;
> @@ -230,6 +238,13 @@ struct gensum_param_desc
>       without performing further checks (for example because it is a
>       REFERENCE_TYPE)?  */
>    bool safe_ref;
> +  /* If set, this parameter can only be a candidate for removal if the function
> +     is going to loose its return value.  */
> +  bool remove_only_when_retval_removed;
> +  /* If set, this parameter can only be a candidate for splitting if the
> +     function is going to loose its return value.  Can only be meaningfully set
> +     for by_ref parameters.  */
> +  bool split_only_when_retval_removed;
>    /* Only meaningful for by_ref parameters.  If set, this parameter can only be
>       a split candidate if all callers pass pointers that are known to point to
>       a chunk of memory large enough to contain all accesses.  */
> @@ -445,6 +460,8 @@ ipa_sra_function_summaries::duplicate (cgraph_node *, cgraph_node *,
>        d->locally_unused = s->locally_unused;
>        d->split_candidate = s->split_candidate;
>        d->by_ref = s->by_ref;
> +      d->remove_only_when_retval_removed = s->remove_only_when_retval_removed;
> +      d->split_only_when_retval_removed = s->split_only_when_retval_removed;
>        d->not_specially_constructed = s->not_specially_constructed;
>        d->conditionally_dereferenceable = s->conditionally_dereferenceable;
>        d->safe_size_set = s->safe_size_set;
> @@ -732,17 +749,21 @@ static void
>  dump_gensum_param_descriptor (FILE *f, gensum_param_desc *desc)
>  {
>    if (desc->locally_unused)
> -    fprintf (f, "    unused with %i call_uses\n", desc->call_uses);
> +    fprintf (f, "    unused with %i call_uses%s\n", desc->call_uses,
> +	     desc->remove_only_when_retval_removed ?
> +	     " remove_only_when_retval_removed" : "");
>    if (!desc->split_candidate)
>      {
>        fprintf (f, "    not a candidate\n");
>        return;
>      }
>    if (desc->by_ref)
> -    fprintf (f, "    %s%s by_ref with %u pass throughs\n",
> +    fprintf (f, "    %s%s%s by_ref with %u pass throughs\n",
>  	     desc->safe_ref ? "safe" : "unsafe",
>  	     desc->conditionally_dereferenceable
> -	     ? " conditionally_dereferenceable" : " ok",
> +	     ? " conditionally_dereferenceable" : "",
> +	     desc->split_only_when_retval_removed
> +	     ? " split_only_when_retval_removed" : "",
>  	     desc->ptr_pt_count);
>  
>    for (gensum_param_access *acc = desc->accesses; acc; acc = acc->next_sibling)
> @@ -790,6 +811,10 @@ dump_isra_param_descriptor (FILE *f, isra_param_desc *desc, bool hints)
>    fprintf (f, "    param_size_limit: %u, size_reached: %u%s",
>  	   desc->param_size_limit, desc->size_reached,
>  	   desc->by_ref ? ", by_ref" : "");
> +  if (desc->remove_only_when_retval_removed)
> +    fprintf (f, ", remove_only_when_retval_removed");
> +  if (desc->split_only_when_retval_removed)
> +    fprintf (f, ", split_only_when_retval_removed");
>    if (desc->by_ref && desc->conditionally_dereferenceable)
>      fprintf (f, ", conditionally_dereferenceable");
>    if (hints)
> @@ -881,16 +906,18 @@ get_single_param_flow_source (const isra_param_flow *param_flow)
>  
>  /* Inspect all uses of NAME and simple arithmetic calculations involving NAME
>     in FUN represented with NODE and return a negative number if any of them is
> -   used for something else than either an actual call argument, simple
> -   arithmetic operation or debug statement.  If there are no such uses, return
> -   the number of actual arguments that this parameter eventually feeds to (or
> -   zero if there is none).  For any such parameter, mark PARM_NUM as one of its
> -   sources.  ANALYZED is a bitmap that tracks which SSA names we have already
> -   started investigating.  */
> +   used for something else than either an actual call argument, simple return,
> +   simple arithmetic operation or debug statement.  If there are no such uses,
> +   return the number of actual arguments that this parameter eventually feeds
> +   to (or zero if there is none).  If there are any simple return uses, set
> +   DESC->remove_only_when_retval_removed.  For any such parameter, mark
> +   PARM_NUM as one of its sources.  ANALYZED is a bitmap that tracks which SSA
> +   names we have already started investigating.  */
>  
>  static int
>  isra_track_scalar_value_uses (function *fun, cgraph_node *node, tree name,
> -			      int parm_num, bitmap analyzed)
> +			      int parm_num, bitmap analyzed,
> +			      gensum_param_desc *desc)
>  {
>    int res = 0;
>    imm_use_iterator imm_iter;
> @@ -964,7 +991,7 @@ isra_track_scalar_value_uses (function *fun, cgraph_node *node, tree name,
>  	  if (bitmap_set_bit (analyzed, SSA_NAME_VERSION (lhs)))
>  	    {
>  	      int tmp = isra_track_scalar_value_uses (fun, node, lhs, parm_num,
> -						      analyzed);
> +						      analyzed, desc);
>  	      if (tmp < 0)
>  		{
>  		  res = tmp;
> @@ -973,6 +1000,16 @@ isra_track_scalar_value_uses (function *fun, cgraph_node *node, tree name,
>  	      res += tmp;
>  	    }
>  	}
> +      else if (greturn *gr = dyn_cast<greturn *>(stmt))
> +	{
> +	  tree rv = gimple_return_retval (gr);
> +	  if (rv != name)
> +	    {
> +	      res = -1;
> +	      break;
> +	    }
> +	  desc->remove_only_when_retval_removed = true;
> +	}
>        else
>  	{
>  	  res = -1;
> @@ -985,11 +1022,12 @@ isra_track_scalar_value_uses (function *fun, cgraph_node *node, tree name,
>  /* Inspect all uses of PARM, which must be a gimple register, in FUN (which is
>     also described by NODE) and simple arithmetic calculations involving PARM
>     and return false if any of them is used for something else than either an
> -   actual call argument, simple arithmetic operation or debug statement.  If
> -   there are no such uses, return true and store the number of actual arguments
> -   that this parameter eventually feeds to (or zero if there is none) to
> -   *CALL_USES_P.  For any such parameter, mark PARM_NUM as one of its
> -   sources.
> +   actual call argument, simple return, simple arithmetic operation or debug
> +   statement.  If there are no such uses, return true and store the number of
> +   actual arguments that this parameter eventually feeds to (or zero if there
> +   is none) to DESC->call_uses and set DESC->remove_only_when_retval_removed if
> +   there are any uses in return statemens.  For any such parameter, mark
> +   PARM_NUM as one of its sources.
>  
>     This function is similar to ptr_parm_has_nonarg_uses but its results are
>     meant for unused parameter removal, as opposed to splitting of parameters
> @@ -997,14 +1035,14 @@ isra_track_scalar_value_uses (function *fun, cgraph_node *node, tree name,
>  
>  static bool
>  isra_track_scalar_param_local_uses (function *fun, cgraph_node *node, tree parm,
> -				    int parm_num, int *call_uses_p)
> +				    int parm_num, gensum_param_desc *desc)
>  {
>    gcc_checking_assert (is_gimple_reg (parm));
>  
>    tree name = ssa_default_def (fun, parm);
>    if (!name || has_zero_uses (name))
>      {
> -      *call_uses_p = 0;
> +      desc->call_uses = 0;
>        return false;
>      }
>  
> @@ -1014,11 +1052,11 @@ isra_track_scalar_param_local_uses (function *fun, cgraph_node *node, tree parm,
>  
>    bitmap analyzed = BITMAP_ALLOC (NULL);
>    int call_uses = isra_track_scalar_value_uses (fun, node, name, parm_num,
> -						analyzed);
> +						analyzed, desc);
>    BITMAP_FREE (analyzed);
>    if (call_uses < 0)
>      return true;
> -  *call_uses_p = call_uses;
> +  desc->call_uses = call_uses;
>    return false;
>  }
>  
> @@ -1026,9 +1064,11 @@ isra_track_scalar_param_local_uses (function *fun, cgraph_node *node, tree parm,
>     examine whether there are any nonarg uses that are not actual arguments or
>     otherwise infeasible uses.  If so, return true, otherwise return false.
>     Create pass-through IPA flow records for any direct uses as argument calls
> -   and if returning false, store their number into *PT_COUNT_P.  NODE and FUN
> -   must represent the function that is currently analyzed, PARM_NUM must be the
> -   index of the analyzed parameter.
> +   and if returning false, store their number into DESC->ptr_pt_count.  If
> +   removal of return value would still allow splitting, return true but set
> +   DESC->split_only_when_retval_removed.  NODE and FUN must represent the
> +   function that is currently analyzed, PARM_NUM must be the index of the
> +   analyzed parameter.
>  
>     This function is similar to isra_track_scalar_param_local_uses but its
>     results are meant for splitting of parameters passed by reference or turning
> @@ -1037,7 +1077,7 @@ isra_track_scalar_param_local_uses (function *fun, cgraph_node *node, tree parm,
>  
>  static bool
>  ptr_parm_has_nonarg_uses (cgraph_node *node, function *fun, tree parm,
> -			  int parm_num, unsigned *pt_count_p)
> +			  int parm_num, gensum_param_desc *desc)
>  {
>    imm_use_iterator ui;
>    gimple *stmt;
> @@ -1121,6 +1161,19 @@ ptr_parm_has_nonarg_uses (cgraph_node *node, function *fun, tree parm,
>  		}
>  	    }
>  	}
> +      else if (greturn *gr = dyn_cast<greturn *>(stmt))
> +	{
> +	  tree rv = gimple_return_retval (gr);
> +	  if (rv == name)
> +	    {
> +	      uses_ok++;
> +	      /* Analysis for feasibility of removal must have already reached
> +		 the conclusion that the flag must be set if it completed.  */
> +	      gcc_assert (!desc->locally_unused
> +			  || desc->remove_only_when_retval_removed);
> +	      desc->split_only_when_retval_removed = true;
> +	    }
> +	}
>  
>        /* If the number of valid uses does not match the number of
>           uses in this stmt there is an unhandled use.  */
> @@ -1136,7 +1189,7 @@ ptr_parm_has_nonarg_uses (cgraph_node *node, function *fun, tree parm,
>  	}
>      }
>  
> -  *pt_count_p = pt_count;
> +  desc->ptr_pt_count = pt_count;
>    return ret;
>  }
>  
> @@ -1166,7 +1219,6 @@ create_parameter_descriptors (cgraph_node *node,
>        if (dump_file && (dump_flags & TDF_DETAILS))
>  	print_generic_expr (dump_file, parm, TDF_UID);
>  
> -      int scalar_call_uses;
>        tree type = TREE_TYPE (parm);
>        if (TREE_THIS_VOLATILE (parm))
>  	{
> @@ -1194,15 +1246,15 @@ create_parameter_descriptors (cgraph_node *node,
>  	}
>  
>        if (is_gimple_reg (parm)
> -	  && !isra_track_scalar_param_local_uses (fun, node, parm, num,
> -						  &scalar_call_uses))
> +	  && !isra_track_scalar_param_local_uses (fun, node, parm, num, desc))
>  	{
> -	  if (dump_file && (dump_flags & TDF_DETAILS))
> -	    fprintf (dump_file, " is a scalar with only %i call uses\n",
> -		     scalar_call_uses);
> -
>  	  desc->locally_unused = true;
> -	  desc->call_uses = scalar_call_uses;
> +
> +	  if (dump_file && (dump_flags & TDF_DETAILS))
> +	    fprintf (dump_file, " is a scalar with only %i call uses%s\n",
> +		     desc->call_uses,
> +		     desc->remove_only_when_retval_removed
> +		     ? " and return uses": "");
>  	}
>  
>        if (POINTER_TYPE_P (type))
> @@ -1253,8 +1305,7 @@ create_parameter_descriptors (cgraph_node *node,
>  			 "a va list\n");
>  	      continue;
>  	    }
> -	  if (ptr_parm_has_nonarg_uses (node, fun, parm, num,
> -					&desc->ptr_pt_count))
> +	  if (ptr_parm_has_nonarg_uses (node, fun, parm, num, desc))
>  	    {
>  	      if (dump_file && (dump_flags & TDF_DETAILS))
>  		fprintf (dump_file, " not a candidate, reference has "
> @@ -2628,6 +2679,8 @@ process_scan_results (cgraph_node *node, struct function *fun,
>        d->locally_unused = s->locally_unused;
>        d->split_candidate = s->split_candidate;
>        d->by_ref = s->by_ref;
> +      d->remove_only_when_retval_removed = s->remove_only_when_retval_removed;
> +      d->split_only_when_retval_removed = s->split_only_when_retval_removed;
>        d->conditionally_dereferenceable = s->conditionally_dereferenceable;
>  
>        for (gensum_param_access *acc = s->accesses;
> @@ -2789,6 +2842,8 @@ isra_write_node_summary (output_block *ob, cgraph_node *node)
>        bp_pack_value (&bp, desc->split_candidate, 1);
>        bp_pack_value (&bp, desc->by_ref, 1);
>        gcc_assert (!desc->not_specially_constructed);
> +      bp_pack_value (&bp, desc->remove_only_when_retval_removed, 1);
> +      bp_pack_value (&bp, desc->split_only_when_retval_removed, 1);
>        bp_pack_value (&bp, desc->conditionally_dereferenceable, 1);
>        gcc_assert (!desc->safe_size_set);
>        streamer_write_bitpack (&bp);
> @@ -2913,6 +2968,8 @@ isra_read_node_info (struct lto_input_block *ib, cgraph_node *node,
>        desc->split_candidate = bp_unpack_value (&bp, 1);
>        desc->by_ref = bp_unpack_value (&bp, 1);
>        desc->not_specially_constructed = 0;
> +      desc->remove_only_when_retval_removed = bp_unpack_value (&bp, 1);
> +      desc->split_only_when_retval_removed = bp_unpack_value (&bp, 1);
>        desc->conditionally_dereferenceable = bp_unpack_value (&bp, 1);
>        desc->safe_size_set = 0;
>      }
> @@ -4256,8 +4313,32 @@ adjust_parameter_descriptions (cgraph_node *node, isra_func_summary *ifs)
>  	{
>  	  desc->locally_unused = false;
>  	  desc->split_candidate = false;
> +	  continue;
> +	}
> +
> +      if (desc->split_only_when_retval_removed
> +	       && !ifs->m_return_ignored)
> +	{
> +	  if (dump_file && (dump_flags & TDF_DETAILS)
> +	      && (desc->locally_unused || desc->split_candidate))
> +	    dump_bad_cond_indices.safe_push (i);
> +
> +	  gcc_checking_assert (!desc->locally_unused
> +			       || desc->remove_only_when_retval_removed);
> +	  desc->locally_unused = false;
> +	  desc->split_candidate = false;
> +	  continue;
> +	}
> +      if (desc->remove_only_when_retval_removed
> +	       && !ifs->m_return_ignored)
> +	{
> +	  if (dump_file && (dump_flags & TDF_DETAILS)
> +	      && (desc->locally_unused || desc->split_candidate))
> +	    dump_bad_cond_indices.safe_push (i);
> +
> +	  desc->locally_unused = false;
>  	}
> -      else if (check_surviving
> +      if (check_surviving
>  	       && (i >= surviving_params.length ()
>  		   || !surviving_params[i]))
>  	{
> @@ -4269,67 +4350,65 @@ adjust_parameter_descriptions (cgraph_node *node, isra_func_summary *ifs)
>  	  if (dump_file && (dump_flags & TDF_DETAILS))
>  	    dump_dead_indices.safe_push (i);
>  	}
> -      else
> +
> +      if (desc->split_candidate && desc->conditionally_dereferenceable)
>  	{
> -	  if (desc->split_candidate && desc->conditionally_dereferenceable)
> -	    {
> -	      gcc_assert (desc->safe_size_set);
> -	      for (param_access *pa : *desc->accesses)
> -		if ((pa->unit_offset + pa->unit_size) > desc->safe_size)
> -		  {
> -		    if (dump_file && (dump_flags & TDF_DETAILS))
> -		      dump_bad_cond_indices.safe_push (i);
> -		    desc->split_candidate = false;
> -		    break;
> -		  }
> -	    }
> +	  gcc_assert (desc->safe_size_set);
> +	  for (param_access *pa : *desc->accesses)
> +	    if ((pa->unit_offset + pa->unit_size) > desc->safe_size)
> +	      {
> +		if (dump_file && (dump_flags & TDF_DETAILS))
> +		  dump_bad_cond_indices.safe_push (i);
> +		desc->split_candidate = false;
> +		break;
> +	      }
> +	}
>  
> -	  if (desc->split_candidate)
> +      if (desc->split_candidate)
> +	{
> +	  if (desc->by_ref && !desc->not_specially_constructed)
>  	    {
> -	      if (desc->by_ref && !desc->not_specially_constructed)
> -		{
> -		  int extra_factor
> -		    = opt_for_fn (node->decl,
> -				  param_ipa_sra_ptrwrap_growth_factor);
> -		  desc->param_size_limit = extra_factor * desc->param_size_limit;
> -		}
> -	      if (size_would_violate_limit_p (desc, desc->size_reached))
> -		desc->split_candidate = false;
> +	      int extra_factor
> +		= opt_for_fn (node->decl,
> +			      param_ipa_sra_ptrwrap_growth_factor);
> +	      desc->param_size_limit = extra_factor * desc->param_size_limit;
>  	    }
> +	  if (size_would_violate_limit_p (desc, desc->size_reached))
> +	    desc->split_candidate = false;
> +	}
>  
> -	  /* Avoid ICEs on size-mismatched VIEW_CONVERT_EXPRs when callers and
> -	     callees don't agree on types in aggregates and we try to do both
> -	     IPA-CP and IPA-SRA.  */
> -	  if (ipcp_ts && desc->split_candidate)
> +      /* Avoid ICEs on size-mismatched VIEW_CONVERT_EXPRs when callers and
> +	 callees don't agree on types in aggregates and we try to do both
> +	 IPA-CP and IPA-SRA.  */
> +      if (ipcp_ts && desc->split_candidate)
> +	{
> +	  ipa_argagg_value_list avl (ipcp_ts);
> +	  for (const param_access *pa : desc->accesses)
>  	    {
> -	      ipa_argagg_value_list avl (ipcp_ts);
> -	      for (const param_access *pa : desc->accesses)
> +	      if (!pa->certain)
> +		continue;
> +	      tree value = avl.get_value (i, pa->unit_offset);
> +	      if (value
> +		  && ((tree_to_uhwi (TYPE_SIZE (TREE_TYPE (value)))
> +		       / BITS_PER_UNIT)
> +		      != pa->unit_size))
>  		{
> -		  if (!pa->certain)
> -		    continue;
> -		  tree value = avl.get_value (i, pa->unit_offset);
> -		  if (value
> -		      && ((tree_to_uhwi (TYPE_SIZE (TREE_TYPE (value)))
> -			   / BITS_PER_UNIT)
> -			  != pa->unit_size))
> -		    {
> -		      desc->split_candidate = false;
> -		      if (dump_file && (dump_flags & TDF_DETAILS))
> -			dump_dead_indices.safe_push (i);
> -		      break;
> -		    }
> +		  desc->split_candidate = false;
> +		  if (dump_file && (dump_flags & TDF_DETAILS))
> +		    dump_dead_indices.safe_push (i);
> +		  break;
>  		}
>  	    }
> -
> -	  if (desc->locally_unused || desc->split_candidate)
> -	    ret = false;
>  	}
> +
> +      if (desc->locally_unused || desc->split_candidate)
> +	ret = false;
>      }
>  
>    dump_list_of_param_indices (node, "are dead on arrival or have a type "
>  			      "mismatch with IPA-CP", dump_dead_indices);
> -  dump_list_of_param_indices (node, "are not safe to dereference in all "
> -			      "callers", dump_bad_cond_indices);
> +  dump_list_of_param_indices (node, "fail additional requirements ",
> +			      dump_bad_cond_indices);
>  
>    return ret;
>  }
> diff --git a/gcc/testsuite/gcc.dg/ipa/ipa-sra-32.c b/gcc/testsuite/gcc.dg/ipa/ipa-sra-32.c
> new file mode 100644
> index 00000000000..f84442816b6
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/ipa/ipa-sra-32.c
> @@ -0,0 +1,30 @@
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -fdump-ipa-sra"  } */
> +
> +/* Test that parameters can be removed even when they are returned but the
> +   return is unused.  */
> +
> +extern int use(int use);
> +
> +
> +static int __attribute__((noinline))
> +foo(int a, int b, int c)
> +{
> +  use (c);
> +  return a + b + c;
> +}
> +
> +static int __attribute__((noinline))
> +bar (int a, int b, int c, int d)
> +{
> +  return foo (a, b, c + d);
> +}
> +
> +int
> +baz (int a, int b, int c, int d)
> +{
> +  bar (a, b, c, d);
> +  return a + d;
> +}
> +
> +/* { dg-final { scan-ipa-dump-times "Will remove parameter" 4 "sra" } } */
> diff --git a/gcc/testsuite/gcc.dg/ipa/ipa-sra-4.c b/gcc/testsuite/gcc.dg/ipa/ipa-sra-4.c
> index c86ae8320a7..5b42fbd8329 100644
> --- a/gcc/testsuite/gcc.dg/ipa/ipa-sra-4.c
> +++ b/gcc/testsuite/gcc.dg/ipa/ipa-sra-4.c
> @@ -54,10 +54,10 @@ void caller (void)
>    int b = 10;
>    int c;
>  
> -  ox (&a);
> +  c = ox (&a);
>    ox_ctrl_1 (&a);
>    ox_ctrl_2 (&a);
> -  *holder = ox_improved (1, &b);
> +  *holder = ox_improved (1, &b) + c;
>    return;
>  }
>  
> diff --git a/gcc/testsuite/gcc.dg/ipa/pr110378-4.c b/gcc/testsuite/gcc.dg/ipa/pr110378-4.c
> new file mode 100644
> index 00000000000..32432a8dbe7
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/ipa/pr110378-4.c
> @@ -0,0 +1,50 @@
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -fdump-ipa-sra -fdump-tree-optimized-slim"  } */
> +
> +/* This emulates what C++ trstcase pr110378-1.C looks like on 32-bit arm (or
> +   any architecture where the destructor returns this pointer.  It verifies
> +   that when it later becomes known that the return value will be removed, we
> +   can split a parameter even in this case.  */
> +
> +struct S
> +{
> +  short move_offset_of_a;
> +  int *a;
> +};
> +
> +extern int *allocate_stuff (unsigned);
> +extern void deallocate_stuff (void *);
> +
> +static void
> +something_like_a_constructor (struct S *p, int len)
> +{
> +  p->a = allocate_stuff (len * sizeof (int));
> +  *p->a = 4;
> +}
> +
> +static int
> +operation (struct S *p)
> +{
> +  return *p->a + 1;
> +}
> +
> +static struct S * __attribute__((noinline))
> +something_like_an_arm32_destructor (struct S *p)
> +{
> +  deallocate_stuff (p->a);
> +  return p;
> +}
> +
> +volatile int v2 = 20;
> +
> +int test (void)
> +{
> +  struct S shouldnotexist;
> +  something_like_a_constructor (&shouldnotexist, v2);
> +  v2 = operation (&shouldnotexist);
> +  something_like_an_arm32_destructor (&shouldnotexist);
> +  return 0;
> +}
> +
> +/* { dg-final { scan-ipa-dump "Will split parameter 0" "sra"  } } */
> +/* { dg-final { scan-tree-dump-not "shouldnotexist" "optimized" } } */
> -- 
> 2.41.0