1 // inremental.h -- incremental linking support for gold -*- C++ -*- 2 3 // Copyright (C) 2009-2020 Free Software Foundation, Inc. 4 // Written by Mikolaj Zalewski <mikolajz@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 #ifndef GOLD_INCREMENTAL_H 24 #define GOLD_INCREMENTAL_H 25 26 #include <map> 27 #include <vector> 28 29 #include "elfcpp_file.h" 30 #include "stringpool.h" 31 #include "workqueue.h" 32 #include "fileread.h" 33 #include "output.h" 34 #include "archive.h" 35 36 namespace gold 37 { 38 39 class Input_argument; 40 class Incremental_inputs_checker; 41 class Incremental_script_entry; 42 class Incremental_object_entry; 43 class Incremental_dynobj_entry; 44 class Incremental_archive_entry; 45 class Incremental_inputs; 46 class Incremental_binary; 47 class Incremental_library; 48 class Object; 49 50 // Incremental input type as stored in .gnu_incremental_inputs. 51 52 enum Incremental_input_type 53 { 54 INCREMENTAL_INPUT_OBJECT = 1, 55 INCREMENTAL_INPUT_ARCHIVE_MEMBER = 2, 56 INCREMENTAL_INPUT_ARCHIVE = 3, 57 INCREMENTAL_INPUT_SHARED_LIBRARY = 4, 58 INCREMENTAL_INPUT_SCRIPT = 5 59 }; 60 61 // Incremental input file flags. 62 // The input file type is stored in the lower eight bits. 63 64 enum Incremental_input_flags 65 { 66 INCREMENTAL_INPUT_IN_SYSTEM_DIR = 0x8000, 67 INCREMENTAL_INPUT_AS_NEEDED = 0x4000 68 }; 69 70 // Symbol flags for the incremental symbol table. 71 // These flags are stored in the top two bits of 72 // the symbol index field. 73 74 enum Incremental_shlib_symbol_flags 75 { 76 // Symbol is defined in this library. 77 INCREMENTAL_SHLIB_SYM_DEF = 2, 78 // Symbol is defined in this library, with a COPY relocation. 79 INCREMENTAL_SHLIB_SYM_COPY = 3 80 }; 81 82 static const int INCREMENTAL_SHLIB_SYM_FLAGS_SHIFT = 30; 83 84 // Return TRUE if a section of type SH_TYPE can be updated in place 85 // during an incremental update. 86 bool 87 can_incremental_update(unsigned int sh_type); 88 89 // Create an Incremental_binary object for FILE. Returns NULL is this is not 90 // possible, e.g. FILE is not an ELF file or has an unsupported target. 91 92 Incremental_binary* 93 open_incremental_binary(Output_file* file); 94 95 // Base class for recording each input file. 96 97 class Incremental_input_entry 98 { 99 public: 100 Incremental_input_entry(Stringpool::Key filename_key, unsigned int arg_serial, 101 Timespec mtime) 102 : filename_key_(filename_key), file_index_(0), offset_(0), info_offset_(0), 103 arg_serial_(arg_serial), mtime_(mtime), is_in_system_directory_(false), 104 as_needed_(false) 105 { } 106 107 virtual 108 ~Incremental_input_entry() 109 { } 110 111 // Return the type of input file. 112 Incremental_input_type 113 type() const 114 { return this->do_type(); } 115 116 // Set the index and section offset of this input file entry. 117 void 118 set_offset(unsigned int file_index, unsigned int offset) 119 { 120 this->file_index_ = file_index; 121 this->offset_ = offset; 122 } 123 124 // Set the section offset of the supplemental information for this entry. 125 void 126 set_info_offset(unsigned int info_offset) 127 { this->info_offset_ = info_offset; } 128 129 // Get the index of this input file entry. 130 unsigned int 131 get_file_index() const 132 { return this->file_index_; } 133 134 // Get the section offset of this input file entry. 135 unsigned int 136 get_offset() const 137 { return this->offset_; } 138 139 // Get the section offset of the supplemental information for this entry. 140 unsigned int 141 get_info_offset() const 142 { return this->info_offset_; } 143 144 // Get the stringpool key for the input filename. 145 Stringpool::Key 146 get_filename_key() const 147 { return this->filename_key_; } 148 149 // Get the serial number of the input file. 150 unsigned int 151 arg_serial() const 152 { return this->arg_serial_; } 153 154 // Get the modification time of the input file. 155 const Timespec& 156 get_mtime() const 157 { return this->mtime_; } 158 159 // Record that the file was found in a system directory. 160 void 161 set_is_in_system_directory() 162 { this->is_in_system_directory_ = true; } 163 164 // Return TRUE if the file was found in a system directory. 165 bool 166 is_in_system_directory() const 167 { return this->is_in_system_directory_; } 168 169 // Record that the file was linked with --as-needed. 170 void 171 set_as_needed() 172 { this->as_needed_ = true; } 173 174 // Return TRUE if the file was linked with --as-needed. 175 bool 176 as_needed() const 177 { return this->as_needed_; } 178 179 // Return a pointer to the derived Incremental_script_entry object. 180 // Return NULL for input entries that are not script files. 181 Incremental_script_entry* 182 script_entry() 183 { return this->do_script_entry(); } 184 185 // Return a pointer to the derived Incremental_object_entry object. 186 // Return NULL for input entries that are not object files. 187 Incremental_object_entry* 188 object_entry() 189 { return this->do_object_entry(); } 190 191 // Return a pointer to the derived Incremental_dynobj_entry object. 192 // Return NULL for input entries that are not shared object files. 193 Incremental_dynobj_entry* 194 dynobj_entry() 195 { return this->do_dynobj_entry(); } 196 197 // Return a pointer to the derived Incremental_archive_entry object. 198 // Return NULL for input entries that are not archive files. 199 Incremental_archive_entry* 200 archive_entry() 201 { return this->do_archive_entry(); } 202 203 protected: 204 // Return the type of input file. 205 virtual Incremental_input_type 206 do_type() const = 0; 207 208 // Return a pointer to the derived Incremental_script_entry object. 209 // Return NULL for input entries that are not script files. 210 virtual Incremental_script_entry* 211 do_script_entry() 212 { return NULL; } 213 214 // Return a pointer to the derived Incremental_object_entry object. 215 // Return NULL for input entries that are not object files. 216 virtual Incremental_object_entry* 217 do_object_entry() 218 { return NULL; } 219 220 // Return a pointer to the derived Incremental_dynobj_entry object. 221 // Return NULL for input entries that are not shared object files. 222 virtual Incremental_dynobj_entry* 223 do_dynobj_entry() 224 { return NULL; } 225 226 // Return a pointer to the derived Incremental_archive_entry object. 227 // Return NULL for input entries that are not archive files. 228 virtual Incremental_archive_entry* 229 do_archive_entry() 230 { return NULL; } 231 232 private: 233 // Key of the filename string in the section stringtable. 234 Stringpool::Key filename_key_; 235 236 // Index of the entry in the output section. 237 unsigned int file_index_; 238 239 // Offset of the entry in the output section. 240 unsigned int offset_; 241 242 // Offset of the extra information in the output section. 243 unsigned int info_offset_; 244 245 // Serial number of the file in the argument list. 246 unsigned int arg_serial_; 247 248 // Last modification time of the file. 249 Timespec mtime_; 250 251 // TRUE if the file was found in a system directory. 252 bool is_in_system_directory_; 253 254 // TRUE if the file was linked with --as-needed. 255 bool as_needed_; 256 }; 257 258 // Information about a script input that will persist during the whole linker 259 // run. Needed only during an incremental build to retrieve the input files 260 // added by this script. 261 262 class Script_info 263 { 264 public: 265 Script_info(const std::string& filename) 266 : filename_(filename), input_file_index_(0), 267 incremental_script_entry_(NULL) 268 { } 269 270 Script_info(const std::string& filename, unsigned int input_file_index) 271 : filename_(filename), input_file_index_(input_file_index), 272 incremental_script_entry_(NULL) 273 { } 274 275 // Store a pointer to the incremental information for this script. 276 void 277 set_incremental_info(Incremental_script_entry* entry) 278 { this->incremental_script_entry_ = entry; } 279 280 // Return the filename. 281 const std::string& 282 filename() const 283 { return this->filename_; } 284 285 // Return the input file index. 286 unsigned int 287 input_file_index() const 288 { return this->input_file_index_; } 289 290 // Return the pointer to the incremental information for this script. 291 Incremental_script_entry* 292 incremental_info() const 293 { return this->incremental_script_entry_; } 294 295 private: 296 const std::string filename_; 297 unsigned int input_file_index_; 298 Incremental_script_entry* incremental_script_entry_; 299 }; 300 301 // Class for recording input scripts. 302 303 class Incremental_script_entry : public Incremental_input_entry 304 { 305 public: 306 Incremental_script_entry(Stringpool::Key filename_key, 307 unsigned int arg_serial, Script_info* /*script*/, 308 Timespec mtime) 309 : Incremental_input_entry(filename_key, arg_serial, mtime), 310 objects_() 311 { } 312 313 // Add a member object to the archive. 314 void 315 add_object(Incremental_input_entry* obj_entry) 316 { 317 this->objects_.push_back(obj_entry); 318 } 319 320 // Return the number of objects included by this script. 321 unsigned int 322 get_object_count() 323 { return this->objects_.size(); } 324 325 // Return the Nth object. 326 Incremental_input_entry* 327 get_object(unsigned int n) 328 { 329 gold_assert(n < this->objects_.size()); 330 return this->objects_[n]; 331 } 332 333 protected: 334 virtual Incremental_input_type 335 do_type() const 336 { return INCREMENTAL_INPUT_SCRIPT; } 337 338 // Return a pointer to the derived Incremental_script_entry object. 339 virtual Incremental_script_entry* 340 do_script_entry() 341 { return this; } 342 343 private: 344 // Objects that have been included by this script. 345 std::vector<Incremental_input_entry*> objects_; 346 }; 347 348 // Class for recording input object files. 349 350 class Incremental_object_entry : public Incremental_input_entry 351 { 352 public: 353 Incremental_object_entry(Stringpool::Key filename_key, Object* obj, 354 unsigned int arg_serial, Timespec mtime) 355 : Incremental_input_entry(filename_key, arg_serial, mtime), obj_(obj), 356 is_member_(false), sections_(), groups_() 357 { this->sections_.reserve(obj->shnum()); } 358 359 // Get the object. 360 Object* 361 object() const 362 { return this->obj_; } 363 364 // Record that this object is an archive member. 365 void 366 set_is_member() 367 { this->is_member_ = true; } 368 369 // Return true if this object is an archive member. 370 bool 371 is_member() const 372 { return this->is_member_; } 373 374 // Add an input section. 375 void 376 add_input_section(unsigned int shndx, Stringpool::Key name_key, off_t sh_size) 377 { this->sections_.push_back(Input_section(shndx, name_key, sh_size)); } 378 379 // Return the number of input sections in this object. 380 unsigned int 381 get_input_section_count() const 382 { return this->sections_.size(); } 383 384 // Return the input section index for the Nth input section. 385 Stringpool::Key 386 get_input_section_index(unsigned int n) const 387 { return this->sections_[n].shndx_; } 388 389 // Return the stringpool key of the Nth input section. 390 Stringpool::Key 391 get_input_section_name_key(unsigned int n) const 392 { return this->sections_[n].name_key_; } 393 394 // Return the size of the Nth input section. 395 off_t 396 get_input_section_size(unsigned int n) const 397 { return this->sections_[n].sh_size_; } 398 399 // Add a kept COMDAT group. 400 void 401 add_comdat_group(Stringpool::Key signature_key) 402 { this->groups_.push_back(signature_key); } 403 404 // Return the number of COMDAT groups. 405 unsigned int 406 get_comdat_group_count() const 407 { return this->groups_.size(); } 408 409 // Return the stringpool key for the signature of the Nth comdat group. 410 Stringpool::Key 411 get_comdat_signature_key(unsigned int n) const 412 { return this->groups_[n]; } 413 414 protected: 415 virtual Incremental_input_type 416 do_type() const 417 { 418 return (this->is_member_ 419 ? INCREMENTAL_INPUT_ARCHIVE_MEMBER 420 : INCREMENTAL_INPUT_OBJECT); 421 } 422 423 // Return a pointer to the derived Incremental_object_entry object. 424 virtual Incremental_object_entry* 425 do_object_entry() 426 { return this; } 427 428 private: 429 // The object file itself. 430 Object* obj_; 431 432 // Whether this object is an archive member. 433 bool is_member_; 434 435 // Input sections. 436 struct Input_section 437 { 438 Input_section(unsigned int shndx, Stringpool::Key name_key, off_t sh_size) 439 : shndx_(shndx), name_key_(name_key), sh_size_(sh_size) 440 { } 441 unsigned int shndx_; 442 Stringpool::Key name_key_; 443 off_t sh_size_; 444 }; 445 std::vector<Input_section> sections_; 446 447 // COMDAT groups. 448 std::vector<Stringpool::Key> groups_; 449 }; 450 451 // Class for recording shared library input files. 452 453 class Incremental_dynobj_entry : public Incremental_input_entry 454 { 455 public: 456 Incremental_dynobj_entry(Stringpool::Key filename_key, 457 Stringpool::Key soname_key, Object* obj, 458 unsigned int arg_serial, Timespec mtime) 459 : Incremental_input_entry(filename_key, arg_serial, mtime), 460 soname_key_(soname_key), obj_(obj) 461 { } 462 463 // Get the object. 464 Object* 465 object() const 466 { return this->obj_; } 467 468 // Get the stringpool key for the soname. 469 Stringpool::Key 470 get_soname_key() const 471 { return this->soname_key_; } 472 473 protected: 474 virtual Incremental_input_type 475 do_type() const 476 { return INCREMENTAL_INPUT_SHARED_LIBRARY; } 477 478 // Return a pointer to the derived Incremental_dynobj_entry object. 479 virtual Incremental_dynobj_entry* 480 do_dynobj_entry() 481 { return this; } 482 483 private: 484 // Key of the soname string in the section stringtable. 485 Stringpool::Key soname_key_; 486 487 // The object file itself. 488 Object* obj_; 489 }; 490 491 // Class for recording archive library input files. 492 493 class Incremental_archive_entry : public Incremental_input_entry 494 { 495 public: 496 Incremental_archive_entry(Stringpool::Key filename_key, 497 unsigned int arg_serial, Timespec mtime) 498 : Incremental_input_entry(filename_key, arg_serial, mtime), members_(), 499 unused_syms_() 500 { } 501 502 // Add a member object to the archive. 503 void 504 add_object(Incremental_object_entry* obj_entry) 505 { 506 this->members_.push_back(obj_entry); 507 obj_entry->set_is_member(); 508 } 509 510 // Add an unused global symbol to the archive. 511 void 512 add_unused_global_symbol(Stringpool::Key symbol_key) 513 { this->unused_syms_.push_back(symbol_key); } 514 515 // Return the number of member objects included in the link. 516 unsigned int 517 get_member_count() 518 { return this->members_.size(); } 519 520 // Return the Nth member object. 521 Incremental_object_entry* 522 get_member(unsigned int n) 523 { return this->members_[n]; } 524 525 // Return the number of unused global symbols in this archive. 526 unsigned int 527 get_unused_global_symbol_count() 528 { return this->unused_syms_.size(); } 529 530 // Return the Nth unused global symbol. 531 Stringpool::Key 532 get_unused_global_symbol(unsigned int n) 533 { return this->unused_syms_[n]; } 534 535 protected: 536 virtual Incremental_input_type 537 do_type() const 538 { return INCREMENTAL_INPUT_ARCHIVE; } 539 540 // Return a pointer to the derived Incremental_archive_entry object. 541 virtual Incremental_archive_entry* 542 do_archive_entry() 543 { return this; } 544 545 private: 546 // Members of the archive that have been included in the link. 547 std::vector<Incremental_object_entry*> members_; 548 549 // Unused global symbols from this archive. 550 std::vector<Stringpool::Key> unused_syms_; 551 }; 552 553 // This class contains the information needed during an incremental 554 // build about the inputs necessary to build the .gnu_incremental_inputs. 555 556 class Incremental_inputs 557 { 558 public: 559 typedef std::vector<Incremental_input_entry*> Input_list; 560 561 Incremental_inputs() 562 : inputs_(), command_line_(), command_line_key_(0), 563 strtab_(new Stringpool()), current_object_(NULL), 564 current_object_entry_(NULL), inputs_section_(NULL), 565 symtab_section_(NULL), relocs_section_(NULL), 566 reloc_count_(0) 567 { } 568 569 ~Incremental_inputs() { delete this->strtab_; } 570 571 // Record the command line. 572 void 573 report_command_line(int argc, const char* const* argv); 574 575 // Record the initial info for archive file ARCHIVE. 576 void 577 report_archive_begin(Library_base* arch, unsigned int arg_serial, 578 Script_info* script_info); 579 580 // Record the final info for archive file ARCHIVE. 581 void 582 report_archive_end(Library_base* arch); 583 584 // Record the info for object file OBJ. If ARCH is not NULL, 585 // attach the object file to the archive. 586 void 587 report_object(Object* obj, unsigned int arg_serial, Library_base* arch, 588 Script_info* script_info); 589 590 // Record an input section belonging to object file OBJ. 591 void 592 report_input_section(Object* obj, unsigned int shndx, const char* name, 593 off_t sh_size); 594 595 // Record a kept COMDAT group belonging to object file OBJ. 596 void 597 report_comdat_group(Object* obj, const char* name); 598 599 // Record the info for input script SCRIPT. 600 void 601 report_script(Script_info* script, unsigned int arg_serial, 602 Timespec mtime); 603 604 // Return the running count of incremental relocations. 605 unsigned int 606 get_reloc_count() const 607 { return this->reloc_count_; } 608 609 // Update the running count of incremental relocations. 610 void 611 set_reloc_count(unsigned int count) 612 { this->reloc_count_ = count; } 613 614 // Prepare for layout. Called from Layout::finalize. 615 void 616 finalize(); 617 618 // Create the .gnu_incremental_inputs and related sections. 619 void 620 create_data_sections(Symbol_table* symtab); 621 622 // Return the .gnu_incremental_inputs section. 623 Output_section_data* 624 inputs_section() const 625 { return this->inputs_section_; } 626 627 // Return the .gnu_incremental_symtab section. 628 Output_data_space* 629 symtab_section() const 630 { return this->symtab_section_; } 631 632 // Return the .gnu_incremental_relocs section. 633 Output_data_space* 634 relocs_section() const 635 { return this->relocs_section_; } 636 637 // Return the .gnu_incremental_got_plt section. 638 Output_data_space* 639 got_plt_section() const 640 { return this->got_plt_section_; } 641 642 // Return the .gnu_incremental_strtab stringpool. 643 Stringpool* 644 get_stringpool() const 645 { return this->strtab_; } 646 647 // Return the canonical form of the command line, as will be stored in 648 // .gnu_incremental_strtab. 649 const std::string& 650 command_line() const 651 { return this->command_line_; } 652 653 // Return the stringpool key of the command line. 654 Stringpool::Key 655 command_line_key() const 656 { return this->command_line_key_; } 657 658 // Return the number of input files. 659 int 660 input_file_count() const 661 { return this->inputs_.size(); } 662 663 // Return the input files. 664 const Input_list& 665 input_files() const 666 { return this->inputs_; } 667 668 // Return the sh_entsize value for the .gnu_incremental_relocs section. 669 unsigned int 670 relocs_entsize() const; 671 672 private: 673 // The list of input files. 674 Input_list inputs_; 675 676 // Canonical form of the command line, as will be stored in 677 // .gnu_incremental_strtab. 678 std::string command_line_; 679 680 // The key of the command line string in the string pool. 681 Stringpool::Key command_line_key_; 682 683 // The .gnu_incremental_strtab string pool associated with the 684 // .gnu_incremental_inputs. 685 Stringpool* strtab_; 686 687 // Keep track of the object currently being processed. 688 Object* current_object_; 689 Incremental_object_entry* current_object_entry_; 690 691 // The .gnu_incremental_inputs section. 692 Output_section_data* inputs_section_; 693 694 // The .gnu_incremental_symtab section. 695 Output_data_space* symtab_section_; 696 697 // The .gnu_incremental_relocs section. 698 Output_data_space* relocs_section_; 699 700 // The .gnu_incremental_got_plt section. 701 Output_data_space* got_plt_section_; 702 703 // Total count of incremental relocations. Updated during Scan_relocs 704 // phase at the completion of each object file. 705 unsigned int reloc_count_; 706 }; 707 708 // Reader class for global symbol info from an object file entry in 709 // the .gnu_incremental_inputs section. 710 711 template<bool big_endian> 712 class Incremental_global_symbol_reader 713 { 714 private: 715 typedef elfcpp::Swap<32, big_endian> Swap32; 716 717 public: 718 Incremental_global_symbol_reader(const unsigned char* p) 719 : p_(p) 720 { } 721 722 unsigned int 723 output_symndx() const 724 { return Swap32::readval(this->p_); } 725 726 unsigned int 727 shndx() const 728 { return Swap32::readval(this->p_ + 4); } 729 730 unsigned int 731 next_offset() const 732 { return Swap32::readval(this->p_ + 8); } 733 734 unsigned int 735 reloc_count() const 736 { return Swap32::readval(this->p_ + 12); } 737 738 unsigned int 739 reloc_offset() const 740 { return Swap32::readval(this->p_ + 16); } 741 742 private: 743 // Base address of the symbol entry. 744 const unsigned char* p_; 745 }; 746 747 // Reader class for .gnu_incremental_inputs section. 748 749 template<int size, bool big_endian> 750 class Incremental_inputs_reader 751 { 752 private: 753 typedef elfcpp::Swap<size, big_endian> Swap; 754 typedef elfcpp::Swap<16, big_endian> Swap16; 755 typedef elfcpp::Swap<32, big_endian> Swap32; 756 typedef elfcpp::Swap<64, big_endian> Swap64; 757 758 public: 759 // Size of the .gnu_incremental_inputs header. 760 // (3 x 4-byte fields, plus 4 bytes padding.) 761 static const unsigned int header_size = 16; 762 // Size of an input file entry. 763 // (2 x 4-byte fields, 1 x 12-byte field, 2 x 2-byte fields.) 764 static const unsigned int input_entry_size = 24; 765 // Size of the first part of the supplemental info block for 766 // relocatable objects and archive members. 767 // (7 x 4-byte fields, plus 4 bytes padding.) 768 static const unsigned int object_info_size = 32; 769 // Size of an input section entry. 770 // (2 x 4-byte fields, 2 x address-sized fields.) 771 static const unsigned int input_section_entry_size = 8 + 2 * size / 8; 772 // Size of a global symbol entry in the supplemental info block. 773 // (5 x 4-byte fields.) 774 static const unsigned int global_sym_entry_size = 20; 775 776 Incremental_inputs_reader() 777 : p_(NULL), strtab_(NULL, 0), input_file_count_(0) 778 { } 779 780 Incremental_inputs_reader(const unsigned char* p, 781 const elfcpp::Elf_strtab& strtab) 782 : p_(p), strtab_(strtab) 783 { this->input_file_count_ = Swap32::readval(this->p_ + 4); } 784 785 // Return the version number. 786 unsigned int 787 version() const 788 { return Swap32::readval(this->p_); } 789 790 // Return the count of input file entries. 791 unsigned int 792 input_file_count() const 793 { return this->input_file_count_; } 794 795 // Return the command line. 796 const char* 797 command_line() const 798 { 799 unsigned int offset = Swap32::readval(this->p_ + 8); 800 return this->get_string(offset); 801 } 802 803 // Reader class for an input file entry and its supplemental info. 804 class Incremental_input_entry_reader 805 { 806 private: 807 static const unsigned int object_info_size = 808 Incremental_inputs_reader<size, big_endian>::object_info_size; 809 static const unsigned int input_section_entry_size = 810 Incremental_inputs_reader<size, big_endian>::input_section_entry_size; 811 static const unsigned int global_sym_entry_size = 812 Incremental_inputs_reader<size, big_endian>::global_sym_entry_size; 813 814 public: 815 Incremental_input_entry_reader(const Incremental_inputs_reader* inputs, 816 unsigned int offset) 817 : inputs_(inputs), offset_(offset) 818 { 819 this->info_offset_ = Swap32::readval(inputs->p_ + offset + 4); 820 this->flags_ = Swap16::readval(this->inputs_->p_ + offset + 20); 821 } 822 823 // Return the filename. 824 const char* 825 filename() const 826 { 827 unsigned int offset = Swap32::readval(this->inputs_->p_ + this->offset_); 828 return this->inputs_->get_string(offset); 829 } 830 831 // Return the argument serial number. 832 unsigned int 833 arg_serial() const 834 { 835 return Swap16::readval(this->inputs_->p_ + this->offset_ + 22); 836 } 837 838 // Return the timestamp. 839 Timespec 840 get_mtime() const 841 { 842 Timespec t; 843 const unsigned char* p = this->inputs_->p_ + this->offset_ + 8; 844 t.seconds = Swap64::readval(p); 845 t.nanoseconds = Swap32::readval(p+8); 846 return t; 847 } 848 849 // Return the type of input file. 850 Incremental_input_type 851 type() const 852 { return static_cast<Incremental_input_type>(this->flags_ & 0xff); } 853 854 // Return TRUE if the file was found in a system directory. 855 bool 856 is_in_system_directory() const 857 { return (this->flags_ & INCREMENTAL_INPUT_IN_SYSTEM_DIR) != 0; } 858 859 // Return TRUE if the file was linked with --as-needed. 860 bool 861 as_needed() const 862 { return (this->flags_ & INCREMENTAL_INPUT_AS_NEEDED) != 0; } 863 864 // Return the input section count -- for objects only. 865 unsigned int 866 get_input_section_count() const 867 { 868 gold_assert(this->type() == INCREMENTAL_INPUT_OBJECT 869 || this->type() == INCREMENTAL_INPUT_ARCHIVE_MEMBER); 870 return Swap32::readval(this->inputs_->p_ + this->info_offset_); 871 } 872 873 // Return the soname -- for shared libraries only. 874 const char* 875 get_soname() const 876 { 877 gold_assert(this->type() == INCREMENTAL_INPUT_SHARED_LIBRARY); 878 unsigned int offset = Swap32::readval(this->inputs_->p_ 879 + this->info_offset_); 880 return this->inputs_->get_string(offset); 881 } 882 883 // Return the offset of the supplemental info for symbol SYMNDX -- 884 // for objects only. 885 unsigned int 886 get_symbol_offset(unsigned int symndx) const 887 { 888 gold_assert(this->type() == INCREMENTAL_INPUT_OBJECT 889 || this->type() == INCREMENTAL_INPUT_ARCHIVE_MEMBER); 890 891 unsigned int section_count = this->get_input_section_count(); 892 return (this->info_offset_ 893 + this->object_info_size 894 + section_count * this->input_section_entry_size 895 + symndx * this->global_sym_entry_size); 896 } 897 898 // Return the global symbol count -- for objects & shared libraries only. 899 unsigned int 900 get_global_symbol_count() const 901 { 902 gold_assert(this->type() == INCREMENTAL_INPUT_OBJECT 903 || this->type() == INCREMENTAL_INPUT_ARCHIVE_MEMBER 904 || this->type() == INCREMENTAL_INPUT_SHARED_LIBRARY); 905 return Swap32::readval(this->inputs_->p_ + this->info_offset_ + 4); 906 } 907 908 // Return the offset of the first local symbol -- for objects only. 909 unsigned int 910 get_local_symbol_offset() const 911 { 912 gold_assert(this->type() == INCREMENTAL_INPUT_OBJECT 913 || this->type() == INCREMENTAL_INPUT_ARCHIVE_MEMBER); 914 915 return Swap32::readval(this->inputs_->p_ + this->info_offset_ + 8); 916 } 917 918 // Return the local symbol count -- for objects only. 919 unsigned int 920 get_local_symbol_count() const 921 { 922 gold_assert(this->type() == INCREMENTAL_INPUT_OBJECT 923 || this->type() == INCREMENTAL_INPUT_ARCHIVE_MEMBER); 924 925 return Swap32::readval(this->inputs_->p_ + this->info_offset_ + 12); 926 } 927 928 // Return the index of the first dynamic relocation -- for objects only. 929 unsigned int 930 get_first_dyn_reloc() const 931 { 932 gold_assert(this->type() == INCREMENTAL_INPUT_OBJECT 933 || this->type() == INCREMENTAL_INPUT_ARCHIVE_MEMBER); 934 935 return Swap32::readval(this->inputs_->p_ + this->info_offset_ + 16); 936 } 937 938 // Return the dynamic relocation count -- for objects only. 939 unsigned int 940 get_dyn_reloc_count() const 941 { 942 gold_assert(this->type() == INCREMENTAL_INPUT_OBJECT 943 || this->type() == INCREMENTAL_INPUT_ARCHIVE_MEMBER); 944 945 return Swap32::readval(this->inputs_->p_ + this->info_offset_ + 20); 946 } 947 948 // Return the COMDAT group count -- for objects only. 949 unsigned int 950 get_comdat_group_count() const 951 { 952 gold_assert(this->type() == INCREMENTAL_INPUT_OBJECT 953 || this->type() == INCREMENTAL_INPUT_ARCHIVE_MEMBER); 954 955 return Swap32::readval(this->inputs_->p_ + this->info_offset_ + 24); 956 } 957 958 // Return the object count -- for scripts only. 959 unsigned int 960 get_object_count() const 961 { 962 gold_assert(this->type() == INCREMENTAL_INPUT_SCRIPT); 963 return Swap32::readval(this->inputs_->p_ + this->info_offset_); 964 } 965 966 // Return the input file offset for object N -- for scripts only. 967 unsigned int 968 get_object_offset(unsigned int n) const 969 { 970 gold_assert(this->type() == INCREMENTAL_INPUT_SCRIPT); 971 return Swap32::readval(this->inputs_->p_ + this->info_offset_ 972 + 4 + n * 4); 973 } 974 975 // Return the member count -- for archives only. 976 unsigned int 977 get_member_count() const 978 { 979 gold_assert(this->type() == INCREMENTAL_INPUT_ARCHIVE); 980 return Swap32::readval(this->inputs_->p_ + this->info_offset_); 981 } 982 983 // Return the unused symbol count -- for archives only. 984 unsigned int 985 get_unused_symbol_count() const 986 { 987 gold_assert(this->type() == INCREMENTAL_INPUT_ARCHIVE); 988 return Swap32::readval(this->inputs_->p_ + this->info_offset_ + 4); 989 } 990 991 // Return the input file offset for archive member N -- for archives only. 992 unsigned int 993 get_member_offset(unsigned int n) const 994 { 995 gold_assert(this->type() == INCREMENTAL_INPUT_ARCHIVE); 996 return Swap32::readval(this->inputs_->p_ + this->info_offset_ 997 + 8 + n * 4); 998 } 999 1000 // Return the Nth unused global symbol -- for archives only. 1001 const char* 1002 get_unused_symbol(unsigned int n) const 1003 { 1004 gold_assert(this->type() == INCREMENTAL_INPUT_ARCHIVE); 1005 unsigned int member_count = this->get_member_count(); 1006 unsigned int offset = Swap32::readval(this->inputs_->p_ 1007 + this->info_offset_ + 8 1008 + member_count * 4 1009 + n * 4); 1010 return this->inputs_->get_string(offset); 1011 } 1012 1013 // Information about an input section. 1014 struct Input_section_info 1015 { 1016 const char* name; 1017 unsigned int output_shndx; 1018 off_t sh_offset; 1019 off_t sh_size; 1020 }; 1021 1022 // Return info about the Nth input section -- for objects only. 1023 Input_section_info 1024 get_input_section(unsigned int n) const 1025 { 1026 Input_section_info info; 1027 const unsigned char* p = (this->inputs_->p_ 1028 + this->info_offset_ 1029 + this->object_info_size 1030 + n * this->input_section_entry_size); 1031 unsigned int name_offset = Swap32::readval(p); 1032 info.name = this->inputs_->get_string(name_offset); 1033 info.output_shndx = Swap32::readval(p + 4); 1034 info.sh_offset = Swap::readval(p + 8); 1035 info.sh_size = Swap::readval(p + 8 + size / 8); 1036 return info; 1037 } 1038 1039 // Return info about the Nth global symbol -- for objects only. 1040 Incremental_global_symbol_reader<big_endian> 1041 get_global_symbol_reader(unsigned int n) const 1042 { 1043 gold_assert(this->type() == INCREMENTAL_INPUT_OBJECT 1044 || this->type() == INCREMENTAL_INPUT_ARCHIVE_MEMBER); 1045 unsigned int section_count = this->get_input_section_count(); 1046 const unsigned char* p = (this->inputs_->p_ 1047 + this->info_offset_ 1048 + this->object_info_size 1049 + section_count * this->input_section_entry_size 1050 + n * this->global_sym_entry_size); 1051 return Incremental_global_symbol_reader<big_endian>(p); 1052 } 1053 1054 // Return the signature of the Nth comdat group -- for objects only. 1055 const char* 1056 get_comdat_group_signature(unsigned int n) const 1057 { 1058 unsigned int section_count = this->get_input_section_count(); 1059 unsigned int symbol_count = this->get_global_symbol_count(); 1060 const unsigned char* p = (this->inputs_->p_ 1061 + this->info_offset_ 1062 + this->object_info_size 1063 + section_count * this->input_section_entry_size 1064 + symbol_count * this->global_sym_entry_size 1065 + n * 4); 1066 unsigned int name_offset = Swap32::readval(p); 1067 return this->inputs_->get_string(name_offset); 1068 } 1069 1070 // Return the output symbol index for the Nth global symbol -- for shared 1071 // libraries only. Sets *IS_DEF to TRUE if the symbol is defined in this 1072 // input file. Sets *IS_COPY to TRUE if the symbol was copied from this 1073 // input file with a COPY relocation. 1074 unsigned int 1075 get_output_symbol_index(unsigned int n, bool* is_def, bool* is_copy) 1076 { 1077 gold_assert(this->type() == INCREMENTAL_INPUT_SHARED_LIBRARY); 1078 const unsigned char* p = (this->inputs_->p_ 1079 + this->info_offset_ + 8 1080 + n * 4); 1081 unsigned int output_symndx = Swap32::readval(p); 1082 unsigned int flags = output_symndx >> INCREMENTAL_SHLIB_SYM_FLAGS_SHIFT; 1083 output_symndx &= ((1U << INCREMENTAL_SHLIB_SYM_FLAGS_SHIFT) - 1); 1084 switch (flags) 1085 { 1086 case INCREMENTAL_SHLIB_SYM_DEF: 1087 *is_def = true; 1088 *is_copy = false; 1089 break; 1090 case INCREMENTAL_SHLIB_SYM_COPY: 1091 *is_def = true; 1092 *is_copy = true; 1093 break; 1094 default: 1095 *is_def = false; 1096 *is_copy = false; 1097 } 1098 return output_symndx; 1099 } 1100 1101 private: 1102 // The reader instance for the containing section. 1103 const Incremental_inputs_reader* inputs_; 1104 // The flags, including the type of input file. 1105 unsigned int flags_; 1106 // Section offset to the input file entry. 1107 unsigned int offset_; 1108 // Section offset to the supplemental info for the input file. 1109 unsigned int info_offset_; 1110 }; 1111 1112 // Return the offset of an input file entry given its index N. 1113 unsigned int 1114 input_file_offset(unsigned int n) const 1115 { 1116 gold_assert(n < this->input_file_count_); 1117 return this->header_size + n * this->input_entry_size; 1118 } 1119 1120 // Return the index of an input file entry given its OFFSET. 1121 unsigned int 1122 input_file_index(unsigned int offset) const 1123 { 1124 int n = ((offset - this->header_size) / this->input_entry_size); 1125 gold_assert(input_file_offset(n) == offset); 1126 return n; 1127 } 1128 1129 // Return a reader for the Nth input file entry. 1130 Incremental_input_entry_reader 1131 input_file(unsigned int n) const 1132 { return Incremental_input_entry_reader(this, this->input_file_offset(n)); } 1133 1134 // Return a reader for the input file entry at OFFSET. 1135 Incremental_input_entry_reader 1136 input_file_at_offset(unsigned int offset) const 1137 { 1138 gold_assert(offset < (this->header_size 1139 + this->input_file_count_ * this->input_entry_size)); 1140 return Incremental_input_entry_reader(this, offset); 1141 } 1142 1143 // Return a reader for the global symbol info at OFFSET. 1144 Incremental_global_symbol_reader<big_endian> 1145 global_symbol_reader_at_offset(unsigned int offset) const 1146 { 1147 const unsigned char* p = this->p_ + offset; 1148 return Incremental_global_symbol_reader<big_endian>(p); 1149 } 1150 1151 private: 1152 // Lookup a string in the ELF string table. 1153 const char* get_string(unsigned int offset) const 1154 { 1155 const char* s; 1156 if (this->strtab_.get_c_string(offset, &s)) 1157 return s; 1158 return NULL; 1159 } 1160 1161 // Base address of the .gnu_incremental_inputs section. 1162 const unsigned char* p_; 1163 // The associated ELF string table. 1164 elfcpp::Elf_strtab strtab_; 1165 // The number of input file entries in this section. 1166 unsigned int input_file_count_; 1167 }; 1168 1169 // Reader class for the .gnu_incremental_symtab section. 1170 1171 template<bool big_endian> 1172 class Incremental_symtab_reader 1173 { 1174 public: 1175 Incremental_symtab_reader() 1176 : p_(NULL), len_(0) 1177 { } 1178 1179 Incremental_symtab_reader(const unsigned char* p, off_t len) 1180 : p_(p), len_(len) 1181 { } 1182 1183 // Return the count of symbols in this section. 1184 unsigned int 1185 symbol_count() const 1186 { return static_cast<unsigned int>(this->len_ / 4); } 1187 1188 // Return the list head for symbol table entry N. 1189 unsigned int 1190 get_list_head(unsigned int n) const 1191 { return elfcpp::Swap<32, big_endian>::readval(this->p_ + 4 * n); } 1192 1193 private: 1194 // Base address of the .gnu_incremental_relocs section. 1195 const unsigned char* p_; 1196 // Size of the section. 1197 off_t len_; 1198 }; 1199 1200 // Reader class for the .gnu_incremental_relocs section. 1201 1202 template<int size, bool big_endian> 1203 class Incremental_relocs_reader 1204 { 1205 private: 1206 // Size of each field. 1207 static const unsigned int field_size = size / 8; 1208 1209 public: 1210 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address; 1211 typedef typename elfcpp::Elf_types<size>::Elf_Swxword Addend; 1212 1213 // Size of each entry. 1214 static const unsigned int reloc_size = 8 + 2 * field_size; 1215 1216 Incremental_relocs_reader() 1217 : p_(NULL), len_(0) 1218 { } 1219 1220 Incremental_relocs_reader(const unsigned char* p, off_t len) 1221 : p_(p), len_(len) 1222 { } 1223 1224 // Return the count of relocations in this section. 1225 unsigned int 1226 reloc_count() const 1227 { return static_cast<unsigned int>(this->len_ / reloc_size); } 1228 1229 // Return the relocation type for relocation entry at offset OFF. 1230 unsigned int 1231 get_r_type(unsigned int off) const 1232 { return elfcpp::Swap<32, big_endian>::readval(this->p_ + off); } 1233 1234 // Return the output section index for relocation entry at offset OFF. 1235 unsigned int 1236 get_r_shndx(unsigned int off) const 1237 { return elfcpp::Swap<32, big_endian>::readval(this->p_ + off + 4); } 1238 1239 // Return the output section offset for relocation entry at offset OFF. 1240 Address 1241 get_r_offset(unsigned int off) const 1242 { return elfcpp::Swap<size, big_endian>::readval(this->p_ + off + 8); } 1243 1244 // Return the addend for relocation entry at offset OFF. 1245 Addend 1246 get_r_addend(unsigned int off) const 1247 { 1248 return elfcpp::Swap<size, big_endian>::readval(this->p_ + off + 8 1249 + this->field_size); 1250 } 1251 1252 // Return a pointer to the relocation entry at offset OFF. 1253 const unsigned char* 1254 data(unsigned int off) const 1255 { return this->p_ + off; } 1256 1257 private: 1258 // Base address of the .gnu_incremental_relocs section. 1259 const unsigned char* p_; 1260 // Size of the section. 1261 off_t len_; 1262 }; 1263 1264 // Reader class for the .gnu_incremental_got_plt section. 1265 1266 template<bool big_endian> 1267 class Incremental_got_plt_reader 1268 { 1269 public: 1270 Incremental_got_plt_reader() 1271 : p_(NULL), got_count_(0), got_desc_p_(NULL), plt_desc_p_(NULL) 1272 { } 1273 1274 Incremental_got_plt_reader(const unsigned char* p) : p_(p) 1275 { 1276 this->got_count_ = elfcpp::Swap<32, big_endian>::readval(p); 1277 this->got_desc_p_ = p + 8 + ((this->got_count_ + 3) & ~3); 1278 this->plt_desc_p_ = this->got_desc_p_ + this->got_count_ * 8; 1279 } 1280 1281 // Return the GOT entry count. 1282 unsigned int 1283 get_got_entry_count() const 1284 { 1285 return this->got_count_; 1286 } 1287 1288 // Return the PLT entry count. 1289 unsigned int 1290 get_plt_entry_count() const 1291 { 1292 return elfcpp::Swap<32, big_endian>::readval(this->p_ + 4); 1293 } 1294 1295 // Return the GOT type for GOT entry N. 1296 unsigned int 1297 get_got_type(unsigned int n) 1298 { 1299 return this->p_[8 + n]; 1300 } 1301 1302 // Return the symbol index for GOT entry N. 1303 unsigned int 1304 get_got_symndx(unsigned int n) 1305 { 1306 return elfcpp::Swap<32, big_endian>::readval(this->got_desc_p_ + n * 8); 1307 } 1308 1309 // Return the input file index for GOT entry N. 1310 unsigned int 1311 get_got_input_index(unsigned int n) 1312 { 1313 return elfcpp::Swap<32, big_endian>::readval(this->got_desc_p_ + n * 8 + 4); 1314 } 1315 1316 // Return the PLT descriptor for PLT entry N. 1317 unsigned int 1318 get_plt_desc(unsigned int n) 1319 { 1320 return elfcpp::Swap<32, big_endian>::readval(this->plt_desc_p_ + n * 4); 1321 } 1322 1323 private: 1324 // Base address of the .gnu_incremental_got_plt section. 1325 const unsigned char* p_; 1326 // GOT entry count. 1327 unsigned int got_count_; 1328 // Base address of the GOT descriptor array. 1329 const unsigned char* got_desc_p_; 1330 // Base address of the PLT descriptor array. 1331 const unsigned char* plt_desc_p_; 1332 }; 1333 1334 // An object representing the ELF file we edit during an incremental build. 1335 // Similar to Object or Dynobj, but operates on Output_file and contains 1336 // methods to support incremental updating. This is the abstract parent class 1337 // implemented in Sized_incremental_binary<size, big_endian> for a specific 1338 // endianness and size. 1339 1340 class Incremental_binary 1341 { 1342 public: 1343 Incremental_binary(Output_file* output, Target* /*target*/) 1344 : input_args_map_(), library_map_(), script_map_(), 1345 output_(output) 1346 { } 1347 1348 virtual 1349 ~Incremental_binary() 1350 { } 1351 1352 // Check the .gnu_incremental_inputs section to see whether an incremental 1353 // build is possible. 1354 bool 1355 check_inputs(const Command_line& cmdline, 1356 Incremental_inputs* incremental_inputs) 1357 { return this->do_check_inputs(cmdline, incremental_inputs); } 1358 1359 // Report an error. 1360 void 1361 error(const char* format, ...) const ATTRIBUTE_PRINTF_2; 1362 1363 // Proxy class for a sized Incremental_input_entry_reader. 1364 1365 class Input_reader 1366 { 1367 public: 1368 Input_reader() 1369 { } 1370 1371 Input_reader(const Input_reader&) 1372 { } 1373 1374 virtual 1375 ~Input_reader() 1376 { } 1377 1378 const char* 1379 filename() const 1380 { return this->do_filename(); } 1381 1382 Timespec 1383 get_mtime() const 1384 { return this->do_get_mtime(); } 1385 1386 Incremental_input_type 1387 type() const 1388 { return this->do_type(); } 1389 1390 unsigned int 1391 arg_serial() const 1392 { return this->do_arg_serial(); } 1393 1394 unsigned int 1395 get_unused_symbol_count() const 1396 { return this->do_get_unused_symbol_count(); } 1397 1398 const char* 1399 get_unused_symbol(unsigned int n) const 1400 { return this->do_get_unused_symbol(n); } 1401 1402 protected: 1403 virtual const char* 1404 do_filename() const = 0; 1405 1406 virtual Timespec 1407 do_get_mtime() const = 0; 1408 1409 virtual Incremental_input_type 1410 do_type() const = 0; 1411 1412 virtual unsigned int 1413 do_arg_serial() const = 0; 1414 1415 virtual unsigned int 1416 do_get_unused_symbol_count() const = 0; 1417 1418 virtual const char* 1419 do_get_unused_symbol(unsigned int n) const = 0; 1420 }; 1421 1422 // Return the number of input files. 1423 unsigned int 1424 input_file_count() const 1425 { return this->do_input_file_count(); } 1426 1427 // Return an Input_reader for input file N. 1428 const Input_reader* 1429 get_input_reader(unsigned int n) const 1430 { return this->do_get_input_reader(n); } 1431 1432 // Return TRUE if the input file N has changed since the last link. 1433 bool 1434 file_has_changed(unsigned int n) const 1435 { return this->do_file_has_changed(n); } 1436 1437 // Return the Input_argument for input file N. Returns NULL if 1438 // the Input_argument is not available. 1439 const Input_argument* 1440 get_input_argument(unsigned int n) const 1441 { 1442 const Input_reader* input_file = this->do_get_input_reader(n); 1443 unsigned int arg_serial = input_file->arg_serial(); 1444 if (arg_serial == 0 || arg_serial > this->input_args_map_.size()) 1445 return NULL; 1446 return this->input_args_map_[arg_serial - 1]; 1447 } 1448 1449 // Return an Incremental_library for the given input file. 1450 Incremental_library* 1451 get_library(unsigned int n) const 1452 { return this->library_map_[n]; } 1453 1454 // Return a Script_info for the given input file. 1455 Script_info* 1456 get_script_info(unsigned int n) const 1457 { return this->script_map_[n]; } 1458 1459 // Initialize the layout of the output file based on the existing 1460 // output file. 1461 void 1462 init_layout(Layout* layout) 1463 { this->do_init_layout(layout); } 1464 1465 // Mark regions of the input file that must be kept unchanged. 1466 void 1467 reserve_layout(unsigned int input_file_index) 1468 { this->do_reserve_layout(input_file_index); } 1469 1470 // Process the GOT and PLT entries from the existing output file. 1471 void 1472 process_got_plt(Symbol_table* symtab, Layout* layout) 1473 { this->do_process_got_plt(symtab, layout); } 1474 1475 // Emit COPY relocations from the existing output file. 1476 void 1477 emit_copy_relocs(Symbol_table* symtab) 1478 { this->do_emit_copy_relocs(symtab); } 1479 1480 // Apply incremental relocations for symbols whose values have changed. 1481 void 1482 apply_incremental_relocs(const Symbol_table* symtab, Layout* layout, 1483 Output_file* of) 1484 { this->do_apply_incremental_relocs(symtab, layout, of); } 1485 1486 // Functions and types for the elfcpp::Elf_file interface. This 1487 // permit us to use Incremental_binary as the File template parameter for 1488 // elfcpp::Elf_file. 1489 1490 // The View class is returned by view. It must support a single 1491 // method, data(). This is trivial, because Output_file::get_output_view 1492 // does what we need. 1493 class View 1494 { 1495 public: 1496 View(const unsigned char* p) 1497 : p_(p) 1498 { } 1499 1500 const unsigned char* 1501 data() const 1502 { return this->p_; } 1503 1504 private: 1505 const unsigned char* p_; 1506 }; 1507 1508 // Return a View. 1509 View 1510 view(off_t file_offset, section_size_type data_size) 1511 { return View(this->output_->get_input_view(file_offset, data_size)); } 1512 1513 // A location in the file. 1514 struct Location 1515 { 1516 off_t file_offset; 1517 off_t data_size; 1518 1519 Location(off_t fo, section_size_type ds) 1520 : file_offset(fo), data_size(ds) 1521 { } 1522 1523 Location() 1524 : file_offset(0), data_size(0) 1525 { } 1526 }; 1527 1528 // Get a View given a Location. 1529 View 1530 view(Location loc) 1531 { return View(this->view(loc.file_offset, loc.data_size)); } 1532 1533 // Return the Output_file. 1534 Output_file* 1535 output_file() 1536 { return this->output_; } 1537 1538 protected: 1539 // Check the .gnu_incremental_inputs section to see whether an incremental 1540 // build is possible. 1541 virtual bool 1542 do_check_inputs(const Command_line& cmdline, 1543 Incremental_inputs* incremental_inputs) = 0; 1544 1545 // Return TRUE if input file N has changed since the last incremental link. 1546 virtual bool 1547 do_file_has_changed(unsigned int n) const = 0; 1548 1549 // Initialize the layout of the output file based on the existing 1550 // output file. 1551 virtual void 1552 do_init_layout(Layout* layout) = 0; 1553 1554 // Mark regions of the input file that must be kept unchanged. 1555 virtual void 1556 do_reserve_layout(unsigned int input_file_index) = 0; 1557 1558 // Process the GOT and PLT entries from the existing output file. 1559 virtual void 1560 do_process_got_plt(Symbol_table* symtab, Layout* layout) = 0; 1561 1562 // Emit COPY relocations from the existing output file. 1563 virtual void 1564 do_emit_copy_relocs(Symbol_table* symtab) = 0; 1565 1566 // Apply incremental relocations for symbols whose values have changed. 1567 virtual void 1568 do_apply_incremental_relocs(const Symbol_table*, Layout*, Output_file*) = 0; 1569 1570 virtual unsigned int 1571 do_input_file_count() const = 0; 1572 1573 virtual const Input_reader* 1574 do_get_input_reader(unsigned int) const = 0; 1575 1576 // Map from input file index to Input_argument. 1577 std::vector<const Input_argument*> input_args_map_; 1578 // Map from an input file index to an Incremental_library. 1579 std::vector<Incremental_library*> library_map_; 1580 // Map from an input file index to a Script_info. 1581 std::vector<Script_info*> script_map_; 1582 1583 private: 1584 // Edited output file object. 1585 Output_file* output_; 1586 }; 1587 1588 template<int size, bool big_endian> 1589 class Sized_relobj_incr; 1590 1591 template<int size, bool big_endian> 1592 class Sized_incremental_binary : public Incremental_binary 1593 { 1594 public: 1595 Sized_incremental_binary(Output_file* output, 1596 const elfcpp::Ehdr<size, big_endian>& ehdr, 1597 Target* target) 1598 : Incremental_binary(output, target), elf_file_(this, ehdr), 1599 input_objects_(), section_map_(), symbol_map_(), copy_relocs_(), 1600 main_symtab_loc_(), main_strtab_loc_(), has_incremental_info_(false), 1601 inputs_reader_(), symtab_reader_(), relocs_reader_(), got_plt_reader_(), 1602 input_entry_readers_() 1603 { this->setup_readers(); } 1604 1605 // Returns TRUE if the file contains incremental info. 1606 bool 1607 has_incremental_info() const 1608 { return this->has_incremental_info_; } 1609 1610 // Record a pointer to the object for input file N. 1611 void 1612 set_input_object(unsigned int n, 1613 Sized_relobj_incr<size, big_endian>* obj) 1614 { this->input_objects_[n] = obj; } 1615 1616 // Return a pointer to the object for input file N. 1617 Sized_relobj_incr<size, big_endian>* 1618 input_object(unsigned int n) const 1619 { 1620 gold_assert(n < this->input_objects_.size()); 1621 return this->input_objects_[n]; 1622 } 1623 1624 // Return the Output_section for section index SHNDX. 1625 Output_section* 1626 output_section(unsigned int shndx) 1627 { return this->section_map_[shndx]; } 1628 1629 // Map a symbol table entry from the base file to the output symbol table. 1630 // SYMNDX is relative to the first forced-local or global symbol in the 1631 // input file symbol table. 1632 void 1633 add_global_symbol(unsigned int symndx, Symbol* gsym) 1634 { this->symbol_map_[symndx] = gsym; } 1635 1636 // Map a symbol table entry from the base file to the output symbol table. 1637 // SYMNDX is relative to the first forced-local or global symbol in the 1638 // input file symbol table. 1639 Symbol* 1640 global_symbol(unsigned int symndx) const 1641 { return this->symbol_map_[symndx]; } 1642 1643 // Add a COPY relocation for a global symbol. 1644 void 1645 add_copy_reloc(Symbol* gsym, Output_section* os, off_t offset) 1646 { this->copy_relocs_.push_back(Copy_reloc(gsym, os, offset)); } 1647 1648 // Readers for the incremental info sections. 1649 1650 const Incremental_inputs_reader<size, big_endian>& 1651 inputs_reader() const 1652 { return this->inputs_reader_; } 1653 1654 const Incremental_symtab_reader<big_endian>& 1655 symtab_reader() const 1656 { return this->symtab_reader_; } 1657 1658 const Incremental_relocs_reader<size, big_endian>& 1659 relocs_reader() const 1660 { return this->relocs_reader_; } 1661 1662 const Incremental_got_plt_reader<big_endian>& 1663 got_plt_reader() const 1664 { return this->got_plt_reader_; } 1665 1666 void 1667 get_symtab_view(View* symtab_view, unsigned int* sym_count, 1668 elfcpp::Elf_strtab* strtab); 1669 1670 protected: 1671 typedef Incremental_inputs_reader<size, big_endian> Inputs_reader; 1672 typedef typename Inputs_reader::Incremental_input_entry_reader 1673 Input_entry_reader; 1674 1675 virtual bool 1676 do_check_inputs(const Command_line& cmdline, 1677 Incremental_inputs* incremental_inputs); 1678 1679 // Return TRUE if input file N has changed since the last incremental link. 1680 virtual bool 1681 do_file_has_changed(unsigned int n) const; 1682 1683 // Initialize the layout of the output file based on the existing 1684 // output file. 1685 virtual void 1686 do_init_layout(Layout* layout); 1687 1688 // Mark regions of the input file that must be kept unchanged. 1689 virtual void 1690 do_reserve_layout(unsigned int input_file_index); 1691 1692 // Process the GOT and PLT entries from the existing output file. 1693 virtual void 1694 do_process_got_plt(Symbol_table* symtab, Layout* layout); 1695 1696 // Emit COPY relocations from the existing output file. 1697 virtual void 1698 do_emit_copy_relocs(Symbol_table* symtab); 1699 1700 // Apply incremental relocations for symbols whose values have changed. 1701 virtual void 1702 do_apply_incremental_relocs(const Symbol_table* symtab, Layout* layout, 1703 Output_file* of); 1704 1705 // Proxy class for a sized Incremental_input_entry_reader. 1706 1707 class Sized_input_reader : public Input_reader 1708 { 1709 public: 1710 Sized_input_reader(Input_entry_reader r) 1711 : Input_reader(), reader_(r) 1712 { } 1713 1714 Sized_input_reader(const Sized_input_reader& r) 1715 : Input_reader(), reader_(r.reader_) 1716 { } 1717 1718 virtual 1719 ~Sized_input_reader() 1720 { } 1721 1722 private: 1723 const char* 1724 do_filename() const 1725 { return this->reader_.filename(); } 1726 1727 Timespec 1728 do_get_mtime() const 1729 { return this->reader_.get_mtime(); } 1730 1731 Incremental_input_type 1732 do_type() const 1733 { return this->reader_.type(); } 1734 1735 unsigned int 1736 do_arg_serial() const 1737 { return this->reader_.arg_serial(); } 1738 1739 unsigned int 1740 do_get_unused_symbol_count() const 1741 { return this->reader_.get_unused_symbol_count(); } 1742 1743 const char* 1744 do_get_unused_symbol(unsigned int n) const 1745 { return this->reader_.get_unused_symbol(n); } 1746 1747 Input_entry_reader reader_; 1748 }; 1749 1750 virtual unsigned int 1751 do_input_file_count() const 1752 { return this->inputs_reader_.input_file_count(); } 1753 1754 virtual const Input_reader* 1755 do_get_input_reader(unsigned int n) const 1756 { 1757 gold_assert(n < this->input_entry_readers_.size()); 1758 return &this->input_entry_readers_[n]; 1759 } 1760 1761 private: 1762 // List of symbols that need COPY relocations. 1763 struct Copy_reloc 1764 { 1765 Copy_reloc(Symbol* sym, Output_section* os, off_t off) 1766 : symbol(sym), output_section(os), offset(off) 1767 { } 1768 1769 // The global symbol to copy. 1770 Symbol* symbol; 1771 // The output section into which the symbol was copied. 1772 Output_section* output_section; 1773 // The offset within that output section. 1774 off_t offset; 1775 }; 1776 typedef std::vector<Copy_reloc> Copy_relocs; 1777 1778 bool 1779 find_incremental_inputs_sections(unsigned int* p_inputs_shndx, 1780 unsigned int* p_symtab_shndx, 1781 unsigned int* p_relocs_shndx, 1782 unsigned int* p_got_plt_shndx, 1783 unsigned int* p_strtab_shndx); 1784 1785 void 1786 setup_readers(); 1787 1788 // Output as an ELF file. 1789 elfcpp::Elf_file<size, big_endian, Incremental_binary> elf_file_; 1790 1791 // Vector of pointers to the input objects for the unchanged files. 1792 // For replaced files, the corresponding pointer is NULL. 1793 std::vector<Sized_relobj_incr<size, big_endian>*> input_objects_; 1794 1795 // Map section index to an Output_section in the updated layout. 1796 std::vector<Output_section*> section_map_; 1797 1798 // Map global symbols from the input file to the symbol table. 1799 std::vector<Symbol*> symbol_map_; 1800 1801 // List of symbols that need COPY relocations. 1802 Copy_relocs copy_relocs_; 1803 1804 // Locations of the main symbol table and symbol string table. 1805 Location main_symtab_loc_; 1806 Location main_strtab_loc_; 1807 1808 // Readers for the incremental info sections. 1809 bool has_incremental_info_; 1810 Incremental_inputs_reader<size, big_endian> inputs_reader_; 1811 Incremental_symtab_reader<big_endian> symtab_reader_; 1812 Incremental_relocs_reader<size, big_endian> relocs_reader_; 1813 Incremental_got_plt_reader<big_endian> got_plt_reader_; 1814 std::vector<Sized_input_reader> input_entry_readers_; 1815 }; 1816 1817 // An incremental Relobj. This class represents a relocatable object 1818 // that has not changed since the last incremental link, and whose contents 1819 // can be used directly from the base file. 1820 1821 template<int size, bool big_endian> 1822 class Sized_relobj_incr : public Sized_relobj<size, big_endian> 1823 { 1824 public: 1825 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address; 1826 typedef typename Sized_relobj<size, big_endian>::Symbols Symbols; 1827 1828 Sized_relobj_incr(const std::string& name, 1829 Sized_incremental_binary<size, big_endian>* ibase, 1830 unsigned int input_file_index); 1831 1832 private: 1833 // For convenience. 1834 typedef Sized_relobj_incr<size, big_endian> This; 1835 static const int sym_size = elfcpp::Elf_sizes<size>::sym_size; 1836 1837 typedef typename Sized_relobj<size, big_endian>::Output_sections 1838 Output_sections; 1839 typedef Incremental_inputs_reader<size, big_endian> Inputs_reader; 1840 typedef typename Inputs_reader::Incremental_input_entry_reader 1841 Input_entry_reader; 1842 1843 // A local symbol. 1844 struct Local_symbol 1845 { 1846 Local_symbol(const char* name_, Address value_, unsigned int size_, 1847 unsigned int shndx_, unsigned int type_, 1848 bool needs_dynsym_entry_) 1849 : st_value(value_), name(name_), st_size(size_), st_shndx(shndx_), 1850 st_type(type_), output_dynsym_index(0), 1851 needs_dynsym_entry(needs_dynsym_entry_) 1852 { } 1853 // The symbol value. 1854 Address st_value; 1855 // The symbol name. This points to the stringpool entry. 1856 const char* name; 1857 // The symbol size. 1858 unsigned int st_size; 1859 // The output section index. 1860 unsigned int st_shndx : 28; 1861 // The symbol type. 1862 unsigned int st_type : 4; 1863 // The index of the symbol in the output dynamic symbol table. 1864 unsigned int output_dynsym_index : 31; 1865 // TRUE if the symbol needs to appear in the dynamic symbol table. 1866 unsigned int needs_dynsym_entry : 1; 1867 }; 1868 1869 // Return TRUE if this is an incremental (unchanged) input file. 1870 bool 1871 do_is_incremental() const 1872 { return true; } 1873 1874 // Return the last modified time of the file. 1875 Timespec 1876 do_get_mtime() 1877 { return this->input_reader_.get_mtime(); } 1878 1879 // Read the symbols. 1880 void 1881 do_read_symbols(Read_symbols_data*); 1882 1883 // Lay out the input sections. 1884 void 1885 do_layout(Symbol_table*, Layout*, Read_symbols_data*); 1886 1887 // Layout sections whose layout was deferred while waiting for 1888 // input files from a plugin. 1889 void 1890 do_layout_deferred_sections(Layout*); 1891 1892 // Add the symbols to the symbol table. 1893 void 1894 do_add_symbols(Symbol_table*, Read_symbols_data*, Layout*); 1895 1896 Archive::Should_include 1897 do_should_include_member(Symbol_table* symtab, Layout*, Read_symbols_data*, 1898 std::string* why); 1899 1900 // Iterate over global symbols, calling a visitor class V for each. 1901 void 1902 do_for_all_global_symbols(Read_symbols_data* sd, 1903 Library_base::Symbol_visitor_base* v); 1904 1905 // Get the size of a section. 1906 uint64_t 1907 do_section_size(unsigned int shndx); 1908 1909 // Get the name of a section. 1910 std::string 1911 do_section_name(unsigned int shndx) const; 1912 1913 // Return a view of the contents of a section. 1914 const unsigned char* 1915 do_section_contents(unsigned int shndx, section_size_type* plen, 1916 bool cache); 1917 1918 // Return section flags. 1919 uint64_t 1920 do_section_flags(unsigned int shndx); 1921 1922 // Return section entsize. 1923 uint64_t 1924 do_section_entsize(unsigned int shndx); 1925 1926 // Return section address. 1927 uint64_t 1928 do_section_address(unsigned int shndx); 1929 1930 // Return section type. 1931 unsigned int 1932 do_section_type(unsigned int shndx); 1933 1934 // Return the section link field. 1935 unsigned int 1936 do_section_link(unsigned int shndx); 1937 1938 // Return the section link field. 1939 unsigned int 1940 do_section_info(unsigned int shndx); 1941 1942 // Return the section alignment. 1943 uint64_t 1944 do_section_addralign(unsigned int shndx); 1945 1946 // Return the Xindex structure to use. 1947 Xindex* 1948 do_initialize_xindex(); 1949 1950 // Get symbol counts. 1951 void 1952 do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const; 1953 1954 // Get global symbols. 1955 const Symbols* 1956 do_get_global_symbols() const 1957 { return &this->symbols_; } 1958 1959 // Return the value of a local symbol. 1960 uint64_t 1961 do_local_symbol_value(unsigned int, uint64_t) const 1962 { gold_unreachable(); } 1963 1964 unsigned int 1965 do_local_plt_offset(unsigned int) const 1966 { gold_unreachable(); } 1967 1968 bool 1969 do_local_is_tls(unsigned int) const 1970 { gold_unreachable(); } 1971 1972 // Return the number of local symbols. 1973 unsigned int 1974 do_local_symbol_count() const 1975 { return this->local_symbol_count_; } 1976 1977 // Return the number of local symbols in the output symbol table. 1978 unsigned int 1979 do_output_local_symbol_count() const 1980 { return this->local_symbol_count_; } 1981 1982 // Return the file offset for local symbols in the output symbol table. 1983 off_t 1984 do_local_symbol_offset() const 1985 { return this->local_symbol_offset_; } 1986 1987 // Read the relocs. 1988 void 1989 do_read_relocs(Read_relocs_data*); 1990 1991 // Process the relocs to find list of referenced sections. Used only 1992 // during garbage collection. 1993 void 1994 do_gc_process_relocs(Symbol_table*, Layout*, Read_relocs_data*); 1995 1996 // Scan the relocs and adjust the symbol table. 1997 void 1998 do_scan_relocs(Symbol_table*, Layout*, Read_relocs_data*); 1999 2000 // Count the local symbols. 2001 void 2002 do_count_local_symbols(Stringpool_template<char>*, 2003 Stringpool_template<char>*); 2004 2005 // Finalize the local symbols. 2006 unsigned int 2007 do_finalize_local_symbols(unsigned int, off_t, Symbol_table*); 2008 2009 // Set the offset where local dynamic symbol information will be stored. 2010 unsigned int 2011 do_set_local_dynsym_indexes(unsigned int); 2012 2013 // Set the offset where local dynamic symbol information will be stored. 2014 unsigned int 2015 do_set_local_dynsym_offset(off_t); 2016 2017 // Relocate the input sections and write out the local symbols. 2018 void 2019 do_relocate(const Symbol_table* symtab, const Layout*, Output_file* of); 2020 2021 // Set the offset of a section. 2022 void 2023 do_set_section_offset(unsigned int shndx, uint64_t off); 2024 2025 // The Incremental_binary base file. 2026 Sized_incremental_binary<size, big_endian>* ibase_; 2027 // The index of the object in the input file list. 2028 unsigned int input_file_index_; 2029 // The reader for the input file. 2030 Input_entry_reader input_reader_; 2031 // The number of local symbols. 2032 unsigned int local_symbol_count_; 2033 // The number of local symbols which go into the output file's dynamic 2034 // symbol table. 2035 unsigned int output_local_dynsym_count_; 2036 // This starting symbol index in the output symbol table. 2037 unsigned int local_symbol_index_; 2038 // The file offset for local symbols in the output symbol table. 2039 unsigned int local_symbol_offset_; 2040 // The file offset for local symbols in the output symbol table. 2041 unsigned int local_dynsym_offset_; 2042 // The entries in the symbol table for the external symbols. 2043 Symbols symbols_; 2044 // Number of symbols defined in object file itself. 2045 size_t defined_count_; 2046 // The offset of the first incremental relocation for this object. 2047 unsigned int incr_reloc_offset_; 2048 // The number of incremental relocations for this object. 2049 unsigned int incr_reloc_count_; 2050 // The index of the first incremental relocation for this object in the 2051 // updated output file. 2052 unsigned int incr_reloc_output_index_; 2053 // A copy of the incremental relocations from this object. 2054 unsigned char* incr_relocs_; 2055 // The local symbols. 2056 std::vector<Local_symbol> local_symbols_; 2057 }; 2058 2059 // An incremental Dynobj. This class represents a shared object that has 2060 // not changed since the last incremental link, and whose contents can be 2061 // used directly from the base file. 2062 2063 template<int size, bool big_endian> 2064 class Sized_incr_dynobj : public Dynobj 2065 { 2066 public: 2067 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address; 2068 2069 static const Address invalid_address = static_cast<Address>(0) - 1; 2070 2071 Sized_incr_dynobj(const std::string& name, 2072 Sized_incremental_binary<size, big_endian>* ibase, 2073 unsigned int input_file_index); 2074 2075 private: 2076 typedef Incremental_inputs_reader<size, big_endian> Inputs_reader; 2077 typedef typename Inputs_reader::Incremental_input_entry_reader 2078 Input_entry_reader; 2079 2080 // Return TRUE if this is an incremental (unchanged) input file. 2081 bool 2082 do_is_incremental() const 2083 { return true; } 2084 2085 // Return the last modified time of the file. 2086 Timespec 2087 do_get_mtime() 2088 { return this->input_reader_.get_mtime(); } 2089 2090 // Read the symbols. 2091 void 2092 do_read_symbols(Read_symbols_data*); 2093 2094 // Lay out the input sections. 2095 void 2096 do_layout(Symbol_table*, Layout*, Read_symbols_data*); 2097 2098 // Add the symbols to the symbol table. 2099 void 2100 do_add_symbols(Symbol_table*, Read_symbols_data*, Layout*); 2101 2102 Archive::Should_include 2103 do_should_include_member(Symbol_table* symtab, Layout*, Read_symbols_data*, 2104 std::string* why); 2105 2106 // Iterate over global symbols, calling a visitor class V for each. 2107 void 2108 do_for_all_global_symbols(Read_symbols_data* sd, 2109 Library_base::Symbol_visitor_base* v); 2110 2111 // Iterate over local symbols, calling a visitor class V for each GOT offset 2112 // associated with a local symbol. 2113 void 2114 do_for_all_local_got_entries(Got_offset_list::Visitor* v) const; 2115 2116 // Get the size of a section. 2117 uint64_t 2118 do_section_size(unsigned int shndx); 2119 2120 // Get the name of a section. 2121 std::string 2122 do_section_name(unsigned int shndx) const; 2123 2124 // Return a view of the contents of a section. 2125 const unsigned char* 2126 do_section_contents(unsigned int shndx, section_size_type* plen, 2127 bool cache); 2128 2129 // Return section flags. 2130 uint64_t 2131 do_section_flags(unsigned int shndx); 2132 2133 // Return section entsize. 2134 uint64_t 2135 do_section_entsize(unsigned int shndx); 2136 2137 // Return section address. 2138 uint64_t 2139 do_section_address(unsigned int shndx); 2140 2141 // Return section type. 2142 unsigned int 2143 do_section_type(unsigned int shndx); 2144 2145 // Return the section link field. 2146 unsigned int 2147 do_section_link(unsigned int shndx); 2148 2149 // Return the section link field. 2150 unsigned int 2151 do_section_info(unsigned int shndx); 2152 2153 // Return the section alignment. 2154 uint64_t 2155 do_section_addralign(unsigned int shndx); 2156 2157 // Return the Xindex structure to use. 2158 Xindex* 2159 do_initialize_xindex(); 2160 2161 // Get symbol counts. 2162 void 2163 do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const; 2164 2165 // Get global symbols. 2166 const Symbols* 2167 do_get_global_symbols() const 2168 { return &this->symbols_; } 2169 2170 // The Incremental_binary base file. 2171 Sized_incremental_binary<size, big_endian>* ibase_; 2172 // The index of the object in the input file list. 2173 unsigned int input_file_index_; 2174 // The reader for the input file. 2175 Input_entry_reader input_reader_; 2176 // The entries in the symbol table for the external symbols. 2177 Symbols symbols_; 2178 // Number of symbols defined in object file itself. 2179 size_t defined_count_; 2180 }; 2181 2182 // Allocate an incremental object of the appropriate size and endianness. 2183 extern Object* 2184 make_sized_incremental_object( 2185 Incremental_binary* base, 2186 unsigned int input_file_index, 2187 Incremental_input_type input_type, 2188 const Incremental_binary::Input_reader* input_reader); 2189 2190 // This class represents an Archive library (or --start-lib/--end-lib group) 2191 // that has not changed since the last incremental link. Its contents come 2192 // from the incremental inputs entry in the base file. 2193 2194 class Incremental_library : public Library_base 2195 { 2196 public: 2197 Incremental_library(const char* filename, unsigned int input_file_index, 2198 const Incremental_binary::Input_reader* input_reader) 2199 : Library_base(NULL), filename_(filename), 2200 input_file_index_(input_file_index), input_reader_(input_reader), 2201 unused_symbols_(), is_reported_(false) 2202 { } 2203 2204 // Return the input file index. 2205 unsigned int 2206 input_file_index() const 2207 { return this->input_file_index_; } 2208 2209 // Return the serial number of the input file. 2210 unsigned int 2211 arg_serial() const 2212 { return this->input_reader_->arg_serial(); } 2213 2214 // Copy the unused symbols from the incremental input info. 2215 // We need to do this because we may be overwriting the incremental 2216 // input info in the base file before we write the new incremental 2217 // info. 2218 void 2219 copy_unused_symbols(); 2220 2221 // Return FALSE on the first call to indicate that the library needs 2222 // to be recorded; return TRUE subsequently. 2223 bool 2224 is_reported() 2225 { 2226 bool was_reported = this->is_reported_; 2227 is_reported_ = true; 2228 return was_reported; 2229 } 2230 2231 private: 2232 typedef std::vector<std::string> Symbol_list; 2233 2234 // The file name. 2235 const std::string& 2236 do_filename() const 2237 { return this->filename_; } 2238 2239 // Return the modification time of the archive file. 2240 Timespec 2241 do_get_mtime() 2242 { return this->input_reader_->get_mtime(); } 2243 2244 // Iterator for unused global symbols in the library. 2245 void 2246 do_for_all_unused_symbols(Symbol_visitor_base* v) const; 2247 2248 // The name of the library. 2249 std::string filename_; 2250 // The input file index of this library. 2251 unsigned int input_file_index_; 2252 // A reader for the incremental input information. 2253 const Incremental_binary::Input_reader* input_reader_; 2254 // List of unused symbols defined in this library. 2255 Symbol_list unused_symbols_; 2256 // TRUE when this library has been reported to the new incremental info. 2257 bool is_reported_; 2258 }; 2259 2260 } // End namespace gold. 2261 2262 #endif // !defined(GOLD_INCREMENTAL_H) 2263