// copy-relocs.cc -- handle COPY relocations for gold. // Copyright (C) 2006-2021 Free Software Foundation, Inc. // Written by Ian Lance Taylor <iant@google.com>. // 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 "symtab.h" #include "copy-relocs.h" namespace gold { // Copy_relocs methods. // Handle a relocation against a symbol which may force us to generate // a COPY reloc. template<int sh_type, int size, bool big_endian> void Copy_relocs<sh_type, size, big_endian>::copy_reloc( Symbol_table* symtab, Layout* layout, Sized_symbol<size>* sym, Sized_relobj_file<size, big_endian>* object, unsigned int shndx, Output_section* output_section, unsigned int r_type, typename elfcpp::Elf_types<size>::Elf_Addr r_offset, typename elfcpp::Elf_types<size>::Elf_Swxword r_addend, Output_data_reloc<sh_type, true, size, big_endian>* reloc_section) { if (this->need_copy_reloc(sym, object, shndx)) this->make_copy_reloc(symtab, layout, sym, object, reloc_section); else { // We may not need a COPY relocation. Save this relocation to // possibly be emitted later. this->save(sym, object, shndx, output_section, r_type, r_offset, r_addend); } } // Return whether we need a COPY reloc for a relocation against SYM. // The relocation is begin applied to section SHNDX in OBJECT. template<int sh_type, int size, bool big_endian> bool Copy_relocs<sh_type, size, big_endian>::need_copy_reloc( Sized_symbol<size>* sym, Sized_relobj_file<size, big_endian>* object, unsigned int shndx) const { if (!parameters->options().copyreloc()) return false; 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. Note that calling // section_flags here can be slow, as the information is not cached; // fortunately we shouldn't see too many potential COPY relocs. if ((object->section_flags(shndx) & elfcpp::SHF_WRITE) == 0) return true; return false; } // Emit a COPY relocation for SYM. template<int sh_type, int size, bool big_endian> void Copy_relocs<sh_type, size, big_endian>::emit_copy_reloc( Symbol_table* symtab, Sized_symbol<size>* sym, Output_data* posd, off_t offset, Output_data_reloc<sh_type, true, size, big_endian>* reloc_section) { // Define the symbol as being copied. symtab->define_with_copy_reloc(sym, posd, offset); // Add the COPY relocation to the dynamic reloc section. reloc_section->add_global_generic(sym, this->copy_reloc_type_, posd, offset, 0); } // Make a COPY relocation for SYM and emit it. template<int sh_type, int size, bool big_endian> void Copy_relocs<sh_type, size, big_endian>::make_copy_reloc( Symbol_table* symtab, Layout* layout, Sized_symbol<size>* sym, Sized_relobj_file<size, big_endian>* object, Output_data_reloc<sh_type, true, size, big_endian>* reloc_section) { // We should not be here if -z nocopyreloc is given. gold_assert(parameters->options().copyreloc()); gold_assert(sym->is_from_dynobj()); // The symbol must not have protected visibility. if (sym->is_protected()) { gold_error(_("%s: cannot make copy relocation for " "protected symbol '%s', defined in %s"), object->name().c_str(), sym->name(), sym->object()->name().c_str()); } typename elfcpp::Elf_types<size>::Elf_WXword symsize = sym->symsize(); // There is no defined way to determine the required alignment of // the symbol. We know that the symbol is defined in a dynamic // object. We start with the alignment of the section in which it // is defined; presumably we do not require an alignment larger than // that. Then we reduce that alignment if the symbol is not aligned // within the section. bool is_ordinary; unsigned int shndx = sym->shndx(&is_ordinary); gold_assert(is_ordinary); typename elfcpp::Elf_types<size>::Elf_WXword addralign; bool is_readonly = false; { // Lock the object so we can read from it. This is only called // single-threaded from scan_relocs, so it is OK to lock. // Unfortunately we have no way to pass in a Task token. const Task* dummy_task = reinterpret_cast<const Task*>(-1); Object* obj = sym->object(); Task_lock_obj<Object> tl(dummy_task, obj); addralign = obj->section_addralign(shndx); if (parameters->options().relro()) { if ((obj->section_flags(shndx) & elfcpp::SHF_WRITE) == 0) is_readonly = true; else { // Symbols in .data.rel.ro should also be treated as read-only. if (obj->section_name(shndx) == ".data.rel.ro") is_readonly = true; } } } typename Sized_symbol<size>::Value_type value = sym->value(); while ((value & (addralign - 1)) != 0) addralign >>= 1; // Mark the dynamic object as needed for the --as-needed option. sym->object()->set_is_needed(); Output_data_space* dynbss; if (is_readonly) { if (this->dynrelro_ == NULL) { this->dynrelro_ = new Output_data_space(addralign, "** dynrelro"); layout->add_output_section_data(".data.rel.ro", elfcpp::SHT_PROGBITS, elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE, this->dynrelro_, ORDER_RELRO, false); } dynbss = this->dynrelro_; } else { if (this->dynbss_ == NULL) { this->dynbss_ = new Output_data_space(addralign, "** dynbss"); layout->add_output_section_data(".bss", elfcpp::SHT_NOBITS, elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE, this->dynbss_, ORDER_BSS, false); } dynbss = this->dynbss_; } if (addralign > dynbss->addralign()) dynbss->set_space_alignment(addralign); section_size_type dynbss_size = convert_to_section_size_type(dynbss->current_data_size()); dynbss_size = align_address(dynbss_size, addralign); section_size_type offset = dynbss_size; dynbss->set_current_data_size(dynbss_size + symsize); this->emit_copy_reloc(symtab, sym, dynbss, offset, reloc_section); } // Save a relocation to possibly be emitted later. template<int sh_type, int size, bool big_endian> void Copy_relocs<sh_type, size, big_endian>::save( Symbol* sym, Sized_relobj_file<size, big_endian>* object, unsigned int shndx, Output_section* output_section, unsigned int r_type, typename elfcpp::Elf_types<size>::Elf_Addr r_offset, typename elfcpp::Elf_types<size>::Elf_Swxword r_addend) { this->entries_.push_back(Copy_reloc_entry(sym, r_type, object, shndx, output_section, r_offset, r_addend)); } // Emit any saved relocs. template<int sh_type, int size, bool big_endian> void Copy_relocs<sh_type, size, big_endian>::emit( Output_data_reloc<sh_type, true, size, big_endian>* reloc_section) { for (typename Copy_reloc_entries::iterator p = this->entries_.begin(); p != this->entries_.end(); ++p) { Copy_reloc_entry& entry = *p; // If the symbol is no longer defined in a dynamic object, then we // emitted a COPY relocation, and we do not want to emit this // dynamic relocation. if (entry.sym_->is_from_dynobj()) reloc_section->add_global_generic(entry.sym_, entry.reloc_type_, entry.output_section_, entry.relobj_, entry.shndx_, entry.address_, entry.addend_); } // We no longer need the saved information. this->entries_.clear(); } // Instantiate the templates we need. #ifdef HAVE_TARGET_32_LITTLE template class Copy_relocs<elfcpp::SHT_REL, 32, false>; template class Copy_relocs<elfcpp::SHT_RELA, 32, false>; #endif #ifdef HAVE_TARGET_32_BIG template class Copy_relocs<elfcpp::SHT_REL, 32, true>; template class Copy_relocs<elfcpp::SHT_RELA, 32, true>; #endif #ifdef HAVE_TARGET_64_LITTLE template class Copy_relocs<elfcpp::SHT_REL, 64, false>; template class Copy_relocs<elfcpp::SHT_RELA, 64, false>; #endif #ifdef HAVE_TARGET_64_BIG template class Copy_relocs<elfcpp::SHT_REL, 64, true>; template class Copy_relocs<elfcpp::SHT_RELA, 64, true>; #endif } // End namespace gold.