PR ld/10515

[binutils-gdb.git] / gold / resolve.cc

diff --git a/gold/resolve.cc b/gold/resolve.cc
index 0ad990cd055db328df05adf6a657a00d04931a52..45a4a7aabda34571be6bfeff74225ed46a02b720 100644 (file)
--- a/gold/resolve.cc
+++ b/gold/resolve.cc
@@ -1,6 +1,6 @@
 // resolve.cc -- symbol resolution for gold
 
-// Copyright 2006, 2007, 2008 Free Software Foundation, Inc.
+// Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
 // Written by Ian Lance Taylor <iant@google.com>.
 
 // This file is part of gold.
@@ -26,6 +26,7 @@
 #include "target.h"
 #include "object.h"
 #include "symtab.h"
+#include "plugin.h"
 
 namespace gold
 {
@@ -62,6 +63,26 @@ Symbol::override_version(const char* version)
     }
 }
 
+// This symbol is being overidden by another symbol whose visibility
+// is VISIBILITY.  Updated the VISIBILITY_ field accordingly.
+
+inline void
+Symbol::override_visibility(elfcpp::STV visibility)
+{
+  // The rule for combining visibility is that we always choose the
+  // most constrained visibility.  In order of increasing constraint,
+  // visibility goes PROTECTED, HIDDEN, INTERNAL.  This is the reverse
+  // of the numeric values, so the effect is that we always want the
+  // smallest non-zero value.
+  if (visibility != elfcpp::STV_DEFAULT)
+    {
+      if (this->visibility_ == elfcpp::STV_DEFAULT)
+       this->visibility_ = visibility;
+      else if (this->visibility_ > visibility)
+       this->visibility_ = visibility;
+    }
+}
+
 // Override the fields in Symbol.
 
 template<int size, bool big_endian>
@@ -77,7 +98,7 @@ Symbol::override_base(const elfcpp::Sym<size, big_endian>& sym,
   this->is_ordinary_shndx_ = is_ordinary;
   this->type_ = sym.get_st_type();
   this->binding_ = sym.get_st_bind();
-  this->visibility_ = sym.get_st_visibility();
+  this->override_visibility(sym.get_st_visibility());
   this->nonvis_ = sym.get_st_nonvis();
   if (object->is_dynamic())
     this->in_dyn_ = true;
@@ -196,6 +217,8 @@ symbol_to_bits(elfcpp::STB binding, bool is_dynamic,
     default:
       if (type == elfcpp::STT_COMMON)
        bits |= common_flag;
+      else if (!is_ordinary && Symbol::is_common_shndx(shndx))
+       bits |= common_flag;
       else
         bits |= def_flag;
       break;
@@ -234,12 +257,45 @@ Symbol_table::resolve(Sized_symbol<size>* to,
       // Record that we've seen this symbol in a regular object.
       to->set_in_reg();
     }
+  else if (st_shndx == elfcpp::SHN_UNDEF
+           && (to->visibility() == elfcpp::STV_HIDDEN
+               || to->visibility() == elfcpp::STV_INTERNAL))
+    {
+      // A dynamic object cannot reference a hidden or internal symbol
+      // defined in another object.
+      gold_warning(_("%s symbol '%s' in %s is referenced by DSO %s"),
+                   (to->visibility() == elfcpp::STV_HIDDEN
+                    ? "hidden"
+                    : "internal"),
+                   to->demangled_name().c_str(),
+                   to->object()->name().c_str(),
+                   object->name().c_str());
+      return;
+    }
   else
     {
       // Record that we've seen this symbol in a dynamic object.
       to->set_in_dyn();
     }
 
+  // Record if we've seen this symbol in a real ELF object (i.e., the
+  // symbol is referenced from outside the world known to the plugin).
+  if (object->pluginobj() == NULL)
+    to->set_in_real_elf();
+
+  // If we're processing replacement files, allow new symbols to override
+  // the placeholders from the plugin objects.
+  if (to->source() == Symbol::FROM_OBJECT)
+    {
+      Pluginobj* obj = to->object()->pluginobj();
+      if (obj != NULL
+          && parameters->options().plugins()->in_replacement_phase())
+        {
+          this->override(to, sym, st_shndx, is_ordinary, object, version);
+          return;
+        }
+    }
+
   unsigned int frombits = symbol_to_bits(sym.get_st_bind(),
                                          object->is_dynamic(),
                                         st_shndx, is_ordinary,
@@ -260,6 +316,9 @@ Symbol_table::resolve(Sized_symbol<size>* to,
     {
       if (adjust_common_sizes && sym.get_st_size() > to->symsize())
         to->set_symsize(sym.get_st_size());
+      // The ELF ABI says that even for a reference to a symbol we
+      // merge the visibility.
+      to->override_visibility(sym.get_st_visibility());
     }
 
   // A new weak undefined reference, merging with an old weak
@@ -702,7 +761,7 @@ Symbol::override_base_with_special(const Symbol* from)
   this->override_version(from->version_);
   this->type_ = from->type_;
   this->binding_ = from->binding_;
-  this->visibility_ = from->visibility_;
+  this->override_visibility(from->visibility_);
   this->nonvis_ = from->nonvis_;
 
   // Special symbols are always considered to be regular symbols.
@@ -757,7 +816,12 @@ Symbol_table::override_with_special(Sized_symbol<size>* tosym,
        }
       while (ssym != tosym);
     }
-  if (tosym->binding() == elfcpp::STB_LOCAL)
+  if (tosym->binding() == elfcpp::STB_LOCAL
+      || ((tosym->visibility() == elfcpp::STV_HIDDEN
+          || tosym->visibility() == elfcpp::STV_INTERNAL)
+         && (tosym->binding() == elfcpp::STB_GLOBAL
+             || tosym->binding() == elfcpp::STB_WEAK)
+         && !parameters->options().relocatable()))
     this->force_local(tosym);
 }