1 // archive.cc -- archive support for gold 2 3 // Copyright (C) 2006-2014 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 <climits> 28 #include <vector> 29 #include "libiberty.h" 30 #include "filenames.h" 31 32 #include "elfcpp.h" 33 #include "options.h" 34 #include "mapfile.h" 35 #include "fileread.h" 36 #include "readsyms.h" 37 #include "symtab.h" 38 #include "object.h" 39 #include "layout.h" 40 #include "archive.h" 41 #include "plugin.h" 42 #include "incremental.h" 43 44 namespace gold 45 { 46 47 // Library_base methods. 48 49 // Determine whether a definition of SYM_NAME should cause an archive 50 // library member to be included in the link. Returns SHOULD_INCLUDE_YES 51 // if the symbol is referenced but not defined, SHOULD_INCLUDE_NO if the 52 // symbol is already defined, and SHOULD_INCLUDE_UNKNOWN if the symbol is 53 // neither referenced nor defined. 54 55 Library_base::Should_include 56 Library_base::should_include_member(Symbol_table* symtab, Layout* layout, 57 const char* sym_name, Symbol** symp, 58 std::string* why, char** tmpbufp, 59 size_t* tmpbuflen) 60 { 61 // In an object file, and therefore in an archive map, an 62 // '@' in the name separates the symbol name from the 63 // version name. If there are two '@' characters, this is 64 // the default version. 65 char* tmpbuf = *tmpbufp; 66 const char* ver = strchr(sym_name, '@'); 67 bool def = false; 68 if (ver != NULL) 69 { 70 size_t symlen = ver - sym_name; 71 if (symlen + 1 > *tmpbuflen) 72 { 73 tmpbuf = static_cast<char*>(xrealloc(tmpbuf, symlen + 1)); 74 *tmpbufp = tmpbuf; 75 *tmpbuflen = symlen + 1; 76 } 77 memcpy(tmpbuf, sym_name, symlen); 78 tmpbuf[symlen] = '\0'; 79 sym_name = tmpbuf; 80 81 ++ver; 82 if (*ver == '@') 83 { 84 ++ver; 85 def = true; 86 } 87 } 88 89 Symbol* sym = symtab->lookup(sym_name, ver); 90 if (def 91 && ver != NULL 92 && (sym == NULL 93 || !sym->is_undefined() 94 || sym->binding() == elfcpp::STB_WEAK)) 95 sym = symtab->lookup(sym_name, NULL); 96 97 *symp = sym; 98 99 if (sym != NULL) 100 { 101 if (!sym->is_undefined()) 102 return Library_base::SHOULD_INCLUDE_NO; 103 104 // PR 12001: Do not include an archive when the undefined 105 // symbol has actually been defined on the command line. 106 if (layout->script_options()->is_pending_assignment(sym_name)) 107 return Library_base::SHOULD_INCLUDE_NO; 108 109 // If the symbol is weak undefined, we still need to check 110 // for other reasons (like a -u option). 111 if (sym->binding() != elfcpp::STB_WEAK) 112 return Library_base::SHOULD_INCLUDE_YES; 113 } 114 115 // Check whether the symbol was named in a -u option. 116 if (parameters->options().is_undefined(sym_name)) 117 { 118 *why = "-u "; 119 *why += sym_name; 120 return Library_base::SHOULD_INCLUDE_YES; 121 } 122 123 if (parameters->options().is_export_dynamic_symbol(sym_name)) 124 { 125 *why = "--export-dynamic-symbol "; 126 *why += sym_name; 127 return Library_base::SHOULD_INCLUDE_YES; 128 } 129 130 if (layout->script_options()->is_referenced(sym_name)) 131 { 132 size_t alc = 100 + strlen(sym_name); 133 char* buf = new char[alc]; 134 snprintf(buf, alc, _("script or expression reference to %s"), 135 sym_name); 136 *why = buf; 137 delete[] buf; 138 return Library_base::SHOULD_INCLUDE_YES; 139 } 140 141 if (strcmp(sym_name, parameters->entry()) == 0) 142 { 143 *why = "entry symbol "; 144 *why += sym_name; 145 return Library_base::SHOULD_INCLUDE_YES; 146 } 147 148 return Library_base::SHOULD_INCLUDE_UNKNOWN; 149 } 150 151 // The header of an entry in the archive. This is all readable text, 152 // padded with spaces where necessary. If the contents of an archive 153 // are all text file, the entire archive is readable. 154 155 struct Archive::Archive_header 156 { 157 // The entry name. 158 char ar_name[16]; 159 // The file modification time. 160 char ar_date[12]; 161 // The user's UID in decimal. 162 char ar_uid[6]; 163 // The user's GID in decimal. 164 char ar_gid[6]; 165 // The file mode in octal. 166 char ar_mode[8]; 167 // The file size in decimal. 168 char ar_size[10]; 169 // The final magic code. 170 char ar_fmag[2]; 171 }; 172 173 // Class Archive static variables. 174 unsigned int Archive::total_archives; 175 unsigned int Archive::total_members; 176 unsigned int Archive::total_members_loaded; 177 178 // Archive methods. 179 180 const char Archive::armag[sarmag] = 181 { 182 '!', '<', 'a', 'r', 'c', 'h', '>', '\n' 183 }; 184 185 const char Archive::armagt[sarmag] = 186 { 187 '!', '<', 't', 'h', 'i', 'n', '>', '\n' 188 }; 189 190 const char Archive::arfmag[2] = { '`', '\n' }; 191 192 Archive::Archive(const std::string& name, Input_file* input_file, 193 bool is_thin_archive, Dirsearch* dirpath, Task* task) 194 : Library_base(task), name_(name), input_file_(input_file), armap_(), 195 armap_names_(), extended_names_(), armap_checked_(), seen_offsets_(), 196 members_(), is_thin_archive_(is_thin_archive), included_member_(false), 197 nested_archives_(), dirpath_(dirpath), num_members_(0), 198 included_all_members_(false) 199 { 200 this->no_export_ = 201 parameters->options().check_excluded_libs(input_file->found_name()); 202 } 203 204 // Set up the archive: read the symbol map and the extended name 205 // table. 206 207 void 208 Archive::setup() 209 { 210 // We need to ignore empty archives. 211 if (this->input_file_->file().filesize() == sarmag) 212 return; 213 214 // The first member of the archive should be the symbol table. 215 std::string armap_name; 216 off_t header_size = this->read_header(sarmag, false, &armap_name, NULL); 217 if (header_size == -1) 218 return; 219 220 section_size_type armap_size = convert_to_section_size_type(header_size); 221 off_t off = sarmag; 222 if (armap_name.empty()) 223 { 224 this->read_armap(sarmag + sizeof(Archive_header), armap_size); 225 off = sarmag + sizeof(Archive_header) + armap_size; 226 } 227 else if (!this->input_file_->options().whole_archive()) 228 gold_error(_("%s: no archive symbol table (run ranlib)"), 229 this->name().c_str()); 230 231 // See if there is an extended name table. We cache these views 232 // because it is likely that we will want to read the following 233 // header in the add_symbols routine. 234 if ((off & 1) != 0) 235 ++off; 236 std::string xname; 237 header_size = this->read_header(off, true, &xname, NULL); 238 if (header_size == -1) 239 return; 240 241 section_size_type extended_size = convert_to_section_size_type(header_size); 242 if (xname == "/") 243 { 244 const unsigned char* p = this->get_view(off + sizeof(Archive_header), 245 extended_size, false, true); 246 const char* px = reinterpret_cast<const char*>(p); 247 this->extended_names_.assign(px, extended_size); 248 } 249 bool preread_syms = (parameters->options().threads() 250 && parameters->options().preread_archive_symbols()); 251 #ifndef ENABLE_THREADS 252 preread_syms = false; 253 #else 254 if (parameters->options().has_plugins()) 255 preread_syms = false; 256 #endif 257 if (preread_syms) 258 this->read_all_symbols(); 259 } 260 261 // Unlock any nested archives. 262 263 void 264 Archive::unlock_nested_archives() 265 { 266 for (Nested_archive_table::iterator p = this->nested_archives_.begin(); 267 p != this->nested_archives_.end(); 268 ++p) 269 { 270 p->second->unlock(this->task_); 271 } 272 } 273 274 // Read the archive symbol map. 275 276 void 277 Archive::read_armap(off_t start, section_size_type size) 278 { 279 // To count the total number of archive members, we'll just count 280 // the number of times the file offset changes. Since most archives 281 // group the symbols in the armap by object, this ought to give us 282 // an accurate count. 283 off_t last_seen_offset = -1; 284 285 // Read in the entire armap. 286 const unsigned char* p = this->get_view(start, size, true, false); 287 288 // Numbers in the armap are always big-endian. 289 const elfcpp::Elf_Word* pword = reinterpret_cast<const elfcpp::Elf_Word*>(p); 290 unsigned int nsyms = elfcpp::Swap<32, true>::readval(pword); 291 ++pword; 292 293 // Note that the addition is in units of sizeof(elfcpp::Elf_Word). 294 const char* pnames = reinterpret_cast<const char*>(pword + nsyms); 295 section_size_type names_size = 296 reinterpret_cast<const char*>(p) + size - pnames; 297 this->armap_names_.assign(pnames, names_size); 298 299 this->armap_.resize(nsyms); 300 301 section_offset_type name_offset = 0; 302 for (unsigned int i = 0; i < nsyms; ++i) 303 { 304 this->armap_[i].name_offset = name_offset; 305 this->armap_[i].file_offset = elfcpp::Swap<32, true>::readval(pword); 306 name_offset += strlen(pnames + name_offset) + 1; 307 ++pword; 308 if (this->armap_[i].file_offset != last_seen_offset) 309 { 310 last_seen_offset = this->armap_[i].file_offset; 311 ++this->num_members_; 312 } 313 } 314 315 if (static_cast<section_size_type>(name_offset) > names_size) 316 gold_error(_("%s: bad archive symbol table names"), 317 this->name().c_str()); 318 319 // This array keeps track of which symbols are for archive elements 320 // which we have already included in the link. 321 this->armap_checked_.resize(nsyms); 322 } 323 324 // Read the header of an archive member at OFF. Fail if something 325 // goes wrong. Return the size of the member. Set *PNAME to the name 326 // of the member. 327 328 off_t 329 Archive::read_header(off_t off, bool cache, std::string* pname, 330 off_t* nested_off) 331 { 332 const unsigned char* p = this->get_view(off, sizeof(Archive_header), true, 333 cache); 334 const Archive_header* hdr = reinterpret_cast<const Archive_header*>(p); 335 return this->interpret_header(hdr, off, pname, nested_off); 336 } 337 338 // Interpret the header of HDR, the header of the archive member at 339 // file offset OFF. Return the size of the member, or -1 if something 340 // has gone wrong. Set *PNAME to the name of the member. 341 342 off_t 343 Archive::interpret_header(const Archive_header* hdr, off_t off, 344 std::string* pname, off_t* nested_off) const 345 { 346 if (memcmp(hdr->ar_fmag, arfmag, sizeof arfmag) != 0) 347 { 348 gold_error(_("%s: malformed archive header at %zu"), 349 this->name().c_str(), static_cast<size_t>(off)); 350 return -1; 351 } 352 353 const int size_string_size = sizeof hdr->ar_size; 354 char size_string[size_string_size + 1]; 355 memcpy(size_string, hdr->ar_size, size_string_size); 356 char* ps = size_string + size_string_size; 357 while (ps[-1] == ' ') 358 --ps; 359 *ps = '\0'; 360 361 errno = 0; 362 char* end; 363 off_t member_size = strtol(size_string, &end, 10); 364 if (*end != '\0' 365 || member_size < 0 366 || (member_size == LONG_MAX && errno == ERANGE)) 367 { 368 gold_error(_("%s: malformed archive header size at %zu"), 369 this->name().c_str(), static_cast<size_t>(off)); 370 return -1; 371 } 372 373 if (hdr->ar_name[0] != '/') 374 { 375 const char* name_end = strchr(hdr->ar_name, '/'); 376 if (name_end == NULL 377 || name_end - hdr->ar_name >= static_cast<int>(sizeof hdr->ar_name)) 378 { 379 gold_error(_("%s: malformed archive header name at %zu"), 380 this->name().c_str(), static_cast<size_t>(off)); 381 return -1; 382 } 383 pname->assign(hdr->ar_name, name_end - hdr->ar_name); 384 if (nested_off != NULL) 385 *nested_off = 0; 386 } 387 else if (hdr->ar_name[1] == ' ') 388 { 389 // This is the symbol table. 390 if (!pname->empty()) 391 pname->clear(); 392 } 393 else if (hdr->ar_name[1] == '/') 394 { 395 // This is the extended name table. 396 pname->assign(1, '/'); 397 } 398 else 399 { 400 errno = 0; 401 long x = strtol(hdr->ar_name + 1, &end, 10); 402 long y = 0; 403 if (*end == ':') 404 y = strtol(end + 1, &end, 10); 405 if (*end != ' ' 406 || x < 0 407 || (x == LONG_MAX && errno == ERANGE) 408 || static_cast<size_t>(x) >= this->extended_names_.size()) 409 { 410 gold_error(_("%s: bad extended name index at %zu"), 411 this->name().c_str(), static_cast<size_t>(off)); 412 return -1; 413 } 414 415 const char* name = this->extended_names_.data() + x; 416 const char* name_end = strchr(name, '\n'); 417 if (static_cast<size_t>(name_end - name) > this->extended_names_.size() 418 || name_end[-1] != '/') 419 { 420 gold_error(_("%s: bad extended name entry at header %zu"), 421 this->name().c_str(), static_cast<size_t>(off)); 422 return -1; 423 } 424 pname->assign(name, name_end - 1 - name); 425 if (nested_off != NULL) 426 *nested_off = y; 427 } 428 429 return member_size; 430 } 431 432 // An archive member iterator. 433 434 class Archive::const_iterator 435 { 436 public: 437 // The header of an archive member. This is what this iterator 438 // points to. 439 struct Header 440 { 441 // The name of the member. 442 std::string name; 443 // The file offset of the member. 444 off_t off; 445 // The file offset of a nested archive member. 446 off_t nested_off; 447 // The size of the member. 448 off_t size; 449 }; 450 451 const_iterator(Archive* archive, off_t off) 452 : archive_(archive), off_(off) 453 { this->read_next_header(); } 454 455 const Header& 456 operator*() const 457 { return this->header_; } 458 459 const Header* 460 operator->() const 461 { return &this->header_; } 462 463 const_iterator& 464 operator++() 465 { 466 if (this->off_ == this->archive_->file().filesize()) 467 return *this; 468 this->off_ += sizeof(Archive_header); 469 if (!this->archive_->is_thin_archive()) 470 this->off_ += this->header_.size; 471 if ((this->off_ & 1) != 0) 472 ++this->off_; 473 this->read_next_header(); 474 return *this; 475 } 476 477 const_iterator 478 operator++(int) 479 { 480 const_iterator ret = *this; 481 ++*this; 482 return ret; 483 } 484 485 bool 486 operator==(const const_iterator p) const 487 { return this->off_ == p->off; } 488 489 bool 490 operator!=(const const_iterator p) const 491 { return this->off_ != p->off; } 492 493 private: 494 void 495 read_next_header(); 496 497 // The underlying archive. 498 Archive* archive_; 499 // The current offset in the file. 500 off_t off_; 501 // The current archive header. 502 Header header_; 503 }; 504 505 // Read the next archive header. 506 507 void 508 Archive::const_iterator::read_next_header() 509 { 510 off_t filesize = this->archive_->file().filesize(); 511 while (true) 512 { 513 if (filesize - this->off_ < static_cast<off_t>(sizeof(Archive_header))) 514 { 515 if (filesize != this->off_) 516 { 517 gold_error(_("%s: short archive header at %zu"), 518 this->archive_->filename().c_str(), 519 static_cast<size_t>(this->off_)); 520 this->off_ = filesize; 521 } 522 this->header_.off = filesize; 523 return; 524 } 525 526 unsigned char buf[sizeof(Archive_header)]; 527 this->archive_->file().read(this->off_, sizeof(Archive_header), buf); 528 529 const Archive_header* hdr = reinterpret_cast<const Archive_header*>(buf); 530 off_t size = this->archive_->interpret_header(hdr, this->off_, 531 &this->header_.name, 532 &this->header_.nested_off); 533 if (size == -1) 534 { 535 this->header_.off = filesize; 536 return; 537 } 538 539 this->header_.size = size; 540 this->header_.off = this->off_; 541 542 // Skip special members. 543 if (!this->header_.name.empty() && this->header_.name != "/") 544 return; 545 546 this->off_ += sizeof(Archive_header) + this->header_.size; 547 if ((this->off_ & 1) != 0) 548 ++this->off_; 549 } 550 } 551 552 // Initial iterator. 553 554 Archive::const_iterator 555 Archive::begin() 556 { 557 return Archive::const_iterator(this, sarmag); 558 } 559 560 // Final iterator. 561 562 Archive::const_iterator 563 Archive::end() 564 { 565 return Archive::const_iterator(this, this->input_file_->file().filesize()); 566 } 567 568 // Get the file and offset for an archive member, which may be an 569 // external member of a thin archive. Set *INPUT_FILE to the 570 // file containing the actual member, *MEMOFF to the offset 571 // within that file (0 if not a nested archive), and *MEMBER_NAME 572 // to the name of the archive member. Return TRUE on success. 573 574 bool 575 Archive::get_file_and_offset(off_t off, Input_file** input_file, off_t* memoff, 576 off_t* memsize, std::string* member_name) 577 { 578 off_t nested_off; 579 580 *memsize = this->read_header(off, false, member_name, &nested_off); 581 if (*memsize == -1) 582 return false; 583 584 *input_file = this->input_file_; 585 *memoff = off + static_cast<off_t>(sizeof(Archive_header)); 586 587 if (!this->is_thin_archive_) 588 return true; 589 590 // Adjust a relative pathname so that it is relative 591 // to the directory containing the archive. 592 if (!IS_ABSOLUTE_PATH(member_name->c_str())) 593 { 594 const char* arch_path = this->filename().c_str(); 595 const char* basename = lbasename(arch_path); 596 if (basename > arch_path) 597 member_name->replace(0, 0, 598 this->filename().substr(0, basename - arch_path)); 599 } 600 601 if (nested_off > 0) 602 { 603 // This is a member of a nested archive. Open the containing 604 // archive if we don't already have it open, then do a recursive 605 // call to include the member from that archive. 606 Archive* arch; 607 Nested_archive_table::const_iterator p = 608 this->nested_archives_.find(*member_name); 609 if (p != this->nested_archives_.end()) 610 arch = p->second; 611 else 612 { 613 Input_file_argument* input_file_arg = 614 new Input_file_argument(member_name->c_str(), 615 Input_file_argument::INPUT_FILE_TYPE_FILE, 616 "", false, parameters->options()); 617 *input_file = new Input_file(input_file_arg); 618 int dummy = 0; 619 if (!(*input_file)->open(*this->dirpath_, this->task_, &dummy)) 620 return false; 621 arch = new Archive(*member_name, *input_file, false, this->dirpath_, 622 this->task_); 623 arch->setup(); 624 std::pair<Nested_archive_table::iterator, bool> ins = 625 this->nested_archives_.insert(std::make_pair(*member_name, arch)); 626 gold_assert(ins.second); 627 } 628 return arch->get_file_and_offset(nested_off, input_file, memoff, 629 memsize, member_name); 630 } 631 632 // This is an external member of a thin archive. Open the 633 // file as a regular relocatable object file. 634 Input_file_argument* input_file_arg = 635 new Input_file_argument(member_name->c_str(), 636 Input_file_argument::INPUT_FILE_TYPE_FILE, 637 "", false, this->input_file_->options()); 638 *input_file = new Input_file(input_file_arg); 639 int dummy = 0; 640 if (!(*input_file)->open(*this->dirpath_, this->task_, &dummy)) 641 return false; 642 643 *memoff = 0; 644 *memsize = (*input_file)->file().filesize(); 645 return true; 646 } 647 648 // Return an ELF object for the member at offset OFF. If 649 // PUNCONFIGURED is not NULL, then if the ELF object has an 650 // unsupported target type, set *PUNCONFIGURED to true and return 651 // NULL. 652 653 Object* 654 Archive::get_elf_object_for_member(off_t off, bool* punconfigured) 655 { 656 if (punconfigured != NULL) 657 *punconfigured = false; 658 659 Input_file* input_file; 660 off_t memoff; 661 off_t memsize; 662 std::string member_name; 663 if (!this->get_file_and_offset(off, &input_file, &memoff, &memsize, 664 &member_name)) 665 return NULL; 666 667 const unsigned char* ehdr; 668 int read_size; 669 Object *obj = NULL; 670 bool is_elf_obj = false; 671 672 if (is_elf_object(input_file, memoff, &ehdr, &read_size)) 673 { 674 obj = make_elf_object((std::string(this->input_file_->filename()) 675 + "(" + member_name + ")"), 676 input_file, memoff, ehdr, read_size, 677 punconfigured); 678 is_elf_obj = true; 679 } 680 681 if (parameters->options().has_plugins()) 682 { 683 Object* plugin_obj 684 = parameters->options().plugins()->claim_file(input_file, 685 memoff, 686 memsize, 687 obj); 688 if (plugin_obj != NULL) 689 { 690 // The input file was claimed by a plugin, and its symbols 691 // have been provided by the plugin. 692 // Delete its elf object. 693 if (obj != NULL) 694 delete obj; 695 return plugin_obj; 696 } 697 } 698 699 if (!is_elf_obj) 700 { 701 gold_error(_("%s: member at %zu is not an ELF object"), 702 this->name().c_str(), static_cast<size_t>(off)); 703 return NULL; 704 } 705 706 if (obj == NULL) 707 return NULL; 708 obj->set_no_export(this->no_export()); 709 return obj; 710 } 711 712 // Read the symbols from all the archive members in the link. 713 714 void 715 Archive::read_all_symbols() 716 { 717 for (Archive::const_iterator p = this->begin(); 718 p != this->end(); 719 ++p) 720 this->read_symbols(p->off); 721 } 722 723 // Read the symbols from an archive member in the link. OFF is the file 724 // offset of the member header. 725 726 void 727 Archive::read_symbols(off_t off) 728 { 729 Object* obj = this->get_elf_object_for_member(off, NULL); 730 if (obj == NULL) 731 return; 732 733 Read_symbols_data* sd = new Read_symbols_data; 734 obj->read_symbols(sd); 735 Archive_member member(obj, sd); 736 this->members_[off] = member; 737 } 738 739 // Select members from the archive and add them to the link. We walk 740 // through the elements in the archive map, and look each one up in 741 // the symbol table. If it exists as a strong undefined symbol, we 742 // pull in the corresponding element. We have to do this in a loop, 743 // since pulling in one element may create new undefined symbols which 744 // may be satisfied by other objects in the archive. Return true in 745 // the normal case, false if the first member we tried to add from 746 // this archive had an incompatible target. 747 748 bool 749 Archive::add_symbols(Symbol_table* symtab, Layout* layout, 750 Input_objects* input_objects, Mapfile* mapfile) 751 { 752 ++Archive::total_archives; 753 754 if (this->input_file_->options().whole_archive()) 755 return this->include_all_members(symtab, layout, input_objects, 756 mapfile); 757 758 Archive::total_members += this->num_members_; 759 760 input_objects->archive_start(this); 761 762 const size_t armap_size = this->armap_.size(); 763 764 // This is a quick optimization, since we usually see many symbols 765 // in a row with the same offset. last_seen_offset holds the last 766 // offset we saw that was present in the seen_offsets_ set. 767 off_t last_seen_offset = -1; 768 769 // Track which symbols in the symbol table we've already found to be 770 // defined. 771 772 char* tmpbuf = NULL; 773 size_t tmpbuflen = 0; 774 bool added_new_object; 775 do 776 { 777 added_new_object = false; 778 for (size_t i = 0; i < armap_size; ++i) 779 { 780 if (this->armap_checked_[i]) 781 continue; 782 if (this->armap_[i].file_offset == last_seen_offset) 783 { 784 this->armap_checked_[i] = true; 785 continue; 786 } 787 if (this->seen_offsets_.find(this->armap_[i].file_offset) 788 != this->seen_offsets_.end()) 789 { 790 this->armap_checked_[i] = true; 791 last_seen_offset = this->armap_[i].file_offset; 792 continue; 793 } 794 795 const char* sym_name = (this->armap_names_.data() 796 + this->armap_[i].name_offset); 797 798 Symbol* sym; 799 std::string why; 800 Archive::Should_include t = 801 Archive::should_include_member(symtab, layout, sym_name, &sym, 802 &why, &tmpbuf, &tmpbuflen); 803 804 if (t == Archive::SHOULD_INCLUDE_NO 805 || t == Archive::SHOULD_INCLUDE_YES) 806 this->armap_checked_[i] = true; 807 808 if (t != Archive::SHOULD_INCLUDE_YES) 809 continue; 810 811 // We want to include this object in the link. 812 last_seen_offset = this->armap_[i].file_offset; 813 this->seen_offsets_.insert(last_seen_offset); 814 815 if (!this->include_member(symtab, layout, input_objects, 816 last_seen_offset, mapfile, sym, 817 why.c_str())) 818 { 819 if (tmpbuf != NULL) 820 free(tmpbuf); 821 return false; 822 } 823 824 added_new_object = true; 825 } 826 } 827 while (added_new_object); 828 829 if (tmpbuf != NULL) 830 free(tmpbuf); 831 832 input_objects->archive_stop(this); 833 834 return true; 835 } 836 837 // Return whether the archive includes a member which defines the 838 // symbol SYM. 839 840 bool 841 Archive::defines_symbol(Symbol* sym) const 842 { 843 const char* symname = sym->name(); 844 size_t symname_len = strlen(symname); 845 size_t armap_size = this->armap_.size(); 846 for (size_t i = 0; i < armap_size; ++i) 847 { 848 if (this->armap_checked_[i]) 849 continue; 850 const char* archive_symname = (this->armap_names_.data() 851 + this->armap_[i].name_offset); 852 if (strncmp(archive_symname, symname, symname_len) != 0) 853 continue; 854 char c = archive_symname[symname_len]; 855 if (c == '\0' && sym->version() == NULL) 856 return true; 857 if (c == '@') 858 { 859 const char* ver = archive_symname + symname_len + 1; 860 if (*ver == '@') 861 { 862 if (sym->version() == NULL) 863 return true; 864 ++ver; 865 } 866 if (sym->version() != NULL && strcmp(sym->version(), ver) == 0) 867 return true; 868 } 869 } 870 return false; 871 } 872 873 // Include all the archive members in the link. This is for --whole-archive. 874 875 bool 876 Archive::include_all_members(Symbol_table* symtab, Layout* layout, 877 Input_objects* input_objects, Mapfile* mapfile) 878 { 879 // Don't include the same archive twice. This can happen if 880 // --whole-archive is nested inside --start-group (PR gold/12163). 881 if (this->included_all_members_) 882 return true; 883 884 this->included_all_members_ = true; 885 886 input_objects->archive_start(this); 887 888 if (this->members_.size() > 0) 889 { 890 std::map<off_t, Archive_member>::const_iterator p; 891 for (p = this->members_.begin(); 892 p != this->members_.end(); 893 ++p) 894 { 895 if (!this->include_member(symtab, layout, input_objects, p->first, 896 mapfile, NULL, "--whole-archive")) 897 return false; 898 ++Archive::total_members; 899 } 900 } 901 else 902 { 903 for (Archive::const_iterator p = this->begin(); 904 p != this->end(); 905 ++p) 906 { 907 if (!this->include_member(symtab, layout, input_objects, p->off, 908 mapfile, NULL, "--whole-archive")) 909 return false; 910 ++Archive::total_members; 911 } 912 } 913 914 input_objects->archive_stop(this); 915 916 return true; 917 } 918 919 // Return the number of members in the archive. This is only used for 920 // reports. 921 922 size_t 923 Archive::count_members() 924 { 925 size_t ret = 0; 926 for (Archive::const_iterator p = this->begin(); 927 p != this->end(); 928 ++p) 929 ++ret; 930 return ret; 931 } 932 933 // RAII class to ensure we unlock the object if it's a member of a 934 // thin archive. We can't use Task_lock_obj in Archive::include_member 935 // because the object file is already locked when it's opened by 936 // get_elf_object_for_member. 937 938 class Thin_archive_object_unlocker 939 { 940 public: 941 Thin_archive_object_unlocker(const Task *task, Object* obj) 942 : task_(task), obj_(obj) 943 { } 944 945 ~Thin_archive_object_unlocker() 946 { 947 if (this->obj_->offset() == 0) 948 this->obj_->unlock(this->task_); 949 } 950 951 private: 952 Thin_archive_object_unlocker(const Thin_archive_object_unlocker&); 953 Thin_archive_object_unlocker& operator=(const Thin_archive_object_unlocker&); 954 955 const Task* task_; 956 Object* obj_; 957 }; 958 959 // Include an archive member in the link. OFF is the file offset of 960 // the member header. WHY is the reason we are including this member. 961 // Return true if we added the member or if we had an error, return 962 // false if this was the first member we tried to add from this 963 // archive and it had an incompatible format. 964 965 bool 966 Archive::include_member(Symbol_table* symtab, Layout* layout, 967 Input_objects* input_objects, off_t off, 968 Mapfile* mapfile, Symbol* sym, const char* why) 969 { 970 ++Archive::total_members_loaded; 971 972 std::map<off_t, Archive_member>::const_iterator p = this->members_.find(off); 973 if (p != this->members_.end()) 974 { 975 Object* obj = p->second.obj_; 976 977 Read_symbols_data* sd = p->second.sd_; 978 if (mapfile != NULL) 979 mapfile->report_include_archive_member(obj->name(), sym, why); 980 if (input_objects->add_object(obj)) 981 { 982 obj->layout(symtab, layout, sd); 983 obj->add_symbols(symtab, sd, layout); 984 this->included_member_ = true; 985 } 986 delete sd; 987 return true; 988 } 989 990 // If this is the first object we are including from this archive, 991 // and we searched for this archive, most likely because it was 992 // found via a -l option, then if the target is incompatible we want 993 // to move on to the next archive found in the search path. 994 bool unconfigured = false; 995 bool* punconfigured = NULL; 996 if (!this->included_member_ && this->searched_for()) 997 punconfigured = &unconfigured; 998 999 Object* obj = this->get_elf_object_for_member(off, punconfigured); 1000 if (obj == NULL) 1001 { 1002 // Return false to search for another archive, true if we found 1003 // an error. 1004 return unconfigured ? false : true; 1005 } 1006 1007 // If the object is an external member of a thin archive, 1008 // unlock it when we're done here. 1009 Thin_archive_object_unlocker unlocker(this->task_, obj); 1010 1011 if (mapfile != NULL) 1012 mapfile->report_include_archive_member(obj->name(), sym, why); 1013 1014 Pluginobj* pluginobj = obj->pluginobj(); 1015 if (pluginobj != NULL) 1016 { 1017 pluginobj->add_symbols(symtab, NULL, layout); 1018 this->included_member_ = true; 1019 return true; 1020 } 1021 1022 if (!input_objects->add_object(obj)) 1023 { 1024 delete obj; 1025 return true; 1026 } 1027 1028 if (layout->incremental_inputs() != NULL) 1029 layout->incremental_inputs()->report_object(obj, 0, this, NULL); 1030 1031 { 1032 Read_symbols_data sd; 1033 obj->read_symbols(&sd); 1034 obj->layout(symtab, layout, &sd); 1035 obj->add_symbols(symtab, &sd, layout); 1036 } 1037 1038 this->included_member_ = true; 1039 return true; 1040 } 1041 1042 // Iterate over all unused symbols, and call the visitor class V for each. 1043 1044 void 1045 Archive::do_for_all_unused_symbols(Symbol_visitor_base* v) const 1046 { 1047 for (std::vector<Armap_entry>::const_iterator p = this->armap_.begin(); 1048 p != this->armap_.end(); 1049 ++p) 1050 { 1051 if (this->seen_offsets_.find(p->file_offset) 1052 == this->seen_offsets_.end()) 1053 v->visit(this->armap_names_.data() + p->name_offset); 1054 } 1055 } 1056 1057 // Print statistical information to stderr. This is used for --stats. 1058 1059 void 1060 Archive::print_stats() 1061 { 1062 fprintf(stderr, _("%s: archive libraries: %u\n"), 1063 program_name, Archive::total_archives); 1064 fprintf(stderr, _("%s: total archive members: %u\n"), 1065 program_name, Archive::total_members); 1066 fprintf(stderr, _("%s: loaded archive members: %u\n"), 1067 program_name, Archive::total_members_loaded); 1068 } 1069 1070 // Add_archive_symbols methods. 1071 1072 Add_archive_symbols::~Add_archive_symbols() 1073 { 1074 if (this->this_blocker_ != NULL) 1075 delete this->this_blocker_; 1076 // next_blocker_ is deleted by the task associated with the next 1077 // input file. 1078 } 1079 1080 // Return whether we can add the archive symbols. We are blocked by 1081 // this_blocker_. We block next_blocker_. We also lock the file. 1082 1083 Task_token* 1084 Add_archive_symbols::is_runnable() 1085 { 1086 if (this->this_blocker_ != NULL && this->this_blocker_->is_blocked()) 1087 return this->this_blocker_; 1088 return NULL; 1089 } 1090 1091 void 1092 Add_archive_symbols::locks(Task_locker* tl) 1093 { 1094 tl->add(this, this->next_blocker_); 1095 tl->add(this, this->archive_->token()); 1096 } 1097 1098 void 1099 Add_archive_symbols::run(Workqueue* workqueue) 1100 { 1101 // For an incremental link, begin recording layout information. 1102 Incremental_inputs* incremental_inputs = this->layout_->incremental_inputs(); 1103 if (incremental_inputs != NULL) 1104 { 1105 unsigned int arg_serial = this->input_argument_->file().arg_serial(); 1106 Script_info* script_info = this->input_argument_->script_info(); 1107 incremental_inputs->report_archive_begin(this->archive_, arg_serial, 1108 script_info); 1109 } 1110 1111 bool added = this->archive_->add_symbols(this->symtab_, this->layout_, 1112 this->input_objects_, 1113 this->mapfile_); 1114 this->archive_->unlock_nested_archives(); 1115 1116 this->archive_->release(); 1117 this->archive_->clear_uncached_views(); 1118 1119 if (!added) 1120 { 1121 // This archive holds object files which are incompatible with 1122 // our output file. 1123 Read_symbols::incompatible_warning(this->input_argument_, 1124 this->archive_->input_file()); 1125 Read_symbols::requeue(workqueue, this->input_objects_, this->symtab_, 1126 this->layout_, this->dirpath_, this->dirindex_, 1127 this->mapfile_, this->input_argument_, 1128 this->input_group_, this->next_blocker_); 1129 delete this->archive_; 1130 return; 1131 } 1132 1133 if (this->input_group_ != NULL) 1134 this->input_group_->add_archive(this->archive_); 1135 else 1136 { 1137 // For an incremental link, finish recording the layout information. 1138 if (incremental_inputs != NULL) 1139 incremental_inputs->report_archive_end(this->archive_); 1140 1141 if (!parameters->options().has_plugins() 1142 || this->archive_->input_file()->options().whole_archive()) 1143 { 1144 // We no longer need to know about this archive. 1145 delete this->archive_; 1146 } 1147 else 1148 { 1149 // The plugin interface may want to rescan this archive. 1150 parameters->options().plugins()->save_archive(this->archive_); 1151 } 1152 1153 this->archive_ = NULL; 1154 } 1155 } 1156 1157 // Class Lib_group static variables. 1158 unsigned int Lib_group::total_lib_groups; 1159 unsigned int Lib_group::total_members; 1160 unsigned int Lib_group::total_members_loaded; 1161 1162 Lib_group::Lib_group(const Input_file_lib* lib, Task* task) 1163 : Library_base(task), members_() 1164 { 1165 this->members_.resize(lib->size()); 1166 } 1167 1168 const std::string& 1169 Lib_group::do_filename() const 1170 { 1171 std::string *filename = new std::string("/group/"); 1172 return *filename; 1173 } 1174 1175 // Select members from the lib group and add them to the link. We walk 1176 // through the members, and check if each one up should be included. 1177 // If the object says it should be included, we do so. We have to do 1178 // this in a loop, since including one member may create new undefined 1179 // symbols which may be satisfied by other members. 1180 1181 void 1182 Lib_group::add_symbols(Symbol_table* symtab, Layout* layout, 1183 Input_objects* input_objects) 1184 { 1185 ++Lib_group::total_lib_groups; 1186 1187 Lib_group::total_members += this->members_.size(); 1188 1189 bool added_new_object; 1190 do 1191 { 1192 added_new_object = false; 1193 unsigned int i = 0; 1194 while (i < this->members_.size()) 1195 { 1196 const Archive_member& member = this->members_[i]; 1197 Object* obj = member.obj_; 1198 std::string why; 1199 1200 // Skip files with no symbols. Plugin objects have 1201 // member.sd_ == NULL. 1202 if (obj != NULL 1203 && (member.sd_ == NULL || member.sd_->symbol_names != NULL)) 1204 { 1205 Archive::Should_include t = obj->should_include_member(symtab, 1206 layout, 1207 member.sd_, 1208 &why); 1209 1210 if (t != Archive::SHOULD_INCLUDE_YES) 1211 { 1212 ++i; 1213 continue; 1214 } 1215 1216 this->include_member(symtab, layout, input_objects, member); 1217 1218 added_new_object = true; 1219 } 1220 else 1221 { 1222 if (member.sd_ != NULL) 1223 { 1224 // The file must be locked in order to destroy the views 1225 // associated with it. 1226 gold_assert(obj != NULL); 1227 obj->lock(this->task_); 1228 delete member.sd_; 1229 obj->unlock(this->task_); 1230 } 1231 } 1232 1233 this->members_[i] = this->members_.back(); 1234 this->members_.pop_back(); 1235 } 1236 } 1237 while (added_new_object); 1238 } 1239 1240 // Include a lib group member in the link. 1241 1242 void 1243 Lib_group::include_member(Symbol_table* symtab, Layout* layout, 1244 Input_objects* input_objects, 1245 const Archive_member& member) 1246 { 1247 ++Lib_group::total_members_loaded; 1248 1249 Object* obj = member.obj_; 1250 gold_assert(obj != NULL); 1251 1252 Pluginobj* pluginobj = obj->pluginobj(); 1253 if (pluginobj != NULL) 1254 { 1255 pluginobj->add_symbols(symtab, NULL, layout); 1256 return; 1257 } 1258 1259 Read_symbols_data* sd = member.sd_; 1260 gold_assert(sd != NULL); 1261 obj->lock(this->task_); 1262 if (input_objects->add_object(obj)) 1263 { 1264 if (layout->incremental_inputs() != NULL) 1265 layout->incremental_inputs()->report_object(obj, member.arg_serial_, 1266 this, NULL); 1267 obj->layout(symtab, layout, sd); 1268 obj->add_symbols(symtab, sd, layout); 1269 } 1270 delete sd; 1271 // Unlock the file for the next task. 1272 obj->unlock(this->task_); 1273 } 1274 1275 // Iterate over all unused symbols, and call the visitor class V for each. 1276 1277 void 1278 Lib_group::do_for_all_unused_symbols(Symbol_visitor_base* v) const 1279 { 1280 // Files are removed from the members list when used, so all the 1281 // files remaining on the list are unused. 1282 for (std::vector<Archive_member>::const_iterator p = this->members_.begin(); 1283 p != this->members_.end(); 1284 ++p) 1285 { 1286 Object* obj = p->obj_; 1287 obj->for_all_global_symbols(p->sd_, v); 1288 } 1289 } 1290 1291 // Print statistical information to stderr. This is used for --stats. 1292 1293 void 1294 Lib_group::print_stats() 1295 { 1296 fprintf(stderr, _("%s: lib groups: %u\n"), 1297 program_name, Lib_group::total_lib_groups); 1298 fprintf(stderr, _("%s: total lib groups members: %u\n"), 1299 program_name, Lib_group::total_members); 1300 fprintf(stderr, _("%s: loaded lib groups members: %u\n"), 1301 program_name, Lib_group::total_members_loaded); 1302 } 1303 1304 Task_token* 1305 Add_lib_group_symbols::is_runnable() 1306 { 1307 if (this->readsyms_blocker_ != NULL && this->readsyms_blocker_->is_blocked()) 1308 return this->readsyms_blocker_; 1309 if (this->this_blocker_ != NULL && this->this_blocker_->is_blocked()) 1310 return this->this_blocker_; 1311 return NULL; 1312 } 1313 1314 void 1315 Add_lib_group_symbols::locks(Task_locker* tl) 1316 { 1317 tl->add(this, this->next_blocker_); 1318 } 1319 1320 void 1321 Add_lib_group_symbols::run(Workqueue*) 1322 { 1323 // For an incremental link, begin recording layout information. 1324 Incremental_inputs* incremental_inputs = this->layout_->incremental_inputs(); 1325 if (incremental_inputs != NULL) 1326 incremental_inputs->report_archive_begin(this->lib_, 0, NULL); 1327 1328 this->lib_->add_symbols(this->symtab_, this->layout_, this->input_objects_); 1329 1330 if (incremental_inputs != NULL) 1331 incremental_inputs->report_archive_end(this->lib_); 1332 } 1333 1334 Add_lib_group_symbols::~Add_lib_group_symbols() 1335 { 1336 if (this->this_blocker_ != NULL) 1337 delete this->this_blocker_; 1338 // next_blocker_ is deleted by the task associated with the next 1339 // input file. 1340 } 1341 1342 } // End namespace gold. 1343
