[thirdparty/gcc.git] / gcc / gimplify-me.c

/* Tree lowering to gimple for middle end use only.  
   This converts the GENERIC functions-as-trees tree representation into
   the GIMPLE form.
   Copyright (C) 2013-2019 Free Software Foundation, Inc.
   Major work done by Sebastian Pop <s.pop@laposte.net>,
   Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.

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 "backend.h"
#include "tree.h"
#include "gimple.h"
#include "ssa.h"
#include "stmt.h"
#include "stor-layout.h"
#include "tree-eh.h"
#include "gimple-iterator.h"
#include "gimplify.h"
#include "gimplify-me.h"


/* Expand EXPR to list of gimple statements STMTS.  GIMPLE_TEST_F specifies
   the predicate that will hold for the result.  If VAR is not NULL, make the
   base variable of the final destination be VAR if suitable.  */

tree
force_gimple_operand_1 (tree expr, gimple_seq *stmts,
			gimple_predicate gimple_test_f, tree var)
{
  enum gimplify_status ret;
  location_t saved_location;

  *stmts = NULL;

  /* gimple_test_f might be more strict than is_gimple_val, make
     sure we pass both.  Just checking gimple_test_f doesn't work
     because most gimple predicates do not work recursively.  */
  if (is_gimple_val (expr)
      && (*gimple_test_f) (expr))
    return expr;

  push_gimplify_context (gimple_in_ssa_p (cfun), true);
  saved_location = input_location;
  input_location = UNKNOWN_LOCATION;

  if (var)
    {
      if (gimple_in_ssa_p (cfun) && is_gimple_reg (var))
	var = make_ssa_name (var);
      expr = build2 (MODIFY_EXPR, TREE_TYPE (var), var, expr);
    }

  if (TREE_CODE (expr) != MODIFY_EXPR
      && TREE_TYPE (expr) == void_type_node)
    {
      gimplify_and_add (expr, stmts);
      expr = NULL_TREE;
    }
  else
    {
      ret = gimplify_expr (&expr, stmts, NULL, gimple_test_f, fb_rvalue);
      gcc_assert (ret != GS_ERROR);
    }

  input_location = saved_location;
  pop_gimplify_context (NULL);

  return expr;
}

/* Expand EXPR to list of gimple statements STMTS.  If SIMPLE is true,
   force the result to be either ssa_name or an invariant, otherwise
   just force it to be a rhs expression.  If VAR is not NULL, make the
   base variable of the final destination be VAR if suitable.  */

tree
force_gimple_operand (tree expr, gimple_seq *stmts, bool simple, tree var)
{
  return force_gimple_operand_1 (expr, stmts,
				 simple ? is_gimple_val : is_gimple_reg_rhs,
				 var);
}

/* Invoke force_gimple_operand_1 for EXPR with parameters GIMPLE_TEST_F
   and VAR.  If some statements are produced, emits them at GSI.
   If BEFORE is true.  the statements are appended before GSI, otherwise
   they are appended after it.  M specifies the way GSI moves after
   insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING are the usual values).  */

tree
force_gimple_operand_gsi_1 (gimple_stmt_iterator *gsi, tree expr,
			    gimple_predicate gimple_test_f,
			    tree var, bool before,
			    enum gsi_iterator_update m)
{
  gimple_seq stmts;

  expr = force_gimple_operand_1 (expr, &stmts, gimple_test_f, var);

  if (!gimple_seq_empty_p (stmts))
    {
      if (before)
	gsi_insert_seq_before (gsi, stmts, m);
      else
	gsi_insert_seq_after (gsi, stmts, m);
    }

  return expr;
}

/* Invoke force_gimple_operand_1 for EXPR with parameter VAR.
   If SIMPLE is true, force the result to be either ssa_name or an invariant,
   otherwise just force it to be a rhs expression.  If some statements are
   produced, emits them at GSI.  If BEFORE is true, the statements are
   appended before GSI, otherwise they are appended after it.  M specifies
   the way GSI moves after insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING
   are the usual values).  */

tree
force_gimple_operand_gsi (gimple_stmt_iterator *gsi, tree expr,
			  bool simple_p, tree var, bool before,
			  enum gsi_iterator_update m)
{
  return force_gimple_operand_gsi_1 (gsi, expr,
				     simple_p
				     ? is_gimple_val : is_gimple_reg_rhs,
				     var, before, m);
}

/* Some transformations like inlining may invalidate the GIMPLE form
   for operands.  This function traverses all the operands in STMT and
   gimplifies anything that is not a valid gimple operand.  Any new
   GIMPLE statements are inserted before *GSI_P.  */

void
gimple_regimplify_operands (gimple *stmt, gimple_stmt_iterator *gsi_p)
{
  size_t i, num_ops;
  tree lhs;
  gimple_seq pre = NULL;
  gimple *post_stmt = NULL;

  push_gimplify_context (gimple_in_ssa_p (cfun));

  switch (gimple_code (stmt))
    {
    case GIMPLE_COND:
      {
	gcond *cond_stmt = as_a <gcond *> (stmt);
	gimplify_expr (gimple_cond_lhs_ptr (cond_stmt), &pre, NULL,
		       is_gimple_val, fb_rvalue);
	gimplify_expr (gimple_cond_rhs_ptr (cond_stmt), &pre, NULL,
		       is_gimple_val, fb_rvalue);
      }
      break;
    case GIMPLE_SWITCH:
      gimplify_expr (gimple_switch_index_ptr (as_a <gswitch *> (stmt)),
		     &pre, NULL, is_gimple_val, fb_rvalue);
      break;
    case GIMPLE_OMP_ATOMIC_LOAD:
      gimplify_expr (gimple_omp_atomic_load_rhs_ptr (
		       as_a <gomp_atomic_load *> (stmt)),
		     &pre, NULL, is_gimple_val, fb_rvalue);
      break;
    case GIMPLE_ASM:
      {
	gasm *asm_stmt = as_a <gasm *> (stmt);
	size_t i, noutputs = gimple_asm_noutputs (asm_stmt);
	const char *constraint, **oconstraints;
	bool allows_mem, allows_reg, is_inout;

	oconstraints
	  = (const char **) alloca ((noutputs) * sizeof (const char *));
	for (i = 0; i < noutputs; i++)
	  {
	    tree op = gimple_asm_output_op (asm_stmt, i);
	    constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
	    oconstraints[i] = constraint;
	    parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
				     &allows_reg, &is_inout);
	    gimplify_expr (&TREE_VALUE (op), &pre, NULL,
			   is_inout ? is_gimple_min_lval : is_gimple_lvalue,
			   fb_lvalue | fb_mayfail);
	  }
	for (i = 0; i < gimple_asm_ninputs (asm_stmt); i++)
	  {
	    tree op = gimple_asm_input_op (asm_stmt, i);
	    constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
	    parse_input_constraint (&constraint, 0, 0, noutputs, 0,
				    oconstraints, &allows_mem, &allows_reg);
	    if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (op))) && allows_mem)
	      allows_reg = 0;
	    if (!allows_reg && allows_mem)
	      gimplify_expr (&TREE_VALUE (op), &pre, NULL,
			     is_gimple_lvalue, fb_lvalue | fb_mayfail);
	    else
	      gimplify_expr (&TREE_VALUE (op), &pre, NULL,
			     is_gimple_asm_val, fb_rvalue);
	  }
      }
      break;
    default:
      /* NOTE: We start gimplifying operands from last to first to
	 make sure that side-effects on the RHS of calls, assignments
	 and ASMs are executed before the LHS.  The ordering is not
	 important for other statements.  */
      num_ops = gimple_num_ops (stmt);
      for (i = num_ops; i > 0; i--)
	{
	  tree op = gimple_op (stmt, i - 1);
	  if (op == NULL_TREE)
	    continue;
	  if (i == 1 && (is_gimple_call (stmt) || is_gimple_assign (stmt)))
	    gimplify_expr (&op, &pre, NULL, is_gimple_lvalue, fb_lvalue);
	  else if (i == 2
		   && is_gimple_assign (stmt)
		   && num_ops == 2
		   && get_gimple_rhs_class (gimple_expr_code (stmt))
		      == GIMPLE_SINGLE_RHS)
	    gimplify_expr (&op, &pre, NULL,
			   rhs_predicate_for (gimple_assign_lhs (stmt)),
			   fb_rvalue);
	  else if (i == 2 && is_gimple_call (stmt))
	    {
	      if (TREE_CODE (op) == FUNCTION_DECL)
		continue;
	      gimplify_expr (&op, &pre, NULL, is_gimple_call_addr, fb_rvalue);
	    }
	  else
	    gimplify_expr (&op, &pre, NULL, is_gimple_val, fb_rvalue);
	  gimple_set_op (stmt, i - 1, op);
	}

      lhs = gimple_get_lhs (stmt);
      /* If the LHS changed it in a way that requires a simple RHS,
	 create temporary.  */
      if (lhs && !is_gimple_reg (lhs))
	{
	  bool need_temp = false;

	  if (is_gimple_assign (stmt)
	      && num_ops == 2
	      && get_gimple_rhs_class (gimple_expr_code (stmt))
		 == GIMPLE_SINGLE_RHS)
	    gimplify_expr (gimple_assign_rhs1_ptr (stmt), &pre, NULL,
			   rhs_predicate_for (gimple_assign_lhs (stmt)),
			   fb_rvalue);
	  else if (is_gimple_reg (lhs))
	    {
	      if (is_gimple_reg_type (TREE_TYPE (lhs)))
		{
		  if (is_gimple_call (stmt))
		    {
		      i = gimple_call_flags (stmt);
		      if ((i & ECF_LOOPING_CONST_OR_PURE)
			  || !(i & (ECF_CONST | ECF_PURE)))
			need_temp = true;
		    }
		  if (stmt_can_throw_internal (cfun, stmt))
		    need_temp = true;
		}
	    }
	  else
	    {
	      if (is_gimple_reg_type (TREE_TYPE (lhs)))
		need_temp = true;
	      else if (TYPE_MODE (TREE_TYPE (lhs)) != BLKmode)
		{
		  if (is_gimple_call (stmt))
		    {
		      tree fndecl = gimple_call_fndecl (stmt);

		      if (!aggregate_value_p (TREE_TYPE (lhs), fndecl)
			  && !(fndecl && DECL_RESULT (fndecl)
			       && DECL_BY_REFERENCE (DECL_RESULT (fndecl))))
			need_temp = true;
		    }
		  else
		    need_temp = true;
		}
	    }
	  if (need_temp)
	    {
	      tree temp = create_tmp_reg (TREE_TYPE (lhs));
	      if (gimple_in_ssa_p (cfun)
		  && is_gimple_reg_type (TREE_TYPE (lhs)))
		temp = make_ssa_name (temp);
	      gimple_set_lhs (stmt, temp);
	      post_stmt = gimple_build_assign (lhs, temp);
	    }
	}
      break;
    }

  if (!gimple_seq_empty_p (pre))
    gsi_insert_seq_before (gsi_p, pre, GSI_SAME_STMT);
  if (post_stmt)
    gsi_insert_after (gsi_p, post_stmt, GSI_NEW_STMT);

  pop_gimplify_context (NULL);

  update_stmt (stmt);
}
Commit	Line	Data
e795d6e1	1	/* Tree lowering to gimple for middle end use only.
	2	This converts the GENERIC functions-as-trees tree representation into
	3	the GIMPLE form.
fbd26352	4	Copyright (C) 2013-2019 Free Software Foundation, Inc.
e795d6e1	5	Major work done by Sebastian Pop <s.pop@laposte.net>,
	6	Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
	7
	8	This file is part of GCC.
	9
	10	GCC is free software; you can redistribute it and/or modify it under
	11	the terms of the GNU General Public License as published by the Free
	12	Software Foundation; either version 3, or (at your option) any later
	13	version.
	14
	15	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	16	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	17	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	18	for more details.
	19
	20	You should have received a copy of the GNU General Public License
	21	along with GCC; see the file COPYING3. If not see
	22	<http://www.gnu.org/licenses/>. */
	23
	24	#include "config.h"
	25	#include "system.h"
	26	#include "coretypes.h"
9ef16211	27	#include "backend.h"
e795d6e1	28	#include "tree.h"
9ef16211	29	#include "gimple.h"
9ef16211	30	#include "ssa.h"
9ed99284	31	#include "stmt.h"
9ed99284	32	#include "stor-layout.h"
bc61cadb	33	#include "tree-eh.h"
e795d6e1	34	#include "gimple-iterator.h"
	35	#include "gimplify.h"
	36	#include "gimplify-me.h"
e795d6e1	37
	38
	39	/* Expand EXPR to list of gimple statements STMTS. GIMPLE_TEST_F specifies
	40	the predicate that will hold for the result. If VAR is not NULL, make the
	41	base variable of the final destination be VAR if suitable. */
	42
	43	tree
	44	force_gimple_operand_1 (tree expr, gimple_seq *stmts,
	45	gimple_predicate gimple_test_f, tree var)
	46	{
	47	enum gimplify_status ret;
e795d6e1	48	location_t saved_location;
	49
	50	*stmts = NULL;
	51
	52	/* gimple_test_f might be more strict than is_gimple_val, make
	53	sure we pass both. Just checking gimple_test_f doesn't work
	54	because most gimple predicates do not work recursively. */
	55	if (is_gimple_val (expr)
	56	&& (*gimple_test_f) (expr))
	57	return expr;
	58
8a4a28a8	59	push_gimplify_context (gimple_in_ssa_p (cfun), true);
e795d6e1	60	saved_location = input_location;
	61	input_location = UNKNOWN_LOCATION;
	62
	63	if (var)
	64	{
8a4a28a8	65	if (gimple_in_ssa_p (cfun) && is_gimple_reg (var))
f9e245b2	66	var = make_ssa_name (var);
e795d6e1	67	expr = build2 (MODIFY_EXPR, TREE_TYPE (var), var, expr);
	68	}
	69
	70	if (TREE_CODE (expr) != MODIFY_EXPR
	71	&& TREE_TYPE (expr) == void_type_node)
	72	{
	73	gimplify_and_add (expr, stmts);
	74	expr = NULL_TREE;
	75	}
	76	else
	77	{
	78	ret = gimplify_expr (&expr, stmts, NULL, gimple_test_f, fb_rvalue);
	79	gcc_assert (ret != GS_ERROR);
	80	}
	81
	82	input_location = saved_location;
	83	pop_gimplify_context (NULL);
	84
	85	return expr;
	86	}
	87
	88	/* Expand EXPR to list of gimple statements STMTS. If SIMPLE is true,
	89	force the result to be either ssa_name or an invariant, otherwise
	90	just force it to be a rhs expression. If VAR is not NULL, make the
	91	base variable of the final destination be VAR if suitable. */
	92
	93	tree
	94	force_gimple_operand (tree expr, gimple_seq *stmts, bool simple, tree var)
	95	{
	96	return force_gimple_operand_1 (expr, stmts,
	97	simple ? is_gimple_val : is_gimple_reg_rhs,
	98	var);
	99	}
	100
	101	/* Invoke force_gimple_operand_1 for EXPR with parameters GIMPLE_TEST_F
	102	and VAR. If some statements are produced, emits them at GSI.
	103	If BEFORE is true. the statements are appended before GSI, otherwise
	104	they are appended after it. M specifies the way GSI moves after
	105	insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING are the usual values). */
	106
	107	tree
	108	force_gimple_operand_gsi_1 (gimple_stmt_iterator *gsi, tree expr,
	109	gimple_predicate gimple_test_f,
	110	tree var, bool before,
	111	enum gsi_iterator_update m)
	112	{
	113	gimple_seq stmts;
	114
	115	expr = force_gimple_operand_1 (expr, &stmts, gimple_test_f, var);
	116
	117	if (!gimple_seq_empty_p (stmts))
	118	{
	119	if (before)
	120	gsi_insert_seq_before (gsi, stmts, m);
	121	else
	122	gsi_insert_seq_after (gsi, stmts, m);
	123	}
	124
	125	return expr;
	126	}
	127
	128	/* Invoke force_gimple_operand_1 for EXPR with parameter VAR.
	129	If SIMPLE is true, force the result to be either ssa_name or an invariant,
	130	otherwise just force it to be a rhs expression. If some statements are
131	produced, emits them at GSI. If BEFORE is true, the statements are
132	appended before GSI, otherwise they are appended after it. M specifies
133	the way GSI moves after insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING
134	are the usual values). */
135
136	tree
137	force_gimple_operand_gsi (gimple_stmt_iterator *gsi, tree expr,
138	bool simple_p, tree var, bool before,
139	enum gsi_iterator_update m)
140	{
141	return force_gimple_operand_gsi_1 (gsi, expr,
142	simple_p
143	? is_gimple_val : is_gimple_reg_rhs,
144	var, before, m);
145	}
146
147	/* Some transformations like inlining may invalidate the GIMPLE form
148	for operands. This function traverses all the operands in STMT and
149	gimplifies anything that is not a valid gimple operand. Any new
150	GIMPLE statements are inserted before GSI_P. /
151
152	void
42acab1c	153	gimple_regimplify_operands (gimple stmt, gimple_stmt_iterator gsi_p)
e795d6e1	154	{
	155	size_t i, num_ops;
	156	tree lhs;
	157	gimple_seq pre = NULL;
42acab1c	158	gimple *post_stmt = NULL;
e795d6e1	159
8a4a28a8	160	push_gimplify_context (gimple_in_ssa_p (cfun));
e795d6e1	161
	162	switch (gimple_code (stmt))
	163	{
	164	case GIMPLE_COND:
1a91d914	165	{
	166	gcond cond_stmt = as_a <gcond > (stmt);
	167	gimplify_expr (gimple_cond_lhs_ptr (cond_stmt), &pre, NULL,
	168	is_gimple_val, fb_rvalue);
	169	gimplify_expr (gimple_cond_rhs_ptr (cond_stmt), &pre, NULL,
	170	is_gimple_val, fb_rvalue);
	171	}
e795d6e1	172	break;
e795d6e1	173	case GIMPLE_SWITCH:
1a91d914	174	gimplify_expr (gimple_switch_index_ptr (as_a <gswitch *> (stmt)),
1a91d914	175	&pre, NULL, is_gimple_val, fb_rvalue);
e795d6e1	176	break;
e795d6e1	177	case GIMPLE_OMP_ATOMIC_LOAD:
1a91d914	178	gimplify_expr (gimple_omp_atomic_load_rhs_ptr (
	179	as_a <gomp_atomic_load *> (stmt)),
	180	&pre, NULL, is_gimple_val, fb_rvalue);
e795d6e1	181	break;
	182	case GIMPLE_ASM:
	183	{
1a91d914	184	gasm asm_stmt = as_a <gasm > (stmt);
1a91d914	185	size_t i, noutputs = gimple_asm_noutputs (asm_stmt);
e795d6e1	186	const char constraint, *oconstraints;
	187	bool allows_mem, allows_reg, is_inout;
	188
	189	oconstraints
	190	= (const char *) alloca ((noutputs) sizeof (const char *));
	191	for (i = 0; i < noutputs; i++)
	192	{
1a91d914	193	tree op = gimple_asm_output_op (asm_stmt, i);
e795d6e1	194	constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
	195	oconstraints[i] = constraint;
	196	parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
	197	&allows_reg, &is_inout);
	198	gimplify_expr (&TREE_VALUE (op), &pre, NULL,
	199	is_inout ? is_gimple_min_lval : is_gimple_lvalue,
	200	fb_lvalue \| fb_mayfail);
	201	}
1a91d914	202	for (i = 0; i < gimple_asm_ninputs (asm_stmt); i++)
e795d6e1	203	{
1a91d914	204	tree op = gimple_asm_input_op (asm_stmt, i);
e795d6e1	205	constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
	206	parse_input_constraint (&constraint, 0, 0, noutputs, 0,
	207	oconstraints, &allows_mem, &allows_reg);
	208	if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (op))) && allows_mem)
	209	allows_reg = 0;
	210	if (!allows_reg && allows_mem)
	211	gimplify_expr (&TREE_VALUE (op), &pre, NULL,
	212	is_gimple_lvalue, fb_lvalue \| fb_mayfail);
	213	else
	214	gimplify_expr (&TREE_VALUE (op), &pre, NULL,
	215	is_gimple_asm_val, fb_rvalue);
	216	}
	217	}
	218	break;
	219	default:
	220	/* NOTE: We start gimplifying operands from last to first to
	221	make sure that side-effects on the RHS of calls, assignments
	222	and ASMs are executed before the LHS. The ordering is not
	223	important for other statements. */
	224	num_ops = gimple_num_ops (stmt);
	225	for (i = num_ops; i > 0; i--)
	226	{
	227	tree op = gimple_op (stmt, i - 1);
	228	if (op == NULL_TREE)
	229	continue;
	230	if (i == 1 && (is_gimple_call (stmt) \|\| is_gimple_assign (stmt)))
	231	gimplify_expr (&op, &pre, NULL, is_gimple_lvalue, fb_lvalue);
	232	else if (i == 2
	233	&& is_gimple_assign (stmt)
	234	&& num_ops == 2
	235	&& get_gimple_rhs_class (gimple_expr_code (stmt))
	236	== GIMPLE_SINGLE_RHS)
	237	gimplify_expr (&op, &pre, NULL,
	238	rhs_predicate_for (gimple_assign_lhs (stmt)),
	239	fb_rvalue);
	240	else if (i == 2 && is_gimple_call (stmt))
	241	{
	242	if (TREE_CODE (op) == FUNCTION_DECL)
	243	continue;
	244	gimplify_expr (&op, &pre, NULL, is_gimple_call_addr, fb_rvalue);
	245	}
	246	else
	247	gimplify_expr (&op, &pre, NULL, is_gimple_val, fb_rvalue);
	248	gimple_set_op (stmt, i - 1, op);
	249	}
	250
	251	lhs = gimple_get_lhs (stmt);
	252	/* If the LHS changed it in a way that requires a simple RHS,
	253	create temporary. */
	254	if (lhs && !is_gimple_reg (lhs))
	255	{
	256	bool need_temp = false;
	257
	258	if (is_gimple_assign (stmt)
	259	&& num_ops == 2
	260	&& get_gimple_rhs_class (gimple_expr_code (stmt))
	261	== GIMPLE_SINGLE_RHS)
	262	gimplify_expr (gimple_assign_rhs1_ptr (stmt), &pre, NULL,
	263	rhs_predicate_for (gimple_assign_lhs (stmt)),
	264	fb_rvalue);
	265	else if (is_gimple_reg (lhs))
	266	{
	267	if (is_gimple_reg_type (TREE_TYPE (lhs)))
	268	{
269	if (is_gimple_call (stmt))
270	{
271	i = gimple_call_flags (stmt);
272	if ((i & ECF_LOOPING_CONST_OR_PURE)
273	\|\| !(i & (ECF_CONST \| ECF_PURE)))
274	need_temp = true;
275	}
aac19106	276	if (stmt_can_throw_internal (cfun, stmt))
e795d6e1	277	need_temp = true;
	278	}
	279	}
	280	else
	281	{
	282	if (is_gimple_reg_type (TREE_TYPE (lhs)))
	283	need_temp = true;
	284	else if (TYPE_MODE (TREE_TYPE (lhs)) != BLKmode)
	285	{
	286	if (is_gimple_call (stmt))
	287	{
	288	tree fndecl = gimple_call_fndecl (stmt);
	289
	290	if (!aggregate_value_p (TREE_TYPE (lhs), fndecl)
	291	&& !(fndecl && DECL_RESULT (fndecl)
	292	&& DECL_BY_REFERENCE (DECL_RESULT (fndecl))))
	293	need_temp = true;
	294	}
	295	else
	296	need_temp = true;
	297	}
	298	}
	299	if (need_temp)
	300	{
f9e245b2	301	tree temp = create_tmp_reg (TREE_TYPE (lhs));
87825cd5	302	if (gimple_in_ssa_p (cfun)
87825cd5	303	&& is_gimple_reg_type (TREE_TYPE (lhs)))
f9e245b2	304	temp = make_ssa_name (temp);
e795d6e1	305	gimple_set_lhs (stmt, temp);
	306	post_stmt = gimple_build_assign (lhs, temp);
	307	}
	308	}
	309	break;
	310	}
	311
	312	if (!gimple_seq_empty_p (pre))
	313	gsi_insert_seq_before (gsi_p, pre, GSI_SAME_STMT);
	314	if (post_stmt)
	315	gsi_insert_after (gsi_p, post_stmt, GSI_NEW_STMT);
	316
	317	pop_gimplify_context (NULL);
2637468b	318
2637468b	319	update_stmt (stmt);
e795d6e1	320	}
	321
	322