From d491d34e930046f820def9d3d67a2491df8a2198 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Sat, 19 Apr 2008 18:30:58 +0000 Subject: * object.cc (Xindex::initialize_symtab_xindex): New function. (Xindex::read_symtab_xindex): New function. (Xindex::sym_xindex_to_shndx): New function. (Sized_relobj::find_symtab): Pick up SHT_SYMTAB_SHNDX section if available. (Sized_relobj::do_initialize_xindex): New function. (Sized_relobj::do_read_symbols): Adjust section links. (Sized_relobj::symbol_section_and_value): Add is_ordinary parameter. Change all callers. (Sized_relobj::include_section_group): Adjust section links and symbol section indexes. (Sized_relobj::do_layout): Adjust section links. (Sized_relobj::do_count_local_symbols): Adjust section links and symbol section indexes. (Sized_relobj::do_finalize_local_symbols): Distinguish between ordinary and special symbols. (Sized_relobj::write_local_symbols): Add symtab_xindex and dynsym_xindex parameters. Change all callers. Adjust section links. Use SHN_XINDEX when needed. (Sized_relobj::get_symbol_location_info): Adjust section links. Don't get fooled by special symbols. * object.h (class Xindex): Define. (class Object): Add xindex_ parameter. Declare virtual functoin do_initialize_xindex. (Object::adjust_sym_shndx): New function. (Object::set_xindex): New protected function. (class Symbol_value): Add is_ordinary_shndx_ field. (Symbol_value::Symbol_value): Initialize is_ordinary_shndx_. (Symbol_value::value): Assert ordinary section. (Symbol_value::initialize_input_to_output_map): Likewise. (Symbol_value::set_input_shndx): Add is_ordinary parameter. Change all callers. (Symbol_value::input_shndx): Add is_ordinary parameter. Change all callers. (class Sized_relobj): Update declarations. (Sized_relobj::local_symbol_input_shndx): Add is_ordinary parameter. Change all callers. (Sized_relobj::adjust_shndx): New function. * dynobj.cc (Sized_dynobj::Sized_dynobj): Initialize dynsym_shndx_ field. (Sized_dynobj::find_dynsym_sections): Remove pdynsym_shndx parameter. Change all callers. Pick up SHT_DYNSYM_SHNDX section for SHT_DYNSYM section if available. Set dynsym_shndx_ field. (Sized_dynobj::read_dynsym_section): Adjust section links. (Sized_dynobj::read_dynamic): Likewise. (Sized_dynobj::do_read_symbols): Use dynsym_shndx_ field. Adjust section links. (Sized_dynobj::do_initialize_xindex): New function. * dynobj.h (class Sized_dynobj): Add dynsym_shndx_ field. Declare do_initialize_xindex. (Sized_dynobj::adjust_shndx): New function. * layout.cc (Layout::Layout): Initialize symtab_xindex_ and dynsym_xindex_ fields. (Layout::finalize): Add a call to set_section_indexes before creating the symtab sections. (Layout::set_section_indexes): Don't do anything if the section already has a section index. (Layout::create_symtab_sections): Add shnum parameter. Change caller. Create .symtab_shndx section if needed. (Layout::create_shdrs): Add shstrtab_section parameter. Change caller. (Layout::allocated_output_section_count): New function. (Layout::create_dynamic_symtab): Create .dynsym_shndx section if needed. * layout.h (class Layout): Add symtab_xindex_ and dynsym_xindex_ fields. Update declarations. (Layout::symtab_xindex): New function. (Layout::dynsym_xindex): New function. (class Write_symbols_task): Add layout_ field. (Write_symbols_task::Write_symbols_task): Add layout parameter. Change caller. * output.cc (Output_section_headers::Output_section_headers): Add shstrtab_section parameter. Change all callers. (Output_section_headers::do_sized_write): Store overflow values for section count and section string table section index in section header zero. (Output_file_header::do_sized_write): Check for overflow of section count and section string table section index. (Output_symtab_xindex::do_write): New function. (Output_symtab_xindex::endian_do_write): New function. * output.h (class Output_section_headers): Add shstrtab_section_. Update declarations. (class Output_symtab_xindex): Define. (Output_section::has_out_shndx): New function. * symtab.cc (Symbol::init_fields): Initialize is_ordinary_shndx_ field. (Symbol::init_base): Add st_shndx and is_ordinary parameters. Change all callers. (Sized_symbol::init): Likewise. (Symbol::output_section): Check for ordinary symbol. (Symbol_table::add_from_object): Remove orig_sym parameter. Add st_shndx, is_ordinary, and orig_st_shndx parameters. Change all callers. (Symbol_table::add_from_relobj): Add symndx_offset parameter. Change all callers. Simplify handling of symbols from sections not included in the link. (Symbol_table::add_from_dynobj): Handle ordinary symbol distinction. (Weak_alias_sorter::operator()): Assert that symbols are ordinary. (Symbol_table::sized_finalize_symbol): Handle ordinary symbol distinction. (Symbol_table::write_globals): Add symtab_xindex and dynsym_xindex parameters. Change all callers. (Symbol_table::sized_write_globals): Likewise. Handle ordinary symbol distinction. Use SHN_XINDEX when needed. (Symbol_table::write_section_symbol): Add symtab_xindex parameter. Change all callers. (Symbol_table::sized_write_section_symbol): Likewise. Use SHN_XINDEX when needed. * symtab.h (class Symbol): Add is_ordinary_shndx_ field. Update declarations. (Symbol::shndx): Add is_ordinary parameter. Change all callers. (Symbol::is_defined): Check is_ordinary. (Symbol::is_undefined, Symbol::is_weak_undefined): Likewise. (Symbol::is_absolute, Symbol::is_common): Likewise. (class Sized_symbol): Update declarations. (class Symbol_table): Update declarations. * resolve.cc (Symbol::override_base): Add st_shndx and is_ordinary parameters. Change all callers. (Sized_symbol::override): Likewise. (Symbol_table::override): Likewise. (symbol_to_bits): Add is_ordinary parameter. Change all callers. (Symbol_table::resolve): Remove orig_sym parameter. Add st_shndx, is_ordinary, and orig_st_shndx parameters. Change all callers. * copy-relocs.cc (Copy_relocs::emit_copy_reloc): Require symbol to be in an ordinary section. * dwarf_reader.cc (Sized_dwarf_line_info::symbol_section): Add object and is_ordinary parameters. Change all callers. (Sized_dwarf_line_info::read_relocs): Add object parameter. Change all callers. Don't add undefined or non-ordinary symbols to reloc_map_. (Sized_dwarf_line_info::read_line_mappings): Add object parameter. Change all callers. * dwarf_reader.h (class Sized_dwarf_line_info): Update declarations. * ehframe.cc (Eh_frame::read_fde): Check for ordinary symbol. * reloc.cc (Sized_relobj::do_read_relocs): Adjust section links. (Sized_relobj::relocate_sections): Likewise. * target-reloc.h (scan_relocs): Adjust section symbol index. (scan_relocatable_relocs): Likewise. * i386.cc (Scan::local): Check for ordinary symbols. * sparc.cc (Scan::local): Likewise. * x86_64.cc (Scan::local): Likewise. * testsuite/binary_unittest.cc (Sized_binary_test): Update calls to symbol_section_and_value. * testsuite/many_sections_test.cc: New file. * testsuite/Makefile.am (BUILT_SOURCES): Define. (check_PROGRAMS): Add many_sections_test. (many_sections_test_SOURCES): Define. (many_sections_test_DEPENDENCIES): Define. (many_sections_test_LDFLAGS): Define. (BUILT_SOURCES): Add many_sections_define.h. (many_sections_define.h): New target. (BUILT_SOURCES): Add many_sections_check.h. (many_sections_check.h): New target. (check_PROGRAMS): Add many_sections_r_test. (many_sections_r_test_SOURCES): Define. (many_sections_r_test_DEPENDENCIES): Define. (many_sections_r_test_LDFLAGS): Define. (many_sections_r_test_LDADD): Define. (many_sections_r_test.o): New target. * testsuite/Makefile.in: Rebuild. --- gold/resolve.cc | 91 +++++++++++++++++++++++++++++++++++---------------------- 1 file changed, 56 insertions(+), 35 deletions(-) (limited to 'gold/resolve.cc') diff --git a/gold/resolve.cc b/gold/resolve.cc index 00e9278..21a7fc6 100644 --- a/gold/resolve.cc +++ b/gold/resolve.cc @@ -37,6 +37,7 @@ namespace gold template void Symbol::override_base(const elfcpp::Sym& sym, + unsigned int st_shndx, bool is_ordinary, Object* object, const char* version) { gold_assert(this->source_ == FROM_OBJECT); @@ -46,8 +47,8 @@ Symbol::override_base(const elfcpp::Sym& sym, gold_assert(this->version() == NULL); this->version_ = version; } - // FIXME: Handle SHN_XINDEX. - this->u_.from_object.shndx = sym.get_st_shndx(); + this->u_.from_object.shndx = st_shndx; + this->is_ordinary_shndx_ = is_ordinary; this->type_ = sym.get_st_type(); this->binding_ = sym.get_st_bind(); this->visibility_ = sym.get_st_visibility(); @@ -64,9 +65,10 @@ template template void Sized_symbol::override(const elfcpp::Sym& sym, + unsigned st_shndx, bool is_ordinary, Object* object, const char* version) { - this->override_base(sym, object, version); + this->override_base(sym, st_shndx, is_ordinary, object, version); this->value_ = sym.get_st_value(); this->symsize_ = sym.get_st_size(); } @@ -78,9 +80,10 @@ template void Symbol_table::override(Sized_symbol* tosym, const elfcpp::Sym& fromsym, + unsigned int st_shndx, bool is_ordinary, Object* object, const char* version) { - tosym->override(fromsym, object, version); + tosym->override(fromsym, st_shndx, is_ordinary, object, version); if (tosym->has_alias()) { Symbol* sym = this->weak_aliases_[tosym]; @@ -88,7 +91,7 @@ Symbol_table::override(Sized_symbol* tosym, Sized_symbol* ssym = this->get_sized_symbol(sym); do { - ssym->override(fromsym, object, version); + ssym->override(fromsym, st_shndx, is_ordinary, object, version); sym = this->weak_aliases_[ssym]; gold_assert(sym != NULL); ssym = this->get_sized_symbol(sym); @@ -121,7 +124,7 @@ static const unsigned int common_flag = 2 << def_undef_or_common_shift; static unsigned int symbol_to_bits(elfcpp::STB binding, bool is_dynamic, - unsigned int shndx, elfcpp::STT type) + unsigned int shndx, bool is_ordinary, elfcpp::STT type) { unsigned int bits; @@ -160,7 +163,8 @@ symbol_to_bits(elfcpp::STB binding, bool is_dynamic, break; case elfcpp::SHN_COMMON: - bits |= common_flag; + if (!is_ordinary) + bits |= common_flag; break; default: @@ -175,17 +179,20 @@ symbol_to_bits(elfcpp::STB binding, bool is_dynamic, } // Resolve a symbol. This is called the second and subsequent times -// we see a symbol. TO is the pre-existing symbol. ORIG_SYM is the -// new symbol, seen in OBJECT. SYM is almost always identical to -// ORIG_SYM, but may be munged (for instance, if we determine the -// symbol is in a to-be-discarded section, we'll set sym's shndx to -// UNDEFINED). VERSION of the version of SYM. +// 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 +// non-ordinary section indexes are mapped to SHN_UNDEF. VERSION of +// the version of SYM. template void Symbol_table::resolve(Sized_symbol* to, const elfcpp::Sym& sym, - const elfcpp::Sym& orig_sym, + unsigned int st_shndx, bool is_ordinary, + unsigned int orig_st_shndx, Object* object, const char* version) { if (object->target()->has_resolve()) @@ -209,7 +216,7 @@ Symbol_table::resolve(Sized_symbol* to, unsigned int frombits = symbol_to_bits(sym.get_st_bind(), object->is_dynamic(), - sym.get_st_shndx(), + st_shndx, is_ordinary, sym.get_st_type()); bool adjust_common_sizes; @@ -218,7 +225,7 @@ Symbol_table::resolve(Sized_symbol* to, { typename Sized_symbol::Size_type tosize = to->symsize(); - this->override(to, sym, object, version); + this->override(to, sym, st_shndx, is_ordinary, object, version); if (adjust_common_sizes && tosize > to->symsize()) to->set_symsize(tosize); @@ -236,24 +243,25 @@ Symbol_table::resolve(Sized_symbol* to, // actually refer to the same lines of code. (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.) - // We use orig_sym here because we want the symbol exactly as it - // appears in the object file, not munged via our future processing. + bool to_is_ordinary; if (parameters->options().detect_odr_violations() - && orig_sym.get_st_bind() == elfcpp::STB_WEAK + && sym.get_st_bind() == elfcpp::STB_WEAK && to->binding() == elfcpp::STB_WEAK - && orig_sym.get_st_shndx() != elfcpp::SHN_UNDEF - && to->shndx() != elfcpp::SHN_UNDEF - && orig_sym.get_st_size() != 0 // Ignore weird 0-sized symbols. + && orig_st_shndx != elfcpp::SHN_UNDEF + && to->shndx(&to_is_ordinary) != elfcpp::SHN_UNDEF + && to_is_ordinary + && sym.get_st_size() != 0 // Ignore weird 0-sized symbols. && to->symsize() != 0 - && (orig_sym.get_st_type() != to->type() - || orig_sym.get_st_size() != to->symsize()) + && (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 - = { object, orig_sym.get_st_shndx(), orig_sym.get_st_value() }; - Symbol_location toloc = { to->object(), to->shndx(), to->value() }; + = { object, orig_st_shndx, sym.get_st_value() }; + Symbol_location toloc = { to->object(), to->shndx(&to_is_ordinary), + to->value() }; this->candidate_odr_violations_[to->name()].insert(fromloc); this->candidate_odr_violations_[to->name()].insert(toloc); } @@ -273,14 +281,19 @@ Symbol_table::should_override(const Symbol* to, unsigned int frombits, *adjust_common_sizes = false; unsigned int tobits; - if (to->source() == Symbol::FROM_OBJECT) - tobits = symbol_to_bits(to->binding(), - to->object()->is_dynamic(), - to->shndx(), + if (to->source() != Symbol::FROM_OBJECT) + tobits = symbol_to_bits(to->binding(), false, elfcpp::SHN_ABS, false, to->type()); else - tobits = symbol_to_bits(to->binding(), false, elfcpp::SHN_ABS, - to->type()); + { + bool is_ordinary; + unsigned int shndx = to->shndx(&is_ordinary); + tobits = symbol_to_bits(to->binding(), + to->object()->is_dynamic(), + shndx, + is_ordinary, + to->type()); + } // FIXME: Warn if either but not both of TO and SYM are STT_TLS. @@ -733,7 +746,9 @@ void Symbol_table::resolve<32, false>( Sized_symbol<32>* to, const elfcpp::Sym<32, false>& sym, - const elfcpp::Sym<32, false>& orig_sym, + unsigned int st_shndx, + bool is_ordinary, + unsigned int orig_st_shndx, Object* object, const char* version); #endif @@ -744,7 +759,9 @@ void Symbol_table::resolve<32, true>( Sized_symbol<32>* to, const elfcpp::Sym<32, true>& sym, - const elfcpp::Sym<32, true>& orig_sym, + unsigned int st_shndx, + bool is_ordinary, + unsigned int orig_st_shndx, Object* object, const char* version); #endif @@ -755,7 +772,9 @@ void Symbol_table::resolve<64, false>( Sized_symbol<64>* to, const elfcpp::Sym<64, false>& sym, - const elfcpp::Sym<64, false>& orig_sym, + unsigned int st_shndx, + bool is_ordinary, + unsigned int orig_st_shndx, Object* object, const char* version); #endif @@ -766,7 +785,9 @@ void Symbol_table::resolve<64, true>( Sized_symbol<64>* to, const elfcpp::Sym<64, true>& sym, - const elfcpp::Sym<64, true>& orig_sym, + unsigned int st_shndx, + bool is_ordinary, + unsigned int orig_st_shndx, Object* object, const char* version); #endif -- cgit v1.1