X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gold%2Fsymtab.cc;h=5ce5c31bfee4d344386b6d445bb92e04fc31864b;hb=712ec27916b5604d29d928dec060fd1ba0fd9edb;hp=31ecc5c2638056fed5565b349aace636333de25e;hpb=5417c94d1a944d1a27f99240e5d62a6d7cd324f1;p=deliverable%2Fbinutils-gdb.git diff --git a/gold/symtab.cc b/gold/symtab.cc index 31ecc5c263..5ce5c31bfe 100644 --- a/gold/symtab.cc +++ b/gold/symtab.cc @@ -1,6 +1,6 @@ // symtab.cc -- the gold symbol table -// Copyright (C) 2006-2015 Free Software Foundation, Inc. +// Copyright (C) 2006-2016 Free Software Foundation, Inc. // Written by Ian Lance Taylor . // This file is part of gold. @@ -80,6 +80,7 @@ Symbol::init_fields(const char* name, const char* version, this->undef_binding_set_ = false; this->undef_binding_weak_ = false; this->is_predefined_ = false; + this->is_protected_ = false; } // Return the demangled version of the symbol's name, but only @@ -285,11 +286,12 @@ Sized_symbol::init_constant(const char* name, const char* version, template void Sized_symbol::init_undefined(const char* name, const char* version, - elfcpp::STT type, elfcpp::STB binding, - elfcpp::STV visibility, unsigned char nonvis) + Value_type value, elfcpp::STT type, + elfcpp::STB binding, elfcpp::STV visibility, + unsigned char nonvis) { this->init_base_undefined(name, version, type, binding, visibility, nonvis); - this->value_ = 0; + this->value_ = value; this->symsize_ = 0; } @@ -565,7 +567,8 @@ Symbol_table::Symbol_table(unsigned int count, : saw_undefined_(0), offset_(0), table_(count), namepool_(), forwarders_(), commons_(), tls_commons_(), small_commons_(), large_commons_(), forced_locals_(), warnings_(), - version_script_(version_script), gc_(NULL), icf_(NULL) + version_script_(version_script), gc_(NULL), icf_(NULL), + target_symbols_() { namepool_.reserve(count); } @@ -737,7 +740,7 @@ Symbol_table::resolve(Sized_symbol* to, const Sized_symbol* from) bool is_ordinary; unsigned int shndx = from->shndx(&is_ordinary); this->resolve(to, esym.sym(), shndx, is_ordinary, shndx, from->object(), - from->version()); + from->version(), true); if (from->in_reg()) to->set_in_reg(); if (from->in_dyn()) @@ -863,6 +866,9 @@ Symbol_table::define_default_version(Sized_symbol* sym, // other is defined in a shared object, then they are different // symbols. + // If the two symbols are from different shared objects, + // they are different symbols. + // Otherwise, we just resolve the symbols as though they were // the same. @@ -874,6 +880,10 @@ Symbol_table::define_default_version(Sized_symbol* sym, else if (pdef->second->visibility() != elfcpp::STV_DEFAULT && sym->is_from_dynobj()) ; + else if (pdef->second->is_from_dynobj() + && sym->is_from_dynobj() + && pdef->second->object() != sym->object()) + ; else { const Sized_symbol* symdef; @@ -991,13 +1001,40 @@ Symbol_table::add_from_object(Object* object, was_common = ret->is_common() && ret->object()->pluginobj() == NULL; this->resolve(ret, sym, st_shndx, is_ordinary, orig_st_shndx, object, - version); + version, is_default_version); if (parameters->options().gc_sections()) this->gc_mark_dyn_syms(ret); if (is_default_version) this->define_default_version(ret, insdefault.second, insdefault.first); + else + { + bool dummy; + if (version != NULL + && ret->source() == Symbol::FROM_OBJECT + && ret->object() == object + && is_ordinary + && ret->shndx(&dummy) == st_shndx + && ret->is_default()) + { + // We have seen NAME/VERSION already, and marked it as the + // default version, but now we see a definition for + // NAME/VERSION that is not the default version. This can + // happen when the assembler generates two symbols for + // a symbol as a result of a ".symver foo,foo@VER" + // directive. We see the first unversioned symbol and + // we may mark it as the default version (from a + // version script); then we see the second versioned + // symbol and we need to override the first. + // In any other case, the two symbols should have generated + // a multiple definition error. + // (See PR gold/18703.) + ret->set_is_not_default(); + const Stringpool::Key vnull_key = 0; + this->table_.erase(std::make_pair(name_key, vnull_key)); + } + } } else { @@ -1015,7 +1052,7 @@ Symbol_table::add_from_object(Object* object, was_common = ret->is_common() && ret->object()->pluginobj() == NULL; this->resolve(ret, sym, st_shndx, is_ordinary, orig_st_shndx, object, - version); + version, is_default_version); if (parameters->options().gc_sections()) this->gc_mark_dyn_syms(ret); ins.first->second = ret; @@ -1031,7 +1068,8 @@ Symbol_table::add_from_object(Object* object, ret = new Sized_symbol(); else { - ret = target->make_symbol(); + ret = target->make_symbol(name, sym.get_st_type(), object, + st_shndx, sym.get_st_value()); if (ret == NULL) { // This means that we don't want a symbol table @@ -1144,7 +1182,8 @@ Symbol_table::add_from_relobj( const char* name = sym_names + st_name; - if (strcmp (name, "__gnu_lto_slim") == 0) + if (!parameters->options().relocatable() + && strcmp (name, "__gnu_lto_slim") == 0) gold_info(_("%s: plugin needed to handle lto object"), relobj->name().c_str()); @@ -1441,14 +1480,20 @@ Symbol_table::add_from_dynobj( // A protected symbol in a shared library must be treated as a // normal symbol when viewed from outside the shared library. // Implement this by overriding the visibility here. + // Likewise, an IFUNC symbol in a shared library must be treated + // as a normal FUNC symbol. elfcpp::Sym* psym = &sym; unsigned char symbuf[sym_size]; elfcpp::Sym sym2(symbuf); - if (sym.get_st_visibility() == elfcpp::STV_PROTECTED) + if (sym.get_st_visibility() == elfcpp::STV_PROTECTED + || sym.get_st_type() == elfcpp::STT_GNU_IFUNC) { memcpy(symbuf, p, sym_size); elfcpp::Sym_write sw(symbuf); - sw.put_st_other(elfcpp::STV_DEFAULT, sym.get_st_nonvis()); + if (sym.get_st_visibility() == elfcpp::STV_PROTECTED) + sw.put_st_other(elfcpp::STV_DEFAULT, sym.get_st_nonvis()); + if (sym.get_st_type() == elfcpp::STT_GNU_IFUNC) + sw.put_st_info(sym.get_st_bind(), elfcpp::STT_FUNC); psym = &sym2; } @@ -1566,6 +1611,13 @@ Symbol_table::add_from_dynobj( && res->object() == dynobj) object_symbols.push_back(res); + // If the symbol has protected visibility in the dynobj, + // mark it as such if it was not overridden. + if (res->source() == Symbol::FROM_OBJECT + && res->object() == dynobj + && sym.get_st_visibility() == elfcpp::STV_PROTECTED) + res->set_is_protected(); + if (sympointers != NULL) (*sympointers)[i] = res; } @@ -1824,7 +1876,8 @@ Symbol_table::define_special_symbol(const char** pname, const char** pversion, { Sized_target* sized_target = parameters->sized_target(); - sym = sized_target->make_symbol(); + sym = sized_target->make_symbol(*pname, elfcpp::STT_NOTYPE, + NULL, elfcpp::SHN_UNDEF, 0); if (sym == NULL) return NULL; } @@ -1953,8 +2006,9 @@ Symbol_table::do_define_in_output_data( return sym; else { - if (binding == elfcpp::STB_LOCAL - || this->version_script_.symbol_is_local(name)) + if (defined == PREDEFINED + && (binding == elfcpp::STB_LOCAL + || this->version_script_.symbol_is_local(name))) this->force_local(oldsym); delete sym; return oldsym; @@ -2402,7 +2456,7 @@ Symbol_table::add_undefined_symbol_from_command_line(const char* name) gold_assert(oldsym == NULL); - sym->init_undefined(name, version, elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL, + sym->init_undefined(name, version, 0, elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL, elfcpp::STV_DEFAULT, 0); ++this->saw_undefined_; } @@ -2499,6 +2553,17 @@ Symbol_table::set_dynsym_indexes(unsigned int index, // symbols. index = versions->finalize(this, index, syms); + // Process target-specific symbols. + for (std::vector::iterator p = this->target_symbols_.begin(); + p != this->target_symbols_.end(); + ++p) + { + (*p)->set_dynsym_index(index); + ++index; + syms->push_back(*p); + dynpool->add((*p)->name(), false, NULL); + } + return index; } @@ -2604,6 +2669,14 @@ Symbol_table::sized_finalize(off_t off, Stringpool* pool, this->add_to_final_symtab(sym, pool, &index, &off); } + // Now do target-specific symbols. + for (std::vector::iterator p = this->target_symbols_.begin(); + p != this->target_symbols_.end(); + ++p) + { + this->add_to_final_symtab(*p, pool, &index, &off); + } + this->output_count_ = index - orig_index; return off; @@ -3073,6 +3146,54 @@ Symbol_table::sized_write_globals(const Stringpool* sympool, } } + // Write the target-specific symbols. + for (std::vector::const_iterator p = this->target_symbols_.begin(); + p != this->target_symbols_.end(); + ++p) + { + Sized_symbol* sym = static_cast*>(*p); + + unsigned int sym_index = sym->symtab_index(); + unsigned int dynsym_index; + if (dynamic_view == NULL) + dynsym_index = -1U; + else + dynsym_index = sym->dynsym_index(); + + unsigned int shndx; + switch (sym->source()) + { + case Symbol::IS_CONSTANT: + shndx = elfcpp::SHN_ABS; + break; + case Symbol::IS_UNDEFINED: + shndx = elfcpp::SHN_UNDEF; + break; + default: + gold_unreachable(); + } + + if (sym_index != -1U) + { + sym_index -= first_global_index; + gold_assert(sym_index < output_count); + unsigned char* ps = psyms + (sym_index * sym_size); + this->sized_write_symbol(sym, sym->value(), shndx, + sym->binding(), sympool, + ps); + } + + if (dynsym_index != -1U) + { + dynsym_index -= first_dynamic_global_index; + gold_assert(dynsym_index < dynamic_count); + unsigned char* pd = dynamic_view + (dynsym_index * sym_size); + this->sized_write_symbol(sym, sym->value(), shndx, + sym->binding(), dynpool, + pd); + } + } + of->write_output_view(this->offset_, oview_size, psyms); if (dynamic_view != NULL) of->write_output_view(this->dynamic_offset_, dynamic_size, dynamic_view); @@ -3103,10 +3224,7 @@ Symbol_table::sized_write_symbol( else osym.put_st_size(sym->symsize()); elfcpp::STT type = sym->type(); - // Turn IFUNC symbols from shared libraries into normal FUNC symbols. - if (type == elfcpp::STT_GNU_IFUNC - && sym->is_from_dynobj()) - type = elfcpp::STT_FUNC; + gold_assert(type != elfcpp::STT_GNU_IFUNC || !sym->is_from_dynobj()); // A version script may have overridden the default binding. if (sym->is_forced_local()) osym.put_st_info(elfcpp::elf_st_info(elfcpp::STB_LOCAL, type)); @@ -3714,6 +3832,21 @@ Sized_symbol<32>::init_output_data(const char* name, const char* version, unsigned char nonvis, bool offset_is_from_end, bool is_predefined); + +template +void +Sized_symbol<32>::init_constant(const char* name, const char* version, + Value_type value, Size_type symsize, + elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, unsigned char nonvis, + bool is_predefined); + +template +void +Sized_symbol<32>::init_undefined(const char* name, const char* version, + Value_type value, elfcpp::STT type, + elfcpp::STB binding, elfcpp::STV visibility, + unsigned char nonvis); #endif #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) @@ -3727,6 +3860,21 @@ Sized_symbol<64>::init_output_data(const char* name, const char* version, unsigned char nonvis, bool offset_is_from_end, bool is_predefined); + +template +void +Sized_symbol<64>::init_constant(const char* name, const char* version, + Value_type value, Size_type symsize, + elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, unsigned char nonvis, + bool is_predefined); + +template +void +Sized_symbol<64>::init_undefined(const char* name, const char* version, + Value_type value, elfcpp::STT type, + elfcpp::STB binding, elfcpp::STV visibility, + unsigned char nonvis); #endif #ifdef HAVE_TARGET_32_LITTLE