* c-family/c-common.c (handle_alias_ifunc_attribute): Do not set

	DECL_EXTERNAL for weakref variables.
	* c-family/c-pragma.c (handle_pragma_weak): Make sure aliases
	are not declared as external.
	* cgraph.c (cgraph_create_function_alias): Set weakref flag.
	* cgraph.h (symtab_node_base): Add weakref flag.
	* cgraphunit.c (cgraph_reset_node): Clear weakref flag.
	(handle_alias_pairs): Set weakref flag, do not set DECL_EXTERNAL.
	(output_weakrefs): Use weakref flag.
	* fold-const.c (simple_operand_p): Handle WEAK.
	* gimple-fold.c (can_refer_decl_in_current_unit_p): Drop weakref.
	* ipa.c (varpool_externally_visible_p): Drop weakref.
	(function_and_variable_visibility): Update comment; fix weakref
	sanity checks; do not clear DECL_WEAK on them.
	* lto-cgraph.c (lto_output_node): update.
	(lto_output_varpool_node): Update.
	(input_overwrite_node): Update.
	(input_node): Update.
	(input_varpool_node): Update.
	* lto-symtab.c (lto_symtab_symbol_p): Do not special case weakrefs.
	(lto_symtab_merge_symbols): Add sanity check.
	(lto_symtab_prevailing_decl): Do not special case weakrefs.
	* passes.c (rest_of_decl_compilation): Set static flag, too.
	* symtab.c (dump_symtab_base): Dump weakref.
	(verify_symtab_base): Sanity check weakrefs.
	(symtab_make_decl_local): Remove duplicated code.
	(symtab_alias_ultimate_target): Simplify.
	* varpool.c (varpool_create_variable_alias): Set weakref flag.

	* lto-partition.c (get_symbol_class): Simplify weakref handling.
	(add_symbol_to_partition_1): Likewise.
	(contained_in_symbol): Likewise.
	(lto_balanced_map): Likewise.
	(rename_statics): Drop weakref.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@199971 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index baab301..486b77f 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,30 @@
+2013-06-11  Jan Hubicka  <jh@suse.cz>
+
+       * cgraph.c (cgraph_create_function_alias): Set weakref flag.
+       * cgraph.h (symtab_node_base): Add weakref flag.
+       * cgraphunit.c (cgraph_reset_node): Clear weakref flag.
+       (handle_alias_pairs): Set weakref flag, do not set DECL_EXTERNAL.
+       (output_weakrefs): Use weakref flag.
+       * fold-const.c (simple_operand_p): Handle WEAK.
+       * gimple-fold.c (can_refer_decl_in_current_unit_p): Drop weakref.
+       * ipa.c (varpool_externally_visible_p): Drop weakref.
+       (function_and_variable_visibility): Update comment; fix weakref
+       sanity checks; do not clear DECL_WEAK on them.
+       * lto-cgraph.c (lto_output_node): update.
+       (lto_output_varpool_node): Update.
+       (input_overwrite_node): Update.
+       (input_node): Update.
+       (input_varpool_node): Update.
+       * lto-symtab.c (lto_symtab_symbol_p): Do not special case weakrefs.
+       (lto_symtab_merge_symbols): Add sanity check.
+       (lto_symtab_prevailing_decl): Do not special case weakrefs.
+       * passes.c (rest_of_decl_compilation): Set static flag, too.
+       * symtab.c (dump_symtab_base): Dump weakref.
+       (verify_symtab_base): Sanity check weakrefs.
+       (symtab_make_decl_local): Remove duplicated code.
+       (symtab_alias_ultimate_target): Simplify.
+       * varpool.c (varpool_create_variable_alias): Set weakref flag.
+       
 2013-06-11  DJ Delorie  <dj@redhat.com>
 
        * config/rl78/rl78.c (TARGET_UNWIND_WORD_MODE): Define.

diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog
index aaa1b76..3d8f68f 100644 (file)
--- a/gcc/c-family/ChangeLog
+++ b/gcc/c-family/ChangeLog
@@ -1,3 +1,10 @@
+2013-06-11  Jan Hubicka  <jh@suse.cz>
+
+       * c-common.c (handle_alias_ifunc_attribute): Do not set
+       DECL_EXTERNAL for weakref variables.
+       * c-pragma.c (handle_pragma_weak): Make sure aliases
+       are not declared as external.
+
 2013-06-07  Balaji V. Iyer  <balaji.v.iyer@intel.com>
 
        * array-notation-common.c (length_mismatch_in_expr_p): Moved this

diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c
index dec887f..7cb8734 100644 (file)
--- a/gcc/c-family/c-common.c
+++ b/gcc/c-family/c-common.c
@@ -7576,13 +7576,7 @@ handle_alias_ifunc_attribute (bool is_alias, tree *node, tree name, tree args,
       if (TREE_CODE (decl) == FUNCTION_DECL)
        DECL_INITIAL (decl) = error_mark_node;
       else
-       {
-         if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
-           DECL_EXTERNAL (decl) = 1;
-         else
-           DECL_EXTERNAL (decl) = 0;
-         TREE_STATIC (decl) = 1;
-       }
+       TREE_STATIC (decl) = 1;
 
       if (!is_alias)
        /* ifuncs are also aliases, so set that attribute too. */

diff --git a/gcc/c-family/c-pragma.c b/gcc/c-family/c-pragma.c
index d63cbd2..309859f 100644 (file)
--- a/gcc/c-family/c-pragma.c
+++ b/gcc/c-family/c-pragma.c
@@ -367,7 +367,12 @@ handle_pragma_weak (cpp_reader * ARG_UNUSED (dummy))
     {
       apply_pragma_weak (decl, value);
       if (value)
-       assemble_alias (decl, value);
+       {
+         DECL_EXTERNAL (decl) = 0;
+         if (TREE_CODE (decl) == VAR_DECL)
+           TREE_STATIC (decl) = 1;
+         assemble_alias (decl, value);
+       }
     }
   else
     {

diff --git a/gcc/cgraph.c b/gcc/cgraph.c
index 7bcff20..9ebe905 100644 (file)
--- a/gcc/cgraph.c
+++ b/gcc/cgraph.c
@@ -568,6 +568,8 @@ cgraph_create_function_alias (tree alias, tree target)
   alias_node->symbol.alias_target = target;
   alias_node->symbol.definition = true;
   alias_node->symbol.alias = true;
+  if (lookup_attribute ("weakref", DECL_ATTRIBUTES (alias)) != NULL)
+    alias_node->symbol.weakref = true;
   return alias_node;
 }
 

diff --git a/gcc/cgraph.h b/gcc/cgraph.h
index dda4402..c67506d 100644 (file)
--- a/gcc/cgraph.h
+++ b/gcc/cgraph.h
@@ -56,6 +56,8 @@ struct GTY(()) symtab_node_base
   /* True when symbol is an alias.  
      Set by assemble_alias.  */
   unsigned alias : 1;
+  /* True when alias is a weakref.  */
+  unsigned weakref : 1;
   /* C++ frontend produce same body aliases and extra name aliases for
      virutal functions and vtables that are obviously equivalent.
      Those aliases are bit special, especially because C++ frontend

diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c
index 044bdf7..016a6e4 100644 (file)
--- a/gcc/cgraphunit.c
+++ b/gcc/cgraphunit.c
@@ -379,6 +379,7 @@ cgraph_reset_node (struct cgraph_node *node)
   node->symbol.analyzed = false;
   node->symbol.definition = false;
   node->symbol.alias = false;
+  node->symbol.weakref = false;
   node->symbol.cpp_implicit_alias = false;
 
   cgraph_node_remove_callees (node);
@@ -1021,9 +1022,9 @@ handle_alias_pairs (void)
          if (node)
            {
              node->symbol.alias_target = p->target;
+             node->symbol.weakref = true;
              node->symbol.alias = true;
            }
-         DECL_EXTERNAL (p->decl) = 1;
          alias_pairs->unordered_remove (i);
          continue;
        }
@@ -1034,16 +1035,6 @@ handle_alias_pairs (void)
          continue;
        }
 
-      /* Normally EXTERNAL flag is used to mark external inlines,
-        however for aliases it seems to be allowed to use it w/o
-        any meaning. See gcc.dg/attr-alias-3.c  
-        However for weakref we insist on EXTERNAL flag being set.
-        See gcc.dg/attr-alias-5.c  */
-      if (DECL_EXTERNAL (p->decl))
-       DECL_EXTERNAL (p->decl)
-         = lookup_attribute ("weakref",
-                             DECL_ATTRIBUTES (p->decl)) != NULL;
-
       if (DECL_EXTERNAL (target_node->symbol.decl)
          /* We use local aliases for C++ thunks to force the tailcall
             to bind locally.  This is a hack - to keep it working do
@@ -1885,9 +1876,9 @@ output_weakrefs (void)
 {
   symtab_node node;
   FOR_EACH_SYMBOL (node)
-    if (node->symbol.alias && DECL_EXTERNAL (node->symbol.decl)
+    if (node->symbol.alias
         && !TREE_ASM_WRITTEN (node->symbol.decl)
-       && lookup_attribute ("weakref", DECL_ATTRIBUTES (node->symbol.decl)))
+       && node->symbol.weakref)
       {
        tree target;
 

diff --git a/gcc/configure b/gcc/configure
index 8c22107..a59e7c8 100755 (executable)
--- a/gcc/configure
+++ b/gcc/configure
@@ -21973,7 +21973,7 @@ else
   then gcc_cv_as_weakref=yes
 fi
   elif test x$gcc_cv_as != x; then
-    $as_echo ' .weakref foobar, barfnot' > conftest.s
+    $as_echo ' .weakref2 foobar, barfnot' > conftest.s
     if { ac_try='$gcc_cv_as $gcc_cv_as_flags  -o conftest.o conftest.s >&5'
   { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5
   (eval $ac_try) 2>&5

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index a2b7ac1..66e565c 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -3755,6 +3755,10 @@ simple_operand_p (const_tree exp)
                 #pragma weak, etc).  */
              && ! TREE_PUBLIC (exp)
              && ! DECL_EXTERNAL (exp)
+             /* Weakrefs are not safe to be read, since they can be NULL.
+                They are !TREE_PUBLIC && !DECL_EXTERNAL but still
+                have DECL_WEAK flag set.  */
+             && (! VAR_OR_FUNCTION_DECL_P (exp) || ! DECL_WEAK (exp))
              /* Loading a static variable is unduly expensive, but global
                 registers aren't expensive.  */
              && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));

diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index 181d28d..60fca6b 100644 (file)
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -73,11 +73,6 @@ can_refer_decl_in_current_unit_p (tree decl, tree from_decl)
   if ((!TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
       || (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL))
     return true;
-  /* Weakrefs have somewhat confusing DECL_EXTERNAL flag set; they
-     are always safe.  */
-  if (DECL_EXTERNAL (decl)
-      && lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
-    return true;
   /* We are folding reference from external vtable.  The vtable may reffer
      to a symbol keyed to other compilation unit.  The other compilation
      unit may be in separate DSO and the symbol may be hidden.  */

diff --git a/gcc/ipa.c b/gcc/ipa.c
index a73cbb1..98a7b07 100644 (file)
--- a/gcc/ipa.c
+++ b/gcc/ipa.c
@@ -664,12 +664,6 @@ cgraph_externally_visible_p (struct cgraph_node *node,
 bool
 varpool_externally_visible_p (struct varpool_node *vnode)
 {
-  /* Do not touch weakrefs; while they are not externally visible,
-     dropping their DECL_EXTERNAL flags confuse most
-     of code handling them.  */
-  if (vnode->symbol.alias && DECL_EXTERNAL (vnode->symbol.decl))
-    return true;
-
   if (DECL_EXTERNAL (vnode->symbol.decl))
     return true;
 
@@ -784,9 +778,9 @@ function_and_variable_visibility (bool whole_program)
         happy.  Clear the flag here to avoid confusion in middle-end.  */
       if (DECL_COMDAT (node->symbol.decl) && !TREE_PUBLIC (node->symbol.decl))
         DECL_COMDAT (node->symbol.decl) = 0;
-      /* For external decls stop tracking same_comdat_group, it doesn't matter
-        what comdat group they are in when they won't be emitted in this TU,
-        and simplifies later passes.  */
+
+      /* For external decls stop tracking same_comdat_group. It doesn't matter
+        what comdat group they are in when they won't be emitted in this TU.  */
       if (node->symbol.same_comdat_group && DECL_EXTERNAL (node->symbol.decl))
        {
 #ifdef ENABLE_CHECKING
@@ -804,6 +798,7 @@ function_and_variable_visibility (bool whole_program)
       gcc_assert ((!DECL_WEAK (node->symbol.decl)
                  && !DECL_COMDAT (node->symbol.decl))
                  || TREE_PUBLIC (node->symbol.decl)
+                 || node->symbol.weakref
                  || DECL_EXTERNAL (node->symbol.decl));
       if (cgraph_externally_visible_p (node, whole_program))
         {
@@ -815,7 +810,8 @@ function_and_variable_visibility (bool whole_program)
          node->symbol.externally_visible = false;
          node->symbol.forced_by_abi = false;
        }
-      if (!node->symbol.externally_visible && node->symbol.definition
+      if (!node->symbol.externally_visible
+         && node->symbol.definition && !node->symbol.weakref
          && !DECL_EXTERNAL (node->symbol.decl))
        {
          gcc_assert (whole_program || in_lto_p
@@ -860,6 +856,7 @@ function_and_variable_visibility (bool whole_program)
     {
       /* weak flag makes no sense on local variables.  */
       gcc_assert (!DECL_WEAK (vnode->symbol.decl)
+                 || vnode->symbol.weakref
                  || TREE_PUBLIC (vnode->symbol.decl)
                  || DECL_EXTERNAL (vnode->symbol.decl));
       /* In several cases declarations can not be common:
@@ -897,7 +894,8 @@ function_and_variable_visibility (bool whole_program)
           vnode->symbol.externally_visible = false;
          vnode->symbol.forced_by_abi = false;
        }
-      if (!vnode->symbol.externally_visible)
+      if (!vnode->symbol.externally_visible
+         && !vnode->symbol.weakref)
        {
          gcc_assert (in_lto_p || whole_program || !TREE_PUBLIC (vnode->symbol.decl));
          symtab_make_decl_local (vnode->symbol.decl);

diff --git a/gcc/lto-cgraph.c b/gcc/lto-cgraph.c
index bc9e5cd..63a9ddb 100644 (file)
--- a/gcc/lto-cgraph.c
+++ b/gcc/lto-cgraph.c
@@ -487,8 +487,9 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
      defined in other unit, we may use the info on aliases to resolve 
      symbol1 != symbol2 type tests that we can do only for locally defined objects
      otherwise.  */
-  alias_p = node->symbol.alias && (!boundary_p || DECL_EXTERNAL (node->symbol.decl));
+  alias_p = node->symbol.alias && (!boundary_p || node->symbol.weakref);
   bp_pack_value (&bp, alias_p, 1);
+  bp_pack_value (&bp, node->symbol.weakref, 1);
   bp_pack_value (&bp, node->frequency, 2);
   bp_pack_value (&bp, node->only_called_at_startup, 1);
   bp_pack_value (&bp, node->only_called_at_exit, 1);
@@ -531,8 +532,9 @@ lto_output_varpool_node (struct lto_simple_output_block *ob, struct varpool_node
   bp_pack_value (&bp, node->symbol.forced_by_abi, 1);
   bp_pack_value (&bp, node->symbol.unique_name, 1);
   bp_pack_value (&bp, node->symbol.definition, 1);
-  alias_p = node->symbol.alias && (!boundary_p || DECL_EXTERNAL (node->symbol.decl));
+  alias_p = node->symbol.alias && (!boundary_p || node->symbol.weakref);
   bp_pack_value (&bp, alias_p, 1);
+  bp_pack_value (&bp, node->symbol.weakref, 1);
   bp_pack_value (&bp, node->symbol.analyzed && !boundary_p, 1);
   gcc_assert (node->symbol.definition || !node->symbol.analyzed);
   /* Constant pool initializers can be de-unified into individual ltrans units.
@@ -906,6 +908,7 @@ input_overwrite_node (struct lto_file_decl_data *file_data,
       TREE_STATIC (node->symbol.decl) = 0;
     }
   node->symbol.alias = bp_unpack_value (bp, 1);
+  node->symbol.weakref = bp_unpack_value (bp, 1);
   node->frequency = (enum node_frequency)bp_unpack_value (bp, 2);
   node->only_called_at_startup = bp_unpack_value (bp, 1);
   node->only_called_at_exit = bp_unpack_value (bp, 1);
@@ -1010,8 +1013,7 @@ input_node (struct lto_file_decl_data *file_data,
       node->thunk.virtual_value = virtual_value;
       node->thunk.virtual_offset_p = (type & 4);
     }
-  if (node->symbol.alias && !node->symbol.analyzed
-      && lookup_attribute ("weakref", DECL_ATTRIBUTES (node->symbol.decl)))
+  if (node->symbol.alias && !node->symbol.analyzed && node->symbol.weakref)
     node->symbol.alias_target = get_alias_symbol (node->symbol.decl);
   return node;
 }
@@ -1046,6 +1048,7 @@ input_varpool_node (struct lto_file_decl_data *file_data,
   node->symbol.unique_name = bp_unpack_value (&bp, 1);
   node->symbol.definition = bp_unpack_value (&bp, 1);
   node->symbol.alias = bp_unpack_value (&bp, 1);
+  node->symbol.weakref = bp_unpack_value (&bp, 1);
   node->symbol.analyzed = bp_unpack_value (&bp, 1);
   node->symbol.used_from_other_partition = bp_unpack_value (&bp, 1);
   node->symbol.in_other_partition = bp_unpack_value (&bp, 1);
@@ -1054,8 +1057,7 @@ input_varpool_node (struct lto_file_decl_data *file_data,
       DECL_EXTERNAL (node->symbol.decl) = 1;
       TREE_STATIC (node->symbol.decl) = 0;
     }
-  if (node->symbol.alias && !node->symbol.analyzed
-      && lookup_attribute ("weakref", DECL_ATTRIBUTES (node->symbol.decl)))
+  if (node->symbol.alias && !node->symbol.analyzed && node->symbol.weakref)
     node->symbol.alias_target = get_alias_symbol (node->symbol.decl);
   ref = streamer_read_hwi (ib);
   /* Store a reference for now, and fix up later to be a pointer.  */

diff --git a/gcc/lto-symtab.c b/gcc/lto-symtab.c
index 2b41933..5f0b971 100644 (file)
--- a/gcc/lto-symtab.c
+++ b/gcc/lto-symtab.c
@@ -235,9 +235,6 @@ lto_symtab_symbol_p (symtab_node e)
 {
   if (!TREE_PUBLIC (e->symbol.decl) && !DECL_EXTERNAL (e->symbol.decl))
     return false;
-  /* weakrefs are really static variables that are made external by a hack.  */
-  if (lookup_attribute ("weakref", DECL_ATTRIBUTES (e->symbol.decl)))
-    return false;
   return symtab_real_symbol_p (e);
 }
 
@@ -589,6 +586,7 @@ lto_symtab_merge_symbols (void)
          if (!node->symbol.analyzed && node->symbol.alias_target)
            {
              symtab_node tgt = symtab_node_for_asm (node->symbol.alias_target);
+             gcc_assert (node->symbol.weakref);
              if (tgt)
                symtab_resolve_alias (node, tgt);
            }
@@ -617,11 +615,6 @@ lto_symtab_prevailing_decl (tree decl)
   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
     return decl;
 
-  /* As an anoying special cases weakrefs are really static variables with
-     EXTERNAL flag.  */
-  if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
-    return decl;
-
   /* Ensure DECL_ASSEMBLER_NAME will not set assembler name.  */
   gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl));
 

diff --git a/gcc/lto/ChangeLog b/gcc/lto/ChangeLog
index f98c31d..153f023 100644 (file)
--- a/gcc/lto/ChangeLog
+++ b/gcc/lto/ChangeLog
@@ -1,3 +1,11 @@
+2013-06-11 Jan Hubicka  <jh@suse.cz>
+
+       * lto-partition.c (get_symbol_class): Simplify weakref handling.
+       (add_symbol_to_partition_1): Likewise.
+       (contained_in_symbol): Likewise.
+       (lto_balanced_map): Likewise.
+       (rename_statics): Drop weakref.
+
 2013-06-05  Richard Biener  <rguenther@suse.de>
 
        * lto.c (num_merged_types): New global variable.

diff --git a/gcc/lto/lto-partition.c b/gcc/lto/lto-partition.c
index 921b4e2..6f45380 100644 (file)
--- a/gcc/lto/lto-partition.c
+++ b/gcc/lto/lto-partition.c
@@ -60,7 +60,7 @@ get_symbol_class (symtab_node node)
     return SYMBOL_DUPLICATE;
 
   /* Weakref aliases are always duplicated.  */
-  if (lookup_attribute ("weakref", DECL_ATTRIBUTES (node->symbol.decl)))
+  if (node->symbol.weakref)
     return SYMBOL_DUPLICATE;
 
   /* External declarations are external.  */
@@ -218,10 +218,7 @@ add_symbol_to_partition_1 (ltrans_partition part, symtab_node node)
 
   /* Add all aliases associated with the symbol.  */
   for (i = 0; ipa_ref_list_referring_iterate (&node->symbol.ref_list, i, ref); i++)
-    if (ref->use == IPA_REF_ALIAS
-       && !lookup_attribute ("weakref",
-                             DECL_ATTRIBUTES
-                               (ref->referring->symbol.decl)))
+    if (ref->use == IPA_REF_ALIAS && !node->symbol.weakref)
       add_symbol_to_partition_1 (part, ref->referring);
 
   /* Ensure that SAME_COMDAT_GROUP lists all allways added in a group.  */
@@ -243,8 +240,7 @@ static symtab_node
 contained_in_symbol (symtab_node node)
 {
   /* Weakrefs are never contained in anything.  */
-  if (lookup_attribute ("weakref",
-                       DECL_ATTRIBUTES (node->symbol.decl)))
+  if (node->symbol.weakref)
     return node;
   if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
     {
@@ -561,8 +557,7 @@ lto_balanced_map (void)
 
              last_visited_node++;
 
-             gcc_assert (node->symbol.definition
-                         || lookup_attribute ("weakref", DECL_ATTRIBUTES (node->symbol.decl)));
+             gcc_assert (node->symbol.definition || node->symbol.weakref);
 
              /* Compute boundary cost of callgraph edges.  */
              for (edge = node->callees; edge; edge = edge->next_callee)
@@ -871,8 +866,7 @@ rename_statics (lto_symtab_encoder_t encoder, symtab_node node)
         once this is fixed.  */
         || DECL_EXTERNAL (node->symbol.decl)
         || !symtab_real_symbol_p (node))
-       && !may_need_named_section_p (encoder, node)
-       && !lookup_attribute ("weakref", DECL_ATTRIBUTES (node->symbol.decl)))
+       && !may_need_named_section_p (encoder, node))
     return;
 
   /* Now walk symbols sharing the same name and see if there are any conflicts.
@@ -897,11 +891,9 @@ rename_statics (lto_symtab_encoder_t encoder, symtab_node node)
   /* Assign every symbol in the set that shares the same ASM name an unique
      mangled name.  */
   for (s = symtab_node_for_asm (name); s;)
-    if ((!s->symbol.externally_visible
-        || lookup_attribute ("weakref", DECL_ATTRIBUTES (node->symbol.decl)))
+    if (!s->symbol.externally_visible
        && ((symtab_real_symbol_p (s)
-             && (!DECL_EXTERNAL (node->symbol.decl)
-                || lookup_attribute ("weakref", DECL_ATTRIBUTES (node->symbol.decl)))
+             && !DECL_EXTERNAL (node->symbol.decl)
             && !TREE_PUBLIC (node->symbol.decl))
            || may_need_named_section_p (encoder, s))
        && (!encoder

diff --git a/gcc/passes.c b/gcc/passes.c
index a4dad2a..c8b03ee 100644 (file)
--- a/gcc/passes.c
+++ b/gcc/passes.c
@@ -136,8 +136,8 @@ rest_of_decl_compilation (tree decl,
        /* A quirk of the initial implementation of aliases required that the
           user add "extern" to all of them.  Which is silly, but now
           historical.  Do note that the symbol is in fact locally defined.  */
-       if (!lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
-         DECL_EXTERNAL (decl) = 0;
+       DECL_EXTERNAL (decl) = 0;
+       TREE_STATIC (decl) = 1;
        assemble_alias (decl, alias);
       }
   }

diff --git a/gcc/symtab.c b/gcc/symtab.c
index 28ee6f0..7a02270 100644 (file)
--- a/gcc/symtab.c
+++ b/gcc/symtab.c
@@ -481,6 +481,8 @@ dump_symtab_base (FILE *f, symtab_node node)
     fprintf (f, " analyzed");
   if (node->symbol.alias)
     fprintf (f, " alias");
+  if (node->symbol.weakref)
+    fprintf (f, " weakref");
   if (node->symbol.cpp_implicit_alias)
     fprintf (f, " cpp_implicit_alias");
   if (node->symbol.alias_target)
@@ -682,11 +684,16 @@ verify_symtab_base (symtab_node node)
       error_found = true;
     }
   if (node->symbol.alias && !node->symbol.definition
-      && !lookup_attribute ("weakref", DECL_ATTRIBUTES (node->symbol.decl)))
+      && !node->symbol.weakref)
     {
       error ("node is alias but not definition");
       error_found = true;
     }
+  if (node->symbol.weakref && !node->symbol.alias)
+    {
+      error ("node is weakref but not an alias");
+      error_found = true;
+    }
   if (node->symbol.same_comdat_group)
     {
       symtab_node n = node->symbol.same_comdat_group;
@@ -799,8 +806,6 @@ symtab_make_decl_local (tree decl)
   DECL_VISIBILITY_SPECIFIED (decl) = 0;
   DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
   TREE_PUBLIC (decl) = 0;
-  DECL_VISIBILITY_SPECIFIED (decl) = 0;
-  DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
   if (!DECL_RTL_SET_P (decl))
     return;
 
@@ -861,7 +866,7 @@ symtab_alias_ultimate_target (symtab_node node, enum availability *availability)
 
   if (availability)
     {
-      weakref_p = DECL_EXTERNAL (node->symbol.decl) && node->symbol.alias;
+      weakref_p = node->symbol.weakref;
       if (!weakref_p)
         *availability = symtab_node_availability (node);
       else
@@ -893,7 +898,7 @@ symtab_alias_ultimate_target (symtab_node node, enum availability *availability)
          enum availability a = symtab_node_availability (node);
          if (a < *availability)
            *availability = a;
-          weakref_p = DECL_EXTERNAL (node->symbol.decl) && node->symbol.alias;
+          weakref_p = node->symbol.weakref;
        }
     }
   if (availability)

diff --git a/gcc/varpool.c b/gcc/varpool.c
index a3e9325..4b23884 100644 (file)
--- a/gcc/varpool.c
+++ b/gcc/varpool.c
@@ -452,6 +452,8 @@ varpool_create_variable_alias (tree alias, tree decl)
   alias_node->symbol.alias = true;
   alias_node->symbol.definition = true;
   alias_node->symbol.alias_target = decl;
+  if (lookup_attribute ("weakref", DECL_ATTRIBUTES (alias)) != NULL)
+    alias_node->symbol.weakref = true;
   return alias_node;
 }