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