// reloc.cc -- relocate input files for gold. // Copyright (C) 2006-2017 Free Software Foundation, Inc. // Written by Ian Lance Taylor . // This file is part of gold. // This program is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, // MA 02110-1301, USA. #include "gold.h" #include #include "workqueue.h" #include "layout.h" #include "symtab.h" #include "output.h" #include "merge.h" #include "object.h" #include "target-reloc.h" #include "reloc.h" #include "icf.h" #include "compressed_output.h" #include "incremental.h" namespace gold { // Read_relocs methods. // These tasks just read the relocation information from the file. // After reading it, the start another task to process the // information. These tasks requires access to the file. Task_token* Read_relocs::is_runnable() { return this->object_->is_locked() ? this->object_->token() : NULL; } // Lock the file. void Read_relocs::locks(Task_locker* tl) { Task_token* token = this->object_->token(); if (token != NULL) tl->add(this, token); } // Read the relocations and then start a Scan_relocs_task. void 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(); // 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_enabled()) { workqueue->queue_next(new Gc_process_relocs(this->symtab_, this->layout_, this->object_, rd, this->this_blocker_, this->next_blocker_)); } else { workqueue->queue_next(new Scan_relocs(this->symtab_, this->layout_, this->object_, rd, this->this_blocker_, this->next_blocker_)); } } // Return a debugging name for the task. std::string Read_relocs::get_name() const { return "Read_relocs " + this->object_->name(); } // Gc_process_relocs methods. Gc_process_relocs::~Gc_process_relocs() { if (this->this_blocker_ != NULL) delete this->this_blocker_; } // 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. This is blocked // by THIS_BLOCKER_. It unblocks NEXT_BLOCKER_. Task_token* Gc_process_relocs::is_runnable() { if (this->this_blocker_ != NULL && this->this_blocker_->is_blocked()) return this->this_blocker_; 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->next_blocker_); } void Gc_process_relocs::run(Workqueue*) { this->object_->gc_process_relocs(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. Scan_relocs::~Scan_relocs() { if (this->this_blocker_ != NULL) delete this->this_blocker_; } // These tasks scan the relocations read by Read_relocs and mark up // the symbol table to indicate which relocations are required. We // use a lock on the symbol table to keep them from interfering with // each other. Task_token* Scan_relocs::is_runnable() { if (this->this_blocker_ != NULL && this->this_blocker_->is_blocked()) return this->this_blocker_; if (this->object_->is_locked()) return this->object_->token(); return NULL; } // Return the locks we hold: one on the file, one on the symbol table // and one blocker. void Scan_relocs::locks(Task_locker* tl) { Task_token* token = this->object_->token(); if (token != NULL) tl->add(this, token); tl->add(this, this->next_blocker_); } // Scan the relocs. void Scan_relocs::run(Workqueue*) { this->object_->scan_relocs(this->symtab_, this->layout_, this->rd_); delete this->rd_; this->rd_ = NULL; this->object_->release(); } // Return a debugging name for the task. std::string Scan_relocs::get_name() const { return "Scan_relocs " + this->object_->name(); } // Relocate_task methods. // We may have to wait for the output sections to be written. Task_token* Relocate_task::is_runnable() { if (this->object_->relocs_must_follow_section_writes() && this->output_sections_blocker_->is_blocked()) return this->output_sections_blocker_; if (this->object_->is_locked()) return this->object_->token(); return NULL; } // We want to lock the file while we run. We want to unblock // INPUT_SECTIONS_BLOCKER and FINAL_BLOCKER when we are done. // INPUT_SECTIONS_BLOCKER may be NULL. void Relocate_task::locks(Task_locker* tl) { if (this->input_sections_blocker_ != NULL) tl->add(this, this->input_sections_blocker_); tl->add(this, this->final_blocker_); Task_token* token = this->object_->token(); if (token != NULL) tl->add(this, token); } // Run the task. void Relocate_task::run(Workqueue*) { this->object_->relocate(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(); } // Return a debugging name for the task. std::string Relocate_task::get_name() const { return "Relocate_task " + this->object_->name(); } // Read the relocs and local symbols from the object file and store // the information in RD. template void Sized_relobj_file::do_read_relocs(Read_relocs_data* rd) { rd->relocs.clear(); unsigned int shnum = this->shnum(); if (shnum == 0) return; rd->relocs.reserve(shnum / 2); 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); // 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) { typename This::Shdr shdr(ps); unsigned int sh_type = shdr.get_sh_type(); if (sh_type != elfcpp::SHT_REL && sh_type != elfcpp::SHT_RELA) continue; unsigned int shndx = this->adjust_shndx(shdr.get_sh_info()); if (shndx >= shnum) { this->error(_("relocation section %u has bad info %u"), i, shndx); continue; } 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 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); bool is_section_allocated = ((secshdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0); if (!is_section_allocated && !parameters->options().relocatable() && !parameters->options().emit_relocs() && !parameters->incremental()) continue; if (this->adjust_shndx(shdr.get_sh_link()) != this->symtab_shndx_) { this->error(_("relocation section %u uses unexpected " "symbol table %u"), i, this->adjust_shndx(shdr.get_sh_link())); continue; } off_t sh_size = shdr.get_sh_size(); if (sh_size == 0) continue; unsigned int reloc_size; if (sh_type == elfcpp::SHT_REL) reloc_size = elfcpp::Elf_sizes::rel_size; else reloc_size = elfcpp::Elf_sizes::rela_size; if (reloc_size != shdr.get_sh_entsize()) { this->error(_("unexpected entsize for reloc section %u: %lu != %u"), i, static_cast(shdr.get_sh_entsize()), reloc_size); continue; } size_t reloc_count = sh_size / reloc_size; if (static_cast(reloc_count * reloc_size) != sh_size) { this->error(_("reloc section %u size %lu uneven"), i, static_cast(sh_size)); continue; } rd->relocs.push_back(Section_relocs()); Section_relocs& sr(rd->relocs.back()); sr.reloc_shndx = i; sr.data_shndx = shndx; sr.contents = this->get_lasting_view(shdr.get_sh_offset(), sh_size, true, true); sr.sh_type = sh_type; sr.reloc_count = reloc_count; sr.output_section = os; sr.needs_special_offset_handling = out_offsets[shndx] == invalid_address; sr.is_data_section_allocated = is_section_allocated; } // Read the local symbols. gold_assert(this->symtab_shndx_ != -1U); if (this->symtab_shndx_ == 0 || this->local_symbol_count_ == 0) rd->local_symbols = NULL; else { typename This::Shdr symtabshdr(pshdrs + this->symtab_shndx_ * This::shdr_size); gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB); const int sym_size = This::sym_size; const unsigned int loccount = this->local_symbol_count_; 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, true); } } // Process the relocs to generate mappings from source sections to referenced // sections. This is used during garbage collection to determine garbage // sections. template void Sized_relobj_file::do_gc_process_relocs(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(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. template void Sized_relobj_file::do_scan_relocs(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 incremental links, allocate the counters for incremental relocations. if (layout->incremental_inputs() != NULL) this->allocate_incremental_reloc_counts(); for (Read_relocs_data::Relocs_list::iterator p = rd->relocs.begin(); p != rd->relocs.end(); ++p) { // 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_enabled()) { 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(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(symtab, layout, local_symbols, p); if (layout->incremental_inputs() != NULL) this->incremental_relocs_scan(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(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; } // For incremental links, finalize the allocation of relocations. if (layout->incremental_inputs() != NULL) this->finalize_incremental_relocs(layout, true); if (rd->local_symbols != NULL) { delete rd->local_symbols; rd->local_symbols = NULL; } } // Scan the input relocations for --emit-relocs. template void Sized_relobj_file::emit_relocs_scan( Symbol_table* symtab, Layout* layout, const unsigned char* plocal_syms, const Read_relocs_data::Relocs_list::iterator& p) { Sized_target* target = parameters->sized_target(); Relocatable_relocs* rr = this->relocatable_relocs(p->reloc_shndx); gold_assert(rr != NULL); rr->set_reloc_count(p->reloc_count); target->emit_relocs_scan( 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_, plocal_syms, rr); } // Scan the input relocations for --incremental. template void Sized_relobj_file::incremental_relocs_scan( const Read_relocs_data::Relocs_list::iterator& p) { if (p->sh_type == elfcpp::SHT_REL) this->incremental_relocs_scan_reltype(p); else { gold_assert(p->sh_type == elfcpp::SHT_RELA); this->incremental_relocs_scan_reltype(p); } } // Scan the input relocation for --incremental, templatized on the // type of the relocation section. template template void Sized_relobj_file::incremental_relocs_scan_reltype( const Read_relocs_data::Relocs_list::iterator& p) { typedef typename Reloc_types::Reloc Reltype; const int reloc_size = Reloc_types::reloc_size; const unsigned char* prelocs = p->contents->data(); size_t reloc_count = p->reloc_count; for (size_t i = 0; i < reloc_count; ++i, prelocs += reloc_size) { Reltype reloc(prelocs); if (p->needs_special_offset_handling && !p->output_section->is_input_address_mapped(this, p->data_shndx, reloc.get_r_offset())) continue; // FIXME: Some targets have a non-standard r_info field. typename elfcpp::Elf_types::Elf_WXword r_info = reloc.get_r_info(); const unsigned int r_sym = elfcpp::elf_r_sym(r_info); if (r_sym >= this->local_symbol_count_) this->count_incremental_reloc(r_sym - this->local_symbol_count_); } } // Relocate the input sections and write out the local symbols. template void Sized_relobj_file::do_relocate(const Symbol_table* symtab, const Layout* layout, Output_file* of) { unsigned int shnum = this->shnum(); // Read the section headers. const unsigned char* pshdrs = this->get_view(this->elf_file_.shoff(), shnum * This::shdr_size, true, true); Views views; views.resize(shnum); // Make two passes over the sections. The first one copies the // section data to the output file. The second one applies // relocations. this->write_sections(layout, 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(); // Make the views available through get_output_view() for the duration // of this routine. This RAII class will reset output_views_ to NULL // when the views go out of scope. struct Set_output_views { Set_output_views(const Views** ppviews, const Views* pviews) { ppviews_ = ppviews; *ppviews = pviews; } ~Set_output_views() { *ppviews_ = NULL; } const Views** ppviews_; }; Set_output_views set_output_views(&this->output_views_, &views); // Apply relocations. this->relocate_sections(symtab, layout, pshdrs, of, &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) { if (views[i].view != NULL) { if (views[i].is_ctors_reverse_view) this->reverse_words(views[i].view, views[i].view_size); if (!views[i].is_postprocessing_view) { if (views[i].is_input_output_view) of->write_input_output_view(views[i].offset, views[i].view_size, views[i].view); else of->write_output_view(views[i].offset, views[i].view_size, views[i].view); } } } // Write out the local symbols. this->write_local_symbols(of, layout->sympool(), layout->dynpool(), layout->symtab_xindex(), layout->dynsym_xindex(), layout->symtab_section_offset()); } // 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. template void Sized_relobj_file::write_sections(const Layout* layout, const unsigned char* pshdrs, Output_file* of, Views* pviews) { unsigned int shnum = this->shnum(); 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) { View_size* pvs = &(*pviews)[i]; pvs->view = NULL; const Output_section* os = out_sections[i]; if (os == NULL) continue; 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; pvs->is_ctors_reverse_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 == 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 // want to copy the contents of the input section to the output // section; the output section contents were already written, // and we waited for them in Relocate_task::is_runnable because // relocs_must_follow_section_writes is set for the object. // Regardless of which of the above cases is true, we have to // check requires_postprocessing of the output section. If that // is false, then we work with views of the output file // directly. If it is true, then we work with a separate // buffer, and the output section is responsible for writing the // final data to the output file. off_t output_section_offset; Address output_section_size; if (!os->requires_postprocessing()) { output_section_offset = os->offset(); output_section_size = convert_types(os->data_size()); } else { output_section_offset = 0; output_section_size = convert_types(os->postprocessing_buffer_size()); } off_t view_start; section_size_type view_size; bool must_decompress = false; if (output_offset != invalid_address) { view_start = output_section_offset + output_offset; view_size = convert_to_section_size_type(shdr.get_sh_size()); section_size_type uncompressed_size; if (this->section_is_compressed(i, &uncompressed_size)) { view_size = uncompressed_size; must_decompress = true; } } else { view_start = output_section_offset; view_size = convert_to_section_size_type(output_section_size); } if (view_size == 0) continue; 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 != invalid_address && !must_decompress) { 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 == invalid_address) view = of->get_input_output_view(view_start, view_size); else { view = of->get_output_view(view_start, view_size); if (!must_decompress) { 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)); } } } if (must_decompress) { // Read and decompress the section. section_size_type len; const unsigned char* p = this->section_contents(i, &len, false); if (!decompress_input_section(p, len, view, view_size, size, big_endian, shdr.get_sh_flags())) this->error(_("could not decompress section %s"), this->section_name(i).c_str()); } pvs->view = view; pvs->address = os->address(); 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 == invalid_address; pvs->is_postprocessing_view = os->requires_postprocessing(); pvs->is_ctors_reverse_view = (!parameters->options().relocatable() && view_size > size / 8 && (strcmp(os->name(), ".init_array") == 0 || strcmp(os->name(), ".fini_array") == 0) && layout->is_ctors_in_init_array(this, i)); } // 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 // in the output file. template void Sized_relobj_file::do_relocate_sections( const Symbol_table* symtab, const Layout* layout, const unsigned char* pshdrs, Output_file* of, Views* pviews) { unsigned int shnum = this->shnum(); Sized_target* target = parameters->sized_target(); const Output_sections& out_sections(this->output_sections()); const std::vector
& out_offsets(this->section_offsets()); Relocate_info relinfo; relinfo.symtab = symtab; relinfo.layout = layout; relinfo.object = this; const unsigned char* p = pshdrs + This::shdr_size; for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size) { typename This::Shdr shdr(p); unsigned int sh_type = shdr.get_sh_type(); if (sh_type != elfcpp::SHT_REL && sh_type != elfcpp::SHT_RELA) continue; 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"), i, index); continue; } Output_section* os = out_sections[index]; if (os == NULL) { // This relocation section is against a section which we // discarded. continue; } Address output_offset = out_offsets[index]; gold_assert((*pviews)[index].view != NULL); if (parameters->options().relocatable()) gold_assert((*pviews)[i].view != NULL); if (this->adjust_shndx(shdr.get_sh_link()) != this->symtab_shndx_) { gold_error(_("relocation section %u uses unexpected " "symbol table %u"), i, this->adjust_shndx(shdr.get_sh_link())); continue; } const unsigned char* prelocs = this->get_view(shdr.get_sh_offset(), sh_size, true, false); unsigned int reloc_size; if (sh_type == elfcpp::SHT_REL) reloc_size = elfcpp::Elf_sizes::rel_size; else reloc_size = elfcpp::Elf_sizes::rela_size; if (reloc_size != shdr.get_sh_entsize()) { gold_error(_("unexpected entsize for reloc section %u: %lu != %u"), i, static_cast(shdr.get_sh_entsize()), reloc_size); continue; } size_t reloc_count = sh_size / reloc_size; if (static_cast(reloc_count * reloc_size) != sh_size) { gold_error(_("reloc section %u size %lu uneven"), i, static_cast(sh_size)); continue; } gold_assert(output_offset != invalid_address || this->relocs_must_follow_section_writes()); relinfo.reloc_shndx = i; relinfo.reloc_shdr = p; relinfo.data_shndx = index; relinfo.data_shdr = pshdrs + index * This::shdr_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, target); } Relocatable_relocs* rr = NULL; if (parameters->options().emit_relocs() || parameters->options().relocatable()) rr = this->relocatable_relocs(i); relinfo.rr = rr; 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()) target->relocate_relocs(&relinfo, sh_type, prelocs, reloc_count, os, output_offset, view, address, view_size, (*pviews)[i].view, (*pviews)[i].view_size); if (parameters->incremental()) this->incremental_relocs_write(&relinfo, sh_type, prelocs, reloc_count, os, output_offset, of); } else target->relocate_relocs(&relinfo, sh_type, prelocs, reloc_count, os, output_offset, view, address, view_size, (*pviews)[i].view, (*pviews)[i].view_size); } } // Return the output view for section SHNDX. template unsigned char* Sized_relobj_file::do_get_output_view( unsigned int shndx, section_size_type* plen) const { gold_assert(this->output_views_ != NULL); gold_assert(shndx < this->output_views_->size()); const View_size& v = (*this->output_views_)[shndx]; *plen = v.view_size; return v.view; } // Write the incremental relocs. template void Sized_relobj_file::incremental_relocs_write( const Relocate_info* relinfo, unsigned int sh_type, const unsigned char* prelocs, size_t reloc_count, Output_section* output_section, Address output_offset, Output_file* of) { if (sh_type == elfcpp::SHT_REL) this->incremental_relocs_write_reltype( relinfo, prelocs, reloc_count, output_section, output_offset, of); else { gold_assert(sh_type == elfcpp::SHT_RELA); this->incremental_relocs_write_reltype( relinfo, prelocs, reloc_count, output_section, output_offset, of); } } // Write the incremental relocs, templatized on the type of the // relocation section. template template void Sized_relobj_file::incremental_relocs_write_reltype( const Relocate_info* relinfo, const unsigned char* prelocs, size_t reloc_count, Output_section* output_section, Address output_offset, Output_file* of) { typedef typename Reloc_types::Reloc Reloc; const unsigned int reloc_size = Reloc_types::reloc_size; const unsigned int sizeof_addr = size / 8; const unsigned int incr_reloc_size = Incremental_relocs_reader::reloc_size; unsigned int out_shndx = output_section->out_shndx(); // Get a view for the .gnu_incremental_relocs section. Incremental_inputs* inputs = relinfo->layout->incremental_inputs(); gold_assert(inputs != NULL); const off_t relocs_off = inputs->relocs_section()->offset(); const off_t relocs_size = inputs->relocs_section()->data_size(); unsigned char* const view = of->get_output_view(relocs_off, relocs_size); for (size_t i = 0; i < reloc_count; ++i, prelocs += reloc_size) { Reloc reloc(prelocs); // FIXME: Some targets have a non-standard r_info field. typename elfcpp::Elf_types::Elf_WXword r_info = reloc.get_r_info(); const unsigned int r_sym = elfcpp::elf_r_sym(r_info); const unsigned int r_type = elfcpp::elf_r_type(r_info); if (r_sym < this->local_symbol_count_) continue; // Get the new offset--the location in the output section where // this relocation should be applied. Address offset = reloc.get_r_offset(); if (output_offset != invalid_address) offset += output_offset; else { section_offset_type sot_offset = convert_types(offset); section_offset_type new_sot_offset = output_section->output_offset(relinfo->object, relinfo->data_shndx, sot_offset); gold_assert(new_sot_offset != -1); offset += new_sot_offset; } // Get the addend. typename elfcpp::Elf_types::Elf_Swxword addend; if (sh_type == elfcpp::SHT_RELA) addend = Reloc_types::get_reloc_addend(&reloc); else { // FIXME: Get the addend for SHT_REL. addend = 0; } // Get the index of the output relocation. unsigned int reloc_index = this->next_incremental_reloc_index(r_sym - this->local_symbol_count_); // Write the relocation. unsigned char* pov = view + reloc_index * incr_reloc_size; elfcpp::Swap<32, big_endian>::writeval(pov, r_type); elfcpp::Swap<32, big_endian>::writeval(pov + 4, out_shndx); elfcpp::Swap::writeval(pov + 8, offset); elfcpp::Swap::writeval(pov + 8 + sizeof_addr, addend); of->write_output_view(pov - view, incr_reloc_size, view); } } // Create merge hash tables for the local symbols. These are used to // speed up relocations. template void Sized_relobj_file::initialize_input_to_output_maps() { 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); } } // Free merge hash tables for the local symbols. template void Sized_relobj_file::free_input_to_output_maps() { 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(); } } // 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 Sized_relobj_file::split_stack_adjust( const Symbol_table* symtab, const unsigned char* pshdrs, unsigned int sh_type, unsigned int shndx, const unsigned char* prelocs, size_t reloc_count, unsigned char* view, section_size_type view_size, Reloc_symbol_changes** reloc_map, const Sized_target* target) { if (sh_type == elfcpp::SHT_REL) this->split_stack_adjust_reltype(symtab, pshdrs, shndx, prelocs, reloc_count, view, view_size, reloc_map, target); else { gold_assert(sh_type == elfcpp::SHT_RELA); this->split_stack_adjust_reltype(symtab, pshdrs, shndx, prelocs, reloc_count, view, view_size, reloc_map, target); } } // Adjust for -fsplit-stack, templatized on the type of the relocation // section. template template void Sized_relobj_file::split_stack_adjust_reltype( const Symbol_table* symtab, const unsigned char* pshdrs, unsigned int shndx, const unsigned char* prelocs, size_t reloc_count, unsigned char* view, section_size_type view_size, Reloc_symbol_changes** reloc_map, const Sized_target* target) { typedef typename Reloc_types::Reloc Reltype; const int reloc_size = Reloc_types::reloc_size; size_t local_count = this->local_symbol_count(); std::vector non_split_refs; const unsigned char* pr = prelocs; for (size_t i = 0; i < reloc_count; ++i, pr += reloc_size) { // Some supported targets have a non-standard r_info field. // If this call is too slow, we can move this routine to // target-reloc.h and templatize it on Classify_reloc. unsigned int r_sym = target->get_r_sym(pr); 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->is_undefined() && gsym->source() == Symbol::FROM_OBJECT && !gsym->object()->uses_split_stack()) { if (parameters->target().is_call_to_non_split(gsym, pr, view, view_size)) { Reltype reloc(pr); 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) { 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, prelocs, reloc_count, 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); unsigned int r_sym = target->get_r_sym(pr); 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); } } } } } // Find all the function in this object defined in section SHNDX. // Store their offsets in the section in FUNCTION_OFFSETS. template void Sized_relobj_file::find_functions( const unsigned char* pshdrs, unsigned int shndx, Sized_relobj_file::Function_offsets* function_offsets) { // 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) { 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; Symbol_location loc; loc.shndx = this->adjust_sym_shndx(i, isym.get_st_shndx(), &is_ordinary); if (!is_ordinary) continue; loc.object = this; loc.offset = isym.get_st_value(); parameters->target().function_location(&loc); if (loc.shndx != shndx) continue; section_offset_type value = convert_to_section_size_type(loc.offset); section_size_type fnsize = convert_to_section_size_type(isym.get_st_size()); (*function_offsets)[value] = fnsize; } } // Reverse the words in a section. Used for .ctors sections mapped to // .init_array sections. See ctors_sections_in_init_array in // layout.cc. template void Sized_relobj_file::reverse_words(unsigned char* view, section_size_type view_size) { typedef typename elfcpp::Swap::Valtype Valtype; Valtype* vview = reinterpret_cast(view); section_size_type vview_size = view_size / (size / 8); for (section_size_type i = 0; i < vview_size / 2; ++i) { Valtype tmp = vview[i]; vview[i] = vview[vview_size - 1 - i]; vview[vview_size - 1 - i] = tmp; } } // Class Merged_symbol_value. template void Merged_symbol_value::initialize_input_to_output_map( const Relobj* object, unsigned int input_shndx) { object->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_output_offset(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, // the reloc section index, and the type of the relocs. This returns // false if something goes wrong. template bool Track_relocs::initialize( Object* object, unsigned int reloc_shndx, unsigned int reloc_type) { // If RELOC_SHNDX is -1U, it means there is more than one reloc // section for the .eh_frame section. We can't handle that case. if (reloc_shndx == -1U) return false; // If RELOC_SHNDX is 0, there is no reloc section. if (reloc_shndx == 0) return true; // Get the contents of the reloc section. this->prelocs_ = object->section_contents(reloc_shndx, &this->len_, false); if (reloc_type == elfcpp::SHT_REL) this->reloc_size_ = elfcpp::Elf_sizes::rel_size; else if (reloc_type == elfcpp::SHT_RELA) this->reloc_size_ = elfcpp::Elf_sizes::rela_size; else gold_unreachable(); if (this->len_ % this->reloc_size_ != 0) { object->error(_("reloc section size %zu is not a multiple of " "reloc size %d\n"), static_cast(this->len_), this->reloc_size_); return false; } return true; } // Return the offset of the next reloc, or -1 if there isn't one. template off_t Track_relocs::next_offset() const { if (this->pos_ >= this->len_) return -1; // Rel and Rela start out the same, so we can always use Rel to find // the r_offset value. elfcpp::Rel rel(this->prelocs_ + this->pos_); return rel.get_r_offset(); } // Return the index of the symbol referenced by the next reloc, or -1U // if there aren't any more relocs. template unsigned int Track_relocs::next_symndx() const { if (this->pos_ >= this->len_) return -1U; Sized_target* target = parameters->sized_target(); return target->get_r_sym(this->prelocs_ + this->pos_); } // Return the addend of the next reloc, or 0 if there isn't one. template uint64_t Track_relocs::next_addend() const { if (this->pos_ >= this->len_) return 0; if (this->reloc_size_ == elfcpp::Elf_sizes::rel_size) return 0; elfcpp::Rela rela(this->prelocs_ + this->pos_); return rela.get_r_addend(); } // Advance to the next reloc whose r_offset is greater than or equal // to OFFSET. Return the number of relocs we skip. template int Track_relocs::advance(off_t offset) { int ret = 0; while (this->pos_ < this->len_) { // Rel and Rela start out the same, so we can always use Rel to // find the r_offset value. elfcpp::Rel rel(this->prelocs_ + this->pos_); if (static_cast(rel.get_r_offset()) >= offset) break; ++ret; this->pos_ += this->reloc_size_; } return ret; } // Instantiate the templates we need. #ifdef HAVE_TARGET_32_LITTLE template void Sized_relobj_file<32, false>::do_read_relocs(Read_relocs_data* rd); #endif #ifdef HAVE_TARGET_32_BIG template void Sized_relobj_file<32, true>::do_read_relocs(Read_relocs_data* rd); #endif #ifdef HAVE_TARGET_64_LITTLE template void Sized_relobj_file<64, false>::do_read_relocs(Read_relocs_data* rd); #endif #ifdef HAVE_TARGET_64_BIG template void Sized_relobj_file<64, true>::do_read_relocs(Read_relocs_data* rd); #endif #ifdef HAVE_TARGET_32_LITTLE template void Sized_relobj_file<32, false>::do_gc_process_relocs(Symbol_table* symtab, Layout* layout, Read_relocs_data* rd); #endif #ifdef HAVE_TARGET_32_BIG template void Sized_relobj_file<32, true>::do_gc_process_relocs(Symbol_table* symtab, Layout* layout, Read_relocs_data* rd); #endif #ifdef HAVE_TARGET_64_LITTLE template void Sized_relobj_file<64, false>::do_gc_process_relocs(Symbol_table* symtab, Layout* layout, Read_relocs_data* rd); #endif #ifdef HAVE_TARGET_64_BIG template void Sized_relobj_file<64, true>::do_gc_process_relocs(Symbol_table* symtab, Layout* layout, Read_relocs_data* rd); #endif #ifdef HAVE_TARGET_32_LITTLE template void Sized_relobj_file<32, false>::do_scan_relocs(Symbol_table* symtab, Layout* layout, Read_relocs_data* rd); #endif #ifdef HAVE_TARGET_32_BIG template void Sized_relobj_file<32, true>::do_scan_relocs(Symbol_table* symtab, Layout* layout, Read_relocs_data* rd); #endif #ifdef HAVE_TARGET_64_LITTLE template void Sized_relobj_file<64, false>::do_scan_relocs(Symbol_table* symtab, Layout* layout, Read_relocs_data* rd); #endif #ifdef HAVE_TARGET_64_BIG template void Sized_relobj_file<64, true>::do_scan_relocs(Symbol_table* symtab, Layout* layout, Read_relocs_data* rd); #endif #ifdef HAVE_TARGET_32_LITTLE template void Sized_relobj_file<32, false>::do_relocate(const Symbol_table* symtab, const Layout* layout, Output_file* of); #endif #ifdef HAVE_TARGET_32_BIG template void Sized_relobj_file<32, true>::do_relocate(const Symbol_table* symtab, const Layout* layout, Output_file* of); #endif #ifdef HAVE_TARGET_64_LITTLE template void Sized_relobj_file<64, false>::do_relocate(const Symbol_table* symtab, const Layout* layout, Output_file* of); #endif #ifdef HAVE_TARGET_64_BIG template void Sized_relobj_file<64, true>::do_relocate(const Symbol_table* symtab, const Layout* layout, Output_file* of); #endif #ifdef HAVE_TARGET_32_LITTLE template void Sized_relobj_file<32, false>::do_relocate_sections( const Symbol_table* symtab, const Layout* layout, const unsigned char* pshdrs, Output_file* of, Views* pviews); template unsigned char* Sized_relobj_file<32, false>::do_get_output_view( unsigned int shndx, section_size_type* plen) const; #endif #ifdef HAVE_TARGET_32_BIG template void Sized_relobj_file<32, true>::do_relocate_sections( const Symbol_table* symtab, const Layout* layout, const unsigned char* pshdrs, Output_file* of, Views* pviews); template unsigned char* Sized_relobj_file<32, true>::do_get_output_view( unsigned int shndx, section_size_type* plen) const; #endif #ifdef HAVE_TARGET_64_LITTLE template void Sized_relobj_file<64, false>::do_relocate_sections( const Symbol_table* symtab, const Layout* layout, const unsigned char* pshdrs, Output_file* of, Views* pviews); template unsigned char* Sized_relobj_file<64, false>::do_get_output_view( unsigned int shndx, section_size_type* plen) const; #endif #ifdef HAVE_TARGET_64_BIG template void Sized_relobj_file<64, true>::do_relocate_sections( const Symbol_table* symtab, const Layout* layout, const unsigned char* pshdrs, Output_file* of, Views* pviews); template unsigned char* Sized_relobj_file<64, true>::do_get_output_view( unsigned int shndx, section_size_type* plen) const; #endif #ifdef HAVE_TARGET_32_LITTLE template void Sized_relobj_file<32, false>::initialize_input_to_output_maps(); template void Sized_relobj_file<32, false>::free_input_to_output_maps(); #endif #ifdef HAVE_TARGET_32_BIG template void Sized_relobj_file<32, true>::initialize_input_to_output_maps(); template void Sized_relobj_file<32, true>::free_input_to_output_maps(); #endif #ifdef HAVE_TARGET_64_LITTLE template void Sized_relobj_file<64, false>::initialize_input_to_output_maps(); template void Sized_relobj_file<64, false>::free_input_to_output_maps(); #endif #ifdef HAVE_TARGET_64_BIG template void Sized_relobj_file<64, true>::initialize_input_to_output_maps(); template void Sized_relobj_file<64, true>::free_input_to_output_maps(); #endif #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) template class Merged_symbol_value<32>; #endif #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) template class Merged_symbol_value<64>; #endif #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) template class Symbol_value<32>; #endif #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) template class Symbol_value<64>; #endif #ifdef HAVE_TARGET_32_LITTLE template class Track_relocs<32, false>; #endif #ifdef HAVE_TARGET_32_BIG template class Track_relocs<32, true>; #endif #ifdef HAVE_TARGET_64_LITTLE template class Track_relocs<64, false>; #endif #ifdef HAVE_TARGET_64_BIG template class Track_relocs<64, true>; #endif } // End namespace gold.