X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gold%2Freloc.cc;h=7fb5cea7d50556ca167d963c79b791756bd4e438;hb=37e124c9c30152b6833198a8c283c533c7b1fcce;hp=37a9a85591a1df84f4d222ffd1a39c25ead7fe5a;hpb=fe8718a4637d92b3cd991a8f1a22d6d0a09bc6dd;p=deliverable%2Fbinutils-gdb.git diff --git a/gold/reloc.cc b/gold/reloc.cc index 37a9a85591..7fb5cea7d5 100644 --- a/gold/reloc.cc +++ b/gold/reloc.cc @@ -1,6 +1,6 @@ // reloc.cc -- relocate input files for gold. -// Copyright 2006, 2007 Free Software Foundation, Inc. +// Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc. // Written by Ian Lance Taylor . // This file is part of gold. @@ -22,10 +22,14 @@ #include "gold.h" +#include + #include "workqueue.h" -#include "object.h" #include "symtab.h" #include "output.h" +#include "merge.h" +#include "object.h" +#include "target-reloc.h" #include "reloc.h" namespace gold @@ -58,11 +62,28 @@ Read_relocs::run(Workqueue* workqueue) { Read_relocs_data *rd = new Read_relocs_data; this->object_->read_relocs(rd); + this->object_->set_relocs_data(rd); this->object_->release(); - workqueue->queue_front(new Scan_relocs(this->options_, this->symtab_, - this->layout_, this->object_, rd, - this->symtab_lock_, this->blocker_)); + // If garbage collection or identical comdat folding is desired, we + // process the relocs first before scanning them. Scanning of relocs is + // done only after garbage or identical sections is identified. + if (parameters->options().gc_sections() || parameters->options().icf()) + { + workqueue->queue_next(new Gc_process_relocs(this->options_, + this->symtab_, + this->layout_, + this->object_, rd, + this->symtab_lock_, + this->blocker_)); + } + else + { + workqueue->queue_next(new Scan_relocs(this->options_, this->symtab_, + this->layout_, this->object_, rd, + this->symtab_lock_, + this->blocker_)); + } } // Return a debugging name for the task. @@ -73,6 +94,43 @@ Read_relocs::get_name() const return "Read_relocs " + this->object_->name(); } +// Gc_process_relocs methods. + +// These tasks process the relocations read by Read_relocs and +// determine which sections are referenced and which are garbage. +// This task is done only when --gc-sections is used. + +Task_token* +Gc_process_relocs::is_runnable() +{ + if (this->object_->is_locked()) + return this->object_->token(); + return NULL; +} + +void +Gc_process_relocs::locks(Task_locker* tl) +{ + tl->add(this, this->object_->token()); + tl->add(this, this->blocker_); +} + +void +Gc_process_relocs::run(Workqueue*) +{ + this->object_->gc_process_relocs(this->options_, this->symtab_, this->layout_, + this->rd_); + this->object_->release(); +} + +// Return a debugging name for the task. + +std::string +Gc_process_relocs::get_name() const +{ + return "Gc_process_relocs " + this->object_->name(); +} + // Scan_relocs methods. // These tasks scan the relocations read by Read_relocs and mark up @@ -158,6 +216,11 @@ Relocate_task::run(Workqueue*) { this->object_->relocate(this->options_, this->symtab_, this->layout_, this->of_); + + // This is normally the last thing we will do with an object, so + // uncache all views. + this->object_->clear_view_cache_marks(); + this->object_->release(); } @@ -184,11 +247,12 @@ Sized_relobj::do_read_relocs(Read_relocs_data* rd) rd->relocs.reserve(shnum / 2); - std::vector& map_sections(this->map_to_output()); + const Output_sections& out_sections(this->output_sections()); + const std::vector
& out_offsets(this->section_offsets_); const unsigned char *pshdrs = this->get_view(this->elf_file_.shoff(), shnum * This::shdr_size, - true); + true, true); // Skip the first, dummy, section. const unsigned char *ps = pshdrs + This::shdr_size; for (unsigned int i = 1; i < shnum; ++i, ps += This::shdr_size) @@ -199,7 +263,7 @@ Sized_relobj::do_read_relocs(Read_relocs_data* rd) if (sh_type != elfcpp::SHT_REL && sh_type != elfcpp::SHT_RELA) continue; - unsigned int shndx = shdr.get_sh_info(); + unsigned int shndx = this->adjust_shndx(shdr.get_sh_info()); if (shndx >= shnum) { this->error(_("relocation section %u has bad info %u"), @@ -207,23 +271,30 @@ Sized_relobj::do_read_relocs(Read_relocs_data* rd) continue; } - Output_section* os = map_sections[shndx].output_section; + Output_section* os = out_sections[shndx]; if (os == NULL) continue; // We are scanning relocations in order to fill out the GOT and // PLT sections. Relocations for sections which are not // allocated (typically debugging sections) should not add new - // GOT and PLT entries. So we skip them. + // GOT and PLT entries. So we skip them unless this is a + // relocatable link or we need to emit relocations. FIXME: What + // should we do if a linker script maps a section with SHF_ALLOC + // clear to a section with SHF_ALLOC set? typename This::Shdr secshdr(pshdrs + shndx * This::shdr_size); - if ((secshdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0) + bool is_section_allocated = ((secshdr.get_sh_flags() & elfcpp::SHF_ALLOC) + != 0); + if (!is_section_allocated + && !parameters->options().relocatable() + && !parameters->options().emit_relocs()) continue; - if (shdr.get_sh_link() != this->symtab_shndx_) + if (this->adjust_shndx(shdr.get_sh_link()) != this->symtab_shndx_) { this->error(_("relocation section %u uses unexpected " "symbol table %u"), - i, shdr.get_sh_link()); + i, this->adjust_shndx(shdr.get_sh_link())); continue; } @@ -255,11 +326,12 @@ Sized_relobj::do_read_relocs(Read_relocs_data* rd) sr.reloc_shndx = i; sr.data_shndx = shndx; sr.contents = this->get_lasting_view(shdr.get_sh_offset(), sh_size, - true); + true, true); sr.sh_type = sh_type; sr.reloc_count = reloc_count; sr.output_section = os; - sr.needs_special_offset_handling = map_sections[shndx].offset == -1; + sr.needs_special_offset_handling = out_offsets[shndx] == invalid_address; + sr.is_data_section_allocated = is_section_allocated; } // Read the local symbols. @@ -276,10 +348,52 @@ Sized_relobj::do_read_relocs(Read_relocs_data* rd) gold_assert(loccount == symtabshdr.get_sh_info()); off_t locsize = loccount * sym_size; rd->local_symbols = this->get_lasting_view(symtabshdr.get_sh_offset(), - locsize, true); + locsize, true, true); } } +// Process the relocs to generate mappings from source sections to referenced +// sections. This is used during garbage colletion to determine garbage +// sections. + +template +void +Sized_relobj::do_gc_process_relocs(const General_options& options, + Symbol_table* symtab, + Layout* layout, + Read_relocs_data* rd) +{ + Sized_target* target = + parameters->sized_target(); + + const unsigned char* local_symbols; + if (rd->local_symbols == NULL) + local_symbols = NULL; + else + local_symbols = rd->local_symbols->data(); + + for (Read_relocs_data::Relocs_list::iterator p = rd->relocs.begin(); + p != rd->relocs.end(); + ++p) + { + if (!parameters->options().relocatable()) + { + // As noted above, when not generating an object file, we + // only scan allocated sections. We may see a non-allocated + // section here if we are emitting relocs. + if (p->is_data_section_allocated) + target->gc_process_relocs(options, symtab, layout, this, + p->data_shndx, p->sh_type, + p->contents->data(), p->reloc_count, + p->output_section, + p->needs_special_offset_handling, + this->local_symbol_count_, + local_symbols); + } + } +} + + // Scan the relocs and adjust the symbol table. This looks for // relocations which require GOT/PLT/COPY relocations. @@ -290,7 +404,8 @@ Sized_relobj::do_scan_relocs(const General_options& options, Layout* layout, Read_relocs_data* rd) { - Sized_target* target = this->sized_target(); + Sized_target* target = + parameters->sized_target(); const unsigned char* local_symbols; if (rd->local_symbols == NULL) @@ -302,11 +417,45 @@ Sized_relobj::do_scan_relocs(const General_options& options, p != rd->relocs.end(); ++p) { - target->scan_relocs(options, symtab, layout, this, p->data_shndx, - p->sh_type, p->contents->data(), p->reloc_count, - p->output_section, p->needs_special_offset_handling, - this->local_symbol_count_, - local_symbols); + // When garbage collection is on, unreferenced sections are not included + // in the link that would have been included normally. This is known only + // after Read_relocs hence this check has to be done again. + if (parameters->options().gc_sections() || parameters->options().icf()) + { + if (p->output_section == NULL) + continue; + } + if (!parameters->options().relocatable()) + { + // As noted above, when not generating an object file, we + // only scan allocated sections. We may see a non-allocated + // section here if we are emitting relocs. + if (p->is_data_section_allocated) + target->scan_relocs(options, symtab, layout, this, p->data_shndx, + p->sh_type, p->contents->data(), + p->reloc_count, p->output_section, + p->needs_special_offset_handling, + this->local_symbol_count_, + local_symbols); + if (parameters->options().emit_relocs()) + this->emit_relocs_scan(options, symtab, layout, local_symbols, p); + } + else + { + Relocatable_relocs* rr = this->relocatable_relocs(p->reloc_shndx); + gold_assert(rr != NULL); + rr->set_reloc_count(p->reloc_count); + target->scan_relocatable_relocs(options, symtab, layout, this, + p->data_shndx, p->sh_type, + p->contents->data(), + p->reloc_count, + p->output_section, + p->needs_special_offset_handling, + this->local_symbol_count_, + local_symbols, + rr); + } + delete p->contents; p->contents = NULL; } @@ -318,6 +467,98 @@ Sized_relobj::do_scan_relocs(const General_options& options, } } +// This is a strategy class we use when scanning for --emit-relocs. + +template +class Emit_relocs_strategy +{ + public: + // A local non-section symbol. + inline Relocatable_relocs::Reloc_strategy + local_non_section_strategy(unsigned int, Relobj*, unsigned int) + { return Relocatable_relocs::RELOC_COPY; } + + // A local section symbol. + inline Relocatable_relocs::Reloc_strategy + local_section_strategy(unsigned int, Relobj*) + { + if (sh_type == elfcpp::SHT_RELA) + return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA; + else + { + // The addend is stored in the section contents. Since this + // is not a relocatable link, we are going to apply the + // relocation contents to the section as usual. This means + // that we have no way to record the original addend. If the + // original addend is not zero, there is basically no way for + // the user to handle this correctly. Caveat emptor. + return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_0; + } + } + + // A global symbol. + inline Relocatable_relocs::Reloc_strategy + global_strategy(unsigned int, Relobj*, unsigned int) + { return Relocatable_relocs::RELOC_COPY; } +}; + +// Scan the input relocations for --emit-relocs. + +template +void +Sized_relobj::emit_relocs_scan( + const General_options& options, + Symbol_table* symtab, + Layout* layout, + const unsigned char* plocal_syms, + const Read_relocs_data::Relocs_list::iterator& p) +{ + Relocatable_relocs* rr = this->relocatable_relocs(p->reloc_shndx); + gold_assert(rr != NULL); + rr->set_reloc_count(p->reloc_count); + + if (p->sh_type == elfcpp::SHT_REL) + this->emit_relocs_scan_reltype(options, symtab, layout, + plocal_syms, p, rr); + else + { + gold_assert(p->sh_type == elfcpp::SHT_RELA); + this->emit_relocs_scan_reltype(options, symtab, + layout, plocal_syms, p, + rr); + } +} + +// Scan the input relocation for --emit-relocs, templatized on the +// type of the relocation section. + +template +template +void +Sized_relobj::emit_relocs_scan_reltype( + const General_options& options, + Symbol_table* symtab, + Layout* layout, + const unsigned char* plocal_syms, + const Read_relocs_data::Relocs_list::iterator& p, + Relocatable_relocs* rr) +{ + scan_relocatable_relocs >( + options, + symtab, + layout, + this, + p->data_shndx, + p->contents->data(), + p->reloc_count, + p->output_section, + p->needs_special_offset_handling, + this->local_symbol_count_, + plocal_syms, + rr); +} + // Relocate the input sections and write out the local symbols. template @@ -332,7 +573,7 @@ Sized_relobj::do_relocate(const General_options& options, // Read the section headers. const unsigned char* pshdrs = this->get_view(this->elf_file_.shoff(), shnum * This::shdr_size, - true); + true, true); Views views; views.resize(shnum); @@ -343,10 +584,18 @@ Sized_relobj::do_relocate(const General_options& options, this->write_sections(pshdrs, of, &views); + // To speed up relocations, we set up hash tables for fast lookup of + // input offsets to output addresses. + this->initialize_input_to_output_maps(); + // Apply relocations. this->relocate_sections(options, symtab, layout, pshdrs, &views); + // After we've done the relocations, we release the hash tables, + // since we no longer need them. + this->free_input_to_output_maps(); + // Write out the accumulated views. for (unsigned int i = 1; i < shnum; ++i) { @@ -366,9 +615,22 @@ Sized_relobj::do_relocate(const General_options& options, } // Write out the local symbols. - this->write_local_symbols(of, layout->sympool(), layout->dynpool()); + this->write_local_symbols(of, layout->sympool(), layout->dynpool(), + layout->symtab_xindex(), layout->dynsym_xindex()); + + // We should no longer need the local symbol values. + this->clear_local_symbols(); } +// Sort a Read_multiple vector by file offset. +struct Read_multiple_compare +{ + inline bool + operator()(const File_read::Read_multiple_entry& rme1, + const File_read::Read_multiple_entry& rme2) const + { return rme1.file_offset < rme2.file_offset; } +}; + // Write section data to the output file. PSHDRS points to the // section headers. Record the views in *PVIEWS for use when // relocating. @@ -377,10 +639,14 @@ template void Sized_relobj::write_sections(const unsigned char* pshdrs, Output_file* of, - Views* pviews) const + Views* pviews) { unsigned int shnum = this->shnum(); - const std::vector& map_sections(this->map_to_output()); + const Output_sections& out_sections(this->output_sections()); + const std::vector
& out_offsets(this->section_offsets_); + + File_read::Read_multiple rm; + bool is_sorted = true; const unsigned char* p = pshdrs + This::shdr_size; for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size) @@ -389,21 +655,46 @@ Sized_relobj::write_sections(const unsigned char* pshdrs, pvs->view = NULL; - const Output_section* os = map_sections[i].output_section; + const Output_section* os = out_sections[i]; if (os == NULL) continue; - off_t output_offset = map_sections[i].offset; + Address output_offset = out_offsets[i]; typename This::Shdr shdr(p); if (shdr.get_sh_type() == elfcpp::SHT_NOBITS) continue; + if ((parameters->options().relocatable() + || parameters->options().emit_relocs()) + && (shdr.get_sh_type() == elfcpp::SHT_REL + || shdr.get_sh_type() == elfcpp::SHT_RELA) + && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0) + { + // This is a reloc section in a relocatable link or when + // emitting relocs. We don't need to read the input file. + // The size and file offset are stored in the + // Relocatable_relocs structure. + Relocatable_relocs* rr = this->relocatable_relocs(i); + gold_assert(rr != NULL); + Output_data* posd = rr->output_data(); + gold_assert(posd != NULL); + + pvs->offset = posd->offset(); + pvs->view_size = posd->data_size(); + pvs->view = of->get_output_view(pvs->offset, pvs->view_size); + pvs->address = posd->address(); + pvs->is_input_output_view = false; + pvs->is_postprocessing_view = false; + + continue; + } + // In the normal case, this input section is simply mapped to // the output section at offset OUTPUT_OFFSET. - // However, if OUTPUT_OFFSET == -1, then input data is handled - // specially--e.g., a .eh_frame section. The relocation + // However, if OUTPUT_OFFSET == INVALID_ADDRESS, then input data is + // handled specially--e.g., a .eh_frame section. The relocation // routines need to check for each reloc where it should be // applied. For this case, we need an input/output view for the // entire contents of the section in the output file. We don't @@ -420,21 +711,22 @@ Sized_relobj::write_sections(const unsigned char* pshdrs, // final data to the output file. off_t output_section_offset; - off_t output_section_size; + Address output_section_size; if (!os->requires_postprocessing()) { output_section_offset = os->offset(); - output_section_size = os->data_size(); + output_section_size = convert_types(os->data_size()); } else { output_section_offset = 0; - output_section_size = os->postprocessing_buffer_size(); + output_section_size = + convert_types(os->postprocessing_buffer_size()); } off_t view_start; section_size_type view_size; - if (output_offset != -1) + if (output_offset != invalid_address) { view_start = output_section_offset + output_offset; view_size = convert_to_section_size_type(shdr.get_sh_size()); @@ -448,38 +740,55 @@ Sized_relobj::write_sections(const unsigned char* pshdrs, if (view_size == 0) continue; - gold_assert(output_offset == -1 - || (output_offset >= 0 - && output_offset + view_size <= output_section_size)); + gold_assert(output_offset == invalid_address + || output_offset + view_size <= output_section_size); unsigned char* view; if (os->requires_postprocessing()) { unsigned char* buffer = os->postprocessing_buffer(); view = buffer + view_start; - if (output_offset != -1) - this->read(shdr.get_sh_offset(), view_size, view); + if (output_offset != invalid_address) + { + off_t sh_offset = shdr.get_sh_offset(); + if (!rm.empty() && rm.back().file_offset > sh_offset) + is_sorted = false; + rm.push_back(File_read::Read_multiple_entry(sh_offset, + view_size, view)); + } } else { - if (output_offset == -1) + if (output_offset == invalid_address) view = of->get_input_output_view(view_start, view_size); else { view = of->get_output_view(view_start, view_size); - this->read(shdr.get_sh_offset(), view_size, view); + off_t sh_offset = shdr.get_sh_offset(); + if (!rm.empty() && rm.back().file_offset > sh_offset) + is_sorted = false; + rm.push_back(File_read::Read_multiple_entry(sh_offset, + view_size, view)); } } pvs->view = view; pvs->address = os->address(); - if (output_offset != -1) + if (output_offset != invalid_address) pvs->address += output_offset; pvs->offset = view_start; pvs->view_size = view_size; - pvs->is_input_output_view = output_offset == -1; + pvs->is_input_output_view = output_offset == invalid_address; pvs->is_postprocessing_view = os->requires_postprocessing(); } + + // Actually read the data. + if (!rm.empty()) + { + if (!is_sorted) + std::sort(rm.begin(), rm.end(), Read_multiple_compare()); + this->read_multiple(rm); + } } // Relocate section data. VIEWS points to the section data as views @@ -495,9 +804,11 @@ Sized_relobj::relocate_sections( Views* pviews) { unsigned int shnum = this->shnum(); - Sized_target* target = this->sized_target(); + Sized_target* target = + parameters->sized_target(); - const std::vector& map_sections(this->map_to_output()); + const Output_sections& out_sections(this->output_sections()); + const std::vector
& out_offsets(this->section_offsets_); Relocate_info relinfo; relinfo.options = &options; @@ -514,7 +825,11 @@ Sized_relobj::relocate_sections( if (sh_type != elfcpp::SHT_REL && sh_type != elfcpp::SHT_RELA) continue; - unsigned int index = shdr.get_sh_info(); + off_t sh_size = shdr.get_sh_size(); + if (sh_size == 0) + continue; + + unsigned int index = this->adjust_shndx(shdr.get_sh_info()); if (index >= this->shnum()) { this->error(_("relocation section %u has bad info %u"), @@ -522,28 +837,29 @@ Sized_relobj::relocate_sections( continue; } - Output_section* os = map_sections[index].output_section; + Output_section* os = out_sections[index]; if (os == NULL) { // This relocation section is against a section which we // discarded. continue; } - off_t output_offset = map_sections[index].offset; + Address output_offset = out_offsets[index]; gold_assert((*pviews)[index].view != NULL); + if (parameters->options().relocatable()) + gold_assert((*pviews)[i].view != NULL); - if (shdr.get_sh_link() != this->symtab_shndx_) + if (this->adjust_shndx(shdr.get_sh_link()) != this->symtab_shndx_) { gold_error(_("relocation section %u uses unexpected " "symbol table %u"), - i, shdr.get_sh_link()); + i, this->adjust_shndx(shdr.get_sh_link())); continue; } - off_t sh_size = shdr.get_sh_size(); const unsigned char* prelocs = this->get_view(shdr.get_sh_offset(), - sh_size, false); + sh_size, true, false); unsigned int reloc_size; if (sh_type == elfcpp::SHT_REL) @@ -567,161 +883,424 @@ Sized_relobj::relocate_sections( continue; } - gold_assert(output_offset != -1 + gold_assert(output_offset != invalid_address || this->relocs_must_follow_section_writes()); relinfo.reloc_shndx = i; relinfo.data_shndx = index; - target->relocate_section(&relinfo, - sh_type, - prelocs, - reloc_count, - os, - output_offset == -1, - (*pviews)[index].view, - (*pviews)[index].address, - (*pviews)[index].view_size); + unsigned char* view = (*pviews)[index].view; + Address address = (*pviews)[index].address; + section_size_type view_size = (*pviews)[index].view_size; + + Reloc_symbol_changes* reloc_map = NULL; + if (this->uses_split_stack() && output_offset != invalid_address) + { + typename This::Shdr data_shdr(pshdrs + index * This::shdr_size); + if ((data_shdr.get_sh_flags() & elfcpp::SHF_EXECINSTR) != 0) + this->split_stack_adjust(symtab, pshdrs, sh_type, index, + prelocs, reloc_count, view, view_size, + &reloc_map); + } + + if (!parameters->options().relocatable()) + { + target->relocate_section(&relinfo, sh_type, prelocs, reloc_count, os, + output_offset == invalid_address, + view, address, view_size, reloc_map); + if (parameters->options().emit_relocs()) + this->emit_relocs(&relinfo, i, sh_type, prelocs, reloc_count, + os, output_offset, view, address, view_size, + (*pviews)[i].view, (*pviews)[i].view_size); + } + else + { + Relocatable_relocs* rr = this->relocatable_relocs(i); + target->relocate_for_relocatable(&relinfo, sh_type, prelocs, + reloc_count, os, output_offset, rr, + view, address, view_size, + (*pviews)[i].view, + (*pviews)[i].view_size); + } } } -// Copy_relocs::Copy_reloc_entry methods. - -// Return whether we should emit this reloc. We should emit it if the -// symbol is still defined in a dynamic object. If we should not emit -// it, we clear it, to save ourselves the test next time. +// Emit the relocs for --emit-relocs. template -bool -Copy_relocs::Copy_reloc_entry::should_emit() +void +Sized_relobj::emit_relocs( + const Relocate_info* relinfo, + unsigned int i, + unsigned int sh_type, + const unsigned char* prelocs, + size_t reloc_count, + Output_section* output_section, + typename elfcpp::Elf_types::Elf_Addr offset_in_output_section, + unsigned char* view, + typename elfcpp::Elf_types::Elf_Addr address, + section_size_type view_size, + unsigned char* reloc_view, + section_size_type reloc_view_size) { - if (this->sym_ == NULL) - return false; - if (this->sym_->is_from_dynobj()) - return true; - this->sym_ = NULL; - return false; + if (sh_type == elfcpp::SHT_REL) + this->emit_relocs_reltype(relinfo, i, prelocs, + reloc_count, output_section, + offset_in_output_section, + view, address, view_size, + reloc_view, reloc_view_size); + else + { + gold_assert(sh_type == elfcpp::SHT_RELA); + this->emit_relocs_reltype(relinfo, i, prelocs, + reloc_count, output_section, + offset_in_output_section, + view, address, view_size, + reloc_view, reloc_view_size); + } } -// Emit a reloc into a SHT_REL section. +// Emit the relocs for --emit-relocs, templatized on the type of the +// relocation section. template +template void -Copy_relocs::Copy_reloc_entry::emit( - Output_data_reloc* reloc_data) +Sized_relobj::emit_relocs_reltype( + const Relocate_info* relinfo, + unsigned int i, + const unsigned char* prelocs, + size_t reloc_count, + Output_section* output_section, + typename elfcpp::Elf_types::Elf_Addr offset_in_output_section, + unsigned char* view, + typename elfcpp::Elf_types::Elf_Addr address, + section_size_type view_size, + unsigned char* reloc_view, + section_size_type reloc_view_size) { - this->sym_->set_needs_dynsym_entry(); - reloc_data->add_global(this->sym_, this->reloc_type_, this->output_section_, - this->relobj_, this->shndx_, this->address_); + const Relocatable_relocs* rr = this->relocatable_relocs(i); + relocate_for_relocatable( + relinfo, + prelocs, + reloc_count, + output_section, + offset_in_output_section, + rr, + view, + address, + view_size, + reloc_view, + reloc_view_size); } -// Emit a reloc into a SHT_RELA section. +// Create merge hash tables for the local symbols. These are used to +// speed up relocations. template void -Copy_relocs::Copy_reloc_entry::emit( - Output_data_reloc* reloc_data) +Sized_relobj::initialize_input_to_output_maps() { - this->sym_->set_needs_dynsym_entry(); - reloc_data->add_global(this->sym_, this->reloc_type_, this->output_section_, - this->relobj_, this->shndx_, this->address_, - this->addend_); + const unsigned int loccount = this->local_symbol_count_; + for (unsigned int i = 1; i < loccount; ++i) + { + Symbol_value& lv(this->local_values_[i]); + lv.initialize_input_to_output_map(this); + } } -// Copy_relocs methods. - -// Return whether we need a COPY reloc for a relocation against GSYM. -// The relocation is being applied to section SHNDX in OBJECT. +// Free merge hash tables for the local symbols. template -bool -Copy_relocs::need_copy_reloc( - const General_options*, - Relobj* object, - unsigned int shndx, - Sized_symbol* sym) +void +Sized_relobj::free_input_to_output_maps() { - // FIXME: Handle -z nocopyrelocs. - - if (sym->symsize() == 0) - return false; - - // If this is a readonly section, then we need a COPY reloc. - // Otherwise we can use a dynamic reloc. - if ((object->section_flags(shndx) & elfcpp::SHF_WRITE) == 0) - return true; - - return false; + const unsigned int loccount = this->local_symbol_count_; + for (unsigned int i = 1; i < loccount; ++i) + { + Symbol_value& lv(this->local_values_[i]); + lv.free_input_to_output_map(); + } } -// Save a Rel reloc. +// If an object was compiled with -fsplit-stack, this is called to +// check whether any relocations refer to functions defined in objects +// which were not compiled with -fsplit-stack. If they were, then we +// need to apply some target-specific adjustments to request +// additional stack space. template void -Copy_relocs::save( - Symbol* sym, - Relobj* relobj, +Sized_relobj::split_stack_adjust( + const Symbol_table* symtab, + const unsigned char* pshdrs, + unsigned int sh_type, unsigned int shndx, - Output_section* output_section, - const elfcpp::Rel& rel) + const unsigned char* prelocs, + size_t reloc_count, + unsigned char* view, + section_size_type view_size, + Reloc_symbol_changes** reloc_map) { - unsigned int reloc_type = elfcpp::elf_r_type(rel.get_r_info()); - this->entries_.push_back(Copy_reloc_entry(sym, reloc_type, relobj, shndx, - output_section, - rel.get_r_offset(), 0)); + if (sh_type == elfcpp::SHT_REL) + this->split_stack_adjust_reltype(symtab, pshdrs, shndx, + prelocs, reloc_count, + view, view_size, + reloc_map); + else + { + gold_assert(sh_type == elfcpp::SHT_RELA); + this->split_stack_adjust_reltype(symtab, pshdrs, shndx, + prelocs, reloc_count, + view, view_size, + reloc_map); + } } -// Save a Rela reloc. +// Adjust for -fsplit-stack, templatized on the type of the relocation +// section. template +template void -Copy_relocs::save( - Symbol* sym, - Relobj* relobj, +Sized_relobj::split_stack_adjust_reltype( + const Symbol_table* symtab, + const unsigned char* pshdrs, unsigned int shndx, - Output_section* output_section, - const elfcpp::Rela& rela) + const unsigned char* prelocs, + size_t reloc_count, + unsigned char* view, + section_size_type view_size, + Reloc_symbol_changes** reloc_map) { - unsigned int reloc_type = elfcpp::elf_r_type(rela.get_r_info()); - this->entries_.push_back(Copy_reloc_entry(sym, reloc_type, relobj, shndx, - output_section, - rela.get_r_offset(), - rela.get_r_addend())); -} + typedef typename Reloc_types::Reloc Reltype; + const int reloc_size = Reloc_types::reloc_size; -// Return whether there are any relocs to emit. We don't want to emit -// a reloc if the symbol is no longer defined in a dynamic object. + size_t local_count = this->local_symbol_count(); -template -bool -Copy_relocs::any_to_emit() -{ - for (typename Copy_reloc_entries::iterator p = this->entries_.begin(); - p != this->entries_.end(); + std::vector non_split_refs; + + const unsigned char* pr = prelocs; + for (size_t i = 0; i < reloc_count; ++i, pr += reloc_size) + { + Reltype reloc(pr); + + typename elfcpp::Elf_types::Elf_WXword r_info = reloc.get_r_info(); + unsigned int r_sym = elfcpp::elf_r_sym(r_info); + if (r_sym < local_count) + continue; + + const Symbol* gsym = this->global_symbol(r_sym); + gold_assert(gsym != NULL); + if (gsym->is_forwarder()) + gsym = symtab->resolve_forwards(gsym); + + // See if this relocation refers to a function defined in an + // object compiled without -fsplit-stack. Note that we don't + // care about the type of relocation--this means that in some + // cases we will ask for a large stack unnecessarily, but this + // is not fatal. FIXME: Some targets have symbols which are + // functions but are not type STT_FUNC, e.g., STT_ARM_TFUNC. + if (gsym->type() == elfcpp::STT_FUNC + && !gsym->is_undefined() + && gsym->source() == Symbol::FROM_OBJECT + && !gsym->object()->uses_split_stack()) + { + section_offset_type offset = + convert_to_section_size_type(reloc.get_r_offset()); + non_split_refs.push_back(offset); + } + } + + if (non_split_refs.empty()) + return; + + // At this point, every entry in NON_SPLIT_REFS indicates a + // relocation which refers to a function in an object compiled + // without -fsplit-stack. We now have to convert that list into a + // set of offsets to functions. First, we find all the functions. + + Function_offsets function_offsets; + this->find_functions(pshdrs, shndx, &function_offsets); + if (function_offsets.empty()) + return; + + // Now get a list of the function with references to non split-stack + // code. + + Function_offsets calls_non_split; + for (std::vector::const_iterator p + = non_split_refs.begin(); + p != non_split_refs.end(); ++p) { - if (p->should_emit()) - return true; + Function_offsets::const_iterator low = function_offsets.lower_bound(*p); + if (low == function_offsets.end()) + --low; + else if (low->first == *p) + ; + else if (low == function_offsets.begin()) + continue; + else + --low; + + calls_non_split.insert(*low); + } + if (calls_non_split.empty()) + return; + + // Now we have a set of functions to adjust. The adjustments are + // target specific. Besides changing the output section view + // however, it likes, the target may request a relocation change + // from one global symbol name to another. + + for (Function_offsets::const_iterator p = calls_non_split.begin(); + p != calls_non_split.end(); + ++p) + { + std::string from; + std::string to; + parameters->target().calls_non_split(this, shndx, p->first, p->second, + view, view_size, &from, &to); + if (!from.empty()) + { + gold_assert(!to.empty()); + Symbol* tosym = NULL; + + // Find relocations in the relevant function which are for + // FROM. + pr = prelocs; + for (size_t i = 0; i < reloc_count; ++i, pr += reloc_size) + { + Reltype reloc(pr); + + typename elfcpp::Elf_types::Elf_WXword r_info = + reloc.get_r_info(); + unsigned int r_sym = elfcpp::elf_r_sym(r_info); + if (r_sym < local_count) + continue; + + section_offset_type offset = + convert_to_section_size_type(reloc.get_r_offset()); + if (offset < p->first + || (offset + >= (p->first + + static_cast(p->second)))) + continue; + + const Symbol* gsym = this->global_symbol(r_sym); + if (from == gsym->name()) + { + if (tosym == NULL) + { + tosym = symtab->lookup(to.c_str()); + if (tosym == NULL) + { + this->error(_("could not convert call " + "to '%s' to '%s'"), + from.c_str(), to.c_str()); + break; + } + } + + if (*reloc_map == NULL) + *reloc_map = new Reloc_symbol_changes(reloc_count); + (*reloc_map)->set(i, tosym); + } + } + } } - return false; } -// Emit relocs. +// Find all the function in this object defined in section SHNDX. +// Store their offsets in the section in FUNCTION_OFFSETS. template -template void -Copy_relocs::emit( - Output_data_reloc* reloc_data) +Sized_relobj::find_functions( + const unsigned char* pshdrs, + unsigned int shndx, + Sized_relobj::Function_offsets* function_offsets) { - for (typename Copy_reloc_entries::iterator p = this->entries_.begin(); - p != this->entries_.end(); - ++p) + // We need to read the symbols to find the functions. If we wanted + // to, we could cache reading the symbols across all sections in the + // object. + const unsigned int symtab_shndx = this->symtab_shndx_; + typename This::Shdr symtabshdr(pshdrs + symtab_shndx * This::shdr_size); + gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB); + + typename elfcpp::Elf_types::Elf_WXword sh_size = + symtabshdr.get_sh_size(); + const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(), + sh_size, true, true); + + const int sym_size = This::sym_size; + const unsigned int symcount = sh_size / sym_size; + for (unsigned int i = 0; i < symcount; ++i, psyms += sym_size) { - if (p->should_emit()) - p->emit(reloc_data); + typename elfcpp::Sym isym(psyms); + + // FIXME: Some targets can have functions which do not have type + // STT_FUNC, e.g., STT_ARM_TFUNC. + if (isym.get_st_type() != elfcpp::STT_FUNC + || isym.get_st_size() == 0) + continue; + + bool is_ordinary; + unsigned int sym_shndx = this->adjust_sym_shndx(i, isym.get_st_shndx(), + &is_ordinary); + if (!is_ordinary || sym_shndx != shndx) + continue; + + section_offset_type value = + convert_to_section_size_type(isym.get_st_value()); + section_size_type fnsize = + convert_to_section_size_type(isym.get_st_size()); + + (*function_offsets)[value] = fnsize; } } +// Class Merged_symbol_value. + +template +void +Merged_symbol_value::initialize_input_to_output_map( + const Relobj* object, + unsigned int input_shndx) +{ + Object_merge_map* map = object->merge_map(); + map->initialize_input_to_output_map(input_shndx, + this->output_start_address_, + &this->output_addresses_); +} + +// Get the output value corresponding to an input offset if we +// couldn't find it in the hash table. + +template +typename elfcpp::Elf_types::Elf_Addr +Merged_symbol_value::value_from_output_section( + const Relobj* object, + unsigned int input_shndx, + typename elfcpp::Elf_types::Elf_Addr input_offset) const +{ + section_offset_type output_offset; + bool found = object->merge_map()->get_output_offset(NULL, input_shndx, + input_offset, + &output_offset); + + // If this assertion fails, it means that some relocation was + // against a portion of an input merge section which we didn't map + // to the output file and we didn't explicitly discard. We should + // always map all portions of input merge sections. + gold_assert(found); + + if (output_offset == -1) + return 0; + else + return this->output_start_address_ + output_offset; +} + // Track_relocs methods. // Initialize the class to track the relocs. This gets the object, @@ -818,8 +1397,7 @@ Track_relocs::advance(off_t offset) return ret; } -// Instantiate the templates we need. We could use the configure -// script to restrict this to only the ones for implemented targets. +// Instantiate the templates we need. #ifdef HAVE_TARGET_32_LITTLE template @@ -848,7 +1426,7 @@ Sized_relobj<64, true>::do_read_relocs(Read_relocs_data* rd); #ifdef HAVE_TARGET_32_LITTLE template void -Sized_relobj<32, false>::do_scan_relocs(const General_options& options, +Sized_relobj<32, false>::do_gc_process_relocs(const General_options& options, Symbol_table* symtab, Layout* layout, Read_relocs_data* rd); @@ -857,7 +1435,7 @@ Sized_relobj<32, false>::do_scan_relocs(const General_options& options, #ifdef HAVE_TARGET_32_BIG template void -Sized_relobj<32, true>::do_scan_relocs(const General_options& options, +Sized_relobj<32, true>::do_gc_process_relocs(const General_options& options, Symbol_table* symtab, Layout* layout, Read_relocs_data* rd); @@ -866,7 +1444,7 @@ Sized_relobj<32, true>::do_scan_relocs(const General_options& options, #ifdef HAVE_TARGET_64_LITTLE template void -Sized_relobj<64, false>::do_scan_relocs(const General_options& options, +Sized_relobj<64, false>::do_gc_process_relocs(const General_options& options, Symbol_table* symtab, Layout* layout, Read_relocs_data* rd); @@ -875,7 +1453,7 @@ Sized_relobj<64, false>::do_scan_relocs(const General_options& options, #ifdef HAVE_TARGET_64_BIG template void -Sized_relobj<64, true>::do_scan_relocs(const General_options& options, +Sized_relobj<64, true>::do_gc_process_relocs(const General_options& options, Symbol_table* symtab, Layout* layout, Read_relocs_data* rd); @@ -884,113 +1462,93 @@ Sized_relobj<64, true>::do_scan_relocs(const General_options& options, #ifdef HAVE_TARGET_32_LITTLE template void -Sized_relobj<32, false>::do_relocate(const General_options& options, - const Symbol_table* symtab, - const Layout* layout, - Output_file* of); +Sized_relobj<32, false>::do_scan_relocs(const General_options& options, + Symbol_table* symtab, + Layout* layout, + Read_relocs_data* rd); #endif #ifdef HAVE_TARGET_32_BIG template void -Sized_relobj<32, true>::do_relocate(const General_options& options, - const Symbol_table* symtab, - const Layout* layout, - Output_file* of); +Sized_relobj<32, true>::do_scan_relocs(const General_options& options, + Symbol_table* symtab, + Layout* layout, + Read_relocs_data* rd); #endif #ifdef HAVE_TARGET_64_LITTLE template void -Sized_relobj<64, false>::do_relocate(const General_options& options, - const Symbol_table* symtab, - const Layout* layout, - Output_file* of); +Sized_relobj<64, false>::do_scan_relocs(const General_options& options, + Symbol_table* symtab, + Layout* layout, + Read_relocs_data* rd); #endif #ifdef HAVE_TARGET_64_BIG template void -Sized_relobj<64, true>::do_relocate(const General_options& options, - const Symbol_table* symtab, - const Layout* layout, - Output_file* of); -#endif - -#ifdef HAVE_TARGET_32_LITTLE -template -class Copy_relocs<32, false>; -#endif - -#ifdef HAVE_TARGET_32_BIG -template -class Copy_relocs<32, true>; -#endif - -#ifdef HAVE_TARGET_64_LITTLE -template -class Copy_relocs<64, false>; -#endif - -#ifdef HAVE_TARGET_64_BIG -template -class Copy_relocs<64, true>; +Sized_relobj<64, true>::do_scan_relocs(const General_options& options, + Symbol_table* symtab, + Layout* layout, + Read_relocs_data* rd); #endif #ifdef HAVE_TARGET_32_LITTLE template void -Copy_relocs<32, false>::emit( - Output_data_reloc*); +Sized_relobj<32, false>::do_relocate(const General_options& options, + const Symbol_table* symtab, + const Layout* layout, + Output_file* of); #endif #ifdef HAVE_TARGET_32_BIG template void -Copy_relocs<32, true>::emit( - Output_data_reloc*); +Sized_relobj<32, true>::do_relocate(const General_options& options, + const Symbol_table* symtab, + const Layout* layout, + Output_file* of); #endif #ifdef HAVE_TARGET_64_LITTLE template void -Copy_relocs<64, false>::emit( - Output_data_reloc*); +Sized_relobj<64, false>::do_relocate(const General_options& options, + const Symbol_table* symtab, + const Layout* layout, + Output_file* of); #endif #ifdef HAVE_TARGET_64_BIG template void -Copy_relocs<64, true>::emit( - Output_data_reloc*); +Sized_relobj<64, true>::do_relocate(const General_options& options, + const Symbol_table* symtab, + const Layout* layout, + Output_file* of); #endif -#ifdef HAVE_TARGET_32_LITTLE +#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) template -void -Copy_relocs<32, false>::emit( - Output_data_reloc*); +class Merged_symbol_value<32>; #endif -#ifdef HAVE_TARGET_32_BIG +#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) template -void -Copy_relocs<32, true>::emit( - Output_data_reloc*); +class Merged_symbol_value<64>; #endif -#ifdef HAVE_TARGET_64_LITTLE +#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) template -void -Copy_relocs<64, false>::emit( - Output_data_reloc*); +class Symbol_value<32>; #endif -#ifdef HAVE_TARGET_64_BIG +#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) template -void -Copy_relocs<64, true>::emit( - Output_data_reloc*); +class Symbol_value<64>; #endif #ifdef HAVE_TARGET_32_LITTLE