// symtab.cc -- the gold symbol table
-// Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+// Copyright 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
#include "target.h"
#include "workqueue.h"
#include "symtab.h"
-#include "demangle.h" // needed for --dynamic-list-cpp-new
+#include "script.h"
#include "plugin.h"
namespace gold
this->symtab_index_ = 0;
this->dynsym_index_ = 0;
this->got_offsets_.init();
- this->plt_offset_ = 0;
+ this->plt_offset_ = -1U;
this->type_ = type;
this->binding_ = binding;
this->visibility_ = visibility;
this->nonvis_ = nonvis;
- this->is_target_special_ = false;
this->is_def_ = false;
this->is_forwarder_ = false;
this->has_alias_ = false;
this->needs_dynsym_entry_ = false;
this->in_reg_ = false;
this->in_dyn_ = false;
- this->has_plt_offset_ = false;
this->has_warning_ = false;
this->is_copied_from_dynobj_ = false;
this->is_forced_local_ = false;
this->is_ordinary_shndx_ = false;
this->in_real_elf_ = false;
+ this->is_defined_in_discarded_section_ = false;
+ this->undef_binding_set_ = false;
+ this->undef_binding_weak_ = false;
}
// Return the demangled version of the symbol's name, but only
// table.
inline bool
-Symbol::should_add_dynsym_entry() const
+Symbol::should_add_dynsym_entry(Symbol_table* symtab) const
{
+ // If the symbol is only present on plugin files, the plugin decided we
+ // don't need it.
+ if (!this->in_real_elf())
+ return false;
+
// If the symbol is used by a dynamic relocation, we need to add it.
if (this->needs_dynsym_entry())
return true;
bool is_ordinary;
unsigned int shndx = this->shndx(&is_ordinary);
if (is_ordinary && shndx != elfcpp::SHN_UNDEF
- && !relobj->is_section_included(shndx))
+ && !relobj->is_section_included(shndx)
+ && !symtab->is_section_folded(relobj, shndx))
return false;
}
{
}
-// The hash function. The key values are Stringpool keys.
-
-inline size_t
-Symbol_table::Symbol_table_hash::operator()(const Symbol_table_key& key) const
-{
- return key.first ^ key.second;
-}
-
// The symbol table key equality function. This is called with
// Stringpool keys.
// work list to avoid gc'ing them.
void
-Symbol_table::gc_mark_undef_symbols()
+Symbol_table::gc_mark_undef_symbols(Layout* layout)
{
for (options::String_set::const_iterator p =
parameters->options().undefined_begin();
{
const char* name = p->c_str();
Symbol* sym = this->lookup(name);
- gold_assert (sym != NULL);
+ gold_assert(sym != NULL);
if (sym->source() == Symbol::FROM_OBJECT
&& !sym->object()->is_dynamic())
{
}
}
}
+
+ for (Script_options::referenced_const_iterator p =
+ layout->script_options()->referenced_begin();
+ p != layout->script_options()->referenced_end();
+ ++p)
+ {
+ Symbol* sym = this->lookup(p->c_str());
+ gold_assert(sym != NULL);
+ if (sym->source() == Symbol::FROM_OBJECT
+ && !sym->object()->is_dynamic())
+ {
+ Relobj* obj = static_cast<Relobj*>(sym->object());
+ bool is_ordinary;
+ unsigned int shndx = sym->shndx(&is_ordinary);
+ if (is_ordinary)
+ {
+ gold_assert(this->gc_ != NULL);
+ this->gc_->worklist().push(Section_id(obj, shndx));
+ }
+ }
+ }
}
void
if (sym->in_dyn() && sym->source() == Symbol::FROM_OBJECT
&& !sym->object()->is_dynamic())
{
- Relobj *obj = static_cast<Relobj*>(sym->object());
+ Relobj* obj = static_cast<Relobj*>(sym->object());
bool is_ordinary;
unsigned int shndx = sym->shndx(&is_ordinary);
if (is_ordinary && shndx != elfcpp::SHN_UNDEF)
// section index; IS_ORDINARY is whether this is a normal section
// rather than a special code.
-// If DEF is true, then this is the definition of a default version of
-// a symbol. That means that any lookup of NAME/NULL and any lookup
-// of NAME/VERSION should always return the same symbol. This is
-// obvious for references, but in particular we want to do this for
-// definitions: overriding NAME/NULL should also override
-// NAME/VERSION. If we don't do that, it would be very hard to
-// override functions in a shared library which uses versioning.
+// If IS_DEFAULT_VERSION is true, then this is the definition of a
+// default version of a symbol. That means that any lookup of
+// NAME/NULL and any lookup of NAME/VERSION should always return the
+// same symbol. This is obvious for references, but in particular we
+// want to do this for definitions: overriding NAME/NULL should also
+// override NAME/VERSION. If we don't do that, it would be very hard
+// to override functions in a shared library which uses versioning.
// We implement this by simply making both entries in the hash table
// point to the same Symbol structure. That is easy enough if this is
template<int size, bool big_endian>
Sized_symbol<size>*
Symbol_table::add_from_object(Object* object,
- const char *name,
+ const char* name,
Stringpool::Key name_key,
- const char *version,
+ const char* version,
Stringpool::Key version_key,
- bool def,
+ bool is_default_version,
const elfcpp::Sym<size, big_endian>& sym,
unsigned int st_shndx,
bool is_ordinary,
this->table_.insert(std::make_pair(std::make_pair(name_key, version_key),
snull));
- std::pair<typename Symbol_table_type::iterator, bool> insdef =
+ std::pair<typename Symbol_table_type::iterator, bool> insdefault =
std::make_pair(this->table_.end(), false);
- if (def)
+ if (is_default_version)
{
const Stringpool::Key vnull_key = 0;
- insdef = this->table_.insert(std::make_pair(std::make_pair(name_key,
- vnull_key),
- snull));
+ insdefault = this->table_.insert(std::make_pair(std::make_pair(name_key,
+ vnull_key),
+ snull));
}
// ins.first: an iterator, which is a pointer to a pair.
if (parameters->options().gc_sections())
this->gc_mark_dyn_syms(ret);
- if (def)
- this->define_default_version<size, big_endian>(ret, insdef.second,
- insdef.first);
+ if (is_default_version)
+ this->define_default_version<size, big_endian>(ret, insdefault.second,
+ insdefault.first);
}
else
{
// This is the first time we have seen NAME/VERSION.
gold_assert(ins.first->second == NULL);
- if (def && !insdef.second)
+ if (is_default_version && !insdefault.second)
{
// We already have an entry for NAME/NULL. If we override
// it, then change it to NAME/VERSION.
- ret = this->get_sized_symbol<size>(insdef.first->second);
+ ret = this->get_sized_symbol<size>(insdefault.first->second);
was_undefined = ret->is_undefined();
was_common = ret->is_common();
{
// This means that we don't want a symbol table
// entry after all.
- if (!def)
+ if (!is_default_version)
this->table_.erase(ins.first);
else
{
- this->table_.erase(insdef.first);
- // Inserting insdef invalidated ins.
+ this->table_.erase(insdefault.first);
+ // Inserting INSDEFAULT invalidated INS.
this->table_.erase(std::make_pair(name_key,
version_key));
}
ret->init_object(name, version, object, sym, st_shndx, is_ordinary);
ins.first->second = ret;
- if (def)
+ if (is_default_version)
{
// This is the first time we have seen NAME/NULL. Point
// it at the new entry for NAME/VERSION.
- gold_assert(insdef.second);
- insdef.first->second = ret;
+ gold_assert(insdefault.second);
+ insdefault.first->second = ret;
}
}
- if (def)
+ if (is_default_version)
ret->set_is_default();
}
// Record every time we see a new undefined symbol, to speed up
// archive groups.
if (!was_undefined && ret->is_undefined())
- ++this->saw_undefined_;
+ {
+ ++this->saw_undefined_;
+ if (parameters->options().has_plugins())
+ parameters->options().plugins()->new_undefined_symbol(ret);
+ }
// Keep track of common symbols, to speed up common symbol
// allocation.
const char* sym_names,
size_t sym_name_size,
typename Sized_relobj<size, big_endian>::Symbols* sympointers,
- size_t *defined)
+ size_t* defined)
{
*defined = 0;
// A symbol defined in a section which we are not including must
// be treated as an undefined symbol.
+ bool is_defined_in_discarded_section = false;
if (st_shndx != elfcpp::SHN_UNDEF
&& is_ordinary
- && !relobj->is_section_included(st_shndx))
- st_shndx = elfcpp::SHN_UNDEF;
+ && !relobj->is_section_included(st_shndx)
+ && !this->is_section_folded(relobj, st_shndx))
+ {
+ st_shndx = elfcpp::SHN_UNDEF;
+ is_defined_in_discarded_section = true;
+ }
// In an object file, an '@' in the name separates the symbol
// name from the version name. If there are two '@' characters,
const char* ver = strchr(name, '@');
Stringpool::Key ver_key = 0;
int namelen = 0;
- // DEF: is the version default? LOCAL: is the symbol forced local?
- bool def = false;
- bool local = false;
+ // IS_DEFAULT_VERSION: is the version default?
+ // IS_FORCED_LOCAL: is the symbol forced local?
+ bool is_default_version = false;
+ bool is_forced_local = false;
if (ver != NULL)
{
++ver;
if (*ver == '@')
{
- def = true;
+ is_default_version = true;
++ver;
}
ver = this->namepool_.add(ver, true, &ver_key);
// The symbol name did not have a version, but the
// version script may assign a version anyway.
std::string version;
- if (this->version_script_.get_symbol_version(name, &version))
+ bool is_global;
+ if (this->version_script_.get_symbol_version(name, &version,
+ &is_global))
{
- // The version can be empty if the version script is
- // only used to force some symbols to be local.
- if (!version.empty())
+ if (!is_global)
+ is_forced_local = true;
+ else if (!version.empty())
{
ver = this->namepool_.add_with_length(version.c_str(),
version.length(),
true,
&ver_key);
- def = true;
+ is_default_version = true;
}
}
- else if (this->version_script_.symbol_is_local(name))
- local = true;
}
}
}
// Fix up visibility if object has no-export set.
- if (relobj->no_export())
+ if (relobj->no_export()
+ && (orig_st_shndx != elfcpp::SHN_UNDEF || !is_ordinary))
{
// We may have copied symbol already above.
if (psym != &sym2)
Sized_symbol<size>* res;
res = this->add_from_object(relobj, name, name_key, ver, ver_key,
- def, *psym, st_shndx, is_ordinary,
- orig_st_shndx);
+ is_default_version, *psym, st_shndx,
+ is_ordinary, orig_st_shndx);
// If building a shared library using garbage collection, do not
// treat externally visible symbols as garbage.
&& parameters->options().shared())
this->gc_mark_symbol_for_shlib(res);
- if (local)
+ if (is_forced_local)
this->force_local(res);
+ if (is_defined_in_discarded_section)
+ res->set_is_defined_in_discarded_section();
+
(*sympointers)[i] = res;
}
}
bool is_ordinary = st_shndx < elfcpp::SHN_LORESERVE;
Stringpool::Key ver_key = 0;
- bool def = false;
- bool local = false;
+ bool is_default_version = false;
+ bool is_forced_local = false;
if (ver != NULL)
{
// The symbol name did not have a version, but the
// version script may assign a version anyway.
std::string version;
- if (this->version_script_.get_symbol_version(name, &version))
+ bool is_global;
+ if (this->version_script_.get_symbol_version(name, &version,
+ &is_global))
{
- // The version can be empty if the version script is
- // only used to force some symbols to be local.
- if (!version.empty())
+ if (!is_global)
+ is_forced_local = true;
+ else if (!version.empty())
{
ver = this->namepool_.add_with_length(version.c_str(),
version.length(),
true,
&ver_key);
- def = true;
+ is_default_version = true;
}
}
- else if (this->version_script_.symbol_is_local(name))
- local = true;
}
}
Sized_symbol<size>* res;
res = this->add_from_object(obj, name, name_key, ver, ver_key,
- def, *sym, st_shndx, is_ordinary, st_shndx);
+ is_default_version, *sym, st_shndx,
+ is_ordinary, st_shndx);
- if (local)
+ if (is_forced_local)
this->force_local(res);
return res;
st_shndx);
else
{
- const bool def = (!hidden
- && st_shndx != elfcpp::SHN_UNDEF);
+ const bool is_default_version =
+ !hidden && st_shndx != elfcpp::SHN_UNDEF;
res = this->add_from_object(dynobj, name, name_key, version,
- version_key, def, *psym, st_shndx,
+ version_key, is_default_version,
+ *psym, st_shndx,
is_ordinary, st_shndx);
}
}
Symbol_table::define_special_symbol(const char** pname, const char** pversion,
bool only_if_ref,
Sized_symbol<size>** poldsym,
- bool *resolve_oldsym)
+ bool* resolve_oldsym)
{
*resolve_oldsym = false;
bool is_default_version = false;
if (*pversion == NULL)
{
- if (this->version_script_.get_symbol_version(*pname, &v))
+ bool is_global;
+ if (this->version_script_.get_symbol_version(*pname, &v, &is_global))
{
- if (!v.empty())
- *pversion = v.c_str();
-
- // If we get the version from a version script, then we are
- // also the default version.
- is_default_version = true;
+ if (is_global && !v.empty())
+ {
+ *pversion = v.c_str();
+ // If we get the version from a version script, then we
+ // are also the default version.
+ is_default_version = true;
+ }
}
}
version_key),
snull));
- std::pair<typename Symbol_table_type::iterator, bool> insdef =
+ std::pair<typename Symbol_table_type::iterator, bool> insdefault =
std::make_pair(this->table_.end(), false);
if (is_default_version)
{
const Stringpool::Key vnull = 0;
- insdef = this->table_.insert(std::make_pair(std::make_pair(name_key,
- vnull),
- snull));
+ insdefault =
+ this->table_.insert(std::make_pair(std::make_pair(name_key,
+ vnull),
+ snull));
}
if (!ins.second)
Sized_symbol<size>* soldsym =
this->get_sized_symbol<size>(oldsym);
this->define_default_version<size, big_endian>(soldsym,
- insdef.second,
- insdef.first);
+ insdefault.second,
+ insdefault.first);
}
}
else
add_to_table = true;
add_loc = ins.first;
- if (is_default_version && !insdef.second)
+ if (is_default_version && !insdefault.second)
{
// We are adding NAME/VERSION, and it is the default
// version. We already have an entry for NAME/NULL.
- oldsym = insdef.first->second;
+ oldsym = insdefault.first->second;
*resolve_oldsym = true;
}
else
if (is_default_version)
{
add_def_to_table = true;
- add_def_loc = insdef.first;
+ add_def_loc = insdefault.first;
}
}
}
Symbol*
Symbol_table::define_in_output_data(const char* name,
const char* version,
+ Defined defined,
Output_data* od,
uint64_t value,
uint64_t symsize,
if (parameters->target().get_size() == 32)
{
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
- return this->do_define_in_output_data<32>(name, version, od,
+ return this->do_define_in_output_data<32>(name, version, defined, od,
value, symsize, type, binding,
visibility, nonvis,
offset_is_from_end,
else if (parameters->target().get_size() == 64)
{
#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
- return this->do_define_in_output_data<64>(name, version, od,
+ return this->do_define_in_output_data<64>(name, version, defined, od,
value, symsize, type, binding,
visibility, nonvis,
offset_is_from_end,
Symbol_table::do_define_in_output_data(
const char* name,
const char* version,
+ Defined defined,
Output_data* od,
typename elfcpp::Elf_types<size>::Elf_Addr value,
typename elfcpp::Elf_types<size>::Elf_WXword symsize,
return sym;
}
- if (Symbol_table::should_override_with_special(oldsym))
+ if (Symbol_table::should_override_with_special(oldsym, defined))
this->override_with_special(oldsym, sym);
if (resolve_oldsym)
Symbol*
Symbol_table::define_in_output_segment(const char* name,
- const char* version, Output_segment* os,
+ const char* version,
+ Defined defined,
+ Output_segment* os,
uint64_t value,
uint64_t symsize,
elfcpp::STT type,
if (parameters->target().get_size() == 32)
{
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
- return this->do_define_in_output_segment<32>(name, version, os,
+ return this->do_define_in_output_segment<32>(name, version, defined, os,
value, symsize, type,
binding, visibility, nonvis,
offset_base, only_if_ref);
else if (parameters->target().get_size() == 64)
{
#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
- return this->do_define_in_output_segment<64>(name, version, os,
+ return this->do_define_in_output_segment<64>(name, version, defined, os,
value, symsize, type,
binding, visibility, nonvis,
offset_base, only_if_ref);
Symbol_table::do_define_in_output_segment(
const char* name,
const char* version,
+ Defined defined,
Output_segment* os,
typename elfcpp::Elf_types<size>::Elf_Addr value,
typename elfcpp::Elf_types<size>::Elf_WXword symsize,
return sym;
}
- if (Symbol_table::should_override_with_special(oldsym))
+ if (Symbol_table::should_override_with_special(oldsym, defined))
this->override_with_special(oldsym, sym);
if (resolve_oldsym)
Symbol*
Symbol_table::define_as_constant(const char* name,
const char* version,
+ Defined defined,
uint64_t value,
uint64_t symsize,
elfcpp::STT type,
if (parameters->target().get_size() == 32)
{
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
- return this->do_define_as_constant<32>(name, version, value,
+ return this->do_define_as_constant<32>(name, version, defined, value,
symsize, type, binding,
visibility, nonvis, only_if_ref,
force_override);
else if (parameters->target().get_size() == 64)
{
#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
- return this->do_define_as_constant<64>(name, version, value,
+ return this->do_define_as_constant<64>(name, version, defined, value,
symsize, type, binding,
visibility, nonvis, only_if_ref,
force_override);
Symbol_table::do_define_as_constant(
const char* name,
const char* version,
+ Defined defined,
typename elfcpp::Elf_types<size>::Elf_Addr value,
typename elfcpp::Elf_types<size>::Elf_WXword symsize,
elfcpp::STT type,
return sym;
}
- if (force_override || Symbol_table::should_override_with_special(oldsym))
+ if (force_override
+ || Symbol_table::should_override_with_special(oldsym, defined))
this->override_with_special(oldsym, sym);
if (resolve_oldsym)
{
Output_section* os = layout->find_output_section(p->output_section);
if (os != NULL)
- this->define_in_output_data(p->name, NULL, os, p->value,
+ this->define_in_output_data(p->name, NULL, PREDEFINED, os, p->value,
p->size, p->type, p->binding,
p->visibility, p->nonvis,
p->offset_is_from_end,
only_if_ref || p->only_if_ref);
else
- this->define_as_constant(p->name, NULL, 0, p->size, p->type,
- p->binding, p->visibility, p->nonvis,
+ this->define_as_constant(p->name, NULL, PREDEFINED, 0, p->size,
+ p->type, p->binding, p->visibility, p->nonvis,
only_if_ref || p->only_if_ref,
false);
}
p->segment_flags_set,
p->segment_flags_clear);
if (os != NULL)
- this->define_in_output_segment(p->name, NULL, os, p->value,
+ this->define_in_output_segment(p->name, NULL, PREDEFINED, os, p->value,
p->size, p->type, p->binding,
p->visibility, p->nonvis,
p->offset_base,
only_if_ref || p->only_if_ref);
else
- this->define_as_constant(p->name, NULL, 0, p->size, p->type,
- p->binding, p->visibility, p->nonvis,
+ this->define_as_constant(p->name, NULL, PREDEFINED, 0, p->size,
+ p->type, p->binding, p->visibility, p->nonvis,
only_if_ref || p->only_if_ref,
false);
}
if (binding == elfcpp::STB_WEAK)
binding = elfcpp::STB_GLOBAL;
- this->define_in_output_data(csym->name(), csym->version(),
+ this->define_in_output_data(csym->name(), csym->version(), COPY,
posd, value, csym->symsize(),
csym->type(), binding,
csym->visibility(), csym->nonvis(),
// Add any undefined symbols named on the command line.
void
-Symbol_table::add_undefined_symbols_from_command_line()
+Symbol_table::add_undefined_symbols_from_command_line(Layout* layout)
{
- if (parameters->options().any_undefined())
+ if (parameters->options().any_undefined()
+ || layout->script_options()->any_unreferenced())
{
if (parameters->target().get_size() == 32)
{
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
- this->do_add_undefined_symbols_from_command_line<32>();
+ this->do_add_undefined_symbols_from_command_line<32>(layout);
#else
gold_unreachable();
#endif
else if (parameters->target().get_size() == 64)
{
#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
- this->do_add_undefined_symbols_from_command_line<64>();
+ this->do_add_undefined_symbols_from_command_line<64>(layout);
#else
gold_unreachable();
#endif
template<int size>
void
-Symbol_table::do_add_undefined_symbols_from_command_line()
+Symbol_table::do_add_undefined_symbols_from_command_line(Layout* layout)
{
for (options::String_set::const_iterator p =
parameters->options().undefined_begin();
p != parameters->options().undefined_end();
++p)
- {
- const char* name = p->c_str();
+ this->add_undefined_symbol_from_command_line<size>(p->c_str());
- if (this->lookup(name) != NULL)
- continue;
+ for (Script_options::referenced_const_iterator p =
+ layout->script_options()->referenced_begin();
+ p != layout->script_options()->referenced_end();
+ ++p)
+ this->add_undefined_symbol_from_command_line<size>(p->c_str());
+}
- const char* version = NULL;
+template<int size>
+void
+Symbol_table::add_undefined_symbol_from_command_line(const char* name)
+{
+ if (this->lookup(name) != NULL)
+ return;
- Sized_symbol<size>* sym;
- Sized_symbol<size>* oldsym;
- bool resolve_oldsym;
- if (parameters->target().is_big_endian())
- {
+ const char* version = NULL;
+
+ Sized_symbol<size>* sym;
+ Sized_symbol<size>* oldsym;
+ bool resolve_oldsym;
+ if (parameters->target().is_big_endian())
+ {
#if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
- sym = this->define_special_symbol<size, true>(&name, &version,
- false, &oldsym,
- &resolve_oldsym);
+ sym = this->define_special_symbol<size, true>(&name, &version,
+ false, &oldsym,
+ &resolve_oldsym);
#else
- gold_unreachable();
+ gold_unreachable();
#endif
- }
- else
- {
+ }
+ else
+ {
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
- sym = this->define_special_symbol<size, false>(&name, &version,
- false, &oldsym,
- &resolve_oldsym);
+ sym = this->define_special_symbol<size, false>(&name, &version,
+ false, &oldsym,
+ &resolve_oldsym);
#else
- gold_unreachable();
+ gold_unreachable();
#endif
- }
+ }
- gold_assert(oldsym == NULL);
+ gold_assert(oldsym == NULL);
- sym->init_undefined(name, version, elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
- elfcpp::STV_DEFAULT, 0);
- ++this->saw_undefined_;
- }
+ sym->init_undefined(name, version, elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
+ elfcpp::STV_DEFAULT, 0);
+ ++this->saw_undefined_;
}
// Set the dynamic symbol indexes. INDEX is the index of the first
// some symbols appear more than once in the symbol table, with
// and without a version.
- if (!sym->should_add_dynsym_entry())
+ if (!sym->should_add_dynsym_entry(this))
sym->set_dynsym_index(-1U);
else if (!sym->has_dynsym_index())
{
off_t
Symbol_table::finalize(off_t off, off_t dynoff, size_t dyn_global_index,
size_t dyncount, Stringpool* pool,
- unsigned int *plocal_symcount)
+ unsigned int* plocal_symcount)
{
off_t ret;
{
Relobj* relobj = static_cast<Relobj*>(symobj);
Output_section* os = relobj->output_section(shndx);
- uint64_t secoff64 = relobj->output_section_offset(shndx);
if (this->is_section_folded(relobj, shndx))
{
shndx);
gold_assert(folded.first != NULL);
Relobj* folded_obj = reinterpret_cast<Relobj*>(folded.first);
- os = folded_obj->output_section(folded.second);
+ unsigned folded_shndx = folded.second;
+
+ os = folded_obj->output_section(folded_shndx);
gold_assert(os != NULL);
- secoff64 = folded_obj->output_section_offset(folded.second);
+
+ // Replace (relobj, shndx) with canonical ICF input section.
+ shndx = folded_shndx;
+ relobj = folded_obj;
}
+ uint64_t secoff64 = relobj->output_section_offset(shndx);
if (os == NULL)
{
bool static_or_reloc = (parameters->doing_static_link() ||
return false;
}
+ // If the symbol is only present on plugin files, the plugin decided we
+ // don't need it.
+ if (!sym->in_real_elf())
+ {
+ gold_assert(!sym->has_symtab_index());
+ sym->set_symtab_index(-1U);
+ return false;
+ }
+
// Compute final symbol value.
Compute_final_value_status status;
Value_type value = this->compute_final_value(sym, &status);
unsigned int shndx;
typename elfcpp::Elf_types<size>::Elf_Addr sym_value = sym->value();
typename elfcpp::Elf_types<size>::Elf_Addr dynsym_value = sym_value;
+ elfcpp::STB binding = sym->binding();
switch (sym->source())
{
case Symbol::FROM_OBJECT:
if (sym->needs_dynsym_value())
dynsym_value = target.dynsym_value(sym);
shndx = elfcpp::SHN_UNDEF;
+ if (sym->is_undef_binding_weak())
+ binding = elfcpp::STB_WEAK;
+ else
+ binding = elfcpp::STB_GLOBAL;
}
else if (symobj->pluginobj() != NULL)
shndx = elfcpp::SHN_UNDEF;
gold_assert(sym_index < output_count);
unsigned char* ps = psyms + (sym_index * sym_size);
this->sized_write_symbol<size, big_endian>(sym, sym_value, shndx,
- sympool, ps);
+ binding, sympool, ps);
}
if (dynsym_index != -1U)
gold_assert(dynsym_index < dynamic_count);
unsigned char* pd = dynamic_view + (dynsym_index * sym_size);
this->sized_write_symbol<size, big_endian>(sym, dynsym_value, shndx,
- dynpool, pd);
+ binding, dynpool, pd);
}
}
Sized_symbol<size>* sym,
typename elfcpp::Elf_types<size>::Elf_Addr value,
unsigned int shndx,
+ elfcpp::STB binding,
const Stringpool* pool,
unsigned char* p) const
{
if (sym->is_forced_local())
osym.put_st_info(elfcpp::elf_st_info(elfcpp::STB_LOCAL, type));
else
- osym.put_st_info(elfcpp::elf_st_info(sym->binding(), type));
+ osym.put_st_info(elfcpp::elf_st_info(binding, type));
osym.put_st_other(elfcpp::elf_st_other(sym->visibility(), sym->nonvis()));
osym.put_st_shndx(shndx);
}
// Write out a section symbol. Return the update offset.
void
-Symbol_table::write_section_symbol(const Output_section *os,
+Symbol_table::write_section_symbol(const Output_section* os,
Output_symtab_xindex* symtab_xindex,
Output_file* of,
off_t offset) const
// We check for ODR violations by looking for symbols with the same
// name for which the debugging information reports that they were
// defined in different source locations. When comparing the source
-// location, we consider instances with the same base filename and
-// line number to be the same. This is because different object
-// files/shared libraries can include the same header file using
-// different paths, and we don't want to report an ODR violation in
-// that case.
+// location, we consider instances with the same base filename to be
+// the same. This is because different object files/shared libraries
+// can include the same header file using different paths, and
+// different optimization settings can make the line number appear to
+// be a couple lines off, and we don't want to report an ODR violation
+// in those cases.
// This struct is used to compare line information, as returned by
// Dwarf_line_info::one_addr2line. It implements a < comparison
bool
operator()(const std::string& s1, const std::string& s2) const
{
- std::string::size_type pos1 = s1.rfind('/');
- std::string::size_type pos2 = s2.rfind('/');
- if (pos1 == std::string::npos
- || pos2 == std::string::npos)
- return s1 < s2;
- return s1.compare(pos1, std::string::npos,
- s2, pos2, std::string::npos) < 0;
+ // Inputs should be of the form "dirname/filename:linenum" where
+ // "dirname/" is optional. We want to compare just the filename.
+
+ // Find the last '/' and ':' in each string.
+ std::string::size_type s1begin = s1.rfind('/');
+ std::string::size_type s2begin = s2.rfind('/');
+ std::string::size_type s1end = s1.rfind(':');
+ std::string::size_type s2end = s2.rfind(':');
+ // If there was no '/' in a string, start at the beginning.
+ if (s1begin == std::string::npos)
+ s1begin = 0;
+ if (s2begin == std::string::npos)
+ s2begin = 0;
+ // If the ':' appeared in the directory name, compare to the end
+ // of the string.
+ if (s1end < s1begin)
+ s1end = s1.size();
+ if (s2end < s2begin)
+ s2end = s2.size();
+ // Compare takes lengths, not end indices.
+ return s1.compare(s1begin, s1end - s1begin,
+ s2, s2begin, s2end - s2begin) < 0;
}
};
++it)
{
const char* symbol_name = it->first;
- // We use a sorted set so the output is deterministic.
- std::set<std::string, Odr_violation_compare> line_nums;
+ // Maps from symbol location to a sample object file we found
+ // that location in. We use a sorted map so the location order
+ // is deterministic, but we only store an arbitrary object file
+ // to avoid copying lots of names.
+ std::map<std::string, std::string, Odr_violation_compare> line_nums;
for (Unordered_set<Symbol_location, Symbol_location_hash>::const_iterator
locs = it->second.begin();
std::string lineno = Dwarf_line_info::one_addr2line(
locs->object, locs->shndx, locs->offset, 16);
if (!lineno.empty())
- line_nums.insert(lineno);
+ {
+ std::string& sample_object = line_nums[lineno];
+ if (sample_object.empty())
+ sample_object = locs->object->name();
+ }
}
if (line_nums.size() > 1)
gold_warning(_("while linking %s: symbol '%s' defined in multiple "
"places (possible ODR violation):"),
output_file_name, demangle(symbol_name).c_str());
- for (std::set<std::string>::const_iterator it2 = line_nums.begin();
- it2 != line_nums.end();
- ++it2)
- fprintf(stderr, " %s\n", it2->c_str());
+ for (std::map<std::string, std::string>::const_iterator it2 =
+ line_nums.begin();
+ it2 != line_nums.end();
+ ++it2)
+ fprintf(stderr, _(" %s from %s\n"),
+ it2->first.c_str(), it2->second.c_str());
}
}
// We only call one_addr2line() in this function, so we can clear its cache.
projects / deliverable / binutils-gdb.git / blobdiff