[thirdparty/gcc.git] / gcc / tree-nrv.c

/* Language independent return value optimizations
   Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010, 2011, 2012
   Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.

GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#include "function.h"
#include "basic-block.h"
#include "tree-pretty-print.h"
#include "tree-flow.h"
#include "tree-pass.h"
#include "langhooks.h"
#include "flags.h"	/* For "optimize" in gate_pass_return_slot.
			   FIXME: That should be up to the pass manager,
			   but pass_nrv is not in pass_all_optimizations.  */

/* This file implements return value optimizations for functions which
   return aggregate types.

   Basically this pass searches the function for return statements which
   return a local aggregate.  When converted to RTL such statements will
   generate a copy from the local aggregate to final return value destination
   mandated by the target's ABI.

   That copy can often be avoided by directly constructing the return value
   into the final destination mandated by the target's ABI.

   This is basically a generic equivalent to the C++ front-end's
   Named Return Value optimization.  */

struct nrv_data
{
  /* This is the temporary (a VAR_DECL) which appears in all of
     this function's RETURN_EXPR statements.  */
  tree var;

  /* This is the function's RESULT_DECL.  We will replace all occurrences
     of VAR with RESULT_DECL when we apply this optimization.  */
  tree result;
  int modified;
};

static tree finalize_nrv_r (tree *, int *, void *);

/* Callback for the tree walker.

   If TP refers to a RETURN_EXPR, then set the expression being returned
   to nrv_data->result.

   If TP refers to nrv_data->var, then replace nrv_data->var with
   nrv_data->result.

   If we reach a node where we know all the subtrees are uninteresting,
   then set *WALK_SUBTREES to zero.  */

static tree
finalize_nrv_r (tree *tp, int *walk_subtrees, void *data)
{
  struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
  struct nrv_data *dp = (struct nrv_data *) wi->info;

  /* No need to walk into types.  */
  if (TYPE_P (*tp))
    *walk_subtrees = 0;

  /* Otherwise replace all occurrences of VAR with RESULT.  */
  else if (*tp == dp->var)
    {
      *tp = dp->result;
      dp->modified = 1;
    }

  /* Keep iterating.  */
  return NULL_TREE;
}

/* Main entry point for return value optimizations.

   If this function always returns the same local variable, and that
   local variable is an aggregate type, then replace the variable with
   the function's DECL_RESULT.

   This is the equivalent of the C++ named return value optimization
   applied to optimized trees in a language independent form.  If we
   ever encounter languages which prevent this kind of optimization,
   then we could either have the languages register the optimization or
   we could change the gating function to check the current language.  */

static unsigned int
tree_nrv (void)
{
  tree result = DECL_RESULT (current_function_decl);
  tree result_type = TREE_TYPE (result);
  tree found = NULL;
  basic_block bb;
  gimple_stmt_iterator gsi;
  struct nrv_data data;

  /* If this function does not return an aggregate type in memory, then
     there is nothing to do.  */
  if (!aggregate_value_p (result, current_function_decl))
    return 0;

  /* If a GIMPLE type is returned in memory, finalize_nrv_r might create
     non-GIMPLE.  */
  if (is_gimple_reg_type (result_type))
    return 0;

  /* If the front end already did something like this, don't do it here.  */
  if (DECL_NAME (result))
    return 0;

  /* If the result has its address taken then it might be modified
     by means not detected in the following loop.  Bail out in this
     case.  */
  if (TREE_ADDRESSABLE (result))
    return 0;

  /* Look through each block for assignments to the RESULT_DECL.  */
  FOR_EACH_BB (bb)
    {
      for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
	{
	  gimple stmt = gsi_stmt (gsi);
	  tree ret_val;

	  if (gimple_code (stmt) == GIMPLE_RETURN)
	    {
	      /* In a function with an aggregate return value, the
		 gimplifier has changed all non-empty RETURN_EXPRs to
		 return the RESULT_DECL.  */
	      ret_val = gimple_return_retval (stmt);
	      if (ret_val)
		gcc_assert (ret_val == result);
	    }
	  else if (gimple_has_lhs (stmt)
		   && gimple_get_lhs (stmt) == result)
	    {
              tree rhs;

	      if (!gimple_assign_copy_p (stmt))
		return 0;

	      rhs = gimple_assign_rhs1 (stmt);

	      /* Now verify that this return statement uses the same value
		 as any previously encountered return statement.  */
	      if (found != NULL)
		{
		  /* If we found a return statement using a different variable
		     than previous return statements, then we can not perform
		     NRV optimizations.  */
		  if (found != rhs)
		    return 0;
		}
	      else
		found = rhs;

	      /* The returned value must be a local automatic variable of the
		 same type and alignment as the function's result.  */
	      if (TREE_CODE (found) != VAR_DECL
		  || TREE_THIS_VOLATILE (found)
		  || DECL_CONTEXT (found) != current_function_decl
		  || TREE_STATIC (found)
		  || TREE_ADDRESSABLE (found)
		  || DECL_ALIGN (found) > DECL_ALIGN (result)
		  || !useless_type_conversion_p (result_type,
						 TREE_TYPE (found)))
		return 0;
	    }
	  else if (gimple_has_lhs (stmt))
	    {
	      tree addr = get_base_address (gimple_get_lhs (stmt));
	       /* If there's any MODIFY of component of RESULT,
		  then bail out.  */
	      if (addr && addr == result)
		return 0;
	    }
	}
    }

  if (!found)
    return 0;

  /* If dumping details, then note once and only the NRV replacement.  */
  if (dump_file && (dump_flags & TDF_DETAILS))
    {
      fprintf (dump_file, "NRV Replaced: ");
      print_generic_expr (dump_file, found, dump_flags);
      fprintf (dump_file, "  with: ");
      print_generic_expr (dump_file, result, dump_flags);
      fprintf (dump_file, "\n");
    }

  /* At this point we know that all the return statements return the
     same local which has suitable attributes for NRV.   Copy debugging
     information from FOUND to RESULT if it will be useful.  But don't set
     DECL_ABSTRACT_ORIGIN to point at another function.  */
  if (!DECL_IGNORED_P (found)
      && !(DECL_ABSTRACT_ORIGIN (found)
	   && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (found)) != current_function_decl))
    {
      DECL_NAME (result) = DECL_NAME (found);
      DECL_SOURCE_LOCATION (result) = DECL_SOURCE_LOCATION (found);
      DECL_ABSTRACT_ORIGIN (result) = DECL_ABSTRACT_ORIGIN (found);
    }

  TREE_ADDRESSABLE (result) |= TREE_ADDRESSABLE (found);

  /* Now walk through the function changing all references to VAR to be
     RESULT.  */
  data.var = found;
  data.result = result;
  FOR_EACH_BB (bb)
    {
      for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); )
	{
	  gimple stmt = gsi_stmt (gsi);
	  /* If this is a copy from VAR to RESULT, remove it.  */
	  if (gimple_assign_copy_p (stmt)
	      && gimple_assign_lhs (stmt) == result
	      && gimple_assign_rhs1 (stmt) == found)
	    {
	      unlink_stmt_vdef (stmt);
	      gsi_remove (&gsi, true);
	      release_defs (stmt);
	    }
	  else
	    {
	      struct walk_stmt_info wi;
	      memset (&wi, 0, sizeof (wi));
	      wi.info = &data;
	      data.modified = 0;
	      walk_gimple_op (stmt, finalize_nrv_r, &wi);
	      if (data.modified)
		update_stmt (stmt);
	      gsi_next (&gsi);
	    }
	}
    }

  SET_DECL_VALUE_EXPR (found, result);
  DECL_HAS_VALUE_EXPR_P (found) = 1;

  return 0;
}

static bool
gate_pass_return_slot (void)
{
  return optimize > 0;
}

struct gimple_opt_pass pass_nrv =
{
 {
  GIMPLE_PASS,
  "nrv",				/* name */
  OPTGROUP_NONE,                        /* optinfo_flags */
  gate_pass_return_slot,		/* gate */
  tree_nrv,				/* execute */
  NULL,					/* sub */
  NULL,					/* next */
  0,					/* static_pass_number */
  TV_TREE_NRV,				/* tv_id */
  PROP_ssa | PROP_cfg,				/* properties_required */
  0,					/* properties_provided */
  0,					/* properties_destroyed */
  0,					/* todo_flags_start */
  TODO_ggc_collect			/* todo_flags_finish */
 }
};

/* Determine (pessimistically) whether DEST is available for NRV
   optimization, where DEST is expected to be the LHS of a modify
   expression where the RHS is a function returning an aggregate.

   DEST is available if it is not clobbered or used by the call.  */

static bool
dest_safe_for_nrv_p (gimple call)
{
  tree dest = gimple_call_lhs (call);

  dest = get_base_address (dest);
  if (! dest)
    return false;

  if (TREE_CODE (dest) == SSA_NAME)
    return true;

  if (call_may_clobber_ref_p (call, dest)
      || ref_maybe_used_by_stmt_p (call, dest))
    return false;

  return true;
}

/* Walk through the function looking for GIMPLE_ASSIGNs with calls that
   return in memory on the RHS.  For each of these, determine whether it is
   safe to pass the address of the LHS as the return slot, and mark the
   call appropriately if so.

   The NRV shares the return slot with a local variable in the callee; this
   optimization shares the return slot with the target of the call within
   the caller.  If the NRV is performed (which we can't know in general),
   this optimization is safe if the address of the target has not
   escaped prior to the call.  If it has, modifications to the local
   variable will produce visible changes elsewhere, as in PR c++/19317.  */

static unsigned int
execute_return_slot_opt (void)
{
  basic_block bb;

  FOR_EACH_BB (bb)
    {
      gimple_stmt_iterator gsi;
      for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
	{
	  gimple stmt = gsi_stmt (gsi);
	  bool slot_opt_p;

	  if (is_gimple_call (stmt)
	      && gimple_call_lhs (stmt)
	      && !gimple_call_return_slot_opt_p (stmt)
	      && aggregate_value_p (TREE_TYPE (gimple_call_lhs (stmt)),
				    gimple_call_fndecl (stmt)))
	    {
	      /* Check if the location being assigned to is
	         clobbered by the call.  */
	      slot_opt_p = dest_safe_for_nrv_p (stmt);
	      gimple_call_set_return_slot_opt (stmt, slot_opt_p);
	    }
	}
    }
  return 0;
}

struct gimple_opt_pass pass_return_slot =
{
 {
  GIMPLE_PASS,
  "retslot",				/* name */
  OPTGROUP_NONE,                        /* optinfo_flags */
  NULL,					/* gate */
  execute_return_slot_opt,		/* execute */
  NULL,					/* sub */
  NULL,					/* next */
  0,					/* static_pass_number */
  TV_NONE,				/* tv_id */
  PROP_ssa,				/* properties_required */
  0,					/* properties_provided */
  0,					/* properties_destroyed */
  0,					/* todo_flags_start */
  0					/* todo_flags_finish */
 }
};
Commit	Line	Data
4ee9c684	1	/* Language independent return value optimizations
71e45bc2	2	Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010, 2011, 2012
ce084dfc	3	Free Software Foundation, Inc.
4ee9c684	4
	5	This file is part of GCC.
	6
	7	GCC is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
8c4c00c1	9	the Free Software Foundation; either version 3, or (at your option)
4ee9c684	10	any later version.
	11
	12	GCC is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
8c4c00c1	18	along with GCC; see the file COPYING3. If not see
8c4c00c1	19	<http://www.gnu.org/licenses/>. */
4ee9c684	20
	21	#include "config.h"
	22	#include "system.h"
	23	#include "coretypes.h"
	24	#include "tm.h"
	25	#include "tree.h"
4ee9c684	26	#include "function.h"
4ee9c684	27	#include "basic-block.h"
ce084dfc	28	#include "tree-pretty-print.h"
4ee9c684	29	#include "tree-flow.h"
4ee9c684	30	#include "tree-pass.h"
4ee9c684	31	#include "langhooks.h"
a7a46268	32	#include "flags.h" /* For "optimize" in gate_pass_return_slot.
	33	FIXME: That should be up to the pass manager,
	34	but pass_nrv is not in pass_all_optimizations. */
4ee9c684	35
	36	/* This file implements return value optimizations for functions which
	37	return aggregate types.
	38
	39	Basically this pass searches the function for return statements which
	40	return a local aggregate. When converted to RTL such statements will
	41	generate a copy from the local aggregate to final return value destination
	42	mandated by the target's ABI.
	43
	44	That copy can often be avoided by directly constructing the return value
	45	into the final destination mandated by the target's ABI.
	46
48e1416a	47	This is basically a generic equivalent to the C++ front-end's
4ee9c684	48	Named Return Value optimization. */
	49
	50	struct nrv_data
	51	{
	52	/* This is the temporary (a VAR_DECL) which appears in all of
	53	this function's RETURN_EXPR statements. */
	54	tree var;
	55
365db11e	56	/* This is the function's RESULT_DECL. We will replace all occurrences
4ee9c684	57	of VAR with RESULT_DECL when we apply this optimization. */
4ee9c684	58	tree result;
a8dd994c	59	int modified;
4ee9c684	60	};
	61
	62	static tree finalize_nrv_r (tree , int , void *);
	63
	64	/* Callback for the tree walker.
	65
	66	If TP refers to a RETURN_EXPR, then set the expression being returned
	67	to nrv_data->result.
	68
	69	If TP refers to nrv_data->var, then replace nrv_data->var with
	70	nrv_data->result.
	71
	72	If we reach a node where we know all the subtrees are uninteresting,
	73	then set WALK_SUBTREES to zero. /
	74
	75	static tree
	76	finalize_nrv_r (tree tp, int walk_subtrees, void *data)
	77	{
75a70cf9	78	struct walk_stmt_info wi = (struct walk_stmt_info ) data;
75a70cf9	79	struct nrv_data dp = (struct nrv_data ) wi->info;
4ee9c684	80
	81	/* No need to walk into types. */
	82	if (TYPE_P (*tp))
	83	*walk_subtrees = 0;
15a9f039	84
2c763ed4	85	/* Otherwise replace all occurrences of VAR with RESULT. */
4ee9c684	86	else if (*tp == dp->var)
a8dd994c	87	{
	88	*tp = dp->result;
	89	dp->modified = 1;
	90	}
4ee9c684	91
	92	/* Keep iterating. */
	93	return NULL_TREE;
	94	}
	95
	96	/* Main entry point for return value optimizations.
	97
	98	If this function always returns the same local variable, and that
	99	local variable is an aggregate type, then replace the variable with
	100	the function's DECL_RESULT.
	101
	102	This is the equivalent of the C++ named return value optimization
	103	applied to optimized trees in a language independent form. If we
	104	ever encounter languages which prevent this kind of optimization,
	105	then we could either have the languages register the optimization or
	106	we could change the gating function to check the current language. */
48e1416a	107
2a1990e9	108	static unsigned int
4ee9c684	109	tree_nrv (void)
	110	{
	111	tree result = DECL_RESULT (current_function_decl);
	112	tree result_type = TREE_TYPE (result);
	113	tree found = NULL;
	114	basic_block bb;
75a70cf9	115	gimple_stmt_iterator gsi;
4ee9c684	116	struct nrv_data data;
	117
	118	/* If this function does not return an aggregate type in memory, then
	119	there is nothing to do. */
	120	if (!aggregate_value_p (result, current_function_decl))
2a1990e9	121	return 0;
4ee9c684	122
e264d515	123	/* If a GIMPLE type is returned in memory, finalize_nrv_r might create
	124	non-GIMPLE. */
	125	if (is_gimple_reg_type (result_type))
	126	return 0;
	127
93ef9154	128	/* If the front end already did something like this, don't do it here. */
	129	if (DECL_NAME (result))
	130	return 0;
	131
a97b4ced	132	/* If the result has its address taken then it might be modified
	133	by means not detected in the following loop. Bail out in this
	134	case. */
	135	if (TREE_ADDRESSABLE (result))
	136	return 0;
	137
84ef41be	138	/* Look through each block for assignments to the RESULT_DECL. */
4ee9c684	139	FOR_EACH_BB (bb)
4ee9c684	140	{
75a70cf9	141	for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
4ee9c684	142	{
75a70cf9	143	gimple stmt = gsi_stmt (gsi);
75a70cf9	144	tree ret_val;
84ef41be	145
75a70cf9	146	if (gimple_code (stmt) == GIMPLE_RETURN)
4ee9c684	147	{
84ef41be	148	/* In a function with an aggregate return value, the
	149	gimplifier has changed all non-empty RETURN_EXPRs to
	150	return the RESULT_DECL. */
75a70cf9	151	ret_val = gimple_return_retval (stmt);
	152	if (ret_val)
	153	gcc_assert (ret_val == result);
84ef41be	154	}
93ef9154	155	else if (gimple_has_lhs (stmt)
93ef9154	156	&& gimple_get_lhs (stmt) == result)
84ef41be	157	{
75a70cf9	158	tree rhs;
	159
	160	if (!gimple_assign_copy_p (stmt))
	161	return 0;
	162
	163	rhs = gimple_assign_rhs1 (stmt);
84ef41be	164
	165	/* Now verify that this return statement uses the same value
	166	as any previously encountered return statement. */
	167	if (found != NULL)
	168	{
	169	/* If we found a return statement using a different variable
	170	than previous return statements, then we can not perform
	171	NRV optimizations. */
75a70cf9	172	if (found != rhs)
2a1990e9	173	return 0;
84ef41be	174	}
84ef41be	175	else
75a70cf9	176	found = rhs;
84ef41be	177
	178	/* The returned value must be a local automatic variable of the
	179	same type and alignment as the function's result. */
	180	if (TREE_CODE (found) != VAR_DECL
	181	\|\| TREE_THIS_VOLATILE (found)
	182	\|\| DECL_CONTEXT (found) != current_function_decl
	183	\|\| TREE_STATIC (found)
	184	\|\| TREE_ADDRESSABLE (found)
	185	\|\| DECL_ALIGN (found) > DECL_ALIGN (result)
c8ca3ee7	186	\|\| !useless_type_conversion_p (result_type,
a97b4ced	187	TREE_TYPE (found)))
2a1990e9	188	return 0;
4ee9c684	189	}
93ef9154	190	else if (gimple_has_lhs (stmt))
fdf6266d	191	{
93ef9154	192	tree addr = get_base_address (gimple_get_lhs (stmt));
48e1416a	193	/* If there's any MODIFY of component of RESULT,
fdf6266d	194	then bail out. */
	195	if (addr && addr == result)
	196	return 0;
	197	}
4ee9c684	198	}
	199	}
	200
	201	if (!found)
2a1990e9	202	return 0;
4ee9c684	203
	204	/* If dumping details, then note once and only the NRV replacement. */
	205	if (dump_file && (dump_flags & TDF_DETAILS))
	206	{
	207	fprintf (dump_file, "NRV Replaced: ");
	208	print_generic_expr (dump_file, found, dump_flags);
	209	fprintf (dump_file, " with: ");
	210	print_generic_expr (dump_file, result, dump_flags);
	211	fprintf (dump_file, "\n");
	212	}
	213
	214	/* At this point we know that all the return statements return the
	215	same local which has suitable attributes for NRV. Copy debugging
93ef9154	216	information from FOUND to RESULT if it will be useful. But don't set
	217	DECL_ABSTRACT_ORIGIN to point at another function. */
	218	if (!DECL_IGNORED_P (found)
	219	&& !(DECL_ABSTRACT_ORIGIN (found)
	220	&& DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (found)) != current_function_decl))
	221	{
	222	DECL_NAME (result) = DECL_NAME (found);
	223	DECL_SOURCE_LOCATION (result) = DECL_SOURCE_LOCATION (found);
	224	DECL_ABSTRACT_ORIGIN (result) = DECL_ABSTRACT_ORIGIN (found);
	225	}
	226
a97b4ced	227	TREE_ADDRESSABLE (result) \|= TREE_ADDRESSABLE (found);
4ee9c684	228
	229	/* Now walk through the function changing all references to VAR to be
	230	RESULT. */
	231	data.var = found;
	232	data.result = result;
	233	FOR_EACH_BB (bb)
	234	{
75a70cf9	235	for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); )
84ef41be	236	{
75a70cf9	237	gimple stmt = gsi_stmt (gsi);
84ef41be	238	/* If this is a copy from VAR to RESULT, remove it. */
75a70cf9	239	if (gimple_assign_copy_p (stmt)
	240	&& gimple_assign_lhs (stmt) == result
	241	&& gimple_assign_rhs1 (stmt) == found)
a8dd994c	242	{
	243	unlink_stmt_vdef (stmt);
	244	gsi_remove (&gsi, true);
bc8a8451	245	release_defs (stmt);
a8dd994c	246	}
84ef41be	247	else
84ef41be	248	{
75a70cf9	249	struct walk_stmt_info wi;
	250	memset (&wi, 0, sizeof (wi));
	251	wi.info = &data;
a8dd994c	252	data.modified = 0;
75a70cf9	253	walk_gimple_op (stmt, finalize_nrv_r, &wi);
a8dd994c	254	if (data.modified)
a8dd994c	255	update_stmt (stmt);
75a70cf9	256	gsi_next (&gsi);
84ef41be	257	}
84ef41be	258	}
4ee9c684	259	}
4ee9c684	260
e641a23b	261	SET_DECL_VALUE_EXPR (found, result);
	262	DECL_HAS_VALUE_EXPR_P (found) = 1;
	263
2a1990e9	264	return 0;
4ee9c684	265	}
4ee9c684	266
bff4202c	267	static bool
	268	gate_pass_return_slot (void)
	269	{
	270	return optimize > 0;
	271	}
	272
48e1416a	273	struct gimple_opt_pass pass_nrv =
4ee9c684	274	{
20099e35	275	{
20099e35	276	GIMPLE_PASS,
4ee9c684	277	"nrv", /* name */
c7875731	278	OPTGROUP_NONE, /* optinfo_flags */
bff4202c	279	gate_pass_return_slot, /* gate */
4ee9c684	280	tree_nrv, /* execute */
	281	NULL, /* sub */
	282	NULL, /* next */
	283	0, /* static_pass_number */
	284	TV_TREE_NRV, /* tv_id */
a8dd994c	285	PROP_ssa \| PROP_cfg, /* properties_required */
4ee9c684	286	0, /* properties_provided */
	287	0, /* properties_destroyed */
	288	0, /* todo_flags_start */
771e2890	289	TODO_ggc_collect /* todo_flags_finish */
20099e35	290	}
4ee9c684	291	};
ea523851	292
166cf564	293	/* Determine (pessimistically) whether DEST is available for NRV
	294	optimization, where DEST is expected to be the LHS of a modify
	295	expression where the RHS is a function returning an aggregate.
	296
095a3ce9	297	DEST is available if it is not clobbered or used by the call. */
166cf564	298
166cf564	299	static bool
4debfcfc	300	dest_safe_for_nrv_p (gimple call)
166cf564	301	{
4debfcfc	302	tree dest = gimple_call_lhs (call);
fbb5d9ac	303
4debfcfc	304	dest = get_base_address (dest);
4debfcfc	305	if (! dest)
fbb5d9ac	306	return false;
	307
	308	if (TREE_CODE (dest) == SSA_NAME)
4debfcfc	309	return true;
fbb5d9ac	310
095a3ce9	311	if (call_may_clobber_ref_p (call, dest)
095a3ce9	312	\|\| ref_maybe_used_by_stmt_p (call, dest))
fbb5d9ac	313	return false;
fb0ac376	314
fbb5d9ac	315	return true;
166cf564	316	}
166cf564	317
75a70cf9	318	/* Walk through the function looking for GIMPLE_ASSIGNs with calls that
ea523851	319	return in memory on the RHS. For each of these, determine whether it is
	320	safe to pass the address of the LHS as the return slot, and mark the
	321	call appropriately if so.
	322
	323	The NRV shares the return slot with a local variable in the callee; this
	324	optimization shares the return slot with the target of the call within
	325	the caller. If the NRV is performed (which we can't know in general),
	326	this optimization is safe if the address of the target has not
	327	escaped prior to the call. If it has, modifications to the local
	328	variable will produce visible changes elsewhere, as in PR c++/19317. */
	329
2a1990e9	330	static unsigned int
ea523851	331	execute_return_slot_opt (void)
	332	{
	333	basic_block bb;
	334
	335	FOR_EACH_BB (bb)
	336	{
75a70cf9	337	gimple_stmt_iterator gsi;
75a70cf9	338	for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
ea523851	339	{
75a70cf9	340	gimple stmt = gsi_stmt (gsi);
	341	bool slot_opt_p;
	342
	343	if (is_gimple_call (stmt)
	344	&& gimple_call_lhs (stmt)
	345	&& !gimple_call_return_slot_opt_p (stmt)
	346	&& aggregate_value_p (TREE_TYPE (gimple_call_lhs (stmt)),
095a3ce9	347	gimple_call_fndecl (stmt)))
75a70cf9	348	{
75a70cf9	349	/* Check if the location being assigned to is
4debfcfc	350	clobbered by the call. */
4debfcfc	351	slot_opt_p = dest_safe_for_nrv_p (stmt);
75a70cf9	352	gimple_call_set_return_slot_opt (stmt, slot_opt_p);
75a70cf9	353	}
ea523851	354	}
ea523851	355	}
2a1990e9	356	return 0;
ea523851	357	}
ea523851	358
48e1416a	359	struct gimple_opt_pass pass_return_slot =
ea523851	360	{
20099e35	361	{
20099e35	362	GIMPLE_PASS,
ea523851	363	"retslot", /* name */
c7875731	364	OPTGROUP_NONE, /* optinfo_flags */
ea523851	365	NULL, /* gate */
	366	execute_return_slot_opt, /* execute */
	367	NULL, /* sub */
	368	NULL, /* next */
	369	0, /* static_pass_number */
0b1615c1	370	TV_NONE, /* tv_id */
2f8eb909	371	PROP_ssa, /* properties_required */
ea523851	372	0, /* properties_provided */
	373	0, /* properties_destroyed */
	374	0, /* todo_flags_start */
20099e35	375	0 /* todo_flags_finish */
20099e35	376	}
ea523851	377	};