1 // object.cc -- support for an object file for linking in gold 2 3 // Copyright (C) 2006-2020 Free Software Foundation, Inc. 4 // Written by Ian Lance Taylor <iant@google.com>. 5 6 // This file is part of gold. 7 8 // This program is free software; you can redistribute it and/or modify 9 // it under the terms of the GNU General Public License as published by 10 // the Free Software Foundation; either version 3 of the License, or 11 // (at your option) any later version. 12 13 // This program is distributed in the hope that it will be useful, 14 // but WITHOUT ANY WARRANTY; without even the implied warranty of 15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 // GNU General Public License for more details. 17 18 // You should have received a copy of the GNU General Public License 19 // along with this program; if not, write to the Free Software 20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 21 // MA 02110-1301, USA. 22 23 #include "gold.h" 24 25 #include <cerrno> 26 #include <cstring> 27 #include <cstdarg> 28 #include "demangle.h" 29 #include "libiberty.h" 30 31 #include "gc.h" 32 #include "target-select.h" 33 #include "dwarf_reader.h" 34 #include "layout.h" 35 #include "output.h" 36 #include "symtab.h" 37 #include "cref.h" 38 #include "reloc.h" 39 #include "object.h" 40 #include "dynobj.h" 41 #include "plugin.h" 42 #include "compressed_output.h" 43 #include "incremental.h" 44 #include "merge.h" 45 46 namespace gold 47 { 48 49 // Struct Read_symbols_data. 50 51 // Destroy any remaining File_view objects and buffers of decompressed 52 // sections. 53 54 Read_symbols_data::~Read_symbols_data() 55 { 56 if (this->section_headers != NULL) 57 delete this->section_headers; 58 if (this->section_names != NULL) 59 delete this->section_names; 60 if (this->symbols != NULL) 61 delete this->symbols; 62 if (this->symbol_names != NULL) 63 delete this->symbol_names; 64 if (this->versym != NULL) 65 delete this->versym; 66 if (this->verdef != NULL) 67 delete this->verdef; 68 if (this->verneed != NULL) 69 delete this->verneed; 70 } 71 72 // Class Xindex. 73 74 // Initialize the symtab_xindex_ array. Find the SHT_SYMTAB_SHNDX 75 // section and read it in. SYMTAB_SHNDX is the index of the symbol 76 // table we care about. 77 78 template<int size, bool big_endian> 79 void 80 Xindex::initialize_symtab_xindex(Object* object, unsigned int symtab_shndx) 81 { 82 if (!this->symtab_xindex_.empty()) 83 return; 84 85 gold_assert(symtab_shndx != 0); 86 87 // Look through the sections in reverse order, on the theory that it 88 // is more likely to be near the end than the beginning. 89 unsigned int i = object->shnum(); 90 while (i > 0) 91 { 92 --i; 93 if (object->section_type(i) == elfcpp::SHT_SYMTAB_SHNDX 94 && this->adjust_shndx(object->section_link(i)) == symtab_shndx) 95 { 96 this->read_symtab_xindex<size, big_endian>(object, i, NULL); 97 return; 98 } 99 } 100 101 object->error(_("missing SHT_SYMTAB_SHNDX section")); 102 } 103 104 // Read in the symtab_xindex_ array, given the section index of the 105 // SHT_SYMTAB_SHNDX section. If PSHDRS is not NULL, it points at the 106 // section headers. 107 108 template<int size, bool big_endian> 109 void 110 Xindex::read_symtab_xindex(Object* object, unsigned int xindex_shndx, 111 const unsigned char* pshdrs) 112 { 113 section_size_type bytecount; 114 const unsigned char* contents; 115 if (pshdrs == NULL) 116 contents = object->section_contents(xindex_shndx, &bytecount, false); 117 else 118 { 119 const unsigned char* p = (pshdrs 120 + (xindex_shndx 121 * elfcpp::Elf_sizes<size>::shdr_size)); 122 typename elfcpp::Shdr<size, big_endian> shdr(p); 123 bytecount = convert_to_section_size_type(shdr.get_sh_size()); 124 contents = object->get_view(shdr.get_sh_offset(), bytecount, true, false); 125 } 126 127 gold_assert(this->symtab_xindex_.empty()); 128 this->symtab_xindex_.reserve(bytecount / 4); 129 for (section_size_type i = 0; i < bytecount; i += 4) 130 { 131 unsigned int shndx = elfcpp::Swap<32, big_endian>::readval(contents + i); 132 // We preadjust the section indexes we save. 133 this->symtab_xindex_.push_back(this->adjust_shndx(shndx)); 134 } 135 } 136 137 // Symbol symndx has a section of SHN_XINDEX; return the real section 138 // index. 139 140 unsigned int 141 Xindex::sym_xindex_to_shndx(Object* object, unsigned int symndx) 142 { 143 if (symndx >= this->symtab_xindex_.size()) 144 { 145 object->error(_("symbol %u out of range for SHT_SYMTAB_SHNDX section"), 146 symndx); 147 return elfcpp::SHN_UNDEF; 148 } 149 unsigned int shndx = this->symtab_xindex_[symndx]; 150 if (shndx < elfcpp::SHN_LORESERVE || shndx >= object->shnum()) 151 { 152 object->error(_("extended index for symbol %u out of range: %u"), 153 symndx, shndx); 154 return elfcpp::SHN_UNDEF; 155 } 156 return shndx; 157 } 158 159 // Class Object. 160 161 // Report an error for this object file. This is used by the 162 // elfcpp::Elf_file interface, and also called by the Object code 163 // itself. 164 165 void 166 Object::error(const char* format, ...) const 167 { 168 va_list args; 169 va_start(args, format); 170 char* buf = NULL; 171 if (vasprintf(&buf, format, args) < 0) 172 gold_nomem(); 173 va_end(args); 174 gold_error(_("%s: %s"), this->name().c_str(), buf); 175 free(buf); 176 } 177 178 // Return a view of the contents of a section. 179 180 const unsigned char* 181 Object::section_contents(unsigned int shndx, section_size_type* plen, 182 bool cache) 183 { return this->do_section_contents(shndx, plen, cache); } 184 185 // Read the section data into SD. This is code common to Sized_relobj_file 186 // and Sized_dynobj, so we put it into Object. 187 188 template<int size, bool big_endian> 189 void 190 Object::read_section_data(elfcpp::Elf_file<size, big_endian, Object>* elf_file, 191 Read_symbols_data* sd) 192 { 193 const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size; 194 195 // Read the section headers. 196 const off_t shoff = elf_file->shoff(); 197 const unsigned int shnum = this->shnum(); 198 sd->section_headers = this->get_lasting_view(shoff, shnum * shdr_size, 199 true, true); 200 201 // Read the section names. 202 const unsigned char* pshdrs = sd->section_headers->data(); 203 const unsigned char* pshdrnames = pshdrs + elf_file->shstrndx() * shdr_size; 204 typename elfcpp::Shdr<size, big_endian> shdrnames(pshdrnames); 205 206 if (shdrnames.get_sh_type() != elfcpp::SHT_STRTAB) 207 this->error(_("section name section has wrong type: %u"), 208 static_cast<unsigned int>(shdrnames.get_sh_type())); 209 210 sd->section_names_size = 211 convert_to_section_size_type(shdrnames.get_sh_size()); 212 sd->section_names = this->get_lasting_view(shdrnames.get_sh_offset(), 213 sd->section_names_size, false, 214 false); 215 } 216 217 // If NAME is the name of a special .gnu.warning section, arrange for 218 // the warning to be issued. SHNDX is the section index. Return 219 // whether it is a warning section. 220 221 bool 222 Object::handle_gnu_warning_section(const char* name, unsigned int shndx, 223 Symbol_table* symtab) 224 { 225 const char warn_prefix[] = ".gnu.warning."; 226 const int warn_prefix_len = sizeof warn_prefix - 1; 227 if (strncmp(name, warn_prefix, warn_prefix_len) == 0) 228 { 229 // Read the section contents to get the warning text. It would 230 // be nicer if we only did this if we have to actually issue a 231 // warning. Unfortunately, warnings are issued as we relocate 232 // sections. That means that we can not lock the object then, 233 // as we might try to issue the same warning multiple times 234 // simultaneously. 235 section_size_type len; 236 const unsigned char* contents = this->section_contents(shndx, &len, 237 false); 238 if (len == 0) 239 { 240 const char* warning = name + warn_prefix_len; 241 contents = reinterpret_cast<const unsigned char*>(warning); 242 len = strlen(warning); 243 } 244 std::string warning(reinterpret_cast<const char*>(contents), len); 245 symtab->add_warning(name + warn_prefix_len, this, warning); 246 return true; 247 } 248 return false; 249 } 250 251 // If NAME is the name of the special section which indicates that 252 // this object was compiled with -fsplit-stack, mark it accordingly. 253 254 bool 255 Object::handle_split_stack_section(const char* name) 256 { 257 if (strcmp(name, ".note.GNU-split-stack") == 0) 258 { 259 this->uses_split_stack_ = true; 260 return true; 261 } 262 if (strcmp(name, ".note.GNU-no-split-stack") == 0) 263 { 264 this->has_no_split_stack_ = true; 265 return true; 266 } 267 return false; 268 } 269 270 // Class Relobj 271 272 template<int size> 273 void 274 Relobj::initialize_input_to_output_map(unsigned int shndx, 275 typename elfcpp::Elf_types<size>::Elf_Addr starting_address, 276 Unordered_map<section_offset_type, 277 typename elfcpp::Elf_types<size>::Elf_Addr>* output_addresses) const { 278 Object_merge_map *map = this->object_merge_map_; 279 map->initialize_input_to_output_map<size>(shndx, starting_address, 280 output_addresses); 281 } 282 283 void 284 Relobj::add_merge_mapping(Output_section_data *output_data, 285 unsigned int shndx, section_offset_type offset, 286 section_size_type length, 287 section_offset_type output_offset) { 288 Object_merge_map* object_merge_map = this->get_or_create_merge_map(); 289 object_merge_map->add_mapping(output_data, shndx, offset, length, output_offset); 290 } 291 292 bool 293 Relobj::merge_output_offset(unsigned int shndx, section_offset_type offset, 294 section_offset_type *poutput) const { 295 Object_merge_map* object_merge_map = this->object_merge_map_; 296 if (object_merge_map == NULL) 297 return false; 298 return object_merge_map->get_output_offset(shndx, offset, poutput); 299 } 300 301 const Output_section_data* 302 Relobj::find_merge_section(unsigned int shndx) const { 303 Object_merge_map* object_merge_map = this->object_merge_map_; 304 if (object_merge_map == NULL) 305 return NULL; 306 return object_merge_map->find_merge_section(shndx); 307 } 308 309 // To copy the symbols data read from the file to a local data structure. 310 // This function is called from do_layout only while doing garbage 311 // collection. 312 313 void 314 Relobj::copy_symbols_data(Symbols_data* gc_sd, Read_symbols_data* sd, 315 unsigned int section_header_size) 316 { 317 gc_sd->section_headers_data = 318 new unsigned char[(section_header_size)]; 319 memcpy(gc_sd->section_headers_data, sd->section_headers->data(), 320 section_header_size); 321 gc_sd->section_names_data = 322 new unsigned char[sd->section_names_size]; 323 memcpy(gc_sd->section_names_data, sd->section_names->data(), 324 sd->section_names_size); 325 gc_sd->section_names_size = sd->section_names_size; 326 if (sd->symbols != NULL) 327 { 328 gc_sd->symbols_data = 329 new unsigned char[sd->symbols_size]; 330 memcpy(gc_sd->symbols_data, sd->symbols->data(), 331 sd->symbols_size); 332 } 333 else 334 { 335 gc_sd->symbols_data = NULL; 336 } 337 gc_sd->symbols_size = sd->symbols_size; 338 gc_sd->external_symbols_offset = sd->external_symbols_offset; 339 if (sd->symbol_names != NULL) 340 { 341 gc_sd->symbol_names_data = 342 new unsigned char[sd->symbol_names_size]; 343 memcpy(gc_sd->symbol_names_data, sd->symbol_names->data(), 344 sd->symbol_names_size); 345 } 346 else 347 { 348 gc_sd->symbol_names_data = NULL; 349 } 350 gc_sd->symbol_names_size = sd->symbol_names_size; 351 } 352 353 // This function determines if a particular section name must be included 354 // in the link. This is used during garbage collection to determine the 355 // roots of the worklist. 356 357 bool 358 Relobj::is_section_name_included(const char* name) 359 { 360 if (is_prefix_of(".ctors", name) 361 || is_prefix_of(".dtors", name) 362 || is_prefix_of(".note", name) 363 || is_prefix_of(".init", name) 364 || is_prefix_of(".fini", name) 365 || is_prefix_of(".gcc_except_table", name) 366 || is_prefix_of(".jcr", name) 367 || is_prefix_of(".preinit_array", name) 368 || (is_prefix_of(".text", name) 369 && strstr(name, "personality")) 370 || (is_prefix_of(".data", name) 371 && strstr(name, "personality")) 372 || (is_prefix_of(".sdata", name) 373 && strstr(name, "personality")) 374 || (is_prefix_of(".gnu.linkonce.d", name) 375 && strstr(name, "personality")) 376 || (is_prefix_of(".rodata", name) 377 && strstr(name, "nptl_version"))) 378 { 379 return true; 380 } 381 return false; 382 } 383 384 // Finalize the incremental relocation information. Allocates a block 385 // of relocation entries for each symbol, and sets the reloc_bases_ 386 // array to point to the first entry in each block. If CLEAR_COUNTS 387 // is TRUE, also clear the per-symbol relocation counters. 388 389 void 390 Relobj::finalize_incremental_relocs(Layout* layout, bool clear_counts) 391 { 392 unsigned int nsyms = this->get_global_symbols()->size(); 393 this->reloc_bases_ = new unsigned int[nsyms]; 394 395 gold_assert(this->reloc_bases_ != NULL); 396 gold_assert(layout->incremental_inputs() != NULL); 397 398 unsigned int rindex = layout->incremental_inputs()->get_reloc_count(); 399 for (unsigned int i = 0; i < nsyms; ++i) 400 { 401 this->reloc_bases_[i] = rindex; 402 rindex += this->reloc_counts_[i]; 403 if (clear_counts) 404 this->reloc_counts_[i] = 0; 405 } 406 layout->incremental_inputs()->set_reloc_count(rindex); 407 } 408 409 Object_merge_map* 410 Relobj::get_or_create_merge_map() 411 { 412 if (!this->object_merge_map_) 413 this->object_merge_map_ = new Object_merge_map(); 414 return this->object_merge_map_; 415 } 416 417 // Class Sized_relobj. 418 419 // Iterate over local symbols, calling a visitor class V for each GOT offset 420 // associated with a local symbol. 421 422 template<int size, bool big_endian> 423 void 424 Sized_relobj<size, big_endian>::do_for_all_local_got_entries( 425 Got_offset_list::Visitor* v) const 426 { 427 unsigned int nsyms = this->local_symbol_count(); 428 for (unsigned int i = 0; i < nsyms; i++) 429 { 430 Local_got_entry_key key(i, 0); 431 Local_got_offsets::const_iterator p = this->local_got_offsets_.find(key); 432 if (p != this->local_got_offsets_.end()) 433 { 434 const Got_offset_list* got_offsets = p->second; 435 got_offsets->for_all_got_offsets(v); 436 } 437 } 438 } 439 440 // Get the address of an output section. 441 442 template<int size, bool big_endian> 443 uint64_t 444 Sized_relobj<size, big_endian>::do_output_section_address( 445 unsigned int shndx) 446 { 447 // If the input file is linked as --just-symbols, the output 448 // section address is the input section address. 449 if (this->just_symbols()) 450 return this->section_address(shndx); 451 452 const Output_section* os = this->do_output_section(shndx); 453 gold_assert(os != NULL); 454 return os->address(); 455 } 456 457 // Class Sized_relobj_file. 458 459 template<int size, bool big_endian> 460 Sized_relobj_file<size, big_endian>::Sized_relobj_file( 461 const std::string& name, 462 Input_file* input_file, 463 off_t offset, 464 const elfcpp::Ehdr<size, big_endian>& ehdr) 465 : Sized_relobj<size, big_endian>(name, input_file, offset), 466 elf_file_(this, ehdr), 467 symtab_shndx_(-1U), 468 local_symbol_count_(0), 469 output_local_symbol_count_(0), 470 output_local_dynsym_count_(0), 471 symbols_(), 472 defined_count_(0), 473 local_symbol_offset_(0), 474 local_dynsym_offset_(0), 475 local_values_(), 476 local_plt_offsets_(), 477 kept_comdat_sections_(), 478 has_eh_frame_(false), 479 is_deferred_layout_(false), 480 deferred_layout_(), 481 deferred_layout_relocs_(), 482 output_views_(NULL) 483 { 484 this->e_type_ = ehdr.get_e_type(); 485 } 486 487 template<int size, bool big_endian> 488 Sized_relobj_file<size, big_endian>::~Sized_relobj_file() 489 { 490 } 491 492 // Set up an object file based on the file header. This sets up the 493 // section information. 494 495 template<int size, bool big_endian> 496 void 497 Sized_relobj_file<size, big_endian>::do_setup() 498 { 499 const unsigned int shnum = this->elf_file_.shnum(); 500 this->set_shnum(shnum); 501 } 502 503 // Find the SHT_SYMTAB section, given the section headers. The ELF 504 // standard says that maybe in the future there can be more than one 505 // SHT_SYMTAB section. Until somebody figures out how that could 506 // work, we assume there is only one. 507 508 template<int size, bool big_endian> 509 void 510 Sized_relobj_file<size, big_endian>::find_symtab(const unsigned char* pshdrs) 511 { 512 const unsigned int shnum = this->shnum(); 513 this->symtab_shndx_ = 0; 514 if (shnum > 0) 515 { 516 // Look through the sections in reverse order, since gas tends 517 // to put the symbol table at the end. 518 const unsigned char* p = pshdrs + shnum * This::shdr_size; 519 unsigned int i = shnum; 520 unsigned int xindex_shndx = 0; 521 unsigned int xindex_link = 0; 522 while (i > 0) 523 { 524 --i; 525 p -= This::shdr_size; 526 typename This::Shdr shdr(p); 527 if (shdr.get_sh_type() == elfcpp::SHT_SYMTAB) 528 { 529 this->symtab_shndx_ = i; 530 if (xindex_shndx > 0 && xindex_link == i) 531 { 532 Xindex* xindex = 533 new Xindex(this->elf_file_.large_shndx_offset()); 534 xindex->read_symtab_xindex<size, big_endian>(this, 535 xindex_shndx, 536 pshdrs); 537 this->set_xindex(xindex); 538 } 539 break; 540 } 541 542 // Try to pick up the SHT_SYMTAB_SHNDX section, if there is 543 // one. This will work if it follows the SHT_SYMTAB 544 // section. 545 if (shdr.get_sh_type() == elfcpp::SHT_SYMTAB_SHNDX) 546 { 547 xindex_shndx = i; 548 xindex_link = this->adjust_shndx(shdr.get_sh_link()); 549 } 550 } 551 } 552 } 553 554 // Return the Xindex structure to use for object with lots of 555 // sections. 556 557 template<int size, bool big_endian> 558 Xindex* 559 Sized_relobj_file<size, big_endian>::do_initialize_xindex() 560 { 561 gold_assert(this->symtab_shndx_ != -1U); 562 Xindex* xindex = new Xindex(this->elf_file_.large_shndx_offset()); 563 xindex->initialize_symtab_xindex<size, big_endian>(this, this->symtab_shndx_); 564 return xindex; 565 } 566 567 // Return whether SHDR has the right type and flags to be a GNU 568 // .eh_frame section. 569 570 template<int size, bool big_endian> 571 bool 572 Sized_relobj_file<size, big_endian>::check_eh_frame_flags( 573 const elfcpp::Shdr<size, big_endian>* shdr) const 574 { 575 elfcpp::Elf_Word sh_type = shdr->get_sh_type(); 576 return ((sh_type == elfcpp::SHT_PROGBITS 577 || sh_type == parameters->target().unwind_section_type()) 578 && (shdr->get_sh_flags() & elfcpp::SHF_ALLOC) != 0); 579 } 580 581 // Find the section header with the given name. 582 583 template<int size, bool big_endian> 584 const unsigned char* 585 Object::find_shdr( 586 const unsigned char* pshdrs, 587 const char* name, 588 const char* names, 589 section_size_type names_size, 590 const unsigned char* hdr) const 591 { 592 const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size; 593 const unsigned int shnum = this->shnum(); 594 const unsigned char* hdr_end = pshdrs + shdr_size * shnum; 595 size_t sh_name = 0; 596 597 while (1) 598 { 599 if (hdr) 600 { 601 // We found HDR last time we were called, continue looking. 602 typename elfcpp::Shdr<size, big_endian> shdr(hdr); 603 sh_name = shdr.get_sh_name(); 604 } 605 else 606 { 607 // Look for the next occurrence of NAME in NAMES. 608 // The fact that .shstrtab produced by current GNU tools is 609 // string merged means we shouldn't have both .not.foo and 610 // .foo in .shstrtab, and multiple .foo sections should all 611 // have the same sh_name. However, this is not guaranteed 612 // by the ELF spec and not all ELF object file producers may 613 // be so clever. 614 size_t len = strlen(name) + 1; 615 const char *p = sh_name ? names + sh_name + len : names; 616 p = reinterpret_cast<const char*>(memmem(p, names_size - (p - names), 617 name, len)); 618 if (p == NULL) 619 return NULL; 620 sh_name = p - names; 621 hdr = pshdrs; 622 if (sh_name == 0) 623 return hdr; 624 } 625 626 hdr += shdr_size; 627 while (hdr < hdr_end) 628 { 629 typename elfcpp::Shdr<size, big_endian> shdr(hdr); 630 if (shdr.get_sh_name() == sh_name) 631 return hdr; 632 hdr += shdr_size; 633 } 634 hdr = NULL; 635 if (sh_name == 0) 636 return hdr; 637 } 638 } 639 640 // Return whether there is a GNU .eh_frame section, given the section 641 // headers and the section names. 642 643 template<int size, bool big_endian> 644 bool 645 Sized_relobj_file<size, big_endian>::find_eh_frame( 646 const unsigned char* pshdrs, 647 const char* names, 648 section_size_type names_size) const 649 { 650 const unsigned char* s = NULL; 651 652 while (1) 653 { 654 s = this->template find_shdr<size, big_endian>(pshdrs, ".eh_frame", 655 names, names_size, s); 656 if (s == NULL) 657 return false; 658 659 typename This::Shdr shdr(s); 660 if (this->check_eh_frame_flags(&shdr)) 661 return true; 662 } 663 } 664 665 // Return TRUE if this is a section whose contents will be needed in the 666 // Add_symbols task. This function is only called for sections that have 667 // already passed the test in is_compressed_debug_section() and the debug 668 // section name prefix, ".debug"/".zdebug", has been skipped. 669 670 static bool 671 need_decompressed_section(const char* name) 672 { 673 if (*name++ != '_') 674 return false; 675 676 #ifdef ENABLE_THREADS 677 // Decompressing these sections now will help only if we're 678 // multithreaded. 679 if (parameters->options().threads()) 680 { 681 // We will need .zdebug_str if this is not an incremental link 682 // (i.e., we are processing string merge sections) or if we need 683 // to build a gdb index. 684 if ((!parameters->incremental() || parameters->options().gdb_index()) 685 && strcmp(name, "str") == 0) 686 return true; 687 688 // We will need these other sections when building a gdb index. 689 if (parameters->options().gdb_index() 690 && (strcmp(name, "info") == 0 691 || strcmp(name, "types") == 0 692 || strcmp(name, "pubnames") == 0 693 || strcmp(name, "pubtypes") == 0 694 || strcmp(name, "ranges") == 0 695 || strcmp(name, "abbrev") == 0)) 696 return true; 697 } 698 #endif 699 700 // Even when single-threaded, we will need .zdebug_str if this is 701 // not an incremental link and we are building a gdb index. 702 // Otherwise, we would decompress the section twice: once for 703 // string merge processing, and once for building the gdb index. 704 if (!parameters->incremental() 705 && parameters->options().gdb_index() 706 && strcmp(name, "str") == 0) 707 return true; 708 709 return false; 710 } 711 712 // Build a table for any compressed debug sections, mapping each section index 713 // to the uncompressed size and (if needed) the decompressed contents. 714 715 template<int size, bool big_endian> 716 Compressed_section_map* 717 build_compressed_section_map( 718 const unsigned char* pshdrs, 719 unsigned int shnum, 720 const char* names, 721 section_size_type names_size, 722 Object* obj, 723 bool decompress_if_needed) 724 { 725 Compressed_section_map* uncompressed_map = new Compressed_section_map(); 726 const unsigned int shdr_size = elfcpp::Elf_sizes<size>::shdr_size; 727 const unsigned char* p = pshdrs + shdr_size; 728 729 for (unsigned int i = 1; i < shnum; ++i, p += shdr_size) 730 { 731 typename elfcpp::Shdr<size, big_endian> shdr(p); 732 if (shdr.get_sh_type() == elfcpp::SHT_PROGBITS 733 && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0) 734 { 735 if (shdr.get_sh_name() >= names_size) 736 { 737 obj->error(_("bad section name offset for section %u: %lu"), 738 i, static_cast<unsigned long>(shdr.get_sh_name())); 739 continue; 740 } 741 742 const char* name = names + shdr.get_sh_name(); 743 bool is_compressed = ((shdr.get_sh_flags() 744 & elfcpp::SHF_COMPRESSED) != 0); 745 bool is_zcompressed = (!is_compressed 746 && is_compressed_debug_section(name)); 747 748 if (is_zcompressed || is_compressed) 749 { 750 section_size_type len; 751 const unsigned char* contents = 752 obj->section_contents(i, &len, false); 753 uint64_t uncompressed_size; 754 Compressed_section_info info; 755 if (is_zcompressed) 756 { 757 // Skip over the ".zdebug" prefix. 758 name += 7; 759 uncompressed_size = get_uncompressed_size(contents, len); 760 info.addralign = shdr.get_sh_addralign(); 761 } 762 else 763 { 764 // Skip over the ".debug" prefix. 765 name += 6; 766 elfcpp::Chdr<size, big_endian> chdr(contents); 767 uncompressed_size = chdr.get_ch_size(); 768 info.addralign = chdr.get_ch_addralign(); 769 } 770 info.size = convert_to_section_size_type(uncompressed_size); 771 info.flag = shdr.get_sh_flags(); 772 info.contents = NULL; 773 if (uncompressed_size != -1ULL) 774 { 775 unsigned char* uncompressed_data = NULL; 776 if (decompress_if_needed && need_decompressed_section(name)) 777 { 778 uncompressed_data = new unsigned char[uncompressed_size]; 779 if (decompress_input_section(contents, len, 780 uncompressed_data, 781 uncompressed_size, 782 size, big_endian, 783 shdr.get_sh_flags())) 784 info.contents = uncompressed_data; 785 else 786 delete[] uncompressed_data; 787 } 788 (*uncompressed_map)[i] = info; 789 } 790 } 791 } 792 } 793 return uncompressed_map; 794 } 795 796 // Stash away info for a number of special sections. 797 // Return true if any of the sections found require local symbols to be read. 798 799 template<int size, bool big_endian> 800 bool 801 Sized_relobj_file<size, big_endian>::do_find_special_sections( 802 Read_symbols_data* sd) 803 { 804 const unsigned char* const pshdrs = sd->section_headers->data(); 805 const unsigned char* namesu = sd->section_names->data(); 806 const char* names = reinterpret_cast<const char*>(namesu); 807 808 if (this->find_eh_frame(pshdrs, names, sd->section_names_size)) 809 this->has_eh_frame_ = true; 810 811 Compressed_section_map* compressed_sections = 812 build_compressed_section_map<size, big_endian>( 813 pshdrs, this->shnum(), names, sd->section_names_size, this, true); 814 if (compressed_sections != NULL) 815 this->set_compressed_sections(compressed_sections); 816 817 return (this->has_eh_frame_ 818 || (!parameters->options().relocatable() 819 && parameters->options().gdb_index() 820 && (memmem(names, sd->section_names_size, "debug_info", 11) != NULL 821 || memmem(names, sd->section_names_size, 822 "debug_types", 12) != NULL))); 823 } 824 825 // Read the sections and symbols from an object file. 826 827 template<int size, bool big_endian> 828 void 829 Sized_relobj_file<size, big_endian>::do_read_symbols(Read_symbols_data* sd) 830 { 831 this->base_read_symbols(sd); 832 } 833 834 // Read the sections and symbols from an object file. This is common 835 // code for all target-specific overrides of do_read_symbols(). 836 837 template<int size, bool big_endian> 838 void 839 Sized_relobj_file<size, big_endian>::base_read_symbols(Read_symbols_data* sd) 840 { 841 this->read_section_data(&this->elf_file_, sd); 842 843 const unsigned char* const pshdrs = sd->section_headers->data(); 844 845 this->find_symtab(pshdrs); 846 847 bool need_local_symbols = this->do_find_special_sections(sd); 848 849 sd->symbols = NULL; 850 sd->symbols_size = 0; 851 sd->external_symbols_offset = 0; 852 sd->symbol_names = NULL; 853 sd->symbol_names_size = 0; 854 855 if (this->symtab_shndx_ == 0) 856 { 857 // No symbol table. Weird but legal. 858 return; 859 } 860 861 // Get the symbol table section header. 862 typename This::Shdr symtabshdr(pshdrs 863 + this->symtab_shndx_ * This::shdr_size); 864 gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB); 865 866 // If this object has a .eh_frame section, or if building a .gdb_index 867 // section and there is debug info, we need all the symbols. 868 // Otherwise we only need the external symbols. While it would be 869 // simpler to just always read all the symbols, I've seen object 870 // files with well over 2000 local symbols, which for a 64-bit 871 // object file format is over 5 pages that we don't need to read 872 // now. 873 874 const int sym_size = This::sym_size; 875 const unsigned int loccount = symtabshdr.get_sh_info(); 876 this->local_symbol_count_ = loccount; 877 this->local_values_.resize(loccount); 878 section_offset_type locsize = loccount * sym_size; 879 off_t dataoff = symtabshdr.get_sh_offset(); 880 section_size_type datasize = 881 convert_to_section_size_type(symtabshdr.get_sh_size()); 882 off_t extoff = dataoff + locsize; 883 section_size_type extsize = datasize - locsize; 884 885 off_t readoff = need_local_symbols ? dataoff : extoff; 886 section_size_type readsize = need_local_symbols ? datasize : extsize; 887 888 if (readsize == 0) 889 { 890 // No external symbols. Also weird but also legal. 891 return; 892 } 893 894 File_view* fvsymtab = this->get_lasting_view(readoff, readsize, true, false); 895 896 // Read the section header for the symbol names. 897 unsigned int strtab_shndx = this->adjust_shndx(symtabshdr.get_sh_link()); 898 if (strtab_shndx >= this->shnum()) 899 { 900 this->error(_("invalid symbol table name index: %u"), strtab_shndx); 901 return; 902 } 903 typename This::Shdr strtabshdr(pshdrs + strtab_shndx * This::shdr_size); 904 if (strtabshdr.get_sh_type() != elfcpp::SHT_STRTAB) 905 { 906 this->error(_("symbol table name section has wrong type: %u"), 907 static_cast<unsigned int>(strtabshdr.get_sh_type())); 908 return; 909 } 910 911 // Read the symbol names. 912 File_view* fvstrtab = this->get_lasting_view(strtabshdr.get_sh_offset(), 913 strtabshdr.get_sh_size(), 914 false, true); 915 916 sd->symbols = fvsymtab; 917 sd->symbols_size = readsize; 918 sd->external_symbols_offset = need_local_symbols ? locsize : 0; 919 sd->symbol_names = fvstrtab; 920 sd->symbol_names_size = 921 convert_to_section_size_type(strtabshdr.get_sh_size()); 922 } 923 924 // Return the section index of symbol SYM. Set *VALUE to its value in 925 // the object file. Set *IS_ORDINARY if this is an ordinary section 926 // index, not a special code between SHN_LORESERVE and SHN_HIRESERVE. 927 // Note that for a symbol which is not defined in this object file, 928 // this will set *VALUE to 0 and return SHN_UNDEF; it will not return 929 // the final value of the symbol in the link. 930 931 template<int size, bool big_endian> 932 unsigned int 933 Sized_relobj_file<size, big_endian>::symbol_section_and_value(unsigned int sym, 934 Address* value, 935 bool* is_ordinary) 936 { 937 section_size_type symbols_size; 938 const unsigned char* symbols = this->section_contents(this->symtab_shndx_, 939 &symbols_size, 940 false); 941 942 const size_t count = symbols_size / This::sym_size; 943 gold_assert(sym < count); 944 945 elfcpp::Sym<size, big_endian> elfsym(symbols + sym * This::sym_size); 946 *value = elfsym.get_st_value(); 947 948 return this->adjust_sym_shndx(sym, elfsym.get_st_shndx(), is_ordinary); 949 } 950 951 // Return whether to include a section group in the link. LAYOUT is 952 // used to keep track of which section groups we have already seen. 953 // INDEX is the index of the section group and SHDR is the section 954 // header. If we do not want to include this group, we set bits in 955 // OMIT for each section which should be discarded. 956 957 template<int size, bool big_endian> 958 bool 959 Sized_relobj_file<size, big_endian>::include_section_group( 960 Symbol_table* symtab, 961 Layout* layout, 962 unsigned int index, 963 const char* name, 964 const unsigned char* shdrs, 965 const char* section_names, 966 section_size_type section_names_size, 967 std::vector<bool>* omit) 968 { 969 // Read the section contents. 970 typename This::Shdr shdr(shdrs + index * This::shdr_size); 971 const unsigned char* pcon = this->get_view(shdr.get_sh_offset(), 972 shdr.get_sh_size(), true, false); 973 const elfcpp::Elf_Word* pword = 974 reinterpret_cast<const elfcpp::Elf_Word*>(pcon); 975 976 // The first word contains flags. We only care about COMDAT section 977 // groups. Other section groups are always included in the link 978 // just like ordinary sections. 979 elfcpp::Elf_Word flags = elfcpp::Swap<32, big_endian>::readval(pword); 980 981 // Look up the group signature, which is the name of a symbol. ELF 982 // uses a symbol name because some group signatures are long, and 983 // the name is generally already in the symbol table, so it makes 984 // sense to put the long string just once in .strtab rather than in 985 // both .strtab and .shstrtab. 986 987 // Get the appropriate symbol table header (this will normally be 988 // the single SHT_SYMTAB section, but in principle it need not be). 989 const unsigned int link = this->adjust_shndx(shdr.get_sh_link()); 990 typename This::Shdr symshdr(this, this->elf_file_.section_header(link)); 991 992 // Read the symbol table entry. 993 unsigned int symndx = shdr.get_sh_info(); 994 if (symndx >= symshdr.get_sh_size() / This::sym_size) 995 { 996 this->error(_("section group %u info %u out of range"), 997 index, symndx); 998 return false; 999 } 1000 off_t symoff = symshdr.get_sh_offset() + symndx * This::sym_size; 1001 const unsigned char* psym = this->get_view(symoff, This::sym_size, true, 1002 false); 1003 elfcpp::Sym<size, big_endian> sym(psym); 1004 1005 // Read the symbol table names. 1006 section_size_type symnamelen; 1007 const unsigned char* psymnamesu; 1008 psymnamesu = this->section_contents(this->adjust_shndx(symshdr.get_sh_link()), 1009 &symnamelen, true); 1010 const char* psymnames = reinterpret_cast<const char*>(psymnamesu); 1011 1012 // Get the section group signature. 1013 if (sym.get_st_name() >= symnamelen) 1014 { 1015 this->error(_("symbol %u name offset %u out of range"), 1016 symndx, sym.get_st_name()); 1017 return false; 1018 } 1019 1020 std::string signature(psymnames + sym.get_st_name()); 1021 1022 // It seems that some versions of gas will create a section group 1023 // associated with a section symbol, and then fail to give a name to 1024 // the section symbol. In such a case, use the name of the section. 1025 if (signature[0] == '\0' && sym.get_st_type() == elfcpp::STT_SECTION) 1026 { 1027 bool is_ordinary; 1028 unsigned int sym_shndx = this->adjust_sym_shndx(symndx, 1029 sym.get_st_shndx(), 1030 &is_ordinary); 1031 if (!is_ordinary || sym_shndx >= this->shnum()) 1032 { 1033 this->error(_("symbol %u invalid section index %u"), 1034 symndx, sym_shndx); 1035 return false; 1036 } 1037 typename This::Shdr member_shdr(shdrs + sym_shndx * This::shdr_size); 1038 if (member_shdr.get_sh_name() < section_names_size) 1039 signature = section_names + member_shdr.get_sh_name(); 1040 } 1041 1042 // Record this section group in the layout, and see whether we've already 1043 // seen one with the same signature. 1044 bool include_group; 1045 bool is_comdat; 1046 Kept_section* kept_section = NULL; 1047 1048 if ((flags & elfcpp::GRP_COMDAT) == 0) 1049 { 1050 include_group = true; 1051 is_comdat = false; 1052 } 1053 else 1054 { 1055 include_group = layout->find_or_add_kept_section(signature, 1056 this, index, true, 1057 true, &kept_section); 1058 is_comdat = true; 1059 } 1060 1061 if (is_comdat && include_group) 1062 { 1063 Incremental_inputs* incremental_inputs = layout->incremental_inputs(); 1064 if (incremental_inputs != NULL) 1065 incremental_inputs->report_comdat_group(this, signature.c_str()); 1066 } 1067 1068 size_t count = shdr.get_sh_size() / sizeof(elfcpp::Elf_Word); 1069 1070 std::vector<unsigned int> shndxes; 1071 bool relocate_group = include_group && parameters->options().relocatable(); 1072 if (relocate_group) 1073 shndxes.reserve(count - 1); 1074 1075 for (size_t i = 1; i < count; ++i) 1076 { 1077 elfcpp::Elf_Word shndx = 1078 this->adjust_shndx(elfcpp::Swap<32, big_endian>::readval(pword + i)); 1079 1080 if (relocate_group) 1081 shndxes.push_back(shndx); 1082 1083 if (shndx >= this->shnum()) 1084 { 1085 this->error(_("section %u in section group %u out of range"), 1086 shndx, index); 1087 continue; 1088 } 1089 1090 // Check for an earlier section number, since we're going to get 1091 // it wrong--we may have already decided to include the section. 1092 if (shndx < index) 1093 this->error(_("invalid section group %u refers to earlier section %u"), 1094 index, shndx); 1095 1096 // Get the name of the member section. 1097 typename This::Shdr member_shdr(shdrs + shndx * This::shdr_size); 1098 if (member_shdr.get_sh_name() >= section_names_size) 1099 { 1100 // This is an error, but it will be diagnosed eventually 1101 // in do_layout, so we don't need to do anything here but 1102 // ignore it. 1103 continue; 1104 } 1105 std::string mname(section_names + member_shdr.get_sh_name()); 1106 1107 if (include_group) 1108 { 1109 if (is_comdat) 1110 kept_section->add_comdat_section(mname, shndx, 1111 member_shdr.get_sh_size()); 1112 } 1113 else 1114 { 1115 (*omit)[shndx] = true; 1116 1117 // Store a mapping from this section to the Kept_section 1118 // information for the group. This mapping is used for 1119 // relocation processing and diagnostics. 1120 // If the kept section is a linkonce section, we don't 1121 // bother with it unless the comdat group contains just 1122 // a single section, making it easy to match up. 1123 if (is_comdat 1124 && (kept_section->is_comdat() || count == 2)) 1125 this->set_kept_comdat_section(shndx, true, symndx, 1126 member_shdr.get_sh_size(), 1127 kept_section); 1128 } 1129 } 1130 1131 if (relocate_group) 1132 layout->layout_group(symtab, this, index, name, signature.c_str(), 1133 shdr, flags, &shndxes); 1134 1135 return include_group; 1136 } 1137 1138 // Whether to include a linkonce section in the link. NAME is the 1139 // name of the section and SHDR is the section header. 1140 1141 // Linkonce sections are a GNU extension implemented in the original 1142 // GNU linker before section groups were defined. The semantics are 1143 // that we only include one linkonce section with a given name. The 1144 // name of a linkonce section is normally .gnu.linkonce.T.SYMNAME, 1145 // where T is the type of section and SYMNAME is the name of a symbol. 1146 // In an attempt to make linkonce sections interact well with section 1147 // groups, we try to identify SYMNAME and use it like a section group 1148 // signature. We want to block section groups with that signature, 1149 // but not other linkonce sections with that signature. We also use 1150 // the full name of the linkonce section as a normal section group 1151 // signature. 1152 1153 template<int size, bool big_endian> 1154 bool 1155 Sized_relobj_file<size, big_endian>::include_linkonce_section( 1156 Layout* layout, 1157 unsigned int index, 1158 const char* name, 1159 const elfcpp::Shdr<size, big_endian>& shdr) 1160 { 1161 typename elfcpp::Elf_types<size>::Elf_WXword sh_size = shdr.get_sh_size(); 1162 // In general the symbol name we want will be the string following 1163 // the last '.'. However, we have to handle the case of 1164 // .gnu.linkonce.t.__i686.get_pc_thunk.bx, which was generated by 1165 // some versions of gcc. So we use a heuristic: if the name starts 1166 // with ".gnu.linkonce.t.", we use everything after that. Otherwise 1167 // we look for the last '.'. We can't always simply skip 1168 // ".gnu.linkonce.X", because we have to deal with cases like 1169 // ".gnu.linkonce.d.rel.ro.local". 1170 const char* const linkonce_t = ".gnu.linkonce.t."; 1171 const char* symname; 1172 if (strncmp(name, linkonce_t, strlen(linkonce_t)) == 0) 1173 symname = name + strlen(linkonce_t); 1174 else 1175 symname = strrchr(name, '.') + 1; 1176 std::string sig1(symname); 1177 std::string sig2(name); 1178 Kept_section* kept1; 1179 Kept_section* kept2; 1180 bool include1 = layout->find_or_add_kept_section(sig1, this, index, false, 1181 false, &kept1); 1182 bool include2 = layout->find_or_add_kept_section(sig2, this, index, false, 1183 true, &kept2); 1184 1185 if (!include2) 1186 { 1187 // We are not including this section because we already saw the 1188 // name of the section as a signature. This normally implies 1189 // that the kept section is another linkonce section. If it is 1190 // the same size, record it as the section which corresponds to 1191 // this one. 1192 if (kept2->object() != NULL && !kept2->is_comdat()) 1193 this->set_kept_comdat_section(index, false, 0, sh_size, kept2); 1194 } 1195 else if (!include1) 1196 { 1197 // The section is being discarded on the basis of its symbol 1198 // name. This means that the corresponding kept section was 1199 // part of a comdat group, and it will be difficult to identify 1200 // the specific section within that group that corresponds to 1201 // this linkonce section. We'll handle the simple case where 1202 // the group has only one member section. Otherwise, it's not 1203 // worth the effort. 1204 if (kept1->object() != NULL && kept1->is_comdat()) 1205 this->set_kept_comdat_section(index, false, 0, sh_size, kept1); 1206 } 1207 else 1208 { 1209 kept1->set_linkonce_size(sh_size); 1210 kept2->set_linkonce_size(sh_size); 1211 } 1212 1213 return include1 && include2; 1214 } 1215 1216 // Layout an input section. 1217 1218 template<int size, bool big_endian> 1219 inline void 1220 Sized_relobj_file<size, big_endian>::layout_section( 1221 Layout* layout, 1222 unsigned int shndx, 1223 const char* name, 1224 const typename This::Shdr& shdr, 1225 unsigned int sh_type, 1226 unsigned int reloc_shndx, 1227 unsigned int reloc_type) 1228 { 1229 off_t offset; 1230 Output_section* os = layout->layout(this, shndx, name, shdr, sh_type, 1231 reloc_shndx, reloc_type, &offset); 1232 1233 this->output_sections()[shndx] = os; 1234 if (offset == -1) 1235 this->section_offsets()[shndx] = invalid_address; 1236 else 1237 this->section_offsets()[shndx] = convert_types<Address, off_t>(offset); 1238 1239 // If this section requires special handling, and if there are 1240 // relocs that apply to it, then we must do the special handling 1241 // before we apply the relocs. 1242 if (offset == -1 && reloc_shndx != 0) 1243 this->set_relocs_must_follow_section_writes(); 1244 } 1245 1246 // Layout an input .eh_frame section. 1247 1248 template<int size, bool big_endian> 1249 void 1250 Sized_relobj_file<size, big_endian>::layout_eh_frame_section( 1251 Layout* layout, 1252 const unsigned char* symbols_data, 1253 section_size_type symbols_size, 1254 const unsigned char* symbol_names_data, 1255 section_size_type symbol_names_size, 1256 unsigned int shndx, 1257 const typename This::Shdr& shdr, 1258 unsigned int reloc_shndx, 1259 unsigned int reloc_type) 1260 { 1261 gold_assert(this->has_eh_frame_); 1262 1263 off_t offset; 1264 Output_section* os = layout->layout_eh_frame(this, 1265 symbols_data, 1266 symbols_size, 1267 symbol_names_data, 1268 symbol_names_size, 1269 shndx, 1270 shdr, 1271 reloc_shndx, 1272 reloc_type, 1273 &offset); 1274 this->output_sections()[shndx] = os; 1275 if (os == NULL || offset == -1) 1276 this->section_offsets()[shndx] = invalid_address; 1277 else 1278 this->section_offsets()[shndx] = convert_types<Address, off_t>(offset); 1279 1280 // If this section requires special handling, and if there are 1281 // relocs that aply to it, then we must do the special handling 1282 // before we apply the relocs. 1283 if (os != NULL && offset == -1 && reloc_shndx != 0) 1284 this->set_relocs_must_follow_section_writes(); 1285 } 1286 1287 // Layout an input .note.gnu.property section. 1288 1289 // This note section has an *extremely* non-standard layout. 1290 // The gABI spec says that ELF-64 files should have 8-byte fields and 1291 // 8-byte alignment in the note section, but the Gnu tools generally 1292 // use 4-byte fields and 4-byte alignment (see the comment for 1293 // Layout::create_note). This section uses 4-byte fields (i.e., 1294 // namesz, descsz, and type are always 4 bytes), the name field is 1295 // padded to a multiple of 4 bytes, but the desc field is padded 1296 // to a multiple of 4 or 8 bytes, depending on the ELF class. 1297 // The individual properties within the desc field always use 1298 // 4-byte pr_type and pr_datasz fields, but pr_data is padded to 1299 // a multiple of 4 or 8 bytes, depending on the ELF class. 1300 1301 template<int size, bool big_endian> 1302 void 1303 Sized_relobj_file<size, big_endian>::layout_gnu_property_section( 1304 Layout* layout, 1305 unsigned int shndx) 1306 { 1307 section_size_type contents_len; 1308 const unsigned char* pcontents = this->section_contents(shndx, 1309 &contents_len, 1310 false); 1311 const unsigned char* pcontents_end = pcontents + contents_len; 1312 1313 // Loop over all the notes in this section. 1314 while (pcontents < pcontents_end) 1315 { 1316 if (pcontents + 16 > pcontents_end) 1317 { 1318 gold_warning(_("%s: corrupt .note.gnu.property section " 1319 "(note too short)"), 1320 this->name().c_str()); 1321 return; 1322 } 1323 1324 size_t namesz = elfcpp::Swap<32, big_endian>::readval(pcontents); 1325 size_t descsz = elfcpp::Swap<32, big_endian>::readval(pcontents + 4); 1326 unsigned int ntype = elfcpp::Swap<32, big_endian>::readval(pcontents + 8); 1327 const unsigned char* pname = pcontents + 12; 1328 1329 if (namesz != 4 || strcmp(reinterpret_cast<const char*>(pname), "GNU") != 0) 1330 { 1331 gold_warning(_("%s: corrupt .note.gnu.property section " 1332 "(name is not 'GNU')"), 1333 this->name().c_str()); 1334 return; 1335 } 1336 1337 if (ntype != elfcpp::NT_GNU_PROPERTY_TYPE_0) 1338 { 1339 gold_warning(_("%s: unsupported note type %d " 1340 "in .note.gnu.property section"), 1341 this->name().c_str(), ntype); 1342 return; 1343 } 1344 1345 size_t aligned_namesz = align_address(namesz, 4); 1346 const unsigned char* pdesc = pname + aligned_namesz; 1347 1348 if (pdesc + descsz > pcontents + contents_len) 1349 { 1350 gold_warning(_("%s: corrupt .note.gnu.property section"), 1351 this->name().c_str()); 1352 return; 1353 } 1354 1355 const unsigned char* pprop = pdesc; 1356 1357 // Loop over the program properties in this note. 1358 while (pprop < pdesc + descsz) 1359 { 1360 if (pprop + 8 > pdesc + descsz) 1361 { 1362 gold_warning(_("%s: corrupt .note.gnu.property section"), 1363 this->name().c_str()); 1364 return; 1365 } 1366 unsigned int pr_type = elfcpp::Swap<32, big_endian>::readval(pprop); 1367 size_t pr_datasz = elfcpp::Swap<32, big_endian>::readval(pprop + 4); 1368 pprop += 8; 1369 if (pprop + pr_datasz > pdesc + descsz) 1370 { 1371 gold_warning(_("%s: corrupt .note.gnu.property section"), 1372 this->name().c_str()); 1373 return; 1374 } 1375 layout->layout_gnu_property(ntype, pr_type, pr_datasz, pprop, this); 1376 pprop += align_address(pr_datasz, size / 8); 1377 } 1378 1379 pcontents = pdesc + align_address(descsz, size / 8); 1380 } 1381 } 1382 1383 // This a copy of lto_section defined in GCC (lto-streamer.h) 1384 1385 struct lto_section 1386 { 1387 int16_t major_version; 1388 int16_t minor_version; 1389 unsigned char slim_object; 1390 1391 /* Flags is a private field that is not defined publicly. */ 1392 uint16_t flags; 1393 }; 1394 1395 // Lay out the input sections. We walk through the sections and check 1396 // whether they should be included in the link. If they should, we 1397 // pass them to the Layout object, which will return an output section 1398 // and an offset. 1399 // This function is called twice sometimes, two passes, when mapping 1400 // of input sections to output sections must be delayed. 1401 // This is true for the following : 1402 // * Garbage collection (--gc-sections): Some input sections will be 1403 // discarded and hence the assignment must wait until the second pass. 1404 // In the first pass, it is for setting up some sections as roots to 1405 // a work-list for --gc-sections and to do comdat processing. 1406 // * Identical Code Folding (--icf=<safe,all>): Some input sections 1407 // will be folded and hence the assignment must wait. 1408 // * Using plugins to map some sections to unique segments: Mapping 1409 // some sections to unique segments requires mapping them to unique 1410 // output sections too. This can be done via plugins now and this 1411 // information is not available in the first pass. 1412 1413 template<int size, bool big_endian> 1414 void 1415 Sized_relobj_file<size, big_endian>::do_layout(Symbol_table* symtab, 1416 Layout* layout, 1417 Read_symbols_data* sd) 1418 { 1419 const unsigned int unwind_section_type = 1420 parameters->target().unwind_section_type(); 1421 const unsigned int shnum = this->shnum(); 1422 1423 /* Should this function be called twice? */ 1424 bool is_two_pass = (parameters->options().gc_sections() 1425 || parameters->options().icf_enabled() 1426 || layout->is_unique_segment_for_sections_specified()); 1427 1428 /* Only one of is_pass_one and is_pass_two is true. Both are false when 1429 a two-pass approach is not needed. */ 1430 bool is_pass_one = false; 1431 bool is_pass_two = false; 1432 1433 Symbols_data* gc_sd = NULL; 1434 1435 /* Check if do_layout needs to be two-pass. If so, find out which pass 1436 should happen. In the first pass, the data in sd is saved to be used 1437 later in the second pass. */ 1438 if (is_two_pass) 1439 { 1440 gc_sd = this->get_symbols_data(); 1441 if (gc_sd == NULL) 1442 { 1443 gold_assert(sd != NULL); 1444 is_pass_one = true; 1445 } 1446 else 1447 { 1448 if (parameters->options().gc_sections()) 1449 gold_assert(symtab->gc()->is_worklist_ready()); 1450 if (parameters->options().icf_enabled()) 1451 gold_assert(symtab->icf()->is_icf_ready()); 1452 is_pass_two = true; 1453 } 1454 } 1455 1456 if (shnum == 0) 1457 return; 1458 1459 if (is_pass_one) 1460 { 1461 // During garbage collection save the symbols data to use it when 1462 // re-entering this function. 1463 gc_sd = new Symbols_data; 1464 this->copy_symbols_data(gc_sd, sd, This::shdr_size * shnum); 1465 this->set_symbols_data(gc_sd); 1466 } 1467 1468 const unsigned char* section_headers_data = NULL; 1469 section_size_type section_names_size; 1470 const unsigned char* symbols_data = NULL; 1471 section_size_type symbols_size; 1472 const unsigned char* symbol_names_data = NULL; 1473 section_size_type symbol_names_size; 1474 1475 if (is_two_pass) 1476 { 1477 section_headers_data = gc_sd->section_headers_data; 1478 section_names_size = gc_sd->section_names_size; 1479 symbols_data = gc_sd->symbols_data; 1480 symbols_size = gc_sd->symbols_size; 1481 symbol_names_data = gc_sd->symbol_names_data; 1482 symbol_names_size = gc_sd->symbol_names_size; 1483 } 1484 else 1485 { 1486 section_headers_data = sd->section_headers->data(); 1487 section_names_size = sd->section_names_size; 1488 if (sd->symbols != NULL) 1489 symbols_data = sd->symbols->data(); 1490 symbols_size = sd->symbols_size; 1491 if (sd->symbol_names != NULL) 1492 symbol_names_data = sd->symbol_names->data(); 1493 symbol_names_size = sd->symbol_names_size; 1494 } 1495 1496 // Get the section headers. 1497 const unsigned char* shdrs = section_headers_data; 1498 const unsigned char* pshdrs; 1499 1500 // Get the section names. 1501 const unsigned char* pnamesu = (is_two_pass 1502 ? gc_sd->section_names_data 1503 : sd->section_names->data()); 1504 1505 const char* pnames = reinterpret_cast<const char*>(pnamesu); 1506 1507 // If any input files have been claimed by plugins, we need to defer 1508 // actual layout until the replacement files have arrived. 1509 const bool should_defer_layout = 1510 (parameters->options().has_plugins() 1511 && parameters->options().plugins()->should_defer_layout()); 1512 unsigned int num_sections_to_defer = 0; 1513 1514 // For each section, record the index of the reloc section if any. 1515 // Use 0 to mean that there is no reloc section, -1U to mean that 1516 // there is more than one. 1517 std::vector<unsigned int> reloc_shndx(shnum, 0); 1518 std::vector<unsigned int> reloc_type(shnum, elfcpp::SHT_NULL); 1519 // Skip the first, dummy, section. 1520 pshdrs = shdrs + This::shdr_size; 1521 for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size) 1522 { 1523 typename This::Shdr shdr(pshdrs); 1524 1525 // Count the number of sections whose layout will be deferred. 1526 if (should_defer_layout && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC)) 1527 ++num_sections_to_defer; 1528 1529 unsigned int sh_type = shdr.get_sh_type(); 1530 if (sh_type == elfcpp::SHT_REL || sh_type == elfcpp::SHT_RELA) 1531 { 1532 unsigned int target_shndx = this->adjust_shndx(shdr.get_sh_info()); 1533 if (target_shndx == 0 || target_shndx >= shnum) 1534 { 1535 this->error(_("relocation section %u has bad info %u"), 1536 i, target_shndx); 1537 continue; 1538 } 1539 1540 if (reloc_shndx[target_shndx] != 0) 1541 reloc_shndx[target_shndx] = -1U; 1542 else 1543 { 1544 reloc_shndx[target_shndx] = i; 1545 reloc_type[target_shndx] = sh_type; 1546 } 1547 } 1548 } 1549 1550 Output_sections& out_sections(this->output_sections()); 1551 std::vector<Address>& out_section_offsets(this->section_offsets()); 1552 1553 if (!is_pass_two) 1554 { 1555 out_sections.resize(shnum); 1556 out_section_offsets.resize(shnum); 1557 } 1558 1559 // If we are only linking for symbols, then there is nothing else to 1560 // do here. 1561 if (this->input_file()->just_symbols()) 1562 { 1563 if (!is_pass_two) 1564 { 1565 delete sd->section_headers; 1566 sd->section_headers = NULL; 1567 delete sd->section_names; 1568 sd->section_names = NULL; 1569 } 1570 return; 1571 } 1572 1573 if (num_sections_to_defer > 0) 1574 { 1575 parameters->options().plugins()->add_deferred_layout_object(this); 1576 this->deferred_layout_.reserve(num_sections_to_defer); 1577 this->is_deferred_layout_ = true; 1578 } 1579 1580 // Whether we've seen a .note.GNU-stack section. 1581 bool seen_gnu_stack = false; 1582 // The flags of a .note.GNU-stack section. 1583 uint64_t gnu_stack_flags = 0; 1584 1585 // Keep track of which sections to omit. 1586 std::vector<bool> omit(shnum, false); 1587 1588 // Keep track of reloc sections when emitting relocations. 1589 const bool relocatable = parameters->options().relocatable(); 1590 const bool emit_relocs = (relocatable 1591 || parameters->options().emit_relocs()); 1592 std::vector<unsigned int> reloc_sections; 1593 1594 // Keep track of .eh_frame sections. 1595 std::vector<unsigned int> eh_frame_sections; 1596 1597 // Keep track of .debug_info and .debug_types sections. 1598 std::vector<unsigned int> debug_info_sections; 1599 std::vector<unsigned int> debug_types_sections; 1600 1601 // Skip the first, dummy, section. 1602 pshdrs = shdrs + This::shdr_size; 1603 for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size) 1604 { 1605 typename This::Shdr shdr(pshdrs); 1606 const unsigned int sh_name = shdr.get_sh_name(); 1607 unsigned int sh_type = shdr.get_sh_type(); 1608 1609 if (sh_name >= section_names_size) 1610 { 1611 this->error(_("bad section name offset for section %u: %lu"), 1612 i, static_cast<unsigned long>(sh_name)); 1613 return; 1614 } 1615 1616 const char* name = pnames + sh_name; 1617 1618 if (!is_pass_two) 1619 { 1620 if (this->handle_gnu_warning_section(name, i, symtab)) 1621 { 1622 if (!relocatable && !parameters->options().shared()) 1623 omit[i] = true; 1624 } 1625 1626 // The .note.GNU-stack section is special. It gives the 1627 // protection flags that this object file requires for the stack 1628 // in memory. 1629 if (strcmp(name, ".note.GNU-stack") == 0) 1630 { 1631 seen_gnu_stack = true; 1632 gnu_stack_flags |= shdr.get_sh_flags(); 1633 omit[i] = true; 1634 } 1635 1636 // The .note.GNU-split-stack section is also special. It 1637 // indicates that the object was compiled with 1638 // -fsplit-stack. 1639 if (this->handle_split_stack_section(name)) 1640 { 1641 if (!relocatable && !parameters->options().shared()) 1642 omit[i] = true; 1643 } 1644 1645 // Skip attributes section. 1646 if (parameters->target().is_attributes_section(name)) 1647 { 1648 omit[i] = true; 1649 } 1650 1651 // Handle .note.gnu.property sections. 1652 if (sh_type == elfcpp::SHT_NOTE 1653 && strcmp(name, ".note.gnu.property") == 0) 1654 { 1655 this->layout_gnu_property_section(layout, i); 1656 omit[i] = true; 1657 } 1658 1659 bool discard = omit[i]; 1660 if (!discard) 1661 { 1662 if (sh_type == elfcpp::SHT_GROUP) 1663 { 1664 if (!this->include_section_group(symtab, layout, i, name, 1665 shdrs, pnames, 1666 section_names_size, 1667 &omit)) 1668 discard = true; 1669 } 1670 else if ((shdr.get_sh_flags() & elfcpp::SHF_GROUP) == 0 1671 && Layout::is_linkonce(name)) 1672 { 1673 if (!this->include_linkonce_section(layout, i, name, shdr)) 1674 discard = true; 1675 } 1676 } 1677 1678 // Add the section to the incremental inputs layout. 1679 Incremental_inputs* incremental_inputs = layout->incremental_inputs(); 1680 if (incremental_inputs != NULL 1681 && !discard 1682 && can_incremental_update(sh_type)) 1683 { 1684 off_t sh_size = shdr.get_sh_size(); 1685 section_size_type uncompressed_size; 1686 if (this->section_is_compressed(i, &uncompressed_size)) 1687 sh_size = uncompressed_size; 1688 incremental_inputs->report_input_section(this, i, name, sh_size); 1689 } 1690 1691 if (discard) 1692 { 1693 // Do not include this section in the link. 1694 out_sections[i] = NULL; 1695 out_section_offsets[i] = invalid_address; 1696 continue; 1697 } 1698 } 1699 1700 if (is_pass_one && parameters->options().gc_sections()) 1701 { 1702 if (this->is_section_name_included(name) 1703 || layout->keep_input_section (this, name) 1704 || sh_type == elfcpp::SHT_INIT_ARRAY 1705 || sh_type == elfcpp::SHT_FINI_ARRAY) 1706 { 1707 symtab->gc()->worklist().push_back(Section_id(this, i)); 1708 } 1709 // If the section name XXX can be represented as a C identifier 1710 // it cannot be discarded if there are references to 1711 // __start_XXX and __stop_XXX symbols. These need to be 1712 // specially handled. 1713 if (is_cident(name)) 1714 { 1715 symtab->gc()->add_cident_section(name, Section_id(this, i)); 1716 } 1717 } 1718 1719 // When doing a relocatable link we are going to copy input 1720 // reloc sections into the output. We only want to copy the 1721 // ones associated with sections which are not being discarded. 1722 // However, we don't know that yet for all sections. So save 1723 // reloc sections and process them later. Garbage collection is 1724 // not triggered when relocatable code is desired. 1725 if (emit_relocs 1726 && (sh_type == elfcpp::SHT_REL 1727 || sh_type == elfcpp::SHT_RELA)) 1728 { 1729 reloc_sections.push_back(i); 1730 continue; 1731 } 1732 1733 if (relocatable && sh_type == elfcpp::SHT_GROUP) 1734 continue; 1735 1736 // The .eh_frame section is special. It holds exception frame 1737 // information that we need to read in order to generate the 1738 // exception frame header. We process these after all the other 1739 // sections so that the exception frame reader can reliably 1740 // determine which sections are being discarded, and discard the 1741 // corresponding information. 1742 if (this->check_eh_frame_flags(&shdr) 1743 && strcmp(name, ".eh_frame") == 0) 1744 { 1745 // If the target has a special unwind section type, let's 1746 // canonicalize it here. 1747 sh_type = unwind_section_type; 1748 if (!relocatable) 1749 { 1750 if (is_pass_one) 1751 { 1752 if (this->is_deferred_layout()) 1753 out_sections[i] = reinterpret_cast<Output_section*>(2); 1754 else 1755 out_sections[i] = reinterpret_cast<Output_section*>(1); 1756 out_section_offsets[i] = invalid_address; 1757 } 1758 else if (this->is_deferred_layout()) 1759 { 1760 out_sections[i] = reinterpret_cast<Output_section*>(2); 1761 out_section_offsets[i] = invalid_address; 1762 this->deferred_layout_.push_back( 1763 Deferred_layout(i, name, sh_type, pshdrs, 1764 reloc_shndx[i], reloc_type[i])); 1765 } 1766 else 1767 eh_frame_sections.push_back(i); 1768 continue; 1769 } 1770 } 1771 1772 if (is_pass_two && parameters->options().gc_sections()) 1773 { 1774 // This is executed during the second pass of garbage 1775 // collection. do_layout has been called before and some 1776 // sections have been already discarded. Simply ignore 1777 // such sections this time around. 1778 if (out_sections[i] == NULL) 1779 { 1780 gold_assert(out_section_offsets[i] == invalid_address); 1781 continue; 1782 } 1783 if (((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0) 1784 && symtab->gc()->is_section_garbage(this, i)) 1785 { 1786 if (parameters->options().print_gc_sections()) 1787 gold_info(_("%s: removing unused section from '%s'" 1788 " in file '%s'"), 1789 program_name, this->section_name(i).c_str(), 1790 this->name().c_str()); 1791 out_sections[i] = NULL; 1792 out_section_offsets[i] = invalid_address; 1793 continue; 1794 } 1795 } 1796 1797 if (is_pass_two && parameters->options().icf_enabled()) 1798 { 1799 if (out_sections[i] == NULL) 1800 { 1801 gold_assert(out_section_offsets[i] == invalid_address); 1802 continue; 1803 } 1804 if (((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0) 1805 && symtab->icf()->is_section_folded(this, i)) 1806 { 1807 if (parameters->options().print_icf_sections()) 1808 { 1809 Section_id folded = 1810 symtab->icf()->get_folded_section(this, i); 1811 Relobj* folded_obj = 1812 reinterpret_cast<Relobj*>(folded.first); 1813 gold_info(_("%s: ICF folding section '%s' in file '%s' " 1814 "into '%s' in file '%s'"), 1815 program_name, this->section_name(i).c_str(), 1816 this->name().c_str(), 1817 folded_obj->section_name(folded.second).c_str(), 1818 folded_obj->name().c_str()); 1819 } 1820 out_sections[i] = NULL; 1821 out_section_offsets[i] = invalid_address; 1822 continue; 1823 } 1824 } 1825 1826 // Defer layout here if input files are claimed by plugins. When gc 1827 // is turned on this function is called twice; we only want to do this 1828 // on the first pass. 1829 if (!is_pass_two 1830 && this->is_deferred_layout() 1831 && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC)) 1832 { 1833 this->deferred_layout_.push_back(Deferred_layout(i, name, sh_type, 1834 pshdrs, 1835 reloc_shndx[i], 1836 reloc_type[i])); 1837 // Put dummy values here; real values will be supplied by 1838 // do_layout_deferred_sections. 1839 out_sections[i] = reinterpret_cast<Output_section*>(2); 1840 out_section_offsets[i] = invalid_address; 1841 continue; 1842 } 1843 1844 // During gc_pass_two if a section that was previously deferred is 1845 // found, do not layout the section as layout_deferred_sections will 1846 // do it later from gold.cc. 1847 if (is_pass_two 1848 && (out_sections[i] == reinterpret_cast<Output_section*>(2))) 1849 continue; 1850 1851 if (is_pass_one) 1852 { 1853 // This is during garbage collection. The out_sections are 1854 // assigned in the second call to this function. 1855 out_sections[i] = reinterpret_cast<Output_section*>(1); 1856 out_section_offsets[i] = invalid_address; 1857 } 1858 else 1859 { 1860 // When garbage collection is switched on the actual layout 1861 // only happens in the second call. 1862 this->layout_section(layout, i, name, shdr, sh_type, reloc_shndx[i], 1863 reloc_type[i]); 1864 1865 // When generating a .gdb_index section, we do additional 1866 // processing of .debug_info and .debug_types sections after all 1867 // the other sections for the same reason as above. 1868 if (!relocatable 1869 && parameters->options().gdb_index() 1870 && !(shdr.get_sh_flags() & elfcpp::SHF_ALLOC)) 1871 { 1872 if (strcmp(name, ".debug_info") == 0 1873 || strcmp(name, ".zdebug_info") == 0) 1874 debug_info_sections.push_back(i); 1875 else if (strcmp(name, ".debug_types") == 0 1876 || strcmp(name, ".zdebug_types") == 0) 1877 debug_types_sections.push_back(i); 1878 } 1879 } 1880 1881 /* GCC uses .gnu.lto_.lto.<some_hash> as a LTO bytecode information 1882 section. */ 1883 const char *lto_section_name = ".gnu.lto_.lto."; 1884 if (strncmp (name, lto_section_name, strlen (lto_section_name)) == 0) 1885 { 1886 section_size_type contents_len; 1887 const unsigned char* pcontents 1888 = this->section_contents(i, &contents_len, false); 1889 if (contents_len >= sizeof(lto_section)) 1890 { 1891 const lto_section* lsection 1892 = reinterpret_cast<const lto_section*>(pcontents); 1893 if (lsection->slim_object) 1894 layout->set_lto_slim_object(); 1895 } 1896 } 1897 } 1898 1899 if (!is_pass_two) 1900 { 1901 layout->merge_gnu_properties(this); 1902 layout->layout_gnu_stack(seen_gnu_stack, gnu_stack_flags, this); 1903 } 1904 1905 // Handle the .eh_frame sections after the other sections. 1906 gold_assert(!is_pass_one || eh_frame_sections.empty()); 1907 for (std::vector<unsigned int>::const_iterator p = eh_frame_sections.begin(); 1908 p != eh_frame_sections.end(); 1909 ++p) 1910 { 1911 unsigned int i = *p; 1912 const unsigned char* pshdr; 1913 pshdr = section_headers_data + i * This::shdr_size; 1914 typename This::Shdr shdr(pshdr); 1915 1916 this->layout_eh_frame_section(layout, 1917 symbols_data, 1918 symbols_size, 1919 symbol_names_data, 1920 symbol_names_size, 1921 i, 1922 shdr, 1923 reloc_shndx[i], 1924 reloc_type[i]); 1925 } 1926 1927 // When doing a relocatable link handle the reloc sections at the 1928 // end. Garbage collection and Identical Code Folding is not 1929 // turned on for relocatable code. 1930 if (emit_relocs) 1931 this->size_relocatable_relocs(); 1932 1933 gold_assert(!is_two_pass || reloc_sections.empty()); 1934 1935 for (std::vector<unsigned int>::const_iterator p = reloc_sections.begin(); 1936 p != reloc_sections.end(); 1937 ++p) 1938 { 1939 unsigned int i = *p; 1940 const unsigned char* pshdr; 1941 pshdr = section_headers_data + i * This::shdr_size; 1942 typename This::Shdr shdr(pshdr); 1943 1944 unsigned int data_shndx = this->adjust_shndx(shdr.get_sh_info()); 1945 if (data_shndx >= shnum) 1946 { 1947 // We already warned about this above. 1948 continue; 1949 } 1950 1951 Output_section* data_section = out_sections[data_shndx]; 1952 if (data_section == reinterpret_cast<Output_section*>(2)) 1953 { 1954 if (is_pass_two) 1955 continue; 1956 // The layout for the data section was deferred, so we need 1957 // to defer the relocation section, too. 1958 const char* name = pnames + shdr.get_sh_name(); 1959 this->deferred_layout_relocs_.push_back( 1960 Deferred_layout(i, name, shdr.get_sh_type(), pshdr, 0, 1961 elfcpp::SHT_NULL)); 1962 out_sections[i] = reinterpret_cast<Output_section*>(2); 1963 out_section_offsets[i] = invalid_address; 1964 continue; 1965 } 1966 if (data_section == NULL) 1967 { 1968 out_sections[i] = NULL; 1969 out_section_offsets[i] = invalid_address; 1970 continue; 1971 } 1972 1973 Relocatable_relocs* rr = new Relocatable_relocs(); 1974 this->set_relocatable_relocs(i, rr); 1975 1976 Output_section* os = layout->layout_reloc(this, i, shdr, data_section, 1977 rr); 1978 out_sections[i] = os; 1979 out_section_offsets[i] = invalid_address; 1980 } 1981 1982 // When building a .gdb_index section, scan the .debug_info and 1983 // .debug_types sections. 1984 gold_assert(!is_pass_one 1985 || (debug_info_sections.empty() && debug_types_sections.empty())); 1986 for (std::vector<unsigned int>::const_iterator p 1987 = debug_info_sections.begin(); 1988 p != debug_info_sections.end(); 1989 ++p) 1990 { 1991 unsigned int i = *p; 1992 layout->add_to_gdb_index(false, this, symbols_data, symbols_size, 1993 i, reloc_shndx[i], reloc_type[i]); 1994 } 1995 for (std::vector<unsigned int>::const_iterator p 1996 = debug_types_sections.begin(); 1997 p != debug_types_sections.end(); 1998 ++p) 1999 { 2000 unsigned int i = *p; 2001 layout->add_to_gdb_index(true, this, symbols_data, symbols_size, 2002 i, reloc_shndx[i], reloc_type[i]); 2003 } 2004 2005 if (is_pass_two) 2006 { 2007 delete[] gc_sd->section_headers_data; 2008 delete[] gc_sd->section_names_data; 2009 delete[] gc_sd->symbols_data; 2010 delete[] gc_sd->symbol_names_data; 2011 this->set_symbols_data(NULL); 2012 } 2013 else 2014 { 2015 delete sd->section_headers; 2016 sd->section_headers = NULL; 2017 delete sd->section_names; 2018 sd->section_names = NULL; 2019 } 2020 } 2021 2022 // Layout sections whose layout was deferred while waiting for 2023 // input files from a plugin. 2024 2025 template<int size, bool big_endian> 2026 void 2027 Sized_relobj_file<size, big_endian>::do_layout_deferred_sections(Layout* layout) 2028 { 2029 typename std::vector<Deferred_layout>::iterator deferred; 2030 2031 for (deferred = this->deferred_layout_.begin(); 2032 deferred != this->deferred_layout_.end(); 2033 ++deferred) 2034 { 2035 typename This::Shdr shdr(deferred->shdr_data_); 2036 2037 if (!parameters->options().relocatable() 2038 && deferred->name_ == ".eh_frame" 2039 && this->check_eh_frame_flags(&shdr)) 2040 { 2041 // Checking is_section_included is not reliable for 2042 // .eh_frame sections, because they do not have an output 2043 // section. This is not a problem normally because we call 2044 // layout_eh_frame_section unconditionally, but when 2045 // deferring sections that is not true. We don't want to 2046 // keep all .eh_frame sections because that will cause us to 2047 // keep all sections that they refer to, which is the wrong 2048 // way around. Instead, the eh_frame code will discard 2049 // .eh_frame sections that refer to discarded sections. 2050 2051 // Reading the symbols again here may be slow. 2052 Read_symbols_data sd; 2053 this->base_read_symbols(&sd); 2054 this->layout_eh_frame_section(layout, 2055 sd.symbols->data(), 2056 sd.symbols_size, 2057 sd.symbol_names->data(), 2058 sd.symbol_names_size, 2059 deferred->shndx_, 2060 shdr, 2061 deferred->reloc_shndx_, 2062 deferred->reloc_type_); 2063 continue; 2064 } 2065 2066 // If the section is not included, it is because the garbage collector 2067 // decided it is not needed. Avoid reverting that decision. 2068 if (!this->is_section_included(deferred->shndx_)) 2069 continue; 2070 2071 this->layout_section(layout, deferred->shndx_, deferred->name_.c_str(), 2072 shdr, shdr.get_sh_type(), deferred->reloc_shndx_, 2073 deferred->reloc_type_); 2074 } 2075 2076 this->deferred_layout_.clear(); 2077 2078 // Now handle the deferred relocation sections. 2079 2080 Output_sections& out_sections(this->output_sections()); 2081 std::vector<Address>& out_section_offsets(this->section_offsets()); 2082 2083 for (deferred = this->deferred_layout_relocs_.begin(); 2084 deferred != this->deferred_layout_relocs_.end(); 2085 ++deferred) 2086 { 2087 unsigned int shndx = deferred->shndx_; 2088 typename This::Shdr shdr(deferred->shdr_data_); 2089 unsigned int data_shndx = this->adjust_shndx(shdr.get_sh_info()); 2090 2091 Output_section* data_section = out_sections[data_shndx]; 2092 if (data_section == NULL) 2093 { 2094 out_sections[shndx] = NULL; 2095 out_section_offsets[shndx] = invalid_address; 2096 continue; 2097 } 2098 2099 Relocatable_relocs* rr = new Relocatable_relocs(); 2100 this->set_relocatable_relocs(shndx, rr); 2101 2102 Output_section* os = layout->layout_reloc(this, shndx, shdr, 2103 data_section, rr); 2104 out_sections[shndx] = os; 2105 out_section_offsets[shndx] = invalid_address; 2106 } 2107 } 2108 2109 // Add the symbols to the symbol table. 2110 2111 template<int size, bool big_endian> 2112 void 2113 Sized_relobj_file<size, big_endian>::do_add_symbols(Symbol_table* symtab, 2114 Read_symbols_data* sd, 2115 Layout* layout) 2116 { 2117 if (sd->symbols == NULL) 2118 { 2119 gold_assert(sd->symbol_names == NULL); 2120 return; 2121 } 2122 2123 const int sym_size = This::sym_size; 2124 size_t symcount = ((sd->symbols_size - sd->external_symbols_offset) 2125 / sym_size); 2126 if (symcount * sym_size != sd->symbols_size - sd->external_symbols_offset) 2127 { 2128 this->error(_("size of symbols is not multiple of symbol size")); 2129 return; 2130 } 2131 2132 this->symbols_.resize(symcount); 2133 2134 if (!parameters->options().relocatable() 2135 && layout->is_lto_slim_object ()) 2136 gold_info(_("%s: plugin needed to handle lto object"), 2137 this->name().c_str()); 2138 2139 const char* sym_names = 2140 reinterpret_cast<const char*>(sd->symbol_names->data()); 2141 symtab->add_from_relobj(this, 2142 sd->symbols->data() + sd->external_symbols_offset, 2143 symcount, this->local_symbol_count_, 2144 sym_names, sd->symbol_names_size, 2145 &this->symbols_, 2146 &this->defined_count_); 2147 2148 delete sd->symbols; 2149 sd->symbols = NULL; 2150 delete sd->symbol_names; 2151 sd->symbol_names = NULL; 2152 } 2153 2154 // Find out if this object, that is a member of a lib group, should be included 2155 // in the link. We check every symbol defined by this object. If the symbol 2156 // table has a strong undefined reference to that symbol, we have to include 2157 // the object. 2158 2159 template<int size, bool big_endian> 2160 Archive::Should_include 2161 Sized_relobj_file<size, big_endian>::do_should_include_member( 2162 Symbol_table* symtab, 2163 Layout* layout, 2164 Read_symbols_data* sd, 2165 std::string* why) 2166 { 2167 char* tmpbuf = NULL; 2168 size_t tmpbuflen = 0; 2169 const char* sym_names = 2170 reinterpret_cast<const char*>(sd->symbol_names->data()); 2171 const unsigned char* syms = 2172 sd->symbols->data() + sd->external_symbols_offset; 2173 const int sym_size = elfcpp::Elf_sizes<size>::sym_size; 2174 size_t symcount = ((sd->symbols_size - sd->external_symbols_offset) 2175 / sym_size); 2176 2177 const unsigned char* p = syms; 2178 2179 for (size_t i = 0; i < symcount; ++i, p += sym_size) 2180 { 2181 elfcpp::Sym<size, big_endian> sym(p); 2182 unsigned int st_shndx = sym.get_st_shndx(); 2183 if (st_shndx == elfcpp::SHN_UNDEF) 2184 continue; 2185 2186 unsigned int st_name = sym.get_st_name(); 2187 const char* name = sym_names + st_name; 2188 Symbol* symbol; 2189 Archive::Should_include t = Archive::should_include_member(symtab, 2190 layout, 2191 name, 2192 &symbol, why, 2193 &tmpbuf, 2194 &tmpbuflen); 2195 if (t == Archive::SHOULD_INCLUDE_YES) 2196 { 2197 if (tmpbuf != NULL) 2198 free(tmpbuf); 2199 return t; 2200 } 2201 } 2202 if (tmpbuf != NULL) 2203 free(tmpbuf); 2204 return Archive::SHOULD_INCLUDE_UNKNOWN; 2205 } 2206 2207 // Iterate over global defined symbols, calling a visitor class V for each. 2208 2209 template<int size, bool big_endian> 2210 void 2211 Sized_relobj_file<size, big_endian>::do_for_all_global_symbols( 2212 Read_symbols_data* sd, 2213 Library_base::Symbol_visitor_base* v) 2214 { 2215 const char* sym_names = 2216 reinterpret_cast<const char*>(sd->symbol_names->data()); 2217 const unsigned char* syms = 2218 sd->symbols->data() + sd->external_symbols_offset; 2219 const int sym_size = elfcpp::Elf_sizes<size>::sym_size; 2220 size_t symcount = ((sd->symbols_size - sd->external_symbols_offset) 2221 / sym_size); 2222 const unsigned char* p = syms; 2223 2224 for (size_t i = 0; i < symcount; ++i, p += sym_size) 2225 { 2226 elfcpp::Sym<size, big_endian> sym(p); 2227 if (sym.get_st_shndx() != elfcpp::SHN_UNDEF) 2228 v->visit(sym_names + sym.get_st_name()); 2229 } 2230 } 2231 2232 // Return whether the local symbol SYMNDX has a PLT offset. 2233 2234 template<int size, bool big_endian> 2235 bool 2236 Sized_relobj_file<size, big_endian>::local_has_plt_offset( 2237 unsigned int symndx) const 2238 { 2239 typename Local_plt_offsets::const_iterator p = 2240 this->local_plt_offsets_.find(symndx); 2241 return p != this->local_plt_offsets_.end(); 2242 } 2243 2244 // Get the PLT offset of a local symbol. 2245 2246 template<int size, bool big_endian> 2247 unsigned int 2248 Sized_relobj_file<size, big_endian>::do_local_plt_offset( 2249 unsigned int symndx) const 2250 { 2251 typename Local_plt_offsets::const_iterator p = 2252 this->local_plt_offsets_.find(symndx); 2253 gold_assert(p != this->local_plt_offsets_.end()); 2254 return p->second; 2255 } 2256 2257 // Set the PLT offset of a local symbol. 2258 2259 template<int size, bool big_endian> 2260 void 2261 Sized_relobj_file<size, big_endian>::set_local_plt_offset( 2262 unsigned int symndx, unsigned int plt_offset) 2263 { 2264 std::pair<typename Local_plt_offsets::iterator, bool> ins = 2265 this->local_plt_offsets_.insert(std::make_pair(symndx, plt_offset)); 2266 gold_assert(ins.second); 2267 } 2268 2269 // First pass over the local symbols. Here we add their names to 2270 // *POOL and *DYNPOOL, and we store the symbol value in 2271 // THIS->LOCAL_VALUES_. This function is always called from a 2272 // singleton thread. This is followed by a call to 2273 // finalize_local_symbols. 2274 2275 template<int size, bool big_endian> 2276 void 2277 Sized_relobj_file<size, big_endian>::do_count_local_symbols(Stringpool* pool, 2278 Stringpool* dynpool) 2279 { 2280 gold_assert(this->symtab_shndx_ != -1U); 2281 if (this->symtab_shndx_ == 0) 2282 { 2283 // This object has no symbols. Weird but legal. 2284 return; 2285 } 2286 2287 // Read the symbol table section header. 2288 const unsigned int symtab_shndx = this->symtab_shndx_; 2289 typename This::Shdr symtabshdr(this, 2290 this->elf_file_.section_header(symtab_shndx)); 2291 gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB); 2292 2293 // Read the local symbols. 2294 const int sym_size = This::sym_size; 2295 const unsigned int loccount = this->local_symbol_count_; 2296 gold_assert(loccount == symtabshdr.get_sh_info()); 2297 off_t locsize = loccount * sym_size; 2298 const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(), 2299 locsize, true, true); 2300 2301 // Read the symbol names. 2302 const unsigned int strtab_shndx = 2303 this->adjust_shndx(symtabshdr.get_sh_link()); 2304 section_size_type strtab_size; 2305 const unsigned char* pnamesu = this->section_contents(strtab_shndx, 2306 &strtab_size, 2307 true); 2308 const char* pnames = reinterpret_cast<const char*>(pnamesu); 2309 2310 // Loop over the local symbols. 2311 2312 const Output_sections& out_sections(this->output_sections()); 2313 std::vector<Address>& out_section_offsets(this->section_offsets()); 2314 unsigned int shnum = this->shnum(); 2315 unsigned int count = 0; 2316 unsigned int dyncount = 0; 2317 // Skip the first, dummy, symbol. 2318 psyms += sym_size; 2319 bool strip_all = parameters->options().strip_all(); 2320 bool discard_all = parameters->options().discard_all(); 2321 bool discard_locals = parameters->options().discard_locals(); 2322 bool discard_sec_merge = parameters->options().discard_sec_merge(); 2323 for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size) 2324 { 2325 elfcpp::Sym<size, big_endian> sym(psyms); 2326 2327 Symbol_value<size>& lv(this->local_values_[i]); 2328 2329 bool is_ordinary; 2330 unsigned int shndx = this->adjust_sym_shndx(i, sym.get_st_shndx(), 2331 &is_ordinary); 2332 lv.set_input_shndx(shndx, is_ordinary); 2333 2334 if (sym.get_st_type() == elfcpp::STT_SECTION) 2335 lv.set_is_section_symbol(); 2336 else if (sym.get_st_type() == elfcpp::STT_TLS) 2337 lv.set_is_tls_symbol(); 2338 else if (sym.get_st_type() == elfcpp::STT_GNU_IFUNC) 2339 lv.set_is_ifunc_symbol(); 2340 2341 // Save the input symbol value for use in do_finalize_local_symbols(). 2342 lv.set_input_value(sym.get_st_value()); 2343 2344 // Decide whether this symbol should go into the output file. 2345 2346 if (is_ordinary 2347 && shndx < shnum 2348 && (out_sections[shndx] == NULL 2349 || (out_sections[shndx]->order() == ORDER_EHFRAME 2350 && out_section_offsets[shndx] == invalid_address))) 2351 { 2352 // This is either a discarded section or an optimized .eh_frame 2353 // section. 2354 lv.set_no_output_symtab_entry(); 2355 gold_assert(!lv.needs_output_dynsym_entry()); 2356 continue; 2357 } 2358 2359 if (sym.get_st_type() == elfcpp::STT_SECTION 2360 || !this->adjust_local_symbol(&lv)) 2361 { 2362 lv.set_no_output_symtab_entry(); 2363 gold_assert(!lv.needs_output_dynsym_entry()); 2364 continue; 2365 } 2366 2367 if (sym.get_st_name() >= strtab_size) 2368 { 2369 this->error(_("local symbol %u section name out of range: %u >= %u"), 2370 i, sym.get_st_name(), 2371 static_cast<unsigned int>(strtab_size)); 2372 lv.set_no_output_symtab_entry(); 2373 continue; 2374 } 2375 2376 const char* name = pnames + sym.get_st_name(); 2377 2378 // If needed, add the symbol to the dynamic symbol table string pool. 2379 if (lv.needs_output_dynsym_entry()) 2380 { 2381 dynpool->add(name, true, NULL); 2382 ++dyncount; 2383 } 2384 2385 if (strip_all 2386 || (discard_all && lv.may_be_discarded_from_output_symtab())) 2387 { 2388 lv.set_no_output_symtab_entry(); 2389 continue; 2390 } 2391 2392 // By default, discard temporary local symbols in merge sections. 2393 // If --discard-locals option is used, discard all temporary local 2394 // symbols. These symbols start with system-specific local label 2395 // prefixes, typically .L for ELF system. We want to be compatible 2396 // with GNU ld so here we essentially use the same check in 2397 // bfd_is_local_label(). The code is different because we already 2398 // know that: 2399 // 2400 // - the symbol is local and thus cannot have global or weak binding. 2401 // - the symbol is not a section symbol. 2402 // - the symbol has a name. 2403 // 2404 // We do not discard a symbol if it needs a dynamic symbol entry. 2405 if ((discard_locals 2406 || (discard_sec_merge 2407 && is_ordinary 2408 && out_section_offsets[shndx] == invalid_address)) 2409 && sym.get_st_type() != elfcpp::STT_FILE 2410 && !lv.needs_output_dynsym_entry() 2411 && lv.may_be_discarded_from_output_symtab() 2412 && parameters->target().is_local_label_name(name)) 2413 { 2414 lv.set_no_output_symtab_entry(); 2415 continue; 2416 } 2417 2418 // Discard the local symbol if -retain_symbols_file is specified 2419 // and the local symbol is not in that file. 2420 if (!parameters->options().should_retain_symbol(name)) 2421 { 2422 lv.set_no_output_symtab_entry(); 2423 continue; 2424 } 2425 2426 // Add the symbol to the symbol table string pool. 2427 pool->add(name, true, NULL); 2428 ++count; 2429 } 2430 2431 this->output_local_symbol_count_ = count; 2432 this->output_local_dynsym_count_ = dyncount; 2433 } 2434 2435 // Compute the final value of a local symbol. 2436 2437 template<int size, bool big_endian> 2438 typename Sized_relobj_file<size, big_endian>::Compute_final_local_value_status 2439 Sized_relobj_file<size, big_endian>::compute_final_local_value_internal( 2440 unsigned int r_sym, 2441 const Symbol_value<size>* lv_in, 2442 Symbol_value<size>* lv_out, 2443 bool relocatable, 2444 const Output_sections& out_sections, 2445 const std::vector<Address>& out_offsets, 2446 const Symbol_table* symtab) 2447 { 2448 // We are going to overwrite *LV_OUT, if it has a merged symbol value, 2449 // we may have a memory leak. 2450 gold_assert(lv_out->has_output_value()); 2451 2452 bool is_ordinary; 2453 unsigned int shndx = lv_in->input_shndx(&is_ordinary); 2454 2455 // Set the output symbol value. 2456 2457 if (!is_ordinary) 2458 { 2459 if (shndx == elfcpp::SHN_ABS || Symbol::is_common_shndx(shndx)) 2460 lv_out->set_output_value(lv_in->input_value()); 2461 else 2462 { 2463 this->error(_("unknown section index %u for local symbol %u"), 2464 shndx, r_sym); 2465 lv_out->set_output_value(0); 2466 return This::CFLV_ERROR; 2467 } 2468 } 2469 else 2470 { 2471 if (shndx >= this->shnum()) 2472 { 2473 this->error(_("local symbol %u section index %u out of range"), 2474 r_sym, shndx); 2475 lv_out->set_output_value(0); 2476 return This::CFLV_ERROR; 2477 } 2478 2479 Output_section* os = out_sections[shndx]; 2480 Address secoffset = out_offsets[shndx]; 2481 if (symtab->is_section_folded(this, shndx)) 2482 { 2483 gold_assert(os == NULL && secoffset == invalid_address); 2484 // Get the os of the section it is folded onto. 2485 Section_id folded = symtab->icf()->get_folded_section(this, 2486 shndx); 2487 gold_assert(folded.first != NULL); 2488 Sized_relobj_file<size, big_endian>* folded_obj = reinterpret_cast 2489 <Sized_relobj_file<size, big_endian>*>(folded.first); 2490 os = folded_obj->output_section(folded.second); 2491 gold_assert(os != NULL); 2492 secoffset = folded_obj->get_output_section_offset(folded.second); 2493 2494 // This could be a relaxed input section. 2495 if (secoffset == invalid_address) 2496 { 2497 const Output_relaxed_input_section* relaxed_section = 2498 os->find_relaxed_input_section(folded_obj, folded.second); 2499 gold_assert(relaxed_section != NULL); 2500 secoffset = relaxed_section->address() - os->address(); 2501 } 2502 } 2503 2504 if (os == NULL) 2505 { 2506 // This local symbol belongs to a section we are discarding. 2507 // In some cases when applying relocations later, we will 2508 // attempt to match it to the corresponding kept section, 2509 // so we leave the input value unchanged here. 2510 return This::CFLV_DISCARDED; 2511 } 2512 else if (secoffset == invalid_address) 2513 { 2514 uint64_t start; 2515 2516 // This is a SHF_MERGE section or one which otherwise 2517 // requires special handling. 2518 if (os->order() == ORDER_EHFRAME) 2519 { 2520 // This local symbol belongs to a discarded or optimized 2521 // .eh_frame section. Just treat it like the case in which 2522 // os == NULL above. 2523 gold_assert(this->has_eh_frame_); 2524 return This::CFLV_DISCARDED; 2525 } 2526 else if (!lv_in->is_section_symbol()) 2527 { 2528 // This is not a section symbol. We can determine 2529 // the final value now. 2530 uint64_t value = 2531 os->output_address(this, shndx, lv_in->input_value()); 2532 if (relocatable) 2533 value -= os->address(); 2534 lv_out->set_output_value(value); 2535 } 2536 else if (!os->find_starting_output_address(this, shndx, &start)) 2537 { 2538 // This is a section symbol, but apparently not one in a 2539 // merged section. First check to see if this is a relaxed 2540 // input section. If so, use its address. Otherwise just 2541 // use the start of the output section. This happens with 2542 // relocatable links when the input object has section 2543 // symbols for arbitrary non-merge sections. 2544 const Output_section_data* posd = 2545 os->find_relaxed_input_section(this, shndx); 2546 if (posd != NULL) 2547 { 2548 uint64_t value = posd->address(); 2549 if (relocatable) 2550 value -= os->address(); 2551 lv_out->set_output_value(value); 2552 } 2553 else 2554 lv_out->set_output_value(os->address()); 2555 } 2556 else 2557 { 2558 // We have to consider the addend to determine the 2559 // value to use in a relocation. START is the start 2560 // of this input section. If we are doing a relocatable 2561 // link, use offset from start output section instead of 2562 // address. 2563 Address adjusted_start = 2564 relocatable ? start - os->address() : start; 2565 Merged_symbol_value<size>* msv = 2566 new Merged_symbol_value<size>(lv_in->input_value(), 2567 adjusted_start); 2568 lv_out->set_merged_symbol_value(msv); 2569 } 2570 } 2571 else if (lv_in->is_tls_symbol() 2572 || (lv_in->is_section_symbol() 2573 && (os->flags() & elfcpp::SHF_TLS))) 2574 lv_out->set_output_value(os->tls_offset() 2575 + secoffset 2576 + lv_in->input_value()); 2577 else 2578 lv_out->set_output_value((relocatable ? 0 : os->address()) 2579 + secoffset 2580 + lv_in->input_value()); 2581 } 2582 return This::CFLV_OK; 2583 } 2584 2585 // Compute final local symbol value. R_SYM is the index of a local 2586 // symbol in symbol table. LV points to a symbol value, which is 2587 // expected to hold the input value and to be over-written by the 2588 // final value. SYMTAB points to a symbol table. Some targets may want 2589 // to know would-be-finalized local symbol values in relaxation. 2590 // Hence we provide this method. Since this method updates *LV, a 2591 // callee should make a copy of the original local symbol value and 2592 // use the copy instead of modifying an object's local symbols before 2593 // everything is finalized. The caller should also free up any allocated 2594 // memory in the return value in *LV. 2595 template<int size, bool big_endian> 2596 typename Sized_relobj_file<size, big_endian>::Compute_final_local_value_status 2597 Sized_relobj_file<size, big_endian>::compute_final_local_value( 2598 unsigned int r_sym, 2599 const Symbol_value<size>* lv_in, 2600 Symbol_value<size>* lv_out, 2601 const Symbol_table* symtab) 2602 { 2603 // This is just a wrapper of compute_final_local_value_internal. 2604 const bool relocatable = parameters->options().relocatable(); 2605 const Output_sections& out_sections(this->output_sections()); 2606 const std::vector<Address>& out_offsets(this->section_offsets()); 2607 return this->compute_final_local_value_internal(r_sym, lv_in, lv_out, 2608 relocatable, out_sections, 2609 out_offsets, symtab); 2610 } 2611 2612 // Finalize the local symbols. Here we set the final value in 2613 // THIS->LOCAL_VALUES_ and set their output symbol table indexes. 2614 // This function is always called from a singleton thread. The actual 2615 // output of the local symbols will occur in a separate task. 2616 2617 template<int size, bool big_endian> 2618 unsigned int 2619 Sized_relobj_file<size, big_endian>::do_finalize_local_symbols( 2620 unsigned int index, 2621 off_t off, 2622 Symbol_table* symtab) 2623 { 2624 gold_assert(off == static_cast<off_t>(align_address(off, size >> 3))); 2625 2626 const unsigned int loccount = this->local_symbol_count_; 2627 this->local_symbol_offset_ = off; 2628 2629 const bool relocatable = parameters->options().relocatable(); 2630 const Output_sections& out_sections(this->output_sections()); 2631 const std::vector<Address>& out_offsets(this->section_offsets()); 2632 2633 for (unsigned int i = 1; i < loccount; ++i) 2634 { 2635 Symbol_value<size>* lv = &this->local_values_[i]; 2636 2637 Compute_final_local_value_status cflv_status = 2638 this->compute_final_local_value_internal(i, lv, lv, relocatable, 2639 out_sections, out_offsets, 2640 symtab); 2641 switch (cflv_status) 2642 { 2643 case CFLV_OK: 2644 if (!lv->is_output_symtab_index_set()) 2645 { 2646 lv->set_output_symtab_index(index); 2647 ++index; 2648 } 2649 if (lv->is_ifunc_symbol() 2650 && (lv->has_output_symtab_entry() 2651 || lv->needs_output_dynsym_entry())) 2652 symtab->set_has_gnu_output(); 2653 break; 2654 case CFLV_DISCARDED: 2655 case CFLV_ERROR: 2656 // Do nothing. 2657 break; 2658 default: 2659 gold_unreachable(); 2660 } 2661 } 2662 return index; 2663 } 2664 2665 // Set the output dynamic symbol table indexes for the local variables. 2666 2667 template<int size, bool big_endian> 2668 unsigned int 2669 Sized_relobj_file<size, big_endian>::do_set_local_dynsym_indexes( 2670 unsigned int index) 2671 { 2672 const unsigned int loccount = this->local_symbol_count_; 2673 for (unsigned int i = 1; i < loccount; ++i) 2674 { 2675 Symbol_value<size>& lv(this->local_values_[i]); 2676 if (lv.needs_output_dynsym_entry()) 2677 { 2678 lv.set_output_dynsym_index(index); 2679 ++index; 2680 } 2681 } 2682 return index; 2683 } 2684 2685 // Set the offset where local dynamic symbol information will be stored. 2686 // Returns the count of local symbols contributed to the symbol table by 2687 // this object. 2688 2689 template<int size, bool big_endian> 2690 unsigned int 2691 Sized_relobj_file<size, big_endian>::do_set_local_dynsym_offset(off_t off) 2692 { 2693 gold_assert(off == static_cast<off_t>(align_address(off, size >> 3))); 2694 this->local_dynsym_offset_ = off; 2695 return this->output_local_dynsym_count_; 2696 } 2697 2698 // If Symbols_data is not NULL get the section flags from here otherwise 2699 // get it from the file. 2700 2701 template<int size, bool big_endian> 2702 uint64_t 2703 Sized_relobj_file<size, big_endian>::do_section_flags(unsigned int shndx) 2704 { 2705 Symbols_data* sd = this->get_symbols_data(); 2706 if (sd != NULL) 2707 { 2708 const unsigned char* pshdrs = sd->section_headers_data 2709 + This::shdr_size * shndx; 2710 typename This::Shdr shdr(pshdrs); 2711 return shdr.get_sh_flags(); 2712 } 2713 // If sd is NULL, read the section header from the file. 2714 return this->elf_file_.section_flags(shndx); 2715 } 2716 2717 // Get the section's ent size from Symbols_data. Called by get_section_contents 2718 // in icf.cc 2719 2720 template<int size, bool big_endian> 2721 uint64_t 2722 Sized_relobj_file<size, big_endian>::do_section_entsize(unsigned int shndx) 2723 { 2724 Symbols_data* sd = this->get_symbols_data(); 2725 gold_assert(sd != NULL); 2726 2727 const unsigned char* pshdrs = sd->section_headers_data 2728 + This::shdr_size * shndx; 2729 typename This::Shdr shdr(pshdrs); 2730 return shdr.get_sh_entsize(); 2731 } 2732 2733 // Write out the local symbols. 2734 2735 template<int size, bool big_endian> 2736 void 2737 Sized_relobj_file<size, big_endian>::write_local_symbols( 2738 Output_file* of, 2739 const Stringpool* sympool, 2740 const Stringpool* dynpool, 2741 Output_symtab_xindex* symtab_xindex, 2742 Output_symtab_xindex* dynsym_xindex, 2743 off_t symtab_off) 2744 { 2745 const bool strip_all = parameters->options().strip_all(); 2746 if (strip_all) 2747 { 2748 if (this->output_local_dynsym_count_ == 0) 2749 return; 2750 this->output_local_symbol_count_ = 0; 2751 } 2752 2753 gold_assert(this->symtab_shndx_ != -1U); 2754 if (this->symtab_shndx_ == 0) 2755 { 2756 // This object has no symbols. Weird but legal. 2757 return; 2758 } 2759 2760 // Read the symbol table section header. 2761 const unsigned int symtab_shndx = this->symtab_shndx_; 2762 typename This::Shdr symtabshdr(this, 2763 this->elf_file_.section_header(symtab_shndx)); 2764 gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB); 2765 const unsigned int loccount = this->local_symbol_count_; 2766 gold_assert(loccount == symtabshdr.get_sh_info()); 2767 2768 // Read the local symbols. 2769 const int sym_size = This::sym_size; 2770 off_t locsize = loccount * sym_size; 2771 const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(), 2772 locsize, true, false); 2773 2774 // Read the symbol names. 2775 const unsigned int strtab_shndx = 2776 this->adjust_shndx(symtabshdr.get_sh_link()); 2777 section_size_type strtab_size; 2778 const unsigned char* pnamesu = this->section_contents(strtab_shndx, 2779 &strtab_size, 2780 false); 2781 const char* pnames = reinterpret_cast<const char*>(pnamesu); 2782 2783 // Get views into the output file for the portions of the symbol table 2784 // and the dynamic symbol table that we will be writing. 2785 off_t output_size = this->output_local_symbol_count_ * sym_size; 2786 unsigned char* oview = NULL; 2787 if (output_size > 0) 2788 oview = of->get_output_view(symtab_off + this->local_symbol_offset_, 2789 output_size); 2790 2791 off_t dyn_output_size = this->output_local_dynsym_count_ * sym_size; 2792 unsigned char* dyn_oview = NULL; 2793 if (dyn_output_size > 0) 2794 dyn_oview = of->get_output_view(this->local_dynsym_offset_, 2795 dyn_output_size); 2796 2797 const Output_sections& out_sections(this->output_sections()); 2798 2799 gold_assert(this->local_values_.size() == loccount); 2800 2801 unsigned char* ov = oview; 2802 unsigned char* dyn_ov = dyn_oview; 2803 psyms += sym_size; 2804 for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size) 2805 { 2806 elfcpp::Sym<size, big_endian> isym(psyms); 2807 2808 Symbol_value<size>& lv(this->local_values_[i]); 2809 2810 bool is_ordinary; 2811 unsigned int st_shndx = this->adjust_sym_shndx(i, isym.get_st_shndx(), 2812 &is_ordinary); 2813 if (is_ordinary) 2814 { 2815 gold_assert(st_shndx < out_sections.size()); 2816 if (out_sections[st_shndx] == NULL) 2817 continue; 2818 st_shndx = out_sections[st_shndx]->out_shndx(); 2819 if (st_shndx >= elfcpp::SHN_LORESERVE) 2820 { 2821 if (lv.has_output_symtab_entry()) 2822 symtab_xindex->add(lv.output_symtab_index(), st_shndx); 2823 if (lv.has_output_dynsym_entry()) 2824 dynsym_xindex->add(lv.output_dynsym_index(), st_shndx); 2825 st_shndx = elfcpp::SHN_XINDEX; 2826 } 2827 } 2828 2829 // Write the symbol to the output symbol table. 2830 if (lv.has_output_symtab_entry()) 2831 { 2832 elfcpp::Sym_write<size, big_endian> osym(ov); 2833 2834 gold_assert(isym.get_st_name() < strtab_size); 2835 const char* name = pnames + isym.get_st_name(); 2836 osym.put_st_name(sympool->get_offset(name)); 2837 osym.put_st_value(lv.value(this, 0)); 2838 osym.put_st_size(isym.get_st_size()); 2839 osym.put_st_info(isym.get_st_info()); 2840 osym.put_st_other(isym.get_st_other()); 2841 osym.put_st_shndx(st_shndx); 2842 2843 ov += sym_size; 2844 } 2845 2846 // Write the symbol to the output dynamic symbol table. 2847 if (lv.has_output_dynsym_entry()) 2848 { 2849 gold_assert(dyn_ov < dyn_oview + dyn_output_size); 2850 elfcpp::Sym_write<size, big_endian> osym(dyn_ov); 2851 2852 gold_assert(isym.get_st_name() < strtab_size); 2853 const char* name = pnames + isym.get_st_name(); 2854 osym.put_st_name(dynpool->get_offset(name)); 2855 osym.put_st_value(lv.value(this, 0)); 2856 osym.put_st_size(isym.get_st_size()); 2857 osym.put_st_info(isym.get_st_info()); 2858 osym.put_st_other(isym.get_st_other()); 2859 osym.put_st_shndx(st_shndx); 2860 2861 dyn_ov += sym_size; 2862 } 2863 } 2864 2865 2866 if (output_size > 0) 2867 { 2868 gold_assert(ov - oview == output_size); 2869 of->write_output_view(symtab_off + this->local_symbol_offset_, 2870 output_size, oview); 2871 } 2872 2873 if (dyn_output_size > 0) 2874 { 2875 gold_assert(dyn_ov - dyn_oview == dyn_output_size); 2876 of->write_output_view(this->local_dynsym_offset_, dyn_output_size, 2877 dyn_oview); 2878 } 2879 } 2880 2881 // Set *INFO to symbolic information about the offset OFFSET in the 2882 // section SHNDX. Return true if we found something, false if we 2883 // found nothing. 2884 2885 template<int size, bool big_endian> 2886 bool 2887 Sized_relobj_file<size, big_endian>::get_symbol_location_info( 2888 unsigned int shndx, 2889 off_t offset, 2890 Symbol_location_info* info) 2891 { 2892 if (this->symtab_shndx_ == 0) 2893 return false; 2894 2895 section_size_type symbols_size; 2896 const unsigned char* symbols = this->section_contents(this->symtab_shndx_, 2897 &symbols_size, 2898 false); 2899 2900 unsigned int symbol_names_shndx = 2901 this->adjust_shndx(this->section_link(this->symtab_shndx_)); 2902 section_size_type names_size; 2903 const unsigned char* symbol_names_u = 2904 this->section_contents(symbol_names_shndx, &names_size, false); 2905 const char* symbol_names = reinterpret_cast<const char*>(symbol_names_u); 2906 2907 const int sym_size = This::sym_size; 2908 const size_t count = symbols_size / sym_size; 2909 2910 const unsigned char* p = symbols; 2911 for (size_t i = 0; i < count; ++i, p += sym_size) 2912 { 2913 elfcpp::Sym<size, big_endian> sym(p); 2914 2915 if (sym.get_st_type() == elfcpp::STT_FILE) 2916 { 2917 if (sym.get_st_name() >= names_size) 2918 info->source_file = "(invalid)"; 2919 else 2920 info->source_file = symbol_names + sym.get_st_name(); 2921 continue; 2922 } 2923 2924 bool is_ordinary; 2925 unsigned int st_shndx = this->adjust_sym_shndx(i, sym.get_st_shndx(), 2926 &is_ordinary); 2927 if (is_ordinary 2928 && st_shndx == shndx 2929 && static_cast<off_t>(sym.get_st_value()) <= offset 2930 && (static_cast<off_t>(sym.get_st_value() + sym.get_st_size()) 2931 > offset)) 2932 { 2933 info->enclosing_symbol_type = sym.get_st_type(); 2934 if (sym.get_st_name() > names_size) 2935 info->enclosing_symbol_name = "(invalid)"; 2936 else 2937 { 2938 info->enclosing_symbol_name = symbol_names + sym.get_st_name(); 2939 if (parameters->options().do_demangle()) 2940 { 2941 char* demangled_name = cplus_demangle( 2942 info->enclosing_symbol_name.c_str(), 2943 DMGL_ANSI | DMGL_PARAMS); 2944 if (demangled_name != NULL) 2945 { 2946 info->enclosing_symbol_name.assign(demangled_name); 2947 free(demangled_name); 2948 } 2949 } 2950 } 2951 return true; 2952 } 2953 } 2954 2955 return false; 2956 } 2957 2958 // Look for a kept section corresponding to the given discarded section, 2959 // and return its output address. This is used only for relocations in 2960 // debugging sections. If we can't find the kept section, return 0. 2961 2962 template<int size, bool big_endian> 2963 typename Sized_relobj_file<size, big_endian>::Address 2964 Sized_relobj_file<size, big_endian>::map_to_kept_section( 2965 unsigned int shndx, 2966 std::string& section_name, 2967 bool* pfound) const 2968 { 2969 Kept_section* kept_section; 2970 bool is_comdat; 2971 uint64_t sh_size; 2972 unsigned int symndx; 2973 bool found = false; 2974 2975 if (this->get_kept_comdat_section(shndx, &is_comdat, &symndx, &sh_size, 2976 &kept_section)) 2977 { 2978 Relobj* kept_object = kept_section->object(); 2979 unsigned int kept_shndx = 0; 2980 if (!kept_section->is_comdat()) 2981 { 2982 // The kept section is a linkonce section. 2983 if (sh_size == kept_section->linkonce_size()) 2984 found = true; 2985 } 2986 else 2987 { 2988 if (is_comdat) 2989 { 2990 // Find the corresponding kept section. 2991 // Since we're using this mapping for relocation processing, 2992 // we don't want to match sections unless they have the same 2993 // size. 2994 uint64_t kept_size = 0; 2995 if (kept_section->find_comdat_section(section_name, &kept_shndx, 2996 &kept_size)) 2997 { 2998 if (sh_size == kept_size) 2999 found = true; 3000 } 3001 } 3002 else 3003 { 3004 uint64_t kept_size = 0; 3005 if (kept_section->find_single_comdat_section(&kept_shndx, 3006 &kept_size) 3007 && sh_size == kept_size) 3008 found = true; 3009 } 3010 } 3011 3012 if (found) 3013 { 3014 Sized_relobj_file<size, big_endian>* kept_relobj = 3015 static_cast<Sized_relobj_file<size, big_endian>*>(kept_object); 3016 Output_section* os = kept_relobj->output_section(kept_shndx); 3017 Address offset = kept_relobj->get_output_section_offset(kept_shndx); 3018 if (os != NULL && offset != invalid_address) 3019 { 3020 *pfound = true; 3021 return os->address() + offset; 3022 } 3023 } 3024 } 3025 *pfound = false; 3026 return 0; 3027 } 3028 3029 // Look for a kept section corresponding to the given discarded section, 3030 // and return its object file. 3031 3032 template<int size, bool big_endian> 3033 Relobj* 3034 Sized_relobj_file<size, big_endian>::find_kept_section_object( 3035 unsigned int shndx, unsigned int *symndx_p) const 3036 { 3037 Kept_section* kept_section; 3038 bool is_comdat; 3039 uint64_t sh_size; 3040 if (this->get_kept_comdat_section(shndx, &is_comdat, symndx_p, &sh_size, 3041 &kept_section)) 3042 return kept_section->object(); 3043 return NULL; 3044 } 3045 3046 // Return the name of symbol SYMNDX. 3047 3048 template<int size, bool big_endian> 3049 const char* 3050 Sized_relobj_file<size, big_endian>::get_symbol_name(unsigned int symndx) 3051 { 3052 if (this->symtab_shndx_ == 0) 3053 return NULL; 3054 3055 section_size_type symbols_size; 3056 const unsigned char* symbols = this->section_contents(this->symtab_shndx_, 3057 &symbols_size, 3058 false); 3059 3060 unsigned int symbol_names_shndx = 3061 this->adjust_shndx(this->section_link(this->symtab_shndx_)); 3062 section_size_type names_size; 3063 const unsigned char* symbol_names_u = 3064 this->section_contents(symbol_names_shndx, &names_size, false); 3065 const char* symbol_names = reinterpret_cast<const char*>(symbol_names_u); 3066 3067 const unsigned char* p = symbols + symndx * This::sym_size; 3068 3069 if (p >= symbols + symbols_size) 3070 return NULL; 3071 3072 elfcpp::Sym<size, big_endian> sym(p); 3073 3074 return symbol_names + sym.get_st_name(); 3075 } 3076 3077 // Get symbol counts. 3078 3079 template<int size, bool big_endian> 3080 void 3081 Sized_relobj_file<size, big_endian>::do_get_global_symbol_counts( 3082 const Symbol_table*, 3083 size_t* defined, 3084 size_t* used) const 3085 { 3086 *defined = this->defined_count_; 3087 size_t count = 0; 3088 for (typename Symbols::const_iterator p = this->symbols_.begin(); 3089 p != this->symbols_.end(); 3090 ++p) 3091 if (*p != NULL 3092 && (*p)->source() == Symbol::FROM_OBJECT 3093 && (*p)->object() == this 3094 && (*p)->is_defined()) 3095 ++count; 3096 *used = count; 3097 } 3098 3099 // Return a view of the decompressed contents of a section. Set *PLEN 3100 // to the size. Set *IS_NEW to true if the contents need to be freed 3101 // by the caller. 3102 3103 const unsigned char* 3104 Object::decompressed_section_contents( 3105 unsigned int shndx, 3106 section_size_type* plen, 3107 bool* is_new, 3108 uint64_t* palign) 3109 { 3110 section_size_type buffer_size; 3111 const unsigned char* buffer = this->do_section_contents(shndx, &buffer_size, 3112 false); 3113 3114 if (this->compressed_sections_ == NULL) 3115 { 3116 *plen = buffer_size; 3117 *is_new = false; 3118 return buffer; 3119 } 3120 3121 Compressed_section_map::const_iterator p = 3122 this->compressed_sections_->find(shndx); 3123 if (p == this->compressed_sections_->end()) 3124 { 3125 *plen = buffer_size; 3126 *is_new = false; 3127 return buffer; 3128 } 3129 3130 section_size_type uncompressed_size = p->second.size; 3131 if (p->second.contents != NULL) 3132 { 3133 *plen = uncompressed_size; 3134 *is_new = false; 3135 if (palign != NULL) 3136 *palign = p->second.addralign; 3137 return p->second.contents; 3138 } 3139 3140 unsigned char* uncompressed_data = new unsigned char[uncompressed_size]; 3141 if (!decompress_input_section(buffer, 3142 buffer_size, 3143 uncompressed_data, 3144 uncompressed_size, 3145 elfsize(), 3146 is_big_endian(), 3147 p->second.flag)) 3148 this->error(_("could not decompress section %s"), 3149 this->do_section_name(shndx).c_str()); 3150 3151 // We could cache the results in p->second.contents and store 3152 // false in *IS_NEW, but build_compressed_section_map() would 3153 // have done so if it had expected it to be profitable. If 3154 // we reach this point, we expect to need the contents only 3155 // once in this pass. 3156 *plen = uncompressed_size; 3157 *is_new = true; 3158 if (palign != NULL) 3159 *palign = p->second.addralign; 3160 return uncompressed_data; 3161 } 3162 3163 // Discard any buffers of uncompressed sections. This is done 3164 // at the end of the Add_symbols task. 3165 3166 void 3167 Object::discard_decompressed_sections() 3168 { 3169 if (this->compressed_sections_ == NULL) 3170 return; 3171 3172 for (Compressed_section_map::iterator p = this->compressed_sections_->begin(); 3173 p != this->compressed_sections_->end(); 3174 ++p) 3175 { 3176 if (p->second.contents != NULL) 3177 { 3178 delete[] p->second.contents; 3179 p->second.contents = NULL; 3180 } 3181 } 3182 } 3183 3184 // Input_objects methods. 3185 3186 // Add a regular relocatable object to the list. Return false if this 3187 // object should be ignored. 3188 3189 bool 3190 Input_objects::add_object(Object* obj) 3191 { 3192 // Print the filename if the -t/--trace option is selected. 3193 if (parameters->options().trace()) 3194 gold_info("%s", obj->name().c_str()); 3195 3196 if (!obj->is_dynamic()) 3197 this->relobj_list_.push_back(static_cast<Relobj*>(obj)); 3198 else 3199 { 3200 // See if this is a duplicate SONAME. 3201 Dynobj* dynobj = static_cast<Dynobj*>(obj); 3202 const char* soname = dynobj->soname(); 3203 3204 Unordered_map<std::string, Object*>::value_type val(soname, obj); 3205 std::pair<Unordered_map<std::string, Object*>::iterator, bool> ins = 3206 this->sonames_.insert(val); 3207 if (!ins.second) 3208 { 3209 // We have already seen a dynamic object with this soname. 3210 // If any instances of this object on the command line have 3211 // the --no-as-needed flag, make sure the one we keep is 3212 // marked so. 3213 if (!obj->as_needed()) 3214 { 3215 gold_assert(ins.first->second != NULL); 3216 ins.first->second->clear_as_needed(); 3217 } 3218 return false; 3219 } 3220 3221 this->dynobj_list_.push_back(dynobj); 3222 } 3223 3224 // Add this object to the cross-referencer if requested. 3225 if (parameters->options().user_set_print_symbol_counts() 3226 || parameters->options().cref()) 3227 { 3228 if (this->cref_ == NULL) 3229 this->cref_ = new Cref(); 3230 this->cref_->add_object(obj); 3231 } 3232 3233 return true; 3234 } 3235 3236 // For each dynamic object, record whether we've seen all of its 3237 // explicit dependencies. 3238 3239 void 3240 Input_objects::check_dynamic_dependencies() const 3241 { 3242 bool issued_copy_dt_needed_error = false; 3243 for (Dynobj_list::const_iterator p = this->dynobj_list_.begin(); 3244 p != this->dynobj_list_.end(); 3245 ++p) 3246 { 3247 const Dynobj::Needed& needed((*p)->needed()); 3248 bool found_all = true; 3249 Dynobj::Needed::const_iterator pneeded; 3250 for (pneeded = needed.begin(); pneeded != needed.end(); ++pneeded) 3251 { 3252 if (this->sonames_.find(*pneeded) == this->sonames_.end()) 3253 { 3254 found_all = false; 3255 break; 3256 } 3257 } 3258 (*p)->set_has_unknown_needed_entries(!found_all); 3259 3260 // --copy-dt-needed-entries aka --add-needed is a GNU ld option 3261 // that gold does not support. However, they cause no trouble 3262 // unless there is a DT_NEEDED entry that we don't know about; 3263 // warn only in that case. 3264 if (!found_all 3265 && !issued_copy_dt_needed_error 3266 && (parameters->options().copy_dt_needed_entries() 3267 || parameters->options().add_needed())) 3268 { 3269 const char* optname; 3270 if (parameters->options().copy_dt_needed_entries()) 3271 optname = "--copy-dt-needed-entries"; 3272 else 3273 optname = "--add-needed"; 3274 gold_error(_("%s is not supported but is required for %s in %s"), 3275 optname, (*pneeded).c_str(), (*p)->name().c_str()); 3276 issued_copy_dt_needed_error = true; 3277 } 3278 } 3279 } 3280 3281 // Start processing an archive. 3282 3283 void 3284 Input_objects::archive_start(Archive* archive) 3285 { 3286 if (parameters->options().user_set_print_symbol_counts() 3287 || parameters->options().cref()) 3288 { 3289 if (this->cref_ == NULL) 3290 this->cref_ = new Cref(); 3291 this->cref_->add_archive_start(archive); 3292 } 3293 } 3294 3295 // Stop processing an archive. 3296 3297 void 3298 Input_objects::archive_stop(Archive* archive) 3299 { 3300 if (parameters->options().user_set_print_symbol_counts() 3301 || parameters->options().cref()) 3302 this->cref_->add_archive_stop(archive); 3303 } 3304 3305 // Print symbol counts 3306 3307 void 3308 Input_objects::print_symbol_counts(const Symbol_table* symtab) const 3309 { 3310 if (parameters->options().user_set_print_symbol_counts() 3311 && this->cref_ != NULL) 3312 this->cref_->print_symbol_counts(symtab); 3313 } 3314 3315 // Print a cross reference table. 3316 3317 void 3318 Input_objects::print_cref(const Symbol_table* symtab, FILE* f) const 3319 { 3320 if (parameters->options().cref() && this->cref_ != NULL) 3321 this->cref_->print_cref(symtab, f); 3322 } 3323 3324 // Relocate_info methods. 3325 3326 // Return a string describing the location of a relocation when file 3327 // and lineno information is not available. This is only used in 3328 // error messages. 3329 3330 template<int size, bool big_endian> 3331 std::string 3332 Relocate_info<size, big_endian>::location(size_t, off_t offset) const 3333 { 3334 Sized_dwarf_line_info<size, big_endian> line_info(this->object); 3335 std::string ret = line_info.addr2line(this->data_shndx, offset, NULL); 3336 if (!ret.empty()) 3337 return ret; 3338 3339 ret = this->object->name(); 3340 3341 Symbol_location_info info; 3342 if (this->object->get_symbol_location_info(this->data_shndx, offset, &info)) 3343 { 3344 if (!info.source_file.empty()) 3345 { 3346 ret += ":"; 3347 ret += info.source_file; 3348 } 3349 ret += ":"; 3350 if (info.enclosing_symbol_type == elfcpp::STT_FUNC) 3351 ret += _("function "); 3352 ret += info.enclosing_symbol_name; 3353 return ret; 3354 } 3355 3356 ret += "("; 3357 ret += this->object->section_name(this->data_shndx); 3358 char buf[100]; 3359 snprintf(buf, sizeof buf, "+0x%lx)", static_cast<long>(offset)); 3360 ret += buf; 3361 return ret; 3362 } 3363 3364 } // End namespace gold. 3365 3366 namespace 3367 { 3368 3369 using namespace gold; 3370 3371 // Read an ELF file with the header and return the appropriate 3372 // instance of Object. 3373 3374 template<int size, bool big_endian> 3375 Object* 3376 make_elf_sized_object(const std::string& name, Input_file* input_file, 3377 off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr, 3378 bool* punconfigured) 3379 { 3380 Target* target = select_target(input_file, offset, 3381 ehdr.get_e_machine(), size, big_endian, 3382 ehdr.get_e_ident()[elfcpp::EI_OSABI], 3383 ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]); 3384 if (target == NULL) 3385 gold_fatal(_("%s: unsupported ELF machine number %d"), 3386 name.c_str(), ehdr.get_e_machine()); 3387 3388 if (!parameters->target_valid()) 3389 set_parameters_target(target); 3390 else if (target != ¶meters->target()) 3391 { 3392 if (punconfigured != NULL) 3393 *punconfigured = true; 3394 else 3395 gold_error(_("%s: incompatible target"), name.c_str()); 3396 return NULL; 3397 } 3398 3399 return target->make_elf_object<size, big_endian>(name, input_file, offset, 3400 ehdr); 3401 } 3402 3403 } // End anonymous namespace. 3404 3405 namespace gold 3406 { 3407 3408 // Return whether INPUT_FILE is an ELF object. 3409 3410 bool 3411 is_elf_object(Input_file* input_file, off_t offset, 3412 const unsigned char** start, int* read_size) 3413 { 3414 off_t filesize = input_file->file().filesize(); 3415 int want = elfcpp::Elf_recognizer::max_header_size; 3416 if (filesize - offset < want) 3417 want = filesize - offset; 3418 3419 const unsigned char* p = input_file->file().get_view(offset, 0, want, 3420 true, false); 3421 *start = p; 3422 *read_size = want; 3423 3424 return elfcpp::Elf_recognizer::is_elf_file(p, want); 3425 } 3426 3427 // Read an ELF file and return the appropriate instance of Object. 3428 3429 Object* 3430 make_elf_object(const std::string& name, Input_file* input_file, off_t offset, 3431 const unsigned char* p, section_offset_type bytes, 3432 bool* punconfigured) 3433 { 3434 if (punconfigured != NULL) 3435 *punconfigured = false; 3436 3437 std::string error; 3438 bool big_endian = false; 3439 int size = 0; 3440 if (!elfcpp::Elf_recognizer::is_valid_header(p, bytes, &size, 3441 &big_endian, &error)) 3442 { 3443 gold_error(_("%s: %s"), name.c_str(), error.c_str()); 3444 return NULL; 3445 } 3446 3447 if (size == 32) 3448 { 3449 if (big_endian) 3450 { 3451 #ifdef HAVE_TARGET_32_BIG 3452 elfcpp::Ehdr<32, true> ehdr(p); 3453 return make_elf_sized_object<32, true>(name, input_file, 3454 offset, ehdr, punconfigured); 3455 #else 3456 if (punconfigured != NULL) 3457 *punconfigured = true; 3458 else 3459 gold_error(_("%s: not configured to support " 3460 "32-bit big-endian object"), 3461 name.c_str()); 3462 return NULL; 3463 #endif 3464 } 3465 else 3466 { 3467 #ifdef HAVE_TARGET_32_LITTLE 3468 elfcpp::Ehdr<32, false> ehdr(p); 3469 return make_elf_sized_object<32, false>(name, input_file, 3470 offset, ehdr, punconfigured); 3471 #else 3472 if (punconfigured != NULL) 3473 *punconfigured = true; 3474 else 3475 gold_error(_("%s: not configured to support " 3476 "32-bit little-endian object"), 3477 name.c_str()); 3478 return NULL; 3479 #endif 3480 } 3481 } 3482 else if (size == 64) 3483 { 3484 if (big_endian) 3485 { 3486 #ifdef HAVE_TARGET_64_BIG 3487 elfcpp::Ehdr<64, true> ehdr(p); 3488 return make_elf_sized_object<64, true>(name, input_file, 3489 offset, ehdr, punconfigured); 3490 #else 3491 if (punconfigured != NULL) 3492 *punconfigured = true; 3493 else 3494 gold_error(_("%s: not configured to support " 3495 "64-bit big-endian object"), 3496 name.c_str()); 3497 return NULL; 3498 #endif 3499 } 3500 else 3501 { 3502 #ifdef HAVE_TARGET_64_LITTLE 3503 elfcpp::Ehdr<64, false> ehdr(p); 3504 return make_elf_sized_object<64, false>(name, input_file, 3505 offset, ehdr, punconfigured); 3506 #else 3507 if (punconfigured != NULL) 3508 *punconfigured = true; 3509 else 3510 gold_error(_("%s: not configured to support " 3511 "64-bit little-endian object"), 3512 name.c_str()); 3513 return NULL; 3514 #endif 3515 } 3516 } 3517 else 3518 gold_unreachable(); 3519 } 3520 3521 // Instantiate the templates we need. 3522 3523 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) 3524 template 3525 void 3526 Relobj::initialize_input_to_output_map<64>(unsigned int shndx, 3527 elfcpp::Elf_types<64>::Elf_Addr starting_address, 3528 Unordered_map<section_offset_type, 3529 elfcpp::Elf_types<64>::Elf_Addr>* output_addresses) const; 3530 #endif 3531 3532 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) 3533 template 3534 void 3535 Relobj::initialize_input_to_output_map<32>(unsigned int shndx, 3536 elfcpp::Elf_types<32>::Elf_Addr starting_address, 3537 Unordered_map<section_offset_type, 3538 elfcpp::Elf_types<32>::Elf_Addr>* output_addresses) const; 3539 #endif 3540 3541 #ifdef HAVE_TARGET_32_LITTLE 3542 template 3543 void 3544 Object::read_section_data<32, false>(elfcpp::Elf_file<32, false, Object>*, 3545 Read_symbols_data*); 3546 template 3547 const unsigned char* 3548 Object::find_shdr<32,false>(const unsigned char*, const char*, const char*, 3549 section_size_type, const unsigned char*) const; 3550 #endif 3551 3552 #ifdef HAVE_TARGET_32_BIG 3553 template 3554 void 3555 Object::read_section_data<32, true>(elfcpp::Elf_file<32, true, Object>*, 3556 Read_symbols_data*); 3557 template 3558 const unsigned char* 3559 Object::find_shdr<32,true>(const unsigned char*, const char*, const char*, 3560 section_size_type, const unsigned char*) const; 3561 #endif 3562 3563 #ifdef HAVE_TARGET_64_LITTLE 3564 template 3565 void 3566 Object::read_section_data<64, false>(elfcpp::Elf_file<64, false, Object>*, 3567 Read_symbols_data*); 3568 template 3569 const unsigned char* 3570 Object::find_shdr<64,false>(const unsigned char*, const char*, const char*, 3571 section_size_type, const unsigned char*) const; 3572 #endif 3573 3574 #ifdef HAVE_TARGET_64_BIG 3575 template 3576 void 3577 Object::read_section_data<64, true>(elfcpp::Elf_file<64, true, Object>*, 3578 Read_symbols_data*); 3579 template 3580 const unsigned char* 3581 Object::find_shdr<64,true>(const unsigned char*, const char*, const char*, 3582 section_size_type, const unsigned char*) const; 3583 #endif 3584 3585 #ifdef HAVE_TARGET_32_LITTLE 3586 template 3587 class Sized_relobj<32, false>; 3588 3589 template 3590 class Sized_relobj_file<32, false>; 3591 #endif 3592 3593 #ifdef HAVE_TARGET_32_BIG 3594 template 3595 class Sized_relobj<32, true>; 3596 3597 template 3598 class Sized_relobj_file<32, true>; 3599 #endif 3600 3601 #ifdef HAVE_TARGET_64_LITTLE 3602 template 3603 class Sized_relobj<64, false>; 3604 3605 template 3606 class Sized_relobj_file<64, false>; 3607 #endif 3608 3609 #ifdef HAVE_TARGET_64_BIG 3610 template 3611 class Sized_relobj<64, true>; 3612 3613 template 3614 class Sized_relobj_file<64, true>; 3615 #endif 3616 3617 #ifdef HAVE_TARGET_32_LITTLE 3618 template 3619 struct Relocate_info<32, false>; 3620 #endif 3621 3622 #ifdef HAVE_TARGET_32_BIG 3623 template 3624 struct Relocate_info<32, true>; 3625 #endif 3626 3627 #ifdef HAVE_TARGET_64_LITTLE 3628 template 3629 struct Relocate_info<64, false>; 3630 #endif 3631 3632 #ifdef HAVE_TARGET_64_BIG 3633 template 3634 struct Relocate_info<64, true>; 3635 #endif 3636 3637 #ifdef HAVE_TARGET_32_LITTLE 3638 template 3639 void 3640 Xindex::initialize_symtab_xindex<32, false>(Object*, unsigned int); 3641 3642 template 3643 void 3644 Xindex::read_symtab_xindex<32, false>(Object*, unsigned int, 3645 const unsigned char*); 3646 #endif 3647 3648 #ifdef HAVE_TARGET_32_BIG 3649 template 3650 void 3651 Xindex::initialize_symtab_xindex<32, true>(Object*, unsigned int); 3652 3653 template 3654 void 3655 Xindex::read_symtab_xindex<32, true>(Object*, unsigned int, 3656 const unsigned char*); 3657 #endif 3658 3659 #ifdef HAVE_TARGET_64_LITTLE 3660 template 3661 void 3662 Xindex::initialize_symtab_xindex<64, false>(Object*, unsigned int); 3663 3664 template 3665 void 3666 Xindex::read_symtab_xindex<64, false>(Object*, unsigned int, 3667 const unsigned char*); 3668 #endif 3669 3670 #ifdef HAVE_TARGET_64_BIG 3671 template 3672 void 3673 Xindex::initialize_symtab_xindex<64, true>(Object*, unsigned int); 3674 3675 template 3676 void 3677 Xindex::read_symtab_xindex<64, true>(Object*, unsigned int, 3678 const unsigned char*); 3679 #endif 3680 3681 #ifdef HAVE_TARGET_32_LITTLE 3682 template 3683 Compressed_section_map* 3684 build_compressed_section_map<32, false>(const unsigned char*, unsigned int, 3685 const char*, section_size_type, 3686 Object*, bool); 3687 #endif 3688 3689 #ifdef HAVE_TARGET_32_BIG 3690 template 3691 Compressed_section_map* 3692 build_compressed_section_map<32, true>(const unsigned char*, unsigned int, 3693 const char*, section_size_type, 3694 Object*, bool); 3695 #endif 3696 3697 #ifdef HAVE_TARGET_64_LITTLE 3698 template 3699 Compressed_section_map* 3700 build_compressed_section_map<64, false>(const unsigned char*, unsigned int, 3701 const char*, section_size_type, 3702 Object*, bool); 3703 #endif 3704 3705 #ifdef HAVE_TARGET_64_BIG 3706 template 3707 Compressed_section_map* 3708 build_compressed_section_map<64, true>(const unsigned char*, unsigned int, 3709 const char*, section_size_type, 3710 Object*, bool); 3711 #endif 3712 3713 } // End namespace gold. 3714