gold/
[external/binutils.git] / gold / incremental.cc
1 // inremental.cc -- incremental linking support for gold
2
3 // Copyright 2009, 2010, 2011, 2012 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 #include "gold.h"
24
25 #include <set>
26 #include <cstdarg>
27 #include "libiberty.h"
28
29 #include "elfcpp.h"
30 #include "options.h"
31 #include "output.h"
32 #include "symtab.h"
33 #include "incremental.h"
34 #include "archive.h"
35 #include "object.h"
36 #include "output.h"
37 #include "target-select.h"
38 #include "target.h"
39 #include "fileread.h"
40 #include "script.h"
41
42 namespace gold {
43
44 // Version number for the .gnu_incremental_inputs section.
45 // Version 1 was the initial checkin.
46 // Version 2 adds some padding to ensure 8-byte alignment where necessary.
47 const unsigned int INCREMENTAL_LINK_VERSION = 2;
48
49 // This class manages the .gnu_incremental_inputs section, which holds
50 // the header information, a directory of input files, and separate
51 // entries for each input file.
52
53 template<int size, bool big_endian>
54 class Output_section_incremental_inputs : public Output_section_data
55 {
56  public:
57   Output_section_incremental_inputs(const Incremental_inputs* inputs,
58                                     const Symbol_table* symtab)
59     : Output_section_data(size / 8), inputs_(inputs), symtab_(symtab)
60   { }
61
62  protected:
63   // This is called to update the section size prior to assigning
64   // the address and file offset.
65   void
66   update_data_size()
67   { this->set_final_data_size(); }
68
69   // Set the final data size.
70   void
71   set_final_data_size();
72
73   // Write the data to the file.
74   void
75   do_write(Output_file*);
76
77   // Write to a map file.
78   void
79   do_print_to_mapfile(Mapfile* mapfile) const
80   { mapfile->print_output_data(this, _("** incremental_inputs")); }
81
82  private:
83   // Write the section header.
84   unsigned char*
85   write_header(unsigned char* pov, unsigned int input_file_count,
86                section_offset_type command_line_offset);
87
88   // Write the input file entries.
89   unsigned char*
90   write_input_files(unsigned char* oview, unsigned char* pov,
91                     Stringpool* strtab);
92
93   // Write the supplemental information blocks.
94   unsigned char*
95   write_info_blocks(unsigned char* oview, unsigned char* pov,
96                     Stringpool* strtab, unsigned int* global_syms,
97                     unsigned int global_sym_count);
98
99   // Write the contents of the .gnu_incremental_symtab section.
100   void
101   write_symtab(unsigned char* pov, unsigned int* global_syms,
102                unsigned int global_sym_count);
103
104   // Write the contents of the .gnu_incremental_got_plt section.
105   void
106   write_got_plt(unsigned char* pov, off_t view_size);
107
108   // Typedefs for writing the data to the output sections.
109   typedef elfcpp::Swap<size, big_endian> Swap;
110   typedef elfcpp::Swap<16, big_endian> Swap16;
111   typedef elfcpp::Swap<32, big_endian> Swap32;
112   typedef elfcpp::Swap<64, big_endian> Swap64;
113
114   // Sizes of various structures.
115   static const int sizeof_addr = size / 8;
116   static const int header_size =
117       Incremental_inputs_reader<size, big_endian>::header_size;
118   static const int input_entry_size =
119       Incremental_inputs_reader<size, big_endian>::input_entry_size;
120   static const unsigned int object_info_size =
121       Incremental_inputs_reader<size, big_endian>::object_info_size;
122   static const unsigned int input_section_entry_size =
123       Incremental_inputs_reader<size, big_endian>::input_section_entry_size;
124   static const unsigned int global_sym_entry_size =
125       Incremental_inputs_reader<size, big_endian>::global_sym_entry_size;
126   static const unsigned int incr_reloc_size =
127       Incremental_relocs_reader<size, big_endian>::reloc_size;
128
129   // The Incremental_inputs object.
130   const Incremental_inputs* inputs_;
131
132   // The symbol table.
133   const Symbol_table* symtab_;
134 };
135
136 // Inform the user why we don't do an incremental link.  Not called in
137 // the obvious case of missing output file.  TODO: Is this helpful?
138
139 void
140 vexplain_no_incremental(const char* format, va_list args)
141 {
142   char* buf = NULL;
143   if (vasprintf(&buf, format, args) < 0)
144     gold_nomem();
145   gold_info(_("the link might take longer: "
146               "cannot perform incremental link: %s"), buf);
147   free(buf);
148 }
149
150 void
151 explain_no_incremental(const char* format, ...)
152 {
153   va_list args;
154   va_start(args, format);
155   vexplain_no_incremental(format, args);
156   va_end(args);
157 }
158
159 // Report an error.
160
161 void
162 Incremental_binary::error(const char* format, ...) const
163 {
164   va_list args;
165   va_start(args, format);
166   // Current code only checks if the file can be used for incremental linking,
167   // so errors shouldn't fail the build, but only result in a fallback to a
168   // full build.
169   // TODO: when we implement incremental editing of the file, we may need a
170   // flag that will cause errors to be treated seriously.
171   vexplain_no_incremental(format, args);
172   va_end(args);
173 }
174
175 // Return TRUE if a section of type SH_TYPE can be updated in place
176 // during an incremental update.  We can update sections of type PROGBITS,
177 // NOBITS, INIT_ARRAY, FINI_ARRAY, PREINIT_ARRAY, and NOTE.  All others
178 // will be regenerated.
179
180 bool
181 can_incremental_update(unsigned int sh_type)
182 {
183   return (sh_type == elfcpp::SHT_PROGBITS
184           || sh_type == elfcpp::SHT_NOBITS
185           || sh_type == elfcpp::SHT_INIT_ARRAY
186           || sh_type == elfcpp::SHT_FINI_ARRAY
187           || sh_type == elfcpp::SHT_PREINIT_ARRAY
188           || sh_type == elfcpp::SHT_NOTE);
189 }
190
191 // Find the .gnu_incremental_inputs section and related sections.
192
193 template<int size, bool big_endian>
194 bool
195 Sized_incremental_binary<size, big_endian>::find_incremental_inputs_sections(
196     unsigned int* p_inputs_shndx,
197     unsigned int* p_symtab_shndx,
198     unsigned int* p_relocs_shndx,
199     unsigned int* p_got_plt_shndx,
200     unsigned int* p_strtab_shndx)
201 {
202   unsigned int inputs_shndx =
203       this->elf_file_.find_section_by_type(elfcpp::SHT_GNU_INCREMENTAL_INPUTS);
204   if (inputs_shndx == elfcpp::SHN_UNDEF)  // Not found.
205     return false;
206
207   unsigned int symtab_shndx =
208       this->elf_file_.find_section_by_type(elfcpp::SHT_GNU_INCREMENTAL_SYMTAB);
209   if (symtab_shndx == elfcpp::SHN_UNDEF)  // Not found.
210     return false;
211   if (this->elf_file_.section_link(symtab_shndx) != inputs_shndx)
212     return false;
213
214   unsigned int relocs_shndx =
215       this->elf_file_.find_section_by_type(elfcpp::SHT_GNU_INCREMENTAL_RELOCS);
216   if (relocs_shndx == elfcpp::SHN_UNDEF)  // Not found.
217     return false;
218   if (this->elf_file_.section_link(relocs_shndx) != inputs_shndx)
219     return false;
220
221   unsigned int got_plt_shndx =
222       this->elf_file_.find_section_by_type(elfcpp::SHT_GNU_INCREMENTAL_GOT_PLT);
223   if (got_plt_shndx == elfcpp::SHN_UNDEF)  // Not found.
224     return false;
225   if (this->elf_file_.section_link(got_plt_shndx) != inputs_shndx)
226     return false;
227
228   unsigned int strtab_shndx = this->elf_file_.section_link(inputs_shndx);
229   if (strtab_shndx == elfcpp::SHN_UNDEF
230       || strtab_shndx > this->elf_file_.shnum()
231       || this->elf_file_.section_type(strtab_shndx) != elfcpp::SHT_STRTAB)
232     return false;
233
234   if (p_inputs_shndx != NULL)
235     *p_inputs_shndx = inputs_shndx;
236   if (p_symtab_shndx != NULL)
237     *p_symtab_shndx = symtab_shndx;
238   if (p_relocs_shndx != NULL)
239     *p_relocs_shndx = relocs_shndx;
240   if (p_got_plt_shndx != NULL)
241     *p_got_plt_shndx = got_plt_shndx;
242   if (p_strtab_shndx != NULL)
243     *p_strtab_shndx = strtab_shndx;
244   return true;
245 }
246
247 // Set up the readers into the incremental info sections.
248
249 template<int size, bool big_endian>
250 void
251 Sized_incremental_binary<size, big_endian>::setup_readers()
252 {
253   unsigned int inputs_shndx;
254   unsigned int symtab_shndx;
255   unsigned int relocs_shndx;
256   unsigned int got_plt_shndx;
257   unsigned int strtab_shndx;
258
259   if (!this->find_incremental_inputs_sections(&inputs_shndx, &symtab_shndx,
260                                               &relocs_shndx, &got_plt_shndx,
261                                               &strtab_shndx))
262     return;
263
264   Location inputs_location(this->elf_file_.section_contents(inputs_shndx));
265   Location symtab_location(this->elf_file_.section_contents(symtab_shndx));
266   Location relocs_location(this->elf_file_.section_contents(relocs_shndx));
267   Location got_plt_location(this->elf_file_.section_contents(got_plt_shndx));
268   Location strtab_location(this->elf_file_.section_contents(strtab_shndx));
269
270   View inputs_view = this->view(inputs_location);
271   View symtab_view = this->view(symtab_location);
272   View relocs_view = this->view(relocs_location);
273   View got_plt_view = this->view(got_plt_location);
274   View strtab_view = this->view(strtab_location);
275
276   elfcpp::Elf_strtab strtab(strtab_view.data(), strtab_location.data_size);
277
278   this->inputs_reader_ =
279       Incremental_inputs_reader<size, big_endian>(inputs_view.data(), strtab);
280   this->symtab_reader_ =
281       Incremental_symtab_reader<big_endian>(symtab_view.data(),
282                                             symtab_location.data_size);
283   this->relocs_reader_ =
284       Incremental_relocs_reader<size, big_endian>(relocs_view.data(),
285                                                   relocs_location.data_size);
286   this->got_plt_reader_ =
287       Incremental_got_plt_reader<big_endian>(got_plt_view.data());
288
289   // Find the main symbol table.
290   unsigned int main_symtab_shndx =
291       this->elf_file_.find_section_by_type(elfcpp::SHT_SYMTAB);
292   gold_assert(main_symtab_shndx != elfcpp::SHN_UNDEF);
293   this->main_symtab_loc_ = this->elf_file_.section_contents(main_symtab_shndx);
294
295   // Find the main symbol string table.
296   unsigned int main_strtab_shndx =
297       this->elf_file_.section_link(main_symtab_shndx);
298   gold_assert(main_strtab_shndx != elfcpp::SHN_UNDEF
299               && main_strtab_shndx < this->elf_file_.shnum());
300   this->main_strtab_loc_ = this->elf_file_.section_contents(main_strtab_shndx);
301
302   // Walk the list of input files (a) to setup an Input_reader for each
303   // input file, and (b) to record maps of files added from archive
304   // libraries and scripts.
305   Incremental_inputs_reader<size, big_endian>& inputs = this->inputs_reader_;
306   unsigned int count = inputs.input_file_count();
307   this->input_objects_.resize(count);
308   this->input_entry_readers_.reserve(count);
309   this->library_map_.resize(count);
310   this->script_map_.resize(count);
311   for (unsigned int i = 0; i < count; i++)
312     {
313       Input_entry_reader input_file = inputs.input_file(i);
314       this->input_entry_readers_.push_back(Sized_input_reader(input_file));
315       switch (input_file.type())
316         {
317         case INCREMENTAL_INPUT_OBJECT:
318         case INCREMENTAL_INPUT_ARCHIVE_MEMBER:
319         case INCREMENTAL_INPUT_SHARED_LIBRARY:
320           // No special treatment necessary.
321           break;
322         case INCREMENTAL_INPUT_ARCHIVE:
323           {
324             Incremental_library* lib =
325                 new Incremental_library(input_file.filename(), i,
326                                         &this->input_entry_readers_[i]);
327             this->library_map_[i] = lib;
328             unsigned int member_count = input_file.get_member_count();
329             for (unsigned int j = 0; j < member_count; j++)
330               {
331                 int member_offset = input_file.get_member_offset(j);
332                 int member_index = inputs.input_file_index(member_offset);
333                 this->library_map_[member_index] = lib;
334               }
335           }
336           break;
337         case INCREMENTAL_INPUT_SCRIPT:
338           {
339             Script_info* script = new Script_info(input_file.filename(), i);
340             this->script_map_[i] = script;
341             unsigned int object_count = input_file.get_object_count();
342             for (unsigned int j = 0; j < object_count; j++)
343               {
344                 int object_offset = input_file.get_object_offset(j);
345                 int object_index = inputs.input_file_index(object_offset);
346                 this->script_map_[object_index] = script;
347               }
348           }
349           break;
350         default:
351           gold_unreachable();
352         }
353     }
354
355   // Initialize the map of global symbols.
356   unsigned int nglobals = this->symtab_reader_.symbol_count();
357   this->symbol_map_.resize(nglobals);
358
359   this->has_incremental_info_ = true;
360 }
361
362 // Walk the list of input files given on the command line, and build
363 // a direct map of file index to the corresponding input argument.
364
365 void
366 check_input_args(std::vector<const Input_argument*>& input_args_map,
367                  Input_arguments::const_iterator begin,
368                  Input_arguments::const_iterator end)
369 {
370   for (Input_arguments::const_iterator p = begin;
371        p != end;
372        ++p)
373     {
374       if (p->is_group())
375         {
376           const Input_file_group* group = p->group();
377           check_input_args(input_args_map, group->begin(), group->end());
378         }
379       else if (p->is_lib())
380         {
381           const Input_file_lib* lib = p->lib();
382           check_input_args(input_args_map, lib->begin(), lib->end());
383         }
384       else
385         {
386           gold_assert(p->is_file());
387           unsigned int arg_serial = p->file().arg_serial();
388           if (arg_serial > 0)
389             {
390               gold_assert(arg_serial <= input_args_map.size());
391               gold_assert(input_args_map[arg_serial - 1] == 0);
392               input_args_map[arg_serial - 1] = &*p;
393             }
394         }
395     }
396 }
397
398 // Determine whether an incremental link based on the existing output file
399 // can be done.
400
401 template<int size, bool big_endian>
402 bool
403 Sized_incremental_binary<size, big_endian>::do_check_inputs(
404     const Command_line& cmdline,
405     Incremental_inputs* incremental_inputs)
406 {
407   Incremental_inputs_reader<size, big_endian>& inputs = this->inputs_reader_;
408
409   if (!this->has_incremental_info_)
410     {
411       explain_no_incremental(_("no incremental data from previous build"));
412       return false;
413     }
414
415   if (inputs.version() != INCREMENTAL_LINK_VERSION)
416     {
417       explain_no_incremental(_("different version of incremental build data"));
418       return false;
419     }
420
421   if (incremental_inputs->command_line() != inputs.command_line())
422     {
423       gold_debug(DEBUG_INCREMENTAL,
424                  "old command line: %s",
425                  inputs.command_line());
426       gold_debug(DEBUG_INCREMENTAL,
427                  "new command line: %s",
428                  incremental_inputs->command_line().c_str());
429       explain_no_incremental(_("command line changed"));
430       return false;
431     }
432
433   // Walk the list of input files given on the command line, and build
434   // a direct map of argument serial numbers to the corresponding input
435   // arguments.
436   this->input_args_map_.resize(cmdline.number_of_input_files());
437   check_input_args(this->input_args_map_, cmdline.begin(), cmdline.end());
438
439   // Walk the list of input files to check for conditions that prevent
440   // an incremental update link.
441   unsigned int count = inputs.input_file_count();
442   for (unsigned int i = 0; i < count; i++)
443     {
444       Input_entry_reader input_file = inputs.input_file(i);
445       switch (input_file.type())
446         {
447         case INCREMENTAL_INPUT_OBJECT:
448         case INCREMENTAL_INPUT_ARCHIVE_MEMBER:
449         case INCREMENTAL_INPUT_SHARED_LIBRARY:
450         case INCREMENTAL_INPUT_ARCHIVE:
451           // No special treatment necessary.
452           break;
453         case INCREMENTAL_INPUT_SCRIPT:
454           if (this->do_file_has_changed(i))
455             {
456               explain_no_incremental(_("%s: script file changed"),
457                                      input_file.filename());
458               return false;
459             }
460           break;
461         default:
462           gold_unreachable();
463         }
464     }
465
466   return true;
467 }
468
469 // Return TRUE if input file N has changed since the last incremental link.
470
471 template<int size, bool big_endian>
472 bool
473 Sized_incremental_binary<size, big_endian>::do_file_has_changed(
474     unsigned int n) const
475 {
476   Input_entry_reader input_file = this->inputs_reader_.input_file(n);
477   Incremental_disposition disp = INCREMENTAL_CHECK;
478
479   // For files named in scripts, find the file that was actually named
480   // on the command line, so that we can get the incremental disposition
481   // flag.
482   Script_info* script = this->get_script_info(n);
483   if (script != NULL)
484     n = script->input_file_index();
485
486   const Input_argument* input_argument = this->get_input_argument(n);
487   if (input_argument != NULL)
488     disp = input_argument->file().options().incremental_disposition();
489
490   // For files at the beginning of the command line (i.e., those added
491   // implicitly by gcc), check whether the --incremental-startup-unchanged
492   // option was used.
493   if (disp == INCREMENTAL_STARTUP)
494     disp = parameters->options().incremental_startup_disposition();
495
496   if (disp != INCREMENTAL_CHECK)
497     return disp == INCREMENTAL_CHANGED;
498
499   const char* filename = input_file.filename();
500   Timespec old_mtime = input_file.get_mtime();
501   Timespec new_mtime;
502   if (!get_mtime(filename, &new_mtime))
503     {
504       // If we can't open get the current modification time, assume it has
505       // changed.  If the file doesn't exist, we'll issue an error when we
506       // try to open it later.
507       return true;
508     }
509
510   if (new_mtime.seconds > old_mtime.seconds)
511     return true;
512   if (new_mtime.seconds == old_mtime.seconds
513       && new_mtime.nanoseconds > old_mtime.nanoseconds)
514     return true;
515   return false;
516 }
517
518 // Initialize the layout of the output file based on the existing
519 // output file.
520
521 template<int size, bool big_endian>
522 void
523 Sized_incremental_binary<size, big_endian>::do_init_layout(Layout* layout)
524 {
525   typedef elfcpp::Shdr<size, big_endian> Shdr;
526   const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
527
528   // Get views of the section headers and the section string table.
529   const off_t shoff = this->elf_file_.shoff();
530   const unsigned int shnum = this->elf_file_.shnum();
531   const unsigned int shstrndx = this->elf_file_.shstrndx();
532   Location shdrs_location(shoff, shnum * shdr_size);
533   Location shstrndx_location(this->elf_file_.section_contents(shstrndx));
534   View shdrs_view = this->view(shdrs_location);
535   View shstrndx_view = this->view(shstrndx_location);
536   elfcpp::Elf_strtab shstrtab(shstrndx_view.data(),
537                               shstrndx_location.data_size);
538
539   layout->set_incremental_base(this);
540
541   // Initialize the layout.
542   this->section_map_.resize(shnum);
543   const unsigned char* pshdr = shdrs_view.data() + shdr_size;
544   for (unsigned int i = 1; i < shnum; i++)
545     {
546       Shdr shdr(pshdr);
547       const char* name;
548       if (!shstrtab.get_c_string(shdr.get_sh_name(), &name))
549         name = NULL;
550       gold_debug(DEBUG_INCREMENTAL,
551                  "Output section: %2d %08lx %08lx %08lx %3d %s",
552                  i,
553                  static_cast<long>(shdr.get_sh_addr()),
554                  static_cast<long>(shdr.get_sh_offset()),
555                  static_cast<long>(shdr.get_sh_size()),
556                  shdr.get_sh_type(), name ? name : "<null>");
557       this->section_map_[i] = layout->init_fixed_output_section(name, shdr);
558       pshdr += shdr_size;
559     }
560 }
561
562 // Mark regions of the input file that must be kept unchanged.
563
564 template<int size, bool big_endian>
565 void
566 Sized_incremental_binary<size, big_endian>::do_reserve_layout(
567     unsigned int input_file_index)
568 {
569   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
570
571   Input_entry_reader input_file =
572       this->inputs_reader_.input_file(input_file_index);
573
574   if (input_file.type() == INCREMENTAL_INPUT_SHARED_LIBRARY)
575     {
576       // Reserve the BSS space used for COPY relocations.
577       unsigned int nsyms = input_file.get_global_symbol_count();
578       Incremental_binary::View symtab_view(NULL);
579       unsigned int symtab_count;
580       elfcpp::Elf_strtab strtab(NULL, 0);
581       this->get_symtab_view(&symtab_view, &symtab_count, &strtab);
582       for (unsigned int i = 0; i < nsyms; ++i)
583         {
584           bool is_def;
585           bool is_copy;
586           unsigned int output_symndx =
587               input_file.get_output_symbol_index(i, &is_def, &is_copy);
588           if (is_copy)
589             {
590               const unsigned char* sym_p = (symtab_view.data()
591                                             + output_symndx * sym_size);
592               elfcpp::Sym<size, big_endian> gsym(sym_p);
593               unsigned int shndx = gsym.get_st_shndx();
594               if (shndx < 1 || shndx >= this->section_map_.size())
595                 continue;
596               Output_section* os = this->section_map_[shndx];
597               off_t offset = gsym.get_st_value() - os->address();
598               os->reserve(offset, gsym.get_st_size());
599               gold_debug(DEBUG_INCREMENTAL,
600                          "Reserve for COPY reloc: %s, off %d, size %d",
601                          os->name(),
602                          static_cast<int>(offset),
603                          static_cast<int>(gsym.get_st_size()));
604             }
605         }
606       return;
607     }
608
609   unsigned int shnum = input_file.get_input_section_count();
610   for (unsigned int i = 0; i < shnum; i++)
611     {
612       typename Input_entry_reader::Input_section_info sect =
613           input_file.get_input_section(i);
614       if (sect.output_shndx == 0 || sect.sh_offset == -1)
615         continue;
616       Output_section* os = this->section_map_[sect.output_shndx];
617       gold_assert(os != NULL);
618       os->reserve(sect.sh_offset, sect.sh_size);
619     }
620 }
621
622 // Process the GOT and PLT entries from the existing output file.
623
624 template<int size, bool big_endian>
625 void
626 Sized_incremental_binary<size, big_endian>::do_process_got_plt(
627     Symbol_table* symtab,
628     Layout* layout)
629 {
630   Incremental_got_plt_reader<big_endian> got_plt_reader(this->got_plt_reader());
631   Sized_target<size, big_endian>* target =
632       parameters->sized_target<size, big_endian>();
633
634   // Get the number of symbols in the main symbol table and in the
635   // incremental symbol table.  The difference between the two counts
636   // is the index of the first forced-local or global symbol in the
637   // main symbol table.
638   unsigned int symtab_count =
639       this->main_symtab_loc_.data_size / elfcpp::Elf_sizes<size>::sym_size;
640   unsigned int isym_count = this->symtab_reader_.symbol_count();
641   unsigned int first_global = symtab_count - isym_count;
642
643   // Tell the target how big the GOT and PLT sections are.
644   unsigned int got_count = got_plt_reader.get_got_entry_count();
645   unsigned int plt_count = got_plt_reader.get_plt_entry_count();
646   Output_data_got_base* got =
647       target->init_got_plt_for_update(symtab, layout, got_count, plt_count);
648
649   // Read the GOT entries from the base file and build the outgoing GOT.
650   for (unsigned int i = 0; i < got_count; ++i)
651     {
652       unsigned int got_type = got_plt_reader.get_got_type(i);
653       if ((got_type & 0x7f) == 0x7f)
654         {
655           // This is the second entry of a pair.
656           got->reserve_slot(i);
657           continue;
658         }
659       unsigned int symndx = got_plt_reader.get_got_symndx(i);
660       if (got_type & 0x80)
661         {
662           // This is an entry for a local symbol.  Ignore this entry if
663           // the object file was replaced.
664           unsigned int input_index = got_plt_reader.get_got_input_index(i);
665           gold_debug(DEBUG_INCREMENTAL,
666                      "GOT entry %d, type %02x: (local symbol)",
667                      i, got_type & 0x7f);
668           Sized_relobj_incr<size, big_endian>* obj =
669               this->input_object(input_index);
670           if (obj != NULL)
671             target->reserve_local_got_entry(i, obj, symndx, got_type & 0x7f);
672         }
673       else
674         {
675           // This is an entry for a global symbol.  GOT_DESC is the symbol
676           // table index.
677           // FIXME: This should really be a fatal error (corrupt input).
678           gold_assert(symndx >= first_global && symndx < symtab_count);
679           Symbol* sym = this->global_symbol(symndx - first_global);
680           // Add the GOT entry only if the symbol is still referenced.
681           if (sym != NULL && sym->in_reg())
682             {
683               gold_debug(DEBUG_INCREMENTAL,
684                          "GOT entry %d, type %02x: %s",
685                          i, got_type, sym->name());
686               target->reserve_global_got_entry(i, sym, got_type);
687             }
688         }
689     }
690
691   // Read the PLT entries from the base file and pass each to the target.
692   for (unsigned int i = 0; i < plt_count; ++i)
693     {
694       unsigned int plt_desc = got_plt_reader.get_plt_desc(i);
695       // FIXME: This should really be a fatal error (corrupt input).
696       gold_assert(plt_desc >= first_global && plt_desc < symtab_count);
697       Symbol* sym = this->global_symbol(plt_desc - first_global);
698       // Add the PLT entry only if the symbol is still referenced.
699       if (sym != NULL && sym->in_reg())
700         {
701           gold_debug(DEBUG_INCREMENTAL,
702                      "PLT entry %d: %s",
703                      i, sym->name());
704           target->register_global_plt_entry(symtab, layout, i, sym);
705         }
706     }
707 }
708
709 // Emit COPY relocations from the existing output file.
710
711 template<int size, bool big_endian>
712 void
713 Sized_incremental_binary<size, big_endian>::do_emit_copy_relocs(
714     Symbol_table* symtab)
715 {
716   Sized_target<size, big_endian>* target =
717       parameters->sized_target<size, big_endian>();
718
719   for (typename Copy_relocs::iterator p = this->copy_relocs_.begin();
720        p != this->copy_relocs_.end();
721        ++p)
722     {
723       if (!(*p).symbol->is_copied_from_dynobj())
724         target->emit_copy_reloc(symtab, (*p).symbol, (*p).output_section,
725                                 (*p).offset);
726     }
727 }
728
729 // Apply incremental relocations for symbols whose values have changed.
730
731 template<int size, bool big_endian>
732 void
733 Sized_incremental_binary<size, big_endian>::do_apply_incremental_relocs(
734     const Symbol_table* symtab,
735     Layout* layout,
736     Output_file* of)
737 {
738   typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
739   typedef typename elfcpp::Elf_types<size>::Elf_Swxword Addend;
740   Incremental_symtab_reader<big_endian> isymtab(this->symtab_reader());
741   Incremental_relocs_reader<size, big_endian> irelocs(this->relocs_reader());
742   unsigned int nglobals = isymtab.symbol_count();
743   const unsigned int incr_reloc_size = irelocs.reloc_size;
744
745   Relocate_info<size, big_endian> relinfo;
746   relinfo.symtab = symtab;
747   relinfo.layout = layout;
748   relinfo.object = NULL;
749   relinfo.reloc_shndx = 0;
750   relinfo.reloc_shdr = NULL;
751   relinfo.data_shndx = 0;
752   relinfo.data_shdr = NULL;
753
754   Sized_target<size, big_endian>* target =
755       parameters->sized_target<size, big_endian>();
756
757   for (unsigned int i = 0; i < nglobals; i++)
758     {
759       const Symbol* gsym = this->global_symbol(i);
760
761       // If the symbol is not referenced from any unchanged input files,
762       // we do not need to reapply any of its relocations.
763       if (gsym == NULL)
764         continue;
765
766       // If the symbol is defined in an unchanged file, we do not need to
767       // reapply any of its relocations.
768       if (gsym->source() == Symbol::FROM_OBJECT
769           && gsym->object()->is_incremental())
770         continue;
771
772       gold_debug(DEBUG_INCREMENTAL,
773                  "Applying incremental relocations for global symbol %s [%d]",
774                  gsym->name(), i);
775
776       // Follow the linked list of input symbol table entries for this symbol.
777       // We don't bother to figure out whether the symbol table entry belongs
778       // to a changed or unchanged file because it's easier just to apply all
779       // the relocations -- although we might scribble over an area that has
780       // been reallocated, we do this before copying any new data into the
781       // output file.
782       unsigned int offset = isymtab.get_list_head(i);
783       while (offset > 0)
784         {
785           Incremental_global_symbol_reader<big_endian> sym_info =
786               this->inputs_reader().global_symbol_reader_at_offset(offset);
787           unsigned int r_base = sym_info.reloc_offset();
788           unsigned int r_count = sym_info.reloc_count();
789
790           // Apply each relocation for this symbol table entry.
791           for (unsigned int j = 0; j < r_count;
792                ++j, r_base += incr_reloc_size)
793             {
794               unsigned int r_type = irelocs.get_r_type(r_base);
795               unsigned int r_shndx = irelocs.get_r_shndx(r_base);
796               Address r_offset = irelocs.get_r_offset(r_base);
797               Addend r_addend = irelocs.get_r_addend(r_base);
798               Output_section* os = this->output_section(r_shndx);
799               Address address = os->address();
800               off_t section_offset = os->offset();
801               size_t view_size = os->data_size();
802               unsigned char* const view = of->get_output_view(section_offset,
803                                                               view_size);
804
805               gold_debug(DEBUG_INCREMENTAL,
806                          "  %08lx: %s + %d: type %d addend %ld",
807                          (long)(section_offset + r_offset),
808                          os->name(),
809                          (int)r_offset,
810                          r_type,
811                          (long)r_addend);
812
813               target->apply_relocation(&relinfo, r_offset, r_type, r_addend,
814                                        gsym, view, address, view_size);
815
816               // FIXME: Do something more efficient if write_output_view
817               // ever becomes more than a no-op.
818               of->write_output_view(section_offset, view_size, view);
819             }
820           offset = sym_info.next_offset();
821         }
822     }
823 }
824
825 // Get a view of the main symbol table and the symbol string table.
826
827 template<int size, bool big_endian>
828 void
829 Sized_incremental_binary<size, big_endian>::get_symtab_view(
830     View* symtab_view,
831     unsigned int* nsyms,
832     elfcpp::Elf_strtab* strtab)
833 {
834   *symtab_view = this->view(this->main_symtab_loc_);
835   *nsyms = this->main_symtab_loc_.data_size / elfcpp::Elf_sizes<size>::sym_size;
836
837   View strtab_view(this->view(this->main_strtab_loc_));
838   *strtab = elfcpp::Elf_strtab(strtab_view.data(),
839                                this->main_strtab_loc_.data_size);
840 }
841
842 namespace
843 {
844
845 // Create a Sized_incremental_binary object of the specified size and
846 // endianness. Fails if the target architecture is not supported.
847
848 template<int size, bool big_endian>
849 Incremental_binary*
850 make_sized_incremental_binary(Output_file* file,
851                               const elfcpp::Ehdr<size, big_endian>& ehdr)
852 {
853   Target* target = select_target(NULL, 0, // XXX
854                                  ehdr.get_e_machine(), size, big_endian,
855                                  ehdr.get_e_ident()[elfcpp::EI_OSABI],
856                                  ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]);
857   if (target == NULL)
858     {
859       explain_no_incremental(_("unsupported ELF machine number %d"),
860                ehdr.get_e_machine());
861       return NULL;
862     }
863
864   if (!parameters->target_valid())
865     set_parameters_target(target);
866   else if (target != &parameters->target())
867     gold_error(_("%s: incompatible target"), file->filename());
868
869   return new Sized_incremental_binary<size, big_endian>(file, ehdr, target);
870 }
871
872 }  // End of anonymous namespace.
873
874 // Create an Incremental_binary object for FILE.  Returns NULL is this is not
875 // possible, e.g. FILE is not an ELF file or has an unsupported target.  FILE
876 // should be opened.
877
878 Incremental_binary*
879 open_incremental_binary(Output_file* file)
880 {
881   off_t filesize = file->filesize();
882   int want = elfcpp::Elf_recognizer::max_header_size;
883   if (filesize < want)
884     want = filesize;
885
886   const unsigned char* p = file->get_input_view(0, want);
887   if (!elfcpp::Elf_recognizer::is_elf_file(p, want))
888     {
889       explain_no_incremental(_("output is not an ELF file."));
890       return NULL;
891     }
892
893   int size = 0;
894   bool big_endian = false;
895   std::string error;
896   if (!elfcpp::Elf_recognizer::is_valid_header(p, want, &size, &big_endian,
897                                                &error))
898     {
899       explain_no_incremental(error.c_str());
900       return NULL;
901     }
902
903   Incremental_binary* result = NULL;
904   if (size == 32)
905     {
906       if (big_endian)
907         {
908 #ifdef HAVE_TARGET_32_BIG
909           result = make_sized_incremental_binary<32, true>(
910               file, elfcpp::Ehdr<32, true>(p));
911 #else
912           explain_no_incremental(_("unsupported file: 32-bit, big-endian"));
913 #endif
914         }
915       else
916         {
917 #ifdef HAVE_TARGET_32_LITTLE
918           result = make_sized_incremental_binary<32, false>(
919               file, elfcpp::Ehdr<32, false>(p));
920 #else
921           explain_no_incremental(_("unsupported file: 32-bit, little-endian"));
922 #endif
923         }
924     }
925   else if (size == 64)
926     {
927       if (big_endian)
928         {
929 #ifdef HAVE_TARGET_64_BIG
930           result = make_sized_incremental_binary<64, true>(
931               file, elfcpp::Ehdr<64, true>(p));
932 #else
933           explain_no_incremental(_("unsupported file: 64-bit, big-endian"));
934 #endif
935         }
936       else
937         {
938 #ifdef HAVE_TARGET_64_LITTLE
939           result = make_sized_incremental_binary<64, false>(
940               file, elfcpp::Ehdr<64, false>(p));
941 #else
942           explain_no_incremental(_("unsupported file: 64-bit, little-endian"));
943 #endif
944         }
945     }
946   else
947     gold_unreachable();
948
949   return result;
950 }
951
952 // Class Incremental_inputs.
953
954 // Add the command line to the string table, setting
955 // command_line_key_.  In incremental builds, the command line is
956 // stored in .gnu_incremental_inputs so that the next linker run can
957 // check if the command line options didn't change.
958
959 void
960 Incremental_inputs::report_command_line(int argc, const char* const* argv)
961 {
962   // Always store 'gold' as argv[0] to avoid a full relink if the user used a
963   // different path to the linker.
964   std::string args("gold");
965   // Copied from collect_argv in main.cc.
966   for (int i = 1; i < argc; ++i)
967     {
968       // Adding/removing these options should not result in a full relink.
969       if (strcmp(argv[i], "--incremental") == 0
970           || strcmp(argv[i], "--incremental-full") == 0
971           || strcmp(argv[i], "--incremental-update") == 0
972           || strcmp(argv[i], "--incremental-changed") == 0
973           || strcmp(argv[i], "--incremental-unchanged") == 0
974           || strcmp(argv[i], "--incremental-unknown") == 0
975           || strcmp(argv[i], "--incremental-startup-unchanged") == 0
976           || is_prefix_of("--incremental-base=", argv[i])
977           || is_prefix_of("--incremental-patch=", argv[i])
978           || is_prefix_of("--debug=", argv[i]))
979         continue;
980       if (strcmp(argv[i], "--incremental-base") == 0
981           || strcmp(argv[i], "--incremental-patch") == 0
982           || strcmp(argv[i], "--debug") == 0)
983         {
984           // When these options are used without the '=', skip the
985           // following parameter as well.
986           ++i;
987           continue;
988         }
989
990       args.append(" '");
991       // Now append argv[i], but with all single-quotes escaped
992       const char* argpos = argv[i];
993       while (1)
994         {
995           const int len = strcspn(argpos, "'");
996           args.append(argpos, len);
997           if (argpos[len] == '\0')
998             break;
999           args.append("'\"'\"'");
1000           argpos += len + 1;
1001         }
1002       args.append("'");
1003     }
1004
1005   this->command_line_ = args;
1006   this->strtab_->add(this->command_line_.c_str(), false,
1007                      &this->command_line_key_);
1008 }
1009
1010 // Record the input archive file ARCHIVE.  This is called by the
1011 // Add_archive_symbols task before determining which archive members
1012 // to include.  We create the Incremental_archive_entry here and
1013 // attach it to the Archive, but we do not add it to the list of
1014 // input objects until report_archive_end is called.
1015
1016 void
1017 Incremental_inputs::report_archive_begin(Library_base* arch,
1018                                          unsigned int arg_serial,
1019                                          Script_info* script_info)
1020 {
1021   Stringpool::Key filename_key;
1022   Timespec mtime = arch->get_mtime();
1023
1024   // For a file loaded from a script, don't record its argument serial number.
1025   if (script_info != NULL)
1026     arg_serial = 0;
1027
1028   this->strtab_->add(arch->filename().c_str(), false, &filename_key);
1029   Incremental_archive_entry* entry =
1030       new Incremental_archive_entry(filename_key, arg_serial, mtime);
1031   arch->set_incremental_info(entry);
1032
1033   if (script_info != NULL)
1034     {
1035       Incremental_script_entry* script_entry = script_info->incremental_info();
1036       gold_assert(script_entry != NULL);
1037       script_entry->add_object(entry);
1038     }
1039 }
1040
1041 // Visitor class for processing the unused global symbols in a library.
1042 // An instance of this class is passed to the library's
1043 // for_all_unused_symbols() iterator, which will call the visit()
1044 // function for each global symbol defined in each unused library
1045 // member.  We add those symbol names to the incremental info for the
1046 // library.
1047
1048 class Unused_symbol_visitor : public Library_base::Symbol_visitor_base
1049 {
1050  public:
1051   Unused_symbol_visitor(Incremental_archive_entry* entry, Stringpool* strtab)
1052     : entry_(entry), strtab_(strtab)
1053   { }
1054
1055   void
1056   visit(const char* sym)
1057   {
1058     Stringpool::Key symbol_key;
1059     this->strtab_->add(sym, true, &symbol_key);
1060     this->entry_->add_unused_global_symbol(symbol_key);
1061   }
1062
1063  private:
1064   Incremental_archive_entry* entry_;
1065   Stringpool* strtab_;
1066 };
1067
1068 // Finish recording the input archive file ARCHIVE.  This is called by the
1069 // Add_archive_symbols task after determining which archive members
1070 // to include.
1071
1072 void
1073 Incremental_inputs::report_archive_end(Library_base* arch)
1074 {
1075   Incremental_archive_entry* entry = arch->incremental_info();
1076
1077   gold_assert(entry != NULL);
1078   this->inputs_.push_back(entry);
1079
1080   // Collect unused global symbols.
1081   Unused_symbol_visitor v(entry, this->strtab_);
1082   arch->for_all_unused_symbols(&v);
1083 }
1084
1085 // Record the input object file OBJ.  If ARCH is not NULL, attach
1086 // the object file to the archive.  This is called by the
1087 // Add_symbols task after finding out the type of the file.
1088
1089 void
1090 Incremental_inputs::report_object(Object* obj, unsigned int arg_serial,
1091                                   Library_base* arch, Script_info* script_info)
1092 {
1093   Stringpool::Key filename_key;
1094   Timespec mtime = obj->get_mtime();
1095
1096   // For a file loaded from a script, don't record its argument serial number.
1097   if (script_info != NULL)
1098     arg_serial = 0;
1099
1100   this->strtab_->add(obj->name().c_str(), false, &filename_key);
1101
1102   Incremental_input_entry* input_entry;
1103
1104   this->current_object_ = obj;
1105
1106   if (!obj->is_dynamic())
1107     {
1108       this->current_object_entry_ =
1109           new Incremental_object_entry(filename_key, obj, arg_serial, mtime);
1110       input_entry = this->current_object_entry_;
1111       if (arch != NULL)
1112         {
1113           Incremental_archive_entry* arch_entry = arch->incremental_info();
1114           gold_assert(arch_entry != NULL);
1115           arch_entry->add_object(this->current_object_entry_);
1116         }
1117     }
1118   else
1119     {
1120       this->current_object_entry_ = NULL;
1121       Stringpool::Key soname_key;
1122       Dynobj* dynobj = obj->dynobj();
1123       gold_assert(dynobj != NULL);
1124       this->strtab_->add(dynobj->soname(), false, &soname_key);
1125       input_entry = new Incremental_dynobj_entry(filename_key, soname_key, obj,
1126                                                  arg_serial, mtime);
1127     }
1128
1129   if (obj->is_in_system_directory())
1130     input_entry->set_is_in_system_directory();
1131
1132   if (obj->as_needed())
1133     input_entry->set_as_needed();
1134
1135   this->inputs_.push_back(input_entry);
1136
1137   if (script_info != NULL)
1138     {
1139       Incremental_script_entry* script_entry = script_info->incremental_info();
1140       gold_assert(script_entry != NULL);
1141       script_entry->add_object(input_entry);
1142     }
1143 }
1144
1145 // Record an input section SHNDX from object file OBJ.
1146
1147 void
1148 Incremental_inputs::report_input_section(Object* obj, unsigned int shndx,
1149                                          const char* name, off_t sh_size)
1150 {
1151   Stringpool::Key key = 0;
1152
1153   if (name != NULL)
1154     this->strtab_->add(name, true, &key);
1155
1156   gold_assert(obj == this->current_object_);
1157   gold_assert(this->current_object_entry_ != NULL);
1158   this->current_object_entry_->add_input_section(shndx, key, sh_size);
1159 }
1160
1161 // Record a kept COMDAT group belonging to object file OBJ.
1162
1163 void
1164 Incremental_inputs::report_comdat_group(Object* obj, const char* name)
1165 {
1166   Stringpool::Key key = 0;
1167
1168   if (name != NULL)
1169     this->strtab_->add(name, true, &key);
1170   gold_assert(obj == this->current_object_);
1171   gold_assert(this->current_object_entry_ != NULL);
1172   this->current_object_entry_->add_comdat_group(key);
1173 }
1174
1175 // Record that the input argument INPUT is a script SCRIPT.  This is
1176 // called by read_script after parsing the script and reading the list
1177 // of inputs added by this script.
1178
1179 void
1180 Incremental_inputs::report_script(Script_info* script,
1181                                   unsigned int arg_serial,
1182                                   Timespec mtime)
1183 {
1184   Stringpool::Key filename_key;
1185
1186   this->strtab_->add(script->filename().c_str(), false, &filename_key);
1187   Incremental_script_entry* entry =
1188       new Incremental_script_entry(filename_key, arg_serial, script, mtime);
1189   this->inputs_.push_back(entry);
1190   script->set_incremental_info(entry);
1191 }
1192
1193 // Finalize the incremental link information.  Called from
1194 // Layout::finalize.
1195
1196 void
1197 Incremental_inputs::finalize()
1198 {
1199   // Finalize the string table.
1200   this->strtab_->set_string_offsets();
1201 }
1202
1203 // Create the .gnu_incremental_inputs, _symtab, and _relocs input sections.
1204
1205 void
1206 Incremental_inputs::create_data_sections(Symbol_table* symtab)
1207 {
1208   int reloc_align = 4;
1209
1210   switch (parameters->size_and_endianness())
1211     {
1212 #ifdef HAVE_TARGET_32_LITTLE
1213     case Parameters::TARGET_32_LITTLE:
1214       this->inputs_section_ =
1215           new Output_section_incremental_inputs<32, false>(this, symtab);
1216       reloc_align = 4;
1217       break;
1218 #endif
1219 #ifdef HAVE_TARGET_32_BIG
1220     case Parameters::TARGET_32_BIG:
1221       this->inputs_section_ =
1222           new Output_section_incremental_inputs<32, true>(this, symtab);
1223       reloc_align = 4;
1224       break;
1225 #endif
1226 #ifdef HAVE_TARGET_64_LITTLE
1227     case Parameters::TARGET_64_LITTLE:
1228       this->inputs_section_ =
1229           new Output_section_incremental_inputs<64, false>(this, symtab);
1230       reloc_align = 8;
1231       break;
1232 #endif
1233 #ifdef HAVE_TARGET_64_BIG
1234     case Parameters::TARGET_64_BIG:
1235       this->inputs_section_ =
1236           new Output_section_incremental_inputs<64, true>(this, symtab);
1237       reloc_align = 8;
1238       break;
1239 #endif
1240     default:
1241       gold_unreachable();
1242     }
1243   this->symtab_section_ = new Output_data_space(4, "** incremental_symtab");
1244   this->relocs_section_ = new Output_data_space(reloc_align,
1245                                                 "** incremental_relocs");
1246   this->got_plt_section_ = new Output_data_space(4, "** incremental_got_plt");
1247 }
1248
1249 // Return the sh_entsize value for the .gnu_incremental_relocs section.
1250 unsigned int
1251 Incremental_inputs::relocs_entsize() const
1252 {
1253   return 8 + 2 * parameters->target().get_size() / 8;
1254 }
1255
1256 // Class Output_section_incremental_inputs.
1257
1258 // Finalize the offsets for each input section and supplemental info block,
1259 // and set the final data size of the incremental output sections.
1260
1261 template<int size, bool big_endian>
1262 void
1263 Output_section_incremental_inputs<size, big_endian>::set_final_data_size()
1264 {
1265   const Incremental_inputs* inputs = this->inputs_;
1266
1267   // Offset of each input entry.
1268   unsigned int input_offset = this->header_size;
1269
1270   // Offset of each supplemental info block.
1271   unsigned int file_index = 0;
1272   unsigned int info_offset = this->header_size;
1273   info_offset += this->input_entry_size * inputs->input_file_count();
1274
1275   // Count each input file and its supplemental information block.
1276   for (Incremental_inputs::Input_list::const_iterator p =
1277            inputs->input_files().begin();
1278        p != inputs->input_files().end();
1279        ++p)
1280     {
1281       // Set the index and offset of the input file entry.
1282       (*p)->set_offset(file_index, input_offset);
1283       ++file_index;
1284       input_offset += this->input_entry_size;
1285
1286       // Set the offset of the supplemental info block.
1287       switch ((*p)->type())
1288         {
1289         case INCREMENTAL_INPUT_SCRIPT:
1290           {
1291             Incremental_script_entry *entry = (*p)->script_entry();
1292             gold_assert(entry != NULL);
1293             (*p)->set_info_offset(info_offset);
1294             // Object count.
1295             info_offset += 4;
1296             // Each member.
1297             info_offset += (entry->get_object_count() * 4);
1298           }
1299           break;
1300         case INCREMENTAL_INPUT_OBJECT:
1301         case INCREMENTAL_INPUT_ARCHIVE_MEMBER:
1302           {
1303             Incremental_object_entry* entry = (*p)->object_entry();
1304             gold_assert(entry != NULL);
1305             (*p)->set_info_offset(info_offset);
1306             // Input section count, global symbol count, local symbol offset,
1307             // local symbol count, first dynamic reloc, dynamic reloc count,
1308             // comdat group count.
1309             info_offset += this->object_info_size;
1310             // Each input section.
1311             info_offset += (entry->get_input_section_count()
1312                             * this->input_section_entry_size);
1313             // Each global symbol.
1314             const Object::Symbols* syms = entry->object()->get_global_symbols();
1315             info_offset += syms->size() * this->global_sym_entry_size;
1316             // Each comdat group.
1317             info_offset += entry->get_comdat_group_count() * 4;
1318           }
1319           break;
1320         case INCREMENTAL_INPUT_SHARED_LIBRARY:
1321           {
1322             Incremental_dynobj_entry* entry = (*p)->dynobj_entry();
1323             gold_assert(entry != NULL);
1324             (*p)->set_info_offset(info_offset);
1325             // Global symbol count, soname index.
1326             info_offset += 8;
1327             // Each global symbol.
1328             const Object::Symbols* syms = entry->object()->get_global_symbols();
1329             gold_assert(syms != NULL);
1330             unsigned int nsyms = syms->size();
1331             unsigned int nsyms_out = 0;
1332             for (unsigned int i = 0; i < nsyms; ++i)
1333               {
1334                 const Symbol* sym = (*syms)[i];
1335                 if (sym == NULL)
1336                   continue;
1337                 if (sym->is_forwarder())
1338                   sym = this->symtab_->resolve_forwards(sym);
1339                 if (sym->symtab_index() != -1U)
1340                   ++nsyms_out;
1341               }
1342             info_offset += nsyms_out * 4;
1343           }
1344           break;
1345         case INCREMENTAL_INPUT_ARCHIVE:
1346           {
1347             Incremental_archive_entry* entry = (*p)->archive_entry();
1348             gold_assert(entry != NULL);
1349             (*p)->set_info_offset(info_offset);
1350             // Member count + unused global symbol count.
1351             info_offset += 8;
1352             // Each member.
1353             info_offset += (entry->get_member_count() * 4);
1354             // Each global symbol.
1355             info_offset += (entry->get_unused_global_symbol_count() * 4);
1356           }
1357           break;
1358         default:
1359           gold_unreachable();
1360         }
1361
1362      // Pad so each supplemental info block begins at an 8-byte boundary.
1363      if (info_offset & 4)
1364        info_offset += 4;
1365    }
1366
1367   this->set_data_size(info_offset);
1368
1369   // Set the size of the .gnu_incremental_symtab section.
1370   inputs->symtab_section()->set_current_data_size(this->symtab_->output_count()
1371                                                   * sizeof(unsigned int));
1372
1373   // Set the size of the .gnu_incremental_relocs section.
1374   inputs->relocs_section()->set_current_data_size(inputs->get_reloc_count()
1375                                                   * this->incr_reloc_size);
1376
1377   // Set the size of the .gnu_incremental_got_plt section.
1378   Sized_target<size, big_endian>* target =
1379     parameters->sized_target<size, big_endian>();
1380   unsigned int got_count = target->got_entry_count();
1381   unsigned int plt_count = target->plt_entry_count();
1382   unsigned int got_plt_size = 8;  // GOT entry count, PLT entry count.
1383   got_plt_size = (got_plt_size + got_count + 3) & ~3;  // GOT type array.
1384   got_plt_size += got_count * 8 + plt_count * 4;  // GOT array, PLT array.
1385   inputs->got_plt_section()->set_current_data_size(got_plt_size);
1386 }
1387
1388 // Write the contents of the .gnu_incremental_inputs and
1389 // .gnu_incremental_symtab sections.
1390
1391 template<int size, bool big_endian>
1392 void
1393 Output_section_incremental_inputs<size, big_endian>::do_write(Output_file* of)
1394 {
1395   const Incremental_inputs* inputs = this->inputs_;
1396   Stringpool* strtab = inputs->get_stringpool();
1397
1398   // Get a view into the .gnu_incremental_inputs section.
1399   const off_t off = this->offset();
1400   const off_t oview_size = this->data_size();
1401   unsigned char* const oview = of->get_output_view(off, oview_size);
1402   unsigned char* pov = oview;
1403
1404   // Get a view into the .gnu_incremental_symtab section.
1405   const off_t symtab_off = inputs->symtab_section()->offset();
1406   const off_t symtab_size = inputs->symtab_section()->data_size();
1407   unsigned char* const symtab_view = of->get_output_view(symtab_off,
1408                                                          symtab_size);
1409
1410   // Allocate an array of linked list heads for the .gnu_incremental_symtab
1411   // section.  Each element corresponds to a global symbol in the output
1412   // symbol table, and points to the head of the linked list that threads
1413   // through the object file input entries.  The value of each element
1414   // is the section-relative offset to a global symbol entry in a
1415   // supplemental information block.
1416   unsigned int global_sym_count = this->symtab_->output_count();
1417   unsigned int* global_syms = new unsigned int[global_sym_count];
1418   memset(global_syms, 0, global_sym_count * sizeof(unsigned int));
1419
1420   // Write the section header.
1421   Stringpool::Key command_line_key = inputs->command_line_key();
1422   pov = this->write_header(pov, inputs->input_file_count(),
1423                            strtab->get_offset_from_key(command_line_key));
1424
1425   // Write the list of input files.
1426   pov = this->write_input_files(oview, pov, strtab);
1427
1428   // Write the supplemental information blocks for each input file.
1429   pov = this->write_info_blocks(oview, pov, strtab, global_syms,
1430                                 global_sym_count);
1431
1432   gold_assert(pov - oview == oview_size);
1433
1434   // Write the .gnu_incremental_symtab section.
1435   gold_assert(static_cast<off_t>(global_sym_count) * 4 == symtab_size);
1436   this->write_symtab(symtab_view, global_syms, global_sym_count);
1437
1438   delete[] global_syms;
1439
1440   // Write the .gnu_incremental_got_plt section.
1441   const off_t got_plt_off = inputs->got_plt_section()->offset();
1442   const off_t got_plt_size = inputs->got_plt_section()->data_size();
1443   unsigned char* const got_plt_view = of->get_output_view(got_plt_off,
1444                                                           got_plt_size);
1445   this->write_got_plt(got_plt_view, got_plt_size);
1446
1447   of->write_output_view(off, oview_size, oview);
1448   of->write_output_view(symtab_off, symtab_size, symtab_view);
1449   of->write_output_view(got_plt_off, got_plt_size, got_plt_view);
1450 }
1451
1452 // Write the section header: version, input file count, offset of command line
1453 // in the string table, and 4 bytes of padding.
1454
1455 template<int size, bool big_endian>
1456 unsigned char*
1457 Output_section_incremental_inputs<size, big_endian>::write_header(
1458     unsigned char* pov,
1459     unsigned int input_file_count,
1460     section_offset_type command_line_offset)
1461 {
1462   Swap32::writeval(pov, INCREMENTAL_LINK_VERSION);
1463   Swap32::writeval(pov + 4, input_file_count);
1464   Swap32::writeval(pov + 8, command_line_offset);
1465   Swap32::writeval(pov + 12, 0);
1466   gold_assert(this->header_size == 16);
1467   return pov + this->header_size;
1468 }
1469
1470 // Write the input file entries.
1471
1472 template<int size, bool big_endian>
1473 unsigned char*
1474 Output_section_incremental_inputs<size, big_endian>::write_input_files(
1475     unsigned char* oview,
1476     unsigned char* pov,
1477     Stringpool* strtab)
1478 {
1479   const Incremental_inputs* inputs = this->inputs_;
1480
1481   for (Incremental_inputs::Input_list::const_iterator p =
1482            inputs->input_files().begin();
1483        p != inputs->input_files().end();
1484        ++p)
1485     {
1486       gold_assert(static_cast<unsigned int>(pov - oview) == (*p)->get_offset());
1487       section_offset_type filename_offset =
1488           strtab->get_offset_from_key((*p)->get_filename_key());
1489       const Timespec& mtime = (*p)->get_mtime();
1490       unsigned int flags = (*p)->type();
1491       if ((*p)->is_in_system_directory())
1492         flags |= INCREMENTAL_INPUT_IN_SYSTEM_DIR;
1493       if ((*p)->as_needed())
1494         flags |= INCREMENTAL_INPUT_AS_NEEDED;
1495       Swap32::writeval(pov, filename_offset);
1496       Swap32::writeval(pov + 4, (*p)->get_info_offset());
1497       Swap64::writeval(pov + 8, mtime.seconds);
1498       Swap32::writeval(pov + 16, mtime.nanoseconds);
1499       Swap16::writeval(pov + 20, flags);
1500       Swap16::writeval(pov + 22, (*p)->arg_serial());
1501       gold_assert(this->input_entry_size == 24);
1502       pov += this->input_entry_size;
1503     }
1504   return pov;
1505 }
1506
1507 // Write the supplemental information blocks.
1508
1509 template<int size, bool big_endian>
1510 unsigned char*
1511 Output_section_incremental_inputs<size, big_endian>::write_info_blocks(
1512     unsigned char* oview,
1513     unsigned char* pov,
1514     Stringpool* strtab,
1515     unsigned int* global_syms,
1516     unsigned int global_sym_count)
1517 {
1518   const Incremental_inputs* inputs = this->inputs_;
1519   unsigned int first_global_index = this->symtab_->first_global_index();
1520
1521   for (Incremental_inputs::Input_list::const_iterator p =
1522            inputs->input_files().begin();
1523        p != inputs->input_files().end();
1524        ++p)
1525     {
1526       switch ((*p)->type())
1527         {
1528         case INCREMENTAL_INPUT_SCRIPT:
1529           {
1530             gold_assert(static_cast<unsigned int>(pov - oview)
1531                         == (*p)->get_info_offset());
1532             Incremental_script_entry* entry = (*p)->script_entry();
1533             gold_assert(entry != NULL);
1534
1535             // Write the object count.
1536             unsigned int nobjects = entry->get_object_count();
1537             Swap32::writeval(pov, nobjects);
1538             pov += 4;
1539
1540             // For each object, write the offset to its input file entry.
1541             for (unsigned int i = 0; i < nobjects; ++i)
1542               {
1543                 Incremental_input_entry* obj = entry->get_object(i);
1544                 Swap32::writeval(pov, obj->get_offset());
1545                 pov += 4;
1546               }
1547           }
1548           break;
1549
1550         case INCREMENTAL_INPUT_OBJECT:
1551         case INCREMENTAL_INPUT_ARCHIVE_MEMBER:
1552           {
1553             gold_assert(static_cast<unsigned int>(pov - oview)
1554                         == (*p)->get_info_offset());
1555             Incremental_object_entry* entry = (*p)->object_entry();
1556             gold_assert(entry != NULL);
1557             const Object* obj = entry->object();
1558             const Relobj* relobj = static_cast<const Relobj*>(obj);
1559             const Object::Symbols* syms = obj->get_global_symbols();
1560             // Write the input section count and global symbol count.
1561             unsigned int nsections = entry->get_input_section_count();
1562             unsigned int nsyms = syms->size();
1563             off_t locals_offset = relobj->local_symbol_offset();
1564             unsigned int nlocals = relobj->output_local_symbol_count();
1565             unsigned int first_dynrel = relobj->first_dyn_reloc();
1566             unsigned int ndynrel = relobj->dyn_reloc_count();
1567             unsigned int ncomdat = entry->get_comdat_group_count();
1568             Swap32::writeval(pov, nsections);
1569             Swap32::writeval(pov + 4, nsyms);
1570             Swap32::writeval(pov + 8, static_cast<unsigned int>(locals_offset));
1571             Swap32::writeval(pov + 12, nlocals);
1572             Swap32::writeval(pov + 16, first_dynrel);
1573             Swap32::writeval(pov + 20, ndynrel);
1574             Swap32::writeval(pov + 24, ncomdat);
1575             Swap32::writeval(pov + 28, 0);
1576             gold_assert(this->object_info_size == 32);
1577             pov += this->object_info_size;
1578
1579             // Build a temporary array to map input section indexes
1580             // from the original object file index to the index in the
1581             // incremental info table.
1582             unsigned int* index_map = new unsigned int[obj->shnum()];
1583             memset(index_map, 0, obj->shnum() * sizeof(unsigned int));
1584
1585             // For each input section, write the name, output section index,
1586             // offset within output section, and input section size.
1587             for (unsigned int i = 0; i < nsections; i++)
1588               {
1589                 unsigned int shndx = entry->get_input_section_index(i);
1590                 index_map[shndx] = i + 1;
1591                 Stringpool::Key key = entry->get_input_section_name_key(i);
1592                 off_t name_offset = 0;
1593                 if (key != 0)
1594                   name_offset = strtab->get_offset_from_key(key);
1595                 int out_shndx = 0;
1596                 off_t out_offset = 0;
1597                 off_t sh_size = 0;
1598                 Output_section* os = obj->output_section(shndx);
1599                 if (os != NULL)
1600                   {
1601                     out_shndx = os->out_shndx();
1602                     out_offset = obj->output_section_offset(shndx);
1603                     sh_size = entry->get_input_section_size(i);
1604                   }
1605                 Swap32::writeval(pov, name_offset);
1606                 Swap32::writeval(pov + 4, out_shndx);
1607                 Swap::writeval(pov + 8, out_offset);
1608                 Swap::writeval(pov + 8 + sizeof_addr, sh_size);
1609                 gold_assert(this->input_section_entry_size
1610                             == 8 + 2 * sizeof_addr);
1611                 pov += this->input_section_entry_size;
1612               }
1613
1614             // For each global symbol, write its associated relocations,
1615             // add it to the linked list of globals, then write the
1616             // supplemental information:  global symbol table index,
1617             // input section index, linked list chain pointer, relocation
1618             // count, and offset to the relocations.
1619             for (unsigned int i = 0; i < nsyms; i++)
1620               {
1621                 const Symbol* sym = (*syms)[i];
1622                 if (sym->is_forwarder())
1623                   sym = this->symtab_->resolve_forwards(sym);
1624                 unsigned int shndx = 0;
1625                 if (sym->source() != Symbol::FROM_OBJECT)
1626                   {
1627                     // The symbol was defined by the linker (e.g., common).
1628                     // We mark these symbols with a special SHNDX of -1,
1629                     // but exclude linker-predefined symbols and symbols
1630                     // copied from shared objects.
1631                     if (!sym->is_predefined()
1632                         && !sym->is_copied_from_dynobj())
1633                       shndx = -1U;
1634                   }
1635                 else if (sym->object() == obj && sym->is_defined())
1636                   {
1637                     bool is_ordinary;
1638                     unsigned int orig_shndx = sym->shndx(&is_ordinary);
1639                     if (is_ordinary)
1640                       shndx = index_map[orig_shndx];
1641                     else
1642                       shndx = 1;
1643                   }
1644                 unsigned int symtab_index = sym->symtab_index();
1645                 unsigned int chain = 0;
1646                 unsigned int first_reloc = 0;
1647                 unsigned int nrelocs = obj->get_incremental_reloc_count(i);
1648                 if (nrelocs > 0)
1649                   {
1650                     gold_assert(symtab_index != -1U
1651                                 && (symtab_index - first_global_index
1652                                     < global_sym_count));
1653                     first_reloc = obj->get_incremental_reloc_base(i);
1654                     chain = global_syms[symtab_index - first_global_index];
1655                     global_syms[symtab_index - first_global_index] =
1656                         pov - oview;
1657                   }
1658                 Swap32::writeval(pov, symtab_index);
1659                 Swap32::writeval(pov + 4, shndx);
1660                 Swap32::writeval(pov + 8, chain);
1661                 Swap32::writeval(pov + 12, nrelocs);
1662                 Swap32::writeval(pov + 16,
1663                                  first_reloc * (8 + 2 * sizeof_addr));
1664                 gold_assert(this->global_sym_entry_size == 20);
1665                 pov += this->global_sym_entry_size;
1666               }
1667
1668             // For each kept COMDAT group, write the group signature.
1669             for (unsigned int i = 0; i < ncomdat; i++)
1670               {
1671                 Stringpool::Key key = entry->get_comdat_signature_key(i);
1672                 off_t name_offset = 0;
1673                 if (key != 0)
1674                   name_offset = strtab->get_offset_from_key(key);
1675                 Swap32::writeval(pov, name_offset);
1676                 pov += 4;
1677               }
1678
1679             delete[] index_map;
1680           }
1681           break;
1682
1683         case INCREMENTAL_INPUT_SHARED_LIBRARY:
1684           {
1685             gold_assert(static_cast<unsigned int>(pov - oview)
1686                         == (*p)->get_info_offset());
1687             Incremental_dynobj_entry* entry = (*p)->dynobj_entry();
1688             gold_assert(entry != NULL);
1689             Object* obj = entry->object();
1690             Dynobj* dynobj = obj->dynobj();
1691             gold_assert(dynobj != NULL);
1692             const Object::Symbols* syms = obj->get_global_symbols();
1693
1694             // Write the soname string table index.
1695             section_offset_type soname_offset =
1696                 strtab->get_offset_from_key(entry->get_soname_key());
1697             Swap32::writeval(pov, soname_offset);
1698             pov += 4;
1699
1700             // Skip the global symbol count for now.
1701             unsigned char* orig_pov = pov;
1702             pov += 4;
1703
1704             // For each global symbol, write the global symbol table index.
1705             unsigned int nsyms = syms->size();
1706             unsigned int nsyms_out = 0;
1707             for (unsigned int i = 0; i < nsyms; i++)
1708               {
1709                 const Symbol* sym = (*syms)[i];
1710                 if (sym == NULL)
1711                   continue;
1712                 if (sym->is_forwarder())
1713                   sym = this->symtab_->resolve_forwards(sym);
1714                 if (sym->symtab_index() == -1U)
1715                   continue;
1716                 unsigned int flags = 0;
1717                 // If the symbol has hidden or internal visibility, we
1718                 // mark it as defined in the shared object so we don't
1719                 // try to resolve it during an incremental update.
1720                 if (sym->visibility() == elfcpp::STV_HIDDEN
1721                     || sym->visibility() == elfcpp::STV_INTERNAL)
1722                   flags = INCREMENTAL_SHLIB_SYM_DEF;
1723                 else if (sym->source() == Symbol::FROM_OBJECT
1724                          && sym->object() == obj
1725                          && sym->is_defined())
1726                   flags = INCREMENTAL_SHLIB_SYM_DEF;
1727                 else if (sym->is_copied_from_dynobj()
1728                          && this->symtab_->get_copy_source(sym) == dynobj)
1729                   flags = INCREMENTAL_SHLIB_SYM_COPY;
1730                 flags <<= INCREMENTAL_SHLIB_SYM_FLAGS_SHIFT;
1731                 Swap32::writeval(pov, sym->symtab_index() | flags);
1732                 pov += 4;
1733                 ++nsyms_out;
1734               }
1735
1736             // Now write the global symbol count.
1737             Swap32::writeval(orig_pov, nsyms_out);
1738           }
1739           break;
1740
1741         case INCREMENTAL_INPUT_ARCHIVE:
1742           {
1743             gold_assert(static_cast<unsigned int>(pov - oview)
1744                         == (*p)->get_info_offset());
1745             Incremental_archive_entry* entry = (*p)->archive_entry();
1746             gold_assert(entry != NULL);
1747
1748             // Write the member count and unused global symbol count.
1749             unsigned int nmembers = entry->get_member_count();
1750             unsigned int nsyms = entry->get_unused_global_symbol_count();
1751             Swap32::writeval(pov, nmembers);
1752             Swap32::writeval(pov + 4, nsyms);
1753             pov += 8;
1754
1755             // For each member, write the offset to its input file entry.
1756             for (unsigned int i = 0; i < nmembers; ++i)
1757               {
1758                 Incremental_object_entry* member = entry->get_member(i);
1759                 Swap32::writeval(pov, member->get_offset());
1760                 pov += 4;
1761               }
1762
1763             // For each global symbol, write the name offset.
1764             for (unsigned int i = 0; i < nsyms; ++i)
1765               {
1766                 Stringpool::Key key = entry->get_unused_global_symbol(i);
1767                 Swap32::writeval(pov, strtab->get_offset_from_key(key));
1768                 pov += 4;
1769               }
1770           }
1771           break;
1772
1773         default:
1774           gold_unreachable();
1775         }
1776
1777      // Pad the info block to a multiple of 8 bytes.
1778      if (static_cast<unsigned int>(pov - oview) & 4)
1779       {
1780         Swap32::writeval(pov, 0);
1781         pov += 4;
1782       }
1783     }
1784   return pov;
1785 }
1786
1787 // Write the contents of the .gnu_incremental_symtab section.
1788
1789 template<int size, bool big_endian>
1790 void
1791 Output_section_incremental_inputs<size, big_endian>::write_symtab(
1792     unsigned char* pov,
1793     unsigned int* global_syms,
1794     unsigned int global_sym_count)
1795 {
1796   for (unsigned int i = 0; i < global_sym_count; ++i)
1797     {
1798       Swap32::writeval(pov, global_syms[i]);
1799       pov += 4;
1800     }
1801 }
1802
1803 // This struct holds the view information needed to write the
1804 // .gnu_incremental_got_plt section.
1805
1806 struct Got_plt_view_info
1807 {
1808   // Start of the GOT type array in the output view.
1809   unsigned char* got_type_p;
1810   // Start of the GOT descriptor array in the output view.
1811   unsigned char* got_desc_p;
1812   // Start of the PLT descriptor array in the output view.
1813   unsigned char* plt_desc_p;
1814   // Number of GOT entries.
1815   unsigned int got_count;
1816   // Number of PLT entries.
1817   unsigned int plt_count;
1818   // Offset of the first non-reserved PLT entry (this is a target-dependent value).
1819   unsigned int first_plt_entry_offset;
1820   // Size of a PLT entry (this is a target-dependent value).
1821   unsigned int plt_entry_size;
1822   // Symbol index to write in the GOT descriptor array.  For global symbols,
1823   // this is the global symbol table index; for local symbols, it is the
1824   // local symbol table index.
1825   unsigned int sym_index;
1826   // Input file index to write in the GOT descriptor array.  For global
1827   // symbols, this is 0; for local symbols, it is the index of the input
1828   // file entry in the .gnu_incremental_inputs section.
1829   unsigned int input_index;
1830 };
1831
1832 // Functor class for processing a GOT offset list for local symbols.
1833 // Writes the GOT type and symbol index into the GOT type and descriptor
1834 // arrays in the output section.
1835
1836 template<int size, bool big_endian>
1837 class Local_got_offset_visitor : public Got_offset_list::Visitor
1838 {
1839  public:
1840   Local_got_offset_visitor(struct Got_plt_view_info& info)
1841     : info_(info)
1842   { }
1843
1844   void
1845   visit(unsigned int got_type, unsigned int got_offset)
1846   {
1847     unsigned int got_index = got_offset / this->got_entry_size_;
1848     gold_assert(got_index < this->info_.got_count);
1849     // We can only handle GOT entry types in the range 0..0x7e
1850     // because we use a byte array to store them, and we use the
1851     // high bit to flag a local symbol.
1852     gold_assert(got_type < 0x7f);
1853     this->info_.got_type_p[got_index] = got_type | 0x80;
1854     unsigned char* pov = this->info_.got_desc_p + got_index * 8;
1855     elfcpp::Swap<32, big_endian>::writeval(pov, this->info_.sym_index);
1856     elfcpp::Swap<32, big_endian>::writeval(pov + 4, this->info_.input_index);
1857   }
1858
1859  private:
1860   static const unsigned int got_entry_size_ = size / 8;
1861   struct Got_plt_view_info& info_;
1862 };
1863
1864 // Functor class for processing a GOT offset list.  Writes the GOT type
1865 // and symbol index into the GOT type and descriptor arrays in the output
1866 // section.
1867
1868 template<int size, bool big_endian>
1869 class Global_got_offset_visitor : public Got_offset_list::Visitor
1870 {
1871  public:
1872   Global_got_offset_visitor(struct Got_plt_view_info& info)
1873     : info_(info)
1874   { }
1875
1876   void
1877   visit(unsigned int got_type, unsigned int got_offset)
1878   {
1879     unsigned int got_index = got_offset / this->got_entry_size_;
1880     gold_assert(got_index < this->info_.got_count);
1881     // We can only handle GOT entry types in the range 0..0x7e
1882     // because we use a byte array to store them, and we use the
1883     // high bit to flag a local symbol.
1884     gold_assert(got_type < 0x7f);
1885     this->info_.got_type_p[got_index] = got_type;
1886     unsigned char* pov = this->info_.got_desc_p + got_index * 8;
1887     elfcpp::Swap<32, big_endian>::writeval(pov, this->info_.sym_index);
1888     elfcpp::Swap<32, big_endian>::writeval(pov + 4, 0);
1889   }
1890
1891  private:
1892   static const unsigned int got_entry_size_ = size / 8;
1893   struct Got_plt_view_info& info_;
1894 };
1895
1896 // Functor class for processing the global symbol table.  Processes the
1897 // GOT offset list for the symbol, and writes the symbol table index
1898 // into the PLT descriptor array in the output section.
1899
1900 template<int size, bool big_endian>
1901 class Global_symbol_visitor_got_plt
1902 {
1903  public:
1904   Global_symbol_visitor_got_plt(struct Got_plt_view_info& info)
1905     : info_(info)
1906   { }
1907
1908   void
1909   operator()(const Sized_symbol<size>* sym)
1910   {
1911     typedef Global_got_offset_visitor<size, big_endian> Got_visitor;
1912     const Got_offset_list* got_offsets = sym->got_offset_list();
1913     if (got_offsets != NULL)
1914       {
1915         this->info_.sym_index = sym->symtab_index();
1916         this->info_.input_index = 0;
1917         Got_visitor v(this->info_);
1918         got_offsets->for_all_got_offsets(&v);
1919       }
1920     if (sym->has_plt_offset())
1921       {
1922         unsigned int plt_index =
1923             ((sym->plt_offset() - this->info_.first_plt_entry_offset)
1924              / this->info_.plt_entry_size);
1925         gold_assert(plt_index < this->info_.plt_count);
1926         unsigned char* pov = this->info_.plt_desc_p + plt_index * 4;
1927         elfcpp::Swap<32, big_endian>::writeval(pov, sym->symtab_index());
1928       }
1929   }
1930
1931  private:
1932   struct Got_plt_view_info& info_;
1933 };
1934
1935 // Write the contents of the .gnu_incremental_got_plt section.
1936
1937 template<int size, bool big_endian>
1938 void
1939 Output_section_incremental_inputs<size, big_endian>::write_got_plt(
1940     unsigned char* pov,
1941     off_t view_size)
1942 {
1943   Sized_target<size, big_endian>* target =
1944     parameters->sized_target<size, big_endian>();
1945
1946   // Set up the view information for the functors.
1947   struct Got_plt_view_info view_info;
1948   view_info.got_count = target->got_entry_count();
1949   view_info.plt_count = target->plt_entry_count();
1950   view_info.first_plt_entry_offset = target->first_plt_entry_offset();
1951   view_info.plt_entry_size = target->plt_entry_size();
1952   view_info.got_type_p = pov + 8;
1953   view_info.got_desc_p = (view_info.got_type_p
1954                           + ((view_info.got_count + 3) & ~3));
1955   view_info.plt_desc_p = view_info.got_desc_p + view_info.got_count * 8;
1956
1957   gold_assert(pov + view_size ==
1958               view_info.plt_desc_p + view_info.plt_count * 4);
1959
1960   // Write the section header.
1961   Swap32::writeval(pov, view_info.got_count);
1962   Swap32::writeval(pov + 4, view_info.plt_count);
1963
1964   // Initialize the GOT type array to 0xff (reserved).
1965   memset(view_info.got_type_p, 0xff, view_info.got_count);
1966
1967   // Write the incremental GOT descriptors for local symbols.
1968   typedef Local_got_offset_visitor<size, big_endian> Got_visitor;
1969   for (Incremental_inputs::Input_list::const_iterator p =
1970            this->inputs_->input_files().begin();
1971        p != this->inputs_->input_files().end();
1972        ++p)
1973     {
1974       if ((*p)->type() != INCREMENTAL_INPUT_OBJECT
1975           && (*p)->type() != INCREMENTAL_INPUT_ARCHIVE_MEMBER)
1976         continue;
1977       Incremental_object_entry* entry = (*p)->object_entry();
1978       gold_assert(entry != NULL);
1979       const Object* obj = entry->object();
1980       gold_assert(obj != NULL);
1981       view_info.input_index = (*p)->get_file_index();
1982       Got_visitor v(view_info);
1983       obj->for_all_local_got_entries(&v);
1984     }
1985
1986   // Write the incremental GOT and PLT descriptors for global symbols.
1987   typedef Global_symbol_visitor_got_plt<size, big_endian> Symbol_visitor;
1988   symtab_->for_all_symbols<size, Symbol_visitor>(Symbol_visitor(view_info));
1989 }
1990
1991 // Class Sized_relobj_incr.  Most of these methods are not used for
1992 // Incremental objects, but are required to be implemented by the
1993 // base class Object.
1994
1995 template<int size, bool big_endian>
1996 Sized_relobj_incr<size, big_endian>::Sized_relobj_incr(
1997     const std::string& name,
1998     Sized_incremental_binary<size, big_endian>* ibase,
1999     unsigned int input_file_index)
2000   : Sized_relobj<size, big_endian>(name, NULL), ibase_(ibase),
2001     input_file_index_(input_file_index),
2002     input_reader_(ibase->inputs_reader().input_file(input_file_index)),
2003     local_symbol_count_(0), output_local_dynsym_count_(0),
2004     local_symbol_index_(0), local_symbol_offset_(0), local_dynsym_offset_(0),
2005     symbols_(), defined_count_(0), incr_reloc_offset_(-1U),
2006     incr_reloc_count_(0), incr_reloc_output_index_(0), incr_relocs_(NULL),
2007     local_symbols_()
2008 {
2009   if (this->input_reader_.is_in_system_directory())
2010     this->set_is_in_system_directory();
2011   const unsigned int shnum = this->input_reader_.get_input_section_count() + 1;
2012   this->set_shnum(shnum);
2013   ibase->set_input_object(input_file_index, this);
2014 }
2015
2016 // Read the symbols.
2017
2018 template<int size, bool big_endian>
2019 void
2020 Sized_relobj_incr<size, big_endian>::do_read_symbols(Read_symbols_data*)
2021 {
2022   gold_unreachable();
2023 }
2024
2025 // Lay out the input sections.
2026
2027 template<int size, bool big_endian>
2028 void
2029 Sized_relobj_incr<size, big_endian>::do_layout(
2030     Symbol_table*,
2031     Layout* layout,
2032     Read_symbols_data*)
2033 {
2034   const unsigned int shnum = this->shnum();
2035   Incremental_inputs* incremental_inputs = layout->incremental_inputs();
2036   gold_assert(incremental_inputs != NULL);
2037   Output_sections& out_sections(this->output_sections());
2038   out_sections.resize(shnum);
2039   this->section_offsets().resize(shnum);
2040
2041   // Keep track of .debug_info and .debug_types sections.
2042   std::vector<unsigned int> debug_info_sections;
2043   std::vector<unsigned int> debug_types_sections;
2044
2045   for (unsigned int i = 1; i < shnum; i++)
2046     {
2047       typename Input_entry_reader::Input_section_info sect =
2048           this->input_reader_.get_input_section(i - 1);
2049       // Add the section to the incremental inputs layout.
2050       incremental_inputs->report_input_section(this, i, sect.name,
2051                                                sect.sh_size);
2052       if (sect.output_shndx == 0 || sect.sh_offset == -1)
2053         continue;
2054       Output_section* os = this->ibase_->output_section(sect.output_shndx);
2055       gold_assert(os != NULL);
2056       out_sections[i] = os;
2057       this->section_offsets()[i] = static_cast<Address>(sect.sh_offset);
2058
2059       // When generating a .gdb_index section, we do additional
2060       // processing of .debug_info and .debug_types sections after all
2061       // the other sections.
2062       if (parameters->options().gdb_index())
2063         {
2064           const char* name = os->name();
2065           if (strcmp(name, ".debug_info") == 0)
2066             debug_info_sections.push_back(i);
2067           else if (strcmp(name, ".debug_types") == 0)
2068             debug_types_sections.push_back(i);
2069         }
2070     }
2071
2072   // Process the COMDAT groups.
2073   unsigned int ncomdat = this->input_reader_.get_comdat_group_count();
2074   for (unsigned int i = 0; i < ncomdat; i++)
2075     {
2076       const char* signature = this->input_reader_.get_comdat_group_signature(i);
2077       if (signature == NULL || signature[0] == '\0')
2078         this->error(_("COMDAT group has no signature"));
2079       bool keep = layout->find_or_add_kept_section(signature, this, i, true,
2080                                                    true, NULL);
2081       if (keep)
2082         incremental_inputs->report_comdat_group(this, signature);
2083       else
2084         this->error(_("COMDAT group %s included twice in incremental link"),
2085                     signature);
2086     }
2087
2088   // When building a .gdb_index section, scan the .debug_info and
2089   // .debug_types sections.
2090   for (std::vector<unsigned int>::const_iterator p
2091            = debug_info_sections.begin();
2092        p != debug_info_sections.end();
2093        ++p)
2094     {
2095       unsigned int i = *p;
2096       layout->add_to_gdb_index(false, this, NULL, 0, i, 0, 0);
2097     }
2098   for (std::vector<unsigned int>::const_iterator p
2099            = debug_types_sections.begin();
2100        p != debug_types_sections.end();
2101        ++p)
2102     {
2103       unsigned int i = *p;
2104       layout->add_to_gdb_index(true, this, 0, 0, i, 0, 0);
2105     }
2106 }
2107
2108 // Layout sections whose layout was deferred while waiting for
2109 // input files from a plugin.
2110 template<int size, bool big_endian>
2111 void
2112 Sized_relobj_incr<size, big_endian>::do_layout_deferred_sections(Layout*)
2113 {
2114 }
2115
2116 // Add the symbols to the symbol table.
2117
2118 template<int size, bool big_endian>
2119 void
2120 Sized_relobj_incr<size, big_endian>::do_add_symbols(
2121     Symbol_table* symtab,
2122     Read_symbols_data*,
2123     Layout*)
2124 {
2125   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
2126   unsigned char symbuf[sym_size];
2127   elfcpp::Sym<size, big_endian> sym(symbuf);
2128   elfcpp::Sym_write<size, big_endian> osym(symbuf);
2129
2130   typedef typename elfcpp::Elf_types<size>::Elf_WXword Elf_size_type;
2131
2132   unsigned int nsyms = this->input_reader_.get_global_symbol_count();
2133   this->symbols_.resize(nsyms);
2134
2135   Incremental_binary::View symtab_view(NULL);
2136   unsigned int symtab_count;
2137   elfcpp::Elf_strtab strtab(NULL, 0);
2138   this->ibase_->get_symtab_view(&symtab_view, &symtab_count, &strtab);
2139
2140   Incremental_symtab_reader<big_endian> isymtab(this->ibase_->symtab_reader());
2141   unsigned int isym_count = isymtab.symbol_count();
2142   unsigned int first_global = symtab_count - isym_count;
2143
2144   const unsigned char* sym_p;
2145   for (unsigned int i = 0; i < nsyms; ++i)
2146     {
2147       Incremental_global_symbol_reader<big_endian> info =
2148           this->input_reader_.get_global_symbol_reader(i);
2149       unsigned int output_symndx = info.output_symndx();
2150       sym_p = symtab_view.data() + output_symndx * sym_size;
2151       elfcpp::Sym<size, big_endian> gsym(sym_p);
2152       const char* name;
2153       if (!strtab.get_c_string(gsym.get_st_name(), &name))
2154         name = "";
2155
2156       typename elfcpp::Elf_types<size>::Elf_Addr v = gsym.get_st_value();
2157       unsigned int shndx = gsym.get_st_shndx();
2158       elfcpp::STB st_bind = gsym.get_st_bind();
2159       elfcpp::STT st_type = gsym.get_st_type();
2160
2161       // Local hidden symbols start out as globals, but get converted to
2162       // to local during output.
2163       if (st_bind == elfcpp::STB_LOCAL)
2164         st_bind = elfcpp::STB_GLOBAL;
2165
2166       unsigned int input_shndx = info.shndx();
2167       if (input_shndx == 0 || input_shndx == -1U)
2168         {
2169           shndx = elfcpp::SHN_UNDEF;
2170           v = 0;
2171         }
2172       else if (shndx != elfcpp::SHN_ABS)
2173         {
2174           // Find the input section and calculate the section-relative value.
2175           gold_assert(shndx != elfcpp::SHN_UNDEF);
2176           Output_section* os = this->ibase_->output_section(shndx);
2177           gold_assert(os != NULL && os->has_fixed_layout());
2178           typename Input_entry_reader::Input_section_info sect =
2179               this->input_reader_.get_input_section(input_shndx - 1);
2180           gold_assert(sect.output_shndx == shndx);
2181           if (st_type != elfcpp::STT_TLS)
2182             v -= os->address();
2183           v -= sect.sh_offset;
2184           shndx = input_shndx;
2185         }
2186
2187       osym.put_st_name(0);
2188       osym.put_st_value(v);
2189       osym.put_st_size(gsym.get_st_size());
2190       osym.put_st_info(st_bind, st_type);
2191       osym.put_st_other(gsym.get_st_other());
2192       osym.put_st_shndx(shndx);
2193
2194       Symbol* res = symtab->add_from_incrobj(this, name, NULL, &sym);
2195
2196       if (shndx != elfcpp::SHN_UNDEF)
2197         ++this->defined_count_;
2198
2199       // If this is a linker-defined symbol that hasn't yet been defined,
2200       // define it now.
2201       if (input_shndx == -1U && !res->is_defined())
2202         {
2203           shndx = gsym.get_st_shndx();
2204           v = gsym.get_st_value();
2205           Elf_size_type symsize = gsym.get_st_size();
2206           if (shndx == elfcpp::SHN_ABS)
2207             {
2208               symtab->define_as_constant(name, NULL,
2209                                          Symbol_table::INCREMENTAL_BASE,
2210                                          v, symsize, st_type, st_bind,
2211                                          gsym.get_st_visibility(), 0,
2212                                          false, false);
2213             }
2214           else
2215             {
2216               Output_section* os = this->ibase_->output_section(shndx);
2217               gold_assert(os != NULL && os->has_fixed_layout());
2218               v -= os->address();
2219               if (symsize > 0)
2220                 os->reserve(v, symsize);
2221               symtab->define_in_output_data(name, NULL,
2222                                             Symbol_table::INCREMENTAL_BASE,
2223                                             os, v, symsize, st_type, st_bind,
2224                                             gsym.get_st_visibility(), 0,
2225                                             false, false);
2226             }
2227         }
2228
2229       this->symbols_[i] = res;
2230       this->ibase_->add_global_symbol(output_symndx - first_global, res);
2231     }
2232 }
2233
2234 // Return TRUE if we should include this object from an archive library.
2235
2236 template<int size, bool big_endian>
2237 Archive::Should_include
2238 Sized_relobj_incr<size, big_endian>::do_should_include_member(
2239     Symbol_table*,
2240     Layout*,
2241     Read_symbols_data*,
2242     std::string*)
2243 {
2244   gold_unreachable();
2245 }
2246
2247 // Iterate over global symbols, calling a visitor class V for each.
2248
2249 template<int size, bool big_endian>
2250 void
2251 Sized_relobj_incr<size, big_endian>::do_for_all_global_symbols(
2252     Read_symbols_data*,
2253     Library_base::Symbol_visitor_base*)
2254 {
2255   // This routine is not used for incremental objects.
2256 }
2257
2258 // Get the size of a section.
2259
2260 template<int size, bool big_endian>
2261 uint64_t
2262 Sized_relobj_incr<size, big_endian>::do_section_size(unsigned int)
2263 {
2264   gold_unreachable();
2265 }
2266
2267 // Get the name of a section.  This returns the name of the output
2268 // section, because we don't usually track the names of the input
2269 // sections.
2270
2271 template<int size, bool big_endian>
2272 std::string
2273 Sized_relobj_incr<size, big_endian>::do_section_name(unsigned int shndx)
2274 {
2275   Output_sections& out_sections(this->output_sections());
2276   Output_section* os = out_sections[shndx];
2277   if (os == NULL)
2278     return NULL;
2279   return os->name();
2280 }
2281
2282 // Return a view of the contents of a section.
2283
2284 template<int size, bool big_endian>
2285 const unsigned char*
2286 Sized_relobj_incr<size, big_endian>::do_section_contents(
2287     unsigned int shndx,
2288     section_size_type* plen,
2289     bool)
2290 {
2291   Output_sections& out_sections(this->output_sections());
2292   Output_section* os = out_sections[shndx];
2293   gold_assert(os != NULL);
2294   off_t section_offset = os->offset();
2295   typename Input_entry_reader::Input_section_info sect =
2296       this->input_reader_.get_input_section(shndx - 1);
2297   section_offset += sect.sh_offset;
2298   *plen = sect.sh_size;
2299   return this->ibase_->view(section_offset, sect.sh_size).data();
2300 }
2301
2302 // Return section flags.
2303
2304 template<int size, bool big_endian>
2305 uint64_t
2306 Sized_relobj_incr<size, big_endian>::do_section_flags(unsigned int)
2307 {
2308   gold_unreachable();
2309 }
2310
2311 // Return section entsize.
2312
2313 template<int size, bool big_endian>
2314 uint64_t
2315 Sized_relobj_incr<size, big_endian>::do_section_entsize(unsigned int)
2316 {
2317   gold_unreachable();
2318 }
2319
2320 // Return section address.
2321
2322 template<int size, bool big_endian>
2323 uint64_t
2324 Sized_relobj_incr<size, big_endian>::do_section_address(unsigned int)
2325 {
2326   gold_unreachable();
2327 }
2328
2329 // Return section type.
2330
2331 template<int size, bool big_endian>
2332 unsigned int
2333 Sized_relobj_incr<size, big_endian>::do_section_type(unsigned int)
2334 {
2335   gold_unreachable();
2336 }
2337
2338 // Return the section link field.
2339
2340 template<int size, bool big_endian>
2341 unsigned int
2342 Sized_relobj_incr<size, big_endian>::do_section_link(unsigned int)
2343 {
2344   gold_unreachable();
2345 }
2346
2347 // Return the section link field.
2348
2349 template<int size, bool big_endian>
2350 unsigned int
2351 Sized_relobj_incr<size, big_endian>::do_section_info(unsigned int)
2352 {
2353   gold_unreachable();
2354 }
2355
2356 // Return the section alignment.
2357
2358 template<int size, bool big_endian>
2359 uint64_t
2360 Sized_relobj_incr<size, big_endian>::do_section_addralign(unsigned int)
2361 {
2362   gold_unreachable();
2363 }
2364
2365 // Return the Xindex structure to use.
2366
2367 template<int size, bool big_endian>
2368 Xindex*
2369 Sized_relobj_incr<size, big_endian>::do_initialize_xindex()
2370 {
2371   gold_unreachable();
2372 }
2373
2374 // Get symbol counts.
2375
2376 template<int size, bool big_endian>
2377 void
2378 Sized_relobj_incr<size, big_endian>::do_get_global_symbol_counts(
2379     const Symbol_table*,
2380     size_t* defined,
2381     size_t* used) const
2382 {
2383   *defined = this->defined_count_;
2384   size_t count = 0;
2385   for (typename Symbols::const_iterator p = this->symbols_.begin();
2386        p != this->symbols_.end();
2387        ++p)
2388     if (*p != NULL
2389         && (*p)->source() == Symbol::FROM_OBJECT
2390         && (*p)->object() == this
2391         && (*p)->is_defined())
2392       ++count;
2393   *used = count;
2394 }
2395
2396 // Read the relocs.
2397
2398 template<int size, bool big_endian>
2399 void
2400 Sized_relobj_incr<size, big_endian>::do_read_relocs(Read_relocs_data*)
2401 {
2402 }
2403
2404 // Process the relocs to find list of referenced sections. Used only
2405 // during garbage collection.
2406
2407 template<int size, bool big_endian>
2408 void
2409 Sized_relobj_incr<size, big_endian>::do_gc_process_relocs(Symbol_table*,
2410                                                           Layout*,
2411                                                           Read_relocs_data*)
2412 {
2413   gold_unreachable();
2414 }
2415
2416 // Scan the relocs and adjust the symbol table.
2417
2418 template<int size, bool big_endian>
2419 void
2420 Sized_relobj_incr<size, big_endian>::do_scan_relocs(Symbol_table*,
2421                                                     Layout* layout,
2422                                                     Read_relocs_data*)
2423 {
2424   // Count the incremental relocations for this object.
2425   unsigned int nsyms = this->input_reader_.get_global_symbol_count();
2426   this->allocate_incremental_reloc_counts();
2427   for (unsigned int i = 0; i < nsyms; i++)
2428     {
2429       Incremental_global_symbol_reader<big_endian> sym =
2430           this->input_reader_.get_global_symbol_reader(i);
2431       unsigned int reloc_count = sym.reloc_count();
2432       if (reloc_count > 0 && this->incr_reloc_offset_ == -1U)
2433         this->incr_reloc_offset_ = sym.reloc_offset();
2434       this->incr_reloc_count_ += reloc_count;
2435       for (unsigned int j = 0; j < reloc_count; j++)
2436         this->count_incremental_reloc(i);
2437     }
2438   this->incr_reloc_output_index_ =
2439       layout->incremental_inputs()->get_reloc_count();
2440   this->finalize_incremental_relocs(layout, false);
2441
2442   // The incoming incremental relocations may not end up in the same
2443   // location after the incremental update, because the incremental info
2444   // is regenerated in each link.  Because the new location may overlap
2445   // with other data in the updated output file, we need to copy the
2446   // relocations into a buffer so that we can still read them safely
2447   // after we start writing updates to the output file.
2448   if (this->incr_reloc_count_ > 0)
2449     {
2450       const Incremental_relocs_reader<size, big_endian>& relocs_reader =
2451           this->ibase_->relocs_reader();
2452       const unsigned int incr_reloc_size = relocs_reader.reloc_size;
2453       unsigned int len = this->incr_reloc_count_ * incr_reloc_size;
2454       this->incr_relocs_ = new unsigned char[len];
2455       memcpy(this->incr_relocs_,
2456              relocs_reader.data(this->incr_reloc_offset_),
2457              len);
2458     }
2459 }
2460
2461 // Count the local symbols.
2462
2463 template<int size, bool big_endian>
2464 void
2465 Sized_relobj_incr<size, big_endian>::do_count_local_symbols(
2466     Stringpool_template<char>* pool,
2467     Stringpool_template<char>*)
2468 {
2469   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
2470
2471   // Set the count of local symbols based on the incremental info.
2472   unsigned int nlocals = this->input_reader_.get_local_symbol_count();
2473   this->local_symbol_count_ = nlocals;
2474   this->local_symbols_.reserve(nlocals);
2475
2476   // Get views of the base file's symbol table and string table.
2477   Incremental_binary::View symtab_view(NULL);
2478   unsigned int symtab_count;
2479   elfcpp::Elf_strtab strtab(NULL, 0);
2480   this->ibase_->get_symtab_view(&symtab_view, &symtab_count, &strtab);
2481
2482   // Read the local symbols from the base file's symbol table.
2483   off_t off = this->input_reader_.get_local_symbol_offset();
2484   const unsigned char* symp = symtab_view.data() + off;
2485   for (unsigned int i = 0; i < nlocals; ++i, symp += sym_size)
2486     {
2487       elfcpp::Sym<size, big_endian> sym(symp);
2488       const char* name;
2489       if (!strtab.get_c_string(sym.get_st_name(), &name))
2490         name = "";
2491       gold_debug(DEBUG_INCREMENTAL, "Local symbol %d: %s", i, name);
2492       name = pool->add(name, true, NULL);
2493       this->local_symbols_.push_back(Local_symbol(name,
2494                                                   sym.get_st_value(),
2495                                                   sym.get_st_size(),
2496                                                   sym.get_st_shndx(),
2497                                                   sym.get_st_type(),
2498                                                   false));
2499     }
2500 }
2501
2502 // Finalize the local symbols.
2503
2504 template<int size, bool big_endian>
2505 unsigned int
2506 Sized_relobj_incr<size, big_endian>::do_finalize_local_symbols(
2507     unsigned int index,
2508     off_t off,
2509     Symbol_table*)
2510 {
2511   this->local_symbol_index_ = index;
2512   this->local_symbol_offset_ = off;
2513   return index + this->local_symbol_count_;
2514 }
2515
2516 // Set the offset where local dynamic symbol information will be stored.
2517
2518 template<int size, bool big_endian>
2519 unsigned int
2520 Sized_relobj_incr<size, big_endian>::do_set_local_dynsym_indexes(
2521     unsigned int index)
2522 {
2523   // FIXME: set local dynsym indexes.
2524   return index;
2525 }
2526
2527 // Set the offset where local dynamic symbol information will be stored.
2528
2529 template<int size, bool big_endian>
2530 unsigned int
2531 Sized_relobj_incr<size, big_endian>::do_set_local_dynsym_offset(off_t)
2532 {
2533   return 0;
2534 }
2535
2536 // Relocate the input sections and write out the local symbols.
2537 // We don't actually do any relocation here.  For unchanged input files,
2538 // we reapply relocations only for symbols that have changed; that happens
2539 // in queue_final_tasks.  We do need to rewrite the incremental relocations
2540 // for this object.
2541
2542 template<int size, bool big_endian>
2543 void
2544 Sized_relobj_incr<size, big_endian>::do_relocate(const Symbol_table*,
2545                                                  const Layout* layout,
2546                                                  Output_file* of)
2547 {
2548   if (this->incr_reloc_count_ == 0)
2549     return;
2550
2551   const unsigned int incr_reloc_size =
2552       Incremental_relocs_reader<size, big_endian>::reloc_size;
2553
2554   // Get a view for the .gnu_incremental_relocs section.
2555   Incremental_inputs* inputs = layout->incremental_inputs();
2556   gold_assert(inputs != NULL);
2557   const off_t relocs_off = inputs->relocs_section()->offset();
2558   const off_t relocs_size = inputs->relocs_section()->data_size();
2559   unsigned char* const view = of->get_output_view(relocs_off, relocs_size);
2560
2561   // Copy the relocations from the buffer.
2562   off_t off = this->incr_reloc_output_index_ * incr_reloc_size;
2563   unsigned int len = this->incr_reloc_count_ * incr_reloc_size;
2564   memcpy(view + off, this->incr_relocs_, len);
2565
2566   // The output section table may have changed, so we need to map
2567   // the old section index to the new section index for each relocation.
2568   for (unsigned int i = 0; i < this->incr_reloc_count_; ++i)
2569     {
2570       unsigned char* pov = view + off + i * incr_reloc_size;
2571       unsigned int shndx = elfcpp::Swap<32, big_endian>::readval(pov + 4);
2572       Output_section* os = this->ibase_->output_section(shndx);
2573       gold_assert(os != NULL);
2574       shndx = os->out_shndx();
2575       elfcpp::Swap<32, big_endian>::writeval(pov + 4, shndx);
2576     }
2577
2578   of->write_output_view(off, len, view);
2579
2580   // Get views into the output file for the portions of the symbol table
2581   // and the dynamic symbol table that we will be writing.
2582   off_t symtab_off = layout->symtab_section()->offset();
2583   off_t output_size = this->local_symbol_count_ * This::sym_size;
2584   unsigned char* oview = NULL;
2585   if (output_size > 0)
2586     oview = of->get_output_view(symtab_off + this->local_symbol_offset_,
2587                                 output_size);
2588
2589   off_t dyn_output_size = this->output_local_dynsym_count_ * sym_size;
2590   unsigned char* dyn_oview = NULL;
2591   if (dyn_output_size > 0)
2592     dyn_oview = of->get_output_view(this->local_dynsym_offset_,
2593                                     dyn_output_size);
2594
2595   // Write the local symbols.
2596   unsigned char* ov = oview;
2597   unsigned char* dyn_ov = dyn_oview;
2598   const Stringpool* sympool = layout->sympool();
2599   const Stringpool* dynpool = layout->dynpool();
2600   Output_symtab_xindex* symtab_xindex = layout->symtab_xindex();
2601   Output_symtab_xindex* dynsym_xindex = layout->dynsym_xindex();
2602   for (unsigned int i = 0; i < this->local_symbol_count_; ++i)
2603     {
2604       Local_symbol& lsym(this->local_symbols_[i]);
2605
2606       bool is_ordinary;
2607       unsigned int st_shndx = this->adjust_sym_shndx(i, lsym.st_shndx,
2608                                                      &is_ordinary);
2609       if (is_ordinary)
2610         {
2611           Output_section* os = this->ibase_->output_section(st_shndx);
2612           st_shndx = os->out_shndx();
2613           if (st_shndx >= elfcpp::SHN_LORESERVE)
2614             {
2615               symtab_xindex->add(this->local_symbol_index_ + i, st_shndx);
2616               if (lsym.needs_dynsym_entry)
2617                 dynsym_xindex->add(lsym.output_dynsym_index, st_shndx);
2618               st_shndx = elfcpp::SHN_XINDEX;
2619             }
2620         }
2621
2622       // Write the symbol to the output symbol table.
2623       {
2624         elfcpp::Sym_write<size, big_endian> osym(ov);
2625         osym.put_st_name(sympool->get_offset(lsym.name));
2626         osym.put_st_value(lsym.st_value);
2627         osym.put_st_size(lsym.st_size);
2628         osym.put_st_info(elfcpp::STB_LOCAL,
2629                          static_cast<elfcpp::STT>(lsym.st_type));
2630         osym.put_st_other(0);
2631         osym.put_st_shndx(st_shndx);
2632         ov += sym_size;
2633       }
2634
2635       // Write the symbol to the output dynamic symbol table.
2636       if (lsym.needs_dynsym_entry)
2637         {
2638           gold_assert(dyn_ov < dyn_oview + dyn_output_size);
2639           elfcpp::Sym_write<size, big_endian> osym(dyn_ov);
2640           osym.put_st_name(dynpool->get_offset(lsym.name));
2641           osym.put_st_value(lsym.st_value);
2642           osym.put_st_size(lsym.st_size);
2643           osym.put_st_info(elfcpp::STB_LOCAL,
2644                            static_cast<elfcpp::STT>(lsym.st_type));
2645           osym.put_st_other(0);
2646           osym.put_st_shndx(st_shndx);
2647           dyn_ov += sym_size;
2648         }
2649     }
2650
2651   if (output_size > 0)
2652     {
2653       gold_assert(ov - oview == output_size);
2654       of->write_output_view(symtab_off + this->local_symbol_offset_,
2655                             output_size, oview);
2656     }
2657
2658   if (dyn_output_size > 0)
2659     {
2660       gold_assert(dyn_ov - dyn_oview == dyn_output_size);
2661       of->write_output_view(this->local_dynsym_offset_, dyn_output_size,
2662                             dyn_oview);
2663     }
2664 }
2665
2666 // Set the offset of a section.
2667
2668 template<int size, bool big_endian>
2669 void
2670 Sized_relobj_incr<size, big_endian>::do_set_section_offset(unsigned int,
2671                                                            uint64_t)
2672 {
2673 }
2674
2675 // Class Sized_incr_dynobj.  Most of these methods are not used for
2676 // Incremental objects, but are required to be implemented by the
2677 // base class Object.
2678
2679 template<int size, bool big_endian>
2680 Sized_incr_dynobj<size, big_endian>::Sized_incr_dynobj(
2681     const std::string& name,
2682     Sized_incremental_binary<size, big_endian>* ibase,
2683     unsigned int input_file_index)
2684   : Dynobj(name, NULL), ibase_(ibase),
2685     input_file_index_(input_file_index),
2686     input_reader_(ibase->inputs_reader().input_file(input_file_index)),
2687     symbols_(), defined_count_(0)
2688 {
2689   if (this->input_reader_.is_in_system_directory())
2690     this->set_is_in_system_directory();
2691   if (this->input_reader_.as_needed())
2692     this->set_as_needed();
2693   this->set_soname_string(this->input_reader_.get_soname());
2694   this->set_shnum(0);
2695 }
2696
2697 // Read the symbols.
2698
2699 template<int size, bool big_endian>
2700 void
2701 Sized_incr_dynobj<size, big_endian>::do_read_symbols(Read_symbols_data*)
2702 {
2703   gold_unreachable();
2704 }
2705
2706 // Lay out the input sections.
2707
2708 template<int size, bool big_endian>
2709 void
2710 Sized_incr_dynobj<size, big_endian>::do_layout(
2711     Symbol_table*,
2712     Layout*,
2713     Read_symbols_data*)
2714 {
2715 }
2716
2717 // Add the symbols to the symbol table.
2718
2719 template<int size, bool big_endian>
2720 void
2721 Sized_incr_dynobj<size, big_endian>::do_add_symbols(
2722     Symbol_table* symtab,
2723     Read_symbols_data*,
2724     Layout*)
2725 {
2726   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
2727   unsigned char symbuf[sym_size];
2728   elfcpp::Sym<size, big_endian> sym(symbuf);
2729   elfcpp::Sym_write<size, big_endian> osym(symbuf);
2730
2731   unsigned int nsyms = this->input_reader_.get_global_symbol_count();
2732   this->symbols_.resize(nsyms);
2733
2734   Incremental_binary::View symtab_view(NULL);
2735   unsigned int symtab_count;
2736   elfcpp::Elf_strtab strtab(NULL, 0);
2737   this->ibase_->get_symtab_view(&symtab_view, &symtab_count, &strtab);
2738
2739   Incremental_symtab_reader<big_endian> isymtab(this->ibase_->symtab_reader());
2740   unsigned int isym_count = isymtab.symbol_count();
2741   unsigned int first_global = symtab_count - isym_count;
2742
2743   // We keep a set of symbols that we have generated COPY relocations
2744   // for, indexed by the symbol value. We do not need more than one
2745   // COPY relocation per address.
2746   typedef typename std::set<Address> Copied_symbols;
2747   Copied_symbols copied_symbols;
2748
2749   const unsigned char* sym_p;
2750   for (unsigned int i = 0; i < nsyms; ++i)
2751     {
2752       bool is_def;
2753       bool is_copy;
2754       unsigned int output_symndx =
2755           this->input_reader_.get_output_symbol_index(i, &is_def, &is_copy);
2756       sym_p = symtab_view.data() + output_symndx * sym_size;
2757       elfcpp::Sym<size, big_endian> gsym(sym_p);
2758       const char* name;
2759       if (!strtab.get_c_string(gsym.get_st_name(), &name))
2760         name = "";
2761
2762       Address v;
2763       unsigned int shndx;
2764       elfcpp::STB st_bind = gsym.get_st_bind();
2765       elfcpp::STT st_type = gsym.get_st_type();
2766
2767       // Local hidden symbols start out as globals, but get converted to
2768       // to local during output.
2769       if (st_bind == elfcpp::STB_LOCAL)
2770         st_bind = elfcpp::STB_GLOBAL;
2771
2772       if (!is_def)
2773         {
2774           shndx = elfcpp::SHN_UNDEF;
2775           v = 0;
2776         }
2777       else
2778         {
2779           // For a symbol defined in a shared object, the section index
2780           // is meaningless, as long as it's not SHN_UNDEF.
2781           shndx = 1;
2782           v = gsym.get_st_value();
2783           ++this->defined_count_;
2784         }
2785
2786       osym.put_st_name(0);
2787       osym.put_st_value(v);
2788       osym.put_st_size(gsym.get_st_size());
2789       osym.put_st_info(st_bind, st_type);
2790       osym.put_st_other(gsym.get_st_other());
2791       osym.put_st_shndx(shndx);
2792
2793       Sized_symbol<size>* res =
2794           symtab->add_from_incrobj<size, big_endian>(this, name, NULL, &sym);
2795       this->symbols_[i] = res;
2796       this->ibase_->add_global_symbol(output_symndx - first_global,
2797                                       this->symbols_[i]);
2798
2799       if (is_copy)
2800         {
2801           std::pair<typename Copied_symbols::iterator, bool> ins =
2802               copied_symbols.insert(v);
2803           if (ins.second)
2804             {
2805               unsigned int shndx = gsym.get_st_shndx();
2806               Output_section* os = this->ibase_->output_section(shndx);
2807               off_t offset = v - os->address();
2808               this->ibase_->add_copy_reloc(this->symbols_[i], os, offset);
2809             }
2810         }
2811     }
2812 }
2813
2814 // Return TRUE if we should include this object from an archive library.
2815
2816 template<int size, bool big_endian>
2817 Archive::Should_include
2818 Sized_incr_dynobj<size, big_endian>::do_should_include_member(
2819     Symbol_table*,
2820     Layout*,
2821     Read_symbols_data*,
2822     std::string*)
2823 {
2824   gold_unreachable();
2825 }
2826
2827 // Iterate over global symbols, calling a visitor class V for each.
2828
2829 template<int size, bool big_endian>
2830 void
2831 Sized_incr_dynobj<size, big_endian>::do_for_all_global_symbols(
2832     Read_symbols_data*,
2833     Library_base::Symbol_visitor_base*)
2834 {
2835   // This routine is not used for dynamic libraries.
2836 }
2837
2838 // Iterate over local symbols, calling a visitor class V for each GOT offset
2839 // associated with a local symbol.
2840
2841 template<int size, bool big_endian>
2842 void
2843 Sized_incr_dynobj<size, big_endian>::do_for_all_local_got_entries(
2844     Got_offset_list::Visitor*) const
2845 {
2846 }
2847
2848 // Get the size of a section.
2849
2850 template<int size, bool big_endian>
2851 uint64_t
2852 Sized_incr_dynobj<size, big_endian>::do_section_size(unsigned int)
2853 {
2854   gold_unreachable();
2855 }
2856
2857 // Get the name of a section.
2858
2859 template<int size, bool big_endian>
2860 std::string
2861 Sized_incr_dynobj<size, big_endian>::do_section_name(unsigned int)
2862 {
2863   gold_unreachable();
2864 }
2865
2866 // Return a view of the contents of a section.
2867
2868 template<int size, bool big_endian>
2869 const unsigned char*
2870 Sized_incr_dynobj<size, big_endian>::do_section_contents(
2871     unsigned int,
2872     section_size_type*,
2873     bool)
2874 {
2875   gold_unreachable();
2876 }
2877
2878 // Return section flags.
2879
2880 template<int size, bool big_endian>
2881 uint64_t
2882 Sized_incr_dynobj<size, big_endian>::do_section_flags(unsigned int)
2883 {
2884   gold_unreachable();
2885 }
2886
2887 // Return section entsize.
2888
2889 template<int size, bool big_endian>
2890 uint64_t
2891 Sized_incr_dynobj<size, big_endian>::do_section_entsize(unsigned int)
2892 {
2893   gold_unreachable();
2894 }
2895
2896 // Return section address.
2897
2898 template<int size, bool big_endian>
2899 uint64_t
2900 Sized_incr_dynobj<size, big_endian>::do_section_address(unsigned int)
2901 {
2902   gold_unreachable();
2903 }
2904
2905 // Return section type.
2906
2907 template<int size, bool big_endian>
2908 unsigned int
2909 Sized_incr_dynobj<size, big_endian>::do_section_type(unsigned int)
2910 {
2911   gold_unreachable();
2912 }
2913
2914 // Return the section link field.
2915
2916 template<int size, bool big_endian>
2917 unsigned int
2918 Sized_incr_dynobj<size, big_endian>::do_section_link(unsigned int)
2919 {
2920   gold_unreachable();
2921 }
2922
2923 // Return the section link field.
2924
2925 template<int size, bool big_endian>
2926 unsigned int
2927 Sized_incr_dynobj<size, big_endian>::do_section_info(unsigned int)
2928 {
2929   gold_unreachable();
2930 }
2931
2932 // Return the section alignment.
2933
2934 template<int size, bool big_endian>
2935 uint64_t
2936 Sized_incr_dynobj<size, big_endian>::do_section_addralign(unsigned int)
2937 {
2938   gold_unreachable();
2939 }
2940
2941 // Return the Xindex structure to use.
2942
2943 template<int size, bool big_endian>
2944 Xindex*
2945 Sized_incr_dynobj<size, big_endian>::do_initialize_xindex()
2946 {
2947   gold_unreachable();
2948 }
2949
2950 // Get symbol counts.
2951
2952 template<int size, bool big_endian>
2953 void
2954 Sized_incr_dynobj<size, big_endian>::do_get_global_symbol_counts(
2955     const Symbol_table*,
2956     size_t* defined,
2957     size_t* used) const
2958 {
2959   *defined = this->defined_count_;
2960   size_t count = 0;
2961   for (typename Symbols::const_iterator p = this->symbols_.begin();
2962        p != this->symbols_.end();
2963        ++p)
2964     if (*p != NULL
2965         && (*p)->source() == Symbol::FROM_OBJECT
2966         && (*p)->object() == this
2967         && (*p)->is_defined()
2968         && (*p)->dynsym_index() != -1U)
2969       ++count;
2970   *used = count;
2971 }
2972
2973 // Allocate an incremental object of the appropriate size and endianness.
2974
2975 Object*
2976 make_sized_incremental_object(
2977     Incremental_binary* ibase,
2978     unsigned int input_file_index,
2979     Incremental_input_type input_type,
2980     const Incremental_binary::Input_reader* input_reader)
2981 {
2982   Object* obj = NULL;
2983   std::string name(input_reader->filename());
2984
2985   switch (parameters->size_and_endianness())
2986     {
2987 #ifdef HAVE_TARGET_32_LITTLE
2988     case Parameters::TARGET_32_LITTLE:
2989       {
2990         Sized_incremental_binary<32, false>* sized_ibase =
2991             static_cast<Sized_incremental_binary<32, false>*>(ibase);
2992         if (input_type == INCREMENTAL_INPUT_SHARED_LIBRARY)
2993           obj = new Sized_incr_dynobj<32, false>(name, sized_ibase,
2994                                                  input_file_index);
2995         else
2996           obj = new Sized_relobj_incr<32, false>(name, sized_ibase,
2997                                                  input_file_index);
2998       }
2999       break;
3000 #endif
3001 #ifdef HAVE_TARGET_32_BIG
3002     case Parameters::TARGET_32_BIG:
3003       {
3004         Sized_incremental_binary<32, true>* sized_ibase =
3005             static_cast<Sized_incremental_binary<32, true>*>(ibase);
3006         if (input_type == INCREMENTAL_INPUT_SHARED_LIBRARY)
3007           obj = new Sized_incr_dynobj<32, true>(name, sized_ibase,
3008                                                 input_file_index);
3009         else
3010           obj = new Sized_relobj_incr<32, true>(name, sized_ibase,
3011                                                 input_file_index);
3012       }
3013       break;
3014 #endif
3015 #ifdef HAVE_TARGET_64_LITTLE
3016     case Parameters::TARGET_64_LITTLE:
3017       {
3018         Sized_incremental_binary<64, false>* sized_ibase =
3019             static_cast<Sized_incremental_binary<64, false>*>(ibase);
3020         if (input_type == INCREMENTAL_INPUT_SHARED_LIBRARY)
3021           obj = new Sized_incr_dynobj<64, false>(name, sized_ibase,
3022                                                  input_file_index);
3023         else
3024           obj = new Sized_relobj_incr<64, false>(name, sized_ibase,
3025                                                  input_file_index);
3026      }
3027       break;
3028 #endif
3029 #ifdef HAVE_TARGET_64_BIG
3030     case Parameters::TARGET_64_BIG:
3031       {
3032         Sized_incremental_binary<64, true>* sized_ibase =
3033             static_cast<Sized_incremental_binary<64, true>*>(ibase);
3034         if (input_type == INCREMENTAL_INPUT_SHARED_LIBRARY)
3035           obj = new Sized_incr_dynobj<64, true>(name, sized_ibase,
3036                                                 input_file_index);
3037         else
3038           obj = new Sized_relobj_incr<64, true>(name, sized_ibase,
3039                                                 input_file_index);
3040       }
3041       break;
3042 #endif
3043     default:
3044       gold_unreachable();
3045     }
3046
3047   gold_assert(obj != NULL);
3048   return obj;
3049 }
3050
3051 // Copy the unused symbols from the incremental input info.
3052 // We need to do this because we may be overwriting the incremental
3053 // input info in the base file before we write the new incremental
3054 // info.
3055 void
3056 Incremental_library::copy_unused_symbols()
3057 {
3058   unsigned int symcount = this->input_reader_->get_unused_symbol_count();
3059   this->unused_symbols_.reserve(symcount);
3060   for (unsigned int i = 0; i < symcount; ++i)
3061     {
3062       std::string name(this->input_reader_->get_unused_symbol(i));
3063       this->unused_symbols_.push_back(name);
3064     }
3065 }
3066
3067 // Iterator for unused global symbols in the library.
3068 void
3069 Incremental_library::do_for_all_unused_symbols(Symbol_visitor_base* v) const
3070 {
3071   for (Symbol_list::const_iterator p = this->unused_symbols_.begin();
3072        p != this->unused_symbols_.end();
3073        ++p)
3074   v->visit(p->c_str());
3075 }
3076
3077 // Instantiate the templates we need.
3078
3079 #ifdef HAVE_TARGET_32_LITTLE
3080 template
3081 class Sized_incremental_binary<32, false>;
3082
3083 template
3084 class Sized_relobj_incr<32, false>;
3085
3086 template
3087 class Sized_incr_dynobj<32, false>;
3088 #endif
3089
3090 #ifdef HAVE_TARGET_32_BIG
3091 template
3092 class Sized_incremental_binary<32, true>;
3093
3094 template
3095 class Sized_relobj_incr<32, true>;
3096
3097 template
3098 class Sized_incr_dynobj<32, true>;
3099 #endif
3100
3101 #ifdef HAVE_TARGET_64_LITTLE
3102 template
3103 class Sized_incremental_binary<64, false>;
3104
3105 template
3106 class Sized_relobj_incr<64, false>;
3107
3108 template
3109 class Sized_incr_dynobj<64, false>;
3110 #endif
3111
3112 #ifdef HAVE_TARGET_64_BIG
3113 template
3114 class Sized_incremental_binary<64, true>;
3115
3116 template
3117 class Sized_relobj_incr<64, true>;
3118
3119 template
3120 class Sized_incr_dynobj<64, true>;
3121 #endif
3122
3123 } // End namespace gold.