X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gold%2Fsymtab.cc;h=7258ae4579e4c608e044fd3e88b1b80be55d5fa0;hb=53d25da64b00c1cf7f10d04785d66fa003f8bfc9;hp=24430237d62865b7ef9544916517df8d9c54cb6c;hpb=3728821ffcf74858b028948e224e1dc4695d9112;p=deliverable%2Fbinutils-gdb.git diff --git a/gold/symtab.cc b/gold/symtab.cc index 24430237d6..7258ae4579 100644 --- a/gold/symtab.cc +++ b/gold/symtab.cc @@ -1,6 +1,6 @@ // symtab.cc -- the gold symbol table -// Copyright 2006, 2007 Free Software Foundation, Inc. +// Copyright 2006, 2007, 2008 Free Software Foundation, Inc. // Written by Ian Lance Taylor . // This file is part of gold. @@ -26,6 +26,7 @@ #include #include #include +#include "demangle.h" #include "object.h" #include "dwarf_reader.h" @@ -69,7 +70,33 @@ Symbol::init_fields(const char* name, const char* version, this->has_plt_offset_ = false; this->has_warning_ = false; this->is_copied_from_dynobj_ = false; - this->needs_value_in_got_ = false; + this->is_forced_local_ = false; +} + +// Return the demangled version of the symbol's name, but only +// if the --demangle flag was set. + +static std::string +demangle(const char* name) +{ + if (!parameters->demangle()) + return name; + + // cplus_demangle allocates memory for the result it returns, + // and returns NULL if the name is already demangled. + char* demangled_name = cplus_demangle(name, DMGL_ANSI | DMGL_PARAMS); + if (demangled_name == NULL) + return name; + + std::string retval(demangled_name); + free(demangled_name); + return retval; +} + +std::string +Symbol::demangled_name() const +{ + return demangle(this->name()); } // Initialize the fields in the base class Symbol for SYM in OBJECT. @@ -132,6 +159,17 @@ Symbol::init_base(const char* name, elfcpp::STT type, this->in_reg_ = true; } +// Allocate a common symbol in the base. + +void +Symbol::allocate_base_common(Output_data* od) +{ + gold_assert(this->is_common()); + this->source_ = IN_OUTPUT_DATA; + this->u_.in_output_data.output_data = od; + this->u_.in_output_data.offset_is_from_end = false; +} + // Initialize the fields in Sized_symbol for SYM in OBJECT. template @@ -192,6 +230,16 @@ Sized_symbol::init(const char* name, Value_type value, Size_type symsize, this->symsize_ = symsize; } +// Allocate a common symbol. + +template +void +Sized_symbol::allocate_common(Output_data* od, Value_type value) +{ + this->allocate_base_common(od); + this->value_ = value; +} + // Return true if this symbol should be added to the dynamic symbol // table. @@ -202,6 +250,10 @@ Symbol::should_add_dynsym_entry() const if (this->needs_dynsym_entry()) return true; + // If the symbol was forced local in a version script, do not add it. + if (this->is_forced_local()) + return false; + // If exporting all symbols or building a shared library, // and the symbol is defined in a regular object and is // externally visible, we need to add it. @@ -248,37 +300,38 @@ Symbol::final_value_is_known() const // Class Symbol_table. -Symbol_table::Symbol_table() - : saw_undefined_(0), offset_(0), table_(), namepool_(), - forwarders_(), commons_(), warnings_() +Symbol_table::Symbol_table(unsigned int count, + const Version_script_info& version_script) + : saw_undefined_(0), offset_(0), table_(count), namepool_(), + forwarders_(), commons_(), forced_locals_(), warnings_(), + version_script_(version_script) { + namepool_.reserve(count); } Symbol_table::~Symbol_table() { } -// The hash function. The key is always canonicalized, so we use a -// simple combination of the pointers. +// The hash function. The key values are Stringpool keys. -size_t +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 only called with -// canonicalized name and version strings, so we can use pointer -// comparison. +// The symbol table key equality function. This is called with +// Stringpool keys. -bool +inline bool Symbol_table::Symbol_table_eq::operator()(const Symbol_table_key& k1, const Symbol_table_key& k2) const { return k1.first == k2.first && k1.second == k2.second; } -// Make TO a symbol which forwards to FROM. +// Make TO a symbol which forwards to FROM. void Symbol_table::make_forwarder(Symbol* from, Symbol* to) @@ -352,6 +405,22 @@ Symbol_table::resolve(Sized_symbol* to, const Sized_symbol* from, to->set_in_dyn(); } +// Record that a symbol is forced to be local by a version script. + +void +Symbol_table::force_local(Symbol* sym) +{ + if (!sym->is_defined() && !sym->is_common()) + return; + if (sym->is_forced_local()) + { + // We already got this one. + return; + } + sym->set_is_forced_local(); + this->forced_locals_.push_back(sym); +} + // Add one symbol from OBJECT to the symbol table. NAME is symbol // name and VERSION is the version; both are canonicalized. DEF is // whether this is the default version. @@ -434,10 +503,18 @@ Symbol_table::add_from_object(Object* object, // NAME/NULL point to NAME/VERSION. insdef.first->second = ret; } - else if (insdef.first->second != ret) + else if (insdef.first->second != ret + && insdef.first->second->is_undefined()) { // This is the unfortunate case where we already have - // entries for both NAME/VERSION and NAME/NULL. + // entries for both NAME/VERSION and NAME/NULL. Note + // that we don't want to combine them if the existing + // symbol is going to override the new one. FIXME: We + // currently just test is_undefined, but this may not do + // the right thing if the existing symbol is from a + // shared library and the new one is from a regular + // object. + const Sized_symbol* sym2; sym2 = this->get_sized_symbol SELECT_SIZE_NAME(size) ( insdef.first->second @@ -517,6 +594,7 @@ Symbol_table::add_from_object(Object* object, if (!was_common && ret->is_common()) this->commons_.push_back(ret); + ret->set_is_default(def); return ret; } @@ -572,6 +650,37 @@ Symbol_table::add_from_relobj( // name from the version name. If there are two '@' characters, // this is the default version. const char* ver = strchr(name, '@'); + int namelen = 0; + // DEF: is the version default? LOCAL: is the symbol forced local? + bool def = false; + bool local = false; + + if (ver != NULL) + { + // The symbol name is of the form foo@VERSION or foo@@VERSION + namelen = ver - name; + ++ver; + if (*ver == '@') + { + def = true; + ++ver; + } + } + else if (!version_script_.empty()) + { + // The symbol name did not have a version, but + // the version script may assign a version anyway. + namelen = strlen(name); + def = true; + // Check the global: entries from the version script. + const std::string& version = + version_script_.get_symbol_version(name); + if (!version.empty()) + ver = version.c_str(); + // Check the local: entries from the version script + if (version_script_.symbol_is_local(name)) + local = true; + } Sized_symbol* res; if (ver == NULL) @@ -580,20 +689,14 @@ Symbol_table::add_from_relobj( name = this->namepool_.add(name, true, &name_key); res = this->add_from_object(relobj, name, name_key, NULL, 0, false, *psym, sym); + if (local) + this->force_local(res); } else { Stringpool::Key name_key; - name = this->namepool_.add_prefix(name, ver - name, &name_key); - - bool def = false; - ++ver; - if (*ver == '@') - { - def = true; - ++ver; - } - + name = this->namepool_.add_with_length(name, namelen, true, + &name_key); Stringpool::Key ver_key; ver = this->namepool_.add(ver, true, &ver_key); @@ -846,6 +949,15 @@ Symbol_table::define_special_symbol(const Target* target, const char** pname, bool add_to_table = false; typename Symbol_table_type::iterator add_loc = this->table_.end(); + // If the caller didn't give us a version, see if we get one from + // the version script. + if (*pversion == NULL) + { + const std::string& v(this->version_script_.get_symbol_version(*pname)); + if (!v.empty()) + *pversion = v.c_str(); + } + if (only_if_ref) { oldsym = this->lookup(*pname, *pversion); @@ -1001,11 +1113,18 @@ Symbol_table::do_define_in_output_data( sym->init(name, od, value, symsize, type, binding, visibility, nonvis, offset_is_from_end); - if (oldsym != NULL - && Symbol_table::should_override_with_special(oldsym)) - this->override_with_special(oldsym, sym); + if (oldsym == NULL) + { + if (binding == elfcpp::STB_LOCAL + || this->version_script_.symbol_is_local(name)) + this->force_local(sym); + return sym; + } - return sym; + if (Symbol_table::should_override_with_special(oldsym)) + this->override_with_special(oldsym, sym); + delete sym; + return oldsym; } // Define a symbol based on an Output_segment. @@ -1095,11 +1214,18 @@ Symbol_table::do_define_in_output_segment( sym->init(name, os, value, symsize, type, binding, visibility, nonvis, offset_base); - if (oldsym != NULL - && Symbol_table::should_override_with_special(oldsym)) - this->override_with_special(oldsym, sym); + if (oldsym == NULL) + { + if (binding == elfcpp::STB_LOCAL + || this->version_script_.symbol_is_local(name)) + this->force_local(sym); + return sym; + } - return sym; + if (Symbol_table::should_override_with_special(oldsym)) + this->override_with_special(oldsym, sym); + delete sym; + return oldsym; } // Define a special symbol with a constant value. It is a multiple @@ -1179,14 +1305,21 @@ Symbol_table::do_define_as_constant( if (sym == NULL) return NULL; - gold_assert(version == NULL || oldsym != NULL); + gold_assert(version == NULL || version == name || oldsym != NULL); sym->init(name, value, symsize, type, binding, visibility, nonvis); - if (oldsym != NULL - && Symbol_table::should_override_with_special(oldsym)) - this->override_with_special(oldsym, sym); + if (oldsym == NULL) + { + if (binding == elfcpp::STB_LOCAL + || this->version_script_.symbol_is_local(name)) + this->force_local(sym); + return sym; + } - return sym; + if (Symbol_table::should_override_with_special(oldsym)) + this->override_with_special(oldsym, sym); + delete sym; + return oldsym; } // Define a set of symbols in output sections. @@ -1239,9 +1372,11 @@ Symbol_table::define_symbols(const Layout* layout, const Target* target, template void -Symbol_table::define_with_copy_reloc(const Target* target, - Sized_symbol* csym, - Output_data* posd, uint64_t value) +Symbol_table::define_with_copy_reloc( + const Target* target, + Sized_symbol* csym, + Output_data* posd, + typename elfcpp::Elf_types::Elf_Addr value) { gold_assert(csym->is_from_dynobj()); gold_assert(!csym->is_copied_from_dynobj()); @@ -1329,8 +1464,8 @@ Symbol_table::set_dynsym_indexes(const Target* target, dynpool->add(sym->name(), false, NULL); // Record any version information. - if (sym->version() != NULL) - versions->record_version(this, dynpool, sym); + if (sym->version() != NULL) + versions->record_version(this, dynpool, sym); } } @@ -1342,18 +1477,19 @@ Symbol_table::set_dynsym_indexes(const Target* target, } // Set the final values for all the symbols. The index of the first -// global symbol in the output file is INDEX. Record the file offset -// OFF. Add their names to POOL. Return the new file offset. +// global symbol in the output file is *PLOCAL_SYMCOUNT. Record the +// file offset OFF. Add their names to POOL. Return the new file +// offset. Update *PLOCAL_SYMCOUNT if necessary. off_t -Symbol_table::finalize(unsigned int index, off_t off, off_t dynoff, - size_t dyn_global_index, size_t dyncount, - Stringpool* pool) +Symbol_table::finalize(off_t off, off_t dynoff, size_t dyn_global_index, + size_t dyncount, Stringpool* pool, + unsigned int *plocal_symcount) { off_t ret; - gold_assert(index != 0); - this->first_global_index_ = index; + gold_assert(*plocal_symcount != 0); + this->first_global_index_ = *plocal_symcount; this->dynamic_offset_ = dynoff; this->first_dynamic_global_index_ = dyn_global_index; @@ -1362,7 +1498,7 @@ Symbol_table::finalize(unsigned int index, off_t off, off_t dynoff, if (parameters->get_size() == 32) { #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_32_LITTLE) - ret = this->sized_finalize<32>(index, off, pool); + ret = this->sized_finalize<32>(off, pool, plocal_symcount); #else gold_unreachable(); #endif @@ -1370,7 +1506,7 @@ Symbol_table::finalize(unsigned int index, off_t off, off_t dynoff, else if (parameters->get_size() == 64) { #if defined(HAVE_TARGET_64_BIG) || defined(HAVE_TARGET_64_LITTLE) - ret = this->sized_finalize<64>(index, off, pool); + ret = this->sized_finalize<64>(off, pool, plocal_symcount); #else gold_unreachable(); #endif @@ -1385,146 +1521,188 @@ Symbol_table::finalize(unsigned int index, off_t off, off_t dynoff, return ret; } +// SYM is going into the symbol table at *PINDEX. Add the name to +// POOL, update *PINDEX and *POFF. + +template +void +Symbol_table::add_to_final_symtab(Symbol* sym, Stringpool* pool, + unsigned int* pindex, off_t* poff) +{ + sym->set_symtab_index(*pindex); + pool->add(sym->name(), false, NULL); + ++*pindex; + *poff += elfcpp::Elf_sizes::sym_size; +} + // Set the final value for all the symbols. This is called after // Layout::finalize, so all the output sections have their final // address. template off_t -Symbol_table::sized_finalize(unsigned index, off_t off, Stringpool* pool) +Symbol_table::sized_finalize(off_t off, Stringpool* pool, + unsigned int* plocal_symcount) { off = align_address(off, size >> 3); this->offset_ = off; - size_t orig_index = index; + unsigned int index = *plocal_symcount; + const unsigned int orig_index = index; - const int sym_size = elfcpp::Elf_sizes::sym_size; + // First do all the symbols which have been forced to be local, as + // they must appear before all global symbols. + for (Forced_locals::iterator p = this->forced_locals_.begin(); + p != this->forced_locals_.end(); + ++p) + { + Symbol* sym = *p; + gold_assert(sym->is_forced_local()); + if (this->sized_finalize_symbol(sym)) + { + this->add_to_final_symtab(sym, pool, &index, &off); + ++*plocal_symcount; + } + } + + // Now do all the remaining symbols. for (Symbol_table_type::iterator p = this->table_.begin(); p != this->table_.end(); ++p) { - Sized_symbol* sym = static_cast*>(p->second); + Symbol* sym = p->second; + if (this->sized_finalize_symbol(sym)) + this->add_to_final_symtab(sym, pool, &index, &off); + } - // FIXME: Here we need to decide which symbols should go into - // the output file, based on --strip. + this->output_count_ = index - orig_index; - // The default version of a symbol may appear twice in the - // symbol table. We only need to finalize it once. - if (sym->has_symtab_index()) - continue; + return off; +} - if (!sym->in_reg()) - { - gold_assert(!sym->has_symtab_index()); - sym->set_symtab_index(-1U); - gold_assert(sym->dynsym_index() == -1U); - continue; - } +// Finalize the symbol SYM. This returns true if the symbol should be +// added to the symbol table, false otherwise. - typename Sized_symbol::Value_type value; +template +bool +Symbol_table::sized_finalize_symbol(Symbol* unsized_sym) +{ + Sized_symbol* sym = static_cast*>(unsized_sym); - switch (sym->source()) - { - case Symbol::FROM_OBJECT: - { - unsigned int shndx = sym->shndx(); + // The default version of a symbol may appear twice in the symbol + // table. We only need to finalize it once. + if (sym->has_symtab_index()) + return false; - // FIXME: We need some target specific support here. - if (shndx >= elfcpp::SHN_LORESERVE - && shndx != elfcpp::SHN_ABS) - { - gold_error(_("%s: unsupported symbol section 0x%x"), - sym->name(), shndx); - shndx = elfcpp::SHN_UNDEF; - } + if (!sym->in_reg()) + { + gold_assert(!sym->has_symtab_index()); + sym->set_symtab_index(-1U); + gold_assert(sym->dynsym_index() == -1U); + return false; + } - Object* symobj = sym->object(); - if (symobj->is_dynamic()) - { - value = 0; - shndx = elfcpp::SHN_UNDEF; - } - else if (shndx == elfcpp::SHN_UNDEF) - value = 0; - else if (shndx == elfcpp::SHN_ABS) - value = sym->value(); - else - { - Relobj* relobj = static_cast(symobj); - off_t secoff; - Output_section* os = relobj->output_section(shndx, &secoff); + typename Sized_symbol::Value_type value; - if (os == NULL) - { - sym->set_symtab_index(-1U); - gold_assert(sym->dynsym_index() == -1U); - continue; - } + switch (sym->source()) + { + case Symbol::FROM_OBJECT: + { + unsigned int shndx = sym->shndx(); - value = sym->value() + os->address() + secoff; - } + // FIXME: We need some target specific support here. + if (shndx >= elfcpp::SHN_LORESERVE + && shndx != elfcpp::SHN_ABS) + { + gold_error(_("%s: unsupported symbol section 0x%x"), + sym->demangled_name().c_str(), shndx); + shndx = elfcpp::SHN_UNDEF; } - break; - case Symbol::IN_OUTPUT_DATA: + Object* symobj = sym->object(); + if (symobj->is_dynamic()) { - Output_data* od = sym->output_data(); - value = sym->value() + od->address(); - if (sym->offset_is_from_end()) - value += od->data_size(); + value = 0; + shndx = elfcpp::SHN_UNDEF; } - break; - - case Symbol::IN_OUTPUT_SEGMENT: + else if (shndx == elfcpp::SHN_UNDEF) + value = 0; + else if (shndx == elfcpp::SHN_ABS) + value = sym->value(); + else { - Output_segment* os = sym->output_segment(); - value = sym->value() + os->vaddr(); - switch (sym->offset_base()) + Relobj* relobj = static_cast(symobj); + section_offset_type secoff; + Output_section* os = relobj->output_section(shndx, &secoff); + + if (os == NULL) { - case Symbol::SEGMENT_START: - break; - case Symbol::SEGMENT_END: - value += os->memsz(); - break; - case Symbol::SEGMENT_BSS: - value += os->filesz(); - break; - default: - gold_unreachable(); + sym->set_symtab_index(-1U); + gold_assert(sym->dynsym_index() == -1U); + return false; } + + if (sym->type() == elfcpp::STT_TLS) + value = sym->value() + os->tls_offset() + secoff; + else + value = sym->value() + os->address() + secoff; } - break; + } + break; + + case Symbol::IN_OUTPUT_DATA: + { + Output_data* od = sym->output_data(); + value = sym->value() + od->address(); + if (sym->offset_is_from_end()) + value += od->data_size(); + } + break; + + case Symbol::IN_OUTPUT_SEGMENT: + { + Output_segment* os = sym->output_segment(); + value = sym->value() + os->vaddr(); + switch (sym->offset_base()) + { + case Symbol::SEGMENT_START: + break; + case Symbol::SEGMENT_END: + value += os->memsz(); + break; + case Symbol::SEGMENT_BSS: + value += os->filesz(); + break; + default: + gold_unreachable(); + } + } + break; - case Symbol::CONSTANT: - value = sym->value(); - break; + case Symbol::CONSTANT: + value = sym->value(); + break; - default: - gold_unreachable(); - } + default: + gold_unreachable(); + } - sym->set_value(value); + sym->set_value(value); - if (parameters->strip_all()) - sym->set_symtab_index(-1U); - else - { - sym->set_symtab_index(index); - pool->add(sym->name(), false, NULL); - ++index; - off += sym_size; - } + if (parameters->strip_all()) + { + sym->set_symtab_index(-1U); + return false; } - this->output_count_ = index - orig_index; - - return off; + return true; } // Write out the global symbols. void -Symbol_table::write_globals(const Target* target, const Stringpool* sympool, +Symbol_table::write_globals(const Input_objects* input_objects, + const Stringpool* sympool, const Stringpool* dynpool, Output_file* of) const { if (parameters->get_size() == 32) @@ -1532,7 +1710,8 @@ Symbol_table::write_globals(const Target* target, const Stringpool* sympool, if (parameters->is_big_endian()) { #ifdef HAVE_TARGET_32_BIG - this->sized_write_globals<32, true>(target, sympool, dynpool, of); + this->sized_write_globals<32, true>(input_objects, sympool, + dynpool, of); #else gold_unreachable(); #endif @@ -1540,7 +1719,8 @@ Symbol_table::write_globals(const Target* target, const Stringpool* sympool, else { #ifdef HAVE_TARGET_32_LITTLE - this->sized_write_globals<32, false>(target, sympool, dynpool, of); + this->sized_write_globals<32, false>(input_objects, sympool, + dynpool, of); #else gold_unreachable(); #endif @@ -1551,7 +1731,8 @@ Symbol_table::write_globals(const Target* target, const Stringpool* sympool, if (parameters->is_big_endian()) { #ifdef HAVE_TARGET_64_BIG - this->sized_write_globals<64, true>(target, sympool, dynpool, of); + this->sized_write_globals<64, true>(input_objects, sympool, + dynpool, of); #else gold_unreachable(); #endif @@ -1559,7 +1740,8 @@ Symbol_table::write_globals(const Target* target, const Stringpool* sympool, else { #ifdef HAVE_TARGET_64_LITTLE - this->sized_write_globals<64, false>(target, sympool, dynpool, of); + this->sized_write_globals<64, false>(input_objects, sympool, + dynpool, of); #else gold_unreachable(); #endif @@ -1573,52 +1755,38 @@ Symbol_table::write_globals(const Target* target, const Stringpool* sympool, template void -Symbol_table::sized_write_globals(const Target* target, +Symbol_table::sized_write_globals(const Input_objects* input_objects, const Stringpool* sympool, const Stringpool* dynpool, Output_file* of) const { + const Target* const target = input_objects->target(); + const int sym_size = elfcpp::Elf_sizes::sym_size; - unsigned int index = this->first_global_index_; - const off_t oview_size = this->output_count_ * sym_size; + + const unsigned int output_count = this->output_count_; + const section_size_type oview_size = output_count * sym_size; + const unsigned int first_global_index = this->first_global_index_; unsigned char* const psyms = of->get_output_view(this->offset_, oview_size); - unsigned int dynamic_count = this->dynamic_count_; - off_t dynamic_size = dynamic_count * sym_size; - unsigned int first_dynamic_global_index = this->first_dynamic_global_index_; + const unsigned int dynamic_count = this->dynamic_count_; + const section_size_type dynamic_size = dynamic_count * sym_size; + const unsigned int first_dynamic_global_index = + this->first_dynamic_global_index_; unsigned char* dynamic_view; if (this->dynamic_offset_ == 0) dynamic_view = NULL; else dynamic_view = of->get_output_view(this->dynamic_offset_, dynamic_size); - unsigned char* ps = psyms; for (Symbol_table_type::const_iterator p = this->table_.begin(); p != this->table_.end(); ++p) { Sized_symbol* sym = static_cast*>(p->second); - // Optionally check for unresolved symbols in shared libraries. - // This is controlled by the --allow-shlib-undefined option. We - // only warn about libraries for which we have seen all the - // DT_NEEDED entries. We don't try to track down DT_NEEDED - // entries which were not seen in this link. If we didn't see a - // DT_NEEDED entry, we aren't going to be able to reliably - // report whether the symbol is undefined. - if (sym->source() == Symbol::FROM_OBJECT - && sym->object()->is_dynamic() - && sym->shndx() == elfcpp::SHN_UNDEF - && sym->binding() != elfcpp::STB_WEAK - && !parameters->allow_shlib_undefined() - && !target->is_always_defined(sym)) - { - // A very ugly cast. - Dynobj* dynobj = static_cast(sym->object()); - if (!dynobj->has_unknown_needed_entries()) - gold_error(_("%s: undefined reference to '%s'"), - sym->object()->name().c_str(), sym->name()); - } + // Possibly warn about unresolved symbols in shared libraries. + this->warn_about_undefined_dynobj_symbol(input_objects, sym); unsigned int sym_index = sym->symtab_index(); unsigned int dynsym_index; @@ -1633,18 +1801,6 @@ Symbol_table::sized_write_globals(const Target* target, continue; } - if (sym_index == index) - ++index; - else if (sym_index != -1U) - { - // We have already seen this symbol, because it has a - // default version. - gold_assert(sym_index < index); - if (dynsym_index == -1U) - continue; - sym_index = -1U; - } - unsigned int shndx; typename elfcpp::Elf_types<32>::Elf_Addr value = sym->value(); switch (sym->source()) @@ -1658,7 +1814,7 @@ Symbol_table::sized_write_globals(const Target* target, && in_shndx != elfcpp::SHN_ABS) { gold_error(_("%s: unsupported symbol section 0x%x"), - sym->name(), in_shndx); + sym->demangled_name().c_str(), in_shndx); shndx = in_shndx; } else @@ -1676,7 +1832,7 @@ Symbol_table::sized_write_globals(const Target* target, else { Relobj* relobj = static_cast(symobj); - off_t secoff; + section_offset_type secoff; Output_section* os = relobj->output_section(in_shndx, &secoff); gold_assert(os != NULL); @@ -1704,10 +1860,12 @@ Symbol_table::sized_write_globals(const Target* target, 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 SELECT_SIZE_ENDIAN_NAME(size, big_endian) ( sym, sym->value(), shndx, sympool, ps SELECT_SIZE_ENDIAN(size, big_endian)); - ps += sym_size; } if (dynsym_index != -1U) @@ -1721,8 +1879,6 @@ Symbol_table::sized_write_globals(const Target* target, } } - gold_assert(ps - psyms == oview_size); - of->write_output_view(this->offset_, oview_size, psyms); if (dynamic_view != NULL) of->write_output_view(this->dynamic_offset_, dynamic_size, dynamic_view); @@ -1745,11 +1901,52 @@ Symbol_table::sized_write_symbol( osym.put_st_name(pool->get_offset(sym->name())); osym.put_st_value(value); osym.put_st_size(sym->symsize()); - osym.put_st_info(elfcpp::elf_st_info(sym->binding(), sym->type())); + // 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, sym->type())); + else + osym.put_st_info(elfcpp::elf_st_info(sym->binding(), sym->type())); osym.put_st_other(elfcpp::elf_st_other(sym->visibility(), sym->nonvis())); osym.put_st_shndx(shndx); } +// Check for unresolved symbols in shared libraries. This is +// controlled by the --allow-shlib-undefined option. + +// We only warn about libraries for which we have seen all the +// DT_NEEDED entries. We don't try to track down DT_NEEDED entries +// which were not seen in this link. If we didn't see a DT_NEEDED +// entry, we aren't going to be able to reliably report whether the +// symbol is undefined. + +// We also don't warn about libraries found in the system library +// directory (the directory were we find libc.so); we assume that +// those libraries are OK. This heuristic avoids problems in +// GNU/Linux, in which -ldl can have undefined references satisfied by +// ld-linux.so. + +inline void +Symbol_table::warn_about_undefined_dynobj_symbol( + const Input_objects* input_objects, + Symbol* sym) const +{ + if (sym->source() == Symbol::FROM_OBJECT + && sym->object()->is_dynamic() + && sym->shndx() == elfcpp::SHN_UNDEF + && sym->binding() != elfcpp::STB_WEAK + && !parameters->allow_shlib_undefined() + && !input_objects->target()->is_defined_by_abi(sym) + && !input_objects->found_in_system_library_directory(sym->object())) + { + // A very ugly cast. + Dynobj* dynobj = static_cast(sym->object()); + if (!dynobj->has_unknown_needed_entries()) + gold_error(_("%s: undefined reference to '%s'"), + sym->object()->name().c_str(), + sym->demangled_name().c_str()); + } +} + // Write out a section symbol. Return the update offset. void @@ -1823,11 +2020,55 @@ Symbol_table::sized_write_section_symbol(const Output_section* os, of->write_output_view(offset, sym_size, pov); } +// Print statistical information to stderr. This is used for --stats. + +void +Symbol_table::print_stats() const +{ +#if defined(HAVE_TR1_UNORDERED_MAP) || defined(HAVE_EXT_HASH_MAP) + fprintf(stderr, _("%s: symbol table entries: %zu; buckets: %zu\n"), + program_name, this->table_.size(), this->table_.bucket_count()); +#else + fprintf(stderr, _("%s: symbol table entries: %zu\n"), + program_name, this->table_.size()); +#endif + this->namepool_.print_stats("symbol table stringpool"); +} + +// 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. + +// This struct is used to compare line information, as returned by +// Dwarf_line_info::one_addr2line. It implements a < comparison +// operator used with std::set. + +struct Odr_violation_compare +{ + 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; + } +}; + // Check candidate_odr_violations_ to find symbols with the same name // but apparently different definitions (different source-file/line-no). void -Symbol_table::detect_odr_violations() const +Symbol_table::detect_odr_violations(const Task* task, + const char* output_file_name) const { for (Odr_map::const_iterator it = candidate_odr_violations_.begin(); it != candidate_odr_violations_.end(); @@ -1835,29 +2076,31 @@ Symbol_table::detect_odr_violations() const { const char* symbol_name = it->first; // We use a sorted set so the output is deterministic. - std::set line_nums; + std::set line_nums; - Unordered_set::const_iterator - locs; - for (locs = it->second.begin(); locs != it->second.end(); ++locs) + for (Unordered_set::const_iterator + locs = it->second.begin(); + locs != it->second.end(); + ++locs) { // We need to lock the object in order to read it. This - // means that we can not run inside a Task. If we want to - // run this in a Task for better performance, we will need - // one Task for object, plus appropriate locking to ensure - // that we don't conflict with other uses of the object. - locs->object->lock(); + // means that we have to run in a singleton Task. If we + // want to run this in a general Task for better + // performance, we will need one Task for object, plus + // appropriate locking to ensure that we don't conflict with + // other uses of the object. + Task_lock_obj tl(task, locs->object); std::string lineno = Dwarf_line_info::one_addr2line( locs->object, locs->shndx, locs->offset); - locs->object->unlock(); if (!lineno.empty()) line_nums.insert(lineno); } if (line_nums.size() > 1) { - gold_warning(_("symbol %s defined in multiple places " - "(possible ODR violation):"), symbol_name); + 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::const_iterator it2 = line_nums.begin(); it2 != line_nums.end(); ++it2) @@ -1872,10 +2115,10 @@ Symbol_table::detect_odr_violations() const void Warnings::add_warning(Symbol_table* symtab, const char* name, Object* obj, - unsigned int shndx) + const std::string& warning) { name = symtab->canonicalize_name(name); - this->warnings_[name].set(obj, shndx); + this->warnings_[name].set(obj, warning); } // Look through the warnings and mark the symbols for which we should @@ -1893,24 +2136,7 @@ Warnings::note_warnings(Symbol_table* symtab) if (sym != NULL && sym->source() == Symbol::FROM_OBJECT && sym->object() == p->second.object) - { - sym->set_has_warning(); - - // Read the section contents to get the warning text. It - // would be nicer if we only did this if we have to actually - // issue a warning. Unfortunately, warnings are issued as - // we relocate sections. That means that we can not lock - // the object then, as we might try to issue the same - // warning multiple times simultaneously. - { - Task_locker_obj tl(*p->second.object); - const unsigned char* c; - off_t len; - c = p->second.object->section_contents(p->second.shndx, &len, - false); - p->second.set_text(reinterpret_cast(c), len); - } - } + sym->set_has_warning(); } } @@ -1934,6 +2160,18 @@ Warnings::issue_warning(const Symbol* sym, // script to restrict this to only the ones needed for implemented // targets. +#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) +template +void +Sized_symbol<32>::allocate_common(Output_data*, Value_type); +#endif + +#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) +template +void +Sized_symbol<64>::allocate_common(Output_data*, Value_type); +#endif + #ifdef HAVE_TARGET_32_LITTLE template void @@ -2041,17 +2279,21 @@ Symbol_table::add_from_dynobj<64, true>( #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) template void -Symbol_table::define_with_copy_reloc<32>(const Target* target, - Sized_symbol<32>* sym, - Output_data* posd, uint64_t value); +Symbol_table::define_with_copy_reloc<32>( + const Target* target, + Sized_symbol<32>* sym, + Output_data* posd, + elfcpp::Elf_types<32>::Elf_Addr value); #endif #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) template void -Symbol_table::define_with_copy_reloc<64>(const Target* target, - Sized_symbol<64>* sym, - Output_data* posd, uint64_t value); +Symbol_table::define_with_copy_reloc<64>( + const Target* target, + Sized_symbol<64>* sym, + Output_data* posd, + elfcpp::Elf_types<64>::Elf_Addr value); #endif #ifdef HAVE_TARGET_32_LITTLE