Remove debugging code accidentally included in last commit.

[binutils.git] / gold / dynobj.cc

diff --git a/gold/dynobj.cc b/gold/dynobj.cc
index 558129837e5629a5e8333e859647b085b82c8088..dec6f3d0f3d8bf77b0c80c8836982f48851d757d 100644 (file)
--- a/gold/dynobj.cc
+++ b/gold/dynobj.cc
@@ -72,7 +72,10 @@ Sized_dynobj<size, big_endian>::Sized_dynobj(
     off_t offset,
     const elfcpp::Ehdr<size, big_endian>& ehdr)
   : Dynobj(name, input_file, offset),
     off_t offset,
     const elfcpp::Ehdr<size, big_endian>& ehdr)
   : Dynobj(name, input_file, offset),

-    elf_file_(this, ehdr)
+    elf_file_(this, ehdr),
+    dynsym_shndx_(-1U),
+    symbols_(NULL),
+    defined_count_(0)

 {
 }
 
 {
 }
 


@@ -80,13 +83,8 @@ Sized_dynobj<size, big_endian>::Sized_dynobj(
 
 template<int size, bool big_endian>
 void
 
 template<int size, bool big_endian>
 void

-Sized_dynobj<size, big_endian>::setup(
-    const elfcpp::Ehdr<size, big_endian>& ehdr)
+Sized_dynobj<size, big_endian>::setup()

 {
 {

-  this->set_target(ehdr.get_e_machine(), size, big_endian,
-                  ehdr.get_e_ident()[elfcpp::EI_OSABI],
-                  ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]);
-

   const unsigned int shnum = this->elf_file_.shnum();
   this->set_shnum(shnum);
 }
   const unsigned int shnum = this->elf_file_.shnum();
   this->set_shnum(shnum);
 }


@@ -98,18 +96,18 @@ template<int size, bool big_endian>
 void
 Sized_dynobj<size, big_endian>::find_dynsym_sections(
     const unsigned char* pshdrs,
 void
 Sized_dynobj<size, big_endian>::find_dynsym_sections(
     const unsigned char* pshdrs,

-    unsigned int* pdynsym_shndx,

     unsigned int* pversym_shndx,
     unsigned int* pverdef_shndx,
     unsigned int* pverneed_shndx,
     unsigned int* pdynamic_shndx)
 {
     unsigned int* pversym_shndx,
     unsigned int* pverdef_shndx,
     unsigned int* pverneed_shndx,
     unsigned int* pdynamic_shndx)
 {

-  *pdynsym_shndx = -1U;

   *pversym_shndx = -1U;
   *pverdef_shndx = -1U;
   *pverneed_shndx = -1U;
   *pdynamic_shndx = -1U;
 
   *pversym_shndx = -1U;
   *pverdef_shndx = -1U;
   *pverneed_shndx = -1U;
   *pdynamic_shndx = -1U;
 

+  unsigned int xindex_shndx = 0;
+  unsigned int xindex_link = 0;

   const unsigned int shnum = this->shnum();
   const unsigned char* p = pshdrs;
   for (unsigned int i = 0; i < shnum; ++i, p += This::shdr_size)
   const unsigned int shnum = this->shnum();
   const unsigned char* p = pshdrs;
   for (unsigned int i = 0; i < shnum; ++i, p += This::shdr_size)


@@ -120,7 +118,15 @@ Sized_dynobj<size, big_endian>::find_dynsym_sections(
       switch (shdr.get_sh_type())
        {
        case elfcpp::SHT_DYNSYM:
       switch (shdr.get_sh_type())
        {
        case elfcpp::SHT_DYNSYM:

-         pi = pdynsym_shndx;
+         this->dynsym_shndx_ = i;
+         if (xindex_shndx > 0 && xindex_link == i)
+           {
+             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);
+           }
+         pi = NULL;

          break;
        case elfcpp::SHT_GNU_versym:
          pi = pversym_shndx;
          break;
        case elfcpp::SHT_GNU_versym:
          pi = pversym_shndx;


@@ -134,6 +140,18 @@ Sized_dynobj<size, big_endian>::find_dynsym_sections(
        case elfcpp::SHT_DYNAMIC:
          pi = pdynamic_shndx;
          break;
        case elfcpp::SHT_DYNAMIC:
          pi = pdynamic_shndx;
          break;

+       case elfcpp::SHT_SYMTAB_SHNDX:
+         xindex_shndx = i;
+         xindex_link = this->adjust_shndx(shdr.get_sh_link());
+         if (xindex_link == this->dynsym_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);
+           }
+         pi = NULL;
+         break;

        default:
          pi = NULL;
          break;
        default:
          pi = NULL;
          break;


@@ -178,12 +196,12 @@ Sized_dynobj<size, big_endian>::read_dynsym_section(
 
   gold_assert(shdr.get_sh_type() == type);
 
 
   gold_assert(shdr.get_sh_type() == type);
 

-  if (shdr.get_sh_link() != link)
+  if (this->adjust_shndx(shdr.get_sh_link()) != link)

     this->error(_("unexpected link in section %u header: %u != %u"),
     this->error(_("unexpected link in section %u header: %u != %u"),

-               shndx, shdr.get_sh_link(), link);
+               shndx, this->adjust_shndx(shdr.get_sh_link()), link);

 
   *view = this->get_lasting_view(shdr.get_sh_offset(), shdr.get_sh_size(),
 
   *view = this->get_lasting_view(shdr.get_sh_offset(), shdr.get_sh_size(),

-                                false);
+                                true, false);

   *view_size = convert_to_section_size_type(shdr.get_sh_size());
   *view_info = shdr.get_sh_info();
 }
   *view_size = convert_to_section_size_type(shdr.get_sh_size());
   *view_info = shdr.get_sh_info();
 }


@@ -208,9 +226,9 @@ Sized_dynobj<size, big_endian>::read_dynamic(const unsigned char* pshdrs,
 
   const off_t dynamic_size = dynamicshdr.get_sh_size();
   const unsigned char* pdynamic = this->get_view(dynamicshdr.get_sh_offset(),
 
   const off_t dynamic_size = dynamicshdr.get_sh_size();
   const unsigned char* pdynamic = this->get_view(dynamicshdr.get_sh_offset(),

-                                                dynamic_size, false);
+                                                dynamic_size, true, false);

 
 

-  const unsigned int link = dynamicshdr.get_sh_link();
+  const unsigned int link = this->adjust_shndx(dynamicshdr.get_sh_link());

   if (link != strtab_shndx)
     {
       if (link >= this->shnum())
   if (link != strtab_shndx)
     {
       if (link >= this->shnum())


@@ -229,7 +247,8 @@ Sized_dynobj<size, big_endian>::read_dynamic(const unsigned char* pshdrs,
        }
 
       strtab_size = strtabshdr.get_sh_size();
        }
 
       strtab_size = strtabshdr.get_sh_size();

-      strtabu = this->get_view(strtabshdr.get_sh_offset(), strtab_size, false);
+      strtabu = this->get_view(strtabshdr.get_sh_offset(), strtab_size, false,
+                              false);

     }
 
   const char* const strtab = reinterpret_cast<const char*>(strtabu);
     }
 
   const char* const strtab = reinterpret_cast<const char*>(strtabu);


@@ -290,13 +309,12 @@ Sized_dynobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
 
   const unsigned char* const pshdrs = sd->section_headers->data();
 
 
   const unsigned char* const pshdrs = sd->section_headers->data();
 

-  unsigned int dynsym_shndx;

   unsigned int versym_shndx;
   unsigned int verdef_shndx;
   unsigned int verneed_shndx;
   unsigned int dynamic_shndx;
   unsigned int versym_shndx;
   unsigned int verdef_shndx;
   unsigned int verneed_shndx;
   unsigned int dynamic_shndx;

-  this->find_dynsym_sections(pshdrs, &dynsym_shndx, &versym_shndx,
-                            &verdef_shndx, &verneed_shndx, &dynamic_shndx);
+  this->find_dynsym_sections(pshdrs, &versym_shndx, &verdef_shndx,
+                            &verneed_shndx, &dynamic_shndx);

 
   unsigned int strtab_shndx = -1U;
 
 
   unsigned int strtab_shndx = -1U;
 


@@ -306,19 +324,21 @@ Sized_dynobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
   sd->symbol_names = NULL;
   sd->symbol_names_size = 0;
 
   sd->symbol_names = NULL;
   sd->symbol_names_size = 0;
 

-  if (dynsym_shndx != -1U)
+  if (this->dynsym_shndx_ != -1U)

     {
       // Get the dynamic symbols.
     {
       // Get the dynamic symbols.

-      typename This::Shdr dynsymshdr(pshdrs + dynsym_shndx * This::shdr_size);
+      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(),
       gold_assert(dynsymshdr.get_sh_type() == elfcpp::SHT_DYNSYM);
 
       sd->symbols = this->get_lasting_view(dynsymshdr.get_sh_offset(),

-                                          dynsymshdr.get_sh_size(), false);
+                                          dynsymshdr.get_sh_size(), true,
+                                          false);

       sd->symbols_size =
        convert_to_section_size_type(dynsymshdr.get_sh_size());
 
       // Get the symbol names.
       sd->symbols_size =
        convert_to_section_size_type(dynsymshdr.get_sh_size());
 
       // Get the symbol names.

-      strtab_shndx = dynsymshdr.get_sh_link();
+      strtab_shndx = this->adjust_shndx(dynsymshdr.get_sh_link());

       if (strtab_shndx >= this->shnum())
        {
          this->error(_("invalid dynamic symbol table name index: %u"),
       if (strtab_shndx >= this->shnum())
        {
          this->error(_("invalid dynamic symbol table name index: %u"),


@@ -336,7 +356,7 @@ Sized_dynobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
 
       sd->symbol_names = this->get_lasting_view(strtabshdr.get_sh_offset(),
                                                strtabshdr.get_sh_size(),
 
       sd->symbol_names = this->get_lasting_view(strtabshdr.get_sh_offset(),
                                                strtabshdr.get_sh_size(),

-                                               false);
+                                               false, false);

       sd->symbol_names_size =
        convert_to_section_size_type(strtabshdr.get_sh_size());
 
       sd->symbol_names_size =
        convert_to_section_size_type(strtabshdr.get_sh_size());
 


@@ -344,8 +364,8 @@ Sized_dynobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
 
       unsigned int dummy;
       this->read_dynsym_section(pshdrs, versym_shndx, elfcpp::SHT_GNU_versym,
 
       unsigned int dummy;
       this->read_dynsym_section(pshdrs, versym_shndx, elfcpp::SHT_GNU_versym,

-                               dynsym_shndx, &sd->versym, &sd->versym_size,
-                               &dummy);
+                               this->dynsym_shndx_,
+                               &sd->versym, &sd->versym_size, &dummy);

 
       // We require that the version definition and need section link
       // to the same string table as the dynamic symbol table.  This
 
       // We require that the version definition and need section link
       // to the same string table as the dynamic symbol table.  This


@@ -373,9 +393,22 @@ Sized_dynobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
                       sd->symbol_names_size);
 }
 
                       sd->symbol_names_size);
 }
 

+// Return the Xindex structure to use for object with lots of
+// sections.
+
+template<int size, bool big_endian>
+Xindex*
+Sized_dynobj<size, big_endian>::do_initialize_xindex()
+{
+  gold_assert(this->dynsym_shndx_ != -1U);
+  Xindex* xindex = new Xindex(this->elf_file_.large_shndx_offset());
+  xindex->initialize_symtab_xindex<size, big_endian>(this, this->dynsym_shndx_);
+  return xindex;
+}
+

 // Lay out the input sections for a dynamic object.  We don't want to
 // include sections from a dynamic object, so all that we actually do
 // Lay out the input sections for a dynamic object.  We don't want to
 // include sections from a dynamic object, so all that we actually do

-// here is check for .gnu.warning sections.
+// here is check for .gnu.warning and .note.GNU-split-stack sections.

 
 template<int size, bool big_endian>
 void
 
 template<int size, bool big_endian>
 void


@@ -410,6 +443,7 @@ Sized_dynobj<size, big_endian>::do_layout(Symbol_table* symtab,
       const char* name = pnames + shdr.get_sh_name();
 
       this->handle_gnu_warning_section(name, i, symtab);
       const char* name = pnames + shdr.get_sh_name();
 
       this->handle_gnu_warning_section(name, i, symtab);

+      this->handle_split_stack_section(name);

     }
 
   delete sd->section_headers;
     }
 
   delete sd->section_headers;


@@ -617,7 +651,8 @@ Sized_dynobj<size, big_endian>::make_version_map(
 template<int size, bool big_endian>
 void
 Sized_dynobj<size, big_endian>::do_add_symbols(Symbol_table* symtab,
 template<int size, bool big_endian>
 void
 Sized_dynobj<size, big_endian>::do_add_symbols(Symbol_table* symtab,

-                                              Read_symbols_data* sd)
+                                              Read_symbols_data* sd,
+                                              Layout*)

 {
   if (sd->symbols == NULL)
     {
 {
   if (sd->symbols == NULL)
     {


@@ -639,6 +674,14 @@ Sized_dynobj<size, big_endian>::do_add_symbols(Symbol_table* symtab,
   Version_map version_map;
   this->make_version_map(sd, &version_map);
 
   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())
+    {
+      this->symbols_ = new Symbols();
+      this->symbols_->resize(symcount);
+    }
+

   const char* sym_names =
     reinterpret_cast<const char*>(sd->symbol_names->data());
   symtab->add_from_dynobj(this, sd->symbols->data(), symcount,
   const char* sym_names =
     reinterpret_cast<const char*>(sd->symbol_names->data());
   symtab->add_from_dynobj(this, sd->symbols->data(), symcount,


@@ -647,7 +690,9 @@ Sized_dynobj<size, big_endian>::do_add_symbols(Symbol_table* symtab,
                           ? NULL
                           : sd->versym->data()),
                          sd->versym_size,
                           ? NULL
                           : sd->versym->data()),
                          sd->versym_size,

-                         &version_map);
+                         &version_map,
+                         this->symbols_,
+                         &this->defined_count_);

 
   delete sd->symbols;
   sd->symbols = NULL;
 
   delete sd->symbols;
   sd->symbols = NULL;


@@ -674,6 +719,29 @@ Sized_dynobj<size, big_endian>::do_add_symbols(Symbol_table* symtab,
   this->clear_view_cache_marks();
 }
 
   this->clear_view_cache_marks();
 }
 

+// Get symbol counts.
+
+template<int size, bool big_endian>
+void
+Sized_dynobj<size, big_endian>::do_get_global_symbol_counts(
+    const Symbol_table*,
+    size_t* defined,
+    size_t* used) const
+{
+  *defined = this->defined_count_;
+  size_t count = 0;
+  for (typename Symbols::const_iterator p = this->symbols_->begin();
+       p != this->symbols_->end();
+       ++p)
+    if (*p != NULL
+       && (*p)->source() == Symbol::FROM_OBJECT
+       && (*p)->object() == this
+       && (*p)->is_defined()
+       && (*p)->dynsym_index() != -1U)
+      ++count;
+  *used = count;
+}
+

 // Given a vector of hash codes, compute the number of hash buckets to
 // use.
 
 // Given a vector of hash codes, compute the number of hash buckets to
 // use.
 


@@ -687,12 +755,12 @@ Dynobj::compute_bucket_count(const std::vector<uint32_t>& hashcodes,
   // based on the number of symbols there are.  If there are fewer
   // than 3 symbols we use 1 bucket, fewer than 17 symbols we use 3
   // buckets, fewer than 37 we use 17 buckets, and so forth.  We never
   // based on the number of symbols there are.  If there are fewer
   // than 3 symbols we use 1 bucket, fewer than 17 symbols we use 3
   // buckets, fewer than 37 we use 17 buckets, and so forth.  We never

-  // use more than 32771 buckets.  This is straight from the old GNU
+  // use more than 262147 buckets.  This is straight from the old GNU

   // linker.
   static const unsigned int buckets[] =
   {
     1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
   // linker.
   static const unsigned int buckets[] =
   {
     1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,

-    16411, 32771
+    16411, 32771, 65537, 131101, 262147

   };
   const int buckets_count = sizeof buckets / sizeof buckets[0];
 
   };
   const int buckets_count = sizeof buckets / sizeof buckets[0];
 


@@ -1232,28 +1300,18 @@ Verneed::write(const Stringpool* dynpool, bool is_last,
 Versions::Versions(const Version_script_info& version_script,
                    Stringpool* dynpool)
   : defs_(), needs_(), version_table_(),
 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_.
-  // FIXME: Should use soname here when creating a shared object. Is
-  // this fixme still valid? It looks like it's doing the right thing
-  // to me.
-  if (parameters->options().shared())
-    {
-      const char* name = dynpool->add(parameters->options().output_file_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->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;
       for (size_t k = 0; k < versions.size(); ++k)
         {
           Stringpool::Key version_key;


@@ -1283,6 +1341,28 @@ Versions::~Versions()
     delete *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*
 // Return the dynamic object which a symbol refers to.
 
 Dynobj*


@@ -1352,12 +1432,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())
       // 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);
-         return;
-       }
-
+       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>(),
       // When creating a regular executable, automatically define
       // a new version.
       Verdef* vd = new Verdef(version, std::vector<std::string>(),


@@ -1404,6 +1484,10 @@ Versions::add_need(Stringpool* dynpool, const char* filename, const char* name,
 
   if (vn == NULL)
     {
 
   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);
       // We have a new filename.
       vn = new Verneed(filename);
       this->needs_.push_back(vn);