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

/* Language independent return value optimizations
   Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010
   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 */
  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 */
  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
6de9cd9a	1	/* Language independent return value optimizations
cf835838 JM	2	Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010
cf835838 JM	3	Free Software Foundation, Inc.
6de9cd9a DN	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
9dcd6f09	9	the Free Software Foundation; either version 3, or (at your option)
6de9cd9a DN	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
9dcd6f09 NC	18	along with GCC; see the file COPYING3. If not see
9dcd6f09 NC	19	<http://www.gnu.org/licenses/>. */
6de9cd9a DN	20
	21	#include "config.h"
	22	#include "system.h"
	23	#include "coretypes.h"
	24	#include "tm.h"
	25	#include "tree.h"
6de9cd9a DN	26	#include "function.h"
6de9cd9a DN	27	#include "basic-block.h"
cf835838	28	#include "tree-pretty-print.h"
6de9cd9a	29	#include "tree-flow.h"
6de9cd9a DN	30	#include "tree-pass.h"
6de9cd9a DN	31	#include "langhooks.h"
40013784 SB	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. */
6de9cd9a DN	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
b8698a0f	47	This is basically a generic equivalent to the C++ front-end's
6de9cd9a DN	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
1ea7e6ad	56	/* This is the function's RESULT_DECL. We will replace all occurrences
6de9cd9a DN	57	of VAR with RESULT_DECL when we apply this optimization. */
6de9cd9a DN	58	tree result;
4e3825db	59	int modified;
6de9cd9a DN	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	{
726a989a RB	78	struct walk_stmt_info wi = (struct walk_stmt_info ) data;
726a989a RB	79	struct nrv_data dp = (struct nrv_data ) wi->info;
6de9cd9a DN	80
	81	/* No need to walk into types. */
	82	if (TYPE_P (*tp))
	83	*walk_subtrees = 0;
500b9b49	84
61ada8ae	85	/* Otherwise replace all occurrences of VAR with RESULT. */
6de9cd9a	86	else if (*tp == dp->var)
4e3825db MM	87	{
	88	*tp = dp->result;
	89	dp->modified = 1;
	90	}
6de9cd9a DN	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. */
b8698a0f	107
c2924966	108	static unsigned int
6de9cd9a DN	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;
726a989a	115	gimple_stmt_iterator gsi;
6de9cd9a DN	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))
c2924966	121	return 0;
6de9cd9a	122
12e19e05 JJ	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
7716876b JM	128	/* If the front end already did something like this, don't do it here. */
	129	if (DECL_NAME (result))
	130	return 0;
	131
f1c19648 RG	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
06208009	138	/* Look through each block for assignments to the RESULT_DECL. */
6de9cd9a DN	139	FOR_EACH_BB (bb)
6de9cd9a DN	140	{
726a989a	141	for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
6de9cd9a	142	{
726a989a RB	143	gimple stmt = gsi_stmt (gsi);
726a989a RB	144	tree ret_val;
06208009	145
726a989a	146	if (gimple_code (stmt) == GIMPLE_RETURN)
6de9cd9a	147	{
06208009 JM	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. */
726a989a RB	151	ret_val = gimple_return_retval (stmt);
	152	if (ret_val)
	153	gcc_assert (ret_val == result);
06208009	154	}
7716876b JM	155	else if (gimple_has_lhs (stmt)
7716876b JM	156	&& gimple_get_lhs (stmt) == result)
06208009	157	{
726a989a RB	158	tree rhs;
	159
	160	if (!gimple_assign_copy_p (stmt))
	161	return 0;
	162
	163	rhs = gimple_assign_rhs1 (stmt);
06208009 JM	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. */
726a989a	172	if (found != rhs)
c2924966	173	return 0;
06208009 JM	174	}
06208009 JM	175	else
726a989a	176	found = rhs;
06208009 JM	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)
f4088621	186	\|\| !useless_type_conversion_p (result_type,
f1c19648	187	TREE_TYPE (found)))
c2924966	188	return 0;
6de9cd9a	189	}
7716876b	190	else if (gimple_has_lhs (stmt))
e31657e8	191	{
7716876b	192	tree addr = get_base_address (gimple_get_lhs (stmt));
b8698a0f	193	/* If there's any MODIFY of component of RESULT,
e31657e8 SP	194	then bail out. */
	195	if (addr && addr == result)
	196	return 0;
	197	}
6de9cd9a DN	198	}
	199	}
	200
	201	if (!found)
c2924966	202	return 0;
6de9cd9a DN	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
7716876b JM	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
f1c19648	227	TREE_ADDRESSABLE (result) \|= TREE_ADDRESSABLE (found);
6de9cd9a DN	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	{
726a989a	235	for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); )
06208009	236	{
726a989a	237	gimple stmt = gsi_stmt (gsi);
06208009	238	/* If this is a copy from VAR to RESULT, remove it. */
726a989a RB	239	if (gimple_assign_copy_p (stmt)
	240	&& gimple_assign_lhs (stmt) == result
	241	&& gimple_assign_rhs1 (stmt) == found)
4e3825db MM	242	{
	243	unlink_stmt_vdef (stmt);
	244	gsi_remove (&gsi, true);
3d3f2249	245	release_defs (stmt);
4e3825db	246	}
06208009 JM	247	else
06208009 JM	248	{
726a989a RB	249	struct walk_stmt_info wi;
	250	memset (&wi, 0, sizeof (wi));
	251	wi.info = &data;
4e3825db	252	data.modified = 0;
726a989a	253	walk_gimple_op (stmt, finalize_nrv_r, &wi);
4e3825db MM	254	if (data.modified)
4e3825db MM	255	update_stmt (stmt);
726a989a	256	gsi_next (&gsi);
06208009 JM	257	}
06208009 JM	258	}
6de9cd9a DN	259	}
6de9cd9a DN	260
938650d8 JJ	261	SET_DECL_VALUE_EXPR (found, result);
	262	DECL_HAS_VALUE_EXPR_P (found) = 1;
	263
c2924966	264	return 0;
6de9cd9a DN	265	}
6de9cd9a DN	266
c72321c9 JH	267	static bool
	268	gate_pass_return_slot (void)
	269	{
	270	return optimize > 0;
	271	}
	272
b8698a0f	273	struct gimple_opt_pass pass_nrv =
6de9cd9a	274	{
8ddbbcae JH	275	{
8ddbbcae JH	276	GIMPLE_PASS,
6de9cd9a	277	"nrv", /* name */
c72321c9	278	gate_pass_return_slot, /* gate */
6de9cd9a DN	279	tree_nrv, /* execute */
	280	NULL, /* sub */
	281	NULL, /* next */
	282	0, /* static_pass_number */
	283	TV_TREE_NRV, /* tv_id */
4e3825db	284	PROP_ssa \| PROP_cfg, /* properties_required */
6de9cd9a DN	285	0, /* properties_provided */
	286	0, /* properties_destroyed */
	287	0, /* todo_flags_start */
22c5fa5f	288	TODO_ggc_collect /* todo_flags_finish */
8ddbbcae	289	}
6de9cd9a	290	};
fa47911c	291
f0ce7858 JC	292	/* Determine (pessimistically) whether DEST is available for NRV
	293	optimization, where DEST is expected to be the LHS of a modify
	294	expression where the RHS is a function returning an aggregate.
	295
7f8ac3d7	296	DEST is available if it is not clobbered or used by the call. */
f0ce7858 JC	297
f0ce7858 JC	298	static bool
12de6355	299	dest_safe_for_nrv_p (gimple call)
f0ce7858	300	{
12de6355	301	tree dest = gimple_call_lhs (call);
a2daf82c	302
12de6355 RG	303	dest = get_base_address (dest);
12de6355 RG	304	if (! dest)
a2daf82c JJ	305	return false;
	306
	307	if (TREE_CODE (dest) == SSA_NAME)
12de6355	308	return true;
a2daf82c	309
7f8ac3d7 RG	310	if (call_may_clobber_ref_p (call, dest)
7f8ac3d7 RG	311	\|\| ref_maybe_used_by_stmt_p (call, dest))
a2daf82c	312	return false;
eee717aa	313
a2daf82c	314	return true;
f0ce7858 JC	315	}
f0ce7858 JC	316
726a989a	317	/* Walk through the function looking for GIMPLE_ASSIGNs with calls that
fa47911c JM	318	return in memory on the RHS. For each of these, determine whether it is
	319	safe to pass the address of the LHS as the return slot, and mark the
	320	call appropriately if so.
	321
	322	The NRV shares the return slot with a local variable in the callee; this
	323	optimization shares the return slot with the target of the call within
	324	the caller. If the NRV is performed (which we can't know in general),
	325	this optimization is safe if the address of the target has not
	326	escaped prior to the call. If it has, modifications to the local
	327	variable will produce visible changes elsewhere, as in PR c++/19317. */
	328
c2924966	329	static unsigned int
fa47911c JM	330	execute_return_slot_opt (void)
	331	{
	332	basic_block bb;
	333
	334	FOR_EACH_BB (bb)
	335	{
726a989a RB	336	gimple_stmt_iterator gsi;
726a989a RB	337	for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
fa47911c	338	{
726a989a RB	339	gimple stmt = gsi_stmt (gsi);
	340	bool slot_opt_p;
	341
	342	if (is_gimple_call (stmt)
	343	&& gimple_call_lhs (stmt)
	344	&& !gimple_call_return_slot_opt_p (stmt)
	345	&& aggregate_value_p (TREE_TYPE (gimple_call_lhs (stmt)),
7f8ac3d7	346	gimple_call_fndecl (stmt)))
726a989a RB	347	{
726a989a RB	348	/* Check if the location being assigned to is
12de6355 RG	349	clobbered by the call. */
12de6355 RG	350	slot_opt_p = dest_safe_for_nrv_p (stmt);
726a989a RB	351	gimple_call_set_return_slot_opt (stmt, slot_opt_p);
726a989a RB	352	}
fa47911c JM	353	}
fa47911c JM	354	}
c2924966	355	return 0;
fa47911c JM	356	}
fa47911c JM	357
b8698a0f	358	struct gimple_opt_pass pass_return_slot =
fa47911c	359	{
8ddbbcae JH	360	{
8ddbbcae JH	361	GIMPLE_PASS,
fa47911c JM	362	"retslot", /* name */
	363	NULL, /* gate */
	364	execute_return_slot_opt, /* execute */
	365	NULL, /* sub */
	366	NULL, /* next */
	367	0, /* static_pass_number */
7072a650	368	TV_NONE, /* tv_id */
4effdf02	369	PROP_ssa, /* properties_required */
fa47911c JM	370	0, /* properties_provided */
	371	0, /* properties_destroyed */
	372	0, /* todo_flags_start */
8ddbbcae JH	373	0 /* todo_flags_finish */
8ddbbcae JH	374	}
fa47911c	375	};