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

/* Language independent return value optimizations
   Copyright (C) 2004, 2005, 2007, 2008, 2009 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 "rtl.h"
#include "function.h"
#include "basic-block.h"
#include "expr.h"
#include "diagnostic.h"
#include "tree-flow.h"
#include "timevar.h"
#include "tree-dump.h"
#include "tree-pass.h"
#include "langhooks.h"

/* 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;

  /* 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);
	    }
	  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);
	    }
	}
    }

  /* FOUND is no longer used.  Ensure it gets removed.  */
  var_ann (found)->used = 0;
  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_dump_func | 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.

   We search for a base VAR_DECL and look to see if it is call clobbered.
   Note that we could do better, for example, by
   attempting to doing points-to analysis on INDIRECT_REFs.  */

static bool
dest_safe_for_nrv_p (tree dest)
{
  while (handled_component_p (dest))
    dest = TREE_OPERAND (dest, 0);

  if (! SSA_VAR_P (dest))
    return false;

  if (TREE_CODE (dest) == SSA_NAME)
    dest = SSA_NAME_VAR (dest);

  if (is_call_used (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
	         call-clobbered.  */
	      slot_opt_p = dest_safe_for_nrv_p (gimple_call_lhs (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
7072a650	2	Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
6de9cd9a DN	3
	4	This file is part of GCC.
	5
	6	GCC is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
9dcd6f09	8	the Free Software Foundation; either version 3, or (at your option)
6de9cd9a DN	9	any later version.
	10
	11	GCC is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
9dcd6f09 NC	17	along with GCC; see the file COPYING3. If not see
9dcd6f09 NC	18	<http://www.gnu.org/licenses/>. */
6de9cd9a DN	19
	20	#include "config.h"
	21	#include "system.h"
	22	#include "coretypes.h"
	23	#include "tm.h"
	24	#include "tree.h"
	25	#include "rtl.h"
	26	#include "function.h"
	27	#include "basic-block.h"
	28	#include "expr.h"
	29	#include "diagnostic.h"
	30	#include "tree-flow.h"
	31	#include "timevar.h"
	32	#include "tree-dump.h"
	33	#include "tree-pass.h"
	34	#include "langhooks.h"
	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
	47	This is basically a generic equivalent to the C++ front-end's
	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. */
	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
06208009	132	/* Look through each block for assignments to the RESULT_DECL. */
6de9cd9a DN	133	FOR_EACH_BB (bb)
6de9cd9a DN	134	{
726a989a	135	for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
6de9cd9a	136	{
726a989a RB	137	gimple stmt = gsi_stmt (gsi);
726a989a RB	138	tree ret_val;
06208009	139
726a989a	140	if (gimple_code (stmt) == GIMPLE_RETURN)
6de9cd9a	141	{
06208009 JM	142	/* In a function with an aggregate return value, the
	143	gimplifier has changed all non-empty RETURN_EXPRs to
	144	return the RESULT_DECL. */
726a989a RB	145	ret_val = gimple_return_retval (stmt);
	146	if (ret_val)
	147	gcc_assert (ret_val == result);
06208009	148	}
7716876b JM	149	else if (gimple_has_lhs (stmt)
7716876b JM	150	&& gimple_get_lhs (stmt) == result)
06208009	151	{
726a989a RB	152	tree rhs;
	153
	154	if (!gimple_assign_copy_p (stmt))
	155	return 0;
	156
	157	rhs = gimple_assign_rhs1 (stmt);
06208009 JM	158
	159	/* Now verify that this return statement uses the same value
	160	as any previously encountered return statement. */
	161	if (found != NULL)
	162	{
	163	/* If we found a return statement using a different variable
	164	than previous return statements, then we can not perform
	165	NRV optimizations. */
726a989a	166	if (found != rhs)
c2924966	167	return 0;
06208009 JM	168	}
06208009 JM	169	else
726a989a	170	found = rhs;
06208009 JM	171
	172	/* The returned value must be a local automatic variable of the
	173	same type and alignment as the function's result. */
	174	if (TREE_CODE (found) != VAR_DECL
	175	\|\| TREE_THIS_VOLATILE (found)
	176	\|\| DECL_CONTEXT (found) != current_function_decl
	177	\|\| TREE_STATIC (found)
	178	\|\| TREE_ADDRESSABLE (found)
	179	\|\| DECL_ALIGN (found) > DECL_ALIGN (result)
f4088621 RG	180	\|\| !useless_type_conversion_p (result_type,
f4088621 RG	181	TREE_TYPE (found)))
c2924966	182	return 0;
6de9cd9a	183	}
7716876b	184	else if (gimple_has_lhs (stmt))
e31657e8	185	{
7716876b	186	tree addr = get_base_address (gimple_get_lhs (stmt));
e31657e8 SP	187	/* If there's any MODIFY of component of RESULT,
	188	then bail out. */
	189	if (addr && addr == result)
	190	return 0;
	191	}
6de9cd9a DN	192	}
	193	}
	194
	195	if (!found)
c2924966	196	return 0;
6de9cd9a DN	197
	198	/* If dumping details, then note once and only the NRV replacement. */
	199	if (dump_file && (dump_flags & TDF_DETAILS))
	200	{
	201	fprintf (dump_file, "NRV Replaced: ");
	202	print_generic_expr (dump_file, found, dump_flags);
	203	fprintf (dump_file, " with: ");
	204	print_generic_expr (dump_file, result, dump_flags);
	205	fprintf (dump_file, "\n");
	206	}
	207
	208	/* At this point we know that all the return statements return the
	209	same local which has suitable attributes for NRV. Copy debugging
7716876b JM	210	information from FOUND to RESULT if it will be useful. But don't set
	211	DECL_ABSTRACT_ORIGIN to point at another function. */
	212	if (!DECL_IGNORED_P (found)
	213	&& !(DECL_ABSTRACT_ORIGIN (found)
	214	&& DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (found)) != current_function_decl))
	215	{
	216	DECL_NAME (result) = DECL_NAME (found);
	217	DECL_SOURCE_LOCATION (result) = DECL_SOURCE_LOCATION (found);
	218	DECL_ABSTRACT_ORIGIN (result) = DECL_ABSTRACT_ORIGIN (found);
	219	}
	220
6de9cd9a DN	221	TREE_ADDRESSABLE (result) = TREE_ADDRESSABLE (found);
	222
	223	/* Now walk through the function changing all references to VAR to be
	224	RESULT. */
	225	data.var = found;
	226	data.result = result;
	227	FOR_EACH_BB (bb)
	228	{
726a989a	229	for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); )
06208009	230	{
726a989a	231	gimple stmt = gsi_stmt (gsi);
06208009	232	/* If this is a copy from VAR to RESULT, remove it. */
726a989a RB	233	if (gimple_assign_copy_p (stmt)
	234	&& gimple_assign_lhs (stmt) == result
	235	&& gimple_assign_rhs1 (stmt) == found)
4e3825db MM	236	{
	237	unlink_stmt_vdef (stmt);
	238	gsi_remove (&gsi, true);
	239	}
06208009 JM	240	else
06208009 JM	241	{
726a989a RB	242	struct walk_stmt_info wi;
	243	memset (&wi, 0, sizeof (wi));
	244	wi.info = &data;
4e3825db	245	data.modified = 0;
726a989a	246	walk_gimple_op (stmt, finalize_nrv_r, &wi);
4e3825db MM	247	if (data.modified)
4e3825db MM	248	update_stmt (stmt);
726a989a	249	gsi_next (&gsi);
06208009 JM	250	}
06208009 JM	251	}
6de9cd9a DN	252	}
	253
	254	/* FOUND is no longer used. Ensure it gets removed. */
	255	var_ann (found)->used = 0;
c2924966	256	return 0;
6de9cd9a DN	257	}
6de9cd9a DN	258
c72321c9 JH	259	static bool
	260	gate_pass_return_slot (void)
	261	{
	262	return optimize > 0;
	263	}
	264
8ddbbcae	265	struct gimple_opt_pass pass_nrv =
6de9cd9a	266	{
8ddbbcae JH	267	{
8ddbbcae JH	268	GIMPLE_PASS,
6de9cd9a	269	"nrv", /* name */
c72321c9	270	gate_pass_return_slot, /* gate */
6de9cd9a DN	271	tree_nrv, /* execute */
	272	NULL, /* sub */
	273	NULL, /* next */
	274	0, /* static_pass_number */
	275	TV_TREE_NRV, /* tv_id */
4e3825db	276	PROP_ssa \| PROP_cfg, /* properties_required */
6de9cd9a DN	277	0, /* properties_provided */
	278	0, /* properties_destroyed */
	279	0, /* todo_flags_start */
8ddbbcae JH	280	TODO_dump_func \| TODO_ggc_collect /* todo_flags_finish */
8ddbbcae JH	281	}
6de9cd9a	282	};
fa47911c	283
f0ce7858 JC	284	/* Determine (pessimistically) whether DEST is available for NRV
	285	optimization, where DEST is expected to be the LHS of a modify
	286	expression where the RHS is a function returning an aggregate.
	287
5611cf0b RG	288	We search for a base VAR_DECL and look to see if it is call clobbered.
5611cf0b RG	289	Note that we could do better, for example, by
f0ce7858 JC	290	attempting to doing points-to analysis on INDIRECT_REFs. */
	291
	292	static bool
	293	dest_safe_for_nrv_p (tree dest)
	294	{
a2daf82c JJ	295	while (handled_component_p (dest))
	296	dest = TREE_OPERAND (dest, 0);
	297
	298	if (! SSA_VAR_P (dest))
	299	return false;
	300
	301	if (TREE_CODE (dest) == SSA_NAME)
	302	dest = SSA_NAME_VAR (dest);
	303
115340c7	304	if (is_call_used (dest))
a2daf82c	305	return false;
eee717aa	306
a2daf82c	307	return true;
f0ce7858 JC	308	}
f0ce7858 JC	309
726a989a	310	/* Walk through the function looking for GIMPLE_ASSIGNs with calls that
fa47911c JM	311	return in memory on the RHS. For each of these, determine whether it is
	312	safe to pass the address of the LHS as the return slot, and mark the
	313	call appropriately if so.
	314
	315	The NRV shares the return slot with a local variable in the callee; this
	316	optimization shares the return slot with the target of the call within
	317	the caller. If the NRV is performed (which we can't know in general),
	318	this optimization is safe if the address of the target has not
	319	escaped prior to the call. If it has, modifications to the local
	320	variable will produce visible changes elsewhere, as in PR c++/19317. */
	321
c2924966	322	static unsigned int
fa47911c JM	323	execute_return_slot_opt (void)
	324	{
	325	basic_block bb;
	326
	327	FOR_EACH_BB (bb)
	328	{
726a989a RB	329	gimple_stmt_iterator gsi;
726a989a RB	330	for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
fa47911c	331	{
726a989a RB	332	gimple stmt = gsi_stmt (gsi);
	333	bool slot_opt_p;
	334
	335	if (is_gimple_call (stmt)
	336	&& gimple_call_lhs (stmt)
	337	&& !gimple_call_return_slot_opt_p (stmt)
	338	&& aggregate_value_p (TREE_TYPE (gimple_call_lhs (stmt)),
	339	gimple_call_fndecl (stmt))
	340	)
	341	{
	342	/* Check if the location being assigned to is
	343	call-clobbered. */
	344	slot_opt_p = dest_safe_for_nrv_p (gimple_call_lhs (stmt));
	345	gimple_call_set_return_slot_opt (stmt, slot_opt_p);
	346	}
fa47911c JM	347	}
fa47911c JM	348	}
c2924966	349	return 0;
fa47911c JM	350	}
fa47911c JM	351
8ddbbcae	352	struct gimple_opt_pass pass_return_slot =
fa47911c	353	{
8ddbbcae JH	354	{
8ddbbcae JH	355	GIMPLE_PASS,
fa47911c JM	356	"retslot", /* name */
	357	NULL, /* gate */
	358	execute_return_slot_opt, /* execute */
	359	NULL, /* sub */
	360	NULL, /* next */
	361	0, /* static_pass_number */
7072a650	362	TV_NONE, /* tv_id */
4effdf02	363	PROP_ssa, /* properties_required */
fa47911c JM	364	0, /* properties_provided */
	365	0, /* properties_destroyed */
	366	0, /* todo_flags_start */
8ddbbcae JH	367	0 /* todo_flags_finish */
8ddbbcae JH	368	}
fa47911c	369	};