1 // output.cc -- manage the output file for gold 2 3 // Copyright (C) 2006-2016 Free Software Foundation, Inc. 4 // Written by Ian Lance Taylor <iant (at) 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 <cstdlib> 26 #include <cstring> 27 #include <cerrno> 28 #include <fcntl.h> 29 #include <unistd.h> 30 #include <sys/stat.h> 31 #include <algorithm> 32 33 #ifdef HAVE_SYS_MMAN_H 34 #include <sys/mman.h> 35 #endif 36 37 #include "libiberty.h" 38 39 #include "dwarf.h" 40 #include "parameters.h" 41 #include "object.h" 42 #include "symtab.h" 43 #include "reloc.h" 44 #include "merge.h" 45 #include "descriptors.h" 46 #include "layout.h" 47 #include "output.h" 48 49 // For systems without mmap support. 50 #ifndef HAVE_MMAP 51 # define mmap gold_mmap 52 # define munmap gold_munmap 53 # define mremap gold_mremap 54 # ifndef MAP_FAILED 55 # define MAP_FAILED (reinterpret_cast<void*>(-1)) 56 # endif 57 # ifndef PROT_READ 58 # define PROT_READ 0 59 # endif 60 # ifndef PROT_WRITE 61 # define PROT_WRITE 0 62 # endif 63 # ifndef MAP_PRIVATE 64 # define MAP_PRIVATE 0 65 # endif 66 # ifndef MAP_ANONYMOUS 67 # define MAP_ANONYMOUS 0 68 # endif 69 # ifndef MAP_SHARED 70 # define MAP_SHARED 0 71 # endif 72 73 # ifndef ENOSYS 74 # define ENOSYS EINVAL 75 # endif 76 77 static void * 78 gold_mmap(void *, size_t, int, int, int, off_t) 79 { 80 errno = ENOSYS; 81 return MAP_FAILED; 82 } 83 84 static int 85 gold_munmap(void *, size_t) 86 { 87 errno = ENOSYS; 88 return -1; 89 } 90 91 static void * 92 gold_mremap(void *, size_t, size_t, int) 93 { 94 errno = ENOSYS; 95 return MAP_FAILED; 96 } 97 98 #endif 99 100 #if defined(HAVE_MMAP) && !defined(HAVE_MREMAP) 101 # define mremap gold_mremap 102 extern "C" void *gold_mremap(void *, size_t, size_t, int); 103 #endif 104 105 // Some BSD systems still use MAP_ANON instead of MAP_ANONYMOUS 106 #ifndef MAP_ANONYMOUS 107 # define MAP_ANONYMOUS MAP_ANON 108 #endif 109 110 #ifndef MREMAP_MAYMOVE 111 # define MREMAP_MAYMOVE 1 112 #endif 113 114 // Mingw does not have S_ISLNK. 115 #ifndef S_ISLNK 116 # define S_ISLNK(mode) 0 117 #endif 118 119 namespace gold 120 { 121 122 // A wrapper around posix_fallocate. If we don't have posix_fallocate, 123 // or the --no-posix-fallocate option is set, we try the fallocate 124 // system call directly. If that fails, we use ftruncate to set 125 // the file size and hope that there is enough disk space. 126 127 static int 128 gold_fallocate(int o, off_t offset, off_t len) 129 { 130 #ifdef HAVE_POSIX_FALLOCATE 131 if (parameters->options().posix_fallocate()) 132 return ::posix_fallocate(o, offset, len); 133 #endif // defined(HAVE_POSIX_FALLOCATE) 134 #ifdef HAVE_FALLOCATE 135 if (::fallocate(o, 0, offset, len) == 0) 136 return 0; 137 #endif // defined(HAVE_FALLOCATE) 138 if (::ftruncate(o, offset + len) < 0) 139 return errno; 140 return 0; 141 } 142 143 // Output_data variables. 144 145 bool Output_data::allocated_sizes_are_fixed; 146 147 // Output_data methods. 148 149 Output_data::~Output_data() 150 { 151 } 152 153 // Return the default alignment for the target size. 154 155 uint64_t 156 Output_data::default_alignment() 157 { 158 return Output_data::default_alignment_for_size( 159 parameters->target().get_size()); 160 } 161 162 // Return the default alignment for a size--32 or 64. 163 164 uint64_t 165 Output_data::default_alignment_for_size(int size) 166 { 167 if (size == 32) 168 return 4; 169 else if (size == 64) 170 return 8; 171 else 172 gold_unreachable(); 173 } 174 175 // Output_section_header methods. This currently assumes that the 176 // segment and section lists are complete at construction time. 177 178 Output_section_headers::Output_section_headers( 179 const Layout* layout, 180 const Layout::Segment_list* segment_list, 181 const Layout::Section_list* section_list, 182 const Layout::Section_list* unattached_section_list, 183 const Stringpool* secnamepool, 184 const Output_section* shstrtab_section) 185 : layout_(layout), 186 segment_list_(segment_list), 187 section_list_(section_list), 188 unattached_section_list_(unattached_section_list), 189 secnamepool_(secnamepool), 190 shstrtab_section_(shstrtab_section) 191 { 192 } 193 194 // Compute the current data size. 195 196 off_t 197 Output_section_headers::do_size() const 198 { 199 // Count all the sections. Start with 1 for the null section. 200 off_t count = 1; 201 if (!parameters->options().relocatable()) 202 { 203 for (Layout::Segment_list::const_iterator p = 204 this->segment_list_->begin(); 205 p != this->segment_list_->end(); 206 ++p) 207 if ((*p)->type() == elfcpp::PT_LOAD) 208 count += (*p)->output_section_count(); 209 } 210 else 211 { 212 for (Layout::Section_list::const_iterator p = 213 this->section_list_->begin(); 214 p != this->section_list_->end(); 215 ++p) 216 if (((*p)->flags() & elfcpp::SHF_ALLOC) != 0) 217 ++count; 218 } 219 count += this->unattached_section_list_->size(); 220 221 const int size = parameters->target().get_size(); 222 int shdr_size; 223 if (size == 32) 224 shdr_size = elfcpp::Elf_sizes<32>::shdr_size; 225 else if (size == 64) 226 shdr_size = elfcpp::Elf_sizes<64>::shdr_size; 227 else 228 gold_unreachable(); 229 230 return count * shdr_size; 231 } 232 233 // Write out the section headers. 234 235 void 236 Output_section_headers::do_write(Output_file* of) 237 { 238 switch (parameters->size_and_endianness()) 239 { 240 #ifdef HAVE_TARGET_32_LITTLE 241 case Parameters::TARGET_32_LITTLE: 242 this->do_sized_write<32, false>(of); 243 break; 244 #endif 245 #ifdef HAVE_TARGET_32_BIG 246 case Parameters::TARGET_32_BIG: 247 this->do_sized_write<32, true>(of); 248 break; 249 #endif 250 #ifdef HAVE_TARGET_64_LITTLE 251 case Parameters::TARGET_64_LITTLE: 252 this->do_sized_write<64, false>(of); 253 break; 254 #endif 255 #ifdef HAVE_TARGET_64_BIG 256 case Parameters::TARGET_64_BIG: 257 this->do_sized_write<64, true>(of); 258 break; 259 #endif 260 default: 261 gold_unreachable(); 262 } 263 } 264 265 template<int size, bool big_endian> 266 void 267 Output_section_headers::do_sized_write(Output_file* of) 268 { 269 off_t all_shdrs_size = this->data_size(); 270 unsigned char* view = of->get_output_view(this->offset(), all_shdrs_size); 271 272 const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size; 273 unsigned char* v = view; 274 275 { 276 typename elfcpp::Shdr_write<size, big_endian> oshdr(v); 277 oshdr.put_sh_name(0); 278 oshdr.put_sh_type(elfcpp::SHT_NULL); 279 oshdr.put_sh_flags(0); 280 oshdr.put_sh_addr(0); 281 oshdr.put_sh_offset(0); 282 283 size_t section_count = (this->data_size() 284 / elfcpp::Elf_sizes<size>::shdr_size); 285 if (section_count < elfcpp::SHN_LORESERVE) 286 oshdr.put_sh_size(0); 287 else 288 oshdr.put_sh_size(section_count); 289 290 unsigned int shstrndx = this->shstrtab_section_->out_shndx(); 291 if (shstrndx < elfcpp::SHN_LORESERVE) 292 oshdr.put_sh_link(0); 293 else 294 oshdr.put_sh_link(shstrndx); 295 296 size_t segment_count = this->segment_list_->size(); 297 oshdr.put_sh_info(segment_count >= elfcpp::PN_XNUM ? segment_count : 0); 298 299 oshdr.put_sh_addralign(0); 300 oshdr.put_sh_entsize(0); 301 } 302 303 v += shdr_size; 304 305 unsigned int shndx = 1; 306 if (!parameters->options().relocatable()) 307 { 308 for (Layout::Segment_list::const_iterator p = 309 this->segment_list_->begin(); 310 p != this->segment_list_->end(); 311 ++p) 312 v = (*p)->write_section_headers<size, big_endian>(this->layout_, 313 this->secnamepool_, 314 v, 315 &shndx); 316 } 317 else 318 { 319 for (Layout::Section_list::const_iterator p = 320 this->section_list_->begin(); 321 p != this->section_list_->end(); 322 ++p) 323 { 324 // We do unallocated sections below, except that group 325 // sections have to come first. 326 if (((*p)->flags() & elfcpp::SHF_ALLOC) == 0 327 && (*p)->type() != elfcpp::SHT_GROUP) 328 continue; 329 gold_assert(shndx == (*p)->out_shndx()); 330 elfcpp::Shdr_write<size, big_endian> oshdr(v); 331 (*p)->write_header(this->layout_, this->secnamepool_, &oshdr); 332 v += shdr_size; 333 ++shndx; 334 } 335 } 336 337 for (Layout::Section_list::const_iterator p = 338 this->unattached_section_list_->begin(); 339 p != this->unattached_section_list_->end(); 340 ++p) 341 { 342 // For a relocatable link, we did unallocated group sections 343 // above, since they have to come first. 344 if ((*p)->type() == elfcpp::SHT_GROUP 345 && parameters->options().relocatable()) 346 continue; 347 gold_assert(shndx == (*p)->out_shndx()); 348 elfcpp::Shdr_write<size, big_endian> oshdr(v); 349 (*p)->write_header(this->layout_, this->secnamepool_, &oshdr); 350 v += shdr_size; 351 ++shndx; 352 } 353 354 of->write_output_view(this->offset(), all_shdrs_size, view); 355 } 356 357 // Output_segment_header methods. 358 359 Output_segment_headers::Output_segment_headers( 360 const Layout::Segment_list& segment_list) 361 : segment_list_(segment_list) 362 { 363 this->set_current_data_size_for_child(this->do_size()); 364 } 365 366 void 367 Output_segment_headers::do_write(Output_file* of) 368 { 369 switch (parameters->size_and_endianness()) 370 { 371 #ifdef HAVE_TARGET_32_LITTLE 372 case Parameters::TARGET_32_LITTLE: 373 this->do_sized_write<32, false>(of); 374 break; 375 #endif 376 #ifdef HAVE_TARGET_32_BIG 377 case Parameters::TARGET_32_BIG: 378 this->do_sized_write<32, true>(of); 379 break; 380 #endif 381 #ifdef HAVE_TARGET_64_LITTLE 382 case Parameters::TARGET_64_LITTLE: 383 this->do_sized_write<64, false>(of); 384 break; 385 #endif 386 #ifdef HAVE_TARGET_64_BIG 387 case Parameters::TARGET_64_BIG: 388 this->do_sized_write<64, true>(of); 389 break; 390 #endif 391 default: 392 gold_unreachable(); 393 } 394 } 395 396 template<int size, bool big_endian> 397 void 398 Output_segment_headers::do_sized_write(Output_file* of) 399 { 400 const int phdr_size = elfcpp::Elf_sizes<size>::phdr_size; 401 off_t all_phdrs_size = this->segment_list_.size() * phdr_size; 402 gold_assert(all_phdrs_size == this->data_size()); 403 unsigned char* view = of->get_output_view(this->offset(), 404 all_phdrs_size); 405 unsigned char* v = view; 406 for (Layout::Segment_list::const_iterator p = this->segment_list_.begin(); 407 p != this->segment_list_.end(); 408 ++p) 409 { 410 elfcpp::Phdr_write<size, big_endian> ophdr(v); 411 (*p)->write_header(&ophdr); 412 v += phdr_size; 413 } 414 415 gold_assert(v - view == all_phdrs_size); 416 417 of->write_output_view(this->offset(), all_phdrs_size, view); 418 } 419 420 off_t 421 Output_segment_headers::do_size() const 422 { 423 const int size = parameters->target().get_size(); 424 int phdr_size; 425 if (size == 32) 426 phdr_size = elfcpp::Elf_sizes<32>::phdr_size; 427 else if (size == 64) 428 phdr_size = elfcpp::Elf_sizes<64>::phdr_size; 429 else 430 gold_unreachable(); 431 432 return this->segment_list_.size() * phdr_size; 433 } 434 435 // Output_file_header methods. 436 437 Output_file_header::Output_file_header(Target* target, 438 const Symbol_table* symtab, 439 const Output_segment_headers* osh) 440 : target_(target), 441 symtab_(symtab), 442 segment_header_(osh), 443 section_header_(NULL), 444 shstrtab_(NULL) 445 { 446 this->set_data_size(this->do_size()); 447 } 448 449 // Set the section table information for a file header. 450 451 void 452 Output_file_header::set_section_info(const Output_section_headers* shdrs, 453 const Output_section* shstrtab) 454 { 455 this->section_header_ = shdrs; 456 this->shstrtab_ = shstrtab; 457 } 458 459 // Write out the file header. 460 461 void 462 Output_file_header::do_write(Output_file* of) 463 { 464 gold_assert(this->offset() == 0); 465 466 switch (parameters->size_and_endianness()) 467 { 468 #ifdef HAVE_TARGET_32_LITTLE 469 case Parameters::TARGET_32_LITTLE: 470 this->do_sized_write<32, false>(of); 471 break; 472 #endif 473 #ifdef HAVE_TARGET_32_BIG 474 case Parameters::TARGET_32_BIG: 475 this->do_sized_write<32, true>(of); 476 break; 477 #endif 478 #ifdef HAVE_TARGET_64_LITTLE 479 case Parameters::TARGET_64_LITTLE: 480 this->do_sized_write<64, false>(of); 481 break; 482 #endif 483 #ifdef HAVE_TARGET_64_BIG 484 case Parameters::TARGET_64_BIG: 485 this->do_sized_write<64, true>(of); 486 break; 487 #endif 488 default: 489 gold_unreachable(); 490 } 491 } 492 493 // Write out the file header with appropriate size and endianness. 494 495 template<int size, bool big_endian> 496 void 497 Output_file_header::do_sized_write(Output_file* of) 498 { 499 gold_assert(this->offset() == 0); 500 501 int ehdr_size = elfcpp::Elf_sizes<size>::ehdr_size; 502 unsigned char* view = of->get_output_view(0, ehdr_size); 503 elfcpp::Ehdr_write<size, big_endian> oehdr(view); 504 505 unsigned char e_ident[elfcpp::EI_NIDENT]; 506 memset(e_ident, 0, elfcpp::EI_NIDENT); 507 e_ident[elfcpp::EI_MAG0] = elfcpp::ELFMAG0; 508 e_ident[elfcpp::EI_MAG1] = elfcpp::ELFMAG1; 509 e_ident[elfcpp::EI_MAG2] = elfcpp::ELFMAG2; 510 e_ident[elfcpp::EI_MAG3] = elfcpp::ELFMAG3; 511 if (size == 32) 512 e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS32; 513 else if (size == 64) 514 e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS64; 515 else 516 gold_unreachable(); 517 e_ident[elfcpp::EI_DATA] = (big_endian 518 ? elfcpp::ELFDATA2MSB 519 : elfcpp::ELFDATA2LSB); 520 e_ident[elfcpp::EI_VERSION] = elfcpp::EV_CURRENT; 521 oehdr.put_e_ident(e_ident); 522 523 elfcpp::ET e_type; 524 if (parameters->options().relocatable()) 525 e_type = elfcpp::ET_REL; 526 else if (parameters->options().output_is_position_independent()) 527 e_type = elfcpp::ET_DYN; 528 else 529 e_type = elfcpp::ET_EXEC; 530 oehdr.put_e_type(e_type); 531 532 oehdr.put_e_machine(this->target_->machine_code()); 533 oehdr.put_e_version(elfcpp::EV_CURRENT); 534 535 oehdr.put_e_entry(this->entry<size>()); 536 537 if (this->segment_header_ == NULL) 538 oehdr.put_e_phoff(0); 539 else 540 oehdr.put_e_phoff(this->segment_header_->offset()); 541 542 oehdr.put_e_shoff(this->section_header_->offset()); 543 oehdr.put_e_flags(this->target_->processor_specific_flags()); 544 oehdr.put_e_ehsize(elfcpp::Elf_sizes<size>::ehdr_size); 545 546 if (this->segment_header_ == NULL) 547 { 548 oehdr.put_e_phentsize(0); 549 oehdr.put_e_phnum(0); 550 } 551 else 552 { 553 oehdr.put_e_phentsize(elfcpp::Elf_sizes<size>::phdr_size); 554 size_t phnum = (this->segment_header_->data_size() 555 / elfcpp::Elf_sizes<size>::phdr_size); 556 if (phnum > elfcpp::PN_XNUM) 557 phnum = elfcpp::PN_XNUM; 558 oehdr.put_e_phnum(phnum); 559 } 560 561 oehdr.put_e_shentsize(elfcpp::Elf_sizes<size>::shdr_size); 562 size_t section_count = (this->section_header_->data_size() 563 / elfcpp::Elf_sizes<size>::shdr_size); 564 565 if (section_count < elfcpp::SHN_LORESERVE) 566 oehdr.put_e_shnum(this->section_header_->data_size() 567 / elfcpp::Elf_sizes<size>::shdr_size); 568 else 569 oehdr.put_e_shnum(0); 570 571 unsigned int shstrndx = this->shstrtab_->out_shndx(); 572 if (shstrndx < elfcpp::SHN_LORESERVE) 573 oehdr.put_e_shstrndx(this->shstrtab_->out_shndx()); 574 else 575 oehdr.put_e_shstrndx(elfcpp::SHN_XINDEX); 576 577 // Let the target adjust the ELF header, e.g., to set EI_OSABI in 578 // the e_ident field. 579 this->target_->adjust_elf_header(view, ehdr_size); 580 581 of->write_output_view(0, ehdr_size, view); 582 } 583 584 // Return the value to use for the entry address. 585 586 template<int size> 587 typename elfcpp::Elf_types<size>::Elf_Addr 588 Output_file_header::entry() 589 { 590 const bool should_issue_warning = (parameters->options().entry() != NULL 591 && !parameters->options().relocatable() 592 && !parameters->options().shared()); 593 const char* entry = parameters->entry(); 594 Symbol* sym = this->symtab_->lookup(entry); 595 596 typename Sized_symbol<size>::Value_type v; 597 if (sym != NULL) 598 { 599 Sized_symbol<size>* ssym; 600 ssym = this->symtab_->get_sized_symbol<size>(sym); 601 if (!ssym->is_defined() && should_issue_warning) 602 gold_warning("entry symbol '%s' exists but is not defined", entry); 603 v = ssym->value(); 604 } 605 else 606 { 607 // We couldn't find the entry symbol. See if we can parse it as 608 // a number. This supports, e.g., -e 0x1000. 609 char* endptr; 610 v = strtoull(entry, &endptr, 0); 611 if (*endptr != '\0') 612 { 613 if (should_issue_warning) 614 gold_warning("cannot find entry symbol '%s'", entry); 615 v = 0; 616 } 617 } 618 619 return v; 620 } 621 622 // Compute the current data size. 623 624 off_t 625 Output_file_header::do_size() const 626 { 627 const int size = parameters->target().get_size(); 628 if (size == 32) 629 return elfcpp::Elf_sizes<32>::ehdr_size; 630 else if (size == 64) 631 return elfcpp::Elf_sizes<64>::ehdr_size; 632 else 633 gold_unreachable(); 634 } 635 636 // Output_data_const methods. 637 638 void 639 Output_data_const::do_write(Output_file* of) 640 { 641 of->write(this->offset(), this->data_.data(), this->data_.size()); 642 } 643 644 // Output_data_const_buffer methods. 645 646 void 647 Output_data_const_buffer::do_write(Output_file* of) 648 { 649 of->write(this->offset(), this->p_, this->data_size()); 650 } 651 652 // Output_section_data methods. 653 654 // Record the output section, and set the entry size and such. 655 656 void 657 Output_section_data::set_output_section(Output_section* os) 658 { 659 gold_assert(this->output_section_ == NULL); 660 this->output_section_ = os; 661 this->do_adjust_output_section(os); 662 } 663 664 // Return the section index of the output section. 665 666 unsigned int 667 Output_section_data::do_out_shndx() const 668 { 669 gold_assert(this->output_section_ != NULL); 670 return this->output_section_->out_shndx(); 671 } 672 673 // Set the alignment, which means we may need to update the alignment 674 // of the output section. 675 676 void 677 Output_section_data::set_addralign(uint64_t addralign) 678 { 679 this->addralign_ = addralign; 680 if (this->output_section_ != NULL 681 && this->output_section_->addralign() < addralign) 682 this->output_section_->set_addralign(addralign); 683 } 684 685 // Output_data_strtab methods. 686 687 // Set the final data size. 688 689 void 690 Output_data_strtab::set_final_data_size() 691 { 692 this->strtab_->set_string_offsets(); 693 this->set_data_size(this->strtab_->get_strtab_size()); 694 } 695 696 // Write out a string table. 697 698 void 699 Output_data_strtab::do_write(Output_file* of) 700 { 701 this->strtab_->write(of, this->offset()); 702 } 703 704 // Output_reloc methods. 705 706 // A reloc against a global symbol. 707 708 template<bool dynamic, int size, bool big_endian> 709 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc( 710 Symbol* gsym, 711 unsigned int type, 712 Output_data* od, 713 Address address, 714 bool is_relative, 715 bool is_symbolless, 716 bool use_plt_offset) 717 : address_(address), local_sym_index_(GSYM_CODE), type_(type), 718 is_relative_(is_relative), is_symbolless_(is_symbolless), 719 is_section_symbol_(false), use_plt_offset_(use_plt_offset), shndx_(INVALID_CODE) 720 { 721 // this->type_ is a bitfield; make sure TYPE fits. 722 gold_assert(this->type_ == type); 723 this->u1_.gsym = gsym; 724 this->u2_.od = od; 725 if (dynamic) 726 this->set_needs_dynsym_index(); 727 } 728 729 template<bool dynamic, int size, bool big_endian> 730 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc( 731 Symbol* gsym, 732 unsigned int type, 733 Sized_relobj<size, big_endian>* relobj, 734 unsigned int shndx, 735 Address address, 736 bool is_relative, 737 bool is_symbolless, 738 bool use_plt_offset) 739 : address_(address), local_sym_index_(GSYM_CODE), type_(type), 740 is_relative_(is_relative), is_symbolless_(is_symbolless), 741 is_section_symbol_(false), use_plt_offset_(use_plt_offset), shndx_(shndx) 742 { 743 gold_assert(shndx != INVALID_CODE); 744 // this->type_ is a bitfield; make sure TYPE fits. 745 gold_assert(this->type_ == type); 746 this->u1_.gsym = gsym; 747 this->u2_.relobj = relobj; 748 if (dynamic) 749 this->set_needs_dynsym_index(); 750 } 751 752 // A reloc against a local symbol. 753 754 template<bool dynamic, int size, bool big_endian> 755 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc( 756 Sized_relobj<size, big_endian>* relobj, 757 unsigned int local_sym_index, 758 unsigned int type, 759 Output_data* od, 760 Address address, 761 bool is_relative, 762 bool is_symbolless, 763 bool is_section_symbol, 764 bool use_plt_offset) 765 : address_(address), local_sym_index_(local_sym_index), type_(type), 766 is_relative_(is_relative), is_symbolless_(is_symbolless), 767 is_section_symbol_(is_section_symbol), use_plt_offset_(use_plt_offset), 768 shndx_(INVALID_CODE) 769 { 770 gold_assert(local_sym_index != GSYM_CODE 771 && local_sym_index != INVALID_CODE); 772 // this->type_ is a bitfield; make sure TYPE fits. 773 gold_assert(this->type_ == type); 774 this->u1_.relobj = relobj; 775 this->u2_.od = od; 776 if (dynamic) 777 this->set_needs_dynsym_index(); 778 } 779 780 template<bool dynamic, int size, bool big_endian> 781 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc( 782 Sized_relobj<size, big_endian>* relobj, 783 unsigned int local_sym_index, 784 unsigned int type, 785 unsigned int shndx, 786 Address address, 787 bool is_relative, 788 bool is_symbolless, 789 bool is_section_symbol, 790 bool use_plt_offset) 791 : address_(address), local_sym_index_(local_sym_index), type_(type), 792 is_relative_(is_relative), is_symbolless_(is_symbolless), 793 is_section_symbol_(is_section_symbol), use_plt_offset_(use_plt_offset), 794 shndx_(shndx) 795 { 796 gold_assert(local_sym_index != GSYM_CODE 797 && local_sym_index != INVALID_CODE); 798 gold_assert(shndx != INVALID_CODE); 799 // this->type_ is a bitfield; make sure TYPE fits. 800 gold_assert(this->type_ == type); 801 this->u1_.relobj = relobj; 802 this->u2_.relobj = relobj; 803 if (dynamic) 804 this->set_needs_dynsym_index(); 805 } 806 807 // A reloc against the STT_SECTION symbol of an output section. 808 809 template<bool dynamic, int size, bool big_endian> 810 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc( 811 Output_section* os, 812 unsigned int type, 813 Output_data* od, 814 Address address, 815 bool is_relative) 816 : address_(address), local_sym_index_(SECTION_CODE), type_(type), 817 is_relative_(is_relative), is_symbolless_(is_relative), 818 is_section_symbol_(true), use_plt_offset_(false), shndx_(INVALID_CODE) 819 { 820 // this->type_ is a bitfield; make sure TYPE fits. 821 gold_assert(this->type_ == type); 822 this->u1_.os = os; 823 this->u2_.od = od; 824 if (dynamic) 825 this->set_needs_dynsym_index(); 826 else 827 os->set_needs_symtab_index(); 828 } 829 830 template<bool dynamic, int size, bool big_endian> 831 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc( 832 Output_section* os, 833 unsigned int type, 834 Sized_relobj<size, big_endian>* relobj, 835 unsigned int shndx, 836 Address address, 837 bool is_relative) 838 : address_(address), local_sym_index_(SECTION_CODE), type_(type), 839 is_relative_(is_relative), is_symbolless_(is_relative), 840 is_section_symbol_(true), use_plt_offset_(false), shndx_(shndx) 841 { 842 gold_assert(shndx != INVALID_CODE); 843 // this->type_ is a bitfield; make sure TYPE fits. 844 gold_assert(this->type_ == type); 845 this->u1_.os = os; 846 this->u2_.relobj = relobj; 847 if (dynamic) 848 this->set_needs_dynsym_index(); 849 else 850 os->set_needs_symtab_index(); 851 } 852 853 // An absolute or relative relocation. 854 855 template<bool dynamic, int size, bool big_endian> 856 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc( 857 unsigned int type, 858 Output_data* od, 859 Address address, 860 bool is_relative) 861 : address_(address), local_sym_index_(0), type_(type), 862 is_relative_(is_relative), is_symbolless_(false), 863 is_section_symbol_(false), use_plt_offset_(false), shndx_(INVALID_CODE) 864 { 865 // this->type_ is a bitfield; make sure TYPE fits. 866 gold_assert(this->type_ == type); 867 this->u1_.relobj = NULL; 868 this->u2_.od = od; 869 } 870 871 template<bool dynamic, int size, bool big_endian> 872 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc( 873 unsigned int type, 874 Sized_relobj<size, big_endian>* relobj, 875 unsigned int shndx, 876 Address address, 877 bool is_relative) 878 : address_(address), local_sym_index_(0), type_(type), 879 is_relative_(is_relative), is_symbolless_(false), 880 is_section_symbol_(false), use_plt_offset_(false), shndx_(shndx) 881 { 882 gold_assert(shndx != INVALID_CODE); 883 // this->type_ is a bitfield; make sure TYPE fits. 884 gold_assert(this->type_ == type); 885 this->u1_.relobj = NULL; 886 this->u2_.relobj = relobj; 887 } 888 889 // A target specific relocation. 890 891 template<bool dynamic, int size, bool big_endian> 892 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc( 893 unsigned int type, 894 void* arg, 895 Output_data* od, 896 Address address) 897 : address_(address), local_sym_index_(TARGET_CODE), type_(type), 898 is_relative_(false), is_symbolless_(false), 899 is_section_symbol_(false), use_plt_offset_(false), shndx_(INVALID_CODE) 900 { 901 // this->type_ is a bitfield; make sure TYPE fits. 902 gold_assert(this->type_ == type); 903 this->u1_.arg = arg; 904 this->u2_.od = od; 905 } 906 907 template<bool dynamic, int size, bool big_endian> 908 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc( 909 unsigned int type, 910 void* arg, 911 Sized_relobj<size, big_endian>* relobj, 912 unsigned int shndx, 913 Address address) 914 : address_(address), local_sym_index_(TARGET_CODE), type_(type), 915 is_relative_(false), is_symbolless_(false), 916 is_section_symbol_(false), use_plt_offset_(false), shndx_(shndx) 917 { 918 gold_assert(shndx != INVALID_CODE); 919 // this->type_ is a bitfield; make sure TYPE fits. 920 gold_assert(this->type_ == type); 921 this->u1_.arg = arg; 922 this->u2_.relobj = relobj; 923 } 924 925 // Record that we need a dynamic symbol index for this relocation. 926 927 template<bool dynamic, int size, bool big_endian> 928 void 929 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>:: 930 set_needs_dynsym_index() 931 { 932 if (this->is_symbolless_) 933 return; 934 switch (this->local_sym_index_) 935 { 936 case INVALID_CODE: 937 gold_unreachable(); 938 939 case GSYM_CODE: 940 this->u1_.gsym->set_needs_dynsym_entry(); 941 break; 942 943 case SECTION_CODE: 944 this->u1_.os->set_needs_dynsym_index(); 945 break; 946 947 case TARGET_CODE: 948 // The target must take care of this if necessary. 949 break; 950 951 case 0: 952 break; 953 954 default: 955 { 956 const unsigned int lsi = this->local_sym_index_; 957 Sized_relobj_file<size, big_endian>* relobj = 958 this->u1_.relobj->sized_relobj(); 959 gold_assert(relobj != NULL); 960 if (!this->is_section_symbol_) 961 relobj->set_needs_output_dynsym_entry(lsi); 962 else 963 relobj->output_section(lsi)->set_needs_dynsym_index(); 964 } 965 break; 966 } 967 } 968 969 // Get the symbol index of a relocation. 970 971 template<bool dynamic, int size, bool big_endian> 972 unsigned int 973 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_symbol_index() 974 const 975 { 976 unsigned int index; 977 if (this->is_symbolless_) 978 return 0; 979 switch (this->local_sym_index_) 980 { 981 case INVALID_CODE: 982 gold_unreachable(); 983 984 case GSYM_CODE: 985 if (this->u1_.gsym == NULL) 986 index = 0; 987 else if (dynamic) 988 index = this->u1_.gsym->dynsym_index(); 989 else 990 index = this->u1_.gsym->symtab_index(); 991 break; 992 993 case SECTION_CODE: 994 if (dynamic) 995 index = this->u1_.os->dynsym_index(); 996 else 997 index = this->u1_.os->symtab_index(); 998 break; 999 1000 case TARGET_CODE: 1001 index = parameters->target().reloc_symbol_index(this->u1_.arg, 1002 this->type_); 1003 break; 1004 1005 case 0: 1006 // Relocations without symbols use a symbol index of 0. 1007 index = 0; 1008 break; 1009 1010 default: 1011 { 1012 const unsigned int lsi = this->local_sym_index_; 1013 Sized_relobj_file<size, big_endian>* relobj = 1014 this->u1_.relobj->sized_relobj(); 1015 gold_assert(relobj != NULL); 1016 if (!this->is_section_symbol_) 1017 { 1018 if (dynamic) 1019 index = relobj->dynsym_index(lsi); 1020 else 1021 index = relobj->symtab_index(lsi); 1022 } 1023 else 1024 { 1025 Output_section* os = relobj->output_section(lsi); 1026 gold_assert(os != NULL); 1027 if (dynamic) 1028 index = os->dynsym_index(); 1029 else 1030 index = os->symtab_index(); 1031 } 1032 } 1033 break; 1034 } 1035 gold_assert(index != -1U); 1036 return index; 1037 } 1038 1039 // For a local section symbol, get the address of the offset ADDEND 1040 // within the input section. 1041 1042 template<bool dynamic, int size, bool big_endian> 1043 typename elfcpp::Elf_types<size>::Elf_Addr 1044 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>:: 1045 local_section_offset(Addend addend) const 1046 { 1047 gold_assert(this->local_sym_index_ != GSYM_CODE 1048 && this->local_sym_index_ != SECTION_CODE 1049 && this->local_sym_index_ != TARGET_CODE 1050 && this->local_sym_index_ != INVALID_CODE 1051 && this->local_sym_index_ != 0 1052 && this->is_section_symbol_); 1053 const unsigned int lsi = this->local_sym_index_; 1054 Output_section* os = this->u1_.relobj->output_section(lsi); 1055 gold_assert(os != NULL); 1056 Address offset = this->u1_.relobj->get_output_section_offset(lsi); 1057 if (offset != invalid_address) 1058 return offset + addend; 1059 // This is a merge section. 1060 Sized_relobj_file<size, big_endian>* relobj = 1061 this->u1_.relobj->sized_relobj(); 1062 gold_assert(relobj != NULL); 1063 offset = os->output_address(relobj, lsi, addend); 1064 gold_assert(offset != invalid_address); 1065 return offset; 1066 } 1067 1068 // Get the output address of a relocation. 1069 1070 template<bool dynamic, int size, bool big_endian> 1071 typename elfcpp::Elf_types<size>::Elf_Addr 1072 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_address() const 1073 { 1074 Address address = this->address_; 1075 if (this->shndx_ != INVALID_CODE) 1076 { 1077 Output_section* os = this->u2_.relobj->output_section(this->shndx_); 1078 gold_assert(os != NULL); 1079 Address off = this->u2_.relobj->get_output_section_offset(this->shndx_); 1080 if (off != invalid_address) 1081 address += os->address() + off; 1082 else 1083 { 1084 Sized_relobj_file<size, big_endian>* relobj = 1085 this->u2_.relobj->sized_relobj(); 1086 gold_assert(relobj != NULL); 1087 address = os->output_address(relobj, this->shndx_, address); 1088 gold_assert(address != invalid_address); 1089 } 1090 } 1091 else if (this->u2_.od != NULL) 1092 address += this->u2_.od->address(); 1093 return address; 1094 } 1095 1096 // Write out the offset and info fields of a Rel or Rela relocation 1097 // entry. 1098 1099 template<bool dynamic, int size, bool big_endian> 1100 template<typename Write_rel> 1101 void 1102 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write_rel( 1103 Write_rel* wr) const 1104 { 1105 wr->put_r_offset(this->get_address()); 1106 unsigned int sym_index = this->get_symbol_index(); 1107 wr->put_r_info(elfcpp::elf_r_info<size>(sym_index, this->type_)); 1108 } 1109 1110 // Write out a Rel relocation. 1111 1112 template<bool dynamic, int size, bool big_endian> 1113 void 1114 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write( 1115 unsigned char* pov) const 1116 { 1117 elfcpp::Rel_write<size, big_endian> orel(pov); 1118 this->write_rel(&orel); 1119 } 1120 1121 // Get the value of the symbol referred to by a Rel relocation. 1122 1123 template<bool dynamic, int size, bool big_endian> 1124 typename elfcpp::Elf_types<size>::Elf_Addr 1125 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::symbol_value( 1126 Addend addend) const 1127 { 1128 if (this->local_sym_index_ == GSYM_CODE) 1129 { 1130 const Sized_symbol<size>* sym; 1131 sym = static_cast<const Sized_symbol<size>*>(this->u1_.gsym); 1132 if (this->use_plt_offset_ && sym->has_plt_offset()) 1133 return parameters->target().plt_address_for_global(sym); 1134 else 1135 return sym->value() + addend; 1136 } 1137 if (this->local_sym_index_ == SECTION_CODE) 1138 { 1139 gold_assert(!this->use_plt_offset_); 1140 return this->u1_.os->address() + addend; 1141 } 1142 gold_assert(this->local_sym_index_ != TARGET_CODE 1143 && this->local_sym_index_ != INVALID_CODE 1144 && this->local_sym_index_ != 0 1145 && !this->is_section_symbol_); 1146 const unsigned int lsi = this->local_sym_index_; 1147 Sized_relobj_file<size, big_endian>* relobj = 1148 this->u1_.relobj->sized_relobj(); 1149 gold_assert(relobj != NULL); 1150 if (this->use_plt_offset_) 1151 return parameters->target().plt_address_for_local(relobj, lsi); 1152 const Symbol_value<size>* symval = relobj->local_symbol(lsi); 1153 return symval->value(relobj, addend); 1154 } 1155 1156 // Reloc comparison. This function sorts the dynamic relocs for the 1157 // benefit of the dynamic linker. First we sort all relative relocs 1158 // to the front. Among relative relocs, we sort by output address. 1159 // Among non-relative relocs, we sort by symbol index, then by output 1160 // address. 1161 1162 template<bool dynamic, int size, bool big_endian> 1163 int 1164 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>:: 1165 compare(const Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>& r2) 1166 const 1167 { 1168 if (this->is_relative_) 1169 { 1170 if (!r2.is_relative_) 1171 return -1; 1172 // Otherwise sort by reloc address below. 1173 } 1174 else if (r2.is_relative_) 1175 return 1; 1176 else 1177 { 1178 unsigned int sym1 = this->get_symbol_index(); 1179 unsigned int sym2 = r2.get_symbol_index(); 1180 if (sym1 < sym2) 1181 return -1; 1182 else if (sym1 > sym2) 1183 return 1; 1184 // Otherwise sort by reloc address. 1185 } 1186 1187 section_offset_type addr1 = this->get_address(); 1188 section_offset_type addr2 = r2.get_address(); 1189 if (addr1 < addr2) 1190 return -1; 1191 else if (addr1 > addr2) 1192 return 1; 1193 1194 // Final tie breaker, in order to generate the same output on any 1195 // host: reloc type. 1196 unsigned int type1 = this->type_; 1197 unsigned int type2 = r2.type_; 1198 if (type1 < type2) 1199 return -1; 1200 else if (type1 > type2) 1201 return 1; 1202 1203 // These relocs appear to be exactly the same. 1204 return 0; 1205 } 1206 1207 // Write out a Rela relocation. 1208 1209 template<bool dynamic, int size, bool big_endian> 1210 void 1211 Output_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>::write( 1212 unsigned char* pov) const 1213 { 1214 elfcpp::Rela_write<size, big_endian> orel(pov); 1215 this->rel_.write_rel(&orel); 1216 Addend addend = this->addend_; 1217 if (this->rel_.is_target_specific()) 1218 addend = parameters->target().reloc_addend(this->rel_.target_arg(), 1219 this->rel_.type(), addend); 1220 else if (this->rel_.is_symbolless()) 1221 addend = this->rel_.symbol_value(addend); 1222 else if (this->rel_.is_local_section_symbol()) 1223 addend = this->rel_.local_section_offset(addend); 1224 orel.put_r_addend(addend); 1225 } 1226 1227 // Write out a Relr relocation. 1228 1229 template<bool dynamic, int size, bool big_endian> 1230 void 1231 Output_reloc<elfcpp::SHT_RELR, dynamic, size, big_endian>::write( 1232 unsigned char* pov) const 1233 { 1234 elfcpp::Relr_write<size, big_endian> orel(pov); 1235 if (this->bits_ == 0) 1236 { 1237 // This is not a continuation entry. Output full address. 1238 orel.put_r_data(this->rel_.get_address()); 1239 } 1240 else 1241 { 1242 // This is a continuation entry. Output the bitmap. 1243 orel.put_r_data((this->bits_<<1)|1); 1244 } 1245 } 1246 1247 // Output_data_reloc_base methods. 1248 1249 // Adjust the output section. 1250 1251 template<int sh_type, bool dynamic, int size, bool big_endian> 1252 void 1253 Output_data_reloc_base<sh_type, dynamic, size, big_endian> 1254 ::do_adjust_output_section(Output_section* os) 1255 { 1256 if (sh_type == elfcpp::SHT_REL) 1257 os->set_entsize(elfcpp::Elf_sizes<size>::rel_size); 1258 else if (sh_type == elfcpp::SHT_RELA) 1259 os->set_entsize(elfcpp::Elf_sizes<size>::rela_size); 1260 else if (sh_type == elfcpp::SHT_RELR) 1261 os->set_entsize(elfcpp::Elf_sizes<size>::relr_size); 1262 else 1263 gold_unreachable(); 1264 1265 // A STT_GNU_IFUNC symbol may require a IRELATIVE reloc when doing a 1266 // static link. The backends will generate a dynamic reloc section 1267 // to hold this. In that case we don't want to link to the dynsym 1268 // section, because there isn't one. 1269 if (!dynamic) 1270 os->set_should_link_to_symtab(); 1271 else if (parameters->doing_static_link()) 1272 ; 1273 else 1274 os->set_should_link_to_dynsym(); 1275 } 1276 1277 // Standard relocation writer, which just calls Output_reloc::write(). 1278 1279 template<int sh_type, bool dynamic, int size, bool big_endian> 1280 struct Output_reloc_writer 1281 { 1282 typedef Output_reloc<sh_type, dynamic, size, big_endian> Output_reloc_type; 1283 typedef std::vector<Output_reloc_type> Relocs; 1284 1285 static void 1286 write(typename Relocs::const_iterator p, unsigned char* pov) 1287 { p->write(pov); } 1288 }; 1289 1290 // Write out relocation data. 1291 1292 template<int sh_type, bool dynamic, int size, bool big_endian> 1293 void 1294 Output_data_reloc_base<sh_type, dynamic, size, big_endian>::do_write( 1295 Output_file* of) 1296 { 1297 typedef Output_reloc_writer<sh_type, dynamic, size, big_endian> Writer; 1298 this->do_write_generic<Writer>(of); 1299 } 1300 1301 template<bool dynamic, int size, bool big_endian> 1302 void 1303 Output_data_reloc<elfcpp::SHT_RELR, dynamic, size, big_endian>::do_write( 1304 Output_file* of) 1305 { 1306 typedef Output_reloc_writer<elfcpp::SHT_RELR, dynamic, size, big_endian> Writer; 1307 this->template do_write_generic<Writer>(of); 1308 } 1309 1310 // Class Output_relocatable_relocs. 1311 1312 template<int sh_type, int size, bool big_endian> 1313 void 1314 Output_relocatable_relocs<sh_type, size, big_endian>::set_final_data_size() 1315 { 1316 this->set_data_size(this->rr_->output_reloc_count() 1317 * Reloc_types<sh_type, size, big_endian>::reloc_size); 1318 } 1319 1320 // class Output_data_group. 1321 1322 template<int size, bool big_endian> 1323 Output_data_group<size, big_endian>::Output_data_group( 1324 Sized_relobj_file<size, big_endian>* relobj, 1325 section_size_type entry_count, 1326 elfcpp::Elf_Word flags, 1327 std::vector<unsigned int>* input_shndxes) 1328 : Output_section_data(entry_count * 4, 4, false), 1329 relobj_(relobj), 1330 flags_(flags) 1331 { 1332 this->input_shndxes_.swap(*input_shndxes); 1333 } 1334 1335 // Write out the section group, which means translating the section 1336 // indexes to apply to the output file. 1337 1338 template<int size, bool big_endian> 1339 void 1340 Output_data_group<size, big_endian>::do_write(Output_file* of) 1341 { 1342 const off_t off = this->offset(); 1343 const section_size_type oview_size = 1344 convert_to_section_size_type(this->data_size()); 1345 unsigned char* const oview = of->get_output_view(off, oview_size); 1346 1347 elfcpp::Elf_Word* contents = reinterpret_cast<elfcpp::Elf_Word*>(oview); 1348 elfcpp::Swap<32, big_endian>::writeval(contents, this->flags_); 1349 ++contents; 1350 1351 for (std::vector<unsigned int>::const_iterator p = 1352 this->input_shndxes_.begin(); 1353 p != this->input_shndxes_.end(); 1354 ++p, ++contents) 1355 { 1356 Output_section* os = this->relobj_->output_section(*p); 1357 1358 unsigned int output_shndx; 1359 if (os != NULL) 1360 output_shndx = os->out_shndx(); 1361 else 1362 { 1363 this->relobj_->error(_("section group retained but " 1364 "group element discarded")); 1365 output_shndx = 0; 1366 } 1367 1368 elfcpp::Swap<32, big_endian>::writeval(contents, output_shndx); 1369 } 1370 1371 size_t wrote = reinterpret_cast<unsigned char*>(contents) - oview; 1372 gold_assert(wrote == oview_size); 1373 1374 of->write_output_view(off, oview_size, oview); 1375 1376 // We no longer need this information. 1377 this->input_shndxes_.clear(); 1378 } 1379 1380 // Output_data_got::Got_entry methods. 1381 1382 // Write out the entry. 1383 1384 template<int got_size, bool big_endian> 1385 void 1386 Output_data_got<got_size, big_endian>::Got_entry::write( 1387 unsigned int got_indx, 1388 unsigned char* pov) const 1389 { 1390 Valtype val = 0; 1391 1392 switch (this->local_sym_index_) 1393 { 1394 case GSYM_CODE: 1395 { 1396 // If the symbol is resolved locally, we need to write out the 1397 // link-time value, which will be relocated dynamically by a 1398 // RELATIVE relocation. 1399 Symbol* gsym = this->u_.gsym; 1400 if (this->use_plt_or_tls_offset_ && gsym->has_plt_offset()) 1401 val = parameters->target().plt_address_for_global(gsym); 1402 else 1403 { 1404 switch (parameters->size_and_endianness()) 1405 { 1406 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) 1407 case Parameters::TARGET_32_LITTLE: 1408 case Parameters::TARGET_32_BIG: 1409 { 1410 // This cast is ugly. We don't want to put a 1411 // virtual method in Symbol, because we want Symbol 1412 // to be as small as possible. 1413 Sized_symbol<32>::Value_type v; 1414 v = static_cast<Sized_symbol<32>*>(gsym)->value(); 1415 val = convert_types<Valtype, Sized_symbol<32>::Value_type>(v); 1416 } 1417 break; 1418 #endif 1419 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) 1420 case Parameters::TARGET_64_LITTLE: 1421 case Parameters::TARGET_64_BIG: 1422 { 1423 Sized_symbol<64>::Value_type v; 1424 v = static_cast<Sized_symbol<64>*>(gsym)->value(); 1425 val = convert_types<Valtype, Sized_symbol<64>::Value_type>(v); 1426 } 1427 break; 1428 #endif 1429 default: 1430 gold_unreachable(); 1431 } 1432 if (this->use_plt_or_tls_offset_ 1433 && gsym->type() == elfcpp::STT_TLS) 1434 val += parameters->target().tls_offset_for_global(gsym, 1435 got_indx); 1436 } 1437 } 1438 break; 1439 1440 case CONSTANT_CODE: 1441 val = this->u_.constant; 1442 break; 1443 1444 case RESERVED_CODE: 1445 // If we're doing an incremental update, don't touch this GOT entry. 1446 if (parameters->incremental_update()) 1447 return; 1448 val = this->u_.constant; 1449 break; 1450 1451 default: 1452 { 1453 const Relobj* object = this->u_.object; 1454 const unsigned int lsi = this->local_sym_index_; 1455 bool is_tls = object->local_is_tls(lsi); 1456 if (this->use_plt_or_tls_offset_ && !is_tls) 1457 val = parameters->target().plt_address_for_local(object, lsi); 1458 else 1459 { 1460 uint64_t lval = object->local_symbol_value(lsi, this->addend_); 1461 val = convert_types<Valtype, uint64_t>(lval); 1462 if (this->use_plt_or_tls_offset_ && is_tls) 1463 val += parameters->target().tls_offset_for_local(object, lsi, 1464 got_indx); 1465 } 1466 } 1467 break; 1468 } 1469 1470 elfcpp::Swap<got_size, big_endian>::writeval(pov, val); 1471 } 1472 1473 // Output_data_got methods. 1474 1475 // Add an entry for a global symbol to the GOT. This returns true if 1476 // this is a new GOT entry, false if the symbol already had a GOT 1477 // entry. 1478 1479 template<int got_size, bool big_endian> 1480 bool 1481 Output_data_got<got_size, big_endian>::add_global( 1482 Symbol* gsym, 1483 unsigned int got_type) 1484 { 1485 if (gsym->has_got_offset(got_type)) 1486 return false; 1487 1488 unsigned int got_offset = this->add_got_entry(Got_entry(gsym, false)); 1489 gsym->set_got_offset(got_type, got_offset); 1490 return true; 1491 } 1492 1493 // Like add_global, but use the PLT offset. 1494 1495 template<int got_size, bool big_endian> 1496 bool 1497 Output_data_got<got_size, big_endian>::add_global_plt(Symbol* gsym, 1498 unsigned int got_type) 1499 { 1500 if (gsym->has_got_offset(got_type)) 1501 return false; 1502 1503 unsigned int got_offset = this->add_got_entry(Got_entry(gsym, true)); 1504 gsym->set_got_offset(got_type, got_offset); 1505 return true; 1506 } 1507 1508 // Add an entry for a global symbol to the GOT, and add a dynamic 1509 // relocation of type R_TYPE for the GOT entry. 1510 1511 template<int got_size, bool big_endian> 1512 void 1513 Output_data_got<got_size, big_endian>::add_global_with_rel( 1514 Symbol* gsym, 1515 unsigned int got_type, 1516 Output_data_reloc_generic* rel_dyn, 1517 unsigned int r_type) 1518 { 1519 if (gsym->has_got_offset(got_type)) 1520 return; 1521 1522 unsigned int got_offset = this->add_got_entry(Got_entry()); 1523 gsym->set_got_offset(got_type, got_offset); 1524 rel_dyn->add_global_generic(gsym, r_type, this, got_offset, 0); 1525 } 1526 1527 // Add a pair of entries for a global symbol to the GOT, and add 1528 // dynamic relocations of type R_TYPE_1 and R_TYPE_2, respectively. 1529 // If R_TYPE_2 == 0, add the second entry with no relocation. 1530 template<int got_size, bool big_endian> 1531 void 1532 Output_data_got<got_size, big_endian>::add_global_pair_with_rel( 1533 Symbol* gsym, 1534 unsigned int got_type, 1535 Output_data_reloc_generic* rel_dyn, 1536 unsigned int r_type_1, 1537 unsigned int r_type_2) 1538 { 1539 if (gsym->has_got_offset(got_type)) 1540 return; 1541 1542 unsigned int got_offset = this->add_got_entry_pair(Got_entry(), Got_entry()); 1543 gsym->set_got_offset(got_type, got_offset); 1544 rel_dyn->add_global_generic(gsym, r_type_1, this, got_offset, 0); 1545 1546 if (r_type_2 != 0) 1547 rel_dyn->add_global_generic(gsym, r_type_2, this, 1548 got_offset + got_size / 8, 0); 1549 } 1550 1551 // Add an entry for a local symbol to the GOT. This returns true if 1552 // this is a new GOT entry, false if the symbol already has a GOT 1553 // entry. 1554 1555 template<int got_size, bool big_endian> 1556 bool 1557 Output_data_got<got_size, big_endian>::add_local( 1558 Relobj* object, 1559 unsigned int symndx, 1560 unsigned int got_type) 1561 { 1562 if (object->local_has_got_offset(symndx, got_type)) 1563 return false; 1564 1565 unsigned int got_offset = this->add_got_entry(Got_entry(object, symndx, 1566 false)); 1567 object->set_local_got_offset(symndx, got_type, got_offset); 1568 return true; 1569 } 1570 1571 // Add an entry for a local symbol plus ADDEND to the GOT. This returns 1572 // true if this is a new GOT entry, false if the symbol already has a GOT 1573 // entry. 1574 1575 template<int got_size, bool big_endian> 1576 bool 1577 Output_data_got<got_size, big_endian>::add_local( 1578 Relobj* object, 1579 unsigned int symndx, 1580 unsigned int got_type, 1581 uint64_t addend) 1582 { 1583 if (object->local_has_got_offset(symndx, got_type, addend)) 1584 return false; 1585 1586 unsigned int got_offset = this->add_got_entry(Got_entry(object, symndx, 1587 false, addend)); 1588 object->set_local_got_offset(symndx, got_type, got_offset, addend); 1589 return true; 1590 } 1591 1592 // Like add_local, but use the PLT offset. 1593 1594 template<int got_size, bool big_endian> 1595 bool 1596 Output_data_got<got_size, big_endian>::add_local_plt( 1597 Relobj* object, 1598 unsigned int symndx, 1599 unsigned int got_type) 1600 { 1601 if (object->local_has_got_offset(symndx, got_type)) 1602 return false; 1603 1604 unsigned int got_offset = this->add_got_entry(Got_entry(object, symndx, 1605 true)); 1606 object->set_local_got_offset(symndx, got_type, got_offset); 1607 return true; 1608 } 1609 1610 // Add an entry for a local symbol to the GOT, and add a dynamic 1611 // relocation of type R_TYPE for the GOT entry. 1612 1613 template<int got_size, bool big_endian> 1614 void 1615 Output_data_got<got_size, big_endian>::add_local_with_rel( 1616 Relobj* object, 1617 unsigned int symndx, 1618 unsigned int got_type, 1619 Output_data_reloc_generic* rel_dyn, 1620 unsigned int r_type) 1621 { 1622 if (object->local_has_got_offset(symndx, got_type)) 1623 return; 1624 1625 unsigned int got_offset = this->add_got_entry(Got_entry()); 1626 object->set_local_got_offset(symndx, got_type, got_offset); 1627 rel_dyn->add_local_generic(object, symndx, r_type, this, got_offset, 0); 1628 } 1629 1630 // Add an entry for a local symbol plus ADDEND to the GOT, and add a dynamic 1631 // relocation of type R_TYPE for the GOT entry. 1632 1633 template<int got_size, bool big_endian> 1634 void 1635 Output_data_got<got_size, big_endian>::add_local_with_rel( 1636 Relobj* object, 1637 unsigned int symndx, 1638 unsigned int got_type, 1639 Output_data_reloc_generic* rel_dyn, 1640 unsigned int r_type, uint64_t addend) 1641 { 1642 if (object->local_has_got_offset(symndx, got_type, addend)) 1643 return; 1644 1645 unsigned int got_offset = this->add_got_entry(Got_entry()); 1646 object->set_local_got_offset(symndx, got_type, got_offset, addend); 1647 rel_dyn->add_local_generic(object, symndx, r_type, this, got_offset, 1648 addend); 1649 } 1650 1651 // Add a pair of entries for a local symbol to the GOT, and add 1652 // a dynamic relocation of type R_TYPE using the section symbol of 1653 // the output section to which input section SHNDX maps, on the first. 1654 // The first got entry will have a value of zero, the second the 1655 // value of the local symbol. 1656 template<int got_size, bool big_endian> 1657 void 1658 Output_data_got<got_size, big_endian>::add_local_pair_with_rel( 1659 Relobj* object, 1660 unsigned int symndx, 1661 unsigned int shndx, 1662 unsigned int got_type, 1663 Output_data_reloc_generic* rel_dyn, 1664 unsigned int r_type) 1665 { 1666 if (object->local_has_got_offset(symndx, got_type)) 1667 return; 1668 1669 unsigned int got_offset = 1670 this->add_got_entry_pair(Got_entry(), 1671 Got_entry(object, symndx, false)); 1672 object->set_local_got_offset(symndx, got_type, got_offset); 1673 Output_section* os = object->output_section(shndx); 1674 rel_dyn->add_output_section_generic(os, r_type, this, got_offset, 0); 1675 } 1676 1677 // Add a pair of entries for a local symbol plus ADDEND to the GOT, and add 1678 // a dynamic relocation of type R_TYPE using the section symbol of 1679 // the output section to which input section SHNDX maps, on the first. 1680 // The first got entry will have a value of zero, the second the 1681 // value of the local symbol. 1682 template<int got_size, bool big_endian> 1683 void 1684 Output_data_got<got_size, big_endian>::add_local_pair_with_rel( 1685 Relobj* object, 1686 unsigned int symndx, 1687 unsigned int shndx, 1688 unsigned int got_type, 1689 Output_data_reloc_generic* rel_dyn, 1690 unsigned int r_type, uint64_t addend) 1691 { 1692 if (object->local_has_got_offset(symndx, got_type, addend)) 1693 return; 1694 1695 unsigned int got_offset = 1696 this->add_got_entry_pair(Got_entry(), 1697 Got_entry(object, symndx, false, addend)); 1698 object->set_local_got_offset(symndx, got_type, got_offset, addend); 1699 Output_section* os = object->output_section(shndx); 1700 rel_dyn->add_output_section_generic(os, r_type, this, got_offset, addend); 1701 } 1702 1703 // Add a pair of entries for a local symbol to the GOT, and add 1704 // a dynamic relocation of type R_TYPE using STN_UNDEF on the first. 1705 // The first got entry will have a value of zero, the second the 1706 // value of the local symbol offset by Target::tls_offset_for_local. 1707 template<int got_size, bool big_endian> 1708 void 1709 Output_data_got<got_size, big_endian>::add_local_tls_pair( 1710 Relobj* object, 1711 unsigned int symndx, 1712 unsigned int got_type, 1713 Output_data_reloc_generic* rel_dyn, 1714 unsigned int r_type) 1715 { 1716 if (object->local_has_got_offset(symndx, got_type)) 1717 return; 1718 1719 unsigned int got_offset 1720 = this->add_got_entry_pair(Got_entry(), 1721 Got_entry(object, symndx, true)); 1722 object->set_local_got_offset(symndx, got_type, got_offset); 1723 rel_dyn->add_local_generic(object, 0, r_type, this, got_offset, 0); 1724 } 1725 1726 // Reserve a slot in the GOT for a local symbol or the second slot of a pair. 1727 1728 template<int got_size, bool big_endian> 1729 void 1730 Output_data_got<got_size, big_endian>::reserve_local( 1731 unsigned int i, 1732 Relobj* object, 1733 unsigned int sym_index, 1734 unsigned int got_type) 1735 { 1736 this->do_reserve_slot(i); 1737 object->set_local_got_offset(sym_index, got_type, this->got_offset(i)); 1738 } 1739 1740 // Reserve a slot in the GOT for a global symbol. 1741 1742 template<int got_size, bool big_endian> 1743 void 1744 Output_data_got<got_size, big_endian>::reserve_global( 1745 unsigned int i, 1746 Symbol* gsym, 1747 unsigned int got_type) 1748 { 1749 this->do_reserve_slot(i); 1750 gsym->set_got_offset(got_type, this->got_offset(i)); 1751 } 1752 1753 // Write out the GOT. 1754 1755 template<int got_size, bool big_endian> 1756 void 1757 Output_data_got<got_size, big_endian>::do_write(Output_file* of) 1758 { 1759 const int add = got_size / 8; 1760 1761 const off_t off = this->offset(); 1762 const off_t oview_size = this->data_size(); 1763 unsigned char* const oview = of->get_output_view(off, oview_size); 1764 1765 unsigned char* pov = oview; 1766 for (unsigned int i = 0; i < this->entries_.size(); ++i) 1767 { 1768 this->entries_[i].write(i, pov); 1769 pov += add; 1770 } 1771 1772 gold_assert(pov - oview == oview_size); 1773 1774 of->write_output_view(off, oview_size, oview); 1775 1776 // We no longer need the GOT entries. 1777 this->entries_.clear(); 1778 } 1779 1780 // Create a new GOT entry and return its offset. 1781 1782 template<int got_size, bool big_endian> 1783 unsigned int 1784 Output_data_got<got_size, big_endian>::add_got_entry(Got_entry got_entry) 1785 { 1786 if (!this->is_data_size_valid()) 1787 { 1788 this->entries_.push_back(got_entry); 1789 this->set_got_size(); 1790 return this->last_got_offset(); 1791 } 1792 else 1793 { 1794 // For an incremental update, find an available slot. 1795 off_t got_offset = this->free_list_.allocate(got_size / 8, 1796 got_size / 8, 0); 1797 if (got_offset == -1) 1798 gold_fallback(_("out of patch space (GOT);" 1799 " relink with --incremental-full")); 1800 unsigned int got_index = got_offset / (got_size / 8); 1801 gold_assert(got_index < this->entries_.size()); 1802 this->entries_[got_index] = got_entry; 1803 return static_cast<unsigned int>(got_offset); 1804 } 1805 } 1806 1807 // Create a pair of new GOT entries and return the offset of the first. 1808 1809 template<int got_size, bool big_endian> 1810 unsigned int 1811 Output_data_got<got_size, big_endian>::add_got_entry_pair( 1812 Got_entry got_entry_1, 1813 Got_entry got_entry_2) 1814 { 1815 if (!this->is_data_size_valid()) 1816 { 1817 unsigned int got_offset; 1818 this->entries_.push_back(got_entry_1); 1819 got_offset = this->last_got_offset(); 1820 this->entries_.push_back(got_entry_2); 1821 this->set_got_size(); 1822 return got_offset; 1823 } 1824 else 1825 { 1826 // For an incremental update, find an available pair of slots. 1827 off_t got_offset = this->free_list_.allocate(2 * got_size / 8, 1828 got_size / 8, 0); 1829 if (got_offset == -1) 1830 gold_fallback(_("out of patch space (GOT);" 1831 " relink with --incremental-full")); 1832 unsigned int got_index = got_offset / (got_size / 8); 1833 gold_assert(got_index < this->entries_.size()); 1834 this->entries_[got_index] = got_entry_1; 1835 this->entries_[got_index + 1] = got_entry_2; 1836 return static_cast<unsigned int>(got_offset); 1837 } 1838 } 1839 1840 // Replace GOT entry I with a new value. 1841 1842 template<int got_size, bool big_endian> 1843 void 1844 Output_data_got<got_size, big_endian>::replace_got_entry( 1845 unsigned int i, 1846 Got_entry got_entry) 1847 { 1848 gold_assert(i < this->entries_.size()); 1849 this->entries_[i] = got_entry; 1850 } 1851 1852 // Output_data_dynamic::Dynamic_entry methods. 1853 1854 // Write out the entry. 1855 1856 template<int size, bool big_endian> 1857 void 1858 Output_data_dynamic::Dynamic_entry::write( 1859 unsigned char* pov, 1860 const Stringpool* pool) const 1861 { 1862 typename elfcpp::Elf_types<size>::Elf_WXword val; 1863 switch (this->offset_) 1864 { 1865 case DYNAMIC_NUMBER: 1866 val = this->u_.val; 1867 break; 1868 1869 case DYNAMIC_SECTION_SIZE: 1870 val = this->u_.od->data_size(); 1871 if (this->od2 != NULL) 1872 val += this->od2->data_size(); 1873 break; 1874 1875 case DYNAMIC_SYMBOL: 1876 { 1877 const Sized_symbol<size>* s = 1878 static_cast<const Sized_symbol<size>*>(this->u_.sym); 1879 val = s->value(); 1880 } 1881 break; 1882 1883 case DYNAMIC_STRING: 1884 val = pool->get_offset(this->u_.str); 1885 break; 1886 1887 case DYNAMIC_CUSTOM: 1888 val = parameters->target().dynamic_tag_custom_value(this->tag_); 1889 break; 1890 1891 default: 1892 val = this->u_.od->address() + this->offset_; 1893 break; 1894 } 1895 1896 elfcpp::Dyn_write<size, big_endian> dw(pov); 1897 dw.put_d_tag(this->tag_); 1898 dw.put_d_val(val); 1899 } 1900 1901 // Output_data_dynamic methods. 1902 1903 // Adjust the output section to set the entry size. 1904 1905 void 1906 Output_data_dynamic::do_adjust_output_section(Output_section* os) 1907 { 1908 if (parameters->target().get_size() == 32) 1909 os->set_entsize(elfcpp::Elf_sizes<32>::dyn_size); 1910 else if (parameters->target().get_size() == 64) 1911 os->set_entsize(elfcpp::Elf_sizes<64>::dyn_size); 1912 else 1913 gold_unreachable(); 1914 } 1915 1916 // Get a dynamic entry offset. 1917 1918 unsigned int 1919 Output_data_dynamic::get_entry_offset(elfcpp::DT tag) const 1920 { 1921 int dyn_size; 1922 1923 if (parameters->target().get_size() == 32) 1924 dyn_size = elfcpp::Elf_sizes<32>::dyn_size; 1925 else if (parameters->target().get_size() == 64) 1926 dyn_size = elfcpp::Elf_sizes<64>::dyn_size; 1927 else 1928 gold_unreachable(); 1929 1930 for (size_t i = 0; i < entries_.size(); ++i) 1931 if (entries_[i].tag() == tag) 1932 return i * dyn_size; 1933 1934 return -1U; 1935 } 1936 1937 // Set the final data size. 1938 1939 void 1940 Output_data_dynamic::set_final_data_size() 1941 { 1942 // Add the terminating entry if it hasn't been added. 1943 // Because of relaxation, we can run this multiple times. 1944 if (this->entries_.empty() || this->entries_.back().tag() != elfcpp::DT_NULL) 1945 { 1946 int extra = parameters->options().spare_dynamic_tags(); 1947 for (int i = 0; i < extra; ++i) 1948 this->add_constant(elfcpp::DT_NULL, 0); 1949 this->add_constant(elfcpp::DT_NULL, 0); 1950 } 1951 1952 int dyn_size; 1953 if (parameters->target().get_size() == 32) 1954 dyn_size = elfcpp::Elf_sizes<32>::dyn_size; 1955 else if (parameters->target().get_size() == 64) 1956 dyn_size = elfcpp::Elf_sizes<64>::dyn_size; 1957 else 1958 gold_unreachable(); 1959 this->set_data_size(this->entries_.size() * dyn_size); 1960 } 1961 1962 // Write out the dynamic entries. 1963 1964 void 1965 Output_data_dynamic::do_write(Output_file* of) 1966 { 1967 switch (parameters->size_and_endianness()) 1968 { 1969 #ifdef HAVE_TARGET_32_LITTLE 1970 case Parameters::TARGET_32_LITTLE: 1971 this->sized_write<32, false>(of); 1972 break; 1973 #endif 1974 #ifdef HAVE_TARGET_32_BIG 1975 case Parameters::TARGET_32_BIG: 1976 this->sized_write<32, true>(of); 1977 break; 1978 #endif 1979 #ifdef HAVE_TARGET_64_LITTLE 1980 case Parameters::TARGET_64_LITTLE: 1981 this->sized_write<64, false>(of); 1982 break; 1983 #endif 1984 #ifdef HAVE_TARGET_64_BIG 1985 case Parameters::TARGET_64_BIG: 1986 this->sized_write<64, true>(of); 1987 break; 1988 #endif 1989 default: 1990 gold_unreachable(); 1991 } 1992 } 1993 1994 template<int size, bool big_endian> 1995 void 1996 Output_data_dynamic::sized_write(Output_file* of) 1997 { 1998 const int dyn_size = elfcpp::Elf_sizes<size>::dyn_size; 1999 2000 const off_t offset = this->offset(); 2001 const off_t oview_size = this->data_size(); 2002 unsigned char* const oview = of->get_output_view(offset, oview_size); 2003 2004 unsigned char* pov = oview; 2005 for (typename Dynamic_entries::const_iterator p = this->entries_.begin(); 2006 p != this->entries_.end(); 2007 ++p) 2008 { 2009 p->write<size, big_endian>(pov, this->pool_); 2010 pov += dyn_size; 2011 } 2012 2013 gold_assert(pov - oview == oview_size); 2014 2015 of->write_output_view(offset, oview_size, oview); 2016 2017 // We no longer need the dynamic entries. 2018 this->entries_.clear(); 2019 } 2020 2021 // Class Output_symtab_xindex. 2022 2023 void 2024 Output_symtab_xindex::do_write(Output_file* of) 2025 { 2026 const off_t offset = this->offset(); 2027 const off_t oview_size = this->data_size(); 2028 unsigned char* const oview = of->get_output_view(offset, oview_size); 2029 2030 memset(oview, 0, oview_size); 2031 2032 if (parameters->target().is_big_endian()) 2033 this->endian_do_write<true>(oview); 2034 else 2035 this->endian_do_write<false>(oview); 2036 2037 of->write_output_view(offset, oview_size, oview); 2038 2039 // We no longer need the data. 2040 this->entries_.clear(); 2041 } 2042 2043 template<bool big_endian> 2044 void 2045 Output_symtab_xindex::endian_do_write(unsigned char* const oview) 2046 { 2047 for (Xindex_entries::const_iterator p = this->entries_.begin(); 2048 p != this->entries_.end(); 2049 ++p) 2050 { 2051 unsigned int symndx = p->first; 2052 gold_assert(static_cast<off_t>(symndx) * 4 < this->data_size()); 2053 elfcpp::Swap<32, big_endian>::writeval(oview + symndx * 4, p->second); 2054 } 2055 } 2056 2057 // Output_fill_debug_info methods. 2058 2059 // Return the minimum size needed for a dummy compilation unit header. 2060 2061 size_t 2062 Output_fill_debug_info::do_minimum_hole_size() const 2063 { 2064 // Compile unit header fields: unit_length, version, debug_abbrev_offset, 2065 // address_size. 2066 const size_t len = 4 + 2 + 4 + 1; 2067 // For type units, add type_signature, type_offset. 2068 if (this->is_debug_types_) 2069 return len + 8 + 4; 2070 return len; 2071 } 2072 2073 // Write a dummy compilation unit header to fill a hole in the 2074 // .debug_info or .debug_types section. 2075 2076 void 2077 Output_fill_debug_info::do_write(Output_file* of, off_t off, size_t len) const 2078 { 2079 gold_debug(DEBUG_INCREMENTAL, "fill_debug_info(%08lx, %08lx)", 2080 static_cast<long>(off), static_cast<long>(len)); 2081 2082 gold_assert(len >= this->do_minimum_hole_size()); 2083 2084 unsigned char* const oview = of->get_output_view(off, len); 2085 unsigned char* pov = oview; 2086 2087 // Write header fields: unit_length, version, debug_abbrev_offset, 2088 // address_size. 2089 if (this->is_big_endian()) 2090 { 2091 elfcpp::Swap_unaligned<32, true>::writeval(pov, len - 4); 2092 elfcpp::Swap_unaligned<16, true>::writeval(pov + 4, this->version); 2093 elfcpp::Swap_unaligned<32, true>::writeval(pov + 6, 0); 2094 } 2095 else 2096 { 2097 elfcpp::Swap_unaligned<32, false>::writeval(pov, len - 4); 2098 elfcpp::Swap_unaligned<16, false>::writeval(pov + 4, this->version); 2099 elfcpp::Swap_unaligned<32, false>::writeval(pov + 6, 0); 2100 } 2101 pov += 4 + 2 + 4; 2102 *pov++ = 4; 2103 2104 // For type units, the additional header fields -- type_signature, 2105 // type_offset -- can be filled with zeroes. 2106 2107 // Fill the remainder of the free space with zeroes. The first 2108 // zero should tell the consumer there are no DIEs to read in this 2109 // compilation unit. 2110 if (pov < oview + len) 2111 memset(pov, 0, oview + len - pov); 2112 2113 of->write_output_view(off, len, oview); 2114 } 2115 2116 // Output_fill_debug_line methods. 2117 2118 // Return the minimum size needed for a dummy line number program header. 2119 2120 size_t 2121 Output_fill_debug_line::do_minimum_hole_size() const 2122 { 2123 // Line number program header fields: unit_length, version, header_length, 2124 // minimum_instruction_length, default_is_stmt, line_base, line_range, 2125 // opcode_base, standard_opcode_lengths[], include_directories, filenames. 2126 const size_t len = 4 + 2 + 4 + this->header_length; 2127 return len; 2128 } 2129 2130 // Write a dummy line number program header to fill a hole in the 2131 // .debug_line section. 2132 2133 void 2134 Output_fill_debug_line::do_write(Output_file* of, off_t off, size_t len) const 2135 { 2136 gold_debug(DEBUG_INCREMENTAL, "fill_debug_line(%08lx, %08lx)", 2137 static_cast<long>(off), static_cast<long>(len)); 2138 2139 gold_assert(len >= this->do_minimum_hole_size()); 2140 2141 unsigned char* const oview = of->get_output_view(off, len); 2142 unsigned char* pov = oview; 2143 2144 // Write header fields: unit_length, version, header_length, 2145 // minimum_instruction_length, default_is_stmt, line_base, line_range, 2146 // opcode_base, standard_opcode_lengths[], include_directories, filenames. 2147 // We set the header_length field to cover the entire hole, so the 2148 // line number program is empty. 2149 if (this->is_big_endian()) 2150 { 2151 elfcpp::Swap_unaligned<32, true>::writeval(pov, len - 4); 2152 elfcpp::Swap_unaligned<16, true>::writeval(pov + 4, this->version); 2153 elfcpp::Swap_unaligned<32, true>::writeval(pov + 6, len - (4 + 2 + 4)); 2154 } 2155 else 2156 { 2157 elfcpp::Swap_unaligned<32, false>::writeval(pov, len - 4); 2158 elfcpp::Swap_unaligned<16, false>::writeval(pov + 4, this->version); 2159 elfcpp::Swap_unaligned<32, false>::writeval(pov + 6, len - (4 + 2 + 4)); 2160 } 2161 pov += 4 + 2 + 4; 2162 *pov++ = 1; // minimum_instruction_length 2163 *pov++ = 0; // default_is_stmt 2164 *pov++ = 0; // line_base 2165 *pov++ = 5; // line_range 2166 *pov++ = 13; // opcode_base 2167 *pov++ = 0; // standard_opcode_lengths[1] 2168 *pov++ = 1; // standard_opcode_lengths[2] 2169 *pov++ = 1; // standard_opcode_lengths[3] 2170 *pov++ = 1; // standard_opcode_lengths[4] 2171 *pov++ = 1; // standard_opcode_lengths[5] 2172 *pov++ = 0; // standard_opcode_lengths[6] 2173 *pov++ = 0; // standard_opcode_lengths[7] 2174 *pov++ = 0; // standard_opcode_lengths[8] 2175 *pov++ = 1; // standard_opcode_lengths[9] 2176 *pov++ = 0; // standard_opcode_lengths[10] 2177 *pov++ = 0; // standard_opcode_lengths[11] 2178 *pov++ = 1; // standard_opcode_lengths[12] 2179 *pov++ = 0; // include_directories (empty) 2180 *pov++ = 0; // filenames (empty) 2181 2182 // Some consumers don't check the header_length field, and simply 2183 // start reading the line number program immediately following the 2184 // header. For those consumers, we fill the remainder of the free 2185 // space with DW_LNS_set_basic_block opcodes. These are effectively 2186 // no-ops: the resulting line table program will not create any rows. 2187 if (pov < oview + len) 2188 memset(pov, elfcpp::DW_LNS_set_basic_block, oview + len - pov); 2189 2190 of->write_output_view(off, len, oview); 2191 } 2192 2193 // Output_section::Input_section methods. 2194 2195 // Return the current data size. For an input section we store the size here. 2196 // For an Output_section_data, we have to ask it for the size. 2197 2198 off_t 2199 Output_section::Input_section::current_data_size() const 2200 { 2201 if (this->is_input_section()) 2202 return this->u1_.data_size; 2203 else 2204 { 2205 this->u2_.posd->pre_finalize_data_size(); 2206 return this->u2_.posd->current_data_size(); 2207 } 2208 } 2209 2210 // Return the data size. For an input section we store the size here. 2211 // For an Output_section_data, we have to ask it for the size. 2212 2213 off_t 2214 Output_section::Input_section::data_size() const 2215 { 2216 if (this->is_input_section()) 2217 return this->u1_.data_size; 2218 else 2219 return this->u2_.posd->data_size(); 2220 } 2221 2222 // Return the object for an input section. 2223 2224 Relobj* 2225 Output_section::Input_section::relobj() const 2226 { 2227 if (this->is_input_section()) 2228 return this->u2_.object; 2229 else if (this->is_merge_section()) 2230 { 2231 gold_assert(this->u2_.pomb->first_relobj() != NULL); 2232 return this->u2_.pomb->first_relobj(); 2233 } 2234 else if (this->is_relaxed_input_section()) 2235 return this->u2_.poris->relobj(); 2236 else 2237 gold_unreachable(); 2238 } 2239 2240 // Return the input section index for an input section. 2241 2242 unsigned int 2243 Output_section::Input_section::shndx() const 2244 { 2245 if (this->is_input_section()) 2246 return this->shndx_; 2247 else if (this->is_merge_section()) 2248 { 2249 gold_assert(this->u2_.pomb->first_relobj() != NULL); 2250 return this->u2_.pomb->first_shndx(); 2251 } 2252 else if (this->is_relaxed_input_section()) 2253 return this->u2_.poris->shndx(); 2254 else 2255 gold_unreachable(); 2256 } 2257 2258 // Set the address and file offset. 2259 2260 void 2261 Output_section::Input_section::set_address_and_file_offset( 2262 uint64_t address, 2263 off_t file_offset, 2264 off_t section_file_offset) 2265 { 2266 if (this->is_input_section()) 2267 this->u2_.object->set_section_offset(this->shndx_, 2268 file_offset - section_file_offset); 2269 else 2270 this->u2_.posd->set_address_and_file_offset(address, file_offset); 2271 } 2272 2273 // Reset the address and file offset. 2274 2275 void 2276 Output_section::Input_section::reset_address_and_file_offset() 2277 { 2278 if (!this->is_input_section()) 2279 this->u2_.posd->reset_address_and_file_offset(); 2280 } 2281 2282 // Finalize the data size. 2283 2284 void 2285 Output_section::Input_section::finalize_data_size() 2286 { 2287 if (!this->is_input_section()) 2288 this->u2_.posd->finalize_data_size(); 2289 } 2290 2291 // Try to turn an input offset into an output offset. We want to 2292 // return the output offset relative to the start of this 2293 // Input_section in the output section. 2294 2295 inline bool 2296 Output_section::Input_section::output_offset( 2297 const Relobj* object, 2298 unsigned int shndx, 2299 section_offset_type offset, 2300 section_offset_type* poutput) const 2301 { 2302 if (!this->is_input_section()) 2303 return this->u2_.posd->output_offset(object, shndx, offset, poutput); 2304 else 2305 { 2306 if (this->shndx_ != shndx || this->u2_.object != object) 2307 return false; 2308 *poutput = offset; 2309 return true; 2310 } 2311 } 2312 2313 // Write out the data. We don't have to do anything for an input 2314 // section--they are handled via Object::relocate--but this is where 2315 // we write out the data for an Output_section_data. 2316 2317 void 2318 Output_section::Input_section::write(Output_file* of) 2319 { 2320 if (!this->is_input_section()) 2321 this->u2_.posd->write(of); 2322 } 2323 2324 // Write the data to a buffer. As for write(), we don't have to do 2325 // anything for an input section. 2326 2327 void 2328 Output_section::Input_section::write_to_buffer(unsigned char* buffer) 2329 { 2330 if (!this->is_input_section()) 2331 this->u2_.posd->write_to_buffer(buffer); 2332 } 2333 2334 // Print to a map file. 2335 2336 void 2337 Output_section::Input_section::print_to_mapfile(Mapfile* mapfile) const 2338 { 2339 switch (this->shndx_) 2340 { 2341 case OUTPUT_SECTION_CODE: 2342 case MERGE_DATA_SECTION_CODE: 2343 case MERGE_STRING_SECTION_CODE: 2344 this->u2_.posd->print_to_mapfile(mapfile); 2345 break; 2346 2347 case RELAXED_INPUT_SECTION_CODE: 2348 { 2349 Output_relaxed_input_section* relaxed_section = 2350 this->relaxed_input_section(); 2351 mapfile->print_input_section(relaxed_section->relobj(), 2352 relaxed_section->shndx()); 2353 } 2354 break; 2355 default: 2356 mapfile->print_input_section(this->u2_.object, this->shndx_); 2357 break; 2358 } 2359 } 2360 2361 // Output_section methods. 2362 2363 // Construct an Output_section. NAME will point into a Stringpool. 2364 2365 Output_section::Output_section(const char* name, elfcpp::Elf_Word type, 2366 elfcpp::Elf_Xword flags) 2367 : name_(name), 2368 addralign_(0), 2369 entsize_(0), 2370 load_address_(0), 2371 link_section_(NULL), 2372 link_(0), 2373 info_section_(NULL), 2374 info_symndx_(NULL), 2375 info_(0), 2376 type_(type), 2377 flags_(flags), 2378 order_(ORDER_INVALID), 2379 out_shndx_(-1U), 2380 symtab_index_(0), 2381 dynsym_index_(0), 2382 input_sections_(), 2383 first_input_offset_(0), 2384 fills_(), 2385 postprocessing_buffer_(NULL), 2386 needs_symtab_index_(false), 2387 needs_dynsym_index_(false), 2388 should_link_to_symtab_(false), 2389 should_link_to_dynsym_(false), 2390 after_input_sections_(false), 2391 requires_postprocessing_(false), 2392 found_in_sections_clause_(false), 2393 has_load_address_(false), 2394 info_uses_section_index_(false), 2395 input_section_order_specified_(false), 2396 may_sort_attached_input_sections_(false), 2397 must_sort_attached_input_sections_(false), 2398 attached_input_sections_are_sorted_(false), 2399 is_relro_(false), 2400 is_small_section_(false), 2401 is_large_section_(false), 2402 generate_code_fills_at_write_(false), 2403 is_entsize_zero_(false), 2404 section_offsets_need_adjustment_(false), 2405 is_noload_(false), 2406 always_keeps_input_sections_(false), 2407 has_fixed_layout_(false), 2408 is_patch_space_allowed_(false), 2409 is_unique_segment_(false), 2410 tls_offset_(0), 2411 extra_segment_flags_(0), 2412 segment_alignment_(0), 2413 checkpoint_(NULL), 2414 lookup_maps_(new Output_section_lookup_maps), 2415 free_list_(), 2416 free_space_fill_(NULL), 2417 patch_space_(0) 2418 { 2419 // An unallocated section has no address. Forcing this means that 2420 // we don't need special treatment for symbols defined in debug 2421 // sections. 2422 if ((flags & elfcpp::SHF_ALLOC) == 0) 2423 this->set_address(0); 2424 } 2425 2426 Output_section::~Output_section() 2427 { 2428 delete this->checkpoint_; 2429 } 2430 2431 // Set the entry size. 2432 2433 void 2434 Output_section::set_entsize(uint64_t v) 2435 { 2436 if (this->is_entsize_zero_) 2437 ; 2438 else if (this->entsize_ == 0) 2439 this->entsize_ = v; 2440 else if (this->entsize_ != v) 2441 { 2442 this->entsize_ = 0; 2443 this->is_entsize_zero_ = 1; 2444 } 2445 } 2446 2447 // Add the input section SHNDX, with header SHDR, named SECNAME, in 2448 // OBJECT, to the Output_section. RELOC_SHNDX is the index of a 2449 // relocation section which applies to this section, or 0 if none, or 2450 // -1U if more than one. Return the offset of the input section 2451 // within the output section. Return -1 if the input section will 2452 // receive special handling. In the normal case we don't always keep 2453 // track of input sections for an Output_section. Instead, each 2454 // Object keeps track of the Output_section for each of its input 2455 // sections. However, if HAVE_SECTIONS_SCRIPT is true, we do keep 2456 // track of input sections here; this is used when SECTIONS appears in 2457 // a linker script. 2458 2459 template<int size, bool big_endian> 2460 off_t 2461 Output_section::add_input_section(Layout* layout, 2462 Sized_relobj_file<size, big_endian>* object, 2463 unsigned int shndx, 2464 const char* secname, 2465 const elfcpp::Shdr<size, big_endian>& shdr, 2466 unsigned int reloc_shndx, 2467 bool have_sections_script) 2468 { 2469 elfcpp::Elf_Xword addralign = shdr.get_sh_addralign(); 2470 if ((addralign & (addralign - 1)) != 0) 2471 { 2472 object->error(_("invalid alignment %lu for section \"%s\""), 2473 static_cast<unsigned long>(addralign), secname); 2474 addralign = 1; 2475 } 2476 2477 if (addralign > this->addralign_) 2478 this->addralign_ = addralign; 2479 2480 typename elfcpp::Elf_types<size>::Elf_WXword sh_flags = shdr.get_sh_flags(); 2481 uint64_t entsize = shdr.get_sh_entsize(); 2482 2483 // .debug_str is a mergeable string section, but is not always so 2484 // marked by compilers. Mark manually here so we can optimize. 2485 if (strcmp(secname, ".debug_str") == 0) 2486 { 2487 sh_flags |= (elfcpp::SHF_MERGE | elfcpp::SHF_STRINGS); 2488 entsize = 1; 2489 } 2490 2491 this->update_flags_for_input_section(sh_flags); 2492 this->set_entsize(entsize); 2493 2494 // If this is a SHF_MERGE section, we pass all the input sections to 2495 // a Output_data_merge. We don't try to handle relocations for such 2496 // a section. We don't try to handle empty merge sections--they 2497 // mess up the mappings, and are useless anyhow. 2498 // FIXME: Need to handle merge sections during incremental update. 2499 if ((sh_flags & elfcpp::SHF_MERGE) != 0 2500 && reloc_shndx == 0 2501 && shdr.get_sh_size() > 0 2502 && !parameters->incremental()) 2503 { 2504 // Keep information about merged input sections for rebuilding fast 2505 // lookup maps if we have sections-script or we do relaxation. 2506 bool keeps_input_sections = (this->always_keeps_input_sections_ 2507 || have_sections_script 2508 || parameters->target().may_relax()); 2509 2510 if (this->add_merge_input_section(object, shndx, sh_flags, entsize, 2511 addralign, keeps_input_sections)) 2512 { 2513 // Tell the relocation routines that they need to call the 2514 // output_offset method to determine the final address. 2515 return -1; 2516 } 2517 } 2518 2519 section_size_type input_section_size = shdr.get_sh_size(); 2520 section_size_type uncompressed_size; 2521 if (object->section_is_compressed(shndx, &uncompressed_size)) 2522 input_section_size = uncompressed_size; 2523 2524 off_t offset_in_section; 2525 2526 if (this->has_fixed_layout()) 2527 { 2528 // For incremental updates, find a chunk of unused space in the section. 2529 offset_in_section = this->free_list_.allocate(input_section_size, 2530 addralign, 0); 2531 if (offset_in_section == -1) 2532 gold_fallback(_("out of patch space in section %s; " 2533 "relink with --incremental-full"), 2534 this->name()); 2535 return offset_in_section; 2536 } 2537 2538 offset_in_section = this->current_data_size_for_child(); 2539 off_t aligned_offset_in_section = align_address(offset_in_section, 2540 addralign); 2541 this->set_current_data_size_for_child(aligned_offset_in_section 2542 + input_section_size); 2543 2544 // Determine if we want to delay code-fill generation until the output 2545 // section is written. When the target is relaxing, we want to delay fill 2546 // generating to avoid adjusting them during relaxation. Also, if we are 2547 // sorting input sections we must delay fill generation. 2548 if (!this->generate_code_fills_at_write_ 2549 && !have_sections_script 2550 && (sh_flags & elfcpp::SHF_EXECINSTR) != 0 2551 && parameters->target().has_code_fill() 2552 && (parameters->target().may_relax() 2553 || layout->is_section_ordering_specified())) 2554 { 2555 gold_assert(this->fills_.empty()); 2556 this->generate_code_fills_at_write_ = true; 2557 } 2558 2559 if (aligned_offset_in_section > offset_in_section 2560 && !this->generate_code_fills_at_write_ 2561 && !have_sections_script 2562 && (sh_flags & elfcpp::SHF_EXECINSTR) != 0 2563 && parameters->target().has_code_fill()) 2564 { 2565 // We need to add some fill data. Using fill_list_ when 2566 // possible is an optimization, since we will often have fill 2567 // sections without input sections. 2568 off_t fill_len = aligned_offset_in_section - offset_in_section; 2569 if (this->input_sections_.empty()) 2570 this->fills_.push_back(Fill(offset_in_section, fill_len)); 2571 else 2572 { 2573 std::string fill_data(parameters->target().code_fill(fill_len)); 2574 Output_data_const* odc = new Output_data_const(fill_data, 1); 2575 this->input_sections_.push_back(Input_section(odc)); 2576 } 2577 } 2578 2579 // We need to keep track of this section if we are already keeping 2580 // track of sections, or if we are relaxing. Also, if this is a 2581 // section which requires sorting, or which may require sorting in 2582 // the future, we keep track of the sections. If the 2583 // --section-ordering-file option is used to specify the order of 2584 // sections, we need to keep track of sections. 2585 if (this->always_keeps_input_sections_ 2586 || have_sections_script 2587 || !this->input_sections_.empty() 2588 || this->may_sort_attached_input_sections() 2589 || this->must_sort_attached_input_sections() 2590 || parameters->options().user_set_Map() 2591 || parameters->target().may_relax() 2592 || layout->is_section_ordering_specified()) 2593 { 2594 Input_section isecn(object, shndx, input_section_size, addralign); 2595 /* If section ordering is requested by specifying a ordering file, 2596 using --section-ordering-file, match the section name with 2597 a pattern. */ 2598 if (parameters->options().section_ordering_file()) 2599 { 2600 unsigned int section_order_index = 2601 layout->find_section_order_index(std::string(secname)); 2602 if (section_order_index != 0) 2603 { 2604 isecn.set_section_order_index(section_order_index); 2605 this->set_input_section_order_specified(); 2606 } 2607 } 2608 this->input_sections_.push_back(isecn); 2609 } 2610 2611 return aligned_offset_in_section; 2612 } 2613 2614 // Add arbitrary data to an output section. 2615 2616 void 2617 Output_section::add_output_section_data(Output_section_data* posd) 2618 { 2619 Input_section inp(posd); 2620 this->add_output_section_data(&inp); 2621 2622 if (posd->is_data_size_valid()) 2623 { 2624 off_t offset_in_section; 2625 if (this->has_fixed_layout()) 2626 { 2627 // For incremental updates, find a chunk of unused space. 2628 offset_in_section = this->free_list_.allocate(posd->data_size(), 2629 posd->addralign(), 0); 2630 if (offset_in_section == -1) 2631 gold_fallback(_("out of patch space in section %s; " 2632 "relink with --incremental-full"), 2633 this->name()); 2634 // Finalize the address and offset now. 2635 uint64_t addr = this->address(); 2636 off_t offset = this->offset(); 2637 posd->set_address_and_file_offset(addr + offset_in_section, 2638 offset + offset_in_section); 2639 } 2640 else 2641 { 2642 offset_in_section = this->current_data_size_for_child(); 2643 off_t aligned_offset_in_section = align_address(offset_in_section, 2644 posd->addralign()); 2645 this->set_current_data_size_for_child(aligned_offset_in_section 2646 + posd->data_size()); 2647 } 2648 } 2649 else if (this->has_fixed_layout()) 2650 { 2651 // For incremental updates, arrange for the data to have a fixed layout. 2652 // This will mean that additions to the data must be allocated from 2653 // free space within the containing output section. 2654 uint64_t addr = this->address(); 2655 posd->set_address(addr); 2656 posd->set_file_offset(0); 2657 // FIXME: This should eventually be unreachable. 2658 // gold_unreachable(); 2659 } 2660 } 2661 2662 // Add a relaxed input section. 2663 2664 void 2665 Output_section::add_relaxed_input_section(Layout* layout, 2666 Output_relaxed_input_section* poris, 2667 const std::string& name) 2668 { 2669 Input_section inp(poris); 2670 2671 // If the --section-ordering-file option is used to specify the order of 2672 // sections, we need to keep track of sections. 2673 if (layout->is_section_ordering_specified()) 2674 { 2675 unsigned int section_order_index = 2676 layout->find_section_order_index(name); 2677 if (section_order_index != 0) 2678 { 2679 inp.set_section_order_index(section_order_index); 2680 this->set_input_section_order_specified(); 2681 } 2682 } 2683 2684 this->add_output_section_data(&inp); 2685 if (this->lookup_maps_->is_valid()) 2686 this->lookup_maps_->add_relaxed_input_section(poris->relobj(), 2687 poris->shndx(), poris); 2688 2689 // For a relaxed section, we use the current data size. Linker scripts 2690 // get all the input sections, including relaxed one from an output 2691 // section and add them back to the same output section to compute the 2692 // output section size. If we do not account for sizes of relaxed input 2693 // sections, an output section would be incorrectly sized. 2694 off_t offset_in_section = this->current_data_size_for_child(); 2695 off_t aligned_offset_in_section = align_address(offset_in_section, 2696 poris->addralign()); 2697 this->set_current_data_size_for_child(aligned_offset_in_section 2698 + poris->current_data_size()); 2699 } 2700 2701 // Add arbitrary data to an output section by Input_section. 2702 2703 void 2704 Output_section::add_output_section_data(Input_section* inp) 2705 { 2706 if (this->input_sections_.empty()) 2707 this->first_input_offset_ = this->current_data_size_for_child(); 2708 2709 this->input_sections_.push_back(*inp); 2710 2711 uint64_t addralign = inp->addralign(); 2712 if (addralign > this->addralign_) 2713 this->addralign_ = addralign; 2714 2715 inp->set_output_section(this); 2716 } 2717 2718 // Add a merge section to an output section. 2719 2720 void 2721 Output_section::add_output_merge_section(Output_section_data* posd, 2722 bool is_string, uint64_t entsize) 2723 { 2724 Input_section inp(posd, is_string, entsize); 2725 this->add_output_section_data(&inp); 2726 } 2727 2728 // Add an input section to a SHF_MERGE section. 2729 2730 bool 2731 Output_section::add_merge_input_section(Relobj* object, unsigned int shndx, 2732 uint64_t flags, uint64_t entsize, 2733 uint64_t addralign, 2734 bool keeps_input_sections) 2735 { 2736 // We cannot merge sections with entsize == 0. 2737 if (entsize == 0) 2738 return false; 2739 2740 bool is_string = (flags & elfcpp::SHF_STRINGS) != 0; 2741 2742 // We cannot restore merged input section states. 2743 gold_assert(this->checkpoint_ == NULL); 2744 2745 // Look up merge sections by required properties. 2746 // Currently, we only invalidate the lookup maps in script processing 2747 // and relaxation. We should not have done either when we reach here. 2748 // So we assume that the lookup maps are valid to simply code. 2749 gold_assert(this->lookup_maps_->is_valid()); 2750 Merge_section_properties msp(is_string, entsize, addralign); 2751 Output_merge_base* pomb = this->lookup_maps_->find_merge_section(msp); 2752 bool is_new = false; 2753 if (pomb != NULL) 2754 { 2755 gold_assert(pomb->is_string() == is_string 2756 && pomb->entsize() == entsize 2757 && pomb->addralign() == addralign); 2758 } 2759 else 2760 { 2761 // Create a new Output_merge_data or Output_merge_string_data. 2762 if (!is_string) 2763 pomb = new Output_merge_data(entsize, addralign); 2764 else 2765 { 2766 switch (entsize) 2767 { 2768 case 1: 2769 pomb = new Output_merge_string<char>(addralign); 2770 break; 2771 case 2: 2772 pomb = new Output_merge_string<uint16_t>(addralign); 2773 break; 2774 case 4: 2775 pomb = new Output_merge_string<uint32_t>(addralign); 2776 break; 2777 default: 2778 return false; 2779 } 2780 } 2781 // If we need to do script processing or relaxation, we need to keep 2782 // the original input sections to rebuild the fast lookup maps. 2783 if (keeps_input_sections) 2784 pomb->set_keeps_input_sections(); 2785 is_new = true; 2786 } 2787 2788 if (pomb->add_input_section(object, shndx)) 2789 { 2790 // Add new merge section to this output section and link merge 2791 // section properties to new merge section in map. 2792 if (is_new) 2793 { 2794 this->add_output_merge_section(pomb, is_string, entsize); 2795 this->lookup_maps_->add_merge_section(msp, pomb); 2796 } 2797 2798 return true; 2799 } 2800 else 2801 { 2802 // If add_input_section failed, delete new merge section to avoid 2803 // exporting empty merge sections in Output_section::get_input_section. 2804 if (is_new) 2805 delete pomb; 2806 return false; 2807 } 2808 } 2809 2810 // Build a relaxation map to speed up relaxation of existing input sections. 2811 // Look up to the first LIMIT elements in INPUT_SECTIONS. 2812 2813 void 2814 Output_section::build_relaxation_map( 2815 const Input_section_list& input_sections, 2816 size_t limit, 2817 Relaxation_map* relaxation_map) const 2818 { 2819 for (size_t i = 0; i < limit; ++i) 2820 { 2821 const Input_section& is(input_sections[i]); 2822 if (is.is_input_section() || is.is_relaxed_input_section()) 2823 { 2824 Section_id sid(is.relobj(), is.shndx()); 2825 (*relaxation_map)[sid] = i; 2826 } 2827 } 2828 } 2829 2830 // Convert regular input sections in INPUT_SECTIONS into relaxed input 2831 // sections in RELAXED_SECTIONS. MAP is a prebuilt map from section id 2832 // indices of INPUT_SECTIONS. 2833 2834 void 2835 Output_section::convert_input_sections_in_list_to_relaxed_sections( 2836 const std::vector<Output_relaxed_input_section*>& relaxed_sections, 2837 const Relaxation_map& map, 2838 Input_section_list* input_sections) 2839 { 2840 for (size_t i = 0; i < relaxed_sections.size(); ++i) 2841 { 2842 Output_relaxed_input_section* poris = relaxed_sections[i]; 2843 Section_id sid(poris->relobj(), poris->shndx()); 2844 Relaxation_map::const_iterator p = map.find(sid); 2845 gold_assert(p != map.end()); 2846 gold_assert((*input_sections)[p->second].is_input_section()); 2847 2848 // Remember section order index of original input section 2849 // if it is set. Copy it to the relaxed input section. 2850 unsigned int soi = 2851 (*input_sections)[p->second].section_order_index(); 2852 (*input_sections)[p->second] = Input_section(poris); 2853 (*input_sections)[p->second].set_section_order_index(soi); 2854 } 2855 } 2856 2857 // Convert regular input sections into relaxed input sections. RELAXED_SECTIONS 2858 // is a vector of pointers to Output_relaxed_input_section or its derived 2859 // classes. The relaxed sections must correspond to existing input sections. 2860 2861 void 2862 Output_section::convert_input_sections_to_relaxed_sections( 2863 const std::vector<Output_relaxed_input_section*>& relaxed_sections) 2864 { 2865 gold_assert(parameters->target().may_relax()); 2866 2867 // We want to make sure that restore_states does not undo the effect of 2868 // this. If there is no checkpoint active, just search the current 2869 // input section list and replace the sections there. If there is 2870 // a checkpoint, also replace the sections there. 2871 2872 // By default, we look at the whole list. 2873 size_t limit = this->input_sections_.size(); 2874 2875 if (this->checkpoint_ != NULL) 2876 { 2877 // Replace input sections with relaxed input section in the saved 2878 // copy of the input section list. 2879 if (this->checkpoint_->input_sections_saved()) 2880 { 2881 Relaxation_map map; 2882 this->build_relaxation_map( 2883 *(this->checkpoint_->input_sections()), 2884 this->checkpoint_->input_sections()->size(), 2885 &map); 2886 this->convert_input_sections_in_list_to_relaxed_sections( 2887 relaxed_sections, 2888 map, 2889 this->checkpoint_->input_sections()); 2890 } 2891 else 2892 { 2893 // We have not copied the input section list yet. Instead, just 2894 // look at the portion that would be saved. 2895 limit = this->checkpoint_->input_sections_size(); 2896 } 2897 } 2898 2899 // Convert input sections in input_section_list. 2900 Relaxation_map map; 2901 this->build_relaxation_map(this->input_sections_, limit, &map); 2902 this->convert_input_sections_in_list_to_relaxed_sections( 2903 relaxed_sections, 2904 map, 2905 &this->input_sections_); 2906 2907 // Update fast look-up map. 2908 if (this->lookup_maps_->is_valid()) 2909 for (size_t i = 0; i < relaxed_sections.size(); ++i) 2910 { 2911 Output_relaxed_input_section* poris = relaxed_sections[i]; 2912 this->lookup_maps_->add_relaxed_input_section(poris->relobj(), 2913 poris->shndx(), poris); 2914 } 2915 } 2916 2917 // Update the output section flags based on input section flags. 2918 2919 void 2920 Output_section::update_flags_for_input_section(elfcpp::Elf_Xword flags) 2921 { 2922 // If we created the section with SHF_ALLOC clear, we set the 2923 // address. If we are now setting the SHF_ALLOC flag, we need to 2924 // undo that. 2925 if ((this->flags_ & elfcpp::SHF_ALLOC) == 0 2926 && (flags & elfcpp::SHF_ALLOC) != 0) 2927 this->mark_address_invalid(); 2928 2929 this->flags_ |= (flags 2930 & (elfcpp::SHF_WRITE 2931 | elfcpp::SHF_ALLOC 2932 | elfcpp::SHF_EXECINSTR)); 2933 2934 if ((flags & elfcpp::SHF_MERGE) == 0) 2935 this->flags_ &=~ elfcpp::SHF_MERGE; 2936 else 2937 { 2938 if (this->current_data_size_for_child() == 0) 2939 this->flags_ |= elfcpp::SHF_MERGE; 2940 } 2941 2942 if ((flags & elfcpp::SHF_STRINGS) == 0) 2943 this->flags_ &=~ elfcpp::SHF_STRINGS; 2944 else 2945 { 2946 if (this->current_data_size_for_child() == 0) 2947 this->flags_ |= elfcpp::SHF_STRINGS; 2948 } 2949 } 2950 2951 // Find the merge section into which an input section with index SHNDX in 2952 // OBJECT has been added. Return NULL if none found. 2953 2954 const Output_section_data* 2955 Output_section::find_merge_section(const Relobj* object, 2956 unsigned int shndx) const 2957 { 2958 return object->find_merge_section(shndx); 2959 } 2960 2961 // Build the lookup maps for relaxed sections. This needs 2962 // to be declared as a const method so that it is callable with a const 2963 // Output_section pointer. The method only updates states of the maps. 2964 2965 void 2966 Output_section::build_lookup_maps() const 2967 { 2968 this->lookup_maps_->clear(); 2969 for (Input_section_list::const_iterator p = this->input_sections_.begin(); 2970 p != this->input_sections_.end(); 2971 ++p) 2972 { 2973 if (p->is_relaxed_input_section()) 2974 { 2975 Output_relaxed_input_section* poris = p->relaxed_input_section(); 2976 this->lookup_maps_->add_relaxed_input_section(poris->relobj(), 2977 poris->shndx(), poris); 2978 } 2979 } 2980 } 2981 2982 // Find an relaxed input section corresponding to an input section 2983 // in OBJECT with index SHNDX. 2984 2985 const Output_relaxed_input_section* 2986 Output_section::find_relaxed_input_section(const Relobj* object, 2987 unsigned int shndx) const 2988 { 2989 if (!this->lookup_maps_->is_valid()) 2990 this->build_lookup_maps(); 2991 return this->lookup_maps_->find_relaxed_input_section(object, shndx); 2992 } 2993 2994 // Given an address OFFSET relative to the start of input section 2995 // SHNDX in OBJECT, return whether this address is being included in 2996 // the final link. This should only be called if SHNDX in OBJECT has 2997 // a special mapping. 2998 2999 bool 3000 Output_section::is_input_address_mapped(const Relobj* object, 3001 unsigned int shndx, 3002 off_t offset) const 3003 { 3004 // Look at the Output_section_data_maps first. 3005 const Output_section_data* posd = this->find_merge_section(object, shndx); 3006 if (posd == NULL) 3007 posd = this->find_relaxed_input_section(object, shndx); 3008 3009 if (posd != NULL) 3010 { 3011 section_offset_type output_offset; 3012 bool found = posd->output_offset(object, shndx, offset, &output_offset); 3013 // By default we assume that the address is mapped. See comment at the 3014 // end. 3015 if (!found) 3016 return true; 3017 return output_offset != -1; 3018 } 3019 3020 // Fall back to the slow look-up. 3021 for (Input_section_list::const_iterator p = this->input_sections_.begin(); 3022 p != this->input_sections_.end(); 3023 ++p) 3024 { 3025 section_offset_type output_offset; 3026 if (p->output_offset(object, shndx, offset, &output_offset)) 3027 return output_offset != -1; 3028 } 3029 3030 // By default we assume that the address is mapped. This should 3031 // only be called after we have passed all sections to Layout. At 3032 // that point we should know what we are discarding. 3033 return true; 3034 } 3035 3036 // Given an address OFFSET relative to the start of input section 3037 // SHNDX in object OBJECT, return the output offset relative to the 3038 // start of the input section in the output section. This should only 3039 // be called if SHNDX in OBJECT has a special mapping. 3040 3041 section_offset_type 3042 Output_section::output_offset(const Relobj* object, unsigned int shndx, 3043 section_offset_type offset) const 3044 { 3045 // This can only be called meaningfully when we know the data size 3046 // of this. 3047 gold_assert(this->is_data_size_valid()); 3048 3049 // Look at the Output_section_data_maps first. 3050 const Output_section_data* posd = this->find_merge_section(object, shndx); 3051 if (posd == NULL) 3052 posd = this->find_relaxed_input_section(object, shndx); 3053 if (posd != NULL) 3054 { 3055 section_offset_type output_offset; 3056 bool found = posd->output_offset(object, shndx, offset, &output_offset); 3057 gold_assert(found); 3058 return output_offset; 3059 } 3060 3061 // Fall back to the slow look-up. 3062 for (Input_section_list::const_iterator p = this->input_sections_.begin(); 3063 p != this->input_sections_.end(); 3064 ++p) 3065 { 3066 section_offset_type output_offset; 3067 if (p->output_offset(object, shndx, offset, &output_offset)) 3068 return output_offset; 3069 } 3070 gold_unreachable(); 3071 } 3072 3073 // Return the output virtual address of OFFSET relative to the start 3074 // of input section SHNDX in object OBJECT. 3075 3076 uint64_t 3077 Output_section::output_address(const Relobj* object, unsigned int shndx, 3078 off_t offset) const 3079 { 3080 uint64_t addr = this->address() + this->first_input_offset_; 3081 3082 // Look at the Output_section_data_maps first. 3083 const Output_section_data* posd = this->find_merge_section(object, shndx); 3084 if (posd == NULL) 3085 posd = this->find_relaxed_input_section(object, shndx); 3086 if (posd != NULL && posd->is_address_valid()) 3087 { 3088 section_offset_type output_offset; 3089 bool found = posd->output_offset(object, shndx, offset, &output_offset); 3090 gold_assert(found); 3091 return posd->address() + output_offset; 3092 } 3093 3094 // Fall back to the slow look-up. 3095 for (Input_section_list::const_iterator p = this->input_sections_.begin(); 3096 p != this->input_sections_.end(); 3097 ++p) 3098 { 3099 addr = align_address(addr, p->addralign()); 3100 section_offset_type output_offset; 3101 if (p->output_offset(object, shndx, offset, &output_offset)) 3102 { 3103 if (output_offset == -1) 3104 return -1ULL; 3105 return addr + output_offset; 3106 } 3107 addr += p->data_size(); 3108 } 3109 3110 // If we get here, it means that we don't know the mapping for this 3111 // input section. This might happen in principle if 3112 // add_input_section were called before add_output_section_data. 3113 // But it should never actually happen. 3114 3115 gold_unreachable(); 3116 } 3117 3118 // Find the output address of the start of the merged section for 3119 // input section SHNDX in object OBJECT. 3120 3121 bool 3122 Output_section::find_starting_output_address(const Relobj* object, 3123 unsigned int shndx, 3124 uint64_t* paddr) const 3125 { 3126 const Output_section_data* data = this->find_merge_section(object, shndx); 3127 if (data == NULL) 3128 return false; 3129 3130 // FIXME: This becomes a bottle-neck if we have many relaxed sections. 3131 // Looking up the merge section map does not always work as we sometimes 3132 // find a merge section without its address set. 3133 uint64_t addr = this->address() + this->first_input_offset_; 3134 for (Input_section_list::const_iterator p = this->input_sections_.begin(); 3135 p != this->input_sections_.end(); 3136 ++p) 3137 { 3138 addr = align_address(addr, p->addralign()); 3139 3140 // It would be nice if we could use the existing output_offset 3141 // method to get the output offset of input offset 0. 3142 // Unfortunately we don't know for sure that input offset 0 is 3143 // mapped at all. 3144 if (!p->is_input_section() && p->output_section_data() == data) 3145 { 3146 *paddr = addr; 3147 return true; 3148 } 3149 3150 addr += p->data_size(); 3151 } 3152 3153 // We couldn't find a merge output section for this input section. 3154 return false; 3155 } 3156 3157 // Update the data size of an Output_section. 3158 3159 void 3160 Output_section::update_data_size() 3161 { 3162 if (this->input_sections_.empty()) 3163 return; 3164 3165 if (this->must_sort_attached_input_sections() 3166 || this->input_section_order_specified()) 3167 this->sort_attached_input_sections(); 3168 3169 off_t off = this->first_input_offset_; 3170 for (Input_section_list::iterator p = this->input_sections_.begin(); 3171 p != this->input_sections_.end(); 3172 ++p) 3173 { 3174 off = align_address(off, p->addralign()); 3175 off += p->current_data_size(); 3176 } 3177 3178 this->set_current_data_size_for_child(off); 3179 } 3180 3181 // Set the data size of an Output_section. This is where we handle 3182 // setting the addresses of any Output_section_data objects. 3183 3184 void 3185 Output_section::set_final_data_size() 3186 { 3187 off_t data_size; 3188 3189 if (this->input_sections_.empty()) 3190 data_size = this->current_data_size_for_child(); 3191 else 3192 { 3193 if (this->must_sort_attached_input_sections() 3194 || this->input_section_order_specified()) 3195 this->sort_attached_input_sections(); 3196 3197 uint64_t address = this->address(); 3198 off_t startoff = this->offset(); 3199 off_t off = startoff + this->first_input_offset_; 3200 for (Input_section_list::iterator p = this->input_sections_.begin(); 3201 p != this->input_sections_.end(); 3202 ++p) 3203 { 3204 off = align_address(off, p->addralign()); 3205 p->set_address_and_file_offset(address + (off - startoff), off, 3206 startoff); 3207 off += p->data_size(); 3208 } 3209 data_size = off - startoff; 3210 } 3211 3212 // For full incremental links, we want to allocate some patch space 3213 // in most sections for subsequent incremental updates. 3214 if (this->is_patch_space_allowed_ && parameters->incremental_full()) 3215 { 3216 double pct = parameters->options().incremental_patch(); 3217 size_t extra = static_cast<size_t>(data_size * pct); 3218 if (this->free_space_fill_ != NULL 3219 && this->free_space_fill_->minimum_hole_size() > extra) 3220 extra = this->free_space_fill_->minimum_hole_size(); 3221 off_t new_size = align_address(data_size + extra, this->addralign()); 3222 this->patch_space_ = new_size - data_size; 3223 gold_debug(DEBUG_INCREMENTAL, 3224 "set_final_data_size: %08lx + %08lx: section %s", 3225 static_cast<long>(data_size), 3226 static_cast<long>(this->patch_space_), 3227 this->name()); 3228 data_size = new_size; 3229 } 3230 3231 this->set_data_size(data_size); 3232 } 3233 3234 // Reset the address and file offset. 3235 3236 void 3237 Output_section::do_reset_address_and_file_offset() 3238 { 3239 // An unallocated section has no address. Forcing this means that 3240 // we don't need special treatment for symbols defined in debug 3241 // sections. We do the same in the constructor. This does not 3242 // apply to NOLOAD sections though. 3243 if (((this->flags_ & elfcpp::SHF_ALLOC) == 0) && !this->is_noload_) 3244 this->set_address(0); 3245 3246 for (Input_section_list::iterator p = this->input_sections_.begin(); 3247 p != this->input_sections_.end(); 3248 ++p) 3249 p->reset_address_and_file_offset(); 3250 3251 // Remove any patch space that was added in set_final_data_size. 3252 if (this->patch_space_ > 0) 3253 { 3254 this->set_current_data_size_for_child(this->current_data_size_for_child() 3255 - this->patch_space_); 3256 this->patch_space_ = 0; 3257 } 3258 } 3259 3260 // Return true if address and file offset have the values after reset. 3261 3262 bool 3263 Output_section::do_address_and_file_offset_have_reset_values() const 3264 { 3265 if (this->is_offset_valid()) 3266 return false; 3267 3268 // An unallocated section has address 0 after its construction or a reset. 3269 if ((this->flags_ & elfcpp::SHF_ALLOC) == 0) 3270 return this->is_address_valid() && this->address() == 0; 3271 else 3272 return !this->is_address_valid(); 3273 } 3274 3275 // Set the TLS offset. Called only for SHT_TLS sections. 3276 3277 void 3278 Output_section::do_set_tls_offset(uint64_t tls_base) 3279 { 3280 this->tls_offset_ = this->address() - tls_base; 3281 } 3282 3283 // In a few cases we need to sort the input sections attached to an 3284 // output section. This is used to implement the type of constructor 3285 // priority ordering implemented by the GNU linker, in which the 3286 // priority becomes part of the section name and the sections are 3287 // sorted by name. We only do this for an output section if we see an 3288 // attached input section matching ".ctors.*", ".dtors.*", 3289 // ".init_array.*" or ".fini_array.*". 3290 3291 class Output_section::Input_section_sort_entry 3292 { 3293 public: 3294 Input_section_sort_entry() 3295 : input_section_(), index_(-1U), section_name_() 3296 { } 3297 3298 Input_section_sort_entry(const Input_section& input_section, 3299 unsigned int index, 3300 bool must_sort_attached_input_sections, 3301 const char* output_section_name) 3302 : input_section_(input_section), index_(index), section_name_() 3303 { 3304 if ((input_section.is_input_section() 3305 || input_section.is_relaxed_input_section()) 3306 && must_sort_attached_input_sections) 3307 { 3308 // This is only called single-threaded from Layout::finalize, 3309 // so it is OK to lock. Unfortunately we have no way to pass 3310 // in a Task token. 3311 const Task* dummy_task = reinterpret_cast<const Task*>(-1); 3312 Object* obj = (input_section.is_input_section() 3313 ? input_section.relobj() 3314 : input_section.relaxed_input_section()->relobj()); 3315 Task_lock_obj<Object> tl(dummy_task, obj); 3316 3317 // This is a slow operation, which should be cached in 3318 // Layout::layout if this becomes a speed problem. 3319 this->section_name_ = obj->section_name(input_section.shndx()); 3320 } 3321 else if (input_section.is_output_section_data() 3322 && must_sort_attached_input_sections) 3323 { 3324 // For linker-generated sections, use the output section name. 3325 this->section_name_.assign(output_section_name); 3326 } 3327 } 3328 3329 // Return the Input_section. 3330 const Input_section& 3331 input_section() const 3332 { 3333 gold_assert(this->index_ != -1U); 3334 return this->input_section_; 3335 } 3336 3337 // The index of this entry in the original list. This is used to 3338 // make the sort stable. 3339 unsigned int 3340 index() const 3341 { 3342 gold_assert(this->index_ != -1U); 3343 return this->index_; 3344 } 3345 3346 // The section name. 3347 const std::string& 3348 section_name() const 3349 { 3350 return this->section_name_; 3351 } 3352 3353 // Return true if the section name has a priority. This is assumed 3354 // to be true if it has a dot after the initial dot. 3355 bool 3356 has_priority() const 3357 { 3358 return this->section_name_.find('.', 1) != std::string::npos; 3359 } 3360 3361 // Return the priority. Believe it or not, gcc encodes the priority 3362 // differently for .ctors/.dtors and .init_array/.fini_array 3363 // sections. 3364 unsigned int 3365 get_priority() const 3366 { 3367 bool is_ctors; 3368 if (is_prefix_of(".ctors.", this->section_name_.c_str()) 3369 || is_prefix_of(".dtors.", this->section_name_.c_str())) 3370 is_ctors = true; 3371 else if (is_prefix_of(".init_array.", this->section_name_.c_str()) 3372 || is_prefix_of(".fini_array.", this->section_name_.c_str())) 3373 is_ctors = false; 3374 else 3375 return 0; 3376 char* end; 3377 unsigned long prio = strtoul((this->section_name_.c_str() 3378 + (is_ctors ? 7 : 12)), 3379 &end, 10); 3380 if (*end != '\0') 3381 return 0; 3382 else if (is_ctors) 3383 return 65535 - prio; 3384 else 3385 return prio; 3386 } 3387 3388 // Return true if this an input file whose base name matches 3389 // FILE_NAME. The base name must have an extension of ".o", and 3390 // must be exactly FILE_NAME.o or FILE_NAME, one character, ".o". 3391 // This is to match crtbegin.o as well as crtbeginS.o without 3392 // getting confused by other possibilities. Overall matching the 3393 // file name this way is a dreadful hack, but the GNU linker does it 3394 // in order to better support gcc, and we need to be compatible. 3395 bool 3396 match_file_name(const char* file_name) const 3397 { 3398 if (this->input_section_.is_output_section_data()) 3399 return false; 3400 return Layout::match_file_name(this->input_section_.relobj(), file_name); 3401 } 3402 3403 // Returns 1 if THIS should appear before S in section order, -1 if S 3404 // appears before THIS and 0 if they are not comparable. 3405 int 3406 compare_section_ordering(const Input_section_sort_entry& s) const 3407 { 3408 unsigned int this_secn_index = this->input_section_.section_order_index(); 3409 unsigned int s_secn_index = s.input_section().section_order_index(); 3410 if (this_secn_index > 0 && s_secn_index > 0) 3411 { 3412 if (this_secn_index < s_secn_index) 3413 return 1; 3414 else if (this_secn_index > s_secn_index) 3415 return -1; 3416 } 3417 return 0; 3418 } 3419 3420 private: 3421 // The Input_section we are sorting. 3422 Input_section input_section_; 3423 // The index of this Input_section in the original list. 3424 unsigned int index_; 3425 // The section name if there is one. 3426 std::string section_name_; 3427 }; 3428 3429 // Return true if S1 should come before S2 in the output section. 3430 3431 bool 3432 Output_section::Input_section_sort_compare::operator()( 3433 const Output_section::Input_section_sort_entry& s1, 3434 const Output_section::Input_section_sort_entry& s2) const 3435 { 3436 // crtbegin.o must come first. 3437 bool s1_begin = s1.match_file_name("crtbegin"); 3438 bool s2_begin = s2.match_file_name("crtbegin"); 3439 if (s1_begin || s2_begin) 3440 { 3441 if (!s1_begin) 3442 return false; 3443 if (!s2_begin) 3444 return true; 3445 return s1.index() < s2.index(); 3446 } 3447 3448 // crtend.o must come last. 3449 bool s1_end = s1.match_file_name("crtend"); 3450 bool s2_end = s2.match_file_name("crtend"); 3451 if (s1_end || s2_end) 3452 { 3453 if (!s1_end) 3454 return true; 3455 if (!s2_end) 3456 return false; 3457 return s1.index() < s2.index(); 3458 } 3459 3460 // A section with a priority follows a section without a priority. 3461 bool s1_has_priority = s1.has_priority(); 3462 bool s2_has_priority = s2.has_priority(); 3463 if (s1_has_priority && !s2_has_priority) 3464 return false; 3465 if (!s1_has_priority && s2_has_priority) 3466 return true; 3467 3468 // Check if a section order exists for these sections through a section 3469 // ordering file. If sequence_num is 0, an order does not exist. 3470 int sequence_num = s1.compare_section_ordering(s2); 3471 if (sequence_num != 0) 3472 return sequence_num == 1; 3473 3474 // Otherwise we sort by name. 3475 int compare = s1.section_name().compare(s2.section_name()); 3476 if (compare != 0) 3477 return compare < 0; 3478 3479 // Otherwise we keep the input order. 3480 return s1.index() < s2.index(); 3481 } 3482 3483 // Return true if S1 should come before S2 in an .init_array or .fini_array 3484 // output section. 3485 3486 bool 3487 Output_section::Input_section_sort_init_fini_compare::operator()( 3488 const Output_section::Input_section_sort_entry& s1, 3489 const Output_section::Input_section_sort_entry& s2) const 3490 { 3491 // A section without a priority follows a section with a priority. 3492 // This is the reverse of .ctors and .dtors sections. 3493 bool s1_has_priority = s1.has_priority(); 3494 bool s2_has_priority = s2.has_priority(); 3495 if (s1_has_priority && !s2_has_priority) 3496 return true; 3497 if (!s1_has_priority && s2_has_priority) 3498 return false; 3499 3500 // .ctors and .dtors sections without priority come after 3501 // .init_array and .fini_array sections without priority. 3502 if (!s1_has_priority 3503 && (s1.section_name() == ".ctors" || s1.section_name() == ".dtors") 3504 && s1.section_name() != s2.section_name()) 3505 return false; 3506 if (!s2_has_priority 3507 && (s2.section_name() == ".ctors" || s2.section_name() == ".dtors") 3508 && s2.section_name() != s1.section_name()) 3509 return true; 3510 3511 // Sort by priority if we can. 3512 if (s1_has_priority) 3513 { 3514 unsigned int s1_prio = s1.get_priority(); 3515 unsigned int s2_prio = s2.get_priority(); 3516 if (s1_prio < s2_prio) 3517 return true; 3518 else if (s1_prio > s2_prio) 3519 return false; 3520 } 3521 3522 // Check if a section order exists for these sections through a section 3523 // ordering file. If sequence_num is 0, an order does not exist. 3524 int sequence_num = s1.compare_section_ordering(s2); 3525 if (sequence_num != 0) 3526 return sequence_num == 1; 3527 3528 // Otherwise we sort by name. 3529 int compare = s1.section_name().compare(s2.section_name()); 3530 if (compare != 0) 3531 return compare < 0; 3532 3533 // Otherwise we keep the input order. 3534 return s1.index() < s2.index(); 3535 } 3536 3537 // Return true if S1 should come before S2. Sections that do not match 3538 // any pattern in the section ordering file are placed ahead of the sections 3539 // that match some pattern. 3540 3541 bool 3542 Output_section::Input_section_sort_section_order_index_compare::operator()( 3543 const Output_section::Input_section_sort_entry& s1, 3544 const Output_section::Input_section_sort_entry& s2) const 3545 { 3546 unsigned int s1_secn_index = s1.input_section().section_order_index(); 3547 unsigned int s2_secn_index = s2.input_section().section_order_index(); 3548 3549 // Keep input order if section ordering cannot determine order. 3550 if (s1_secn_index == s2_secn_index) 3551 return s1.index() < s2.index(); 3552 3553 return s1_secn_index < s2_secn_index; 3554 } 3555 3556 // Return true if S1 should come before S2. This is the sort comparison 3557 // function for .text to sort sections with prefixes 3558 // .text.{unlikely,exit,startup,hot} before other sections. 3559 3560 bool 3561 Output_section::Input_section_sort_section_prefix_special_ordering_compare 3562 ::operator()( 3563 const Output_section::Input_section_sort_entry& s1, 3564 const Output_section::Input_section_sort_entry& s2) const 3565 { 3566 // Some input section names have special ordering requirements. 3567 int o1 = Layout::special_ordering_of_input_section(s1.section_name().c_str()); 3568 int o2 = Layout::special_ordering_of_input_section(s2.section_name().c_str()); 3569 if (o1 != o2) 3570 { 3571 if (o1 < 0) 3572 return false; 3573 else if (o2 < 0) 3574 return true; 3575 else 3576 return o1 < o2; 3577 } 3578 3579 // Keep input order otherwise. 3580 return s1.index() < s2.index(); 3581 } 3582 3583 // Return true if S1 should come before S2. This is the sort comparison 3584 // function for sections to sort them by name. 3585 3586 bool 3587 Output_section::Input_section_sort_section_name_compare 3588 ::operator()( 3589 const Output_section::Input_section_sort_entry& s1, 3590 const Output_section::Input_section_sort_entry& s2) const 3591 { 3592 // We sort by name. 3593 int compare = s1.section_name().compare(s2.section_name()); 3594 if (compare != 0) 3595 return compare < 0; 3596 3597 // Keep input order otherwise. 3598 return s1.index() < s2.index(); 3599 } 3600 3601 // This updates the section order index of input sections according to the 3602 // the order specified in the mapping from Section id to order index. 3603 3604 void 3605 Output_section::update_section_layout( 3606 const Section_layout_order* order_map) 3607 { 3608 for (Input_section_list::iterator p = this->input_sections_.begin(); 3609 p != this->input_sections_.end(); 3610 ++p) 3611 { 3612 if (p->is_input_section() 3613 || p->is_relaxed_input_section()) 3614 { 3615 Relobj* obj = (p->is_input_section() 3616 ? p->relobj() 3617 : p->relaxed_input_section()->relobj()); 3618 unsigned int shndx = p->shndx(); 3619 Section_layout_order::const_iterator it 3620 = order_map->find(Section_id(obj, shndx)); 3621 if (it == order_map->end()) 3622 continue; 3623 unsigned int section_order_index = it->second; 3624 if (section_order_index != 0) 3625 { 3626 p->set_section_order_index(section_order_index); 3627 this->set_input_section_order_specified(); 3628 } 3629 } 3630 } 3631 } 3632 3633 // Sort the input sections attached to an output section. 3634 3635 void 3636 Output_section::sort_attached_input_sections() 3637 { 3638 if (this->attached_input_sections_are_sorted_) 3639 return; 3640 3641 if (this->checkpoint_ != NULL 3642 && !this->checkpoint_->input_sections_saved()) 3643 this->checkpoint_->save_input_sections(); 3644 3645 // The only thing we know about an input section is the object and 3646 // the section index. We need the section name. Recomputing this 3647 // is slow but this is an unusual case. If this becomes a speed 3648 // problem we can cache the names as required in Layout::layout. 3649 3650 // We start by building a larger vector holding a copy of each 3651 // Input_section, plus its current index in the list and its name. 3652 std::vector<Input_section_sort_entry> sort_list; 3653 3654 unsigned int i = 0; 3655 for (Input_section_list::iterator p = this->input_sections_.begin(); 3656 p != this->input_sections_.end(); 3657 ++p, ++i) 3658 sort_list.push_back(Input_section_sort_entry(*p, i, 3659 this->must_sort_attached_input_sections(), 3660 this->name())); 3661 3662 // Sort the input sections. 3663 if (this->must_sort_attached_input_sections()) 3664 { 3665 if (this->type() == elfcpp::SHT_PREINIT_ARRAY 3666 || this->type() == elfcpp::SHT_INIT_ARRAY 3667 || this->type() == elfcpp::SHT_FINI_ARRAY) 3668 std::sort(sort_list.begin(), sort_list.end(), 3669 Input_section_sort_init_fini_compare()); 3670 else if (strcmp(parameters->options().sort_section(), "name") == 0) 3671 std::sort(sort_list.begin(), sort_list.end(), 3672 Input_section_sort_section_name_compare()); 3673 else if (strcmp(this->name(), ".text") == 0) 3674 std::sort(sort_list.begin(), sort_list.end(), 3675 Input_section_sort_section_prefix_special_ordering_compare()); 3676 else 3677 std::sort(sort_list.begin(), sort_list.end(), 3678 Input_section_sort_compare()); 3679 } 3680 else 3681 { 3682 gold_assert(this->input_section_order_specified()); 3683 std::sort(sort_list.begin(), sort_list.end(), 3684 Input_section_sort_section_order_index_compare()); 3685 } 3686 3687 // Copy the sorted input sections back to our list. 3688 this->input_sections_.clear(); 3689 for (std::vector<Input_section_sort_entry>::iterator p = sort_list.begin(); 3690 p != sort_list.end(); 3691 ++p) 3692 this->input_sections_.push_back(p->input_section()); 3693 sort_list.clear(); 3694 3695 // Remember that we sorted the input sections, since we might get 3696 // called again. 3697 this->attached_input_sections_are_sorted_ = true; 3698 } 3699 3700 // Write the section header to *OSHDR. 3701 3702 template<int size, bool big_endian> 3703 void 3704 Output_section::write_header(const Layout* layout, 3705 const Stringpool* secnamepool, 3706 elfcpp::Shdr_write<size, big_endian>* oshdr) const 3707 { 3708 oshdr->put_sh_name(secnamepool->get_offset(this->name_)); 3709 oshdr->put_sh_type(this->type_); 3710 3711 elfcpp::Elf_Xword flags = this->flags_; 3712 if (this->info_section_ != NULL && this->info_uses_section_index_) 3713 flags |= elfcpp::SHF_INFO_LINK; 3714 oshdr->put_sh_flags(flags); 3715 3716 oshdr->put_sh_addr(this->address()); 3717 oshdr->put_sh_offset(this->offset()); 3718 oshdr->put_sh_size(this->data_size()); 3719 if (this->link_section_ != NULL) 3720 oshdr->put_sh_link(this->link_section_->out_shndx()); 3721 else if (this->should_link_to_symtab_) 3722 oshdr->put_sh_link(layout->symtab_section_shndx()); 3723 else if (this->should_link_to_dynsym_) 3724 oshdr->put_sh_link(layout->dynsym_section()->out_shndx()); 3725 else 3726 oshdr->put_sh_link(this->link_); 3727 3728 elfcpp::Elf_Word info; 3729 if (this->info_section_ != NULL) 3730 { 3731 if (this->info_uses_section_index_) 3732 info = this->info_section_->out_shndx(); 3733 else 3734 info = this->info_section_->symtab_index(); 3735 } 3736 else if (this->info_symndx_ != NULL) 3737 info = this->info_symndx_->symtab_index(); 3738 else 3739 info = this->info_; 3740 oshdr->put_sh_info(info); 3741 3742 oshdr->put_sh_addralign(this->addralign_); 3743 oshdr->put_sh_entsize(this->entsize_); 3744 } 3745 3746 // Write out the data. For input sections the data is written out by 3747 // Object::relocate, but we have to handle Output_section_data objects 3748 // here. 3749 3750 void 3751 Output_section::do_write(Output_file* of) 3752 { 3753 gold_assert(!this->requires_postprocessing()); 3754 3755 // If the target performs relaxation, we delay filler generation until now. 3756 gold_assert(!this->generate_code_fills_at_write_ || this->fills_.empty()); 3757 3758 off_t output_section_file_offset = this->offset(); 3759 for (Fill_list::iterator p = this->fills_.begin(); 3760 p != this->fills_.end(); 3761 ++p) 3762 { 3763 std::string fill_data(parameters->target().code_fill(p->length())); 3764 of->write(output_section_file_offset + p->section_offset(), 3765 fill_data.data(), fill_data.size()); 3766 } 3767 3768 off_t off = this->offset() + this->first_input_offset_; 3769 for (Input_section_list::iterator p = this->input_sections_.begin(); 3770 p != this->input_sections_.end(); 3771 ++p) 3772 { 3773 off_t aligned_off = align_address(off, p->addralign()); 3774 if (this->generate_code_fills_at_write_ && (off != aligned_off)) 3775 { 3776 size_t fill_len = aligned_off - off; 3777 std::string fill_data(parameters->target().code_fill(fill_len)); 3778 of->write(off, fill_data.data(), fill_data.size()); 3779 } 3780 3781 p->write(of); 3782 off = aligned_off + p->data_size(); 3783 } 3784 3785 // For incremental links, fill in unused chunks in debug sections 3786 // with dummy compilation unit headers. 3787 if (this->free_space_fill_ != NULL) 3788 { 3789 for (Free_list::Const_iterator p = this->free_list_.begin(); 3790 p != this->free_list_.end(); 3791 ++p) 3792 { 3793 off_t off = p->start_; 3794 size_t len = p->end_ - off; 3795 this->free_space_fill_->write(of, this->offset() + off, len); 3796 } 3797 if (this->patch_space_ > 0) 3798 { 3799 off_t off = this->current_data_size_for_child() - this->patch_space_; 3800 this->free_space_fill_->write(of, this->offset() + off, 3801 this->patch_space_); 3802 } 3803 } 3804 } 3805 3806 // If a section requires postprocessing, create the buffer to use. 3807 3808 void 3809 Output_section::create_postprocessing_buffer() 3810 { 3811 gold_assert(this->requires_postprocessing()); 3812 3813 if (this->postprocessing_buffer_ != NULL) 3814 return; 3815 3816 if (!this->input_sections_.empty()) 3817 { 3818 off_t off = this->first_input_offset_; 3819 for (Input_section_list::iterator p = this->input_sections_.begin(); 3820 p != this->input_sections_.end(); 3821 ++p) 3822 { 3823 off = align_address(off, p->addralign()); 3824 p->finalize_data_size(); 3825 off += p->data_size(); 3826 } 3827 this->set_current_data_size_for_child(off); 3828 } 3829 3830 off_t buffer_size = this->current_data_size_for_child(); 3831 this->postprocessing_buffer_ = new unsigned char[buffer_size]; 3832 } 3833 3834 // Write all the data of an Output_section into the postprocessing 3835 // buffer. This is used for sections which require postprocessing, 3836 // such as compression. Input sections are handled by 3837 // Object::Relocate. 3838 3839 void 3840 Output_section::write_to_postprocessing_buffer() 3841 { 3842 gold_assert(this->requires_postprocessing()); 3843 3844 // If the target performs relaxation, we delay filler generation until now. 3845 gold_assert(!this->generate_code_fills_at_write_ || this->fills_.empty()); 3846 3847 unsigned char* buffer = this->postprocessing_buffer(); 3848 for (Fill_list::iterator p = this->fills_.begin(); 3849 p != this->fills_.end(); 3850 ++p) 3851 { 3852 std::string fill_data(parameters->target().code_fill(p->length())); 3853 memcpy(buffer + p->section_offset(), fill_data.data(), 3854 fill_data.size()); 3855 } 3856 3857 off_t off = this->first_input_offset_; 3858 for (Input_section_list::iterator p = this->input_sections_.begin(); 3859 p != this->input_sections_.end(); 3860 ++p) 3861 { 3862 off_t aligned_off = align_address(off, p->addralign()); 3863 if (this->generate_code_fills_at_write_ && (off != aligned_off)) 3864 { 3865 size_t fill_len = aligned_off - off; 3866 std::string fill_data(parameters->target().code_fill(fill_len)); 3867 memcpy(buffer + off, fill_data.data(), fill_data.size()); 3868 } 3869 3870 p->write_to_buffer(buffer + aligned_off); 3871 off = aligned_off + p->data_size(); 3872 } 3873 } 3874 3875 // Get the input sections for linker script processing. We leave 3876 // behind the Output_section_data entries. Note that this may be 3877 // slightly incorrect for merge sections. We will leave them behind, 3878 // but it is possible that the script says that they should follow 3879 // some other input sections, as in: 3880 // .rodata { *(.rodata) *(.rodata.cst*) } 3881 // For that matter, we don't handle this correctly: 3882 // .rodata { foo.o(.rodata.cst*) *(.rodata.cst*) } 3883 // With luck this will never matter. 3884 3885 uint64_t 3886 Output_section::get_input_sections( 3887 uint64_t address, 3888 const std::string& fill, 3889 std::list<Input_section>* input_sections) 3890 { 3891 if (this->checkpoint_ != NULL 3892 && !this->checkpoint_->input_sections_saved()) 3893 this->checkpoint_->save_input_sections(); 3894 3895 // Invalidate fast look-up maps. 3896 this->lookup_maps_->invalidate(); 3897 3898 uint64_t orig_address = address; 3899 3900 address = align_address(address, this->addralign()); 3901 3902 Input_section_list remaining; 3903 for (Input_section_list::iterator p = this->input_sections_.begin(); 3904 p != this->input_sections_.end(); 3905 ++p) 3906 { 3907 if (p->is_input_section() 3908 || p->is_relaxed_input_section() 3909 || p->is_merge_section()) 3910 input_sections->push_back(*p); 3911 else 3912 { 3913 uint64_t aligned_address = align_address(address, p->addralign()); 3914 if (aligned_address != address && !fill.empty()) 3915 { 3916 section_size_type length = 3917 convert_to_section_size_type(aligned_address - address); 3918 std::string this_fill; 3919 this_fill.reserve(length); 3920 while (this_fill.length() + fill.length() <= length) 3921 this_fill += fill; 3922 if (this_fill.length() < length) 3923 this_fill.append(fill, 0, length - this_fill.length()); 3924 3925 Output_section_data* posd = new Output_data_const(this_fill, 0); 3926 remaining.push_back(Input_section(posd)); 3927 } 3928 address = aligned_address; 3929 3930 remaining.push_back(*p); 3931 3932 p->finalize_data_size(); 3933 address += p->data_size(); 3934 } 3935 } 3936 3937 this->input_sections_.swap(remaining); 3938 this->first_input_offset_ = 0; 3939 3940 uint64_t data_size = address - orig_address; 3941 this->set_current_data_size_for_child(data_size); 3942 return data_size; 3943 } 3944 3945 // Add a script input section. SIS is an Output_section::Input_section, 3946 // which can be either a plain input section or a special input section like 3947 // a relaxed input section. For a special input section, its size must be 3948 // finalized. 3949 3950 void 3951 Output_section::add_script_input_section(const Input_section& sis) 3952 { 3953 uint64_t data_size = sis.data_size(); 3954 uint64_t addralign = sis.addralign(); 3955 if (addralign > this->addralign_) 3956 this->addralign_ = addralign; 3957 3958 off_t offset_in_section = this->current_data_size_for_child(); 3959 off_t aligned_offset_in_section = align_address(offset_in_section, 3960 addralign); 3961 3962 this->set_current_data_size_for_child(aligned_offset_in_section 3963 + data_size); 3964 3965 this->input_sections_.push_back(sis); 3966 3967 // Update fast lookup maps if necessary. 3968 if (this->lookup_maps_->is_valid()) 3969 { 3970 if (sis.is_relaxed_input_section()) 3971 { 3972 Output_relaxed_input_section* poris = sis.relaxed_input_section(); 3973 this->lookup_maps_->add_relaxed_input_section(poris->relobj(), 3974 poris->shndx(), poris); 3975 } 3976 } 3977 } 3978 3979 // Save states for relaxation. 3980 3981 void 3982 Output_section::save_states() 3983 { 3984 gold_assert(this->checkpoint_ == NULL); 3985 Checkpoint_output_section* checkpoint = 3986 new Checkpoint_output_section(this->addralign_, this->flags_, 3987 this->input_sections_, 3988 this->first_input_offset_, 3989 this->attached_input_sections_are_sorted_); 3990 this->checkpoint_ = checkpoint; 3991 gold_assert(this->fills_.empty()); 3992 } 3993 3994 void 3995 Output_section::discard_states() 3996 { 3997 gold_assert(this->checkpoint_ != NULL); 3998 delete this->checkpoint_; 3999 this->checkpoint_ = NULL; 4000 gold_assert(this->fills_.empty()); 4001 4002 // Simply invalidate the fast lookup maps since we do not keep 4003 // track of them. 4004 this->lookup_maps_->invalidate(); 4005 } 4006 4007 void 4008 Output_section::restore_states() 4009 { 4010 gold_assert(this->checkpoint_ != NULL); 4011 Checkpoint_output_section* checkpoint = this->checkpoint_; 4012 4013 this->addralign_ = checkpoint->addralign(); 4014 this->flags_ = checkpoint->flags(); 4015 this->first_input_offset_ = checkpoint->first_input_offset(); 4016 4017 if (!checkpoint->input_sections_saved()) 4018 { 4019 // If we have not copied the input sections, just resize it. 4020 size_t old_size = checkpoint->input_sections_size(); 4021 gold_assert(this->input_sections_.size() >= old_size); 4022 this->input_sections_.resize(old_size); 4023 } 4024 else 4025 { 4026 // We need to copy the whole list. This is not efficient for 4027 // extremely large output with hundreads of thousands of input 4028 // objects. We may need to re-think how we should pass sections 4029 // to scripts. 4030 this->input_sections_ = *checkpoint->input_sections(); 4031 } 4032 4033 this->attached_input_sections_are_sorted_ = 4034 checkpoint->attached_input_sections_are_sorted(); 4035 4036 // Simply invalidate the fast lookup maps since we do not keep 4037 // track of them. 4038 this->lookup_maps_->invalidate(); 4039 } 4040 4041 // Update the section offsets of input sections in this. This is required if 4042 // relaxation causes some input sections to change sizes. 4043 4044 void 4045 Output_section::adjust_section_offsets() 4046 { 4047 if (!this->section_offsets_need_adjustment_) 4048 return; 4049 4050 off_t off = 0; 4051 for (Input_section_list::iterator p = this->input_sections_.begin(); 4052 p != this->input_sections_.end(); 4053 ++p) 4054 { 4055 off = align_address(off, p->addralign()); 4056 if (p->is_input_section()) 4057 p->relobj()->set_section_offset(p->shndx(), off); 4058 off += p->data_size(); 4059 } 4060 4061 this->section_offsets_need_adjustment_ = false; 4062 } 4063 4064 // Print to the map file. 4065 4066 void 4067 Output_section::do_print_to_mapfile(Mapfile* mapfile) const 4068 { 4069 mapfile->print_output_section(this); 4070 4071 for (Input_section_list::const_iterator p = this->input_sections_.begin(); 4072 p != this->input_sections_.end(); 4073 ++p) 4074 p->print_to_mapfile(mapfile); 4075 } 4076 4077 // Print stats for merge sections to stderr. 4078 4079 void 4080 Output_section::print_merge_stats() 4081 { 4082 Input_section_list::iterator p; 4083 for (p = this->input_sections_.begin(); 4084 p != this->input_sections_.end(); 4085 ++p) 4086 p->print_merge_stats(this->name_); 4087 } 4088 4089 // Set a fixed layout for the section. Used for incremental update links. 4090 4091 void 4092 Output_section::set_fixed_layout(uint64_t sh_addr, off_t sh_offset, 4093 off_t sh_size, uint64_t sh_addralign) 4094 { 4095 this->addralign_ = sh_addralign; 4096 this->set_current_data_size(sh_size); 4097 if ((this->flags_ & elfcpp::SHF_ALLOC) != 0) 4098 this->set_address(sh_addr); 4099 this->set_file_offset(sh_offset); 4100 this->finalize_data_size(); 4101 this->free_list_.init(sh_size, false); 4102 this->has_fixed_layout_ = true; 4103 } 4104 4105 // Reserve space within the fixed layout for the section. Used for 4106 // incremental update links. 4107 4108 void 4109 Output_section::reserve(uint64_t sh_offset, uint64_t sh_size) 4110 { 4111 this->free_list_.remove(sh_offset, sh_offset + sh_size); 4112 } 4113 4114 // Allocate space from the free list for the section. Used for 4115 // incremental update links. 4116 4117 off_t 4118 Output_section::allocate(off_t len, uint64_t addralign) 4119 { 4120 return this->free_list_.allocate(len, addralign, 0); 4121 } 4122 4123 // Output segment methods. 4124 4125 Output_segment::Output_segment(elfcpp::Elf_Word type, elfcpp::Elf_Word flags) 4126 : vaddr_(0), 4127 paddr_(0), 4128 memsz_(0), 4129 max_align_(0), 4130 min_p_align_(0), 4131 offset_(0), 4132 filesz_(0), 4133 type_(type), 4134 flags_(flags), 4135 is_max_align_known_(false), 4136 are_addresses_set_(false), 4137 is_large_data_segment_(false), 4138 is_unique_segment_(false) 4139 { 4140 // The ELF ABI specifies that a PT_TLS segment always has PF_R as 4141 // the flags. 4142 if (type == elfcpp::PT_TLS) 4143 this->flags_ = elfcpp::PF_R; 4144 } 4145 4146 // Add an Output_section to a PT_LOAD Output_segment. 4147 4148 void 4149 Output_segment::add_output_section_to_load(Layout* layout, 4150 Output_section* os, 4151 elfcpp::Elf_Word seg_flags) 4152 { 4153 gold_assert(this->type() == elfcpp::PT_LOAD); 4154 gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0); 4155 gold_assert(!this->is_max_align_known_); 4156 gold_assert(os->is_large_data_section() == this->is_large_data_segment()); 4157 4158 this->update_flags_for_output_section(seg_flags); 4159 4160 // We don't want to change the ordering if we have a linker script 4161 // with a SECTIONS clause. 4162 Output_section_order order = os->order(); 4163 if (layout->script_options()->saw_sections_clause()) 4164 order = static_cast<Output_section_order>(0); 4165 else 4166 gold_assert(order != ORDER_INVALID); 4167 4168 this->output_lists_[order].push_back(os); 4169 } 4170 4171 // Add an Output_section to a non-PT_LOAD Output_segment. 4172 4173 void 4174 Output_segment::add_output_section_to_nonload(Output_section* os, 4175 elfcpp::Elf_Word seg_flags) 4176 { 4177 gold_assert(this->type() != elfcpp::PT_LOAD); 4178 gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0); 4179 gold_assert(!this->is_max_align_known_); 4180 4181 this->update_flags_for_output_section(seg_flags); 4182 4183 this->output_lists_[0].push_back(os); 4184 } 4185 4186 // Remove an Output_section from this segment. It is an error if it 4187 // is not present. 4188 4189 void 4190 Output_segment::remove_output_section(Output_section* os) 4191 { 4192 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i) 4193 { 4194 Output_data_list* pdl = &this->output_lists_[i]; 4195 for (Output_data_list::iterator p = pdl->begin(); p != pdl->end(); ++p) 4196 { 4197 if (*p == os) 4198 { 4199 pdl->erase(p); 4200 return; 4201 } 4202 } 4203 } 4204 gold_unreachable(); 4205 } 4206 4207 // Add an Output_data (which need not be an Output_section) to the 4208 // start of a segment. 4209 4210 void 4211 Output_segment::add_initial_output_data(Output_data* od) 4212 { 4213 gold_assert(!this->is_max_align_known_); 4214 Output_data_list::iterator p = this->output_lists_[0].begin(); 4215 this->output_lists_[0].insert(p, od); 4216 } 4217 4218 // Return true if this segment has any sections which hold actual 4219 // data, rather than being a BSS section. 4220 4221 bool 4222 Output_segment::has_any_data_sections() const 4223 { 4224 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i) 4225 { 4226 const Output_data_list* pdl = &this->output_lists_[i]; 4227 for (Output_data_list::const_iterator p = pdl->begin(); 4228 p != pdl->end(); 4229 ++p) 4230 { 4231 if (!(*p)->is_section()) 4232 return true; 4233 if ((*p)->output_section()->type() != elfcpp::SHT_NOBITS) 4234 return true; 4235 } 4236 } 4237 return false; 4238 } 4239 4240 // Return whether the first data section (not counting TLS sections) 4241 // is a relro section. 4242 4243 bool 4244 Output_segment::is_first_section_relro() const 4245 { 4246 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i) 4247 { 4248 if (i == static_cast<int>(ORDER_TLS_BSS)) 4249 continue; 4250 const Output_data_list* pdl = &this->output_lists_[i]; 4251 if (!pdl->empty()) 4252 { 4253 Output_data* p = pdl->front(); 4254 return p->is_section() && p->output_section()->is_relro(); 4255 } 4256 } 4257 return false; 4258 } 4259 4260 // Return the maximum alignment of the Output_data in Output_segment. 4261 4262 uint64_t 4263 Output_segment::maximum_alignment() 4264 { 4265 if (!this->is_max_align_known_) 4266 { 4267 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i) 4268 { 4269 const Output_data_list* pdl = &this->output_lists_[i]; 4270 uint64_t addralign = Output_segment::maximum_alignment_list(pdl); 4271 if (addralign > this->max_align_) 4272 this->max_align_ = addralign; 4273 } 4274 this->is_max_align_known_ = true; 4275 } 4276 4277 return this->max_align_; 4278 } 4279 4280 // Return the maximum alignment of a list of Output_data. 4281 4282 uint64_t 4283 Output_segment::maximum_alignment_list(const Output_data_list* pdl) 4284 { 4285 uint64_t ret = 0; 4286 for (Output_data_list::const_iterator p = pdl->begin(); 4287 p != pdl->end(); 4288 ++p) 4289 { 4290 uint64_t addralign = (*p)->addralign(); 4291 if (addralign > ret) 4292 ret = addralign; 4293 } 4294 return ret; 4295 } 4296 4297 // Return whether this segment has any dynamic relocs. 4298 4299 bool 4300 Output_segment::has_dynamic_reloc() const 4301 { 4302 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i) 4303 if (this->has_dynamic_reloc_list(&this->output_lists_[i])) 4304 return true; 4305 return false; 4306 } 4307 4308 // Return whether this Output_data_list has any dynamic relocs. 4309 4310 bool 4311 Output_segment::has_dynamic_reloc_list(const Output_data_list* pdl) const 4312 { 4313 for (Output_data_list::const_iterator p = pdl->begin(); 4314 p != pdl->end(); 4315 ++p) 4316 if ((*p)->has_dynamic_reloc()) 4317 return true; 4318 return false; 4319 } 4320 4321 // Set the section addresses for an Output_segment. If RESET is true, 4322 // reset the addresses first. ADDR is the address and *POFF is the 4323 // file offset. Set the section indexes starting with *PSHNDX. 4324 // INCREASE_RELRO is the size of the portion of the first non-relro 4325 // section that should be included in the PT_GNU_RELRO segment. 4326 // If this segment has relro sections, and has been aligned for 4327 // that purpose, set *HAS_RELRO to TRUE. Return the address of 4328 // the immediately following segment. Update *HAS_RELRO, *POFF, 4329 // and *PSHNDX. 4330 4331 uint64_t 4332 Output_segment::set_section_addresses(const Target* target, 4333 Layout* layout, bool reset, 4334 uint64_t addr, 4335 unsigned int* increase_relro, 4336 bool* has_relro, 4337 off_t* poff, 4338 unsigned int* pshndx) 4339 { 4340 gold_assert(this->type_ == elfcpp::PT_LOAD); 4341 4342 uint64_t last_relro_pad = 0; 4343 off_t orig_off = *poff; 4344 4345 bool in_tls = false; 4346 4347 // If we have relro sections, we need to pad forward now so that the 4348 // relro sections plus INCREASE_RELRO end on an abi page boundary. 4349 if (parameters->options().relro() 4350 && this->is_first_section_relro() 4351 && (!this->are_addresses_set_ || reset)) 4352 { 4353 uint64_t relro_size = 0; 4354 off_t off = *poff; 4355 uint64_t max_align = 0; 4356 for (int i = 0; i <= static_cast<int>(ORDER_RELRO_LAST); ++i) 4357 { 4358 Output_data_list* pdl = &this->output_lists_[i]; 4359 Output_data_list::iterator p; 4360 for (p = pdl->begin(); p != pdl->end(); ++p) 4361 { 4362 if (!(*p)->is_section()) 4363 break; 4364 uint64_t align = (*p)->addralign(); 4365 if (align > max_align) 4366 max_align = align; 4367 if ((*p)->is_section_flag_set(elfcpp::SHF_TLS)) 4368 in_tls = true; 4369 else if (in_tls) 4370 { 4371 // Align the first non-TLS section to the alignment 4372 // of the TLS segment. 4373 align = max_align; 4374 in_tls = false; 4375 } 4376 // Ignore the size of the .tbss section. 4377 if ((*p)->is_section_flag_set(elfcpp::SHF_TLS) 4378 && (*p)->is_section_type(elfcpp::SHT_NOBITS)) 4379 continue; 4380 relro_size = align_address(relro_size, align); 4381 if ((*p)->is_address_valid()) 4382 relro_size += (*p)->data_size(); 4383 else 4384 { 4385 // FIXME: This could be faster. 4386 (*p)->set_address_and_file_offset(relro_size, 4387 relro_size); 4388 relro_size += (*p)->data_size(); 4389 (*p)->reset_address_and_file_offset(); 4390 } 4391 } 4392 if (p != pdl->end()) 4393 break; 4394 } 4395 relro_size += *increase_relro; 4396 // Pad the total relro size to a multiple of the maximum 4397 // section alignment seen. 4398 uint64_t aligned_size = align_address(relro_size, max_align); 4399 // Note the amount of padding added after the last relro section. 4400 last_relro_pad = aligned_size - relro_size; 4401 *has_relro = true; 4402 4403 uint64_t page_align = parameters->target().abi_pagesize(); 4404 4405 // Align to offset N such that (N + RELRO_SIZE) % PAGE_ALIGN == 0. 4406 uint64_t desired_align = page_align - (aligned_size % page_align); 4407 if (desired_align < off % page_align) 4408 off += page_align; 4409 off += desired_align - off % page_align; 4410 addr += off - orig_off; 4411 orig_off = off; 4412 *poff = off; 4413 } 4414 4415 if (!reset && this->are_addresses_set_) 4416 { 4417 gold_assert(this->paddr_ == addr); 4418 addr = this->vaddr_; 4419 } 4420 else 4421 { 4422 this->vaddr_ = addr; 4423 this->paddr_ = addr; 4424 this->are_addresses_set_ = true; 4425 } 4426 4427 in_tls = false; 4428 4429 this->offset_ = orig_off; 4430 4431 off_t off = 0; 4432 uint64_t ret; 4433 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i) 4434 { 4435 if (i == static_cast<int>(ORDER_RELRO_LAST)) 4436 { 4437 *poff += last_relro_pad; 4438 addr += last_relro_pad; 4439 if (this->output_lists_[i].empty()) 4440 { 4441 // If there is nothing in the ORDER_RELRO_LAST list, 4442 // the padding will occur at the end of the relro 4443 // segment, and we need to add it to *INCREASE_RELRO. 4444 *increase_relro += last_relro_pad; 4445 } 4446 } 4447 addr = this->set_section_list_addresses(layout, reset, 4448 &this->output_lists_[i], 4449 addr, poff, pshndx, &in_tls); 4450 if (i < static_cast<int>(ORDER_SMALL_BSS)) 4451 { 4452 this->filesz_ = *poff - orig_off; 4453 off = *poff; 4454 } 4455 4456 ret = addr; 4457 } 4458 4459 // If the last section was a TLS section, align upward to the 4460 // alignment of the TLS segment, so that the overall size of the TLS 4461 // segment is aligned. 4462 if (in_tls) 4463 { 4464 uint64_t segment_align = layout->tls_segment()->maximum_alignment(); 4465 *poff = align_address(*poff, segment_align); 4466 } 4467 4468 this->memsz_ = *poff - orig_off; 4469 4470 // Ignore the file offset adjustments made by the BSS Output_data 4471 // objects. 4472 *poff = off; 4473 4474 // If code segments must contain only code, and this code segment is 4475 // page-aligned in the file, then fill it out to a whole page with 4476 // code fill (the tail of the segment will not be within any section). 4477 // Thus the entire code segment can be mapped from the file as whole 4478 // pages and that mapping will contain only valid instructions. 4479 if (target->isolate_execinstr() && (this->flags() & elfcpp::PF_X) != 0) 4480 { 4481 uint64_t abi_pagesize = target->abi_pagesize(); 4482 if (orig_off % abi_pagesize == 0 && off % abi_pagesize != 0) 4483 { 4484 size_t fill_size = abi_pagesize - (off % abi_pagesize); 4485 4486 std::string fill_data; 4487 if (target->has_code_fill()) 4488 fill_data = target->code_fill(fill_size); 4489 else 4490 fill_data.resize(fill_size); // Zero fill. 4491 4492 Output_data_const* fill = new Output_data_const(fill_data, 0); 4493 fill->set_address(this->vaddr_ + this->memsz_); 4494 fill->set_file_offset(off); 4495 layout->add_relax_output(fill); 4496 4497 off += fill_size; 4498 gold_assert(off % abi_pagesize == 0); 4499 ret += fill_size; 4500 gold_assert(ret % abi_pagesize == 0); 4501 4502 gold_assert((uint64_t) this->filesz_ == this->memsz_); 4503 this->memsz_ = this->filesz_ += fill_size; 4504 4505 *poff = off; 4506 } 4507 } 4508 4509 return ret; 4510 } 4511 4512 // Set the addresses and file offsets in a list of Output_data 4513 // structures. 4514 4515 uint64_t 4516 Output_segment::set_section_list_addresses(Layout* layout, bool reset, 4517 Output_data_list* pdl, 4518 uint64_t addr, off_t* poff, 4519 unsigned int* pshndx, 4520 bool* in_tls) 4521 { 4522 off_t startoff = *poff; 4523 // For incremental updates, we may allocate non-fixed sections from 4524 // free space in the file. This keeps track of the high-water mark. 4525 off_t maxoff = startoff; 4526 4527 off_t off = startoff; 4528 for (Output_data_list::iterator p = pdl->begin(); 4529 p != pdl->end(); 4530 ++p) 4531 { 4532 if (reset) 4533 (*p)->reset_address_and_file_offset(); 4534 4535 // When doing an incremental update or when using a linker script, 4536 // the section will most likely already have an address. 4537 if (!(*p)->is_address_valid()) 4538 { 4539 uint64_t align = (*p)->addralign(); 4540 4541 if ((*p)->is_section_flag_set(elfcpp::SHF_TLS)) 4542 { 4543 // Give the first TLS section the alignment of the 4544 // entire TLS segment. Otherwise the TLS segment as a 4545 // whole may be misaligned. 4546 if (!*in_tls) 4547 { 4548 Output_segment* tls_segment = layout->tls_segment(); 4549 gold_assert(tls_segment != NULL); 4550 uint64_t segment_align = tls_segment->maximum_alignment(); 4551 gold_assert(segment_align >= align); 4552 align = segment_align; 4553 4554 *in_tls = true; 4555 } 4556 } 4557 else 4558 { 4559 // If this is the first section after the TLS segment, 4560 // align it to at least the alignment of the TLS 4561 // segment, so that the size of the overall TLS segment 4562 // is aligned. 4563 if (*in_tls) 4564 { 4565 uint64_t segment_align = 4566 layout->tls_segment()->maximum_alignment(); 4567 if (segment_align > align) 4568 align = segment_align; 4569 4570 *in_tls = false; 4571 } 4572 } 4573 4574 if (!parameters->incremental_update()) 4575 { 4576 off = align_address(off, align); 4577 (*p)->set_address_and_file_offset(addr + (off - startoff), off); 4578 } 4579 else 4580 { 4581 // Incremental update: allocate file space from free list. 4582 (*p)->pre_finalize_data_size(); 4583 off_t current_size = (*p)->current_data_size(); 4584 off = layout->allocate(current_size, align, startoff); 4585 if (off == -1) 4586 { 4587 gold_assert((*p)->output_section() != NULL); 4588 gold_fallback(_("out of patch space for section %s; " 4589 "relink with --incremental-full"), 4590 (*p)->output_section()->name()); 4591 } 4592 (*p)->set_address_and_file_offset(addr + (off - startoff), off); 4593 if ((*p)->data_size() > current_size) 4594 { 4595 gold_assert((*p)->output_section() != NULL); 4596 gold_fallback(_("%s: section changed size; " 4597 "relink with --incremental-full"), 4598 (*p)->output_section()->name()); 4599 } 4600 } 4601 } 4602 else if (parameters->incremental_update()) 4603 { 4604 // For incremental updates, use the fixed offset for the 4605 // high-water mark computation. 4606 off = (*p)->offset(); 4607 } 4608 else 4609 { 4610 // The script may have inserted a skip forward, but it 4611 // better not have moved backward. 4612 if ((*p)->address() >= addr + (off - startoff)) 4613 off += (*p)->address() - (addr + (off - startoff)); 4614 else 4615 { 4616 if (!layout->script_options()->saw_sections_clause()) 4617 gold_unreachable(); 4618 else 4619 { 4620 Output_section* os = (*p)->output_section(); 4621 4622 // Cast to unsigned long long to avoid format warnings. 4623 unsigned long long previous_dot = 4624 static_cast<unsigned long long>(addr + (off - startoff)); 4625 unsigned long long dot = 4626 static_cast<unsigned long long>((*p)->address()); 4627 4628 if (os == NULL) 4629 gold_error(_("dot moves backward in linker script " 4630 "from 0x%llx to 0x%llx"), previous_dot, dot); 4631 else 4632 gold_error(_("address of section '%s' moves backward " 4633 "from 0x%llx to 0x%llx"), 4634 os->name(), previous_dot, dot); 4635 } 4636 } 4637 (*p)->set_file_offset(off); 4638 (*p)->finalize_data_size(); 4639 } 4640 4641 if (parameters->incremental_update()) 4642 gold_debug(DEBUG_INCREMENTAL, 4643 "set_section_list_addresses: %08lx %08lx %s", 4644 static_cast<long>(off), 4645 static_cast<long>((*p)->data_size()), 4646 ((*p)->output_section() != NULL 4647 ? (*p)->output_section()->name() : "(special)")); 4648 4649 // We want to ignore the size of a SHF_TLS SHT_NOBITS 4650 // section. Such a section does not affect the size of a 4651 // PT_LOAD segment. 4652 if (!(*p)->is_section_flag_set(elfcpp::SHF_TLS) 4653 || !(*p)->is_section_type(elfcpp::SHT_NOBITS)) 4654 off += (*p)->data_size(); 4655 4656 if (off > maxoff) 4657 maxoff = off; 4658 4659 if ((*p)->is_section()) 4660 { 4661 (*p)->set_out_shndx(*pshndx); 4662 ++*pshndx; 4663 } 4664 } 4665 4666 *poff = maxoff; 4667 return addr + (maxoff - startoff); 4668 } 4669 4670 // For a non-PT_LOAD segment, set the offset from the sections, if 4671 // any. Add INCREASE to the file size and the memory size. 4672 4673 void 4674 Output_segment::set_offset(unsigned int increase) 4675 { 4676 gold_assert(this->type_ != elfcpp::PT_LOAD); 4677 4678 gold_assert(!this->are_addresses_set_); 4679 4680 // A non-load section only uses output_lists_[0]. 4681 4682 Output_data_list* pdl = &this->output_lists_[0]; 4683 4684 if (pdl->empty()) 4685 { 4686 gold_assert(increase == 0); 4687 this->vaddr_ = 0; 4688 this->paddr_ = 0; 4689 this->are_addresses_set_ = true; 4690 this->memsz_ = 0; 4691 this->min_p_align_ = 0; 4692 this->offset_ = 0; 4693 this->filesz_ = 0; 4694 return; 4695 } 4696 4697 // Find the first and last section by address. 4698 const Output_data* first = NULL; 4699 const Output_data* last_data = NULL; 4700 const Output_data* last_bss = NULL; 4701 for (Output_data_list::const_iterator p = pdl->begin(); 4702 p != pdl->end(); 4703 ++p) 4704 { 4705 if (first == NULL 4706 || (*p)->address() < first->address() 4707 || ((*p)->address() == first->address() 4708 && (*p)->data_size() < first->data_size())) 4709 first = *p; 4710 const Output_data** plast; 4711 if ((*p)->is_section() 4712 && (*p)->output_section()->type() == elfcpp::SHT_NOBITS) 4713 plast = &last_bss; 4714 else 4715 plast = &last_data; 4716 if (*plast == NULL 4717 || (*p)->address() > (*plast)->address() 4718 || ((*p)->address() == (*plast)->address() 4719 && (*p)->data_size() > (*plast)->data_size())) 4720 *plast = *p; 4721 } 4722 4723 this->vaddr_ = first->address(); 4724 this->paddr_ = (first->has_load_address() 4725 ? first->load_address() 4726 : this->vaddr_); 4727 this->are_addresses_set_ = true; 4728 this->offset_ = first->offset(); 4729 4730 if (last_data == NULL) 4731 this->filesz_ = 0; 4732 else 4733 this->filesz_ = (last_data->address() 4734 + last_data->data_size() 4735 - this->vaddr_); 4736 4737 const Output_data* last = last_bss != NULL ? last_bss : last_data; 4738 this->memsz_ = (last->address() 4739 + last->data_size() 4740 - this->vaddr_); 4741 4742 this->filesz_ += increase; 4743 this->memsz_ += increase; 4744 4745 // If this is a RELRO segment, verify that the segment ends at a 4746 // page boundary. 4747 if (this->type_ == elfcpp::PT_GNU_RELRO) 4748 { 4749 uint64_t page_align = parameters->target().abi_pagesize(); 4750 uint64_t segment_end = this->vaddr_ + this->memsz_; 4751 if (parameters->incremental_update()) 4752 { 4753 // The INCREASE_RELRO calculation is bypassed for an incremental 4754 // update, so we need to adjust the segment size manually here. 4755 segment_end = align_address(segment_end, page_align); 4756 this->memsz_ = segment_end - this->vaddr_; 4757 } 4758 else 4759 gold_assert(segment_end == align_address(segment_end, page_align)); 4760 } 4761 4762 // If this is a TLS segment, align the memory size. The code in 4763 // set_section_list ensures that the section after the TLS segment 4764 // is aligned to give us room. 4765 if (this->type_ == elfcpp::PT_TLS) 4766 { 4767 uint64_t segment_align = this->maximum_alignment(); 4768 gold_assert(this->vaddr_ == align_address(this->vaddr_, segment_align)); 4769 this->memsz_ = align_address(this->memsz_, segment_align); 4770 } 4771 } 4772 4773 // Set the TLS offsets of the sections in the PT_TLS segment. 4774 4775 void 4776 Output_segment::set_tls_offsets() 4777 { 4778 gold_assert(this->type_ == elfcpp::PT_TLS); 4779 4780 for (Output_data_list::iterator p = this->output_lists_[0].begin(); 4781 p != this->output_lists_[0].end(); 4782 ++p) 4783 (*p)->set_tls_offset(this->vaddr_); 4784 } 4785 4786 // Return the first section. 4787 4788 Output_section* 4789 Output_segment::first_section() const 4790 { 4791 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i) 4792 { 4793 const Output_data_list* pdl = &this->output_lists_[i]; 4794 for (Output_data_list::const_iterator p = pdl->begin(); 4795 p != pdl->end(); 4796 ++p) 4797 { 4798 if ((*p)->is_section()) 4799 return (*p)->output_section(); 4800 } 4801 } 4802 gold_unreachable(); 4803 } 4804 4805 // Return the number of Output_sections in an Output_segment. 4806 4807 unsigned int 4808 Output_segment::output_section_count() const 4809 { 4810 unsigned int ret = 0; 4811 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i) 4812 ret += this->output_section_count_list(&this->output_lists_[i]); 4813 return ret; 4814 } 4815 4816 // Return the number of Output_sections in an Output_data_list. 4817 4818 unsigned int 4819 Output_segment::output_section_count_list(const Output_data_list* pdl) const 4820 { 4821 unsigned int count = 0; 4822 for (Output_data_list::const_iterator p = pdl->begin(); 4823 p != pdl->end(); 4824 ++p) 4825 { 4826 if ((*p)->is_section()) 4827 ++count; 4828 } 4829 return count; 4830 } 4831 4832 // Return the section attached to the list segment with the lowest 4833 // load address. This is used when handling a PHDRS clause in a 4834 // linker script. 4835 4836 Output_section* 4837 Output_segment::section_with_lowest_load_address() const 4838 { 4839 Output_section* found = NULL; 4840 uint64_t found_lma = 0; 4841 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i) 4842 this->lowest_load_address_in_list(&this->output_lists_[i], &found, 4843 &found_lma); 4844 return found; 4845 } 4846 4847 // Look through a list for a section with a lower load address. 4848 4849 void 4850 Output_segment::lowest_load_address_in_list(const Output_data_list* pdl, 4851 Output_section** found, 4852 uint64_t* found_lma) const 4853 { 4854 for (Output_data_list::const_iterator p = pdl->begin(); 4855 p != pdl->end(); 4856 ++p) 4857 { 4858 if (!(*p)->is_section()) 4859 continue; 4860 Output_section* os = static_cast<Output_section*>(*p); 4861 uint64_t lma = (os->has_load_address() 4862 ? os->load_address() 4863 : os->address()); 4864 if (*found == NULL || lma < *found_lma) 4865 { 4866 *found = os; 4867 *found_lma = lma; 4868 } 4869 } 4870 } 4871 4872 // Write the segment data into *OPHDR. 4873 4874 template<int size, bool big_endian> 4875 void 4876 Output_segment::write_header(elfcpp::Phdr_write<size, big_endian>* ophdr) 4877 { 4878 ophdr->put_p_type(this->type_); 4879 ophdr->put_p_offset(this->offset_); 4880 ophdr->put_p_vaddr(this->vaddr_); 4881 ophdr->put_p_paddr(this->paddr_); 4882 ophdr->put_p_filesz(this->filesz_); 4883 ophdr->put_p_memsz(this->memsz_); 4884 ophdr->put_p_flags(this->flags_); 4885 ophdr->put_p_align(std::max(this->min_p_align_, this->maximum_alignment())); 4886 } 4887 4888 // Write the section headers into V. 4889 4890 template<int size, bool big_endian> 4891 unsigned char* 4892 Output_segment::write_section_headers(const Layout* layout, 4893 const Stringpool* secnamepool, 4894 unsigned char* v, 4895 unsigned int* pshndx) const 4896 { 4897 // Every section that is attached to a segment must be attached to a 4898 // PT_LOAD segment, so we only write out section headers for PT_LOAD 4899 // segments. 4900 if (this->type_ != elfcpp::PT_LOAD) 4901 return v; 4902 4903 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i) 4904 { 4905 const Output_data_list* pdl = &this->output_lists_[i]; 4906 v = this->write_section_headers_list<size, big_endian>(layout, 4907 secnamepool, 4908 pdl, 4909 v, pshndx); 4910 } 4911 4912 return v; 4913 } 4914 4915 template<int size, bool big_endian> 4916 unsigned char* 4917 Output_segment::write_section_headers_list(const Layout* layout, 4918 const Stringpool* secnamepool, 4919 const Output_data_list* pdl, 4920 unsigned char* v, 4921 unsigned int* pshndx) const 4922 { 4923 const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size; 4924 for (Output_data_list::const_iterator p = pdl->begin(); 4925 p != pdl->end(); 4926 ++p) 4927 { 4928 if ((*p)->is_section()) 4929 { 4930 const Output_section* ps = static_cast<const Output_section*>(*p); 4931 gold_assert(*pshndx == ps->out_shndx()); 4932 elfcpp::Shdr_write<size, big_endian> oshdr(v); 4933 ps->write_header(layout, secnamepool, &oshdr); 4934 v += shdr_size; 4935 ++*pshndx; 4936 } 4937 } 4938 return v; 4939 } 4940 4941 // Print the output sections to the map file. 4942 4943 void 4944 Output_segment::print_sections_to_mapfile(Mapfile* mapfile) const 4945 { 4946 if (this->type() != elfcpp::PT_LOAD) 4947 return; 4948 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i) 4949 this->print_section_list_to_mapfile(mapfile, &this->output_lists_[i]); 4950 } 4951 4952 // Print an output section list to the map file. 4953 4954 void 4955 Output_segment::print_section_list_to_mapfile(Mapfile* mapfile, 4956 const Output_data_list* pdl) const 4957 { 4958 for (Output_data_list::const_iterator p = pdl->begin(); 4959 p != pdl->end(); 4960 ++p) 4961 (*p)->print_to_mapfile(mapfile); 4962 } 4963 4964 // Output_file methods. 4965 4966 Output_file::Output_file(const char* name) 4967 : name_(name), 4968 o_(-1), 4969 file_size_(0), 4970 base_(NULL), 4971 map_is_anonymous_(false), 4972 map_is_allocated_(false), 4973 is_temporary_(false) 4974 { 4975 } 4976 4977 // Try to open an existing file. Returns false if the file doesn't 4978 // exist, has a size of 0 or can't be mmapped. If BASE_NAME is not 4979 // NULL, open that file as the base for incremental linking, and 4980 // copy its contents to the new output file. This routine can 4981 // be called for incremental updates, in which case WRITABLE should 4982 // be true, or by the incremental-dump utility, in which case 4983 // WRITABLE should be false. 4984 4985 bool 4986 Output_file::open_base_file(const char* base_name, bool writable) 4987 { 4988 // The name "-" means "stdout". 4989 if (strcmp(this->name_, "-") == 0) 4990 return false; 4991 4992 bool use_base_file = base_name != NULL; 4993 if (!use_base_file) 4994 base_name = this->name_; 4995 else if (strcmp(base_name, this->name_) == 0) 4996 gold_fatal(_("%s: incremental base and output file name are the same"), 4997 base_name); 4998 4999 // Don't bother opening files with a size of zero. 5000 struct stat s; 5001 if (::stat(base_name, &s) != 0) 5002 { 5003 gold_info(_("%s: stat: %s"), base_name, strerror(errno)); 5004 return false; 5005 } 5006 if (s.st_size == 0) 5007 { 5008 gold_info(_("%s: incremental base file is empty"), base_name); 5009 return false; 5010 } 5011 5012 // If we're using a base file, we want to open it read-only. 5013 if (use_base_file) 5014 writable = false; 5015 5016 int oflags = writable ? O_RDWR : O_RDONLY; 5017 int o = open_descriptor(-1, base_name, oflags, 0); 5018 if (o < 0) 5019 { 5020 gold_info(_("%s: open: %s"), base_name, strerror(errno)); 5021 return false; 5022 } 5023 5024 // If the base file and the output file are different, open a 5025 // new output file and read the contents from the base file into 5026 // the newly-mapped region. 5027 if (use_base_file) 5028 { 5029 this->open(s.st_size); 5030 ssize_t bytes_to_read = s.st_size; 5031 unsigned char* p = this->base_; 5032 while (bytes_to_read > 0) 5033 { 5034 ssize_t len = ::read(o, p, bytes_to_read); 5035 if (len < 0) 5036 { 5037 gold_info(_("%s: read failed: %s"), base_name, strerror(errno)); 5038 return false; 5039 } 5040 if (len == 0) 5041 { 5042 gold_info(_("%s: file too short: read only %lld of %lld bytes"), 5043 base_name, 5044 static_cast<long long>(s.st_size - bytes_to_read), 5045 static_cast<long long>(s.st_size)); 5046 return false; 5047 } 5048 p += len; 5049 bytes_to_read -= len; 5050 } 5051 ::close(o); 5052 return true; 5053 } 5054 5055 this->o_ = o; 5056 this->file_size_ = s.st_size; 5057 5058 if (!this->map_no_anonymous(writable)) 5059 { 5060 release_descriptor(o, true); 5061 this->o_ = -1; 5062 this->file_size_ = 0; 5063 return false; 5064 } 5065 5066 return true; 5067 } 5068 5069 // Open the output file. 5070 5071 void 5072 Output_file::open(off_t file_size) 5073 { 5074 this->file_size_ = file_size; 5075 5076 // Unlink the file first; otherwise the open() may fail if the file 5077 // is busy (e.g. it's an executable that's currently being executed). 5078 // 5079 // However, the linker may be part of a system where a zero-length 5080 // file is created for it to write to, with tight permissions (gcc 5081 // 2.95 did something like this). Unlinking the file would work 5082 // around those permission controls, so we only unlink if the file 5083 // has a non-zero size. We also unlink only regular files to avoid 5084 // trouble with directories/etc. 5085 // 5086 // If we fail, continue; this command is merely a best-effort attempt 5087 // to improve the odds for open(). 5088 5089 // We let the name "-" mean "stdout" 5090 if (!this->is_temporary_) 5091 { 5092 if (strcmp(this->name_, "-") == 0) 5093 this->o_ = STDOUT_FILENO; 5094 else 5095 { 5096 struct stat s; 5097 if (::stat(this->name_, &s) == 0 5098 && (S_ISREG (s.st_mode) || S_ISLNK (s.st_mode))) 5099 { 5100 if (s.st_size != 0) 5101 ::unlink(this->name_); 5102 else if (!parameters->options().relocatable()) 5103 { 5104 // If we don't unlink the existing file, add execute 5105 // permission where read permissions already exist 5106 // and where the umask permits. 5107 int mask = ::umask(0); 5108 ::umask(mask); 5109 s.st_mode |= (s.st_mode & 0444) >> 2; 5110 ::chmod(this->name_, s.st_mode & ~mask); 5111 } 5112 } 5113 5114 int mode = parameters->options().relocatable() ? 0666 : 0777; 5115 int o = open_descriptor(-1, this->name_, O_RDWR | O_CREAT | O_TRUNC, 5116 mode); 5117 if (o < 0) 5118 gold_fatal(_("%s: open: %s"), this->name_, strerror(errno)); 5119 this->o_ = o; 5120 } 5121 } 5122 5123 this->map(); 5124 } 5125 5126 // Resize the output file. 5127 5128 void 5129 Output_file::resize(off_t file_size) 5130 { 5131 // If the mmap is mapping an anonymous memory buffer, this is easy: 5132 // just mremap to the new size. If it's mapping to a file, we want 5133 // to unmap to flush to the file, then remap after growing the file. 5134 if (this->map_is_anonymous_) 5135 { 5136 void* base; 5137 if (!this->map_is_allocated_) 5138 { 5139 base = ::mremap(this->base_, this->file_size_, file_size, 5140 MREMAP_MAYMOVE); 5141 if (base == MAP_FAILED) 5142 gold_fatal(_("%s: mremap: %s"), this->name_, strerror(errno)); 5143 } 5144 else 5145 { 5146 base = realloc(this->base_, file_size); 5147 if (base == NULL) 5148 gold_nomem(); 5149 if (file_size > this->file_size_) 5150 memset(static_cast<char*>(base) + this->file_size_, 0, 5151 file_size - this->file_size_); 5152 } 5153 this->base_ = static_cast<unsigned char*>(base); 5154 this->file_size_ = file_size; 5155 } 5156 else 5157 { 5158 this->unmap(); 5159 this->file_size_ = file_size; 5160 if (!this->map_no_anonymous(true)) 5161 gold_fatal(_("%s: mmap: %s"), this->name_, strerror(errno)); 5162 } 5163 } 5164 5165 // Map an anonymous block of memory which will later be written to the 5166 // file. Return whether the map succeeded. 5167 5168 bool 5169 Output_file::map_anonymous() 5170 { 5171 void* base = ::mmap(NULL, this->file_size_, PROT_READ | PROT_WRITE, 5172 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); 5173 if (base == MAP_FAILED) 5174 { 5175 base = malloc(this->file_size_); 5176 if (base == NULL) 5177 return false; 5178 memset(base, 0, this->file_size_); 5179 this->map_is_allocated_ = true; 5180 } 5181 this->base_ = static_cast<unsigned char*>(base); 5182 this->map_is_anonymous_ = true; 5183 return true; 5184 } 5185 5186 // Map the file into memory. Return whether the mapping succeeded. 5187 // If WRITABLE is true, map with write access. 5188 5189 bool 5190 Output_file::map_no_anonymous(bool writable) 5191 { 5192 const int o = this->o_; 5193 5194 // If the output file is not a regular file, don't try to mmap it; 5195 // instead, we'll mmap a block of memory (an anonymous buffer), and 5196 // then later write the buffer to the file. 5197 void* base; 5198 struct stat statbuf; 5199 if (o == STDOUT_FILENO || o == STDERR_FILENO 5200 || ::fstat(o, &statbuf) != 0 5201 || !S_ISREG(statbuf.st_mode) 5202 || this->is_temporary_) 5203 return false; 5204 5205 // Ensure that we have disk space available for the file. If we 5206 // don't do this, it is possible that we will call munmap, close, 5207 // and exit with dirty buffers still in the cache with no assigned 5208 // disk blocks. If the disk is out of space at that point, the 5209 // output file will wind up incomplete, but we will have already 5210 // exited. The alternative to fallocate would be to use fdatasync, 5211 // but that would be a more significant performance hit. 5212 if (writable) 5213 { 5214 int err = gold_fallocate(o, 0, this->file_size_); 5215 if (err != 0) 5216 gold_fatal(_("%s: %s"), this->name_, strerror(err)); 5217 } 5218 5219 // Map the file into memory. 5220 int prot = PROT_READ; 5221 if (writable) 5222 prot |= PROT_WRITE; 5223 base = ::mmap(NULL, this->file_size_, prot, MAP_SHARED, o, 0); 5224 5225 // The mmap call might fail because of file system issues: the file 5226 // system might not support mmap at all, or it might not support 5227 // mmap with PROT_WRITE. 5228 if (base == MAP_FAILED) 5229 return false; 5230 5231 this->map_is_anonymous_ = false; 5232 this->base_ = static_cast<unsigned char*>(base); 5233 return true; 5234 } 5235 5236 // Map the file into memory. 5237 5238 void 5239 Output_file::map() 5240 { 5241 if (parameters->options().mmap_output_file() 5242 && this->map_no_anonymous(true)) 5243 return; 5244 5245 // The mmap call might fail because of file system issues: the file 5246 // system might not support mmap at all, or it might not support 5247 // mmap with PROT_WRITE. I'm not sure which errno values we will 5248 // see in all cases, so if the mmap fails for any reason and we 5249 // don't care about file contents, try for an anonymous map. 5250 if (this->map_anonymous()) 5251 return; 5252 5253 gold_fatal(_("%s: mmap: failed to allocate %lu bytes for output file: %s"), 5254 this->name_, static_cast<unsigned long>(this->file_size_), 5255 strerror(errno)); 5256 } 5257 5258 // Unmap the file from memory. 5259 5260 void 5261 Output_file::unmap() 5262 { 5263 if (this->map_is_anonymous_) 5264 { 5265 // We've already written out the data, so there is no reason to 5266 // waste time unmapping or freeing the memory. 5267 } 5268 else 5269 { 5270 if (::munmap(this->base_, this->file_size_) < 0) 5271 gold_error(_("%s: munmap: %s"), this->name_, strerror(errno)); 5272 } 5273 this->base_ = NULL; 5274 } 5275 5276 // Close the output file. 5277 5278 void 5279 Output_file::close() 5280 { 5281 // If the map isn't file-backed, we need to write it now. 5282 if (this->map_is_anonymous_ && !this->is_temporary_) 5283 { 5284 size_t bytes_to_write = this->file_size_; 5285 size_t offset = 0; 5286 while (bytes_to_write > 0) 5287 { 5288 ssize_t bytes_written = ::write(this->o_, this->base_ + offset, 5289 bytes_to_write); 5290 if (bytes_written == 0) 5291 gold_error(_("%s: write: unexpected 0 return-value"), this->name_); 5292 else if (bytes_written < 0) 5293 gold_error(_("%s: write: %s"), this->name_, strerror(errno)); 5294 else 5295 { 5296 bytes_to_write -= bytes_written; 5297 offset += bytes_written; 5298 } 5299 } 5300 } 5301 this->unmap(); 5302 5303 // We don't close stdout or stderr 5304 if (this->o_ != STDOUT_FILENO 5305 && this->o_ != STDERR_FILENO 5306 && !this->is_temporary_) 5307 if (::close(this->o_) < 0) 5308 gold_error(_("%s: close: %s"), this->name_, strerror(errno)); 5309 this->o_ = -1; 5310 } 5311 5312 // Instantiate the templates we need. We could use the configure 5313 // script to restrict this to only the ones for implemented targets. 5314 5315 #ifdef HAVE_TARGET_32_LITTLE 5316 template 5317 off_t 5318 Output_section::add_input_section<32, false>( 5319 Layout* layout, 5320 Sized_relobj_file<32, false>* object, 5321 unsigned int shndx, 5322 const char* secname, 5323 const elfcpp::Shdr<32, false>& shdr, 5324 unsigned int reloc_shndx, 5325 bool have_sections_script); 5326 #endif 5327 5328 #ifdef HAVE_TARGET_32_BIG 5329 template 5330 off_t 5331 Output_section::add_input_section<32, true>( 5332 Layout* layout, 5333 Sized_relobj_file<32, true>* object, 5334 unsigned int shndx, 5335 const char* secname, 5336 const elfcpp::Shdr<32, true>& shdr, 5337 unsigned int reloc_shndx, 5338 bool have_sections_script); 5339 #endif 5340 5341 #ifdef HAVE_TARGET_64_LITTLE 5342 template 5343 off_t 5344 Output_section::add_input_section<64, false>( 5345 Layout* layout, 5346 Sized_relobj_file<64, false>* object, 5347 unsigned int shndx, 5348 const char* secname, 5349 const elfcpp::Shdr<64, false>& shdr, 5350 unsigned int reloc_shndx, 5351 bool have_sections_script); 5352 #endif 5353 5354 #ifdef HAVE_TARGET_64_BIG 5355 template 5356 off_t 5357 Output_section::add_input_section<64, true>( 5358 Layout* layout, 5359 Sized_relobj_file<64, true>* object, 5360 unsigned int shndx, 5361 const char* secname, 5362 const elfcpp::Shdr<64, true>& shdr, 5363 unsigned int reloc_shndx, 5364 bool have_sections_script); 5365 #endif 5366 5367 #ifdef HAVE_TARGET_32_LITTLE 5368 template 5369 class Output_reloc<elfcpp::SHT_REL, false, 32, false>; 5370 #endif 5371 5372 #ifdef HAVE_TARGET_32_BIG 5373 template 5374 class Output_reloc<elfcpp::SHT_REL, false, 32, true>; 5375 #endif 5376 5377 #ifdef HAVE_TARGET_64_LITTLE 5378 template 5379 class Output_reloc<elfcpp::SHT_REL, false, 64, false>; 5380 #endif 5381 5382 #ifdef HAVE_TARGET_64_BIG 5383 template 5384 class Output_reloc<elfcpp::SHT_REL, false, 64, true>; 5385 #endif 5386 5387 #ifdef HAVE_TARGET_32_LITTLE 5388 template 5389 class Output_reloc<elfcpp::SHT_REL, true, 32, false>; 5390 #endif 5391 5392 #ifdef HAVE_TARGET_32_BIG 5393 template 5394 class Output_reloc<elfcpp::SHT_REL, true, 32, true>; 5395 #endif 5396 5397 #ifdef HAVE_TARGET_64_LITTLE 5398 template 5399 class Output_reloc<elfcpp::SHT_REL, true, 64, false>; 5400 #endif 5401 5402 #ifdef HAVE_TARGET_64_BIG 5403 template 5404 class Output_reloc<elfcpp::SHT_REL, true, 64, true>; 5405 #endif 5406 5407 #ifdef HAVE_TARGET_32_LITTLE 5408 template 5409 class Output_reloc<elfcpp::SHT_RELA, false, 32, false>; 5410 #endif 5411 5412 #ifdef HAVE_TARGET_32_BIG 5413 template 5414 class Output_reloc<elfcpp::SHT_RELA, false, 32, true>; 5415 #endif 5416 5417 #ifdef HAVE_TARGET_64_LITTLE 5418 template 5419 class Output_reloc<elfcpp::SHT_RELA, false, 64, false>; 5420 #endif 5421 5422 #ifdef HAVE_TARGET_64_BIG 5423 template 5424 class Output_reloc<elfcpp::SHT_RELA, false, 64, true>; 5425 #endif 5426 5427 #ifdef HAVE_TARGET_32_LITTLE 5428 template 5429 class Output_reloc<elfcpp::SHT_RELA, true, 32, false>; 5430 #endif 5431 5432 #ifdef HAVE_TARGET_32_BIG 5433 template 5434 class Output_reloc<elfcpp::SHT_RELA, true, 32, true>; 5435 #endif 5436 5437 #ifdef HAVE_TARGET_64_LITTLE 5438 template 5439 class Output_reloc<elfcpp::SHT_RELA, true, 64, false>; 5440 #endif 5441 5442 #ifdef HAVE_TARGET_64_BIG 5443 template 5444 class Output_reloc<elfcpp::SHT_RELA, true, 64, true>; 5445 #endif 5446 5447 #ifdef HAVE_TARGET_32_LITTLE 5448 template 5449 class Output_data_reloc<elfcpp::SHT_REL, false, 32, false>; 5450 #endif 5451 5452 #ifdef HAVE_TARGET_32_BIG 5453 template 5454 class Output_data_reloc<elfcpp::SHT_REL, false, 32, true>; 5455 #endif 5456 5457 #ifdef HAVE_TARGET_64_LITTLE 5458 template 5459 class Output_data_reloc<elfcpp::SHT_REL, false, 64, false>; 5460 #endif 5461 5462 #ifdef HAVE_TARGET_64_BIG 5463 template 5464 class Output_data_reloc<elfcpp::SHT_REL, false, 64, true>; 5465 #endif 5466 5467 #ifdef HAVE_TARGET_32_LITTLE 5468 template 5469 class Output_data_reloc<elfcpp::SHT_REL, true, 32, false>; 5470 #endif 5471 5472 #ifdef HAVE_TARGET_32_BIG 5473 template 5474 class Output_data_reloc<elfcpp::SHT_REL, true, 32, true>; 5475 #endif 5476 5477 #ifdef HAVE_TARGET_64_LITTLE 5478 template 5479 class Output_data_reloc<elfcpp::SHT_REL, true, 64, false>; 5480 #endif 5481 5482 #ifdef HAVE_TARGET_64_BIG 5483 template 5484 class Output_data_reloc<elfcpp::SHT_REL, true, 64, true>; 5485 #endif 5486 5487 #ifdef HAVE_TARGET_32_LITTLE 5488 template 5489 class Output_data_reloc<elfcpp::SHT_RELA, false, 32, false>; 5490 #endif 5491 5492 #ifdef HAVE_TARGET_32_BIG 5493 template 5494 class Output_data_reloc<elfcpp::SHT_RELA, false, 32, true>; 5495 #endif 5496 5497 #ifdef HAVE_TARGET_64_LITTLE 5498 template 5499 class Output_data_reloc<elfcpp::SHT_RELA, false, 64, false>; 5500 #endif 5501 5502 #ifdef HAVE_TARGET_64_BIG 5503 template 5504 class Output_data_reloc<elfcpp::SHT_RELA, false, 64, true>; 5505 #endif 5506 5507 #ifdef HAVE_TARGET_32_LITTLE 5508 template 5509 class Output_data_reloc<elfcpp::SHT_RELA, true, 32, false>; 5510 #endif 5511 5512 #ifdef HAVE_TARGET_32_BIG 5513 template 5514 class Output_data_reloc<elfcpp::SHT_RELA, true, 32, true>; 5515 #endif 5516 5517 #ifdef HAVE_TARGET_64_LITTLE 5518 template 5519 class Output_data_reloc<elfcpp::SHT_RELA, true, 64, false>; 5520 #endif 5521 5522 #ifdef HAVE_TARGET_64_BIG 5523 template 5524 class Output_data_reloc<elfcpp::SHT_RELA, true, 64, true>; 5525 #endif 5526 5527 #ifdef HAVE_TARGET_32_LITTLE 5528 template 5529 class Output_data_reloc<elfcpp::SHT_RELR, true, 32, false>; 5530 #endif 5531 5532 #ifdef HAVE_TARGET_32_BIG 5533 template 5534 class Output_data_reloc<elfcpp::SHT_RELR, true, 32, true>; 5535 #endif 5536 5537 #ifdef HAVE_TARGET_64_LITTLE 5538 template 5539 class Output_data_reloc<elfcpp::SHT_RELR, true, 64, false>; 5540 #endif 5541 5542 #ifdef HAVE_TARGET_64_BIG 5543 template 5544 class Output_data_reloc<elfcpp::SHT_RELR, true, 64, true>; 5545 #endif 5546 5547 #ifdef HAVE_TARGET_32_LITTLE 5548 template 5549 class Output_relocatable_relocs<elfcpp::SHT_REL, 32, false>; 5550 #endif 5551 5552 #ifdef HAVE_TARGET_32_BIG 5553 template 5554 class Output_relocatable_relocs<elfcpp::SHT_REL, 32, true>; 5555 #endif 5556 5557 #ifdef HAVE_TARGET_64_LITTLE 5558 template 5559 class Output_relocatable_relocs<elfcpp::SHT_REL, 64, false>; 5560 #endif 5561 5562 #ifdef HAVE_TARGET_64_BIG 5563 template 5564 class Output_relocatable_relocs<elfcpp::SHT_REL, 64, true>; 5565 #endif 5566 5567 #ifdef HAVE_TARGET_32_LITTLE 5568 template 5569 class Output_relocatable_relocs<elfcpp::SHT_RELA, 32, false>; 5570 #endif 5571 5572 #ifdef HAVE_TARGET_32_BIG 5573 template 5574 class Output_relocatable_relocs<elfcpp::SHT_RELA, 32, true>; 5575 #endif 5576 5577 #ifdef HAVE_TARGET_64_LITTLE 5578 template 5579 class Output_relocatable_relocs<elfcpp::SHT_RELA, 64, false>; 5580 #endif 5581 5582 #ifdef HAVE_TARGET_64_BIG 5583 template 5584 class Output_relocatable_relocs<elfcpp::SHT_RELA, 64, true>; 5585 #endif 5586 5587 #ifdef HAVE_TARGET_32_LITTLE 5588 template 5589 class Output_data_group<32, false>; 5590 #endif 5591 5592 #ifdef HAVE_TARGET_32_BIG 5593 template 5594 class Output_data_group<32, true>; 5595 #endif 5596 5597 #ifdef HAVE_TARGET_64_LITTLE 5598 template 5599 class Output_data_group<64, false>; 5600 #endif 5601 5602 #ifdef HAVE_TARGET_64_BIG 5603 template 5604 class Output_data_group<64, true>; 5605 #endif 5606 5607 template 5608 class Output_data_got<32, false>; 5609 5610 template 5611 class Output_data_got<32, true>; 5612 5613 template 5614 class Output_data_got<64, false>; 5615 5616 template 5617 class Output_data_got<64, true>; 5618 5619 } // End namespace gold. 5620