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;
}
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 can not 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->global.inlined_to)
symbol2 = cn->global.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 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->global.inlined_to)
symbol2 = cn->global.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;
}
static unsigned int
ipa_comdats (void)
{
pointer_map<tree> map;
pointer_map<symtab_node *> comdat_head_map;
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 (!symtab_real_symbol_p (symbol))
;
else if ((group = symbol->get_comdat_group ()) != NULL)
{
*map.insert (symbol) = group;
*comdat_head_map.insert (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.insert (symtab_alias_ultimate_target (symbol, NULL)) = 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.contains (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.insert (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)
{
symbol->aux = NULL;
if (!symbol->get_comdat_group ()
&& !symbol->alias
&& symtab_real_symbol_p (symbol))
{
tree group = *map.contains (symbol);
if (group == error_mark_node)
continue;
if (dump_file)
{
fprintf (dump_file, "Localizing symbol\n");
dump_symtab_node (dump_file, symbol);
fprintf (dump_file, "To group: %s\n", IDENTIFIER_POINTER (group));
}
symtab_for_node_and_aliases (symbol, set_comdat_group,
*comdat_head_map.contains (group), true);
}
}
return 0;
}
