lto-symtab.c (lto_varpool_replace_node): Do not merge needed flags.

[gcc.git] / gcc / lto-symtab.c

diff --git a/gcc/lto-symtab.c b/gcc/lto-symtab.c
index 3a7c783f770efb3da8aa9facfd9c4ffe3b70f9fb..f1424447d0fa9e56657677e0fba2363a2693fa12 100644 (file)
--- a/gcc/lto-symtab.c
+++ b/gcc/lto-symtab.c
@@ -219,15 +219,15 @@ lto_cgraph_replace_node (struct cgraph_node *node,
               cgraph_node_name (prevailing_node),
               prevailing_node->uid,
               IDENTIFIER_POINTER ((*targetm.asm_out.mangle_assembler_name)
-                (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node->decl)))));
+                (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);
@@ -235,8 +235,8 @@ lto_cgraph_replace_node (struct cgraph_node *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;
@@ -249,7 +249,7 @@ lto_cgraph_replace_node (struct cgraph_node *node,
        e->call_stmt_cannot_inline_p = 1;
     }
   /* Redirect incomming references.  */
-  ipa_clone_refering (prevailing_node, NULL, &node->ref_list);
+  ipa_clone_referring ((symtab_node)prevailing_node, &node->symbol.ref_list);
 
   /* Finally remove the replaced node.  */
   cgraph_remove_node (node);
@@ -262,20 +262,14 @@ static void
 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);
-    }
   gcc_assert (!vnode->finalized || prevailing_node->finalized);
   gcc_assert (!vnode->analyzed || prevailing_node->analyzed);
 
-  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);
 }
@@ -441,12 +435,14 @@ lto_symtab_resolve_symbols (void **slot)
        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
@@ -586,6 +582,7 @@ lto_symtab_merge_decls_1 (void **slot, void *data ATTRIBUTE_UNUSED)
   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)
     ;
@@ -595,6 +592,7 @@ lto_symtab_merge_decls_1 (void **slot, void *data ATTRIBUTE_UNUSED)
     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));
@@ -685,13 +683,13 @@ lto_symtab_merge_decls_1 (void **slot, void *data ATTRIBUTE_UNUSED)
      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;
 }
 
@@ -757,11 +755,11 @@ lto_symtab_merge_cgraph_nodes (void)
   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)
+  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 (vnode = varpool_nodes; vnode; vnode = vnode->next)
+  FOR_EACH_VARIABLE (vnode)
     if (vnode->alias_of)
       vnode->alias_of = lto_symtab_prevailing_decl (vnode->alias_of);
 }