X-Git-Url: http://drtracing.org/?a=blobdiff_plain;ds=sidebyside;f=gold%2Fobject.cc;h=99c2ca7a7bee5bcac7312280ecdcd349a878385a;hb=40b2987463cd3792ba025dc2fbb8a640bb49f45a;hp=798e42d808d124398b40232a9e7a9e34b5767522;hpb=2ea97941102380c28117882600265c1187c6fc8b;p=deliverable%2Fbinutils-gdb.git diff --git a/gold/object.cc b/gold/object.cc index 798e42d808..99c2ca7a7b 100644 --- a/gold/object.cc +++ b/gold/object.cc @@ -1,6 +1,6 @@ // object.cc -- support for an object file for linking in gold -// 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 . // This file is part of gold. @@ -39,10 +39,34 @@ #include "object.h" #include "dynobj.h" #include "plugin.h" +#include "compressed_output.h" +#include "incremental.h" namespace gold { +// Struct Read_symbols_data. + +// Destroy any remaining File_view objects. + +Read_symbols_data::~Read_symbols_data() +{ + if (this->section_headers != NULL) + delete this->section_headers; + if (this->section_names != NULL) + delete this->section_names; + if (this->symbols != NULL) + delete this->symbols; + if (this->symbol_names != NULL) + delete this->symbol_names; + if (this->versym != NULL) + delete this->versym; + if (this->verdef != NULL) + delete this->verdef; + if (this->verneed != NULL) + delete this->verneed; +} + // Class Xindex. // Initialize the symtab_xindex_ array. Find the SHT_SYMTAB_SHNDX @@ -165,7 +189,7 @@ Object::section_contents(unsigned int shndx, section_size_type* plen, return this->get_view(loc.file_offset, *plen, true, cache); } -// Read the section data into SD. This is code common to Sized_relobj +// Read the section data into SD. This is code common to Sized_relobj_file // and Sized_dynobj, so we put it into Object. template @@ -232,7 +256,7 @@ Object::handle_gnu_warning_section(const char* name, unsigned int shndx, } // If NAME is the name of the special section which indicates that -// this object was compiled with -fstack-split, mark it accordingly. +// this object was compiled with -fsplit-stack, mark it accordingly. bool Object::handle_split_stack_section(const char* name) @@ -315,23 +339,70 @@ Relobj::is_section_name_included(const char* name) && strstr(name, "personality")) || (is_prefix_of(".data", name) && strstr(name, "personality")) - || (is_prefix_of(".gnu.linkonce.d", name) && - strstr(name, "personality"))) + || (is_prefix_of(".gnu.linkonce.d", name) + && strstr(name, "personality"))) { return true; } return false; } +// Finalize the incremental relocation information. Allocates a block +// of relocation entries for each symbol, and sets the reloc_bases_ +// array to point to the first entry in each block. If CLEAR_COUNTS +// is TRUE, also clear the per-symbol relocation counters. + +void +Relobj::finalize_incremental_relocs(Layout* layout, bool clear_counts) +{ + unsigned int nsyms = this->get_global_symbols()->size(); + this->reloc_bases_ = new unsigned int[nsyms]; + + gold_assert(this->reloc_bases_ != NULL); + gold_assert(layout->incremental_inputs() != NULL); + + unsigned int rindex = layout->incremental_inputs()->get_reloc_count(); + for (unsigned int i = 0; i < nsyms; ++i) + { + this->reloc_bases_[i] = rindex; + rindex += this->reloc_counts_[i]; + if (clear_counts) + this->reloc_counts_[i] = 0; + } + layout->incremental_inputs()->set_reloc_count(rindex); +} + // Class Sized_relobj. +// Iterate over local symbols, calling a visitor class V for each GOT offset +// associated with a local symbol. + +template +void +Sized_relobj::do_for_all_local_got_entries( + Got_offset_list::Visitor* v) const +{ + unsigned int nsyms = this->local_symbol_count(); + for (unsigned int i = 0; i < nsyms; i++) + { + Local_got_offsets::const_iterator p = this->local_got_offsets_.find(i); + if (p != this->local_got_offsets_.end()) + { + const Got_offset_list* got_offsets = p->second; + got_offsets->for_all_got_offsets(v); + } + } +} + +// Class Sized_relobj_file. + template -Sized_relobj::Sized_relobj( +Sized_relobj_file::Sized_relobj_file( const std::string& name, Input_file* input_file, off_t offset, const elfcpp::Ehdr& ehdr) - : Relobj(name, input_file, offset), + : Sized_relobj(name, input_file, offset), elf_file_(this, ehdr), symtab_shndx_(-1U), local_symbol_count_(0), @@ -342,15 +413,19 @@ Sized_relobj::Sized_relobj( local_symbol_offset_(0), local_dynsym_offset_(0), local_values_(), - local_got_offsets_(), + local_plt_offsets_(), kept_comdat_sections_(), has_eh_frame_(false), - discarded_eh_frame_shndx_(-1U) + discarded_eh_frame_shndx_(-1U), + deferred_layout_(), + deferred_layout_relocs_(), + compressed_sections_() { + this->e_type_ = ehdr.get_e_type(); } template -Sized_relobj::~Sized_relobj() +Sized_relobj_file::~Sized_relobj_file() { } @@ -359,7 +434,7 @@ Sized_relobj::~Sized_relobj() template void -Sized_relobj::do_setup() +Sized_relobj_file::do_setup() { const unsigned int shnum = this->elf_file_.shnum(); this->set_shnum(shnum); @@ -372,7 +447,7 @@ Sized_relobj::do_setup() template void -Sized_relobj::find_symtab(const unsigned char* pshdrs) +Sized_relobj_file::find_symtab(const unsigned char* pshdrs) { const unsigned int shnum = this->shnum(); this->symtab_shndx_ = 0; @@ -421,7 +496,7 @@ Sized_relobj::find_symtab(const unsigned char* pshdrs) template Xindex* -Sized_relobj::do_initialize_xindex() +Sized_relobj_file::do_initialize_xindex() { gold_assert(this->symtab_shndx_ != -1U); Xindex* xindex = new Xindex(this->elf_file_.large_shndx_offset()); @@ -434,10 +509,12 @@ Sized_relobj::do_initialize_xindex() template bool -Sized_relobj::check_eh_frame_flags( +Sized_relobj_file::check_eh_frame_flags( const elfcpp::Shdr* shdr) const { - return (shdr->get_sh_type() == elfcpp::SHT_PROGBITS + elfcpp::Elf_Word sh_type = shdr->get_sh_type(); + return ((sh_type == elfcpp::SHT_PROGBITS + || sh_type == elfcpp::SHT_X86_64_UNWIND) && (shdr->get_sh_flags() & elfcpp::SHF_ALLOC) != 0); } @@ -446,7 +523,7 @@ Sized_relobj::check_eh_frame_flags( template bool -Sized_relobj::find_eh_frame( +Sized_relobj_file::find_eh_frame( const unsigned char* pshdrs, const char* names, section_size_type names_size) const @@ -473,11 +550,55 @@ Sized_relobj::find_eh_frame( return false; } +// Build a table for any compressed debug sections, mapping each section index +// to the uncompressed size. + +template +Compressed_section_map* +build_compressed_section_map( + const unsigned char* pshdrs, + unsigned int shnum, + const char* names, + section_size_type names_size, + Sized_relobj_file* obj) +{ + Compressed_section_map* uncompressed_sizes = new Compressed_section_map(); + const unsigned int shdr_size = elfcpp::Elf_sizes::shdr_size; + const unsigned char* p = pshdrs + shdr_size; + for (unsigned int i = 1; i < shnum; ++i, p += shdr_size) + { + typename elfcpp::Shdr shdr(p); + if (shdr.get_sh_type() == elfcpp::SHT_PROGBITS + && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0) + { + if (shdr.get_sh_name() >= names_size) + { + obj->error(_("bad section name offset for section %u: %lu"), + i, static_cast(shdr.get_sh_name())); + continue; + } + + const char* name = names + shdr.get_sh_name(); + if (is_compressed_debug_section(name)) + { + section_size_type len; + const unsigned char* contents = + obj->section_contents(i, &len, false); + uint64_t uncompressed_size = get_uncompressed_size(contents, len); + if (uncompressed_size != -1ULL) + (*uncompressed_sizes)[i] = + convert_to_section_size_type(uncompressed_size); + } + } + } + return uncompressed_sizes; +} + // Read the sections and symbols from an object file. template void -Sized_relobj::do_read_symbols(Read_symbols_data* sd) +Sized_relobj_file::do_read_symbols(Read_symbols_data* sd) { this->read_section_data(&this->elf_file_, sd); @@ -492,6 +613,10 @@ Sized_relobj::do_read_symbols(Read_symbols_data* sd) if (this->find_eh_frame(pshdrs, names, sd->section_names_size)) this->has_eh_frame_ = true; } + if (memmem(names, sd->section_names_size, ".zdebug_", 8) != NULL) + this->compressed_sections_ = + build_compressed_section_map(pshdrs, this->shnum(), names, + sd->section_names_size, this); sd->symbols = NULL; sd->symbols_size = 0; @@ -569,16 +694,16 @@ Sized_relobj::do_read_symbols(Read_symbols_data* sd) // Return the section index of symbol SYM. Set *VALUE to its value in // the object file. Set *IS_ORDINARY if this is an ordinary section -// index. not a special cod between SHN_LORESERVE and SHN_HIRESERVE. +// index, not a special code between SHN_LORESERVE and SHN_HIRESERVE. // Note that for a symbol which is not defined in this object file, // this will set *VALUE to 0 and return SHN_UNDEF; it will not return // the final value of the symbol in the link. template unsigned int -Sized_relobj::symbol_section_and_value(unsigned int sym, - Address* value, - bool* is_ordinary) +Sized_relobj_file::symbol_section_and_value(unsigned int sym, + Address* value, + bool* is_ordinary) { section_size_type symbols_size; const unsigned char* symbols = this->section_contents(this->symtab_shndx_, @@ -602,7 +727,7 @@ Sized_relobj::symbol_section_and_value(unsigned int sym, template bool -Sized_relobj::include_section_group( +Sized_relobj_file::include_section_group( Symbol_table* symtab, Layout* layout, unsigned int index, @@ -624,10 +749,11 @@ Sized_relobj::include_section_group( // just like ordinary sections. elfcpp::Elf_Word flags = elfcpp::Swap<32, big_endian>::readval(pword); - // Look up the group signature, which is the name of a symbol. This - // is a lot of effort to go to to read a string. Why didn't they - // just have the group signature point into the string table, rather - // than indirect through a symbol? + // Look up the group signature, which is the name of a symbol. ELF + // uses a symbol name because some group signatures are long, and + // the name is generally already in the symbol table, so it makes + // sense to put the long string just once in .strtab rather than in + // both .strtab and .shstrtab. // Get the appropriate symbol table header (this will normally be // the single SHT_SYMTAB section, but in principle it need not be). @@ -703,6 +829,13 @@ Sized_relobj::include_section_group( is_comdat = true; } + if (is_comdat && include_group) + { + Incremental_inputs* incremental_inputs = layout->incremental_inputs(); + if (incremental_inputs != NULL) + incremental_inputs->report_comdat_group(this, signature.c_str()); + } + size_t count = shdr.get_sh_size() / sizeof(elfcpp::Elf_Word); std::vector shndxes; @@ -815,7 +948,7 @@ Sized_relobj::include_section_group( template bool -Sized_relobj::include_linkonce_section( +Sized_relobj_file::include_linkonce_section( Layout* layout, unsigned int index, const char* name, @@ -887,12 +1020,13 @@ Sized_relobj::include_linkonce_section( template inline void -Sized_relobj::layout_section(Layout* layout, - unsigned int shndx, - const char* name, - typename This::Shdr& shdr, - unsigned int reloc_shndx, - unsigned int reloc_type) +Sized_relobj_file::layout_section( + Layout* layout, + unsigned int shndx, + const char* name, + const typename This::Shdr& shdr, + unsigned int reloc_shndx, + unsigned int reloc_type) { off_t offset; Output_section* os = layout->layout(this, shndx, name, shdr, @@ -900,9 +1034,9 @@ Sized_relobj::layout_section(Layout* layout, this->output_sections()[shndx] = os; if (offset == -1) - this->section_offsets_[shndx] = invalid_address; + this->section_offsets()[shndx] = invalid_address; else - this->section_offsets_[shndx] = convert_types(offset); + this->section_offsets()[shndx] = convert_types(offset); // If this section requires special handling, and if there are // relocs that apply to it, then we must do the special handling @@ -911,6 +1045,53 @@ Sized_relobj::layout_section(Layout* layout, this->set_relocs_must_follow_section_writes(); } +// Layout an input .eh_frame section. + +template +void +Sized_relobj_file::layout_eh_frame_section( + Layout* layout, + const unsigned char* symbols_data, + section_size_type symbols_size, + const unsigned char* symbol_names_data, + section_size_type symbol_names_size, + unsigned int shndx, + const typename This::Shdr& shdr, + unsigned int reloc_shndx, + unsigned int reloc_type) +{ + gold_assert(this->has_eh_frame_); + + off_t offset; + Output_section* os = layout->layout_eh_frame(this, + symbols_data, + symbols_size, + symbol_names_data, + symbol_names_size, + shndx, + shdr, + reloc_shndx, + reloc_type, + &offset); + this->output_sections()[shndx] = os; + if (os == NULL || offset == -1) + { + // An object can contain at most one section holding exception + // frame information. + gold_assert(this->discarded_eh_frame_shndx_ == -1U); + this->discarded_eh_frame_shndx_ = shndx; + this->section_offsets()[shndx] = invalid_address; + } + else + this->section_offsets()[shndx] = convert_types(offset); + + // If this section requires special handling, and if there are + // relocs that aply to it, then we must do the special handling + // before we apply the relocs. + if (os != NULL && offset == -1 && reloc_shndx != 0) + this->set_relocs_must_follow_section_writes(); +} + // Lay out the input sections. We walk through the sections and check // whether they should be included in the link. If they should, we // pass them to the Layout object, which will return an output section @@ -927,9 +1108,9 @@ Sized_relobj::layout_section(Layout* layout, template void -Sized_relobj::do_layout(Symbol_table* symtab, - Layout* layout, - Read_symbols_data* sd) +Sized_relobj_file::do_layout(Symbol_table* symtab, + Layout* layout, + Read_symbols_data* sd) { const unsigned int shnum = this->shnum(); bool is_gc_pass_one = ((parameters->options().gc_sections() @@ -968,7 +1149,6 @@ Sized_relobj::do_layout(Symbol_table* symtab, section_size_type section_names_size; const unsigned char* symbols_data = NULL; section_size_type symbols_size; - section_offset_type external_symbols_offset; const unsigned char* symbol_names_data = NULL; section_size_type symbol_names_size; @@ -978,7 +1158,6 @@ Sized_relobj::do_layout(Symbol_table* symtab, section_names_size = gc_sd->section_names_size; symbols_data = gc_sd->symbols_data; symbols_size = gc_sd->symbols_size; - external_symbols_offset = gc_sd->external_symbols_offset; symbol_names_data = gc_sd->symbol_names_data; symbol_names_size = gc_sd->symbol_names_size; } @@ -989,7 +1168,6 @@ Sized_relobj::do_layout(Symbol_table* symtab, if (sd->symbols != NULL) symbols_data = sd->symbols->data(); symbols_size = sd->symbols_size; - external_symbols_offset = sd->external_symbols_offset; if (sd->symbol_names != NULL) symbol_names_data = sd->symbol_names->data(); symbol_names_size = sd->symbol_names_size; @@ -1050,7 +1228,7 @@ Sized_relobj::do_layout(Symbol_table* symtab, } Output_sections& out_sections(this->output_sections()); - std::vector
& out_section_offsets(this->section_offsets_); + std::vector
& out_section_offsets(this->section_offsets()); if (!is_gc_pass_two) { @@ -1114,7 +1292,7 @@ Sized_relobj::do_layout(Symbol_table* symtab, { if (this->handle_gnu_warning_section(name, i, symtab)) { - if (!relocatable) + if (!relocatable && !parameters->options().shared()) omit[i] = true; } @@ -1133,8 +1311,7 @@ Sized_relobj::do_layout(Symbol_table* symtab, // -fsplit-stack. if (this->handle_split_stack_section(name)) { - if (!parameters->options().relocatable() - && !parameters->options().shared()) + if (!relocatable && !parameters->options().shared()) omit[i] = true; } @@ -1163,6 +1340,21 @@ Sized_relobj::do_layout(Symbol_table* symtab, } } + // Add the section to the incremental inputs layout. + Incremental_inputs* incremental_inputs = layout->incremental_inputs(); + if (incremental_inputs != NULL + && !discard + && (shdr.get_sh_type() == elfcpp::SHT_PROGBITS + || shdr.get_sh_type() == elfcpp::SHT_NOBITS + || shdr.get_sh_type() == elfcpp::SHT_NOTE)) + { + off_t sh_size = shdr.get_sh_size(); + section_size_type uncompressed_size; + if (this->section_is_compressed(i, &uncompressed_size)) + sh_size = uncompressed_size; + incremental_inputs->report_input_section(this, i, name, sh_size); + } + if (discard) { // Do not include this section in the link. @@ -1174,12 +1366,20 @@ Sized_relobj::do_layout(Symbol_table* symtab, if (is_gc_pass_one && parameters->options().gc_sections()) { - if (is_section_name_included(name) + if (this->is_section_name_included(name) || shdr.get_sh_type() == elfcpp::SHT_INIT_ARRAY || shdr.get_sh_type() == elfcpp::SHT_FINI_ARRAY) { symtab->gc()->worklist().push(Section_id(this, i)); } + // If the section name XXX can be represented as a C identifier + // it cannot be discarded if there are references to + // __start_XXX and __stop_XXX symbols. These need to be + // specially handled. + if (is_cident(name)) + { + symtab->gc()->add_cident_section(name, Section_id(this, i)); + } } // When doing a relocatable link we are going to copy input @@ -1214,7 +1414,12 @@ Sized_relobj::do_layout(Symbol_table* symtab, out_sections[i] = reinterpret_cast(1); out_section_offsets[i] = invalid_address; } - else + else if (should_defer_layout) + this->deferred_layout_.push_back(Deferred_layout(i, name, + pshdrs, + reloc_shndx[i], + reloc_type[i])); + else eh_frame_sections.push_back(i); continue; } @@ -1313,8 +1518,8 @@ Sized_relobj::do_layout(Symbol_table* symtab, } } - if (!is_gc_pass_one) - layout->layout_gnu_stack(seen_gnu_stack, gnu_stack_flags); + if (!is_gc_pass_two) + layout->layout_gnu_stack(seen_gnu_stack, gnu_stack_flags, this); // When doing a relocatable link handle the reloc sections at the // end. Garbage collection and Identical Code Folding is not @@ -1341,6 +1546,17 @@ Sized_relobj::do_layout(Symbol_table* symtab, } Output_section* data_section = out_sections[data_shndx]; + if (data_section == reinterpret_cast(2)) + { + // The layout for the data section was deferred, so we need + // to defer the relocation section, too. + const char* name = pnames + shdr.get_sh_name(); + this->deferred_layout_relocs_.push_back( + Deferred_layout(i, name, pshdr, 0, elfcpp::SHT_NULL)); + out_sections[i] = reinterpret_cast(2); + out_section_offsets[i] = invalid_address; + continue; + } if (data_section == NULL) { out_sections[i] = NULL; @@ -1363,41 +1579,20 @@ Sized_relobj::do_layout(Symbol_table* symtab, p != eh_frame_sections.end(); ++p) { - gold_assert(this->has_eh_frame_); - gold_assert(external_symbols_offset != 0); - unsigned int i = *p; - const unsigned char *pshdr; + const unsigned char* pshdr; pshdr = section_headers_data + i * This::shdr_size; typename This::Shdr shdr(pshdr); - off_t offset; - Output_section* os = layout->layout_eh_frame(this, - symbols_data, - symbols_size, - symbol_names_data, - symbol_names_size, - i, shdr, - reloc_shndx[i], - reloc_type[i], - &offset); - out_sections[i] = os; - if (offset == -1) - { - // An object can contain at most one section holding exception - // frame information. - gold_assert(this->discarded_eh_frame_shndx_ == -1U); - this->discarded_eh_frame_shndx_ = i; - out_section_offsets[i] = invalid_address; - } - else - out_section_offsets[i] = convert_types(offset); - - // If this section requires special handling, and if there are - // relocs that apply to it, then we must do the special handling - // before we apply the relocs. - if (offset == -1 && reloc_shndx[i] != 0) - this->set_relocs_must_follow_section_writes(); + this->layout_eh_frame_section(layout, + symbols_data, + symbols_size, + symbol_names_data, + symbol_names_size, + i, + shdr, + reloc_shndx[i], + reloc_type[i]); } if (is_gc_pass_two) @@ -1422,7 +1617,7 @@ Sized_relobj::do_layout(Symbol_table* symtab, template void -Sized_relobj::do_layout_deferred_sections(Layout* layout) +Sized_relobj_file::do_layout_deferred_sections(Layout* layout) { typename std::vector::iterator deferred; @@ -1431,20 +1626,74 @@ Sized_relobj::do_layout_deferred_sections(Layout* layout) ++deferred) { typename This::Shdr shdr(deferred->shdr_data_); - this->layout_section(layout, deferred->shndx_, deferred->name_.c_str(), - shdr, deferred->reloc_shndx_, deferred->reloc_type_); + // If the section is not included, it is because the garbage collector + // decided it is not needed. Avoid reverting that decision. + if (!this->is_section_included(deferred->shndx_)) + continue; + + if (parameters->options().relocatable() + || deferred->name_ != ".eh_frame" + || !this->check_eh_frame_flags(&shdr)) + this->layout_section(layout, deferred->shndx_, deferred->name_.c_str(), + shdr, deferred->reloc_shndx_, + deferred->reloc_type_); + else + { + // Reading the symbols again here may be slow. + Read_symbols_data sd; + this->read_symbols(&sd); + this->layout_eh_frame_section(layout, + sd.symbols->data(), + sd.symbols_size, + sd.symbol_names->data(), + sd.symbol_names_size, + deferred->shndx_, + shdr, + deferred->reloc_shndx_, + deferred->reloc_type_); + } } this->deferred_layout_.clear(); + + // Now handle the deferred relocation sections. + + Output_sections& out_sections(this->output_sections()); + std::vector
& out_section_offsets(this->section_offsets()); + + for (deferred = this->deferred_layout_relocs_.begin(); + deferred != this->deferred_layout_relocs_.end(); + ++deferred) + { + unsigned int shndx = deferred->shndx_; + typename This::Shdr shdr(deferred->shdr_data_); + unsigned int data_shndx = this->adjust_shndx(shdr.get_sh_info()); + + Output_section* data_section = out_sections[data_shndx]; + if (data_section == NULL) + { + out_sections[shndx] = NULL; + out_section_offsets[shndx] = invalid_address; + continue; + } + + Relocatable_relocs* rr = new Relocatable_relocs(); + this->set_relocatable_relocs(shndx, rr); + + Output_section* os = layout->layout_reloc(this, shndx, shdr, + data_section, rr); + out_sections[shndx] = os; + out_section_offsets[shndx] = invalid_address; + } } // Add the symbols to the symbol table. template void -Sized_relobj::do_add_symbols(Symbol_table* symtab, - Read_symbols_data* sd, - Layout*) +Sized_relobj_file::do_add_symbols(Symbol_table* symtab, + Read_symbols_data* sd, + Layout*) { if (sd->symbols == NULL) { @@ -1478,6 +1727,120 @@ Sized_relobj::do_add_symbols(Symbol_table* symtab, sd->symbol_names = NULL; } +// Find out if this object, that is a member of a lib group, should be included +// in the link. We check every symbol defined by this object. If the symbol +// table has a strong undefined reference to that symbol, we have to include +// the object. + +template +Archive::Should_include +Sized_relobj_file::do_should_include_member( + Symbol_table* symtab, + Layout* layout, + Read_symbols_data* sd, + std::string* why) +{ + char* tmpbuf = NULL; + size_t tmpbuflen = 0; + const char* sym_names = + reinterpret_cast(sd->symbol_names->data()); + const unsigned char* syms = + sd->symbols->data() + sd->external_symbols_offset; + const int sym_size = elfcpp::Elf_sizes::sym_size; + size_t symcount = ((sd->symbols_size - sd->external_symbols_offset) + / sym_size); + + const unsigned char* p = syms; + + for (size_t i = 0; i < symcount; ++i, p += sym_size) + { + elfcpp::Sym sym(p); + unsigned int st_shndx = sym.get_st_shndx(); + if (st_shndx == elfcpp::SHN_UNDEF) + continue; + + unsigned int st_name = sym.get_st_name(); + const char* name = sym_names + st_name; + Symbol* symbol; + Archive::Should_include t = Archive::should_include_member(symtab, + layout, + name, + &symbol, why, + &tmpbuf, + &tmpbuflen); + if (t == Archive::SHOULD_INCLUDE_YES) + { + if (tmpbuf != NULL) + free(tmpbuf); + return t; + } + } + if (tmpbuf != NULL) + free(tmpbuf); + return Archive::SHOULD_INCLUDE_UNKNOWN; +} + +// Iterate over global defined symbols, calling a visitor class V for each. + +template +void +Sized_relobj_file::do_for_all_global_symbols( + Read_symbols_data* sd, + Library_base::Symbol_visitor_base* v) +{ + const char* sym_names = + reinterpret_cast(sd->symbol_names->data()); + const unsigned char* syms = + sd->symbols->data() + sd->external_symbols_offset; + const int sym_size = elfcpp::Elf_sizes::sym_size; + size_t symcount = ((sd->symbols_size - sd->external_symbols_offset) + / sym_size); + const unsigned char* p = syms; + + for (size_t i = 0; i < symcount; ++i, p += sym_size) + { + elfcpp::Sym sym(p); + if (sym.get_st_shndx() != elfcpp::SHN_UNDEF) + v->visit(sym_names + sym.get_st_name()); + } +} + +// Return whether the local symbol SYMNDX has a PLT offset. + +template +bool +Sized_relobj_file::local_has_plt_offset( + unsigned int symndx) const +{ + typename Local_plt_offsets::const_iterator p = + this->local_plt_offsets_.find(symndx); + return p != this->local_plt_offsets_.end(); +} + +// Get the PLT offset of a local symbol. + +template +unsigned int +Sized_relobj_file::local_plt_offset(unsigned int symndx) const +{ + typename Local_plt_offsets::const_iterator p = + this->local_plt_offsets_.find(symndx); + gold_assert(p != this->local_plt_offsets_.end()); + return p->second; +} + +// Set the PLT offset of a local symbol. + +template +void +Sized_relobj_file::set_local_plt_offset( + unsigned int symndx, unsigned int plt_offset) +{ + std::pair ins = + this->local_plt_offsets_.insert(std::make_pair(symndx, plt_offset)); + gold_assert(ins.second); +} + // First pass over the local symbols. Here we add their names to // *POOL and *DYNPOOL, and we store the symbol value in // THIS->LOCAL_VALUES_. This function is always called from a @@ -1486,8 +1849,8 @@ Sized_relobj::do_add_symbols(Symbol_table* symtab, template void -Sized_relobj::do_count_local_symbols(Stringpool* pool, - Stringpool* dynpool) +Sized_relobj_file::do_count_local_symbols(Stringpool* pool, + Stringpool* dynpool) { gold_assert(this->symtab_shndx_ != -1U); if (this->symtab_shndx_ == 0) @@ -1527,6 +1890,8 @@ Sized_relobj::do_count_local_symbols(Stringpool* pool, unsigned int dyncount = 0; // Skip the first, dummy, symbol. psyms += sym_size; + bool strip_all = parameters->options().strip_all(); + bool discard_all = parameters->options().discard_all(); bool discard_locals = parameters->options().discard_locals(); for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size) { @@ -1543,6 +1908,8 @@ Sized_relobj::do_count_local_symbols(Stringpool* pool, lv.set_is_section_symbol(); else if (sym.get_st_type() == elfcpp::STT_TLS) lv.set_is_tls_symbol(); + else if (sym.get_st_type() == elfcpp::STT_GNU_IFUNC) + lv.set_is_ifunc_symbol(); // Save the input symbol value for use in do_finalize_local_symbols(). lv.set_input_value(sym.get_st_value()); @@ -1550,7 +1917,7 @@ Sized_relobj::do_count_local_symbols(Stringpool* pool, // Decide whether this symbol should go into the output file. if ((shndx < shnum && out_sections[shndx] == NULL) - || (shndx == this->discarded_eh_frame_shndx_)) + || shndx == this->discarded_eh_frame_shndx_) { lv.set_no_output_symtab_entry(); gold_assert(!lv.needs_output_dynsym_entry()); @@ -1573,6 +1940,22 @@ Sized_relobj::do_count_local_symbols(Stringpool* pool, continue; } + const char* name = pnames + sym.get_st_name(); + + // If needed, add the symbol to the dynamic symbol table string pool. + if (lv.needs_output_dynsym_entry()) + { + dynpool->add(name, true, NULL); + ++dyncount; + } + + if (strip_all + || (discard_all && lv.may_be_discarded_from_output_symtab())) + { + lv.set_no_output_symtab_entry(); + continue; + } + // If --discard-locals option is used, discard all temporary local // symbols. These symbols start with system-specific local label // prefixes, typically .L for ELF system. We want to be compatible @@ -1585,10 +1968,10 @@ Sized_relobj::do_count_local_symbols(Stringpool* pool, // - the symbol has a name. // // We do not discard a symbol if it needs a dynamic symbol entry. - const char* name = pnames + sym.get_st_name(); if (discard_locals && sym.get_st_type() != elfcpp::STT_FILE && !lv.needs_output_dynsym_entry() + && lv.may_be_discarded_from_output_symtab() && parameters->target().is_local_label_name(name)) { lv.set_no_output_symtab_entry(); @@ -1606,19 +1989,184 @@ Sized_relobj::do_count_local_symbols(Stringpool* pool, // Add the symbol to the symbol table string pool. pool->add(name, true, NULL); ++count; - - // If needed, add the symbol to the dynamic symbol table string pool. - if (lv.needs_output_dynsym_entry()) - { - dynpool->add(name, true, NULL); - ++dyncount; - } } this->output_local_symbol_count_ = count; this->output_local_dynsym_count_ = dyncount; } +// Compute the final value of a local symbol. + +template +typename Sized_relobj_file::Compute_final_local_value_status +Sized_relobj_file::compute_final_local_value_internal( + unsigned int r_sym, + const Symbol_value* lv_in, + Symbol_value* lv_out, + bool relocatable, + const Output_sections& out_sections, + const std::vector
& out_offsets, + const Symbol_table* symtab) +{ + // We are going to overwrite *LV_OUT, if it has a merged symbol value, + // we may have a memory leak. + gold_assert(lv_out->has_output_value()); + + bool is_ordinary; + unsigned int shndx = lv_in->input_shndx(&is_ordinary); + + // Set the output symbol value. + + if (!is_ordinary) + { + if (shndx == elfcpp::SHN_ABS || Symbol::is_common_shndx(shndx)) + lv_out->set_output_value(lv_in->input_value()); + else + { + this->error(_("unknown section index %u for local symbol %u"), + shndx, r_sym); + lv_out->set_output_value(0); + return This::CFLV_ERROR; + } + } + else + { + if (shndx >= this->shnum()) + { + this->error(_("local symbol %u section index %u out of range"), + r_sym, shndx); + lv_out->set_output_value(0); + return This::CFLV_ERROR; + } + + Output_section* os = out_sections[shndx]; + Address secoffset = out_offsets[shndx]; + if (symtab->is_section_folded(this, shndx)) + { + gold_assert(os == NULL && secoffset == invalid_address); + // Get the os of the section it is folded onto. + Section_id folded = symtab->icf()->get_folded_section(this, + shndx); + gold_assert(folded.first != NULL); + Sized_relobj_file* folded_obj = reinterpret_cast + *>(folded.first); + os = folded_obj->output_section(folded.second); + gold_assert(os != NULL); + secoffset = folded_obj->get_output_section_offset(folded.second); + + // This could be a relaxed input section. + if (secoffset == invalid_address) + { + const Output_relaxed_input_section* relaxed_section = + os->find_relaxed_input_section(folded_obj, folded.second); + gold_assert(relaxed_section != NULL); + secoffset = relaxed_section->address() - os->address(); + } + } + + if (os == NULL) + { + // This local symbol belongs to a section we are discarding. + // In some cases when applying relocations later, we will + // attempt to match it to the corresponding kept section, + // so we leave the input value unchanged here. + return This::CFLV_DISCARDED; + } + else if (secoffset == invalid_address) + { + uint64_t start; + + // This is a SHF_MERGE section or one which otherwise + // requires special handling. + if (shndx == this->discarded_eh_frame_shndx_) + { + // This local symbol belongs to a discarded .eh_frame + // section. Just treat it like the case in which + // os == NULL above. + gold_assert(this->has_eh_frame_); + return This::CFLV_DISCARDED; + } + else if (!lv_in->is_section_symbol()) + { + // This is not a section symbol. We can determine + // the final value now. + lv_out->set_output_value( + os->output_address(this, shndx, lv_in->input_value())); + } + else if (!os->find_starting_output_address(this, shndx, &start)) + { + // This is a section symbol, but apparently not one in a + // merged section. First check to see if this is a relaxed + // input section. If so, use its address. Otherwise just + // use the start of the output section. This happens with + // relocatable links when the input object has section + // symbols for arbitrary non-merge sections. + const Output_section_data* posd = + os->find_relaxed_input_section(this, shndx); + if (posd != NULL) + { + Address relocatable_link_adjustment = + relocatable ? os->address() : 0; + lv_out->set_output_value(posd->address() + - relocatable_link_adjustment); + } + else + lv_out->set_output_value(os->address()); + } + else + { + // We have to consider the addend to determine the + // value to use in a relocation. START is the start + // of this input section. If we are doing a relocatable + // link, use offset from start output section instead of + // address. + Address adjusted_start = + relocatable ? start - os->address() : start; + Merged_symbol_value* msv = + new Merged_symbol_value(lv_in->input_value(), + adjusted_start); + lv_out->set_merged_symbol_value(msv); + } + } + else if (lv_in->is_tls_symbol()) + lv_out->set_output_value(os->tls_offset() + + secoffset + + lv_in->input_value()); + else + lv_out->set_output_value((relocatable ? 0 : os->address()) + + secoffset + + lv_in->input_value()); + } + return This::CFLV_OK; +} + +// Compute final local symbol value. R_SYM is the index of a local +// symbol in symbol table. LV points to a symbol value, which is +// expected to hold the input value and to be over-written by the +// final value. SYMTAB points to a symbol table. Some targets may want +// to know would-be-finalized local symbol values in relaxation. +// Hence we provide this method. Since this method updates *LV, a +// callee should make a copy of the original local symbol value and +// use the copy instead of modifying an object's local symbols before +// everything is finalized. The caller should also free up any allocated +// memory in the return value in *LV. +template +typename Sized_relobj_file::Compute_final_local_value_status +Sized_relobj_file::compute_final_local_value( + unsigned int r_sym, + const Symbol_value* lv_in, + Symbol_value* lv_out, + const Symbol_table* symtab) +{ + // This is just a wrapper of compute_final_local_value_internal. + const bool relocatable = parameters->options().relocatable(); + const Output_sections& out_sections(this->output_sections()); + const std::vector
& out_offsets(this->section_offsets()); + return this->compute_final_local_value_internal(r_sym, lv_in, lv_out, + relocatable, out_sections, + out_offsets, symtab); +} + // Finalize the local symbols. Here we set the final value in // THIS->LOCAL_VALUES_ and set their output symbol table indexes. // This function is always called from a singleton thread. The actual @@ -1626,9 +2174,10 @@ Sized_relobj::do_count_local_symbols(Stringpool* pool, template unsigned int -Sized_relobj::do_finalize_local_symbols(unsigned int index, - off_t off, - Symbol_table* symtab) +Sized_relobj_file::do_finalize_local_symbols( + unsigned int index, + off_t off, + Symbol_table* symtab) { gold_assert(off == static_cast(align_address(off, size >> 3))); @@ -1637,124 +2186,32 @@ Sized_relobj::do_finalize_local_symbols(unsigned int index, const bool relocatable = parameters->options().relocatable(); const Output_sections& out_sections(this->output_sections()); - const std::vector
& out_offsets(this->section_offsets_); - unsigned int shnum = this->shnum(); + const std::vector
& out_offsets(this->section_offsets()); for (unsigned int i = 1; i < loccount; ++i) { - Symbol_value& lv(this->local_values_[i]); + Symbol_value* lv = &this->local_values_[i]; - bool is_ordinary; - unsigned int shndx = lv.input_shndx(&is_ordinary); - - // Set the output symbol value. - - if (!is_ordinary) + Compute_final_local_value_status cflv_status = + this->compute_final_local_value_internal(i, lv, lv, relocatable, + out_sections, out_offsets, + symtab); + switch (cflv_status) { - if (shndx == elfcpp::SHN_ABS || Symbol::is_common_shndx(shndx)) - lv.set_output_value(lv.input_value()); - else - { - this->error(_("unknown section index %u for local symbol %u"), - shndx, i); - lv.set_output_value(0); - } - } - else - { - if (shndx >= shnum) - { - this->error(_("local symbol %u section index %u out of range"), - i, shndx); - shndx = 0; - } - - Output_section* os = out_sections[shndx]; - Address secoffset = out_offsets[shndx]; - if (symtab->is_section_folded(this, shndx)) - { - gold_assert (os == NULL && secoffset == invalid_address); - // Get the os of the section it is folded onto. - Section_id folded = symtab->icf()->get_folded_section(this, - shndx); - gold_assert(folded.first != NULL); - Sized_relobj* folded_obj = reinterpret_cast - *>(folded.first); - os = folded_obj->output_section(folded.second); - gold_assert(os != NULL); - secoffset = folded_obj->get_output_section_offset(folded.second); - gold_assert(secoffset != invalid_address); - } - - if (os == NULL) + case CFLV_OK: + if (!lv->is_output_symtab_index_set()) { - // This local symbol belongs to a section we are discarding. - // In some cases when applying relocations later, we will - // attempt to match it to the corresponding kept section, - // so we leave the input value unchanged here. - continue; - } - else if (secoffset == invalid_address) - { - uint64_t start; - - // This is a SHF_MERGE section or one which otherwise - // requires special handling. - if (shndx == this->discarded_eh_frame_shndx_) - { - // This local symbol belongs to a discarded .eh_frame - // section. Just treat it like the case in which - // os == NULL above. - gold_assert(this->has_eh_frame_); - continue; - } - else if (!lv.is_section_symbol()) - { - // This is not a section symbol. We can determine - // the final value now. - lv.set_output_value(os->output_address(this, shndx, - lv.input_value())); - } - else if (!os->find_starting_output_address(this, shndx, &start)) - { - // This is a section symbol, but apparently not one in a - // merged section. First check to see if this is a relaxed - // input section. If so, use its address. Otherwise just - // use the start of the output section. This happens with - // relocatable links when the input object has section - // symbols for arbitrary non-merge sections. - const Output_section_data* posd = - os->find_relaxed_input_section(this, shndx); - if (posd != NULL) - lv.set_output_value(posd->address()); - else - lv.set_output_value(os->address()); - } - else - { - // We have to consider the addend to determine the - // value to use in a relocation. START is the start - // of this input section. - Merged_symbol_value* msv = - new Merged_symbol_value(lv.input_value(), start); - lv.set_merged_symbol_value(msv); - } + lv->set_output_symtab_index(index); + ++index; } - else if (lv.is_tls_symbol()) - lv.set_output_value(os->tls_offset() - + secoffset - + lv.input_value()); - else - lv.set_output_value((relocatable ? 0 : os->address()) - + secoffset - + lv.input_value()); + break; + case CFLV_DISCARDED: + case CFLV_ERROR: + // Do nothing. + break; + default: + gold_unreachable(); } - - if (lv.needs_output_symtab_entry()) - { - lv.set_output_symtab_index(index); - ++index; - } } return index; } @@ -1763,7 +2220,8 @@ Sized_relobj::do_finalize_local_symbols(unsigned int index, template unsigned int -Sized_relobj::do_set_local_dynsym_indexes(unsigned int index) +Sized_relobj_file::do_set_local_dynsym_indexes( + unsigned int index) { const unsigned int loccount = this->local_symbol_count_; for (unsigned int i = 1; i < loccount; ++i) @@ -1784,7 +2242,7 @@ Sized_relobj::do_set_local_dynsym_indexes(unsigned int index) template unsigned int -Sized_relobj::do_set_local_dynsym_offset(off_t off) +Sized_relobj_file::do_set_local_dynsym_offset(off_t off) { gold_assert(off == static_cast(align_address(off, size >> 3))); this->local_dynsym_offset_ = off; @@ -1796,7 +2254,7 @@ Sized_relobj::do_set_local_dynsym_offset(off_t off) template uint64_t -Sized_relobj::do_section_flags(unsigned int shndx) +Sized_relobj_file::do_section_flags(unsigned int shndx) { Symbols_data* sd = this->get_symbols_data(); if (sd != NULL) @@ -1815,10 +2273,10 @@ Sized_relobj::do_section_flags(unsigned int shndx) template uint64_t -Sized_relobj::do_section_entsize(unsigned int shndx) +Sized_relobj_file::do_section_entsize(unsigned int shndx) { Symbols_data* sd = this->get_symbols_data(); - gold_assert (sd != NULL); + gold_assert(sd != NULL); const unsigned char* pshdrs = sd->section_headers_data + This::shdr_size * shndx; @@ -1826,17 +2284,17 @@ Sized_relobj::do_section_entsize(unsigned int shndx) return shdr.get_sh_entsize(); } - // Write out the local symbols. template void -Sized_relobj::write_local_symbols( +Sized_relobj_file::write_local_symbols( Output_file* of, const Stringpool* sympool, const Stringpool* dynpool, Output_symtab_xindex* symtab_xindex, - Output_symtab_xindex* dynsym_xindex) + Output_symtab_xindex* dynsym_xindex, + off_t symtab_off) { const bool strip_all = parameters->options().strip_all(); if (strip_all) @@ -1881,7 +2339,8 @@ Sized_relobj::write_local_symbols( off_t output_size = this->output_local_symbol_count_ * sym_size; unsigned char* oview = NULL; if (output_size > 0) - oview = of->get_output_view(this->local_symbol_offset_, output_size); + oview = of->get_output_view(symtab_off + this->local_symbol_offset_, + output_size); off_t dyn_output_size = this->output_local_dynsym_count_ * sym_size; unsigned char* dyn_oview = NULL; @@ -1913,16 +2372,16 @@ Sized_relobj::write_local_symbols( st_shndx = out_sections[st_shndx]->out_shndx(); if (st_shndx >= elfcpp::SHN_LORESERVE) { - if (lv.needs_output_symtab_entry() && !strip_all) + if (lv.has_output_symtab_entry()) symtab_xindex->add(lv.output_symtab_index(), st_shndx); - if (lv.needs_output_dynsym_entry()) + if (lv.has_output_dynsym_entry()) dynsym_xindex->add(lv.output_dynsym_index(), st_shndx); st_shndx = elfcpp::SHN_XINDEX; } } // Write the symbol to the output symbol table. - if (!strip_all && lv.needs_output_symtab_entry()) + if (lv.has_output_symtab_entry()) { elfcpp::Sym_write osym(ov); @@ -1939,7 +2398,7 @@ Sized_relobj::write_local_symbols( } // Write the symbol to the output dynamic symbol table. - if (lv.needs_output_dynsym_entry()) + if (lv.has_output_dynsym_entry()) { gold_assert(dyn_ov < dyn_oview + dyn_output_size); elfcpp::Sym_write osym(dyn_ov); @@ -1961,7 +2420,8 @@ Sized_relobj::write_local_symbols( if (output_size > 0) { gold_assert(ov - oview == output_size); - of->write_output_view(this->local_symbol_offset_, output_size, oview); + of->write_output_view(symtab_off + this->local_symbol_offset_, + output_size, oview); } if (dyn_output_size > 0) @@ -1978,7 +2438,7 @@ Sized_relobj::write_local_symbols( template bool -Sized_relobj::get_symbol_location_info( +Sized_relobj_file::get_symbol_location_info( unsigned int shndx, off_t offset, Symbol_location_info* info) @@ -2053,8 +2513,8 @@ Sized_relobj::get_symbol_location_info( // debugging sections. If we can't find the kept section, return 0. template -typename Sized_relobj::Address -Sized_relobj::map_to_kept_section( +typename Sized_relobj_file::Address +Sized_relobj_file::map_to_kept_section( unsigned int shndx, bool* found) const { @@ -2062,8 +2522,8 @@ Sized_relobj::map_to_kept_section( unsigned int kept_shndx; if (this->get_kept_comdat_section(shndx, &kept_object, &kept_shndx)) { - Sized_relobj* kept_relobj = - static_cast*>(kept_object); + Sized_relobj_file* kept_relobj = + static_cast*>(kept_object); Output_section* os = kept_relobj->output_section(kept_shndx); Address offset = kept_relobj->get_output_section_offset(kept_shndx); if (os != NULL && offset != invalid_address) @@ -2080,14 +2540,14 @@ Sized_relobj::map_to_kept_section( template void -Sized_relobj::do_get_global_symbol_counts( +Sized_relobj_file::do_get_global_symbol_counts( const Symbol_table*, size_t* defined, size_t* used) const { *defined = this->defined_count_; size_t count = 0; - for (Symbols::const_iterator p = this->symbols_.begin(); + for (typename Symbols::const_iterator p = this->symbols_.begin(); p != this->symbols_.end(); ++p) if (*p != NULL @@ -2130,7 +2590,8 @@ Input_objects::add_object(Object* obj) } // Add this object to the cross-referencer if requested. - if (parameters->options().user_set_print_symbol_counts()) + if (parameters->options().user_set_print_symbol_counts() + || parameters->options().cref()) { if (this->cref_ == NULL) this->cref_ = new Cref(); @@ -2146,15 +2607,15 @@ Input_objects::add_object(Object* obj) void Input_objects::check_dynamic_dependencies() const { + bool issued_copy_dt_needed_error = false; for (Dynobj_list::const_iterator p = this->dynobj_list_.begin(); p != this->dynobj_list_.end(); ++p) { const Dynobj::Needed& needed((*p)->needed()); bool found_all = true; - for (Dynobj::Needed::const_iterator pneeded = needed.begin(); - pneeded != needed.end(); - ++pneeded) + Dynobj::Needed::const_iterator pneeded; + for (pneeded = needed.begin(); pneeded != needed.end(); ++pneeded) { if (this->sonames_.find(*pneeded) == this->sonames_.end()) { @@ -2163,6 +2624,25 @@ Input_objects::check_dynamic_dependencies() const } } (*p)->set_has_unknown_needed_entries(!found_all); + + // --copy-dt-needed-entries aka --add-needed is a GNU ld option + // that gold does not support. However, they cause no trouble + // unless there is a DT_NEEDED entry that we don't know about; + // warn only in that case. + if (!found_all + && !issued_copy_dt_needed_error + && (parameters->options().copy_dt_needed_entries() + || parameters->options().add_needed())) + { + const char* optname; + if (parameters->options().copy_dt_needed_entries()) + optname = "--copy-dt-needed-entries"; + else + optname = "--add-needed"; + gold_error(_("%s is not supported but is required for %s in %s"), + optname, (*pneeded).c_str(), (*p)->name().c_str()); + issued_copy_dt_needed_error = true; + } } } @@ -2171,7 +2651,8 @@ Input_objects::check_dynamic_dependencies() const void Input_objects::archive_start(Archive* archive) { - if (parameters->options().user_set_print_symbol_counts()) + if (parameters->options().user_set_print_symbol_counts() + || parameters->options().cref()) { if (this->cref_ == NULL) this->cref_ = new Cref(); @@ -2184,7 +2665,8 @@ Input_objects::archive_start(Archive* archive) void Input_objects::archive_stop(Archive* archive) { - if (parameters->options().user_set_print_symbol_counts()) + if (parameters->options().user_set_print_symbol_counts() + || parameters->options().cref()) this->cref_->add_archive_stop(archive); } @@ -2198,48 +2680,54 @@ Input_objects::print_symbol_counts(const Symbol_table* symtab) const this->cref_->print_symbol_counts(symtab); } +// Print a cross reference table. + +void +Input_objects::print_cref(const Symbol_table* symtab, FILE* f) const +{ + if (parameters->options().cref() && this->cref_ != NULL) + this->cref_->print_cref(symtab, f); +} + // Relocate_info methods. -// Return a string describing the location of a relocation. This is -// only used in error messages. +// Return a string describing the location of a relocation when file +// and lineno information is not available. This is only used in +// error messages. template std::string Relocate_info::location(size_t, off_t offset) const { - // See if we can get line-number information from debugging sections. - std::string filename; - std::string file_and_lineno; // Better than filename-only, if available. - Sized_dwarf_line_info line_info(this->object); - // This will be "" if we failed to parse the debug info for any reason. - file_and_lineno = line_info.addr2line(this->data_shndx, offset); + std::string ret = line_info.addr2line(this->data_shndx, offset, NULL); + if (!ret.empty()) + return ret; + + ret = this->object->name(); - std::string ret(this->object->name()); - ret += ':'; Symbol_location_info info; if (this->object->get_symbol_location_info(this->data_shndx, offset, &info)) { - ret += " in function "; - ret += info.enclosing_symbol_name; - ret += ":"; - filename = info.source_file; - } - - if (!file_and_lineno.empty()) - ret += file_and_lineno; - else - { - if (!filename.empty()) - ret += filename; - ret += "("; - ret += this->object->section_name(this->data_shndx); - char buf[100]; - // Offsets into sections have to be positive. - snprintf(buf, sizeof(buf), "+0x%lx", static_cast(offset)); + if (!info.source_file.empty()) + { + ret += ":"; + ret += info.source_file; + } + size_t len = info.enclosing_symbol_name.length() + 100; + char* buf = new char[len]; + snprintf(buf, len, _(":function %s"), + info.enclosing_symbol_name.c_str()); ret += buf; - ret += ")"; + delete[] buf; + return ret; } + + ret += "("; + ret += this->object->section_name(this->data_shndx); + char buf[100]; + snprintf(buf, sizeof buf, "+0x%lx)", static_cast(offset)); + ret += buf; return ret; } @@ -2290,7 +2778,7 @@ namespace gold bool is_elf_object(Input_file* input_file, off_t offset, - const unsigned char** start, int *read_size) + const unsigned char** start, int* read_size) { off_t filesize = input_file->file().filesize(); int want = elfcpp::Elf_recognizer::max_header_size; @@ -2431,22 +2919,22 @@ Object::read_section_data<64, true>(elfcpp::Elf_file<64, true, Object>*, #ifdef HAVE_TARGET_32_LITTLE template -class Sized_relobj<32, false>; +class Sized_relobj_file<32, false>; #endif #ifdef HAVE_TARGET_32_BIG template -class Sized_relobj<32, true>; +class Sized_relobj_file<32, true>; #endif #ifdef HAVE_TARGET_64_LITTLE template -class Sized_relobj<64, false>; +class Sized_relobj_file<64, false>; #endif #ifdef HAVE_TARGET_64_BIG template -class Sized_relobj<64, true>; +class Sized_relobj_file<64, true>; #endif #ifdef HAVE_TARGET_32_LITTLE @@ -2469,4 +2957,48 @@ template struct Relocate_info<64, true>; #endif +#ifdef HAVE_TARGET_32_LITTLE +template +void +Xindex::initialize_symtab_xindex<32, false>(Object*, unsigned int); + +template +void +Xindex::read_symtab_xindex<32, false>(Object*, unsigned int, + const unsigned char*); +#endif + +#ifdef HAVE_TARGET_32_BIG +template +void +Xindex::initialize_symtab_xindex<32, true>(Object*, unsigned int); + +template +void +Xindex::read_symtab_xindex<32, true>(Object*, unsigned int, + const unsigned char*); +#endif + +#ifdef HAVE_TARGET_64_LITTLE +template +void +Xindex::initialize_symtab_xindex<64, false>(Object*, unsigned int); + +template +void +Xindex::read_symtab_xindex<64, false>(Object*, unsigned int, + const unsigned char*); +#endif + +#ifdef HAVE_TARGET_64_BIG +template +void +Xindex::initialize_symtab_xindex<64, true>(Object*, unsigned int); + +template +void +Xindex::read_symtab_xindex<64, true>(Object*, unsigned int, + const unsigned char*); +#endif + } // End namespace gold.