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 (at) 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 lv_out->set_output_value( 2408 os->output_address(this, shndx, lv_in->input_value())); 2409 } 2410 else if (!os->find_starting_output_address(this, shndx, &start)) 2411 { 2412 // This is a section symbol, but apparently not one in a 2413 // merged section. First check to see if this is a relaxed 2414 // input section. If so, use its address. Otherwise just 2415 // use the start of the output section. This happens with 2416 // relocatable links when the input object has section 2417 // symbols for arbitrary non-merge sections. 2418 const Output_section_data* posd = 2419 os->find_relaxed_input_section(this, shndx); 2420 if (posd != NULL) 2421 { 2422 Address relocatable_link_adjustment = 2423 relocatable ? os->address() : 0; 2424 lv_out->set_output_value(posd->address() 2425 - relocatable_link_adjustment); 2426 } 2427 else 2428 lv_out->set_output_value(os->address()); 2429 } 2430 else 2431 { 2432 // We have to consider the addend to determine the 2433 // value to use in a relocation. START is the start 2434 // of this input section. If we are doing a relocatable 2435 // link, use offset from start output section instead of 2436 // address. 2437 Address adjusted_start = 2438 relocatable ? start - os->address() : start; 2439 Merged_symbol_value<size>* msv = 2440 new Merged_symbol_value<size>(lv_in->input_value(), 2441 adjusted_start); 2442 lv_out->set_merged_symbol_value(msv); 2443 } 2444 } 2445 else if (lv_in->is_tls_symbol() 2446 || (lv_in->is_section_symbol() 2447 && (os->flags() & elfcpp::SHF_TLS))) 2448 lv_out->set_output_value(os->tls_offset() 2449 + secoffset 2450 + lv_in->input_value()); 2451 else 2452 lv_out->set_output_value((relocatable ? 0 : os->address()) 2453 + secoffset 2454 + lv_in->input_value()); 2455 } 2456 return This::CFLV_OK; 2457 } 2458 2459 // Compute final local symbol value. R_SYM is the index of a local 2460 // symbol in symbol table. LV points to a symbol value, which is 2461 // expected to hold the input value and to be over-written by the 2462 // final value. SYMTAB points to a symbol table. Some targets may want 2463 // to know would-be-finalized local symbol values in relaxation. 2464 // Hence we provide this method. Since this method updates *LV, a 2465 // callee should make a copy of the original local symbol value and 2466 // use the copy instead of modifying an object's local symbols before 2467 // everything is finalized. The caller should also free up any allocated 2468 // memory in the return value in *LV. 2469 template<int size, bool big_endian> 2470 typename Sized_relobj_file<size, big_endian>::Compute_final_local_value_status 2471 Sized_relobj_file<size, big_endian>::compute_final_local_value( 2472 unsigned int r_sym, 2473 const Symbol_value<size>* lv_in, 2474 Symbol_value<size>* lv_out, 2475 const Symbol_table* symtab) 2476 { 2477 // This is just a wrapper of compute_final_local_value_internal. 2478 const bool relocatable = parameters->options().relocatable(); 2479 const Output_sections& out_sections(this->output_sections()); 2480 const std::vector<Address>& out_offsets(this->section_offsets()); 2481 return this->compute_final_local_value_internal(r_sym, lv_in, lv_out, 2482 relocatable, out_sections, 2483 out_offsets, symtab); 2484 } 2485 2486 // Finalize the local symbols. Here we set the final value in 2487 // THIS->LOCAL_VALUES_ and set their output symbol table indexes. 2488 // This function is always called from a singleton thread. The actual 2489 // output of the local symbols will occur in a separate task. 2490 2491 template<int size, bool big_endian> 2492 unsigned int 2493 Sized_relobj_file<size, big_endian>::do_finalize_local_symbols( 2494 unsigned int index, 2495 off_t off, 2496 Symbol_table* symtab) 2497 { 2498 gold_assert(off == static_cast<off_t>(align_address(off, size >> 3))); 2499 2500 const unsigned int loccount = this->local_symbol_count_; 2501 this->local_symbol_offset_ = off; 2502 2503 const bool relocatable = parameters->options().relocatable(); 2504 const Output_sections& out_sections(this->output_sections()); 2505 const std::vector<Address>& out_offsets(this->section_offsets()); 2506 2507 for (unsigned int i = 1; i < loccount; ++i) 2508 { 2509 Symbol_value<size>* lv = &this->local_values_[i]; 2510 2511 Compute_final_local_value_status cflv_status = 2512 this->compute_final_local_value_internal(i, lv, lv, relocatable, 2513 out_sections, out_offsets, 2514 symtab); 2515 switch (cflv_status) 2516 { 2517 case CFLV_OK: 2518 if (!lv->is_output_symtab_index_set()) 2519 { 2520 lv->set_output_symtab_index(index); 2521 ++index; 2522 } 2523 break; 2524 case CFLV_DISCARDED: 2525 case CFLV_ERROR: 2526 // Do nothing. 2527 break; 2528 default: 2529 gold_unreachable(); 2530 } 2531 } 2532 return index; 2533 } 2534 2535 // Set the output dynamic symbol table indexes for the local variables. 2536 2537 template<int size, bool big_endian> 2538 unsigned int 2539 Sized_relobj_file<size, big_endian>::do_set_local_dynsym_indexes( 2540 unsigned int index) 2541 { 2542 const unsigned int loccount = this->local_symbol_count_; 2543 for (unsigned int i = 1; i < loccount; ++i) 2544 { 2545 Symbol_value<size>& lv(this->local_values_[i]); 2546 if (lv.needs_output_dynsym_entry()) 2547 { 2548 lv.set_output_dynsym_index(index); 2549 ++index; 2550 } 2551 } 2552 return index; 2553 } 2554 2555 // Set the offset where local dynamic symbol information will be stored. 2556 // Returns the count of local symbols contributed to the symbol table by 2557 // this object. 2558 2559 template<int size, bool big_endian> 2560 unsigned int 2561 Sized_relobj_file<size, big_endian>::do_set_local_dynsym_offset(off_t off) 2562 { 2563 gold_assert(off == static_cast<off_t>(align_address(off, size >> 3))); 2564 this->local_dynsym_offset_ = off; 2565 return this->output_local_dynsym_count_; 2566 } 2567 2568 // If Symbols_data is not NULL get the section flags from here otherwise 2569 // get it from the file. 2570 2571 template<int size, bool big_endian> 2572 uint64_t 2573 Sized_relobj_file<size, big_endian>::do_section_flags(unsigned int shndx) 2574 { 2575 Symbols_data* sd = this->get_symbols_data(); 2576 if (sd != NULL) 2577 { 2578 const unsigned char* pshdrs = sd->section_headers_data 2579 + This::shdr_size * shndx; 2580 typename This::Shdr shdr(pshdrs); 2581 return shdr.get_sh_flags(); 2582 } 2583 // If sd is NULL, read the section header from the file. 2584 return this->elf_file_.section_flags(shndx); 2585 } 2586 2587 // Get the section's ent size from Symbols_data. Called by get_section_contents 2588 // in icf.cc 2589 2590 template<int size, bool big_endian> 2591 uint64_t 2592 Sized_relobj_file<size, big_endian>::do_section_entsize(unsigned int shndx) 2593 { 2594 Symbols_data* sd = this->get_symbols_data(); 2595 gold_assert(sd != NULL); 2596 2597 const unsigned char* pshdrs = sd->section_headers_data 2598 + This::shdr_size * shndx; 2599 typename This::Shdr shdr(pshdrs); 2600 return shdr.get_sh_entsize(); 2601 } 2602 2603 // Write out the local symbols. 2604 2605 template<int size, bool big_endian> 2606 void 2607 Sized_relobj_file<size, big_endian>::write_local_symbols( 2608 Output_file* of, 2609 const Stringpool* sympool, 2610 const Stringpool* dynpool, 2611 Output_symtab_xindex* symtab_xindex, 2612 Output_symtab_xindex* dynsym_xindex, 2613 off_t symtab_off) 2614 { 2615 const bool strip_all = parameters->options().strip_all(); 2616 if (strip_all) 2617 { 2618 if (this->output_local_dynsym_count_ == 0) 2619 return; 2620 this->output_local_symbol_count_ = 0; 2621 } 2622 2623 gold_assert(this->symtab_shndx_ != -1U); 2624 if (this->symtab_shndx_ == 0) 2625 { 2626 // This object has no symbols. Weird but legal. 2627 return; 2628 } 2629 2630 // Read the symbol table section header. 2631 const unsigned int symtab_shndx = this->symtab_shndx_; 2632 typename This::Shdr symtabshdr(this, 2633 this->elf_file_.section_header(symtab_shndx)); 2634 gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB); 2635 const unsigned int loccount = this->local_symbol_count_; 2636 gold_assert(loccount == symtabshdr.get_sh_info()); 2637 2638 // Read the local symbols. 2639 const int sym_size = This::sym_size; 2640 off_t locsize = loccount * sym_size; 2641 const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(), 2642 locsize, true, false); 2643 2644 // Read the symbol names. 2645 const unsigned int strtab_shndx = 2646 this->adjust_shndx(symtabshdr.get_sh_link()); 2647 section_size_type strtab_size; 2648 const unsigned char* pnamesu = this->section_contents(strtab_shndx, 2649 &strtab_size, 2650 false); 2651 const char* pnames = reinterpret_cast<const char*>(pnamesu); 2652 2653 // Get views into the output file for the portions of the symbol table 2654 // and the dynamic symbol table that we will be writing. 2655 off_t output_size = this->output_local_symbol_count_ * sym_size; 2656 unsigned char* oview = NULL; 2657 if (output_size > 0) 2658 oview = of->get_output_view(symtab_off + this->local_symbol_offset_, 2659 output_size); 2660 2661 off_t dyn_output_size = this->output_local_dynsym_count_ * sym_size; 2662 unsigned char* dyn_oview = NULL; 2663 if (dyn_output_size > 0) 2664 dyn_oview = of->get_output_view(this->local_dynsym_offset_, 2665 dyn_output_size); 2666 2667 const Output_sections& out_sections(this->output_sections()); 2668 2669 gold_assert(this->local_values_.size() == loccount); 2670 2671 unsigned char* ov = oview; 2672 unsigned char* dyn_ov = dyn_oview; 2673 psyms += sym_size; 2674 for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size) 2675 { 2676 elfcpp::Sym<size, big_endian> isym(psyms); 2677 2678 Symbol_value<size>& lv(this->local_values_[i]); 2679 typename elfcpp::Elf_types<size>::Elf_Addr sym_value = lv.value(this, 0); 2680 2681 bool is_ordinary; 2682 unsigned int st_shndx = this->adjust_sym_shndx(i, isym.get_st_shndx(), 2683 &is_ordinary); 2684 if (is_ordinary) 2685 { 2686 gold_assert(st_shndx < out_sections.size()); 2687 if (out_sections[st_shndx] == NULL) 2688 continue; 2689 // In relocatable object files symbol values are section relative. 2690 if (parameters->options().relocatable()) 2691 sym_value -= out_sections[st_shndx]->address(); 2692 st_shndx = out_sections[st_shndx]->out_shndx(); 2693 if (st_shndx >= elfcpp::SHN_LORESERVE) 2694 { 2695 if (lv.has_output_symtab_entry()) 2696 symtab_xindex->add(lv.output_symtab_index(), st_shndx); 2697 if (lv.has_output_dynsym_entry()) 2698 dynsym_xindex->add(lv.output_dynsym_index(), st_shndx); 2699 st_shndx = elfcpp::SHN_XINDEX; 2700 } 2701 } 2702 2703 // Write the symbol to the output symbol table. 2704 if (lv.has_output_symtab_entry()) 2705 { 2706 elfcpp::Sym_write<size, big_endian> osym(ov); 2707 2708 gold_assert(isym.get_st_name() < strtab_size); 2709 const char* name = pnames + isym.get_st_name(); 2710 osym.put_st_name(sympool->get_offset(name)); 2711 osym.put_st_value(sym_value); 2712 osym.put_st_size(isym.get_st_size()); 2713 osym.put_st_info(isym.get_st_info()); 2714 osym.put_st_other(isym.get_st_other()); 2715 osym.put_st_shndx(st_shndx); 2716 2717 ov += sym_size; 2718 } 2719 2720 // Write the symbol to the output dynamic symbol table. 2721 if (lv.has_output_dynsym_entry()) 2722 { 2723 gold_assert(dyn_ov < dyn_oview + dyn_output_size); 2724 elfcpp::Sym_write<size, big_endian> osym(dyn_ov); 2725 2726 gold_assert(isym.get_st_name() < strtab_size); 2727 const char* name = pnames + isym.get_st_name(); 2728 osym.put_st_name(dynpool->get_offset(name)); 2729 osym.put_st_value(sym_value); 2730 osym.put_st_size(isym.get_st_size()); 2731 osym.put_st_info(isym.get_st_info()); 2732 osym.put_st_other(isym.get_st_other()); 2733 osym.put_st_shndx(st_shndx); 2734 2735 dyn_ov += sym_size; 2736 } 2737 } 2738 2739 2740 if (output_size > 0) 2741 { 2742 gold_assert(ov - oview == output_size); 2743 of->write_output_view(symtab_off + this->local_symbol_offset_, 2744 output_size, oview); 2745 } 2746 2747 if (dyn_output_size > 0) 2748 { 2749 gold_assert(dyn_ov - dyn_oview == dyn_output_size); 2750 of->write_output_view(this->local_dynsym_offset_, dyn_output_size, 2751 dyn_oview); 2752 } 2753 } 2754 2755 // Set *INFO to symbolic information about the offset OFFSET in the 2756 // section SHNDX. Return true if we found something, false if we 2757 // found nothing. 2758 2759 template<int size, bool big_endian> 2760 bool 2761 Sized_relobj_file<size, big_endian>::get_symbol_location_info( 2762 unsigned int shndx, 2763 off_t offset, 2764 Symbol_location_info* info) 2765 { 2766 if (this->symtab_shndx_ == 0) 2767 return false; 2768 2769 section_size_type symbols_size; 2770 const unsigned char* symbols = this->section_contents(this->symtab_shndx_, 2771 &symbols_size, 2772 false); 2773 2774 unsigned int symbol_names_shndx = 2775 this->adjust_shndx(this->section_link(this->symtab_shndx_)); 2776 section_size_type names_size; 2777 const unsigned char* symbol_names_u = 2778 this->section_contents(symbol_names_shndx, &names_size, false); 2779 const char* symbol_names = reinterpret_cast<const char*>(symbol_names_u); 2780 2781 const int sym_size = This::sym_size; 2782 const size_t count = symbols_size / sym_size; 2783 2784 const unsigned char* p = symbols; 2785 for (size_t i = 0; i < count; ++i, p += sym_size) 2786 { 2787 elfcpp::Sym<size, big_endian> sym(p); 2788 2789 if (sym.get_st_type() == elfcpp::STT_FILE) 2790 { 2791 if (sym.get_st_name() >= names_size) 2792 info->source_file = "(invalid)"; 2793 else 2794 info->source_file = symbol_names + sym.get_st_name(); 2795 continue; 2796 } 2797 2798 bool is_ordinary; 2799 unsigned int st_shndx = this->adjust_sym_shndx(i, sym.get_st_shndx(), 2800 &is_ordinary); 2801 if (is_ordinary 2802 && st_shndx == shndx 2803 && static_cast<off_t>(sym.get_st_value()) <= offset 2804 && (static_cast<off_t>(sym.get_st_value() + sym.get_st_size()) 2805 > offset)) 2806 { 2807 info->enclosing_symbol_type = sym.get_st_type(); 2808 if (sym.get_st_name() > names_size) 2809 info->enclosing_symbol_name = "(invalid)"; 2810 else 2811 { 2812 info->enclosing_symbol_name = symbol_names + sym.get_st_name(); 2813 if (parameters->options().do_demangle()) 2814 { 2815 char* demangled_name = cplus_demangle( 2816 info->enclosing_symbol_name.c_str(), 2817 DMGL_ANSI | DMGL_PARAMS); 2818 if (demangled_name != NULL) 2819 { 2820 info->enclosing_symbol_name.assign(demangled_name); 2821 free(demangled_name); 2822 } 2823 } 2824 } 2825 return true; 2826 } 2827 } 2828 2829 return false; 2830 } 2831 2832 // Look for a kept section corresponding to the given discarded section, 2833 // and return its output address. This is used only for relocations in 2834 // debugging sections. If we can't find the kept section, return 0. 2835 2836 template<int size, bool big_endian> 2837 typename Sized_relobj_file<size, big_endian>::Address 2838 Sized_relobj_file<size, big_endian>::map_to_kept_section( 2839 unsigned int shndx, 2840 bool* found) const 2841 { 2842 Relobj* kept_object; 2843 unsigned int kept_shndx; 2844 if (this->get_kept_comdat_section(shndx, &kept_object, &kept_shndx)) 2845 { 2846 Sized_relobj_file<size, big_endian>* kept_relobj = 2847 static_cast<Sized_relobj_file<size, big_endian>*>(kept_object); 2848 Output_section* os = kept_relobj->output_section(kept_shndx); 2849 Address offset = kept_relobj->get_output_section_offset(kept_shndx); 2850 if (os != NULL && offset != invalid_address) 2851 { 2852 *found = true; 2853 return os->address() + offset; 2854 } 2855 } 2856 *found = false; 2857 return 0; 2858 } 2859 2860 // Get symbol counts. 2861 2862 template<int size, bool big_endian> 2863 void 2864 Sized_relobj_file<size, big_endian>::do_get_global_symbol_counts( 2865 const Symbol_table*, 2866 size_t* defined, 2867 size_t* used) const 2868 { 2869 *defined = this->defined_count_; 2870 size_t count = 0; 2871 for (typename Symbols::const_iterator p = this->symbols_.begin(); 2872 p != this->symbols_.end(); 2873 ++p) 2874 if (*p != NULL 2875 && (*p)->source() == Symbol::FROM_OBJECT 2876 && (*p)->object() == this 2877 && (*p)->is_defined()) 2878 ++count; 2879 *used = count; 2880 } 2881 2882 // Return a view of the decompressed contents of a section. Set *PLEN 2883 // to the size. Set *IS_NEW to true if the contents need to be freed 2884 // by the caller. 2885 2886 const unsigned char* 2887 Object::decompressed_section_contents( 2888 unsigned int shndx, 2889 section_size_type* plen, 2890 bool* is_new) 2891 { 2892 section_size_type buffer_size; 2893 const unsigned char* buffer = this->do_section_contents(shndx, &buffer_size, 2894 false); 2895 2896 if (this->compressed_sections_ == NULL) 2897 { 2898 *plen = buffer_size; 2899 *is_new = false; 2900 return buffer; 2901 } 2902 2903 Compressed_section_map::const_iterator p = 2904 this->compressed_sections_->find(shndx); 2905 if (p == this->compressed_sections_->end()) 2906 { 2907 *plen = buffer_size; 2908 *is_new = false; 2909 return buffer; 2910 } 2911 2912 section_size_type uncompressed_size = p->second.size; 2913 if (p->second.contents != NULL) 2914 { 2915 *plen = uncompressed_size; 2916 *is_new = false; 2917 return p->second.contents; 2918 } 2919 2920 unsigned char* uncompressed_data = new unsigned char[uncompressed_size]; 2921 if (!decompress_input_section(buffer, 2922 buffer_size, 2923 uncompressed_data, 2924 uncompressed_size, 2925 elfsize(), 2926 is_big_endian(), 2927 p->second.flag)) 2928 this->error(_("could not decompress section %s"), 2929 this->do_section_name(shndx).c_str()); 2930 2931 // We could cache the results in p->second.contents and store 2932 // false in *IS_NEW, but build_compressed_section_map() would 2933 // have done so if it had expected it to be profitable. If 2934 // we reach this point, we expect to need the contents only 2935 // once in this pass. 2936 *plen = uncompressed_size; 2937 *is_new = true; 2938 return uncompressed_data; 2939 } 2940 2941 // Discard any buffers of uncompressed sections. This is done 2942 // at the end of the Add_symbols task. 2943 2944 void 2945 Object::discard_decompressed_sections() 2946 { 2947 if (this->compressed_sections_ == NULL) 2948 return; 2949 2950 for (Compressed_section_map::iterator p = this->compressed_sections_->begin(); 2951 p != this->compressed_sections_->end(); 2952 ++p) 2953 { 2954 if (p->second.contents != NULL) 2955 { 2956 delete[] p->second.contents; 2957 p->second.contents = NULL; 2958 } 2959 } 2960 } 2961 2962 // Input_objects methods. 2963 2964 // Add a regular relocatable object to the list. Return false if this 2965 // object should be ignored. 2966 2967 bool 2968 Input_objects::add_object(Object* obj) 2969 { 2970 // Print the filename if the -t/--trace option is selected. 2971 if (parameters->options().trace()) 2972 gold_info("%s", obj->name().c_str()); 2973 2974 if (!obj->is_dynamic()) 2975 this->relobj_list_.push_back(static_cast<Relobj*>(obj)); 2976 else 2977 { 2978 // See if this is a duplicate SONAME. 2979 Dynobj* dynobj = static_cast<Dynobj*>(obj); 2980 const char* soname = dynobj->soname(); 2981 2982 Unordered_map<std::string, Object*>::value_type val(soname, obj); 2983 std::pair<Unordered_map<std::string, Object*>::iterator, bool> ins = 2984 this->sonames_.insert(val); 2985 if (!ins.second) 2986 { 2987 // We have already seen a dynamic object with this soname. 2988 // If any instances of this object on the command line have 2989 // the --no-as-needed flag, make sure the one we keep is 2990 // marked so. 2991 if (!obj->as_needed()) 2992 { 2993 gold_assert(ins.first->second != NULL); 2994 ins.first->second->clear_as_needed(); 2995 } 2996 return false; 2997 } 2998 2999 this->dynobj_list_.push_back(dynobj); 3000 } 3001 3002 // Add this object to the cross-referencer if requested. 3003 if (parameters->options().user_set_print_symbol_counts() 3004 || parameters->options().cref()) 3005 { 3006 if (this->cref_ == NULL) 3007 this->cref_ = new Cref(); 3008 this->cref_->add_object(obj); 3009 } 3010 3011 return true; 3012 } 3013 3014 // For each dynamic object, record whether we've seen all of its 3015 // explicit dependencies. 3016 3017 void 3018 Input_objects::check_dynamic_dependencies() const 3019 { 3020 bool issued_copy_dt_needed_error = false; 3021 for (Dynobj_list::const_iterator p = this->dynobj_list_.begin(); 3022 p != this->dynobj_list_.end(); 3023 ++p) 3024 { 3025 const Dynobj::Needed& needed((*p)->needed()); 3026 bool found_all = true; 3027 Dynobj::Needed::const_iterator pneeded; 3028 for (pneeded = needed.begin(); pneeded != needed.end(); ++pneeded) 3029 { 3030 if (this->sonames_.find(*pneeded) == this->sonames_.end()) 3031 { 3032 found_all = false; 3033 break; 3034 } 3035 } 3036 (*p)->set_has_unknown_needed_entries(!found_all); 3037 3038 // --copy-dt-needed-entries aka --add-needed is a GNU ld option 3039 // that gold does not support. However, they cause no trouble 3040 // unless there is a DT_NEEDED entry that we don't know about; 3041 // warn only in that case. 3042 if (!found_all 3043 && !issued_copy_dt_needed_error 3044 && (parameters->options().copy_dt_needed_entries() 3045 || parameters->options().add_needed())) 3046 { 3047 const char* optname; 3048 if (parameters->options().copy_dt_needed_entries()) 3049 optname = "--copy-dt-needed-entries"; 3050 else 3051 optname = "--add-needed"; 3052 gold_error(_("%s is not supported but is required for %s in %s"), 3053 optname, (*pneeded).c_str(), (*p)->name().c_str()); 3054 issued_copy_dt_needed_error = true; 3055 } 3056 } 3057 } 3058 3059 // Start processing an archive. 3060 3061 void 3062 Input_objects::archive_start(Archive* archive) 3063 { 3064 if (parameters->options().user_set_print_symbol_counts() 3065 || parameters->options().cref()) 3066 { 3067 if (this->cref_ == NULL) 3068 this->cref_ = new Cref(); 3069 this->cref_->add_archive_start(archive); 3070 } 3071 } 3072 3073 // Stop processing an archive. 3074 3075 void 3076 Input_objects::archive_stop(Archive* archive) 3077 { 3078 if (parameters->options().user_set_print_symbol_counts() 3079 || parameters->options().cref()) 3080 this->cref_->add_archive_stop(archive); 3081 } 3082 3083 // Print symbol counts 3084 3085 void 3086 Input_objects::print_symbol_counts(const Symbol_table* symtab) const 3087 { 3088 if (parameters->options().user_set_print_symbol_counts() 3089 && this->cref_ != NULL) 3090 this->cref_->print_symbol_counts(symtab); 3091 } 3092 3093 // Print a cross reference table. 3094 3095 void 3096 Input_objects::print_cref(const Symbol_table* symtab, FILE* f) const 3097 { 3098 if (parameters->options().cref() && this->cref_ != NULL) 3099 this->cref_->print_cref(symtab, f); 3100 } 3101 3102 // Relocate_info methods. 3103 3104 // Return a string describing the location of a relocation when file 3105 // and lineno information is not available. This is only used in 3106 // error messages. 3107 3108 template<int size, bool big_endian> 3109 std::string 3110 Relocate_info<size, big_endian>::location(size_t, off_t offset) const 3111 { 3112 Sized_dwarf_line_info<size, big_endian> line_info(this->object); 3113 std::string ret = line_info.addr2line(this->data_shndx, offset, NULL); 3114 if (!ret.empty()) 3115 return ret; 3116 3117 ret = this->object->name(); 3118 3119 Symbol_location_info info; 3120 if (this->object->get_symbol_location_info(this->data_shndx, offset, &info)) 3121 { 3122 if (!info.source_file.empty()) 3123 { 3124 ret += ":"; 3125 ret += info.source_file; 3126 } 3127 ret += ":"; 3128 if (info.enclosing_symbol_type == elfcpp::STT_FUNC) 3129 ret += _("function "); 3130 ret += info.enclosing_symbol_name; 3131 return ret; 3132 } 3133 3134 ret += "("; 3135 ret += this->object->section_name(this->data_shndx); 3136 char buf[100]; 3137 snprintf(buf, sizeof buf, "+0x%lx)", static_cast<long>(offset)); 3138 ret += buf; 3139 return ret; 3140 } 3141 3142 } // End namespace gold. 3143 3144 namespace 3145 { 3146 3147 using namespace gold; 3148 3149 // Read an ELF file with the header and return the appropriate 3150 // instance of Object. 3151 3152 template<int size, bool big_endian> 3153 Object* 3154 make_elf_sized_object(const std::string& name, Input_file* input_file, 3155 off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr, 3156 bool* punconfigured) 3157 { 3158 Target* target = select_target(input_file, offset, 3159 ehdr.get_e_machine(), size, big_endian, 3160 ehdr.get_e_ident()[elfcpp::EI_OSABI], 3161 ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]); 3162 if (target == NULL) 3163 gold_fatal(_("%s: unsupported ELF machine number %d"), 3164 name.c_str(), ehdr.get_e_machine()); 3165 3166 if (!parameters->target_valid()) 3167 set_parameters_target(target); 3168 else if (target != ¶meters->target()) 3169 { 3170 if (punconfigured != NULL) 3171 *punconfigured = true; 3172 else 3173 gold_error(_("%s: incompatible target"), name.c_str()); 3174 return NULL; 3175 } 3176 3177 return target->make_elf_object<size, big_endian>(name, input_file, offset, 3178 ehdr); 3179 } 3180 3181 } // End anonymous namespace. 3182 3183 namespace gold 3184 { 3185 3186 // Return whether INPUT_FILE is an ELF object. 3187 3188 bool 3189 is_elf_object(Input_file* input_file, off_t offset, 3190 const unsigned char** start, int* read_size) 3191 { 3192 off_t filesize = input_file->file().filesize(); 3193 int want = elfcpp::Elf_recognizer::max_header_size; 3194 if (filesize - offset < want) 3195 want = filesize - offset; 3196 3197 const unsigned char* p = input_file->file().get_view(offset, 0, want, 3198 true, false); 3199 *start = p; 3200 *read_size = want; 3201 3202 return elfcpp::Elf_recognizer::is_elf_file(p, want); 3203 } 3204 3205 // Read an ELF file and return the appropriate instance of Object. 3206 3207 Object* 3208 make_elf_object(const std::string& name, Input_file* input_file, off_t offset, 3209 const unsigned char* p, section_offset_type bytes, 3210 bool* punconfigured) 3211 { 3212 if (punconfigured != NULL) 3213 *punconfigured = false; 3214 3215 std::string error; 3216 bool big_endian = false; 3217 int size = 0; 3218 if (!elfcpp::Elf_recognizer::is_valid_header(p, bytes, &size, 3219 &big_endian, &error)) 3220 { 3221 gold_error(_("%s: %s"), name.c_str(), error.c_str()); 3222 return NULL; 3223 } 3224 3225 if (size == 32) 3226 { 3227 if (big_endian) 3228 { 3229 #ifdef HAVE_TARGET_32_BIG 3230 elfcpp::Ehdr<32, true> ehdr(p); 3231 return make_elf_sized_object<32, true>(name, input_file, 3232 offset, ehdr, punconfigured); 3233 #else 3234 if (punconfigured != NULL) 3235 *punconfigured = true; 3236 else 3237 gold_error(_("%s: not configured to support " 3238 "32-bit big-endian object"), 3239 name.c_str()); 3240 return NULL; 3241 #endif 3242 } 3243 else 3244 { 3245 #ifdef HAVE_TARGET_32_LITTLE 3246 elfcpp::Ehdr<32, false> ehdr(p); 3247 return make_elf_sized_object<32, false>(name, input_file, 3248 offset, ehdr, punconfigured); 3249 #else 3250 if (punconfigured != NULL) 3251 *punconfigured = true; 3252 else 3253 gold_error(_("%s: not configured to support " 3254 "32-bit little-endian object"), 3255 name.c_str()); 3256 return NULL; 3257 #endif 3258 } 3259 } 3260 else if (size == 64) 3261 { 3262 if (big_endian) 3263 { 3264 #ifdef HAVE_TARGET_64_BIG 3265 elfcpp::Ehdr<64, true> ehdr(p); 3266 return make_elf_sized_object<64, true>(name, input_file, 3267 offset, ehdr, punconfigured); 3268 #else 3269 if (punconfigured != NULL) 3270 *punconfigured = true; 3271 else 3272 gold_error(_("%s: not configured to support " 3273 "64-bit big-endian object"), 3274 name.c_str()); 3275 return NULL; 3276 #endif 3277 } 3278 else 3279 { 3280 #ifdef HAVE_TARGET_64_LITTLE 3281 elfcpp::Ehdr<64, false> ehdr(p); 3282 return make_elf_sized_object<64, false>(name, input_file, 3283 offset, ehdr, punconfigured); 3284 #else 3285 if (punconfigured != NULL) 3286 *punconfigured = true; 3287 else 3288 gold_error(_("%s: not configured to support " 3289 "64-bit little-endian object"), 3290 name.c_str()); 3291 return NULL; 3292 #endif 3293 } 3294 } 3295 else 3296 gold_unreachable(); 3297 } 3298 3299 // Instantiate the templates we need. 3300 3301 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) 3302 template 3303 void 3304 Relobj::initialize_input_to_output_map<64>(unsigned int shndx, 3305 elfcpp::Elf_types<64>::Elf_Addr starting_address, 3306 Unordered_map<section_offset_type, 3307 elfcpp::Elf_types<64>::Elf_Addr>* output_addresses) const; 3308 #endif 3309 3310 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) 3311 template 3312 void 3313 Relobj::initialize_input_to_output_map<32>(unsigned int shndx, 3314 elfcpp::Elf_types<32>::Elf_Addr starting_address, 3315 Unordered_map<section_offset_type, 3316 elfcpp::Elf_types<32>::Elf_Addr>* output_addresses) const; 3317 #endif 3318 3319 #ifdef HAVE_TARGET_32_LITTLE 3320 template 3321 void 3322 Object::read_section_data<32, false>(elfcpp::Elf_file<32, false, Object>*, 3323 Read_symbols_data*); 3324 template 3325 const unsigned char* 3326 Object::find_shdr<32,false>(const unsigned char*, const char*, const char*, 3327 section_size_type, const unsigned char*) const; 3328 #endif 3329 3330 #ifdef HAVE_TARGET_32_BIG 3331 template 3332 void 3333 Object::read_section_data<32, true>(elfcpp::Elf_file<32, true, Object>*, 3334 Read_symbols_data*); 3335 template 3336 const unsigned char* 3337 Object::find_shdr<32,true>(const unsigned char*, const char*, const char*, 3338 section_size_type, const unsigned char*) const; 3339 #endif 3340 3341 #ifdef HAVE_TARGET_64_LITTLE 3342 template 3343 void 3344 Object::read_section_data<64, false>(elfcpp::Elf_file<64, false, Object>*, 3345 Read_symbols_data*); 3346 template 3347 const unsigned char* 3348 Object::find_shdr<64,false>(const unsigned char*, const char*, const char*, 3349 section_size_type, const unsigned char*) const; 3350 #endif 3351 3352 #ifdef HAVE_TARGET_64_BIG 3353 template 3354 void 3355 Object::read_section_data<64, true>(elfcpp::Elf_file<64, true, Object>*, 3356 Read_symbols_data*); 3357 template 3358 const unsigned char* 3359 Object::find_shdr<64,true>(const unsigned char*, const char*, const char*, 3360 section_size_type, const unsigned char*) const; 3361 #endif 3362 3363 #ifdef HAVE_TARGET_32_LITTLE 3364 template 3365 class Sized_relobj<32, false>; 3366 3367 template 3368 class Sized_relobj_file<32, false>; 3369 #endif 3370 3371 #ifdef HAVE_TARGET_32_BIG 3372 template 3373 class Sized_relobj<32, true>; 3374 3375 template 3376 class Sized_relobj_file<32, true>; 3377 #endif 3378 3379 #ifdef HAVE_TARGET_64_LITTLE 3380 template 3381 class Sized_relobj<64, false>; 3382 3383 template 3384 class Sized_relobj_file<64, false>; 3385 #endif 3386 3387 #ifdef HAVE_TARGET_64_BIG 3388 template 3389 class Sized_relobj<64, true>; 3390 3391 template 3392 class Sized_relobj_file<64, true>; 3393 #endif 3394 3395 #ifdef HAVE_TARGET_32_LITTLE 3396 template 3397 struct Relocate_info<32, false>; 3398 #endif 3399 3400 #ifdef HAVE_TARGET_32_BIG 3401 template 3402 struct Relocate_info<32, true>; 3403 #endif 3404 3405 #ifdef HAVE_TARGET_64_LITTLE 3406 template 3407 struct Relocate_info<64, false>; 3408 #endif 3409 3410 #ifdef HAVE_TARGET_64_BIG 3411 template 3412 struct Relocate_info<64, true>; 3413 #endif 3414 3415 #ifdef HAVE_TARGET_32_LITTLE 3416 template 3417 void 3418 Xindex::initialize_symtab_xindex<32, false>(Object*, unsigned int); 3419 3420 template 3421 void 3422 Xindex::read_symtab_xindex<32, false>(Object*, unsigned int, 3423 const unsigned char*); 3424 #endif 3425 3426 #ifdef HAVE_TARGET_32_BIG 3427 template 3428 void 3429 Xindex::initialize_symtab_xindex<32, true>(Object*, unsigned int); 3430 3431 template 3432 void 3433 Xindex::read_symtab_xindex<32, true>(Object*, unsigned int, 3434 const unsigned char*); 3435 #endif 3436 3437 #ifdef HAVE_TARGET_64_LITTLE 3438 template 3439 void 3440 Xindex::initialize_symtab_xindex<64, false>(Object*, unsigned int); 3441 3442 template 3443 void 3444 Xindex::read_symtab_xindex<64, false>(Object*, unsigned int, 3445 const unsigned char*); 3446 #endif 3447 3448 #ifdef HAVE_TARGET_64_BIG 3449 template 3450 void 3451 Xindex::initialize_symtab_xindex<64, true>(Object*, unsigned int); 3452 3453 template 3454 void 3455 Xindex::read_symtab_xindex<64, true>(Object*, unsigned int, 3456 const unsigned char*); 3457 #endif 3458 3459 } // End namespace gold. 3460