1// reloc.cc -- relocate input files for gold. 2 3// Copyright (C) 2006-2017 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 <algorithm> 26 27#include "workqueue.h" 28#include "layout.h" 29#include "symtab.h" 30#include "output.h" 31#include "merge.h" 32#include "object.h" 33#include "target-reloc.h" 34#include "reloc.h" 35#include "icf.h" 36#include "compressed_output.h" 37#include "incremental.h" 38 39namespace gold 40{ 41 42// Read_relocs methods. 43 44// These tasks just read the relocation information from the file. 45// After reading it, the start another task to process the 46// information. These tasks requires access to the file. 47 48Task_token* 49Read_relocs::is_runnable() 50{ 51 return this->object_->is_locked() ? this->object_->token() : NULL; 52} 53 54// Lock the file. 55 56void 57Read_relocs::locks(Task_locker* tl) 58{ 59 Task_token* token = this->object_->token(); 60 if (token != NULL) 61 tl->add(this, token); 62} 63 64// Read the relocations and then start a Scan_relocs_task. 65 66void 67Read_relocs::run(Workqueue* workqueue) 68{ 69 Read_relocs_data* rd = new Read_relocs_data; 70 this->object_->read_relocs(rd); 71 this->object_->set_relocs_data(rd); 72 this->object_->release(); 73 74 // If garbage collection or identical comdat folding is desired, we 75 // process the relocs first before scanning them. Scanning of relocs is 76 // done only after garbage or identical sections is identified. 77 if (parameters->options().gc_sections() 78 || parameters->options().icf_enabled()) 79 { 80 workqueue->queue_next(new Gc_process_relocs(this->symtab_, 81 this->layout_, 82 this->object_, rd, 83 this->this_blocker_, 84 this->next_blocker_)); 85 } 86 else 87 { 88 workqueue->queue_next(new Scan_relocs(this->symtab_, this->layout_, 89 this->object_, rd, 90 this->this_blocker_, 91 this->next_blocker_)); 92 } 93} 94 95// Return a debugging name for the task. 96 97std::string 98Read_relocs::get_name() const 99{ 100 return "Read_relocs " + this->object_->name(); 101} 102 103// Gc_process_relocs methods. 104 105Gc_process_relocs::~Gc_process_relocs() 106{ 107 if (this->this_blocker_ != NULL) 108 delete this->this_blocker_; 109} 110 111// These tasks process the relocations read by Read_relocs and 112// determine which sections are referenced and which are garbage. 113// This task is done only when --gc-sections is used. This is blocked 114// by THIS_BLOCKER_. It unblocks NEXT_BLOCKER_. 115 116Task_token* 117Gc_process_relocs::is_runnable() 118{ 119 if (this->this_blocker_ != NULL && this->this_blocker_->is_blocked()) 120 return this->this_blocker_; 121 if (this->object_->is_locked()) 122 return this->object_->token(); 123 return NULL; 124} 125 126void 127Gc_process_relocs::locks(Task_locker* tl) 128{ 129 tl->add(this, this->object_->token()); 130 tl->add(this, this->next_blocker_); 131} 132 133void 134Gc_process_relocs::run(Workqueue*) 135{ 136 this->object_->gc_process_relocs(this->symtab_, this->layout_, this->rd_); 137 this->object_->release(); 138} 139 140// Return a debugging name for the task. 141 142std::string 143Gc_process_relocs::get_name() const 144{ 145 return "Gc_process_relocs " + this->object_->name(); 146} 147 148// Scan_relocs methods. 149 150Scan_relocs::~Scan_relocs() 151{ 152 if (this->this_blocker_ != NULL) 153 delete this->this_blocker_; 154} 155 156// These tasks scan the relocations read by Read_relocs and mark up 157// the symbol table to indicate which relocations are required. We 158// use a lock on the symbol table to keep them from interfering with 159// each other. 160 161Task_token* 162Scan_relocs::is_runnable() 163{ 164 if (this->this_blocker_ != NULL && this->this_blocker_->is_blocked()) 165 return this->this_blocker_; 166 if (this->object_->is_locked()) 167 return this->object_->token(); 168 return NULL; 169} 170 171// Return the locks we hold: one on the file, one on the symbol table 172// and one blocker. 173 174void 175Scan_relocs::locks(Task_locker* tl) 176{ 177 Task_token* token = this->object_->token(); 178 if (token != NULL) 179 tl->add(this, token); 180 tl->add(this, this->next_blocker_); 181} 182 183// Scan the relocs. 184 185void 186Scan_relocs::run(Workqueue*) 187{ 188 this->object_->scan_relocs(this->symtab_, this->layout_, this->rd_); 189 delete this->rd_; 190 this->rd_ = NULL; 191 this->object_->release(); 192} 193 194// Return a debugging name for the task. 195 196std::string 197Scan_relocs::get_name() const 198{ 199 return "Scan_relocs " + this->object_->name(); 200} 201 202// Relocate_task methods. 203 204// We may have to wait for the output sections to be written. 205 206Task_token* 207Relocate_task::is_runnable() 208{ 209 if (this->object_->relocs_must_follow_section_writes() 210 && this->output_sections_blocker_->is_blocked()) 211 return this->output_sections_blocker_; 212 213 if (this->object_->is_locked()) 214 return this->object_->token(); 215 216 return NULL; 217} 218 219// We want to lock the file while we run. We want to unblock 220// INPUT_SECTIONS_BLOCKER and FINAL_BLOCKER when we are done. 221// INPUT_SECTIONS_BLOCKER may be NULL. 222 223void 224Relocate_task::locks(Task_locker* tl) 225{ 226 if (this->input_sections_blocker_ != NULL) 227 tl->add(this, this->input_sections_blocker_); 228 tl->add(this, this->final_blocker_); 229 Task_token* token = this->object_->token(); 230 if (token != NULL) 231 tl->add(this, token); 232} 233 234// Run the task. 235 236void 237Relocate_task::run(Workqueue*) 238{ 239 this->object_->relocate(this->symtab_, this->layout_, this->of_); 240 241 // This is normally the last thing we will do with an object, so 242 // uncache all views. 243 this->object_->clear_view_cache_marks(); 244 245 this->object_->release(); 246} 247 248// Return a debugging name for the task. 249 250std::string 251Relocate_task::get_name() const 252{ 253 return "Relocate_task " + this->object_->name(); 254} 255 256// Read the relocs and local symbols from the object file and store 257// the information in RD. 258 259template<int size, bool big_endian> 260void 261Sized_relobj_file<size, big_endian>::do_read_relocs(Read_relocs_data* rd) 262{ 263 rd->relocs.clear(); 264 265 unsigned int shnum = this->shnum(); 266 if (shnum == 0) 267 return; 268 269 rd->relocs.reserve(shnum / 2); 270 271 const Output_sections& out_sections(this->output_sections()); 272 const std::vector<Address>& out_offsets(this->section_offsets()); 273 274 const unsigned char* pshdrs = this->get_view(this->elf_file_.shoff(), 275 shnum * This::shdr_size, 276 true, true); 277 // Skip the first, dummy, section. 278 const unsigned char* ps = pshdrs + This::shdr_size; 279 for (unsigned int i = 1; i < shnum; ++i, ps += This::shdr_size) 280 { 281 typename This::Shdr shdr(ps); 282 283 unsigned int sh_type = shdr.get_sh_type(); 284 if (sh_type != elfcpp::SHT_REL && sh_type != elfcpp::SHT_RELA) 285 continue; 286 287 unsigned int shndx = this->adjust_shndx(shdr.get_sh_info()); 288 if (shndx >= shnum) 289 { 290 this->error(_("relocation section %u has bad info %u"), 291 i, shndx); 292 continue; 293 } 294 295 Output_section* os = out_sections[shndx]; 296 if (os == NULL) 297 continue; 298 299 // We are scanning relocations in order to fill out the GOT and 300 // PLT sections. Relocations for sections which are not 301 // allocated (typically debugging sections) should not add new 302 // GOT and PLT entries. So we skip them unless this is a 303 // relocatable link or we need to emit relocations. FIXME: What 304 // should we do if a linker script maps a section with SHF_ALLOC 305 // clear to a section with SHF_ALLOC set? 306 typename This::Shdr secshdr(pshdrs + shndx * This::shdr_size); 307 bool is_section_allocated = ((secshdr.get_sh_flags() & elfcpp::SHF_ALLOC) 308 != 0); 309 if (!is_section_allocated 310 && !parameters->options().relocatable() 311 && !parameters->options().emit_relocs() 312 && !parameters->incremental()) 313 continue; 314 315 if (this->adjust_shndx(shdr.get_sh_link()) != this->symtab_shndx_) 316 { 317 this->error(_("relocation section %u uses unexpected " 318 "symbol table %u"), 319 i, this->adjust_shndx(shdr.get_sh_link())); 320 continue; 321 } 322 323 off_t sh_size = shdr.get_sh_size(); 324 325 if (sh_size == 0) 326 continue; 327 328 unsigned int reloc_size; 329 if (sh_type == elfcpp::SHT_REL) 330 reloc_size = elfcpp::Elf_sizes<size>::rel_size; 331 else 332 reloc_size = elfcpp::Elf_sizes<size>::rela_size; 333 if (reloc_size != shdr.get_sh_entsize()) 334 { 335 this->error(_("unexpected entsize for reloc section %u: %lu != %u"), 336 i, static_cast<unsigned long>(shdr.get_sh_entsize()), 337 reloc_size); 338 continue; 339 } 340 341 size_t reloc_count = sh_size / reloc_size; 342 if (static_cast<off_t>(reloc_count * reloc_size) != sh_size) 343 { 344 this->error(_("reloc section %u size %lu uneven"), 345 i, static_cast<unsigned long>(sh_size)); 346 continue; 347 } 348 349 rd->relocs.push_back(Section_relocs()); 350 Section_relocs& sr(rd->relocs.back()); 351 sr.reloc_shndx = i; 352 sr.data_shndx = shndx; 353 sr.contents = this->get_lasting_view(shdr.get_sh_offset(), sh_size, 354 true, true); 355 sr.sh_type = sh_type; 356 sr.reloc_count = reloc_count; 357 sr.output_section = os; 358 sr.needs_special_offset_handling = out_offsets[shndx] == invalid_address; 359 sr.is_data_section_allocated = is_section_allocated; 360 } 361 362 // Read the local symbols. 363 gold_assert(this->symtab_shndx_ != -1U); 364 if (this->symtab_shndx_ == 0 || this->local_symbol_count_ == 0) 365 rd->local_symbols = NULL; 366 else 367 { 368 typename This::Shdr symtabshdr(pshdrs 369 + this->symtab_shndx_ * This::shdr_size); 370 gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB); 371 const int sym_size = This::sym_size; 372 const unsigned int loccount = this->local_symbol_count_; 373 gold_assert(loccount == symtabshdr.get_sh_info()); 374 off_t locsize = loccount * sym_size; 375 rd->local_symbols = this->get_lasting_view(symtabshdr.get_sh_offset(), 376 locsize, true, true); 377 } 378} 379 380// Process the relocs to generate mappings from source sections to referenced 381// sections. This is used during garbage collection to determine garbage 382// sections. 383 384template<int size, bool big_endian> 385void 386Sized_relobj_file<size, big_endian>::do_gc_process_relocs(Symbol_table* symtab, 387 Layout* layout, 388 Read_relocs_data* rd) 389{ 390 Sized_target<size, big_endian>* target = 391 parameters->sized_target<size, big_endian>(); 392 393 const unsigned char* local_symbols; 394 if (rd->local_symbols == NULL) 395 local_symbols = NULL; 396 else 397 local_symbols = rd->local_symbols->data(); 398 399 for (Read_relocs_data::Relocs_list::iterator p = rd->relocs.begin(); 400 p != rd->relocs.end(); 401 ++p) 402 { 403 if (!parameters->options().relocatable()) 404 { 405 // As noted above, when not generating an object file, we 406 // only scan allocated sections. We may see a non-allocated 407 // section here if we are emitting relocs. 408 if (p->is_data_section_allocated) 409 target->gc_process_relocs(symtab, layout, this, 410 p->data_shndx, p->sh_type, 411 p->contents->data(), p->reloc_count, 412 p->output_section, 413 p->needs_special_offset_handling, 414 this->local_symbol_count_, 415 local_symbols); 416 } 417 } 418} 419 420 421// Scan the relocs and adjust the symbol table. This looks for 422// relocations which require GOT/PLT/COPY relocations. 423 424template<int size, bool big_endian> 425void 426Sized_relobj_file<size, big_endian>::do_scan_relocs(Symbol_table* symtab, 427 Layout* layout, 428 Read_relocs_data* rd) 429{ 430 Sized_target<size, big_endian>* target = 431 parameters->sized_target<size, big_endian>(); 432 433 const unsigned char* local_symbols; 434 if (rd->local_symbols == NULL) 435 local_symbols = NULL; 436 else 437 local_symbols = rd->local_symbols->data(); 438 439 // For incremental links, allocate the counters for incremental relocations. 440 if (layout->incremental_inputs() != NULL) 441 this->allocate_incremental_reloc_counts(); 442 443 for (Read_relocs_data::Relocs_list::iterator p = rd->relocs.begin(); 444 p != rd->relocs.end(); 445 ++p) 446 { 447 // When garbage collection is on, unreferenced sections are not included 448 // in the link that would have been included normally. This is known only 449 // after Read_relocs hence this check has to be done again. 450 if (parameters->options().gc_sections() 451 || parameters->options().icf_enabled()) 452 { 453 if (p->output_section == NULL) 454 continue; 455 } 456 if (!parameters->options().relocatable()) 457 { 458 // As noted above, when not generating an object file, we 459 // only scan allocated sections. We may see a non-allocated 460 // section here if we are emitting relocs. 461 if (p->is_data_section_allocated) 462 target->scan_relocs(symtab, layout, this, p->data_shndx, 463 p->sh_type, p->contents->data(), 464 p->reloc_count, p->output_section, 465 p->needs_special_offset_handling, 466 this->local_symbol_count_, 467 local_symbols); 468 if (parameters->options().emit_relocs()) 469 this->emit_relocs_scan(symtab, layout, local_symbols, p); 470 if (layout->incremental_inputs() != NULL) 471 this->incremental_relocs_scan(p); 472 } 473 else 474 { 475 Relocatable_relocs* rr = this->relocatable_relocs(p->reloc_shndx); 476 gold_assert(rr != NULL); 477 rr->set_reloc_count(p->reloc_count); 478 target->scan_relocatable_relocs(symtab, layout, this, 479 p->data_shndx, p->sh_type, 480 p->contents->data(), 481 p->reloc_count, 482 p->output_section, 483 p->needs_special_offset_handling, 484 this->local_symbol_count_, 485 local_symbols, 486 rr); 487 } 488 489 delete p->contents; 490 p->contents = NULL; 491 } 492 493 // For incremental links, finalize the allocation of relocations. 494 if (layout->incremental_inputs() != NULL) 495 this->finalize_incremental_relocs(layout, true); 496 497 if (rd->local_symbols != NULL) 498 { 499 delete rd->local_symbols; 500 rd->local_symbols = NULL; 501 } 502} 503 504// Scan the input relocations for --emit-relocs. 505 506template<int size, bool big_endian> 507void 508Sized_relobj_file<size, big_endian>::emit_relocs_scan( 509 Symbol_table* symtab, 510 Layout* layout, 511 const unsigned char* plocal_syms, 512 const Read_relocs_data::Relocs_list::iterator& p) 513{ 514 Sized_target<size, big_endian>* target = 515 parameters->sized_target<size, big_endian>(); 516 517 Relocatable_relocs* rr = this->relocatable_relocs(p->reloc_shndx); 518 gold_assert(rr != NULL); 519 rr->set_reloc_count(p->reloc_count); 520 target->emit_relocs_scan( 521 symtab, 522 layout, 523 this, 524 p->data_shndx, 525 p->sh_type, 526 p->contents->data(), 527 p->reloc_count, 528 p->output_section, 529 p->needs_special_offset_handling, 530 this->local_symbol_count_, 531 plocal_syms, 532 rr); 533} 534 535// Scan the input relocations for --incremental. 536 537template<int size, bool big_endian> 538void 539Sized_relobj_file<size, big_endian>::incremental_relocs_scan( 540 const Read_relocs_data::Relocs_list::iterator& p) 541{ 542 if (p->sh_type == elfcpp::SHT_REL) 543 this->incremental_relocs_scan_reltype<elfcpp::SHT_REL>(p); 544 else 545 { 546 gold_assert(p->sh_type == elfcpp::SHT_RELA); 547 this->incremental_relocs_scan_reltype<elfcpp::SHT_RELA>(p); 548 } 549} 550 551// Scan the input relocation for --incremental, templatized on the 552// type of the relocation section. 553 554template<int size, bool big_endian> 555template<int sh_type> 556void 557Sized_relobj_file<size, big_endian>::incremental_relocs_scan_reltype( 558 const Read_relocs_data::Relocs_list::iterator& p) 559{ 560 typedef typename Reloc_types<sh_type, size, big_endian>::Reloc Reltype; 561 const int reloc_size = Reloc_types<sh_type, size, big_endian>::reloc_size; 562 const unsigned char* prelocs = p->contents->data(); 563 size_t reloc_count = p->reloc_count; 564 565 for (size_t i = 0; i < reloc_count; ++i, prelocs += reloc_size) 566 { 567 Reltype reloc(prelocs); 568 569 if (p->needs_special_offset_handling 570 && !p->output_section->is_input_address_mapped(this, p->data_shndx, 571 reloc.get_r_offset())) 572 continue; 573 574 // FIXME: Some targets have a non-standard r_info field. 575 typename elfcpp::Elf_types<size>::Elf_WXword r_info = reloc.get_r_info(); 576 const unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info); 577 578 if (r_sym >= this->local_symbol_count_) 579 this->count_incremental_reloc(r_sym - this->local_symbol_count_); 580 } 581} 582 583// Relocate the input sections and write out the local symbols. 584 585template<int size, bool big_endian> 586void 587Sized_relobj_file<size, big_endian>::do_relocate(const Symbol_table* symtab, 588 const Layout* layout, 589 Output_file* of) 590{ 591 unsigned int shnum = this->shnum(); 592 593 // Read the section headers. 594 const unsigned char* pshdrs = this->get_view(this->elf_file_.shoff(), 595 shnum * This::shdr_size, 596 true, true); 597 598 Views views; 599 views.resize(shnum); 600 601 // Make two passes over the sections. The first one copies the 602 // section data to the output file. The second one applies 603 // relocations. 604 605 this->write_sections(layout, pshdrs, of, &views); 606 607 // To speed up relocations, we set up hash tables for fast lookup of 608 // input offsets to output addresses. 609 this->initialize_input_to_output_maps(); 610 611 // Make the views available through get_output_view() for the duration 612 // of this routine. This RAII class will reset output_views_ to NULL 613 // when the views go out of scope. 614 struct Set_output_views 615 { 616 Set_output_views(const Views** ppviews, const Views* pviews) 617 { 618 ppviews_ = ppviews; 619 *ppviews = pviews; 620 } 621 622 ~Set_output_views() 623 { *ppviews_ = NULL; } 624 625 const Views** ppviews_; 626 }; 627 Set_output_views set_output_views(&this->output_views_, &views); 628 629 // Apply relocations. 630 631 this->relocate_sections(symtab, layout, pshdrs, of, &views); 632 633 // After we've done the relocations, we release the hash tables, 634 // since we no longer need them. 635 this->free_input_to_output_maps(); 636 637 // Write out the accumulated views. 638 for (unsigned int i = 1; i < shnum; ++i) 639 { 640 if (views[i].view != NULL) 641 { 642 if (views[i].is_ctors_reverse_view) 643 this->reverse_words(views[i].view, views[i].view_size); 644 if (!views[i].is_postprocessing_view) 645 { 646 if (views[i].is_input_output_view) 647 of->write_input_output_view(views[i].offset, 648 views[i].view_size, 649 views[i].view); 650 else 651 of->write_output_view(views[i].offset, views[i].view_size, 652 views[i].view); 653 } 654 } 655 } 656 657 // Write out the local symbols. 658 this->write_local_symbols(of, layout->sympool(), layout->dynpool(), 659 layout->symtab_xindex(), layout->dynsym_xindex(), 660 layout->symtab_section_offset()); 661} 662 663// Sort a Read_multiple vector by file offset. 664struct Read_multiple_compare 665{ 666 inline bool 667 operator()(const File_read::Read_multiple_entry& rme1, 668 const File_read::Read_multiple_entry& rme2) const 669 { return rme1.file_offset < rme2.file_offset; } 670}; 671 672// Write section data to the output file. PSHDRS points to the 673// section headers. Record the views in *PVIEWS for use when 674// relocating. 675 676template<int size, bool big_endian> 677void 678Sized_relobj_file<size, big_endian>::write_sections(const Layout* layout, 679 const unsigned char* pshdrs, 680 Output_file* of, 681 Views* pviews) 682{ 683 unsigned int shnum = this->shnum(); 684 const Output_sections& out_sections(this->output_sections()); 685 const std::vector<Address>& out_offsets(this->section_offsets()); 686 687 File_read::Read_multiple rm; 688 bool is_sorted = true; 689 690 const unsigned char* p = pshdrs + This::shdr_size; 691 for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size) 692 { 693 View_size* pvs = &(*pviews)[i]; 694 695 pvs->view = NULL; 696 697 const Output_section* os = out_sections[i]; 698 if (os == NULL) 699 continue; 700 Address output_offset = out_offsets[i]; 701 702 typename This::Shdr shdr(p); 703 704 if (shdr.get_sh_type() == elfcpp::SHT_NOBITS) 705 continue; 706 707 if ((parameters->options().relocatable() 708 || parameters->options().emit_relocs()) 709 && (shdr.get_sh_type() == elfcpp::SHT_REL 710 || shdr.get_sh_type() == elfcpp::SHT_RELA) 711 && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0) 712 { 713 // This is a reloc section in a relocatable link or when 714 // emitting relocs. We don't need to read the input file. 715 // The size and file offset are stored in the 716 // Relocatable_relocs structure. 717 Relocatable_relocs* rr = this->relocatable_relocs(i); 718 gold_assert(rr != NULL); 719 Output_data* posd = rr->output_data(); 720 gold_assert(posd != NULL); 721 722 pvs->offset = posd->offset(); 723 pvs->view_size = posd->data_size(); 724 pvs->view = of->get_output_view(pvs->offset, pvs->view_size); 725 pvs->address = posd->address(); 726 pvs->is_input_output_view = false; 727 pvs->is_postprocessing_view = false; 728 pvs->is_ctors_reverse_view = false; 729 730 continue; 731 } 732 733 // In the normal case, this input section is simply mapped to 734 // the output section at offset OUTPUT_OFFSET. 735 736 // However, if OUTPUT_OFFSET == INVALID_ADDRESS, then input data is 737 // handled specially--e.g., a .eh_frame section. The relocation 738 // routines need to check for each reloc where it should be 739 // applied. For this case, we need an input/output view for the 740 // entire contents of the section in the output file. We don't 741 // want to copy the contents of the input section to the output 742 // section; the output section contents were already written, 743 // and we waited for them in Relocate_task::is_runnable because 744 // relocs_must_follow_section_writes is set for the object. 745 746 // Regardless of which of the above cases is true, we have to 747 // check requires_postprocessing of the output section. If that 748 // is false, then we work with views of the output file 749 // directly. If it is true, then we work with a separate 750 // buffer, and the output section is responsible for writing the 751 // final data to the output file. 752 753 off_t output_section_offset; 754 Address output_section_size; 755 if (!os->requires_postprocessing()) 756 { 757 output_section_offset = os->offset(); 758 output_section_size = convert_types<Address, off_t>(os->data_size()); 759 } 760 else 761 { 762 output_section_offset = 0; 763 output_section_size = 764 convert_types<Address, off_t>(os->postprocessing_buffer_size()); 765 } 766 767 off_t view_start; 768 section_size_type view_size; 769 bool must_decompress = false; 770 if (output_offset != invalid_address) 771 { 772 view_start = output_section_offset + output_offset; 773 view_size = convert_to_section_size_type(shdr.get_sh_size()); 774 section_size_type uncompressed_size; 775 if (this->section_is_compressed(i, &uncompressed_size)) 776 { 777 view_size = uncompressed_size; 778 must_decompress = true; 779 } 780 } 781 else 782 { 783 view_start = output_section_offset; 784 view_size = convert_to_section_size_type(output_section_size); 785 } 786 787 if (view_size == 0) 788 continue; 789 790 gold_assert(output_offset == invalid_address 791 || output_offset + view_size <= output_section_size); 792 793 unsigned char* view; 794 if (os->requires_postprocessing()) 795 { 796 unsigned char* buffer = os->postprocessing_buffer(); 797 view = buffer + view_start; 798 if (output_offset != invalid_address && !must_decompress) 799 { 800 off_t sh_offset = shdr.get_sh_offset(); 801 if (!rm.empty() && rm.back().file_offset > sh_offset) 802 is_sorted = false; 803 rm.push_back(File_read::Read_multiple_entry(sh_offset, 804 view_size, view)); 805 } 806 } 807 else 808 { 809 if (output_offset == invalid_address) 810 view = of->get_input_output_view(view_start, view_size); 811 else 812 { 813 view = of->get_output_view(view_start, view_size); 814 if (!must_decompress) 815 { 816 off_t sh_offset = shdr.get_sh_offset(); 817 if (!rm.empty() && rm.back().file_offset > sh_offset) 818 is_sorted = false; 819 rm.push_back(File_read::Read_multiple_entry(sh_offset, 820 view_size, view)); 821 } 822 } 823 } 824 825 if (must_decompress) 826 { 827 // Read and decompress the section. 828 section_size_type len; 829 const unsigned char* p = this->section_contents(i, &len, false); 830 if (!decompress_input_section(p, len, view, view_size, 831 size, big_endian, 832 shdr.get_sh_flags())) 833 this->error(_("could not decompress section %s"), 834 this->section_name(i).c_str()); 835 } 836 837 pvs->view = view; 838 pvs->address = os->address(); 839 if (output_offset != invalid_address) 840 pvs->address += output_offset; 841 pvs->offset = view_start; 842 pvs->view_size = view_size; 843 pvs->is_input_output_view = output_offset == invalid_address; 844 pvs->is_postprocessing_view = os->requires_postprocessing(); 845 pvs->is_ctors_reverse_view = 846 (!parameters->options().relocatable() 847 && view_size > size / 8 848 && (strcmp(os->name(), ".init_array") == 0 849 || strcmp(os->name(), ".fini_array") == 0) 850 && layout->is_ctors_in_init_array(this, i)); 851 } 852 853 // Actually read the data. 854 if (!rm.empty()) 855 { 856 if (!is_sorted) 857 std::sort(rm.begin(), rm.end(), Read_multiple_compare()); 858 this->read_multiple(rm); 859 } 860} 861 862// Relocate section data. VIEWS points to the section data as views 863// in the output file. 864 865template<int size, bool big_endian> 866void 867Sized_relobj_file<size, big_endian>::do_relocate_sections( 868 const Symbol_table* symtab, 869 const Layout* layout, 870 const unsigned char* pshdrs, 871 Output_file* of, 872 Views* pviews) 873{ 874 this->relocate_section_range(symtab, layout, pshdrs, of, pviews, 875 1, this->shnum() - 1); 876} 877 878// Relocate section data for the range of sections START_SHNDX through 879// END_SHNDX. 880 881template<int size, bool big_endian> 882void 883Sized_relobj_file<size, big_endian>::relocate_section_range( 884 const Symbol_table* symtab, 885 const Layout* layout, 886 const unsigned char* pshdrs, 887 Output_file* of, 888 Views* pviews, 889 unsigned int start_shndx, 890 unsigned int end_shndx) 891{ 892 gold_assert(start_shndx >= 1); 893 gold_assert(end_shndx < this->shnum()); 894 895 if (end_shndx < start_shndx) 896 return; 897 898 Sized_target<size, big_endian>* target = 899 parameters->sized_target<size, big_endian>(); 900 901 const Output_sections& out_sections(this->output_sections()); 902 const std::vector<Address>& out_offsets(this->section_offsets()); 903 904 Relocate_info<size, big_endian> relinfo; 905 relinfo.symtab = symtab; 906 relinfo.layout = layout; 907 relinfo.object = this; 908 909 const unsigned char* p = pshdrs + start_shndx * This::shdr_size; 910 for (unsigned int i = start_shndx; i <= end_shndx; ++i, p += This::shdr_size) 911 { 912 typename This::Shdr shdr(p); 913 914 unsigned int sh_type = shdr.get_sh_type(); 915 if (sh_type != elfcpp::SHT_REL && sh_type != elfcpp::SHT_RELA) 916 continue; 917 918 off_t sh_size = shdr.get_sh_size(); 919 if (sh_size == 0) 920 continue; 921 922 unsigned int index = this->adjust_shndx(shdr.get_sh_info()); 923 if (index >= this->shnum()) 924 { 925 this->error(_("relocation section %u has bad info %u"), 926 i, index); 927 continue; 928 } 929 930 Output_section* os = out_sections[index]; 931 if (os == NULL) 932 { 933 // This relocation section is against a section which we 934 // discarded. 935 continue; 936 } 937 Address output_offset = out_offsets[index]; 938 939 gold_assert((*pviews)[index].view != NULL); 940 if (parameters->options().relocatable()) 941 gold_assert((*pviews)[i].view != NULL); 942 943 if (this->adjust_shndx(shdr.get_sh_link()) != this->symtab_shndx_) 944 { 945 gold_error(_("relocation section %u uses unexpected " 946 "symbol table %u"), 947 i, this->adjust_shndx(shdr.get_sh_link())); 948 continue; 949 } 950 951 const unsigned char* prelocs = this->get_view(shdr.get_sh_offset(), 952 sh_size, true, false); 953 954 unsigned int reloc_size; 955 if (sh_type == elfcpp::SHT_REL) 956 reloc_size = elfcpp::Elf_sizes<size>::rel_size; 957 else 958 reloc_size = elfcpp::Elf_sizes<size>::rela_size; 959 960 if (reloc_size != shdr.get_sh_entsize()) 961 { 962 gold_error(_("unexpected entsize for reloc section %u: %lu != %u"), 963 i, static_cast<unsigned long>(shdr.get_sh_entsize()), 964 reloc_size); 965 continue; 966 } 967 968 size_t reloc_count = sh_size / reloc_size; 969 if (static_cast<off_t>(reloc_count * reloc_size) != sh_size) 970 { 971 gold_error(_("reloc section %u size %lu uneven"), 972 i, static_cast<unsigned long>(sh_size)); 973 continue; 974 } 975 976 gold_assert(output_offset != invalid_address 977 || this->relocs_must_follow_section_writes()); 978 979 relinfo.reloc_shndx = i; 980 relinfo.reloc_shdr = p; 981 relinfo.data_shndx = index; 982 relinfo.data_shdr = pshdrs + index * This::shdr_size; 983 unsigned char* view = (*pviews)[index].view; 984 Address address = (*pviews)[index].address; 985 section_size_type view_size = (*pviews)[index].view_size; 986 987 Reloc_symbol_changes* reloc_map = NULL; 988 if (this->uses_split_stack() && output_offset != invalid_address) 989 { 990 typename This::Shdr data_shdr(pshdrs + index * This::shdr_size); 991 if ((data_shdr.get_sh_flags() & elfcpp::SHF_EXECINSTR) != 0) 992 this->split_stack_adjust(symtab, pshdrs, sh_type, index, 993 prelocs, reloc_count, view, view_size, 994 &reloc_map, target); 995 } 996 997 Relocatable_relocs* rr = NULL; 998 if (parameters->options().emit_relocs() 999 || parameters->options().relocatable()) 1000 rr = this->relocatable_relocs(i); 1001 relinfo.rr = rr; 1002 1003 if (!parameters->options().relocatable()) 1004 { 1005 target->relocate_section(&relinfo, sh_type, prelocs, reloc_count, os, 1006 output_offset == invalid_address, 1007 view, address, view_size, reloc_map); 1008 if (parameters->options().emit_relocs()) 1009 target->relocate_relocs(&relinfo, sh_type, prelocs, reloc_count, 1010 os, output_offset, 1011 view, address, view_size, 1012 (*pviews)[i].view, 1013 (*pviews)[i].view_size); 1014 if (parameters->incremental()) 1015 this->incremental_relocs_write(&relinfo, sh_type, prelocs, 1016 reloc_count, os, output_offset, of); 1017 } 1018 else 1019 target->relocate_relocs(&relinfo, sh_type, prelocs, reloc_count, 1020 os, output_offset, 1021 view, address, view_size, 1022 (*pviews)[i].view, 1023 (*pviews)[i].view_size); 1024 } 1025} 1026 1027// Return the output view for section SHNDX. 1028 1029template<int size, bool big_endian> 1030unsigned char* 1031Sized_relobj_file<size, big_endian>::do_get_output_view( 1032 unsigned int shndx, 1033 section_size_type* plen) const 1034{ 1035 gold_assert(this->output_views_ != NULL); 1036 gold_assert(shndx < this->output_views_->size()); 1037 const View_size& v = (*this->output_views_)[shndx]; 1038 *plen = v.view_size; 1039 return v.view; 1040} 1041 1042// Write the incremental relocs. 1043 1044template<int size, bool big_endian> 1045void 1046Sized_relobj_file<size, big_endian>::incremental_relocs_write( 1047 const Relocate_info<size, big_endian>* relinfo, 1048 unsigned int sh_type, 1049 const unsigned char* prelocs, 1050 size_t reloc_count, 1051 Output_section* output_section, 1052 Address output_offset, 1053 Output_file* of) 1054{ 1055 if (sh_type == elfcpp::SHT_REL) 1056 this->incremental_relocs_write_reltype<elfcpp::SHT_REL>( 1057 relinfo, 1058 prelocs, 1059 reloc_count, 1060 output_section, 1061 output_offset, 1062 of); 1063 else 1064 { 1065 gold_assert(sh_type == elfcpp::SHT_RELA); 1066 this->incremental_relocs_write_reltype<elfcpp::SHT_RELA>( 1067 relinfo, 1068 prelocs, 1069 reloc_count, 1070 output_section, 1071 output_offset, 1072 of); 1073 } 1074} 1075 1076// Write the incremental relocs, templatized on the type of the 1077// relocation section. 1078 1079template<int size, bool big_endian> 1080template<int sh_type> 1081void 1082Sized_relobj_file<size, big_endian>::incremental_relocs_write_reltype( 1083 const Relocate_info<size, big_endian>* relinfo, 1084 const unsigned char* prelocs, 1085 size_t reloc_count, 1086 Output_section* output_section, 1087 Address output_offset, 1088 Output_file* of) 1089{ 1090 typedef typename Reloc_types<sh_type, size, big_endian>::Reloc Reloc; 1091 const unsigned int reloc_size = 1092 Reloc_types<sh_type, size, big_endian>::reloc_size; 1093 const unsigned int sizeof_addr = size / 8; 1094 const unsigned int incr_reloc_size = 1095 Incremental_relocs_reader<size, big_endian>::reloc_size; 1096 1097 unsigned int out_shndx = output_section->out_shndx(); 1098 1099 // Get a view for the .gnu_incremental_relocs section. 1100 1101 Incremental_inputs* inputs = relinfo->layout->incremental_inputs(); 1102 gold_assert(inputs != NULL); 1103 const off_t relocs_off = inputs->relocs_section()->offset(); 1104 const off_t relocs_size = inputs->relocs_section()->data_size(); 1105 unsigned char* const view = of->get_output_view(relocs_off, relocs_size); 1106 1107 for (size_t i = 0; i < reloc_count; ++i, prelocs += reloc_size) 1108 { 1109 Reloc reloc(prelocs); 1110 1111 // FIXME: Some targets have a non-standard r_info field. 1112 typename elfcpp::Elf_types<size>::Elf_WXword r_info = reloc.get_r_info(); 1113 const unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info); 1114 const unsigned int r_type = elfcpp::elf_r_type<size>(r_info); 1115 1116 if (r_sym < this->local_symbol_count_) 1117 continue; 1118 1119 // Get the new offset--the location in the output section where 1120 // this relocation should be applied. 1121 1122 Address offset = reloc.get_r_offset(); 1123 if (output_offset != invalid_address) 1124 offset += output_offset; 1125 else 1126 { 1127 section_offset_type sot_offset = 1128 convert_types<section_offset_type, Address>(offset); 1129 section_offset_type new_sot_offset = 1130 output_section->output_offset(relinfo->object, 1131 relinfo->data_shndx, 1132 sot_offset); 1133 gold_assert(new_sot_offset != -1); 1134 offset += new_sot_offset; 1135 } 1136 1137 // Get the addend. 1138 typename elfcpp::Elf_types<size>::Elf_Swxword addend; 1139 if (sh_type == elfcpp::SHT_RELA) 1140 addend = 1141 Reloc_types<sh_type, size, big_endian>::get_reloc_addend(&reloc); 1142 else 1143 { 1144 // FIXME: Get the addend for SHT_REL. 1145 addend = 0; 1146 } 1147 1148 // Get the index of the output relocation. 1149 1150 unsigned int reloc_index = 1151 this->next_incremental_reloc_index(r_sym - this->local_symbol_count_); 1152 1153 // Write the relocation. 1154 1155 unsigned char* pov = view + reloc_index * incr_reloc_size; 1156 elfcpp::Swap<32, big_endian>::writeval(pov, r_type); 1157 elfcpp::Swap<32, big_endian>::writeval(pov + 4, out_shndx); 1158 elfcpp::Swap<size, big_endian>::writeval(pov + 8, offset); 1159 elfcpp::Swap<size, big_endian>::writeval(pov + 8 + sizeof_addr, addend); 1160 of->write_output_view(pov - view, incr_reloc_size, view); 1161 } 1162} 1163 1164// Create merge hash tables for the local symbols. These are used to 1165// speed up relocations. 1166 1167template<int size, bool big_endian> 1168void 1169Sized_relobj_file<size, big_endian>::initialize_input_to_output_maps() 1170{ 1171 const unsigned int loccount = this->local_symbol_count_; 1172 for (unsigned int i = 1; i < loccount; ++i) 1173 { 1174 Symbol_value<size>& lv(this->local_values_[i]); 1175 lv.initialize_input_to_output_map(this); 1176 } 1177} 1178 1179// Free merge hash tables for the local symbols. 1180 1181template<int size, bool big_endian> 1182void 1183Sized_relobj_file<size, big_endian>::free_input_to_output_maps() 1184{ 1185 const unsigned int loccount = this->local_symbol_count_; 1186 for (unsigned int i = 1; i < loccount; ++i) 1187 { 1188 Symbol_value<size>& lv(this->local_values_[i]); 1189 lv.free_input_to_output_map(); 1190 } 1191} 1192 1193// If an object was compiled with -fsplit-stack, this is called to 1194// check whether any relocations refer to functions defined in objects 1195// which were not compiled with -fsplit-stack. If they were, then we 1196// need to apply some target-specific adjustments to request 1197// additional stack space. 1198 1199template<int size, bool big_endian> 1200void 1201Sized_relobj_file<size, big_endian>::split_stack_adjust( 1202 const Symbol_table* symtab, 1203 const unsigned char* pshdrs, 1204 unsigned int sh_type, 1205 unsigned int shndx, 1206 const unsigned char* prelocs, 1207 size_t reloc_count, 1208 unsigned char* view, 1209 section_size_type view_size, 1210 Reloc_symbol_changes** reloc_map, 1211 const Sized_target<size, big_endian>* target) 1212{ 1213 if (sh_type == elfcpp::SHT_REL) 1214 this->split_stack_adjust_reltype<elfcpp::SHT_REL>(symtab, pshdrs, shndx, 1215 prelocs, reloc_count, 1216 view, view_size, 1217 reloc_map, target); 1218 else 1219 { 1220 gold_assert(sh_type == elfcpp::SHT_RELA); 1221 this->split_stack_adjust_reltype<elfcpp::SHT_RELA>(symtab, pshdrs, shndx, 1222 prelocs, reloc_count, 1223 view, view_size, 1224 reloc_map, target); 1225 } 1226} 1227 1228// Adjust for -fsplit-stack, templatized on the type of the relocation 1229// section. 1230 1231template<int size, bool big_endian> 1232template<int sh_type> 1233void 1234Sized_relobj_file<size, big_endian>::split_stack_adjust_reltype( 1235 const Symbol_table* symtab, 1236 const unsigned char* pshdrs, 1237 unsigned int shndx, 1238 const unsigned char* prelocs, 1239 size_t reloc_count, 1240 unsigned char* view, 1241 section_size_type view_size, 1242 Reloc_symbol_changes** reloc_map, 1243 const Sized_target<size, big_endian>* target) 1244{ 1245 typedef typename Reloc_types<sh_type, size, big_endian>::Reloc Reltype; 1246 const int reloc_size = Reloc_types<sh_type, size, big_endian>::reloc_size; 1247 1248 size_t local_count = this->local_symbol_count(); 1249 1250 std::vector<section_offset_type> non_split_refs; 1251 1252 const unsigned char* pr = prelocs; 1253 for (size_t i = 0; i < reloc_count; ++i, pr += reloc_size) 1254 { 1255 // Some supported targets have a non-standard r_info field. 1256 // If this call is too slow, we can move this routine to 1257 // target-reloc.h and templatize it on Classify_reloc. 1258 unsigned int r_sym = target->get_r_sym(pr); 1259 if (r_sym < local_count) 1260 continue; 1261 1262 const Symbol* gsym = this->global_symbol(r_sym); 1263 gold_assert(gsym != NULL); 1264 if (gsym->is_forwarder()) 1265 gsym = symtab->resolve_forwards(gsym); 1266 1267 // See if this relocation refers to a function defined in an 1268 // object compiled without -fsplit-stack. Note that we don't 1269 // care about the type of relocation--this means that in some 1270 // cases we will ask for a large stack unnecessarily, but this 1271 // is not fatal. FIXME: Some targets have symbols which are 1272 // functions but are not type STT_FUNC, e.g., STT_ARM_TFUNC. 1273 if (!gsym->is_undefined() 1274 && gsym->source() == Symbol::FROM_OBJECT 1275 && !gsym->object()->uses_split_stack()) 1276 { 1277 if (parameters->target().is_call_to_non_split(gsym, pr, view, 1278 view_size)) 1279 { 1280 Reltype reloc(pr); 1281 section_offset_type offset = 1282 convert_to_section_size_type(reloc.get_r_offset()); 1283 non_split_refs.push_back(offset); 1284 } 1285 } 1286 } 1287 1288 if (non_split_refs.empty()) 1289 return; 1290 1291 // At this point, every entry in NON_SPLIT_REFS indicates a 1292 // relocation which refers to a function in an object compiled 1293 // without -fsplit-stack. We now have to convert that list into a 1294 // set of offsets to functions. First, we find all the functions. 1295 1296 Function_offsets function_offsets; 1297 this->find_functions(pshdrs, shndx, &function_offsets); 1298 if (function_offsets.empty()) 1299 return; 1300 1301 // Now get a list of the function with references to non split-stack 1302 // code. 1303 1304 Function_offsets calls_non_split; 1305 for (std::vector<section_offset_type>::const_iterator p 1306 = non_split_refs.begin(); 1307 p != non_split_refs.end(); 1308 ++p) 1309 { 1310 Function_offsets::const_iterator low = function_offsets.lower_bound(*p); 1311 if (low == function_offsets.end()) 1312 --low; 1313 else if (low->first == *p) 1314 ; 1315 else if (low == function_offsets.begin()) 1316 continue; 1317 else 1318 --low; 1319 1320 calls_non_split.insert(*low); 1321 } 1322 if (calls_non_split.empty()) 1323 return; 1324 1325 // Now we have a set of functions to adjust. The adjustments are 1326 // target specific. Besides changing the output section view 1327 // however, it likes, the target may request a relocation change 1328 // from one global symbol name to another. 1329 1330 for (Function_offsets::const_iterator p = calls_non_split.begin(); 1331 p != calls_non_split.end(); 1332 ++p) 1333 { 1334 std::string from; 1335 std::string to; 1336 parameters->target().calls_non_split(this, shndx, p->first, p->second, 1337 prelocs, reloc_count, 1338 view, view_size, &from, &to); 1339 if (!from.empty()) 1340 { 1341 gold_assert(!to.empty()); 1342 Symbol* tosym = NULL; 1343 1344 // Find relocations in the relevant function which are for 1345 // FROM. 1346 pr = prelocs; 1347 for (size_t i = 0; i < reloc_count; ++i, pr += reloc_size) 1348 { 1349 Reltype reloc(pr); 1350 1351 unsigned int r_sym = target->get_r_sym(pr); 1352 if (r_sym < local_count) 1353 continue; 1354 1355 section_offset_type offset = 1356 convert_to_section_size_type(reloc.get_r_offset()); 1357 if (offset < p->first 1358 || (offset 1359 >= (p->first 1360 + static_cast<section_offset_type>(p->second)))) 1361 continue; 1362 1363 const Symbol* gsym = this->global_symbol(r_sym); 1364 if (from == gsym->name()) 1365 { 1366 if (tosym == NULL) 1367 { 1368 tosym = symtab->lookup(to.c_str()); 1369 if (tosym == NULL) 1370 { 1371 this->error(_("could not convert call " 1372 "to '%s' to '%s'"), 1373 from.c_str(), to.c_str()); 1374 break; 1375 } 1376 } 1377 1378 if (*reloc_map == NULL) 1379 *reloc_map = new Reloc_symbol_changes(reloc_count); 1380 (*reloc_map)->set(i, tosym); 1381 } 1382 } 1383 } 1384 } 1385} 1386 1387// Find all the function in this object defined in section SHNDX. 1388// Store their offsets in the section in FUNCTION_OFFSETS. 1389 1390template<int size, bool big_endian> 1391void 1392Sized_relobj_file<size, big_endian>::find_functions( 1393 const unsigned char* pshdrs, 1394 unsigned int shndx, 1395 Sized_relobj_file<size, big_endian>::Function_offsets* function_offsets) 1396{ 1397 // We need to read the symbols to find the functions. If we wanted 1398 // to, we could cache reading the symbols across all sections in the 1399 // object. 1400 const unsigned int symtab_shndx = this->symtab_shndx_; 1401 typename This::Shdr symtabshdr(pshdrs + symtab_shndx * This::shdr_size); 1402 gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB); 1403 1404 typename elfcpp::Elf_types<size>::Elf_WXword sh_size = 1405 symtabshdr.get_sh_size(); 1406 const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(), 1407 sh_size, true, true); 1408 1409 const int sym_size = This::sym_size; 1410 const unsigned int symcount = sh_size / sym_size; 1411 for (unsigned int i = 0; i < symcount; ++i, psyms += sym_size) 1412 { 1413 typename elfcpp::Sym<size, big_endian> isym(psyms); 1414 1415 // FIXME: Some targets can have functions which do not have type 1416 // STT_FUNC, e.g., STT_ARM_TFUNC. 1417 if (isym.get_st_type() != elfcpp::STT_FUNC 1418 || isym.get_st_size() == 0) 1419 continue; 1420 1421 bool is_ordinary; 1422 Symbol_location loc; 1423 loc.shndx = this->adjust_sym_shndx(i, isym.get_st_shndx(), 1424 &is_ordinary); 1425 if (!is_ordinary) 1426 continue; 1427 1428 loc.object = this; 1429 loc.offset = isym.get_st_value(); 1430 parameters->target().function_location(&loc); 1431 1432 if (loc.shndx != shndx) 1433 continue; 1434 1435 section_offset_type value = 1436 convert_to_section_size_type(loc.offset); 1437 section_size_type fnsize = 1438 convert_to_section_size_type(isym.get_st_size()); 1439 1440 (*function_offsets)[value] = fnsize; 1441 } 1442} 1443 1444// Reverse the words in a section. Used for .ctors sections mapped to 1445// .init_array sections. See ctors_sections_in_init_array in 1446// layout.cc. 1447 1448template<int size, bool big_endian> 1449void 1450Sized_relobj_file<size, big_endian>::reverse_words(unsigned char* view, 1451 section_size_type view_size) 1452{ 1453 typedef typename elfcpp::Swap<size, big_endian>::Valtype Valtype; 1454 Valtype* vview = reinterpret_cast<Valtype*>(view); 1455 section_size_type vview_size = view_size / (size / 8); 1456 for (section_size_type i = 0; i < vview_size / 2; ++i) 1457 { 1458 Valtype tmp = vview[i]; 1459 vview[i] = vview[vview_size - 1 - i]; 1460 vview[vview_size - 1 - i] = tmp; 1461 } 1462} 1463 1464// Class Merged_symbol_value. 1465 1466template<int size> 1467void 1468Merged_symbol_value<size>::initialize_input_to_output_map( 1469 const Relobj* object, 1470 unsigned int input_shndx) 1471{ 1472 object->initialize_input_to_output_map<size>(input_shndx, 1473 this->output_start_address_, 1474 &this->output_addresses_); 1475} 1476 1477// Get the output value corresponding to an input offset if we 1478// couldn't find it in the hash table. 1479 1480template<int size> 1481typename elfcpp::Elf_types<size>::Elf_Addr 1482Merged_symbol_value<size>::value_from_output_section( 1483 const Relobj* object, 1484 unsigned int input_shndx, 1485 typename elfcpp::Elf_types<size>::Elf_Addr input_offset) const 1486{ 1487 section_offset_type output_offset; 1488 bool found = object->merge_output_offset(input_shndx, input_offset, 1489 &output_offset); 1490 1491 // If this assertion fails, it means that some relocation was 1492 // against a portion of an input merge section which we didn't map 1493 // to the output file and we didn't explicitly discard. We should 1494 // always map all portions of input merge sections. 1495 gold_assert(found); 1496 1497 if (output_offset == -1) 1498 return 0; 1499 else 1500 return this->output_start_address_ + output_offset; 1501} 1502 1503// Track_relocs methods. 1504 1505// Initialize the class to track the relocs. This gets the object, 1506// the reloc section index, and the type of the relocs. This returns 1507// false if something goes wrong. 1508 1509template<int size, bool big_endian> 1510bool 1511Track_relocs<size, big_endian>::initialize( 1512 Object* object, 1513 unsigned int reloc_shndx, 1514 unsigned int reloc_type) 1515{ 1516 // If RELOC_SHNDX is -1U, it means there is more than one reloc 1517 // section for the .eh_frame section. We can't handle that case. 1518 if (reloc_shndx == -1U) 1519 return false; 1520 1521 // If RELOC_SHNDX is 0, there is no reloc section. 1522 if (reloc_shndx == 0) 1523 return true; 1524 1525 // Get the contents of the reloc section. 1526 this->prelocs_ = object->section_contents(reloc_shndx, &this->len_, false); 1527 1528 if (reloc_type == elfcpp::SHT_REL) 1529 this->reloc_size_ = elfcpp::Elf_sizes<size>::rel_size; 1530 else if (reloc_type == elfcpp::SHT_RELA) 1531 this->reloc_size_ = elfcpp::Elf_sizes<size>::rela_size; 1532 else 1533 gold_unreachable(); 1534 1535 if (this->len_ % this->reloc_size_ != 0) 1536 { 1537 object->error(_("reloc section size %zu is not a multiple of " 1538 "reloc size %d\n"), 1539 static_cast<size_t>(this->len_), 1540 this->reloc_size_); 1541 return false; 1542 } 1543 1544 return true; 1545} 1546 1547// Return the offset of the next reloc, or -1 if there isn't one. 1548 1549template<int size, bool big_endian> 1550off_t 1551Track_relocs<size, big_endian>::next_offset() const 1552{ 1553 if (this->pos_ >= this->len_) 1554 return -1; 1555 1556 // Rel and Rela start out the same, so we can always use Rel to find 1557 // the r_offset value. 1558 elfcpp::Rel<size, big_endian> rel(this->prelocs_ + this->pos_); 1559 return rel.get_r_offset(); 1560} 1561 1562// Return the index of the symbol referenced by the next reloc, or -1U 1563// if there aren't any more relocs. 1564 1565template<int size, bool big_endian> 1566unsigned int 1567Track_relocs<size, big_endian>::next_symndx() const 1568{ 1569 if (this->pos_ >= this->len_) 1570 return -1U; 1571 Sized_target<size, big_endian>* target 1572 = parameters->sized_target<size, big_endian>(); 1573 return target->get_r_sym(this->prelocs_ + this->pos_); 1574} 1575 1576// Return the addend of the next reloc, or 0 if there isn't one. 1577 1578template<int size, bool big_endian> 1579uint64_t 1580Track_relocs<size, big_endian>::next_addend() const 1581{ 1582 if (this->pos_ >= this->len_) 1583 return 0; 1584 if (this->reloc_size_ == elfcpp::Elf_sizes<size>::rel_size) 1585 return 0; 1586 elfcpp::Rela<size, big_endian> rela(this->prelocs_ + this->pos_); 1587 return rela.get_r_addend(); 1588} 1589 1590// Advance to the next reloc whose r_offset is greater than or equal 1591// to OFFSET. Return the number of relocs we skip. 1592 1593template<int size, bool big_endian> 1594int 1595Track_relocs<size, big_endian>::advance(off_t offset) 1596{ 1597 int ret = 0; 1598 while (this->pos_ < this->len_) 1599 { 1600 // Rel and Rela start out the same, so we can always use Rel to 1601 // find the r_offset value. 1602 elfcpp::Rel<size, big_endian> rel(this->prelocs_ + this->pos_); 1603 if (static_cast<off_t>(rel.get_r_offset()) >= offset) 1604 break; 1605 ++ret; 1606 this->pos_ += this->reloc_size_; 1607 } 1608 return ret; 1609} 1610 1611// Instantiate the templates we need. 1612 1613#ifdef HAVE_TARGET_32_LITTLE 1614template 1615void 1616Sized_relobj_file<32, false>::do_read_relocs(Read_relocs_data* rd); 1617#endif 1618 1619#ifdef HAVE_TARGET_32_BIG 1620template 1621void 1622Sized_relobj_file<32, true>::do_read_relocs(Read_relocs_data* rd); 1623#endif 1624 1625#ifdef HAVE_TARGET_64_LITTLE 1626template 1627void 1628Sized_relobj_file<64, false>::do_read_relocs(Read_relocs_data* rd); 1629#endif 1630 1631#ifdef HAVE_TARGET_64_BIG 1632template 1633void 1634Sized_relobj_file<64, true>::do_read_relocs(Read_relocs_data* rd); 1635#endif 1636 1637#ifdef HAVE_TARGET_32_LITTLE 1638template 1639void 1640Sized_relobj_file<32, false>::do_gc_process_relocs(Symbol_table* symtab, 1641 Layout* layout, 1642 Read_relocs_data* rd); 1643#endif 1644 1645#ifdef HAVE_TARGET_32_BIG 1646template 1647void 1648Sized_relobj_file<32, true>::do_gc_process_relocs(Symbol_table* symtab, 1649 Layout* layout, 1650 Read_relocs_data* rd); 1651#endif 1652 1653#ifdef HAVE_TARGET_64_LITTLE 1654template 1655void 1656Sized_relobj_file<64, false>::do_gc_process_relocs(Symbol_table* symtab, 1657 Layout* layout, 1658 Read_relocs_data* rd); 1659#endif 1660 1661#ifdef HAVE_TARGET_64_BIG 1662template 1663void 1664Sized_relobj_file<64, true>::do_gc_process_relocs(Symbol_table* symtab, 1665 Layout* layout, 1666 Read_relocs_data* rd); 1667#endif 1668 1669#ifdef HAVE_TARGET_32_LITTLE 1670template 1671void 1672Sized_relobj_file<32, false>::do_scan_relocs(Symbol_table* symtab, 1673 Layout* layout, 1674 Read_relocs_data* rd); 1675#endif 1676 1677#ifdef HAVE_TARGET_32_BIG 1678template 1679void 1680Sized_relobj_file<32, true>::do_scan_relocs(Symbol_table* symtab, 1681 Layout* layout, 1682 Read_relocs_data* rd); 1683#endif 1684 1685#ifdef HAVE_TARGET_64_LITTLE 1686template 1687void 1688Sized_relobj_file<64, false>::do_scan_relocs(Symbol_table* symtab, 1689 Layout* layout, 1690 Read_relocs_data* rd); 1691#endif 1692 1693#ifdef HAVE_TARGET_64_BIG 1694template 1695void 1696Sized_relobj_file<64, true>::do_scan_relocs(Symbol_table* symtab, 1697 Layout* layout, 1698 Read_relocs_data* rd); 1699#endif 1700 1701#ifdef HAVE_TARGET_32_LITTLE 1702template 1703void 1704Sized_relobj_file<32, false>::do_relocate(const Symbol_table* symtab, 1705 const Layout* layout, 1706 Output_file* of); 1707#endif 1708 1709#ifdef HAVE_TARGET_32_BIG 1710template 1711void 1712Sized_relobj_file<32, true>::do_relocate(const Symbol_table* symtab, 1713 const Layout* layout, 1714 Output_file* of); 1715#endif 1716 1717#ifdef HAVE_TARGET_64_LITTLE 1718template 1719void 1720Sized_relobj_file<64, false>::do_relocate(const Symbol_table* symtab, 1721 const Layout* layout, 1722 Output_file* of); 1723#endif 1724 1725#ifdef HAVE_TARGET_64_BIG 1726template 1727void 1728Sized_relobj_file<64, true>::do_relocate(const Symbol_table* symtab, 1729 const Layout* layout, 1730 Output_file* of); 1731#endif 1732 1733#ifdef HAVE_TARGET_32_LITTLE 1734template 1735void 1736Sized_relobj_file<32, false>::do_relocate_sections( 1737 const Symbol_table* symtab, 1738 const Layout* layout, 1739 const unsigned char* pshdrs, 1740 Output_file* of, 1741 Views* pviews); 1742 1743template 1744void 1745Sized_relobj_file<32, false>::relocate_section_range( 1746 const Symbol_table* symtab, 1747 const Layout* layout, 1748 const unsigned char* pshdrs, 1749 Output_file* of, 1750 Views* pviews, 1751 unsigned int start_shndx, 1752 unsigned int end_shndx); 1753 1754template 1755unsigned char* 1756Sized_relobj_file<32, false>::do_get_output_view( 1757 unsigned int shndx, 1758 section_size_type* plen) const; 1759#endif 1760 1761#ifdef HAVE_TARGET_32_BIG 1762template 1763void 1764Sized_relobj_file<32, true>::do_relocate_sections( 1765 const Symbol_table* symtab, 1766 const Layout* layout, 1767 const unsigned char* pshdrs, 1768 Output_file* of, 1769 Views* pviews); 1770 1771template 1772void 1773Sized_relobj_file<32, true>::relocate_section_range( 1774 const Symbol_table* symtab, 1775 const Layout* layout, 1776 const unsigned char* pshdrs, 1777 Output_file* of, 1778 Views* pviews, 1779 unsigned int start_shndx, 1780 unsigned int end_shndx); 1781 1782template 1783unsigned char* 1784Sized_relobj_file<32, true>::do_get_output_view( 1785 unsigned int shndx, 1786 section_size_type* plen) const; 1787#endif 1788 1789#ifdef HAVE_TARGET_64_LITTLE 1790template 1791void 1792Sized_relobj_file<64, false>::do_relocate_sections( 1793 const Symbol_table* symtab, 1794 const Layout* layout, 1795 const unsigned char* pshdrs, 1796 Output_file* of, 1797 Views* pviews); 1798 1799template 1800void 1801Sized_relobj_file<64, false>::relocate_section_range( 1802 const Symbol_table* symtab, 1803 const Layout* layout, 1804 const unsigned char* pshdrs, 1805 Output_file* of, 1806 Views* pviews, 1807 unsigned int start_shndx, 1808 unsigned int end_shndx); 1809 1810template 1811unsigned char* 1812Sized_relobj_file<64, false>::do_get_output_view( 1813 unsigned int shndx, 1814 section_size_type* plen) const; 1815#endif 1816 1817#ifdef HAVE_TARGET_64_BIG 1818template 1819void 1820Sized_relobj_file<64, true>::do_relocate_sections( 1821 const Symbol_table* symtab, 1822 const Layout* layout, 1823 const unsigned char* pshdrs, 1824 Output_file* of, 1825 Views* pviews); 1826 1827template 1828void 1829Sized_relobj_file<64, true>::relocate_section_range( 1830 const Symbol_table* symtab, 1831 const Layout* layout, 1832 const unsigned char* pshdrs, 1833 Output_file* of, 1834 Views* pviews, 1835 unsigned int start_shndx, 1836 unsigned int end_shndx); 1837 1838template 1839unsigned char* 1840Sized_relobj_file<64, true>::do_get_output_view( 1841 unsigned int shndx, 1842 section_size_type* plen) const; 1843#endif 1844 1845#ifdef HAVE_TARGET_32_LITTLE 1846template 1847void 1848Sized_relobj_file<32, false>::initialize_input_to_output_maps(); 1849 1850template 1851void 1852Sized_relobj_file<32, false>::free_input_to_output_maps(); 1853#endif 1854 1855#ifdef HAVE_TARGET_32_BIG 1856template 1857void 1858Sized_relobj_file<32, true>::initialize_input_to_output_maps(); 1859 1860template 1861void 1862Sized_relobj_file<32, true>::free_input_to_output_maps(); 1863#endif 1864 1865#ifdef HAVE_TARGET_64_LITTLE 1866template 1867void 1868Sized_relobj_file<64, false>::initialize_input_to_output_maps(); 1869 1870template 1871void 1872Sized_relobj_file<64, false>::free_input_to_output_maps(); 1873#endif 1874 1875#ifdef HAVE_TARGET_64_BIG 1876template 1877void 1878Sized_relobj_file<64, true>::initialize_input_to_output_maps(); 1879 1880template 1881void 1882Sized_relobj_file<64, true>::free_input_to_output_maps(); 1883#endif 1884 1885#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) 1886template 1887class Merged_symbol_value<32>; 1888#endif 1889 1890#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) 1891template 1892class Merged_symbol_value<64>; 1893#endif 1894 1895#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) 1896template 1897class Symbol_value<32>; 1898#endif 1899 1900#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) 1901template 1902class Symbol_value<64>; 1903#endif 1904 1905#ifdef HAVE_TARGET_32_LITTLE 1906template 1907class Track_relocs<32, false>; 1908#endif 1909 1910#ifdef HAVE_TARGET_32_BIG 1911template 1912class Track_relocs<32, true>; 1913#endif 1914 1915#ifdef HAVE_TARGET_64_LITTLE 1916template 1917class Track_relocs<64, false>; 1918#endif 1919 1920#ifdef HAVE_TARGET_64_BIG 1921template 1922class Track_relocs<64, true>; 1923#endif 1924 1925} // End namespace gold. 1926