gold/incremental.cc

   1 // inremental.cc -- incremental linking support for gold
   2
   3 // Copyright 2009, 2010 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 <cstdarg>
  26 #include "libiberty.h"
  27
  28 #include "elfcpp.h"
  29 #include "output.h"
  30 #include "symtab.h"
  31 #include "incremental.h"
  32 #include "archive.h"
  33 #include "output.h"
  34 #include "target-select.h"
  35 #include "target.h"
  36
  37 namespace gold {
  38
  39 // Version information. Will change frequently during the development, later
  40 // we could think about backward (and forward?) compatibility.
  41 const unsigned int INCREMENTAL_LINK_VERSION = 1;
  42
  43 // This class manages the .gnu_incremental_inputs section, which holds
  44 // the header information, a directory of input files, and separate
  45 // entries for each input file.
  46
  47 template<int size, bool big_endian>
  48 class Output_section_incremental_inputs : public Output_section_data
  49 {
  50  public:
  51   Output_section_incremental_inputs(const Incremental_inputs* inputs,
  52                                     const Symbol_table* symtab)
  53     : Output_section_data(size / 8), inputs_(inputs), symtab_(symtab)
  54   { }
  55
  56  protected:
  57   // Set the final data size.
  58   void
  59   set_final_data_size();
  60
  61   // Write the data to the file.
  62   void
  63   do_write(Output_file*);
  64
  65   // Write to a map file.
  66   void
  67   do_print_to_mapfile(Mapfile* mapfile) const
  68   { mapfile->print_output_data(this, _("** incremental_inputs")); }
  69
  70  private:
  71   // Write the section header.
  72   unsigned char*
  73   write_header(unsigned char* pov, unsigned int input_file_count,
  74                section_offset_type command_line_offset);
  75
  76   // Write the input file entries.
  77   unsigned char*
  78   write_input_files(unsigned char* oview, unsigned char* pov,
  79                     Stringpool* strtab);
  80
  81   // Write the supplemental information blocks.
  82   unsigned char*
  83   write_info_blocks(unsigned char* oview, unsigned char* pov,
  84                     Stringpool* strtab, unsigned int* global_syms,
  85                     unsigned int global_sym_count);
  86
  87   // Write the contents of the .gnu_incremental_symtab section.
  88   void
  89   write_symtab(unsigned char* pov, unsigned int* global_syms,
  90                unsigned int global_sym_count);
  91
  92   // Write the contents of the .gnu_incremental_got_plt section.
  93   void
  94   write_got_plt(unsigned char* pov, off_t view_size);
  95
  96   // Typedefs for writing the data to the output sections.
  97   typedef elfcpp::Swap<size, big_endian> Swap;
  98   typedef elfcpp::Swap<16, big_endian> Swap16;
  99   typedef elfcpp::Swap<32, big_endian> Swap32;
 100   typedef elfcpp::Swap<64, big_endian> Swap64;
 101
 102   // Sizes of various structures.
 103   static const int sizeof_addr = size / 8;
 104   static const int header_size = 16;
 105   static const int input_entry_size = 24;
 106
 107   // The Incremental_inputs object.
 108   const Incremental_inputs* inputs_;
 109
 110   // The symbol table.
 111   const Symbol_table* symtab_;
 112 };
 113
 114 // Inform the user why we don't do an incremental link.  Not called in
 115 // the obvious case of missing output file.  TODO: Is this helpful?
 116
 117 void
 118 vexplain_no_incremental(const char* format, va_list args)
 119 {
 120   char* buf = NULL;
 121   if (vasprintf(&buf, format, args) < 0)
 122     gold_nomem();
 123   gold_info(_("the link might take longer: "
 124               "cannot perform incremental link: %s"), buf);
 125   free(buf);
 126 }
 127
 128 void
 129 explain_no_incremental(const char* format, ...)
 130 {
 131   va_list args;
 132   va_start(args, format);
 133   vexplain_no_incremental(format, args);
 134   va_end(args);
 135 }
 136
 137 // Report an error.
 138
 139 void
 140 Incremental_binary::error(const char* format, ...) const
 141 {
 142   va_list args;
 143   va_start(args, format);
 144   // Current code only checks if the file can be used for incremental linking,
 145   // so errors shouldn't fail the build, but only result in a fallback to a
 146   // full build.
 147   // TODO: when we implement incremental editing of the file, we may need a
 148   // flag that will cause errors to be treated seriously.
 149   vexplain_no_incremental(format, args);
 150   va_end(args);
 151 }
 152
 153 // Find the .gnu_incremental_inputs section and related sections.
 154
 155 template<int size, bool big_endian>
 156 bool
 157 Sized_incremental_binary<size, big_endian>::do_find_incremental_inputs_sections(
 158     unsigned int* p_inputs_shndx,
 159     unsigned int* p_symtab_shndx,
 160     unsigned int* p_relocs_shndx,
 161     unsigned int* p_got_plt_shndx,
 162     unsigned int* p_strtab_shndx)
 163 {
 164   unsigned int inputs_shndx =
 165       this->elf_file_.find_section_by_type(elfcpp::SHT_GNU_INCREMENTAL_INPUTS);
 166   if (inputs_shndx == elfcpp::SHN_UNDEF)  // Not found.
 167     return false;
 168
 169   unsigned int symtab_shndx =
 170       this->elf_file_.find_section_by_type(elfcpp::SHT_GNU_INCREMENTAL_SYMTAB);
 171   if (symtab_shndx == elfcpp::SHN_UNDEF)  // Not found.
 172     return false;
 173   if (this->elf_file_.section_link(symtab_shndx) != inputs_shndx)
 174     return false;
 175
 176   unsigned int relocs_shndx =
 177       this->elf_file_.find_section_by_type(elfcpp::SHT_GNU_INCREMENTAL_RELOCS);
 178   if (relocs_shndx == elfcpp::SHN_UNDEF)  // Not found.
 179     return false;
 180   if (this->elf_file_.section_link(relocs_shndx) != inputs_shndx)
 181     return false;
 182
 183   unsigned int got_plt_shndx =
 184       this->elf_file_.find_section_by_type(elfcpp::SHT_GNU_INCREMENTAL_GOT_PLT);
 185   if (got_plt_shndx == elfcpp::SHN_UNDEF)  // Not found.
 186     return false;
 187   if (this->elf_file_.section_link(got_plt_shndx) != inputs_shndx)
 188     return false;
 189
 190   unsigned int strtab_shndx = this->elf_file_.section_link(inputs_shndx);
 191   if (strtab_shndx == elfcpp::SHN_UNDEF
 192       || strtab_shndx > this->elf_file_.shnum()
 193       || this->elf_file_.section_type(strtab_shndx) != elfcpp::SHT_STRTAB)
 194     return false;
 195
 196   if (p_inputs_shndx != NULL)
 197     *p_inputs_shndx = inputs_shndx;
 198   if (p_symtab_shndx != NULL)
 199     *p_symtab_shndx = symtab_shndx;
 200   if (p_relocs_shndx != NULL)
 201     *p_relocs_shndx = relocs_shndx;
 202   if (p_got_plt_shndx != NULL)
 203     *p_got_plt_shndx = got_plt_shndx;
 204   if (p_strtab_shndx != NULL)
 205     *p_strtab_shndx = strtab_shndx;
 206   return true;
 207 }
 208
 209 // Determine whether an incremental link based on the existing output file
 210 // can be done.
 211
 212 template<int size, bool big_endian>
 213 bool
 214 Sized_incremental_binary<size, big_endian>::do_check_inputs(
 215     Incremental_inputs* incremental_inputs)
 216 {
 217   unsigned int inputs_shndx;
 218   unsigned int symtab_shndx;
 219   unsigned int relocs_shndx;
 220   unsigned int plt_got_shndx;
 221   unsigned int strtab_shndx;
 222
 223   if (!do_find_incremental_inputs_sections(&inputs_shndx, &symtab_shndx,
 224                                            &relocs_shndx, &plt_got_shndx,
 225                                            &strtab_shndx))
 226     {
 227       explain_no_incremental(_("no incremental data from previous build"));
 228       return false;
 229     }
 230
 231   Location inputs_location(this->elf_file_.section_contents(inputs_shndx));
 232   Location symtab_location(this->elf_file_.section_contents(symtab_shndx));
 233   Location relocs_location(this->elf_file_.section_contents(relocs_shndx));
 234   Location strtab_location(this->elf_file_.section_contents(strtab_shndx));
 235
 236   View inputs_view(view(inputs_location));
 237   View symtab_view(view(symtab_location));
 238   View relocs_view(view(relocs_location));
 239   View strtab_view(view(strtab_location));
 240
 241   elfcpp::Elf_strtab strtab(strtab_view.data(), strtab_location.data_size);
 242
 243   Incremental_inputs_reader<size, big_endian>
 244       incoming_inputs(inputs_view.data(), strtab);
 245
 246   if (incoming_inputs.version() != INCREMENTAL_LINK_VERSION)
 247     {
 248       explain_no_incremental(_("different version of incremental build data"));
 249       return false;
 250     }
 251
 252   if (incremental_inputs->command_line() != incoming_inputs.command_line())
 253     {
 254       explain_no_incremental(_("command line changed"));
 255       return false;
 256     }
 257
 258   // TODO: compare incremental_inputs->inputs() with entries in data_view.
 259
 260   return true;
 261 }
 262
 263 namespace
 264 {
 265
 266 // Create a Sized_incremental_binary object of the specified size and
 267 // endianness. Fails if the target architecture is not supported.
 268
 269 template<int size, bool big_endian>
 270 Incremental_binary*
 271 make_sized_incremental_binary(Output_file* file,
 272                               const elfcpp::Ehdr<size, big_endian>& ehdr)
 273 {
 274   Target* target = select_target(ehdr.get_e_machine(), size, big_endian,
 275                                  ehdr.get_e_ident()[elfcpp::EI_OSABI],
 276                                  ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]);
 277   if (target == NULL)
 278     {
 279       explain_no_incremental(_("unsupported ELF machine number %d"),
 280                ehdr.get_e_machine());
 281       return NULL;
 282     }
 283
 284   if (!parameters->target_valid())
 285     set_parameters_target(target);
 286   else if (target != &parameters->target())
 287     gold_error(_("%s: incompatible target"), file->filename());
 288
 289   return new Sized_incremental_binary<size, big_endian>(file, ehdr, target);
 290 }
 291
 292 }  // End of anonymous namespace.
 293
 294 // Create an Incremental_binary object for FILE.  Returns NULL is this is not
 295 // possible, e.g. FILE is not an ELF file or has an unsupported target.  FILE
 296 // should be opened.
 297
 298 Incremental_binary*
 299 open_incremental_binary(Output_file* file)
 300 {
 301   off_t filesize = file->filesize();
 302   int want = elfcpp::Elf_recognizer::max_header_size;
 303   if (filesize < want)
 304     want = filesize;
 305
 306   const unsigned char* p = file->get_input_view(0, want);
 307   if (!elfcpp::Elf_recognizer::is_elf_file(p, want))
 308     {
 309       explain_no_incremental(_("output is not an ELF file."));
 310       return NULL;
 311     }
 312
 313   int size = 0;
 314   bool big_endian = false;
 315   std::string error;
 316   if (!elfcpp::Elf_recognizer::is_valid_header(p, want, &size, &big_endian,
 317                                                &error))
 318     {
 319       explain_no_incremental(error.c_str());
 320       return NULL;
 321     }
 322
 323   Incremental_binary* result = NULL;
 324   if (size == 32)
 325     {
 326       if (big_endian)
 327         {
 328 #ifdef HAVE_TARGET_32_BIG
 329           result = make_sized_incremental_binary<32, true>(
 330               file, elfcpp::Ehdr<32, true>(p));
 331 #else
 332           explain_no_incremental(_("unsupported file: 32-bit, big-endian"));
 333 #endif
 334         }
 335       else
 336         {
 337 #ifdef HAVE_TARGET_32_LITTLE
 338           result = make_sized_incremental_binary<32, false>(
 339               file, elfcpp::Ehdr<32, false>(p));
 340 #else
 341           explain_no_incremental(_("unsupported file: 32-bit, little-endian"));
 342 #endif
 343         }
 344     }
 345   else if (size == 64)
 346     {
 347       if (big_endian)
 348         {
 349 #ifdef HAVE_TARGET_64_BIG
 350           result = make_sized_incremental_binary<64, true>(
 351               file, elfcpp::Ehdr<64, true>(p));
 352 #else
 353           explain_no_incremental(_("unsupported file: 64-bit, big-endian"));
 354 #endif
 355         }
 356       else
 357         {
 358 #ifdef HAVE_TARGET_64_LITTLE
 359           result = make_sized_incremental_binary<64, false>(
 360               file, elfcpp::Ehdr<64, false>(p));
 361 #else
 362           explain_no_incremental(_("unsupported file: 64-bit, little-endian"));
 363 #endif
 364         }
 365     }
 366   else
 367     gold_unreachable();
 368
 369   return result;
 370 }
 371
 372 // Analyzes the output file to check if incremental linking is possible and
 373 // (to be done) what files need to be relinked.
 374
 375 bool
 376 Incremental_checker::can_incrementally_link_output_file()
 377 {
 378   Output_file output(this->output_name_);
 379   if (!output.open_for_modification())
 380     return false;
 381   Incremental_binary* binary = open_incremental_binary(&output);
 382   if (binary == NULL)
 383     return false;
 384   return binary->check_inputs(this->incremental_inputs_);
 385 }
 386
 387 // Class Incremental_inputs.
 388
 389 // Add the command line to the string table, setting
 390 // command_line_key_.  In incremental builds, the command line is
 391 // stored in .gnu_incremental_inputs so that the next linker run can
 392 // check if the command line options didn't change.
 393
 394 void
 395 Incremental_inputs::report_command_line(int argc, const char* const* argv)
 396 {
 397   // Always store 'gold' as argv[0] to avoid a full relink if the user used a
 398   // different path to the linker.
 399   std::string args("gold");
 400   // Copied from collect_argv in main.cc.
 401   for (int i = 1; i < argc; ++i)
 402     {
 403       // Adding/removing these options should not result in a full relink.
 404       if (strcmp(argv[i], "--incremental") == 0
 405           || strcmp(argv[i], "--incremental-full") == 0
 406           || strcmp(argv[i], "--incremental-update") == 0
 407           || strcmp(argv[i], "--incremental-changed") == 0
 408           || strcmp(argv[i], "--incremental-unchanged") == 0
 409           || strcmp(argv[i], "--incremental-unknown") == 0)
 410         continue;
 411
 412       args.append(" '");
 413       // Now append argv[i], but with all single-quotes escaped
 414       const char* argpos = argv[i];
 415       while (1)
 416         {
 417           const int len = strcspn(argpos, "'");
 418           args.append(argpos, len);
 419           if (argpos[len] == '\0')
 420             break;
 421           args.append("'\"'\"'");
 422           argpos += len + 1;
 423         }
 424       args.append("'");
 425     }
 426
 427   this->command_line_ = args;
 428   this->strtab_->add(this->command_line_.c_str(), false,
 429                      &this->command_line_key_);
 430 }
 431
 432 // Record the input archive file ARCHIVE.  This is called by the
 433 // Add_archive_symbols task before determining which archive members
 434 // to include.  We create the Incremental_archive_entry here and
 435 // attach it to the Archive, but we do not add it to the list of
 436 // input objects until report_archive_end is called.
 437
 438 void
 439 Incremental_inputs::report_archive_begin(Library_base* arch)
 440 {
 441   Stringpool::Key filename_key;
 442   Timespec mtime = arch->get_mtime();
 443
 444   this->strtab_->add(arch->filename().c_str(), false, &filename_key);
 445   Incremental_archive_entry* entry =
 446       new Incremental_archive_entry(filename_key, mtime);
 447   arch->set_incremental_info(entry);
 448   this->inputs_.push_back(entry);
 449 }
 450
 451 // Visitor class for processing the unused global symbols in a library.
 452 // An instance of this class is passed to the library's
 453 // for_all_unused_symbols() iterator, which will call the visit()
 454 // function for each global symbol defined in each unused library
 455 // member.  We add those symbol names to the incremental info for the
 456 // library.
 457
 458 class Unused_symbol_visitor : public Library_base::Symbol_visitor_base
 459 {
 460  public:
 461   Unused_symbol_visitor(Incremental_archive_entry* entry, Stringpool* strtab)
 462     : entry_(entry), strtab_(strtab)
 463   { }
 464
 465   void
 466   visit(const char* sym)
 467   {
 468     Stringpool::Key symbol_key;
 469     this->strtab_->add(sym, true, &symbol_key);
 470     this->entry_->add_unused_global_symbol(symbol_key);
 471   }
 472
 473  private:
 474   Incremental_archive_entry* entry_;
 475   Stringpool* strtab_;
 476 };
 477
 478 // Finish recording the input archive file ARCHIVE.  This is called by the
 479 // Add_archive_symbols task after determining which archive members
 480 // to include.
 481
 482 void
 483 Incremental_inputs::report_archive_end(Library_base* arch)
 484 {
 485   Incremental_archive_entry* entry = arch->incremental_info();
 486
 487   gold_assert(entry != NULL);
 488
 489   // Collect unused global symbols.
 490   Unused_symbol_visitor v(entry, this->strtab_);
 491   arch->for_all_unused_symbols(&v);
 492 }
 493
 494 // Record the input object file OBJ.  If ARCH is not NULL, attach
 495 // the object file to the archive.  This is called by the
 496 // Add_symbols task after finding out the type of the file.
 497
 498 void
 499 Incremental_inputs::report_object(Object* obj, Library_base* arch)
 500 {
 501   Stringpool::Key filename_key;
 502   Timespec mtime = obj->input_file()->file().get_mtime();
 503
 504   this->strtab_->add(obj->name().c_str(), false, &filename_key);
 505   Incremental_object_entry* obj_entry =
 506       new Incremental_object_entry(filename_key, obj, mtime);
 507   this->inputs_.push_back(obj_entry);
 508
 509   if (arch != NULL)
 510     {
 511       Incremental_archive_entry* arch_entry = arch->incremental_info();
 512       gold_assert(arch_entry != NULL);
 513       arch_entry->add_object(obj_entry);
 514     }
 515
 516   this->current_object_ = obj;
 517   this->current_object_entry_ = obj_entry;
 518 }
 519
 520 // Record the input object file OBJ.  If ARCH is not NULL, attach
 521 // the object file to the archive.  This is called by the
 522 // Add_symbols task after finding out the type of the file.
 523
 524 void
 525 Incremental_inputs::report_input_section(Object* obj, unsigned int shndx,
 526                                          const char* name, off_t sh_size)
 527 {
 528   Stringpool::Key key = 0;
 529
 530   if (name != NULL)
 531       this->strtab_->add(name, true, &key);
 532
 533   gold_assert(obj == this->current_object_);
 534   this->current_object_entry_->add_input_section(shndx, key, sh_size);
 535 }
 536
 537 // Record that the input argument INPUT is a script SCRIPT.  This is
 538 // called by read_script after parsing the script and reading the list
 539 // of inputs added by this script.
 540
 541 void
 542 Incremental_inputs::report_script(const std::string& filename,
 543                                   Script_info* script, Timespec mtime)
 544 {
 545   Stringpool::Key filename_key;
 546
 547   this->strtab_->add(filename.c_str(), false, &filename_key);
 548   Incremental_script_entry* entry =
 549       new Incremental_script_entry(filename_key, script, mtime);
 550   this->inputs_.push_back(entry);
 551 }
 552
 553 // Finalize the incremental link information.  Called from
 554 // Layout::finalize.
 555
 556 void
 557 Incremental_inputs::finalize()
 558 {
 559   // Finalize the string table.
 560   this->strtab_->set_string_offsets();
 561 }
 562
 563 // Create the .gnu_incremental_inputs, _symtab, and _relocs input sections.
 564
 565 void
 566 Incremental_inputs::create_data_sections(Symbol_table* symtab)
 567 {
 568   switch (parameters->size_and_endianness())
 569     {
 570 #ifdef HAVE_TARGET_32_LITTLE
 571     case Parameters::TARGET_32_LITTLE:
 572       this->inputs_section_ =
 573           new Output_section_incremental_inputs<32, false>(this, symtab);
 574       break;
 575 #endif
 576 #ifdef HAVE_TARGET_32_BIG
 577     case Parameters::TARGET_32_BIG:
 578       this->inputs_section_ =
 579           new Output_section_incremental_inputs<32, true>(this, symtab);
 580       break;
 581 #endif
 582 #ifdef HAVE_TARGET_64_LITTLE
 583     case Parameters::TARGET_64_LITTLE:
 584       this->inputs_section_ =
 585           new Output_section_incremental_inputs<64, false>(this, symtab);
 586       break;
 587 #endif
 588 #ifdef HAVE_TARGET_64_BIG
 589     case Parameters::TARGET_64_BIG:
 590       this->inputs_section_ =
 591           new Output_section_incremental_inputs<64, true>(this, symtab);
 592       break;
 593 #endif
 594     default:
 595       gold_unreachable();
 596     }
 597   this->symtab_section_ = new Output_data_space(4, "** incremental_symtab");
 598   this->relocs_section_ = new Output_data_space(4, "** incremental_relocs");
 599   this->got_plt_section_ = new Output_data_space(4, "** incremental_got_plt");
 600 }
 601
 602 // Return the sh_entsize value for the .gnu_incremental_relocs section.
 603 unsigned int
 604 Incremental_inputs::relocs_entsize() const
 605 {
 606   return 8 + 2 * parameters->target().get_size() / 8;
 607 }
 608
 609 // Class Output_section_incremental_inputs.
 610
 611 // Finalize the offsets for each input section and supplemental info block,
 612 // and set the final data size of the incremental output sections.
 613
 614 template<int size, bool big_endian>
 615 void
 616 Output_section_incremental_inputs<size, big_endian>::set_final_data_size()
 617 {
 618   const Incremental_inputs* inputs = this->inputs_;
 619   const unsigned int sizeof_addr = size / 8;
 620   const unsigned int rel_size = 8 + 2 * sizeof_addr;
 621
 622   // Offset of each input entry.
 623   unsigned int input_offset = this->header_size;
 624
 625   // Offset of each supplemental info block.
 626   unsigned int info_offset = this->header_size;
 627   info_offset += this->input_entry_size * inputs->input_file_count();
 628
 629   // Count each input file and its supplemental information block.
 630   for (Incremental_inputs::Input_list::const_iterator p =
 631            inputs->input_files().begin();
 632        p != inputs->input_files().end();
 633        ++p)
 634     {
 635       // Set the offset of the input file entry.
 636       (*p)->set_offset(input_offset);
 637       input_offset += this->input_entry_size;
 638
 639       // Set the offset of the supplemental info block.
 640       switch ((*p)->type())
 641         {
 642         case INCREMENTAL_INPUT_SCRIPT:
 643           // No supplemental info for a script.
 644           (*p)->set_info_offset(0);
 645           break;
 646         case INCREMENTAL_INPUT_OBJECT:
 647         case INCREMENTAL_INPUT_ARCHIVE_MEMBER:
 648           {
 649             Incremental_object_entry* entry = (*p)->object_entry();
 650             gold_assert(entry != NULL);
 651             (*p)->set_info_offset(info_offset);
 652             // Input section count + global symbol count.
 653             info_offset += 8;
 654             // Each input section.
 655             info_offset += (entry->get_input_section_count()
 656                             * (8 + 2 * sizeof_addr));
 657             // Each global symbol.
 658             const Object::Symbols* syms = entry->object()->get_global_symbols();
 659             info_offset += syms->size() * 16;
 660           }
 661           break;
 662         case INCREMENTAL_INPUT_SHARED_LIBRARY:
 663           {
 664             Incremental_object_entry* entry = (*p)->object_entry();
 665             gold_assert(entry != NULL);
 666             (*p)->set_info_offset(info_offset);
 667             // Global symbol count.
 668             info_offset += 4;
 669             // Each global symbol.
 670             const Object::Symbols* syms = entry->object()->get_global_symbols();
 671             unsigned int nsyms = syms != NULL ? syms->size() : 0;
 672             info_offset += nsyms * 4;
 673           }
 674           break;
 675         case INCREMENTAL_INPUT_ARCHIVE:
 676           {
 677             Incremental_archive_entry* entry = (*p)->archive_entry();
 678             gold_assert(entry != NULL);
 679             (*p)->set_info_offset(info_offset);
 680             // Member count + unused global symbol count.
 681             info_offset += 8;
 682             // Each member.
 683             info_offset += (entry->get_member_count() * 4);
 684             // Each global symbol.
 685             info_offset += (entry->get_unused_global_symbol_count() * 4);
 686           }
 687           break;
 688         default:
 689           gold_unreachable();
 690         }
 691     }
 692
 693   this->set_data_size(info_offset);
 694
 695   // Set the size of the .gnu_incremental_symtab section.
 696   inputs->symtab_section()->set_current_data_size(this->symtab_->output_count()
 697                                                   * sizeof(unsigned int));
 698
 699   // Set the size of the .gnu_incremental_relocs section.
 700   inputs->relocs_section()->set_current_data_size(inputs->get_reloc_count()
 701                                                   * rel_size);
 702
 703   // Set the size of the .gnu_incremental_got_plt section.
 704   Sized_target<size, big_endian>* target =
 705     parameters->sized_target<size, big_endian>();
 706   unsigned int got_count = target->got_entry_count();
 707   unsigned int plt_count = target->plt_entry_count();
 708   unsigned int got_plt_size = 8;  // GOT entry count, PLT entry count.
 709   got_plt_size = (got_plt_size + got_count + 3) & ~3;  // GOT type array.
 710   got_plt_size += got_count * 4 + plt_count * 4;  // GOT array, PLT array.
 711   inputs->got_plt_section()->set_current_data_size(got_plt_size);
 712 }
 713
 714 // Write the contents of the .gnu_incremental_inputs and
 715 // .gnu_incremental_symtab sections.
 716
 717 template<int size, bool big_endian>
 718 void
 719 Output_section_incremental_inputs<size, big_endian>::do_write(Output_file* of)
 720 {
 721   const Incremental_inputs* inputs = this->inputs_;
 722   Stringpool* strtab = inputs->get_stringpool();
 723
 724   // Get a view into the .gnu_incremental_inputs section.
 725   const off_t off = this->offset();
 726   const off_t oview_size = this->data_size();
 727   unsigned char* const oview = of->get_output_view(off, oview_size);
 728   unsigned char* pov = oview;
 729
 730   // Get a view into the .gnu_incremental_symtab section.
 731   const off_t symtab_off = inputs->symtab_section()->offset();
 732   const off_t symtab_size = inputs->symtab_section()->data_size();
 733   unsigned char* const symtab_view = of->get_output_view(symtab_off,
 734                                                          symtab_size);
 735
 736   // Allocate an array of linked list heads for the .gnu_incremental_symtab
 737   // section.  Each element corresponds to a global symbol in the output
 738   // symbol table, and points to the head of the linked list that threads
 739   // through the object file input entries.  The value of each element
 740   // is the section-relative offset to a global symbol entry in a
 741   // supplemental information block.
 742   unsigned int global_sym_count = this->symtab_->output_count();
 743   unsigned int* global_syms = new unsigned int[global_sym_count];
 744   memset(global_syms, 0, global_sym_count * sizeof(unsigned int));
 745
 746   // Write the section header.
 747   Stringpool::Key command_line_key = inputs->command_line_key();
 748   pov = this->write_header(pov, inputs->input_file_count(),
 749                            strtab->get_offset_from_key(command_line_key));
 750
 751   // Write the list of input files.
 752   pov = this->write_input_files(oview, pov, strtab);
 753
 754   // Write the supplemental information blocks for each input file.
 755   pov = this->write_info_blocks(oview, pov, strtab, global_syms,
 756                                 global_sym_count);
 757
 758   gold_assert(pov - oview == oview_size);
 759
 760   // Write the .gnu_incremental_symtab section.
 761   gold_assert(global_sym_count * 4 == symtab_size);
 762   this->write_symtab(symtab_view, global_syms, global_sym_count);
 763
 764   delete[] global_syms;
 765
 766   // Write the .gnu_incremental_got_plt section.
 767   const off_t got_plt_off = inputs->got_plt_section()->offset();
 768   const off_t got_plt_size = inputs->got_plt_section()->data_size();
 769   unsigned char* const got_plt_view = of->get_output_view(got_plt_off,
 770                                                           got_plt_size);
 771   this->write_got_plt(got_plt_view, got_plt_size);
 772
 773   of->write_output_view(off, oview_size, oview);
 774   of->write_output_view(symtab_off, symtab_size, symtab_view);
 775   of->write_output_view(got_plt_off, got_plt_size, got_plt_view);
 776 }
 777
 778 // Write the section header: version, input file count, offset of command line
 779 // in the string table, and 4 bytes of padding.
 780
 781 template<int size, bool big_endian>
 782 unsigned char*
 783 Output_section_incremental_inputs<size, big_endian>::write_header(
 784     unsigned char* pov,
 785     unsigned int input_file_count,
 786     section_offset_type command_line_offset)
 787 {
 788   Swap32::writeval(pov, INCREMENTAL_LINK_VERSION);
 789   Swap32::writeval(pov + 4, input_file_count);
 790   Swap32::writeval(pov + 8, command_line_offset);
 791   Swap32::writeval(pov + 12, 0);
 792   return pov + this->header_size;
 793 }
 794
 795 // Write the input file entries.
 796
 797 template<int size, bool big_endian>
 798 unsigned char*
 799 Output_section_incremental_inputs<size, big_endian>::write_input_files(
 800     unsigned char* oview,
 801     unsigned char* pov,
 802     Stringpool* strtab)
 803 {
 804   const Incremental_inputs* inputs = this->inputs_;
 805
 806   for (Incremental_inputs::Input_list::const_iterator p =
 807            inputs->input_files().begin();
 808        p != inputs->input_files().end();
 809        ++p)
 810     {
 811       gold_assert(static_cast<unsigned int>(pov - oview) == (*p)->get_offset());
 812       section_offset_type filename_offset =
 813           strtab->get_offset_from_key((*p)->get_filename_key());
 814       const Timespec& mtime = (*p)->get_mtime();
 815       Swap32::writeval(pov, filename_offset);
 816       Swap32::writeval(pov + 4, (*p)->get_info_offset());
 817       Swap64::writeval(pov + 8, mtime.seconds);
 818       Swap32::writeval(pov + 16, mtime.nanoseconds);
 819       Swap16::writeval(pov + 20, (*p)->type());
 820       Swap16::writeval(pov + 22, 0);
 821       pov += this->input_entry_size;
 822     }
 823   return pov;
 824 }
 825
 826 // Write the supplemental information blocks.
 827
 828 template<int size, bool big_endian>
 829 unsigned char*
 830 Output_section_incremental_inputs<size, big_endian>::write_info_blocks(
 831     unsigned char* oview,
 832     unsigned char* pov,
 833     Stringpool* strtab,
 834     unsigned int* global_syms,
 835     unsigned int global_sym_count)
 836 {
 837   const Incremental_inputs* inputs = this->inputs_;
 838   unsigned int first_global_index = this->symtab_->first_global_index();
 839
 840   for (Incremental_inputs::Input_list::const_iterator p =
 841            inputs->input_files().begin();
 842        p != inputs->input_files().end();
 843        ++p)
 844     {
 845       switch ((*p)->type())
 846         {
 847         case INCREMENTAL_INPUT_SCRIPT:
 848           // No supplemental info for a script.
 849           break;
 850
 851         case INCREMENTAL_INPUT_OBJECT:
 852         case INCREMENTAL_INPUT_ARCHIVE_MEMBER:
 853           {
 854             gold_assert(static_cast<unsigned int>(pov - oview)
 855                         == (*p)->get_info_offset());
 856             Incremental_object_entry* entry = (*p)->object_entry();
 857             gold_assert(entry != NULL);
 858             const Object* obj = entry->object();
 859             const Object::Symbols* syms = obj->get_global_symbols();
 860             // Write the input section count and global symbol count.
 861             unsigned int nsections = entry->get_input_section_count();
 862             unsigned int nsyms = syms->size();
 863             Swap32::writeval(pov, nsections);
 864             Swap32::writeval(pov + 4, nsyms);
 865             pov += 8;
 866
 867             // For each input section, write the name, output section index,
 868             // offset within output section, and input section size.
 869             for (unsigned int i = 0; i < nsections; i++)
 870               {
 871                 Stringpool::Key key = entry->get_input_section_name_key(i);
 872                 off_t name_offset = 0;
 873                 if (key != 0)
 874                   name_offset = strtab->get_offset_from_key(key);
 875                 int out_shndx = 0;
 876                 off_t out_offset = 0;
 877                 off_t sh_size = 0;
 878                 Output_section* os = obj->output_section(i);
 879                 if (os != NULL)
 880                   {
 881                     out_shndx = os->out_shndx();
 882                     out_offset = obj->output_section_offset(i);
 883                     sh_size = entry->get_input_section_size(i);
 884                   }
 885                 Swap32::writeval(pov, name_offset);
 886                 Swap32::writeval(pov + 4, out_shndx);
 887                 Swap::writeval(pov + 8, out_offset);
 888                 Swap::writeval(pov + 8 + sizeof_addr, sh_size);
 889                 pov += 8 + 2 * sizeof_addr;
 890               }
 891
 892             // For each global symbol, write its associated relocations,
 893             // add it to the linked list of globals, then write the
 894             // supplemental information:  global symbol table index,
 895             // linked list chain pointer, relocation count, and offset
 896             // to the relocations.
 897             for (unsigned int i = 0; i < nsyms; i++)
 898               {
 899                 const Symbol* sym = (*syms)[i];
 900                 if (sym->is_forwarder())
 901                   sym = this->symtab_->resolve_forwards(sym);
 902                 unsigned int symtab_index = sym->symtab_index();
 903                 unsigned int chain = 0;
 904                 unsigned int first_reloc = 0;
 905                 unsigned int nrelocs = obj->get_incremental_reloc_count(i);
 906                 if (nrelocs > 0)
 907                   {
 908                     gold_assert(symtab_index != -1U
 909                                 && (symtab_index - first_global_index
 910                                     < global_sym_count));
 911                     first_reloc = obj->get_incremental_reloc_base(i);
 912                     chain = global_syms[symtab_index - first_global_index];
 913                     global_syms[symtab_index - first_global_index] =
 914                         pov - oview;
 915                   }
 916                 Swap32::writeval(pov, symtab_index);
 917                 Swap32::writeval(pov + 4, chain);
 918                 Swap32::writeval(pov + 8, nrelocs);
 919                 Swap32::writeval(pov + 12, first_reloc * 3 * sizeof_addr);
 920                 pov += 16;
 921               }
 922           }
 923           break;
 924
 925         case INCREMENTAL_INPUT_SHARED_LIBRARY:
 926           {
 927             gold_assert(static_cast<unsigned int>(pov - oview)
 928                         == (*p)->get_info_offset());
 929             Incremental_object_entry* entry = (*p)->object_entry();
 930             gold_assert(entry != NULL);
 931             const Object* obj = entry->object();
 932             const Object::Symbols* syms = obj->get_global_symbols();
 933
 934             // Write the global symbol count.
 935             unsigned int nsyms = syms != NULL ? syms->size() : 0;
 936             Swap32::writeval(pov, nsyms);
 937             pov += 4;
 938
 939             // For each global symbol, write the global symbol table index.
 940             for (unsigned int i = 0; i < nsyms; i++)
 941               {
 942                 const Symbol* sym = (*syms)[i];
 943                 Swap32::writeval(pov, sym->symtab_index());
 944                 pov += 4;
 945               }
 946           }
 947           break;
 948
 949         case INCREMENTAL_INPUT_ARCHIVE:
 950           {
 951             gold_assert(static_cast<unsigned int>(pov - oview)
 952                         == (*p)->get_info_offset());
 953             Incremental_archive_entry* entry = (*p)->archive_entry();
 954             gold_assert(entry != NULL);
 955
 956             // Write the member count and unused global symbol count.
 957             unsigned int nmembers = entry->get_member_count();
 958             unsigned int nsyms = entry->get_unused_global_symbol_count();
 959             Swap32::writeval(pov, nmembers);
 960             Swap32::writeval(pov + 4, nsyms);
 961             pov += 8;
 962
 963             // For each member, write the offset to its input file entry.
 964             for (unsigned int i = 0; i < nmembers; ++i)
 965               {
 966                 Incremental_object_entry* member = entry->get_member(i);
 967                 Swap32::writeval(pov, member->get_offset());
 968                 pov += 4;
 969               }
 970
 971             // For each global symbol, write the name offset.
 972             for (unsigned int i = 0; i < nsyms; ++i)
 973               {
 974                 Stringpool::Key key = entry->get_unused_global_symbol(i);
 975                 Swap32::writeval(pov, strtab->get_offset_from_key(key));
 976                 pov += 4;
 977               }
 978           }
 979           break;
 980
 981         default:
 982           gold_unreachable();
 983         }
 984     }
 985   return pov;
 986 }
 987
 988 // Write the contents of the .gnu_incremental_symtab section.
 989
 990 template<int size, bool big_endian>
 991 void
 992 Output_section_incremental_inputs<size, big_endian>::write_symtab(
 993     unsigned char* pov,
 994     unsigned int* global_syms,
 995     unsigned int global_sym_count)
 996 {
 997   for (unsigned int i = 0; i < global_sym_count; ++i)
 998     {
 999       Swap32::writeval(pov, global_syms[i]);
1000       pov += 4;
1001     }
1002 }
1003
1004 // This struct holds the view information needed to write the
1005 // .gnu_incremental_got_plt section.
1006
1007 struct Got_plt_view_info
1008 {
1009   // Start of the GOT type array in the output view.
1010   unsigned char* got_type_p;
1011   // Start of the GOT descriptor array in the output view.
1012   unsigned char* got_desc_p;
1013   // Start of the PLT descriptor array in the output view.
1014   unsigned char* plt_desc_p;
1015   // Number of GOT entries.
1016   unsigned int got_count;
1017   // Number of PLT entries.
1018   unsigned int plt_count;
1019   // Offset of the first non-reserved PLT entry (this is a target-dependent value).
1020   unsigned int first_plt_entry_offset;
1021   // Size of a PLT entry (this is a target-dependent value).
1022   unsigned int plt_entry_size;
1023   // Value to write in the GOT descriptor array.  For global symbols,
1024   // this is the global symbol table index; for local symbols, it is
1025   // the offset of the input file entry in the .gnu_incremental_inputs
1026   // section.
1027   unsigned int got_descriptor;
1028 };
1029
1030 // Functor class for processing a GOT offset list for local symbols.
1031 // Writes the GOT type and symbol index into the GOT type and descriptor
1032 // arrays in the output section.
1033
1034 template<int size, bool big_endian>
1035 class Local_got_offset_visitor
1036 {
1037  public:
1038   Local_got_offset_visitor(struct Got_plt_view_info& info)
1039     : info_(info)
1040   { }
1041
1042   void
1043   operator()(unsigned int got_type, unsigned int got_offset)
1044   {
1045     unsigned int got_index = got_offset / this->got_entry_size_;
1046     gold_assert(got_index < this->info_.got_count);
1047     // We can only handle GOT entry types in the range 0..0x7e
1048     // because we use a byte array to store them, and we use the
1049     // high bit to flag a local symbol.
1050     gold_assert(got_type < 0x7f);
1051     this->info_.got_type_p[got_index] = got_type | 0x80;
1052     unsigned char* pov = this->info_.got_desc_p + got_index * 4;
1053     elfcpp::Swap<32, big_endian>::writeval(pov, this->info_.got_descriptor);
1054   }
1055
1056  private:
1057   static const unsigned int got_entry_size_ = size / 8;
1058   struct Got_plt_view_info& info_;
1059 };
1060
1061 // Functor class for processing a GOT offset list.  Writes the GOT type
1062 // and symbol index into the GOT type and descriptor arrays in the output
1063 // section.
1064
1065 template<int size, bool big_endian>
1066 class Global_got_offset_visitor
1067 {
1068  public:
1069   Global_got_offset_visitor(struct Got_plt_view_info& info)
1070     : info_(info)
1071   { }
1072
1073   void
1074   operator()(unsigned int got_type, unsigned int got_offset)
1075   {
1076     unsigned int got_index = got_offset / this->got_entry_size_;
1077     gold_assert(got_index < this->info_.got_count);
1078     // We can only handle GOT entry types in the range 0..0x7e
1079     // because we use a byte array to store them, and we use the
1080     // high bit to flag a local symbol.
1081     gold_assert(got_type < 0x7f);
1082     this->info_.got_type_p[got_index] = got_type;
1083     unsigned char* pov = this->info_.got_desc_p + got_index * 4;
1084     elfcpp::Swap<32, big_endian>::writeval(pov, this->info_.got_descriptor);
1085   }
1086
1087  private:
1088   static const unsigned int got_entry_size_ = size / 8;
1089   struct Got_plt_view_info& info_;
1090 };
1091
1092 // Functor class for processing the global symbol table.  Processes the
1093 // GOT offset list for the symbol, and writes the symbol table index
1094 // into the PLT descriptor array in the output section.
1095
1096 template<int size, bool big_endian>
1097 class Global_symbol_visitor_got_plt
1098 {
1099  public:
1100   Global_symbol_visitor_got_plt(struct Got_plt_view_info& info)
1101     : info_(info)
1102   { }
1103
1104   void
1105   operator()(const Sized_symbol<size>* sym)
1106   {
1107     typedef Global_got_offset_visitor<size, big_endian> Got_visitor;
1108     const Got_offset_list* got_offsets = sym->got_offset_list();
1109     if (got_offsets != NULL)
1110       {
1111         info_.got_descriptor = sym->symtab_index();
1112         got_offsets->for_all_got_offsets(Got_visitor(info_));
1113       }
1114     if (sym->has_plt_offset())
1115       {
1116         unsigned int plt_index =
1117             ((sym->plt_offset() - this->info_.first_plt_entry_offset)
1118              / this->info_.plt_entry_size);
1119         gold_assert(plt_index < this->info_.plt_count);
1120         unsigned char* pov = this->info_.plt_desc_p + plt_index * 4;
1121         elfcpp::Swap<32, big_endian>::writeval(pov, sym->symtab_index());
1122       }
1123   }
1124
1125  private:
1126   struct Got_plt_view_info& info_;
1127 };
1128
1129 // Write the contents of the .gnu_incremental_got_plt section.
1130
1131 template<int size, bool big_endian>
1132 void
1133 Output_section_incremental_inputs<size, big_endian>::write_got_plt(
1134     unsigned char* pov,
1135     off_t view_size)
1136 {
1137   Sized_target<size, big_endian>* target =
1138     parameters->sized_target<size, big_endian>();
1139
1140   // Set up the view information for the functors.
1141   struct Got_plt_view_info view_info;
1142   view_info.got_count = target->got_entry_count();
1143   view_info.plt_count = target->plt_entry_count();
1144   view_info.first_plt_entry_offset = target->first_plt_entry_offset();
1145   view_info.plt_entry_size = target->plt_entry_size();
1146   view_info.got_type_p = pov + 8;
1147   view_info.got_desc_p = (view_info.got_type_p
1148                           + ((view_info.got_count + 3) & ~3));
1149   view_info.plt_desc_p = view_info.got_desc_p + view_info.got_count * 4;
1150
1151   gold_assert(pov + view_size ==
1152               view_info.plt_desc_p + view_info.plt_count * 4);
1153
1154   // Write the section header.
1155   Swap32::writeval(pov, view_info.got_count);
1156   Swap32::writeval(pov + 4, view_info.plt_count);
1157
1158   // Initialize the GOT type array to 0xff (reserved).
1159   memset(view_info.got_type_p, 0xff, view_info.got_count);
1160
1161   // Write the incremental GOT descriptors for local symbols.
1162   for (Incremental_inputs::Input_list::const_iterator p =
1163            this->inputs_->input_files().begin();
1164        p != this->inputs_->input_files().end();
1165        ++p)
1166     {
1167       if ((*p)->type() != INCREMENTAL_INPUT_OBJECT
1168           && (*p)->type() != INCREMENTAL_INPUT_ARCHIVE_MEMBER)
1169         continue;
1170       Incremental_object_entry* entry = (*p)->object_entry();
1171       gold_assert(entry != NULL);
1172       const Sized_relobj<size, big_endian>* obj =
1173           static_cast<Sized_relobj<size, big_endian>*>(entry->object());
1174       gold_assert(obj != NULL);
1175       unsigned int nsyms = obj->local_symbol_count();
1176       for (unsigned int i = 0; i < nsyms; i++)
1177         {
1178           const Got_offset_list* got_offsets = obj->local_got_offset_list(i);
1179           if (got_offsets != NULL)
1180             {
1181               typedef Local_got_offset_visitor<size, big_endian> Got_visitor;
1182               view_info.got_descriptor = (*p)->get_offset();
1183               got_offsets->for_all_got_offsets(Got_visitor(view_info));
1184             }
1185         }
1186     }
1187
1188   // Write the incremental GOT and PLT descriptors for global symbols.
1189   typedef Global_symbol_visitor_got_plt<size, big_endian> Symbol_visitor;
1190   symtab_->for_all_symbols<size, Symbol_visitor>(Symbol_visitor(view_info));
1191 }
1192
1193 // Instantiate the templates we need.
1194
1195 #ifdef HAVE_TARGET_32_LITTLE
1196 template
1197 class Sized_incremental_binary<32, false>;
1198 #endif
1199
1200 #ifdef HAVE_TARGET_32_BIG
1201 template
1202 class Sized_incremental_binary<32, true>;
1203 #endif
1204
1205 #ifdef HAVE_TARGET_64_LITTLE
1206 template
1207 class Sized_incremental_binary<64, false>;
1208 #endif
1209
1210 #ifdef HAVE_TARGET_64_BIG
1211 template
1212 class Sized_incremental_binary<64, true>;
1213 #endif
1214
1215 } // End namespace gold.