Home | History | Annotate | Download | only in gold
      1 // inremental.h -- incremental linking support for gold   -*- C++ -*-
      2 
      3 // Copyright (C) 2009-2014 Free Software Foundation, Inc.
      4 // Written by Mikolaj Zalewski <mikolajz (at) google.com>.
      5 
      6 // This file is part of gold.
      7 
      8 // This program is free software; you can redistribute it and/or modify
      9 // it under the terms of the GNU General Public License as published by
     10 // the Free Software Foundation; either version 3 of the License, or
     11 // (at your option) any later version.
     12 
     13 // This program is distributed in the hope that it will be useful,
     14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
     15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     16 // GNU General Public License for more details.
     17 
     18 // You should have received a copy of the GNU General Public License
     19 // along with this program; if not, write to the Free Software
     20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
     21 // MA 02110-1301, USA.
     22 
     23 #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     virtual
   1372     ~Input_reader()
   1373     { }
   1374 
   1375     const char*
   1376     filename() const
   1377     { return this->do_filename(); }
   1378 
   1379     Timespec
   1380     get_mtime() const
   1381     { return this->do_get_mtime(); }
   1382 
   1383     Incremental_input_type
   1384     type() const
   1385     { return this->do_type(); }
   1386 
   1387     unsigned int
   1388     arg_serial() const
   1389     { return this->do_arg_serial(); }
   1390 
   1391     unsigned int
   1392     get_unused_symbol_count() const
   1393     { return this->do_get_unused_symbol_count(); }
   1394 
   1395     const char*
   1396     get_unused_symbol(unsigned int n) const
   1397     { return this->do_get_unused_symbol(n); }
   1398 
   1399    protected:
   1400     virtual const char*
   1401     do_filename() const = 0;
   1402 
   1403     virtual Timespec
   1404     do_get_mtime() const = 0;
   1405 
   1406     virtual Incremental_input_type
   1407     do_type() const = 0;
   1408 
   1409     virtual unsigned int
   1410     do_arg_serial() const = 0;
   1411 
   1412     virtual unsigned int
   1413     do_get_unused_symbol_count() const = 0;
   1414 
   1415     virtual const char*
   1416     do_get_unused_symbol(unsigned int n) const = 0;
   1417   };
   1418 
   1419   // Return the number of input files.
   1420   unsigned int
   1421   input_file_count() const
   1422   { return this->do_input_file_count(); }
   1423 
   1424   // Return an Input_reader for input file N.
   1425   const Input_reader*
   1426   get_input_reader(unsigned int n) const
   1427   { return this->do_get_input_reader(n); }
   1428 
   1429   // Return TRUE if the input file N has changed since the last link.
   1430   bool
   1431   file_has_changed(unsigned int n) const
   1432   { return this->do_file_has_changed(n); }
   1433 
   1434   // Return the Input_argument for input file N.  Returns NULL if
   1435   // the Input_argument is not available.
   1436   const Input_argument*
   1437   get_input_argument(unsigned int n) const
   1438   {
   1439     const Input_reader* input_file = this->do_get_input_reader(n);
   1440     unsigned int arg_serial = input_file->arg_serial();
   1441     if (arg_serial == 0 || arg_serial > this->input_args_map_.size())
   1442       return NULL;
   1443     return this->input_args_map_[arg_serial - 1];
   1444   }
   1445 
   1446   // Return an Incremental_library for the given input file.
   1447   Incremental_library*
   1448   get_library(unsigned int n) const
   1449   { return this->library_map_[n]; }
   1450 
   1451   // Return a Script_info for the given input file.
   1452   Script_info*
   1453   get_script_info(unsigned int n) const
   1454   { return this->script_map_[n]; }
   1455 
   1456   // Initialize the layout of the output file based on the existing
   1457   // output file.
   1458   void
   1459   init_layout(Layout* layout)
   1460   { this->do_init_layout(layout); }
   1461 
   1462   // Mark regions of the input file that must be kept unchanged.
   1463   void
   1464   reserve_layout(unsigned int input_file_index)
   1465   { this->do_reserve_layout(input_file_index); }
   1466 
   1467   // Process the GOT and PLT entries from the existing output file.
   1468   void
   1469   process_got_plt(Symbol_table* symtab, Layout* layout)
   1470   { this->do_process_got_plt(symtab, layout); }
   1471 
   1472   // Emit COPY relocations from the existing output file.
   1473   void
   1474   emit_copy_relocs(Symbol_table* symtab)
   1475   { this->do_emit_copy_relocs(symtab); }
   1476 
   1477   // Apply incremental relocations for symbols whose values have changed.
   1478   void
   1479   apply_incremental_relocs(const Symbol_table* symtab, Layout* layout,
   1480 			   Output_file* of)
   1481   { this->do_apply_incremental_relocs(symtab, layout, of); }
   1482 
   1483   // Functions and types for the elfcpp::Elf_file interface.  This
   1484   // permit us to use Incremental_binary as the File template parameter for
   1485   // elfcpp::Elf_file.
   1486 
   1487   // The View class is returned by view.  It must support a single
   1488   // method, data().  This is trivial, because Output_file::get_output_view
   1489   // does what we need.
   1490   class View
   1491   {
   1492    public:
   1493     View(const unsigned char* p)
   1494       : p_(p)
   1495     { }
   1496 
   1497     const unsigned char*
   1498     data() const
   1499     { return this->p_; }
   1500 
   1501    private:
   1502     const unsigned char* p_;
   1503   };
   1504 
   1505   // Return a View.
   1506   View
   1507   view(off_t file_offset, section_size_type data_size)
   1508   { return View(this->output_->get_input_view(file_offset, data_size)); }
   1509 
   1510   // A location in the file.
   1511   struct Location
   1512   {
   1513     off_t file_offset;
   1514     off_t data_size;
   1515 
   1516     Location(off_t fo, section_size_type ds)
   1517       : file_offset(fo), data_size(ds)
   1518     { }
   1519 
   1520     Location()
   1521       : file_offset(0), data_size(0)
   1522     { }
   1523   };
   1524 
   1525   // Get a View given a Location.
   1526   View
   1527   view(Location loc)
   1528   { return View(this->view(loc.file_offset, loc.data_size)); }
   1529 
   1530   // Return the Output_file.
   1531   Output_file*
   1532   output_file()
   1533   { return this->output_; }
   1534 
   1535  protected:
   1536   // Check the .gnu_incremental_inputs section to see whether an incremental
   1537   // build is possible.
   1538   virtual bool
   1539   do_check_inputs(const Command_line& cmdline,
   1540 		  Incremental_inputs* incremental_inputs) = 0;
   1541 
   1542   // Return TRUE if input file N has changed since the last incremental link.
   1543   virtual bool
   1544   do_file_has_changed(unsigned int n) const = 0;
   1545 
   1546   // Initialize the layout of the output file based on the existing
   1547   // output file.
   1548   virtual void
   1549   do_init_layout(Layout* layout) = 0;
   1550 
   1551   // Mark regions of the input file that must be kept unchanged.
   1552   virtual void
   1553   do_reserve_layout(unsigned int input_file_index) = 0;
   1554 
   1555   // Process the GOT and PLT entries from the existing output file.
   1556   virtual void
   1557   do_process_got_plt(Symbol_table* symtab, Layout* layout) = 0;
   1558 
   1559   // Emit COPY relocations from the existing output file.
   1560   virtual void
   1561   do_emit_copy_relocs(Symbol_table* symtab) = 0;
   1562 
   1563   // Apply incremental relocations for symbols whose values have changed.
   1564   virtual void
   1565   do_apply_incremental_relocs(const Symbol_table*, Layout*, Output_file*) = 0;
   1566 
   1567   virtual unsigned int
   1568   do_input_file_count() const = 0;
   1569 
   1570   virtual const Input_reader*
   1571   do_get_input_reader(unsigned int) const = 0;
   1572 
   1573   // Map from input file index to Input_argument.
   1574   std::vector<const Input_argument*> input_args_map_;
   1575   // Map from an input file index to an Incremental_library.
   1576   std::vector<Incremental_library*> library_map_;
   1577   // Map from an input file index to a Script_info.
   1578   std::vector<Script_info*> script_map_;
   1579 
   1580  private:
   1581   // Edited output file object.
   1582   Output_file* output_;
   1583 };
   1584 
   1585 template<int size, bool big_endian>
   1586 class Sized_relobj_incr;
   1587 
   1588 template<int size, bool big_endian>
   1589 class Sized_incremental_binary : public Incremental_binary
   1590 {
   1591  public:
   1592   Sized_incremental_binary(Output_file* output,
   1593                            const elfcpp::Ehdr<size, big_endian>& ehdr,
   1594                            Target* target)
   1595     : Incremental_binary(output, target), elf_file_(this, ehdr),
   1596       input_objects_(), section_map_(), symbol_map_(), copy_relocs_(),
   1597       main_symtab_loc_(), main_strtab_loc_(), has_incremental_info_(false),
   1598       inputs_reader_(), symtab_reader_(), relocs_reader_(), got_plt_reader_(),
   1599       input_entry_readers_()
   1600   { this->setup_readers(); }
   1601 
   1602   // Returns TRUE if the file contains incremental info.
   1603   bool
   1604   has_incremental_info() const
   1605   { return this->has_incremental_info_; }
   1606 
   1607   // Record a pointer to the object for input file N.
   1608   void
   1609   set_input_object(unsigned int n,
   1610 		   Sized_relobj_incr<size, big_endian>* obj)
   1611   { this->input_objects_[n] = obj; }
   1612 
   1613   // Return a pointer to the object for input file N.
   1614   Sized_relobj_incr<size, big_endian>*
   1615   input_object(unsigned int n) const
   1616   {
   1617     gold_assert(n < this->input_objects_.size());
   1618     return this->input_objects_[n];
   1619   }
   1620 
   1621   // Return the Output_section for section index SHNDX.
   1622   Output_section*
   1623   output_section(unsigned int shndx)
   1624   { return this->section_map_[shndx]; }
   1625 
   1626   // Map a symbol table entry from the base file to the output symbol table.
   1627   // SYMNDX is relative to the first forced-local or global symbol in the
   1628   // input file symbol table.
   1629   void
   1630   add_global_symbol(unsigned int symndx, Symbol* gsym)
   1631   { this->symbol_map_[symndx] = gsym; }
   1632 
   1633   // Map a symbol table entry from the base file to the output symbol table.
   1634   // SYMNDX is relative to the first forced-local or global symbol in the
   1635   // input file symbol table.
   1636   Symbol*
   1637   global_symbol(unsigned int symndx) const
   1638   { return this->symbol_map_[symndx]; }
   1639 
   1640   // Add a COPY relocation for a global symbol.
   1641   void
   1642   add_copy_reloc(Symbol* gsym, Output_section* os, off_t offset)
   1643   { this->copy_relocs_.push_back(Copy_reloc(gsym, os, offset)); }
   1644 
   1645   // Readers for the incremental info sections.
   1646 
   1647   const Incremental_inputs_reader<size, big_endian>&
   1648   inputs_reader() const
   1649   { return this->inputs_reader_; }
   1650 
   1651   const Incremental_symtab_reader<big_endian>&
   1652   symtab_reader() const
   1653   { return this->symtab_reader_; }
   1654 
   1655   const Incremental_relocs_reader<size, big_endian>&
   1656   relocs_reader() const
   1657   { return this->relocs_reader_; }
   1658 
   1659   const Incremental_got_plt_reader<big_endian>&
   1660   got_plt_reader() const
   1661   { return this->got_plt_reader_; }
   1662 
   1663   void
   1664   get_symtab_view(View* symtab_view, unsigned int* sym_count,
   1665 		  elfcpp::Elf_strtab* strtab);
   1666 
   1667  protected:
   1668   typedef Incremental_inputs_reader<size, big_endian> Inputs_reader;
   1669   typedef typename Inputs_reader::Incremental_input_entry_reader
   1670       Input_entry_reader;
   1671 
   1672   virtual bool
   1673   do_check_inputs(const Command_line& cmdline,
   1674 		  Incremental_inputs* incremental_inputs);
   1675 
   1676   // Return TRUE if input file N has changed since the last incremental link.
   1677   virtual bool
   1678   do_file_has_changed(unsigned int n) const;
   1679 
   1680   // Initialize the layout of the output file based on the existing
   1681   // output file.
   1682   virtual void
   1683   do_init_layout(Layout* layout);
   1684 
   1685   // Mark regions of the input file that must be kept unchanged.
   1686   virtual void
   1687   do_reserve_layout(unsigned int input_file_index);
   1688 
   1689   // Process the GOT and PLT entries from the existing output file.
   1690   virtual void
   1691   do_process_got_plt(Symbol_table* symtab, Layout* layout);
   1692 
   1693   // Emit COPY relocations from the existing output file.
   1694   virtual void
   1695   do_emit_copy_relocs(Symbol_table* symtab);
   1696 
   1697   // Apply incremental relocations for symbols whose values have changed.
   1698   virtual void
   1699   do_apply_incremental_relocs(const Symbol_table* symtab, Layout* layout,
   1700 			      Output_file* of);
   1701 
   1702   // Proxy class for a sized Incremental_input_entry_reader.
   1703 
   1704   class Sized_input_reader : public Input_reader
   1705   {
   1706    public:
   1707     Sized_input_reader(Input_entry_reader r)
   1708       : Input_reader(), reader_(r)
   1709     { }
   1710 
   1711     virtual
   1712     ~Sized_input_reader()
   1713     { }
   1714 
   1715    private:
   1716     const char*
   1717     do_filename() const
   1718     { return this->reader_.filename(); }
   1719 
   1720     Timespec
   1721     do_get_mtime() const
   1722     { return this->reader_.get_mtime(); }
   1723 
   1724     Incremental_input_type
   1725     do_type() const
   1726     { return this->reader_.type(); }
   1727 
   1728     unsigned int
   1729     do_arg_serial() const
   1730     { return this->reader_.arg_serial(); }
   1731 
   1732     unsigned int
   1733     do_get_unused_symbol_count() const
   1734     { return this->reader_.get_unused_symbol_count(); }
   1735 
   1736     const char*
   1737     do_get_unused_symbol(unsigned int n) const
   1738     { return this->reader_.get_unused_symbol(n); }
   1739 
   1740     Input_entry_reader reader_;
   1741   };
   1742 
   1743   virtual unsigned int
   1744   do_input_file_count() const
   1745   { return this->inputs_reader_.input_file_count(); }
   1746 
   1747   virtual const Input_reader*
   1748   do_get_input_reader(unsigned int n) const
   1749   {
   1750     gold_assert(n < this->input_entry_readers_.size());
   1751     return &this->input_entry_readers_[n];
   1752   }
   1753 
   1754  private:
   1755   // List of symbols that need COPY relocations.
   1756   struct Copy_reloc
   1757   {
   1758     Copy_reloc(Symbol* sym, Output_section* os, off_t off)
   1759       : symbol(sym), output_section(os), offset(off)
   1760     { }
   1761 
   1762     // The global symbol to copy.
   1763     Symbol* symbol;
   1764     // The output section into which the symbol was copied.
   1765     Output_section* output_section;
   1766     // The offset within that output section.
   1767     off_t offset;
   1768   };
   1769   typedef std::vector<Copy_reloc> Copy_relocs;
   1770 
   1771   bool
   1772   find_incremental_inputs_sections(unsigned int* p_inputs_shndx,
   1773 				   unsigned int* p_symtab_shndx,
   1774 				   unsigned int* p_relocs_shndx,
   1775 				   unsigned int* p_got_plt_shndx,
   1776 				   unsigned int* p_strtab_shndx);
   1777 
   1778   void
   1779   setup_readers();
   1780 
   1781   // Output as an ELF file.
   1782   elfcpp::Elf_file<size, big_endian, Incremental_binary> elf_file_;
   1783 
   1784   // Vector of pointers to the input objects for the unchanged files.
   1785   // For replaced files, the corresponding pointer is NULL.
   1786   std::vector<Sized_relobj_incr<size, big_endian>*> input_objects_;
   1787 
   1788   // Map section index to an Output_section in the updated layout.
   1789   std::vector<Output_section*> section_map_;
   1790 
   1791   // Map global symbols from the input file to the symbol table.
   1792   std::vector<Symbol*> symbol_map_;
   1793 
   1794   // List of symbols that need COPY relocations.
   1795   Copy_relocs copy_relocs_;
   1796 
   1797   // Locations of the main symbol table and symbol string table.
   1798   Location main_symtab_loc_;
   1799   Location main_strtab_loc_;
   1800 
   1801   // Readers for the incremental info sections.
   1802   bool has_incremental_info_;
   1803   Incremental_inputs_reader<size, big_endian> inputs_reader_;
   1804   Incremental_symtab_reader<big_endian> symtab_reader_;
   1805   Incremental_relocs_reader<size, big_endian> relocs_reader_;
   1806   Incremental_got_plt_reader<big_endian> got_plt_reader_;
   1807   std::vector<Sized_input_reader> input_entry_readers_;
   1808 };
   1809 
   1810 // An incremental Relobj.  This class represents a relocatable object
   1811 // that has not changed since the last incremental link, and whose contents
   1812 // can be used directly from the base file.
   1813 
   1814 template<int size, bool big_endian>
   1815 class Sized_relobj_incr : public Sized_relobj<size, big_endian>
   1816 {
   1817  public:
   1818   typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
   1819   typedef typename Sized_relobj<size, big_endian>::Symbols Symbols;
   1820 
   1821   Sized_relobj_incr(const std::string& name,
   1822 		    Sized_incremental_binary<size, big_endian>* ibase,
   1823 		    unsigned int input_file_index);
   1824 
   1825  private:
   1826   // For convenience.
   1827   typedef Sized_relobj_incr<size, big_endian> This;
   1828   static const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
   1829 
   1830   typedef typename Sized_relobj<size, big_endian>::Output_sections
   1831       Output_sections;
   1832   typedef Incremental_inputs_reader<size, big_endian> Inputs_reader;
   1833   typedef typename Inputs_reader::Incremental_input_entry_reader
   1834       Input_entry_reader;
   1835 
   1836   // A local symbol.
   1837   struct Local_symbol
   1838   {
   1839     Local_symbol(const char* name_, Address value_, unsigned int size_,
   1840 		 unsigned int shndx_, unsigned int type_,
   1841 		 bool needs_dynsym_entry_)
   1842       : st_value(value_), name(name_), st_size(size_), st_shndx(shndx_),
   1843 	st_type(type_), output_dynsym_index(0),
   1844 	needs_dynsym_entry(needs_dynsym_entry_)
   1845     { }
   1846     // The symbol value.
   1847     Address st_value;
   1848     // The symbol name.  This points to the stringpool entry.
   1849     const char* name;
   1850     // The symbol size.
   1851     unsigned int st_size;
   1852     // The output section index.
   1853     unsigned int st_shndx : 28;
   1854     // The symbol type.
   1855     unsigned int st_type : 4;
   1856     // The index of the symbol in the output dynamic symbol table.
   1857     unsigned int output_dynsym_index : 31;
   1858     // TRUE if the symbol needs to appear in the dynamic symbol table.
   1859     unsigned int needs_dynsym_entry : 1;
   1860   };
   1861 
   1862   // Return TRUE if this is an incremental (unchanged) input file.
   1863   bool
   1864   do_is_incremental() const
   1865   { return true; }
   1866 
   1867   // Return the last modified time of the file.
   1868   Timespec
   1869   do_get_mtime()
   1870   { return this->input_reader_.get_mtime(); }
   1871 
   1872   // Read the symbols.
   1873   void
   1874   do_read_symbols(Read_symbols_data*);
   1875 
   1876   // Lay out the input sections.
   1877   void
   1878   do_layout(Symbol_table*, Layout*, Read_symbols_data*);
   1879 
   1880   // Layout sections whose layout was deferred while waiting for
   1881   // input files from a plugin.
   1882   void
   1883   do_layout_deferred_sections(Layout*);
   1884 
   1885   // Add the symbols to the symbol table.
   1886   void
   1887   do_add_symbols(Symbol_table*, Read_symbols_data*, Layout*);
   1888 
   1889   Archive::Should_include
   1890   do_should_include_member(Symbol_table* symtab, Layout*, Read_symbols_data*,
   1891                            std::string* why);
   1892 
   1893   // Iterate over global symbols, calling a visitor class V for each.
   1894   void
   1895   do_for_all_global_symbols(Read_symbols_data* sd,
   1896 			    Library_base::Symbol_visitor_base* v);
   1897 
   1898   // Get the size of a section.
   1899   uint64_t
   1900   do_section_size(unsigned int shndx);
   1901 
   1902   // Get the name of a section.
   1903   std::string
   1904   do_section_name(unsigned int shndx) const;
   1905 
   1906   // Return a view of the contents of a section.
   1907   const unsigned char*
   1908   do_section_contents(unsigned int shndx, section_size_type* plen,
   1909 		      bool cache);
   1910 
   1911   // Return section flags.
   1912   uint64_t
   1913   do_section_flags(unsigned int shndx);
   1914 
   1915   // Return section entsize.
   1916   uint64_t
   1917   do_section_entsize(unsigned int shndx);
   1918 
   1919   // Return section address.
   1920   uint64_t
   1921   do_section_address(unsigned int shndx);
   1922 
   1923   // Return section type.
   1924   unsigned int
   1925   do_section_type(unsigned int shndx);
   1926 
   1927   // Return the section link field.
   1928   unsigned int
   1929   do_section_link(unsigned int shndx);
   1930 
   1931   // Return the section link field.
   1932   unsigned int
   1933   do_section_info(unsigned int shndx);
   1934 
   1935   // Return the section alignment.
   1936   uint64_t
   1937   do_section_addralign(unsigned int shndx);
   1938 
   1939   // Return the Xindex structure to use.
   1940   Xindex*
   1941   do_initialize_xindex();
   1942 
   1943   // Get symbol counts.
   1944   void
   1945   do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const;
   1946 
   1947   // Get global symbols.
   1948   const Symbols*
   1949   do_get_global_symbols() const
   1950   { return &this->symbols_; }
   1951 
   1952   // Return the value of a local symbol.
   1953   uint64_t
   1954   do_local_symbol_value(unsigned int, uint64_t) const
   1955   { gold_unreachable(); }
   1956 
   1957   unsigned int
   1958   do_local_plt_offset(unsigned int) const
   1959   { gold_unreachable(); }
   1960 
   1961   bool
   1962   do_local_is_tls(unsigned int) const
   1963   { gold_unreachable(); }
   1964 
   1965   // Return the number of local symbols.
   1966   unsigned int
   1967   do_local_symbol_count() const
   1968   { return this->local_symbol_count_; }
   1969 
   1970   // Return the number of local symbols in the output symbol table.
   1971   unsigned int
   1972   do_output_local_symbol_count() const
   1973   { return this->local_symbol_count_; }
   1974 
   1975   // Return the file offset for local symbols in the output symbol table.
   1976   off_t
   1977   do_local_symbol_offset() const
   1978   { return this->local_symbol_offset_; }
   1979 
   1980   // Read the relocs.
   1981   void
   1982   do_read_relocs(Read_relocs_data*);
   1983 
   1984   // Process the relocs to find list of referenced sections. Used only
   1985   // during garbage collection.
   1986   void
   1987   do_gc_process_relocs(Symbol_table*, Layout*, Read_relocs_data*);
   1988 
   1989   // Scan the relocs and adjust the symbol table.
   1990   void
   1991   do_scan_relocs(Symbol_table*, Layout*, Read_relocs_data*);
   1992 
   1993   // Count the local symbols.
   1994   void
   1995   do_count_local_symbols(Stringpool_template<char>*,
   1996 			 Stringpool_template<char>*);
   1997 
   1998   // Finalize the local symbols.
   1999   unsigned int
   2000   do_finalize_local_symbols(unsigned int, off_t, Symbol_table*);
   2001 
   2002   // Set the offset where local dynamic symbol information will be stored.
   2003   unsigned int
   2004   do_set_local_dynsym_indexes(unsigned int);
   2005 
   2006   // Set the offset where local dynamic symbol information will be stored.
   2007   unsigned int
   2008   do_set_local_dynsym_offset(off_t);
   2009 
   2010   // Relocate the input sections and write out the local symbols.
   2011   void
   2012   do_relocate(const Symbol_table* symtab, const Layout*, Output_file* of);
   2013 
   2014   // Set the offset of a section.
   2015   void
   2016   do_set_section_offset(unsigned int shndx, uint64_t off);
   2017 
   2018   // The Incremental_binary base file.
   2019   Sized_incremental_binary<size, big_endian>* ibase_;
   2020   // The index of the object in the input file list.
   2021   unsigned int input_file_index_;
   2022   // The reader for the input file.
   2023   Input_entry_reader input_reader_;
   2024   // The number of local symbols.
   2025   unsigned int local_symbol_count_;
   2026   // The number of local symbols which go into the output file's dynamic
   2027   // symbol table.
   2028   unsigned int output_local_dynsym_count_;
   2029   // This starting symbol index in the output symbol table.
   2030   unsigned int local_symbol_index_;
   2031   // The file offset for local symbols in the output symbol table.
   2032   unsigned int local_symbol_offset_;
   2033   // The file offset for local symbols in the output symbol table.
   2034   unsigned int local_dynsym_offset_;
   2035   // The entries in the symbol table for the external symbols.
   2036   Symbols symbols_;
   2037   // Number of symbols defined in object file itself.
   2038   size_t defined_count_;
   2039   // The offset of the first incremental relocation for this object.
   2040   unsigned int incr_reloc_offset_;
   2041   // The number of incremental relocations for this object.
   2042   unsigned int incr_reloc_count_;
   2043   // The index of the first incremental relocation for this object in the
   2044   // updated output file.
   2045   unsigned int incr_reloc_output_index_;
   2046   // A copy of the incremental relocations from this object.
   2047   unsigned char* incr_relocs_;
   2048   // The local symbols.
   2049   std::vector<Local_symbol> local_symbols_;
   2050 };
   2051 
   2052 // An incremental Dynobj.  This class represents a shared object that has
   2053 // not changed since the last incremental link, and whose contents can be
   2054 // used directly from the base file.
   2055 
   2056 template<int size, bool big_endian>
   2057 class Sized_incr_dynobj : public Dynobj
   2058 {
   2059  public:
   2060   typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
   2061 
   2062   static const Address invalid_address = static_cast<Address>(0) - 1;
   2063 
   2064   Sized_incr_dynobj(const std::string& name,
   2065 		    Sized_incremental_binary<size, big_endian>* ibase,
   2066 		    unsigned int input_file_index);
   2067 
   2068  private:
   2069   typedef Incremental_inputs_reader<size, big_endian> Inputs_reader;
   2070   typedef typename Inputs_reader::Incremental_input_entry_reader
   2071       Input_entry_reader;
   2072 
   2073   // Return TRUE if this is an incremental (unchanged) input file.
   2074   bool
   2075   do_is_incremental() const
   2076   { return true; }
   2077 
   2078   // Return the last modified time of the file.
   2079   Timespec
   2080   do_get_mtime()
   2081   { return this->input_reader_.get_mtime(); }
   2082 
   2083   // Read the symbols.
   2084   void
   2085   do_read_symbols(Read_symbols_data*);
   2086 
   2087   // Lay out the input sections.
   2088   void
   2089   do_layout(Symbol_table*, Layout*, Read_symbols_data*);
   2090 
   2091   // Add the symbols to the symbol table.
   2092   void
   2093   do_add_symbols(Symbol_table*, Read_symbols_data*, Layout*);
   2094 
   2095   Archive::Should_include
   2096   do_should_include_member(Symbol_table* symtab, Layout*, Read_symbols_data*,
   2097                            std::string* why);
   2098 
   2099   // Iterate over global symbols, calling a visitor class V for each.
   2100   void
   2101   do_for_all_global_symbols(Read_symbols_data* sd,
   2102 			    Library_base::Symbol_visitor_base* v);
   2103 
   2104   // Iterate over local symbols, calling a visitor class V for each GOT offset
   2105   // associated with a local symbol.
   2106   void
   2107   do_for_all_local_got_entries(Got_offset_list::Visitor* v) const;
   2108 
   2109   // Get the size of a section.
   2110   uint64_t
   2111   do_section_size(unsigned int shndx);
   2112 
   2113   // Get the name of a section.
   2114   std::string
   2115   do_section_name(unsigned int shndx) const;
   2116 
   2117   // Return a view of the contents of a section.
   2118   const unsigned char*
   2119   do_section_contents(unsigned int shndx, section_size_type* plen,
   2120 		      bool cache);
   2121 
   2122   // Return section flags.
   2123   uint64_t
   2124   do_section_flags(unsigned int shndx);
   2125 
   2126   // Return section entsize.
   2127   uint64_t
   2128   do_section_entsize(unsigned int shndx);
   2129 
   2130   // Return section address.
   2131   uint64_t
   2132   do_section_address(unsigned int shndx);
   2133 
   2134   // Return section type.
   2135   unsigned int
   2136   do_section_type(unsigned int shndx);
   2137 
   2138   // Return the section link field.
   2139   unsigned int
   2140   do_section_link(unsigned int shndx);
   2141 
   2142   // Return the section link field.
   2143   unsigned int
   2144   do_section_info(unsigned int shndx);
   2145 
   2146   // Return the section alignment.
   2147   uint64_t
   2148   do_section_addralign(unsigned int shndx);
   2149 
   2150   // Return the Xindex structure to use.
   2151   Xindex*
   2152   do_initialize_xindex();
   2153 
   2154   // Get symbol counts.
   2155   void
   2156   do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const;
   2157 
   2158   // Get global symbols.
   2159   const Symbols*
   2160   do_get_global_symbols() const
   2161   { return &this->symbols_; }
   2162 
   2163   // The Incremental_binary base file.
   2164   Sized_incremental_binary<size, big_endian>* ibase_;
   2165   // The index of the object in the input file list.
   2166   unsigned int input_file_index_;
   2167   // The reader for the input file.
   2168   Input_entry_reader input_reader_;
   2169   // The entries in the symbol table for the external symbols.
   2170   Symbols symbols_;
   2171   // Number of symbols defined in object file itself.
   2172   size_t defined_count_;
   2173 };
   2174 
   2175 // Allocate an incremental object of the appropriate size and endianness.
   2176 extern Object*
   2177 make_sized_incremental_object(
   2178     Incremental_binary* base,
   2179     unsigned int input_file_index,
   2180     Incremental_input_type input_type,
   2181     const Incremental_binary::Input_reader* input_reader);
   2182 
   2183 // This class represents an Archive library (or --start-lib/--end-lib group)
   2184 // that has not changed since the last incremental link.  Its contents come
   2185 // from the incremental inputs entry in the base file.
   2186 
   2187 class Incremental_library : public Library_base
   2188 {
   2189  public:
   2190   Incremental_library(const char* filename, unsigned int input_file_index,
   2191 		      const Incremental_binary::Input_reader* input_reader)
   2192     : Library_base(NULL), filename_(filename),
   2193       input_file_index_(input_file_index), input_reader_(input_reader),
   2194       unused_symbols_(), is_reported_(false)
   2195   { }
   2196 
   2197   // Return the input file index.
   2198   unsigned int
   2199   input_file_index() const
   2200   { return this->input_file_index_; }
   2201 
   2202   // Return the serial number of the input file.
   2203   unsigned int
   2204   arg_serial() const
   2205   { return this->input_reader_->arg_serial(); }
   2206 
   2207   // Copy the unused symbols from the incremental input info.
   2208   // We need to do this because we may be overwriting the incremental
   2209   // input info in the base file before we write the new incremental
   2210   // info.
   2211   void
   2212   copy_unused_symbols();
   2213 
   2214   // Return FALSE on the first call to indicate that the library needs
   2215   // to be recorded; return TRUE subsequently.
   2216   bool
   2217   is_reported()
   2218   {
   2219     bool was_reported = this->is_reported_;
   2220     is_reported_ = true;
   2221     return was_reported;
   2222   }
   2223 
   2224  private:
   2225   typedef std::vector<std::string> Symbol_list;
   2226 
   2227   // The file name.
   2228   const std::string&
   2229   do_filename() const
   2230   { return this->filename_; }
   2231 
   2232   // Return the modification time of the archive file.
   2233   Timespec
   2234   do_get_mtime()
   2235   { return this->input_reader_->get_mtime(); }
   2236 
   2237   // Iterator for unused global symbols in the library.
   2238   void
   2239   do_for_all_unused_symbols(Symbol_visitor_base* v) const;
   2240 
   2241   // The name of the library.
   2242   std::string filename_;
   2243   // The input file index of this library.
   2244   unsigned int input_file_index_;
   2245   // A reader for the incremental input information.
   2246   const Incremental_binary::Input_reader* input_reader_;
   2247   // List of unused symbols defined in this library.
   2248   Symbol_list unused_symbols_;
   2249   // TRUE when this library has been reported to the new incremental info.
   2250   bool is_reported_;
   2251 };
   2252 
   2253 } // End namespace gold.
   2254 
   2255 #endif // !defined(GOLD_INCREMENTAL_H)
   2256