DEBUG_FUNCTION void
symtab_node::verify_symtab_nodes (void)
{
symtab_node *node;
hash_map<tree, symtab_node *> comdat_head_map (251);
FOR_EACH_SYMBOL (node)
{
node->verify ();
if (node->get_comdat_group ())
{
symtab_node **entry, *s;
bool existed;
entry = &comdat_head_map.get_or_insert (node->get_comdat_group (),
&existed);
if (!existed)
*entry = node;
else
for (s = (*entry)->same_comdat_group; s != NULL && s != node; s = s->same_comdat_group)
if (!s || s == *entry)
{
error ("Two symbols with same comdat_group are not linked by the same_comdat_group list.");
(*entry)->debug ();
node->debug ();
internal_error ("symtab_node::verify failed");
}
}
}
}
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 can not 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))))
{
map.put (symbol->ultimate_alias_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
/* Thunks to external functions do not need to be categorized. */
&& (!(fun = dyn_cast <cgraph_node *> (symbol))
|| !fun->thunk.thunk_p
|| fun->function_symbol ()->definition)
&& 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));
}
symbol->call_for_symbol_and_aliases (set_comdat_group,
*comdat_head_map.get (group),
true);
}
}
return 0;
}
