diff options
Diffstat (limited to 'binutils-2.25/gold/copy-relocs.cc')
| -rw-r--r-- | binutils-2.25/gold/copy-relocs.cc | 258 |
1 files changed, 258 insertions, 0 deletions
diff --git a/binutils-2.25/gold/copy-relocs.cc b/binutils-2.25/gold/copy-relocs.cc new file mode 100644 index 00000000..92c5aeaa --- /dev/null +++ b/binutils-2.25/gold/copy-relocs.cc @@ -0,0 +1,258 @@ +// copy-relocs.cc -- handle COPY relocations for gold. + +// Copyright 2006, 2007, 2008, 2009, 2010, 2011 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::Copy_reloc_entry methods. + +// Emit the reloc if appropriate. + +template<int sh_type, int size, bool big_endian> +void +Copy_relocs<sh_type, size, big_endian>::Copy_reloc_entry::emit( + Output_data_reloc<sh_type, true, size, big_endian>* reloc_section) +{ + // 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 (this->sym_->is_from_dynobj()) + reloc_section->add_global_generic(this->sym_, this->reloc_type_, + this->output_section_, this->relobj_, + this->shndx_, this->address_, + this->addend_); +} + +// 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, + const Reloc& rel, + 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, 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, rel); + } +} + +// 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, + 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()); + + 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. + gold_assert(sym->is_from_dynobj()); + bool is_ordinary; + unsigned int shndx = sym->shndx(&is_ordinary); + gold_assert(is_ordinary); + typename elfcpp::Elf_types<size>::Elf_WXword addralign; + + { + // 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); + } + + 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(); + + 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); + } + + Output_data_space* 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, + const Reloc& rel) +{ + unsigned int reloc_type = elfcpp::elf_r_type<size>(rel.get_r_info()); + typename elfcpp::Elf_types<size>::Elf_Addr addend = + Reloc_types<sh_type, size, big_endian>::get_reloc_addend_noerror(&rel); + this->entries_.push_back(Copy_reloc_entry(sym, reloc_type, object, shndx, + output_section, rel.get_r_offset(), + 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) + p->emit(reloc_section); + + // 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. |