struct cgraph_node *prevailing_node)
{
struct cgraph_edge *e, *next;
- bool no_aliases_please = false;
bool compatible_p;
if (cgraph_dump_file)
cgraph_node_name (prevailing_node),
prevailing_node->uid,
IDENTIFIER_POINTER ((*targetm.asm_out.mangle_assembler_name)
- (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node->decl)))));
- }
-
- if (prevailing_node->same_body_alias)
- {
- if (prevailing_node->thunk.thunk_p)
- no_aliases_please = true;
- prevailing_node = prevailing_node->same_body;
+ (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node->symbol.decl)))));
}
/* Merge node flags. */
- if (node->needed)
- cgraph_mark_needed_node (prevailing_node);
+ if (node->symbol.force_output)
+ cgraph_mark_force_output_node (prevailing_node);
if (node->reachable)
cgraph_mark_reachable_node (prevailing_node);
- if (node->address_taken)
+ if (node->symbol.address_taken)
{
gcc_assert (!prevailing_node->global.inlined_to);
cgraph_mark_address_taken_node (prevailing_node);
/* Redirect all incoming edges. */
compatible_p
- = types_compatible_p (TREE_TYPE (TREE_TYPE (prevailing_node->decl)),
- TREE_TYPE (TREE_TYPE (node->decl)));
+ = types_compatible_p (TREE_TYPE (TREE_TYPE (prevailing_node->symbol.decl)),
+ TREE_TYPE (TREE_TYPE (node->symbol.decl)));
for (e = node->callers; e; e = next)
{
next = e->next_caller;
e->call_stmt_cannot_inline_p = 1;
}
/* Redirect incomming references. */
- ipa_clone_refering (prevailing_node, NULL, &node->ref_list);
-
- /* If we have aliases, redirect them to the prevailing node. */
- if (!node->same_body_alias && node->same_body)
- {
- struct cgraph_node *alias, *last;
- /* We prevail aliases/tunks by a thunk. This is doable but
- would need thunk combination. Hopefully no ABI changes will
- every be crazy enough. */
- gcc_assert (!no_aliases_please);
-
- for (alias = node->same_body; alias; alias = alias->next)
- {
- last = alias;
- gcc_assert (alias->same_body_alias);
- alias->same_body = prevailing_node;
- }
- last->next = prevailing_node->same_body;
- /* Node with aliases is prevailed by alias.
- We could handle this, but combining thunks together will be tricky.
- Hopefully this does not happen. */
- if (prevailing_node->same_body)
- prevailing_node->same_body->previous = last;
- prevailing_node->same_body = node->same_body;
- node->same_body = NULL;
- }
+ ipa_clone_referring ((symtab_node)prevailing_node, &node->symbol.ref_list);
/* Finally remove the replaced node. */
- if (node->same_body_alias)
- cgraph_remove_same_body_alias (node);
- else
- cgraph_remove_node (node);
+ cgraph_remove_node (node);
}
/* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging
lto_varpool_replace_node (struct varpool_node *vnode,
struct varpool_node *prevailing_node)
{
- /* Merge node flags. */
- if (vnode->needed)
- {
- gcc_assert (!vnode->analyzed || prevailing_node->analyzed);
- varpool_mark_needed_node (prevailing_node);
- }
- /* Relink aliases. */
- if (vnode->extra_name && !vnode->alias)
- {
- struct varpool_node *alias, *last;
- for (alias = vnode->extra_name;
- alias; alias = alias->next)
- {
- last = alias;
- alias->extra_name = prevailing_node;
- }
-
- if (prevailing_node->extra_name)
- {
- last->next = prevailing_node->extra_name;
- prevailing_node->extra_name->prev = last;
- }
- prevailing_node->extra_name = vnode->extra_name;
- vnode->extra_name = NULL;
- }
gcc_assert (!vnode->finalized || prevailing_node->finalized);
gcc_assert (!vnode->analyzed || prevailing_node->analyzed);
- /* When replacing by an alias, the references goes to the original
- variable. */
- if (prevailing_node->alias && prevailing_node->extra_name)
- prevailing_node = prevailing_node->extra_name;
- ipa_clone_refering (NULL, prevailing_node, &vnode->ref_list);
+ ipa_clone_referring ((symtab_node)prevailing_node, &vnode->symbol.ref_list);
/* Be sure we can garbage collect the initializer. */
- if (DECL_INITIAL (vnode->decl))
- DECL_INITIAL (vnode->decl) = error_mark_node;
+ if (DECL_INITIAL (vnode->symbol.decl))
+ DECL_INITIAL (vnode->symbol.decl) = error_mark_node;
/* Finally remove the replaced node. */
varpool_remove_node (vnode);
}
/* For functions we need a non-discarded body. */
if (TREE_CODE (e->decl) == FUNCTION_DECL)
- return (e->node
- && (e->node->analyzed
- || (e->node->same_body_alias && e->node->same_body->analyzed)));
+ return (e->node && e->node->analyzed);
- /* A variable should have a size. */
else if (TREE_CODE (e->decl) == VAR_DECL)
{
if (!e->vnode)
return false;
- if (e->vnode->finalized)
- return true;
- return e->vnode->alias && e->vnode->extra_name->finalized;
+ return e->vnode->finalized;
}
gcc_unreachable ();
for (e = (lto_symtab_entry_t) *slot; e; e = e->next)
{
if (TREE_CODE (e->decl) == FUNCTION_DECL)
- e->node = cgraph_get_node_or_alias (e->decl);
+ e->node = cgraph_get_node (e->decl);
else if (TREE_CODE (e->decl) == VAR_DECL)
e->vnode = varpool_get_node (e->decl);
+ if (e->resolution == LDPR_PREVAILING_DEF_IRONLY
+ || e->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP
+ || e->resolution == LDPR_PREVAILING_DEF)
+ prevailing = e;
}
- e = (lto_symtab_entry_t) *slot;
-
/* If the chain is already resolved there is nothing else to do. */
- if (e->resolution != LDPR_UNKNOWN)
+ if (prevailing)
return;
/* Find the single non-replaceable prevailing symbol and
for (prevailing = (lto_symtab_entry_t) *slot;
prevailing
&& prevailing->resolution != LDPR_PREVAILING_DEF_IRONLY
+ && prevailing->resolution != LDPR_PREVAILING_DEF_IRONLY_EXP
&& prevailing->resolution != LDPR_PREVAILING_DEF;
prevailing = prevailing->next)
;
for (e = prevailing->next; e; e = e->next)
{
if (e->resolution == LDPR_PREVAILING_DEF_IRONLY
+ || e->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP
|| e->resolution == LDPR_PREVAILING_DEF)
fatal_error ("multiple prevailing defs for %qE",
DECL_NAME (prevailing->decl));
to handle UNKNOWN relocation well.
The problem with storing guessed decision is whether to use
- PREVAILING_DEF or PREVAILING_DEF_IRONLY. First one would disable
- some whole program optimizations, while ther second would imply
- to many whole program assumptions. */
+ PREVAILING_DEF, PREVAILING_DEF_IRONLY, PREVAILING_DEF_IRONLY_EXP.
+ First one would disable some whole program optimizations, while
+ ther second would imply to many whole program assumptions. */
if (prevailing->node && !flag_ltrans && !prevailing->guessed)
- prevailing->node->resolution = prevailing->resolution;
+ prevailing->node->symbol.resolution = prevailing->resolution;
else if (prevailing->vnode && !flag_ltrans && !prevailing->guessed)
- prevailing->vnode->resolution = prevailing->resolution;
+ prevailing->vnode->symbol.resolution = prevailing->resolution;
return 1;
}
void
lto_symtab_merge_cgraph_nodes (void)
{
- struct cgraph_node *node, *alias, *next;
+ struct cgraph_node *node;
+ struct varpool_node *vnode;
lto_symtab_maybe_init_hash_table ();
htab_traverse (lto_symtab_identifiers, lto_symtab_merge_cgraph_nodes_1, NULL);
- for (node = cgraph_nodes; node; node = node->next)
- {
- if (node->thunk.thunk_p)
- node->thunk.alias = lto_symtab_prevailing_decl (node->thunk.alias);
- for (alias = node->same_body; alias; alias = next)
- {
- next = alias->next;
- alias->thunk.alias = lto_symtab_prevailing_decl (alias->thunk.alias);
- }
- }
+ FOR_EACH_FUNCTION (node)
+ if ((node->thunk.thunk_p || node->alias)
+ && node->thunk.alias)
+ node->thunk.alias = lto_symtab_prevailing_decl (node->thunk.alias);
+ FOR_EACH_VARIABLE (vnode)
+ if (vnode->alias_of)
+ vnode->alias_of = lto_symtab_prevailing_decl (vnode->alias_of);
}
/* Given the decl DECL, return the prevailing decl with the same name. */