[gcc.git] / gcc / tree-ssa-copyrename.c

/* Rename SSA copies.
   Copyright (C) 2004, 2006, 2007, 2008 Free Software Foundation, Inc.
   Contributed by Andrew MacLeod <amacleod@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 "tm.h"
#include "tree.h"
#include "flags.h"
#include "basic-block.h"
#include "function.h"
#include "diagnostic.h"
#include "bitmap.h"
#include "tree-flow.h"
#include "tree-gimple.h"
#include "tree-inline.h"
#include "timevar.h"
#include "hashtab.h"
#include "tree-dump.h"
#include "tree-ssa-live.h"
#include "tree-pass.h"
#include "langhooks.h"

/* The following routines implement the SSA copy renaming phase.

   This optimization looks for copies between 2 SSA_NAMES, either through a
   direct copy, or an implicit one via a PHI node result and its arguments.

   Each copy is examined to determine if it is possible to rename the base
   variable of one of the operands to the same variable as the other operand.
   i.e.
   T.3_5 = <blah>
   a_1 = T.3_5

   If this copy couldn't be copy propagated, it could possibly remain in the 
   program throughout the optimization phases.   After SSA->normal, it would 
   become:

   T.3 = <blah>
   a = T.3
   
   Since T.3_5 is distinct from all other SSA versions of T.3, there is no 
   fundamental reason why the base variable needs to be T.3, subject to 
   certain restrictions.  This optimization attempts to determine if we can 
   change the base variable on copies like this, and result in code such as:

   a_5 = <blah>
   a_1 = a_5

   This gives the SSA->normal pass a shot at coalescing a_1 and a_5. If it is 
   possible, the copy goes away completely. If it isn't possible, a new temp
   will be created for a_5, and you will end up with the exact same code:

   a.8 = <blah>
   a = a.8

   The other benefit of performing this optimization relates to what variables
   are chosen in copies.  Gimplification of the program uses temporaries for
   a lot of things. expressions like

   a_1 = <blah>
   <blah2> = a_1

   get turned into 
    
   T.3_5 = <blah>
   a_1 = T.3_5
   <blah2> = a_1

   Copy propagation is done in a forward direction, and if we can propagate
   through the copy, we end up with:

   T.3_5 = <blah>
   <blah2> = T.3_5

   The copy is gone, but so is all reference to the user variable 'a'. By
   performing this optimization, we would see the sequence:

   a_5 = <blah>
   a_1 = a_5
   <blah2> = a_1

   which copy propagation would then turn into:
   
   a_5 = <blah>
   <blah2> = a_5

   and so we still retain the user variable whenever possible.  */


/* Coalesce the partitions in MAP representing VAR1 and VAR2 if it is valid.
   Choose a representative for the partition, and send debug info to DEBUG.  */

static bool
copy_rename_partition_coalesce (var_map map, tree var1, tree var2, FILE *debug)
{
  int p1, p2, p3;
  tree root1, root2;
  tree rep1, rep2;
  var_ann_t ann1, ann2, ann3;
  bool ign1, ign2, abnorm;

  gcc_assert (TREE_CODE (var1) == SSA_NAME);
  gcc_assert (TREE_CODE (var2) == SSA_NAME);

  register_ssa_partition (map, var1);
  register_ssa_partition (map, var2);

  p1 = partition_find (map->var_partition, SSA_NAME_VERSION (var1));
  p2 = partition_find (map->var_partition, SSA_NAME_VERSION (var2));

  if (debug)
    {
      fprintf (debug, "Try : ");
      print_generic_expr (debug, var1, TDF_SLIM);
      fprintf (debug, "(P%d) & ", p1);
      print_generic_expr (debug, var2, TDF_SLIM);
      fprintf (debug, "(P%d)", p2);
    }

  gcc_assert (p1 != NO_PARTITION);
  gcc_assert (p2 != NO_PARTITION);

  rep1 = partition_to_var (map, p1);
  rep2 = partition_to_var (map, p2);
  root1 = SSA_NAME_VAR (rep1);
  root2 = SSA_NAME_VAR (rep2);

  ann1 = var_ann (root1);
  ann2 = var_ann (root2);

  if (p1 == p2)
    {
      if (debug)
	fprintf (debug, " : Already coalesced.\n");
      return false;
    }

  /* Don't coalesce if one of the variables occurs in an abnormal PHI.  */
  abnorm = (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rep1)
	    || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rep2));
  if (abnorm)
    {
      if (debug)
	fprintf (debug, " : Abnormal PHI barrier.  No coalesce.\n");
      return false;
    }

  /* Partitions already have the same root, simply merge them.  */
  if (root1 == root2)
    {
      p1 = partition_union (map->var_partition, p1, p2);
      if (debug)
	fprintf (debug, " : Same root, coalesced --> P%d.\n", p1);
      return false;
    }

  /* Never attempt to coalesce 2 difference parameters.  */
  if (TREE_CODE (root1) == PARM_DECL && TREE_CODE (root2) == PARM_DECL)
    {
      if (debug)
        fprintf (debug, " : 2 different PARM_DECLS. No coalesce.\n");
      return false;
    }

  if ((TREE_CODE (root1) == RESULT_DECL) != (TREE_CODE (root2) == RESULT_DECL))
    {
      if (debug)
        fprintf (debug, " : One root a RESULT_DECL. No coalesce.\n");
      return false;
    }

  ign1 = TREE_CODE (root1) == VAR_DECL && DECL_IGNORED_P (root1);
  ign2 = TREE_CODE (root2) == VAR_DECL && DECL_IGNORED_P (root2);

  /* Never attempt to coalesce 2 user variables unless one is an inline 
     variable.  */
  if (!ign1 && !ign2)
    {
      if (DECL_FROM_INLINE (root2))
        ign2 = true;
      else if (DECL_FROM_INLINE (root1))
	ign1 = true;
      else 
	{
	  if (debug)
	    fprintf (debug, " : 2 different USER vars. No coalesce.\n");
	  return false;
	}
    }

  /* Don't coalesce if there are two different memory tags.  */
  if (ann1->symbol_mem_tag
      && ann2->symbol_mem_tag
      && ann1->symbol_mem_tag != ann2->symbol_mem_tag)
    {
      if (debug)
	fprintf (debug, " : 2 memory tags. No coalesce.\n");
      return false;
    }

  /* If both values have default defs, we can't coalesce.  If only one has a 
     tag, make sure that variable is the new root partition.  */
  if (gimple_default_def (cfun, root1))
    {
      if (gimple_default_def (cfun, root2))
	{
	  if (debug)
	    fprintf (debug, " : 2 default defs. No coalesce.\n");
	  return false;
	}
      else
        {
	  ign2 = true;
	  ign1 = false;
	}
    }
  else if (gimple_default_def (cfun, root2))
    {
      ign1 = true;
      ign2 = false;
    }

  /* Don't coalesce if the two variables aren't type compatible.  */
  if (!types_compatible_p (TREE_TYPE (root1), TREE_TYPE (root2)))
    {
      if (debug)
	fprintf (debug, " : Incompatible types.  No coalesce.\n");
      return false;
    }

  /* Don't coalesce if the aliasing sets of the types are different.  */
  if (POINTER_TYPE_P (TREE_TYPE (root1))
      && POINTER_TYPE_P (TREE_TYPE (root2))
      && ((get_alias_set (TREE_TYPE (TREE_TYPE (root1)))
	   != get_alias_set (TREE_TYPE (TREE_TYPE (root2))))
	  || ((DECL_P (root1) && !MTAG_P (root1))
	      && (DECL_P (root2) && !MTAG_P (root2))
	      && DECL_NO_TBAA_P (root1) != DECL_NO_TBAA_P (root2))))
    {
      if (debug)
	fprintf (debug, " : 2 different aliasing sets. No coalesce.\n");
      return false;
    }


  /* Merge the two partitions.  */
  p3 = partition_union (map->var_partition, p1, p2);

  /* Set the root variable of the partition to the better choice, if there is 
     one.  */
  if (!ign2)
    replace_ssa_name_symbol (partition_to_var (map, p3), root2);
  else if (!ign1)
    replace_ssa_name_symbol (partition_to_var (map, p3), root1);

  /* Update the various flag widgitry of the current base representative.  */
  ann3 = var_ann (SSA_NAME_VAR (partition_to_var (map, p3)));
  if (ann1->symbol_mem_tag)
    ann3->symbol_mem_tag = ann1->symbol_mem_tag;
  else
    ann3->symbol_mem_tag = ann2->symbol_mem_tag;

  if (debug)
    {
      fprintf (debug, " --> P%d ", p3);
      print_generic_expr (debug, SSA_NAME_VAR (partition_to_var (map, p3)), 
			  TDF_SLIM);
      fprintf (debug, "\n");
    }
  return true;
}


/* This function will make a pass through the IL, and attempt to coalesce any
   SSA versions which occur in PHI's or copies.  Coalescing is accomplished by
   changing the underlying root variable of all coalesced version.  This will 
   then cause the SSA->normal pass to attempt to coalesce them all to the same 
   variable.  */

static unsigned int
rename_ssa_copies (void)
{
  var_map map;
  basic_block bb;
  block_stmt_iterator bsi;
  tree phi, stmt, var, part_var;
  unsigned x;
  FILE *debug;
  bool updated = false;

  if (dump_file && (dump_flags & TDF_DETAILS))
    debug = dump_file;
  else
    debug = NULL;

  map = init_var_map (num_ssa_names + 1);

  FOR_EACH_BB (bb)
    {
      /* Scan for real copies.  */
      for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
	{
	  stmt = bsi_stmt (bsi); 
	  if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
	    {
	      tree lhs = GIMPLE_STMT_OPERAND (stmt, 0);
	      tree rhs = GIMPLE_STMT_OPERAND (stmt, 1);

              if (TREE_CODE (lhs) == SSA_NAME && TREE_CODE (rhs) == SSA_NAME)
		updated |= copy_rename_partition_coalesce (map, lhs, rhs, debug);
	    }
	}
    }

  FOR_EACH_BB (bb)
    {
      /* Treat PHI nodes as copies between the result and each argument.  */
      for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
        {
          int i;
	  tree res = PHI_RESULT (phi);

	  /* Do not process virtual SSA_NAMES.  */
	  if (!is_gimple_reg (SSA_NAME_VAR (res)))
	    continue;

          for (i = 0; i < PHI_NUM_ARGS (phi); i++)
            {
              tree arg = PHI_ARG_DEF (phi, i);
              if (TREE_CODE (arg) == SSA_NAME)
		updated |= copy_rename_partition_coalesce (map, res, arg, debug);
            }
        }
    }

  if (debug)
    dump_var_map (debug, map);

  /* Now one more pass to make all elements of a partition share the same
     root variable.  */
  
  for (x = 1; x <= num_ssa_names; x++)
    {
      part_var = partition_to_var (map, x);
      if (!part_var)
        continue;
      var = map->partition_to_var[x];
      if (debug)
        {
	  if (SSA_NAME_VAR (var) != SSA_NAME_VAR (part_var))
	    {
	      fprintf (debug, "Coalesced ");
	      print_generic_expr (debug, var, TDF_SLIM);
	      fprintf (debug, " to ");
	      print_generic_expr (debug, part_var, TDF_SLIM);
	      fprintf (debug, "\n");
	    }
	}
      replace_ssa_name_symbol (var, SSA_NAME_VAR (part_var));
    }

  delete_var_map (map);
  return updated ? TODO_remove_unused_locals : 0;
}

/* Return true if copy rename is to be performed.  */

static bool
gate_copyrename (void)
{
  return flag_tree_copyrename != 0;
}

struct gimple_opt_pass pass_rename_ssa_copies = 
{
 {
  GIMPLE_PASS,
  "copyrename",				/* name */
  gate_copyrename,			/* gate */
  rename_ssa_copies,			/* execute */
  NULL,					/* sub */
  NULL,					/* next */
  0,					/* static_pass_number */
  TV_TREE_COPY_RENAME,			/* tv_id */
  PROP_cfg | PROP_ssa,			/* properties_required */
  0,					/* properties_provided */
  0,					/* properties_destroyed */
  0,					/* todo_flags_start */ 
  TODO_dump_func | TODO_verify_ssa      /* todo_flags_finish */
 }
};
Commit	Line	Data
6de9cd9a	1	/* Rename SSA copies.
e8b0eabc	2	Copyright (C) 2004, 2006, 2007, 2008 Free Software Foundation, Inc.
6de9cd9a DN	3	Contributed by Andrew MacLeod <amacleod@redhat.com>
	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"
	26	#include "flags.h"
	27	#include "basic-block.h"
	28	#include "function.h"
	29	#include "diagnostic.h"
	30	#include "bitmap.h"
	31	#include "tree-flow.h"
eadf906f	32	#include "tree-gimple.h"
6de9cd9a DN	33	#include "tree-inline.h"
6de9cd9a DN	34	#include "timevar.h"
6de9cd9a DN	35	#include "hashtab.h"
	36	#include "tree-dump.h"
	37	#include "tree-ssa-live.h"
	38	#include "tree-pass.h"
bbc630f5	39	#include "langhooks.h"
6de9cd9a	40
6de9cd9a DN	41	/* The following routines implement the SSA copy renaming phase.
	42
	43	This optimization looks for copies between 2 SSA_NAMES, either through a
	44	direct copy, or an implicit one via a PHI node result and its arguments.
	45
	46	Each copy is examined to determine if it is possible to rename the base
	47	variable of one of the operands to the same variable as the other operand.
89dbed81	48	i.e.
6de9cd9a DN	49	T.3_5 = <blah>
	50	a_1 = T.3_5
	51
	52	If this copy couldn't be copy propagated, it could possibly remain in the
	53	program throughout the optimization phases. After SSA->normal, it would
	54	become:
	55
	56	T.3 = <blah>
	57	a = T.3
	58
	59	Since T.3_5 is distinct from all other SSA versions of T.3, there is no
	60	fundamental reason why the base variable needs to be T.3, subject to
	61	certain restrictions. This optimization attempts to determine if we can
	62	change the base variable on copies like this, and result in code such as:
	63
	64	a_5 = <blah>
	65	a_1 = a_5
	66
	67	This gives the SSA->normal pass a shot at coalescing a_1 and a_5. If it is
	68	possible, the copy goes away completely. If it isn't possible, a new temp
	69	will be created for a_5, and you will end up with the exact same code:
	70
	71	a.8 = <blah>
	72	a = a.8
	73
	74	The other benefit of performing this optimization relates to what variables
	75	are chosen in copies. Gimplification of the program uses temporaries for
	76	a lot of things. expressions like
	77
	78	a_1 = <blah>
	79	<blah2> = a_1
	80
	81	get turned into
	82
	83	T.3_5 = <blah>
	84	a_1 = T.3_5
	85	<blah2> = a_1
	86
	87	Copy propagation is done in a forward direction, and if we can propagate
	88	through the copy, we end up with:
	89
	90	T.3_5 = <blah>
	91	<blah2> = T.3_5
	92
	93	The copy is gone, but so is all reference to the user variable 'a'. By
	94	performing this optimization, we would see the sequence:
	95
	96	a_5 = <blah>
	97	a_1 = a_5
	98	<blah2> = a_1
	99
	100	which copy propagation would then turn into:
	101
	102	a_5 = <blah>
	103	<blah2> = a_5
	104
	105	and so we still retain the user variable whenever possible. */
	106
	107
	108	/* Coalesce the partitions in MAP representing VAR1 and VAR2 if it is valid.
	109	Choose a representative for the partition, and send debug info to DEBUG. */
	110
facbf948	111	static bool
6de9cd9a DN	112	copy_rename_partition_coalesce (var_map map, tree var1, tree var2, FILE *debug)
	113	{
	114	int p1, p2, p3;
	115	tree root1, root2;
a78e238e	116	tree rep1, rep2;
6de9cd9a	117	var_ann_t ann1, ann2, ann3;
a78e238e	118	bool ign1, ign2, abnorm;
6de9cd9a	119
1e128c5f GB	120	gcc_assert (TREE_CODE (var1) == SSA_NAME);
1e128c5f GB	121	gcc_assert (TREE_CODE (var2) == SSA_NAME);
6de9cd9a	122
7c6a62dd AM	123	register_ssa_partition (map, var1);
7c6a62dd AM	124	register_ssa_partition (map, var2);
6de9cd9a DN	125
	126	p1 = partition_find (map->var_partition, SSA_NAME_VERSION (var1));
	127	p2 = partition_find (map->var_partition, SSA_NAME_VERSION (var2));
	128
	129	if (debug)
	130	{
	131	fprintf (debug, "Try : ");
	132	print_generic_expr (debug, var1, TDF_SLIM);
	133	fprintf (debug, "(P%d) & ", p1);
	134	print_generic_expr (debug, var2, TDF_SLIM);
	135	fprintf (debug, "(P%d)", p2);
	136	}
	137
1e128c5f GB	138	gcc_assert (p1 != NO_PARTITION);
1e128c5f GB	139	gcc_assert (p2 != NO_PARTITION);
6de9cd9a	140
a78e238e AM	141	rep1 = partition_to_var (map, p1);
	142	rep2 = partition_to_var (map, p2);
	143	root1 = SSA_NAME_VAR (rep1);
	144	root2 = SSA_NAME_VAR (rep2);
6de9cd9a	145
6de9cd9a DN	146	ann1 = var_ann (root1);
	147	ann2 = var_ann (root2);
	148
	149	if (p1 == p2)
	150	{
	151	if (debug)
	152	fprintf (debug, " : Already coalesced.\n");
facbf948	153	return false;
6de9cd9a DN	154	}
6de9cd9a DN	155
49f48e9f AM	156	/* Don't coalesce if one of the variables occurs in an abnormal PHI. */
	157	abnorm = (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rep1)
	158	\|\| SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rep2));
	159	if (abnorm)
	160	{
	161	if (debug)
	162	fprintf (debug, " : Abnormal PHI barrier. No coalesce.\n");
facbf948	163	return false;
49f48e9f AM	164	}
49f48e9f AM	165
6de9cd9a DN	166	/* Partitions already have the same root, simply merge them. */
	167	if (root1 == root2)
	168	{
	169	p1 = partition_union (map->var_partition, p1, p2);
	170	if (debug)
	171	fprintf (debug, " : Same root, coalesced --> P%d.\n", p1);
facbf948	172	return false;
6de9cd9a DN	173	}
	174
	175	/* Never attempt to coalesce 2 difference parameters. */
	176	if (TREE_CODE (root1) == PARM_DECL && TREE_CODE (root2) == PARM_DECL)
	177	{
	178	if (debug)
	179	fprintf (debug, " : 2 different PARM_DECLS. No coalesce.\n");
facbf948	180	return false;
6de9cd9a DN	181	}
6de9cd9a DN	182
f5a76aea RH	183	if ((TREE_CODE (root1) == RESULT_DECL) != (TREE_CODE (root2) == RESULT_DECL))
	184	{
	185	if (debug)
	186	fprintf (debug, " : One root a RESULT_DECL. No coalesce.\n");
facbf948	187	return false;
f5a76aea RH	188	}
f5a76aea RH	189
17ad5b5e RH	190	ign1 = TREE_CODE (root1) == VAR_DECL && DECL_IGNORED_P (root1);
17ad5b5e RH	191	ign2 = TREE_CODE (root2) == VAR_DECL && DECL_IGNORED_P (root2);
6de9cd9a	192
694dd537 AO	193	/* Never attempt to coalesce 2 user variables unless one is an inline
694dd537 AO	194	variable. */
17ad5b5e	195	if (!ign1 && !ign2)
6de9cd9a	196	{
694dd537 AO	197	if (DECL_FROM_INLINE (root2))
	198	ign2 = true;
	199	else if (DECL_FROM_INLINE (root1))
	200	ign1 = true;
	201	else
	202	{
	203	if (debug)
	204	fprintf (debug, " : 2 different USER vars. No coalesce.\n");
	205	return false;
	206	}
6de9cd9a DN	207	}
6de9cd9a DN	208
6de9cd9a	209	/* Don't coalesce if there are two different memory tags. */
18cd8a03 DN	210	if (ann1->symbol_mem_tag
	211	&& ann2->symbol_mem_tag
	212	&& ann1->symbol_mem_tag != ann2->symbol_mem_tag)
6de9cd9a DN	213	{
	214	if (debug)
	215	fprintf (debug, " : 2 memory tags. No coalesce.\n");
facbf948	216	return false;
6de9cd9a DN	217	}
	218
	219	/* If both values have default defs, we can't coalesce. If only one has a
	220	tag, make sure that variable is the new root partition. */
5cd4ec7f	221	if (gimple_default_def (cfun, root1))
6de9cd9a	222	{
5cd4ec7f	223	if (gimple_default_def (cfun, root2))
6de9cd9a DN	224	{
	225	if (debug)
	226	fprintf (debug, " : 2 default defs. No coalesce.\n");
facbf948	227	return false;
6de9cd9a DN	228	}
	229	else
	230	{
17ad5b5e RH	231	ign2 = true;
17ad5b5e RH	232	ign1 = false;
6de9cd9a DN	233	}
6de9cd9a DN	234	}
5cd4ec7f	235	else if (gimple_default_def (cfun, root2))
17ad5b5e RH	236	{
	237	ign1 = true;
	238	ign2 = false;
	239	}
6de9cd9a	240
bbc630f5	241	/* Don't coalesce if the two variables aren't type compatible. */
f4088621	242	if (!types_compatible_p (TREE_TYPE (root1), TREE_TYPE (root2)))
bbc630f5 DN	243	{
	244	if (debug)
	245	fprintf (debug, " : Incompatible types. No coalesce.\n");
facbf948	246	return false;
bbc630f5 DN	247	}
bbc630f5 DN	248
532c67ca AP	249	/* Don't coalesce if the aliasing sets of the types are different. */
	250	if (POINTER_TYPE_P (TREE_TYPE (root1))
	251	&& POINTER_TYPE_P (TREE_TYPE (root2))
e8b0eabc ILT	252	&& ((get_alias_set (TREE_TYPE (TREE_TYPE (root1)))
	253	!= get_alias_set (TREE_TYPE (TREE_TYPE (root2))))
	254	\|\| ((DECL_P (root1) && !MTAG_P (root1))
	255	&& (DECL_P (root2) && !MTAG_P (root2))
	256	&& DECL_NO_TBAA_P (root1) != DECL_NO_TBAA_P (root2))))
532c67ca AP	257	{
532c67ca AP	258	if (debug)
cc9795d4	259	fprintf (debug, " : 2 different aliasing sets. No coalesce.\n");
facbf948	260	return false;
532c67ca AP	261	}
	262
	263
6de9cd9a DN	264	/* Merge the two partitions. */
	265	p3 = partition_union (map->var_partition, p1, p2);
	266
	267	/* Set the root variable of the partition to the better choice, if there is
	268	one. */
17ad5b5e	269	if (!ign2)
bbc630f5	270	replace_ssa_name_symbol (partition_to_var (map, p3), root2);
17ad5b5e RH	271	else if (!ign1)
17ad5b5e RH	272	replace_ssa_name_symbol (partition_to_var (map, p3), root1);
6de9cd9a DN	273
	274	/* Update the various flag widgitry of the current base representative. */
	275	ann3 = var_ann (SSA_NAME_VAR (partition_to_var (map, p3)));
18cd8a03 DN	276	if (ann1->symbol_mem_tag)
18cd8a03 DN	277	ann3->symbol_mem_tag = ann1->symbol_mem_tag;
6de9cd9a	278	else
18cd8a03	279	ann3->symbol_mem_tag = ann2->symbol_mem_tag;
6de9cd9a DN	280
	281	if (debug)
	282	{
	283	fprintf (debug, " --> P%d ", p3);
	284	print_generic_expr (debug, SSA_NAME_VAR (partition_to_var (map, p3)),
	285	TDF_SLIM);
	286	fprintf (debug, "\n");
	287	}
facbf948	288	return true;
6de9cd9a DN	289	}
	290
	291
	292	/* This function will make a pass through the IL, and attempt to coalesce any
	293	SSA versions which occur in PHI's or copies. Coalescing is accomplished by
	294	changing the underlying root variable of all coalesced version. This will
	295	then cause the SSA->normal pass to attempt to coalesce them all to the same
	296	variable. */
	297
c2924966	298	static unsigned int
6de9cd9a DN	299	rename_ssa_copies (void)
	300	{
	301	var_map map;
	302	basic_block bb;
	303	block_stmt_iterator bsi;
	304	tree phi, stmt, var, part_var;
	305	unsigned x;
	306	FILE *debug;
facbf948	307	bool updated = false;
6de9cd9a DN	308
	309	if (dump_file && (dump_flags & TDF_DETAILS))
	310	debug = dump_file;
	311	else
	312	debug = NULL;
	313
95a3742c	314	map = init_var_map (num_ssa_names + 1);
6de9cd9a DN	315
	316	FOR_EACH_BB (bb)
	317	{
	318	/* Scan for real copies. */
	319	for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
	320	{
	321	stmt = bsi_stmt (bsi);
07beea0d	322	if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
6de9cd9a	323	{
07beea0d AH	324	tree lhs = GIMPLE_STMT_OPERAND (stmt, 0);
07beea0d AH	325	tree rhs = GIMPLE_STMT_OPERAND (stmt, 1);
6de9cd9a	326
26e79d10	327	if (TREE_CODE (lhs) == SSA_NAME && TREE_CODE (rhs) == SSA_NAME)
facbf948	328	updated \|= copy_rename_partition_coalesce (map, lhs, rhs, debug);
6de9cd9a DN	329	}
	330	}
	331	}
	332
	333	FOR_EACH_BB (bb)
	334	{
	335	/* Treat PHI nodes as copies between the result and each argument. */
17192884	336	for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
6de9cd9a DN	337	{
	338	int i;
	339	tree res = PHI_RESULT (phi);
	340
26e79d10 RH	341	/* Do not process virtual SSA_NAMES. */
26e79d10 RH	342	if (!is_gimple_reg (SSA_NAME_VAR (res)))
6de9cd9a DN	343	continue;
	344
	345	for (i = 0; i < PHI_NUM_ARGS (phi); i++)
	346	{
	347	tree arg = PHI_ARG_DEF (phi, i);
	348	if (TREE_CODE (arg) == SSA_NAME)
facbf948	349	updated \|= copy_rename_partition_coalesce (map, res, arg, debug);
6de9cd9a DN	350	}
	351	}
	352	}
	353
	354	if (debug)
	355	dump_var_map (debug, map);
	356
	357	/* Now one more pass to make all elements of a partition share the same
	358	root variable. */
	359
95a3742c	360	for (x = 1; x <= num_ssa_names; x++)
6de9cd9a DN	361	{
	362	part_var = partition_to_var (map, x);
	363	if (!part_var)
	364	continue;
	365	var = map->partition_to_var[x];
	366	if (debug)
	367	{
	368	if (SSA_NAME_VAR (var) != SSA_NAME_VAR (part_var))
	369	{
	370	fprintf (debug, "Coalesced ");
	371	print_generic_expr (debug, var, TDF_SLIM);
	372	fprintf (debug, " to ");
	373	print_generic_expr (debug, part_var, TDF_SLIM);
	374	fprintf (debug, "\n");
	375	}
	376	}
bbc630f5	377	replace_ssa_name_symbol (var, SSA_NAME_VAR (part_var));
6de9cd9a DN	378	}
	379
	380	delete_var_map (map);
facbf948	381	return updated ? TODO_remove_unused_locals : 0;
6de9cd9a DN	382	}
	383
	384	/* Return true if copy rename is to be performed. */
	385
	386	static bool
	387	gate_copyrename (void)
	388	{
	389	return flag_tree_copyrename != 0;
	390	}
	391
8ddbbcae JH	392	struct gimple_opt_pass pass_rename_ssa_copies =
	393	{
	394	{
	395	GIMPLE_PASS,
6de9cd9a DN	396	"copyrename", /* name */
	397	gate_copyrename, /* gate */
	398	rename_ssa_copies, /* execute */
	399	NULL, /* sub */
	400	NULL, /* next */
	401	0, /* static_pass_number */
	402	TV_TREE_COPY_RENAME, /* tv_id */
7faade0f	403	PROP_cfg \| PROP_ssa, /* properties_required */
6de9cd9a DN	404	0, /* properties_provided */
	405	0, /* properties_destroyed */
	406	0, /* todo_flags_start */
8ddbbcae JH	407	TODO_dump_func \| TODO_verify_ssa /* todo_flags_finish */
8ddbbcae JH	408	}
6de9cd9a DN	409	};
6de9cd9a DN	410