[thirdparty/gcc.git] / gcc / ipa-comdats.c

/* Localize comdats.
   Copyright (C) 2014-2019 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/>.  */

/* This is very simple pass that looks for static symbols that are used
   exclusively by symbol within one comdat group.  In this case it makes
   sense to bring the symbol itself into the group to avoid dead code
   that would arrise when the comdat group from current unit is replaced
   by a different copy.  Consider for example:

    static int q(void)
    {
      ....
    }
    inline int t(void)
    {
      return q();
    }

   if Q is used only by T, it makes sense to put Q into T's comdat group.

   The pass solve simple dataflow across the callgraph trying to prove what
   symbols are used exclusively from a given comdat group.

   The implementation maintains a queue linked by AUX pointer terminated by
   pointer value 1. Lattice values are NULL for TOP, actual comdat group, or
   ERROR_MARK_NODE for bottom.

   TODO: When symbol is used only by comdat symbols, but from different groups,
   it would make sense to produce a new comdat group for it with anonymous name.

   TODO2: We can't mix variables and functions within one group.  Currently
   we just give up on references of symbols of different types.  We also should
   handle this by anonymous comdat group section.  */

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#include "tree-pass.h"
#include "cgraph.h"

/* Main dataflow loop propagating comdat groups across
   the symbol table.  All references to SYMBOL are examined
   and NEWGROUP is updated accordingly. MAP holds current lattice
   values for individual symbols.  */

tree
propagate_comdat_group (struct symtab_node *symbol,
			tree newgroup, hash_map<symtab_node *, tree> &map)
{
  int i;
  struct ipa_ref *ref;

  /* Walk all references to SYMBOL, recursively dive into aliases.  */

  for (i = 0;
       symbol->iterate_referring (i, ref)
       && newgroup != error_mark_node; i++)
    {
      struct symtab_node *symbol2 = ref->referring;

      if (ref->use == IPA_REF_ALIAS)
	{
	  newgroup = propagate_comdat_group (symbol2, newgroup, map);
	  continue;
	}

      /* One COMDAT group cannot hold both variables and functions at
	 a same time.  For now we just go to BOTTOM, in future we may
	 invent special comdat groups for this case.  */

      if (symbol->type != symbol2->type)
	{
	  newgroup = error_mark_node;
	  break;
	}

      /* If we see inline clone, its comdat group actually
	 corresponds to the comdat group of the function it is inlined
	 to.  */

      if (cgraph_node * cn = dyn_cast <cgraph_node *> (symbol2))
	{
	  if (cn->inlined_to)
	    symbol2 = cn->inlined_to;
	}

      /* The actual merge operation.  */

      tree *val2 = map.get (symbol2);

      if (val2 && *val2 != newgroup)
	{
	  if (!newgroup)
	    newgroup = *val2;
	  else
	    newgroup = error_mark_node;
	}
    }

  /* If we analyze function, walk also callers.  */

  cgraph_node *cnode = dyn_cast <cgraph_node *> (symbol);

  if (cnode)
    for (struct cgraph_edge * edge = cnode->callers;
	 edge && newgroup != error_mark_node; edge = edge->next_caller)
      {
	struct symtab_node *symbol2 = edge->caller;

	if (cgraph_node * cn = dyn_cast <cgraph_node *> (symbol2))
	  {
	    /* Thunks cannot call across section boundary.  */
	    if (cn->thunk.thunk_p)
	      newgroup = propagate_comdat_group (symbol2, newgroup, map);
	    /* If we see inline clone, its comdat group actually
	       corresponds to the comdat group of the function it
	       is inlined to.  */
	    if (cn->inlined_to)
	      symbol2 = cn->inlined_to;
	  }

        /* The actual merge operation.  */

	tree *val2 = map.get (symbol2);

	if (val2 && *val2 != newgroup)
	  {
	    if (!newgroup)
	      newgroup = *val2;
	    else
	      newgroup = error_mark_node;
	  }
      }
  return newgroup;
}


/* Add all references of SYMBOL that are defined into queue started by FIRST
   and linked by AUX pointer (unless they are already enqueued).
   Walk recursively inlined functions.  */

void
enqueue_references (symtab_node **first,
		    symtab_node *symbol)
{
  int i;
  struct ipa_ref *ref = NULL;

  for (i = 0; symbol->iterate_reference (i, ref); i++)
    {
      symtab_node *node = ref->referred->ultimate_alias_target ();

      /* Always keep thunks in same sections as target function.  */
      if (is_a <cgraph_node *>(node))
	node = dyn_cast <cgraph_node *> (node)->function_symbol ();
      if (!node->aux && node->definition)
	{
	   node->aux = *first;
	   *first = node;
	}
    }

  if (cgraph_node *cnode = dyn_cast <cgraph_node *> (symbol))
    {
      struct cgraph_edge *edge;

      for (edge = cnode->callees; edge; edge = edge->next_callee)
	if (!edge->inline_failed)
	  enqueue_references (first, edge->callee);
	else
	  {
	    symtab_node *node = edge->callee->ultimate_alias_target ();

	    /* Always keep thunks in same sections as target function.  */
	    if (is_a <cgraph_node *>(node))
	      node = dyn_cast <cgraph_node *> (node)->function_symbol ();
	    if (!node->aux && node->definition)
	      {
		 node->aux = *first;
		 *first = node;
	      }
	  }
    }
}

/* Set comdat group of SYMBOL to GROUP.
   Callback for for_node_and_aliases.  */

bool
set_comdat_group (symtab_node *symbol,
	          void *head_p)
{
  symtab_node *head = (symtab_node *)head_p;

  gcc_assert (!symbol->get_comdat_group ());
  if (symbol->real_symbol_p ())
    {
      symbol->set_comdat_group (head->get_comdat_group ());
      symbol->add_to_same_comdat_group (head);
    }
  return false;
}

/* Set comdat group of SYMBOL to GROUP.
   Callback for for_node_thunks_and_aliases.  */

bool
set_comdat_group_1 (cgraph_node *symbol,
		    void *head_p)
{
  return set_comdat_group (symbol, head_p);
}

/* The actual pass with the main dataflow loop.  */

static unsigned int
ipa_comdats (void)
{
  hash_map<symtab_node *, tree> map (251);
  hash_map<tree, symtab_node *> comdat_head_map (251);
  symtab_node *symbol;
  bool comdat_group_seen = false;
  symtab_node *first = (symtab_node *) (void *) 1;
  tree group;

  /* Start the dataflow by assigning comdat group to symbols that are in comdat
     groups already.  All other externally visible symbols must stay, we use
     ERROR_MARK_NODE as bottom for the propagation.  */

  FOR_EACH_DEFINED_SYMBOL (symbol)
    if (!symbol->real_symbol_p ())
      ;
    else if ((group = symbol->get_comdat_group ()) != NULL)
      {
        map.put (symbol, group);
        comdat_head_map.put (group, symbol);
	comdat_group_seen = true;

	/* Mark the symbol so we won't waste time visiting it for dataflow.  */
	symbol->aux = (symtab_node *) (void *) 1;
      }
    /* See symbols that cannot be privatized to comdats; that is externally
       visible symbols or otherwise used ones.  We also do not want to mangle
       user section names.  */
    else if (symbol->externally_visible
	     || symbol->force_output
	     || symbol->used_from_other_partition
	     || TREE_THIS_VOLATILE (symbol->decl)
	     || symbol->get_section ()
	     || (TREE_CODE (symbol->decl) == FUNCTION_DECL
		 && (DECL_STATIC_CONSTRUCTOR (symbol->decl)
		     || DECL_STATIC_DESTRUCTOR (symbol->decl))))
      {
	symtab_node *target = symbol->ultimate_alias_target ();

	/* Always keep thunks in same sections as target function.  */
	if (is_a <cgraph_node *>(target))
	  target = dyn_cast <cgraph_node *> (target)->function_symbol ();
	map.put (target, error_mark_node);

	/* Mark the symbol so we won't waste time visiting it for dataflow.  */
	symbol->aux = (symtab_node *) (void *) 1;
      }
    else
      {
	/* Enqueue symbol for dataflow.  */
        symbol->aux = first;
	first = symbol;
      }

  if (!comdat_group_seen)
    {
      FOR_EACH_DEFINED_SYMBOL (symbol)
        symbol->aux = NULL;
      return 0;
    }

  /* The actual dataflow.  */

  while (first != (void *) 1)
    {
      tree group = NULL;
      tree newgroup, *val;

      symbol = first;
      first = (symtab_node *)first->aux;

      /* Get current lattice value of SYMBOL.  */
      val = map.get (symbol);
      if (val)
	group = *val;

      /* If it is bottom, there is nothing to do; do not clear AUX
	 so we won't re-queue the symbol.  */
      if (group == error_mark_node)
	continue;

      newgroup = propagate_comdat_group (symbol, group, map);

      /* If nothing changed, proceed to next symbol.  */
      if (newgroup == group)
	{
	  symbol->aux = NULL;
	  continue;
	}

      /* Update lattice value and enqueue all references for re-visiting.  */
      gcc_assert (newgroup);
      if (val)
	*val = newgroup;
      else
	map.put (symbol, newgroup);
      enqueue_references (&first, symbol);

      /* We may need to revisit the symbol unless it is BOTTOM.  */
      if (newgroup != error_mark_node)
        symbol->aux = NULL;
    }

  /* Finally assign symbols to the sections.  */

  FOR_EACH_DEFINED_SYMBOL (symbol)
    {
      struct cgraph_node *fun;
      symbol->aux = NULL; 
      if (!symbol->get_comdat_group ()
	  && !symbol->alias
	  && (!(fun = dyn_cast <cgraph_node *> (symbol))
	      || !fun->thunk.thunk_p)
	  && symbol->real_symbol_p ())
	{
	  tree *val = map.get (symbol);

	  /* A NULL here means that SYMBOL is unreachable in the definition
	     of ipa-comdats. Either ipa-comdats is wrong about this or someone
	     forgot to cleanup and remove unreachable functions earlier.  */
	  gcc_assert (val);

	  tree group = *val;

	  if (group == error_mark_node)
	    continue;
	  if (dump_file)
	    {
	      fprintf (dump_file, "Localizing symbol\n");
	      symbol->dump (dump_file);
	      fprintf (dump_file, "To group: %s\n", IDENTIFIER_POINTER (group));
	    }
	  if (is_a <cgraph_node *> (symbol))
	   dyn_cast <cgraph_node *>(symbol)->call_for_symbol_thunks_and_aliases
		  (set_comdat_group_1,
		   *comdat_head_map.get (group),
		   true);
	  else
	   symbol->call_for_symbol_and_aliases
		  (set_comdat_group,
		   *comdat_head_map.get (group),
		   true);
	}
    }
  return 0;
}

namespace {

const pass_data pass_data_ipa_comdats =
{
  IPA_PASS, /* type */
  "comdats", /* name */
  OPTGROUP_NONE, /* optinfo_flags */
  TV_IPA_COMDATS, /* tv_id */
  0, /* properties_required */
  0, /* properties_provided */
  0, /* properties_destroyed */
  0, /* todo_flags_start */
  0, /* todo_flags_finish */
};

class pass_ipa_comdats : public ipa_opt_pass_d
{
public:
  pass_ipa_comdats (gcc::context *ctxt)
    : ipa_opt_pass_d (pass_data_ipa_comdats, ctxt,
		      NULL, /* generate_summary */
		      NULL, /* write_summary */
		      NULL, /* read_summary */
		      NULL, /* write_optimization_summary */
		      NULL, /* read_optimization_summary */
		      NULL, /* stmt_fixup */
		      0, /* function_transform_todo_flags_start */
		      NULL, /* function_transform */
		      NULL) /* variable_transform */
  {}

  /* opt_pass methods: */
  virtual bool gate (function *);
  virtual unsigned int execute (function *) { return ipa_comdats (); }

}; // class pass_ipa_comdats

bool
pass_ipa_comdats::gate (function *)
{
  return HAVE_COMDAT_GROUP;
}

} // anon namespace

ipa_opt_pass_d *
make_pass_ipa_comdats (gcc::context *ctxt)
{
  return new pass_ipa_comdats (ctxt);
}
Commit	Line	Data
a04d9035	1	/* Localize comdats.
a5544970	2	Copyright (C) 2014-2019 Free Software Foundation, Inc.
a04d9035 JH	3
	4	This file is part of GCC.
	5
	6	GCC is free software; you can redistribute it and/or modify it under
	7	the terms of the GNU General Public License as published by the Free
	8	Software Foundation; either version 3, or (at your option) any later
	9	version.
	10
	11	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	12	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GCC; see the file COPYING3. If not see
	18	<http://www.gnu.org/licenses/>. */
	19
	20	/* This is very simple pass that looks for static symbols that are used
53dd3bcc	21	exclusively by symbol within one comdat group. In this case it makes
a04d9035 JH	22	sense to bring the symbol itself into the group to avoid dead code
	23	that would arrise when the comdat group from current unit is replaced
	24	by a different copy. Consider for example:
	25
	26	static int q(void)
	27	{
	28	....
	29	}
	30	inline int t(void)
	31	{
	32	return q();
	33	}
	34
	35	if Q is used only by T, it makes sense to put Q into T's comdat group.
	36
	37	The pass solve simple dataflow across the callgraph trying to prove what
	38	symbols are used exclusively from a given comdat group.
	39
	40	The implementation maintains a queue linked by AUX pointer terminated by
	41	pointer value 1. Lattice values are NULL for TOP, actual comdat group, or
	42	ERROR_MARK_NODE for bottom.
	43
	44	TODO: When symbol is used only by comdat symbols, but from different groups,
	45	it would make sense to produce a new comdat group for it with anonymous name.
	46
	47	TODO2: We can't mix variables and functions within one group. Currently
	48	we just give up on references of symbols of different types. We also should
	49	handle this by anonymous comdat group section. */
	50
	51	#include "config.h"
	52	#include "system.h"
	53	#include "coretypes.h"
	54	#include "tm.h"
957060b5	55	#include "tree.h"
a04d9035	56	#include "tree-pass.h"
957060b5	57	#include "cgraph.h"
a04d9035 JH	58
	59	/* Main dataflow loop propagating comdat groups across
	60	the symbol table. All references to SYMBOL are examined
	61	and NEWGROUP is updated accordingly. MAP holds current lattice
	62	values for individual symbols. */
	63
	64	tree
	65	propagate_comdat_group (struct symtab_node *symbol,
1eb68d2d	66	tree newgroup, hash_map<symtab_node *, tree> &map)
a04d9035 JH	67	{
	68	int i;
	69	struct ipa_ref *ref;
	70
	71	/* Walk all references to SYMBOL, recursively dive into aliases. */
	72
	73	for (i = 0;
d122681a	74	symbol->iterate_referring (i, ref)
a04d9035 JH	75	&& newgroup != error_mark_node; i++)
	76	{
	77	struct symtab_node *symbol2 = ref->referring;
	78
	79	if (ref->use == IPA_REF_ALIAS)
	80	{
	81	newgroup = propagate_comdat_group (symbol2, newgroup, map);
	82	continue;
	83	}
	84
67914693	85	/* One COMDAT group cannot hold both variables and functions at
a04d9035 JH	86	a same time. For now we just go to BOTTOM, in future we may
	87	invent special comdat groups for this case. */
	88
	89	if (symbol->type != symbol2->type)
	90	{
	91	newgroup = error_mark_node;
	92	break;
	93	}
	94
	95	/* If we see inline clone, its comdat group actually
	96	corresponds to the comdat group of the function it is inlined
	97	to. */
	98
	99	if (cgraph_node * cn = dyn_cast <cgraph_node *> (symbol2))
	100	{
a62bfab5 ML	101	if (cn->inlined_to)
a62bfab5 ML	102	symbol2 = cn->inlined_to;
a04d9035 JH	103	}
	104
	105	/* The actual merge operation. */
	106
1eb68d2d	107	tree *val2 = map.get (symbol2);
a04d9035 JH	108
	109	if (val2 && *val2 != newgroup)
	110	{
	111	if (!newgroup)
	112	newgroup = *val2;
	113	else
	114	newgroup = error_mark_node;
	115	}
	116	}
	117
	118	/* If we analyze function, walk also callers. */
	119
	120	cgraph_node cnode = dyn_cast <cgraph_node > (symbol);
	121
	122	if (cnode)
	123	for (struct cgraph_edge * edge = cnode->callers;
	124	edge && newgroup != error_mark_node; edge = edge->next_caller)
	125	{
	126	struct symtab_node *symbol2 = edge->caller;
	127
a04d9035 JH	128	if (cgraph_node * cn = dyn_cast <cgraph_node *> (symbol2))
a04d9035 JH	129	{
67914693	130	/* Thunks cannot call across section boundary. */
930ee116 IE	131	if (cn->thunk.thunk_p)
	132	newgroup = propagate_comdat_group (symbol2, newgroup, map);
	133	/* If we see inline clone, its comdat group actually
	134	corresponds to the comdat group of the function it
	135	is inlined to. */
a62bfab5 ML	136	if (cn->inlined_to)
a62bfab5 ML	137	symbol2 = cn->inlined_to;
a04d9035 JH	138	}
	139
	140	/* The actual merge operation. */
	141
1eb68d2d	142	tree *val2 = map.get (symbol2);
a04d9035 JH	143
	144	if (val2 && *val2 != newgroup)
	145	{
	146	if (!newgroup)
	147	newgroup = *val2;
	148	else
	149	newgroup = error_mark_node;
	150	}
	151	}
	152	return newgroup;
	153	}
	154
	155
	156	/* Add all references of SYMBOL that are defined into queue started by FIRST
	157	and linked by AUX pointer (unless they are already enqueued).
	158	Walk recursively inlined functions. */
	159
	160	void
	161	enqueue_references (symtab_node **first,
	162	symtab_node *symbol)
	163	{
	164	int i;
d122681a	165	struct ipa_ref *ref = NULL;
a04d9035	166
d122681a	167	for (i = 0; symbol->iterate_reference (i, ref); i++)
a04d9035	168	{
d52f5295	169	symtab_node *node = ref->referred->ultimate_alias_target ();
dcbde1f8 JH	170
	171	/* Always keep thunks in same sections as target function. */
	172	if (is_a <cgraph_node *>(node))
	173	node = dyn_cast <cgraph_node *> (node)->function_symbol ();
a04d9035 JH	174	if (!node->aux && node->definition)
	175	{
	176	node->aux = *first;
	177	*first = node;
	178	}
	179	}
	180
	181	if (cgraph_node cnode = dyn_cast <cgraph_node > (symbol))
	182	{
	183	struct cgraph_edge *edge;
	184
	185	for (edge = cnode->callees; edge; edge = edge->next_callee)
	186	if (!edge->inline_failed)
	187	enqueue_references (first, edge->callee);
	188	else
	189	{
d52f5295	190	symtab_node *node = edge->callee->ultimate_alias_target ();
dcbde1f8 JH	191
	192	/* Always keep thunks in same sections as target function. */
	193	if (is_a <cgraph_node *>(node))
	194	node = dyn_cast <cgraph_node *> (node)->function_symbol ();
a04d9035 JH	195	if (!node->aux && node->definition)
	196	{
	197	node->aux = *first;
	198	*first = node;
	199	}
	200	}
	201	}
	202	}
	203
	204	/* Set comdat group of SYMBOL to GROUP.
dcbde1f8	205	Callback for for_node_and_aliases. */
a04d9035 JH	206
	207	bool
	208	set_comdat_group (symtab_node *symbol,
	209	void *head_p)
	210	{
	211	symtab_node head = (symtab_node )head_p;
	212
aede2c10	213	gcc_assert (!symbol->get_comdat_group ());
6291062f JH	214	if (symbol->real_symbol_p ())
	215	{
	216	symbol->set_comdat_group (head->get_comdat_group ());
	217	symbol->add_to_same_comdat_group (head);
	218	}
a04d9035 JH	219	return false;
	220	}
	221
dcbde1f8 JH	222	/* Set comdat group of SYMBOL to GROUP.
	223	Callback for for_node_thunks_and_aliases. */
	224
	225	bool
	226	set_comdat_group_1 (cgraph_node *symbol,
	227	void *head_p)
	228	{
	229	return set_comdat_group (symbol, head_p);
	230	}
	231
a04d9035 JH	232	/* The actual pass with the main dataflow loop. */
	233
	234	static unsigned int
	235	ipa_comdats (void)
	236	{
1eb68d2d TS	237	hash_map<symtab_node *, tree> map (251);
1eb68d2d TS	238	hash_map<tree, symtab_node *> comdat_head_map (251);
a04d9035 JH	239	symtab_node *symbol;
	240	bool comdat_group_seen = false;
	241	symtab_node first = (symtab_node ) (void *) 1;
aede2c10	242	tree group;
a04d9035 JH	243
	244	/* Start the dataflow by assigning comdat group to symbols that are in comdat
	245	groups already. All other externally visible symbols must stay, we use
	246	ERROR_MARK_NODE as bottom for the propagation. */
	247
	248	FOR_EACH_DEFINED_SYMBOL (symbol)
d52f5295	249	if (!symbol->real_symbol_p ())
a04d9035	250	;
aede2c10	251	else if ((group = symbol->get_comdat_group ()) != NULL)
a04d9035	252	{
1eb68d2d TS	253	map.put (symbol, group);
1eb68d2d TS	254	comdat_head_map.put (group, symbol);
a04d9035 JH	255	comdat_group_seen = true;
	256
	257	/* Mark the symbol so we won't waste time visiting it for dataflow. */
	258	symbol->aux = (symtab_node ) (void ) 1;
	259	}
67914693	260	/* See symbols that cannot be privatized to comdats; that is externally
a04d9035 JH	261	visible symbols or otherwise used ones. We also do not want to mangle
	262	user section names. */
	263	else if (symbol->externally_visible
	264	\|\| symbol->force_output
	265	\|\| symbol->used_from_other_partition
	266	\|\| TREE_THIS_VOLATILE (symbol->decl)
24d047a3	267	\|\| symbol->get_section ()
a04d9035 JH	268	\|\| (TREE_CODE (symbol->decl) == FUNCTION_DECL
	269	&& (DECL_STATIC_CONSTRUCTOR (symbol->decl)
	270	\|\| DECL_STATIC_DESTRUCTOR (symbol->decl))))
	271	{
dcbde1f8 JH	272	symtab_node *target = symbol->ultimate_alias_target ();
	273
	274	/* Always keep thunks in same sections as target function. */
	275	if (is_a <cgraph_node *>(target))
	276	target = dyn_cast <cgraph_node *> (target)->function_symbol ();
	277	map.put (target, error_mark_node);
a04d9035 JH	278
	279	/* Mark the symbol so we won't waste time visiting it for dataflow. */
	280	symbol->aux = (symtab_node ) (void ) 1;
	281	}
	282	else
	283	{
	284	/* Enqueue symbol for dataflow. */
	285	symbol->aux = first;
	286	first = symbol;
	287	}
	288
	289	if (!comdat_group_seen)
	290	{
	291	FOR_EACH_DEFINED_SYMBOL (symbol)
	292	symbol->aux = NULL;
	293	return 0;
	294	}
	295
	296	/* The actual dataflow. */
	297
	298	while (first != (void *) 1)
	299	{
	300	tree group = NULL;
	301	tree newgroup, *val;
	302
	303	symbol = first;
	304	first = (symtab_node *)first->aux;
	305
	306	/* Get current lattice value of SYMBOL. */
1eb68d2d	307	val = map.get (symbol);
a04d9035 JH	308	if (val)
	309	group = *val;
	310
	311	/* If it is bottom, there is nothing to do; do not clear AUX
	312	so we won't re-queue the symbol. */
	313	if (group == error_mark_node)
	314	continue;
	315
	316	newgroup = propagate_comdat_group (symbol, group, map);
	317
	318	/* If nothing changed, proceed to next symbol. */
	319	if (newgroup == group)
	320	{
	321	symbol->aux = NULL;
	322	continue;
	323	}
	324
	325	/* Update lattice value and enqueue all references for re-visiting. */
	326	gcc_assert (newgroup);
	327	if (val)
	328	*val = newgroup;
	329	else
1eb68d2d	330	map.put (symbol, newgroup);
a04d9035 JH	331	enqueue_references (&first, symbol);
	332
	333	/* We may need to revisit the symbol unless it is BOTTOM. */
	334	if (newgroup != error_mark_node)
	335	symbol->aux = NULL;
	336	}
	337
	338	/* Finally assign symbols to the sections. */
	339
	340	FOR_EACH_DEFINED_SYMBOL (symbol)
	341	{
62991c35	342	struct cgraph_node *fun;
a04d9035	343	symbol->aux = NULL;
aede2c10	344	if (!symbol->get_comdat_group ()
a04d9035	345	&& !symbol->alias
62991c35	346	&& (!(fun = dyn_cast <cgraph_node *> (symbol))
dcbde1f8	347	\|\| !fun->thunk.thunk_p)
d52f5295	348	&& symbol->real_symbol_p ())
a04d9035	349	{
17e0fc92 JH	350	tree *val = map.get (symbol);
	351
	352	/* A NULL here means that SYMBOL is unreachable in the definition
	353	of ipa-comdats. Either ipa-comdats is wrong about this or someone
	354	forgot to cleanup and remove unreachable functions earlier. */
	355	gcc_assert (val);
	356
	357	tree group = *val;
a04d9035 JH	358
	359	if (group == error_mark_node)
	360	continue;
	361	if (dump_file)
	362	{
	363	fprintf (dump_file, "Localizing symbol\n");
d52f5295	364	symbol->dump (dump_file);
a04d9035 JH	365	fprintf (dump_file, "To group: %s\n", IDENTIFIER_POINTER (group));
a04d9035 JH	366	}
dcbde1f8	367	if (is_a <cgraph_node *> (symbol))
0e081bde	368	dyn_cast <cgraph_node *>(symbol)->call_for_symbol_thunks_and_aliases
dcbde1f8 JH	369	(set_comdat_group_1,
	370	*comdat_head_map.get (group),
	371	true);
	372	else
	373	symbol->call_for_symbol_and_aliases
	374	(set_comdat_group,
	375	*comdat_head_map.get (group),
	376	true);
a04d9035 JH	377	}
	378	}
	379	return 0;
	380	}
	381
	382	namespace {
	383
	384	const pass_data pass_data_ipa_comdats =
	385	{
	386	IPA_PASS, /* type */
	387	"comdats", /* name */
	388	OPTGROUP_NONE, /* optinfo_flags */
a04d9035 JH	389	TV_IPA_COMDATS, /* tv_id */
	390	0, /* properties_required */
	391	0, /* properties_provided */
	392	0, /* properties_destroyed */
	393	0, /* todo_flags_start */
	394	0, /* todo_flags_finish */
	395	};
	396
	397	class pass_ipa_comdats : public ipa_opt_pass_d
	398	{
	399	public:
	400	pass_ipa_comdats (gcc::context *ctxt)
	401	: ipa_opt_pass_d (pass_data_ipa_comdats, ctxt,
	402	NULL, /* generate_summary */
	403	NULL, /* write_summary */
	404	NULL, /* read_summary */
	405	NULL, /* write_optimization_summary */
	406	NULL, /* read_optimization_summary */
	407	NULL, /* stmt_fixup */
	408	0, /* function_transform_todo_flags_start */
	409	NULL, /* function_transform */
	410	NULL) /* variable_transform */
	411	{}
	412
	413	/* opt_pass methods: */
	414	virtual bool gate (function *);
	415	virtual unsigned int execute (function *) { return ipa_comdats (); }
	416
	417	}; // class pass_ipa_comdats
	418
	419	bool
	420	pass_ipa_comdats::gate (function *)
	421	{
29f1e2b1	422	return HAVE_COMDAT_GROUP;
a04d9035 JH	423	}
	424
	425	} // anon namespace
	426
	427	ipa_opt_pass_d *
	428	make_pass_ipa_comdats (gcc::context *ctxt)
	429	{
	430	return new pass_ipa_comdats (ctxt);
	431	}