1// layout.cc -- lay out output file sections for gold 2 3// Copyright (C) 2006-2017 Free Software Foundation, Inc. 4// Written by Ian Lance Taylor <iant@google.com>. 5 6// This file is part of gold. 7 8// This program is free software; you can redistribute it and/or modify 9// it under the terms of the GNU General Public License as published by 10// the Free Software Foundation; either version 3 of the License, or 11// (at your option) any later version. 12 13// This program is distributed in the hope that it will be useful, 14// but WITHOUT ANY WARRANTY; without even the implied warranty of 15// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16// GNU General Public License for more details. 17 18// You should have received a copy of the GNU General Public License 19// along with this program; if not, write to the Free Software 20// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 21// MA 02110-1301, USA. 22 23#include "gold.h" 24 25#include <cerrno> 26#include <cstring> 27#include <algorithm> 28#include <iostream> 29#include <fstream> 30#include <utility> 31#include <fcntl.h> 32#include <fnmatch.h> 33#include <unistd.h> 34#include "libiberty.h" 35#include "md5.h" 36#include "sha1.h" 37#ifdef __MINGW32__ 38#include <windows.h> 39#include <rpcdce.h> 40#endif 41 42#include "parameters.h" 43#include "options.h" 44#include "mapfile.h" 45#include "script.h" 46#include "script-sections.h" 47#include "output.h" 48#include "symtab.h" 49#include "dynobj.h" 50#include "ehframe.h" 51#include "gdb-index.h" 52#include "compressed_output.h" 53#include "reduced_debug_output.h" 54#include "object.h" 55#include "reloc.h" 56#include "descriptors.h" 57#include "plugin.h" 58#include "incremental.h" 59#include "layout.h" 60 61namespace gold 62{ 63 64// Class Free_list. 65 66// The total number of free lists used. 67unsigned int Free_list::num_lists = 0; 68// The total number of free list nodes used. 69unsigned int Free_list::num_nodes = 0; 70// The total number of calls to Free_list::remove. 71unsigned int Free_list::num_removes = 0; 72// The total number of nodes visited during calls to Free_list::remove. 73unsigned int Free_list::num_remove_visits = 0; 74// The total number of calls to Free_list::allocate. 75unsigned int Free_list::num_allocates = 0; 76// The total number of nodes visited during calls to Free_list::allocate. 77unsigned int Free_list::num_allocate_visits = 0; 78 79// Initialize the free list. Creates a single free list node that 80// describes the entire region of length LEN. If EXTEND is true, 81// allocate() is allowed to extend the region beyond its initial 82// length. 83 84void 85Free_list::init(off_t len, bool extend) 86{ 87 this->list_.push_front(Free_list_node(0, len)); 88 this->last_remove_ = this->list_.begin(); 89 this->extend_ = extend; 90 this->length_ = len; 91 ++Free_list::num_lists; 92 ++Free_list::num_nodes; 93} 94 95// Remove a chunk from the free list. Because we start with a single 96// node that covers the entire section, and remove chunks from it one 97// at a time, we do not need to coalesce chunks or handle cases that 98// span more than one free node. We expect to remove chunks from the 99// free list in order, and we expect to have only a few chunks of free 100// space left (corresponding to files that have changed since the last 101// incremental link), so a simple linear list should provide sufficient 102// performance. 103 104void 105Free_list::remove(off_t start, off_t end) 106{ 107 if (start == end) 108 return; 109 gold_assert(start < end); 110 111 ++Free_list::num_removes; 112 113 Iterator p = this->last_remove_; 114 if (p->start_ > start) 115 p = this->list_.begin(); 116 117 for (; p != this->list_.end(); ++p) 118 { 119 ++Free_list::num_remove_visits; 120 // Find a node that wholly contains the indicated region. 121 if (p->start_ <= start && p->end_ >= end) 122 { 123 // Case 1: the indicated region spans the whole node. 124 // Add some fuzz to avoid creating tiny free chunks. 125 if (p->start_ + 3 >= start && p->end_ <= end + 3) 126 p = this->list_.erase(p); 127 // Case 2: remove a chunk from the start of the node. 128 else if (p->start_ + 3 >= start) 129 p->start_ = end; 130 // Case 3: remove a chunk from the end of the node. 131 else if (p->end_ <= end + 3) 132 p->end_ = start; 133 // Case 4: remove a chunk from the middle, and split 134 // the node into two. 135 else 136 { 137 Free_list_node newnode(p->start_, start); 138 p->start_ = end; 139 this->list_.insert(p, newnode); 140 ++Free_list::num_nodes; 141 } 142 this->last_remove_ = p; 143 return; 144 } 145 } 146 147 // Did not find a node containing the given chunk. This could happen 148 // because a small chunk was already removed due to the fuzz. 149 gold_debug(DEBUG_INCREMENTAL, 150 "Free_list::remove(%d,%d) not found", 151 static_cast<int>(start), static_cast<int>(end)); 152} 153 154// Allocate a chunk of size LEN from the free list. Returns -1ULL 155// if a sufficiently large chunk of free space is not found. 156// We use a simple first-fit algorithm. 157 158off_t 159Free_list::allocate(off_t len, uint64_t align, off_t minoff) 160{ 161 gold_debug(DEBUG_INCREMENTAL, 162 "Free_list::allocate(%08lx, %d, %08lx)", 163 static_cast<long>(len), static_cast<int>(align), 164 static_cast<long>(minoff)); 165 if (len == 0) 166 return align_address(minoff, align); 167 168 ++Free_list::num_allocates; 169 170 // We usually want to drop free chunks smaller than 4 bytes. 171 // If we need to guarantee a minimum hole size, though, we need 172 // to keep track of all free chunks. 173 const int fuzz = this->min_hole_ > 0 ? 0 : 3; 174 175 for (Iterator p = this->list_.begin(); p != this->list_.end(); ++p) 176 { 177 ++Free_list::num_allocate_visits; 178 off_t start = p->start_ > minoff ? p->start_ : minoff; 179 start = align_address(start, align); 180 off_t end = start + len; 181 if (end > p->end_ && p->end_ == this->length_ && this->extend_) 182 { 183 this->length_ = end; 184 p->end_ = end; 185 } 186 if (end == p->end_ || (end <= p->end_ - this->min_hole_)) 187 { 188 if (p->start_ + fuzz >= start && p->end_ <= end + fuzz) 189 this->list_.erase(p); 190 else if (p->start_ + fuzz >= start) 191 p->start_ = end; 192 else if (p->end_ <= end + fuzz) 193 p->end_ = start; 194 else 195 { 196 Free_list_node newnode(p->start_, start); 197 p->start_ = end; 198 this->list_.insert(p, newnode); 199 ++Free_list::num_nodes; 200 } 201 return start; 202 } 203 } 204 if (this->extend_) 205 { 206 off_t start = align_address(this->length_, align); 207 this->length_ = start + len; 208 return start; 209 } 210 return -1; 211} 212 213// Dump the free list (for debugging). 214void 215Free_list::dump() 216{ 217 gold_info("Free list:\n start end length\n"); 218 for (Iterator p = this->list_.begin(); p != this->list_.end(); ++p) 219 gold_info(" %08lx %08lx %08lx", static_cast<long>(p->start_), 220 static_cast<long>(p->end_), 221 static_cast<long>(p->end_ - p->start_)); 222} 223 224// Print the statistics for the free lists. 225void 226Free_list::print_stats() 227{ 228 fprintf(stderr, _("%s: total free lists: %u\n"), 229 program_name, Free_list::num_lists); 230 fprintf(stderr, _("%s: total free list nodes: %u\n"), 231 program_name, Free_list::num_nodes); 232 fprintf(stderr, _("%s: calls to Free_list::remove: %u\n"), 233 program_name, Free_list::num_removes); 234 fprintf(stderr, _("%s: nodes visited: %u\n"), 235 program_name, Free_list::num_remove_visits); 236 fprintf(stderr, _("%s: calls to Free_list::allocate: %u\n"), 237 program_name, Free_list::num_allocates); 238 fprintf(stderr, _("%s: nodes visited: %u\n"), 239 program_name, Free_list::num_allocate_visits); 240} 241 242// A Hash_task computes the MD5 checksum of an array of char. 243 244class Hash_task : public Task 245{ 246 public: 247 Hash_task(Output_file* of, 248 size_t offset, 249 size_t size, 250 unsigned char* dst, 251 Task_token* final_blocker) 252 : of_(of), offset_(offset), size_(size), dst_(dst), 253 final_blocker_(final_blocker) 254 { } 255 256 void 257 run(Workqueue*) 258 { 259 const unsigned char* iv = 260 this->of_->get_input_view(this->offset_, this->size_); 261 md5_buffer(reinterpret_cast<const char*>(iv), this->size_, this->dst_); 262 this->of_->free_input_view(this->offset_, this->size_, iv); 263 } 264 265 Task_token* 266 is_runnable() 267 { return NULL; } 268 269 // Unblock FINAL_BLOCKER_ when done. 270 void 271 locks(Task_locker* tl) 272 { tl->add(this, this->final_blocker_); } 273 274 std::string 275 get_name() const 276 { return "Hash_task"; } 277 278 private: 279 Output_file* of_; 280 const size_t offset_; 281 const size_t size_; 282 unsigned char* const dst_; 283 Task_token* const final_blocker_; 284}; 285 286// Layout::Relaxation_debug_check methods. 287 288// Check that sections and special data are in reset states. 289// We do not save states for Output_sections and special Output_data. 290// So we check that they have not assigned any addresses or offsets. 291// clean_up_after_relaxation simply resets their addresses and offsets. 292void 293Layout::Relaxation_debug_check::check_output_data_for_reset_values( 294 const Layout::Section_list& sections, 295 const Layout::Data_list& special_outputs, 296 const Layout::Data_list& relax_outputs) 297{ 298 for(Layout::Section_list::const_iterator p = sections.begin(); 299 p != sections.end(); 300 ++p) 301 gold_assert((*p)->address_and_file_offset_have_reset_values()); 302 303 for(Layout::Data_list::const_iterator p = special_outputs.begin(); 304 p != special_outputs.end(); 305 ++p) 306 gold_assert((*p)->address_and_file_offset_have_reset_values()); 307 308 gold_assert(relax_outputs.empty()); 309} 310 311// Save information of SECTIONS for checking later. 312 313void 314Layout::Relaxation_debug_check::read_sections( 315 const Layout::Section_list& sections) 316{ 317 for(Layout::Section_list::const_iterator p = sections.begin(); 318 p != sections.end(); 319 ++p) 320 { 321 Output_section* os = *p; 322 Section_info info; 323 info.output_section = os; 324 info.address = os->is_address_valid() ? os->address() : 0; 325 info.data_size = os->is_data_size_valid() ? os->data_size() : -1; 326 info.offset = os->is_offset_valid()? os->offset() : -1 ; 327 this->section_infos_.push_back(info); 328 } 329} 330 331// Verify SECTIONS using previously recorded information. 332 333void 334Layout::Relaxation_debug_check::verify_sections( 335 const Layout::Section_list& sections) 336{ 337 size_t i = 0; 338 for(Layout::Section_list::const_iterator p = sections.begin(); 339 p != sections.end(); 340 ++p, ++i) 341 { 342 Output_section* os = *p; 343 uint64_t address = os->is_address_valid() ? os->address() : 0; 344 off_t data_size = os->is_data_size_valid() ? os->data_size() : -1; 345 off_t offset = os->is_offset_valid()? os->offset() : -1 ; 346 347 if (i >= this->section_infos_.size()) 348 { 349 gold_fatal("Section_info of %s missing.\n", os->name()); 350 } 351 const Section_info& info = this->section_infos_[i]; 352 if (os != info.output_section) 353 gold_fatal("Section order changed. Expecting %s but see %s\n", 354 info.output_section->name(), os->name()); 355 if (address != info.address 356 || data_size != info.data_size 357 || offset != info.offset) 358 gold_fatal("Section %s changed.\n", os->name()); 359 } 360} 361 362// Layout_task_runner methods. 363 364// Lay out the sections. This is called after all the input objects 365// have been read. 366 367void 368Layout_task_runner::run(Workqueue* workqueue, const Task* task) 369{ 370 // See if any of the input definitions violate the One Definition Rule. 371 // TODO: if this is too slow, do this as a task, rather than inline. 372 this->symtab_->detect_odr_violations(task, this->options_.output_file_name()); 373 374 Layout* layout = this->layout_; 375 off_t file_size = layout->finalize(this->input_objects_, 376 this->symtab_, 377 this->target_, 378 task); 379 380 // Now we know the final size of the output file and we know where 381 // each piece of information goes. 382 383 if (this->mapfile_ != NULL) 384 { 385 this->mapfile_->print_discarded_sections(this->input_objects_); 386 layout->print_to_mapfile(this->mapfile_); 387 } 388 389 Output_file* of; 390 if (layout->incremental_base() == NULL) 391 { 392 of = new Output_file(parameters->options().output_file_name()); 393 if (this->options_.oformat_enum() != General_options::OBJECT_FORMAT_ELF) 394 of->set_is_temporary(); 395 of->open(file_size); 396 } 397 else 398 { 399 of = layout->incremental_base()->output_file(); 400 401 // Apply the incremental relocations for symbols whose values 402 // have changed. We do this before we resize the file and start 403 // writing anything else to it, so that we can read the old 404 // incremental information from the file before (possibly) 405 // overwriting it. 406 if (parameters->incremental_update()) 407 layout->incremental_base()->apply_incremental_relocs(this->symtab_, 408 this->layout_, 409 of); 410 411 of->resize(file_size); 412 } 413 414 // Queue up the final set of tasks. 415 gold::queue_final_tasks(this->options_, this->input_objects_, 416 this->symtab_, layout, workqueue, of); 417} 418 419// Layout methods. 420 421Layout::Layout(int number_of_input_files, Script_options* script_options) 422 : number_of_input_files_(number_of_input_files), 423 script_options_(script_options), 424 namepool_(), 425 sympool_(), 426 dynpool_(), 427 signatures_(), 428 section_name_map_(), 429 segment_list_(), 430 section_list_(), 431 unattached_section_list_(), 432 special_output_list_(), 433 relax_output_list_(), 434 section_headers_(NULL), 435 tls_segment_(NULL), 436 relro_segment_(NULL), 437 interp_segment_(NULL), 438 increase_relro_(0), 439 symtab_section_(NULL), 440 symtab_xindex_(NULL), 441 dynsym_section_(NULL), 442 dynsym_xindex_(NULL), 443 dynamic_section_(NULL), 444 dynamic_symbol_(NULL), 445 dynamic_data_(NULL), 446 eh_frame_section_(NULL), 447 eh_frame_data_(NULL), 448 added_eh_frame_data_(false), 449 eh_frame_hdr_section_(NULL), 450 gdb_index_data_(NULL), 451 build_id_note_(NULL), 452 debug_abbrev_(NULL), 453 debug_info_(NULL), 454 group_signatures_(), 455 output_file_size_(-1), 456 have_added_input_section_(false), 457 sections_are_attached_(false), 458 input_requires_executable_stack_(false), 459 input_with_gnu_stack_note_(false), 460 input_without_gnu_stack_note_(false), 461 has_static_tls_(false), 462 any_postprocessing_sections_(false), 463 resized_signatures_(false), 464 have_stabstr_section_(false), 465 section_ordering_specified_(false), 466 unique_segment_for_sections_specified_(false), 467 incremental_inputs_(NULL), 468 record_output_section_data_from_script_(false), 469 script_output_section_data_list_(), 470 segment_states_(NULL), 471 relaxation_debug_check_(NULL), 472 section_order_map_(), 473 section_segment_map_(), 474 input_section_position_(), 475 input_section_glob_(), 476 incremental_base_(NULL), 477 free_list_() 478{ 479 // Make space for more than enough segments for a typical file. 480 // This is just for efficiency--it's OK if we wind up needing more. 481 this->segment_list_.reserve(12); 482 483 // We expect two unattached Output_data objects: the file header and 484 // the segment headers. 485 this->special_output_list_.reserve(2); 486 487 // Initialize structure needed for an incremental build. 488 if (parameters->incremental()) 489 this->incremental_inputs_ = new Incremental_inputs; 490 491 // The section name pool is worth optimizing in all cases, because 492 // it is small, but there are often overlaps due to .rel sections. 493 this->namepool_.set_optimize(); 494} 495 496// For incremental links, record the base file to be modified. 497 498void 499Layout::set_incremental_base(Incremental_binary* base) 500{ 501 this->incremental_base_ = base; 502 this->free_list_.init(base->output_file()->filesize(), true); 503} 504 505// Hash a key we use to look up an output section mapping. 506 507size_t 508Layout::Hash_key::operator()(const Layout::Key& k) const 509{ 510 return k.first + k.second.first + k.second.second; 511} 512 513// These are the debug sections that are actually used by gdb. 514// Currently, we've checked versions of gdb up to and including 7.4. 515// We only check the part of the name that follows ".debug_" or 516// ".zdebug_". 517 518static const char* gdb_sections[] = 519{ 520 "abbrev", 521 "addr", // Fission extension 522 // "aranges", // not used by gdb as of 7.4 523 "frame", 524 "gdb_scripts", 525 "info", 526 "types", 527 "line", 528 "loc", 529 "macinfo", 530 "macro", 531 // "pubnames", // not used by gdb as of 7.4 532 // "pubtypes", // not used by gdb as of 7.4 533 // "gnu_pubnames", // Fission extension 534 // "gnu_pubtypes", // Fission extension 535 "ranges", 536 "str", 537 "str_offsets", 538}; 539 540// This is the minimum set of sections needed for line numbers. 541 542static const char* lines_only_debug_sections[] = 543{ 544 "abbrev", 545 // "addr", // Fission extension 546 // "aranges", // not used by gdb as of 7.4 547 // "frame", 548 // "gdb_scripts", 549 "info", 550 // "types", 551 "line", 552 // "loc", 553 // "macinfo", 554 // "macro", 555 // "pubnames", // not used by gdb as of 7.4 556 // "pubtypes", // not used by gdb as of 7.4 557 // "gnu_pubnames", // Fission extension 558 // "gnu_pubtypes", // Fission extension 559 // "ranges", 560 "str", 561 "str_offsets", // Fission extension 562}; 563 564// These sections are the DWARF fast-lookup tables, and are not needed 565// when building a .gdb_index section. 566 567static const char* gdb_fast_lookup_sections[] = 568{ 569 "aranges", 570 "pubnames", 571 "gnu_pubnames", 572 "pubtypes", 573 "gnu_pubtypes", 574}; 575 576// Returns whether the given debug section is in the list of 577// debug-sections-used-by-some-version-of-gdb. SUFFIX is the 578// portion of the name following ".debug_" or ".zdebug_". 579 580static inline bool 581is_gdb_debug_section(const char* suffix) 582{ 583 // We can do this faster: binary search or a hashtable. But why bother? 584 for (size_t i = 0; i < sizeof(gdb_sections)/sizeof(*gdb_sections); ++i) 585 if (strcmp(suffix, gdb_sections[i]) == 0) 586 return true; 587 return false; 588} 589 590// Returns whether the given section is needed for lines-only debugging. 591 592static inline bool 593is_lines_only_debug_section(const char* suffix) 594{ 595 // We can do this faster: binary search or a hashtable. But why bother? 596 for (size_t i = 0; 597 i < sizeof(lines_only_debug_sections)/sizeof(*lines_only_debug_sections); 598 ++i) 599 if (strcmp(suffix, lines_only_debug_sections[i]) == 0) 600 return true; 601 return false; 602} 603 604// Returns whether the given section is a fast-lookup section that 605// will not be needed when building a .gdb_index section. 606 607static inline bool 608is_gdb_fast_lookup_section(const char* suffix) 609{ 610 // We can do this faster: binary search or a hashtable. But why bother? 611 for (size_t i = 0; 612 i < sizeof(gdb_fast_lookup_sections)/sizeof(*gdb_fast_lookup_sections); 613 ++i) 614 if (strcmp(suffix, gdb_fast_lookup_sections[i]) == 0) 615 return true; 616 return false; 617} 618 619// Sometimes we compress sections. This is typically done for 620// sections that are not part of normal program execution (such as 621// .debug_* sections), and where the readers of these sections know 622// how to deal with compressed sections. This routine doesn't say for 623// certain whether we'll compress -- it depends on commandline options 624// as well -- just whether this section is a candidate for compression. 625// (The Output_compressed_section class decides whether to compress 626// a given section, and picks the name of the compressed section.) 627 628static bool 629is_compressible_debug_section(const char* secname) 630{ 631 return (is_prefix_of(".debug", secname)); 632} 633 634// We may see compressed debug sections in input files. Return TRUE 635// if this is the name of a compressed debug section. 636 637bool 638is_compressed_debug_section(const char* secname) 639{ 640 return (is_prefix_of(".zdebug", secname)); 641} 642 643std::string 644corresponding_uncompressed_section_name(std::string secname) 645{ 646 gold_assert(secname[0] == '.' && secname[1] == 'z'); 647 std::string ret("."); 648 ret.append(secname, 2, std::string::npos); 649 return ret; 650} 651 652// Whether to include this section in the link. 653 654template<int size, bool big_endian> 655bool 656Layout::include_section(Sized_relobj_file<size, big_endian>*, const char* name, 657 const elfcpp::Shdr<size, big_endian>& shdr) 658{ 659 if (!parameters->options().relocatable() 660 && (shdr.get_sh_flags() & elfcpp::SHF_EXCLUDE)) 661 return false; 662 663 elfcpp::Elf_Word sh_type = shdr.get_sh_type(); 664 665 if ((sh_type >= elfcpp::SHT_LOOS && sh_type <= elfcpp::SHT_HIOS) 666 || (sh_type >= elfcpp::SHT_LOPROC && sh_type <= elfcpp::SHT_HIPROC)) 667 return parameters->target().should_include_section(sh_type); 668 669 switch (sh_type) 670 { 671 case elfcpp::SHT_NULL: 672 case elfcpp::SHT_SYMTAB: 673 case elfcpp::SHT_DYNSYM: 674 case elfcpp::SHT_HASH: 675 case elfcpp::SHT_DYNAMIC: 676 case elfcpp::SHT_SYMTAB_SHNDX: 677 return false; 678 679 case elfcpp::SHT_STRTAB: 680 // Discard the sections which have special meanings in the ELF 681 // ABI. Keep others (e.g., .stabstr). We could also do this by 682 // checking the sh_link fields of the appropriate sections. 683 return (strcmp(name, ".dynstr") != 0 684 && strcmp(name, ".strtab") != 0 685 && strcmp(name, ".shstrtab") != 0); 686 687 case elfcpp::SHT_RELA: 688 case elfcpp::SHT_REL: 689 case elfcpp::SHT_GROUP: 690 // If we are emitting relocations these should be handled 691 // elsewhere. 692 gold_assert(!parameters->options().relocatable()); 693 return false; 694 695 case elfcpp::SHT_PROGBITS: 696 if (parameters->options().strip_debug() 697 && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0) 698 { 699 if (is_debug_info_section(name)) 700 return false; 701 } 702 if (parameters->options().strip_debug_non_line() 703 && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0) 704 { 705 // Debugging sections can only be recognized by name. 706 if (is_prefix_of(".debug_", name) 707 && !is_lines_only_debug_section(name + 7)) 708 return false; 709 if (is_prefix_of(".zdebug_", name) 710 && !is_lines_only_debug_section(name + 8)) 711 return false; 712 } 713 if (parameters->options().strip_debug_gdb() 714 && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0) 715 { 716 // Debugging sections can only be recognized by name. 717 if (is_prefix_of(".debug_", name) 718 && !is_gdb_debug_section(name + 7)) 719 return false; 720 if (is_prefix_of(".zdebug_", name) 721 && !is_gdb_debug_section(name + 8)) 722 return false; 723 } 724 if (parameters->options().gdb_index() 725 && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0) 726 { 727 // When building .gdb_index, we can strip .debug_pubnames, 728 // .debug_pubtypes, and .debug_aranges sections. 729 if (is_prefix_of(".debug_", name) 730 && is_gdb_fast_lookup_section(name + 7)) 731 return false; 732 if (is_prefix_of(".zdebug_", name) 733 && is_gdb_fast_lookup_section(name + 8)) 734 return false; 735 } 736 if (parameters->options().strip_lto_sections() 737 && !parameters->options().relocatable() 738 && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0) 739 { 740 // Ignore LTO sections containing intermediate code. 741 if (is_prefix_of(".gnu.lto_", name)) 742 return false; 743 } 744 // The GNU linker strips .gnu_debuglink sections, so we do too. 745 // This is a feature used to keep debugging information in 746 // separate files. 747 if (strcmp(name, ".gnu_debuglink") == 0) 748 return false; 749 return true; 750 751 default: 752 return true; 753 } 754} 755 756// Return an output section named NAME, or NULL if there is none. 757 758Output_section* 759Layout::find_output_section(const char* name) const 760{ 761 for (Section_list::const_iterator p = this->section_list_.begin(); 762 p != this->section_list_.end(); 763 ++p) 764 if (strcmp((*p)->name(), name) == 0) 765 return *p; 766 return NULL; 767} 768 769// Return an output segment of type TYPE, with segment flags SET set 770// and segment flags CLEAR clear. Return NULL if there is none. 771 772Output_segment* 773Layout::find_output_segment(elfcpp::PT type, elfcpp::Elf_Word set, 774 elfcpp::Elf_Word clear) const 775{ 776 for (Segment_list::const_iterator p = this->segment_list_.begin(); 777 p != this->segment_list_.end(); 778 ++p) 779 if (static_cast<elfcpp::PT>((*p)->type()) == type 780 && ((*p)->flags() & set) == set 781 && ((*p)->flags() & clear) == 0) 782 return *p; 783 return NULL; 784} 785 786// When we put a .ctors or .dtors section with more than one word into 787// a .init_array or .fini_array section, we need to reverse the words 788// in the .ctors/.dtors section. This is because .init_array executes 789// constructors front to back, where .ctors executes them back to 790// front, and vice-versa for .fini_array/.dtors. Although we do want 791// to remap .ctors/.dtors into .init_array/.fini_array because it can 792// be more efficient, we don't want to change the order in which 793// constructors/destructors are run. This set just keeps track of 794// these sections which need to be reversed. It is only changed by 795// Layout::layout. It should be a private member of Layout, but that 796// would require layout.h to #include object.h to get the definition 797// of Section_id. 798static Unordered_set<Section_id, Section_id_hash> ctors_sections_in_init_array; 799 800// Return whether OBJECT/SHNDX is a .ctors/.dtors section mapped to a 801// .init_array/.fini_array section. 802 803bool 804Layout::is_ctors_in_init_array(Relobj* relobj, unsigned int shndx) const 805{ 806 return (ctors_sections_in_init_array.find(Section_id(relobj, shndx)) 807 != ctors_sections_in_init_array.end()); 808} 809 810// Return the output section to use for section NAME with type TYPE 811// and section flags FLAGS. NAME must be canonicalized in the string 812// pool, and NAME_KEY is the key. ORDER is where this should appear 813// in the output sections. IS_RELRO is true for a relro section. 814 815Output_section* 816Layout::get_output_section(const char* name, Stringpool::Key name_key, 817 elfcpp::Elf_Word type, elfcpp::Elf_Xword flags, 818 Output_section_order order, bool is_relro) 819{ 820 elfcpp::Elf_Word lookup_type = type; 821 822 // For lookup purposes, treat INIT_ARRAY, FINI_ARRAY, and 823 // PREINIT_ARRAY like PROGBITS. This ensures that we combine 824 // .init_array, .fini_array, and .preinit_array sections by name 825 // whatever their type in the input file. We do this because the 826 // types are not always right in the input files. 827 if (lookup_type == elfcpp::SHT_INIT_ARRAY 828 || lookup_type == elfcpp::SHT_FINI_ARRAY 829 || lookup_type == elfcpp::SHT_PREINIT_ARRAY) 830 lookup_type = elfcpp::SHT_PROGBITS; 831 832 elfcpp::Elf_Xword lookup_flags = flags; 833 834 // Ignoring SHF_WRITE and SHF_EXECINSTR here means that we combine 835 // read-write with read-only sections. Some other ELF linkers do 836 // not do this. FIXME: Perhaps there should be an option 837 // controlling this. 838 lookup_flags &= ~(elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR); 839 840 const Key key(name_key, std::make_pair(lookup_type, lookup_flags)); 841 const std::pair<Key, Output_section*> v(key, NULL); 842 std::pair<Section_name_map::iterator, bool> ins( 843 this->section_name_map_.insert(v)); 844 845 if (!ins.second) 846 return ins.first->second; 847 else 848 { 849 // This is the first time we've seen this name/type/flags 850 // combination. For compatibility with the GNU linker, we 851 // combine sections with contents and zero flags with sections 852 // with non-zero flags. This is a workaround for cases where 853 // assembler code forgets to set section flags. FIXME: Perhaps 854 // there should be an option to control this. 855 Output_section* os = NULL; 856 857 if (lookup_type == elfcpp::SHT_PROGBITS) 858 { 859 if (flags == 0) 860 { 861 Output_section* same_name = this->find_output_section(name); 862 if (same_name != NULL 863 && (same_name->type() == elfcpp::SHT_PROGBITS 864 || same_name->type() == elfcpp::SHT_INIT_ARRAY 865 || same_name->type() == elfcpp::SHT_FINI_ARRAY 866 || same_name->type() == elfcpp::SHT_PREINIT_ARRAY) 867 && (same_name->flags() & elfcpp::SHF_TLS) == 0) 868 os = same_name; 869 } 870 else if ((flags & elfcpp::SHF_TLS) == 0) 871 { 872 elfcpp::Elf_Xword zero_flags = 0; 873 const Key zero_key(name_key, std::make_pair(lookup_type, 874 zero_flags)); 875 Section_name_map::iterator p = 876 this->section_name_map_.find(zero_key); 877 if (p != this->section_name_map_.end()) 878 os = p->second; 879 } 880 } 881 882 if (os == NULL) 883 os = this->make_output_section(name, type, flags, order, is_relro); 884 885 ins.first->second = os; 886 return os; 887 } 888} 889 890// Returns TRUE iff NAME (an input section from RELOBJ) will 891// be mapped to an output section that should be KEPT. 892 893bool 894Layout::keep_input_section(const Relobj* relobj, const char* name) 895{ 896 if (! this->script_options_->saw_sections_clause()) 897 return false; 898 899 Script_sections* ss = this->script_options_->script_sections(); 900 const char* file_name = relobj == NULL ? NULL : relobj->name().c_str(); 901 Output_section** output_section_slot; 902 Script_sections::Section_type script_section_type; 903 bool keep; 904 905 name = ss->output_section_name(file_name, name, &output_section_slot, 906 &script_section_type, &keep, true); 907 return name != NULL && keep; 908} 909 910// Clear the input section flags that should not be copied to the 911// output section. 912 913elfcpp::Elf_Xword 914Layout::get_output_section_flags(elfcpp::Elf_Xword input_section_flags) 915{ 916 // Some flags in the input section should not be automatically 917 // copied to the output section. 918 input_section_flags &= ~ (elfcpp::SHF_INFO_LINK 919 | elfcpp::SHF_GROUP 920 | elfcpp::SHF_COMPRESSED 921 | elfcpp::SHF_MERGE 922 | elfcpp::SHF_STRINGS); 923 924 // We only clear the SHF_LINK_ORDER flag in for 925 // a non-relocatable link. 926 if (!parameters->options().relocatable()) 927 input_section_flags &= ~elfcpp::SHF_LINK_ORDER; 928 929 return input_section_flags; 930} 931 932// Pick the output section to use for section NAME, in input file 933// RELOBJ, with type TYPE and flags FLAGS. RELOBJ may be NULL for a 934// linker created section. IS_INPUT_SECTION is true if we are 935// choosing an output section for an input section found in a input 936// file. ORDER is where this section should appear in the output 937// sections. IS_RELRO is true for a relro section. This will return 938// NULL if the input section should be discarded. MATCH_INPUT_SPEC 939// is true if the section name should be matched against input specs 940// in a linker script. 941 942Output_section* 943Layout::choose_output_section(const Relobj* relobj, const char* name, 944 elfcpp::Elf_Word type, elfcpp::Elf_Xword flags, 945 bool is_input_section, Output_section_order order, 946 bool is_relro, bool is_reloc, 947 bool match_input_spec) 948{ 949 // We should not see any input sections after we have attached 950 // sections to segments. 951 gold_assert(!is_input_section || !this->sections_are_attached_); 952 953 flags = this->get_output_section_flags(flags); 954 955 if (this->script_options_->saw_sections_clause() && !is_reloc) 956 { 957 // We are using a SECTIONS clause, so the output section is 958 // chosen based only on the name. 959 960 Script_sections* ss = this->script_options_->script_sections(); 961 const char* file_name = relobj == NULL ? NULL : relobj->name().c_str(); 962 Output_section** output_section_slot; 963 Script_sections::Section_type script_section_type; 964 const char* orig_name = name; 965 bool keep; 966 name = ss->output_section_name(file_name, name, &output_section_slot, 967 &script_section_type, &keep, 968 match_input_spec); 969 970 if (name == NULL) 971 { 972 gold_debug(DEBUG_SCRIPT, _("Unable to create output section '%s' " 973 "because it is not allowed by the " 974 "SECTIONS clause of the linker script"), 975 orig_name); 976 // The SECTIONS clause says to discard this input section. 977 return NULL; 978 } 979 980 // We can only handle script section types ST_NONE and ST_NOLOAD. 981 switch (script_section_type) 982 { 983 case Script_sections::ST_NONE: 984 break; 985 case Script_sections::ST_NOLOAD: 986 flags &= elfcpp::SHF_ALLOC; 987 break; 988 default: 989 gold_unreachable(); 990 } 991 992 // If this is an orphan section--one not mentioned in the linker 993 // script--then OUTPUT_SECTION_SLOT will be NULL, and we do the 994 // default processing below. 995 996 if (output_section_slot != NULL) 997 { 998 if (*output_section_slot != NULL) 999 { 1000 (*output_section_slot)->update_flags_for_input_section(flags); 1001 return *output_section_slot; 1002 } 1003 1004 // We don't put sections found in the linker script into 1005 // SECTION_NAME_MAP_. That keeps us from getting confused 1006 // if an orphan section is mapped to a section with the same 1007 // name as one in the linker script. 1008 1009 name = this->namepool_.add(name, false, NULL); 1010 1011 Output_section* os = this->make_output_section(name, type, flags, 1012 order, is_relro); 1013 1014 os->set_found_in_sections_clause(); 1015 1016 // Special handling for NOLOAD sections. 1017 if (script_section_type == Script_sections::ST_NOLOAD) 1018 { 1019 os->set_is_noload(); 1020 1021 // The constructor of Output_section sets addresses of non-ALLOC 1022 // sections to 0 by default. We don't want that for NOLOAD 1023 // sections even if they have no SHF_ALLOC flag. 1024 if ((os->flags() & elfcpp::SHF_ALLOC) == 0 1025 && os->is_address_valid()) 1026 { 1027 gold_assert(os->address() == 0 1028 && !os->is_offset_valid() 1029 && !os->is_data_size_valid()); 1030 os->reset_address_and_file_offset(); 1031 } 1032 } 1033 1034 *output_section_slot = os; 1035 return os; 1036 } 1037 } 1038 1039 // FIXME: Handle SHF_OS_NONCONFORMING somewhere. 1040 1041 size_t len = strlen(name); 1042 std::string uncompressed_name; 1043 1044 // Compressed debug sections should be mapped to the corresponding 1045 // uncompressed section. 1046 if (is_compressed_debug_section(name)) 1047 { 1048 uncompressed_name = 1049 corresponding_uncompressed_section_name(std::string(name, len)); 1050 name = uncompressed_name.c_str(); 1051 len = uncompressed_name.length(); 1052 } 1053 1054 // Turn NAME from the name of the input section into the name of the 1055 // output section. 1056 if (is_input_section 1057 && !this->script_options_->saw_sections_clause() 1058 && !parameters->options().relocatable()) 1059 { 1060 const char *orig_name = name; 1061 name = parameters->target().output_section_name(relobj, name, &len); 1062 if (name == NULL) 1063 name = Layout::output_section_name(relobj, orig_name, &len); 1064 } 1065 1066 Stringpool::Key name_key; 1067 name = this->namepool_.add_with_length(name, len, true, &name_key); 1068 1069 // Find or make the output section. The output section is selected 1070 // based on the section name, type, and flags. 1071 return this->get_output_section(name, name_key, type, flags, order, is_relro); 1072} 1073 1074// For incremental links, record the initial fixed layout of a section 1075// from the base file, and return a pointer to the Output_section. 1076 1077template<int size, bool big_endian> 1078Output_section* 1079Layout::init_fixed_output_section(const char* name, 1080 elfcpp::Shdr<size, big_endian>& shdr) 1081{ 1082 unsigned int sh_type = shdr.get_sh_type(); 1083 1084 // We preserve the layout of PROGBITS, NOBITS, INIT_ARRAY, FINI_ARRAY, 1085 // PRE_INIT_ARRAY, and NOTE sections. 1086 // All others will be created from scratch and reallocated. 1087 if (!can_incremental_update(sh_type)) 1088 return NULL; 1089 1090 // If we're generating a .gdb_index section, we need to regenerate 1091 // it from scratch. 1092 if (parameters->options().gdb_index() 1093 && sh_type == elfcpp::SHT_PROGBITS 1094 && strcmp(name, ".gdb_index") == 0) 1095 return NULL; 1096 1097 typename elfcpp::Elf_types<size>::Elf_Addr sh_addr = shdr.get_sh_addr(); 1098 typename elfcpp::Elf_types<size>::Elf_Off sh_offset = shdr.get_sh_offset(); 1099 typename elfcpp::Elf_types<size>::Elf_WXword sh_size = shdr.get_sh_size(); 1100 typename elfcpp::Elf_types<size>::Elf_WXword sh_flags = shdr.get_sh_flags(); 1101 typename elfcpp::Elf_types<size>::Elf_WXword sh_addralign = 1102 shdr.get_sh_addralign(); 1103 1104 // Make the output section. 1105 Stringpool::Key name_key; 1106 name = this->namepool_.add(name, true, &name_key); 1107 Output_section* os = this->get_output_section(name, name_key, sh_type, 1108 sh_flags, ORDER_INVALID, false); 1109 os->set_fixed_layout(sh_addr, sh_offset, sh_size, sh_addralign); 1110 if (sh_type != elfcpp::SHT_NOBITS) 1111 this->free_list_.remove(sh_offset, sh_offset + sh_size); 1112 return os; 1113} 1114 1115// Return the index by which an input section should be ordered. This 1116// is used to sort some .text sections, for compatibility with GNU ld. 1117 1118int 1119Layout::special_ordering_of_input_section(const char* name) 1120{ 1121 // The GNU linker has some special handling for some sections that 1122 // wind up in the .text section. Sections that start with these 1123 // prefixes must appear first, and must appear in the order listed 1124 // here. 1125 static const char* const text_section_sort[] = 1126 { 1127 ".text.unlikely", 1128 ".text.exit", 1129 ".text.startup", 1130 ".text.hot" 1131 }; 1132 1133 for (size_t i = 0; 1134 i < sizeof(text_section_sort) / sizeof(text_section_sort[0]); 1135 i++) 1136 if (is_prefix_of(text_section_sort[i], name)) 1137 return i; 1138 1139 return -1; 1140} 1141 1142// Return the output section to use for input section SHNDX, with name 1143// NAME, with header HEADER, from object OBJECT. RELOC_SHNDX is the 1144// index of a relocation section which applies to this section, or 0 1145// if none, or -1U if more than one. RELOC_TYPE is the type of the 1146// relocation section if there is one. Set *OFF to the offset of this 1147// input section without the output section. Return NULL if the 1148// section should be discarded. Set *OFF to -1 if the section 1149// contents should not be written directly to the output file, but 1150// will instead receive special handling. 1151 1152template<int size, bool big_endian> 1153Output_section* 1154Layout::layout(Sized_relobj_file<size, big_endian>* object, unsigned int shndx, 1155 const char* name, const elfcpp::Shdr<size, big_endian>& shdr, 1156 unsigned int reloc_shndx, unsigned int, off_t* off) 1157{ 1158 *off = 0; 1159 1160 if (!this->include_section(object, name, shdr)) 1161 return NULL; 1162 1163 elfcpp::Elf_Word sh_type = shdr.get_sh_type(); 1164 1165 // In a relocatable link a grouped section must not be combined with 1166 // any other sections. 1167 Output_section* os; 1168 if (parameters->options().relocatable() 1169 && (shdr.get_sh_flags() & elfcpp::SHF_GROUP) != 0) 1170 { 1171 // Some flags in the input section should not be automatically 1172 // copied to the output section. 1173 elfcpp::Elf_Xword flags = (shdr.get_sh_flags() 1174 & ~ elfcpp::SHF_COMPRESSED); 1175 name = this->namepool_.add(name, true, NULL); 1176 os = this->make_output_section(name, sh_type, flags, 1177 ORDER_INVALID, false); 1178 } 1179 else 1180 { 1181 // Plugins can choose to place one or more subsets of sections in 1182 // unique segments and this is done by mapping these section subsets 1183 // to unique output sections. Check if this section needs to be 1184 // remapped to a unique output section. 1185 Section_segment_map::iterator it 1186 = this->section_segment_map_.find(Const_section_id(object, shndx)); 1187 if (it == this->section_segment_map_.end()) 1188 { 1189 os = this->choose_output_section(object, name, sh_type, 1190 shdr.get_sh_flags(), true, 1191 ORDER_INVALID, false, false, 1192 true); 1193 } 1194 else 1195 { 1196 // We know the name of the output section, directly call 1197 // get_output_section here by-passing choose_output_section. 1198 elfcpp::Elf_Xword flags 1199 = this->get_output_section_flags(shdr.get_sh_flags()); 1200 1201 const char* os_name = it->second->name; 1202 Stringpool::Key name_key; 1203 os_name = this->namepool_.add(os_name, true, &name_key); 1204 os = this->get_output_section(os_name, name_key, sh_type, flags, 1205 ORDER_INVALID, false); 1206 if (!os->is_unique_segment()) 1207 { 1208 os->set_is_unique_segment(); 1209 os->set_extra_segment_flags(it->second->flags); 1210 os->set_segment_alignment(it->second->align); 1211 } 1212 } 1213 if (os == NULL) 1214 return NULL; 1215 } 1216 1217 // By default the GNU linker sorts input sections whose names match 1218 // .ctors.*, .dtors.*, .init_array.*, or .fini_array.*. The 1219 // sections are sorted by name. This is used to implement 1220 // constructor priority ordering. We are compatible. When we put 1221 // .ctor sections in .init_array and .dtor sections in .fini_array, 1222 // we must also sort plain .ctor and .dtor sections. 1223 if (!this->script_options_->saw_sections_clause() 1224 && !parameters->options().relocatable() 1225 && (is_prefix_of(".ctors.", name) 1226 || is_prefix_of(".dtors.", name) 1227 || is_prefix_of(".init_array.", name) 1228 || is_prefix_of(".fini_array.", name) 1229 || (parameters->options().ctors_in_init_array() 1230 && (strcmp(name, ".ctors") == 0 1231 || strcmp(name, ".dtors") == 0)))) 1232 os->set_must_sort_attached_input_sections(); 1233 1234 // By default the GNU linker sorts some special text sections ahead 1235 // of others. We are compatible. 1236 if (parameters->options().text_reorder() 1237 && !this->script_options_->saw_sections_clause() 1238 && !this->is_section_ordering_specified() 1239 && !parameters->options().relocatable() 1240 && Layout::special_ordering_of_input_section(name) >= 0) 1241 os->set_must_sort_attached_input_sections(); 1242 1243 // If this is a .ctors or .ctors.* section being mapped to a 1244 // .init_array section, or a .dtors or .dtors.* section being mapped 1245 // to a .fini_array section, we will need to reverse the words if 1246 // there is more than one. Record this section for later. See 1247 // ctors_sections_in_init_array above. 1248 if (!this->script_options_->saw_sections_clause() 1249 && !parameters->options().relocatable() 1250 && shdr.get_sh_size() > size / 8 1251 && (((strcmp(name, ".ctors") == 0 1252 || is_prefix_of(".ctors.", name)) 1253 && strcmp(os->name(), ".init_array") == 0) 1254 || ((strcmp(name, ".dtors") == 0 1255 || is_prefix_of(".dtors.", name)) 1256 && strcmp(os->name(), ".fini_array") == 0))) 1257 ctors_sections_in_init_array.insert(Section_id(object, shndx)); 1258 1259 // FIXME: Handle SHF_LINK_ORDER somewhere. 1260 1261 elfcpp::Elf_Xword orig_flags = os->flags(); 1262 1263 *off = os->add_input_section(this, object, shndx, name, shdr, reloc_shndx, 1264 this->script_options_->saw_sections_clause()); 1265 1266 // If the flags changed, we may have to change the order. 1267 if ((orig_flags & elfcpp::SHF_ALLOC) != 0) 1268 { 1269 orig_flags &= (elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR); 1270 elfcpp::Elf_Xword new_flags = 1271 os->flags() & (elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR); 1272 if (orig_flags != new_flags) 1273 os->set_order(this->default_section_order(os, false)); 1274 } 1275 1276 this->have_added_input_section_ = true; 1277 1278 return os; 1279} 1280 1281// Maps section SECN to SEGMENT s. 1282void 1283Layout::insert_section_segment_map(Const_section_id secn, 1284 Unique_segment_info *s) 1285{ 1286 gold_assert(this->unique_segment_for_sections_specified_); 1287 this->section_segment_map_[secn] = s; 1288} 1289 1290// Handle a relocation section when doing a relocatable link. 1291 1292template<int size, bool big_endian> 1293Output_section* 1294Layout::layout_reloc(Sized_relobj_file<size, big_endian>* object, 1295 unsigned int, 1296 const elfcpp::Shdr<size, big_endian>& shdr, 1297 Output_section* data_section, 1298 Relocatable_relocs* rr) 1299{ 1300 gold_assert(parameters->options().relocatable() 1301 || parameters->options().emit_relocs()); 1302 1303 int sh_type = shdr.get_sh_type(); 1304 1305 std::string name; 1306 if (sh_type == elfcpp::SHT_REL) 1307 name = ".rel"; 1308 else if (sh_type == elfcpp::SHT_RELA) 1309 name = ".rela"; 1310 else 1311 gold_unreachable(); 1312 name += data_section->name(); 1313 1314 // In a relocatable link relocs for a grouped section must not be 1315 // combined with other reloc sections. 1316 Output_section* os; 1317 if (!parameters->options().relocatable() 1318 || (data_section->flags() & elfcpp::SHF_GROUP) == 0) 1319 os = this->choose_output_section(object, name.c_str(), sh_type, 1320 shdr.get_sh_flags(), false, 1321 ORDER_INVALID, false, true, false); 1322 else 1323 { 1324 const char* n = this->namepool_.add(name.c_str(), true, NULL); 1325 os = this->make_output_section(n, sh_type, shdr.get_sh_flags(), 1326 ORDER_INVALID, false); 1327 } 1328 1329 os->set_should_link_to_symtab(); 1330 os->set_info_section(data_section); 1331 1332 Output_section_data* posd; 1333 if (sh_type == elfcpp::SHT_REL) 1334 { 1335 os->set_entsize(elfcpp::Elf_sizes<size>::rel_size); 1336 posd = new Output_relocatable_relocs<elfcpp::SHT_REL, 1337 size, 1338 big_endian>(rr); 1339 } 1340 else if (sh_type == elfcpp::SHT_RELA) 1341 { 1342 os->set_entsize(elfcpp::Elf_sizes<size>::rela_size); 1343 posd = new Output_relocatable_relocs<elfcpp::SHT_RELA, 1344 size, 1345 big_endian>(rr); 1346 } 1347 else 1348 gold_unreachable(); 1349 1350 os->add_output_section_data(posd); 1351 rr->set_output_data(posd); 1352 1353 return os; 1354} 1355 1356// Handle a group section when doing a relocatable link. 1357 1358template<int size, bool big_endian> 1359void 1360Layout::layout_group(Symbol_table* symtab, 1361 Sized_relobj_file<size, big_endian>* object, 1362 unsigned int, 1363 const char* group_section_name, 1364 const char* signature, 1365 const elfcpp::Shdr<size, big_endian>& shdr, 1366 elfcpp::Elf_Word flags, 1367 std::vector<unsigned int>* shndxes) 1368{ 1369 gold_assert(parameters->options().relocatable()); 1370 gold_assert(shdr.get_sh_type() == elfcpp::SHT_GROUP); 1371 group_section_name = this->namepool_.add(group_section_name, true, NULL); 1372 Output_section* os = this->make_output_section(group_section_name, 1373 elfcpp::SHT_GROUP, 1374 shdr.get_sh_flags(), 1375 ORDER_INVALID, false); 1376 1377 // We need to find a symbol with the signature in the symbol table. 1378 // If we don't find one now, we need to look again later. 1379 Symbol* sym = symtab->lookup(signature, NULL); 1380 if (sym != NULL) 1381 os->set_info_symndx(sym); 1382 else 1383 { 1384 // Reserve some space to minimize reallocations. 1385 if (this->group_signatures_.empty()) 1386 this->group_signatures_.reserve(this->number_of_input_files_ * 16); 1387 1388 // We will wind up using a symbol whose name is the signature. 1389 // So just put the signature in the symbol name pool to save it. 1390 signature = symtab->canonicalize_name(signature); 1391 this->group_signatures_.push_back(Group_signature(os, signature)); 1392 } 1393 1394 os->set_should_link_to_symtab(); 1395 os->set_entsize(4); 1396 1397 section_size_type entry_count = 1398 convert_to_section_size_type(shdr.get_sh_size() / 4); 1399 Output_section_data* posd = 1400 new Output_data_group<size, big_endian>(object, entry_count, flags, 1401 shndxes); 1402 os->add_output_section_data(posd); 1403} 1404 1405// Special GNU handling of sections name .eh_frame. They will 1406// normally hold exception frame data as defined by the C++ ABI 1407// (http://codesourcery.com/cxx-abi/). 1408 1409template<int size, bool big_endian> 1410Output_section* 1411Layout::layout_eh_frame(Sized_relobj_file<size, big_endian>* object, 1412 const unsigned char* symbols, 1413 off_t symbols_size, 1414 const unsigned char* symbol_names, 1415 off_t symbol_names_size, 1416 unsigned int shndx, 1417 const elfcpp::Shdr<size, big_endian>& shdr, 1418 unsigned int reloc_shndx, unsigned int reloc_type, 1419 off_t* off) 1420{ 1421 gold_assert(shdr.get_sh_type() == elfcpp::SHT_PROGBITS 1422 || shdr.get_sh_type() == elfcpp::SHT_X86_64_UNWIND); 1423 gold_assert((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0); 1424 1425 Output_section* os = this->make_eh_frame_section(object); 1426 if (os == NULL) 1427 return NULL; 1428 1429 gold_assert(this->eh_frame_section_ == os); 1430 1431 elfcpp::Elf_Xword orig_flags = os->flags(); 1432 1433 Eh_frame::Eh_frame_section_disposition disp = 1434 Eh_frame::EH_UNRECOGNIZED_SECTION; 1435 if (!parameters->incremental()) 1436 { 1437 disp = this->eh_frame_data_->add_ehframe_input_section(object, 1438 symbols, 1439 symbols_size, 1440 symbol_names, 1441 symbol_names_size, 1442 shndx, 1443 reloc_shndx, 1444 reloc_type); 1445 } 1446 1447 if (disp == Eh_frame::EH_OPTIMIZABLE_SECTION) 1448 { 1449 os->update_flags_for_input_section(shdr.get_sh_flags()); 1450 1451 // A writable .eh_frame section is a RELRO section. 1452 if ((orig_flags & (elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR)) 1453 != (os->flags() & (elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR))) 1454 { 1455 os->set_is_relro(); 1456 os->set_order(ORDER_RELRO); 1457 } 1458 1459 *off = -1; 1460 return os; 1461 } 1462 1463 if (disp == Eh_frame::EH_END_MARKER_SECTION && !this->added_eh_frame_data_) 1464 { 1465 // We found the end marker section, so now we can add the set of 1466 // optimized sections to the output section. We need to postpone 1467 // adding this until we've found a section we can optimize so that 1468 // the .eh_frame section in crtbeginT.o winds up at the start of 1469 // the output section. 1470 os->add_output_section_data(this->eh_frame_data_); 1471 this->added_eh_frame_data_ = true; 1472 } 1473 1474 // We couldn't handle this .eh_frame section for some reason. 1475 // Add it as a normal section. 1476 bool saw_sections_clause = this->script_options_->saw_sections_clause(); 1477 *off = os->add_input_section(this, object, shndx, ".eh_frame", shdr, 1478 reloc_shndx, saw_sections_clause); 1479 this->have_added_input_section_ = true; 1480 1481 if ((orig_flags & (elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR)) 1482 != (os->flags() & (elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR))) 1483 os->set_order(this->default_section_order(os, false)); 1484 1485 return os; 1486} 1487 1488void 1489Layout::finalize_eh_frame_section() 1490{ 1491 // If we never found an end marker section, we need to add the 1492 // optimized eh sections to the output section now. 1493 if (!parameters->incremental() 1494 && this->eh_frame_section_ != NULL 1495 && !this->added_eh_frame_data_) 1496 { 1497 this->eh_frame_section_->add_output_section_data(this->eh_frame_data_); 1498 this->added_eh_frame_data_ = true; 1499 } 1500} 1501 1502// Create and return the magic .eh_frame section. Create 1503// .eh_frame_hdr also if appropriate. OBJECT is the object with the 1504// input .eh_frame section; it may be NULL. 1505 1506Output_section* 1507Layout::make_eh_frame_section(const Relobj* object) 1508{ 1509 // FIXME: On x86_64, this could use SHT_X86_64_UNWIND rather than 1510 // SHT_PROGBITS. 1511 Output_section* os = this->choose_output_section(object, ".eh_frame", 1512 elfcpp::SHT_PROGBITS, 1513 elfcpp::SHF_ALLOC, false, 1514 ORDER_EHFRAME, false, false, 1515 false); 1516 if (os == NULL) 1517 return NULL; 1518 1519 if (this->eh_frame_section_ == NULL) 1520 { 1521 this->eh_frame_section_ = os; 1522 this->eh_frame_data_ = new Eh_frame(); 1523 1524 // For incremental linking, we do not optimize .eh_frame sections 1525 // or create a .eh_frame_hdr section. 1526 if (parameters->options().eh_frame_hdr() && !parameters->incremental()) 1527 { 1528 Output_section* hdr_os = 1529 this->choose_output_section(NULL, ".eh_frame_hdr", 1530 elfcpp::SHT_PROGBITS, 1531 elfcpp::SHF_ALLOC, false, 1532 ORDER_EHFRAME, false, false, 1533 false); 1534 1535 if (hdr_os != NULL) 1536 { 1537 Eh_frame_hdr* hdr_posd = new Eh_frame_hdr(os, 1538 this->eh_frame_data_); 1539 hdr_os->add_output_section_data(hdr_posd); 1540 1541 hdr_os->set_after_input_sections(); 1542 1543 if (!this->script_options_->saw_phdrs_clause()) 1544 { 1545 Output_segment* hdr_oseg; 1546 hdr_oseg = this->make_output_segment(elfcpp::PT_GNU_EH_FRAME, 1547 elfcpp::PF_R); 1548 hdr_oseg->add_output_section_to_nonload(hdr_os, 1549 elfcpp::PF_R); 1550 } 1551 1552 this->eh_frame_data_->set_eh_frame_hdr(hdr_posd); 1553 } 1554 } 1555 } 1556 1557 return os; 1558} 1559 1560// Add an exception frame for a PLT. This is called from target code. 1561 1562void 1563Layout::add_eh_frame_for_plt(Output_data* plt, const unsigned char* cie_data, 1564 size_t cie_length, const unsigned char* fde_data, 1565 size_t fde_length) 1566{ 1567 if (parameters->incremental()) 1568 { 1569 // FIXME: Maybe this could work some day.... 1570 return; 1571 } 1572 Output_section* os = this->make_eh_frame_section(NULL); 1573 if (os == NULL) 1574 return; 1575 this->eh_frame_data_->add_ehframe_for_plt(plt, cie_data, cie_length, 1576 fde_data, fde_length); 1577 if (!this->added_eh_frame_data_) 1578 { 1579 os->add_output_section_data(this->eh_frame_data_); 1580 this->added_eh_frame_data_ = true; 1581 } 1582} 1583 1584// Scan a .debug_info or .debug_types section, and add summary 1585// information to the .gdb_index section. 1586 1587template<int size, bool big_endian> 1588void 1589Layout::add_to_gdb_index(bool is_type_unit, 1590 Sized_relobj<size, big_endian>* object, 1591 const unsigned char* symbols, 1592 off_t symbols_size, 1593 unsigned int shndx, 1594 unsigned int reloc_shndx, 1595 unsigned int reloc_type) 1596{ 1597 if (this->gdb_index_data_ == NULL) 1598 { 1599 Output_section* os = this->choose_output_section(NULL, ".gdb_index", 1600 elfcpp::SHT_PROGBITS, 0, 1601 false, ORDER_INVALID, 1602 false, false, false); 1603 if (os == NULL) 1604 return; 1605 1606 this->gdb_index_data_ = new Gdb_index(os); 1607 os->add_output_section_data(this->gdb_index_data_); 1608 os->set_after_input_sections(); 1609 } 1610 1611 this->gdb_index_data_->scan_debug_info(is_type_unit, object, symbols, 1612 symbols_size, shndx, reloc_shndx, 1613 reloc_type); 1614} 1615 1616// Add POSD to an output section using NAME, TYPE, and FLAGS. Return 1617// the output section. 1618 1619Output_section* 1620Layout::add_output_section_data(const char* name, elfcpp::Elf_Word type, 1621 elfcpp::Elf_Xword flags, 1622 Output_section_data* posd, 1623 Output_section_order order, bool is_relro) 1624{ 1625 Output_section* os = this->choose_output_section(NULL, name, type, flags, 1626 false, order, is_relro, 1627 false, false); 1628 if (os != NULL) 1629 os->add_output_section_data(posd); 1630 return os; 1631} 1632 1633// Map section flags to segment flags. 1634 1635elfcpp::Elf_Word 1636Layout::section_flags_to_segment(elfcpp::Elf_Xword flags) 1637{ 1638 elfcpp::Elf_Word ret = elfcpp::PF_R; 1639 if ((flags & elfcpp::SHF_WRITE) != 0) 1640 ret |= elfcpp::PF_W; 1641 if ((flags & elfcpp::SHF_EXECINSTR) != 0) 1642 ret |= elfcpp::PF_X; 1643 return ret; 1644} 1645 1646// Make a new Output_section, and attach it to segments as 1647// appropriate. ORDER is the order in which this section should 1648// appear in the output segment. IS_RELRO is true if this is a relro 1649// (read-only after relocations) section. 1650 1651Output_section* 1652Layout::make_output_section(const char* name, elfcpp::Elf_Word type, 1653 elfcpp::Elf_Xword flags, 1654 Output_section_order order, bool is_relro) 1655{ 1656 Output_section* os; 1657 if ((flags & elfcpp::SHF_ALLOC) == 0 1658 && strcmp(parameters->options().compress_debug_sections(), "none") != 0 1659 && is_compressible_debug_section(name)) 1660 os = new Output_compressed_section(¶meters->options(), name, type, 1661 flags); 1662 else if ((flags & elfcpp::SHF_ALLOC) == 0 1663 && parameters->options().strip_debug_non_line() 1664 && strcmp(".debug_abbrev", name) == 0) 1665 { 1666 os = this->debug_abbrev_ = new Output_reduced_debug_abbrev_section( 1667 name, type, flags); 1668 if (this->debug_info_) 1669 this->debug_info_->set_abbreviations(this->debug_abbrev_); 1670 } 1671 else if ((flags & elfcpp::SHF_ALLOC) == 0 1672 && parameters->options().strip_debug_non_line() 1673 && strcmp(".debug_info", name) == 0) 1674 { 1675 os = this->debug_info_ = new Output_reduced_debug_info_section( 1676 name, type, flags); 1677 if (this->debug_abbrev_) 1678 this->debug_info_->set_abbreviations(this->debug_abbrev_); 1679 } 1680 else 1681 { 1682 // Sometimes .init_array*, .preinit_array* and .fini_array* do 1683 // not have correct section types. Force them here. 1684 if (type == elfcpp::SHT_PROGBITS) 1685 { 1686 if (is_prefix_of(".init_array", name)) 1687 type = elfcpp::SHT_INIT_ARRAY; 1688 else if (is_prefix_of(".preinit_array", name)) 1689 type = elfcpp::SHT_PREINIT_ARRAY; 1690 else if (is_prefix_of(".fini_array", name)) 1691 type = elfcpp::SHT_FINI_ARRAY; 1692 } 1693 1694 // FIXME: const_cast is ugly. 1695 Target* target = const_cast<Target*>(¶meters->target()); 1696 os = target->make_output_section(name, type, flags); 1697 } 1698 1699 // With -z relro, we have to recognize the special sections by name. 1700 // There is no other way. 1701 bool is_relro_local = false; 1702 if (!this->script_options_->saw_sections_clause() 1703 && parameters->options().relro() 1704 && (flags & elfcpp::SHF_ALLOC) != 0 1705 && (flags & elfcpp::SHF_WRITE) != 0) 1706 { 1707 if (type == elfcpp::SHT_PROGBITS) 1708 { 1709 if ((flags & elfcpp::SHF_TLS) != 0) 1710 is_relro = true; 1711 else if (strcmp(name, ".data.rel.ro") == 0) 1712 is_relro = true; 1713 else if (strcmp(name, ".data.rel.ro.local") == 0) 1714 { 1715 is_relro = true; 1716 is_relro_local = true; 1717 } 1718 else if (strcmp(name, ".ctors") == 0 1719 || strcmp(name, ".dtors") == 0 1720 || strcmp(name, ".jcr") == 0) 1721 is_relro = true; 1722 } 1723 else if (type == elfcpp::SHT_INIT_ARRAY 1724 || type == elfcpp::SHT_FINI_ARRAY 1725 || type == elfcpp::SHT_PREINIT_ARRAY) 1726 is_relro = true; 1727 } 1728 1729 if (is_relro) 1730 os->set_is_relro(); 1731 1732 if (order == ORDER_INVALID && (flags & elfcpp::SHF_ALLOC) != 0) 1733 order = this->default_section_order(os, is_relro_local); 1734 1735 os->set_order(order); 1736 1737 parameters->target().new_output_section(os); 1738 1739 this->section_list_.push_back(os); 1740 1741 // The GNU linker by default sorts some sections by priority, so we 1742 // do the same. We need to know that this might happen before we 1743 // attach any input sections. 1744 if (!this->script_options_->saw_sections_clause() 1745 && !parameters->options().relocatable() 1746 && (strcmp(name, ".init_array") == 0 1747 || strcmp(name, ".fini_array") == 0 1748 || (!parameters->options().ctors_in_init_array() 1749 && (strcmp(name, ".ctors") == 0 1750 || strcmp(name, ".dtors") == 0)))) 1751 os->set_may_sort_attached_input_sections(); 1752 1753 // The GNU linker by default sorts .text.{unlikely,exit,startup,hot} 1754 // sections before other .text sections. We are compatible. We 1755 // need to know that this might happen before we attach any input 1756 // sections. 1757 if (parameters->options().text_reorder() 1758 && !this->script_options_->saw_sections_clause() 1759 && !this->is_section_ordering_specified() 1760 && !parameters->options().relocatable() 1761 && strcmp(name, ".text") == 0) 1762 os->set_may_sort_attached_input_sections(); 1763 1764 // GNU linker sorts section by name with --sort-section=name. 1765 if (strcmp(parameters->options().sort_section(), "name") == 0) 1766 os->set_must_sort_attached_input_sections(); 1767 1768 // Check for .stab*str sections, as .stab* sections need to link to 1769 // them. 1770 if (type == elfcpp::SHT_STRTAB 1771 && !this->have_stabstr_section_ 1772 && strncmp(name, ".stab", 5) == 0 1773 && strcmp(name + strlen(name) - 3, "str") == 0) 1774 this->have_stabstr_section_ = true; 1775 1776 // During a full incremental link, we add patch space to most 1777 // PROGBITS and NOBITS sections. Flag those that may be 1778 // arbitrarily padded. 1779 if ((type == elfcpp::SHT_PROGBITS || type == elfcpp::SHT_NOBITS) 1780 && order != ORDER_INTERP 1781 && order != ORDER_INIT 1782 && order != ORDER_PLT 1783 && order != ORDER_FINI 1784 && order != ORDER_RELRO_LAST 1785 && order != ORDER_NON_RELRO_FIRST 1786 && strcmp(name, ".eh_frame") != 0 1787 && strcmp(name, ".ctors") != 0 1788 && strcmp(name, ".dtors") != 0 1789 && strcmp(name, ".jcr") != 0) 1790 { 1791 os->set_is_patch_space_allowed(); 1792 1793 // Certain sections require "holes" to be filled with 1794 // specific fill patterns. These fill patterns may have 1795 // a minimum size, so we must prevent allocations from the 1796 // free list that leave a hole smaller than the minimum. 1797 if (strcmp(name, ".debug_info") == 0) 1798 os->set_free_space_fill(new Output_fill_debug_info(false)); 1799 else if (strcmp(name, ".debug_types") == 0) 1800 os->set_free_space_fill(new Output_fill_debug_info(true)); 1801 else if (strcmp(name, ".debug_line") == 0) 1802 os->set_free_space_fill(new Output_fill_debug_line()); 1803 } 1804 1805 // If we have already attached the sections to segments, then we 1806 // need to attach this one now. This happens for sections created 1807 // directly by the linker. 1808 if (this->sections_are_attached_) 1809 this->attach_section_to_segment(¶meters->target(), os); 1810 1811 return os; 1812} 1813 1814// Return the default order in which a section should be placed in an 1815// output segment. This function captures a lot of the ideas in 1816// ld/scripttempl/elf.sc in the GNU linker. Note that the order of a 1817// linker created section is normally set when the section is created; 1818// this function is used for input sections. 1819 1820Output_section_order 1821Layout::default_section_order(Output_section* os, bool is_relro_local) 1822{ 1823 gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0); 1824 bool is_write = (os->flags() & elfcpp::SHF_WRITE) != 0; 1825 bool is_execinstr = (os->flags() & elfcpp::SHF_EXECINSTR) != 0; 1826 bool is_bss = false; 1827 1828 switch (os->type()) 1829 { 1830 default: 1831 case elfcpp::SHT_PROGBITS: 1832 break; 1833 case elfcpp::SHT_NOBITS: 1834 is_bss = true; 1835 break; 1836 case elfcpp::SHT_RELA: 1837 case elfcpp::SHT_REL: 1838 if (!is_write) 1839 return ORDER_DYNAMIC_RELOCS; 1840 break; 1841 case elfcpp::SHT_HASH: 1842 case elfcpp::SHT_DYNAMIC: 1843 case elfcpp::SHT_SHLIB: 1844 case elfcpp::SHT_DYNSYM: 1845 case elfcpp::SHT_GNU_HASH: 1846 case elfcpp::SHT_GNU_verdef: 1847 case elfcpp::SHT_GNU_verneed: 1848 case elfcpp::SHT_GNU_versym: 1849 if (!is_write) 1850 return ORDER_DYNAMIC_LINKER; 1851 break; 1852 case elfcpp::SHT_NOTE: 1853 return is_write ? ORDER_RW_NOTE : ORDER_RO_NOTE; 1854 } 1855 1856 if ((os->flags() & elfcpp::SHF_TLS) != 0) 1857 return is_bss ? ORDER_TLS_BSS : ORDER_TLS_DATA; 1858 1859 if (!is_bss && !is_write) 1860 { 1861 if (is_execinstr) 1862 { 1863 if (strcmp(os->name(), ".init") == 0) 1864 return ORDER_INIT; 1865 else if (strcmp(os->name(), ".fini") == 0) 1866 return ORDER_FINI; 1867 } 1868 return is_execinstr ? ORDER_TEXT : ORDER_READONLY; 1869 } 1870 1871 if (os->is_relro()) 1872 return is_relro_local ? ORDER_RELRO_LOCAL : ORDER_RELRO; 1873 1874 if (os->is_small_section()) 1875 return is_bss ? ORDER_SMALL_BSS : ORDER_SMALL_DATA; 1876 if (os->is_large_section()) 1877 return is_bss ? ORDER_LARGE_BSS : ORDER_LARGE_DATA; 1878 1879 return is_bss ? ORDER_BSS : ORDER_DATA; 1880} 1881 1882// Attach output sections to segments. This is called after we have 1883// seen all the input sections. 1884 1885void 1886Layout::attach_sections_to_segments(const Target* target) 1887{ 1888 for (Section_list::iterator p = this->section_list_.begin(); 1889 p != this->section_list_.end(); 1890 ++p) 1891 this->attach_section_to_segment(target, *p); 1892 1893 this->sections_are_attached_ = true; 1894} 1895 1896// Attach an output section to a segment. 1897 1898void 1899Layout::attach_section_to_segment(const Target* target, Output_section* os) 1900{ 1901 if ((os->flags() & elfcpp::SHF_ALLOC) == 0) 1902 this->unattached_section_list_.push_back(os); 1903 else 1904 this->attach_allocated_section_to_segment(target, os); 1905} 1906 1907// Attach an allocated output section to a segment. 1908 1909void 1910Layout::attach_allocated_section_to_segment(const Target* target, 1911 Output_section* os) 1912{ 1913 elfcpp::Elf_Xword flags = os->flags(); 1914 gold_assert((flags & elfcpp::SHF_ALLOC) != 0); 1915 1916 if (parameters->options().relocatable()) 1917 return; 1918 1919 // If we have a SECTIONS clause, we can't handle the attachment to 1920 // segments until after we've seen all the sections. 1921 if (this->script_options_->saw_sections_clause()) 1922 return; 1923 1924 gold_assert(!this->script_options_->saw_phdrs_clause()); 1925 1926 // This output section goes into a PT_LOAD segment. 1927 1928 elfcpp::Elf_Word seg_flags = Layout::section_flags_to_segment(flags); 1929 1930 // If this output section's segment has extra flags that need to be set, 1931 // coming from a linker plugin, do that. 1932 seg_flags |= os->extra_segment_flags(); 1933 1934 // Check for --section-start. 1935 uint64_t addr; 1936 bool is_address_set = parameters->options().section_start(os->name(), &addr); 1937 1938 // In general the only thing we really care about for PT_LOAD 1939 // segments is whether or not they are writable or executable, 1940 // so that is how we search for them. 1941 // Large data sections also go into their own PT_LOAD segment. 1942 // People who need segments sorted on some other basis will 1943 // have to use a linker script. 1944 1945 Segment_list::const_iterator p; 1946 if (!os->is_unique_segment()) 1947 { 1948 for (p = this->segment_list_.begin(); 1949 p != this->segment_list_.end(); 1950 ++p) 1951 { 1952 if ((*p)->type() != elfcpp::PT_LOAD) 1953 continue; 1954 if ((*p)->is_unique_segment()) 1955 continue; 1956 if (!parameters->options().omagic() 1957 && ((*p)->flags() & elfcpp::PF_W) != (seg_flags & elfcpp::PF_W)) 1958 continue; 1959 if ((target->isolate_execinstr() || parameters->options().rosegment()) 1960 && ((*p)->flags() & elfcpp::PF_X) != (seg_flags & elfcpp::PF_X)) 1961 continue; 1962 // If -Tbss was specified, we need to separate the data and BSS 1963 // segments. 1964 if (parameters->options().user_set_Tbss()) 1965 { 1966 if ((os->type() == elfcpp::SHT_NOBITS) 1967 == (*p)->has_any_data_sections()) 1968 continue; 1969 } 1970 if (os->is_large_data_section() && !(*p)->is_large_data_segment()) 1971 continue; 1972 1973 if (is_address_set) 1974 { 1975 if ((*p)->are_addresses_set()) 1976 continue; 1977 1978 (*p)->add_initial_output_data(os); 1979 (*p)->update_flags_for_output_section(seg_flags); 1980 (*p)->set_addresses(addr, addr); 1981 break; 1982 } 1983 1984 (*p)->add_output_section_to_load(this, os, seg_flags); 1985 break; 1986 } 1987 } 1988 1989 if (p == this->segment_list_.end() 1990 || os->is_unique_segment()) 1991 { 1992 Output_segment* oseg = this->make_output_segment(elfcpp::PT_LOAD, 1993 seg_flags); 1994 if (os->is_large_data_section()) 1995 oseg->set_is_large_data_segment(); 1996 oseg->add_output_section_to_load(this, os, seg_flags); 1997 if (is_address_set) 1998 oseg->set_addresses(addr, addr); 1999 // Check if segment should be marked unique. For segments marked 2000 // unique by linker plugins, set the new alignment if specified. 2001 if (os->is_unique_segment()) 2002 { 2003 oseg->set_is_unique_segment(); 2004 if (os->segment_alignment() != 0) 2005 oseg->set_minimum_p_align(os->segment_alignment()); 2006 } 2007 } 2008 2009 // If we see a loadable SHT_NOTE section, we create a PT_NOTE 2010 // segment. 2011 if (os->type() == elfcpp::SHT_NOTE) 2012 { 2013 // See if we already have an equivalent PT_NOTE segment. 2014 for (p = this->segment_list_.begin(); 2015 p != segment_list_.end(); 2016 ++p) 2017 { 2018 if ((*p)->type() == elfcpp::PT_NOTE 2019 && (((*p)->flags() & elfcpp::PF_W) 2020 == (seg_flags & elfcpp::PF_W))) 2021 { 2022 (*p)->add_output_section_to_nonload(os, seg_flags); 2023 break; 2024 } 2025 } 2026 2027 if (p == this->segment_list_.end()) 2028 { 2029 Output_segment* oseg = this->make_output_segment(elfcpp::PT_NOTE, 2030 seg_flags); 2031 oseg->add_output_section_to_nonload(os, seg_flags); 2032 } 2033 } 2034 2035 // If we see a loadable SHF_TLS section, we create a PT_TLS 2036 // segment. There can only be one such segment. 2037 if ((flags & elfcpp::SHF_TLS) != 0) 2038 { 2039 if (this->tls_segment_ == NULL) 2040 this->make_output_segment(elfcpp::PT_TLS, seg_flags); 2041 this->tls_segment_->add_output_section_to_nonload(os, seg_flags); 2042 } 2043 2044 // If -z relro is in effect, and we see a relro section, we create a 2045 // PT_GNU_RELRO segment. There can only be one such segment. 2046 if (os->is_relro() && parameters->options().relro()) 2047 { 2048 gold_assert(seg_flags == (elfcpp::PF_R | elfcpp::PF_W)); 2049 if (this->relro_segment_ == NULL) 2050 this->make_output_segment(elfcpp::PT_GNU_RELRO, seg_flags); 2051 this->relro_segment_->add_output_section_to_nonload(os, seg_flags); 2052 } 2053 2054 // If we see a section named .interp, put it into a PT_INTERP 2055 // segment. This seems broken to me, but this is what GNU ld does, 2056 // and glibc expects it. 2057 if (strcmp(os->name(), ".interp") == 0 2058 && !this->script_options_->saw_phdrs_clause()) 2059 { 2060 if (this->interp_segment_ == NULL) 2061 this->make_output_segment(elfcpp::PT_INTERP, seg_flags); 2062 else 2063 gold_warning(_("multiple '.interp' sections in input files " 2064 "may cause confusing PT_INTERP segment")); 2065 this->interp_segment_->add_output_section_to_nonload(os, seg_flags); 2066 } 2067} 2068 2069// Make an output section for a script. 2070 2071Output_section* 2072Layout::make_output_section_for_script( 2073 const char* name, 2074 Script_sections::Section_type section_type) 2075{ 2076 name = this->namepool_.add(name, false, NULL); 2077 elfcpp::Elf_Xword sh_flags = elfcpp::SHF_ALLOC; 2078 if (section_type == Script_sections::ST_NOLOAD) 2079 sh_flags = 0; 2080 Output_section* os = this->make_output_section(name, elfcpp::SHT_PROGBITS, 2081 sh_flags, ORDER_INVALID, 2082 false); 2083 os->set_found_in_sections_clause(); 2084 if (section_type == Script_sections::ST_NOLOAD) 2085 os->set_is_noload(); 2086 return os; 2087} 2088 2089// Return the number of segments we expect to see. 2090 2091size_t 2092Layout::expected_segment_count() const 2093{ 2094 size_t ret = this->segment_list_.size(); 2095 2096 // If we didn't see a SECTIONS clause in a linker script, we should 2097 // already have the complete list of segments. Otherwise we ask the 2098 // SECTIONS clause how many segments it expects, and add in the ones 2099 // we already have (PT_GNU_STACK, PT_GNU_EH_FRAME, etc.) 2100 2101 if (!this->script_options_->saw_sections_clause()) 2102 return ret; 2103 else 2104 { 2105 const Script_sections* ss = this->script_options_->script_sections(); 2106 return ret + ss->expected_segment_count(this); 2107 } 2108} 2109 2110// Handle the .note.GNU-stack section at layout time. SEEN_GNU_STACK 2111// is whether we saw a .note.GNU-stack section in the object file. 2112// GNU_STACK_FLAGS is the section flags. The flags give the 2113// protection required for stack memory. We record this in an 2114// executable as a PT_GNU_STACK segment. If an object file does not 2115// have a .note.GNU-stack segment, we must assume that it is an old 2116// object. On some targets that will force an executable stack. 2117 2118void 2119Layout::layout_gnu_stack(bool seen_gnu_stack, uint64_t gnu_stack_flags, 2120 const Object* obj) 2121{ 2122 if (!seen_gnu_stack) 2123 { 2124 this->input_without_gnu_stack_note_ = true; 2125 if (parameters->options().warn_execstack() 2126 && parameters->target().is_default_stack_executable()) 2127 gold_warning(_("%s: missing .note.GNU-stack section" 2128 " implies executable stack"), 2129 obj->name().c_str()); 2130 } 2131 else 2132 { 2133 this->input_with_gnu_stack_note_ = true; 2134 if ((gnu_stack_flags & elfcpp::SHF_EXECINSTR) != 0) 2135 { 2136 this->input_requires_executable_stack_ = true; 2137 if (parameters->options().warn_execstack()) 2138 gold_warning(_("%s: requires executable stack"), 2139 obj->name().c_str()); 2140 } 2141 } 2142} 2143 2144// Create automatic note sections. 2145 2146void 2147Layout::create_notes() 2148{ 2149 this->create_gold_note(); 2150 this->create_stack_segment(); 2151 this->create_build_id(); 2152} 2153 2154// Create the dynamic sections which are needed before we read the 2155// relocs. 2156 2157void 2158Layout::create_initial_dynamic_sections(Symbol_table* symtab) 2159{ 2160 if (parameters->doing_static_link()) 2161 return; 2162 2163 this->dynamic_section_ = this->choose_output_section(NULL, ".dynamic", 2164 elfcpp::SHT_DYNAMIC, 2165 (elfcpp::SHF_ALLOC 2166 | elfcpp::SHF_WRITE), 2167 false, ORDER_RELRO, 2168 true, false, false); 2169 2170 // A linker script may discard .dynamic, so check for NULL. 2171 if (this->dynamic_section_ != NULL) 2172 { 2173 this->dynamic_symbol_ = 2174 symtab->define_in_output_data("_DYNAMIC", NULL, 2175 Symbol_table::PREDEFINED, 2176 this->dynamic_section_, 0, 0, 2177 elfcpp::STT_OBJECT, elfcpp::STB_LOCAL, 2178 elfcpp::STV_HIDDEN, 0, false, false); 2179 2180 this->dynamic_data_ = new Output_data_dynamic(&this->dynpool_); 2181 2182 this->dynamic_section_->add_output_section_data(this->dynamic_data_); 2183 } 2184} 2185 2186// For each output section whose name can be represented as C symbol, 2187// define __start and __stop symbols for the section. This is a GNU 2188// extension. 2189 2190void 2191Layout::define_section_symbols(Symbol_table* symtab) 2192{ 2193 for (Section_list::const_iterator p = this->section_list_.begin(); 2194 p != this->section_list_.end(); 2195 ++p) 2196 { 2197 const char* const name = (*p)->name(); 2198 if (is_cident(name)) 2199 { 2200 const std::string name_string(name); 2201 const std::string start_name(cident_section_start_prefix 2202 + name_string); 2203 const std::string stop_name(cident_section_stop_prefix 2204 + name_string); 2205 2206 symtab->define_in_output_data(start_name.c_str(), 2207 NULL, // version 2208 Symbol_table::PREDEFINED, 2209 *p, 2210 0, // value 2211 0, // symsize 2212 elfcpp::STT_NOTYPE, 2213 elfcpp::STB_GLOBAL, 2214 elfcpp::STV_DEFAULT, 2215 0, // nonvis 2216 false, // offset_is_from_end 2217 true); // only_if_ref 2218 2219 symtab->define_in_output_data(stop_name.c_str(), 2220 NULL, // version 2221 Symbol_table::PREDEFINED, 2222 *p, 2223 0, // value 2224 0, // symsize 2225 elfcpp::STT_NOTYPE, 2226 elfcpp::STB_GLOBAL, 2227 elfcpp::STV_DEFAULT, 2228 0, // nonvis 2229 true, // offset_is_from_end 2230 true); // only_if_ref 2231 } 2232 } 2233} 2234 2235// Define symbols for group signatures. 2236 2237void 2238Layout::define_group_signatures(Symbol_table* symtab) 2239{ 2240 for (Group_signatures::iterator p = this->group_signatures_.begin(); 2241 p != this->group_signatures_.end(); 2242 ++p) 2243 { 2244 Symbol* sym = symtab->lookup(p->signature, NULL); 2245 if (sym != NULL) 2246 p->section->set_info_symndx(sym); 2247 else 2248 { 2249 // Force the name of the group section to the group 2250 // signature, and use the group's section symbol as the 2251 // signature symbol. 2252 if (strcmp(p->section->name(), p->signature) != 0) 2253 { 2254 const char* name = this->namepool_.add(p->signature, 2255 true, NULL); 2256 p->section->set_name(name); 2257 } 2258 p->section->set_needs_symtab_index(); 2259 p->section->set_info_section_symndx(p->section); 2260 } 2261 } 2262 2263 this->group_signatures_.clear(); 2264} 2265 2266// Find the first read-only PT_LOAD segment, creating one if 2267// necessary. 2268 2269Output_segment* 2270Layout::find_first_load_seg(const Target* target) 2271{ 2272 Output_segment* best = NULL; 2273 for (Segment_list::const_iterator p = this->segment_list_.begin(); 2274 p != this->segment_list_.end(); 2275 ++p) 2276 { 2277 if ((*p)->type() == elfcpp::PT_LOAD 2278 && ((*p)->flags() & elfcpp::PF_R) != 0 2279 && (parameters->options().omagic() 2280 || ((*p)->flags() & elfcpp::PF_W) == 0) 2281 && (!target->isolate_execinstr() 2282 || ((*p)->flags() & elfcpp::PF_X) == 0)) 2283 { 2284 if (best == NULL || this->segment_precedes(*p, best)) 2285 best = *p; 2286 } 2287 } 2288 if (best != NULL) 2289 return best; 2290 2291 gold_assert(!this->script_options_->saw_phdrs_clause()); 2292 2293 Output_segment* load_seg = this->make_output_segment(elfcpp::PT_LOAD, 2294 elfcpp::PF_R); 2295 return load_seg; 2296} 2297 2298// Save states of all current output segments. Store saved states 2299// in SEGMENT_STATES. 2300 2301void 2302Layout::save_segments(Segment_states* segment_states) 2303{ 2304 for (Segment_list::const_iterator p = this->segment_list_.begin(); 2305 p != this->segment_list_.end(); 2306 ++p) 2307 { 2308 Output_segment* segment = *p; 2309 // Shallow copy. 2310 Output_segment* copy = new Output_segment(*segment); 2311 (*segment_states)[segment] = copy; 2312 } 2313} 2314 2315// Restore states of output segments and delete any segment not found in 2316// SEGMENT_STATES. 2317 2318void 2319Layout::restore_segments(const Segment_states* segment_states) 2320{ 2321 // Go through the segment list and remove any segment added in the 2322 // relaxation loop. 2323 this->tls_segment_ = NULL; 2324 this->relro_segment_ = NULL; 2325 Segment_list::iterator list_iter = this->segment_list_.begin(); 2326 while (list_iter != this->segment_list_.end()) 2327 { 2328 Output_segment* segment = *list_iter; 2329 Segment_states::const_iterator states_iter = 2330 segment_states->find(segment); 2331 if (states_iter != segment_states->end()) 2332 { 2333 const Output_segment* copy = states_iter->second; 2334 // Shallow copy to restore states. 2335 *segment = *copy; 2336 2337 // Also fix up TLS and RELRO segment pointers as appropriate. 2338 if (segment->type() == elfcpp::PT_TLS) 2339 this->tls_segment_ = segment; 2340 else if (segment->type() == elfcpp::PT_GNU_RELRO) 2341 this->relro_segment_ = segment; 2342 2343 ++list_iter; 2344 } 2345 else 2346 { 2347 list_iter = this->segment_list_.erase(list_iter); 2348 // This is a segment created during section layout. It should be 2349 // safe to remove it since we should have removed all pointers to it. 2350 delete segment; 2351 } 2352 } 2353} 2354 2355// Clean up after relaxation so that sections can be laid out again. 2356 2357void 2358Layout::clean_up_after_relaxation() 2359{ 2360 // Restore the segments to point state just prior to the relaxation loop. 2361 Script_sections* script_section = this->script_options_->script_sections(); 2362 script_section->release_segments(); 2363 this->restore_segments(this->segment_states_); 2364 2365 // Reset section addresses and file offsets 2366 for (Section_list::iterator p = this->section_list_.begin(); 2367 p != this->section_list_.end(); 2368 ++p) 2369 { 2370 (*p)->restore_states(); 2371 2372 // If an input section changes size because of relaxation, 2373 // we need to adjust the section offsets of all input sections. 2374 // after such a section. 2375 if ((*p)->section_offsets_need_adjustment()) 2376 (*p)->adjust_section_offsets(); 2377 2378 (*p)->reset_address_and_file_offset(); 2379 } 2380 2381 // Reset special output object address and file offsets. 2382 for (Data_list::iterator p = this->special_output_list_.begin(); 2383 p != this->special_output_list_.end(); 2384 ++p) 2385 (*p)->reset_address_and_file_offset(); 2386 2387 // A linker script may have created some output section data objects. 2388 // They are useless now. 2389 for (Output_section_data_list::const_iterator p = 2390 this->script_output_section_data_list_.begin(); 2391 p != this->script_output_section_data_list_.end(); 2392 ++p) 2393 delete *p; 2394 this->script_output_section_data_list_.clear(); 2395 2396 // Special-case fill output objects are recreated each time through 2397 // the relaxation loop. 2398 this->reset_relax_output(); 2399} 2400 2401void 2402Layout::reset_relax_output() 2403{ 2404 for (Data_list::const_iterator p = this->relax_output_list_.begin(); 2405 p != this->relax_output_list_.end(); 2406 ++p) 2407 delete *p; 2408 this->relax_output_list_.clear(); 2409} 2410 2411// Prepare for relaxation. 2412 2413void 2414Layout::prepare_for_relaxation() 2415{ 2416 // Create an relaxation debug check if in debugging mode. 2417 if (is_debugging_enabled(DEBUG_RELAXATION)) 2418 this->relaxation_debug_check_ = new Relaxation_debug_check(); 2419 2420 // Save segment states. 2421 this->segment_states_ = new Segment_states(); 2422 this->save_segments(this->segment_states_); 2423 2424 for(Section_list::const_iterator p = this->section_list_.begin(); 2425 p != this->section_list_.end(); 2426 ++p) 2427 (*p)->save_states(); 2428 2429 if (is_debugging_enabled(DEBUG_RELAXATION)) 2430 this->relaxation_debug_check_->check_output_data_for_reset_values( 2431 this->section_list_, this->special_output_list_, 2432 this->relax_output_list_); 2433 2434 // Also enable recording of output section data from scripts. 2435 this->record_output_section_data_from_script_ = true; 2436} 2437 2438// If the user set the address of the text segment, that may not be 2439// compatible with putting the segment headers and file headers into 2440// that segment. For isolate_execinstr() targets, it's the rodata 2441// segment rather than text where we might put the headers. 2442static inline bool 2443load_seg_unusable_for_headers(const Target* target) 2444{ 2445 const General_options& options = parameters->options(); 2446 if (target->isolate_execinstr()) 2447 return (options.user_set_Trodata_segment() 2448 && options.Trodata_segment() % target->abi_pagesize() != 0); 2449 else 2450 return (options.user_set_Ttext() 2451 && options.Ttext() % target->abi_pagesize() != 0); 2452} 2453 2454// Relaxation loop body: If target has no relaxation, this runs only once 2455// Otherwise, the target relaxation hook is called at the end of 2456// each iteration. If the hook returns true, it means re-layout of 2457// section is required. 2458// 2459// The number of segments created by a linking script without a PHDRS 2460// clause may be affected by section sizes and alignments. There is 2461// a remote chance that relaxation causes different number of PT_LOAD 2462// segments are created and sections are attached to different segments. 2463// Therefore, we always throw away all segments created during section 2464// layout. In order to be able to restart the section layout, we keep 2465// a copy of the segment list right before the relaxation loop and use 2466// that to restore the segments. 2467// 2468// PASS is the current relaxation pass number. 2469// SYMTAB is a symbol table. 2470// PLOAD_SEG is the address of a pointer for the load segment. 2471// PHDR_SEG is a pointer to the PHDR segment. 2472// SEGMENT_HEADERS points to the output segment header. 2473// FILE_HEADER points to the output file header. 2474// PSHNDX is the address to store the output section index. 2475 2476off_t inline 2477Layout::relaxation_loop_body( 2478 int pass, 2479 Target* target, 2480 Symbol_table* symtab, 2481 Output_segment** pload_seg, 2482 Output_segment* phdr_seg, 2483 Output_segment_headers* segment_headers, 2484 Output_file_header* file_header, 2485 unsigned int* pshndx) 2486{ 2487 // If this is not the first iteration, we need to clean up after 2488 // relaxation so that we can lay out the sections again. 2489 if (pass != 0) 2490 this->clean_up_after_relaxation(); 2491 2492 // If there is a SECTIONS clause, put all the input sections into 2493 // the required order. 2494 Output_segment* load_seg; 2495 if (this->script_options_->saw_sections_clause()) 2496 load_seg = this->set_section_addresses_from_script(symtab); 2497 else if (parameters->options().relocatable()) 2498 load_seg = NULL; 2499 else 2500 load_seg = this->find_first_load_seg(target); 2501 2502 if (parameters->options().oformat_enum() 2503 != General_options::OBJECT_FORMAT_ELF) 2504 load_seg = NULL; 2505 2506 if (load_seg_unusable_for_headers(target)) 2507 { 2508 load_seg = NULL; 2509 phdr_seg = NULL; 2510 } 2511 2512 gold_assert(phdr_seg == NULL 2513 || load_seg != NULL 2514 || this->script_options_->saw_sections_clause()); 2515 2516 // If the address of the load segment we found has been set by 2517 // --section-start rather than by a script, then adjust the VMA and 2518 // LMA downward if possible to include the file and section headers. 2519 uint64_t header_gap = 0; 2520 if (load_seg != NULL 2521 && load_seg->are_addresses_set() 2522 && !this->script_options_->saw_sections_clause() 2523 && !parameters->options().relocatable()) 2524 { 2525 file_header->finalize_data_size(); 2526 segment_headers->finalize_data_size(); 2527 size_t sizeof_headers = (file_header->data_size() 2528 + segment_headers->data_size()); 2529 const uint64_t abi_pagesize = target->abi_pagesize(); 2530 uint64_t hdr_paddr = load_seg->paddr() - sizeof_headers; 2531 hdr_paddr &= ~(abi_pagesize - 1); 2532 uint64_t subtract = load_seg->paddr() - hdr_paddr; 2533 if (load_seg->paddr() < subtract || load_seg->vaddr() < subtract) 2534 load_seg = NULL; 2535 else 2536 { 2537 load_seg->set_addresses(load_seg->vaddr() - subtract, 2538 load_seg->paddr() - subtract); 2539 header_gap = subtract - sizeof_headers; 2540 } 2541 } 2542 2543 // Lay out the segment headers. 2544 if (!parameters->options().relocatable()) 2545 { 2546 gold_assert(segment_headers != NULL); 2547 if (header_gap != 0 && load_seg != NULL) 2548 { 2549 Output_data_zero_fill* z = new Output_data_zero_fill(header_gap, 1); 2550 load_seg->add_initial_output_data(z); 2551 } 2552 if (load_seg != NULL) 2553 load_seg->add_initial_output_data(segment_headers); 2554 if (phdr_seg != NULL) 2555 phdr_seg->add_initial_output_data(segment_headers); 2556 } 2557 2558 // Lay out the file header. 2559 if (load_seg != NULL) 2560 load_seg->add_initial_output_data(file_header); 2561 2562 if (this->script_options_->saw_phdrs_clause() 2563 && !parameters->options().relocatable()) 2564 { 2565 // Support use of FILEHDRS and PHDRS attachments in a PHDRS 2566 // clause in a linker script. 2567 Script_sections* ss = this->script_options_->script_sections(); 2568 ss->put_headers_in_phdrs(file_header, segment_headers); 2569 } 2570 2571 // We set the output section indexes in set_segment_offsets and 2572 // set_section_indexes. 2573 *pshndx = 1; 2574 2575 // Set the file offsets of all the segments, and all the sections 2576 // they contain. 2577 off_t off; 2578 if (!parameters->options().relocatable()) 2579 off = this->set_segment_offsets(target, load_seg, pshndx); 2580 else 2581 off = this->set_relocatable_section_offsets(file_header, pshndx); 2582 2583 // Verify that the dummy relaxation does not change anything. 2584 if (is_debugging_enabled(DEBUG_RELAXATION)) 2585 { 2586 if (pass == 0) 2587 this->relaxation_debug_check_->read_sections(this->section_list_); 2588 else 2589 this->relaxation_debug_check_->verify_sections(this->section_list_); 2590 } 2591 2592 *pload_seg = load_seg; 2593 return off; 2594} 2595 2596// Search the list of patterns and find the position of the given section 2597// name in the output section. If the section name matches a glob 2598// pattern and a non-glob name, then the non-glob position takes 2599// precedence. Return 0 if no match is found. 2600 2601unsigned int 2602Layout::find_section_order_index(const std::string& section_name) 2603{ 2604 Unordered_map<std::string, unsigned int>::iterator map_it; 2605 map_it = this->input_section_position_.find(section_name); 2606 if (map_it != this->input_section_position_.end()) 2607 return map_it->second; 2608 2609 // Absolute match failed. Linear search the glob patterns. 2610 std::vector<std::string>::iterator it; 2611 for (it = this->input_section_glob_.begin(); 2612 it != this->input_section_glob_.end(); 2613 ++it) 2614 { 2615 if (fnmatch((*it).c_str(), section_name.c_str(), FNM_NOESCAPE) == 0) 2616 { 2617 map_it = this->input_section_position_.find(*it); 2618 gold_assert(map_it != this->input_section_position_.end()); 2619 return map_it->second; 2620 } 2621 } 2622 return 0; 2623} 2624 2625// Read the sequence of input sections from the file specified with 2626// option --section-ordering-file. 2627 2628void 2629Layout::read_layout_from_file() 2630{ 2631 const char* filename = parameters->options().section_ordering_file(); 2632 std::ifstream in; 2633 std::string line; 2634 2635 in.open(filename); 2636 if (!in) 2637 gold_fatal(_("unable to open --section-ordering-file file %s: %s"), 2638 filename, strerror(errno)); 2639 2640 std::getline(in, line); // this chops off the trailing \n, if any 2641 unsigned int position = 1; 2642 this->set_section_ordering_specified(); 2643 2644 while (in) 2645 { 2646 if (!line.empty() && line[line.length() - 1] == '\r') // Windows 2647 line.resize(line.length() - 1); 2648 // Ignore comments, beginning with '#' 2649 if (line[0] == '#') 2650 { 2651 std::getline(in, line); 2652 continue; 2653 } 2654 this->input_section_position_[line] = position; 2655 // Store all glob patterns in a vector. 2656 if (is_wildcard_string(line.c_str())) 2657 this->input_section_glob_.push_back(line); 2658 position++; 2659 std::getline(in, line); 2660 } 2661} 2662 2663// Finalize the layout. When this is called, we have created all the 2664// output sections and all the output segments which are based on 2665// input sections. We have several things to do, and we have to do 2666// them in the right order, so that we get the right results correctly 2667// and efficiently. 2668 2669// 1) Finalize the list of output segments and create the segment 2670// table header. 2671 2672// 2) Finalize the dynamic symbol table and associated sections. 2673 2674// 3) Determine the final file offset of all the output segments. 2675 2676// 4) Determine the final file offset of all the SHF_ALLOC output 2677// sections. 2678 2679// 5) Create the symbol table sections and the section name table 2680// section. 2681 2682// 6) Finalize the symbol table: set symbol values to their final 2683// value and make a final determination of which symbols are going 2684// into the output symbol table. 2685 2686// 7) Create the section table header. 2687 2688// 8) Determine the final file offset of all the output sections which 2689// are not SHF_ALLOC, including the section table header. 2690 2691// 9) Finalize the ELF file header. 2692 2693// This function returns the size of the output file. 2694 2695off_t 2696Layout::finalize(const Input_objects* input_objects, Symbol_table* symtab, 2697 Target* target, const Task* task) 2698{ 2699 unsigned int local_dynamic_count = 0; 2700 unsigned int forced_local_dynamic_count = 0; 2701 2702 target->finalize_sections(this, input_objects, symtab); 2703 2704 this->count_local_symbols(task, input_objects); 2705 2706 this->link_stabs_sections(); 2707 2708 Output_segment* phdr_seg = NULL; 2709 if (!parameters->options().relocatable() && !parameters->doing_static_link()) 2710 { 2711 // There was a dynamic object in the link. We need to create 2712 // some information for the dynamic linker. 2713 2714 // Create the PT_PHDR segment which will hold the program 2715 // headers. 2716 if (!this->script_options_->saw_phdrs_clause()) 2717 phdr_seg = this->make_output_segment(elfcpp::PT_PHDR, elfcpp::PF_R); 2718 2719 // Create the dynamic symbol table, including the hash table. 2720 Output_section* dynstr; 2721 std::vector<Symbol*> dynamic_symbols; 2722 Versions versions(*this->script_options()->version_script_info(), 2723 &this->dynpool_); 2724 this->create_dynamic_symtab(input_objects, symtab, &dynstr, 2725 &local_dynamic_count, 2726 &forced_local_dynamic_count, 2727 &dynamic_symbols, 2728 &versions); 2729 2730 // Create the .interp section to hold the name of the 2731 // interpreter, and put it in a PT_INTERP segment. Don't do it 2732 // if we saw a .interp section in an input file. 2733 if ((!parameters->options().shared() 2734 || parameters->options().dynamic_linker() != NULL) 2735 && this->interp_segment_ == NULL) 2736 this->create_interp(target); 2737 2738 // Finish the .dynamic section to hold the dynamic data, and put 2739 // it in a PT_DYNAMIC segment. 2740 this->finish_dynamic_section(input_objects, symtab); 2741 2742 // We should have added everything we need to the dynamic string 2743 // table. 2744 this->dynpool_.set_string_offsets(); 2745 2746 // Create the version sections. We can't do this until the 2747 // dynamic string table is complete. 2748 this->create_version_sections(&versions, symtab, 2749 (local_dynamic_count 2750 + forced_local_dynamic_count), 2751 dynamic_symbols, dynstr); 2752 2753 // Set the size of the _DYNAMIC symbol. We can't do this until 2754 // after we call create_version_sections. 2755 this->set_dynamic_symbol_size(symtab); 2756 } 2757 2758 // Create segment headers. 2759 Output_segment_headers* segment_headers = 2760 (parameters->options().relocatable() 2761 ? NULL 2762 : new Output_segment_headers(this->segment_list_)); 2763 2764 // Lay out the file header. 2765 Output_file_header* file_header = new Output_file_header(target, symtab, 2766 segment_headers); 2767 2768 this->special_output_list_.push_back(file_header); 2769 if (segment_headers != NULL) 2770 this->special_output_list_.push_back(segment_headers); 2771 2772 // Find approriate places for orphan output sections if we are using 2773 // a linker script. 2774 if (this->script_options_->saw_sections_clause()) 2775 this->place_orphan_sections_in_script(); 2776 2777 Output_segment* load_seg; 2778 off_t off; 2779 unsigned int shndx; 2780 int pass = 0; 2781 2782 // Take a snapshot of the section layout as needed. 2783 if (target->may_relax()) 2784 this->prepare_for_relaxation(); 2785 2786 // Run the relaxation loop to lay out sections. 2787 do 2788 { 2789 off = this->relaxation_loop_body(pass, target, symtab, &load_seg, 2790 phdr_seg, segment_headers, file_header, 2791 &shndx); 2792 pass++; 2793 } 2794 while (target->may_relax() 2795 && target->relax(pass, input_objects, symtab, this, task)); 2796 2797 // If there is a load segment that contains the file and program headers, 2798 // provide a symbol __ehdr_start pointing there. 2799 // A program can use this to examine itself robustly. 2800 Symbol *ehdr_start = symtab->lookup("__ehdr_start"); 2801 if (ehdr_start != NULL && ehdr_start->is_predefined()) 2802 { 2803 if (load_seg != NULL) 2804 ehdr_start->set_output_segment(load_seg, Symbol::SEGMENT_START); 2805 else 2806 ehdr_start->set_undefined(); 2807 } 2808 2809 // Set the file offsets of all the non-data sections we've seen so 2810 // far which don't have to wait for the input sections. We need 2811 // this in order to finalize local symbols in non-allocated 2812 // sections. 2813 off = this->set_section_offsets(off, BEFORE_INPUT_SECTIONS_PASS); 2814 2815 // Set the section indexes of all unallocated sections seen so far, 2816 // in case any of them are somehow referenced by a symbol. 2817 shndx = this->set_section_indexes(shndx); 2818 2819 // Create the symbol table sections. 2820 this->create_symtab_sections(input_objects, symtab, shndx, &off, 2821 local_dynamic_count); 2822 if (!parameters->doing_static_link()) 2823 this->assign_local_dynsym_offsets(input_objects); 2824 2825 // Process any symbol assignments from a linker script. This must 2826 // be called after the symbol table has been finalized. 2827 this->script_options_->finalize_symbols(symtab, this); 2828 2829 // Create the incremental inputs sections. 2830 if (this->incremental_inputs_) 2831 { 2832 this->incremental_inputs_->finalize(); 2833 this->create_incremental_info_sections(symtab); 2834 } 2835 2836 // Create the .shstrtab section. 2837 Output_section* shstrtab_section = this->create_shstrtab(); 2838 2839 // Set the file offsets of the rest of the non-data sections which 2840 // don't have to wait for the input sections. 2841 off = this->set_section_offsets(off, BEFORE_INPUT_SECTIONS_PASS); 2842 2843 // Now that all sections have been created, set the section indexes 2844 // for any sections which haven't been done yet. 2845 shndx = this->set_section_indexes(shndx); 2846 2847 // Create the section table header. 2848 this->create_shdrs(shstrtab_section, &off); 2849 2850 // If there are no sections which require postprocessing, we can 2851 // handle the section names now, and avoid a resize later. 2852 if (!this->any_postprocessing_sections_) 2853 { 2854 off = this->set_section_offsets(off, 2855 POSTPROCESSING_SECTIONS_PASS); 2856 off = 2857 this->set_section_offsets(off, 2858 STRTAB_AFTER_POSTPROCESSING_SECTIONS_PASS); 2859 } 2860 2861 file_header->set_section_info(this->section_headers_, shstrtab_section); 2862 2863 // Now we know exactly where everything goes in the output file 2864 // (except for non-allocated sections which require postprocessing). 2865 Output_data::layout_complete(); 2866 2867 this->output_file_size_ = off; 2868 2869 return off; 2870} 2871 2872// Create a note header following the format defined in the ELF ABI. 2873// NAME is the name, NOTE_TYPE is the type, SECTION_NAME is the name 2874// of the section to create, DESCSZ is the size of the descriptor. 2875// ALLOCATE is true if the section should be allocated in memory. 2876// This returns the new note section. It sets *TRAILING_PADDING to 2877// the number of trailing zero bytes required. 2878 2879Output_section* 2880Layout::create_note(const char* name, int note_type, 2881 const char* section_name, size_t descsz, 2882 bool allocate, size_t* trailing_padding) 2883{ 2884 // Authorities all agree that the values in a .note field should 2885 // be aligned on 4-byte boundaries for 32-bit binaries. However, 2886 // they differ on what the alignment is for 64-bit binaries. 2887 // The GABI says unambiguously they take 8-byte alignment: 2888 // http://sco.com/developers/gabi/latest/ch5.pheader.html#note_section 2889 // Other documentation says alignment should always be 4 bytes: 2890 // http://www.netbsd.org/docs/kernel/elf-notes.html#note-format 2891 // GNU ld and GNU readelf both support the latter (at least as of 2892 // version 2.16.91), and glibc always generates the latter for 2893 // .note.ABI-tag (as of version 1.6), so that's the one we go with 2894 // here. 2895#ifdef GABI_FORMAT_FOR_DOTNOTE_SECTION // This is not defined by default. 2896 const int size = parameters->target().get_size(); 2897#else 2898 const int size = 32; 2899#endif 2900 2901 // The contents of the .note section. 2902 size_t namesz = strlen(name) + 1; 2903 size_t aligned_namesz = align_address(namesz, size / 8); 2904 size_t aligned_descsz = align_address(descsz, size / 8); 2905 2906 size_t notehdrsz = 3 * (size / 8) + aligned_namesz; 2907 2908 unsigned char* buffer = new unsigned char[notehdrsz]; 2909 memset(buffer, 0, notehdrsz); 2910 2911 bool is_big_endian = parameters->target().is_big_endian(); 2912 2913 if (size == 32) 2914 { 2915 if (!is_big_endian) 2916 { 2917 elfcpp::Swap<32, false>::writeval(buffer, namesz); 2918 elfcpp::Swap<32, false>::writeval(buffer + 4, descsz); 2919 elfcpp::Swap<32, false>::writeval(buffer + 8, note_type); 2920 } 2921 else 2922 { 2923 elfcpp::Swap<32, true>::writeval(buffer, namesz); 2924 elfcpp::Swap<32, true>::writeval(buffer + 4, descsz); 2925 elfcpp::Swap<32, true>::writeval(buffer + 8, note_type); 2926 } 2927 } 2928 else if (size == 64) 2929 { 2930 if (!is_big_endian) 2931 { 2932 elfcpp::Swap<64, false>::writeval(buffer, namesz); 2933 elfcpp::Swap<64, false>::writeval(buffer + 8, descsz); 2934 elfcpp::Swap<64, false>::writeval(buffer + 16, note_type); 2935 } 2936 else 2937 { 2938 elfcpp::Swap<64, true>::writeval(buffer, namesz); 2939 elfcpp::Swap<64, true>::writeval(buffer + 8, descsz); 2940 elfcpp::Swap<64, true>::writeval(buffer + 16, note_type); 2941 } 2942 } 2943 else 2944 gold_unreachable(); 2945 2946 memcpy(buffer + 3 * (size / 8), name, namesz); 2947 2948 elfcpp::Elf_Xword flags = 0; 2949 Output_section_order order = ORDER_INVALID; 2950 if (allocate) 2951 { 2952 flags = elfcpp::SHF_ALLOC; 2953 order = ORDER_RO_NOTE; 2954 } 2955 Output_section* os = this->choose_output_section(NULL, section_name, 2956 elfcpp::SHT_NOTE, 2957 flags, false, order, false, 2958 false, true); 2959 if (os == NULL) 2960 return NULL; 2961 2962 Output_section_data* posd = new Output_data_const_buffer(buffer, notehdrsz, 2963 size / 8, 2964 "** note header"); 2965 os->add_output_section_data(posd); 2966 2967 *trailing_padding = aligned_descsz - descsz; 2968 2969 return os; 2970} 2971 2972// For an executable or shared library, create a note to record the 2973// version of gold used to create the binary. 2974 2975void 2976Layout::create_gold_note() 2977{ 2978 if (parameters->options().relocatable() 2979 || parameters->incremental_update()) 2980 return; 2981 2982 std::string desc = std::string("gold ") + gold::get_version_string(); 2983 2984 size_t trailing_padding; 2985 Output_section* os = this->create_note("GNU", elfcpp::NT_GNU_GOLD_VERSION, 2986 ".note.gnu.gold-version", desc.size(), 2987 false, &trailing_padding); 2988 if (os == NULL) 2989 return; 2990 2991 Output_section_data* posd = new Output_data_const(desc, 4); 2992 os->add_output_section_data(posd); 2993 2994 if (trailing_padding > 0) 2995 { 2996 posd = new Output_data_zero_fill(trailing_padding, 0); 2997 os->add_output_section_data(posd); 2998 } 2999} 3000 3001// Record whether the stack should be executable. This can be set 3002// from the command line using the -z execstack or -z noexecstack 3003// options. Otherwise, if any input file has a .note.GNU-stack 3004// section with the SHF_EXECINSTR flag set, the stack should be 3005// executable. Otherwise, if at least one input file a 3006// .note.GNU-stack section, and some input file has no .note.GNU-stack 3007// section, we use the target default for whether the stack should be 3008// executable. If -z stack-size was used to set a p_memsz value for 3009// PT_GNU_STACK, we generate the segment regardless. Otherwise, we 3010// don't generate a stack note. When generating a object file, we 3011// create a .note.GNU-stack section with the appropriate marking. 3012// When generating an executable or shared library, we create a 3013// PT_GNU_STACK segment. 3014 3015void 3016Layout::create_stack_segment() 3017{ 3018 bool is_stack_executable; 3019 if (parameters->options().is_execstack_set()) 3020 { 3021 is_stack_executable = parameters->options().is_stack_executable(); 3022 if (!is_stack_executable 3023 && this->input_requires_executable_stack_ 3024 && parameters->options().warn_execstack()) 3025 gold_warning(_("one or more inputs require executable stack, " 3026 "but -z noexecstack was given")); 3027 } 3028 else if (!this->input_with_gnu_stack_note_ 3029 && (!parameters->options().user_set_stack_size() 3030 || parameters->options().relocatable())) 3031 return; 3032 else 3033 { 3034 if (this->input_requires_executable_stack_) 3035 is_stack_executable = true; 3036 else if (this->input_without_gnu_stack_note_) 3037 is_stack_executable = 3038 parameters->target().is_default_stack_executable(); 3039 else 3040 is_stack_executable = false; 3041 } 3042 3043 if (parameters->options().relocatable()) 3044 { 3045 const char* name = this->namepool_.add(".note.GNU-stack", false, NULL); 3046 elfcpp::Elf_Xword flags = 0; 3047 if (is_stack_executable) 3048 flags |= elfcpp::SHF_EXECINSTR; 3049 this->make_output_section(name, elfcpp::SHT_PROGBITS, flags, 3050 ORDER_INVALID, false); 3051 } 3052 else 3053 { 3054 if (this->script_options_->saw_phdrs_clause()) 3055 return; 3056 int flags = elfcpp::PF_R | elfcpp::PF_W; 3057 if (is_stack_executable) 3058 flags |= elfcpp::PF_X; 3059 Output_segment* seg = 3060 this->make_output_segment(elfcpp::PT_GNU_STACK, flags); 3061 seg->set_size(parameters->options().stack_size()); 3062 // BFD lets targets override this default alignment, but the only 3063 // targets that do so are ones that Gold does not support so far. 3064 seg->set_minimum_p_align(16); 3065 } 3066} 3067 3068// If --build-id was used, set up the build ID note. 3069 3070void 3071Layout::create_build_id() 3072{ 3073 if (!parameters->options().user_set_build_id()) 3074 return; 3075 3076 const char* style = parameters->options().build_id(); 3077 if (strcmp(style, "none") == 0) 3078 return; 3079 3080 // Set DESCSZ to the size of the note descriptor. When possible, 3081 // set DESC to the note descriptor contents. 3082 size_t descsz; 3083 std::string desc; 3084 if (strcmp(style, "md5") == 0) 3085 descsz = 128 / 8; 3086 else if ((strcmp(style, "sha1") == 0) || (strcmp(style, "tree") == 0)) 3087 descsz = 160 / 8; 3088 else if (strcmp(style, "uuid") == 0) 3089 { 3090#ifndef __MINGW32__ 3091 const size_t uuidsz = 128 / 8; 3092 3093 char buffer[uuidsz]; 3094 memset(buffer, 0, uuidsz); 3095 3096 int descriptor = open_descriptor(-1, "/dev/urandom", O_RDONLY); 3097 if (descriptor < 0) 3098 gold_error(_("--build-id=uuid failed: could not open /dev/urandom: %s"), 3099 strerror(errno)); 3100 else 3101 { 3102 ssize_t got = ::read(descriptor, buffer, uuidsz); 3103 release_descriptor(descriptor, true); 3104 if (got < 0) 3105 gold_error(_("/dev/urandom: read failed: %s"), strerror(errno)); 3106 else if (static_cast<size_t>(got) != uuidsz) 3107 gold_error(_("/dev/urandom: expected %zu bytes, got %zd bytes"), 3108 uuidsz, got); 3109 } 3110 3111 desc.assign(buffer, uuidsz); 3112 descsz = uuidsz; 3113#else // __MINGW32__ 3114 UUID uuid; 3115 typedef RPC_STATUS (RPC_ENTRY *UuidCreateFn)(UUID *Uuid); 3116 3117 HMODULE rpc_library = LoadLibrary("rpcrt4.dll"); 3118 if (!rpc_library) 3119 gold_error(_("--build-id=uuid failed: could not load rpcrt4.dll")); 3120 else 3121 { 3122 UuidCreateFn uuid_create = reinterpret_cast<UuidCreateFn>( 3123 GetProcAddress(rpc_library, "UuidCreate")); 3124 if (!uuid_create) 3125 gold_error(_("--build-id=uuid failed: could not find UuidCreate")); 3126 else if (uuid_create(&uuid) != RPC_S_OK) 3127 gold_error(_("__build_id=uuid failed: call UuidCreate() failed")); 3128 FreeLibrary(rpc_library); 3129 } 3130 desc.assign(reinterpret_cast<const char *>(&uuid), sizeof(UUID)); 3131 descsz = sizeof(UUID); 3132#endif // __MINGW32__ 3133 } 3134 else if (strncmp(style, "0x", 2) == 0) 3135 { 3136 hex_init(); 3137 const char* p = style + 2; 3138 while (*p != '\0') 3139 { 3140 if (hex_p(p[0]) && hex_p(p[1])) 3141 { 3142 char c = (hex_value(p[0]) << 4) | hex_value(p[1]); 3143 desc += c; 3144 p += 2; 3145 } 3146 else if (*p == '-' || *p == ':') 3147 ++p; 3148 else 3149 gold_fatal(_("--build-id argument '%s' not a valid hex number"), 3150 style); 3151 } 3152 descsz = desc.size(); 3153 } 3154 else 3155 gold_fatal(_("unrecognized --build-id argument '%s'"), style); 3156 3157 // Create the note. 3158 size_t trailing_padding; 3159 Output_section* os = this->create_note("GNU", elfcpp::NT_GNU_BUILD_ID, 3160 ".note.gnu.build-id", descsz, true, 3161 &trailing_padding); 3162 if (os == NULL) 3163 return; 3164 3165 if (!desc.empty()) 3166 { 3167 // We know the value already, so we fill it in now. 3168 gold_assert(desc.size() == descsz); 3169 3170 Output_section_data* posd = new Output_data_const(desc, 4); 3171 os->add_output_section_data(posd); 3172 3173 if (trailing_padding != 0) 3174 { 3175 posd = new Output_data_zero_fill(trailing_padding, 0); 3176 os->add_output_section_data(posd); 3177 } 3178 } 3179 else 3180 { 3181 // We need to compute a checksum after we have completed the 3182 // link. 3183 gold_assert(trailing_padding == 0); 3184 this->build_id_note_ = new Output_data_zero_fill(descsz, 4); 3185 os->add_output_section_data(this->build_id_note_); 3186 } 3187} 3188 3189// If we have both .stabXX and .stabXXstr sections, then the sh_link 3190// field of the former should point to the latter. I'm not sure who 3191// started this, but the GNU linker does it, and some tools depend 3192// upon it. 3193 3194void 3195Layout::link_stabs_sections() 3196{ 3197 if (!this->have_stabstr_section_) 3198 return; 3199 3200 for (Section_list::iterator p = this->section_list_.begin(); 3201 p != this->section_list_.end(); 3202 ++p) 3203 { 3204 if ((*p)->type() != elfcpp::SHT_STRTAB) 3205 continue; 3206 3207 const char* name = (*p)->name(); 3208 if (strncmp(name, ".stab", 5) != 0) 3209 continue; 3210 3211 size_t len = strlen(name); 3212 if (strcmp(name + len - 3, "str") != 0) 3213 continue; 3214 3215 std::string stab_name(name, len - 3); 3216 Output_section* stab_sec; 3217 stab_sec = this->find_output_section(stab_name.c_str()); 3218 if (stab_sec != NULL) 3219 stab_sec->set_link_section(*p); 3220 } 3221} 3222 3223// Create .gnu_incremental_inputs and related sections needed 3224// for the next run of incremental linking to check what has changed. 3225 3226void 3227Layout::create_incremental_info_sections(Symbol_table* symtab) 3228{ 3229 Incremental_inputs* incr = this->incremental_inputs_; 3230 3231 gold_assert(incr != NULL); 3232 3233 // Create the .gnu_incremental_inputs, _symtab, and _relocs input sections. 3234 incr->create_data_sections(symtab); 3235 3236 // Add the .gnu_incremental_inputs section. 3237 const char* incremental_inputs_name = 3238 this->namepool_.add(".gnu_incremental_inputs", false, NULL); 3239 Output_section* incremental_inputs_os = 3240 this->make_output_section(incremental_inputs_name, 3241 elfcpp::SHT_GNU_INCREMENTAL_INPUTS, 0, 3242 ORDER_INVALID, false); 3243 incremental_inputs_os->add_output_section_data(incr->inputs_section()); 3244 3245 // Add the .gnu_incremental_symtab section. 3246 const char* incremental_symtab_name = 3247 this->namepool_.add(".gnu_incremental_symtab", false, NULL); 3248 Output_section* incremental_symtab_os = 3249 this->make_output_section(incremental_symtab_name, 3250 elfcpp::SHT_GNU_INCREMENTAL_SYMTAB, 0, 3251 ORDER_INVALID, false); 3252 incremental_symtab_os->add_output_section_data(incr->symtab_section()); 3253 incremental_symtab_os->set_entsize(4); 3254 3255 // Add the .gnu_incremental_relocs section. 3256 const char* incremental_relocs_name = 3257 this->namepool_.add(".gnu_incremental_relocs", false, NULL); 3258 Output_section* incremental_relocs_os = 3259 this->make_output_section(incremental_relocs_name, 3260 elfcpp::SHT_GNU_INCREMENTAL_RELOCS, 0, 3261 ORDER_INVALID, false); 3262 incremental_relocs_os->add_output_section_data(incr->relocs_section()); 3263 incremental_relocs_os->set_entsize(incr->relocs_entsize()); 3264 3265 // Add the .gnu_incremental_got_plt section. 3266 const char* incremental_got_plt_name = 3267 this->namepool_.add(".gnu_incremental_got_plt", false, NULL); 3268 Output_section* incremental_got_plt_os = 3269 this->make_output_section(incremental_got_plt_name, 3270 elfcpp::SHT_GNU_INCREMENTAL_GOT_PLT, 0, 3271 ORDER_INVALID, false); 3272 incremental_got_plt_os->add_output_section_data(incr->got_plt_section()); 3273 3274 // Add the .gnu_incremental_strtab section. 3275 const char* incremental_strtab_name = 3276 this->namepool_.add(".gnu_incremental_strtab", false, NULL); 3277 Output_section* incremental_strtab_os = this->make_output_section(incremental_strtab_name, 3278 elfcpp::SHT_STRTAB, 0, 3279 ORDER_INVALID, false); 3280 Output_data_strtab* strtab_data = 3281 new Output_data_strtab(incr->get_stringpool()); 3282 incremental_strtab_os->add_output_section_data(strtab_data); 3283 3284 incremental_inputs_os->set_after_input_sections(); 3285 incremental_symtab_os->set_after_input_sections(); 3286 incremental_relocs_os->set_after_input_sections(); 3287 incremental_got_plt_os->set_after_input_sections(); 3288 3289 incremental_inputs_os->set_link_section(incremental_strtab_os); 3290 incremental_symtab_os->set_link_section(incremental_inputs_os); 3291 incremental_relocs_os->set_link_section(incremental_inputs_os); 3292 incremental_got_plt_os->set_link_section(incremental_inputs_os); 3293} 3294 3295// Return whether SEG1 should be before SEG2 in the output file. This 3296// is based entirely on the segment type and flags. When this is 3297// called the segment addresses have normally not yet been set. 3298 3299bool 3300Layout::segment_precedes(const Output_segment* seg1, 3301 const Output_segment* seg2) 3302{ 3303 // In order to produce a stable ordering if we're called with the same pointer 3304 // return false. 3305 if (seg1 == seg2) 3306 return false; 3307 3308 elfcpp::Elf_Word type1 = seg1->type(); 3309 elfcpp::Elf_Word type2 = seg2->type(); 3310 3311 // The single PT_PHDR segment is required to precede any loadable 3312 // segment. We simply make it always first. 3313 if (type1 == elfcpp::PT_PHDR) 3314 { 3315 gold_assert(type2 != elfcpp::PT_PHDR); 3316 return true; 3317 } 3318 if (type2 == elfcpp::PT_PHDR) 3319 return false; 3320 3321 // The single PT_INTERP segment is required to precede any loadable 3322 // segment. We simply make it always second. 3323 if (type1 == elfcpp::PT_INTERP) 3324 { 3325 gold_assert(type2 != elfcpp::PT_INTERP); 3326 return true; 3327 } 3328 if (type2 == elfcpp::PT_INTERP) 3329 return false; 3330 3331 // We then put PT_LOAD segments before any other segments. 3332 if (type1 == elfcpp::PT_LOAD && type2 != elfcpp::PT_LOAD) 3333 return true; 3334 if (type2 == elfcpp::PT_LOAD && type1 != elfcpp::PT_LOAD) 3335 return false; 3336 3337 // We put the PT_TLS segment last except for the PT_GNU_RELRO 3338 // segment, because that is where the dynamic linker expects to find 3339 // it (this is just for efficiency; other positions would also work 3340 // correctly). 3341 if (type1 == elfcpp::PT_TLS 3342 && type2 != elfcpp::PT_TLS 3343 && type2 != elfcpp::PT_GNU_RELRO) 3344 return false; 3345 if (type2 == elfcpp::PT_TLS 3346 && type1 != elfcpp::PT_TLS 3347 && type1 != elfcpp::PT_GNU_RELRO) 3348 return true; 3349 3350 // We put the PT_GNU_RELRO segment last, because that is where the 3351 // dynamic linker expects to find it (as with PT_TLS, this is just 3352 // for efficiency). 3353 if (type1 == elfcpp::PT_GNU_RELRO && type2 != elfcpp::PT_GNU_RELRO) 3354 return false; 3355 if (type2 == elfcpp::PT_GNU_RELRO && type1 != elfcpp::PT_GNU_RELRO) 3356 return true; 3357 3358 const elfcpp::Elf_Word flags1 = seg1->flags(); 3359 const elfcpp::Elf_Word flags2 = seg2->flags(); 3360 3361 // The order of non-PT_LOAD segments is unimportant. We simply sort 3362 // by the numeric segment type and flags values. There should not 3363 // be more than one segment with the same type and flags, except 3364 // when a linker script specifies such. 3365 if (type1 != elfcpp::PT_LOAD) 3366 { 3367 if (type1 != type2) 3368 return type1 < type2; 3369 gold_assert(flags1 != flags2 3370 || this->script_options_->saw_phdrs_clause()); 3371 return flags1 < flags2; 3372 } 3373 3374 // If the addresses are set already, sort by load address. 3375 if (seg1->are_addresses_set()) 3376 { 3377 if (!seg2->are_addresses_set()) 3378 return true; 3379 3380 unsigned int section_count1 = seg1->output_section_count(); 3381 unsigned int section_count2 = seg2->output_section_count(); 3382 if (section_count1 == 0 && section_count2 > 0) 3383 return true; 3384 if (section_count1 > 0 && section_count2 == 0) 3385 return false; 3386 3387 uint64_t paddr1 = (seg1->are_addresses_set() 3388 ? seg1->paddr() 3389 : seg1->first_section_load_address()); 3390 uint64_t paddr2 = (seg2->are_addresses_set() 3391 ? seg2->paddr() 3392 : seg2->first_section_load_address()); 3393 3394 if (paddr1 != paddr2) 3395 return paddr1 < paddr2; 3396 } 3397 else if (seg2->are_addresses_set()) 3398 return false; 3399 3400 // A segment which holds large data comes after a segment which does 3401 // not hold large data. 3402 if (seg1->is_large_data_segment()) 3403 { 3404 if (!seg2->is_large_data_segment()) 3405 return false; 3406 } 3407 else if (seg2->is_large_data_segment()) 3408 return true; 3409 3410 // Otherwise, we sort PT_LOAD segments based on the flags. Readonly 3411 // segments come before writable segments. Then writable segments 3412 // with data come before writable segments without data. Then 3413 // executable segments come before non-executable segments. Then 3414 // the unlikely case of a non-readable segment comes before the 3415 // normal case of a readable segment. If there are multiple 3416 // segments with the same type and flags, we require that the 3417 // address be set, and we sort by virtual address and then physical 3418 // address. 3419 if ((flags1 & elfcpp::PF_W) != (flags2 & elfcpp::PF_W)) 3420 return (flags1 & elfcpp::PF_W) == 0; 3421 if ((flags1 & elfcpp::PF_W) != 0 3422 && seg1->has_any_data_sections() != seg2->has_any_data_sections()) 3423 return seg1->has_any_data_sections(); 3424 if ((flags1 & elfcpp::PF_X) != (flags2 & elfcpp::PF_X)) 3425 return (flags1 & elfcpp::PF_X) != 0; 3426 if ((flags1 & elfcpp::PF_R) != (flags2 & elfcpp::PF_R)) 3427 return (flags1 & elfcpp::PF_R) == 0; 3428 3429 // We shouldn't get here--we shouldn't create segments which we 3430 // can't distinguish. Unless of course we are using a weird linker 3431 // script or overlapping --section-start options. We could also get 3432 // here if plugins want unique segments for subsets of sections. 3433 gold_assert(this->script_options_->saw_phdrs_clause() 3434 || parameters->options().any_section_start() 3435 || this->is_unique_segment_for_sections_specified()); 3436 return false; 3437} 3438 3439// Increase OFF so that it is congruent to ADDR modulo ABI_PAGESIZE. 3440 3441static off_t 3442align_file_offset(off_t off, uint64_t addr, uint64_t abi_pagesize) 3443{ 3444 uint64_t unsigned_off = off; 3445 uint64_t aligned_off = ((unsigned_off & ~(abi_pagesize - 1)) 3446 | (addr & (abi_pagesize - 1))); 3447 if (aligned_off < unsigned_off) 3448 aligned_off += abi_pagesize; 3449 return aligned_off; 3450} 3451 3452// On targets where the text segment contains only executable code, 3453// a non-executable segment is never the text segment. 3454 3455static inline bool 3456is_text_segment(const Target* target, const Output_segment* seg) 3457{ 3458 elfcpp::Elf_Xword flags = seg->flags(); 3459 if ((flags & elfcpp::PF_W) != 0) 3460 return false; 3461 if ((flags & elfcpp::PF_X) == 0) 3462 return !target->isolate_execinstr(); 3463 return true; 3464} 3465 3466// Set the file offsets of all the segments, and all the sections they 3467// contain. They have all been created. LOAD_SEG must be be laid out 3468// first. Return the offset of the data to follow. 3469 3470off_t 3471Layout::set_segment_offsets(const Target* target, Output_segment* load_seg, 3472 unsigned int* pshndx) 3473{ 3474 // Sort them into the final order. We use a stable sort so that we 3475 // don't randomize the order of indistinguishable segments created 3476 // by linker scripts. 3477 std::stable_sort(this->segment_list_.begin(), this->segment_list_.end(), 3478 Layout::Compare_segments(this)); 3479 3480 // Find the PT_LOAD segments, and set their addresses and offsets 3481 // and their section's addresses and offsets. 3482 uint64_t start_addr; 3483 if (parameters->options().user_set_Ttext()) 3484 start_addr = parameters->options().Ttext(); 3485 else if (parameters->options().output_is_position_independent()) 3486 start_addr = 0; 3487 else 3488 start_addr = target->default_text_segment_address(); 3489 3490 uint64_t addr = start_addr; 3491 off_t off = 0; 3492 3493 // If LOAD_SEG is NULL, then the file header and segment headers 3494 // will not be loadable. But they still need to be at offset 0 in 3495 // the file. Set their offsets now. 3496 if (load_seg == NULL) 3497 { 3498 for (Data_list::iterator p = this->special_output_list_.begin(); 3499 p != this->special_output_list_.end(); 3500 ++p) 3501 { 3502 off = align_address(off, (*p)->addralign()); 3503 (*p)->set_address_and_file_offset(0, off); 3504 off += (*p)->data_size(); 3505 } 3506 } 3507 3508 unsigned int increase_relro = this->increase_relro_; 3509 if (this->script_options_->saw_sections_clause()) 3510 increase_relro = 0; 3511 3512 const bool check_sections = parameters->options().check_sections(); 3513 Output_segment* last_load_segment = NULL; 3514 3515 unsigned int shndx_begin = *pshndx; 3516 unsigned int shndx_load_seg = *pshndx; 3517 3518 for (Segment_list::iterator p = this->segment_list_.begin(); 3519 p != this->segment_list_.end(); 3520 ++p) 3521 { 3522 if ((*p)->type() == elfcpp::PT_LOAD) 3523 { 3524 if (target->isolate_execinstr()) 3525 { 3526 // When we hit the segment that should contain the 3527 // file headers, reset the file offset so we place 3528 // it and subsequent segments appropriately. 3529 // We'll fix up the preceding segments below. 3530 if (load_seg == *p) 3531 { 3532 if (off == 0) 3533 load_seg = NULL; 3534 else 3535 { 3536 off = 0; 3537 shndx_load_seg = *pshndx; 3538 } 3539 } 3540 } 3541 else 3542 { 3543 // Verify that the file headers fall into the first segment. 3544 if (load_seg != NULL && load_seg != *p) 3545 gold_unreachable(); 3546 load_seg = NULL; 3547 } 3548 3549 bool are_addresses_set = (*p)->are_addresses_set(); 3550 if (are_addresses_set) 3551 { 3552 // When it comes to setting file offsets, we care about 3553 // the physical address. 3554 addr = (*p)->paddr(); 3555 } 3556 else if (parameters->options().user_set_Ttext() 3557 && (parameters->options().omagic() 3558 || is_text_segment(target, *p))) 3559 { 3560 are_addresses_set = true; 3561 } 3562 else if (parameters->options().user_set_Trodata_segment() 3563 && ((*p)->flags() & (elfcpp::PF_W | elfcpp::PF_X)) == 0) 3564 { 3565 addr = parameters->options().Trodata_segment(); 3566 are_addresses_set = true; 3567 } 3568 else if (parameters->options().user_set_Tdata() 3569 && ((*p)->flags() & elfcpp::PF_W) != 0 3570 && (!parameters->options().user_set_Tbss() 3571 || (*p)->has_any_data_sections())) 3572 { 3573 addr = parameters->options().Tdata(); 3574 are_addresses_set = true; 3575 } 3576 else if (parameters->options().user_set_Tbss() 3577 && ((*p)->flags() & elfcpp::PF_W) != 0 3578 && !(*p)->has_any_data_sections()) 3579 { 3580 addr = parameters->options().Tbss(); 3581 are_addresses_set = true; 3582 } 3583 3584 uint64_t orig_addr = addr; 3585 uint64_t orig_off = off; 3586 3587 uint64_t aligned_addr = 0; 3588 uint64_t abi_pagesize = target->abi_pagesize(); 3589 uint64_t common_pagesize = target->common_pagesize(); 3590 3591 if (!parameters->options().nmagic() 3592 && !parameters->options().omagic()) 3593 (*p)->set_minimum_p_align(abi_pagesize); 3594 3595 if (!are_addresses_set) 3596 { 3597 // Skip the address forward one page, maintaining the same 3598 // position within the page. This lets us store both segments 3599 // overlapping on a single page in the file, but the loader will 3600 // put them on different pages in memory. We will revisit this 3601 // decision once we know the size of the segment. 3602 3603 uint64_t max_align = (*p)->maximum_alignment(); 3604 if (max_align > abi_pagesize) 3605 addr = align_address(addr, max_align); 3606 aligned_addr = addr; 3607 3608 if (load_seg == *p) 3609 { 3610 // This is the segment that will contain the file 3611 // headers, so its offset will have to be exactly zero. 3612 gold_assert(orig_off == 0); 3613 3614 // If the target wants a fixed minimum distance from the 3615 // text segment to the read-only segment, move up now. 3616 uint64_t min_addr = 3617 start_addr + (parameters->options().user_set_rosegment_gap() 3618 ? parameters->options().rosegment_gap() 3619 : target->rosegment_gap()); 3620 if (addr < min_addr) 3621 addr = min_addr; 3622 3623 // But this is not the first segment! To make its 3624 // address congruent with its offset, that address better 3625 // be aligned to the ABI-mandated page size. 3626 addr = align_address(addr, abi_pagesize); 3627 aligned_addr = addr; 3628 } 3629 else 3630 { 3631 if ((addr & (abi_pagesize - 1)) != 0) 3632 addr = addr + abi_pagesize; 3633 3634 off = orig_off + ((addr - orig_addr) & (abi_pagesize - 1)); 3635 } 3636 } 3637 3638 if (!parameters->options().nmagic() 3639 && !parameters->options().omagic()) 3640 { 3641 // Here we are also taking care of the case when 3642 // the maximum segment alignment is larger than the page size. 3643 off = align_file_offset(off, addr, 3644 std::max(abi_pagesize, 3645 (*p)->maximum_alignment())); 3646 } 3647 else 3648 { 3649 // This is -N or -n with a section script which prevents 3650 // us from using a load segment. We need to ensure that 3651 // the file offset is aligned to the alignment of the 3652 // segment. This is because the linker script 3653 // implicitly assumed a zero offset. If we don't align 3654 // here, then the alignment of the sections in the 3655 // linker script may not match the alignment of the 3656 // sections in the set_section_addresses call below, 3657 // causing an error about dot moving backward. 3658 off = align_address(off, (*p)->maximum_alignment()); 3659 } 3660 3661 unsigned int shndx_hold = *pshndx; 3662 bool has_relro = false; 3663 uint64_t new_addr = (*p)->set_section_addresses(target, this, 3664 false, addr, 3665 &increase_relro, 3666 &has_relro, 3667 &off, pshndx); 3668 3669 // Now that we know the size of this segment, we may be able 3670 // to save a page in memory, at the cost of wasting some 3671 // file space, by instead aligning to the start of a new 3672 // page. Here we use the real machine page size rather than 3673 // the ABI mandated page size. If the segment has been 3674 // aligned so that the relro data ends at a page boundary, 3675 // we do not try to realign it. 3676 3677 if (!are_addresses_set 3678 && !has_relro 3679 && aligned_addr != addr 3680 && !parameters->incremental()) 3681 { 3682 uint64_t first_off = (common_pagesize 3683 - (aligned_addr 3684 & (common_pagesize - 1))); 3685 uint64_t last_off = new_addr & (common_pagesize - 1); 3686 if (first_off > 0 3687 && last_off > 0 3688 && ((aligned_addr & ~ (common_pagesize - 1)) 3689 != (new_addr & ~ (common_pagesize - 1))) 3690 && first_off + last_off <= common_pagesize) 3691 { 3692 *pshndx = shndx_hold; 3693 addr = align_address(aligned_addr, common_pagesize); 3694 addr = align_address(addr, (*p)->maximum_alignment()); 3695 if ((addr & (abi_pagesize - 1)) != 0) 3696 addr = addr + abi_pagesize; 3697 off = orig_off + ((addr - orig_addr) & (abi_pagesize - 1)); 3698 off = align_file_offset(off, addr, abi_pagesize); 3699 3700 increase_relro = this->increase_relro_; 3701 if (this->script_options_->saw_sections_clause()) 3702 increase_relro = 0; 3703 has_relro = false; 3704 3705 new_addr = (*p)->set_section_addresses(target, this, 3706 true, addr, 3707 &increase_relro, 3708 &has_relro, 3709 &off, pshndx); 3710 } 3711 } 3712 3713 addr = new_addr; 3714 3715 // Implement --check-sections. We know that the segments 3716 // are sorted by LMA. 3717 if (check_sections && last_load_segment != NULL) 3718 { 3719 gold_assert(last_load_segment->paddr() <= (*p)->paddr()); 3720 if (last_load_segment->paddr() + last_load_segment->memsz() 3721 > (*p)->paddr()) 3722 { 3723 unsigned long long lb1 = last_load_segment->paddr(); 3724 unsigned long long le1 = lb1 + last_load_segment->memsz(); 3725 unsigned long long lb2 = (*p)->paddr(); 3726 unsigned long long le2 = lb2 + (*p)->memsz(); 3727 gold_error(_("load segment overlap [0x%llx -> 0x%llx] and " 3728 "[0x%llx -> 0x%llx]"), 3729 lb1, le1, lb2, le2); 3730 } 3731 } 3732 last_load_segment = *p; 3733 } 3734 } 3735 3736 if (load_seg != NULL && target->isolate_execinstr()) 3737 { 3738 // Process the early segments again, setting their file offsets 3739 // so they land after the segments starting at LOAD_SEG. 3740 off = align_file_offset(off, 0, target->abi_pagesize()); 3741 3742 this->reset_relax_output(); 3743 3744 for (Segment_list::iterator p = this->segment_list_.begin(); 3745 *p != load_seg; 3746 ++p) 3747 { 3748 if ((*p)->type() == elfcpp::PT_LOAD) 3749 { 3750 // We repeat the whole job of assigning addresses and 3751 // offsets, but we really only want to change the offsets and 3752 // must ensure that the addresses all come out the same as 3753 // they did the first time through. 3754 bool has_relro = false; 3755 const uint64_t old_addr = (*p)->vaddr(); 3756 const uint64_t old_end = old_addr + (*p)->memsz(); 3757 uint64_t new_addr = (*p)->set_section_addresses(target, this, 3758 true, old_addr, 3759 &increase_relro, 3760 &has_relro, 3761 &off, 3762 &shndx_begin); 3763 gold_assert(new_addr == old_end); 3764 } 3765 } 3766 3767 gold_assert(shndx_begin == shndx_load_seg); 3768 } 3769 3770 // Handle the non-PT_LOAD segments, setting their offsets from their 3771 // section's offsets. 3772 for (Segment_list::iterator p = this->segment_list_.begin(); 3773 p != this->segment_list_.end(); 3774 ++p) 3775 { 3776 // PT_GNU_STACK was set up correctly when it was created. 3777 if ((*p)->type() != elfcpp::PT_LOAD 3778 && (*p)->type() != elfcpp::PT_GNU_STACK) 3779 (*p)->set_offset((*p)->type() == elfcpp::PT_GNU_RELRO 3780 ? increase_relro 3781 : 0); 3782 } 3783 3784 // Set the TLS offsets for each section in the PT_TLS segment. 3785 if (this->tls_segment_ != NULL) 3786 this->tls_segment_->set_tls_offsets(); 3787 3788 return off; 3789} 3790 3791// Set the offsets of all the allocated sections when doing a 3792// relocatable link. This does the same jobs as set_segment_offsets, 3793// only for a relocatable link. 3794 3795off_t 3796Layout::set_relocatable_section_offsets(Output_data* file_header, 3797 unsigned int* pshndx) 3798{ 3799 off_t off = 0; 3800 3801 file_header->set_address_and_file_offset(0, 0); 3802 off += file_header->data_size(); 3803 3804 for (Section_list::iterator p = this->section_list_.begin(); 3805 p != this->section_list_.end(); 3806 ++p) 3807 { 3808 // We skip unallocated sections here, except that group sections 3809 // have to come first. 3810 if (((*p)->flags() & elfcpp::SHF_ALLOC) == 0 3811 && (*p)->type() != elfcpp::SHT_GROUP) 3812 continue; 3813 3814 off = align_address(off, (*p)->addralign()); 3815 3816 // The linker script might have set the address. 3817 if (!(*p)->is_address_valid()) 3818 (*p)->set_address(0); 3819 (*p)->set_file_offset(off); 3820 (*p)->finalize_data_size(); 3821 if ((*p)->type() != elfcpp::SHT_NOBITS) 3822 off += (*p)->data_size(); 3823 3824 (*p)->set_out_shndx(*pshndx); 3825 ++*pshndx; 3826 } 3827 3828 return off; 3829} 3830 3831// Set the file offset of all the sections not associated with a 3832// segment. 3833 3834off_t 3835Layout::set_section_offsets(off_t off, Layout::Section_offset_pass pass) 3836{ 3837 off_t startoff = off; 3838 off_t maxoff = off; 3839 3840 for (Section_list::iterator p = this->unattached_section_list_.begin(); 3841 p != this->unattached_section_list_.end(); 3842 ++p) 3843 { 3844 // The symtab section is handled in create_symtab_sections. 3845 if (*p == this->symtab_section_) 3846 continue; 3847 3848 // If we've already set the data size, don't set it again. 3849 if ((*p)->is_offset_valid() && (*p)->is_data_size_valid()) 3850 continue; 3851 3852 if (pass == BEFORE_INPUT_SECTIONS_PASS 3853 && (*p)->requires_postprocessing()) 3854 { 3855 (*p)->create_postprocessing_buffer(); 3856 this->any_postprocessing_sections_ = true; 3857 } 3858 3859 if (pass == BEFORE_INPUT_SECTIONS_PASS 3860 && (*p)->after_input_sections()) 3861 continue; 3862 else if (pass == POSTPROCESSING_SECTIONS_PASS 3863 && (!(*p)->after_input_sections() 3864 || (*p)->type() == elfcpp::SHT_STRTAB)) 3865 continue; 3866 else if (pass == STRTAB_AFTER_POSTPROCESSING_SECTIONS_PASS 3867 && (!(*p)->after_input_sections() 3868 || (*p)->type() != elfcpp::SHT_STRTAB)) 3869 continue; 3870 3871 if (!parameters->incremental_update()) 3872 { 3873 off = align_address(off, (*p)->addralign()); 3874 (*p)->set_file_offset(off); 3875 (*p)->finalize_data_size(); 3876 } 3877 else 3878 { 3879 // Incremental update: allocate file space from free list. 3880 (*p)->pre_finalize_data_size(); 3881 off_t current_size = (*p)->current_data_size(); 3882 off = this->allocate(current_size, (*p)->addralign(), startoff); 3883 if (off == -1) 3884 { 3885 if (is_debugging_enabled(DEBUG_INCREMENTAL)) 3886 this->free_list_.dump(); 3887 gold_assert((*p)->output_section() != NULL); 3888 gold_fallback(_("out of patch space for section %s; " 3889 "relink with --incremental-full"), 3890 (*p)->output_section()->name()); 3891 } 3892 (*p)->set_file_offset(off); 3893 (*p)->finalize_data_size(); 3894 if ((*p)->data_size() > current_size) 3895 { 3896 gold_assert((*p)->output_section() != NULL); 3897 gold_fallback(_("%s: section changed size; " 3898 "relink with --incremental-full"), 3899 (*p)->output_section()->name()); 3900 } 3901 gold_debug(DEBUG_INCREMENTAL, 3902 "set_section_offsets: %08lx %08lx %s", 3903 static_cast<long>(off), 3904 static_cast<long>((*p)->data_size()), 3905 ((*p)->output_section() != NULL 3906 ? (*p)->output_section()->name() : "(special)")); 3907 } 3908 3909 off += (*p)->data_size(); 3910 if (off > maxoff) 3911 maxoff = off; 3912 3913 // At this point the name must be set. 3914 if (pass != STRTAB_AFTER_POSTPROCESSING_SECTIONS_PASS) 3915 this->namepool_.add((*p)->name(), false, NULL); 3916 } 3917 return maxoff; 3918} 3919 3920// Set the section indexes of all the sections not associated with a 3921// segment. 3922 3923unsigned int 3924Layout::set_section_indexes(unsigned int shndx) 3925{ 3926 for (Section_list::iterator p = this->unattached_section_list_.begin(); 3927 p != this->unattached_section_list_.end(); 3928 ++p) 3929 { 3930 if (!(*p)->has_out_shndx()) 3931 { 3932 (*p)->set_out_shndx(shndx); 3933 ++shndx; 3934 } 3935 } 3936 return shndx; 3937} 3938 3939// Set the section addresses according to the linker script. This is 3940// only called when we see a SECTIONS clause. This returns the 3941// program segment which should hold the file header and segment 3942// headers, if any. It will return NULL if they should not be in a 3943// segment. 3944 3945Output_segment* 3946Layout::set_section_addresses_from_script(Symbol_table* symtab) 3947{ 3948 Script_sections* ss = this->script_options_->script_sections(); 3949 gold_assert(ss->saw_sections_clause()); 3950 return this->script_options_->set_section_addresses(symtab, this); 3951} 3952 3953// Place the orphan sections in the linker script. 3954 3955void 3956Layout::place_orphan_sections_in_script() 3957{ 3958 Script_sections* ss = this->script_options_->script_sections(); 3959 gold_assert(ss->saw_sections_clause()); 3960 3961 // Place each orphaned output section in the script. 3962 for (Section_list::iterator p = this->section_list_.begin(); 3963 p != this->section_list_.end(); 3964 ++p) 3965 { 3966 if (!(*p)->found_in_sections_clause()) 3967 ss->place_orphan(*p); 3968 } 3969} 3970 3971// Count the local symbols in the regular symbol table and the dynamic 3972// symbol table, and build the respective string pools. 3973 3974void 3975Layout::count_local_symbols(const Task* task, 3976 const Input_objects* input_objects) 3977{ 3978 // First, figure out an upper bound on the number of symbols we'll 3979 // be inserting into each pool. This helps us create the pools with 3980 // the right size, to avoid unnecessary hashtable resizing. 3981 unsigned int symbol_count = 0; 3982 for (Input_objects::Relobj_iterator p = input_objects->relobj_begin(); 3983 p != input_objects->relobj_end(); 3984 ++p) 3985 symbol_count += (*p)->local_symbol_count(); 3986 3987 // Go from "upper bound" to "estimate." We overcount for two 3988 // reasons: we double-count symbols that occur in more than one 3989 // object file, and we count symbols that are dropped from the 3990 // output. Add it all together and assume we overcount by 100%. 3991 symbol_count /= 2; 3992 3993 // We assume all symbols will go into both the sympool and dynpool. 3994 this->sympool_.reserve(symbol_count); 3995 this->dynpool_.reserve(symbol_count); 3996 3997 for (Input_objects::Relobj_iterator p = input_objects->relobj_begin(); 3998 p != input_objects->relobj_end(); 3999 ++p) 4000 { 4001 Task_lock_obj<Object> tlo(task, *p); 4002 (*p)->count_local_symbols(&this->sympool_, &this->dynpool_); 4003 } 4004} 4005 4006// Create the symbol table sections. Here we also set the final 4007// values of the symbols. At this point all the loadable sections are 4008// fully laid out. SHNUM is the number of sections so far. 4009 4010void 4011Layout::create_symtab_sections(const Input_objects* input_objects, 4012 Symbol_table* symtab, 4013 unsigned int shnum, 4014 off_t* poff, 4015 unsigned int local_dynamic_count) 4016{ 4017 int symsize; 4018 unsigned int align; 4019 if (parameters->target().get_size() == 32) 4020 { 4021 symsize = elfcpp::Elf_sizes<32>::sym_size; 4022 align = 4; 4023 } 4024 else if (parameters->target().get_size() == 64) 4025 { 4026 symsize = elfcpp::Elf_sizes<64>::sym_size; 4027 align = 8; 4028 } 4029 else 4030 gold_unreachable(); 4031 4032 // Compute file offsets relative to the start of the symtab section. 4033 off_t off = 0; 4034 4035 // Save space for the dummy symbol at the start of the section. We 4036 // never bother to write this out--it will just be left as zero. 4037 off += symsize; 4038 unsigned int local_symbol_index = 1; 4039 4040 // Add STT_SECTION symbols for each Output section which needs one. 4041 for (Section_list::iterator p = this->section_list_.begin(); 4042 p != this->section_list_.end(); 4043 ++p) 4044 { 4045 if (!(*p)->needs_symtab_index()) 4046 (*p)->set_symtab_index(-1U); 4047 else 4048 { 4049 (*p)->set_symtab_index(local_symbol_index); 4050 ++local_symbol_index; 4051 off += symsize; 4052 } 4053 } 4054 4055 for (Input_objects::Relobj_iterator p = input_objects->relobj_begin(); 4056 p != input_objects->relobj_end(); 4057 ++p) 4058 { 4059 unsigned int index = (*p)->finalize_local_symbols(local_symbol_index, 4060 off, symtab); 4061 off += (index - local_symbol_index) * symsize; 4062 local_symbol_index = index; 4063 } 4064 4065 unsigned int local_symcount = local_symbol_index; 4066 gold_assert(static_cast<off_t>(local_symcount * symsize) == off); 4067 4068 off_t dynoff; 4069 size_t dyncount; 4070 if (this->dynsym_section_ == NULL) 4071 { 4072 dynoff = 0; 4073 dyncount = 0; 4074 } 4075 else 4076 { 4077 off_t locsize = local_dynamic_count * this->dynsym_section_->entsize(); 4078 dynoff = this->dynsym_section_->offset() + locsize; 4079 dyncount = (this->dynsym_section_->data_size() - locsize) / symsize; 4080 gold_assert(static_cast<off_t>(dyncount * symsize) 4081 == this->dynsym_section_->data_size() - locsize); 4082 } 4083 4084 off_t global_off = off; 4085 off = symtab->finalize(off, dynoff, local_dynamic_count, dyncount, 4086 &this->sympool_, &local_symcount); 4087 4088 if (!parameters->options().strip_all()) 4089 { 4090 this->sympool_.set_string_offsets(); 4091 4092 const char* symtab_name = this->namepool_.add(".symtab", false, NULL); 4093 Output_section* osymtab = this->make_output_section(symtab_name, 4094 elfcpp::SHT_SYMTAB, 4095 0, ORDER_INVALID, 4096 false); 4097 this->symtab_section_ = osymtab; 4098 4099 Output_section_data* pos = new Output_data_fixed_space(off, align, 4100 "** symtab"); 4101 osymtab->add_output_section_data(pos); 4102 4103 // We generate a .symtab_shndx section if we have more than 4104 // SHN_LORESERVE sections. Technically it is possible that we 4105 // don't need one, because it is possible that there are no 4106 // symbols in any of sections with indexes larger than 4107 // SHN_LORESERVE. That is probably unusual, though, and it is 4108 // easier to always create one than to compute section indexes 4109 // twice (once here, once when writing out the symbols). 4110 if (shnum >= elfcpp::SHN_LORESERVE) 4111 { 4112 const char* symtab_xindex_name = this->namepool_.add(".symtab_shndx", 4113 false, NULL); 4114 Output_section* osymtab_xindex = 4115 this->make_output_section(symtab_xindex_name, 4116 elfcpp::SHT_SYMTAB_SHNDX, 0, 4117 ORDER_INVALID, false); 4118 4119 size_t symcount = off / symsize; 4120 this->symtab_xindex_ = new Output_symtab_xindex(symcount); 4121 4122 osymtab_xindex->add_output_section_data(this->symtab_xindex_); 4123 4124 osymtab_xindex->set_link_section(osymtab); 4125 osymtab_xindex->set_addralign(4); 4126 osymtab_xindex->set_entsize(4); 4127 4128 osymtab_xindex->set_after_input_sections(); 4129 4130 // This tells the driver code to wait until the symbol table 4131 // has written out before writing out the postprocessing 4132 // sections, including the .symtab_shndx section. 4133 this->any_postprocessing_sections_ = true; 4134 } 4135 4136 const char* strtab_name = this->namepool_.add(".strtab", false, NULL); 4137 Output_section* ostrtab = this->make_output_section(strtab_name, 4138 elfcpp::SHT_STRTAB, 4139 0, ORDER_INVALID, 4140 false); 4141 4142 Output_section_data* pstr = new Output_data_strtab(&this->sympool_); 4143 ostrtab->add_output_section_data(pstr); 4144 4145 off_t symtab_off; 4146 if (!parameters->incremental_update()) 4147 symtab_off = align_address(*poff, align); 4148 else 4149 { 4150 symtab_off = this->allocate(off, align, *poff); 4151 if (off == -1) 4152 gold_fallback(_("out of patch space for symbol table; " 4153 "relink with --incremental-full")); 4154 gold_debug(DEBUG_INCREMENTAL, 4155 "create_symtab_sections: %08lx %08lx .symtab", 4156 static_cast<long>(symtab_off), 4157 static_cast<long>(off)); 4158 } 4159 4160 symtab->set_file_offset(symtab_off + global_off); 4161 osymtab->set_file_offset(symtab_off); 4162 osymtab->finalize_data_size(); 4163 osymtab->set_link_section(ostrtab); 4164 osymtab->set_info(local_symcount); 4165 osymtab->set_entsize(symsize); 4166 4167 if (symtab_off + off > *poff) 4168 *poff = symtab_off + off; 4169 } 4170} 4171 4172// Create the .shstrtab section, which holds the names of the 4173// sections. At the time this is called, we have created all the 4174// output sections except .shstrtab itself. 4175 4176Output_section* 4177Layout::create_shstrtab() 4178{ 4179 // FIXME: We don't need to create a .shstrtab section if we are 4180 // stripping everything. 4181 4182 const char* name = this->namepool_.add(".shstrtab", false, NULL); 4183 4184 Output_section* os = this->make_output_section(name, elfcpp::SHT_STRTAB, 0, 4185 ORDER_INVALID, false); 4186 4187 if (strcmp(parameters->options().compress_debug_sections(), "none") != 0) 4188 { 4189 // We can't write out this section until we've set all the 4190 // section names, and we don't set the names of compressed 4191 // output sections until relocations are complete. FIXME: With 4192 // the current names we use, this is unnecessary. 4193 os->set_after_input_sections(); 4194 } 4195 4196 Output_section_data* posd = new Output_data_strtab(&this->namepool_); 4197 os->add_output_section_data(posd); 4198 4199 return os; 4200} 4201 4202// Create the section headers. SIZE is 32 or 64. OFF is the file 4203// offset. 4204 4205void 4206Layout::create_shdrs(const Output_section* shstrtab_section, off_t* poff) 4207{ 4208 Output_section_headers* oshdrs; 4209 oshdrs = new Output_section_headers(this, 4210 &this->segment_list_, 4211 &this->section_list_, 4212 &this->unattached_section_list_, 4213 &this->namepool_, 4214 shstrtab_section); 4215 off_t off; 4216 if (!parameters->incremental_update()) 4217 off = align_address(*poff, oshdrs->addralign()); 4218 else 4219 { 4220 oshdrs->pre_finalize_data_size(); 4221 off = this->allocate(oshdrs->data_size(), oshdrs->addralign(), *poff); 4222 if (off == -1) 4223 gold_fallback(_("out of patch space for section header table; " 4224 "relink with --incremental-full")); 4225 gold_debug(DEBUG_INCREMENTAL, 4226 "create_shdrs: %08lx %08lx (section header table)", 4227 static_cast<long>(off), 4228 static_cast<long>(off + oshdrs->data_size())); 4229 } 4230 oshdrs->set_address_and_file_offset(0, off); 4231 off += oshdrs->data_size(); 4232 if (off > *poff) 4233 *poff = off; 4234 this->section_headers_ = oshdrs; 4235} 4236 4237// Count the allocated sections. 4238 4239size_t 4240Layout::allocated_output_section_count() const 4241{ 4242 size_t section_count = 0; 4243 for (Segment_list::const_iterator p = this->segment_list_.begin(); 4244 p != this->segment_list_.end(); 4245 ++p) 4246 section_count += (*p)->output_section_count(); 4247 return section_count; 4248} 4249 4250// Create the dynamic symbol table. 4251// *PLOCAL_DYNAMIC_COUNT will be set to the number of local symbols 4252// from input objects, and *PFORCED_LOCAL_DYNAMIC_COUNT will be set 4253// to the number of global symbols that have been forced local. 4254// We need to remember the former because the forced-local symbols are 4255// written along with the global symbols in Symtab::write_globals(). 4256 4257void 4258Layout::create_dynamic_symtab(const Input_objects* input_objects, 4259 Symbol_table* symtab, 4260 Output_section** pdynstr, 4261 unsigned int* plocal_dynamic_count, 4262 unsigned int* pforced_local_dynamic_count, 4263 std::vector<Symbol*>* pdynamic_symbols, 4264 Versions* pversions) 4265{ 4266 // Count all the symbols in the dynamic symbol table, and set the 4267 // dynamic symbol indexes. 4268 4269 // Skip symbol 0, which is always all zeroes. 4270 unsigned int index = 1; 4271 4272 // Add STT_SECTION symbols for each Output section which needs one. 4273 for (Section_list::iterator p = this->section_list_.begin(); 4274 p != this->section_list_.end(); 4275 ++p) 4276 { 4277 if (!(*p)->needs_dynsym_index()) 4278 (*p)->set_dynsym_index(-1U); 4279 else 4280 { 4281 (*p)->set_dynsym_index(index); 4282 ++index; 4283 } 4284 } 4285 4286 // Count the local symbols that need to go in the dynamic symbol table, 4287 // and set the dynamic symbol indexes. 4288 for (Input_objects::Relobj_iterator p = input_objects->relobj_begin(); 4289 p != input_objects->relobj_end(); 4290 ++p) 4291 { 4292 unsigned int new_index = (*p)->set_local_dynsym_indexes(index); 4293 index = new_index; 4294 } 4295 4296 unsigned int local_symcount = index; 4297 unsigned int forced_local_count = 0; 4298 4299 index = symtab->set_dynsym_indexes(index, &forced_local_count, 4300 pdynamic_symbols, &this->dynpool_, 4301 pversions); 4302 4303 *plocal_dynamic_count = local_symcount; 4304 *pforced_local_dynamic_count = forced_local_count; 4305 4306 int symsize; 4307 unsigned int align; 4308 const int size = parameters->target().get_size(); 4309 if (size == 32) 4310 { 4311 symsize = elfcpp::Elf_sizes<32>::sym_size; 4312 align = 4; 4313 } 4314 else if (size == 64) 4315 { 4316 symsize = elfcpp::Elf_sizes<64>::sym_size; 4317 align = 8; 4318 } 4319 else 4320 gold_unreachable(); 4321 4322 // Create the dynamic symbol table section. 4323 4324 Output_section* dynsym = this->choose_output_section(NULL, ".dynsym", 4325 elfcpp::SHT_DYNSYM, 4326 elfcpp::SHF_ALLOC, 4327 false, 4328 ORDER_DYNAMIC_LINKER, 4329 false, false, false); 4330 4331 // Check for NULL as a linker script may discard .dynsym. 4332 if (dynsym != NULL) 4333 { 4334 Output_section_data* odata = new Output_data_fixed_space(index * symsize, 4335 align, 4336 "** dynsym"); 4337 dynsym->add_output_section_data(odata); 4338 4339 dynsym->set_info(local_symcount + forced_local_count); 4340 dynsym->set_entsize(symsize); 4341 dynsym->set_addralign(align); 4342 4343 this->dynsym_section_ = dynsym; 4344 } 4345 4346 Output_data_dynamic* const odyn = this->dynamic_data_; 4347 if (odyn != NULL) 4348 { 4349 odyn->add_section_address(elfcpp::DT_SYMTAB, dynsym); 4350 odyn->add_constant(elfcpp::DT_SYMENT, symsize); 4351 } 4352 4353 // If there are more than SHN_LORESERVE allocated sections, we 4354 // create a .dynsym_shndx section. It is possible that we don't 4355 // need one, because it is possible that there are no dynamic 4356 // symbols in any of the sections with indexes larger than 4357 // SHN_LORESERVE. This is probably unusual, though, and at this 4358 // time we don't know the actual section indexes so it is 4359 // inconvenient to check. 4360 if (this->allocated_output_section_count() >= elfcpp::SHN_LORESERVE) 4361 { 4362 Output_section* dynsym_xindex = 4363 this->choose_output_section(NULL, ".dynsym_shndx", 4364 elfcpp::SHT_SYMTAB_SHNDX, 4365 elfcpp::SHF_ALLOC, 4366 false, ORDER_DYNAMIC_LINKER, false, false, 4367 false); 4368 4369 if (dynsym_xindex != NULL) 4370 { 4371 this->dynsym_xindex_ = new Output_symtab_xindex(index); 4372 4373 dynsym_xindex->add_output_section_data(this->dynsym_xindex_); 4374 4375 dynsym_xindex->set_link_section(dynsym); 4376 dynsym_xindex->set_addralign(4); 4377 dynsym_xindex->set_entsize(4); 4378 4379 dynsym_xindex->set_after_input_sections(); 4380 4381 // This tells the driver code to wait until the symbol table 4382 // has written out before writing out the postprocessing 4383 // sections, including the .dynsym_shndx section. 4384 this->any_postprocessing_sections_ = true; 4385 } 4386 } 4387 4388 // Create the dynamic string table section. 4389 4390 Output_section* dynstr = this->choose_output_section(NULL, ".dynstr", 4391 elfcpp::SHT_STRTAB, 4392 elfcpp::SHF_ALLOC, 4393 false, 4394 ORDER_DYNAMIC_LINKER, 4395 false, false, false); 4396 *pdynstr = dynstr; 4397 if (dynstr != NULL) 4398 { 4399 Output_section_data* strdata = new Output_data_strtab(&this->dynpool_); 4400 dynstr->add_output_section_data(strdata); 4401 4402 if (dynsym != NULL) 4403 dynsym->set_link_section(dynstr); 4404 if (this->dynamic_section_ != NULL) 4405 this->dynamic_section_->set_link_section(dynstr); 4406 4407 if (odyn != NULL) 4408 { 4409 odyn->add_section_address(elfcpp::DT_STRTAB, dynstr); 4410 odyn->add_section_size(elfcpp::DT_STRSZ, dynstr); 4411 } 4412 } 4413 4414 // Create the hash tables. The Gnu-style hash table must be 4415 // built first, because it changes the order of the symbols 4416 // in the dynamic symbol table. 4417 4418 if (strcmp(parameters->options().hash_style(), "gnu") == 0 4419 || strcmp(parameters->options().hash_style(), "both") == 0) 4420 { 4421 unsigned char* phash; 4422 unsigned int hashlen; 4423 Dynobj::create_gnu_hash_table(*pdynamic_symbols, 4424 local_symcount + forced_local_count, 4425 &phash, &hashlen); 4426 4427 Output_section* hashsec = 4428 this->choose_output_section(NULL, ".gnu.hash", elfcpp::SHT_GNU_HASH, 4429 elfcpp::SHF_ALLOC, false, 4430 ORDER_DYNAMIC_LINKER, false, false, 4431 false); 4432 4433 Output_section_data* hashdata = new Output_data_const_buffer(phash, 4434 hashlen, 4435 align, 4436 "** hash"); 4437 if (hashsec != NULL && hashdata != NULL) 4438 hashsec->add_output_section_data(hashdata); 4439 4440 if (hashsec != NULL) 4441 { 4442 if (dynsym != NULL) 4443 hashsec->set_link_section(dynsym); 4444 4445 // For a 64-bit target, the entries in .gnu.hash do not have 4446 // a uniform size, so we only set the entry size for a 4447 // 32-bit target. 4448 if (parameters->target().get_size() == 32) 4449 hashsec->set_entsize(4); 4450 4451 if (odyn != NULL) 4452 odyn->add_section_address(elfcpp::DT_GNU_HASH, hashsec); 4453 } 4454 } 4455 4456 if (strcmp(parameters->options().hash_style(), "sysv") == 0 4457 || strcmp(parameters->options().hash_style(), "both") == 0) 4458 { 4459 unsigned char* phash; 4460 unsigned int hashlen; 4461 Dynobj::create_elf_hash_table(*pdynamic_symbols, 4462 local_symcount + forced_local_count, 4463 &phash, &hashlen); 4464 4465 Output_section* hashsec = 4466 this->choose_output_section(NULL, ".hash", elfcpp::SHT_HASH, 4467 elfcpp::SHF_ALLOC, false, 4468 ORDER_DYNAMIC_LINKER, false, false, 4469 false); 4470 4471 Output_section_data* hashdata = new Output_data_const_buffer(phash, 4472 hashlen, 4473 align, 4474 "** hash"); 4475 if (hashsec != NULL && hashdata != NULL) 4476 hashsec->add_output_section_data(hashdata); 4477 4478 if (hashsec != NULL) 4479 { 4480 if (dynsym != NULL) 4481 hashsec->set_link_section(dynsym); 4482 hashsec->set_entsize(parameters->target().hash_entry_size() / 8); 4483 } 4484 4485 if (odyn != NULL) 4486 odyn->add_section_address(elfcpp::DT_HASH, hashsec); 4487 } 4488} 4489 4490// Assign offsets to each local portion of the dynamic symbol table. 4491 4492void 4493Layout::assign_local_dynsym_offsets(const Input_objects* input_objects) 4494{ 4495 Output_section* dynsym = this->dynsym_section_; 4496 if (dynsym == NULL) 4497 return; 4498 4499 off_t off = dynsym->offset(); 4500 4501 // Skip the dummy symbol at the start of the section. 4502 off += dynsym->entsize(); 4503 4504 for (Input_objects::Relobj_iterator p = input_objects->relobj_begin(); 4505 p != input_objects->relobj_end(); 4506 ++p) 4507 { 4508 unsigned int count = (*p)->set_local_dynsym_offset(off); 4509 off += count * dynsym->entsize(); 4510 } 4511} 4512 4513// Create the version sections. 4514 4515void 4516Layout::create_version_sections(const Versions* versions, 4517 const Symbol_table* symtab, 4518 unsigned int local_symcount, 4519 const std::vector<Symbol*>& dynamic_symbols, 4520 const Output_section* dynstr) 4521{ 4522 if (!versions->any_defs() && !versions->any_needs()) 4523 return; 4524 4525 switch (parameters->size_and_endianness()) 4526 { 4527#ifdef HAVE_TARGET_32_LITTLE 4528 case Parameters::TARGET_32_LITTLE: 4529 this->sized_create_version_sections<32, false>(versions, symtab, 4530 local_symcount, 4531 dynamic_symbols, dynstr); 4532 break; 4533#endif 4534#ifdef HAVE_TARGET_32_BIG 4535 case Parameters::TARGET_32_BIG: 4536 this->sized_create_version_sections<32, true>(versions, symtab, 4537 local_symcount, 4538 dynamic_symbols, dynstr); 4539 break; 4540#endif 4541#ifdef HAVE_TARGET_64_LITTLE 4542 case Parameters::TARGET_64_LITTLE: 4543 this->sized_create_version_sections<64, false>(versions, symtab, 4544 local_symcount, 4545 dynamic_symbols, dynstr); 4546 break; 4547#endif 4548#ifdef HAVE_TARGET_64_BIG 4549 case Parameters::TARGET_64_BIG: 4550 this->sized_create_version_sections<64, true>(versions, symtab, 4551 local_symcount, 4552 dynamic_symbols, dynstr); 4553 break; 4554#endif 4555 default: 4556 gold_unreachable(); 4557 } 4558} 4559 4560// Create the version sections, sized version. 4561 4562template<int size, bool big_endian> 4563void 4564Layout::sized_create_version_sections( 4565 const Versions* versions, 4566 const Symbol_table* symtab, 4567 unsigned int local_symcount, 4568 const std::vector<Symbol*>& dynamic_symbols, 4569 const Output_section* dynstr) 4570{ 4571 Output_section* vsec = this->choose_output_section(NULL, ".gnu.version", 4572 elfcpp::SHT_GNU_versym, 4573 elfcpp::SHF_ALLOC, 4574 false, 4575 ORDER_DYNAMIC_LINKER, 4576 false, false, false); 4577 4578 // Check for NULL since a linker script may discard this section. 4579 if (vsec != NULL) 4580 { 4581 unsigned char* vbuf; 4582 unsigned int vsize; 4583 versions->symbol_section_contents<size, big_endian>(symtab, 4584 &this->dynpool_, 4585 local_symcount, 4586 dynamic_symbols, 4587 &vbuf, &vsize); 4588 4589 Output_section_data* vdata = new Output_data_const_buffer(vbuf, vsize, 2, 4590 "** versions"); 4591 4592 vsec->add_output_section_data(vdata); 4593 vsec->set_entsize(2); 4594 vsec->set_link_section(this->dynsym_section_); 4595 } 4596 4597 Output_data_dynamic* const odyn = this->dynamic_data_; 4598 if (odyn != NULL && vsec != NULL) 4599 odyn->add_section_address(elfcpp::DT_VERSYM, vsec); 4600 4601 if (versions->any_defs()) 4602 { 4603 Output_section* vdsec; 4604 vdsec = this->choose_output_section(NULL, ".gnu.version_d", 4605 elfcpp::SHT_GNU_verdef, 4606 elfcpp::SHF_ALLOC, 4607 false, ORDER_DYNAMIC_LINKER, false, 4608 false, false); 4609 4610 if (vdsec != NULL) 4611 { 4612 unsigned char* vdbuf; 4613 unsigned int vdsize; 4614 unsigned int vdentries; 4615 versions->def_section_contents<size, big_endian>(&this->dynpool_, 4616 &vdbuf, &vdsize, 4617 &vdentries); 4618 4619 Output_section_data* vddata = 4620 new Output_data_const_buffer(vdbuf, vdsize, 4, "** version defs"); 4621 4622 vdsec->add_output_section_data(vddata); 4623 vdsec->set_link_section(dynstr); 4624 vdsec->set_info(vdentries); 4625 4626 if (odyn != NULL) 4627 { 4628 odyn->add_section_address(elfcpp::DT_VERDEF, vdsec); 4629 odyn->add_constant(elfcpp::DT_VERDEFNUM, vdentries); 4630 } 4631 } 4632 } 4633 4634 if (versions->any_needs()) 4635 { 4636 Output_section* vnsec; 4637 vnsec = this->choose_output_section(NULL, ".gnu.version_r", 4638 elfcpp::SHT_GNU_verneed, 4639 elfcpp::SHF_ALLOC, 4640 false, ORDER_DYNAMIC_LINKER, false, 4641 false, false); 4642 4643 if (vnsec != NULL) 4644 { 4645 unsigned char* vnbuf; 4646 unsigned int vnsize; 4647 unsigned int vnentries; 4648 versions->need_section_contents<size, big_endian>(&this->dynpool_, 4649 &vnbuf, &vnsize, 4650 &vnentries); 4651 4652 Output_section_data* vndata = 4653 new Output_data_const_buffer(vnbuf, vnsize, 4, "** version refs"); 4654 4655 vnsec->add_output_section_data(vndata); 4656 vnsec->set_link_section(dynstr); 4657 vnsec->set_info(vnentries); 4658 4659 if (odyn != NULL) 4660 { 4661 odyn->add_section_address(elfcpp::DT_VERNEED, vnsec); 4662 odyn->add_constant(elfcpp::DT_VERNEEDNUM, vnentries); 4663 } 4664 } 4665 } 4666} 4667 4668// Create the .interp section and PT_INTERP segment. 4669 4670void 4671Layout::create_interp(const Target* target) 4672{ 4673 gold_assert(this->interp_segment_ == NULL); 4674 4675 const char* interp = parameters->options().dynamic_linker(); 4676 if (interp == NULL) 4677 { 4678 interp = target->dynamic_linker(); 4679 gold_assert(interp != NULL); 4680 } 4681 4682 size_t len = strlen(interp) + 1; 4683 4684 Output_section_data* odata = new Output_data_const(interp, len, 1); 4685 4686 Output_section* osec = this->choose_output_section(NULL, ".interp", 4687 elfcpp::SHT_PROGBITS, 4688 elfcpp::SHF_ALLOC, 4689 false, ORDER_INTERP, 4690 false, false, false); 4691 if (osec != NULL) 4692 osec->add_output_section_data(odata); 4693} 4694 4695// Add dynamic tags for the PLT and the dynamic relocs. This is 4696// called by the target-specific code. This does nothing if not doing 4697// a dynamic link. 4698 4699// USE_REL is true for REL relocs rather than RELA relocs. 4700 4701// If PLT_GOT is not NULL, then DT_PLTGOT points to it. 4702 4703// If PLT_REL is not NULL, it is used for DT_PLTRELSZ, and DT_JMPREL, 4704// and we also set DT_PLTREL. We use PLT_REL's output section, since 4705// some targets have multiple reloc sections in PLT_REL. 4706 4707// If DYN_REL is not NULL, it is used for DT_REL/DT_RELA, 4708// DT_RELSZ/DT_RELASZ, DT_RELENT/DT_RELAENT. Again we use the output 4709// section. 4710 4711// If ADD_DEBUG is true, we add a DT_DEBUG entry when generating an 4712// executable. 4713 4714void 4715Layout::add_target_dynamic_tags(bool use_rel, const Output_data* plt_got, 4716 const Output_data* plt_rel, 4717 const Output_data_reloc_generic* dyn_rel, 4718 bool add_debug, bool dynrel_includes_plt) 4719{ 4720 Output_data_dynamic* odyn = this->dynamic_data_; 4721 if (odyn == NULL) 4722 return; 4723 4724 if (plt_got != NULL && plt_got->output_section() != NULL) 4725 odyn->add_section_address(elfcpp::DT_PLTGOT, plt_got); 4726 4727 if (plt_rel != NULL && plt_rel->output_section() != NULL) 4728 { 4729 odyn->add_section_size(elfcpp::DT_PLTRELSZ, plt_rel->output_section()); 4730 odyn->add_section_address(elfcpp::DT_JMPREL, plt_rel->output_section()); 4731 odyn->add_constant(elfcpp::DT_PLTREL, 4732 use_rel ? elfcpp::DT_REL : elfcpp::DT_RELA); 4733 } 4734 4735 if ((dyn_rel != NULL && dyn_rel->output_section() != NULL) 4736 || (dynrel_includes_plt 4737 && plt_rel != NULL 4738 && plt_rel->output_section() != NULL)) 4739 { 4740 bool have_dyn_rel = dyn_rel != NULL && dyn_rel->output_section() != NULL; 4741 bool have_plt_rel = plt_rel != NULL && plt_rel->output_section() != NULL; 4742 odyn->add_section_address(use_rel ? elfcpp::DT_REL : elfcpp::DT_RELA, 4743 (have_dyn_rel 4744 ? dyn_rel->output_section() 4745 : plt_rel->output_section())); 4746 elfcpp::DT size_tag = use_rel ? elfcpp::DT_RELSZ : elfcpp::DT_RELASZ; 4747 if (have_dyn_rel && have_plt_rel && dynrel_includes_plt) 4748 odyn->add_section_size(size_tag, 4749 dyn_rel->output_section(), 4750 plt_rel->output_section()); 4751 else if (have_dyn_rel) 4752 odyn->add_section_size(size_tag, dyn_rel->output_section()); 4753 else 4754 odyn->add_section_size(size_tag, plt_rel->output_section()); 4755 const int size = parameters->target().get_size(); 4756 elfcpp::DT rel_tag; 4757 int rel_size; 4758 if (use_rel) 4759 { 4760 rel_tag = elfcpp::DT_RELENT; 4761 if (size == 32) 4762 rel_size = Reloc_types<elfcpp::SHT_REL, 32, false>::reloc_size; 4763 else if (size == 64) 4764 rel_size = Reloc_types<elfcpp::SHT_REL, 64, false>::reloc_size; 4765 else 4766 gold_unreachable(); 4767 } 4768 else 4769 { 4770 rel_tag = elfcpp::DT_RELAENT; 4771 if (size == 32) 4772 rel_size = Reloc_types<elfcpp::SHT_RELA, 32, false>::reloc_size; 4773 else if (size == 64) 4774 rel_size = Reloc_types<elfcpp::SHT_RELA, 64, false>::reloc_size; 4775 else 4776 gold_unreachable(); 4777 } 4778 odyn->add_constant(rel_tag, rel_size); 4779 4780 if (parameters->options().combreloc() && have_dyn_rel) 4781 { 4782 size_t c = dyn_rel->relative_reloc_count(); 4783 if (c > 0) 4784 odyn->add_constant((use_rel 4785 ? elfcpp::DT_RELCOUNT 4786 : elfcpp::DT_RELACOUNT), 4787 c); 4788 } 4789 } 4790 4791 if (add_debug && !parameters->options().shared()) 4792 { 4793 // The value of the DT_DEBUG tag is filled in by the dynamic 4794 // linker at run time, and used by the debugger. 4795 odyn->add_constant(elfcpp::DT_DEBUG, 0); 4796 } 4797} 4798 4799void 4800Layout::add_target_specific_dynamic_tag(elfcpp::DT tag, unsigned int val) 4801{ 4802 Output_data_dynamic* odyn = this->dynamic_data_; 4803 if (odyn == NULL) 4804 return; 4805 odyn->add_constant(tag, val); 4806} 4807 4808// Finish the .dynamic section and PT_DYNAMIC segment. 4809 4810void 4811Layout::finish_dynamic_section(const Input_objects* input_objects, 4812 const Symbol_table* symtab) 4813{ 4814 if (!this->script_options_->saw_phdrs_clause() 4815 && this->dynamic_section_ != NULL) 4816 { 4817 Output_segment* oseg = this->make_output_segment(elfcpp::PT_DYNAMIC, 4818 (elfcpp::PF_R 4819 | elfcpp::PF_W)); 4820 oseg->add_output_section_to_nonload(this->dynamic_section_, 4821 elfcpp::PF_R | elfcpp::PF_W); 4822 } 4823 4824 Output_data_dynamic* const odyn = this->dynamic_data_; 4825 if (odyn == NULL) 4826 return; 4827 4828 for (Input_objects::Dynobj_iterator p = input_objects->dynobj_begin(); 4829 p != input_objects->dynobj_end(); 4830 ++p) 4831 { 4832 if (!(*p)->is_needed() && (*p)->as_needed()) 4833 { 4834 // This dynamic object was linked with --as-needed, but it 4835 // is not needed. 4836 continue; 4837 } 4838 4839 odyn->add_string(elfcpp::DT_NEEDED, (*p)->soname()); 4840 } 4841 4842 if (parameters->options().shared()) 4843 { 4844 const char* soname = parameters->options().soname(); 4845 if (soname != NULL) 4846 odyn->add_string(elfcpp::DT_SONAME, soname); 4847 } 4848 4849 Symbol* sym = symtab->lookup(parameters->options().init()); 4850 if (sym != NULL && sym->is_defined() && !sym->is_from_dynobj()) 4851 odyn->add_symbol(elfcpp::DT_INIT, sym); 4852 4853 sym = symtab->lookup(parameters->options().fini()); 4854 if (sym != NULL && sym->is_defined() && !sym->is_from_dynobj()) 4855 odyn->add_symbol(elfcpp::DT_FINI, sym); 4856 4857 // Look for .init_array, .preinit_array and .fini_array by checking 4858 // section types. 4859 for(Layout::Section_list::const_iterator p = this->section_list_.begin(); 4860 p != this->section_list_.end(); 4861 ++p) 4862 switch((*p)->type()) 4863 { 4864 case elfcpp::SHT_FINI_ARRAY: 4865 odyn->add_section_address(elfcpp::DT_FINI_ARRAY, *p); 4866 odyn->add_section_size(elfcpp::DT_FINI_ARRAYSZ, *p); 4867 break; 4868 case elfcpp::SHT_INIT_ARRAY: 4869 odyn->add_section_address(elfcpp::DT_INIT_ARRAY, *p); 4870 odyn->add_section_size(elfcpp::DT_INIT_ARRAYSZ, *p); 4871 break; 4872 case elfcpp::SHT_PREINIT_ARRAY: 4873 odyn->add_section_address(elfcpp::DT_PREINIT_ARRAY, *p); 4874 odyn->add_section_size(elfcpp::DT_PREINIT_ARRAYSZ, *p); 4875 break; 4876 default: 4877 break; 4878 } 4879 4880 // Add a DT_RPATH entry if needed. 4881 const General_options::Dir_list& rpath(parameters->options().rpath()); 4882 if (!rpath.empty()) 4883 { 4884 std::string rpath_val; 4885 for (General_options::Dir_list::const_iterator p = rpath.begin(); 4886 p != rpath.end(); 4887 ++p) 4888 { 4889 if (rpath_val.empty()) 4890 rpath_val = p->name(); 4891 else 4892 { 4893 // Eliminate duplicates. 4894 General_options::Dir_list::const_iterator q; 4895 for (q = rpath.begin(); q != p; ++q) 4896 if (q->name() == p->name()) 4897 break; 4898 if (q == p) 4899 { 4900 rpath_val += ':'; 4901 rpath_val += p->name(); 4902 } 4903 } 4904 } 4905 4906 if (!parameters->options().enable_new_dtags()) 4907 odyn->add_string(elfcpp::DT_RPATH, rpath_val); 4908 else 4909 odyn->add_string(elfcpp::DT_RUNPATH, rpath_val); 4910 } 4911 4912 // Look for text segments that have dynamic relocations. 4913 bool have_textrel = false; 4914 if (!this->script_options_->saw_sections_clause()) 4915 { 4916 for (Segment_list::const_iterator p = this->segment_list_.begin(); 4917 p != this->segment_list_.end(); 4918 ++p) 4919 { 4920 if ((*p)->type() == elfcpp::PT_LOAD 4921 && ((*p)->flags() & elfcpp::PF_W) == 0 4922 && (*p)->has_dynamic_reloc()) 4923 { 4924 have_textrel = true; 4925 break; 4926 } 4927 } 4928 } 4929 else 4930 { 4931 // We don't know the section -> segment mapping, so we are 4932 // conservative and just look for readonly sections with 4933 // relocations. If those sections wind up in writable segments, 4934 // then we have created an unnecessary DT_TEXTREL entry. 4935 for (Section_list::const_iterator p = this->section_list_.begin(); 4936 p != this->section_list_.end(); 4937 ++p) 4938 { 4939 if (((*p)->flags() & elfcpp::SHF_ALLOC) != 0 4940 && ((*p)->flags() & elfcpp::SHF_WRITE) == 0 4941 && (*p)->has_dynamic_reloc()) 4942 { 4943 have_textrel = true; 4944 break; 4945 } 4946 } 4947 } 4948 4949 if (parameters->options().filter() != NULL) 4950 odyn->add_string(elfcpp::DT_FILTER, parameters->options().filter()); 4951 if (parameters->options().any_auxiliary()) 4952 { 4953 for (options::String_set::const_iterator p = 4954 parameters->options().auxiliary_begin(); 4955 p != parameters->options().auxiliary_end(); 4956 ++p) 4957 odyn->add_string(elfcpp::DT_AUXILIARY, *p); 4958 } 4959 4960 // Add a DT_FLAGS entry if necessary. 4961 unsigned int flags = 0; 4962 if (have_textrel) 4963 { 4964 // Add a DT_TEXTREL for compatibility with older loaders. 4965 odyn->add_constant(elfcpp::DT_TEXTREL, 0); 4966 flags |= elfcpp::DF_TEXTREL; 4967 4968 if (parameters->options().text()) 4969 gold_error(_("read-only segment has dynamic relocations")); 4970 else if (parameters->options().warn_shared_textrel() 4971 && parameters->options().shared()) 4972 gold_warning(_("shared library text segment is not shareable")); 4973 } 4974 if (parameters->options().shared() && this->has_static_tls()) 4975 flags |= elfcpp::DF_STATIC_TLS; 4976 if (parameters->options().origin()) 4977 flags |= elfcpp::DF_ORIGIN; 4978 if (parameters->options().Bsymbolic() 4979 && !parameters->options().have_dynamic_list()) 4980 { 4981 flags |= elfcpp::DF_SYMBOLIC; 4982 // Add DT_SYMBOLIC for compatibility with older loaders. 4983 odyn->add_constant(elfcpp::DT_SYMBOLIC, 0); 4984 } 4985 if (parameters->options().now()) 4986 flags |= elfcpp::DF_BIND_NOW; 4987 if (flags != 0) 4988 odyn->add_constant(elfcpp::DT_FLAGS, flags); 4989 4990 flags = 0; 4991 if (parameters->options().global()) 4992 flags |= elfcpp::DF_1_GLOBAL; 4993 if (parameters->options().initfirst()) 4994 flags |= elfcpp::DF_1_INITFIRST; 4995 if (parameters->options().interpose()) 4996 flags |= elfcpp::DF_1_INTERPOSE; 4997 if (parameters->options().loadfltr()) 4998 flags |= elfcpp::DF_1_LOADFLTR; 4999 if (parameters->options().nodefaultlib()) 5000 flags |= elfcpp::DF_1_NODEFLIB; 5001 if (parameters->options().nodelete()) 5002 flags |= elfcpp::DF_1_NODELETE; 5003 if (parameters->options().nodlopen()) 5004 flags |= elfcpp::DF_1_NOOPEN; 5005 if (parameters->options().nodump()) 5006 flags |= elfcpp::DF_1_NODUMP; 5007 if (!parameters->options().shared()) 5008 flags &= ~(elfcpp::DF_1_INITFIRST 5009 | elfcpp::DF_1_NODELETE 5010 | elfcpp::DF_1_NOOPEN); 5011 if (parameters->options().origin()) 5012 flags |= elfcpp::DF_1_ORIGIN; 5013 if (parameters->options().now()) 5014 flags |= elfcpp::DF_1_NOW; 5015 if (parameters->options().Bgroup()) 5016 flags |= elfcpp::DF_1_GROUP; 5017 if (flags != 0) 5018 odyn->add_constant(elfcpp::DT_FLAGS_1, flags); 5019} 5020 5021// Set the size of the _DYNAMIC symbol table to be the size of the 5022// dynamic data. 5023 5024void 5025Layout::set_dynamic_symbol_size(const Symbol_table* symtab) 5026{ 5027 Output_data_dynamic* const odyn = this->dynamic_data_; 5028 if (odyn == NULL) 5029 return; 5030 odyn->finalize_data_size(); 5031 if (this->dynamic_symbol_ == NULL) 5032 return; 5033 off_t data_size = odyn->data_size(); 5034 const int size = parameters->target().get_size(); 5035 if (size == 32) 5036 symtab->get_sized_symbol<32>(this->dynamic_symbol_)->set_symsize(data_size); 5037 else if (size == 64) 5038 symtab->get_sized_symbol<64>(this->dynamic_symbol_)->set_symsize(data_size); 5039 else 5040 gold_unreachable(); 5041} 5042 5043// The mapping of input section name prefixes to output section names. 5044// In some cases one prefix is itself a prefix of another prefix; in 5045// such a case the longer prefix must come first. These prefixes are 5046// based on the GNU linker default ELF linker script. 5047 5048#define MAPPING_INIT(f, t) { f, sizeof(f) - 1, t, sizeof(t) - 1 } 5049#define MAPPING_INIT_EXACT(f, t) { f, 0, t, sizeof(t) - 1 } 5050const Layout::Section_name_mapping Layout::section_name_mapping[] = 5051{ 5052 MAPPING_INIT(".text.", ".text"), 5053 MAPPING_INIT(".rodata.", ".rodata"), 5054 MAPPING_INIT(".data.rel.ro.local.", ".data.rel.ro.local"), 5055 MAPPING_INIT_EXACT(".data.rel.ro.local", ".data.rel.ro.local"), 5056 MAPPING_INIT(".data.rel.ro.", ".data.rel.ro"), 5057 MAPPING_INIT_EXACT(".data.rel.ro", ".data.rel.ro"), 5058 MAPPING_INIT(".data.", ".data"), 5059 MAPPING_INIT(".bss.", ".bss"), 5060 MAPPING_INIT(".tdata.", ".tdata"), 5061 MAPPING_INIT(".tbss.", ".tbss"), 5062 MAPPING_INIT(".init_array.", ".init_array"), 5063 MAPPING_INIT(".fini_array.", ".fini_array"), 5064 MAPPING_INIT(".sdata.", ".sdata"), 5065 MAPPING_INIT(".sbss.", ".sbss"), 5066 // FIXME: In the GNU linker, .sbss2 and .sdata2 are handled 5067 // differently depending on whether it is creating a shared library. 5068 MAPPING_INIT(".sdata2.", ".sdata"), 5069 MAPPING_INIT(".sbss2.", ".sbss"), 5070 MAPPING_INIT(".lrodata.", ".lrodata"), 5071 MAPPING_INIT(".ldata.", ".ldata"), 5072 MAPPING_INIT(".lbss.", ".lbss"), 5073 MAPPING_INIT(".gcc_except_table.", ".gcc_except_table"), 5074 MAPPING_INIT(".gnu.linkonce.d.rel.ro.local.", ".data.rel.ro.local"), 5075 MAPPING_INIT(".gnu.linkonce.d.rel.ro.", ".data.rel.ro"), 5076 MAPPING_INIT(".gnu.linkonce.t.", ".text"), 5077 MAPPING_INIT(".gnu.linkonce.r.", ".rodata"), 5078 MAPPING_INIT(".gnu.linkonce.d.", ".data"), 5079 MAPPING_INIT(".gnu.linkonce.b.", ".bss"), 5080 MAPPING_INIT(".gnu.linkonce.s.", ".sdata"), 5081 MAPPING_INIT(".gnu.linkonce.sb.", ".sbss"), 5082 MAPPING_INIT(".gnu.linkonce.s2.", ".sdata"), 5083 MAPPING_INIT(".gnu.linkonce.sb2.", ".sbss"), 5084 MAPPING_INIT(".gnu.linkonce.wi.", ".debug_info"), 5085 MAPPING_INIT(".gnu.linkonce.td.", ".tdata"), 5086 MAPPING_INIT(".gnu.linkonce.tb.", ".tbss"), 5087 MAPPING_INIT(".gnu.linkonce.lr.", ".lrodata"), 5088 MAPPING_INIT(".gnu.linkonce.l.", ".ldata"), 5089 MAPPING_INIT(".gnu.linkonce.lb.", ".lbss"), 5090 MAPPING_INIT(".ARM.extab", ".ARM.extab"), 5091 MAPPING_INIT(".gnu.linkonce.armextab.", ".ARM.extab"), 5092 MAPPING_INIT(".ARM.exidx", ".ARM.exidx"), 5093 MAPPING_INIT(".gnu.linkonce.armexidx.", ".ARM.exidx"), 5094}; 5095#undef MAPPING_INIT 5096#undef MAPPING_INIT_EXACT 5097 5098const int Layout::section_name_mapping_count = 5099 (sizeof(Layout::section_name_mapping) 5100 / sizeof(Layout::section_name_mapping[0])); 5101 5102// Choose the output section name to use given an input section name. 5103// Set *PLEN to the length of the name. *PLEN is initialized to the 5104// length of NAME. 5105 5106const char* 5107Layout::output_section_name(const Relobj* relobj, const char* name, 5108 size_t* plen) 5109{ 5110 // gcc 4.3 generates the following sorts of section names when it 5111 // needs a section name specific to a function: 5112 // .text.FN 5113 // .rodata.FN 5114 // .sdata2.FN 5115 // .data.FN 5116 // .data.rel.FN 5117 // .data.rel.local.FN 5118 // .data.rel.ro.FN 5119 // .data.rel.ro.local.FN 5120 // .sdata.FN 5121 // .bss.FN 5122 // .sbss.FN 5123 // .tdata.FN 5124 // .tbss.FN 5125 5126 // The GNU linker maps all of those to the part before the .FN, 5127 // except that .data.rel.local.FN is mapped to .data, and 5128 // .data.rel.ro.local.FN is mapped to .data.rel.ro. The sections 5129 // beginning with .data.rel.ro.local are grouped together. 5130 5131 // For an anonymous namespace, the string FN can contain a '.'. 5132 5133 // Also of interest: .rodata.strN.N, .rodata.cstN, both of which the 5134 // GNU linker maps to .rodata. 5135 5136 // The .data.rel.ro sections are used with -z relro. The sections 5137 // are recognized by name. We use the same names that the GNU 5138 // linker does for these sections. 5139 5140 // It is hard to handle this in a principled way, so we don't even 5141 // try. We use a table of mappings. If the input section name is 5142 // not found in the table, we simply use it as the output section 5143 // name. 5144 5145 const Section_name_mapping* psnm = section_name_mapping; 5146 for (int i = 0; i < section_name_mapping_count; ++i, ++psnm) 5147 { 5148 if (psnm->fromlen > 0) 5149 { 5150 if (strncmp(name, psnm->from, psnm->fromlen) == 0) 5151 { 5152 *plen = psnm->tolen; 5153 return psnm->to; 5154 } 5155 } 5156 else 5157 { 5158 if (strcmp(name, psnm->from) == 0) 5159 { 5160 *plen = psnm->tolen; 5161 return psnm->to; 5162 } 5163 } 5164 } 5165 5166 // As an additional complication, .ctors sections are output in 5167 // either .ctors or .init_array sections, and .dtors sections are 5168 // output in either .dtors or .fini_array sections. 5169 if (is_prefix_of(".ctors.", name) || is_prefix_of(".dtors.", name)) 5170 { 5171 if (parameters->options().ctors_in_init_array()) 5172 { 5173 *plen = 11; 5174 return name[1] == 'c' ? ".init_array" : ".fini_array"; 5175 } 5176 else 5177 { 5178 *plen = 6; 5179 return name[1] == 'c' ? ".ctors" : ".dtors"; 5180 } 5181 } 5182 if (parameters->options().ctors_in_init_array() 5183 && (strcmp(name, ".ctors") == 0 || strcmp(name, ".dtors") == 0)) 5184 { 5185 // To make .init_array/.fini_array work with gcc we must exclude 5186 // .ctors and .dtors sections from the crtbegin and crtend 5187 // files. 5188 if (relobj == NULL 5189 || (!Layout::match_file_name(relobj, "crtbegin") 5190 && !Layout::match_file_name(relobj, "crtend"))) 5191 { 5192 *plen = 11; 5193 return name[1] == 'c' ? ".init_array" : ".fini_array"; 5194 } 5195 } 5196 5197 return name; 5198} 5199 5200// Return true if RELOBJ is an input file whose base name matches 5201// FILE_NAME. The base name must have an extension of ".o", and must 5202// be exactly FILE_NAME.o or FILE_NAME, one character, ".o". This is 5203// to match crtbegin.o as well as crtbeginS.o without getting confused 5204// by other possibilities. Overall matching the file name this way is 5205// a dreadful hack, but the GNU linker does it in order to better 5206// support gcc, and we need to be compatible. 5207 5208bool 5209Layout::match_file_name(const Relobj* relobj, const char* match) 5210{ 5211 const std::string& file_name(relobj->name()); 5212 const char* base_name = lbasename(file_name.c_str()); 5213 size_t match_len = strlen(match); 5214 if (strncmp(base_name, match, match_len) != 0) 5215 return false; 5216 size_t base_len = strlen(base_name); 5217 if (base_len != match_len + 2 && base_len != match_len + 3) 5218 return false; 5219 return memcmp(base_name + base_len - 2, ".o", 2) == 0; 5220} 5221 5222// Check if a comdat group or .gnu.linkonce section with the given 5223// NAME is selected for the link. If there is already a section, 5224// *KEPT_SECTION is set to point to the existing section and the 5225// function returns false. Otherwise, OBJECT, SHNDX, IS_COMDAT, and 5226// IS_GROUP_NAME are recorded for this NAME in the layout object, 5227// *KEPT_SECTION is set to the internal copy and the function returns 5228// true. 5229 5230bool 5231Layout::find_or_add_kept_section(const std::string& name, 5232 Relobj* object, 5233 unsigned int shndx, 5234 bool is_comdat, 5235 bool is_group_name, 5236 Kept_section** kept_section) 5237{ 5238 // It's normal to see a couple of entries here, for the x86 thunk 5239 // sections. If we see more than a few, we're linking a C++ 5240 // program, and we resize to get more space to minimize rehashing. 5241 if (this->signatures_.size() > 4 5242 && !this->resized_signatures_) 5243 { 5244 reserve_unordered_map(&this->signatures_, 5245 this->number_of_input_files_ * 64); 5246 this->resized_signatures_ = true; 5247 } 5248 5249 Kept_section candidate; 5250 std::pair<Signatures::iterator, bool> ins = 5251 this->signatures_.insert(std::make_pair(name, candidate)); 5252 5253 if (kept_section != NULL) 5254 *kept_section = &ins.first->second; 5255 if (ins.second) 5256 { 5257 // This is the first time we've seen this signature. 5258 ins.first->second.set_object(object); 5259 ins.first->second.set_shndx(shndx); 5260 if (is_comdat) 5261 ins.first->second.set_is_comdat(); 5262 if (is_group_name) 5263 ins.first->second.set_is_group_name(); 5264 return true; 5265 } 5266 5267 // We have already seen this signature. 5268 5269 if (ins.first->second.is_group_name()) 5270 { 5271 // We've already seen a real section group with this signature. 5272 // If the kept group is from a plugin object, and we're in the 5273 // replacement phase, accept the new one as a replacement. 5274 if (ins.first->second.object() == NULL 5275 && parameters->options().plugins()->in_replacement_phase()) 5276 { 5277 ins.first->second.set_object(object); 5278 ins.first->second.set_shndx(shndx); 5279 return true; 5280 } 5281 return false; 5282 } 5283 else if (is_group_name) 5284 { 5285 // This is a real section group, and we've already seen a 5286 // linkonce section with this signature. Record that we've seen 5287 // a section group, and don't include this section group. 5288 ins.first->second.set_is_group_name(); 5289 return false; 5290 } 5291 else 5292 { 5293 // We've already seen a linkonce section and this is a linkonce 5294 // section. These don't block each other--this may be the same 5295 // symbol name with different section types. 5296 return true; 5297 } 5298} 5299 5300// Store the allocated sections into the section list. 5301 5302void 5303Layout::get_allocated_sections(Section_list* section_list) const 5304{ 5305 for (Section_list::const_iterator p = this->section_list_.begin(); 5306 p != this->section_list_.end(); 5307 ++p) 5308 if (((*p)->flags() & elfcpp::SHF_ALLOC) != 0) 5309 section_list->push_back(*p); 5310} 5311 5312// Store the executable sections into the section list. 5313 5314void 5315Layout::get_executable_sections(Section_list* section_list) const 5316{ 5317 for (Section_list::const_iterator p = this->section_list_.begin(); 5318 p != this->section_list_.end(); 5319 ++p) 5320 if (((*p)->flags() & (elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR)) 5321 == (elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR)) 5322 section_list->push_back(*p); 5323} 5324 5325// Create an output segment. 5326 5327Output_segment* 5328Layout::make_output_segment(elfcpp::Elf_Word type, elfcpp::Elf_Word flags) 5329{ 5330 gold_assert(!parameters->options().relocatable()); 5331 Output_segment* oseg = new Output_segment(type, flags); 5332 this->segment_list_.push_back(oseg); 5333 5334 if (type == elfcpp::PT_TLS) 5335 this->tls_segment_ = oseg; 5336 else if (type == elfcpp::PT_GNU_RELRO) 5337 this->relro_segment_ = oseg; 5338 else if (type == elfcpp::PT_INTERP) 5339 this->interp_segment_ = oseg; 5340 5341 return oseg; 5342} 5343 5344// Return the file offset of the normal symbol table. 5345 5346off_t 5347Layout::symtab_section_offset() const 5348{ 5349 if (this->symtab_section_ != NULL) 5350 return this->symtab_section_->offset(); 5351 return 0; 5352} 5353 5354// Return the section index of the normal symbol table. It may have 5355// been stripped by the -s/--strip-all option. 5356 5357unsigned int 5358Layout::symtab_section_shndx() const 5359{ 5360 if (this->symtab_section_ != NULL) 5361 return this->symtab_section_->out_shndx(); 5362 return 0; 5363} 5364 5365// Write out the Output_sections. Most won't have anything to write, 5366// since most of the data will come from input sections which are 5367// handled elsewhere. But some Output_sections do have Output_data. 5368 5369void 5370Layout::write_output_sections(Output_file* of) const 5371{ 5372 for (Section_list::const_iterator p = this->section_list_.begin(); 5373 p != this->section_list_.end(); 5374 ++p) 5375 { 5376 if (!(*p)->after_input_sections()) 5377 (*p)->write(of); 5378 } 5379} 5380 5381// Write out data not associated with a section or the symbol table. 5382 5383void 5384Layout::write_data(const Symbol_table* symtab, Output_file* of) const 5385{ 5386 if (!parameters->options().strip_all()) 5387 { 5388 const Output_section* symtab_section = this->symtab_section_; 5389 for (Section_list::const_iterator p = this->section_list_.begin(); 5390 p != this->section_list_.end(); 5391 ++p) 5392 { 5393 if ((*p)->needs_symtab_index()) 5394 { 5395 gold_assert(symtab_section != NULL); 5396 unsigned int index = (*p)->symtab_index(); 5397 gold_assert(index > 0 && index != -1U); 5398 off_t off = (symtab_section->offset() 5399 + index * symtab_section->entsize()); 5400 symtab->write_section_symbol(*p, this->symtab_xindex_, of, off); 5401 } 5402 } 5403 } 5404 5405 const Output_section* dynsym_section = this->dynsym_section_; 5406 for (Section_list::const_iterator p = this->section_list_.begin(); 5407 p != this->section_list_.end(); 5408 ++p) 5409 { 5410 if ((*p)->needs_dynsym_index()) 5411 { 5412 gold_assert(dynsym_section != NULL); 5413 unsigned int index = (*p)->dynsym_index(); 5414 gold_assert(index > 0 && index != -1U); 5415 off_t off = (dynsym_section->offset() 5416 + index * dynsym_section->entsize()); 5417 symtab->write_section_symbol(*p, this->dynsym_xindex_, of, off); 5418 } 5419 } 5420 5421 // Write out the Output_data which are not in an Output_section. 5422 for (Data_list::const_iterator p = this->special_output_list_.begin(); 5423 p != this->special_output_list_.end(); 5424 ++p) 5425 (*p)->write(of); 5426 5427 // Write out the Output_data which are not in an Output_section 5428 // and are regenerated in each iteration of relaxation. 5429 for (Data_list::const_iterator p = this->relax_output_list_.begin(); 5430 p != this->relax_output_list_.end(); 5431 ++p) 5432 (*p)->write(of); 5433} 5434 5435// Write out the Output_sections which can only be written after the 5436// input sections are complete. 5437 5438void 5439Layout::write_sections_after_input_sections(Output_file* of) 5440{ 5441 // Determine the final section offsets, and thus the final output 5442 // file size. Note we finalize the .shstrab last, to allow the 5443 // after_input_section sections to modify their section-names before 5444 // writing. 5445 if (this->any_postprocessing_sections_) 5446 { 5447 off_t off = this->output_file_size_; 5448 off = this->set_section_offsets(off, POSTPROCESSING_SECTIONS_PASS); 5449 5450 // Now that we've finalized the names, we can finalize the shstrab. 5451 off = 5452 this->set_section_offsets(off, 5453 STRTAB_AFTER_POSTPROCESSING_SECTIONS_PASS); 5454 5455 if (off > this->output_file_size_) 5456 { 5457 of->resize(off); 5458 this->output_file_size_ = off; 5459 } 5460 } 5461 5462 for (Section_list::const_iterator p = this->section_list_.begin(); 5463 p != this->section_list_.end(); 5464 ++p) 5465 { 5466 if ((*p)->after_input_sections()) 5467 (*p)->write(of); 5468 } 5469 5470 this->section_headers_->write(of); 5471} 5472 5473// If a tree-style build ID was requested, the parallel part of that computation 5474// is already done, and the final hash-of-hashes is computed here. For other 5475// types of build IDs, all the work is done here. 5476 5477void 5478Layout::write_build_id(Output_file* of, unsigned char* array_of_hashes, 5479 size_t size_of_hashes) const 5480{ 5481 if (this->build_id_note_ == NULL) 5482 return; 5483 5484 unsigned char* ov = of->get_output_view(this->build_id_note_->offset(), 5485 this->build_id_note_->data_size()); 5486 5487 if (array_of_hashes == NULL) 5488 { 5489 const size_t output_file_size = this->output_file_size(); 5490 const unsigned char* iv = of->get_input_view(0, output_file_size); 5491 const char* style = parameters->options().build_id(); 5492 5493 // If we get here with style == "tree" then the output must be 5494 // too small for chunking, and we use SHA-1 in that case. 5495 if ((strcmp(style, "sha1") == 0) || (strcmp(style, "tree") == 0)) 5496 sha1_buffer(reinterpret_cast<const char*>(iv), output_file_size, ov); 5497 else if (strcmp(style, "md5") == 0) 5498 md5_buffer(reinterpret_cast<const char*>(iv), output_file_size, ov); 5499 else 5500 gold_unreachable(); 5501 5502 of->free_input_view(0, output_file_size, iv); 5503 } 5504 else 5505 { 5506 // Non-overlapping substrings of the output file have been hashed. 5507 // Compute SHA-1 hash of the hashes. 5508 sha1_buffer(reinterpret_cast<const char*>(array_of_hashes), 5509 size_of_hashes, ov); 5510 delete[] array_of_hashes; 5511 } 5512 5513 of->write_output_view(this->build_id_note_->offset(), 5514 this->build_id_note_->data_size(), 5515 ov); 5516} 5517 5518// Write out a binary file. This is called after the link is 5519// complete. IN is the temporary output file we used to generate the 5520// ELF code. We simply walk through the segments, read them from 5521// their file offset in IN, and write them to their load address in 5522// the output file. FIXME: with a bit more work, we could support 5523// S-records and/or Intel hex format here. 5524 5525void 5526Layout::write_binary(Output_file* in) const 5527{ 5528 gold_assert(parameters->options().oformat_enum() 5529 == General_options::OBJECT_FORMAT_BINARY); 5530 5531 // Get the size of the binary file. 5532 uint64_t max_load_address = 0; 5533 for (Segment_list::const_iterator p = this->segment_list_.begin(); 5534 p != this->segment_list_.end(); 5535 ++p) 5536 { 5537 if ((*p)->type() == elfcpp::PT_LOAD && (*p)->filesz() > 0) 5538 { 5539 uint64_t max_paddr = (*p)->paddr() + (*p)->filesz(); 5540 if (max_paddr > max_load_address) 5541 max_load_address = max_paddr; 5542 } 5543 } 5544 5545 Output_file out(parameters->options().output_file_name()); 5546 out.open(max_load_address); 5547 5548 for (Segment_list::const_iterator p = this->segment_list_.begin(); 5549 p != this->segment_list_.end(); 5550 ++p) 5551 { 5552 if ((*p)->type() == elfcpp::PT_LOAD && (*p)->filesz() > 0) 5553 { 5554 const unsigned char* vin = in->get_input_view((*p)->offset(), 5555 (*p)->filesz()); 5556 unsigned char* vout = out.get_output_view((*p)->paddr(), 5557 (*p)->filesz()); 5558 memcpy(vout, vin, (*p)->filesz()); 5559 out.write_output_view((*p)->paddr(), (*p)->filesz(), vout); 5560 in->free_input_view((*p)->offset(), (*p)->filesz(), vin); 5561 } 5562 } 5563 5564 out.close(); 5565} 5566 5567// Print the output sections to the map file. 5568 5569void 5570Layout::print_to_mapfile(Mapfile* mapfile) const 5571{ 5572 for (Segment_list::const_iterator p = this->segment_list_.begin(); 5573 p != this->segment_list_.end(); 5574 ++p) 5575 (*p)->print_sections_to_mapfile(mapfile); 5576 for (Section_list::const_iterator p = this->unattached_section_list_.begin(); 5577 p != this->unattached_section_list_.end(); 5578 ++p) 5579 (*p)->print_to_mapfile(mapfile); 5580} 5581 5582// Print statistical information to stderr. This is used for --stats. 5583 5584void 5585Layout::print_stats() const 5586{ 5587 this->namepool_.print_stats("section name pool"); 5588 this->sympool_.print_stats("output symbol name pool"); 5589 this->dynpool_.print_stats("dynamic name pool"); 5590 5591 for (Section_list::const_iterator p = this->section_list_.begin(); 5592 p != this->section_list_.end(); 5593 ++p) 5594 (*p)->print_merge_stats(); 5595} 5596 5597// Write_sections_task methods. 5598 5599// We can always run this task. 5600 5601Task_token* 5602Write_sections_task::is_runnable() 5603{ 5604 return NULL; 5605} 5606 5607// We need to unlock both OUTPUT_SECTIONS_BLOCKER and FINAL_BLOCKER 5608// when finished. 5609 5610void 5611Write_sections_task::locks(Task_locker* tl) 5612{ 5613 tl->add(this, this->output_sections_blocker_); 5614 if (this->input_sections_blocker_ != NULL) 5615 tl->add(this, this->input_sections_blocker_); 5616 tl->add(this, this->final_blocker_); 5617} 5618 5619// Run the task--write out the data. 5620 5621void 5622Write_sections_task::run(Workqueue*) 5623{ 5624 this->layout_->write_output_sections(this->of_); 5625} 5626 5627// Write_data_task methods. 5628 5629// We can always run this task. 5630 5631Task_token* 5632Write_data_task::is_runnable() 5633{ 5634 return NULL; 5635} 5636 5637// We need to unlock FINAL_BLOCKER when finished. 5638 5639void 5640Write_data_task::locks(Task_locker* tl) 5641{ 5642 tl->add(this, this->final_blocker_); 5643} 5644 5645// Run the task--write out the data. 5646 5647void 5648Write_data_task::run(Workqueue*) 5649{ 5650 this->layout_->write_data(this->symtab_, this->of_); 5651} 5652 5653// Write_symbols_task methods. 5654 5655// We can always run this task. 5656 5657Task_token* 5658Write_symbols_task::is_runnable() 5659{ 5660 return NULL; 5661} 5662 5663// We need to unlock FINAL_BLOCKER when finished. 5664 5665void 5666Write_symbols_task::locks(Task_locker* tl) 5667{ 5668 tl->add(this, this->final_blocker_); 5669} 5670 5671// Run the task--write out the symbols. 5672 5673void 5674Write_symbols_task::run(Workqueue*) 5675{ 5676 this->symtab_->write_globals(this->sympool_, this->dynpool_, 5677 this->layout_->symtab_xindex(), 5678 this->layout_->dynsym_xindex(), this->of_); 5679} 5680 5681// Write_after_input_sections_task methods. 5682 5683// We can only run this task after the input sections have completed. 5684 5685Task_token* 5686Write_after_input_sections_task::is_runnable() 5687{ 5688 if (this->input_sections_blocker_->is_blocked()) 5689 return this->input_sections_blocker_; 5690 return NULL; 5691} 5692 5693// We need to unlock FINAL_BLOCKER when finished. 5694 5695void 5696Write_after_input_sections_task::locks(Task_locker* tl) 5697{ 5698 tl->add(this, this->final_blocker_); 5699} 5700 5701// Run the task. 5702 5703void 5704Write_after_input_sections_task::run(Workqueue*) 5705{ 5706 this->layout_->write_sections_after_input_sections(this->of_); 5707} 5708 5709// Build IDs can be computed as a "flat" sha1 or md5 of a string of bytes, 5710// or as a "tree" where each chunk of the string is hashed and then those 5711// hashes are put into a (much smaller) string which is hashed with sha1. 5712// We compute a checksum over the entire file because that is simplest. 5713 5714void 5715Build_id_task_runner::run(Workqueue* workqueue, const Task*) 5716{ 5717 Task_token* post_hash_tasks_blocker = new Task_token(true); 5718 const Layout* layout = this->layout_; 5719 Output_file* of = this->of_; 5720 const size_t filesize = (layout->output_file_size() <= 0 ? 0 5721 : static_cast<size_t>(layout->output_file_size())); 5722 unsigned char* array_of_hashes = NULL; 5723 size_t size_of_hashes = 0; 5724 5725 if (strcmp(this->options_->build_id(), "tree") == 0 5726 && this->options_->build_id_chunk_size_for_treehash() > 0 5727 && filesize > 0 5728 && (filesize >= this->options_->build_id_min_file_size_for_treehash())) 5729 { 5730 static const size_t MD5_OUTPUT_SIZE_IN_BYTES = 16; 5731 const size_t chunk_size = 5732 this->options_->build_id_chunk_size_for_treehash(); 5733 const size_t num_hashes = ((filesize - 1) / chunk_size) + 1; 5734 post_hash_tasks_blocker->add_blockers(num_hashes); 5735 size_of_hashes = num_hashes * MD5_OUTPUT_SIZE_IN_BYTES; 5736 array_of_hashes = new unsigned char[size_of_hashes]; 5737 unsigned char *dst = array_of_hashes; 5738 for (size_t i = 0, src_offset = 0; i < num_hashes; 5739 i++, dst += MD5_OUTPUT_SIZE_IN_BYTES, src_offset += chunk_size) 5740 { 5741 size_t size = std::min(chunk_size, filesize - src_offset); 5742 workqueue->queue(new Hash_task(of, 5743 src_offset, 5744 size, 5745 dst, 5746 post_hash_tasks_blocker)); 5747 } 5748 } 5749 5750 // Queue the final task to write the build id and close the output file. 5751 workqueue->queue(new Task_function(new Close_task_runner(this->options_, 5752 layout, 5753 of, 5754 array_of_hashes, 5755 size_of_hashes), 5756 post_hash_tasks_blocker, 5757 "Task_function Close_task_runner")); 5758} 5759 5760// Close_task_runner methods. 5761 5762// Finish up the build ID computation, if necessary, and write a binary file, 5763// if necessary. Then close the output file. 5764 5765void 5766Close_task_runner::run(Workqueue*, const Task*) 5767{ 5768 // At this point the multi-threaded part of the build ID computation, 5769 // if any, is done. See Build_id_task_runner. 5770 this->layout_->write_build_id(this->of_, this->array_of_hashes_, 5771 this->size_of_hashes_); 5772 5773 // If we've been asked to create a binary file, we do so here. 5774 if (this->options_->oformat_enum() != General_options::OBJECT_FORMAT_ELF) 5775 this->layout_->write_binary(this->of_); 5776 5777 this->of_->close(); 5778} 5779 5780// Instantiate the templates we need. We could use the configure 5781// script to restrict this to only the ones for implemented targets. 5782 5783#ifdef HAVE_TARGET_32_LITTLE 5784template 5785Output_section* 5786Layout::init_fixed_output_section<32, false>( 5787 const char* name, 5788 elfcpp::Shdr<32, false>& shdr); 5789#endif 5790 5791#ifdef HAVE_TARGET_32_BIG 5792template 5793Output_section* 5794Layout::init_fixed_output_section<32, true>( 5795 const char* name, 5796 elfcpp::Shdr<32, true>& shdr); 5797#endif 5798 5799#ifdef HAVE_TARGET_64_LITTLE 5800template 5801Output_section* 5802Layout::init_fixed_output_section<64, false>( 5803 const char* name, 5804 elfcpp::Shdr<64, false>& shdr); 5805#endif 5806 5807#ifdef HAVE_TARGET_64_BIG 5808template 5809Output_section* 5810Layout::init_fixed_output_section<64, true>( 5811 const char* name, 5812 elfcpp::Shdr<64, true>& shdr); 5813#endif 5814 5815#ifdef HAVE_TARGET_32_LITTLE 5816template 5817Output_section* 5818Layout::layout<32, false>(Sized_relobj_file<32, false>* object, 5819 unsigned int shndx, 5820 const char* name, 5821 const elfcpp::Shdr<32, false>& shdr, 5822 unsigned int, unsigned int, off_t*); 5823#endif 5824 5825#ifdef HAVE_TARGET_32_BIG 5826template 5827Output_section* 5828Layout::layout<32, true>(Sized_relobj_file<32, true>* object, 5829 unsigned int shndx, 5830 const char* name, 5831 const elfcpp::Shdr<32, true>& shdr, 5832 unsigned int, unsigned int, off_t*); 5833#endif 5834 5835#ifdef HAVE_TARGET_64_LITTLE 5836template 5837Output_section* 5838Layout::layout<64, false>(Sized_relobj_file<64, false>* object, 5839 unsigned int shndx, 5840 const char* name, 5841 const elfcpp::Shdr<64, false>& shdr, 5842 unsigned int, unsigned int, off_t*); 5843#endif 5844 5845#ifdef HAVE_TARGET_64_BIG 5846template 5847Output_section* 5848Layout::layout<64, true>(Sized_relobj_file<64, true>* object, 5849 unsigned int shndx, 5850 const char* name, 5851 const elfcpp::Shdr<64, true>& shdr, 5852 unsigned int, unsigned int, off_t*); 5853#endif 5854 5855#ifdef HAVE_TARGET_32_LITTLE 5856template 5857Output_section* 5858Layout::layout_reloc<32, false>(Sized_relobj_file<32, false>* object, 5859 unsigned int reloc_shndx, 5860 const elfcpp::Shdr<32, false>& shdr, 5861 Output_section* data_section, 5862 Relocatable_relocs* rr); 5863#endif 5864 5865#ifdef HAVE_TARGET_32_BIG 5866template 5867Output_section* 5868Layout::layout_reloc<32, true>(Sized_relobj_file<32, true>* object, 5869 unsigned int reloc_shndx, 5870 const elfcpp::Shdr<32, true>& shdr, 5871 Output_section* data_section, 5872 Relocatable_relocs* rr); 5873#endif 5874 5875#ifdef HAVE_TARGET_64_LITTLE 5876template 5877Output_section* 5878Layout::layout_reloc<64, false>(Sized_relobj_file<64, false>* object, 5879 unsigned int reloc_shndx, 5880 const elfcpp::Shdr<64, false>& shdr, 5881 Output_section* data_section, 5882 Relocatable_relocs* rr); 5883#endif 5884 5885#ifdef HAVE_TARGET_64_BIG 5886template 5887Output_section* 5888Layout::layout_reloc<64, true>(Sized_relobj_file<64, true>* object, 5889 unsigned int reloc_shndx, 5890 const elfcpp::Shdr<64, true>& shdr, 5891 Output_section* data_section, 5892 Relocatable_relocs* rr); 5893#endif 5894 5895#ifdef HAVE_TARGET_32_LITTLE 5896template 5897void 5898Layout::layout_group<32, false>(Symbol_table* symtab, 5899 Sized_relobj_file<32, false>* object, 5900 unsigned int, 5901 const char* group_section_name, 5902 const char* signature, 5903 const elfcpp::Shdr<32, false>& shdr, 5904 elfcpp::Elf_Word flags, 5905 std::vector<unsigned int>* shndxes); 5906#endif 5907 5908#ifdef HAVE_TARGET_32_BIG 5909template 5910void 5911Layout::layout_group<32, true>(Symbol_table* symtab, 5912 Sized_relobj_file<32, true>* object, 5913 unsigned int, 5914 const char* group_section_name, 5915 const char* signature, 5916 const elfcpp::Shdr<32, true>& shdr, 5917 elfcpp::Elf_Word flags, 5918 std::vector<unsigned int>* shndxes); 5919#endif 5920 5921#ifdef HAVE_TARGET_64_LITTLE 5922template 5923void 5924Layout::layout_group<64, false>(Symbol_table* symtab, 5925 Sized_relobj_file<64, false>* object, 5926 unsigned int, 5927 const char* group_section_name, 5928 const char* signature, 5929 const elfcpp::Shdr<64, false>& shdr, 5930 elfcpp::Elf_Word flags, 5931 std::vector<unsigned int>* shndxes); 5932#endif 5933 5934#ifdef HAVE_TARGET_64_BIG 5935template 5936void 5937Layout::layout_group<64, true>(Symbol_table* symtab, 5938 Sized_relobj_file<64, true>* object, 5939 unsigned int, 5940 const char* group_section_name, 5941 const char* signature, 5942 const elfcpp::Shdr<64, true>& shdr, 5943 elfcpp::Elf_Word flags, 5944 std::vector<unsigned int>* shndxes); 5945#endif 5946 5947#ifdef HAVE_TARGET_32_LITTLE 5948template 5949Output_section* 5950Layout::layout_eh_frame<32, false>(Sized_relobj_file<32, false>* object, 5951 const unsigned char* symbols, 5952 off_t symbols_size, 5953 const unsigned char* symbol_names, 5954 off_t symbol_names_size, 5955 unsigned int shndx, 5956 const elfcpp::Shdr<32, false>& shdr, 5957 unsigned int reloc_shndx, 5958 unsigned int reloc_type, 5959 off_t* off); 5960#endif 5961 5962#ifdef HAVE_TARGET_32_BIG 5963template 5964Output_section* 5965Layout::layout_eh_frame<32, true>(Sized_relobj_file<32, true>* object, 5966 const unsigned char* symbols, 5967 off_t symbols_size, 5968 const unsigned char* symbol_names, 5969 off_t symbol_names_size, 5970 unsigned int shndx, 5971 const elfcpp::Shdr<32, true>& shdr, 5972 unsigned int reloc_shndx, 5973 unsigned int reloc_type, 5974 off_t* off); 5975#endif 5976 5977#ifdef HAVE_TARGET_64_LITTLE 5978template 5979Output_section* 5980Layout::layout_eh_frame<64, false>(Sized_relobj_file<64, false>* object, 5981 const unsigned char* symbols, 5982 off_t symbols_size, 5983 const unsigned char* symbol_names, 5984 off_t symbol_names_size, 5985 unsigned int shndx, 5986 const elfcpp::Shdr<64, false>& shdr, 5987 unsigned int reloc_shndx, 5988 unsigned int reloc_type, 5989 off_t* off); 5990#endif 5991 5992#ifdef HAVE_TARGET_64_BIG 5993template 5994Output_section* 5995Layout::layout_eh_frame<64, true>(Sized_relobj_file<64, true>* object, 5996 const unsigned char* symbols, 5997 off_t symbols_size, 5998 const unsigned char* symbol_names, 5999 off_t symbol_names_size, 6000 unsigned int shndx, 6001 const elfcpp::Shdr<64, true>& shdr, 6002 unsigned int reloc_shndx, 6003 unsigned int reloc_type, 6004 off_t* off); 6005#endif 6006 6007#ifdef HAVE_TARGET_32_LITTLE 6008template 6009void 6010Layout::add_to_gdb_index(bool is_type_unit, 6011 Sized_relobj<32, false>* object, 6012 const unsigned char* symbols, 6013 off_t symbols_size, 6014 unsigned int shndx, 6015 unsigned int reloc_shndx, 6016 unsigned int reloc_type); 6017#endif 6018 6019#ifdef HAVE_TARGET_32_BIG 6020template 6021void 6022Layout::add_to_gdb_index(bool is_type_unit, 6023 Sized_relobj<32, true>* object, 6024 const unsigned char* symbols, 6025 off_t symbols_size, 6026 unsigned int shndx, 6027 unsigned int reloc_shndx, 6028 unsigned int reloc_type); 6029#endif 6030 6031#ifdef HAVE_TARGET_64_LITTLE 6032template 6033void 6034Layout::add_to_gdb_index(bool is_type_unit, 6035 Sized_relobj<64, false>* object, 6036 const unsigned char* symbols, 6037 off_t symbols_size, 6038 unsigned int shndx, 6039 unsigned int reloc_shndx, 6040 unsigned int reloc_type); 6041#endif 6042 6043#ifdef HAVE_TARGET_64_BIG 6044template 6045void 6046Layout::add_to_gdb_index(bool is_type_unit, 6047 Sized_relobj<64, true>* object, 6048 const unsigned char* symbols, 6049 off_t symbols_size, 6050 unsigned int shndx, 6051 unsigned int reloc_shndx, 6052 unsigned int reloc_type); 6053#endif 6054 6055} // End namespace gold. 6056