2006-08-19 00:29:20 +02:00
|
|
|
// resolve.cc -- symbol resolution for gold
|
|
|
|
|
2017-01-02 04:36:43 +01:00
|
|
|
// Copyright (C) 2006-2017 Free Software Foundation, Inc.
|
2007-09-22 23:02:10 +02: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-08-19 00:29:20 +02:00
|
|
|
#include "gold.h"
|
|
|
|
|
|
|
|
#include "elfcpp.h"
|
|
|
|
#include "target.h"
|
|
|
|
#include "object.h"
|
|
|
|
#include "symtab.h"
|
2008-09-20 00:54:57 +02:00
|
|
|
#include "plugin.h"
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
namespace gold
|
|
|
|
{
|
|
|
|
|
2006-09-07 23:21:41 +02:00
|
|
|
// Symbol methods used in this file.
|
|
|
|
|
2008-05-08 20:44:33 +02:00
|
|
|
// This symbol is being overridden by another symbol whose version is
|
|
|
|
// VERSION. Update the VERSION_ field accordingly.
|
|
|
|
|
|
|
|
inline void
|
2009-12-14 20:53:05 +01:00
|
|
|
Symbol::override_version(const char* version)
|
2008-05-08 20:44:33 +02:00
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
if (version == NULL)
|
2008-05-08 20:44:33 +02:00
|
|
|
{
|
|
|
|
// This is the case where this symbol is NAME/VERSION, and the
|
|
|
|
// version was not marked as hidden. That makes it the default
|
|
|
|
// version, so we create NAME/NULL. Later we see another symbol
|
|
|
|
// NAME/NULL, and that symbol is overriding this one. In this
|
|
|
|
// case, since NAME/VERSION is the default, we make NAME/NULL
|
|
|
|
// override NAME/VERSION as well. They are already the same
|
|
|
|
// Symbol structure. Setting the VERSION_ field to NULL ensures
|
|
|
|
// that it will be output with the correct, empty, version.
|
2009-12-14 20:53:05 +01:00
|
|
|
this->version_ = version;
|
2008-05-08 20:44:33 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// This is the case where this symbol is NAME/VERSION_ONE, and
|
|
|
|
// now we see NAME/VERSION_TWO, and NAME/VERSION_TWO is
|
|
|
|
// overriding NAME. If VERSION_ONE and VERSION_TWO are
|
|
|
|
// different, then this can only happen when VERSION_ONE is NULL
|
|
|
|
// and VERSION_TWO is not hidden.
|
2009-12-14 20:53:05 +01:00
|
|
|
gold_assert(this->version_ == version || this->version_ == NULL);
|
|
|
|
this->version_ = version;
|
2008-05-08 20:44:33 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-27 20:57:46 +01:00
|
|
|
// This symbol is being overidden by another symbol whose visibility
|
|
|
|
// is VISIBILITY. Updated the VISIBILITY_ field accordingly.
|
|
|
|
|
|
|
|
inline void
|
2009-12-14 20:53:05 +01:00
|
|
|
Symbol::override_visibility(elfcpp::STV visibility)
|
2009-02-27 20:57:46 +01:00
|
|
|
{
|
|
|
|
// The rule for combining visibility is that we always choose the
|
|
|
|
// most constrained visibility. In order of increasing constraint,
|
|
|
|
// visibility goes PROTECTED, HIDDEN, INTERNAL. This is the reverse
|
|
|
|
// of the numeric values, so the effect is that we always want the
|
|
|
|
// smallest non-zero value.
|
2009-12-14 20:53:05 +01:00
|
|
|
if (visibility != elfcpp::STV_DEFAULT)
|
2009-02-27 20:57:46 +01:00
|
|
|
{
|
|
|
|
if (this->visibility_ == elfcpp::STV_DEFAULT)
|
2009-12-14 20:53:05 +01:00
|
|
|
this->visibility_ = visibility;
|
|
|
|
else if (this->visibility_ > visibility)
|
|
|
|
this->visibility_ = visibility;
|
2009-02-27 20:57:46 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-09-07 23:21:41 +02:00
|
|
|
// Override the fields in Symbol.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
|
|
|
Symbol::override_base(const elfcpp::Sym<size, big_endian>& sym,
|
2008-04-19 20:30:58 +02:00
|
|
|
unsigned int st_shndx, bool is_ordinary,
|
2009-12-14 20:53:05 +01:00
|
|
|
Object* object, const char* version)
|
2006-09-07 23:21:41 +02:00
|
|
|
{
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_assert(this->source_ == FROM_OBJECT);
|
2017-08-29 08:22:45 +02:00
|
|
|
this->u1_.object = object;
|
2009-12-14 20:53:05 +01:00
|
|
|
this->override_version(version);
|
2017-08-29 08:22:45 +02:00
|
|
|
this->u2_.shndx = st_shndx;
|
2008-04-19 20:30:58 +02:00
|
|
|
this->is_ordinary_shndx_ = is_ordinary;
|
2013-06-14 22:07:18 +02:00
|
|
|
// Don't override st_type from plugin placeholder symbols.
|
|
|
|
if (object->pluginobj() == NULL)
|
2015-09-07 18:44:11 +02:00
|
|
|
this->type_ = sym.get_st_type();
|
2006-09-07 23:21:41 +02:00
|
|
|
this->binding_ = sym.get_st_bind();
|
2009-02-27 20:57:46 +01:00
|
|
|
this->override_visibility(sym.get_st_visibility());
|
2006-11-03 19:26:11 +01:00
|
|
|
this->nonvis_ = sym.get_st_nonvis();
|
2009-12-14 20:53:05 +01:00
|
|
|
if (object->is_dynamic())
|
2007-08-28 06:12:19 +02:00
|
|
|
this->in_dyn_ = true;
|
|
|
|
else
|
|
|
|
this->in_reg_ = true;
|
2006-09-07 23:21:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Override the fields in Sized_symbol.
|
|
|
|
|
|
|
|
template<int size>
|
|
|
|
template<bool big_endian>
|
|
|
|
void
|
|
|
|
Sized_symbol<size>::override(const elfcpp::Sym<size, big_endian>& sym,
|
2008-04-19 20:30:58 +02:00
|
|
|
unsigned st_shndx, bool is_ordinary,
|
2009-12-14 20:53:05 +01:00
|
|
|
Object* object, const char* version)
|
2006-09-07 23:21:41 +02:00
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
this->override_base(sym, st_shndx, is_ordinary, object, version);
|
2006-09-07 23:21:41 +02:00
|
|
|
this->value_ = sym.get_st_value();
|
2006-11-03 19:26:11 +01:00
|
|
|
this->symsize_ = sym.get_st_size();
|
2006-09-07 23:21:41 +02:00
|
|
|
}
|
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
// Override TOSYM with symbol FROMSYM, defined in OBJECT, with version
|
|
|
|
// VERSION. This handles all aliases of TOSYM.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
|
|
|
Symbol_table::override(Sized_symbol<size>* tosym,
|
|
|
|
const elfcpp::Sym<size, big_endian>& fromsym,
|
2008-04-19 20:30:58 +02:00
|
|
|
unsigned int st_shndx, bool is_ordinary,
|
2009-12-14 20:53:05 +01:00
|
|
|
Object* object, const char* version)
|
2007-10-14 17:35:27 +02:00
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
tosym->override(fromsym, st_shndx, is_ordinary, object, version);
|
2007-10-14 17:35:27 +02:00
|
|
|
if (tosym->has_alias())
|
|
|
|
{
|
|
|
|
Symbol* sym = this->weak_aliases_[tosym];
|
|
|
|
gold_assert(sym != NULL);
|
2008-02-29 20:19:17 +01:00
|
|
|
Sized_symbol<size>* ssym = this->get_sized_symbol<size>(sym);
|
2007-10-14 17:35:27 +02:00
|
|
|
do
|
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
ssym->override(fromsym, st_shndx, is_ordinary, object, version);
|
2007-10-14 17:35:27 +02:00
|
|
|
sym = this->weak_aliases_[ssym];
|
|
|
|
gold_assert(sym != NULL);
|
2008-02-29 20:19:17 +01:00
|
|
|
ssym = this->get_sized_symbol<size>(sym);
|
2007-10-14 17:35:27 +02:00
|
|
|
}
|
|
|
|
while (ssym != tosym);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-09-19 08:02:29 +02:00
|
|
|
// The resolve functions build a little code for each symbol.
|
|
|
|
// Bit 0: 0 for global, 1 for weak.
|
|
|
|
// Bit 1: 0 for regular object, 1 for shared object
|
|
|
|
// Bits 2-3: 0 for normal, 1 for undefined, 2 for common
|
|
|
|
// This gives us values from 0 to 11.
|
|
|
|
|
|
|
|
static const int global_or_weak_shift = 0;
|
|
|
|
static const unsigned int global_flag = 0 << global_or_weak_shift;
|
|
|
|
static const unsigned int weak_flag = 1 << global_or_weak_shift;
|
|
|
|
|
|
|
|
static const int regular_or_dynamic_shift = 1;
|
|
|
|
static const unsigned int regular_flag = 0 << regular_or_dynamic_shift;
|
|
|
|
static const unsigned int dynamic_flag = 1 << regular_or_dynamic_shift;
|
|
|
|
|
|
|
|
static const int def_undef_or_common_shift = 2;
|
|
|
|
static const unsigned int def_flag = 0 << def_undef_or_common_shift;
|
|
|
|
static const unsigned int undef_flag = 1 << def_undef_or_common_shift;
|
|
|
|
static const unsigned int common_flag = 2 << def_undef_or_common_shift;
|
|
|
|
|
2007-11-13 21:02:32 +01:00
|
|
|
// This convenience function combines all the flags based on facts
|
|
|
|
// about the symbol.
|
|
|
|
|
|
|
|
static unsigned int
|
|
|
|
symbol_to_bits(elfcpp::STB binding, bool is_dynamic,
|
2015-06-07 23:03:09 +02:00
|
|
|
unsigned int shndx, bool is_ordinary)
|
2007-11-13 21:02:32 +01:00
|
|
|
{
|
|
|
|
unsigned int bits;
|
|
|
|
|
|
|
|
switch (binding)
|
|
|
|
{
|
|
|
|
case elfcpp::STB_GLOBAL:
|
2009-12-05 08:28:45 +01:00
|
|
|
case elfcpp::STB_GNU_UNIQUE:
|
2007-11-13 21:02:32 +01:00
|
|
|
bits = global_flag;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case elfcpp::STB_WEAK:
|
|
|
|
bits = weak_flag;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case elfcpp::STB_LOCAL:
|
|
|
|
// We should only see externally visible symbols in the symbol
|
|
|
|
// table.
|
|
|
|
gold_error(_("invalid STB_LOCAL symbol in external symbols"));
|
|
|
|
bits = global_flag;
|
2016-10-05 07:10:11 +02:00
|
|
|
break;
|
2007-11-13 21:02:32 +01:00
|
|
|
|
|
|
|
default:
|
|
|
|
// Any target which wants to handle STB_LOOS, etc., needs to
|
|
|
|
// define a resolve method.
|
2010-10-11 22:04:04 +02:00
|
|
|
gold_error(_("unsupported symbol binding %d"), static_cast<int>(binding));
|
2007-11-13 21:02:32 +01:00
|
|
|
bits = global_flag;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_dynamic)
|
|
|
|
bits |= dynamic_flag;
|
|
|
|
else
|
|
|
|
bits |= regular_flag;
|
|
|
|
|
|
|
|
switch (shndx)
|
|
|
|
{
|
|
|
|
case elfcpp::SHN_UNDEF:
|
|
|
|
bits |= undef_flag;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case elfcpp::SHN_COMMON:
|
2008-04-19 20:30:58 +02:00
|
|
|
if (!is_ordinary)
|
|
|
|
bits |= common_flag;
|
2007-11-13 21:02:32 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2015-06-07 23:03:09 +02:00
|
|
|
if (!is_ordinary && Symbol::is_common_shndx(shndx))
|
2009-06-22 08:51:53 +02:00
|
|
|
bits |= common_flag;
|
2007-11-13 21:02:32 +01:00
|
|
|
else
|
|
|
|
bits |= def_flag;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return bits;
|
|
|
|
}
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
// Resolve a symbol. This is called the second and subsequent times
|
2008-04-19 20:30:58 +02:00
|
|
|
// we see a symbol. TO is the pre-existing symbol. ST_SHNDX is the
|
|
|
|
// section index for SYM, possibly adjusted for many sections.
|
|
|
|
// IS_ORDINARY is whether ST_SHNDX is a normal section index rather
|
|
|
|
// than a special code. ORIG_ST_SHNDX is the original section index,
|
|
|
|
// before any munging because of discarded sections, except that all
|
2008-07-23 16:36:09 +02:00
|
|
|
// non-ordinary section indexes are mapped to SHN_UNDEF. VERSION is
|
2008-04-19 20:30:58 +02:00
|
|
|
// the version of SYM.
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
2006-09-07 23:21:41 +02:00
|
|
|
Symbol_table::resolve(Sized_symbol<size>* to,
|
2006-08-19 00:29:20 +02:00
|
|
|
const elfcpp::Sym<size, big_endian>& sym,
|
2008-04-19 20:30:58 +02:00
|
|
|
unsigned int st_shndx, bool is_ordinary,
|
|
|
|
unsigned int orig_st_shndx,
|
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 00:09:08 +02:00
|
|
|
Object* object, const char* version,
|
|
|
|
bool is_default_version)
|
2006-08-19 00:29:20 +02:00
|
|
|
{
|
2017-11-29 03:48:12 +01:00
|
|
|
bool to_is_ordinary;
|
|
|
|
const unsigned int to_shndx = to->shndx(&to_is_ordinary);
|
|
|
|
|
2011-06-17 15:31:33 +02:00
|
|
|
// It's possible for a symbol to be defined in an object file
|
|
|
|
// using .symver to give it a version, and for there to also be
|
|
|
|
// a linker script giving that symbol the same version. We
|
|
|
|
// don't want to give a multiple-definition error for this
|
|
|
|
// harmless redefinition.
|
|
|
|
if (to->source() == Symbol::FROM_OBJECT
|
|
|
|
&& to->object() == object
|
|
|
|
&& to->is_defined()
|
2017-11-29 03:48:12 +01:00
|
|
|
&& is_ordinary
|
2011-06-17 15:31:33 +02:00
|
|
|
&& to_is_ordinary
|
2017-11-29 03:48:12 +01:00
|
|
|
&& to_shndx == st_shndx
|
|
|
|
&& to->value() == sym.get_st_value())
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Likewise for an absolute symbol defined twice with the same value.
|
|
|
|
if (!is_ordinary
|
|
|
|
&& st_shndx == elfcpp::SHN_ABS
|
|
|
|
&& !to_is_ordinary
|
|
|
|
&& to_shndx == elfcpp::SHN_ABS
|
2011-06-17 15:31:33 +02:00
|
|
|
&& to->value() == sym.get_st_value())
|
|
|
|
return;
|
|
|
|
|
2009-10-01 00:21:13 +02:00
|
|
|
if (parameters->target().has_resolve())
|
2006-08-19 00:29:20 +02:00
|
|
|
{
|
2006-09-26 23:50:25 +02:00
|
|
|
Sized_target<size, big_endian>* sized_target;
|
2009-10-01 00:21:13 +02:00
|
|
|
sized_target = parameters->sized_target<size, big_endian>();
|
2017-08-28 08:57:33 +02:00
|
|
|
if (sized_target->resolve(to, sym, object, version))
|
|
|
|
return;
|
2006-08-19 00:29:20 +02:00
|
|
|
}
|
|
|
|
|
2007-09-19 08:02:29 +02:00
|
|
|
if (!object->is_dynamic())
|
|
|
|
{
|
2015-06-07 23:03:09 +02:00
|
|
|
if (sym.get_st_type() == elfcpp::STT_COMMON
|
|
|
|
&& (is_ordinary || !Symbol::is_common_shndx(st_shndx)))
|
|
|
|
{
|
|
|
|
gold_warning(_("STT_COMMON symbol '%s' in %s "
|
|
|
|
"is not in a common section"),
|
|
|
|
to->demangled_name().c_str(),
|
|
|
|
to->object()->name().c_str());
|
|
|
|
return;
|
|
|
|
}
|
2007-09-19 08:02:29 +02:00
|
|
|
// Record that we've seen this symbol in a regular object.
|
|
|
|
to->set_in_reg();
|
|
|
|
}
|
2009-08-19 19:53:50 +02:00
|
|
|
else if (st_shndx == elfcpp::SHN_UNDEF
|
|
|
|
&& (to->visibility() == elfcpp::STV_HIDDEN
|
|
|
|
|| to->visibility() == elfcpp::STV_INTERNAL))
|
2009-08-12 20:30:39 +02:00
|
|
|
{
|
2015-07-20 17:47:57 +02:00
|
|
|
// The symbol is hidden, so a reference from a shared object
|
|
|
|
// cannot bind to it. We tried issuing a warning in this case,
|
|
|
|
// but that produces false positives when the symbol is
|
|
|
|
// actually resolved in a different shared object (PR 15574).
|
2009-08-12 20:30:39 +02:00
|
|
|
return;
|
|
|
|
}
|
2007-09-19 08:02:29 +02:00
|
|
|
else
|
|
|
|
{
|
|
|
|
// Record that we've seen this symbol in a dynamic object.
|
|
|
|
to->set_in_dyn();
|
|
|
|
}
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2008-09-20 00:54:57 +02:00
|
|
|
// Record if we've seen this symbol in a real ELF object (i.e., the
|
|
|
|
// symbol is referenced from outside the world known to the plugin).
|
2011-10-18 02:25:53 +02:00
|
|
|
if (object->pluginobj() == NULL && !object->is_dynamic())
|
2008-09-20 00:54:57 +02:00
|
|
|
to->set_in_real_elf();
|
|
|
|
|
|
|
|
// If we're processing replacement files, allow new symbols to override
|
|
|
|
// the placeholders from the plugin objects.
|
2014-09-17 23:53:49 +02:00
|
|
|
// Treat common symbols specially since it is possible that an ELF
|
|
|
|
// file increased the size of the alignment.
|
2008-09-20 00:54:57 +02:00
|
|
|
if (to->source() == Symbol::FROM_OBJECT)
|
|
|
|
{
|
|
|
|
Pluginobj* obj = to->object()->pluginobj();
|
|
|
|
if (obj != NULL
|
Fix problem where TLS common symbols are not allocated properly during LTO.
The plugin API doesn't provide a way for the claimed file handler to
identify a TLS symbol, so when adding a common TLS symbol, gold
mistakenly places the symbol in the non-TLS commons list, and does
not override it when we see the replacement symbol that is marked
as TLS. Consequently, we allocate the TLS common symbol as a regular
common, and, if it's the only TLS in the program, we'll give an
internal error because we haven't allocated a TLS segment.
This patch fixes the problem by removing an exclusion where common
symbols would not override the placeholder symbols, but checking to
see if the size needs adjusting (the original reason for the exclusion).
Furthermore, we need to avoid putting placeholder symbols in the common
list, and wait until we see a real common symbol with a type we can
trust.
gold/
PR gold/17432
* resolve.cc (Symbol_table::resolve): Override common placeholder
symbols, but adjust sizes.
* symtab.cc (Symbol_table::add_from_object): Don't add placeholder
symbols to common lists.
2014-09-26 06:47:10 +02:00
|
|
|
&& parameters->options().plugins()->in_replacement_phase())
|
2008-09-20 00:54:57 +02:00
|
|
|
{
|
Fix problem where TLS common symbols are not allocated properly during LTO.
The plugin API doesn't provide a way for the claimed file handler to
identify a TLS symbol, so when adding a common TLS symbol, gold
mistakenly places the symbol in the non-TLS commons list, and does
not override it when we see the replacement symbol that is marked
as TLS. Consequently, we allocate the TLS common symbol as a regular
common, and, if it's the only TLS in the program, we'll give an
internal error because we haven't allocated a TLS segment.
This patch fixes the problem by removing an exclusion where common
symbols would not override the placeholder symbols, but checking to
see if the size needs adjusting (the original reason for the exclusion).
Furthermore, we need to avoid putting placeholder symbols in the common
list, and wait until we see a real common symbol with a type we can
trust.
gold/
PR gold/17432
* resolve.cc (Symbol_table::resolve): Override common placeholder
symbols, but adjust sizes.
* symtab.cc (Symbol_table::add_from_object): Don't add placeholder
symbols to common lists.
2014-09-26 06:47:10 +02:00
|
|
|
bool adjust_common = false;
|
|
|
|
typename Sized_symbol<size>::Size_type tosize = 0;
|
|
|
|
typename Sized_symbol<size>::Value_type tovalue = 0;
|
2015-06-07 23:03:09 +02:00
|
|
|
if (to->is_common()
|
|
|
|
&& !is_ordinary && Symbol::is_common_shndx(st_shndx))
|
Fix problem where TLS common symbols are not allocated properly during LTO.
The plugin API doesn't provide a way for the claimed file handler to
identify a TLS symbol, so when adding a common TLS symbol, gold
mistakenly places the symbol in the non-TLS commons list, and does
not override it when we see the replacement symbol that is marked
as TLS. Consequently, we allocate the TLS common symbol as a regular
common, and, if it's the only TLS in the program, we'll give an
internal error because we haven't allocated a TLS segment.
This patch fixes the problem by removing an exclusion where common
symbols would not override the placeholder symbols, but checking to
see if the size needs adjusting (the original reason for the exclusion).
Furthermore, we need to avoid putting placeholder symbols in the common
list, and wait until we see a real common symbol with a type we can
trust.
gold/
PR gold/17432
* resolve.cc (Symbol_table::resolve): Override common placeholder
symbols, but adjust sizes.
* symtab.cc (Symbol_table::add_from_object): Don't add placeholder
symbols to common lists.
2014-09-26 06:47:10 +02:00
|
|
|
{
|
|
|
|
adjust_common = true;
|
2014-10-01 01:06:50 +02:00
|
|
|
tosize = to->symsize();
|
|
|
|
tovalue = to->value();
|
Fix problem where TLS common symbols are not allocated properly during LTO.
The plugin API doesn't provide a way for the claimed file handler to
identify a TLS symbol, so when adding a common TLS symbol, gold
mistakenly places the symbol in the non-TLS commons list, and does
not override it when we see the replacement symbol that is marked
as TLS. Consequently, we allocate the TLS common symbol as a regular
common, and, if it's the only TLS in the program, we'll give an
internal error because we haven't allocated a TLS segment.
This patch fixes the problem by removing an exclusion where common
symbols would not override the placeholder symbols, but checking to
see if the size needs adjusting (the original reason for the exclusion).
Furthermore, we need to avoid putting placeholder symbols in the common
list, and wait until we see a real common symbol with a type we can
trust.
gold/
PR gold/17432
* resolve.cc (Symbol_table::resolve): Override common placeholder
symbols, but adjust sizes.
* symtab.cc (Symbol_table::add_from_object): Don't add placeholder
symbols to common lists.
2014-09-26 06:47:10 +02:00
|
|
|
}
|
|
|
|
this->override(to, sym, st_shndx, is_ordinary, object, version);
|
|
|
|
if (adjust_common)
|
|
|
|
{
|
|
|
|
if (tosize > to->symsize())
|
|
|
|
to->set_symsize(tosize);
|
|
|
|
if (tovalue > to->value())
|
|
|
|
to->set_value(tovalue);
|
|
|
|
}
|
|
|
|
return;
|
2008-09-20 00:54:57 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-11 08:09:48 +01:00
|
|
|
// A new weak undefined reference, merging with an old weak
|
|
|
|
// reference, could be a One Definition Rule (ODR) violation --
|
|
|
|
// especially if the types or sizes of the references differ. We'll
|
|
|
|
// store such pairs and look them up later to make sure they
|
|
|
|
// actually refer to the same lines of code. We also check
|
|
|
|
// combinations of weak and strong, which might occur if one case is
|
|
|
|
// inline and the other is not. (Note: not all ODR violations can
|
|
|
|
// be found this way, and not everything this finds is an ODR
|
|
|
|
// violation. But it's helpful to warn about.)
|
|
|
|
if (parameters->options().detect_odr_violations()
|
|
|
|
&& (sym.get_st_bind() == elfcpp::STB_WEAK
|
|
|
|
|| to->binding() == elfcpp::STB_WEAK)
|
|
|
|
&& orig_st_shndx != elfcpp::SHN_UNDEF
|
|
|
|
&& to_is_ordinary
|
2017-11-29 03:48:12 +01:00
|
|
|
&& to_shndx != elfcpp::SHN_UNDEF
|
2010-01-11 08:09:48 +01:00
|
|
|
&& sym.get_st_size() != 0 // Ignore weird 0-sized symbols.
|
|
|
|
&& to->symsize() != 0
|
|
|
|
&& (sym.get_st_type() != to->type()
|
|
|
|
|| sym.get_st_size() != to->symsize())
|
|
|
|
// C does not have a concept of ODR, so we only need to do this
|
|
|
|
// on C++ symbols. These have (mangled) names starting with _Z.
|
|
|
|
&& to->name()[0] == '_' && to->name()[1] == 'Z')
|
|
|
|
{
|
|
|
|
Symbol_location fromloc
|
2011-12-17 23:39:52 +01:00
|
|
|
= { object, orig_st_shndx, static_cast<off_t>(sym.get_st_value()) };
|
2017-11-29 03:48:12 +01:00
|
|
|
Symbol_location toloc = { to->object(), to_shndx,
|
2011-12-17 23:39:52 +01:00
|
|
|
static_cast<off_t>(to->value()) };
|
2010-01-11 08:09:48 +01:00
|
|
|
this->candidate_odr_violations_[to->name()].insert(fromloc);
|
|
|
|
this->candidate_odr_violations_[to->name()].insert(toloc);
|
|
|
|
}
|
|
|
|
|
2013-06-14 22:07:18 +02:00
|
|
|
// Plugins don't provide a symbol type, so adopt the existing type
|
|
|
|
// if the FROM symbol is from a plugin.
|
|
|
|
elfcpp::STT fromtype = (object->pluginobj() != NULL
|
|
|
|
? to->type()
|
|
|
|
: sym.get_st_type());
|
2007-11-13 21:02:32 +01:00
|
|
|
unsigned int frombits = symbol_to_bits(sym.get_st_bind(),
|
|
|
|
object->is_dynamic(),
|
2015-06-07 23:03:09 +02:00
|
|
|
st_shndx, is_ordinary);
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2007-09-19 08:02:29 +02:00
|
|
|
bool adjust_common_sizes;
|
2010-07-09 03:34:31 +02:00
|
|
|
bool adjust_dyndef;
|
2009-11-04 02:24:41 +01:00
|
|
|
typename Sized_symbol<size>::Size_type tosize = to->symsize();
|
2013-06-14 22:07:18 +02:00
|
|
|
if (Symbol_table::should_override(to, frombits, fromtype, OBJECT,
|
2011-07-09 01:49:11 +02:00
|
|
|
object, &adjust_common_sizes,
|
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 00:09:08 +02:00
|
|
|
&adjust_dyndef, is_default_version))
|
2007-09-19 08:02:29 +02:00
|
|
|
{
|
2010-07-09 03:34:31 +02:00
|
|
|
elfcpp::STB tobinding = to->binding();
|
2012-03-13 17:08:53 +01:00
|
|
|
typename Sized_symbol<size>::Value_type tovalue = to->value();
|
2008-04-19 20:30:58 +02:00
|
|
|
this->override(to, sym, st_shndx, is_ordinary, object, version);
|
2012-03-13 17:08:53 +01:00
|
|
|
if (adjust_common_sizes)
|
|
|
|
{
|
|
|
|
if (tosize > to->symsize())
|
|
|
|
to->set_symsize(tosize);
|
|
|
|
if (tovalue > to->value())
|
|
|
|
to->set_value(tovalue);
|
|
|
|
}
|
2010-07-09 03:34:31 +02:00
|
|
|
if (adjust_dyndef)
|
|
|
|
{
|
|
|
|
// We are overriding an UNDEF or WEAK UNDEF with a DYN DEF.
|
|
|
|
// Remember which kind of UNDEF it was for future reference.
|
|
|
|
to->set_undef_binding(tobinding);
|
|
|
|
}
|
2007-09-19 08:02:29 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-03-13 17:08:53 +01:00
|
|
|
if (adjust_common_sizes)
|
|
|
|
{
|
|
|
|
if (sym.get_st_size() > tosize)
|
|
|
|
to->set_symsize(sym.get_st_size());
|
|
|
|
if (sym.get_st_value() > to->value())
|
|
|
|
to->set_value(sym.get_st_value());
|
|
|
|
}
|
2010-07-09 03:34:31 +02:00
|
|
|
if (adjust_dyndef)
|
|
|
|
{
|
|
|
|
// We are keeping a DYN DEF after seeing an UNDEF or WEAK UNDEF.
|
|
|
|
// Remember which kind of UNDEF it was.
|
|
|
|
to->set_undef_binding(sym.get_st_bind());
|
|
|
|
}
|
2009-02-27 20:57:46 +01:00
|
|
|
// The ELF ABI says that even for a reference to a symbol we
|
|
|
|
// merge the visibility.
|
|
|
|
to->override_visibility(sym.get_st_visibility());
|
2007-09-19 08:02:29 +02:00
|
|
|
}
|
2007-11-13 21:02:32 +01:00
|
|
|
|
2009-11-04 02:24:41 +01:00
|
|
|
if (adjust_common_sizes && parameters->options().warn_common())
|
|
|
|
{
|
|
|
|
if (tosize > sym.get_st_size())
|
|
|
|
Symbol_table::report_resolve_problem(false,
|
|
|
|
_("common of '%s' overriding "
|
|
|
|
"smaller common"),
|
2009-12-29 01:31:48 +01:00
|
|
|
to, OBJECT, object);
|
2009-11-04 02:24:41 +01:00
|
|
|
else if (tosize < sym.get_st_size())
|
|
|
|
Symbol_table::report_resolve_problem(false,
|
|
|
|
_("common of '%s' overidden by "
|
|
|
|
"larger common"),
|
2009-12-29 01:31:48 +01:00
|
|
|
to, OBJECT, object);
|
2009-11-04 02:24:41 +01:00
|
|
|
else
|
|
|
|
Symbol_table::report_resolve_problem(false,
|
|
|
|
_("multiple common of '%s'"),
|
2009-12-29 01:31:48 +01:00
|
|
|
to, OBJECT, object);
|
2009-11-04 02:24:41 +01:00
|
|
|
}
|
2007-09-19 08:02:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Handle the core of symbol resolution. This is called with the
|
|
|
|
// existing symbol, TO, and a bitflag describing the new symbol. This
|
|
|
|
// returns true if we should override the existing symbol with the new
|
|
|
|
// one, and returns false otherwise. It sets *ADJUST_COMMON_SIZES to
|
|
|
|
// true if we should set the symbol size to the maximum of the TO and
|
|
|
|
// FROM sizes. It handles error conditions.
|
|
|
|
|
|
|
|
bool
|
|
|
|
Symbol_table::should_override(const Symbol* to, unsigned int frombits,
|
2011-07-09 01:49:11 +02:00
|
|
|
elfcpp::STT fromtype, Defined defined,
|
|
|
|
Object* object, bool* adjust_common_sizes,
|
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 00:09:08 +02:00
|
|
|
bool* adjust_dyndef, bool is_default_version)
|
2007-09-19 08:02:29 +02:00
|
|
|
{
|
|
|
|
*adjust_common_sizes = false;
|
2010-07-09 03:34:31 +02:00
|
|
|
*adjust_dyndef = false;
|
2007-09-19 08:02:29 +02:00
|
|
|
|
2008-01-09 20:57:45 +01:00
|
|
|
unsigned int tobits;
|
2008-05-07 08:08:01 +02:00
|
|
|
if (to->source() == Symbol::IS_UNDEFINED)
|
2015-06-07 23:03:09 +02:00
|
|
|
tobits = symbol_to_bits(to->binding(), false, elfcpp::SHN_UNDEF, true);
|
2008-05-07 08:08:01 +02:00
|
|
|
else if (to->source() != Symbol::FROM_OBJECT)
|
2015-06-07 23:03:09 +02:00
|
|
|
tobits = symbol_to_bits(to->binding(), false, elfcpp::SHN_ABS, false);
|
2008-01-09 20:57:45 +01:00
|
|
|
else
|
2008-04-19 20:30:58 +02:00
|
|
|
{
|
|
|
|
bool is_ordinary;
|
|
|
|
unsigned int shndx = to->shndx(&is_ordinary);
|
|
|
|
tobits = symbol_to_bits(to->binding(),
|
|
|
|
to->object()->is_dynamic(),
|
|
|
|
shndx,
|
2015-06-07 23:03:09 +02:00
|
|
|
is_ordinary);
|
2008-04-19 20:30:58 +02:00
|
|
|
}
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2013-06-14 22:07:18 +02:00
|
|
|
if ((to->type() == elfcpp::STT_TLS) ^ (fromtype == elfcpp::STT_TLS)
|
|
|
|
&& !to->is_placeholder())
|
2011-07-09 01:49:11 +02:00
|
|
|
Symbol_table::report_resolve_problem(true,
|
|
|
|
_("symbol '%s' used as both __thread "
|
|
|
|
"and non-__thread"),
|
|
|
|
to, defined, object);
|
2006-09-07 23:21:41 +02:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
// We use a giant switch table for symbol resolution. This code is
|
|
|
|
// unwieldy, but: 1) it is efficient; 2) we definitely handle all
|
|
|
|
// cases; 3) it is easy to change the handling of a particular case.
|
|
|
|
// The alternative would be a series of conditionals, but it is easy
|
|
|
|
// to get the ordering wrong. This could also be done as a table,
|
|
|
|
// but that is no easier to understand than this large switch
|
|
|
|
// statement.
|
|
|
|
|
2007-09-19 08:02:29 +02:00
|
|
|
// These are the values generated by the bit codes.
|
|
|
|
enum
|
|
|
|
{
|
|
|
|
DEF = global_flag | regular_flag | def_flag,
|
|
|
|
WEAK_DEF = weak_flag | regular_flag | def_flag,
|
|
|
|
DYN_DEF = global_flag | dynamic_flag | def_flag,
|
|
|
|
DYN_WEAK_DEF = weak_flag | dynamic_flag | def_flag,
|
|
|
|
UNDEF = global_flag | regular_flag | undef_flag,
|
|
|
|
WEAK_UNDEF = weak_flag | regular_flag | undef_flag,
|
|
|
|
DYN_UNDEF = global_flag | dynamic_flag | undef_flag,
|
|
|
|
DYN_WEAK_UNDEF = weak_flag | dynamic_flag | undef_flag,
|
|
|
|
COMMON = global_flag | regular_flag | common_flag,
|
|
|
|
WEAK_COMMON = weak_flag | regular_flag | common_flag,
|
|
|
|
DYN_COMMON = global_flag | dynamic_flag | common_flag,
|
|
|
|
DYN_WEAK_COMMON = weak_flag | dynamic_flag | common_flag
|
|
|
|
};
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
switch (tobits * 16 + frombits)
|
|
|
|
{
|
|
|
|
case DEF * 16 + DEF:
|
2006-10-06 22:40:16 +02:00
|
|
|
// Two definitions of the same symbol.
|
2008-02-28 23:39:29 +01:00
|
|
|
|
|
|
|
// If either symbol is defined by an object included using
|
|
|
|
// --just-symbols, then don't warn. This is for compatibility
|
|
|
|
// with the GNU linker. FIXME: This is a hack.
|
|
|
|
if ((to->source() == Symbol::FROM_OBJECT && to->object()->just_symbols())
|
2009-12-29 01:31:48 +01:00
|
|
|
|| (object != NULL && object->just_symbols()))
|
2008-02-28 23:39:29 +01:00
|
|
|
return false;
|
|
|
|
|
2010-01-05 23:55:08 +01:00
|
|
|
if (!parameters->options().muldefs())
|
2010-01-05 06:56:28 +01:00
|
|
|
Symbol_table::report_resolve_problem(true,
|
|
|
|
_("multiple definition of '%s'"),
|
|
|
|
to, defined, object);
|
2007-09-19 08:02:29 +02:00
|
|
|
return false;
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
case WEAK_DEF * 16 + DEF:
|
2006-09-07 23:21:41 +02:00
|
|
|
// We've seen a weak definition, and now we see a strong
|
|
|
|
// definition. In the original SVR4 linker, this was treated as
|
|
|
|
// a multiple definition error. In the Solaris linker and the
|
|
|
|
// GNU linker, a weak definition followed by a regular
|
|
|
|
// definition causes the weak definition to be overridden. We
|
|
|
|
// are currently compatible with the GNU linker. In the future
|
|
|
|
// we should add a target specific option to change this.
|
|
|
|
// FIXME.
|
2007-09-19 08:02:29 +02:00
|
|
|
return true;
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
case DYN_DEF * 16 + DEF:
|
|
|
|
case DYN_WEAK_DEF * 16 + DEF:
|
2006-09-07 23:21:41 +02:00
|
|
|
// We've seen a definition in a dynamic object, and now we see a
|
|
|
|
// definition in a regular object. The definition in the
|
|
|
|
// regular object overrides the definition in the dynamic
|
|
|
|
// object.
|
2007-09-19 08:02:29 +02:00
|
|
|
return true;
|
2006-09-07 23:21:41 +02:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case UNDEF * 16 + DEF:
|
|
|
|
case WEAK_UNDEF * 16 + DEF:
|
|
|
|
case DYN_UNDEF * 16 + DEF:
|
|
|
|
case DYN_WEAK_UNDEF * 16 + DEF:
|
2006-09-07 23:21:41 +02:00
|
|
|
// We've seen an undefined reference, and now we see a
|
|
|
|
// definition. We use the definition.
|
2007-09-19 08:02:29 +02:00
|
|
|
return true;
|
2006-09-07 23:21:41 +02:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case COMMON * 16 + DEF:
|
|
|
|
case WEAK_COMMON * 16 + DEF:
|
|
|
|
case DYN_COMMON * 16 + DEF:
|
|
|
|
case DYN_WEAK_COMMON * 16 + DEF:
|
2006-09-07 23:21:41 +02:00
|
|
|
// We've seen a common symbol and now we see a definition. The
|
2009-11-04 02:24:41 +01:00
|
|
|
// definition overrides.
|
|
|
|
if (parameters->options().warn_common())
|
|
|
|
Symbol_table::report_resolve_problem(false,
|
|
|
|
_("definition of '%s' overriding "
|
|
|
|
"common"),
|
2009-12-29 01:31:48 +01:00
|
|
|
to, defined, object);
|
2007-09-19 08:02:29 +02:00
|
|
|
return true;
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
case DEF * 16 + WEAK_DEF:
|
|
|
|
case WEAK_DEF * 16 + WEAK_DEF:
|
2006-09-07 23:21:41 +02:00
|
|
|
// We've seen a definition and now we see a weak definition. We
|
|
|
|
// ignore the new weak definition.
|
2007-09-19 08:02:29 +02:00
|
|
|
return false;
|
2006-09-07 23:21:41 +02:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case DYN_DEF * 16 + WEAK_DEF:
|
|
|
|
case DYN_WEAK_DEF * 16 + WEAK_DEF:
|
2006-09-07 23:21:41 +02:00
|
|
|
// We've seen a dynamic definition and now we see a regular weak
|
|
|
|
// definition. The regular weak definition overrides.
|
2007-09-19 08:02:29 +02:00
|
|
|
return true;
|
2006-09-07 23:21:41 +02:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case UNDEF * 16 + WEAK_DEF:
|
|
|
|
case WEAK_UNDEF * 16 + WEAK_DEF:
|
|
|
|
case DYN_UNDEF * 16 + WEAK_DEF:
|
|
|
|
case DYN_WEAK_UNDEF * 16 + WEAK_DEF:
|
2006-09-07 23:21:41 +02:00
|
|
|
// A weak definition of a currently undefined symbol.
|
2007-09-19 08:02:29 +02:00
|
|
|
return true;
|
2006-09-07 23:21:41 +02:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case COMMON * 16 + WEAK_DEF:
|
|
|
|
case WEAK_COMMON * 16 + WEAK_DEF:
|
2006-09-07 23:21:41 +02:00
|
|
|
// A weak definition does not override a common definition.
|
2007-09-19 08:02:29 +02:00
|
|
|
return false;
|
2006-09-07 23:21:41 +02:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case DYN_COMMON * 16 + WEAK_DEF:
|
|
|
|
case DYN_WEAK_COMMON * 16 + WEAK_DEF:
|
2006-09-07 23:21:41 +02:00
|
|
|
// A weak definition does override a definition in a dynamic
|
2009-11-04 02:24:41 +01:00
|
|
|
// object.
|
|
|
|
if (parameters->options().warn_common())
|
|
|
|
Symbol_table::report_resolve_problem(false,
|
|
|
|
_("definition of '%s' overriding "
|
|
|
|
"dynamic common definition"),
|
2009-12-29 01:31:48 +01:00
|
|
|
to, defined, object);
|
2007-09-19 08:02:29 +02:00
|
|
|
return true;
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
case DEF * 16 + DYN_DEF:
|
|
|
|
case WEAK_DEF * 16 + DYN_DEF:
|
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 00:09:08 +02:00
|
|
|
// Ignore a dynamic definition if we already have a definition.
|
|
|
|
return false;
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case DYN_DEF * 16 + DYN_DEF:
|
|
|
|
case DYN_WEAK_DEF * 16 + DYN_DEF:
|
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 00:09:08 +02:00
|
|
|
// Ignore a dynamic definition if we already have a definition,
|
|
|
|
// unless the existing definition is an unversioned definition
|
|
|
|
// in the same dynamic object, and the new definition is a
|
|
|
|
// default version.
|
|
|
|
if (to->object() == object
|
|
|
|
&& to->version() == NULL
|
|
|
|
&& is_default_version)
|
|
|
|
return true;
|
2007-09-19 08:02:29 +02:00
|
|
|
return false;
|
2006-09-07 23:21:41 +02:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case UNDEF * 16 + DYN_DEF:
|
|
|
|
case DYN_UNDEF * 16 + DYN_DEF:
|
|
|
|
case DYN_WEAK_UNDEF * 16 + DYN_DEF:
|
2006-09-07 23:21:41 +02:00
|
|
|
// Use a dynamic definition if we have a reference.
|
2007-09-19 08:02:29 +02:00
|
|
|
return true;
|
2006-09-07 23:21:41 +02:00
|
|
|
|
2010-07-09 03:34:31 +02:00
|
|
|
case WEAK_UNDEF * 16 + DYN_DEF:
|
|
|
|
// When overriding a weak undef by a dynamic definition,
|
|
|
|
// we need to remember that the original undef was weak.
|
|
|
|
*adjust_dyndef = true;
|
|
|
|
return true;
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case COMMON * 16 + DYN_DEF:
|
|
|
|
case WEAK_COMMON * 16 + DYN_DEF:
|
|
|
|
case DYN_COMMON * 16 + DYN_DEF:
|
|
|
|
case DYN_WEAK_COMMON * 16 + DYN_DEF:
|
2006-09-07 23:21:41 +02:00
|
|
|
// Ignore a dynamic definition if we already have a common
|
|
|
|
// definition.
|
2007-09-19 08:02:29 +02:00
|
|
|
return false;
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
case DEF * 16 + DYN_WEAK_DEF:
|
|
|
|
case WEAK_DEF * 16 + DYN_WEAK_DEF:
|
|
|
|
case DYN_DEF * 16 + DYN_WEAK_DEF:
|
|
|
|
case DYN_WEAK_DEF * 16 + DYN_WEAK_DEF:
|
2006-09-07 23:21:41 +02:00
|
|
|
// Ignore a weak dynamic definition if we already have a
|
|
|
|
// definition.
|
2007-09-19 08:02:29 +02:00
|
|
|
return false;
|
2006-09-07 23:21:41 +02:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case UNDEF * 16 + DYN_WEAK_DEF:
|
2010-08-13 02:18:19 +02:00
|
|
|
// When overriding an undef by a dynamic weak definition,
|
|
|
|
// we need to remember that the original undef was not weak.
|
|
|
|
*adjust_dyndef = true;
|
|
|
|
return true;
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case DYN_UNDEF * 16 + DYN_WEAK_DEF:
|
|
|
|
case DYN_WEAK_UNDEF * 16 + DYN_WEAK_DEF:
|
2006-09-07 23:21:41 +02:00
|
|
|
// Use a weak dynamic definition if we have a reference.
|
2007-09-19 08:02:29 +02:00
|
|
|
return true;
|
2006-09-07 23:21:41 +02:00
|
|
|
|
2010-07-09 03:34:31 +02:00
|
|
|
case WEAK_UNDEF * 16 + DYN_WEAK_DEF:
|
|
|
|
// When overriding a weak undef by a dynamic definition,
|
|
|
|
// we need to remember that the original undef was weak.
|
|
|
|
*adjust_dyndef = true;
|
|
|
|
return true;
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case COMMON * 16 + DYN_WEAK_DEF:
|
|
|
|
case WEAK_COMMON * 16 + DYN_WEAK_DEF:
|
|
|
|
case DYN_COMMON * 16 + DYN_WEAK_DEF:
|
|
|
|
case DYN_WEAK_COMMON * 16 + DYN_WEAK_DEF:
|
2006-09-07 23:21:41 +02:00
|
|
|
// Ignore a weak dynamic definition if we already have a common
|
|
|
|
// definition.
|
2007-09-19 08:02:29 +02:00
|
|
|
return false;
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
case DEF * 16 + UNDEF:
|
|
|
|
case WEAK_DEF * 16 + UNDEF:
|
|
|
|
case UNDEF * 16 + UNDEF:
|
2006-11-03 19:26:11 +01:00
|
|
|
// A new undefined reference tells us nothing.
|
2007-09-19 08:02:29 +02:00
|
|
|
return false;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2010-07-09 03:34:31 +02:00
|
|
|
case DYN_DEF * 16 + UNDEF:
|
|
|
|
case DYN_WEAK_DEF * 16 + UNDEF:
|
|
|
|
// For a dynamic def, we need to remember which kind of undef we see.
|
|
|
|
*adjust_dyndef = true;
|
|
|
|
return false;
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case WEAK_UNDEF * 16 + UNDEF:
|
|
|
|
case DYN_UNDEF * 16 + UNDEF:
|
|
|
|
case DYN_WEAK_UNDEF * 16 + UNDEF:
|
2006-11-03 19:26:11 +01:00
|
|
|
// A strong undef overrides a dynamic or weak undef.
|
2007-09-19 08:02:29 +02:00
|
|
|
return true;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case COMMON * 16 + UNDEF:
|
|
|
|
case WEAK_COMMON * 16 + UNDEF:
|
|
|
|
case DYN_COMMON * 16 + UNDEF:
|
|
|
|
case DYN_WEAK_COMMON * 16 + UNDEF:
|
2006-09-07 23:21:41 +02:00
|
|
|
// A new undefined reference tells us nothing.
|
2007-09-19 08:02:29 +02:00
|
|
|
return false;
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
case DEF * 16 + WEAK_UNDEF:
|
|
|
|
case WEAK_DEF * 16 + WEAK_UNDEF:
|
|
|
|
case UNDEF * 16 + WEAK_UNDEF:
|
|
|
|
case WEAK_UNDEF * 16 + WEAK_UNDEF:
|
|
|
|
case DYN_UNDEF * 16 + WEAK_UNDEF:
|
|
|
|
case COMMON * 16 + WEAK_UNDEF:
|
|
|
|
case WEAK_COMMON * 16 + WEAK_UNDEF:
|
|
|
|
case DYN_COMMON * 16 + WEAK_UNDEF:
|
|
|
|
case DYN_WEAK_COMMON * 16 + WEAK_UNDEF:
|
2010-08-28 10:05:04 +02:00
|
|
|
// A new weak undefined reference tells us nothing unless the
|
|
|
|
// exisiting symbol is a dynamic weak reference.
|
2007-09-19 08:02:29 +02:00
|
|
|
return false;
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2010-08-28 10:05:04 +02:00
|
|
|
case DYN_WEAK_UNDEF * 16 + WEAK_UNDEF:
|
|
|
|
// A new weak reference overrides an existing dynamic weak reference.
|
|
|
|
// This is necessary because a dynamic weak reference remembers
|
|
|
|
// the old binding, which may not be weak. If we keeps the existing
|
|
|
|
// dynamic weak reference, the weakness may be dropped in the output.
|
|
|
|
return true;
|
|
|
|
|
2010-07-09 03:34:31 +02:00
|
|
|
case DYN_DEF * 16 + WEAK_UNDEF:
|
|
|
|
case DYN_WEAK_DEF * 16 + WEAK_UNDEF:
|
|
|
|
// For a dynamic def, we need to remember which kind of undef we see.
|
|
|
|
*adjust_dyndef = true;
|
|
|
|
return false;
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case DEF * 16 + DYN_UNDEF:
|
|
|
|
case WEAK_DEF * 16 + DYN_UNDEF:
|
|
|
|
case DYN_DEF * 16 + DYN_UNDEF:
|
|
|
|
case DYN_WEAK_DEF * 16 + DYN_UNDEF:
|
|
|
|
case UNDEF * 16 + DYN_UNDEF:
|
|
|
|
case WEAK_UNDEF * 16 + DYN_UNDEF:
|
|
|
|
case DYN_UNDEF * 16 + DYN_UNDEF:
|
|
|
|
case DYN_WEAK_UNDEF * 16 + DYN_UNDEF:
|
|
|
|
case COMMON * 16 + DYN_UNDEF:
|
|
|
|
case WEAK_COMMON * 16 + DYN_UNDEF:
|
|
|
|
case DYN_COMMON * 16 + DYN_UNDEF:
|
|
|
|
case DYN_WEAK_COMMON * 16 + DYN_UNDEF:
|
2006-09-07 23:21:41 +02:00
|
|
|
// A new dynamic undefined reference tells us nothing.
|
2007-09-19 08:02:29 +02:00
|
|
|
return false;
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
case DEF * 16 + DYN_WEAK_UNDEF:
|
|
|
|
case WEAK_DEF * 16 + DYN_WEAK_UNDEF:
|
|
|
|
case DYN_DEF * 16 + DYN_WEAK_UNDEF:
|
|
|
|
case DYN_WEAK_DEF * 16 + DYN_WEAK_UNDEF:
|
|
|
|
case UNDEF * 16 + DYN_WEAK_UNDEF:
|
|
|
|
case WEAK_UNDEF * 16 + DYN_WEAK_UNDEF:
|
|
|
|
case DYN_UNDEF * 16 + DYN_WEAK_UNDEF:
|
|
|
|
case DYN_WEAK_UNDEF * 16 + DYN_WEAK_UNDEF:
|
|
|
|
case COMMON * 16 + DYN_WEAK_UNDEF:
|
|
|
|
case WEAK_COMMON * 16 + DYN_WEAK_UNDEF:
|
|
|
|
case DYN_COMMON * 16 + DYN_WEAK_UNDEF:
|
|
|
|
case DYN_WEAK_COMMON * 16 + DYN_WEAK_UNDEF:
|
2006-09-07 23:21:41 +02:00
|
|
|
// A new weak dynamic undefined reference tells us nothing.
|
2007-09-19 08:02:29 +02:00
|
|
|
return false;
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
case DEF * 16 + COMMON:
|
2006-09-07 23:21:41 +02:00
|
|
|
// A common symbol does not override a definition.
|
2009-11-04 02:24:41 +01:00
|
|
|
if (parameters->options().warn_common())
|
|
|
|
Symbol_table::report_resolve_problem(false,
|
|
|
|
_("common '%s' overridden by "
|
|
|
|
"previous definition"),
|
2009-12-29 01:31:48 +01:00
|
|
|
to, defined, object);
|
2007-09-19 08:02:29 +02:00
|
|
|
return false;
|
2006-09-07 23:21:41 +02:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case WEAK_DEF * 16 + COMMON:
|
|
|
|
case DYN_DEF * 16 + COMMON:
|
|
|
|
case DYN_WEAK_DEF * 16 + COMMON:
|
2006-09-07 23:21:41 +02:00
|
|
|
// A common symbol does override a weak definition or a dynamic
|
|
|
|
// definition.
|
2007-09-19 08:02:29 +02:00
|
|
|
return true;
|
2006-09-07 23:21:41 +02:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case UNDEF * 16 + COMMON:
|
|
|
|
case WEAK_UNDEF * 16 + COMMON:
|
|
|
|
case DYN_UNDEF * 16 + COMMON:
|
|
|
|
case DYN_WEAK_UNDEF * 16 + COMMON:
|
2006-09-07 23:21:41 +02:00
|
|
|
// A common symbol is a definition for a reference.
|
2007-09-19 08:02:29 +02:00
|
|
|
return true;
|
2006-09-07 23:21:41 +02:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case COMMON * 16 + COMMON:
|
2006-11-03 19:26:11 +01:00
|
|
|
// Set the size to the maximum.
|
2007-09-19 08:02:29 +02:00
|
|
|
*adjust_common_sizes = true;
|
|
|
|
return false;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case WEAK_COMMON * 16 + COMMON:
|
2006-11-03 19:26:11 +01:00
|
|
|
// I'm not sure just what a weak common symbol means, but
|
|
|
|
// presumably it can be overridden by a regular common symbol.
|
2007-09-19 08:02:29 +02:00
|
|
|
return true;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case DYN_COMMON * 16 + COMMON:
|
|
|
|
case DYN_WEAK_COMMON * 16 + COMMON:
|
2007-09-19 08:02:29 +02:00
|
|
|
// Use the real common symbol, but adjust the size if necessary.
|
|
|
|
*adjust_common_sizes = true;
|
|
|
|
return true;
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
case DEF * 16 + WEAK_COMMON:
|
|
|
|
case WEAK_DEF * 16 + WEAK_COMMON:
|
|
|
|
case DYN_DEF * 16 + WEAK_COMMON:
|
|
|
|
case DYN_WEAK_DEF * 16 + WEAK_COMMON:
|
2006-11-03 19:26:11 +01:00
|
|
|
// Whatever a weak common symbol is, it won't override a
|
|
|
|
// definition.
|
2007-09-19 08:02:29 +02:00
|
|
|
return false;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case UNDEF * 16 + WEAK_COMMON:
|
|
|
|
case WEAK_UNDEF * 16 + WEAK_COMMON:
|
|
|
|
case DYN_UNDEF * 16 + WEAK_COMMON:
|
|
|
|
case DYN_WEAK_UNDEF * 16 + WEAK_COMMON:
|
2006-11-03 19:26:11 +01:00
|
|
|
// A weak common symbol is better than an undefined symbol.
|
2007-09-19 08:02:29 +02:00
|
|
|
return true;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case COMMON * 16 + WEAK_COMMON:
|
|
|
|
case WEAK_COMMON * 16 + WEAK_COMMON:
|
|
|
|
case DYN_COMMON * 16 + WEAK_COMMON:
|
|
|
|
case DYN_WEAK_COMMON * 16 + WEAK_COMMON:
|
2006-11-03 19:26:11 +01:00
|
|
|
// Ignore a weak common symbol in the presence of a real common
|
|
|
|
// symbol.
|
2007-09-19 08:02:29 +02:00
|
|
|
return false;
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
case DEF * 16 + DYN_COMMON:
|
|
|
|
case WEAK_DEF * 16 + DYN_COMMON:
|
|
|
|
case DYN_DEF * 16 + DYN_COMMON:
|
|
|
|
case DYN_WEAK_DEF * 16 + DYN_COMMON:
|
2006-11-03 19:26:11 +01:00
|
|
|
// Ignore a dynamic common symbol in the presence of a
|
|
|
|
// definition.
|
2007-09-19 08:02:29 +02:00
|
|
|
return false;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case UNDEF * 16 + DYN_COMMON:
|
|
|
|
case WEAK_UNDEF * 16 + DYN_COMMON:
|
|
|
|
case DYN_UNDEF * 16 + DYN_COMMON:
|
|
|
|
case DYN_WEAK_UNDEF * 16 + DYN_COMMON:
|
2006-11-03 19:26:11 +01:00
|
|
|
// A dynamic common symbol is a definition of sorts.
|
2007-09-19 08:02:29 +02:00
|
|
|
return true;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case COMMON * 16 + DYN_COMMON:
|
|
|
|
case WEAK_COMMON * 16 + DYN_COMMON:
|
|
|
|
case DYN_COMMON * 16 + DYN_COMMON:
|
|
|
|
case DYN_WEAK_COMMON * 16 + DYN_COMMON:
|
2006-11-03 19:26:11 +01:00
|
|
|
// Set the size to the maximum.
|
2007-09-19 08:02:29 +02:00
|
|
|
*adjust_common_sizes = true;
|
|
|
|
return false;
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
case DEF * 16 + DYN_WEAK_COMMON:
|
|
|
|
case WEAK_DEF * 16 + DYN_WEAK_COMMON:
|
|
|
|
case DYN_DEF * 16 + DYN_WEAK_COMMON:
|
|
|
|
case DYN_WEAK_DEF * 16 + DYN_WEAK_COMMON:
|
2006-11-03 19:26:11 +01:00
|
|
|
// A common symbol is ignored in the face of a definition.
|
2007-09-19 08:02:29 +02:00
|
|
|
return false;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case UNDEF * 16 + DYN_WEAK_COMMON:
|
|
|
|
case WEAK_UNDEF * 16 + DYN_WEAK_COMMON:
|
|
|
|
case DYN_UNDEF * 16 + DYN_WEAK_COMMON:
|
|
|
|
case DYN_WEAK_UNDEF * 16 + DYN_WEAK_COMMON:
|
2006-11-03 19:26:11 +01:00
|
|
|
// I guess a weak common symbol is better than a definition.
|
2007-09-19 08:02:29 +02:00
|
|
|
return true;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
case COMMON * 16 + DYN_WEAK_COMMON:
|
|
|
|
case WEAK_COMMON * 16 + DYN_WEAK_COMMON:
|
|
|
|
case DYN_COMMON * 16 + DYN_WEAK_COMMON:
|
|
|
|
case DYN_WEAK_COMMON * 16 + DYN_WEAK_COMMON:
|
2006-11-03 19:26:11 +01:00
|
|
|
// Set the size to the maximum.
|
2007-09-19 08:02:29 +02:00
|
|
|
*adjust_common_sizes = true;
|
|
|
|
return false;
|
2006-09-07 23:21:41 +02:00
|
|
|
|
|
|
|
default:
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_unreachable();
|
2006-08-19 00:29:20 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-04 02:24:41 +01:00
|
|
|
// Issue an error or warning due to symbol resolution. IS_ERROR
|
|
|
|
// indicates an error rather than a warning. MSG is the error
|
|
|
|
// message; it is expected to have a %s for the symbol name. TO is
|
2009-12-29 01:31:48 +01:00
|
|
|
// the existing symbol. DEFINED/OBJECT is where the new symbol was
|
|
|
|
// found.
|
2009-11-04 02:24:41 +01:00
|
|
|
|
|
|
|
// FIXME: We should have better location information here. When the
|
|
|
|
// symbol is defined, we should be able to pull the location from the
|
|
|
|
// debug info if there is any.
|
|
|
|
|
|
|
|
void
|
|
|
|
Symbol_table::report_resolve_problem(bool is_error, const char* msg,
|
2009-12-29 01:31:48 +01:00
|
|
|
const Symbol* to, Defined defined,
|
|
|
|
Object* object)
|
2009-11-04 02:24:41 +01:00
|
|
|
{
|
|
|
|
std::string demangled(to->demangled_name());
|
|
|
|
size_t len = strlen(msg) + demangled.length() + 10;
|
|
|
|
char* buf = new char[len];
|
|
|
|
snprintf(buf, len, msg, demangled.c_str());
|
|
|
|
|
|
|
|
const char* objname;
|
2009-12-29 01:31:48 +01:00
|
|
|
switch (defined)
|
|
|
|
{
|
|
|
|
case OBJECT:
|
|
|
|
objname = object->name().c_str();
|
|
|
|
break;
|
|
|
|
case COPY:
|
|
|
|
objname = _("COPY reloc");
|
|
|
|
break;
|
|
|
|
case DEFSYM:
|
|
|
|
case UNDEFINED:
|
|
|
|
objname = _("command line");
|
|
|
|
break;
|
|
|
|
case SCRIPT:
|
|
|
|
objname = _("linker script");
|
|
|
|
break;
|
|
|
|
case PREDEFINED:
|
2011-06-08 06:05:25 +02:00
|
|
|
case INCREMENTAL_BASE:
|
2009-12-29 01:31:48 +01:00
|
|
|
objname = _("linker defined");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
gold_unreachable();
|
|
|
|
}
|
2009-11-04 02:24:41 +01:00
|
|
|
|
|
|
|
if (is_error)
|
|
|
|
gold_error("%s: %s", objname, buf);
|
|
|
|
else
|
|
|
|
gold_warning("%s: %s", objname, buf);
|
|
|
|
|
|
|
|
delete[] buf;
|
|
|
|
|
|
|
|
if (to->source() == Symbol::FROM_OBJECT)
|
|
|
|
objname = to->object()->name().c_str();
|
|
|
|
else
|
|
|
|
objname = _("command line");
|
|
|
|
gold_info("%s: %s: previous definition here", program_name, objname);
|
|
|
|
}
|
|
|
|
|
[GOLD] PowerPC tls_get_addr_optimize
This implements the special __tls_get_addr_opt call stub for powerpc
gold that returns __thread variable addresses without actually making
a call to __tls_get_addr in most cases. Shared libraries that are
loaded at program load time (ie. dlopen is not used) have a known
layout for their __thread variables, and thus DTPMOD64/DPTREL64 pairs
describing those variables can be set up by ld.so for the
__tls_get_addr_opt call stub fast exit.
Ref https://sourceware.org/ml/libc-alpha/2015-03/msg00626.html
I really, really wish I'd used a differently versioned __tls_get_addr
symbol than the base symbol to indicate glibc support for the
optimized call, rather than having glibc export __tls_get_addr_opt. A
lot of the messing around here, flipping symbols from __tls_get_addr
to __tls_get_addr_opt, is caused by that decision. About the only
benefit is that a user can see at a glance that their disassembled
code is calling __tls_get_addr via the fancy call stub.. Anyway, we
need references to __tls_get_addr to seem like they were to
__tls_get_addr_opt, and in cases like the tsan interceptor, a
definition of __tls_get_addr to seem like one of __tls_get_addr_opt
as well. That's the reason for Symbol::clear_in_reg and
Symbol_table::clone, and why symbols are substituted in Scan::global
and other places dealing with dynamic linking.
elfcpp/
* elfcpp.h (DT_PPC_OPT): Define.
* powerpc.h (PPC_OPT_TLS): Define.
gold/
* options.h (tls_get_addr_optimize): New option.
* symtab.h (Symbol::clear_in_reg, clone): New functions.
(Sized_symbol::clone): New function.
(Symbol_table::clone): New function.
* resolve.cc (Symbol::clone, Sized_symbol::clone): New functions.
* powerpc.cc (Target_powerpc::has_tls_get_addr_opt_,
tls_get_addr_, tls_get_addr_opt_): New vars.
(Target_powerpc::tls_get_addr_opt, tls_get_addr,
is_tls_get_addr_opt, replace_tls_get_addr,
set_has_tls_get_addr_opt, stk_linker): New functions.
(Target_powerpc::Track_tls::maybe_skip_tls_get_addr_call): Add
target param. Update callers. Compare symbols rather than names.
(Target_powerpc::do_define_standard_symbols): Init tls_get_addr_
and tls_get_addr_opt_.
(Target_powerpc::Branch_info::mark_pltcall): Translate tls_get_addr
sym to tls_get_addr_opt.
(Target_powerpc::Branch_info::make_stub): Likewise.
(Stub_table::define_stub_syms): Likewise.
(Target_powerpc::Scan::global): Likewise.
(Target_powerpc::Relocate::relocate): Likewise.
(add_3_12_2, add_3_12_13, bctrl, beqlr, cmpdi_11_0, cmpwi_11_0,
ld_11_1, ld_11_3, ld_12_3, lwz_11_3, lwz_12_3, mr_0_3, mr_3_0,
mtlr_11, std_11_1): New constants.
(Stub_table::eh_frame_added_): Delete.
(Stub_table::tls_get_addr_opt_bctrl_, plt_fde_len_, plt_fde_): New vars.
(Stub_table::init_plt_fde): New functions.
(Stub_table::add_eh_frame, replace_eh_frame): Move definition out
of line. Init and use plt_fde_.
(Stub_table::plt_call_size): Return size for tls_get_addr stub.
Extract alignment code to..
(Stub_table::plt_call_align): ..this new function. Adjust all callers.
(Stub_table::add_plt_call_entry): Set has_tls_get_addr_opt and
tls_get_addr_opt_bctrl, and align after that.
(Stub_table::do_write): Write out tls_get_addr stub.
(Target_powerpc::do_finalize_sections): Emit DT_PPC_OPT
PPC_OPT_TLS/PPC64_OPT_TLS bit.
(Target_powerpc::Relocate::relocate): Don't check for or modify
nop following bl for tls_get_addr stub.
2017-08-29 08:25:33 +02:00
|
|
|
// Completely override existing symbol. Everything bar name_,
|
|
|
|
// version_, and is_forced_local_ flag are copied. version_ is
|
|
|
|
// cleared if from->version_ is clear. Returns true if this symbol
|
|
|
|
// should be forced local.
|
|
|
|
bool
|
|
|
|
Symbol::clone(const Symbol* from)
|
|
|
|
{
|
|
|
|
// Don't allow cloning after dynamic linking info is attached to symbols.
|
|
|
|
// We aren't prepared to merge such.
|
|
|
|
gold_assert(!this->has_symtab_index() && !from->has_symtab_index());
|
|
|
|
gold_assert(!this->has_dynsym_index() && !from->has_dynsym_index());
|
2017-09-22 07:41:12 +02:00
|
|
|
gold_assert(this->got_offset_list() == NULL
|
|
|
|
&& from->got_offset_list() == NULL);
|
[GOLD] PowerPC tls_get_addr_optimize
This implements the special __tls_get_addr_opt call stub for powerpc
gold that returns __thread variable addresses without actually making
a call to __tls_get_addr in most cases. Shared libraries that are
loaded at program load time (ie. dlopen is not used) have a known
layout for their __thread variables, and thus DTPMOD64/DPTREL64 pairs
describing those variables can be set up by ld.so for the
__tls_get_addr_opt call stub fast exit.
Ref https://sourceware.org/ml/libc-alpha/2015-03/msg00626.html
I really, really wish I'd used a differently versioned __tls_get_addr
symbol than the base symbol to indicate glibc support for the
optimized call, rather than having glibc export __tls_get_addr_opt. A
lot of the messing around here, flipping symbols from __tls_get_addr
to __tls_get_addr_opt, is caused by that decision. About the only
benefit is that a user can see at a glance that their disassembled
code is calling __tls_get_addr via the fancy call stub.. Anyway, we
need references to __tls_get_addr to seem like they were to
__tls_get_addr_opt, and in cases like the tsan interceptor, a
definition of __tls_get_addr to seem like one of __tls_get_addr_opt
as well. That's the reason for Symbol::clear_in_reg and
Symbol_table::clone, and why symbols are substituted in Scan::global
and other places dealing with dynamic linking.
elfcpp/
* elfcpp.h (DT_PPC_OPT): Define.
* powerpc.h (PPC_OPT_TLS): Define.
gold/
* options.h (tls_get_addr_optimize): New option.
* symtab.h (Symbol::clear_in_reg, clone): New functions.
(Sized_symbol::clone): New function.
(Symbol_table::clone): New function.
* resolve.cc (Symbol::clone, Sized_symbol::clone): New functions.
* powerpc.cc (Target_powerpc::has_tls_get_addr_opt_,
tls_get_addr_, tls_get_addr_opt_): New vars.
(Target_powerpc::tls_get_addr_opt, tls_get_addr,
is_tls_get_addr_opt, replace_tls_get_addr,
set_has_tls_get_addr_opt, stk_linker): New functions.
(Target_powerpc::Track_tls::maybe_skip_tls_get_addr_call): Add
target param. Update callers. Compare symbols rather than names.
(Target_powerpc::do_define_standard_symbols): Init tls_get_addr_
and tls_get_addr_opt_.
(Target_powerpc::Branch_info::mark_pltcall): Translate tls_get_addr
sym to tls_get_addr_opt.
(Target_powerpc::Branch_info::make_stub): Likewise.
(Stub_table::define_stub_syms): Likewise.
(Target_powerpc::Scan::global): Likewise.
(Target_powerpc::Relocate::relocate): Likewise.
(add_3_12_2, add_3_12_13, bctrl, beqlr, cmpdi_11_0, cmpwi_11_0,
ld_11_1, ld_11_3, ld_12_3, lwz_11_3, lwz_12_3, mr_0_3, mr_3_0,
mtlr_11, std_11_1): New constants.
(Stub_table::eh_frame_added_): Delete.
(Stub_table::tls_get_addr_opt_bctrl_, plt_fde_len_, plt_fde_): New vars.
(Stub_table::init_plt_fde): New functions.
(Stub_table::add_eh_frame, replace_eh_frame): Move definition out
of line. Init and use plt_fde_.
(Stub_table::plt_call_size): Return size for tls_get_addr stub.
Extract alignment code to..
(Stub_table::plt_call_align): ..this new function. Adjust all callers.
(Stub_table::add_plt_call_entry): Set has_tls_get_addr_opt and
tls_get_addr_opt_bctrl, and align after that.
(Stub_table::do_write): Write out tls_get_addr stub.
(Target_powerpc::do_finalize_sections): Emit DT_PPC_OPT
PPC_OPT_TLS/PPC64_OPT_TLS bit.
(Target_powerpc::Relocate::relocate): Don't check for or modify
nop following bl for tls_get_addr stub.
2017-08-29 08:25:33 +02:00
|
|
|
gold_assert(!this->has_plt_offset() && !from->has_plt_offset());
|
|
|
|
|
|
|
|
if (!from->version_)
|
|
|
|
this->version_ = from->version_;
|
|
|
|
this->u1_ = from->u1_;
|
|
|
|
this->u2_ = from->u2_;
|
|
|
|
this->type_ = from->type_;
|
|
|
|
this->binding_ = from->binding_;
|
|
|
|
this->visibility_ = from->visibility_;
|
|
|
|
this->nonvis_ = from->nonvis_;
|
|
|
|
this->source_ = from->source_;
|
|
|
|
this->is_def_ = from->is_def_;
|
|
|
|
this->is_forwarder_ = from->is_forwarder_;
|
|
|
|
this->has_alias_ = from->has_alias_;
|
|
|
|
this->needs_dynsym_entry_ = from->needs_dynsym_entry_;
|
|
|
|
this->in_reg_ = from->in_reg_;
|
|
|
|
this->in_dyn_ = from->in_dyn_;
|
|
|
|
this->needs_dynsym_value_ = from->needs_dynsym_value_;
|
|
|
|
this->has_warning_ = from->has_warning_;
|
|
|
|
this->is_copied_from_dynobj_ = from->is_copied_from_dynobj_;
|
|
|
|
this->is_ordinary_shndx_ = from->is_ordinary_shndx_;
|
|
|
|
this->in_real_elf_ = from->in_real_elf_;
|
|
|
|
this->is_defined_in_discarded_section_
|
|
|
|
= from->is_defined_in_discarded_section_;
|
|
|
|
this->undef_binding_set_ = from->undef_binding_set_;
|
|
|
|
this->undef_binding_weak_ = from->undef_binding_weak_;
|
|
|
|
this->is_predefined_ = from->is_predefined_;
|
|
|
|
this->is_protected_ = from->is_protected_;
|
|
|
|
this->non_zero_localentry_ = from->non_zero_localentry_;
|
|
|
|
|
|
|
|
return !this->is_forced_local_ && from->is_forced_local_;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <int size>
|
|
|
|
bool
|
|
|
|
Sized_symbol<size>::clone(const Sized_symbol<size>* from)
|
|
|
|
{
|
|
|
|
this->value_ = from->value_;
|
|
|
|
this->symsize_ = from->symsize_;
|
|
|
|
return Symbol::clone(from);
|
|
|
|
}
|
|
|
|
|
2007-09-19 08:02:29 +02:00
|
|
|
// A special case of should_override which is only called for a strong
|
|
|
|
// defined symbol from a regular object file. This is used when
|
|
|
|
// defining special symbols.
|
|
|
|
|
|
|
|
bool
|
2011-07-09 01:49:11 +02:00
|
|
|
Symbol_table::should_override_with_special(const Symbol* to,
|
|
|
|
elfcpp::STT fromtype,
|
|
|
|
Defined defined)
|
2007-09-19 08:02:29 +02:00
|
|
|
{
|
|
|
|
bool adjust_common_sizes;
|
2010-07-09 03:34:31 +02:00
|
|
|
bool adjust_dyn_def;
|
2007-09-19 08:02:29 +02:00
|
|
|
unsigned int frombits = global_flag | regular_flag | def_flag;
|
2011-07-09 01:49:11 +02:00
|
|
|
bool ret = Symbol_table::should_override(to, frombits, fromtype, defined,
|
|
|
|
NULL, &adjust_common_sizes,
|
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 00:09:08 +02:00
|
|
|
&adjust_dyn_def, false);
|
2010-07-09 03:34:31 +02:00
|
|
|
gold_assert(!adjust_common_sizes && !adjust_dyn_def);
|
2007-09-19 08:02:29 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Override symbol base with a special symbol.
|
|
|
|
|
|
|
|
void
|
|
|
|
Symbol::override_base_with_special(const Symbol* from)
|
|
|
|
{
|
2011-07-02 07:30:00 +02:00
|
|
|
bool same_name = this->name_ == from->name_;
|
|
|
|
gold_assert(same_name || this->has_alias());
|
2007-10-23 01:08:22 +02:00
|
|
|
|
2014-04-02 23:21:14 +02:00
|
|
|
// If we are overriding an undef, remember the original binding.
|
|
|
|
if (this->is_undefined())
|
|
|
|
this->set_undef_binding(this->binding_);
|
|
|
|
|
2007-09-19 08:02:29 +02:00
|
|
|
this->source_ = from->source_;
|
|
|
|
switch (from->source_)
|
|
|
|
{
|
|
|
|
case FROM_OBJECT:
|
|
|
|
case IN_OUTPUT_DATA:
|
|
|
|
case IN_OUTPUT_SEGMENT:
|
2017-08-29 08:22:45 +02:00
|
|
|
this->u1_ = from->u1_;
|
|
|
|
this->u2_ = from->u2_;
|
2007-09-19 08:02:29 +02:00
|
|
|
break;
|
2008-05-07 08:08:01 +02:00
|
|
|
case IS_CONSTANT:
|
|
|
|
case IS_UNDEFINED:
|
2007-09-19 08:02:29 +02:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
gold_unreachable();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-07-02 07:30:00 +02:00
|
|
|
if (same_name)
|
2011-07-06 06:43:39 +02:00
|
|
|
{
|
|
|
|
// When overriding a versioned symbol with a special symbol, we
|
|
|
|
// may be changing the version. This will happen if we see a
|
|
|
|
// special symbol such as "_end" defined in a shared object with
|
|
|
|
// one version (from a version script), but we want to define it
|
|
|
|
// here with a different version (from a different version
|
|
|
|
// script).
|
|
|
|
this->version_ = from->version_;
|
|
|
|
}
|
2007-09-19 08:02:29 +02:00
|
|
|
this->type_ = from->type_;
|
|
|
|
this->binding_ = from->binding_;
|
2009-02-27 20:57:46 +01:00
|
|
|
this->override_visibility(from->visibility_);
|
2007-09-19 08:02:29 +02:00
|
|
|
this->nonvis_ = from->nonvis_;
|
|
|
|
|
|
|
|
// Special symbols are always considered to be regular symbols.
|
|
|
|
this->in_reg_ = true;
|
2007-10-23 01:08:22 +02:00
|
|
|
|
|
|
|
if (from->needs_dynsym_entry_)
|
|
|
|
this->needs_dynsym_entry_ = true;
|
|
|
|
if (from->needs_dynsym_value_)
|
|
|
|
this->needs_dynsym_value_ = true;
|
|
|
|
|
2011-06-08 06:05:25 +02:00
|
|
|
this->is_predefined_ = from->is_predefined_;
|
|
|
|
|
2007-10-23 01:08:22 +02:00
|
|
|
// We shouldn't see these flags. If we do, we need to handle them
|
|
|
|
// somehow.
|
|
|
|
gold_assert(!from->is_forwarder_);
|
2010-01-09 01:13:48 +01:00
|
|
|
gold_assert(!from->has_plt_offset());
|
2007-10-23 01:08:22 +02:00
|
|
|
gold_assert(!from->has_warning_);
|
|
|
|
gold_assert(!from->is_copied_from_dynobj_);
|
2008-01-24 01:15:00 +01:00
|
|
|
gold_assert(!from->is_forced_local_);
|
2007-09-19 08:02:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Override a symbol with a special symbol.
|
|
|
|
|
|
|
|
template<int size>
|
|
|
|
void
|
|
|
|
Sized_symbol<size>::override_with_special(const Sized_symbol<size>* from)
|
|
|
|
{
|
|
|
|
this->override_base_with_special(from);
|
|
|
|
this->value_ = from->value_;
|
|
|
|
this->symsize_ = from->symsize_;
|
|
|
|
}
|
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
// Override TOSYM with the special symbol FROMSYM. This handles all
|
|
|
|
// aliases of TOSYM.
|
|
|
|
|
|
|
|
template<int size>
|
|
|
|
void
|
|
|
|
Symbol_table::override_with_special(Sized_symbol<size>* tosym,
|
|
|
|
const Sized_symbol<size>* fromsym)
|
|
|
|
{
|
|
|
|
tosym->override_with_special(fromsym);
|
|
|
|
if (tosym->has_alias())
|
|
|
|
{
|
|
|
|
Symbol* sym = this->weak_aliases_[tosym];
|
|
|
|
gold_assert(sym != NULL);
|
2008-02-29 20:19:17 +01:00
|
|
|
Sized_symbol<size>* ssym = this->get_sized_symbol<size>(sym);
|
2007-10-14 17:35:27 +02:00
|
|
|
do
|
|
|
|
{
|
|
|
|
ssym->override_with_special(fromsym);
|
|
|
|
sym = this->weak_aliases_[ssym];
|
|
|
|
gold_assert(sym != NULL);
|
2008-02-29 20:19:17 +01:00
|
|
|
ssym = this->get_sized_symbol<size>(sym);
|
2007-10-14 17:35:27 +02:00
|
|
|
}
|
|
|
|
while (ssym != tosym);
|
|
|
|
}
|
2009-02-27 20:57:46 +01:00
|
|
|
if (tosym->binding() == elfcpp::STB_LOCAL
|
|
|
|
|| ((tosym->visibility() == elfcpp::STV_HIDDEN
|
|
|
|
|| tosym->visibility() == elfcpp::STV_INTERNAL)
|
|
|
|
&& (tosym->binding() == elfcpp::STB_GLOBAL
|
2009-12-05 08:28:45 +01:00
|
|
|
|| tosym->binding() == elfcpp::STB_GNU_UNIQUE
|
2009-02-27 20:57:46 +01:00
|
|
|
|| tosym->binding() == elfcpp::STB_WEAK)
|
|
|
|
&& !parameters->options().relocatable()))
|
2008-01-24 01:15:00 +01:00
|
|
|
this->force_local(tosym);
|
2007-10-14 17:35:27 +02:00
|
|
|
}
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
// Instantiate the templates we need. We could use the configure
|
|
|
|
// script to restrict this to only the ones needed for implemented
|
|
|
|
// targets.
|
|
|
|
|
2010-02-05 01:30:35 +01:00
|
|
|
// We have to instantiate both big and little endian versions because
|
|
|
|
// these are used by other templates that depends on size only.
|
|
|
|
|
|
|
|
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
|
2006-08-19 00:29:20 +02:00
|
|
|
template
|
|
|
|
void
|
2007-09-04 22:00:53 +02:00
|
|
|
Symbol_table::resolve<32, false>(
|
2006-09-07 23:21:41 +02:00
|
|
|
Sized_symbol<32>* to,
|
2007-09-04 22:00:53 +02:00
|
|
|
const elfcpp::Sym<32, false>& sym,
|
2008-04-19 20:30:58 +02:00
|
|
|
unsigned int st_shndx,
|
|
|
|
bool is_ordinary,
|
|
|
|
unsigned int orig_st_shndx,
|
2006-12-06 01:02:36 +01:00
|
|
|
Object* object,
|
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 00:09:08 +02:00
|
|
|
const char* version,
|
|
|
|
bool is_default_version);
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
template
|
|
|
|
void
|
2007-09-04 22:00:53 +02:00
|
|
|
Symbol_table::resolve<32, true>(
|
2006-09-07 23:21:41 +02:00
|
|
|
Sized_symbol<32>* to,
|
2007-09-04 22:00:53 +02:00
|
|
|
const elfcpp::Sym<32, true>& sym,
|
2008-04-19 20:30:58 +02:00
|
|
|
unsigned int st_shndx,
|
|
|
|
bool is_ordinary,
|
|
|
|
unsigned int orig_st_shndx,
|
2006-12-06 01:02:36 +01:00
|
|
|
Object* object,
|
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 00:09:08 +02:00
|
|
|
const char* version,
|
|
|
|
bool is_default_version);
|
2007-09-04 22:00:53 +02:00
|
|
|
#endif
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2010-02-05 01:30:35 +01:00
|
|
|
#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
|
2006-08-19 00:29:20 +02:00
|
|
|
template
|
|
|
|
void
|
2007-09-04 22:00:53 +02:00
|
|
|
Symbol_table::resolve<64, false>(
|
2006-09-07 23:21:41 +02:00
|
|
|
Sized_symbol<64>* to,
|
2007-09-04 22:00:53 +02:00
|
|
|
const elfcpp::Sym<64, false>& sym,
|
2008-04-19 20:30:58 +02:00
|
|
|
unsigned int st_shndx,
|
|
|
|
bool is_ordinary,
|
|
|
|
unsigned int orig_st_shndx,
|
2006-12-06 01:02:36 +01:00
|
|
|
Object* object,
|
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 00:09:08 +02:00
|
|
|
const char* version,
|
|
|
|
bool is_default_version);
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
template
|
|
|
|
void
|
2007-09-04 22:00:53 +02:00
|
|
|
Symbol_table::resolve<64, true>(
|
2006-09-07 23:21:41 +02:00
|
|
|
Sized_symbol<64>* to,
|
2007-09-04 22:00:53 +02:00
|
|
|
const elfcpp::Sym<64, true>& sym,
|
2008-04-19 20:30:58 +02:00
|
|
|
unsigned int st_shndx,
|
|
|
|
bool is_ordinary,
|
|
|
|
unsigned int orig_st_shndx,
|
2006-12-06 01:02:36 +01:00
|
|
|
Object* object,
|
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 00:09:08 +02:00
|
|
|
const char* version,
|
|
|
|
bool is_default_version);
|
2007-09-04 22:00:53 +02:00
|
|
|
#endif
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2007-09-19 08:02:29 +02:00
|
|
|
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
|
|
|
|
template
|
|
|
|
void
|
2007-10-14 17:35:27 +02:00
|
|
|
Symbol_table::override_with_special<32>(Sized_symbol<32>*,
|
|
|
|
const Sized_symbol<32>*);
|
2007-09-19 08:02:29 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
|
|
|
|
template
|
|
|
|
void
|
2007-10-14 17:35:27 +02:00
|
|
|
Symbol_table::override_with_special<64>(Sized_symbol<64>*,
|
|
|
|
const Sized_symbol<64>*);
|
2007-09-19 08:02:29 +02:00
|
|
|
#endif
|
|
|
|
|
[GOLD] PowerPC tls_get_addr_optimize
This implements the special __tls_get_addr_opt call stub for powerpc
gold that returns __thread variable addresses without actually making
a call to __tls_get_addr in most cases. Shared libraries that are
loaded at program load time (ie. dlopen is not used) have a known
layout for their __thread variables, and thus DTPMOD64/DPTREL64 pairs
describing those variables can be set up by ld.so for the
__tls_get_addr_opt call stub fast exit.
Ref https://sourceware.org/ml/libc-alpha/2015-03/msg00626.html
I really, really wish I'd used a differently versioned __tls_get_addr
symbol than the base symbol to indicate glibc support for the
optimized call, rather than having glibc export __tls_get_addr_opt. A
lot of the messing around here, flipping symbols from __tls_get_addr
to __tls_get_addr_opt, is caused by that decision. About the only
benefit is that a user can see at a glance that their disassembled
code is calling __tls_get_addr via the fancy call stub.. Anyway, we
need references to __tls_get_addr to seem like they were to
__tls_get_addr_opt, and in cases like the tsan interceptor, a
definition of __tls_get_addr to seem like one of __tls_get_addr_opt
as well. That's the reason for Symbol::clear_in_reg and
Symbol_table::clone, and why symbols are substituted in Scan::global
and other places dealing with dynamic linking.
elfcpp/
* elfcpp.h (DT_PPC_OPT): Define.
* powerpc.h (PPC_OPT_TLS): Define.
gold/
* options.h (tls_get_addr_optimize): New option.
* symtab.h (Symbol::clear_in_reg, clone): New functions.
(Sized_symbol::clone): New function.
(Symbol_table::clone): New function.
* resolve.cc (Symbol::clone, Sized_symbol::clone): New functions.
* powerpc.cc (Target_powerpc::has_tls_get_addr_opt_,
tls_get_addr_, tls_get_addr_opt_): New vars.
(Target_powerpc::tls_get_addr_opt, tls_get_addr,
is_tls_get_addr_opt, replace_tls_get_addr,
set_has_tls_get_addr_opt, stk_linker): New functions.
(Target_powerpc::Track_tls::maybe_skip_tls_get_addr_call): Add
target param. Update callers. Compare symbols rather than names.
(Target_powerpc::do_define_standard_symbols): Init tls_get_addr_
and tls_get_addr_opt_.
(Target_powerpc::Branch_info::mark_pltcall): Translate tls_get_addr
sym to tls_get_addr_opt.
(Target_powerpc::Branch_info::make_stub): Likewise.
(Stub_table::define_stub_syms): Likewise.
(Target_powerpc::Scan::global): Likewise.
(Target_powerpc::Relocate::relocate): Likewise.
(add_3_12_2, add_3_12_13, bctrl, beqlr, cmpdi_11_0, cmpwi_11_0,
ld_11_1, ld_11_3, ld_12_3, lwz_11_3, lwz_12_3, mr_0_3, mr_3_0,
mtlr_11, std_11_1): New constants.
(Stub_table::eh_frame_added_): Delete.
(Stub_table::tls_get_addr_opt_bctrl_, plt_fde_len_, plt_fde_): New vars.
(Stub_table::init_plt_fde): New functions.
(Stub_table::add_eh_frame, replace_eh_frame): Move definition out
of line. Init and use plt_fde_.
(Stub_table::plt_call_size): Return size for tls_get_addr stub.
Extract alignment code to..
(Stub_table::plt_call_align): ..this new function. Adjust all callers.
(Stub_table::add_plt_call_entry): Set has_tls_get_addr_opt and
tls_get_addr_opt_bctrl, and align after that.
(Stub_table::do_write): Write out tls_get_addr stub.
(Target_powerpc::do_finalize_sections): Emit DT_PPC_OPT
PPC_OPT_TLS/PPC64_OPT_TLS bit.
(Target_powerpc::Relocate::relocate): Don't check for or modify
nop following bl for tls_get_addr stub.
2017-08-29 08:25:33 +02:00
|
|
|
template
|
|
|
|
bool
|
|
|
|
Sized_symbol<32>::clone(const Sized_symbol<32>*);
|
|
|
|
|
|
|
|
template
|
|
|
|
bool
|
|
|
|
Sized_symbol<64>::clone(const Sized_symbol<64>*);
|
2006-08-19 00:29:20 +02:00
|
|
|
} // End namespace gold.
|