[binutils] Bump binutils to 2.20.1

binutils/gold/dynobj.cc

 // dynobj.cc -- dynamic object support for gold
 
 // Copyright 2006, 2007, 2008 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 1282 matching lines @@
     }
 
   return pb;
 }
 
 // Versions methods.
 
 Versions::Versions(const Version_script_info& version_script,
                    Stringpool* dynpool)
   : defs_(), needs_(), version_table_(),
-    is_finalized_(false), version_script_(version_script)
+    is_finalized_(false), version_script_(version_script),
+    needs_base_version_(parameters->options().shared())
 {
-  // We always need a base version, so define that first.  Nothing
-  // explicitly declares itself as part of base, so it doesn't need to
-  // be in version_table_.
-  if (parameters->options().shared())
-    {
-      const char* name = parameters->options().soname();
-      if (name == NULL)
-        name = parameters->options().output_file_name();
-      name = dynpool->add(name, false, NULL);
-      Verdef* vdbase = new Verdef(name, std::vector<std::string>(),
-                                  true, false, true);
-      this->defs_.push_back(vdbase);
-    }
-
   if (!this->version_script_.empty())
     {
       // Parse the version script, and insert each declared version into
       // defs_ and version_table_.
       std::vector<std::string> versions = this->version_script_.get_versions();
+
+      if (this->needs_base_version_ && !versions.empty())
+        this->define_base_version(dynpool);
+
       for (size_t k = 0; k < versions.size(); ++k)
         {
           Stringpool::Key version_key;
           const char* version = dynpool->add(versions[k].c_str(),
                                              true, &version_key);
           Verdef* const vd = new Verdef(
               version,
               this->version_script_.get_dependencies(version),
               false, false, false);
           this->defs_.push_back(vd);
           Key key(version_key, 0);
           this->version_table_.insert(std::make_pair(key, vd));
         }
     }
 }
 
 Versions::~Versions()
 {
   for (Defs::iterator p = this->defs_.begin();
        p != this->defs_.end();
        ++p)
     delete *p;
 
   for (Needs::iterator p = this->needs_.begin();
        p != this->needs_.end();
        ++p)
     delete *p;
 }
 
+// Define the base version of a shared library.  The base version definition
+// must be the first entry in defs_.  We insert it lazily so that defs_ is
+// empty if no symbol versioning is used.  Then layout can just drop the
+// version sections.
+
+void
+Versions::define_base_version(Stringpool* dynpool)
+{
+  // If we do any versioning at all,  we always need a base version, so
+  // define that first.  Nothing explicitly declares itself as part of base,
+  // so it doesn't need to be in version_table_.
+  gold_assert(this->defs_.empty());
+  const char* name = parameters->options().soname();
+  if (name == NULL)
+    name = parameters->options().output_file_name();
+  name = dynpool->add(name, false, NULL);
+  Verdef* vdbase = new Verdef(name, std::vector<std::string>(),
+                              true, false, true);
+  this->defs_.push_back(vdbase);
+  this->needs_base_version_ = false;
+}
+
 // Return the dynamic object which a symbol refers to.
 
 Dynobj*
 Versions::get_dynobj_for_sym(const Symbol_table* symtab,
                              const Symbol* sym) const
 {
   if (sym->is_copied_from_dynobj())
     return symtab->get_copy_source(sym);
   else
     {
@@ skipping 51 matching lines @@
       vb->clear_weak();
     }
   else
     {
       // If we are creating a shared object, it is an error to
       // find a definition of a symbol with a version which is not
       // in the version script.
       if (parameters->options().shared())
         gold_error(_("symbol %s has undefined version %s"),
                    sym->demangled_name().c_str(), version);
-
+      else
+        // We only insert a base version for shared library.
+        gold_assert(!this->needs_base_version_);
+        
       // When creating a regular executable, automatically define
       // a new version.
       Verdef* vd = new Verdef(version, std::vector<std::string>(),
                               false, false, false);
       this->defs_.push_back(vd);
       ins.first->second = vd;
     }
 }
 
 // Add a reference to version NAME in file FILENAME.
@@ skipping 26 matching lines @@
     {
       if ((*p)->filename() == filename)
         {
           vn = *p;
           break;
         }
     }
 
   if (vn == NULL)
     {
+      // Create base version definition lazily for shared library.
+      if (this->needs_base_version_)
+        this->define_base_version(dynpool);
+
       // We have a new filename.
       vn = new Verneed(filename);
       this->needs_.push_back(vn);
     }
 
   ins.first->second = vn->add_name(name);
 }
 
 // Set the version indexes.  Create a new dynamic version symbol for
 // each new version definition.
@@ skipping 360 matching lines @@
 template
 void
 Versions::need_section_contents<64, true>(
     const Stringpool*,
     unsigned char**,
     unsigned int*,
     unsigned int*) const;
 #endif
 
 } // End namespace gold.