[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;

  /* 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);
	    }
	  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_clobbered (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
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);
	245	}
06208009 JM	246	else
06208009 JM	247	{
726a989a RB	248	struct walk_stmt_info wi;
	249	memset (&wi, 0, sizeof (wi));
	250	wi.info = &data;
4e3825db	251	data.modified = 0;
726a989a	252	walk_gimple_op (stmt, finalize_nrv_r, &wi);
4e3825db MM	253	if (data.modified)
4e3825db MM	254	update_stmt (stmt);
726a989a	255	gsi_next (&gsi);
06208009 JM	256	}
06208009 JM	257	}
6de9cd9a DN	258	}
	259
	260	/* FOUND is no longer used. Ensure it gets removed. */
	261	var_ann (found)->used = 0;
c2924966	262	return 0;
6de9cd9a DN	263	}
6de9cd9a DN	264
c72321c9 JH	265	static bool
	266	gate_pass_return_slot (void)
	267	{
	268	return optimize > 0;
	269	}
	270
b8698a0f	271	struct gimple_opt_pass pass_nrv =
6de9cd9a	272	{
8ddbbcae JH	273	{
8ddbbcae JH	274	GIMPLE_PASS,
6de9cd9a	275	"nrv", /* name */
c72321c9	276	gate_pass_return_slot, /* gate */
6de9cd9a DN	277	tree_nrv, /* execute */
	278	NULL, /* sub */
	279	NULL, /* next */
	280	0, /* static_pass_number */
	281	TV_TREE_NRV, /* tv_id */
4e3825db	282	PROP_ssa \| PROP_cfg, /* properties_required */
6de9cd9a DN	283	0, /* properties_provided */
	284	0, /* properties_destroyed */
	285	0, /* todo_flags_start */
8ddbbcae JH	286	TODO_dump_func \| TODO_ggc_collect /* todo_flags_finish */
8ddbbcae JH	287	}
6de9cd9a	288	};
fa47911c	289
f0ce7858 JC	290	/* Determine (pessimistically) whether DEST is available for NRV
	291	optimization, where DEST is expected to be the LHS of a modify
	292	expression where the RHS is a function returning an aggregate.
	293
5611cf0b RG	294	We search for a base VAR_DECL and look to see if it is call clobbered.
5611cf0b RG	295	Note that we could do better, for example, by
f0ce7858 JC	296	attempting to doing points-to analysis on INDIRECT_REFs. */
	297
	298	static bool
	299	dest_safe_for_nrv_p (tree dest)
	300	{
a2daf82c JJ	301	while (handled_component_p (dest))
	302	dest = TREE_OPERAND (dest, 0);
	303
	304	if (! SSA_VAR_P (dest))
	305	return false;
	306
	307	if (TREE_CODE (dest) == SSA_NAME)
	308	dest = SSA_NAME_VAR (dest);
	309
d086d311	310	if (is_call_clobbered (dest))
a2daf82c	311	return false;
eee717aa	312
a2daf82c	313	return true;
f0ce7858 JC	314	}
f0ce7858 JC	315
726a989a	316	/* Walk through the function looking for GIMPLE_ASSIGNs with calls that
fa47911c JM	317	return in memory on the RHS. For each of these, determine whether it is
	318	safe to pass the address of the LHS as the return slot, and mark the
	319	call appropriately if so.
	320
	321	The NRV shares the return slot with a local variable in the callee; this
	322	optimization shares the return slot with the target of the call within
	323	the caller. If the NRV is performed (which we can't know in general),
	324	this optimization is safe if the address of the target has not
	325	escaped prior to the call. If it has, modifications to the local
	326	variable will produce visible changes elsewhere, as in PR c++/19317. */
	327
c2924966	328	static unsigned int
fa47911c JM	329	execute_return_slot_opt (void)
	330	{
	331	basic_block bb;
	332
	333	FOR_EACH_BB (bb)
	334	{
726a989a RB	335	gimple_stmt_iterator gsi;
726a989a RB	336	for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
fa47911c	337	{
726a989a RB	338	gimple stmt = gsi_stmt (gsi);
	339	bool slot_opt_p;
	340
	341	if (is_gimple_call (stmt)
	342	&& gimple_call_lhs (stmt)
	343	&& !gimple_call_return_slot_opt_p (stmt)
	344	&& aggregate_value_p (TREE_TYPE (gimple_call_lhs (stmt)),
	345	gimple_call_fndecl (stmt))
	346	)
	347	{
	348	/* Check if the location being assigned to is
	349	call-clobbered. */
	350	slot_opt_p = dest_safe_for_nrv_p (gimple_call_lhs (stmt));
	351	gimple_call_set_return_slot_opt (stmt, slot_opt_p);
	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	};