2006-11-15 03:21:05 +08:00
|
|
|
// dynobj.cc -- dynamic object support for gold
|
|
|
|
|
2017-01-02 11:36:43 +08:00
|
|
|
// Copyright (C) 2006-2017 Free Software Foundation, Inc.
|
2007-09-23 05:02:10 +08:00
|
|
|
// 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
|
|
|
|
// (at your option) any later version.
|
|
|
|
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
// GNU General Public License for more details.
|
|
|
|
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
|
|
// along with this program; if not, write to the Free Software
|
|
|
|
// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
|
|
|
|
// MA 02110-1301, USA.
|
|
|
|
|
2006-11-15 03:21:05 +08:00
|
|
|
#include "gold.h"
|
|
|
|
|
|
|
|
#include <vector>
|
|
|
|
#include <cstring>
|
|
|
|
|
2006-11-30 01:56:40 +08:00
|
|
|
#include "elfcpp.h"
|
2007-09-21 15:20:01 +08:00
|
|
|
#include "parameters.h"
|
2008-01-19 07:26:48 +08:00
|
|
|
#include "script.h"
|
2006-11-15 03:21:05 +08:00
|
|
|
#include "symtab.h"
|
|
|
|
#include "dynobj.h"
|
|
|
|
|
|
|
|
namespace gold
|
|
|
|
{
|
|
|
|
|
2006-11-30 01:56:40 +08:00
|
|
|
// Class Dynobj.
|
|
|
|
|
2007-11-07 08:45:05 +08:00
|
|
|
// Sets up the default soname_ to use, in the (rare) cases we never
|
|
|
|
// see a DT_SONAME entry.
|
|
|
|
|
2009-12-15 03:53:05 +08:00
|
|
|
Dynobj::Dynobj(const std::string& name, Input_file* input_file, off_t offset)
|
|
|
|
: Object(name, input_file, true, offset),
|
2007-11-14 15:34:53 +08:00
|
|
|
needed_(),
|
|
|
|
unknown_needed_(UNKNOWN_NEEDED_UNSET)
|
2007-11-07 08:45:05 +08:00
|
|
|
{
|
|
|
|
// This will be overridden by a DT_SONAME entry, hopefully. But if
|
|
|
|
// we never see a DT_SONAME entry, our rule is to use the dynamic
|
|
|
|
// 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.
|
2011-04-12 08:44:48 +08:00
|
|
|
if (input_file == NULL)
|
|
|
|
this->soname_ = name;
|
|
|
|
else
|
2007-11-07 08:45:05 +08:00
|
|
|
{
|
2011-04-12 08:44:48 +08:00
|
|
|
this->soname_ = input_file->found_name();
|
|
|
|
if (this->offset() != 0)
|
2007-11-07 08:45:05 +08:00
|
|
|
{
|
2011-04-12 08:44:48 +08:00
|
|
|
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);
|
|
|
|
}
|
2007-11-07 08:45:05 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-11-15 03:21:05 +08:00
|
|
|
// Class Sized_dynobj.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
Sized_dynobj<size, big_endian>::Sized_dynobj(
|
2009-12-15 03:53:05 +08:00
|
|
|
const std::string& name,
|
|
|
|
Input_file* input_file,
|
|
|
|
off_t offset,
|
2006-11-15 03:21:05 +08:00
|
|
|
const elfcpp::Ehdr<size, big_endian>& ehdr)
|
2009-12-15 03:53:05 +08:00
|
|
|
: Dynobj(name, input_file, offset),
|
2008-04-20 02:30:58 +08:00
|
|
|
elf_file_(this, ehdr),
|
2008-07-23 06:08:43 +08:00
|
|
|
dynsym_shndx_(-1U),
|
|
|
|
symbols_(NULL),
|
|
|
|
defined_count_(0)
|
2006-11-15 03:21:05 +08:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set up the object.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
2009-10-01 06:21:13 +08:00
|
|
|
Sized_dynobj<size, big_endian>::setup()
|
2006-11-15 03:21:05 +08:00
|
|
|
{
|
2009-12-15 03:53:05 +08:00
|
|
|
const unsigned int shnum = this->elf_file_.shnum();
|
|
|
|
this->set_shnum(shnum);
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Find the SHT_DYNSYM section and the various version sections, and
|
|
|
|
// the dynamic section, given the section headers.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
|
|
|
Sized_dynobj<size, big_endian>::find_dynsym_sections(
|
|
|
|
const unsigned char* pshdrs,
|
|
|
|
unsigned int* pversym_shndx,
|
|
|
|
unsigned int* pverdef_shndx,
|
|
|
|
unsigned int* pverneed_shndx,
|
|
|
|
unsigned int* pdynamic_shndx)
|
|
|
|
{
|
|
|
|
*pversym_shndx = -1U;
|
|
|
|
*pverdef_shndx = -1U;
|
|
|
|
*pverneed_shndx = -1U;
|
|
|
|
*pdynamic_shndx = -1U;
|
|
|
|
|
2010-01-09 05:24:44 +08:00
|
|
|
unsigned int symtab_shndx = 0;
|
2008-04-20 02:30:58 +08:00
|
|
|
unsigned int xindex_shndx = 0;
|
|
|
|
unsigned int xindex_link = 0;
|
2009-12-15 03:53:05 +08:00
|
|
|
const unsigned int shnum = this->shnum();
|
2006-11-15 03:21:05 +08:00
|
|
|
const unsigned char* p = pshdrs;
|
2009-12-15 03:53:05 +08:00
|
|
|
for (unsigned int i = 0; i < shnum; ++i, p += This::shdr_size)
|
2006-11-15 03:21:05 +08:00
|
|
|
{
|
|
|
|
typename This::Shdr shdr(p);
|
|
|
|
|
|
|
|
unsigned int* pi;
|
|
|
|
switch (shdr.get_sh_type())
|
|
|
|
{
|
|
|
|
case elfcpp::SHT_DYNSYM:
|
2008-04-20 02:30:58 +08:00
|
|
|
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;
|
2006-11-15 03:21:05 +08:00
|
|
|
break;
|
2010-01-09 05:24:44 +08:00
|
|
|
case elfcpp::SHT_SYMTAB:
|
|
|
|
symtab_shndx = i;
|
2010-01-09 07:10:58 +08:00
|
|
|
pi = NULL;
|
2010-01-09 05:24:44 +08:00
|
|
|
break;
|
2006-11-15 03:21:05 +08:00
|
|
|
case elfcpp::SHT_GNU_versym:
|
|
|
|
pi = pversym_shndx;
|
|
|
|
break;
|
|
|
|
case elfcpp::SHT_GNU_verdef:
|
|
|
|
pi = pverdef_shndx;
|
|
|
|
break;
|
|
|
|
case elfcpp::SHT_GNU_verneed:
|
|
|
|
pi = pverneed_shndx;
|
|
|
|
break;
|
|
|
|
case elfcpp::SHT_DYNAMIC:
|
|
|
|
pi = pdynamic_shndx;
|
|
|
|
break;
|
2008-04-20 02:30:58 +08:00
|
|
|
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;
|
2006-11-15 03:21:05 +08:00
|
|
|
default:
|
|
|
|
pi = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pi == NULL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (*pi != -1U)
|
2007-10-14 14:49:14 +08:00
|
|
|
this->error(_("unexpected duplicate type %u section: %u, %u"),
|
|
|
|
shdr.get_sh_type(), *pi, i);
|
2006-11-15 03:21:05 +08:00
|
|
|
|
|
|
|
*pi = i;
|
|
|
|
}
|
2010-01-09 05:24:44 +08:00
|
|
|
|
|
|
|
// 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);
|
|
|
|
}
|
|
|
|
}
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Read the contents of section SHNDX. PSHDRS points to the section
|
|
|
|
// headers. TYPE is the expected section type. LINK is the expected
|
|
|
|
// section link. Store the data in *VIEW and *VIEW_SIZE. The
|
|
|
|
// section's sh_info field is stored in *VIEW_INFO.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
|
|
|
Sized_dynobj<size, big_endian>::read_dynsym_section(
|
|
|
|
const unsigned char* pshdrs,
|
|
|
|
unsigned int shndx,
|
|
|
|
elfcpp::SHT type,
|
|
|
|
unsigned int link,
|
2009-12-15 03:53:05 +08:00
|
|
|
File_view** view,
|
2007-12-18 08:48:04 +08:00
|
|
|
section_size_type* view_size,
|
2006-11-15 03:21:05 +08:00
|
|
|
unsigned int* view_info)
|
|
|
|
{
|
|
|
|
if (shndx == -1U)
|
|
|
|
{
|
2009-12-15 03:53:05 +08:00
|
|
|
*view = NULL;
|
2006-11-15 03:21:05 +08:00
|
|
|
*view_size = 0;
|
|
|
|
*view_info = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
typename This::Shdr shdr(pshdrs + shndx * This::shdr_size);
|
|
|
|
|
2006-11-30 01:56:40 +08:00
|
|
|
gold_assert(shdr.get_sh_type() == type);
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2008-04-20 02:30:58 +08:00
|
|
|
if (this->adjust_shndx(shdr.get_sh_link()) != link)
|
2007-10-14 14:49:14 +08:00
|
|
|
this->error(_("unexpected link in section %u header: %u != %u"),
|
2008-04-20 02:30:58 +08:00
|
|
|
shndx, this->adjust_shndx(shdr.get_sh_link()), link);
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2009-12-15 03:53:05 +08:00
|
|
|
*view = this->get_lasting_view(shdr.get_sh_offset(), shdr.get_sh_size(),
|
|
|
|
true, false);
|
2007-12-18 08:48:04 +08:00
|
|
|
*view_size = convert_to_section_size_type(shdr.get_sh_size());
|
2006-11-15 03:21:05 +08:00
|
|
|
*view_info = shdr.get_sh_info();
|
|
|
|
}
|
|
|
|
|
2007-11-14 15:34:53 +08:00
|
|
|
// Read the dynamic tags. Set the soname field if this shared object
|
|
|
|
// has a DT_SONAME tag. Record the DT_NEEDED tags. PSHDRS points to
|
|
|
|
// the section headers. DYNAMIC_SHNDX is the section index of the
|
|
|
|
// SHT_DYNAMIC section. STRTAB_SHNDX, STRTAB, and STRTAB_SIZE are the
|
|
|
|
// section index and contents of a string table which may be the one
|
|
|
|
// associated with the SHT_DYNAMIC section.
|
2006-11-15 03:21:05 +08:00
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
2007-11-14 15:34:53 +08:00
|
|
|
Sized_dynobj<size, big_endian>::read_dynamic(const unsigned char* pshdrs,
|
|
|
|
unsigned int dynamic_shndx,
|
|
|
|
unsigned int strtab_shndx,
|
|
|
|
const unsigned char* strtabu,
|
|
|
|
off_t strtab_size)
|
2006-11-15 03:21:05 +08:00
|
|
|
{
|
|
|
|
typename This::Shdr dynamicshdr(pshdrs + dynamic_shndx * This::shdr_size);
|
2006-11-30 01:56:40 +08:00
|
|
|
gold_assert(dynamicshdr.get_sh_type() == elfcpp::SHT_DYNAMIC);
|
2006-11-15 03:21:05 +08:00
|
|
|
|
|
|
|
const off_t dynamic_size = dynamicshdr.get_sh_size();
|
|
|
|
const unsigned char* pdynamic = this->get_view(dynamicshdr.get_sh_offset(),
|
2008-04-03 04:58:21 +08:00
|
|
|
dynamic_size, true, false);
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2008-04-20 02:30:58 +08:00
|
|
|
const unsigned int link = this->adjust_shndx(dynamicshdr.get_sh_link());
|
2006-11-15 03:21:05 +08:00
|
|
|
if (link != strtab_shndx)
|
|
|
|
{
|
|
|
|
if (link >= this->shnum())
|
|
|
|
{
|
2007-10-14 14:49:14 +08:00
|
|
|
this->error(_("DYNAMIC section %u link out of range: %u"),
|
|
|
|
dynamic_shndx, link);
|
|
|
|
return;
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
typename This::Shdr strtabshdr(pshdrs + link * This::shdr_size);
|
|
|
|
if (strtabshdr.get_sh_type() != elfcpp::SHT_STRTAB)
|
|
|
|
{
|
2007-10-14 14:49:14 +08:00
|
|
|
this->error(_("DYNAMIC section %u link %u is not a strtab"),
|
|
|
|
dynamic_shndx, link);
|
|
|
|
return;
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
strtab_size = strtabshdr.get_sh_size();
|
2008-04-03 04:58:21 +08:00
|
|
|
strtabu = this->get_view(strtabshdr.get_sh_offset(), strtab_size, false,
|
|
|
|
false);
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
|
|
|
|
2007-11-14 15:34:53 +08:00
|
|
|
const char* const strtab = reinterpret_cast<const char*>(strtabu);
|
|
|
|
|
2006-11-15 03:21:05 +08:00
|
|
|
for (const unsigned char* p = pdynamic;
|
|
|
|
p < pdynamic + dynamic_size;
|
|
|
|
p += This::dyn_size)
|
|
|
|
{
|
|
|
|
typename This::Dyn dyn(p);
|
|
|
|
|
2007-11-14 15:34:53 +08:00
|
|
|
switch (dyn.get_d_tag())
|
2006-11-15 03:21:05 +08:00
|
|
|
{
|
2007-11-14 15:34:53 +08:00
|
|
|
case elfcpp::DT_NULL:
|
|
|
|
// We should always see DT_NULL at the end of the dynamic
|
|
|
|
// tags.
|
|
|
|
return;
|
|
|
|
|
|
|
|
case elfcpp::DT_SONAME:
|
|
|
|
{
|
|
|
|
off_t val = dyn.get_d_val();
|
|
|
|
if (val >= strtab_size)
|
2007-10-14 14:49:14 +08:00
|
|
|
this->error(_("DT_SONAME value out of range: %lld >= %lld"),
|
2007-11-14 15:34:53 +08:00
|
|
|
static_cast<long long>(val),
|
|
|
|
static_cast<long long>(strtab_size));
|
|
|
|
else
|
|
|
|
this->set_soname_string(strtab + val);
|
|
|
|
}
|
|
|
|
break;
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2007-11-14 15:34:53 +08:00
|
|
|
case elfcpp::DT_NEEDED:
|
|
|
|
{
|
|
|
|
off_t val = dyn.get_d_val();
|
|
|
|
if (val >= strtab_size)
|
|
|
|
this->error(_("DT_NEEDED value out of range: %lld >= %lld"),
|
|
|
|
static_cast<long long>(val),
|
|
|
|
static_cast<long long>(strtab_size));
|
|
|
|
else
|
|
|
|
this->add_needed(strtab + val);
|
|
|
|
}
|
|
|
|
break;
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2007-11-14 15:34:53 +08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
|
|
|
|
2007-10-14 14:49:14 +08:00
|
|
|
this->error(_("missing DT_NULL in dynamic segment"));
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Read the symbols and sections from a dynamic object. We read the
|
|
|
|
// dynamic symbols, not the normal symbols.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
|
|
|
Sized_dynobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
|
2014-07-08 01:14:45 +08:00
|
|
|
{
|
|
|
|
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)
|
2006-11-15 03:21:05 +08:00
|
|
|
{
|
|
|
|
this->read_section_data(&this->elf_file_, sd);
|
|
|
|
|
|
|
|
const unsigned char* const pshdrs = sd->section_headers->data();
|
|
|
|
|
|
|
|
unsigned int versym_shndx;
|
|
|
|
unsigned int verdef_shndx;
|
|
|
|
unsigned int verneed_shndx;
|
|
|
|
unsigned int dynamic_shndx;
|
2008-04-20 02:30:58 +08:00
|
|
|
this->find_dynsym_sections(pshdrs, &versym_shndx, &verdef_shndx,
|
|
|
|
&verneed_shndx, &dynamic_shndx);
|
2006-11-15 03:21:05 +08:00
|
|
|
|
|
|
|
unsigned int strtab_shndx = -1U;
|
|
|
|
|
2007-10-14 14:49:14 +08:00
|
|
|
sd->symbols = NULL;
|
|
|
|
sd->symbols_size = 0;
|
2007-11-09 15:00:15 +08:00
|
|
|
sd->external_symbols_offset = 0;
|
2007-10-14 14:49:14 +08:00
|
|
|
sd->symbol_names = NULL;
|
|
|
|
sd->symbol_names_size = 0;
|
2009-12-10 09:10:09 +08:00
|
|
|
sd->versym = NULL;
|
|
|
|
sd->versym_size = 0;
|
|
|
|
sd->verdef = NULL;
|
|
|
|
sd->verdef_size = 0;
|
|
|
|
sd->verdef_info = 0;
|
|
|
|
sd->verneed = NULL;
|
|
|
|
sd->verneed_size = 0;
|
|
|
|
sd->verneed_info = 0;
|
2007-10-14 14:49:14 +08:00
|
|
|
|
2015-03-22 09:50:11 +08:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2008-04-20 02:30:58 +08:00
|
|
|
if (this->dynsym_shndx_ != -1U)
|
2006-11-15 03:21:05 +08:00
|
|
|
{
|
|
|
|
// Get the dynamic symbols.
|
2008-04-20 02:30:58 +08:00
|
|
|
typename This::Shdr dynsymshdr(pshdrs
|
|
|
|
+ this->dynsym_shndx_ * This::shdr_size);
|
2006-11-15 03:21:05 +08:00
|
|
|
|
|
|
|
sd->symbols = this->get_lasting_view(dynsymshdr.get_sh_offset(),
|
2008-04-03 04:58:21 +08:00
|
|
|
dynsymshdr.get_sh_size(), true,
|
|
|
|
false);
|
2007-12-18 08:48:04 +08:00
|
|
|
sd->symbols_size =
|
|
|
|
convert_to_section_size_type(dynsymshdr.get_sh_size());
|
2006-11-15 03:21:05 +08:00
|
|
|
|
|
|
|
// Get the symbol names.
|
2008-04-20 02:30:58 +08:00
|
|
|
strtab_shndx = this->adjust_shndx(dynsymshdr.get_sh_link());
|
2006-11-15 03:21:05 +08:00
|
|
|
if (strtab_shndx >= this->shnum())
|
|
|
|
{
|
2007-10-14 14:49:14 +08:00
|
|
|
this->error(_("invalid dynamic symbol table name index: %u"),
|
|
|
|
strtab_shndx);
|
|
|
|
return;
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
|
|
|
typename This::Shdr strtabshdr(pshdrs + strtab_shndx * This::shdr_size);
|
|
|
|
if (strtabshdr.get_sh_type() != elfcpp::SHT_STRTAB)
|
|
|
|
{
|
2007-10-14 14:49:14 +08:00
|
|
|
this->error(_("dynamic symbol table name section "
|
|
|
|
"has wrong type: %u"),
|
|
|
|
static_cast<unsigned int>(strtabshdr.get_sh_type()));
|
|
|
|
return;
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
sd->symbol_names = this->get_lasting_view(strtabshdr.get_sh_offset(),
|
2007-09-26 01:50:26 +08:00
|
|
|
strtabshdr.get_sh_size(),
|
2008-04-03 04:58:21 +08:00
|
|
|
false, false);
|
2007-12-18 08:48:04 +08:00
|
|
|
sd->symbol_names_size =
|
|
|
|
convert_to_section_size_type(strtabshdr.get_sh_size());
|
2006-11-15 03:21:05 +08:00
|
|
|
|
|
|
|
// Get the version information.
|
|
|
|
|
|
|
|
unsigned int dummy;
|
|
|
|
this->read_dynsym_section(pshdrs, versym_shndx, elfcpp::SHT_GNU_versym,
|
2008-04-20 02:30:58 +08:00
|
|
|
this->dynsym_shndx_,
|
|
|
|
&sd->versym, &sd->versym_size, &dummy);
|
2006-11-15 03:21:05 +08:00
|
|
|
|
|
|
|
// We require that the version definition and need section link
|
|
|
|
// to the same string table as the dynamic symbol table. This
|
|
|
|
// is not a technical requirement, but it always happens in
|
|
|
|
// practice. We could change this if necessary.
|
|
|
|
|
|
|
|
this->read_dynsym_section(pshdrs, verdef_shndx, elfcpp::SHT_GNU_verdef,
|
|
|
|
strtab_shndx, &sd->verdef, &sd->verdef_size,
|
|
|
|
&sd->verdef_info);
|
|
|
|
|
|
|
|
this->read_dynsym_section(pshdrs, verneed_shndx, elfcpp::SHT_GNU_verneed,
|
|
|
|
strtab_shndx, &sd->verneed, &sd->verneed_size,
|
|
|
|
&sd->verneed_info);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Read the SHT_DYNAMIC section to find whether this shared object
|
2007-11-14 15:34:53 +08:00
|
|
|
// has a DT_SONAME tag and to record any DT_NEEDED tags. This
|
|
|
|
// doesn't really have anything to do with reading the symbols, but
|
|
|
|
// this is a convenient place to do it.
|
2006-11-15 03:21:05 +08:00
|
|
|
if (dynamic_shndx != -1U)
|
2007-11-14 15:34:53 +08:00
|
|
|
this->read_dynamic(pshdrs, dynamic_shndx, strtab_shndx,
|
|
|
|
(sd->symbol_names == NULL
|
|
|
|
? NULL
|
|
|
|
: sd->symbol_names->data()),
|
|
|
|
sd->symbol_names_size);
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
|
|
|
|
2008-04-20 02:30:58 +08:00
|
|
|
// 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;
|
|
|
|
}
|
|
|
|
|
2006-11-15 03:21:05 +08:00
|
|
|
// 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
|
2009-10-07 06:58:27 +08:00
|
|
|
// here is check for .gnu.warning and .note.GNU-split-stack sections.
|
2006-11-15 03:21:05 +08:00
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
2007-09-21 15:20:01 +08:00
|
|
|
Sized_dynobj<size, big_endian>::do_layout(Symbol_table* symtab,
|
2006-11-15 03:21:05 +08:00
|
|
|
Layout*,
|
|
|
|
Read_symbols_data* sd)
|
|
|
|
{
|
2009-12-15 03:53:05 +08:00
|
|
|
const unsigned int shnum = this->shnum();
|
|
|
|
if (shnum == 0)
|
2006-11-15 03:21:05 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
// Get the section headers.
|
|
|
|
const unsigned char* pshdrs = sd->section_headers->data();
|
|
|
|
|
|
|
|
// Get the section names.
|
|
|
|
const unsigned char* pnamesu = sd->section_names->data();
|
|
|
|
const char* pnames = reinterpret_cast<const char*>(pnamesu);
|
|
|
|
|
|
|
|
// Skip the first, dummy, section.
|
|
|
|
pshdrs += This::shdr_size;
|
2009-12-15 03:53:05 +08:00
|
|
|
for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size)
|
2006-11-15 03:21:05 +08:00
|
|
|
{
|
|
|
|
typename This::Shdr shdr(pshdrs);
|
|
|
|
|
|
|
|
if (shdr.get_sh_name() >= sd->section_names_size)
|
|
|
|
{
|
2007-10-14 14:49:14 +08:00
|
|
|
this->error(_("bad section name offset for section %u: %lu"),
|
|
|
|
i, static_cast<unsigned long>(shdr.get_sh_name()));
|
|
|
|
return;
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
|
|
|
|
2009-12-15 03:53:05 +08:00
|
|
|
const char* name = pnames + shdr.get_sh_name();
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2009-12-15 03:53:05 +08:00
|
|
|
this->handle_gnu_warning_section(name, i, symtab);
|
|
|
|
this->handle_split_stack_section(name);
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
delete sd->section_headers;
|
|
|
|
sd->section_headers = NULL;
|
|
|
|
delete sd->section_names;
|
|
|
|
sd->section_names = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add an entry to the vector mapping version numbers to version
|
|
|
|
// strings.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
|
|
|
Sized_dynobj<size, big_endian>::set_version_map(
|
|
|
|
Version_map* version_map,
|
|
|
|
unsigned int ndx,
|
2009-12-15 03:53:05 +08:00
|
|
|
const char* name) const
|
2006-11-15 03:21:05 +08:00
|
|
|
{
|
2006-12-06 08:02:36 +08:00
|
|
|
if (ndx >= version_map->size())
|
|
|
|
version_map->resize(ndx + 1);
|
2006-11-15 03:21:05 +08:00
|
|
|
if ((*version_map)[ndx] != NULL)
|
2007-10-14 14:49:14 +08:00
|
|
|
this->error(_("duplicate definition for version %u"), ndx);
|
2009-12-15 03:53:05 +08:00
|
|
|
(*version_map)[ndx] = name;
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
// Add mappings for the version definitions to VERSION_MAP.
|
2006-11-15 03:21:05 +08:00
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
2006-12-06 08:02:36 +08:00
|
|
|
Sized_dynobj<size, big_endian>::make_verdef_map(
|
2006-11-15 03:21:05 +08:00
|
|
|
Read_symbols_data* sd,
|
|
|
|
Version_map* version_map) const
|
|
|
|
{
|
2006-12-06 08:02:36 +08:00
|
|
|
if (sd->verdef == NULL)
|
2006-11-15 03:21:05 +08:00
|
|
|
return;
|
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
const char* names = reinterpret_cast<const char*>(sd->symbol_names->data());
|
2007-12-18 08:48:04 +08:00
|
|
|
section_size_type names_size = sd->symbol_names_size;
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
const unsigned char* pverdef = sd->verdef->data();
|
2007-12-18 08:48:04 +08:00
|
|
|
section_size_type verdef_size = sd->verdef_size;
|
2006-12-06 08:02:36 +08:00
|
|
|
const unsigned int count = sd->verdef_info;
|
|
|
|
|
|
|
|
const unsigned char* p = pverdef;
|
|
|
|
for (unsigned int i = 0; i < count; ++i)
|
2006-11-15 03:21:05 +08:00
|
|
|
{
|
2006-12-06 08:02:36 +08:00
|
|
|
elfcpp::Verdef<size, big_endian> verdef(p);
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
if (verdef.get_vd_version() != elfcpp::VER_DEF_CURRENT)
|
2006-11-15 03:21:05 +08:00
|
|
|
{
|
2007-10-14 14:49:14 +08:00
|
|
|
this->error(_("unexpected verdef version %u"),
|
|
|
|
verdef.get_vd_version());
|
|
|
|
return;
|
2006-12-06 08:02:36 +08:00
|
|
|
}
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2007-12-19 09:18:41 +08:00
|
|
|
const section_size_type vd_ndx = verdef.get_vd_ndx();
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
// The GNU linker clears the VERSYM_HIDDEN bit. I'm not
|
|
|
|
// sure why.
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
// The first Verdaux holds the name of this version. Subsequent
|
|
|
|
// ones are versions that this one depends upon, which we don't
|
|
|
|
// care about here.
|
2007-12-19 09:18:41 +08:00
|
|
|
const section_size_type vd_cnt = verdef.get_vd_cnt();
|
2006-12-06 08:02:36 +08:00
|
|
|
if (vd_cnt < 1)
|
|
|
|
{
|
2007-12-19 09:18:41 +08:00
|
|
|
this->error(_("verdef vd_cnt field too small: %u"),
|
|
|
|
static_cast<unsigned int>(vd_cnt));
|
2007-10-14 14:49:14 +08:00
|
|
|
return;
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
|
|
|
|
2007-12-19 09:18:41 +08:00
|
|
|
const section_size_type vd_aux = verdef.get_vd_aux();
|
2006-12-06 08:02:36 +08:00
|
|
|
if ((p - pverdef) + vd_aux >= verdef_size)
|
2006-11-15 03:21:05 +08:00
|
|
|
{
|
2007-12-19 09:18:41 +08:00
|
|
|
this->error(_("verdef vd_aux field out of range: %u"),
|
|
|
|
static_cast<unsigned int>(vd_aux));
|
2007-10-14 14:49:14 +08:00
|
|
|
return;
|
2006-12-06 08:02:36 +08:00
|
|
|
}
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
const unsigned char* pvda = p + vd_aux;
|
|
|
|
elfcpp::Verdaux<size, big_endian> verdaux(pvda);
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2007-12-19 09:18:41 +08:00
|
|
|
const section_size_type vda_name = verdaux.get_vda_name();
|
2006-12-06 08:02:36 +08:00
|
|
|
if (vda_name >= names_size)
|
|
|
|
{
|
2007-12-19 09:18:41 +08:00
|
|
|
this->error(_("verdaux vda_name field out of range: %u"),
|
|
|
|
static_cast<unsigned int>(vda_name));
|
2007-10-14 14:49:14 +08:00
|
|
|
return;
|
2006-12-06 08:02:36 +08:00
|
|
|
}
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
this->set_version_map(version_map, vd_ndx, names + vda_name);
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2007-12-19 09:18:41 +08:00
|
|
|
const section_size_type vd_next = verdef.get_vd_next();
|
2006-12-06 08:02:36 +08:00
|
|
|
if ((p - pverdef) + vd_next >= verdef_size)
|
|
|
|
{
|
2007-12-19 09:18:41 +08:00
|
|
|
this->error(_("verdef vd_next field out of range: %u"),
|
|
|
|
static_cast<unsigned int>(vd_next));
|
2007-10-14 14:49:14 +08:00
|
|
|
return;
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
2006-12-06 08:02:36 +08:00
|
|
|
|
|
|
|
p += vd_next;
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
2006-12-06 08:02:36 +08:00
|
|
|
}
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
// Add mappings for the required versions to VERSION_MAP.
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
|
|
|
Sized_dynobj<size, big_endian>::make_verneed_map(
|
|
|
|
Read_symbols_data* sd,
|
|
|
|
Version_map* version_map) const
|
|
|
|
{
|
|
|
|
if (sd->verneed == NULL)
|
|
|
|
return;
|
2006-11-15 03:21:05 +08:00
|
|
|
|
|
|
|
const char* names = reinterpret_cast<const char*>(sd->symbol_names->data());
|
2007-12-18 08:48:04 +08:00
|
|
|
section_size_type names_size = sd->symbol_names_size;
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
const unsigned char* pverneed = sd->verneed->data();
|
2007-12-18 08:48:04 +08:00
|
|
|
const section_size_type verneed_size = sd->verneed_size;
|
2006-12-06 08:02:36 +08:00
|
|
|
const unsigned int count = sd->verneed_info;
|
|
|
|
|
|
|
|
const unsigned char* p = pverneed;
|
|
|
|
for (unsigned int i = 0; i < count; ++i)
|
2006-11-15 03:21:05 +08:00
|
|
|
{
|
2006-12-06 08:02:36 +08:00
|
|
|
elfcpp::Verneed<size, big_endian> verneed(p);
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
if (verneed.get_vn_version() != elfcpp::VER_NEED_CURRENT)
|
2006-11-15 03:21:05 +08:00
|
|
|
{
|
2007-10-14 14:49:14 +08:00
|
|
|
this->error(_("unexpected verneed version %u"),
|
|
|
|
verneed.get_vn_version());
|
|
|
|
return;
|
2006-12-06 08:02:36 +08:00
|
|
|
}
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2007-12-19 09:18:41 +08:00
|
|
|
const section_size_type vn_aux = verneed.get_vn_aux();
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
if ((p - pverneed) + vn_aux >= verneed_size)
|
|
|
|
{
|
2007-12-19 09:18:41 +08:00
|
|
|
this->error(_("verneed vn_aux field out of range: %u"),
|
|
|
|
static_cast<unsigned int>(vn_aux));
|
2007-10-14 14:49:14 +08:00
|
|
|
return;
|
2006-12-06 08:02:36 +08:00
|
|
|
}
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
const unsigned int vn_cnt = verneed.get_vn_cnt();
|
|
|
|
const unsigned char* pvna = p + vn_aux;
|
|
|
|
for (unsigned int j = 0; j < vn_cnt; ++j)
|
|
|
|
{
|
|
|
|
elfcpp::Vernaux<size, big_endian> vernaux(pvna);
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
const unsigned int vna_name = vernaux.get_vna_name();
|
|
|
|
if (vna_name >= names_size)
|
2006-11-15 03:21:05 +08:00
|
|
|
{
|
2007-10-14 14:49:14 +08:00
|
|
|
this->error(_("vernaux vna_name field out of range: %u"),
|
2007-12-19 09:18:41 +08:00
|
|
|
static_cast<unsigned int>(vna_name));
|
2007-10-14 14:49:14 +08:00
|
|
|
return;
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
this->set_version_map(version_map, vernaux.get_vna_other(),
|
|
|
|
names + vna_name);
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2007-12-19 09:18:41 +08:00
|
|
|
const section_size_type vna_next = vernaux.get_vna_next();
|
2006-12-06 08:02:36 +08:00
|
|
|
if ((pvna - pverneed) + vna_next >= verneed_size)
|
2006-11-15 03:21:05 +08:00
|
|
|
{
|
2007-10-14 14:49:14 +08:00
|
|
|
this->error(_("verneed vna_next field out of range: %u"),
|
2007-12-19 09:18:41 +08:00
|
|
|
static_cast<unsigned int>(vna_next));
|
2007-10-14 14:49:14 +08:00
|
|
|
return;
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
pvna += vna_next;
|
|
|
|
}
|
|
|
|
|
2007-12-19 09:18:41 +08:00
|
|
|
const section_size_type vn_next = verneed.get_vn_next();
|
2006-12-06 08:02:36 +08:00
|
|
|
if ((p - pverneed) + vn_next >= verneed_size)
|
|
|
|
{
|
2007-12-19 09:18:41 +08:00
|
|
|
this->error(_("verneed vn_next field out of range: %u"),
|
|
|
|
static_cast<unsigned int>(vn_next));
|
2007-10-14 14:49:14 +08:00
|
|
|
return;
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
2006-12-06 08:02:36 +08:00
|
|
|
|
|
|
|
p += vn_next;
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
2006-12-06 08:02:36 +08:00
|
|
|
}
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
// Create a vector mapping version numbers to version strings.
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
|
|
|
Sized_dynobj<size, big_endian>::make_version_map(
|
|
|
|
Read_symbols_data* sd,
|
|
|
|
Version_map* version_map) const
|
|
|
|
{
|
|
|
|
if (sd->verdef == NULL && sd->verneed == NULL)
|
|
|
|
return;
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
// A guess at the maximum version number we will see. If this is
|
|
|
|
// wrong we will be less efficient but still correct.
|
|
|
|
version_map->reserve(sd->verdef_info + sd->verneed_info * 10);
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
this->make_verdef_map(sd, version_map);
|
|
|
|
this->make_verneed_map(sd, version_map);
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Add the dynamic symbols to the symbol table.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
|
|
|
Sized_dynobj<size, big_endian>::do_add_symbols(Symbol_table* symtab,
|
2009-02-14 03:04:45 +08:00
|
|
|
Read_symbols_data* sd,
|
|
|
|
Layout*)
|
2006-11-15 03:21:05 +08:00
|
|
|
{
|
|
|
|
if (sd->symbols == NULL)
|
|
|
|
{
|
2006-11-30 01:56:40 +08:00
|
|
|
gold_assert(sd->symbol_names == NULL);
|
|
|
|
gold_assert(sd->versym == NULL && sd->verdef == NULL
|
|
|
|
&& sd->verneed == NULL);
|
2006-11-15 03:21:05 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-12-15 03:53:05 +08:00
|
|
|
const int sym_size = This::sym_size;
|
|
|
|
const size_t symcount = sd->symbols_size / sym_size;
|
2007-11-09 15:00:15 +08:00
|
|
|
gold_assert(sd->external_symbols_offset == 0);
|
2009-12-15 03:53:05 +08:00
|
|
|
if (symcount * sym_size != sd->symbols_size)
|
2006-11-15 03:21:05 +08:00
|
|
|
{
|
2007-10-14 14:49:14 +08:00
|
|
|
this->error(_("size of dynamic symbols is not multiple of symbol size"));
|
|
|
|
return;
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
Version_map version_map;
|
|
|
|
this->make_version_map(sd, &version_map);
|
|
|
|
|
2011-04-12 08:44:48 +08:00
|
|
|
// If printing symbol counts or a cross reference table or
|
|
|
|
// preparing for an incremental link, we want to track symbols.
|
2010-01-06 05:52:51 +08:00
|
|
|
if (parameters->options().user_set_print_symbol_counts()
|
2011-04-12 08:44:48 +08:00
|
|
|
|| parameters->options().cref()
|
|
|
|
|| parameters->incremental())
|
2008-07-23 06:08:43 +08:00
|
|
|
{
|
|
|
|
this->symbols_ = new Symbols();
|
|
|
|
this->symbols_->resize(symcount);
|
|
|
|
}
|
|
|
|
|
2006-11-15 03:21:05 +08:00
|
|
|
const char* sym_names =
|
|
|
|
reinterpret_cast<const char*>(sd->symbol_names->data());
|
|
|
|
symtab->add_from_dynobj(this, sd->symbols->data(), symcount,
|
|
|
|
sym_names, sd->symbol_names_size,
|
|
|
|
(sd->versym == NULL
|
|
|
|
? NULL
|
|
|
|
: sd->versym->data()),
|
|
|
|
sd->versym_size,
|
2008-07-23 06:08:43 +08:00
|
|
|
&version_map,
|
|
|
|
this->symbols_,
|
|
|
|
&this->defined_count_);
|
2006-11-15 03:21:05 +08:00
|
|
|
|
|
|
|
delete sd->symbols;
|
|
|
|
sd->symbols = NULL;
|
|
|
|
delete sd->symbol_names;
|
|
|
|
sd->symbol_names = NULL;
|
|
|
|
if (sd->versym != NULL)
|
|
|
|
{
|
|
|
|
delete sd->versym;
|
|
|
|
sd->versym = NULL;
|
|
|
|
}
|
|
|
|
if (sd->verdef != NULL)
|
|
|
|
{
|
|
|
|
delete sd->verdef;
|
|
|
|
sd->verdef = NULL;
|
|
|
|
}
|
|
|
|
if (sd->verneed != NULL)
|
|
|
|
{
|
|
|
|
delete sd->verneed;
|
|
|
|
sd->verneed = NULL;
|
|
|
|
}
|
2008-01-03 07:48:49 +08:00
|
|
|
|
|
|
|
// This is normally the last time we will read any data from this
|
|
|
|
// file.
|
|
|
|
this->clear_view_cache_marks();
|
2006-11-15 03:21:05 +08:00
|
|
|
}
|
|
|
|
|
2010-03-22 22:18:24 +08:00
|
|
|
template<int size, bool big_endian>
|
|
|
|
Archive::Should_include
|
2010-08-02 21:34:33 +08:00
|
|
|
Sized_dynobj<size, big_endian>::do_should_include_member(Symbol_table*,
|
|
|
|
Layout*,
|
|
|
|
Read_symbols_data*,
|
|
|
|
std::string*)
|
2010-03-22 22:18:24 +08:00
|
|
|
{
|
|
|
|
return Archive::SHOULD_INCLUDE_YES;
|
|
|
|
}
|
|
|
|
|
2011-03-30 09:31:57 +08:00
|
|
|
// 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());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-12 08:44:48 +08:00
|
|
|
// 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
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2008-07-23 06:08:43 +08:00
|
|
|
// 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()
|
2012-06-05 04:00:31 +08:00
|
|
|
&& (*p)->has_dynsym_index())
|
2008-07-23 06:08:43 +08:00
|
|
|
++count;
|
|
|
|
*used = count;
|
|
|
|
}
|
|
|
|
|
2006-11-30 01:56:40 +08:00
|
|
|
// Given a vector of hash codes, compute the number of hash buckets to
|
|
|
|
// use.
|
|
|
|
|
|
|
|
unsigned int
|
|
|
|
Dynobj::compute_bucket_count(const std::vector<uint32_t>& hashcodes,
|
|
|
|
bool for_gnu_hash_table)
|
|
|
|
{
|
|
|
|
// FIXME: Implement optional hash table optimization.
|
|
|
|
|
|
|
|
// Array used to determine the number of hash table buckets to use
|
|
|
|
// 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
|
2008-03-08 00:30:59 +08:00
|
|
|
// use more than 262147 buckets. This is straight from the old GNU
|
2006-11-30 01:56:40 +08:00
|
|
|
// linker.
|
|
|
|
static const unsigned int buckets[] =
|
|
|
|
{
|
|
|
|
1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
|
2008-03-08 00:30:59 +08:00
|
|
|
16411, 32771, 65537, 131101, 262147
|
2006-11-30 01:56:40 +08:00
|
|
|
};
|
|
|
|
const int buckets_count = sizeof buckets / sizeof buckets[0];
|
|
|
|
|
|
|
|
unsigned int symcount = hashcodes.size();
|
|
|
|
unsigned int ret = 1;
|
2008-03-08 00:27:33 +08:00
|
|
|
const double full_fraction
|
|
|
|
= 1.0 - parameters->options().hash_bucket_empty_fraction();
|
2006-11-30 01:56:40 +08:00
|
|
|
for (int i = 0; i < buckets_count; ++i)
|
|
|
|
{
|
2008-03-08 00:27:33 +08:00
|
|
|
if (symcount < buckets[i] * full_fraction)
|
2006-11-30 01:56:40 +08:00
|
|
|
break;
|
|
|
|
ret = buckets[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (for_gnu_hash_table && ret < 2)
|
|
|
|
ret = 2;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
// The standard ELF hash function. This hash function must not
|
|
|
|
// change, as the dynamic linker uses it also.
|
|
|
|
|
|
|
|
uint32_t
|
|
|
|
Dynobj::elf_hash(const char* name)
|
|
|
|
{
|
|
|
|
const unsigned char* nameu = reinterpret_cast<const unsigned char*>(name);
|
|
|
|
uint32_t h = 0;
|
|
|
|
unsigned char c;
|
|
|
|
while ((c = *nameu++) != '\0')
|
|
|
|
{
|
|
|
|
h = (h << 4) + c;
|
|
|
|
uint32_t g = h & 0xf0000000;
|
|
|
|
if (g != 0)
|
|
|
|
{
|
|
|
|
h ^= g >> 24;
|
|
|
|
// The ELF ABI says h &= ~g, but using xor is equivalent in
|
|
|
|
// this case (since g was set from h) and may save one
|
|
|
|
// instruction.
|
|
|
|
h ^= g;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return h;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create a standard ELF hash table, setting *PPHASH and *PHASHLEN.
|
|
|
|
// DYNSYMS is a vector with all the global dynamic symbols.
|
|
|
|
// LOCAL_DYNSYM_COUNT is the number of local symbols in the dynamic
|
|
|
|
// symbol table.
|
|
|
|
|
|
|
|
void
|
2007-09-26 15:01:35 +08:00
|
|
|
Dynobj::create_elf_hash_table(const std::vector<Symbol*>& dynsyms,
|
2006-11-30 01:56:40 +08:00
|
|
|
unsigned int local_dynsym_count,
|
|
|
|
unsigned char** pphash,
|
|
|
|
unsigned int* phashlen)
|
|
|
|
{
|
|
|
|
unsigned int dynsym_count = dynsyms.size();
|
|
|
|
|
|
|
|
// Get the hash values for all the symbols.
|
|
|
|
std::vector<uint32_t> dynsym_hashvals(dynsym_count);
|
|
|
|
for (unsigned int i = 0; i < dynsym_count; ++i)
|
|
|
|
dynsym_hashvals[i] = Dynobj::elf_hash(dynsyms[i]->name());
|
|
|
|
|
|
|
|
const unsigned int bucketcount =
|
|
|
|
Dynobj::compute_bucket_count(dynsym_hashvals, false);
|
|
|
|
|
|
|
|
std::vector<uint32_t> bucket(bucketcount);
|
|
|
|
std::vector<uint32_t> chain(local_dynsym_count + dynsym_count);
|
|
|
|
|
|
|
|
for (unsigned int i = 0; i < dynsym_count; ++i)
|
|
|
|
{
|
|
|
|
unsigned int dynsym_index = dynsyms[i]->dynsym_index();
|
|
|
|
unsigned int bucketpos = dynsym_hashvals[i] % bucketcount;
|
|
|
|
chain[dynsym_index] = bucket[bucketpos];
|
|
|
|
bucket[bucketpos] = dynsym_index;
|
|
|
|
}
|
|
|
|
|
2015-10-05 22:57:11 +08:00
|
|
|
int size = parameters->target().hash_entry_size();
|
2006-11-30 01:56:40 +08:00
|
|
|
unsigned int hashlen = ((2
|
|
|
|
+ bucketcount
|
|
|
|
+ local_dynsym_count
|
|
|
|
+ dynsym_count)
|
2015-10-05 22:57:11 +08:00
|
|
|
* size / 8);
|
2006-11-30 01:56:40 +08:00
|
|
|
unsigned char* phash = new unsigned char[hashlen];
|
|
|
|
|
2015-10-05 22:57:11 +08:00
|
|
|
bool big_endian = parameters->target().is_big_endian();
|
|
|
|
if (size == 32)
|
2007-09-26 15:01:35 +08:00
|
|
|
{
|
2015-10-05 22:57:11 +08:00
|
|
|
if (big_endian)
|
|
|
|
{
|
2007-09-26 15:01:35 +08:00
|
|
|
#if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
|
2015-10-05 22:57:11 +08:00
|
|
|
Dynobj::sized_create_elf_hash_table<32, true>(bucket, chain, phash,
|
|
|
|
hashlen);
|
2007-09-26 15:01:35 +08:00
|
|
|
#else
|
2015-10-05 22:57:11 +08:00
|
|
|
gold_unreachable();
|
2007-09-26 15:01:35 +08:00
|
|
|
#endif
|
2015-10-05 22:57:11 +08:00
|
|
|
}
|
|
|
|
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();
|
|
|
|
#endif
|
|
|
|
}
|
2007-09-26 15:01:35 +08:00
|
|
|
}
|
2015-10-05 22:57:11 +08:00
|
|
|
else if (size == 64)
|
2007-09-26 15:01:35 +08:00
|
|
|
{
|
2015-10-05 22:57:11 +08:00
|
|
|
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
|
|
|
|
{
|
2007-09-26 15:01:35 +08:00
|
|
|
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
|
2015-10-05 22:57:11 +08:00
|
|
|
Dynobj::sized_create_elf_hash_table<64, false>(bucket, chain, phash,
|
|
|
|
hashlen);
|
2007-09-26 15:01:35 +08:00
|
|
|
#else
|
2015-10-05 22:57:11 +08:00
|
|
|
gold_unreachable();
|
2007-09-26 15:01:35 +08:00
|
|
|
#endif
|
2015-10-05 22:57:11 +08:00
|
|
|
}
|
2007-09-26 15:01:35 +08:00
|
|
|
}
|
2015-10-05 22:57:11 +08:00
|
|
|
else
|
|
|
|
gold_unreachable();
|
2006-11-30 01:56:40 +08:00
|
|
|
|
|
|
|
*pphash = phash;
|
|
|
|
*phashlen = hashlen;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Fill in an ELF hash table.
|
|
|
|
|
2015-10-05 22:57:11 +08:00
|
|
|
template<int size, bool big_endian>
|
2006-11-30 01:56:40 +08:00
|
|
|
void
|
|
|
|
Dynobj::sized_create_elf_hash_table(const std::vector<uint32_t>& bucket,
|
|
|
|
const std::vector<uint32_t>& chain,
|
|
|
|
unsigned char* phash,
|
|
|
|
unsigned int hashlen)
|
|
|
|
{
|
|
|
|
unsigned char* p = phash;
|
|
|
|
|
|
|
|
const unsigned int bucketcount = bucket.size();
|
|
|
|
const unsigned int chaincount = chain.size();
|
|
|
|
|
2015-10-05 22:57:11 +08:00
|
|
|
elfcpp::Swap<size, big_endian>::writeval(p, bucketcount);
|
|
|
|
p += size / 8;
|
|
|
|
elfcpp::Swap<size, big_endian>::writeval(p, chaincount);
|
|
|
|
p += size / 8;
|
2006-11-30 01:56:40 +08:00
|
|
|
|
|
|
|
for (unsigned int i = 0; i < bucketcount; ++i)
|
|
|
|
{
|
2015-10-05 22:57:11 +08:00
|
|
|
elfcpp::Swap<size, big_endian>::writeval(p, bucket[i]);
|
|
|
|
p += size / 8;
|
2006-11-30 01:56:40 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
for (unsigned int i = 0; i < chaincount; ++i)
|
|
|
|
{
|
2015-10-05 22:57:11 +08:00
|
|
|
elfcpp::Swap<size, big_endian>::writeval(p, chain[i]);
|
|
|
|
p += size / 8;
|
2006-11-30 01:56:40 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
gold_assert(static_cast<unsigned int>(p - phash) == hashlen);
|
|
|
|
}
|
|
|
|
|
|
|
|
// The hash function used for the GNU hash table. This hash function
|
|
|
|
// must not change, as the dynamic linker uses it also.
|
|
|
|
|
|
|
|
uint32_t
|
|
|
|
Dynobj::gnu_hash(const char* name)
|
|
|
|
{
|
|
|
|
const unsigned char* nameu = reinterpret_cast<const unsigned char*>(name);
|
|
|
|
uint32_t h = 5381;
|
|
|
|
unsigned char c;
|
|
|
|
while ((c = *nameu++) != '\0')
|
|
|
|
h = (h << 5) + h + c;
|
|
|
|
return h;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create a GNU hash table, setting *PPHASH and *PHASHLEN. GNU hash
|
|
|
|
// tables are an extension to ELF which are recognized by the GNU
|
|
|
|
// dynamic linker. They are referenced using dynamic tag DT_GNU_HASH.
|
|
|
|
// TARGET is the target. DYNSYMS is a vector with all the global
|
|
|
|
// symbols which will be going into the dynamic symbol table.
|
|
|
|
// LOCAL_DYNSYM_COUNT is the number of local symbols in the dynamic
|
|
|
|
// symbol table.
|
|
|
|
|
|
|
|
void
|
2007-09-26 15:01:35 +08:00
|
|
|
Dynobj::create_gnu_hash_table(const std::vector<Symbol*>& dynsyms,
|
2006-11-30 01:56:40 +08:00
|
|
|
unsigned int local_dynsym_count,
|
|
|
|
unsigned char** pphash,
|
|
|
|
unsigned int* phashlen)
|
|
|
|
{
|
|
|
|
const unsigned int count = dynsyms.size();
|
|
|
|
|
|
|
|
// Sort the dynamic symbols into two vectors. Symbols which we do
|
|
|
|
// not want to put into the hash table we store into
|
|
|
|
// UNHASHED_DYNSYMS. Symbols which we do want to store we put into
|
|
|
|
// HASHED_DYNSYMS. DYNSYM_HASHVALS is parallel to HASHED_DYNSYMS,
|
|
|
|
// and records the hash codes.
|
|
|
|
|
|
|
|
std::vector<Symbol*> unhashed_dynsyms;
|
|
|
|
unhashed_dynsyms.reserve(count);
|
|
|
|
|
|
|
|
std::vector<Symbol*> hashed_dynsyms;
|
|
|
|
hashed_dynsyms.reserve(count);
|
|
|
|
|
|
|
|
std::vector<uint32_t> dynsym_hashvals;
|
|
|
|
dynsym_hashvals.reserve(count);
|
|
|
|
|
|
|
|
for (unsigned int i = 0; i < count; ++i)
|
|
|
|
{
|
|
|
|
Symbol* sym = dynsyms[i];
|
|
|
|
|
2009-12-30 16:29:37 +08:00
|
|
|
if (!sym->needs_dynsym_value()
|
|
|
|
&& (sym->is_undefined()
|
|
|
|
|| sym->is_from_dynobj()
|
|
|
|
|| sym->is_forced_local()))
|
2006-11-30 01:56:40 +08:00
|
|
|
unhashed_dynsyms.push_back(sym);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
hashed_dynsyms.push_back(sym);
|
|
|
|
dynsym_hashvals.push_back(Dynobj::gnu_hash(sym->name()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Put the unhashed symbols at the start of the global portion of
|
|
|
|
// the dynamic symbol table.
|
|
|
|
const unsigned int unhashed_count = unhashed_dynsyms.size();
|
|
|
|
unsigned int unhashed_dynsym_index = local_dynsym_count;
|
|
|
|
for (unsigned int i = 0; i < unhashed_count; ++i)
|
|
|
|
{
|
|
|
|
unhashed_dynsyms[i]->set_dynsym_index(unhashed_dynsym_index);
|
|
|
|
++unhashed_dynsym_index;
|
|
|
|
}
|
|
|
|
|
|
|
|
// For the actual data generation we call out to a templatized
|
|
|
|
// function.
|
2008-02-28 08:18:24 +08:00
|
|
|
int size = parameters->target().get_size();
|
|
|
|
bool big_endian = parameters->target().is_big_endian();
|
2006-11-30 01:56:40 +08:00
|
|
|
if (size == 32)
|
|
|
|
{
|
|
|
|
if (big_endian)
|
2007-09-26 15:01:35 +08:00
|
|
|
{
|
|
|
|
#ifdef HAVE_TARGET_32_BIG
|
|
|
|
Dynobj::sized_create_gnu_hash_table<32, true>(hashed_dynsyms,
|
|
|
|
dynsym_hashvals,
|
|
|
|
unhashed_dynsym_index,
|
|
|
|
pphash,
|
|
|
|
phashlen);
|
|
|
|
#else
|
|
|
|
gold_unreachable();
|
|
|
|
#endif
|
|
|
|
}
|
2006-11-30 01:56:40 +08:00
|
|
|
else
|
2007-09-26 15:01:35 +08:00
|
|
|
{
|
|
|
|
#ifdef HAVE_TARGET_32_LITTLE
|
|
|
|
Dynobj::sized_create_gnu_hash_table<32, false>(hashed_dynsyms,
|
|
|
|
dynsym_hashvals,
|
|
|
|
unhashed_dynsym_index,
|
|
|
|
pphash,
|
|
|
|
phashlen);
|
|
|
|
#else
|
|
|
|
gold_unreachable();
|
|
|
|
#endif
|
|
|
|
}
|
2006-11-30 01:56:40 +08:00
|
|
|
}
|
|
|
|
else if (size == 64)
|
|
|
|
{
|
|
|
|
if (big_endian)
|
2007-09-26 15:01:35 +08:00
|
|
|
{
|
|
|
|
#ifdef HAVE_TARGET_64_BIG
|
|
|
|
Dynobj::sized_create_gnu_hash_table<64, true>(hashed_dynsyms,
|
|
|
|
dynsym_hashvals,
|
|
|
|
unhashed_dynsym_index,
|
|
|
|
pphash,
|
|
|
|
phashlen);
|
|
|
|
#else
|
|
|
|
gold_unreachable();
|
|
|
|
#endif
|
|
|
|
}
|
2006-11-30 01:56:40 +08:00
|
|
|
else
|
2007-09-26 15:01:35 +08:00
|
|
|
{
|
|
|
|
#ifdef HAVE_TARGET_64_LITTLE
|
|
|
|
Dynobj::sized_create_gnu_hash_table<64, false>(hashed_dynsyms,
|
|
|
|
dynsym_hashvals,
|
|
|
|
unhashed_dynsym_index,
|
|
|
|
pphash,
|
|
|
|
phashlen);
|
|
|
|
#else
|
|
|
|
gold_unreachable();
|
|
|
|
#endif
|
|
|
|
}
|
2006-11-30 01:56:40 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
gold_unreachable();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create the actual data for a GNU hash table. This is just a copy
|
|
|
|
// of the code from the old GNU linker.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
|
|
|
Dynobj::sized_create_gnu_hash_table(
|
|
|
|
const std::vector<Symbol*>& hashed_dynsyms,
|
|
|
|
const std::vector<uint32_t>& dynsym_hashvals,
|
|
|
|
unsigned int unhashed_dynsym_count,
|
|
|
|
unsigned char** pphash,
|
|
|
|
unsigned int* phashlen)
|
|
|
|
{
|
|
|
|
if (hashed_dynsyms.empty())
|
|
|
|
{
|
|
|
|
// Special case for the empty hash table.
|
|
|
|
unsigned int hashlen = 5 * 4 + size / 8;
|
|
|
|
unsigned char* phash = new unsigned char[hashlen];
|
|
|
|
// One empty bucket.
|
|
|
|
elfcpp::Swap<32, big_endian>::writeval(phash, 1);
|
|
|
|
// Symbol index above unhashed symbols.
|
|
|
|
elfcpp::Swap<32, big_endian>::writeval(phash + 4, unhashed_dynsym_count);
|
|
|
|
// One word for bitmask.
|
|
|
|
elfcpp::Swap<32, big_endian>::writeval(phash + 8, 1);
|
|
|
|
// Only bloom filter.
|
|
|
|
elfcpp::Swap<32, big_endian>::writeval(phash + 12, 0);
|
|
|
|
// No valid hashes.
|
|
|
|
elfcpp::Swap<size, big_endian>::writeval(phash + 16, 0);
|
|
|
|
// No hashes in only bucket.
|
|
|
|
elfcpp::Swap<32, big_endian>::writeval(phash + 16 + size / 8, 0);
|
|
|
|
|
|
|
|
*phashlen = hashlen;
|
|
|
|
*pphash = phash;
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const unsigned int bucketcount =
|
|
|
|
Dynobj::compute_bucket_count(dynsym_hashvals, true);
|
|
|
|
|
|
|
|
const unsigned int nsyms = hashed_dynsyms.size();
|
|
|
|
|
|
|
|
uint32_t maskbitslog2 = 1;
|
|
|
|
uint32_t x = nsyms >> 1;
|
|
|
|
while (x != 0)
|
|
|
|
{
|
|
|
|
++maskbitslog2;
|
|
|
|
x >>= 1;
|
|
|
|
}
|
|
|
|
if (maskbitslog2 < 3)
|
|
|
|
maskbitslog2 = 5;
|
|
|
|
else if (((1U << (maskbitslog2 - 2)) & nsyms) != 0)
|
|
|
|
maskbitslog2 += 3;
|
|
|
|
else
|
|
|
|
maskbitslog2 += 2;
|
|
|
|
|
|
|
|
uint32_t shift1;
|
|
|
|
if (size == 32)
|
|
|
|
shift1 = 5;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (maskbitslog2 == 5)
|
|
|
|
maskbitslog2 = 6;
|
|
|
|
shift1 = 6;
|
|
|
|
}
|
|
|
|
uint32_t mask = (1U << shift1) - 1U;
|
|
|
|
uint32_t shift2 = maskbitslog2;
|
|
|
|
uint32_t maskbits = 1U << maskbitslog2;
|
|
|
|
uint32_t maskwords = 1U << (maskbitslog2 - shift1);
|
|
|
|
|
|
|
|
typedef typename elfcpp::Elf_types<size>::Elf_WXword Word;
|
|
|
|
std::vector<Word> bitmask(maskwords);
|
|
|
|
std::vector<uint32_t> counts(bucketcount);
|
|
|
|
std::vector<uint32_t> indx(bucketcount);
|
|
|
|
uint32_t symindx = unhashed_dynsym_count;
|
|
|
|
|
|
|
|
// Count the number of times each hash bucket is used.
|
|
|
|
for (unsigned int i = 0; i < nsyms; ++i)
|
|
|
|
++counts[dynsym_hashvals[i] % bucketcount];
|
|
|
|
|
|
|
|
unsigned int cnt = symindx;
|
|
|
|
for (unsigned int i = 0; i < bucketcount; ++i)
|
|
|
|
{
|
|
|
|
indx[i] = cnt;
|
|
|
|
cnt += counts[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned int hashlen = (4 + bucketcount + nsyms) * 4;
|
|
|
|
hashlen += maskbits / 8;
|
|
|
|
unsigned char* phash = new unsigned char[hashlen];
|
|
|
|
|
|
|
|
elfcpp::Swap<32, big_endian>::writeval(phash, bucketcount);
|
|
|
|
elfcpp::Swap<32, big_endian>::writeval(phash + 4, symindx);
|
|
|
|
elfcpp::Swap<32, big_endian>::writeval(phash + 8, maskwords);
|
|
|
|
elfcpp::Swap<32, big_endian>::writeval(phash + 12, shift2);
|
|
|
|
|
|
|
|
unsigned char* p = phash + 16 + maskbits / 8;
|
|
|
|
for (unsigned int i = 0; i < bucketcount; ++i)
|
|
|
|
{
|
|
|
|
if (counts[i] == 0)
|
|
|
|
elfcpp::Swap<32, big_endian>::writeval(p, 0);
|
|
|
|
else
|
|
|
|
elfcpp::Swap<32, big_endian>::writeval(p, indx[i]);
|
|
|
|
p += 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (unsigned int i = 0; i < nsyms; ++i)
|
|
|
|
{
|
|
|
|
Symbol* sym = hashed_dynsyms[i];
|
|
|
|
uint32_t hashval = dynsym_hashvals[i];
|
|
|
|
|
|
|
|
unsigned int bucket = hashval % bucketcount;
|
|
|
|
unsigned int val = ((hashval >> shift1)
|
|
|
|
& ((maskbits >> shift1) - 1));
|
|
|
|
bitmask[val] |= (static_cast<Word>(1U)) << (hashval & mask);
|
|
|
|
bitmask[val] |= (static_cast<Word>(1U)) << ((hashval >> shift2) & mask);
|
|
|
|
val = hashval & ~ 1U;
|
|
|
|
if (counts[bucket] == 1)
|
|
|
|
{
|
|
|
|
// Last element terminates the chain.
|
|
|
|
val |= 1;
|
|
|
|
}
|
|
|
|
elfcpp::Swap<32, big_endian>::writeval(p + (indx[bucket] - symindx) * 4,
|
|
|
|
val);
|
|
|
|
--counts[bucket];
|
|
|
|
|
|
|
|
sym->set_dynsym_index(indx[bucket]);
|
|
|
|
++indx[bucket];
|
|
|
|
}
|
|
|
|
|
|
|
|
p = phash + 16;
|
|
|
|
for (unsigned int i = 0; i < maskwords; ++i)
|
|
|
|
{
|
|
|
|
elfcpp::Swap<size, big_endian>::writeval(p, bitmask[i]);
|
|
|
|
p += size / 8;
|
|
|
|
}
|
|
|
|
|
|
|
|
*phashlen = hashlen;
|
|
|
|
*pphash = phash;
|
|
|
|
}
|
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
// Verdef methods.
|
|
|
|
|
|
|
|
// Write this definition to a buffer for the output section.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
unsigned char*
|
2008-03-01 03:19:17 +08:00
|
|
|
Verdef::write(const Stringpool* dynpool, bool is_last, unsigned char* pb) const
|
2006-12-06 08:02:36 +08:00
|
|
|
{
|
|
|
|
const int verdef_size = elfcpp::Elf_sizes<size>::verdef_size;
|
|
|
|
const int verdaux_size = elfcpp::Elf_sizes<size>::verdaux_size;
|
|
|
|
|
|
|
|
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)
|
2010-03-06 05:04:59 +08:00
|
|
|
| (this->is_weak_ ? elfcpp::VER_FLG_WEAK : 0)
|
|
|
|
| (this->is_info_ ? elfcpp::VER_FLG_INFO : 0));
|
2006-12-06 08:02:36 +08:00
|
|
|
vd.set_vd_ndx(this->index());
|
|
|
|
vd.set_vd_cnt(1 + this->deps_.size());
|
|
|
|
vd.set_vd_hash(Dynobj::elf_hash(this->name()));
|
|
|
|
vd.set_vd_aux(verdef_size);
|
|
|
|
vd.set_vd_next(is_last
|
|
|
|
? 0
|
|
|
|
: verdef_size + (1 + this->deps_.size()) * verdaux_size);
|
|
|
|
pb += verdef_size;
|
|
|
|
|
|
|
|
elfcpp::Verdaux_write<size, big_endian> vda(pb);
|
|
|
|
vda.set_vda_name(dynpool->get_offset(this->name()));
|
|
|
|
vda.set_vda_next(this->deps_.empty() ? 0 : verdaux_size);
|
|
|
|
pb += verdaux_size;
|
|
|
|
|
|
|
|
Deps::const_iterator p;
|
|
|
|
unsigned int i;
|
|
|
|
for (p = this->deps_.begin(), i = 0;
|
|
|
|
p != this->deps_.end();
|
|
|
|
++p, ++i)
|
|
|
|
{
|
2009-12-15 03:53:05 +08:00
|
|
|
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);
|
2006-12-06 08:02:36 +08:00
|
|
|
pb += verdaux_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
return pb;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Verneed methods.
|
|
|
|
|
|
|
|
Verneed::~Verneed()
|
|
|
|
{
|
|
|
|
for (Need_versions::iterator p = this->need_versions_.begin();
|
|
|
|
p != this->need_versions_.end();
|
|
|
|
++p)
|
|
|
|
delete *p;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add a new version to this file reference.
|
|
|
|
|
|
|
|
Verneed_version*
|
|
|
|
Verneed::add_name(const char* name)
|
|
|
|
{
|
|
|
|
Verneed_version* vv = new Verneed_version(name);
|
|
|
|
this->need_versions_.push_back(vv);
|
|
|
|
return vv;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set the version indexes starting at INDEX.
|
|
|
|
|
|
|
|
unsigned int
|
|
|
|
Verneed::finalize(unsigned int index)
|
|
|
|
{
|
|
|
|
for (Need_versions::iterator p = this->need_versions_.begin();
|
|
|
|
p != this->need_versions_.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
(*p)->set_index(index);
|
|
|
|
++index;
|
|
|
|
}
|
|
|
|
return index;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Write this list of referenced versions to a buffer for the output
|
|
|
|
// section.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
unsigned char*
|
|
|
|
Verneed::write(const Stringpool* dynpool, bool is_last,
|
2008-03-01 03:19:17 +08:00
|
|
|
unsigned char* pb) const
|
2006-12-06 08:02:36 +08:00
|
|
|
{
|
|
|
|
const int verneed_size = elfcpp::Elf_sizes<size>::verneed_size;
|
|
|
|
const int vernaux_size = elfcpp::Elf_sizes<size>::vernaux_size;
|
|
|
|
|
|
|
|
elfcpp::Verneed_write<size, big_endian> vn(pb);
|
|
|
|
vn.set_vn_version(elfcpp::VER_NEED_CURRENT);
|
|
|
|
vn.set_vn_cnt(this->need_versions_.size());
|
|
|
|
vn.set_vn_file(dynpool->get_offset(this->filename()));
|
|
|
|
vn.set_vn_aux(verneed_size);
|
|
|
|
vn.set_vn_next(is_last
|
|
|
|
? 0
|
|
|
|
: verneed_size + this->need_versions_.size() * vernaux_size);
|
|
|
|
pb += verneed_size;
|
|
|
|
|
|
|
|
Need_versions::const_iterator p;
|
|
|
|
unsigned int i;
|
|
|
|
for (p = this->need_versions_.begin(), i = 0;
|
|
|
|
p != this->need_versions_.end();
|
|
|
|
++p, ++i)
|
|
|
|
{
|
|
|
|
elfcpp::Vernaux_write<size, big_endian> vna(pb);
|
|
|
|
vna.set_vna_hash(Dynobj::elf_hash((*p)->version()));
|
|
|
|
// FIXME: We need to sometimes set VER_FLG_WEAK here.
|
|
|
|
vna.set_vna_flags(0);
|
|
|
|
vna.set_vna_other((*p)->index());
|
|
|
|
vna.set_vna_name(dynpool->get_offset((*p)->version()));
|
|
|
|
vna.set_vna_next(i + 1 >= this->need_versions_.size()
|
|
|
|
? 0
|
|
|
|
: vernaux_size);
|
|
|
|
pb += vernaux_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
return pb;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Versions methods.
|
|
|
|
|
2009-12-15 03:53:05 +08:00
|
|
|
Versions::Versions(const Version_script_info& version_script,
|
2008-02-27 06:48:08 +08:00
|
|
|
Stringpool* dynpool)
|
2008-01-16 07:41:28 +08:00
|
|
|
: defs_(), needs_(), version_table_(),
|
2009-12-15 03:53:05 +08:00
|
|
|
is_finalized_(false), version_script_(version_script),
|
2009-10-17 03:11:32 +08:00
|
|
|
needs_base_version_(parameters->options().shared())
|
2008-01-16 07:41:28 +08:00
|
|
|
{
|
|
|
|
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();
|
2009-10-17 03:11:32 +08:00
|
|
|
|
|
|
|
if (this->needs_base_version_ && !versions.empty())
|
|
|
|
this->define_base_version(dynpool);
|
|
|
|
|
2008-01-16 07:41:28 +08:00
|
|
|
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,
|
2008-02-27 06:48:08 +08:00
|
|
|
this->version_script_.get_dependencies(version),
|
2010-03-06 05:04:59 +08:00
|
|
|
false, false, false, false);
|
2008-01-16 07:41:28 +08:00
|
|
|
this->defs_.push_back(vd);
|
|
|
|
Key key(version_key, 0);
|
|
|
|
this->version_table_.insert(std::make_pair(key, vd));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2009-10-17 03:11:32 +08:00
|
|
|
// 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>(),
|
2010-03-06 05:04:59 +08:00
|
|
|
true, false, false, true);
|
2009-10-17 03:11:32 +08:00
|
|
|
this->defs_.push_back(vdbase);
|
|
|
|
this->needs_base_version_ = false;
|
|
|
|
}
|
|
|
|
|
2007-10-23 07:08:22 +08:00
|
|
|
// 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
|
|
|
|
{
|
|
|
|
Object* object = sym->object();
|
|
|
|
gold_assert(object->is_dynamic());
|
|
|
|
return static_cast<Dynobj*>(object);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
// Record version information for a symbol going into the dynamic
|
|
|
|
// symbol table.
|
|
|
|
|
|
|
|
void
|
2007-10-23 13:05:48 +08:00
|
|
|
Versions::record_version(const Symbol_table* symtab,
|
2006-12-06 08:02:36 +08:00
|
|
|
Stringpool* dynpool, const Symbol* sym)
|
|
|
|
{
|
|
|
|
gold_assert(!this->is_finalized_);
|
|
|
|
gold_assert(sym->version() != NULL);
|
2008-02-28 08:18:24 +08:00
|
|
|
|
Fix symbol versioning problems in PR 18703.
If a symbol is defined with ".symver foo,foo@VER", the assembler
creates two symbols in the object: one unversioned, and one with
the (non-default) version "VER". If foo is listed in a version
script, gold would then make the first of those symbols the
default version, and would ignore the second symbol as a
duplicate, without making it a non-default version. While this is
arguably reasonable behavior, it doesn't match Gnu ld behavior,
so this patch fixes that by allowing the second definition to
override the first by resetting the "default version" indication.
Several test cases from the Gnu ld testsuite also exposed another
related problem, where a symbol defined with ".symver foo,foo@",
placed into a shared library, is not handled properly by gold.
This patch also fixes that case, binding the symbol to the base
version.
gold/
PR gold/18703
* dynobj.cc (Versions::record_version): Handle symbol defined with
base version.
(Versions::symbol_section_contents): Likewise.
* symtab.h (Symbol::set_is_not_default): New class method.
(Symbol_table::resolve): Add is_default_version parameter.
(Symbol_table::should_override): Likewise.
* resolve.cc (Symbol_table::resolve): Add is_default_version parameter,
and pass to should_override. Adjust all callers and explicit
instantiations.
(Symbol_table::should_override): Add is_default_value parameter;
allow default version in a dynamic object to override existing
definition from same object.
* symtab.cc (Symbol_table::add_from_object): Handle case where same
symbol is defined as unversioned and non-default version in the same
object.
* testsuite/Makefile.am (ver_test_13): New test case.
* testsuite/Makefile.in: Regenerate.
* testsuite/ver_test_4.cc: Add test for symbol with base version.
* testsuite/ver_test_4.sh: Likewise.
* testsuite/ver_test_13.c: New source file.
* testsuite/ver_test_13.script: New version script.
* testsuite/ver_test_13.sh: New test case.
2015-07-28 06:09:08 +08:00
|
|
|
// A symbol defined as "sym@" is bound to an unspecified base version.
|
|
|
|
if (sym->version()[0] == '\0')
|
|
|
|
return;
|
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
Stringpool::Key version_key;
|
2007-10-12 14:06:34 +08:00
|
|
|
const char* version = dynpool->add(sym->version(), false, &version_key);
|
2006-12-06 08:02:36 +08:00
|
|
|
|
2007-10-23 07:08:22 +08:00
|
|
|
if (!sym->is_from_dynobj() && !sym->is_copied_from_dynobj())
|
2007-09-12 06:57:35 +08:00
|
|
|
{
|
2008-02-28 08:18:24 +08:00
|
|
|
if (parameters->options().shared())
|
2011-07-02 13:30:00 +08:00
|
|
|
this->add_def(dynpool, sym, version, version_key);
|
2007-09-12 06:57:35 +08:00
|
|
|
}
|
2006-12-06 08:02:36 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
// This is a version reference.
|
2007-10-23 07:08:22 +08:00
|
|
|
Dynobj* dynobj = this->get_dynobj_for_sym(symtab, sym);
|
2006-12-06 08:02:36 +08:00
|
|
|
this->add_need(dynpool, dynobj->soname(), version, version_key);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// We've found a symbol SYM defined in version VERSION.
|
|
|
|
|
|
|
|
void
|
2011-07-02 13:30:00 +08:00
|
|
|
Versions::add_def(Stringpool* dynpool, const Symbol* sym, const char* version,
|
2007-10-23 13:05:48 +08:00
|
|
|
Stringpool::Key version_key)
|
2006-12-06 08:02:36 +08:00
|
|
|
{
|
|
|
|
Key k(version_key, 0);
|
|
|
|
Version_base* const vbnull = NULL;
|
|
|
|
std::pair<Version_table::iterator, bool> ins =
|
|
|
|
this->version_table_.insert(std::make_pair(k, vbnull));
|
2008-01-24 08:15:00 +08:00
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
if (!ins.second)
|
|
|
|
{
|
|
|
|
// We already have an entry for this version.
|
|
|
|
Version_base* vb = ins.first->second;
|
|
|
|
|
|
|
|
// We have now seen a symbol in this version, so it is not
|
|
|
|
// weak.
|
2007-12-22 07:31:19 +08:00
|
|
|
gold_assert(vb != NULL);
|
2006-12-06 08:02:36 +08:00
|
|
|
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.
|
2008-02-28 08:18:24 +08:00
|
|
|
if (parameters->options().shared())
|
2011-07-02 13:30:00 +08:00
|
|
|
{
|
|
|
|
gold_error(_("symbol %s has undefined version %s"),
|
|
|
|
sym->demangled_name().c_str(), version);
|
|
|
|
if (this->needs_base_version_)
|
|
|
|
this->define_base_version(dynpool);
|
|
|
|
}
|
2009-10-17 03:11:32 +08:00
|
|
|
else
|
|
|
|
// We only insert a base version for shared library.
|
|
|
|
gold_assert(!this->needs_base_version_);
|
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
// When creating a regular executable, automatically define
|
|
|
|
// a new version.
|
2008-01-16 07:41:28 +08:00
|
|
|
Verdef* vd = new Verdef(version, std::vector<std::string>(),
|
2010-03-06 05:04:59 +08:00
|
|
|
false, false, false, false);
|
2006-12-06 08:02:36 +08:00
|
|
|
this->defs_.push_back(vd);
|
|
|
|
ins.first->second = vd;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add a reference to version NAME in file FILENAME.
|
|
|
|
|
|
|
|
void
|
|
|
|
Versions::add_need(Stringpool* dynpool, const char* filename, const char* name,
|
|
|
|
Stringpool::Key name_key)
|
|
|
|
{
|
|
|
|
Stringpool::Key filename_key;
|
2007-10-12 14:06:34 +08:00
|
|
|
filename = dynpool->add(filename, true, &filename_key);
|
2006-12-06 08:02:36 +08:00
|
|
|
|
|
|
|
Key k(name_key, filename_key);
|
|
|
|
Version_base* const vbnull = NULL;
|
|
|
|
std::pair<Version_table::iterator, bool> ins =
|
|
|
|
this->version_table_.insert(std::make_pair(k, vbnull));
|
|
|
|
|
|
|
|
if (!ins.second)
|
|
|
|
{
|
|
|
|
// We already have an entry for this filename/version.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// See whether we already have this filename. We don't expect many
|
|
|
|
// version references, so we just do a linear search. This could be
|
|
|
|
// replaced by a hash table.
|
|
|
|
Verneed* vn = NULL;
|
|
|
|
for (Needs::iterator p = this->needs_.begin();
|
|
|
|
p != this->needs_.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
if ((*p)->filename() == filename)
|
|
|
|
{
|
|
|
|
vn = *p;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vn == NULL)
|
|
|
|
{
|
2009-10-17 03:11:32 +08:00
|
|
|
// Create base version definition lazily for shared library.
|
|
|
|
if (this->needs_base_version_)
|
|
|
|
this->define_base_version(dynpool);
|
|
|
|
|
2006-12-06 08:02:36 +08:00
|
|
|
// 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.
|
|
|
|
|
|
|
|
unsigned int
|
2008-01-26 09:17:45 +08:00
|
|
|
Versions::finalize(Symbol_table* symtab, unsigned int dynsym_index,
|
|
|
|
std::vector<Symbol*>* syms)
|
2006-12-06 08:02:36 +08:00
|
|
|
{
|
|
|
|
gold_assert(!this->is_finalized_);
|
|
|
|
|
|
|
|
unsigned int vi = 1;
|
|
|
|
|
|
|
|
for (Defs::iterator p = this->defs_.begin();
|
|
|
|
p != this->defs_.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
(*p)->set_index(vi);
|
|
|
|
++vi;
|
|
|
|
|
|
|
|
// Create a version symbol if necessary.
|
|
|
|
if (!(*p)->is_symbol_created())
|
|
|
|
{
|
2008-01-26 09:17:45 +08:00
|
|
|
Symbol* vsym = symtab->define_as_constant((*p)->name(),
|
2009-12-29 08:31:48 +08:00
|
|
|
(*p)->name(),
|
|
|
|
Symbol_table::PREDEFINED,
|
|
|
|
0, 0,
|
2006-12-06 14:28:56 +08:00
|
|
|
elfcpp::STT_OBJECT,
|
|
|
|
elfcpp::STB_GLOBAL,
|
|
|
|
elfcpp::STV_DEFAULT, 0,
|
2008-02-13 09:20:38 +08:00
|
|
|
false, false);
|
2006-12-06 08:02:36 +08:00
|
|
|
vsym->set_needs_dynsym_entry();
|
2007-09-12 06:57:35 +08:00
|
|
|
vsym->set_dynsym_index(dynsym_index);
|
* script.cc (class Lazy_demangler): Recreate--revert part of patch
of 2009-12-30.
(Version_script_info::Version_script_info): Initialize globs_,
default_version_, default_is_global_, and exact_. Don't
initialize globals_ or locals_.
(Version_script_info::build_lookup_tables): Build local symbols
first.
(Version_script_info::unquote): New function.
(Version_script_info::add_exact_match): New function.
(Version_script_info::build_expression_list_lookup): Remove lookup
parameter. Add is_global parameter. Change all callers. Handle
wildcard pattern specially. Unquote pattern. Call
add_exact_match.
(Version_script_info::get_name_to_match): New function.
(Version_script_info::get_symbol_version): New function.
(Version_script_info::get_symbol_version_helper): Remove.
(Version_script_info::check_unmatched_names): Call unquote.
* script.h (class Version_script_info): Change get_symbol_version
to be non-inline and add is_global parameter; change all callers.
Rewrite symbol_is_local. Update declarations. Define struct
Version_tree_match, Exact, Globs. Don't define struct Lookup.
Remove globals_ and locals_ members. Add exact_, globs_,
default_version_, is_global_.
(Version_script_info::Glob): Remove pattern, add expression and
is_global. Update constructor. Change all callers.
* dynobj.cc (Versions::finalize): Mark the version symbol as the
default version.
(Versions::symbol_section_contents): If a symbol is undefined, or
defined in a dynamic object, set the version index to
VER_NDX_LOCAL.
* symtab.cc (Symbol_table::add_from_relobj): Don't call
symbol_is_local.
(Symbol_table::add_from_pluginobj): Likewise.
* testsuite/ver_matching_test.sh: blaza1 and blaza go into V2.
2010-01-12 14:41:36 +08:00
|
|
|
vsym->set_is_default();
|
2006-12-06 08:02:36 +08:00
|
|
|
++dynsym_index;
|
|
|
|
syms->push_back(vsym);
|
|
|
|
// The name is already in the dynamic pool.
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Index 1 is used for global symbols.
|
|
|
|
if (vi == 1)
|
|
|
|
{
|
|
|
|
gold_assert(this->defs_.empty());
|
|
|
|
vi = 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (Needs::iterator p = this->needs_.begin();
|
|
|
|
p != this->needs_.end();
|
|
|
|
++p)
|
|
|
|
vi = (*p)->finalize(vi);
|
|
|
|
|
|
|
|
this->is_finalized_ = true;
|
|
|
|
|
|
|
|
return dynsym_index;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return the version index to use for a symbol. This does two hash
|
|
|
|
// table lookups: one in DYNPOOL and one in this->version_table_.
|
|
|
|
// Another approach alternative would be store a pointer in SYM, which
|
|
|
|
// would increase the size of the symbol table. Or perhaps we could
|
|
|
|
// use a hash table from dynamic symbol pointer values to Version_base
|
|
|
|
// pointers.
|
|
|
|
|
|
|
|
unsigned int
|
2007-10-23 07:08:22 +08:00
|
|
|
Versions::version_index(const Symbol_table* symtab, const Stringpool* dynpool,
|
|
|
|
const Symbol* sym) const
|
2006-12-06 08:02:36 +08:00
|
|
|
{
|
|
|
|
Stringpool::Key version_key;
|
|
|
|
const char* version = dynpool->find(sym->version(), &version_key);
|
|
|
|
gold_assert(version != NULL);
|
|
|
|
|
2006-12-06 08:28:03 +08:00
|
|
|
Key k;
|
2007-10-23 07:08:22 +08:00
|
|
|
if (!sym->is_from_dynobj() && !sym->is_copied_from_dynobj())
|
2007-09-12 08:30:59 +08:00
|
|
|
{
|
2008-02-28 08:18:24 +08:00
|
|
|
if (!parameters->options().shared())
|
2007-09-12 08:30:59 +08:00
|
|
|
return elfcpp::VER_NDX_GLOBAL;
|
|
|
|
k = Key(version_key, 0);
|
|
|
|
}
|
2006-12-06 08:02:36 +08:00
|
|
|
else
|
|
|
|
{
|
2007-10-23 07:08:22 +08:00
|
|
|
Dynobj* dynobj = this->get_dynobj_for_sym(symtab, sym);
|
2006-12-06 08:02:36 +08:00
|
|
|
|
|
|
|
Stringpool::Key filename_key;
|
|
|
|
const char* filename = dynpool->find(dynobj->soname(), &filename_key);
|
|
|
|
gold_assert(filename != NULL);
|
|
|
|
|
2006-12-06 08:28:03 +08:00
|
|
|
k = Key(version_key, filename_key);
|
2006-12-06 08:02:36 +08:00
|
|
|
}
|
|
|
|
|
2006-12-06 08:28:03 +08:00
|
|
|
Version_table::const_iterator p = this->version_table_.find(k);
|
2006-12-06 08:02:36 +08:00
|
|
|
gold_assert(p != this->version_table_.end());
|
|
|
|
|
|
|
|
return p->second->index();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return an allocated buffer holding the contents of the symbol
|
|
|
|
// version section.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
2007-10-23 07:08:22 +08:00
|
|
|
Versions::symbol_section_contents(const Symbol_table* symtab,
|
|
|
|
const Stringpool* dynpool,
|
2006-12-06 08:02:36 +08:00
|
|
|
unsigned int local_symcount,
|
|
|
|
const std::vector<Symbol*>& syms,
|
|
|
|
unsigned char** pp,
|
2008-03-01 03:19:17 +08:00
|
|
|
unsigned int* psize) const
|
2006-12-06 08:02:36 +08:00
|
|
|
{
|
|
|
|
gold_assert(this->is_finalized_);
|
|
|
|
|
|
|
|
unsigned int sz = (local_symcount + syms.size()) * 2;
|
|
|
|
unsigned char* pbuf = new unsigned char[sz];
|
|
|
|
|
|
|
|
for (unsigned int i = 0; i < local_symcount; ++i)
|
|
|
|
elfcpp::Swap<16, big_endian>::writeval(pbuf + i * 2,
|
|
|
|
elfcpp::VER_NDX_LOCAL);
|
|
|
|
|
|
|
|
for (std::vector<Symbol*>::const_iterator p = syms.begin();
|
|
|
|
p != syms.end();
|
|
|
|
++p)
|
|
|
|
{
|
2009-12-15 03:53:05 +08:00
|
|
|
unsigned int version_index;
|
2006-12-06 08:02:36 +08:00
|
|
|
const char* version = (*p)->version();
|
Fix symbol versioning problems in PR 18703.
If a symbol is defined with ".symver foo,foo@VER", the assembler
creates two symbols in the object: one unversioned, and one with
the (non-default) version "VER". If foo is listed in a version
script, gold would then make the first of those symbols the
default version, and would ignore the second symbol as a
duplicate, without making it a non-default version. While this is
arguably reasonable behavior, it doesn't match Gnu ld behavior,
so this patch fixes that by allowing the second definition to
override the first by resetting the "default version" indication.
Several test cases from the Gnu ld testsuite also exposed another
related problem, where a symbol defined with ".symver foo,foo@",
placed into a shared library, is not handled properly by gold.
This patch also fixes that case, binding the symbol to the base
version.
gold/
PR gold/18703
* dynobj.cc (Versions::record_version): Handle symbol defined with
base version.
(Versions::symbol_section_contents): Likewise.
* symtab.h (Symbol::set_is_not_default): New class method.
(Symbol_table::resolve): Add is_default_version parameter.
(Symbol_table::should_override): Likewise.
* resolve.cc (Symbol_table::resolve): Add is_default_version parameter,
and pass to should_override. Adjust all callers and explicit
instantiations.
(Symbol_table::should_override): Add is_default_value parameter;
allow default version in a dynamic object to override existing
definition from same object.
* symtab.cc (Symbol_table::add_from_object): Handle case where same
symbol is defined as unversioned and non-default version in the same
object.
* testsuite/Makefile.am (ver_test_13): New test case.
* testsuite/Makefile.in: Regenerate.
* testsuite/ver_test_4.cc: Add test for symbol with base version.
* testsuite/ver_test_4.sh: Likewise.
* testsuite/ver_test_13.c: New source file.
* testsuite/ver_test_13.script: New version script.
* testsuite/ver_test_13.sh: New test case.
2015-07-28 06:09:08 +08:00
|
|
|
if (version == NULL)
|
* script.cc (class Lazy_demangler): Recreate--revert part of patch
of 2009-12-30.
(Version_script_info::Version_script_info): Initialize globs_,
default_version_, default_is_global_, and exact_. Don't
initialize globals_ or locals_.
(Version_script_info::build_lookup_tables): Build local symbols
first.
(Version_script_info::unquote): New function.
(Version_script_info::add_exact_match): New function.
(Version_script_info::build_expression_list_lookup): Remove lookup
parameter. Add is_global parameter. Change all callers. Handle
wildcard pattern specially. Unquote pattern. Call
add_exact_match.
(Version_script_info::get_name_to_match): New function.
(Version_script_info::get_symbol_version): New function.
(Version_script_info::get_symbol_version_helper): Remove.
(Version_script_info::check_unmatched_names): Call unquote.
* script.h (class Version_script_info): Change get_symbol_version
to be non-inline and add is_global parameter; change all callers.
Rewrite symbol_is_local. Update declarations. Define struct
Version_tree_match, Exact, Globs. Don't define struct Lookup.
Remove globals_ and locals_ members. Add exact_, globs_,
default_version_, is_global_.
(Version_script_info::Glob): Remove pattern, add expression and
is_global. Update constructor. Change all callers.
* dynobj.cc (Versions::finalize): Mark the version symbol as the
default version.
(Versions::symbol_section_contents): If a symbol is undefined, or
defined in a dynamic object, set the version index to
VER_NDX_LOCAL.
* symtab.cc (Symbol_table::add_from_relobj): Don't call
symbol_is_local.
(Symbol_table::add_from_pluginobj): Likewise.
* testsuite/ver_matching_test.sh: blaza1 and blaza go into V2.
2010-01-12 14:41:36 +08:00
|
|
|
{
|
|
|
|
if ((*p)->is_defined() && !(*p)->is_from_dynobj())
|
|
|
|
version_index = elfcpp::VER_NDX_GLOBAL;
|
|
|
|
else
|
|
|
|
version_index = elfcpp::VER_NDX_LOCAL;
|
|
|
|
}
|
Fix symbol versioning problems in PR 18703.
If a symbol is defined with ".symver foo,foo@VER", the assembler
creates two symbols in the object: one unversioned, and one with
the (non-default) version "VER". If foo is listed in a version
script, gold would then make the first of those symbols the
default version, and would ignore the second symbol as a
duplicate, without making it a non-default version. While this is
arguably reasonable behavior, it doesn't match Gnu ld behavior,
so this patch fixes that by allowing the second definition to
override the first by resetting the "default version" indication.
Several test cases from the Gnu ld testsuite also exposed another
related problem, where a symbol defined with ".symver foo,foo@",
placed into a shared library, is not handled properly by gold.
This patch also fixes that case, binding the symbol to the base
version.
gold/
PR gold/18703
* dynobj.cc (Versions::record_version): Handle symbol defined with
base version.
(Versions::symbol_section_contents): Likewise.
* symtab.h (Symbol::set_is_not_default): New class method.
(Symbol_table::resolve): Add is_default_version parameter.
(Symbol_table::should_override): Likewise.
* resolve.cc (Symbol_table::resolve): Add is_default_version parameter,
and pass to should_override. Adjust all callers and explicit
instantiations.
(Symbol_table::should_override): Add is_default_value parameter;
allow default version in a dynamic object to override existing
definition from same object.
* symtab.cc (Symbol_table::add_from_object): Handle case where same
symbol is defined as unversioned and non-default version in the same
object.
* testsuite/Makefile.am (ver_test_13): New test case.
* testsuite/Makefile.in: Regenerate.
* testsuite/ver_test_4.cc: Add test for symbol with base version.
* testsuite/ver_test_4.sh: Likewise.
* testsuite/ver_test_13.c: New source file.
* testsuite/ver_test_13.script: New version script.
* testsuite/ver_test_13.sh: New test case.
2015-07-28 06:09:08 +08:00
|
|
|
else if (version[0] == '\0')
|
|
|
|
version_index = elfcpp::VER_NDX_GLOBAL;
|
|
|
|
else
|
|
|
|
version_index = this->version_index(symtab, dynpool, *p);
|
2008-01-16 07:41:28 +08:00
|
|
|
// If the symbol was defined as foo@V1 instead of foo@@V1, add
|
|
|
|
// the hidden bit.
|
|
|
|
if ((*p)->version() != NULL && !(*p)->is_default())
|
2009-12-15 03:53:05 +08:00
|
|
|
version_index |= elfcpp::VERSYM_HIDDEN;
|
2006-12-06 08:02:36 +08:00
|
|
|
elfcpp::Swap<16, big_endian>::writeval(pbuf + (*p)->dynsym_index() * 2,
|
2009-12-15 03:53:05 +08:00
|
|
|
version_index);
|
2006-12-06 08:02:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
*pp = pbuf;
|
|
|
|
*psize = sz;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return an allocated buffer holding the contents of the version
|
|
|
|
// definition section.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
|
|
|
Versions::def_section_contents(const Stringpool* dynpool,
|
|
|
|
unsigned char** pp, unsigned int* psize,
|
2008-03-01 03:19:17 +08:00
|
|
|
unsigned int* pentries) const
|
2006-12-06 08:02:36 +08:00
|
|
|
{
|
|
|
|
gold_assert(this->is_finalized_);
|
|
|
|
gold_assert(!this->defs_.empty());
|
|
|
|
|
|
|
|
const int verdef_size = elfcpp::Elf_sizes<size>::verdef_size;
|
|
|
|
const int verdaux_size = elfcpp::Elf_sizes<size>::verdaux_size;
|
|
|
|
|
|
|
|
unsigned int sz = 0;
|
|
|
|
for (Defs::const_iterator p = this->defs_.begin();
|
|
|
|
p != this->defs_.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
sz += verdef_size + verdaux_size;
|
|
|
|
sz += (*p)->count_dependencies() * verdaux_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned char* pbuf = new unsigned char[sz];
|
|
|
|
|
|
|
|
unsigned char* pb = pbuf;
|
|
|
|
Defs::const_iterator p;
|
|
|
|
unsigned int i;
|
|
|
|
for (p = this->defs_.begin(), i = 0;
|
|
|
|
p != this->defs_.end();
|
|
|
|
++p, ++i)
|
2008-03-01 03:19:17 +08:00
|
|
|
pb = (*p)->write<size, big_endian>(dynpool,
|
|
|
|
i + 1 >= this->defs_.size(),
|
|
|
|
pb);
|
2006-12-06 08:02:36 +08:00
|
|
|
|
|
|
|
gold_assert(static_cast<unsigned int>(pb - pbuf) == sz);
|
|
|
|
|
|
|
|
*pp = pbuf;
|
|
|
|
*psize = sz;
|
|
|
|
*pentries = this->defs_.size();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return an allocated buffer holding the contents of the version
|
|
|
|
// reference section.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
|
|
|
Versions::need_section_contents(const Stringpool* dynpool,
|
2010-08-25 16:36:54 +08:00
|
|
|
unsigned char** pp, unsigned int* psize,
|
|
|
|
unsigned int* pentries) const
|
2006-12-06 08:02:36 +08:00
|
|
|
{
|
|
|
|
gold_assert(this->is_finalized_);
|
|
|
|
gold_assert(!this->needs_.empty());
|
|
|
|
|
|
|
|
const int verneed_size = elfcpp::Elf_sizes<size>::verneed_size;
|
|
|
|
const int vernaux_size = elfcpp::Elf_sizes<size>::vernaux_size;
|
|
|
|
|
|
|
|
unsigned int sz = 0;
|
|
|
|
for (Needs::const_iterator p = this->needs_.begin();
|
|
|
|
p != this->needs_.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
sz += verneed_size;
|
|
|
|
sz += (*p)->count_versions() * vernaux_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned char* pbuf = new unsigned char[sz];
|
|
|
|
|
|
|
|
unsigned char* pb = pbuf;
|
|
|
|
Needs::const_iterator p;
|
|
|
|
unsigned int i;
|
|
|
|
for (p = this->needs_.begin(), i = 0;
|
|
|
|
p != this->needs_.end();
|
|
|
|
++p, ++i)
|
2008-03-01 03:19:17 +08:00
|
|
|
pb = (*p)->write<size, big_endian>(dynpool,
|
|
|
|
i + 1 >= this->needs_.size(),
|
|
|
|
pb);
|
2006-12-06 08:02:36 +08:00
|
|
|
|
|
|
|
gold_assert(static_cast<unsigned int>(pb - pbuf) == sz);
|
|
|
|
|
|
|
|
*pp = pbuf;
|
|
|
|
*psize = sz;
|
|
|
|
*pentries = this->needs_.size();
|
|
|
|
}
|
|
|
|
|
2006-11-15 03:21:05 +08:00
|
|
|
// Instantiate the templates we need. We could use the configure
|
|
|
|
// script to restrict this to only the ones for implemented targets.
|
|
|
|
|
2007-09-05 04:00:53 +08:00
|
|
|
#ifdef HAVE_TARGET_32_LITTLE
|
2006-11-15 03:21:05 +08:00
|
|
|
template
|
|
|
|
class Sized_dynobj<32, false>;
|
2007-09-05 04:00:53 +08:00
|
|
|
#endif
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2007-09-05 04:00:53 +08:00
|
|
|
#ifdef HAVE_TARGET_32_BIG
|
2006-11-15 03:21:05 +08:00
|
|
|
template
|
|
|
|
class Sized_dynobj<32, true>;
|
2007-09-05 04:00:53 +08:00
|
|
|
#endif
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2007-09-05 04:00:53 +08:00
|
|
|
#ifdef HAVE_TARGET_64_LITTLE
|
2006-11-15 03:21:05 +08:00
|
|
|
template
|
|
|
|
class Sized_dynobj<64, false>;
|
2007-09-05 04:00:53 +08:00
|
|
|
#endif
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2007-09-05 04:00:53 +08:00
|
|
|
#ifdef HAVE_TARGET_64_BIG
|
2006-11-15 03:21:05 +08:00
|
|
|
template
|
|
|
|
class Sized_dynobj<64, true>;
|
2007-09-05 04:00:53 +08:00
|
|
|
#endif
|
2006-11-15 03:21:05 +08:00
|
|
|
|
2007-09-05 04:00:53 +08:00
|
|
|
#ifdef HAVE_TARGET_32_LITTLE
|
2006-12-06 08:02:36 +08:00
|
|
|
template
|
|
|
|
void
|
2006-12-06 08:28:03 +08:00
|
|
|
Versions::symbol_section_contents<32, false>(
|
2007-10-23 07:08:22 +08:00
|
|
|
const Symbol_table*,
|
2006-12-06 08:28:03 +08:00
|
|
|
const Stringpool*,
|
|
|
|
unsigned int,
|
|
|
|
const std::vector<Symbol*>&,
|
|
|
|
unsigned char**,
|
2008-03-01 03:19:17 +08:00
|
|
|
unsigned int*) const;
|
2007-09-05 04:00:53 +08:00
|
|
|
#endif
|
2006-12-06 08:02:36 +08:00
|
|
|
|
2007-09-05 04:00:53 +08:00
|
|
|
#ifdef HAVE_TARGET_32_BIG
|
2006-12-06 08:02:36 +08:00
|
|
|
template
|
|
|
|
void
|
2006-12-06 08:28:03 +08:00
|
|
|
Versions::symbol_section_contents<32, true>(
|
2007-10-23 07:08:22 +08:00
|
|
|
const Symbol_table*,
|
2006-12-06 08:28:03 +08:00
|
|
|
const Stringpool*,
|
|
|
|
unsigned int,
|
|
|
|
const std::vector<Symbol*>&,
|
|
|
|
unsigned char**,
|
2008-03-01 03:19:17 +08:00
|
|
|
unsigned int*) const;
|
2007-09-05 04:00:53 +08:00
|
|
|
#endif
|
2006-12-06 08:02:36 +08:00
|
|
|
|
2007-09-05 04:00:53 +08:00
|
|
|
#ifdef HAVE_TARGET_64_LITTLE
|
2006-12-06 08:02:36 +08:00
|
|
|
template
|
|
|
|
void
|
2006-12-06 08:28:03 +08:00
|
|
|
Versions::symbol_section_contents<64, false>(
|
2007-10-23 07:08:22 +08:00
|
|
|
const Symbol_table*,
|
2006-12-06 08:28:03 +08:00
|
|
|
const Stringpool*,
|
|
|
|
unsigned int,
|
|
|
|
const std::vector<Symbol*>&,
|
|
|
|
unsigned char**,
|
2008-03-01 03:19:17 +08:00
|
|
|
unsigned int*) const;
|
2007-09-05 04:00:53 +08:00
|
|
|
#endif
|
2006-12-06 08:02:36 +08:00
|
|
|
|
2007-09-05 04:00:53 +08:00
|
|
|
#ifdef HAVE_TARGET_64_BIG
|
2006-12-06 08:02:36 +08:00
|
|
|
template
|
|
|
|
void
|
2006-12-06 08:28:03 +08:00
|
|
|
Versions::symbol_section_contents<64, true>(
|
2007-10-23 07:08:22 +08:00
|
|
|
const Symbol_table*,
|
2006-12-06 08:28:03 +08:00
|
|
|
const Stringpool*,
|
|
|
|
unsigned int,
|
|
|
|
const std::vector<Symbol*>&,
|
|
|
|
unsigned char**,
|
2008-03-01 03:19:17 +08:00
|
|
|
unsigned int*) const;
|
2007-09-05 04:00:53 +08:00
|
|
|
#endif
|
2006-12-06 08:02:36 +08:00
|
|
|
|
2007-09-05 04:00:53 +08:00
|
|
|
#ifdef HAVE_TARGET_32_LITTLE
|
2006-12-06 08:02:36 +08:00
|
|
|
template
|
|
|
|
void
|
2006-12-06 08:28:03 +08:00
|
|
|
Versions::def_section_contents<32, false>(
|
|
|
|
const Stringpool*,
|
|
|
|
unsigned char**,
|
|
|
|
unsigned int*,
|
2008-03-01 03:19:17 +08:00
|
|
|
unsigned int*) const;
|
2007-09-05 04:00:53 +08:00
|
|
|
#endif
|
2006-12-06 08:02:36 +08:00
|
|
|
|
2007-09-05 04:00:53 +08:00
|
|
|
#ifdef HAVE_TARGET_32_BIG
|
2006-12-06 08:02:36 +08:00
|
|
|
template
|
|
|
|
void
|
2006-12-06 08:28:03 +08:00
|
|
|
Versions::def_section_contents<32, true>(
|
|
|
|
const Stringpool*,
|
|
|
|
unsigned char**,
|
|
|
|
unsigned int*,
|
2008-03-01 03:19:17 +08:00
|
|
|
unsigned int*) const;
|
2007-09-05 04:00:53 +08:00
|
|
|
#endif
|
2006-12-06 08:02:36 +08:00
|
|
|
|
2007-09-05 04:00:53 +08:00
|
|
|
#ifdef HAVE_TARGET_64_LITTLE
|
2006-12-06 08:02:36 +08:00
|
|
|
template
|
|
|
|
void
|
2006-12-06 08:28:03 +08:00
|
|
|
Versions::def_section_contents<64, false>(
|
|
|
|
const Stringpool*,
|
|
|
|
unsigned char**,
|
|
|
|
unsigned int*,
|
2008-03-01 03:19:17 +08:00
|
|
|
unsigned int*) const;
|
2007-09-05 04:00:53 +08:00
|
|
|
#endif
|
2006-12-06 08:02:36 +08:00
|
|
|
|
2007-09-05 04:00:53 +08:00
|
|
|
#ifdef HAVE_TARGET_64_BIG
|
2006-12-06 08:02:36 +08:00
|
|
|
template
|
|
|
|
void
|
2006-12-06 08:28:03 +08:00
|
|
|
Versions::def_section_contents<64, true>(
|
|
|
|
const Stringpool*,
|
|
|
|
unsigned char**,
|
|
|
|
unsigned int*,
|
2008-03-01 03:19:17 +08:00
|
|
|
unsigned int*) const;
|
2007-09-05 04:00:53 +08:00
|
|
|
#endif
|
2006-12-06 08:02:36 +08:00
|
|
|
|
2007-09-05 04:00:53 +08:00
|
|
|
#ifdef HAVE_TARGET_32_LITTLE
|
2006-12-06 08:02:36 +08:00
|
|
|
template
|
|
|
|
void
|
2006-12-06 08:28:03 +08:00
|
|
|
Versions::need_section_contents<32, false>(
|
|
|
|
const Stringpool*,
|
|
|
|
unsigned char**,
|
|
|
|
unsigned int*,
|
2008-03-01 03:19:17 +08:00
|
|
|
unsigned int*) const;
|
2007-09-05 04:00:53 +08:00
|
|
|
#endif
|
2006-12-06 08:02:36 +08:00
|
|
|
|
2007-09-05 04:00:53 +08:00
|
|
|
#ifdef HAVE_TARGET_32_BIG
|
2006-12-06 08:02:36 +08:00
|
|
|
template
|
|
|
|
void
|
2006-12-06 08:28:03 +08:00
|
|
|
Versions::need_section_contents<32, true>(
|
|
|
|
const Stringpool*,
|
|
|
|
unsigned char**,
|
|
|
|
unsigned int*,
|
2008-03-01 03:19:17 +08:00
|
|
|
unsigned int*) const;
|
2007-09-05 04:00:53 +08:00
|
|
|
#endif
|
2006-12-06 08:02:36 +08:00
|
|
|
|
2007-09-05 04:00:53 +08:00
|
|
|
#ifdef HAVE_TARGET_64_LITTLE
|
2006-12-06 08:02:36 +08:00
|
|
|
template
|
|
|
|
void
|
2006-12-06 08:28:03 +08:00
|
|
|
Versions::need_section_contents<64, false>(
|
|
|
|
const Stringpool*,
|
|
|
|
unsigned char**,
|
|
|
|
unsigned int*,
|
2008-03-01 03:19:17 +08:00
|
|
|
unsigned int*) const;
|
2007-09-05 04:00:53 +08:00
|
|
|
#endif
|
2006-12-06 08:02:36 +08:00
|
|
|
|
2007-09-05 04:00:53 +08:00
|
|
|
#ifdef HAVE_TARGET_64_BIG
|
2006-12-06 08:02:36 +08:00
|
|
|
template
|
|
|
|
void
|
2006-12-06 08:28:03 +08:00
|
|
|
Versions::need_section_contents<64, true>(
|
|
|
|
const Stringpool*,
|
|
|
|
unsigned char**,
|
|
|
|
unsigned int*,
|
2008-03-01 03:19:17 +08:00
|
|
|
unsigned int*) const;
|
2007-09-05 04:00:53 +08:00
|
|
|
#endif
|
2006-12-06 08:02:36 +08:00
|
|
|
|
2006-11-15 03:21:05 +08:00
|
|
|
} // End namespace gold.
|