| 1 | // copy-relocs.h -- handle COPY relocations for gold -*- C++ -*- |
| 2 | |
| 3 | // Copyright (C) 2006-2015 Free Software Foundation, Inc. |
| 4 | // Written by Ian Lance Taylor <iant@google.com>. |
| 5 | |
| 6 | // This file is part of gold. |
| 7 | |
| 8 | // This program is free software; you can redistribute it and/or modify |
| 9 | // it under the terms of the GNU General Public License as published by |
| 10 | // the Free Software Foundation; either version 3 of the License, or |
| 11 | // (at your option) any later version. |
| 12 | |
| 13 | // This program is distributed in the hope that it will be useful, |
| 14 | // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 15 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 16 | // GNU General Public License for more details. |
| 17 | |
| 18 | // You should have received a copy of the GNU General Public License |
| 19 | // along with this program; if not, write to the Free Software |
| 20 | // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, |
| 21 | // MA 02110-1301, USA. |
| 22 | |
| 23 | #ifndef GOLD_COPY_RELOCS_H |
| 24 | #define GOLD_COPY_RELOCS_H |
| 25 | |
| 26 | #include "elfcpp.h" |
| 27 | #include "reloc-types.h" |
| 28 | #include "output.h" |
| 29 | |
| 30 | namespace gold |
| 31 | { |
| 32 | |
| 33 | // This class is used to manage COPY relocations. We try to avoid |
| 34 | // them when possible. A COPY relocation may be required when an |
| 35 | // executable refers to a variable defined in a shared library. COPY |
| 36 | // relocations are problematic because they tie the executable to the |
| 37 | // exact size of the variable in the shared library. We can avoid |
| 38 | // them if all the references to the variable are in a writeable |
| 39 | // section. In that case we can simply use dynamic relocations. |
| 40 | // However, when scanning relocs, we don't know when we see the |
| 41 | // relocation whether we will be forced to use a COPY relocation or |
| 42 | // not. So we have to save the relocation during the reloc scanning, |
| 43 | // and then emit it as a dynamic relocation if necessary. This class |
| 44 | // implements that. It is used by the target specific code. |
| 45 | |
| 46 | // The template parameter SH_TYPE is the type of the reloc section to |
| 47 | // be used for COPY relocs: elfcpp::SHT_REL or elfcpp::SHT_RELA. |
| 48 | |
| 49 | template<int sh_type, int size, bool big_endian> |
| 50 | class Copy_relocs |
| 51 | { |
| 52 | private: |
| 53 | typedef typename Reloc_types<sh_type, size, big_endian>::Reloc Reloc; |
| 54 | |
| 55 | public: |
| 56 | Copy_relocs(unsigned int copy_reloc_type) |
| 57 | : entries_(), copy_reloc_type_(copy_reloc_type), dynbss_(NULL) |
| 58 | { } |
| 59 | |
| 60 | // This is called while scanning relocs if we see a relocation |
| 61 | // against a symbol which may force us to generate a COPY reloc. |
| 62 | // SYM is the symbol. OBJECT is the object whose relocs we are |
| 63 | // scanning. The relocation is being applied to section SHNDX in |
| 64 | // OBJECT. OUTPUT_SECTION is the output section where section SHNDX |
| 65 | // will wind up. REL is the reloc itself. The Output_data_reloc |
| 66 | // section is where the dynamic relocs are put. |
| 67 | void |
| 68 | copy_reloc(Symbol_table*, Layout*, Sized_symbol<size>* sym, |
| 69 | Sized_relobj_file<size, big_endian>* object, |
| 70 | unsigned int shndx, Output_section* output_section, |
| 71 | const Reloc& rel, |
| 72 | Output_data_reloc<sh_type, true, size, big_endian>*); |
| 73 | |
| 74 | // Return whether there are any saved relocations. |
| 75 | bool |
| 76 | any_saved_relocs() const |
| 77 | { return !this->entries_.empty(); } |
| 78 | |
| 79 | // Emit any saved relocations which turn out to be needed. This is |
| 80 | // called after all the relocs have been scanned. |
| 81 | void |
| 82 | emit(Output_data_reloc<sh_type, true, size, big_endian>*); |
| 83 | |
| 84 | // Emit a COPY reloc. |
| 85 | void |
| 86 | emit_copy_reloc(Symbol_table*, Sized_symbol<size>*, |
| 87 | Output_data*, off_t, |
| 88 | Output_data_reloc<sh_type, true, size, big_endian>*); |
| 89 | |
| 90 | protected: |
| 91 | typedef typename elfcpp::Elf_types<size>::Elf_Addr Address; |
| 92 | typedef typename elfcpp::Elf_types<size>::Elf_Addr Addend; |
| 93 | |
| 94 | // This POD class holds the relocations we are saving. We will emit |
| 95 | // these relocations if it turns out that the symbol does not |
| 96 | // require a COPY relocation. |
| 97 | struct Copy_reloc_entry |
| 98 | { |
| 99 | Copy_reloc_entry(Symbol* sym, unsigned int reloc_type, |
| 100 | Sized_relobj_file<size, big_endian>* relobj, |
| 101 | unsigned int shndx, |
| 102 | Output_section* output_section, |
| 103 | Address address, Addend addend) |
| 104 | : sym_(sym), reloc_type_(reloc_type), relobj_(relobj), |
| 105 | shndx_(shndx), output_section_(output_section), |
| 106 | address_(address), addend_(addend) |
| 107 | { } |
| 108 | |
| 109 | Symbol* sym_; |
| 110 | unsigned int reloc_type_; |
| 111 | Sized_relobj_file<size, big_endian>* relobj_; |
| 112 | unsigned int shndx_; |
| 113 | Output_section* output_section_; |
| 114 | Address address_; |
| 115 | Addend addend_; |
| 116 | }; |
| 117 | |
| 118 | // Make a new COPY reloc and emit it. |
| 119 | void |
| 120 | make_copy_reloc(Symbol_table*, Layout*, Sized_symbol<size>*, |
| 121 | Output_data_reloc<sh_type, true, size, big_endian>*); |
| 122 | |
| 123 | // A list of relocs to be saved. |
| 124 | typedef std::vector<Copy_reloc_entry> Copy_reloc_entries; |
| 125 | |
| 126 | // The list of relocs we are saving. |
| 127 | Copy_reloc_entries entries_; |
| 128 | |
| 129 | private: |
| 130 | // Return whether we need a COPY reloc. |
| 131 | bool |
| 132 | need_copy_reloc(Sized_symbol<size>* gsym, |
| 133 | Sized_relobj_file<size, big_endian>* object, |
| 134 | unsigned int shndx) const; |
| 135 | |
| 136 | // Save a reloc against SYM for possible emission later. |
| 137 | void |
| 138 | save(Symbol*, Sized_relobj_file<size, big_endian>*, unsigned int shndx, |
| 139 | Output_section*, const Reloc& rel); |
| 140 | |
| 141 | // The target specific relocation type of the COPY relocation. |
| 142 | const unsigned int copy_reloc_type_; |
| 143 | // The dynamic BSS data which goes into the .bss section. This is |
| 144 | // where variables which require COPY relocations are placed. |
| 145 | Output_data_space* dynbss_; |
| 146 | }; |
| 147 | |
| 148 | } // End namespace gold. |
| 149 | |
| 150 | #endif // !defined(GOLD_COPY_RELOCS_H) |