Fix incorrect handling of STT_COMMON symbols in shared libraries.

[external/binutils.git] / gold / resolve.cc

diff --git a/gold/resolve.cc b/gold/resolve.cc
index 0da8da2..fdae0ba 100644 (file)
--- a/gold/resolve.cc
+++ b/gold/resolve.cc
@@ -1,6 +1,6 @@
 // resolve.cc -- symbol resolution for gold
 
-// Copyright 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+// Copyright (C) 2006-2015 Free Software Foundation, Inc.
 // Written by Ian Lance Taylor <iant@google.com>.
 
 // This file is part of gold.
@@ -96,7 +96,9 @@ Symbol::override_base(const elfcpp::Sym<size, big_endian>& sym,
   this->override_version(version);
   this->u_.from_object.shndx = st_shndx;
   this->is_ordinary_shndx_ = is_ordinary;
-  this->type_ = sym.get_st_type();
+  // Don't override st_type from plugin placeholder symbols.
+  if (object->pluginobj() == NULL)
+    this->type_ = sym.get_st_type();
   this->binding_ = sym.get_st_bind();
   this->override_visibility(sym.get_st_visibility());
   this->nonvis_ = sym.get_st_nonvis();
@@ -171,7 +173,7 @@ static const unsigned int common_flag = 2 << def_undef_or_common_shift;
 
 static unsigned int
 symbol_to_bits(elfcpp::STB binding, bool is_dynamic,
-              unsigned int shndx, bool is_ordinary, elfcpp::STT type)
+              unsigned int shndx, bool is_ordinary)
 {
   unsigned int bits;
 
@@ -216,9 +218,7 @@ symbol_to_bits(elfcpp::STB binding, bool is_dynamic,
       break;
 
     default:
-      if (type == elfcpp::STT_COMMON)
-       bits |= common_flag;
-      else if (!is_ordinary && Symbol::is_common_shndx(shndx))
+      if (!is_ordinary && Symbol::is_common_shndx(shndx))
        bits |= common_flag;
       else
         bits |= def_flag;
@@ -270,6 +270,15 @@ Symbol_table::resolve(Sized_symbol<size>* to,
 
   if (!object->is_dynamic())
     {
+      if (sym.get_st_type() == elfcpp::STT_COMMON
+         && (is_ordinary || !Symbol::is_common_shndx(st_shndx)))
+       {
+         gold_warning(_("STT_COMMON symbol '%s' in %s "
+                        "is not in a common section"),
+                      to->demangled_name().c_str(),
+                      to->object()->name().c_str());
+         return;
+       }
       // Record that we've seen this symbol in a regular object.
       to->set_in_reg();
     }
@@ -301,14 +310,33 @@ Symbol_table::resolve(Sized_symbol<size>* to,
 
   // If we're processing replacement files, allow new symbols to override
   // the placeholders from the plugin objects.
+  // Treat common symbols specially since it is possible that an ELF
+  // file increased the size of the alignment.
   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;
+         bool adjust_common = false;
+         typename Sized_symbol<size>::Size_type tosize = 0;
+         typename Sized_symbol<size>::Value_type tovalue = 0;
+         if (to->is_common()
+             && !is_ordinary && Symbol::is_common_shndx(st_shndx))
+           {
+             adjust_common = true;
+             tosize = to->symsize();
+             tovalue = to->value();
+           }
+         this->override(to, sym, st_shndx, is_ordinary, object, version);
+         if (adjust_common)
+           {
+             if (tosize > to->symsize())
+               to->set_symsize(tosize);
+             if (tovalue > to->value())
+               to->set_value(tovalue);
+           }
+         return;
         }
     }
 
@@ -343,15 +371,19 @@ Symbol_table::resolve(Sized_symbol<size>* to,
       this->candidate_odr_violations_[to->name()].insert(toloc);
     }
 
+  // Plugins don't provide a symbol type, so adopt the existing type
+  // if the FROM symbol is from a plugin.
+  elfcpp::STT fromtype = (object->pluginobj() != NULL
+                         ? to->type()
+                         : sym.get_st_type());
   unsigned int frombits = symbol_to_bits(sym.get_st_bind(),
                                          object->is_dynamic(),
-                                        st_shndx, is_ordinary,
-                                         sym.get_st_type());
+                                        st_shndx, is_ordinary);
 
   bool adjust_common_sizes;
   bool adjust_dyndef;
   typename Sized_symbol<size>::Size_type tosize = to->symsize();
-  if (Symbol_table::should_override(to, frombits, sym.get_st_type(), OBJECT,
+  if (Symbol_table::should_override(to, frombits, fromtype, OBJECT,
                                    object, &adjust_common_sizes,
                                    &adjust_dyndef))
     {
@@ -429,11 +461,9 @@ Symbol_table::should_override(const Symbol* to, unsigned int frombits,
 
   unsigned int tobits;
   if (to->source() == Symbol::IS_UNDEFINED)
-    tobits = symbol_to_bits(to->binding(), false, elfcpp::SHN_UNDEF, true,
-                           to->type());
+    tobits = symbol_to_bits(to->binding(), false, elfcpp::SHN_UNDEF, true);
   else if (to->source() != Symbol::FROM_OBJECT)
-    tobits = symbol_to_bits(to->binding(), false, elfcpp::SHN_ABS, false,
-                           to->type());
+    tobits = symbol_to_bits(to->binding(), false, elfcpp::SHN_ABS, false);
   else
     {
       bool is_ordinary;
@@ -441,13 +471,11 @@ Symbol_table::should_override(const Symbol* to, unsigned int frombits,
       tobits = symbol_to_bits(to->binding(),
                              to->object()->is_dynamic(),
                              shndx,
-                             is_ordinary,
-                             to->type());
+                             is_ordinary);
     }
 
-  if (to->type() == elfcpp::STT_TLS
-      ? fromtype != elfcpp::STT_TLS
-      : fromtype == elfcpp::STT_TLS)
+  if ((to->type() == elfcpp::STT_TLS) ^ (fromtype == elfcpp::STT_TLS)
+      && !to->is_placeholder())
     Symbol_table::report_resolve_problem(true,
                                         _("symbol '%s' used as both __thread "
                                           "and non-__thread"),
@@ -909,6 +937,10 @@ Symbol::override_base_with_special(const Symbol* from)
   bool same_name = this->name_ == from->name_;
   gold_assert(same_name || this->has_alias());
 
+  // If we are overriding an undef, remember the original binding.
+  if (this->is_undefined())
+    this->set_undef_binding(this->binding_);
+
   this->source_ = from->source_;
   switch (from->source_)
     {