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