gold/incremental.h

   1 // inremental.h -- incremental linking support for gold   -*- C++ -*-
   2
   3 // Copyright (C) 2009-2023 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)