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