1 // copy-relocs.cc -- handle COPY relocations for gold. 2 3 // Copyright 2006, 2007, 2008, 2009, 2010, 2011 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 #include "gold.h" 24 25 #include "symtab.h" 26 #include "copy-relocs.h" 27 28 namespace gold 29 { 30 31 // Copy_relocs::Copy_reloc_entry methods. 32 33 // Emit the reloc if appropriate. 34 35 template<int sh_type, int size, bool big_endian> 36 void 37 Copy_relocs<sh_type, size, big_endian>::Copy_reloc_entry::emit( 38 Output_data_reloc<sh_type, true, size, big_endian>* reloc_section) 39 { 40 // If the symbol is no longer defined in a dynamic object, then we 41 // emitted a COPY relocation, and we do not want to emit this 42 // dynamic relocation. 43 if (this->sym_->is_from_dynobj()) 44 reloc_section->add_global_generic(this->sym_, this->reloc_type_, 45 this->output_section_, this->relobj_, 46 this->shndx_, this->address_, 47 this->addend_); 48 } 49 50 // Copy_relocs methods. 51 52 // Handle a relocation against a symbol which may force us to generate 53 // a COPY reloc. 54 55 template<int sh_type, int size, bool big_endian> 56 void 57 Copy_relocs<sh_type, size, big_endian>::copy_reloc( 58 Symbol_table* symtab, 59 Layout* layout, 60 Sized_symbol<size>* sym, 61 Sized_relobj_file<size, big_endian>* object, 62 unsigned int shndx, 63 Output_section* output_section, 64 const Reloc& rel, 65 Output_data_reloc<sh_type, true, size, big_endian>* reloc_section) 66 { 67 if (this->need_copy_reloc(sym, object, shndx)) 68 this->make_copy_reloc(symtab, layout, sym, reloc_section); 69 else 70 { 71 // We may not need a COPY relocation. Save this relocation to 72 // possibly be emitted later. 73 this->save(sym, object, shndx, output_section, rel); 74 } 75 } 76 77 // Return whether we need a COPY reloc for a relocation against SYM. 78 // The relocation is begin applied to section SHNDX in OBJECT. 79 80 template<int sh_type, int size, bool big_endian> 81 bool 82 Copy_relocs<sh_type, size, big_endian>::need_copy_reloc( 83 Sized_symbol<size>* sym, 84 Sized_relobj_file<size, big_endian>* object, 85 unsigned int shndx) const 86 { 87 if (!parameters->options().copyreloc()) 88 return false; 89 90 if (sym->symsize() == 0) 91 return false; 92 93 // If this is a readonly section, then we need a COPY reloc. 94 // Otherwise we can use a dynamic reloc. Note that calling 95 // section_flags here can be slow, as the information is not cached; 96 // fortunately we shouldn't see too many potential COPY relocs. 97 if ((object->section_flags(shndx) & elfcpp::SHF_WRITE) == 0) 98 return true; 99 100 return false; 101 } 102 103 // Emit a COPY relocation for SYM. 104 105 template<int sh_type, int size, bool big_endian> 106 void 107 Copy_relocs<sh_type, size, big_endian>::emit_copy_reloc( 108 Symbol_table* symtab, 109 Sized_symbol<size>* sym, 110 Output_data* posd, 111 off_t offset, 112 Output_data_reloc<sh_type, true, size, big_endian>* reloc_section) 113 { 114 // Define the symbol as being copied. 115 symtab->define_with_copy_reloc(sym, posd, offset); 116 117 // Add the COPY relocation to the dynamic reloc section. 118 reloc_section->add_global_generic(sym, this->copy_reloc_type_, posd, 119 offset, 0); 120 } 121 122 // Make a COPY relocation for SYM and emit it. 123 124 template<int sh_type, int size, bool big_endian> 125 void 126 Copy_relocs<sh_type, size, big_endian>::make_copy_reloc( 127 Symbol_table* symtab, 128 Layout* layout, 129 Sized_symbol<size>* sym, 130 Output_data_reloc<sh_type, true, size, big_endian>* reloc_section) 131 { 132 // We should not be here if -z nocopyreloc is given. 133 gold_assert(parameters->options().copyreloc()); 134 135 typename elfcpp::Elf_types<size>::Elf_WXword symsize = sym->symsize(); 136 137 // There is no defined way to determine the required alignment of 138 // the symbol. We know that the symbol is defined in a dynamic 139 // object. We start with the alignment of the section in which it 140 // is defined; presumably we do not require an alignment larger than 141 // that. Then we reduce that alignment if the symbol is not aligned 142 // within the section. 143 gold_assert(sym->is_from_dynobj()); 144 bool is_ordinary; 145 unsigned int shndx = sym->shndx(&is_ordinary); 146 gold_assert(is_ordinary); 147 typename elfcpp::Elf_types<size>::Elf_WXword addralign; 148 149 { 150 // Lock the object so we can read from it. This is only called 151 // single-threaded from scan_relocs, so it is OK to lock. 152 // Unfortunately we have no way to pass in a Task token. 153 const Task* dummy_task = reinterpret_cast<const Task*>(-1); 154 Object* obj = sym->object(); 155 Task_lock_obj<Object> tl(dummy_task, obj); 156 addralign = obj->section_addralign(shndx); 157 } 158 159 typename Sized_symbol<size>::Value_type value = sym->value(); 160 while ((value & (addralign - 1)) != 0) 161 addralign >>= 1; 162 163 // Mark the dynamic object as needed for the --as-needed option. 164 sym->object()->set_is_needed(); 165 166 if (this->dynbss_ == NULL) 167 { 168 this->dynbss_ = new Output_data_space(addralign, "** dynbss"); 169 layout->add_output_section_data(".bss", 170 elfcpp::SHT_NOBITS, 171 elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE, 172 this->dynbss_, ORDER_BSS, false); 173 } 174 175 Output_data_space* dynbss = this->dynbss_; 176 177 if (addralign > dynbss->addralign()) 178 dynbss->set_space_alignment(addralign); 179 180 section_size_type dynbss_size = 181 convert_to_section_size_type(dynbss->current_data_size()); 182 dynbss_size = align_address(dynbss_size, addralign); 183 section_size_type offset = dynbss_size; 184 dynbss->set_current_data_size(dynbss_size + symsize); 185 186 this->emit_copy_reloc(symtab, sym, dynbss, offset, reloc_section); 187 } 188 189 // Save a relocation to possibly be emitted later. 190 191 template<int sh_type, int size, bool big_endian> 192 void 193 Copy_relocs<sh_type, size, big_endian>::save( 194 Symbol* sym, 195 Sized_relobj_file<size, big_endian>* object, 196 unsigned int shndx, 197 Output_section* output_section, 198 const Reloc& rel) 199 { 200 unsigned int reloc_type = elfcpp::elf_r_type<size>(rel.get_r_info()); 201 typename elfcpp::Elf_types<size>::Elf_Addr addend = 202 Reloc_types<sh_type, size, big_endian>::get_reloc_addend_noerror(&rel); 203 this->entries_.push_back(Copy_reloc_entry(sym, reloc_type, object, shndx, 204 output_section, rel.get_r_offset(), 205 addend)); 206 } 207 208 // Emit any saved relocs. 209 210 template<int sh_type, int size, bool big_endian> 211 void 212 Copy_relocs<sh_type, size, big_endian>::emit( 213 Output_data_reloc<sh_type, true, size, big_endian>* reloc_section) 214 { 215 for (typename Copy_reloc_entries::iterator p = this->entries_.begin(); 216 p != this->entries_.end(); 217 ++p) 218 p->emit(reloc_section); 219 220 // We no longer need the saved information. 221 this->entries_.clear(); 222 } 223 224 // Instantiate the templates we need. 225 226 #ifdef HAVE_TARGET_32_LITTLE 227 template 228 class Copy_relocs<elfcpp::SHT_REL, 32, false>; 229 230 template 231 class Copy_relocs<elfcpp::SHT_RELA, 32, false>; 232 #endif 233 234 #ifdef HAVE_TARGET_32_BIG 235 template 236 class Copy_relocs<elfcpp::SHT_REL, 32, true>; 237 238 template 239 class Copy_relocs<elfcpp::SHT_RELA, 32, true>; 240 #endif 241 242 #ifdef HAVE_TARGET_64_LITTLE 243 template 244 class Copy_relocs<elfcpp::SHT_REL, 64, false>; 245 246 template 247 class Copy_relocs<elfcpp::SHT_RELA, 64, false>; 248 #endif 249 250 #ifdef HAVE_TARGET_64_BIG 251 template 252 class Copy_relocs<elfcpp::SHT_REL, 64, true>; 253 254 template 255 class Copy_relocs<elfcpp::SHT_RELA, 64, true>; 256 #endif 257 258 } // End namespace gold. 259