[binutils] Bump binutils to 2.20.1

binutils/gold/resolve.cc

 // resolve.cc -- symbol resolution for gold
 
 // Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
 // Written by Ian Lance Taylor <iant@google.com>.
 
 // This file is part of gold.
 
 // This program is free software; you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
 // the Free Software Foundation; either version 3 of the License, or
@@ skipping 284 matching lines @@
           return;
         }
     }
 
   unsigned int frombits = symbol_to_bits(sym.get_st_bind(),
                                          object->is_dynamic(),
                                          st_shndx, is_ordinary,
                                          sym.get_st_type());
 
   bool adjust_common_sizes;
+  typename Sized_symbol<size>::Size_type tosize = to->symsize();
   if (Symbol_table::should_override(to, frombits, object,
                                     &adjust_common_sizes))
     {
-      typename Sized_symbol<size>::Size_type tosize = to->symsize();
-
       this->override(to, sym, st_shndx, is_ordinary, object, version);
-
       if (adjust_common_sizes && tosize > to->symsize())
         to->set_symsize(tosize);
     }
   else
     {
-      if (adjust_common_sizes && sym.get_st_size() > to->symsize())
+      if (adjust_common_sizes && sym.get_st_size() > tosize)
         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());
     }
 
+  if (adjust_common_sizes && parameters->options().warn_common())
+    {
+      if (tosize > sym.get_st_size())
+        Symbol_table::report_resolve_problem(false,
+                                             _("common of '%s' overriding "
+                                               "smaller common"),
+                                             to, object);
+      else if (tosize < sym.get_st_size())
+        Symbol_table::report_resolve_problem(false,
+                                             _("common of '%s' overidden by "
+                                               "larger common"),
+                                             to, object);
+      else
+        Symbol_table::report_resolve_problem(false,
+                                             _("multiple common of '%s'"),
+                                             to, object);
+    }
+
   // A new weak undefined reference, merging with an old weak
   // reference, could be a One Definition Rule (ODR) violation --
   // especially if the types or sizes of the references differ.  We'll
   // store such pairs and look them up later to make sure they
   // actually refer to the same lines of code.  (Note: not all ODR
   // violations can be found this way, and not everything this finds
   // is an ODR violation.  But it's helpful to warn about.)
   bool to_is_ordinary;
   if (parameters->options().detect_odr_violations()
       && sym.get_st_bind() == elfcpp::STB_WEAK
@@ skipping 81 matching lines @@
     case DEF * 16 + DEF:
       // Two definitions of the same symbol.
 
       // If either symbol is defined by an object included using
       // --just-symbols, then don't warn.  This is for compatibility
       // with the GNU linker.  FIXME: This is a hack.
       if ((to->source() == Symbol::FROM_OBJECT && to->object()->just_symbols())
           || object->just_symbols())
         return false;
 
-      // FIXME: Do a better job of reporting locations.
-      gold_error(_("%s: multiple definition of %s"),
-                 object != NULL ? object->name().c_str() : _("command line"),
-                 to->demangled_name().c_str());
-      gold_error(_("%s: previous definition here"),
-                 (to->source() == Symbol::FROM_OBJECT
-                  ? to->object()->name().c_str()
-                  : _("command line")));
+      Symbol_table::report_resolve_problem(true,
+                                           _("multiple definition of '%s'"),
+                                           to, object);
       return false;
 
     case WEAK_DEF * 16 + DEF:
       // We've seen a weak definition, and now we see a strong
       // definition.  In the original SVR4 linker, this was treated as
       // a multiple definition error.  In the Solaris linker and the
       // GNU linker, a weak definition followed by a regular
       // definition causes the weak definition to be overridden.  We
       // are currently compatible with the GNU linker.  In the future
       // we should add a target specific option to change this.
@@ skipping 14 matching lines @@
     case DYN_WEAK_UNDEF * 16 + DEF:
       // We've seen an undefined reference, and now we see a
       // definition.  We use the definition.
       return true;
 
     case COMMON * 16 + DEF:
     case WEAK_COMMON * 16 + DEF:
     case DYN_COMMON * 16 + DEF:
     case DYN_WEAK_COMMON * 16 + DEF:
       // We've seen a common symbol and now we see a definition.  The
-      // definition overrides.  FIXME: We should optionally issue, version a
-      // warning.
+      // definition overrides.
+      if (parameters->options().warn_common())
+        Symbol_table::report_resolve_problem(false,
+                                             _("definition of '%s' overriding "
+                                               "common"),
+                                             to, object);
       return true;
 
     case DEF * 16 + WEAK_DEF:
     case WEAK_DEF * 16 + WEAK_DEF:
       // We've seen a definition and now we see a weak definition.  We
       // ignore the new weak definition.
       return false;
 
     case DYN_DEF * 16 + WEAK_DEF:
     case DYN_WEAK_DEF * 16 + WEAK_DEF:
       // We've seen a dynamic definition and now we see a regular weak
       // definition.  The regular weak definition overrides.
       return true;
 
     case UNDEF * 16 + WEAK_DEF:
     case WEAK_UNDEF * 16 + WEAK_DEF:
     case DYN_UNDEF * 16 + WEAK_DEF:
     case DYN_WEAK_UNDEF * 16 + WEAK_DEF:
       // A weak definition of a currently undefined symbol.
       return true;
 
     case COMMON * 16 + WEAK_DEF:
     case WEAK_COMMON * 16 + WEAK_DEF:
       // A weak definition does not override a common definition.
       return false;
 
     case DYN_COMMON * 16 + WEAK_DEF:
     case DYN_WEAK_COMMON * 16 + WEAK_DEF:
       // A weak definition does override a definition in a dynamic
-      // object.  FIXME: We should optionally issue a warning.
+      // object.
+      if (parameters->options().warn_common())
+        Symbol_table::report_resolve_problem(false,
+                                             _("definition of '%s' overriding "
+                                               "dynamic common definition"),
+                                             to, object);
       return true;
 
     case DEF * 16 + DYN_DEF:
     case WEAK_DEF * 16 + DYN_DEF:
     case DYN_DEF * 16 + DYN_DEF:
     case DYN_WEAK_DEF * 16 + DYN_DEF:
       // Ignore a dynamic definition if we already have a definition.
       return false;
 
     case UNDEF * 16 + DYN_DEF:
@@ skipping 95 matching lines @@
     case DYN_WEAK_UNDEF * 16 + DYN_WEAK_UNDEF:
     case COMMON * 16 + DYN_WEAK_UNDEF:
     case WEAK_COMMON * 16 + DYN_WEAK_UNDEF:
     case DYN_COMMON * 16 + DYN_WEAK_UNDEF:
     case DYN_WEAK_COMMON * 16 + DYN_WEAK_UNDEF:
       // A new weak dynamic undefined reference tells us nothing.
       return false;
 
     case DEF * 16 + COMMON:
       // A common symbol does not override a definition.
+      if (parameters->options().warn_common())
+        Symbol_table::report_resolve_problem(false,
+                                             _("common '%s' overridden by "
+                                               "previous definition"),
+                                             to, object);
       return false;
 
     case WEAK_DEF * 16 + COMMON:
     case DYN_DEF * 16 + COMMON:
     case DYN_WEAK_DEF * 16 + COMMON:
       // A common symbol does override a weak definition or a dynamic
       // definition.
       return true;
 
     case UNDEF * 16 + COMMON:
@@ skipping 85 matching lines @@
     case DYN_WEAK_COMMON * 16 + DYN_WEAK_COMMON:
       // Set the size to the maximum.
       *adjust_common_sizes = true;
       return false;
 
     default:
       gold_unreachable();
     }
 }
 
+// Issue an error or warning due to symbol resolution.  IS_ERROR
+// indicates an error rather than a warning.  MSG is the error
+// message; it is expected to have a %s for the symbol name.  TO is
+// the existing symbol.  OBJECT is where the new symbol was found.
+
+// FIXME: We should have better location information here.  When the
+// symbol is defined, we should be able to pull the location from the
+// debug info if there is any.
+
+void
+Symbol_table::report_resolve_problem(bool is_error, const char* msg,
+                                     const Symbol* to, Object* object)
+{
+  std::string demangled(to->demangled_name());
+  size_t len = strlen(msg) + demangled.length() + 10;
+  char* buf = new char[len];
+  snprintf(buf, len, msg, demangled.c_str());
+
+  const char* objname;
+  if (object != NULL)
+    objname = object->name().c_str();
+  else
+    objname = _("command line");
+
+  if (is_error)
+    gold_error("%s: %s", objname, buf);
+  else
+    gold_warning("%s: %s", objname, buf);
+
+  delete[] buf;
+
+  if (to->source() == Symbol::FROM_OBJECT)
+    objname = to->object()->name().c_str();
+  else
+    objname = _("command line");
+  gold_info("%s: %s: previous definition here", program_name, objname);
+}
+
 // A special case of should_override which is only called for a strong
 // defined symbol from a regular object file.  This is used when
 // defining special symbols.
 
 bool
 Symbol_table::should_override_with_special(const Symbol* to)
 {
   bool adjust_common_sizes;
   unsigned int frombits = global_flag | regular_flag | def_flag;
   bool ret = Symbol_table::should_override(to, frombits, NULL,
@@ skipping 160 matching lines @@
 #endif
 
 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
 template
 void
 Symbol_table::override_with_special<64>(Sized_symbol<64>*,
                                         const Sized_symbol<64>*);
 #endif
 
 } // End namespace gold.