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