Re: [TCWG CI] Regression caused by gcc: handle retslot in modref

[Maxim Kuvyrkov <maxim.kuvyrkov@linaro.org>]

Hi Jan,

Just wanted to make sure this is on your radar.

Your "handle retslot in modref” patch broken LTO bootstrap on aarch64 in all configurations that we test:

- tcwg_gcc_bootstrap/master-aarch64-bootstrap_lto
- tcwg_gcc_bootstrap/master-aarch64-bootstrap_profiled_lto
- tcwg_gcc_bootstrap/master-aarch64-bootstrap_profiled_lto_lean

Regards,

--
Maxim Kuvyrkov
https://www.linaro.org

> On 30 Oct 2021, at 05:32, ci_notify@linaro.org wrote:
> 
> [TCWG CI] Regression caused by gcc: handle retslot in modref:
> commit b8ef019ab938471f7f877a1eee3a6374fd8a6ae9
> Author: Jan Hubicka <hubicka@ucw.cz>
> 
>    handle retslot in modref
> 
> Results regressed to
> # reset_artifacts:
> -10
> # true:
> 0
> # build_abe binutils:
> 1
> # First few build errors in logs:
> # 00:04:02 make[3]: [Makefile:1772: aarch64-unknown-linux-gnu/bits/largefile-config.h] Error 1 (ignored)
> # 00:04:02 make[3]: [Makefile:1773: aarch64-unknown-linux-gnu/bits/largefile-config.h] Error 1 (ignored)
> # 00:19:19 checking for suffix of object files... configure: error: in `/home/tcwg-buildslave/workspace/tcwg_gnu_13/abe/builds/aarch64-unknown-linux-gnu/aarch64-unknown-linux-gnu/gcc-gcc.git~master-stage2/aarch64-unknown-linux-gnu/libgcc':
> # 00:19:19 configure: error: cannot compute suffix of object files: cannot compile
> # 00:19:19 make[2]: *** [Makefile:19796: configure-stage2-target-libgcc] Error 1
> # 00:19:19 make[1]: *** [Makefile:25351: stage2-bubble] Error 2
> # 00:19:19 make: *** [Makefile:1019: all] Error 2
> 
> from
> # reset_artifacts:
> -10
> # true:
> 0
> # build_abe binutils:
> 1
> # build_abe bootstrap_lto:
> 2
> 
> THIS IS THE END OF INTERESTING STUFF.  BELOW ARE LINKS TO BUILDS, REPRODUCTION INSTRUCTIONS, AND THE RAW COMMIT.
> 
> This commit has regressed these CI configurations:
> - tcwg_gcc_bootstrap/master-aarch64-bootstrap_lto
> 
> First_bad build: https://ci.linaro.org/job/tcwg_gcc_bootstrap-bisect-master-aarch64-bootstrap_lto/3/artifact/artifacts/build-b8ef019ab938471f7f877a1eee3a6374fd8a6ae9/
> Last_good build: https://ci.linaro.org/job/tcwg_gcc_bootstrap-bisect-master-aarch64-bootstrap_lto/3/artifact/artifacts/build-4045d5fa42f2ee7b284977c8f2f0edc300a63e43/
> Baseline build: https://ci.linaro.org/job/tcwg_gcc_bootstrap-bisect-master-aarch64-bootstrap_lto/3/artifact/artifacts/build-baseline/
> Even more details: https://ci.linaro.org/job/tcwg_gcc_bootstrap-bisect-master-aarch64-bootstrap_lto/3/artifact/artifacts/
> 
> Reproduce builds:
> <cut>
> mkdir investigate-gcc-b8ef019ab938471f7f877a1eee3a6374fd8a6ae9
> cd investigate-gcc-b8ef019ab938471f7f877a1eee3a6374fd8a6ae9
> 
> # Fetch scripts
> git clone https://git.linaro.org/toolchain/jenkins-scripts
> 
> # Fetch manifests and test.sh script
> mkdir -p artifacts/manifests
> curl -o artifacts/manifests/build-baseline.sh https://ci.linaro.org/job/tcwg_gcc_bootstrap-bisect-master-aarch64-bootstrap_lto/3/artifact/artifacts/manifests/build-baseline.sh --fail
> curl -o artifacts/manifests/build-parameters.sh https://ci.linaro.org/job/tcwg_gcc_bootstrap-bisect-master-aarch64-bootstrap_lto/3/artifact/artifacts/manifests/build-parameters.sh --fail
> curl -o artifacts/test.sh https://ci.linaro.org/job/tcwg_gcc_bootstrap-bisect-master-aarch64-bootstrap_lto/3/artifact/artifacts/test.sh --fail
> chmod +x artifacts/test.sh
> 
> # Reproduce the baseline build (build all pre-requisites)
> ./jenkins-scripts/tcwg_gnu-build.sh @@ artifacts/manifests/build-baseline.sh
> 
> # Save baseline build state (which is then restored in artifacts/test.sh)
> mkdir -p ./bisect
> rsync -a --del --delete-excluded --exclude /bisect/ --exclude /artifacts/ --exclude /gcc/ ./ ./bisect/baseline/
> 
> cd gcc
> 
> # Reproduce first_bad build
> git checkout --detach b8ef019ab938471f7f877a1eee3a6374fd8a6ae9
> ../artifacts/test.sh
> 
> # Reproduce last_good build
> git checkout --detach 4045d5fa42f2ee7b284977c8f2f0edc300a63e43
> ../artifacts/test.sh
> 
> cd ..
> </cut>
> 
> Full commit (up to 1000 lines):
> <cut>
> commit b8ef019ab938471f7f877a1eee3a6374fd8a6ae9
> Author: Jan Hubicka <hubicka@ucw.cz>
> Date:   Fri Oct 29 16:01:51 2021 +0200
> 
>    handle retslot in modref
> 
>    Extend modref and tree-ssa-structalias to handle retslot flags.
>    Since retslot it essentially a hidden argument that is known to be write-only
>    we can do pretty much the same stuff as we do for regular parameters.
>    I plan to add static chain handling similar way.
> 
>    We do not handle IPA propagation of retslot flags (where return slot is
>    initialized via return slot of other function). For this ipa-prop needs
>    to be extended to understand retslot as well.
> 
>    Bootstrapped/regtested x86_64-linux, OK for the gimple bits?
> 
>    Honza
> 
>    gcc/ChangeLog:
> 
>            * gimple.c (gimple_call_retslot_flags): New function.
>            * gimple.h (gimple_call_retslot_flags): Declare.
>            * ipa-modref.c: Include tree-cfg.h.
>            (struct escape_entry): Turn parm_index to signed.
>            (modref_summary_lto::modref_summary_lto): Add retslot_flags.
>            (modref_summary::modref_summary): Initialize retslot_flags.
>            (struct modref_summary_lto): Likewise.
>            (modref_summary::useful_p): Check retslot_flags.
>            (modref_summary_lto::useful_p): Likewise.
>            (modref_summary::dump): Dump retslot_flags.
>            (modref_summary_lto::dump): Likewise.
>            (struct escape_point): Add hidden_args enum.
>            (analyze_ssa_name_flags): Ignore return slot return;
>            use gimple_call_retslot_flags.
>            (record_escape_points): Break out from ...
>            (analyze_parms): ... here; handle retslot_flags.
>            (modref_summaries::duplicate): Duplicate retslot_flags.
>            (modref_summaries_lto::duplicate): Likewise.
>            (modref_write_escape_summary): Stream parm_index as signed.
>            (modref_read_escape_summary): Likewise.
>            (modref_write): Stream retslot_flags.
>            (read_section): Likewise.
>            (struct escape_map): Fix typo in comment.
>            (update_escape_summary_1): Fix whitespace.
>            (ipa_merge_modref_summary_after_inlining): Drop retslot_flags.
>            (modref_merge_call_site_flags): Merge retslot_flags.
>            * ipa-modref.h (struct modref_summary): Add retslot_flags.
>            * tree-ssa-structalias.c (handle_rhs_call): Handle retslot_flags.
> ---
> gcc/gimple.c               |  41 ++++++++++++-
> gcc/gimple.h               |   1 +
> gcc/ipa-modref.c           | 145 +++++++++++++++++++++++++++++++++------------
> gcc/ipa-modref.h           |   1 +
> gcc/tree-ssa-structalias.c |  29 ++++++---
> 5 files changed, 170 insertions(+), 47 deletions(-)
> 
> diff --git a/gcc/gimple.c b/gcc/gimple.c
> index cc7a88e822b..22dd6417d19 100644
> --- a/gcc/gimple.c
> +++ b/gcc/gimple.c
> @@ -1597,7 +1597,12 @@ gimple_call_arg_flags (const gcall *stmt, unsigned arg)
> 	  if (!node->binds_to_current_def_p ())
> 	    {
> 	      if ((modref_flags & EAF_UNUSED) && !(flags & EAF_UNUSED))
> -		modref_flags &= ~EAF_UNUSED;
> +		{
> +		  modref_flags &= ~EAF_UNUSED;
> +		  modref_flags |= EAF_NOESCAPE;
> +		}
> +	      if ((modref_flags & EAF_NOREAD) && !(flags & EAF_NOREAD))
> +		modref_flags &= ~EAF_NOREAD;
> 	      if ((modref_flags & EAF_DIRECT) && !(flags & EAF_DIRECT))
> 		modref_flags &= ~EAF_DIRECT;
> 	    }
> @@ -1608,6 +1613,40 @@ gimple_call_arg_flags (const gcall *stmt, unsigned arg)
>   return flags;
> }
> 
> +/* Detects argument flags for return slot on call STMT.  */
> +
> +int
> +gimple_call_retslot_flags (const gcall *stmt)
> +{
> +  int flags = EAF_DIRECT | EAF_NOREAD;
> +
> +  tree callee = gimple_call_fndecl (stmt);
> +  if (callee)
> +    {
> +      cgraph_node *node = cgraph_node::get (callee);
> +      modref_summary *summary = node ? get_modref_function_summary (node)
> +				: NULL;
> +
> +      if (summary)
> +	{
> +	  int modref_flags = summary->retslot_flags;
> +
> +	  /* We have possibly optimized out load.  Be conservative here.  */
> +	  if (!node->binds_to_current_def_p ())
> +	    {
> +	      if ((modref_flags & EAF_UNUSED) && !(flags & EAF_UNUSED))
> +		{
> +		  modref_flags &= ~EAF_UNUSED;
> +		  modref_flags |= EAF_NOESCAPE;
> +		}
> +	    }
> +	  if (dbg_cnt (ipa_mod_ref_pta))
> +	    flags |= modref_flags;
> +	}
> +    }
> +  return flags;
> +}
> +
> /* Detects return flags for the call STMT.  */
> 
> int
> diff --git a/gcc/gimple.h b/gcc/gimple.h
> index 303623b3ced..23a124ec769 100644
> --- a/gcc/gimple.h
> +++ b/gcc/gimple.h
> @@ -1589,6 +1589,7 @@ gimple_seq gimple_seq_copy (gimple_seq);
> bool gimple_call_same_target_p (const gimple *, const gimple *);
> int gimple_call_flags (const gimple *);
> int gimple_call_arg_flags (const gcall *, unsigned);
> +int gimple_call_retslot_flags (const gcall *);
> int gimple_call_return_flags (const gcall *);
> bool gimple_call_nonnull_result_p (gcall *);
> tree gimple_call_nonnull_arg (gcall *);
> diff --git a/gcc/ipa-modref.c b/gcc/ipa-modref.c
> index 0bbec8df0a2..3539cb43d11 100644
> --- a/gcc/ipa-modref.c
> +++ b/gcc/ipa-modref.c
> @@ -86,6 +86,7 @@ along with GCC; see the file COPYING3.  If not see
> #include "stringpool.h"
> #include "tree-ssanames.h"
> #include "attribs.h"
> +#include "tree-cfg.h"
> 
> 
> namespace {
> @@ -133,7 +134,7 @@ static fnspec_summaries_t *fnspec_summaries = NULL;
> struct escape_entry
> {
>   /* Parameter that escapes at a given call.  */
> -  unsigned int parm_index;
> +  int parm_index;
>   /* Argument it escapes to.  */
>   unsigned int arg;
>   /* Minimal flags known about the argument.  */
> @@ -269,7 +270,7 @@ static GTY(()) fast_function_summary <modref_summary_lto *, va_gc>
> /* Summary for a single function which this pass produces.  */
> 
> modref_summary::modref_summary ()
> -  : loads (NULL), stores (NULL), writes_errno (NULL)
> +  : loads (NULL), stores (NULL), retslot_flags (0), writes_errno (false)
> {
> }
> 
> @@ -322,6 +323,8 @@ modref_summary::useful_p (int ecf_flags, bool check_flags)
>   if (check_flags && eaf_flags_useful_p (arg_flags, ecf_flags))
>     return true;
>   arg_flags.release ();
> +  if (check_flags && remove_useless_eaf_flags (retslot_flags, ecf_flags, false))
> +    return true;
>   if (ecf_flags & ECF_CONST)
>     return false;
>   if (loads && !loads->every_base)
> @@ -363,6 +366,7 @@ struct GTY(()) modref_summary_lto
>   modref_records_lto *loads;
>   modref_records_lto *stores;
>   auto_vec<eaf_flags_t> GTY((skip)) arg_flags;
> +  eaf_flags_t retslot_flags;
>   bool writes_errno;
> 
>   modref_summary_lto ();
> @@ -374,7 +378,7 @@ struct GTY(()) modref_summary_lto
> /* Summary for a single function which this pass produces.  */
> 
> modref_summary_lto::modref_summary_lto ()
> -  : loads (NULL), stores (NULL), writes_errno (NULL)
> +  : loads (NULL), stores (NULL), retslot_flags (0), writes_errno (false)
> {
> }
> 
> @@ -400,6 +404,8 @@ modref_summary_lto::useful_p (int ecf_flags, bool check_flags)
>   if (check_flags && eaf_flags_useful_p (arg_flags, ecf_flags))
>     return true;
>   arg_flags.release ();
> +  if (check_flags && remove_useless_eaf_flags (retslot_flags, ecf_flags, false))
> +    return true;
>   if (ecf_flags & ECF_CONST)
>     return false;
>   if (loads && !loads->every_base)
> @@ -608,6 +614,11 @@ modref_summary::dump (FILE *out)
> 	    dump_eaf_flags (out, arg_flags[i]);
> 	  }
>     }
> +  if (retslot_flags)
> +    {
> +      fprintf (out, "  Retslot flags:");
> +      dump_eaf_flags (out, retslot_flags);
> +    }
> }
> 
> /* Dump summary.  */
> @@ -630,6 +641,11 @@ modref_summary_lto::dump (FILE *out)
> 	    dump_eaf_flags (out, arg_flags[i]);
> 	  }
>     }
> +  if (retslot_flags)
> +    {
> +      fprintf (out, "  Retslot flags:");
> +      dump_eaf_flags (out, retslot_flags);
> +    }
> }
> 
> /* Get function summary for FUNC if it exists, return NULL otherwise.  */
> @@ -1396,6 +1412,11 @@ namespace {
> 
> struct escape_point
> {
> +  /* Extra hidden args we keep track of.  */
> +  enum hidden_args
> +  {
> +    retslot_arg = -1
> +  };
>   /* Value escapes to this call.  */
>   gcall *call;
>   /* Argument it escapes to.  */
> @@ -1705,7 +1726,11 @@ analyze_ssa_name_flags (tree name, vec<modref_lattice> &lattice, int depth,
> 	 Returning name counts as an use by tree-ssa-structalias.c  */
>       if (greturn *ret = dyn_cast <greturn *> (use_stmt))
> 	{
> -	  if (gimple_return_retval (ret) == name)
> +	  /* Returning through return slot is seen as memory write earlier.  */
> +	  if (DECL_RESULT (current_function_decl)
> +	      && DECL_BY_REFERENCE (DECL_RESULT (current_function_decl)))
> +	    ;
> +	  else if (gimple_return_retval (ret) == name)
> 	    lattice[index].merge (~(EAF_UNUSED | EAF_NOT_RETURNED));
> 	  else if (memory_access_to (gimple_return_retval (ret), name))
> 	    {
> @@ -1748,7 +1773,7 @@ analyze_ssa_name_flags (tree name, vec<modref_lattice> &lattice, int depth,
> 		     may make LHS to escape.  See PR 98499.  */
> 		  if (gimple_call_return_slot_opt_p (call)
> 		      && TREE_ADDRESSABLE (TREE_TYPE (gimple_call_lhs (call))))
> -		    lattice[index].merge (EAF_NOREAD | EAF_DIRECT);
> +		    lattice[index].merge (gimple_call_retslot_flags (call));
> 		}
> 
> 	      /* We do not track accesses to the static chain (we could)
> @@ -1777,7 +1802,7 @@ analyze_ssa_name_flags (tree name, vec<modref_lattice> &lattice, int depth,
> 			  lattice[index].merge (call_flags);
> 			else
> 			  lattice[index].add_escape_point (call, i,
> -			     				   call_flags, true);
> +							   call_flags, true);
> 		      }
> 		    if (!ignore_retval)
> 		      merge_call_lhs_flags (call, i, index, false,
> @@ -1912,6 +1937,29 @@ analyze_ssa_name_flags (tree name, vec<modref_lattice> &lattice, int depth,
>   lattice[index].known = true;
> }
> 
> +/* Record escape points of PARM_INDEX according to LATTICE.  */
> +
> +static void
> +record_escape_points (modref_lattice &lattice, int parm_index, int flags)
> +{
> +  if (lattice.escape_points.length ())
> +    {
> +      escape_point *ep;
> +      unsigned int ip;
> +      cgraph_node *node = cgraph_node::get (current_function_decl);
> +
> +      FOR_EACH_VEC_ELT (lattice.escape_points, ip, ep)
> +	if ((ep->min_flags & flags) != flags)
> +	  {
> +	    cgraph_edge *e = node->get_edge (ep->call);
> +	    struct escape_entry ee = {parm_index, ep->arg,
> +				      ep->min_flags, ep->direct};
> +
> +	    escape_summaries->get_create (e)->esc.safe_push (ee);
> +	  }
> +    }
> +}
> +
> /* Determine EAF flags for function parameters.  */
> 
> static void
> @@ -1921,16 +1969,22 @@ analyze_parms (modref_summary *summary, modref_summary_lto *summary_lto,
>   unsigned int parm_index = 0;
>   unsigned int count = 0;
>   int ecf_flags = flags_from_decl_or_type (current_function_decl);
> +  tree retslot = NULL;
> 
>   /* For novops functions we have nothing to gain by EAF flags.  */
>   if (ecf_flags & ECF_NOVOPS)
>     return;
> 
> +  /* If there is return slot, look up its SSA name.  */
> +  if (DECL_RESULT (current_function_decl)
> +      && DECL_BY_REFERENCE (DECL_RESULT (current_function_decl)))
> +    retslot = ssa_default_def (cfun, DECL_RESULT (current_function_decl));
> +
>   for (tree parm = DECL_ARGUMENTS (current_function_decl); parm;
>        parm = TREE_CHAIN (parm))
>     count++;
> 
> -  if (!count)
> +  if (!count && !retslot)
>     return;
> 
>   auto_vec<modref_lattice> lattice;
> @@ -1984,24 +2038,24 @@ analyze_parms (modref_summary *summary, modref_summary_lto *summary_lto,
> 		summary_lto->arg_flags.safe_grow_cleared (count, true);
> 	      summary_lto->arg_flags[parm_index] = flags;
> 	    }
> -	  if (lattice[SSA_NAME_VERSION (name)].escape_points.length ())
> -	    {
> -	      escape_point *ep;
> -	      unsigned int ip;
> -	      cgraph_node *node = cgraph_node::get (current_function_decl);
> -
> -	      gcc_checking_assert (ipa);
> -	      FOR_EACH_VEC_ELT
> -		  (lattice[SSA_NAME_VERSION (name)].escape_points, ip, ep)
> -		if ((ep->min_flags & flags) != flags)
> -		  {
> -		    cgraph_edge *e = node->get_edge (ep->call);
> -		    struct escape_entry ee = {parm_index, ep->arg,
> -		     			      ep->min_flags, ep->direct};
> +	  record_escape_points (lattice[SSA_NAME_VERSION (name)],
> +				parm_index, flags);
> +	}
> +    }
> +  if (retslot)
> +    {
> +      analyze_ssa_name_flags (retslot, lattice, 0, ipa);
> +      int flags = lattice[SSA_NAME_VERSION (retslot)].flags;
> 
> -		    escape_summaries->get_create (e)->esc.safe_push (ee);
> -		  }
> -	    }
> +      flags = remove_useless_eaf_flags (flags, ecf_flags, false);
> +      if (flags)
> +	{
> +	  if (summary)
> +	    summary->retslot_flags = flags;
> +	  if (summary_lto)
> +	    summary_lto->retslot_flags = flags;
> +	  record_escape_points (lattice[SSA_NAME_VERSION (retslot)],
> +				escape_point::retslot_arg, flags);
> 	}
>     }
>   if (ipa)
> @@ -2287,6 +2341,7 @@ modref_summaries::duplicate (cgraph_node *, cgraph_node *dst,
>   dst_data->writes_errno = src_data->writes_errno;
>   if (src_data->arg_flags.length ())
>     dst_data->arg_flags = src_data->arg_flags.copy ();
> +  dst_data->retslot_flags = src_data->retslot_flags;
> }
> 
> /* Called when new clone is inserted to callgraph late.  */
> @@ -2312,6 +2367,7 @@ modref_summaries_lto::duplicate (cgraph_node *, cgraph_node *,
>   dst_data->writes_errno = src_data->writes_errno;
>   if (src_data->arg_flags.length ())
>     dst_data->arg_flags = src_data->arg_flags.copy ();
> +  dst_data->retslot_flags = src_data->retslot_flags;
> }
> 
> namespace
> @@ -2551,7 +2607,7 @@ modref_write_escape_summary (struct bitpack_d *bp, escape_summary *esum)
>   escape_entry *ee;
>   FOR_EACH_VEC_ELT (esum->esc, i, ee)
>     {
> -      bp_pack_var_len_unsigned (bp, ee->parm_index);
> +      bp_pack_var_len_int (bp, ee->parm_index);
>       bp_pack_var_len_unsigned (bp, ee->arg);
>       bp_pack_var_len_unsigned (bp, ee->min_flags);
>       bp_pack_value (bp, ee->direct, 1);
> @@ -2571,7 +2627,7 @@ modref_read_escape_summary (struct bitpack_d *bp, cgraph_edge *e)
>   for (unsigned int i = 0; i < n; i++)
>     {
>       escape_entry ee;
> -      ee.parm_index = bp_unpack_var_len_unsigned (bp);
> +      ee.parm_index = bp_unpack_var_len_int (bp);
>       ee.arg = bp_unpack_var_len_unsigned (bp);
>       ee.min_flags = bp_unpack_var_len_unsigned (bp);
>       ee.direct = bp_unpack_value (bp, 1);
> @@ -2628,6 +2684,7 @@ modref_write ()
> 	  streamer_write_uhwi (ob, r->arg_flags.length ());
> 	  for (unsigned int i = 0; i < r->arg_flags.length (); i++)
> 	    streamer_write_uhwi (ob, r->arg_flags[i]);
> +	  streamer_write_uhwi (ob, r->retslot_flags);
> 
> 	  write_modref_records (r->loads, ob);
> 	  write_modref_records (r->stores, ob);
> @@ -2724,6 +2781,11 @@ read_section (struct lto_file_decl_data *file_data, const char *data,
> 	  if (modref_sum_lto)
> 	    modref_sum_lto->arg_flags.quick_push (flags);
> 	}
> +      eaf_flags_t flags = streamer_read_uhwi (&ib);
> +      if (modref_sum)
> +	modref_sum->retslot_flags = flags;
> +      if (modref_sum_lto)
> +	modref_sum_lto->retslot_flags = flags;
>       read_modref_records (&ib, data_in,
> 			   modref_sum ? &modref_sum->loads : NULL,
> 			   modref_sum_lto ? &modref_sum_lto->loads : NULL);
> @@ -3098,7 +3160,7 @@ struct escape_map
>   bool direct;
> };
> 
> -/* Update escape map fo E.  */
> +/* Update escape map for E.  */
> 
> static void
> update_escape_summary_1 (cgraph_edge *e,
> @@ -3117,7 +3179,10 @@ update_escape_summary_1 (cgraph_edge *e,
>     {
>       unsigned int j;
>       struct escape_map *em;
> -      if (ee->parm_index >= map.length ())
> +      /* TODO: We do not have jump functions for return slots, so we
> +	 never propagate them to outer function.  */
> +      if (ee->parm_index >= (int)map.length ()
> +	  || ee->parm_index < 0)
> 	continue;
>       FOR_EACH_VEC_ELT (map[ee->parm_index], j, em)
> 	{
> @@ -3125,7 +3190,7 @@ update_escape_summary_1 (cgraph_edge *e,
> 	  if (ee->direct && !em->direct)
> 	    min_flags = deref_flags (min_flags, ignore_stores);
> 	  struct escape_entry entry = {em->parm_index, ee->arg,
> -	    			       ee->min_flags,
> +				       ee->min_flags,
> 				       ee->direct & em->direct};
> 	  sum->esc.safe_push (entry);
> 	}
> @@ -3245,7 +3310,11 @@ ipa_merge_modref_summary_after_inlining (cgraph_edge *edge)
>     FOR_EACH_VEC_ELT (sum->esc, i, ee)
>       {
> 	bool needed = false;
> -	if (to_info && to_info->arg_flags.length () > ee->parm_index)
> +	/* TODO: We do not have jump functions for return slots, so we
> +	   never propagate them to outer function.  */
> +	if (ee->parm_index < 0)
> +	  continue;
> +	if (to_info && (int)to_info->arg_flags.length () > ee->parm_index)
> 	  {
> 	    int flags = callee_info
> 			&& callee_info->arg_flags.length () > ee->arg
> @@ -3259,7 +3328,7 @@ ipa_merge_modref_summary_after_inlining (cgraph_edge *edge)
> 	    if (to_info->arg_flags[ee->parm_index])
> 	      needed = true;
> 	  }
> -	if (to_info_lto && to_info_lto->arg_flags.length () > ee->parm_index)
> +	if (to_info_lto && (int)to_info_lto->arg_flags.length () > ee->parm_index)
> 	  {
> 	    int flags = callee_info_lto
> 			&& callee_info_lto->arg_flags.length () > ee->arg
> @@ -3798,29 +3867,31 @@ modref_merge_call_site_flags (escape_summary *sum,
>       if (flags_lto & EAF_NOESCAPE)
> 	flags_lto |= EAF_NODIRECTESCAPE;
>       if (!(flags & EAF_UNUSED)
> -	  && cur_summary && ee->parm_index < cur_summary->arg_flags.length ())
> +	  && cur_summary && ee->parm_index < (int)cur_summary->arg_flags.length ())
> 	{
> -	  int f = cur_summary->arg_flags[ee->parm_index];
> +	  eaf_flags_t &f = ee->parm_index == escape_point::retslot_arg
> +			   ? cur_summary->retslot_flags
> +			   : cur_summary->arg_flags[ee->parm_index];
> 	  if ((f & flags) != f)
> 	    {
> 	      f = remove_useless_eaf_flags
> 			 (f & flags, ecf_flags,
> 			  VOID_TYPE_P (TREE_TYPE (TREE_TYPE (caller))));
> -	      cur_summary->arg_flags[ee->parm_index] = f;
> 	      changed = true;
> 	    }
> 	}
>       if (!(flags_lto & EAF_UNUSED)
> 	  && cur_summary_lto
> -	  && ee->parm_index < cur_summary_lto->arg_flags.length ())
> +	  && ee->parm_index < (int)cur_summary_lto->arg_flags.length ())
> 	{
> -	  int f = cur_summary_lto->arg_flags[ee->parm_index];
> +	  eaf_flags_t &f = ee->parm_index == escape_point::retslot_arg
> +			   ? cur_summary_lto->retslot_flags
> +			   : cur_summary_lto->arg_flags[ee->parm_index];
> 	  if ((f & flags_lto) != f)
> 	    {
> 	      f = remove_useless_eaf_flags
> 			 (f & flags_lto, ecf_flags,
> 			  VOID_TYPE_P (TREE_TYPE (TREE_TYPE (caller))));
> -	      cur_summary_lto->arg_flags[ee->parm_index] = f;
> 	      changed = true;
> 	    }
> 	}
> diff --git a/gcc/ipa-modref.h b/gcc/ipa-modref.h
> index 5afa3aa439f..a4db27471eb 100644
> --- a/gcc/ipa-modref.h
> +++ b/gcc/ipa-modref.h
> @@ -31,6 +31,7 @@ struct GTY(()) modref_summary
>   modref_records *loads;
>   modref_records *stores;
>   auto_vec<eaf_flags_t> GTY((skip)) arg_flags;
> +  eaf_flags_t retslot_flags;
>   bool writes_errno;
> 
>   modref_summary ();
> diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c
> index 35971a54e02..99072df0768 100644
> --- a/gcc/tree-ssa-structalias.c
> +++ b/gcc/tree-ssa-structalias.c
> @@ -4254,17 +4254,28 @@ handle_rhs_call (gcall *stmt, vec<ce_s> *results,
>       && gimple_call_lhs (stmt) != NULL_TREE
>       && TREE_ADDRESSABLE (TREE_TYPE (gimple_call_lhs (stmt))))
>     {
> -      auto_vec<ce_s> tmpc;
> -      struct constraint_expr *c;
> -      unsigned i;
> +      int flags = gimple_call_retslot_flags (stmt);
> +      if ((flags & (EAF_NOESCAPE | EAF_NOT_RETURNED))
> +	  != (EAF_NOESCAPE | EAF_NOT_RETURNED))
> +	{
> +	  auto_vec<ce_s> tmpc;
> 
> -      get_constraint_for_address_of (gimple_call_lhs (stmt), &tmpc);
> +	  get_constraint_for_address_of (gimple_call_lhs (stmt), &tmpc);
> 
> -      make_constraints_to (callescape->id, tmpc);
> -      if (writes_global_memory)
> -	make_constraints_to (escaped_id, tmpc);
> -      FOR_EACH_VEC_ELT (tmpc, i, c)
> -	results->safe_push (*c);
> +	  if (!(flags & (EAF_NOESCAPE | EAF_NODIRECTESCAPE)))
> +	    {
> +	      make_constraints_to (callescape->id, tmpc);
> +	      if (writes_global_memory)
> +		make_constraints_to (escaped_id, tmpc);
> +	    }
> +	  if (!(flags & EAF_NOT_RETURNED))
> +	    {
> +	      struct constraint_expr *c;
> +	      unsigned i;
> +	      FOR_EACH_VEC_ELT (tmpc, i, c)
> +		results->safe_push (*c);
> +	    }
> +	}
>     }
> }
> 
> </cut>