| | 1 | // reloc.cc -- relocate input files for gold. |
| | 2 | |
| | 3 | // Copyright 2006, 2007 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 "workqueue.h" |
| | 26 | #include "object.h" |
| | 27 | #include "symtab.h" |
| | 28 | #include "output.h" |
| | 29 | #include "reloc.h" |
| | 30 | |
| | 31 | namespace gold |
| | 32 | { |
| | 33 | |
| | 34 | // Read_relocs methods. |
| | 35 | |
| | 36 | // These tasks just read the relocation information from the file. |
| | 37 | // After reading it, the start another task to process the |
| | 38 | // information. These tasks requires access to the file. |
| | 39 | |
| | 40 | Task::Is_runnable_type |
| | 41 | Read_relocs::is_runnable(Workqueue*) |
| | 42 | { |
| | 43 | return this->object_->is_locked() ? IS_LOCKED : IS_RUNNABLE; |
| | 44 | } |
| | 45 | |
| | 46 | // Lock the file. |
| | 47 | |
| | 48 | Task_locker* |
| | 49 | Read_relocs::locks(Workqueue*) |
| | 50 | { |
| | 51 | return new Task_locker_obj<Object>(*this->object_); |
| | 52 | } |
| | 53 | |
| | 54 | // Read the relocations and then start a Scan_relocs_task. |
| | 55 | |
| | 56 | void |
| | 57 | Read_relocs::run(Workqueue* workqueue) |
| | 58 | { |
| | 59 | Read_relocs_data *rd = new Read_relocs_data; |
| | 60 | this->object_->read_relocs(rd); |
| | 61 | workqueue->queue_front(new Scan_relocs(this->options_, this->symtab_, |
| | 62 | this->layout_, this->object_, rd, |
| | 63 | this->symtab_lock_, this->blocker_)); |
| | 64 | } |
| | 65 | |
| | 66 | // Scan_relocs methods. |
| | 67 | |
| | 68 | // These tasks scan the relocations read by Read_relocs and mark up |
| | 69 | // the symbol table to indicate which relocations are required. We |
| | 70 | // use a lock on the symbol table to keep them from interfering with |
| | 71 | // each other. |
| | 72 | |
| | 73 | Task::Is_runnable_type |
| | 74 | Scan_relocs::is_runnable(Workqueue*) |
| | 75 | { |
| | 76 | if (!this->symtab_lock_->is_writable() || this->object_->is_locked()) |
| | 77 | return IS_LOCKED; |
| | 78 | return IS_RUNNABLE; |
| | 79 | } |
| | 80 | |
| | 81 | // Return the locks we hold: one on the file, one on the symbol table |
| | 82 | // and one blocker. |
| | 83 | |
| | 84 | class Scan_relocs::Scan_relocs_locker : public Task_locker |
| | 85 | { |
| | 86 | public: |
| | 87 | Scan_relocs_locker(Object* object, Task_token& symtab_lock, Task* task, |
| | 88 | Task_token& blocker, Workqueue* workqueue) |
| | 89 | : objlock_(*object), symtab_locker_(symtab_lock, task), |
| | 90 | blocker_(blocker, workqueue) |
| | 91 | { } |
| | 92 | |
| | 93 | private: |
| | 94 | Task_locker_obj<Object> objlock_; |
| | 95 | Task_locker_write symtab_locker_; |
| | 96 | Task_locker_block blocker_; |
| | 97 | }; |
| | 98 | |
| | 99 | Task_locker* |
| | 100 | Scan_relocs::locks(Workqueue* workqueue) |
| | 101 | { |
| | 102 | return new Scan_relocs_locker(this->object_, *this->symtab_lock_, this, |
| | 103 | *this->blocker_, workqueue); |
| | 104 | } |
| | 105 | |
| | 106 | // Scan the relocs. |
| | 107 | |
| | 108 | void |
| | 109 | Scan_relocs::run(Workqueue*) |
| | 110 | { |
| | 111 | this->object_->scan_relocs(this->options_, this->symtab_, this->layout_, |
| | 112 | this->rd_); |
| | 113 | delete this->rd_; |
| | 114 | this->rd_ = NULL; |
| | 115 | } |
| | 116 | |
| | 117 | // Relocate_task methods. |
| | 118 | |
| | 119 | // These tasks are always runnable. |
| | 120 | |
| | 121 | Task::Is_runnable_type |
| | 122 | Relocate_task::is_runnable(Workqueue*) |
| | 123 | { |
| | 124 | return IS_RUNNABLE; |
| | 125 | } |
| | 126 | |
| | 127 | // We want to lock the file while we run. We want to unblock |
| | 128 | // FINAL_BLOCKER when we are done. |
| | 129 | |
| | 130 | class Relocate_task::Relocate_locker : public Task_locker |
| | 131 | { |
| | 132 | public: |
| | 133 | Relocate_locker(Task_token& token, Workqueue* workqueue, |
| | 134 | Object* object) |
| | 135 | : blocker_(token, workqueue), objlock_(*object) |
| | 136 | { } |
| | 137 | |
| | 138 | private: |
| | 139 | Task_locker_block blocker_; |
| | 140 | Task_locker_obj<Object> objlock_; |
| | 141 | }; |
| | 142 | |
| | 143 | Task_locker* |
| | 144 | Relocate_task::locks(Workqueue* workqueue) |
| | 145 | { |
| | 146 | return new Relocate_locker(*this->final_blocker_, workqueue, |
| | 147 | this->object_); |
| | 148 | } |
| | 149 | |
| | 150 | // Run the task. |
| | 151 | |
| | 152 | void |
| | 153 | Relocate_task::run(Workqueue*) |
| | 154 | { |
| | 155 | this->object_->relocate(this->options_, this->symtab_, this->layout_, |
| | 156 | this->of_); |
| | 157 | } |
| | 158 | |
| | 159 | // Read the relocs and local symbols from the object file and store |
| | 160 | // the information in RD. |
| | 161 | |
| | 162 | template<int size, bool big_endian> |
| | 163 | void |
| | 164 | Sized_relobj<size, big_endian>::do_read_relocs(Read_relocs_data* rd) |
| | 165 | { |
| | 166 | rd->relocs.clear(); |
| | 167 | |
| | 168 | unsigned int shnum = this->shnum(); |
| | 169 | if (shnum == 0) |
| | 170 | return; |
| | 171 | |
| | 172 | rd->relocs.reserve(shnum / 2); |
| | 173 | |
| | 174 | const unsigned char *pshdrs = this->get_view(this->elf_file_.shoff(), |
| | 175 | shnum * This::shdr_size, |
| | 176 | true); |
| | 177 | // Skip the first, dummy, section. |
| | 178 | const unsigned char *ps = pshdrs + This::shdr_size; |
| | 179 | for (unsigned int i = 1; i < shnum; ++i, ps += This::shdr_size) |
| | 180 | { |
| | 181 | typename This::Shdr shdr(ps); |
| | 182 | |
| | 183 | unsigned int sh_type = shdr.get_sh_type(); |
| | 184 | if (sh_type != elfcpp::SHT_REL && sh_type != elfcpp::SHT_RELA) |
| | 185 | continue; |
| | 186 | |
| | 187 | unsigned int shndx = shdr.get_sh_info(); |
| | 188 | if (shndx >= shnum) |
| | 189 | { |
| | 190 | fprintf(stderr, _("%s: %s: relocation section %u has bad info %u\n"), |
| | 191 | program_name, this->name().c_str(), i, shndx); |
| | 192 | gold_exit(false); |
| | 193 | } |
| | 194 | |
| | 195 | if (!this->is_section_included(shndx)) |
| | 196 | continue; |
| | 197 | |
| | 198 | // We are scanning relocations in order to fill out the GOT and |
| | 199 | // PLT sections. Relocations for sections which are not |
| | 200 | // allocated (typically debugging sections) should not add new |
| | 201 | // GOT and PLT entries. So we skip them. |
| | 202 | typename This::Shdr secshdr(pshdrs + shndx * This::shdr_size); |
| | 203 | if ((secshdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0) |
| | 204 | continue; |
| | 205 | |
| | 206 | if (shdr.get_sh_link() != this->symtab_shndx_) |
| | 207 | { |
| | 208 | fprintf(stderr, |
| | 209 | _("%s: %s: relocation section %u uses unexpected " |
| | 210 | "symbol table %u\n"), |
| | 211 | program_name, this->name().c_str(), i, shdr.get_sh_link()); |
| | 212 | gold_exit(false); |
| | 213 | } |
| | 214 | |
| | 215 | off_t sh_size = shdr.get_sh_size(); |
| | 216 | |
| | 217 | unsigned int reloc_size; |
| | 218 | if (sh_type == elfcpp::SHT_REL) |
| | 219 | reloc_size = elfcpp::Elf_sizes<size>::rel_size; |
| | 220 | else |
| | 221 | reloc_size = elfcpp::Elf_sizes<size>::rela_size; |
| | 222 | if (reloc_size != shdr.get_sh_entsize()) |
| | 223 | { |
| | 224 | fprintf(stderr, |
| | 225 | _("%s: %s: unexpected entsize for reloc section %u: " |
| | 226 | "%lu != %u"), |
| | 227 | program_name, this->name().c_str(), i, |
| | 228 | static_cast<unsigned long>(shdr.get_sh_entsize()), |
| | 229 | reloc_size); |
| | 230 | gold_exit(false); |
| | 231 | } |
| | 232 | |
| | 233 | size_t reloc_count = sh_size / reloc_size; |
| | 234 | if (reloc_count * reloc_size != sh_size) |
| | 235 | { |
| | 236 | fprintf(stderr, _("%s: %s: reloc section %u size %lu uneven"), |
| | 237 | program_name, this->name().c_str(), i, |
| | 238 | static_cast<unsigned long>(sh_size)); |
| | 239 | gold_exit(false); |
| | 240 | } |
| | 241 | |
| | 242 | rd->relocs.push_back(Section_relocs()); |
| | 243 | Section_relocs& sr(rd->relocs.back()); |
| | 244 | sr.reloc_shndx = i; |
| | 245 | sr.data_shndx = shndx; |
| | 246 | sr.contents = this->get_lasting_view(shdr.get_sh_offset(), sh_size, |
| | 247 | true); |
| | 248 | sr.sh_type = sh_type; |
| | 249 | sr.reloc_count = reloc_count; |
| | 250 | } |
| | 251 | |
| | 252 | // Read the local symbols. |
| | 253 | gold_assert(this->symtab_shndx_ != -1U); |
| | 254 | if (this->symtab_shndx_ == 0 || this->local_symbol_count_ == 0) |
| | 255 | rd->local_symbols = NULL; |
| | 256 | else |
| | 257 | { |
| | 258 | typename This::Shdr symtabshdr(pshdrs |
| | 259 | + this->symtab_shndx_ * This::shdr_size); |
| | 260 | gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB); |
| | 261 | const int sym_size = This::sym_size; |
| | 262 | const unsigned int loccount = this->local_symbol_count_; |
| | 263 | gold_assert(loccount == symtabshdr.get_sh_info()); |
| | 264 | off_t locsize = loccount * sym_size; |
| | 265 | rd->local_symbols = this->get_lasting_view(symtabshdr.get_sh_offset(), |
| | 266 | locsize, true); |
| | 267 | } |
| | 268 | } |
| | 269 | |
| | 270 | // Scan the relocs and adjust the symbol table. This looks for |
| | 271 | // relocations which require GOT/PLT/COPY relocations. |
| | 272 | |
| | 273 | template<int size, bool big_endian> |
| | 274 | void |
| | 275 | Sized_relobj<size, big_endian>::do_scan_relocs(const General_options& options, |
| | 276 | Symbol_table* symtab, |
| | 277 | Layout* layout, |
| | 278 | Read_relocs_data* rd) |
| | 279 | { |
| | 280 | Sized_target<size, big_endian>* target = this->sized_target(); |
| | 281 | |
| | 282 | const unsigned char* local_symbols; |
| | 283 | if (rd->local_symbols == NULL) |
| | 284 | local_symbols = NULL; |
| | 285 | else |
| | 286 | local_symbols = rd->local_symbols->data(); |
| | 287 | |
| | 288 | for (Read_relocs_data::Relocs_list::iterator p = rd->relocs.begin(); |
| | 289 | p != rd->relocs.end(); |
| | 290 | ++p) |
| | 291 | { |
| | 292 | target->scan_relocs(options, symtab, layout, this, p->data_shndx, |
| | 293 | p->sh_type, p->contents->data(), p->reloc_count, |
| | 294 | this->local_symbol_count_, |
| | 295 | local_symbols, |
| | 296 | this->symbols_); |
| | 297 | delete p->contents; |
| | 298 | p->contents = NULL; |
| | 299 | } |
| | 300 | |
| | 301 | if (rd->local_symbols != NULL) |
| | 302 | { |
| | 303 | delete rd->local_symbols; |
| | 304 | rd->local_symbols = NULL; |
| | 305 | } |
| | 306 | } |
| | 307 | |
| | 308 | // Relocate the input sections and write out the local symbols. |
| | 309 | |
| | 310 | template<int size, bool big_endian> |
| | 311 | void |
| | 312 | Sized_relobj<size, big_endian>::do_relocate(const General_options& options, |
| | 313 | const Symbol_table* symtab, |
| | 314 | const Layout* layout, |
| | 315 | Output_file* of) |
| | 316 | { |
| | 317 | unsigned int shnum = this->shnum(); |
| | 318 | |
| | 319 | // Read the section headers. |
| | 320 | const unsigned char* pshdrs = this->get_view(this->elf_file_.shoff(), |
| | 321 | shnum * This::shdr_size, |
| | 322 | true); |
| | 323 | |
| | 324 | Views views; |
| | 325 | views.resize(shnum); |
| | 326 | |
| | 327 | // Make two passes over the sections. The first one copies the |
| | 328 | // section data to the output file. The second one applies |
| | 329 | // relocations. |
| | 330 | |
| | 331 | this->write_sections(pshdrs, of, &views); |
| | 332 | |
| | 333 | // Apply relocations. |
| | 334 | |
| | 335 | this->relocate_sections(options, symtab, layout, pshdrs, &views); |
| | 336 | |
| | 337 | // Write out the accumulated views. |
| | 338 | for (unsigned int i = 1; i < shnum; ++i) |
| | 339 | { |
| | 340 | if (views[i].view != NULL) |
| | 341 | of->write_output_view(views[i].offset, views[i].view_size, |
| | 342 | views[i].view); |
| | 343 | } |
| | 344 | |
| | 345 | // Write out the local symbols. |
| | 346 | this->write_local_symbols(of, layout->sympool()); |
| | 347 | } |
| | 348 | |
| | 349 | // Write section data to the output file. PSHDRS points to the |
| | 350 | // section headers. Record the views in *PVIEWS for use when |
| | 351 | // relocating. |
| | 352 | |
| | 353 | template<int size, bool big_endian> |
| | 354 | void |
| | 355 | Sized_relobj<size, big_endian>::write_sections(const unsigned char* pshdrs, |
| | 356 | Output_file* of, |
| | 357 | Views* pviews) |
| | 358 | { |
| | 359 | unsigned int shnum = this->shnum(); |
| | 360 | std::vector<Map_to_output>& map_sections(this->map_to_output()); |
| | 361 | |
| | 362 | const unsigned char* p = pshdrs + This::shdr_size; |
| | 363 | for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size) |
| | 364 | { |
| | 365 | View_size* pvs = &(*pviews)[i]; |
| | 366 | |
| | 367 | pvs->view = NULL; |
| | 368 | |
| | 369 | if (map_sections[i].offset == -1) |
| | 370 | continue; |
| | 371 | |
| | 372 | const Output_section* os = map_sections[i].output_section; |
| | 373 | if (os == NULL) |
| | 374 | continue; |
| | 375 | |
| | 376 | typename This::Shdr shdr(p); |
| | 377 | |
| | 378 | if (shdr.get_sh_type() == elfcpp::SHT_NOBITS) |
| | 379 | continue; |
| | 380 | |
| | 381 | off_t start = os->offset() + map_sections[i].offset; |
| | 382 | off_t sh_size = shdr.get_sh_size(); |
| | 383 | |
| | 384 | if (sh_size == 0) |
| | 385 | continue; |
| | 386 | |
| | 387 | gold_assert(map_sections[i].offset >= 0 |
| | 388 | && map_sections[i].offset + sh_size <= os->data_size()); |
| | 389 | |
| | 390 | unsigned char* view = of->get_output_view(start, sh_size); |
| | 391 | this->read(shdr.get_sh_offset(), sh_size, view); |
| | 392 | |
| | 393 | pvs->view = view; |
| | 394 | pvs->address = os->address() + map_sections[i].offset; |
| | 395 | pvs->offset = start; |
| | 396 | pvs->view_size = sh_size; |
| | 397 | } |
| | 398 | } |
| | 399 | |
| | 400 | // Relocate section data. VIEWS points to the section data as views |
| | 401 | // in the output file. |
| | 402 | |
| | 403 | template<int size, bool big_endian> |
| | 404 | void |
| | 405 | Sized_relobj<size, big_endian>::relocate_sections( |
| | 406 | const General_options& options, |
| | 407 | const Symbol_table* symtab, |
| | 408 | const Layout* layout, |
| | 409 | const unsigned char* pshdrs, |
| | 410 | Views* pviews) |
| | 411 | { |
| | 412 | unsigned int shnum = this->shnum(); |
| | 413 | Sized_target<size, big_endian>* target = this->sized_target(); |
| | 414 | |
| | 415 | Relocate_info<size, big_endian> relinfo; |
| | 416 | relinfo.options = &options; |
| | 417 | relinfo.symtab = symtab; |
| | 418 | relinfo.layout = layout; |
| | 419 | relinfo.object = this; |
| | 420 | relinfo.local_symbol_count = this->local_symbol_count_; |
| | 421 | relinfo.local_values = &this->local_values_; |
| | 422 | relinfo.symbols = this->symbols_; |
| | 423 | |
| | 424 | const unsigned char* p = pshdrs + This::shdr_size; |
| | 425 | for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size) |
| | 426 | { |
| | 427 | typename This::Shdr shdr(p); |
| | 428 | |
| | 429 | unsigned int sh_type = shdr.get_sh_type(); |
| | 430 | if (sh_type != elfcpp::SHT_REL && sh_type != elfcpp::SHT_RELA) |
| | 431 | continue; |
| | 432 | |
| | 433 | unsigned int index = shdr.get_sh_info(); |
| | 434 | if (index >= this->shnum()) |
| | 435 | { |
| | 436 | fprintf(stderr, _("%s: %s: relocation section %u has bad info %u\n"), |
| | 437 | program_name, this->name().c_str(), i, index); |
| | 438 | gold_exit(false); |
| | 439 | } |
| | 440 | |
| | 441 | if (!this->is_section_included(index)) |
| | 442 | { |
| | 443 | // This relocation section is against a section which we |
| | 444 | // discarded. |
| | 445 | continue; |
| | 446 | } |
| | 447 | |
| | 448 | gold_assert((*pviews)[index].view != NULL); |
| | 449 | |
| | 450 | if (shdr.get_sh_link() != this->symtab_shndx_) |
| | 451 | { |
| | 452 | fprintf(stderr, |
| | 453 | _("%s: %s: relocation section %u uses unexpected " |
| | 454 | "symbol table %u\n"), |
| | 455 | program_name, this->name().c_str(), i, shdr.get_sh_link()); |
| | 456 | gold_exit(false); |
| | 457 | } |
| | 458 | |
| | 459 | off_t sh_size = shdr.get_sh_size(); |
| | 460 | const unsigned char* prelocs = this->get_view(shdr.get_sh_offset(), |
| | 461 | sh_size, false); |
| | 462 | |
| | 463 | unsigned int reloc_size; |
| | 464 | if (sh_type == elfcpp::SHT_REL) |
| | 465 | reloc_size = elfcpp::Elf_sizes<size>::rel_size; |
| | 466 | else |
| | 467 | reloc_size = elfcpp::Elf_sizes<size>::rela_size; |
| | 468 | |
| | 469 | if (reloc_size != shdr.get_sh_entsize()) |
| | 470 | { |
| | 471 | fprintf(stderr, |
| | 472 | _("%s: %s: unexpected entsize for reloc section %u: " |
| | 473 | "%lu != %u"), |
| | 474 | program_name, this->name().c_str(), i, |
| | 475 | static_cast<unsigned long>(shdr.get_sh_entsize()), |
| | 476 | reloc_size); |
| | 477 | gold_exit(false); |
| | 478 | } |
| | 479 | |
| | 480 | size_t reloc_count = sh_size / reloc_size; |
| | 481 | if (reloc_count * reloc_size != sh_size) |
| | 482 | { |
| | 483 | fprintf(stderr, _("%s: %s: reloc section %u size %lu uneven"), |
| | 484 | program_name, this->name().c_str(), i, |
| | 485 | static_cast<unsigned long>(sh_size)); |
| | 486 | gold_exit(false); |
| | 487 | } |
| | 488 | |
| | 489 | relinfo.reloc_shndx = i; |
| | 490 | relinfo.data_shndx = index; |
| | 491 | target->relocate_section(&relinfo, |
| | 492 | sh_type, |
| | 493 | prelocs, |
| | 494 | reloc_count, |
| | 495 | (*pviews)[index].view, |
| | 496 | (*pviews)[index].address, |
| | 497 | (*pviews)[index].view_size); |
| | 498 | } |
| | 499 | } |
| | 500 | |
| | 501 | // Copy_relocs::Copy_reloc_entry methods. |
| | 502 | |
| | 503 | // Return whether we should emit this reloc. We should emit it if the |
| | 504 | // symbol is still defined in a dynamic object. If we should not emit |
| | 505 | // it, we clear it, to save ourselves the test next time. |
| | 506 | |
| | 507 | template<int size, bool big_endian> |
| | 508 | bool |
| | 509 | Copy_relocs<size, big_endian>::Copy_reloc_entry::should_emit() |
| | 510 | { |
| | 511 | if (this->sym_ == NULL) |
| | 512 | return false; |
| | 513 | if (this->sym_->is_from_dynobj()) |
| | 514 | return true; |
| | 515 | this->sym_ = NULL; |
| | 516 | return false; |
| | 517 | } |
| | 518 | |
| | 519 | // Emit a reloc into a SHT_REL section. |
| | 520 | |
| | 521 | template<int size, bool big_endian> |
| | 522 | void |
| | 523 | Copy_relocs<size, big_endian>::Copy_reloc_entry::emit( |
| | 524 | Output_data_reloc<elfcpp::SHT_REL, true, size, big_endian>* reloc_data) |
| | 525 | { |
| | 526 | this->sym_->set_needs_dynsym_entry(); |
| | 527 | reloc_data->add_global(this->sym_, this->reloc_type_, this->relobj_, |
| | 528 | this->shndx_, this->address_); |
| | 529 | } |
| | 530 | |
| | 531 | // Emit a reloc into a SHT_RELA section. |
| | 532 | |
| | 533 | template<int size, bool big_endian> |
| | 534 | void |
| | 535 | Copy_relocs<size, big_endian>::Copy_reloc_entry::emit( |
| | 536 | Output_data_reloc<elfcpp::SHT_RELA, true, size, big_endian>* reloc_data) |
| | 537 | { |
| | 538 | this->sym_->set_needs_dynsym_entry(); |
| | 539 | reloc_data->add_global(this->sym_, this->reloc_type_, this->relobj_, |
| | 540 | this->shndx_, this->address_, this->addend_); |
| | 541 | } |
| | 542 | |
| | 543 | // Copy_relocs methods. |
| | 544 | |
| | 545 | // Return whether we need a COPY reloc for a relocation against GSYM. |
| | 546 | // The relocation is being applied to section SHNDX in OBJECT. |
| | 547 | |
| | 548 | template<int size, bool big_endian> |
| | 549 | bool |
| | 550 | Copy_relocs<size, big_endian>::need_copy_reloc( |
| | 551 | const General_options*, |
| | 552 | Relobj* object, |
| | 553 | unsigned int shndx, |
| | 554 | Sized_symbol<size>* sym) |
| | 555 | { |
| | 556 | // FIXME: Handle -z nocopyrelocs. |
| | 557 | |
| | 558 | if (sym->symsize() == 0) |
| | 559 | return false; |
| | 560 | |
| | 561 | // If this is a readonly section, then we need a COPY reloc. |
| | 562 | // Otherwise we can use a dynamic reloc. |
| | 563 | if ((object->section_flags(shndx) & elfcpp::SHF_WRITE) == 0) |
| | 564 | return true; |
| | 565 | |
| | 566 | return false; |
| | 567 | } |
| | 568 | |
| | 569 | // Save a Rel reloc. |
| | 570 | |
| | 571 | template<int size, bool big_endian> |
| | 572 | void |
| | 573 | Copy_relocs<size, big_endian>::save( |
| | 574 | Symbol* sym, |
| | 575 | Relobj* relobj, |
| | 576 | unsigned int shndx, |
| | 577 | const elfcpp::Rel<size, big_endian>& rel) |
| | 578 | { |
| | 579 | unsigned int reloc_type = elfcpp::elf_r_type<size>(rel.get_r_info()); |
| | 580 | this->entries_.push_back(Copy_reloc_entry(sym, reloc_type, relobj, shndx, |
| | 581 | rel.get_r_offset(), 0)); |
| | 582 | } |
| | 583 | |
| | 584 | // Save a Rela reloc. |
| | 585 | |
| | 586 | template<int size, bool big_endian> |
| | 587 | void |
| | 588 | Copy_relocs<size, big_endian>::save( |
| | 589 | Symbol* sym, |
| | 590 | Relobj* relobj, |
| | 591 | unsigned int shndx, |
| | 592 | const elfcpp::Rela<size, big_endian>& rela) |
| | 593 | { |
| | 594 | unsigned int reloc_type = elfcpp::elf_r_type<size>(rela.get_r_info()); |
| | 595 | this->entries_.push_back(Copy_reloc_entry(sym, reloc_type, relobj, shndx, |
| | 596 | rela.get_r_offset(), |
| | 597 | rela.get_r_addend())); |
| | 598 | } |
| | 599 | |
| | 600 | // Return whether there are any relocs to emit. We don't want to emit |
| | 601 | // a reloc if the symbol is no longer defined in a dynamic object. |
| | 602 | |
| | 603 | template<int size, bool big_endian> |
| | 604 | bool |
| | 605 | Copy_relocs<size, big_endian>::any_to_emit() |
| | 606 | { |
| | 607 | for (typename Copy_reloc_entries::iterator p = this->entries_.begin(); |
| | 608 | p != this->entries_.end(); |
| | 609 | ++p) |
| | 610 | { |
| | 611 | if (p->should_emit()) |
| | 612 | return true; |
| | 613 | } |
| | 614 | return false; |
| | 615 | } |
| | 616 | |
| | 617 | // Emit relocs. |
| | 618 | |
| | 619 | template<int size, bool big_endian> |
| | 620 | template<int sh_type> |
| | 621 | void |
| | 622 | Copy_relocs<size, big_endian>::emit( |
| | 623 | Output_data_reloc<sh_type, true, size, big_endian>* reloc_data) |
| | 624 | { |
| | 625 | for (typename Copy_reloc_entries::iterator p = this->entries_.begin(); |
| | 626 | p != this->entries_.end(); |
| | 627 | ++p) |
| | 628 | { |
| | 629 | if (p->should_emit()) |
| | 630 | p->emit(reloc_data); |
| | 631 | } |
| | 632 | } |
| | 633 | |
| | 634 | // Instantiate the templates we need. We could use the configure |
| | 635 | // script to restrict this to only the ones for implemented targets. |
| | 636 | |
| | 637 | #ifdef HAVE_TARGET_32_LITTLE |
| | 638 | template |
| | 639 | void |
| | 640 | Sized_relobj<32, false>::do_read_relocs(Read_relocs_data* rd); |
| | 641 | #endif |
| | 642 | |
| | 643 | #ifdef HAVE_TARGET_32_BIG |
| | 644 | template |
| | 645 | void |
| | 646 | Sized_relobj<32, true>::do_read_relocs(Read_relocs_data* rd); |
| | 647 | #endif |
| | 648 | |
| | 649 | #ifdef HAVE_TARGET_64_LITTLE |
| | 650 | template |
| | 651 | void |
| | 652 | Sized_relobj<64, false>::do_read_relocs(Read_relocs_data* rd); |
| | 653 | #endif |
| | 654 | |
| | 655 | #ifdef HAVE_TARGET_64_BIG |
| | 656 | template |
| | 657 | void |
| | 658 | Sized_relobj<64, true>::do_read_relocs(Read_relocs_data* rd); |
| | 659 | #endif |
| | 660 | |
| | 661 | #ifdef HAVE_TARGET_32_LITTLE |
| | 662 | template |
| | 663 | void |
| | 664 | Sized_relobj<32, false>::do_scan_relocs(const General_options& options, |
| | 665 | Symbol_table* symtab, |
| | 666 | Layout* layout, |
| | 667 | Read_relocs_data* rd); |
| | 668 | #endif |
| | 669 | |
| | 670 | #ifdef HAVE_TARGET_32_BIG |
| | 671 | template |
| | 672 | void |
| | 673 | Sized_relobj<32, true>::do_scan_relocs(const General_options& options, |
| | 674 | Symbol_table* symtab, |
| | 675 | Layout* layout, |
| | 676 | Read_relocs_data* rd); |
| | 677 | #endif |
| | 678 | |
| | 679 | #ifdef HAVE_TARGET_64_LITTLE |
| | 680 | template |
| | 681 | void |
| | 682 | Sized_relobj<64, false>::do_scan_relocs(const General_options& options, |
| | 683 | Symbol_table* symtab, |
| | 684 | Layout* layout, |
| | 685 | Read_relocs_data* rd); |
| | 686 | #endif |
| | 687 | |
| | 688 | #ifdef HAVE_TARGET_64_BIG |
| | 689 | template |
| | 690 | void |
| | 691 | Sized_relobj<64, true>::do_scan_relocs(const General_options& options, |
| | 692 | Symbol_table* symtab, |
| | 693 | Layout* layout, |
| | 694 | Read_relocs_data* rd); |
| | 695 | #endif |
| | 696 | |
| | 697 | #ifdef HAVE_TARGET_32_LITTLE |
| | 698 | template |
| | 699 | void |
| | 700 | Sized_relobj<32, false>::do_relocate(const General_options& options, |
| | 701 | const Symbol_table* symtab, |
| | 702 | const Layout* layout, |
| | 703 | Output_file* of); |
| | 704 | #endif |
| | 705 | |
| | 706 | #ifdef HAVE_TARGET_32_BIG |
| | 707 | template |
| | 708 | void |
| | 709 | Sized_relobj<32, true>::do_relocate(const General_options& options, |
| | 710 | const Symbol_table* symtab, |
| | 711 | const Layout* layout, |
| | 712 | Output_file* of); |
| | 713 | #endif |
| | 714 | |
| | 715 | #ifdef HAVE_TARGET_64_LITTLE |
| | 716 | template |
| | 717 | void |
| | 718 | Sized_relobj<64, false>::do_relocate(const General_options& options, |
| | 719 | const Symbol_table* symtab, |
| | 720 | const Layout* layout, |
| | 721 | Output_file* of); |
| | 722 | #endif |
| | 723 | |
| | 724 | #ifdef HAVE_TARGET_64_BIG |
| | 725 | template |
| | 726 | void |
| | 727 | Sized_relobj<64, true>::do_relocate(const General_options& options, |
| | 728 | const Symbol_table* symtab, |
| | 729 | const Layout* layout, |
| | 730 | Output_file* of); |
| | 731 | #endif |
| | 732 | |
| | 733 | #ifdef HAVE_TARGET_32_LITTLE |
| | 734 | template |
| | 735 | class Copy_relocs<32, false>; |
| | 736 | #endif |
| | 737 | |
| | 738 | #ifdef HAVE_TARGET_32_BIG |
| | 739 | template |
| | 740 | class Copy_relocs<32, true>; |
| | 741 | #endif |
| | 742 | |
| | 743 | #ifdef HAVE_TARGET_64_LITTLE |
| | 744 | template |
| | 745 | class Copy_relocs<64, false>; |
| | 746 | #endif |
| | 747 | |
| | 748 | #ifdef HAVE_TARGET_64_BIG |
| | 749 | template |
| | 750 | class Copy_relocs<64, true>; |
| | 751 | #endif |
| | 752 | |
| | 753 | #ifdef HAVE_TARGET_32_LITTLE |
| | 754 | template |
| | 755 | void |
| | 756 | Copy_relocs<32, false>::emit<elfcpp::SHT_REL>( |
| | 757 | Output_data_reloc<elfcpp::SHT_REL, true, 32, false>*); |
| | 758 | #endif |
| | 759 | |
| | 760 | #ifdef HAVE_TARGET_32_BIG |
| | 761 | template |
| | 762 | void |
| | 763 | Copy_relocs<32, true>::emit<elfcpp::SHT_REL>( |
| | 764 | Output_data_reloc<elfcpp::SHT_REL, true, 32, true>*); |
| | 765 | #endif |
| | 766 | |
| | 767 | #ifdef HAVE_TARGET_64_LITTLE |
| | 768 | template |
| | 769 | void |
| | 770 | Copy_relocs<64, false>::emit<elfcpp::SHT_REL>( |
| | 771 | Output_data_reloc<elfcpp::SHT_REL, true, 64, false>*); |
| | 772 | #endif |
| | 773 | |
| | 774 | #ifdef HAVE_TARGET_64_BIG |
| | 775 | template |
| | 776 | void |
| | 777 | Copy_relocs<64, true>::emit<elfcpp::SHT_REL>( |
| | 778 | Output_data_reloc<elfcpp::SHT_REL, true, 64, true>*); |
| | 779 | #endif |
| | 780 | |
| | 781 | #ifdef HAVE_TARGET_32_LITTLE |
| | 782 | template |
| | 783 | void |
| | 784 | Copy_relocs<32, false>::emit<elfcpp::SHT_RELA>( |
| | 785 | Output_data_reloc<elfcpp::SHT_RELA , true, 32, false>*); |
| | 786 | #endif |
| | 787 | |
| | 788 | #ifdef HAVE_TARGET_32_BIG |
| | 789 | template |
| | 790 | void |
| | 791 | Copy_relocs<32, true>::emit<elfcpp::SHT_RELA>( |
| | 792 | Output_data_reloc<elfcpp::SHT_RELA, true, 32, true>*); |
| | 793 | #endif |
| | 794 | |
| | 795 | #ifdef HAVE_TARGET_64_LITTLE |
| | 796 | template |
| | 797 | void |
| | 798 | Copy_relocs<64, false>::emit<elfcpp::SHT_RELA>( |
| | 799 | Output_data_reloc<elfcpp::SHT_RELA, true, 64, false>*); |
| | 800 | #endif |
| | 801 | |
| | 802 | #ifdef HAVE_TARGET_64_BIG |
| | 803 | template |
| | 804 | void |
| | 805 | Copy_relocs<64, true>::emit<elfcpp::SHT_RELA>( |
| | 806 | Output_data_reloc<elfcpp::SHT_RELA, true, 64, true>*); |
| | 807 | #endif |
| | 808 | |
| | 809 | } // End namespace gold. |
projects / deliverable / binutils-gdb.git / blame_incremental