X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gold%2Fdynobj.cc;h=8d29dd7ce25b2a9e4d200658576c2f8ce702e8c1;hb=945e0f82dad31db89a107b496532886fe215c011;hp=80d4a4353866b9ccc49af653c9c74895b08cff3c;hpb=91d6fa6a035cc7d0b7be5c99c194a64cb80924b0;p=deliverable%2Fbinutils-gdb.git

diff --git a/gold/dynobj.cc b/gold/dynobj.cc
index 80d4a43538..8d29dd7ce2 100644
--- a/gold/dynobj.cc
+++ b/gold/dynobj.cc
@@ -1,6 +1,6 @@
 // dynobj.cc -- dynamic object support for gold
 
-// Copyright 2006, 2007, 2008 Free Software Foundation, Inc.
+// Copyright (C) 2006-2016 Free Software Foundation, Inc.
 // Written by Ian Lance Taylor <iant@google.com>.
 
 // This file is part of gold.
@@ -39,8 +39,8 @@ namespace gold
 // Sets up the default soname_ to use, in the (rare) cases we never
 // see a DT_SONAME entry.
 
-Dynobj::Dynobj(const std::string& aname, Input_file* ainput_file, off_t aoffset)
-  : Object(aname, ainput_file, true, aoffset),
+Dynobj::Dynobj(const std::string& name, Input_file* input_file, off_t offset)
+  : Object(name, input_file, true, offset),
     needed_(),
     unknown_needed_(UNKNOWN_NEEDED_UNSET)
 {
@@ -49,16 +49,23 @@ Dynobj::Dynobj(const std::string& aname, Input_file* ainput_file, off_t aoffset)
   // object's filename.  The only exception is when the dynamic object
   // is part of an archive (so the filename is the archive's
   // filename).  In that case, we use just the dynobj's name-in-archive.
-  this->soname_ = this->input_file()->found_name();
-  if (this->offset() != 0)
+  if (input_file == NULL)
+    this->soname_ = name;
+  else
     {
-      std::string::size_type open_paren = this->name().find('(');
-      std::string::size_type close_paren = this->name().find(')');
-      if (open_paren != std::string::npos && close_paren != std::string::npos)
+      this->soname_ = input_file->found_name();
+      if (this->offset() != 0)
 	{
-	  // It's an archive, and name() is of the form 'foo.a(bar.so)'.
-	  this->soname_ = this->name().substr(open_paren + 1,
-					      close_paren - (open_paren + 1));
+	  std::string::size_type open_paren = this->name().find('(');
+	  std::string::size_type close_paren = this->name().find(')');
+	  if (open_paren != std::string::npos
+	      && close_paren != std::string::npos)
+	    {
+	      // It's an archive, and name() is of the form 'foo.a(bar.so)'.
+	      open_paren += 1;
+	      this->soname_ = this->name().substr(open_paren,
+						  close_paren - open_paren);
+	    }
 	}
     }
 }
@@ -67,11 +74,11 @@ Dynobj::Dynobj(const std::string& aname, Input_file* ainput_file, off_t aoffset)
 
 template<int size, bool big_endian>
 Sized_dynobj<size, big_endian>::Sized_dynobj(
-    const std::string& aname,
-    Input_file* ainput_file,
-    off_t aoffset,
+    const std::string& name,
+    Input_file* input_file,
+    off_t offset,
     const elfcpp::Ehdr<size, big_endian>& ehdr)
-  : Dynobj(aname, ainput_file, aoffset),
+  : Dynobj(name, input_file, offset),
     elf_file_(this, ehdr),
     dynsym_shndx_(-1U),
     symbols_(NULL),
@@ -85,8 +92,8 @@ template<int size, bool big_endian>
 void
 Sized_dynobj<size, big_endian>::setup()
 {
-  const unsigned int sec_shnum = this->elf_file_.shnum();
-  this->set_shnum(sec_shnum);
+  const unsigned int shnum = this->elf_file_.shnum();
+  this->set_shnum(shnum);
 }
 
 // Find the SHT_DYNSYM section and the various version sections, and
@@ -106,11 +113,12 @@ Sized_dynobj<size, big_endian>::find_dynsym_sections(
   *pverneed_shndx = -1U;
   *pdynamic_shndx = -1U;
 
+  unsigned int symtab_shndx = 0;
   unsigned int xindex_shndx = 0;
   unsigned int xindex_link = 0;
-  const unsigned int sec_shnum = this->shnum();
+  const unsigned int shnum = this->shnum();
   const unsigned char* p = pshdrs;
-  for (unsigned int i = 0; i < sec_shnum; ++i, p += This::shdr_size)
+  for (unsigned int i = 0; i < shnum; ++i, p += This::shdr_size)
     {
       typename This::Shdr shdr(p);
 
@@ -128,6 +136,10 @@ Sized_dynobj<size, big_endian>::find_dynsym_sections(
 	    }
 	  pi = NULL;
 	  break;
+	case elfcpp::SHT_SYMTAB:
+	  symtab_shndx = i;
+	  pi = NULL;
+	  break;
 	case elfcpp::SHT_GNU_versym:
 	  pi = pversym_shndx;
 	  break;
@@ -166,6 +178,25 @@ Sized_dynobj<size, big_endian>::find_dynsym_sections(
 
       *pi = i;
     }
+
+  // If there is no dynamic symbol table, use the normal symbol table.
+  // On some SVR4 systems, a shared library is stored in an archive.
+  // The version stored in the archive only has a normal symbol table.
+  // It has an SONAME entry which points to another copy in the file
+  // system which has a dynamic symbol table as usual.  This is way of
+  // addressing the issues which glibc addresses using GROUP with
+  // libc_nonshared.a.
+  if (this->dynsym_shndx_ == -1U && symtab_shndx != 0)
+    {
+      this->dynsym_shndx_ = symtab_shndx;
+      if (xindex_shndx > 0 && xindex_link == symtab_shndx)
+	{
+	  Xindex* xindex = new Xindex(this->elf_file_.large_shndx_offset());
+	  xindex->read_symtab_xindex<size, big_endian>(this, xindex_shndx,
+						       pshdrs);
+	  this->set_xindex(xindex);
+	}
+    }
 }
 
 // Read the contents of section SHNDX.  PSHDRS points to the section
@@ -180,13 +211,13 @@ Sized_dynobj<size, big_endian>::read_dynsym_section(
     unsigned int shndx,
     elfcpp::SHT type,
     unsigned int link,
-    File_view** aview,
+    File_view** view,
     section_size_type* view_size,
     unsigned int* view_info)
 {
   if (shndx == -1U)
     {
-      *aview = NULL;
+      *view = NULL;
       *view_size = 0;
       *view_info = 0;
       return;
@@ -200,8 +231,8 @@ Sized_dynobj<size, big_endian>::read_dynsym_section(
     this->error(_("unexpected link in section %u header: %u != %u"),
 	        shndx, this->adjust_shndx(shdr.get_sh_link()), link);
 
-  *aview = this->get_lasting_view(shdr.get_sh_offset(), shdr.get_sh_size(),
-				  true, false);
+  *view = this->get_lasting_view(shdr.get_sh_offset(), shdr.get_sh_size(),
+				 true, false);
   *view_size = convert_to_section_size_type(shdr.get_sh_size());
   *view_info = shdr.get_sh_info();
 }
@@ -304,6 +335,17 @@ Sized_dynobj<size, big_endian>::read_dynamic(const unsigned char* pshdrs,
 template<int size, bool big_endian>
 void
 Sized_dynobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
+{
+  this->base_read_symbols(sd);
+}
+
+// Read the symbols and sections from a dynamic object.  We read the
+// dynamic symbols, not the normal symbols.  This is common code for
+// all target-specific overrides of do_read_symbols().
+
+template<int size, bool big_endian>
+void
+Sized_dynobj<size, big_endian>::base_read_symbols(Read_symbols_data* sd)
 {
   this->read_section_data(&this->elf_file_, sd);
 
@@ -332,12 +374,22 @@ Sized_dynobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
   sd->verneed_size = 0;
   sd->verneed_info = 0;
 
+  const unsigned char* namesu = sd->section_names->data();
+  const char* names = reinterpret_cast<const char*>(namesu);
+  if (memmem(names, sd->section_names_size, ".zdebug_", 8) != NULL)
+    {
+      Compressed_section_map* compressed_sections =
+	  build_compressed_section_map<size, big_endian>(
+	      pshdrs, this->shnum(), names, sd->section_names_size, this, true);
+      if (compressed_sections != NULL)
+        this->set_compressed_sections(compressed_sections);
+    }
+
   if (this->dynsym_shndx_ != -1U)
     {
       // Get the dynamic symbols.
       typename This::Shdr dynsymshdr(pshdrs
 				     + this->dynsym_shndx_ * This::shdr_size);
-      gold_assert(dynsymshdr.get_sh_type() == elfcpp::SHT_DYNSYM);
 
       sd->symbols = this->get_lasting_view(dynsymshdr.get_sh_offset(),
 					   dynsymshdr.get_sh_size(), true,
@@ -424,8 +476,8 @@ Sized_dynobj<size, big_endian>::do_layout(Symbol_table* symtab,
 					  Layout*,
 					  Read_symbols_data* sd)
 {
-  const unsigned int sec_shnum = this->shnum();
-  if (sec_shnum == 0)
+  const unsigned int shnum = this->shnum();
+  if (shnum == 0)
     return;
 
   // Get the section headers.
@@ -437,7 +489,7 @@ Sized_dynobj<size, big_endian>::do_layout(Symbol_table* symtab,
 
   // Skip the first, dummy, section.
   pshdrs += This::shdr_size;
-  for (unsigned int i = 1; i < sec_shnum; ++i, pshdrs += This::shdr_size)
+  for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size)
     {
       typename This::Shdr shdr(pshdrs);
 
@@ -448,10 +500,10 @@ Sized_dynobj<size, big_endian>::do_layout(Symbol_table* symtab,
 	  return;
 	}
 
-      const char* aname = pnames + shdr.get_sh_name();
+      const char* name = pnames + shdr.get_sh_name();
 
-      this->handle_gnu_warning_section(aname, i, symtab);
-      this->handle_split_stack_section(aname);
+      this->handle_gnu_warning_section(name, i, symtab);
+      this->handle_split_stack_section(name);
     }
 
   delete sd->section_headers;
@@ -468,13 +520,13 @@ void
 Sized_dynobj<size, big_endian>::set_version_map(
     Version_map* version_map,
     unsigned int ndx,
-    const char* aname) const
+    const char* name) const
 {
   if (ndx >= version_map->size())
     version_map->resize(ndx + 1);
   if ((*version_map)[ndx] != NULL)
     this->error(_("duplicate definition for version %u"), ndx);
-  (*version_map)[ndx] = aname;
+  (*version_map)[ndx] = name;
 }
 
 // Add mappings for the version definitions to VERSION_MAP.
@@ -670,10 +722,10 @@ Sized_dynobj<size, big_endian>::do_add_symbols(Symbol_table* symtab,
       return;
     }
 
-  const int symsize = This::sym_size;
-  const size_t symcount = sd->symbols_size / symsize;
+  const int sym_size = This::sym_size;
+  const size_t symcount = sd->symbols_size / sym_size;
   gold_assert(sd->external_symbols_offset == 0);
-  if (symcount * symsize != sd->symbols_size)
+  if (symcount * sym_size != sd->symbols_size)
     {
       this->error(_("size of dynamic symbols is not multiple of symbol size"));
       return;
@@ -682,9 +734,11 @@ Sized_dynobj<size, big_endian>::do_add_symbols(Symbol_table* symtab,
   Version_map version_map;
   this->make_version_map(sd, &version_map);
 
-  // If printing symbol counts, we want to track symbols.
-  
-  if (parameters->options().user_set_print_symbol_counts())
+  // If printing symbol counts or a cross reference table or
+  // preparing for an incremental link, we want to track symbols.
+  if (parameters->options().user_set_print_symbol_counts()
+      || parameters->options().cref()
+      || parameters->incremental())
     {
       this->symbols_ = new Symbols();
       this->symbols_->resize(symcount);
@@ -727,6 +781,52 @@ Sized_dynobj<size, big_endian>::do_add_symbols(Symbol_table* symtab,
   this->clear_view_cache_marks();
 }
 
+template<int size, bool big_endian>
+Archive::Should_include
+Sized_dynobj<size, big_endian>::do_should_include_member(Symbol_table*,
+							 Layout*,
+							 Read_symbols_data*,
+							 std::string*)
+{
+  return Archive::SHOULD_INCLUDE_YES;
+}
+
+// Iterate over global symbols, calling a visitor class V for each.
+
+template<int size, bool big_endian>
+void
+Sized_dynobj<size, big_endian>::do_for_all_global_symbols(
+    Read_symbols_data* sd,
+    Library_base::Symbol_visitor_base* v)
+{
+  const char* sym_names =
+      reinterpret_cast<const char*>(sd->symbol_names->data());
+  const unsigned char* syms =
+      sd->symbols->data() + sd->external_symbols_offset;
+  const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
+  size_t symcount = ((sd->symbols_size - sd->external_symbols_offset)
+                     / sym_size);
+  const unsigned char* p = syms;
+
+  for (size_t i = 0; i < symcount; ++i, p += sym_size)
+    {
+      elfcpp::Sym<size, big_endian> sym(p);
+      if (sym.get_st_shndx() != elfcpp::SHN_UNDEF
+	  && sym.get_st_bind() != elfcpp::STB_LOCAL)
+	v->visit(sym_names + sym.get_st_name());
+    }
+}
+
+// Iterate over local symbols, calling a visitor class V for each GOT offset
+// associated with a local symbol.
+
+template<int size, bool big_endian>
+void
+Sized_dynobj<size, big_endian>::do_for_all_local_got_entries(
+    Got_offset_list::Visitor*) const
+{
+}
+
 // Get symbol counts.
 
 template<int size, bool big_endian>
@@ -745,7 +845,7 @@ Sized_dynobj<size, big_endian>::do_get_global_symbol_counts(
 	&& (*p)->source() == Symbol::FROM_OBJECT
 	&& (*p)->object() == this
 	&& (*p)->is_defined()
-	&& (*p)->dynsym_index() != -1U)
+	&& (*p)->has_dynsym_index())
       ++count;
   *used = count;
 }
@@ -846,31 +946,59 @@ Dynobj::create_elf_hash_table(const std::vector<Symbol*>& dynsyms,
       bucket[bucketpos] = dynsym_index;
     }
 
+  int size = parameters->target().hash_entry_size();
   unsigned int hashlen = ((2
 			   + bucketcount
 			   + local_dynsym_count
 			   + dynsym_count)
-			  * 4);
+			  * size / 8);
   unsigned char* phash = new unsigned char[hashlen];
 
-  if (parameters->target().is_big_endian())
+  bool big_endian = parameters->target().is_big_endian();
+  if (size == 32)
     {
+      if (big_endian)
+	{
 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
-      Dynobj::sized_create_elf_hash_table<true>(bucket, chain, phash,
-						hashlen);
+	  Dynobj::sized_create_elf_hash_table<32, true>(bucket, chain, phash,
+							hashlen);
+#else
+	  gold_unreachable();
+#endif
+	}
+      else
+	{
+#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
+	  Dynobj::sized_create_elf_hash_table<32, false>(bucket, chain, phash,
+							 hashlen);
 #else
-      gold_unreachable();
+	  gold_unreachable();
 #endif
+	}
     }
-  else
+  else if (size == 64)
     {
+      if (big_endian)
+	{
+#if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
+	  Dynobj::sized_create_elf_hash_table<64, true>(bucket, chain, phash,
+							hashlen);
+#else
+	  gold_unreachable();
+#endif
+	}
+      else
+	{
 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
-      Dynobj::sized_create_elf_hash_table<false>(bucket, chain, phash,
-						 hashlen);
+	  Dynobj::sized_create_elf_hash_table<64, false>(bucket, chain, phash,
+							 hashlen);
 #else
-      gold_unreachable();
+	  gold_unreachable();
 #endif
+	}
     }
+  else
+    gold_unreachable();
 
   *pphash = phash;
   *phashlen = hashlen;
@@ -878,7 +1006,7 @@ Dynobj::create_elf_hash_table(const std::vector<Symbol*>& dynsyms,
 
 // Fill in an ELF hash table.
 
-template<bool big_endian>
+template<int size, bool big_endian>
 void
 Dynobj::sized_create_elf_hash_table(const std::vector<uint32_t>& bucket,
 				    const std::vector<uint32_t>& chain,
@@ -890,21 +1018,21 @@ Dynobj::sized_create_elf_hash_table(const std::vector<uint32_t>& bucket,
   const unsigned int bucketcount = bucket.size();
   const unsigned int chaincount = chain.size();
 
-  elfcpp::Swap<32, big_endian>::writeval(p, bucketcount);
-  p += 4;
-  elfcpp::Swap<32, big_endian>::writeval(p, chaincount);
-  p += 4;
+  elfcpp::Swap<size, big_endian>::writeval(p, bucketcount);
+  p += size / 8;
+  elfcpp::Swap<size, big_endian>::writeval(p, chaincount);
+  p += size / 8;
 
   for (unsigned int i = 0; i < bucketcount; ++i)
     {
-      elfcpp::Swap<32, big_endian>::writeval(p, bucket[i]);
-      p += 4;
+      elfcpp::Swap<size, big_endian>::writeval(p, bucket[i]);
+      p += size / 8;
     }
 
   for (unsigned int i = 0; i < chaincount; ++i)
     {
-      elfcpp::Swap<32, big_endian>::writeval(p, chain[i]);
-      p += 4;
+      elfcpp::Swap<size, big_endian>::writeval(p, chain[i]);
+      p += size / 8;
     }
 
   gold_assert(static_cast<unsigned int>(p - phash) == hashlen);
@@ -959,9 +1087,10 @@ Dynobj::create_gnu_hash_table(const std::vector<Symbol*>& dynsyms,
     {
       Symbol* sym = dynsyms[i];
 
-      // FIXME: Should put on unhashed_dynsyms if the symbol is
-      // hidden.
-      if (sym->is_undefined())
+      if (!sym->needs_dynsym_value()
+	  && (sym->is_undefined()
+	      || sym->is_from_dynobj()
+	      || sym->is_forced_local()))
 	unhashed_dynsyms.push_back(sym);
       else
 	{
@@ -1196,7 +1325,8 @@ Verdef::write(const Stringpool* dynpool, bool is_last, unsigned char* pb) const
   elfcpp::Verdef_write<size, big_endian> vd(pb);
   vd.set_vd_version(elfcpp::VER_DEF_CURRENT);
   vd.set_vd_flags((this->is_base_ ? elfcpp::VER_FLG_BASE : 0)
-		  | (this->is_weak_ ? elfcpp::VER_FLG_WEAK : 0));
+		  | (this->is_weak_ ? elfcpp::VER_FLG_WEAK : 0)
+		  | (this->is_info_ ? elfcpp::VER_FLG_INFO : 0));
   vd.set_vd_ndx(this->index());
   vd.set_vd_cnt(1 + this->deps_.size());
   vd.set_vd_hash(Dynobj::elf_hash(this->name()));
@@ -1217,9 +1347,9 @@ Verdef::write(const Stringpool* dynpool, bool is_last, unsigned char* pb) const
        p != this->deps_.end();
        ++p, ++i)
     {
-      elfcpp::Verdaux_write<size, big_endian> avda(pb);
-      avda.set_vda_name(dynpool->get_offset(*p));
-      avda.set_vda_next(i + 1 >= this->deps_.size() ? 0 : verdaux_size);
+      elfcpp::Verdaux_write<size, big_endian> vda(pb);
+      vda.set_vda_name(dynpool->get_offset(*p));
+      vda.set_vda_next(i + 1 >= this->deps_.size() ? 0 : verdaux_size);
       pb += verdaux_size;
     }
 
@@ -1305,10 +1435,10 @@ Verneed::write(const Stringpool* dynpool, bool is_last,
 
 // Versions methods.
 
-Versions::Versions(const Version_script_info& vscript,
+Versions::Versions(const Version_script_info& version_script,
                    Stringpool* dynpool)
   : defs_(), needs_(), version_table_(),
-    is_finalized_(false), version_script_(vscript),
+    is_finalized_(false), version_script_(version_script),
     needs_base_version_(parameters->options().shared())
 {
   if (!this->version_script_.empty())
@@ -1328,7 +1458,7 @@ Versions::Versions(const Version_script_info& vscript,
           Verdef* const vd = new Verdef(
               version,
               this->version_script_.get_dependencies(version),
-              false, false, false);
+              false, false, false, false);
           this->defs_.push_back(vd);
           Key key(version_key, 0);
           this->version_table_.insert(std::make_pair(key, vd));
@@ -1366,7 +1496,7 @@ Versions::define_base_version(Stringpool* dynpool)
     name = parameters->options().output_file_name();
   name = dynpool->add(name, false, NULL);
   Verdef* vdbase = new Verdef(name, std::vector<std::string>(),
-                              true, false, true);
+                              true, false, false, true);
   this->defs_.push_back(vdbase);
   this->needs_base_version_ = false;
 }
@@ -1397,13 +1527,17 @@ Versions::record_version(const Symbol_table* symtab,
   gold_assert(!this->is_finalized_);
   gold_assert(sym->version() != NULL);
 
+  // A symbol defined as "sym@" is bound to an unspecified base version.
+  if (sym->version()[0] == '\0')
+    return;
+
   Stringpool::Key version_key;
   const char* version = dynpool->add(sym->version(), false, &version_key);
 
   if (!sym->is_from_dynobj() && !sym->is_copied_from_dynobj())
     {
       if (parameters->options().shared())
-        this->add_def(sym, version, version_key);
+        this->add_def(dynpool, sym, version, version_key);
     }
   else
     {
@@ -1416,7 +1550,7 @@ Versions::record_version(const Symbol_table* symtab,
 // We've found a symbol SYM defined in version VERSION.
 
 void
-Versions::add_def(const Symbol* sym, const char* version,
+Versions::add_def(Stringpool* dynpool, const Symbol* sym, const char* version,
 		  Stringpool::Key version_key)
 {
   Key k(version_key, 0);
@@ -1440,8 +1574,12 @@ Versions::add_def(const Symbol* sym, const char* version,
       // 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);
+	{
+	  gold_error(_("symbol %s has undefined version %s"),
+		     sym->demangled_name().c_str(), version);
+	  if (this->needs_base_version_)
+	    this->define_base_version(dynpool);
+	}
       else
 	// We only insert a base version for shared library.
 	gold_assert(!this->needs_base_version_);
@@ -1449,7 +1587,7 @@ Versions::add_def(const Symbol* sym, const char* version,
       // When creating a regular executable, automatically define
       // a new version.
       Verdef* vd = new Verdef(version, std::vector<std::string>(),
-                              false, false, false);
+                              false, false, false, false);
       this->defs_.push_back(vd);
       ins.first->second = vd;
     }
@@ -1526,13 +1664,16 @@ Versions::finalize(Symbol_table* symtab, unsigned int dynsym_index,
       if (!(*p)->is_symbol_created())
 	{
 	  Symbol* vsym = symtab->define_as_constant((*p)->name(),
-						    (*p)->name(), 0, 0,
+						    (*p)->name(),
+						    Symbol_table::PREDEFINED,
+						    0, 0,
 						    elfcpp::STT_OBJECT,
 						    elfcpp::STB_GLOBAL,
 						    elfcpp::STV_DEFAULT, 0,
 						    false, false);
 	  vsym->set_needs_dynsym_entry();
           vsym->set_dynsym_index(dynsym_index);
+	  vsym->set_is_default();
 	  ++dynsym_index;
 	  syms->push_back(vsym);
 	  // The name is already in the dynamic pool.
@@ -1620,18 +1761,25 @@ Versions::symbol_section_contents(const Symbol_table* symtab,
        p != syms.end();
        ++p)
     {
-      unsigned int vindex;
+      unsigned int version_index;
       const char* version = (*p)->version();
       if (version == NULL)
-	vindex = elfcpp::VER_NDX_GLOBAL;
-      else        
-	vindex = this->version_index(symtab, dynpool, *p);
+	{
+	  if ((*p)->is_defined() && !(*p)->is_from_dynobj())
+	    version_index = elfcpp::VER_NDX_GLOBAL;
+	  else
+	    version_index = elfcpp::VER_NDX_LOCAL;
+	}
+      else if (version[0] == '\0')
+        version_index = elfcpp::VER_NDX_GLOBAL;
+      else
+	version_index = this->version_index(symtab, dynpool, *p);
       // If the symbol was defined as foo@V1 instead of foo@@V1, add
       // the hidden bit.
       if ((*p)->version() != NULL && !(*p)->is_default())
-        vindex |= elfcpp::VERSYM_HIDDEN;
+        version_index |= elfcpp::VERSYM_HIDDEN;
       elfcpp::Swap<16, big_endian>::writeval(pbuf + (*p)->dynsym_index() * 2,
-                                             vindex);
+                                             version_index);
     }
 
   *pp = pbuf;
@@ -1687,8 +1835,8 @@ Versions::def_section_contents(const Stringpool* dynpool,
 template<int size, bool big_endian>
 void
 Versions::need_section_contents(const Stringpool* dynpool,
-				unsigned char** pp, unsigned int *psize,
-				unsigned int *pentries) const
+				unsigned char** pp, unsigned int* psize,
+				unsigned int* pentries) const
 {
   gold_assert(this->is_finalized_);
   gold_assert(!this->needs_.empty());